`MsgpackChunk.reserve` used to double the backing buffer with no upper
bound, so a single pathological span (multi-MB stack trace, unsanitized
meta tag the size of a media file) could grow the chunk until allocation
failed and took the host process with it.

The agent's trace intake caps payloads at 50 MiB, so anything above that
is rejected downstream anyway. `reserve` now refuses growth past
`MAX_SIZE = 50 MiB` with an `OverflowError` (a `RangeError` subclass
carrying `code: 'ERR_MSGPACK_CHUNK_OVERFLOW'` as an own property); the
cursor stays put so the caller's recovery path can decide what to do. A
single shared class keeps the `code` identical across every throw site so
every writer recognises it.

A single chunk is not the only way to cross the cap: two chunks each
capped under `MAX_SIZE` can sum past it once stitched together, and that
sum only exists inside `makePayload`, after `encode` already returned —
so the encode-time catch never sees it.

Each path that can raise the tag drops the queued payload rather than
emit a partial buffer — rolling back just the in-flight entry is unsafe
because the string cache may already point at offsets we'd invalidate:

1. `AgentEncoder.encode` calls the virtual `reset()` so subclasses can
   clear their own per-payload state. `AgentlessCiVisibilityEncoder.
   _eventCount` would otherwise stay primed after the bytes were wiped
   and the next `makePayload` would patch the `events` array prefix with
   a count larger than the payload that survived.
2. `CoverageCIVisibilityEncoder` writes into its own `_coverageBytes`
   chunk, so the parent catch never sees its overflow. It catches the
   tag locally and drops the queued coverage form.
3. `DataStreamsWriter.flush` catches the tag from the standalone
   `msgpack.encode` and drops the pipeline-stats payload rather than
   propagating the `RangeError` out of the writer.
4. The v0.5 `makePayload` concatenates the string table and the trace
   bytes; the CI Visibility `makePayload` builds its metadata prefix in a
   fresh chunk and concatenates the events. Both now check the assembled
   size and raise the tag before allocating the fused buffer.
5. The shared `Writer.flush` wraps `makePayload`, so the assembled-size
   overflow from (4) resets the encoder and drops the payload instead of
   escaping as an uncaught `RangeError` in the host application.

`MsgpackChunk.reserve` used to double the backing buffer with no upper
bound, so a single pathological span (multi-MB stack trace, unsanitized
meta tag the size of a media file) could grow the chunk until allocation
failed and took the host process with it.

The agent's trace intake caps payloads at 50 MiB, so anything above that
is rejected downstream anyway. `reserve` now refuses growth past
`MAX_SIZE = 50 MiB` with an `OverflowError` (a `RangeError` subclass
carrying `code: 'ERR_MSGPACK_CHUNK_OVERFLOW'` as an own property); the
cursor stays put so the caller's recovery path can decide what to do. A
single shared class keeps the `code` identical across every throw site so
every writer recognises it.

A single chunk is not the only way to cross the cap: two chunks each
capped under `MAX_SIZE` can sum past it once stitched together, and that
sum only exists inside `makePayload`, after `encode` already returned —
so the encode-time catch never sees it.

Each path that can raise the tag drops the queued payload rather than
emit a partial buffer — rolling back just the in-flight entry is unsafe
because the string cache may already point at offsets we'd invalidate:

1. `AgentEncoder.encode` calls the virtual `reset()` so subclasses can
   clear their own per-payload state. `AgentlessCiVisibilityEncoder.
   _eventCount` would otherwise stay primed after the bytes were wiped
   and the next `makePayload` would patch the `events` array prefix with
   a count larger than the payload that survived.
2. `CoverageCIVisibilityEncoder` writes into its own `_coverageBytes`
   chunk, so the parent catch never sees its overflow. It catches the
   tag locally and drops the queued coverage form.
3. `DataStreamsWriter.flush` catches the tag from the standalone
   `msgpack.encode` and drops the pipeline-stats payload rather than
   propagating the `RangeError` out of the writer.
4. The v0.5 `makePayload` concatenates the string table and the trace
   bytes; the CI Visibility `makePayload` builds its metadata prefix in a
   fresh chunk and concatenates the events. Both now check the assembled
   size and raise the tag before allocating the fused buffer.
5. The shared `Writer.flush` wraps `makePayload`, so the assembled-size
   overflow from (4) resets the encoder and drops the payload instead of
   escaping as an uncaught `RangeError` in the host application.

`MsgpackChunk.reserve` used to double the backing buffer with no upper
bound, so a single pathological span (multi-MB stack trace, unsanitized
meta tag the size of a media file) could grow the chunk until allocation
failed and took the host process with it.

The agent's trace intake caps payloads at 50 MiB, so anything above that
is rejected downstream anyway. `reserve` now refuses growth past
`MAX_SIZE = 50 MiB` with an `OverflowError` (a `RangeError` subclass
carrying `code: 'ERR_MSGPACK_CHUNK_OVERFLOW'` as an own property); the
cursor stays put so the caller's recovery path can decide what to do. A
single shared class keeps the `code` identical across every throw site so
every writer recognises it.

A single chunk is not the only way to cross the cap: two chunks each
capped under `MAX_SIZE` can sum past it once stitched together, and that
sum only exists inside `makePayload`, after `encode` already returned —
so the encode-time catch never sees it.

Each path that can raise the tag drops the queued payload rather than
emit a partial buffer — rolling back just the in-flight entry is unsafe
because the string cache may already point at offsets we'd invalidate:

1. `AgentEncoder.encode` calls the virtual `reset()` so subclasses can
   clear their own per-payload state. `AgentlessCiVisibilityEncoder.
   _eventCount` would otherwise stay primed after the bytes were wiped
   and the next `makePayload` would patch the `events` array prefix with
   a count larger than the payload that survived.
2. `CoverageCIVisibilityEncoder` writes into its own `_coverageBytes`
   chunk, so the parent catch never sees its overflow. It catches the
   tag locally and drops the queued coverage form.
3. `DataStreamsWriter.flush` catches the tag from the standalone
   `msgpack.encode` and drops the pipeline-stats payload rather than
   propagating the `RangeError` out of the writer.
4. The v0.5 `makePayload` concatenates the string table and the trace
   bytes; the CI Visibility `makePayload` builds its metadata prefix in a
   fresh chunk and concatenates the events. Both now check the assembled
   size and raise the tag before allocating the fused buffer.
5. The shared `Writer.flush` wraps `makePayload`, so the assembled-size
   overflow from (4) resets the encoder and drops the payload instead of
   escaping as an uncaught `RangeError` in the host application.

`MsgpackChunk.reserve` used to double the backing buffer with no upper
bound, so a single pathological span (multi-MB stack trace, unsanitized
meta tag the size of a media file) could grow the chunk until allocation
failed and took the host process with it.

The agent's trace intake caps payloads at 50 MiB, so anything above that
is rejected downstream anyway. `reserve` now refuses growth past
`MAX_SIZE = 50 MiB` with an `OverflowError` (a `RangeError` subclass
carrying `code: 'ERR_MSGPACK_CHUNK_OVERFLOW'` as an own property); the
cursor stays put so the caller's recovery path can decide what to do. A
single shared class keeps the `code` identical across every throw site so
every writer recognises it.

A single chunk is not the only way to cross the cap: two chunks each
capped under `MAX_SIZE` can sum past it once stitched together, and that
sum only exists inside `makePayload`, after `encode` already returned —
so the encode-time catch never sees it.

Each path that can raise the tag drops the queued payload rather than
emit a partial buffer — rolling back just the in-flight entry is unsafe
because the string cache may already point at offsets we'd invalidate:

1. `AgentEncoder.encode` calls the virtual `reset()` so subclasses can
   clear their own per-payload state. `AgentlessCiVisibilityEncoder.
   _eventCount` would otherwise stay primed after the bytes were wiped
   and the next `makePayload` would patch the `events` array prefix with
   a count larger than the payload that survived.
2. `CoverageCIVisibilityEncoder` writes into its own `_coverageBytes`
   chunk, so the parent catch never sees its overflow. It catches the
   tag locally and drops the queued coverage form.
3. `DataStreamsWriter.flush` catches the tag from the standalone
   `msgpack.encode` and drops the pipeline-stats payload rather than
   propagating the `RangeError` out of the writer.
4. The v0.5 `makePayload` concatenates the string table and the trace
   bytes; the CI Visibility `makePayload` builds its metadata prefix in a
   fresh chunk and concatenates the events. Both now check the assembled
   size and raise the tag before allocating the fused buffer.
5. The shared `Writer.flush` wraps `makePayload`, so the assembled-size
   overflow from (4) resets the encoder and drops the payload instead of
   escaping as an uncaught `RangeError` in the host application.