@cosyte/mllp 0.0.1 → 0.0.3

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { T as Transport } from './index-DjGQJtYE.cjs';
+import { T as Transport } from './index-CD8V2Mtk.cjs';
 import { EventEmitter } from 'node:events';
 import { Socket } from 'node:net';
 import { TLSSocket } from 'node:tls';
@@ -20,7 +20,7 @@ import { TLSSocket } from 'node:tls';
 /**
  * Union of all stable MLLP warning codes.
  *
- * These codes are a **public API** — they appear in `onWarning` handlers, log pipelines,
+ * These codes are a **public API**, they appear in `onWarning` handlers, log pipelines,
  * monitoring dashboards, and error messages. Renaming is a breaking change.
  *
  * @example
@@ -32,8 +32,8 @@ type WarningCode = "MLLP_MISSING_LEADING_VT" | "MLLP_FS_WITHOUT_CR" | "MLLP_LF_A
 /**
  * A frozen warning object emitted when the decoder tolerates a framing deviation.
  *
- * `connectionId` is `undefined` when emitted by a standalone `FrameReader` (Phase 2).
- * Phase 3 `Connection` enriches it to the real UUIDv4 before forwarding upstream.
+ * `connectionId` is `undefined` when emitted by a standalone `FrameReader`.
+ * `Connection` enriches it to the real UUIDv4 before forwarding upstream.
  *
  * @example
  * ```typescript
@@ -52,7 +52,7 @@ interface MllpWarning {
     readonly byteOffset: number;
     /**
      * Connection identifier. `undefined` at the framing layer;
-     * enriched by Phase 3 `Connection` before emitting upstream.
+     * enriched by `Connection` before emitting upstream.
      */
     readonly connectionId: string | undefined;
     /** Wall-clock time at point of emission. */
@@ -62,8 +62,8 @@ interface MllpWarning {
  * Create a frozen `MllpWarning` object. The returned object is `Object.freeze()`'d
  * so subscribers cannot mutate shared warning state.
  *
- * `connectionId` is always `undefined` here — Phase 3 enriches via
- * `{ ...w, connectionId: this.connectionId }` then re-freezes (D-08).
+ * `connectionId` is always `undefined` here; `Connection` enriches it via
+ * `{ ...w, connectionId: this.connectionId }` then re-freezes.
  *
  * @example
  * ```typescript
@@ -94,15 +94,15 @@ declare function createWarning(code: WarningCode, byteOffset: number, message: s
 /**
  * Thrown for unrecoverable MLLP wire-format violations.
  *
- * - `code` — stable `WarningCode` identifying the violation
- * - `byteOffset` — absolute stream position where the violation was detected
- * - `snippet` — the single framing-boundary byte that broke the structure, or empty when the
+ * - `code`, stable `WarningCode` identifying the violation
+ * - `byteOffset`, absolute stream position where the violation was detected
+ * - `snippet`, the single framing-boundary byte that broke the structure, or empty when the
  *   anomaly is not a specific byte. **Never a run of payload content** (see the `snippet` PHI
  *   contract below); the constructor caps whatever it is given to 64 bytes as a backstop.
  *
  * @example
  * ```typescript
- * // Pass only the offending framing-boundary byte — never a slice of payload content.
+ * // Pass only the offending framing-boundary byte, never a slice of payload content.
  * throw new MllpFramingError('MLLP_MISSING_LEADING_VT', byteOffset, Buffer.from([byte]));
  * ```
  */
@@ -115,13 +115,13 @@ declare class MllpFramingError extends Error {
     /**
      * Up to 64 bytes copied from around the anomaly.
      *
-     * This is a **copied** Buffer — isolated from the source buffer so it remains
+     * This is a **copied** Buffer, isolated from the source buffer so it remains
      * valid after the underlying buffer is reused or overwritten.
      *
-     * **PHI contract (MLLP-9):** the decoder only ever populates this with the single
+     * **PHI contract:** the decoder only ever populates this with the single
      * framing-boundary byte that violated the frame structure (whose hex value the
-     * `message` already discloses) — never a run of payload content bytes. For anomalies
-     * whose fault is not a specific byte (`MLLP_FRAME_TOO_LARGE` — the accumulated size),
+     * `message` already discloses), never a run of payload content bytes. For anomalies
+     * whose fault is not a specific byte (`MLLP_FRAME_TOO_LARGE`, the accumulated size),
      * the snippet is **empty**: a payload slice on a public error field would leak a
      * field-body slice of clinical content. Callers constructing this directly are
      * responsible for the same discipline.
@@ -141,10 +141,10 @@ declare class MllpFramingError extends Error {
 }
 
 /**
- * MLLP frame encoder — canonical `VT + payload + FS + CR` wrapping.
+ * MLLP frame encoder, canonical `VT + payload + FS + CR` wrapping.
  *
  * The encoder is a **strict emitter** (Postel's Law: conservative on write).
- * There is no option to loosen the output format — it always emits canonical framing.
+ * There is no option to loosen the output format, it always emits canonical framing.
  * Tolerance for delimiter bytes in the payload is available via `allowDelimiterBytesInPayload`,
  * which passes bytes through verbatim and emits an `MllpWarning` for each offending byte.
  *
@@ -175,12 +175,12 @@ interface EncoderOptions {
      * verbatim in the output frame instead of throwing `MllpFramingError`.
      * An `MllpWarning` is emitted per offending byte if `onWarning` is provided.
      *
-     * Default: `false` (strict — throws on delimiter bytes).
+     * Default: `false` (strict, throws on delimiter bytes).
      */
     allowDelimiterBytesInPayload?: boolean;
     /**
      * Called for each offending delimiter byte when `allowDelimiterBytesInPayload` is `true`.
-     * Invocation is wrapped in try/catch — a throwing handler does not interrupt encoding (WARN-06).
+     * Invocation is wrapped in try/catch, a throwing handler does not interrupt encoding.
      *
      * @example
      * ```typescript
@@ -211,11 +211,11 @@ interface EncoderOptions {
  * ```typescript
  * import { encodeFrame } from '@cosyte/mllp';
  *
- * // Strict (default) — throws on delimiter bytes in payload
+ * // Strict (default), throws on delimiter bytes in payload
  * const frame = encodeFrame(Buffer.from('MSH|^~\\&|SEND|FAC|RECV|FAC|...'));
  * socket.write(frame);
  *
- * // Tolerant — passes delimiter bytes through with a warning
+ * // Tolerant, passes delimiter bytes through with a warning
  * const frame2 = encodeFrame(dirtyPayload, {
  *   allowDelimiterBytesInPayload: true,
  *   onWarning: (w) => logger.warn(w),
@@ -225,13 +225,13 @@ interface EncoderOptions {
 declare function encodeFrame(payload: Buffer, opts?: EncoderOptions): Buffer;
 
 /**
- * MLLP frame decoder — stateful 3-state FSM for chunked byte-stream parsing.
+ * MLLP frame decoder, stateful 3-state FSM for chunked byte-stream parsing.
  *
  * Feed raw TCP chunks via `push(chunk)`. Complete MLLP frames fire synchronously
  * via the `onFrame` callback during each `push()` call.
  *
  * The decoder is **strict by default**: any framing deviation throws `MllpFramingError`
- * unless the matching tolerance option is explicitly enabled (Postel's Law — liberal receiver
+ * unless the matching tolerance option is explicitly enabled (Postel's Law, liberal receiver
  * means explicit tolerance, not silent acceptance).
  *
  * @example
@@ -252,9 +252,9 @@ declare function encodeFrame(payload: Buffer, opts?: EncoderOptions): Buffer;
 /**
  * Options for `FrameReader`.
  *
- * All tolerance opts default to `false` — every framing deviation throws unless
+ * All tolerance opts default to `false`, every framing deviation throws unless
  * explicitly enabled. Server-level defaults (allowFsOnly, allowLfAfterFs, allowLeadingWhitespace)
- * are applied by Phase 4 when constructing readers per SERVER-12.
+ * are applied by the server when constructing readers.
  *
  * @example
  * ```typescript
@@ -279,27 +279,27 @@ interface FrameReaderOptions {
      */
     onFrame: (payload: Buffer, byteOffset: number, warnings: readonly MllpWarning[]) => void;
     /**
-     * Called for each tolerated framing deviation. Wrapped in try/catch per WARN-06.
+     * Called for each tolerated framing deviation. Wrapped in try/catch.
      * A throwing handler will not corrupt FSM state.
      */
     onWarning?: (w: MllpWarning) => void;
     /**
      * Maximum accumulated payload bytes before `MllpFramingError('MLLP_FRAME_TOO_LARGE')`.
-     * Default: 16 MiB (FRAME-11 DoS prevention).
+     * Default: 16 MiB (DoS prevention).
      */
     maxFrameSizeBytes?: number;
-    /** FRAME-07: Tolerate FS without trailing CR; emits `MLLP_FS_WITHOUT_CR`. */
+    /** Tolerate FS without trailing CR; emits `MLLP_FS_WITHOUT_CR`. */
     allowFsOnly?: boolean;
-    /** FRAME-08: Tolerate FS+LF instead of FS+CR; emits `MLLP_LF_AFTER_FS`. */
+    /** Tolerate FS+LF instead of FS+CR; emits `MLLP_LF_AFTER_FS`. */
     allowLfAfterFs?: boolean;
-    /** FRAME-09: Tolerate missing leading VT; emits `MLLP_MISSING_LEADING_VT`. */
+    /** Tolerate missing leading VT; emits `MLLP_MISSING_LEADING_VT`. */
     allowMissingLeadingVt?: boolean;
-    /** FRAME-10: Tolerate SP/TAB/LF/CR before VT; emits `MLLP_LEADING_WHITESPACE`. */
+    /** Tolerate SP/TAB/LF/CR before VT; emits `MLLP_LEADING_WHITESPACE`. */
     allowLeadingWhitespace?: boolean;
     /**
      * When `true`, escalates the following tolerances to thrown `MllpFramingError`
      * even if individual opt-ins (`allowFsOnly`, `allowLfAfterFs`, `allowMissingLeadingVt`,
-     * `allowLeadingWhitespace`) are enabled (WARN-08):
+     * `allowLeadingWhitespace`) are enabled:
      * - `MLLP_MISSING_LEADING_VT`
      * - `MLLP_FS_WITHOUT_CR`
      * - `MLLP_LF_AFTER_FS`
@@ -309,7 +309,7 @@ interface FrameReaderOptions {
      *
      * @example
      * ```typescript
-     * // Hardened enforcement — no tolerance, all violations throw
+     * // Hardened enforcement, no tolerance, all violations throw
      * const reader = new FrameReader({ onFrame: fn, strict: true });
      * ```
      */
@@ -320,9 +320,9 @@ interface FrameReaderOptions {
  * Complete frames fire synchronously via `onFrame` callback during `push()`.
  *
  * The decoder operates as a 3-state FSM:
- * - `SCANNING_FOR_VT` — waiting for the 0x0B frame-start byte
- * - `READING_PAYLOAD` — accumulating payload bytes until FS (0x1C)
- * - `EXPECTING_CR` — received FS, waiting for CR (0x0D) to complete the frame
+ * - `SCANNING_FOR_VT`, waiting for the 0x0B frame-start byte
+ * - `READING_PAYLOAD`, accumulating payload bytes until FS (0x1C)
+ * - `EXPECTING_CR`, received FS, waiting for CR (0x0D) to complete the frame
  *
  * @example
  * ```typescript
@@ -337,19 +337,19 @@ declare class FrameReader {
     private readonly _opts;
     private readonly _maxFrameSize;
     private _state;
-    /** Reusable accumulator buffer — grown by doubling as needed. */
+    /** Reusable accumulator buffer, grown by doubling as needed. */
     private _accumulator;
     /** Number of payload bytes written to accumulator in current frame. */
     private _writePos;
     /** Monotonic absolute stream byte offset across the entire connection lifetime. */
     private _byteOffset;
-    /** Byte offset where current leading-whitespace run started (FRAME-10). */
+    /** Byte offset where current leading-whitespace run started. */
     private _wsStart;
-    /** Count of leading whitespace bytes accumulated in current run (FRAME-10). */
+    /** Count of leading whitespace bytes accumulated in current run. */
     private _wsCount;
     /** Byte offset of the VT byte that started the current frame. */
     private _frameStartOffset;
-    /** Per-frame warning accumulator — cleared after each _deliverFrame(). */
+    /** Per-frame warning accumulator, cleared after each _deliverFrame(). */
     private _frameWarnings;
     /**
      * Construct a chunked MLLP frame reader.
@@ -371,7 +371,7 @@ declare class FrameReader {
     /**
      * Clear internal accumulator state and reset byte offset to 0.
      *
-     * Call on reconnect / connection reuse to start fresh without allocating a new reader (D-03).
+     * Call on reconnect / connection reuse to start fresh without allocating a new reader.
      * Pending partial frame state is discarded silently.
      *
      * @example
@@ -388,15 +388,15 @@ declare class FrameReader {
     private _appendByte;
     /**
      * Copy accumulated payload bytes into a new Buffer and deliver via `onFrame`.
-     * The copy isolates callers from internal accumulator reuse (T-02-03-03).
+     * The copy isolates callers from internal accumulator reuse.
      */
     private _deliverFrame;
-    /** Emit a warning via the `onWarning` callback, swallowing any handler exceptions (WARN-06). */
+    /** Emit a warning via the `onWarning` callback, swallowing any handler exceptions. */
     private _emitWarning;
 }
 
 /**
- * NetTransport — `Transport` implementation wrapping a `net.Socket`.
+ * NetTransport, `Transport` implementation wrapping a `net.Socket`.
  *
  * This is the **only** place in the codebase that consumes `net.Socket`'s
  * EventEmitter surface. All higher layers (Connection, Server, Client) work
@@ -455,13 +455,13 @@ declare class NetTransport implements Transport {
 }
 
 /**
- * TlsTransport — `Transport` implementation wrapping a `tls.TLSSocket` (Phase 8).
+ * TlsTransport, `Transport` implementation wrapping a `tls.TLSSocket`.
  *
  * Identical wiring to `NetTransport` with one deliberate difference: `onConnect`
  * maps to the socket's `'secureConnect'` event (fires once the TLS handshake
  * completes) rather than `'connect'` (fires once the raw TCP handshake
  * completes). Consumers of `Transport` (Connection, Client, Server) never see
- * the difference — they only ever observe "the transport is ready."
+ * the difference, they only ever observe "the transport is ready."
  *
  * @example
  * ```typescript
@@ -484,7 +484,7 @@ declare class NetTransport implements Transport {
  * `'connect'` event that `NetTransport` uses.
  *
  * Each `onXxx(fn)` call replaces the prior handler and re-registers on the
- * socket (`socket.removeAllListeners(event)` + `socket.on(event, fn)`) —
+ * socket (`socket.removeAllListeners(event)` + `socket.on(event, fn)`),
  * the same set-once semantics as `NetTransport`.
  *
  * @example
@@ -511,8 +511,8 @@ declare class TlsTransport implements Transport {
     /** See {@link Transport.onData}. */
     onData(fn: (chunk: Buffer) => void): void;
     /**
-     * See {@link Transport.onConnect}. Armed on `'secureConnect'` — the TLS
-     * handshake-complete event — not the raw TCP `'connect'` event.
+     * See {@link Transport.onConnect}. Armed on `'secureConnect'`, the TLS
+     * handshake-complete event, not the raw TCP `'connect'` event.
      */
     onConnect(fn: () => void): void;
     /** See {@link Transport.onClose}. */
@@ -522,9 +522,9 @@ declare class TlsTransport implements Transport {
 }
 
 /**
- * Security-warning codes and payload shape shared by the client and server (Phase 8).
+ * Security-warning codes and payload shape shared by the client and server.
  *
- * These codes are a **public API** — they appear in `'securityWarning'` event
+ * These codes are a **public API**, they appear in `'securityWarning'` event
  * handlers, log pipelines, and monitoring dashboards. Renaming or removing a
  * code is a breaking change (mirrors the `WarningCode` guardrail in
  * `src/framing/registry.ts`).
@@ -540,8 +540,8 @@ declare class TlsTransport implements Transport {
  * @packageDocumentation
  */
 /**
- * Emitted (client-side) on every successful `secureConnect` — initial connect
- * AND every reconnect — when {@link TlsOptions.allowUnverified} is `true`.
+ * Emitted (client-side) on every successful `secureConnect`, initial connect
+ * AND every reconnect, when {@link TlsOptions.allowUnverified} is `true`.
  * Certificate verification is disabled for the connection; this is the loud,
  * per-connection reminder that the channel is not authenticated per IHE ATNA
  * ITI-19 (https://profiles.ihe.net/ITI/TF/Volume2/ITI-19.html).
@@ -584,7 +584,7 @@ type SecurityWarningCode = typeof MLLP_TLS_VERIFY_DISABLED | typeof MLLP_BIND_AL
  * {@link MllpClient} (`MLLP_TLS_VERIFY_DISABLED`) and {@link MllpServer}
  * (`MLLP_BIND_ALL_INTERFACES`).
  *
- * Never carries payload bytes or PHI — only routing metadata (host/port) and
+ * Never carries payload bytes or PHI, only routing metadata (host/port) and
  * a fixed, static message string.
  *
  * @example
@@ -608,18 +608,18 @@ interface SecurityWarning {
 }
 
 /**
- * TLS (MLLPS) option types for the client and server (Phase 8).
+ * TLS (MLLPS) option types for the client and server.
  *
  * Spec anchor: IHE ATNA, ITI-19 Authenticate Node
  * (https://profiles.ihe.net/ITI/TF/Volume2/ITI-19.html), the "STX: TLS 1.2
- * Floor using BCP195" option, ITI TF-2 §3.19.6.2.3 — TLS >= 1.2 required;
+ * Floor using BCP195" option, ITI TF-2 §3.19.6.2.3, TLS >= 1.2 required;
  * mutual node authentication; certificate validation via chain-of-trust or
  * direct comparison. ITI TF-2 §3.19.6.2.3 mandates four TLS 1.2 cipher
  * suites: `TLS_DHE_RSA_WITH_AES_128_GCM_SHA256`,
  * `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`, `TLS_DHE_RSA_WITH_AES_256_GCM_SHA384`,
  * `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`. Node's default TLS 1.2 cipher list
  * already includes both mandated ECDHE suites, so this package pins to Node
- * defaults rather than bundling a cipher list — see `docs-content/tls.md`.
+ * defaults rather than bundling a cipher list, see `docs-content/tls.md`.
  *
  * @example
  * ```typescript
@@ -631,7 +631,7 @@ interface SecurityWarning {
  */
 /**
  * A PEM-encoded credential (certificate, key, or CA), matching Node's
- * `tls.connect`/`tls.createServer` input shape — a single PEM string/Buffer,
+ * `tls.connect`/`tls.createServer` input shape, a single PEM string/Buffer,
  * or an array of them (chain / multiple trust anchors).
  *
  * @example
@@ -642,9 +642,9 @@ interface SecurityWarning {
  */
 type PemInput = string | Buffer | Array<string | Buffer>;
 /**
- * Client-side TLS options (Phase 8, `ClientOptions.tls`).
+ * Client-side TLS options (`ClientOptions.tls`).
  *
- * Passing `true` for `ClientOptions.tls` is equivalent to `{}` — TLS enabled
+ * Passing `true` for `ClientOptions.tls` is equivalent to `{}`, TLS enabled
  * with all defaults, including certificate verification **on**.
  *
  * @example
@@ -674,9 +674,9 @@ interface TlsOptions {
     /**
      * Minimum negotiated TLS protocol version.
      *
-     * Default `'TLSv1.2'` — the IHE ATNA ITI-19 "TLS 1.2 Floor" (BCP195) floor
+     * Default `'TLSv1.2'`, the IHE ATNA ITI-19 "TLS 1.2 Floor" (BCP195) floor
      * (ITI TF-2 §3.19.6.2.3). `'TLSv1.0'`/`'TLSv1.1'` are intentionally **not**
-     * expressible by this type — the floor cannot be lowered through this API.
+     * expressible by this type, the floor cannot be lowered through this API.
      *
      * @default 'TLSv1.2'
      */
@@ -695,7 +695,7 @@ interface TlsOptions {
     /**
      * Loud, explicit dev opt-out from certificate verification (maps to
      * `tls.connect`'s `rejectUnauthorized: false`). There is deliberately no
-     * raw `rejectUnauthorized` surface on this type — this is the only door,
+     * raw `rejectUnauthorized` surface on this type, this is the only door,
      * and it is loud: every successful connection (initial + every reconnect)
      * emits a `'securityWarning'` (`MLLP_TLS_VERIFY_DISABLED`) event and calls
      * `process.emitWarning`.
@@ -712,11 +712,11 @@ interface TlsOptions {
  * Mirrors the IHE ATNA "Authenticate Node" mutual-auth requirement
  * (https://profiles.ihe.net/ITI/TF/Volume2/ITI-19.html):
  *
- * - `'NONE'` — no client certificate requested (default).
- * - `'WANT'` — client certificate requested but NOT required; an untrusted or
+ * - `'NONE'`, no client certificate requested (default).
+ * - `'WANT'`, client certificate requested but NOT required; an untrusted or
  *   absent client certificate does not reject the connection. The peer
  *   certificate (if any) is surfaced on the `'connection'` event.
- * - `'MUST'` — client certificate required AND verified against
+ * - `'MUST'`, client certificate required AND verified against
  *   {@link ServerTlsOptions.ca}; the ATNA mutual-authentication mode. A
  *   missing or untrusted client certificate rejects the handshake.
  *
@@ -728,7 +728,7 @@ interface TlsOptions {
  */
 type ClientAuth = "NONE" | "WANT" | "MUST";
 /**
- * Server-side TLS options (Phase 8, `ServerOptions.tls`).
+ * Server-side TLS options (`ServerOptions.tls`).
  *
  * @example
  * ```typescript
@@ -757,7 +757,7 @@ interface ServerTlsOptions {
      */
     readonly clientAuth?: ClientAuth;
     /**
-     * Minimum negotiated TLS protocol version — the IHE ATNA ITI-19 "TLS 1.2
+     * Minimum negotiated TLS protocol version, the IHE ATNA ITI-19 "TLS 1.2
      * Floor" (BCP195) floor (ITI TF-2 §3.19.6.2.3).
      *
      * @default 'TLSv1.2'
@@ -775,7 +775,7 @@ interface ServerTlsOptions {
 }
 
 /**
- * Connection — 6-state FSM over a Transport with lifecycle events, warning streams,
+ * Connection, 6-state FSM over a Transport with lifecycle events, warning streams,
  * and getStats() observability.
  *
  * @example
@@ -795,9 +795,9 @@ interface ServerTlsOptions {
  */
 
 /**
- * The 6 connection states from LIFE-01.
+ * The 6 connection states.
  *
- * Transitions are validated against the LIFE-02 edge graph. Illegal transitions
+ * Transitions are validated against the legal-transition edge graph. Illegal transitions
  * are silently ignored to preserve FSM integrity.
  */
 type ConnectionState = "CONNECTING" | "CONNECTED" | "DRAINING" | "RECONNECTING" | "DISCONNECTED" | "CLOSED";
@@ -819,8 +819,8 @@ interface StateChangeEvent {
 /**
  * Payload for the 'reconnecting' event. Always `Object.freeze`'d.
  *
- * Phase 5 will populate `attempt` and `delayMs` once the reconnect backoff loop
- * is implemented. For now only `connectionId` is present at the point of emission.
+ * `attempt` and `delayMs` are populated by `MllpClient` when it schedules a
+ * reconnect. A `Connection` emitting on its own supplies `connectionId` only.
  *
  * @example
  * ```typescript
@@ -835,7 +835,7 @@ interface ReconnectingEvent {
     readonly delayMs?: number;
 }
 /**
- * Return type of `connection.getStats()` — JSON-serializable per OBS-04.
+ * Return type of `connection.getStats()`, JSON-serializable.
  *
  * All timestamps are `Date | null` (not epoch milliseconds). `JSON.stringify()`
  * serialises them to ISO 8601 strings by default with no information loss.
@@ -877,9 +877,9 @@ interface ConnectionOptions {
     transport: Transport;
     /** Called for each decoded MLLP frame (raw payload bytes, framing stripped). */
     onMessage?: (payload: Buffer) => void;
-    /** Per-connection warning subscriber (WARN-10). Replaces previous subscription. */
+    /** Per-connection warning subscriber. Replaces previous subscription. */
     onWarning?: (w: MllpWarning) => void;
-    /** Drain timeout used by close() in Phase 4/5 (default: 30_000 ms). */
+    /** Drain timeout used by close() (default: 30_000 ms). */
     drainTimeoutMs?: number;
     /** FrameReader options (tolerance, maxFrameSizeBytes). onFrame/onWarning are managed internally. */
     framing?: Omit<FrameReaderOptions, "onFrame" | "onWarning">;
@@ -906,7 +906,7 @@ interface ConnectionOptions {
  * ```
  */
 declare class Connection extends EventEmitter {
-    /** Stable UUIDv4 identifier for this connection (D-11). */
+    /** Stable UUIDv4 identifier for this connection. */
     readonly connectionId: string;
     private _state;
     private readonly _transport;
@@ -919,20 +919,19 @@ declare class Connection extends EventEmitter {
     private _bytesOut;
     private _lastByteInAt;
     private _lastByteOutAt;
-    /** Ring buffer: last MAX_WARNINGS entries (OBS-05). */
+    /** Ring buffer: last MAX_WARNINGS entries. */
     private _warningBuffer;
-    /** Accurate total counts per code — unaffected by ring buffer truncation (OBS-05). */
+    /** Accurate total counts per code, unaffected by ring buffer truncation. */
     private readonly _warningsByCode;
-    /** Set to true once the ring buffer overflows (OBS-05). */
+    /** Set to true once the ring buffer overflows. */
     private _warningsTruncated;
     private _onWarningFn;
     private _drainPromise;
     /**
-     * beforeClose hook — no-op default that resolves immediately.
+     * beforeClose hook, no-op default that resolves immediately.
      *
-     * Phase 4 (Server) and Phase 5 (Client) override this instance property to
-     * register ACK-drain and send-queue drain logic respectively (D-07/D-08).
-     * Connection calls this during `close()`, racing against `drainTimeoutMs`.
+     * An owner may replace this instance property to run work before the socket
+     * closes. Connection calls it during `close()`, racing against `drainTimeoutMs`.
      */
     beforeClose: (drainTimeoutMs: number) => Promise<void>;
     /**
@@ -943,16 +942,16 @@ declare class Connection extends EventEmitter {
      */
     constructor(opts: ConnectionOptions);
     /**
-     * Current FSM state. One of the 6 `ConnectionState` values (LIFE-01).
+     * Current FSM state. One of the 6 `ConnectionState` values.
      *
      * Subscribe to `'stateChange'` events for reactive state monitoring.
      */
     get state(): ConnectionState;
     /**
-     * Register or replace the per-connection warning subscriber (WARN-10).
+     * Register or replace the per-connection warning subscriber.
      *
      * Subsequent calls replace the previous handler (set-once semantics prevent leaks).
-     * The handler is called synchronously and any exception it throws is swallowed (WARN-06).
+     * The handler is called synchronously and any exception it throws is swallowed.
      *
      * @example
      * ```typescript
@@ -980,7 +979,7 @@ declare class Connection extends EventEmitter {
     /**
      * Write raw bytes to the transport (no framing applied).
      *
-     * Phase 4 (Server) and Phase 5 (Client) wrap this with `encodeFrame()` to add MLLP framing.
+     * The server and the client wrap this with `encodeFrame()` to add MLLP framing.
      * Returns `false` if the connection is CLOSED or DISCONNECTED (no bytes written).
      *
      * @returns `true` if bytes flushed immediately; `false` if buffered (backpressure) or not writable.
@@ -996,7 +995,7 @@ declare class Connection extends EventEmitter {
      * Initiate graceful close of the connection.
      *
      * - If `CONNECTING` or `RECONNECTING`: cancels the pending attempt, transitions
-     *   directly to `CLOSED`, and calls `transport.destroy()` (LIFE-05).
+     *   directly to `CLOSED`, and calls `transport.destroy()`.
      * - If `CONNECTED`: transitions to `DRAINING`, calls `beforeClose(drainTimeoutMs)`,
      *   then `DRAINING → DISCONNECTED` once the hook resolves, or `DRAINING → CLOSED`
      *   if the drain timeout elapses first.
@@ -1017,14 +1016,14 @@ declare class Connection extends EventEmitter {
      * Race `beforeClose()` against the drain timeout.
      *
      * On normal completion: `DRAINING → DISCONNECTED` + `transport.close()`.
-     * On timeout: `DRAINING → CLOSED` + `transport.destroy()` (T-03-04-01).
+     * On timeout: `DRAINING → CLOSED` + `transport.destroy()`.
      */
     private _drainWithTimeout;
     /**
      * Abruptly destroy the connection, discarding any pending writes.
      *
      * Transitions from any non-terminal state directly to `CLOSED` and calls
-     * `transport.destroy(reason)`. Emits `'close'` event. Idempotent — safe to
+     * `transport.destroy(reason)`. Emits `'close'` event. Idempotent, safe to
      * call multiple times.
      *
      * @param reason - Optional error to propagate to the transport.
@@ -1036,7 +1035,7 @@ declare class Connection extends EventEmitter {
      */
     destroy(reason?: Error): void;
     /**
-     * Return a JSON-serializable observability snapshot (OBS-03/04/05).
+     * Return a JSON-serializable observability snapshot.
      *
      * All timestamp fields are `Date | null` (not epoch milliseconds). `JSON.stringify()`
      * serialises them to ISO 8601 strings with no information loss.
@@ -1059,12 +1058,12 @@ declare class Connection extends EventEmitter {
      * Node throws `ERR_UNHANDLED_ERROR` when `'error'` is emitted on an `EventEmitter` with no
      * listener. Every `'error'` emission in this class is reached from inside a transport callback
      * (the socket's `'data'`/`'error'` listener), so an unguarded emit would become an **uncaught
-     * exception that kills the process** — the exact failure the containment above exists to
+     * exception that kills the process**, the exact failure the containment above exists to
      * prevent, merely relocated one frame up the stack.
      *
      * `Connection` is a public export and can legitimately be driven with no `'error'` listener
      * (`MllpServer` and `MllpClient` each attach one; a bare `Connection` need not). The connection
-     * is still torn down and `'stateChange'`/`'close'` still fire, so a caller is never blind —
+     * is still torn down and `'stateChange'`/`'close'` still fire, so a caller is never blind,
      * they simply do not get the typed error object they never asked for. Mirrors
      * `MllpServer._emitErrorIfListened`.
      */
@@ -1077,7 +1076,7 @@ declare class Connection extends EventEmitter {
      * consumers keep the stable `code` and `byteOffset`), then **destroy this connection only**.
      *
      * Why destroy rather than resynchronize: once `push` has thrown, the reader's position within
-     * the byte stream is no longer trustworthy — the next bytes could be the middle of a message.
+     * the byte stream is no longer trustworthy, the next bytes could be the middle of a message.
      * Guessing where the next frame starts is how a clinical message gets silently mis-split, so
      * the connection is dropped instead. A server drops that one peer and keeps serving everyone
      * else.
@@ -1089,17 +1088,17 @@ declare class Connection extends EventEmitter {
      * engine that is already unwell. A compatibility failure is not a network blip.
      *
      * If a peer's quirk is *expected* (trailing junk, keepalive bytes, a missing leading VT), the
-     * decoder's tolerance opt-ins are the supported answer — they turn the throw into a warning.
+     * decoder's tolerance opt-ins are the supported answer, they turn the throw into a warning.
      */
     private _onFatalFramingError;
     /**
-     * Backstop for a NON-framing throw escaping `FrameReader.push` — i.e. our own bug, or a
+     * Backstop for a NON-framing throw escaping `FrameReader.push`, i.e. our own bug, or a
      * subscriber's, rather than the peer's bytes.
      *
      * `_onFrameDecoded` already contains subscriber throws at the dispatch site, so this should be
      * unreachable. It exists because "unreachable" and "cannot kill the process from inside a
      * socket `'data'` handler" are different claims, and only the second one is safe to bet a
-     * clinical interface on. Reported honestly as an internal receive error — never dressed up as
+     * clinical interface on. Reported honestly as an internal receive error, never dressed up as
      * a peer framing fault.
      */
     private _onInternalReceiveError;
@@ -1133,41 +1132,41 @@ declare class Connection extends EventEmitter {
 /**
  * Connection lifecycle phase where the error occurred.
  *
- * All 5 phases are defined in Phase 3 even though `'reconnect'` is only
- * exercised in Phase 5 (CLIENT-17). Locking the full union now prevents a
- * breaking type change later (ERR-03).
+ * All 5 phases are defined even though `'reconnect'` is only
+ * exercised by the client. Locking the full union now prevents a
+ * breaking type change later.
  */
 type ConnectionErrorPhase = "connect" | "send" | "receive" | "close" | "reconnect";
 /**
  * Stable cause codes for `MllpConnectionError`.
  *
- * These codes are a **public API** — they appear in error inspection
+ * These codes are a **public API**, they appear in error inspection
  * by callers, log pipelines, and monitoring dashboards. Renaming or
  * removing a member is a breaking change.
  *
- * - `'fifo-unsafe'` — A queued send was rejected during reconnect because
- *   FIFO ordering cannot be safely resumed across sessions (CLIENT-17).
- * - `'in-flight-orphan'` — An in-flight send (already write-flushed,
+ * - `'fifo-unsafe'`, A queued send was rejected during reconnect because
+ *   FIFO ordering cannot be safely resumed across sessions.
+ * - `'in-flight-orphan'`, An in-flight send (already write-flushed,
  *   ACK timer started) was rejected during reconnect in FIFO mode because
  *   the at-most-once delivery contract cannot be preserved across a
- *   socket drop (D-08, healthcare medication/orders semantics).
- * - `'tls-verify'` (Phase 8) — The TLS handshake failed certificate
+ *   socket drop (healthcare medication/orders semantics).
+ * - `'tls-verify'`, The TLS handshake failed certificate
  *   verification (untrusted chain, expired/not-yet-valid cert, hostname
  *   mismatch, revocation, …). See {@link isTlsVerificationErrorCode} for the
  *   exact underlying error codes. Classified **permanent** by
- *   `isTransientConnectionError` — never auto-reconnect-looped into a
+ *   `isTransientConnectionError`, never auto-reconnect-looped into a
  *   misconfigured or MITM'd endpoint.
- * - `'tls-handshake'` (Phase 8) — A TLS-**protocol**-shaped handshake
+ * - `'tls-handshake'`, A TLS-**protocol**-shaped handshake
  *   failure observed before `'secureConnect'`: `ERR_SSL_*` codes, `EPROTO`,
  *   or an OpenSSL alert-bearing error (protocol version mismatch, no shared
  *   cipher, a required mutual-TLS client certificate rejected by the
  *   server, …). See `isTlsProtocolError` for the boundary. Pure TCP-level
  *   failures (`ECONNREFUSED`, `ETIMEDOUT`, …) on a TLS-configured
- *   connection carry **no** `connectionCause` — the same shape as plaintext.
+ *   connection carry **no** `connectionCause`, the same shape as plaintext.
  *
  * Scope note: the `'tls-verify'`/`'tls-handshake'` values are attached on
  * the client's **initial `connect()` path**. Failures on the auto-reconnect
- * path surface as raw socket errors — their transient/permanent
+ * path surface as raw socket errors, their transient/permanent
  * classification still applies, but they do not (yet) carry a
  * `connectionCause`.
  *
@@ -1184,9 +1183,9 @@ type ConnectionErrorCause = "fifo-unsafe" | "in-flight-orphan" | "tls-verify" |
  * Thrown (or emitted via `onError`) for socket-layer problems such as
  * connection refused, ECONNRESET, ETIMEDOUT, or DNS failure.
  *
- * - `cause` — the original OS or TLS error
- * - `phase` — which connection lifecycle phase the failure occurred in
- * - `connectionCause` — optional stable cause-code (e.g. for FIFO reconnect rejections)
+ * - `cause`, the original OS or TLS error
+ * - `phase`, which connection lifecycle phase the failure occurred in
+ * - `connectionCause`, optional stable cause-code (e.g. for FIFO reconnect rejections)
  *
  * @example
  * ```typescript
@@ -1231,14 +1230,14 @@ declare class MllpConnectionError extends Error {
  *
  * ## Why this is safety-critical
  *
- * A positive acknowledgement (`AA`) tells the sender "you may forget this message — I
+ * A positive acknowledgement (`AA`) tells the sender "you may forget this message, I
  * have it." If a server emits `AA` *before* the message is durably handled and then the
  * process crashes, the message is **silently lost** with no record on either side. For
  * clinical messages (an admit, an order, a result) that is a patient-safety failure.
  *
  * The contract this module enforces: a positive ACK (`AA`) is only built once the
  * application handler has resolved success. A handler that throws or rejects yields a
- * **negative** ACK (`AE` by default, `AR` when the handler asks for it) — never `AA`.
+ * **negative** ACK (`AE` by default, `AR` when the handler asks for it), never `AA`.
  *
  * Spec: HL7 v2.5.1 ch. 2 §2.9.2 (original acknowledgement mode), §2.9.3 (enhanced
  * accept/application acknowledgement), Table 0008 (Acknowledgment Code), §2.9.2.2
@@ -1247,14 +1246,14 @@ declare class MllpConnectionError extends Error {
  * @packageDocumentation
  */
 /**
- * HL7 Table 0008 — Acknowledgment Code. A **stable public API**.
+ * HL7 Table 0008, Acknowledgment Code. A **stable public API**.
  *
  * Two families, by mode (HL7 v2.5.1 §2.9):
  *
  * - **Original mode (§2.9.2):** `AA` accept, `AE` application error, `AR` application
  *   reject. The single ACK reports application-level outcome.
  * - **Enhanced mode (§2.9.3):** `CA` commit accept, `CE` commit error, `CR` commit
- *   reject — the *accept* acknowledgement, distinct from a later application ACK.
+ *   reject, the *accept* acknowledgement, distinct from a later application ACK.
  *
  * `AE` vs `AR`: `AE` is a processing **error** (the sender may resend later, e.g. a
  * transient downstream outage); `AR` is a **reject** (the sender should not resend the
@@ -1284,7 +1283,7 @@ type NegativeAckCode = "AE" | "AR";
  * returns. Throwing **any** error from a commit-gated handler yields `AE` by default;
  * throw an `MllpAckError` to choose `AR` (application reject) instead.
  *
- * The `message` is **never** copied into the ACK bytes or any emitted event — it may
+ * The `message` is **never** copied into the ACK bytes or any emitted event, it may
  * carry PHI. Only the static, non-PHI `ackCode` influences the wire response.
  *
  * @example
@@ -1320,7 +1319,7 @@ declare class MllpAckError extends Error {
  * Resolve the negative acknowledgement code for a handler failure.
  *
  * An {@link MllpAckError} carries an explicit `ackCode`; any other thrown value maps to
- * `AE` (application error — the default, since most handler failures are transient and
+ * `AE` (application error, the default, since most handler failures are transient and
  * a resend may succeed).
  *
  * @example
@@ -1338,27 +1337,27 @@ declare function resolveNackCode(err: unknown): NegativeAckCode;
  *
  * The rule this enforces: **never answer `AA` for a message you could not correlate.** A
  * positive ACK is a promise the sender may forget the message; if it names a control ID
- * the sender cannot match — or names one of several messages it never read — the sender
+ * the sender cannot match, or names one of several messages it never read, the sender
  * times out and resends, committing a **duplicate clinical message** (or worse, believes a
  * destroyed message was delivered). Three payload-shaped reasons make a positive ACK
  * uncorrelatable, all peer-reachable off the wire:
  *
- *   1. **No readable `MSH`.** `readMshSegment` returns `null` — e.g. a `BOM`/`SP`/`TAB`
+ *   1. **No readable `MSH`.** `readMshSegment` returns `null`, e.g. a `BOM`/`SP`/`TAB`
  *      before `MSH` (which shares the `MSH`'s segment line, so `MSH` heads no segment), or
  *      a bare fragment delivered after a mid-payload `VT` discard (`MLLP_TRAILING_BYTES`).
  *      MSA-2 would be empty: an ACK that correlates to nothing.
  *   2. **Empty MSH-10.** The `MSH` is readable but carries no message control ID, so there
- *      is nothing to echo — again `MSA|AA|` with an empty MSA-2.
+ *      is nothing to echo, again `MSA|AA|` with an empty MSA-2.
  *   3. **A batch or concatenated messages.** An `FHS`/`BHS`/`BTS`/`FTS` envelope (§2.10.3)
  *      or a second `MSH` in the same frame: a single MSA-2 can echo only ONE control ID, so
  *      a positive ACK naming the first silently drops the rest (see
- *      {@link containsBatchOrExtraMessage}). Batch ACK is its own feature (`MLLP-BATCH`) —
- *      until it is designed, a batch must stay a **loud non-positive** answer.
+ *      {@link containsBatchOrExtraMessage}). Batch ACK is its own feature; until it is
+ *      designed, a batch must stay a **loud non-positive** answer.
  *
  * This is a **refusal**, not a tolerance widening: it never makes an unreadable message
  * readable, never re-bases on a located `MSH`, never parses a batch. It only recognizes
  * the shapes for which a positive disposition would be a lie, so the builder can fall back
- * to `AE`. A **negative** requested code (`AE`/`AR`/`CE`/`CR`) is unaffected — it is
+ * to `AE`. A **negative** requested code (`AE`/`AR`/`CE`/`CR`) is unaffected, it is
  * already non-positive, and echoing whatever control ID it can find is still useful.
  *
  * Pure, byte-level, never throws.
@@ -1375,12 +1374,12 @@ declare function rawAckUncorrelatable(payload: Buffer): boolean;
  * Build a minimal original-mode HL7 v2 acknowledgement from raw inbound payload bytes,
  * **without a parser** (parser-driven ACKs are the `@cosyte/mllp/ack-from-hl7` subpath).
  *
- * Locates the `MSH` segment (the first `CR`/`LF`-delimited segment starting with `MSH` —
+ * Locates the `MSH` segment (the first `CR`/`LF`-delimited segment starting with `MSH`,
  * so a leading `CR` or an `FHS`/`BHS` batch header does not hide it), reads the field
  * separator from **MSH-1** and the encoding characters from **MSH-2**, then splits that
  * segment on that separator to read fields. The ACK swaps sender/receiver per HL7 ACK
- * rules, echoes the inbound MSH-10 into MSA-2 (§2.9.2.2), sets MSA-1 to `code`, and — for
- * negative codes — adds a **static, PHI-free** MSA-3 reason. A fresh control ID fills the
+ * rules, echoes the inbound MSH-10 into MSA-2 (§2.9.2.2), sets MSA-1 to `code`, and, for
+ * negative codes, adds a **static, PHI-free** MSA-3 reason. A fresh control ID fills the
  * ACK's own MSH-10.
  *
  * ## Why the delimiters are read, not assumed
@@ -1390,7 +1389,7 @@ declare function rawAckUncorrelatable(payload: Buffer): boolean;
  * convention, not the spec. Assuming it was wrong in two compounding ways:
  *
  *   1. **Reading.** Splitting a `!`-delimited message on `|` yields ONE field, so every
- *      echoed field — including MSH-10 — came back empty. The ACK went out as
+ *      echoed field, including MSH-10, came back empty. The ACK went out as
  *      `MSA|AA|` with **no correlation id at all**: the sender cannot match it, times
  *      out, and resends → a duplicate clinical message. That is the exact failure this
  *      package's correlator exists to prevent, manufactured by the ACK builder itself.
@@ -1404,28 +1403,28 @@ declare function rawAckUncorrelatable(payload: Buffer): boolean;
  *
  * ## It reads the MSH through the SHARED scanner
  *
- * The MSH read is `readMshSegment` from `src/internal/control-id.ts` — the same call the
+ * The MSH read is `readMshSegment` from `src/internal/control-id.ts`, the same call the
  * client's correlator makes to derive the key it will later match this ACK against. That
  * is deliberate and it is the whole point: this builder used to re-derive the read itself
  * (`payload.toString("latin1").split("\r")`, hunting for an `MSH` anywhere in the
  * payload), and the two disagreed on real inputs. On a **truncated MSH** followed by a
  * `PID` the correlator keyed on the PID's MRN while this builder echoed an empty MSA-2. On
- * a payload with a **leading `CR`** — which the MLLP decoder passes straight through, and
- * which real senders emit — this builder found the `MSH` and echoed MSH-10 correctly while
+ * a payload with a **leading `CR`**, which the MLLP decoder passes straight through, and
+ * which real senders emit, this builder found the `MSH` and echoed MSH-10 correctly while
  * the correlator, requiring `MSH` at byte 0, gave up. Every such disagreement is an ACK the
  * sender cannot match → timeout → resend → **duplicate clinical message**.
  *
- * The fix is one scan — but note *which* scan. The first attempt made them agree by
+ * The fix is one scan, but note *which* scan. The first attempt made them agree by
  * requiring `MSH` at byte 0 everywhere, which "resolved" the leading-`CR` disagreement by
  * degrading the side that had been **right**: `buildRawAck` began emitting a positive `AA`
  * with an empty MSA-2, silently, for a message whose MSH-10 was plainly present. Agreement
  * is not the goal; agreeing on the *correct*, *tolerant* answer is. A lenient reader may
- * never drop data that is there (Postel's Law — CLAUDE.md).
+ * never drop data that is there (Postel's Law, CLAUDE.md).
  *
  * ## The fail-safe downgrade: never a positive `AA`/`CA` it cannot correlate
  *
  * A positive acknowledgement is a promise the sender may forget the message. If it names a
- * control ID the sender cannot match — or names one message out of several it never read —
+ * control ID the sender cannot match, or names one message out of several it never read,
  * the sender times out and resends, committing a **duplicate clinical message**. So a
  * requested positive code is **downgraded** to its non-positive counterpart (`AA`→`AE`,
  * `CA`→`CE`) whenever the payload cannot carry a correlatable positive ACK: no readable
@@ -1433,10 +1432,10 @@ declare function rawAckUncorrelatable(payload: Buffer): boolean;
  * acknowledge. See {@link rawAckUncorrelatable} for the exact conditions and why each is a
  * refusal rather than a widened reader. A requested **negative** code (`AE`/`AR`/`CE`/`CR`)
  * is never touched. This mirrors the parser-backed `buildMllpAck`, which downgrades and
- * warns on an unparseable inbound — the two builders' fail-safe semantics now agree.
+ * warns on an unparseable inbound, the two builders' fail-safe semantics now agree.
  *
  * **Never throws** and **never copies payload content** beyond the routing/control
- * metadata above — `readMshSegment` stops at the MSH's segment terminator, so no field of
+ * metadata above, `readMshSegment` stops at the MSH's segment terminator, so no field of
  * any later segment (PID and friends) can be reached, let alone echoed. On a missing or
  * unreadable `MSH` it returns a minimal well-formed ACK carrying the (downgraded) `code` so
  * the caller can still respond.
@@ -1444,7 +1443,7 @@ declare function rawAckUncorrelatable(payload: Buffer): boolean;
  * @param payload - Raw decoded HL7 v2 payload bytes (MLLP framing already stripped).
  * @param code - Requested MSA-1 acknowledgement code. A positive `AA`/`CA` is downgraded to
  *   `AE`/`CE` when the message cannot be correlated (see above).
- * @returns ACK payload bytes (no framing — the caller wraps with `encodeFrame`).
+ * @returns ACK payload bytes (no framing, the caller wraps with `encodeFrame`).
  *
  * @example
  * ```typescript
@@ -1455,7 +1454,7 @@ declare function rawAckUncorrelatable(payload: Buffer): boolean;
 declare function buildRawAck(payload: Buffer, code: AckCode): Buffer;
 
 /**
- * MLLP Server — createServer(), createStarterServer(), and MllpServer class.
+ * MLLP Server, createServer(), createStarterServer(), and MllpServer class.
  *
  * Provides the server-side MLLP transport: listen for inbound TCP connections,
  * decode MLLP-framed messages, surface them as Buffer payloads, and support
@@ -1477,9 +1476,9 @@ declare function buildRawAck(payload: Buffer, code: AckCode): Buffer;
  */
 
 /**
- * Metadata attached to each decoded MLLP message (SERVER-03).
+ * Metadata attached to each decoded MLLP message.
  *
- * All fields are `readonly` — the object is `Object.freeze()`'d before emission.
+ * All fields are `readonly`, the object is `Object.freeze()`'d before emission.
  *
  * @example
  * ```typescript
@@ -1498,30 +1497,30 @@ interface MessageMeta {
 }
 /**
  * Why the server sent a **negative** acknowledgement instead of `AA` on the auto-ACK path.
- * A stable, **PHI-free** enum (no payload bytes, no control ID) — safe to log and to key
+ * A stable, **PHI-free** enum (no payload bytes, no control ID), safe to log and to key
  * metrics on.
  *
- * - `'handler-rejected'` — a commit-gated `onMessage` handler threw/rejected (the commit
+ * - `'handler-rejected'`, a commit-gated `onMessage` handler threw/rejected (the commit
  *   contract: a positive ACK cannot precede a successful commit).
- * - `'uncorrelatable-inbound'` — the inbound could not carry a correlatable positive ACK
+ * - `'uncorrelatable-inbound'`, the inbound could not carry a correlatable positive ACK
  *   (no readable `MSH`, an empty MSH-10, or a batch/concatenated-message shape). A positive
  *   `AA` here names a control ID the sender cannot match → timeout → resend → **duplicate
  *   clinical message**. See {@link rawAckUncorrelatable}.
- * - `'discarded-bytes'` — the decoder flagged `MLLP_TRAILING_BYTES` for this frame: a
+ * - `'discarded-bytes'`, the decoder flagged `MLLP_TRAILING_BYTES` for this frame: a
  *   mid-payload `VT` made it **discard accumulated bytes** and deliver only the fragment
  *   after it. The clinical message was destroyed in transit; a positive `AA` would tell the
  *   sender a message we never received was delivered.
  */
 type NackReason = "handler-rejected" | "uncorrelatable-inbound" | "discarded-bytes";
 /**
- * Payload of the server `'nack'` event — emitted whenever the server responds with a
+ * Payload of the server `'nack'` event, emitted whenever the server responds with a
  * **negative** acknowledgement instead of `AA` on the auto-ACK path (the fail-safe commit
  * contract). This fires both when a commit-gated `autoAck: 'AA'` handler throws/rejects and
  * when the server **downgrades** a positive auto-ACK because the inbound could not be
  * correlated ({@link NackReason}).
  *
  * **PHI-safe by construction:** carries only the connection ID, the resolved
- * acknowledgement code, and a static `reason` — never the payload, the inbound control ID,
+ * acknowledgement code, and a static `reason`, never the payload, the inbound control ID,
  * or the thrown error's message (which may carry PHI). The object is `Object.freeze()`'d
  * before emission.
  *
@@ -1541,10 +1540,10 @@ interface NackEvent {
     readonly reason: NackReason;
 }
 /**
- * Observability snapshot returned by `server.getStats()` (OBS-02).
+ * Observability snapshot returned by `server.getStats()`.
  *
  * All fields are JSON-serializable. `connections` and `activeConnections` both
- * reflect the current live connection count (ROADMAP SC-5 / OBS-02).
+ * reflect the current live connection count.
  *
  * @example
  * ```typescript
@@ -1560,7 +1559,7 @@ interface ServerStats {
     /** Bound host, or `null` before listen(). */
     readonly host: string | null;
     /**
-     * Current live connection count (OBS-02, ROADMAP SC-5).
+     * Current live connection count.
      * Same value as `activeConnections`.
      */
     readonly connections: number;
@@ -1574,9 +1573,9 @@ interface ServerStats {
     readonly acceptedTotal: number;
     /** Total connections closed since listen() (monotonically increasing). */
     readonly closedTotal: number;
-    /** Whether this server is configured for TLS (Phase 8). Mirrors `ServerOptions.tls` being set. */
+    /** Whether this server is configured for TLS. Mirrors `ServerOptions.tls` being set. */
     readonly tls: boolean;
-    /** Total `'tlsClientError'` events (failed TLS handshakes, incl. rejected client certs) since listen() (Phase 8). */
+    /** Total `'tlsClientError'` events (failed TLS handshakes, incl. rejected client certs) since listen(). */
     readonly tlsClientErrorsTotal: number;
 }
 /**
@@ -1600,11 +1599,11 @@ interface ServerOptions {
     /**
      * Called for each decoded MLLP message.
      *
-     * Its role depends on `autoAck` — this is the **commit contract** (HL7 v2.5.1 §2.9.2):
+     * Its role depends on `autoAck`, this is the **commit contract** (HL7 v2.5.1 §2.9.2):
      *
      * - **`autoAck: 'AA'` + this handler ⇒ commit-gated (the safe default).** The handler
      *   is the durable-commit step. The server **awaits** it and only then sends the ACK:
-     *   resolve ⇒ `AA`; **throw/reject ⇒ `AE`** (or `AR` via {@link MllpAckError}) — a
+     *   resolve ⇒ `AA`; **throw/reject ⇒ `AE`** (or `AR` via {@link MllpAckError}), a
      *   positive ACK can never precede a successful commit. Do **not** call `conn.send()`
      *   here in this mode.
      * - **`autoAck` unset ⇒ manual mode.** The handler owns the response; build and send the
@@ -1616,8 +1615,8 @@ interface ServerOptions {
      */
     onMessage?: (payload: Buffer, meta: MessageMeta, conn: Connection) => void | Promise<void>;
     /**
-     * FrameReader tolerance options applied to every accepted connection (SERVER-12).
-     * Merged with SERVER_DEFAULT_FRAMING — caller-supplied values override defaults.
+     * FrameReader tolerance options applied to every accepted connection.
+     * Merged with SERVER_DEFAULT_FRAMING, caller-supplied values override defaults.
      * `onFrame` and `onWarning` are managed internally and must not be supplied here.
      */
     framing?: Omit<FrameReaderOptions, "onFrame" | "onWarning">;
@@ -1628,44 +1627,44 @@ interface ServerOptions {
     /**
      * Auto-ACK mode. When set, the server builds and sends the ACK for each message.
      *
-     * - **`'AA'`** — auto-acknowledge with the fail-safe **commit contract**:
+     * - **`'AA'`**, auto-acknowledge with the fail-safe **commit contract**:
      *   - **With an `onMessage` handler ⇒ commit-gated (recommended).** The server awaits
      *     `onMessage` (the durable-commit step), then sends `AA` on success or a **negative**
      *     ACK on failure (`AE` by default; `AR` via {@link MllpAckError}). The positive ACK
-     *     **cannot precede a successful commit** — a handler throw can never yield `AA`.
+     *     **cannot precede a successful commit**, a handler throw can never yield `AA`.
      *   - **Without an `onMessage` handler ⇒ transport-accept.** `AA` is sent on frame
-     *     receipt. This `AA` means only **"bytes received and framed"** — *not*
+     *     receipt. This `AA` means only **"bytes received and framed"**, *not*
      *     "application-processed". ⚠️ For clinical messages this is unsafe on its own:
      *     pair `'AA'` with an `onMessage` handler that durably commits, so the ACK reflects
      *     real processing.
-     * - **`fn`** — `fn(payload, meta, conn)` builds the ACK bytes the server sends; the
+     * - **`fn`**, `fn(payload, meta, conn)` builds the ACK bytes the server sends; the
      *   caller fully owns MSA-1 (e.g. to emit enhanced-mode `CA`/`CE`/`CR`).
      *
-     * The `'message'` event always fires BEFORE the ACK is sent (D-03). Do NOT call
-     * `conn.send()` in `onMessage` when `autoAck` is set — this results in two ACKs.
+     * The `'message'` event always fires BEFORE the ACK is sent. Do NOT call
+     * `conn.send()` in `onMessage` when `autoAck` is set, this results in two ACKs.
      */
     autoAck?: "AA" | ((payload: Buffer, meta: MessageMeta, conn: Connection) => Buffer | Promise<Buffer>);
     /**
-     * TCP keepalive probe interval in ms (D-10).
+     * TCP keepalive probe interval in ms.
      * Calls `socket.setKeepAlive(true, ms)` on each accepted socket.
      * Uses OS TCP stack to detect dead peers (half-open, network partitions).
      * Distinct from `deadPeerTimeoutMs` (application-level idle close).
      */
     keepaliveIntervalMs?: number;
     /**
-     * Application-level idle close timeout in ms (D-11, ROADMAP SC-5).
+     * Application-level idle close timeout in ms.
      * If no HL7 messages are received on a connection for this interval, the connection
      * is destroyed via `conn.destroy(new Error('idle timeout'))`.
      * Resets on every `'message'` event. Distinct from `keepaliveIntervalMs` (OS TCP probe).
      */
     deadPeerTimeoutMs?: number;
     /**
-     * Graceful drain timeout passed to `conn.close()` during `server.close()` (D-06).
+     * Graceful drain timeout passed to `conn.close()` during `server.close()`.
      * Default: 30 000 ms.
      */
     drainTimeoutMs?: number;
     /**
-     * Enable TLS (MLLPS) for this server (Phase 8). When set, the server binds a
+     * Enable TLS (MLLPS) for this server. When set, the server binds a
      * `tls.Server` instead of a plain `net.Server`, consumes `'secureConnection'`
      * (post-handshake sockets) instead of `'connection'`, and surfaces failed
      * handshakes via the `'tlsClientError'` event rather than crashing.
@@ -1676,14 +1675,14 @@ interface ServerOptions {
      */
     tls?: ServerTlsOptions;
     /**
-     * Opt-in required to bind a wildcard host — a bind-safety guardrail
-     * (Phase 8). Without this flag, `listen()` rejects a wildcard host in
+     * Opt-in required to bind a wildcard host, a bind-safety guardrail.
+     * Without this flag, `listen()` rejects a wildcard host in
      * two tiers: **literal spellings** (`'0.0.0.0'`, `'::'`, `''`, `'::0'`,
      * `'0:0:0:0:0:0:0:0'`, `'::ffff:0.0.0.0'`, …) reject **pre-bind** (fast
      * path, nothing is ever bound); **resolver-only shorthands** (`'0'`,
      * `'0.0'`, `'0x0.0.0.0'`, hostnames resolving to the unspecified
      * address, …) are caught **post-bind** against the OS-normalized bound
-     * address — the just-bound server closes before any connection can be
+     * address, the just-bound server closes before any connection can be
      * accepted and `listen()` rejects, with no listening state and no
      * `'listening'` event either way. When `true`, binding a wildcard host
      * emits a one-time `'securityWarning'` (`MLLP_BIND_ALL_INTERFACES`) at
@@ -1694,7 +1693,7 @@ interface ServerOptions {
     allowWildcardBind?: boolean;
 }
 /**
- * Options for `createStarterServer()` — the "three lines of code" factory (SERVER-08).
+ * Options for `createStarterServer()`, the "three lines of code" factory.
  *
  * Extends `ServerOptions` with `port`, `host`, and `handleSignals`. Defaults:
  * `autoAck: 'AA'`, `drainTimeoutMs: 30_000`, `Symbol.asyncDispose` wired.
@@ -1715,23 +1714,23 @@ interface StarterServerOptions extends ServerOptions {
     /** Port to listen on. */
     port: number;
     /**
-     * Host to bind to. Default `'127.0.0.1'` (Phase 8 bind-safety hardening —
+     * Host to bind to. Default `'127.0.0.1'` (bind-safety hardening,
      * was `'0.0.0.0'`; binding all interfaces now requires
      * `ServerOptions.allowWildcardBind: true`).
      */
     host?: string;
     /**
      * Register `process.once('SIGTERM')` and `process.once('SIGINT')` handlers that
-     * call `server.close()` then `process.exit(0)` (D-09). Default: `false`.
+     * call `server.close()` then `process.exit(0)`. Default: `false`.
      *
      * Handlers are automatically removed when `server.close()` is called, so
-     * `process.listenerCount('SIGTERM') === 0` after close() completes — preventing
+     * `process.listenerCount('SIGTERM') === 0` after close() completes, preventing
      * handler accumulation across test instances or multiple server restarts.
      */
     handleSignals?: boolean;
 }
 /**
- * MLLP TCP server — wraps `net.Server` without extending it (D-02).
+ * MLLP TCP server, wraps `net.Server` without extending it.
  *
  * Each accepted socket is wrapped in a `NetTransport`, connected to a `Connection`
  * with server-level framing options, and added to `_connections`. Messages are
@@ -1739,7 +1738,7 @@ interface StarterServerOptions extends ServerOptions {
  *
  * Public events: `'listening'`, `'connection'`, `'message'`, `'nack'`, `'error'`, `'close'`.
  * The `'nack'` event ({@link NackEvent}) fires whenever the server returns a negative ACK
- * instead of `AA` on the auto-ACK path — a commit-gated `autoAck: 'AA'` handler failing, or
+ * instead of `AA` on the auto-ACK path, a commit-gated `autoAck: 'AA'` handler failing, or
  * a positive auto-ACK **downgraded** because the inbound could not be correlated (an
  * unreadable/uncorrelatable message, or one whose bytes the decoder discarded). The
  * {@link NackReason} distinguishes the causes.
@@ -1747,19 +1746,19 @@ interface StarterServerOptions extends ServerOptions {
  * **`'error'` contract:** underlying `net.Server`/`tls.Server` errors are forwarded to the
  * `'error'` event whenever a listener is attached. With **no** listener, the outcome depends on
  * server state: during a `listen()` (the bind window) the error **rejects the `listen()` promise**
- * — the primary error surface — and the process never crashes on a bind error; with no `listen()`
+ * the primary error surface, and the process never crashes on a bind error; with no `listen()`
  * in flight and the server not serving (e.g. a stale async error after `close()`) the error is
  * dropped; but **while serving**, an unlistened runtime error (e.g. accept-loop `EMFILE`) keeps
- * Node's fail-loud crash-on-unlistened-`'error'` convention — a silent accept outage is
+ * Node's fail-loud crash-on-unlistened-`'error'` convention, a silent accept outage is
  * impossible. Caveat for `'error'` listeners: the forwarder runs **before** the internal
  * `listen()` rejection handler, so an `'error'` listener that synchronously calls `close()`
  * during the bind window changes the `listen()` rejection from the bind error to the typed
- * close-during-listen `MllpConnectionError` — match on the `'error'` event payload, not the
+ * close-during-listen `MllpConnectionError`, match on the `'error'` event payload, not the
  * rejection, if you do that.
- * Phase 8 (TLS/MLLPS) adds two more: `'tlsClientError'` (a failed TLS handshake — the
+ * TLS (MLLPS) adds two more: `'tlsClientError'` (a failed TLS handshake, the
  * server logs it and keeps serving other connections) and `'securityWarning'` (loud,
  * one-time notice when a wildcard host is bound via `allowWildcardBind: true`).
- * All event payloads are `Object.freeze()`'d before emission (SERVER-10).
+ * All event payloads are `Object.freeze()`'d before emission.
  *
  * @example
  * ```typescript
@@ -1778,13 +1777,13 @@ declare class MllpServer extends EventEmitter {
     private readonly _netServer;
     private readonly _connections;
     private readonly _opts;
-    /** `true` when `ServerOptions.tls` is set — `_netServer` is actually a `tls.Server`. */
+    /** `true` when `ServerOptions.tls` is set, `_netServer` is actually a `tls.Server`. */
     private readonly _isTls;
     private _listening;
-    /** Phase 8 — single-flight guard: `true` while a `listen()` call is settling. */
+    /** Single-flight guard: `true` while a `listen()` call is settling. */
     private _listenInFlight;
     /**
-     * Phase 8 — settle hook for an in-flight `listen()`. Non-null only while a
+     * Settle hook for an in-flight `listen()`. Non-null only while a
      * `listen()` is in flight; invoked by `close()` so a close racing startup
      * rejects the pending `listen()` (typed) instead of leaving it hung with
      * the single-flight guard stuck. Cleared on every settle path.
@@ -1794,7 +1793,7 @@ declare class MllpServer extends EventEmitter {
     private _host;
     private _acceptedTotal;
     private _closedTotal;
-    /** Phase 8 — count of `'tlsClientError'` events since listen(). */
+    /** Count of `'tlsClientError'` events since listen(). */
     private _tlsClientErrorsTotal;
     /**
      * Construct an MLLP server. Created idle; call `listen()` (or use
@@ -1810,23 +1809,23 @@ declare class MllpServer extends EventEmitter {
      * `Object.freeze({ port: actualPort, host: actualHost })`.
      *
      * **Single-flight:** one `listen()` per server lifecycle at a time. A call
-     * while the server is already listening — or while another `listen()` is
-     * still in flight — rejects with a typed `MllpConnectionError` (concurrent
+     * while the server is already listening, or while another `listen()` is
+     * still in flight, rejects with a typed `MllpConnectionError` (concurrent
      * binds raced each other's post-bind safety checks). Call `close()` before
      * re-listening; sequential `listen()` → `close()` → `listen()` is fine.
      *
      * **`close()` during an in-flight `listen()`** rejects that `listen()` with
      * a typed `MllpConnectionError` (never a hang) and clears the single-flight
-     * guard — a subsequent `listen()` on the same server works. This makes
+     * guard, a subsequent `listen()` on the same server works. This makes
      * `Symbol.asyncDispose` (which delegates to `close()`) safe even before a
      * `listen()` has settled. (Exception: `close({ signal })` with an
-     * already-aborted signal is a no-op AbortError rejection — the in-flight
+     * already-aborted signal is a no-op AbortError rejection, the in-flight
      * `listen()` is left to settle on its own bind outcome; see `close()`.)
      *
      * @param port - TCP port to bind. Use `0` to let the OS assign an ephemeral port.
      * @param hostOrOpts - Host string or object with `host` and optional `signal`.
-     *   Default host: `'127.0.0.1'` (Phase 8 bind-safety hardening). Wildcard hosts
-     *   are rejected unless `ServerOptions.allowWildcardBind: true` — literal
+     *   Default host: `'127.0.0.1'` (bind-safety hardening). Wildcard hosts
+     *   are rejected unless `ServerOptions.allowWildcardBind: true`, literal
      *   spellings pre-bind, resolver-only shorthands post-bind via the
      *   OS-normalized bound address.
      *
@@ -1844,19 +1843,19 @@ declare class MllpServer extends EventEmitter {
     /**
      * Stop accepting new connections and gracefully close all active connections.
      *
-     * Sequence (D-06):
-     * 1. `net.Server.close()` — stops accepting new connections immediately
+     * Sequence:
+     * 1. `net.Server.close()`, stops accepting new connections immediately
      * 2. If `_connections` is empty: resolves immediately (no drain needed)
-     * 3. Calls `_drainAll(drainTimeoutMs)` — Promise.all + side-effect setTimeout
+     * 3. Calls `_drainAll(drainTimeoutMs)`, Promise.all + side-effect setTimeout
      *    that force-destroys stragglers after the drain window
      *
      * Calling `close()` while a `listen()` is still in flight proactively
      * settles that `listen()` with a typed `MllpConnectionError` rejection
-     * and clears the single-flight guard — the server is immediately
+     * and clears the single-flight guard, the server is immediately
      * re-listenable. `Symbol.asyncDispose` (which delegates here) is
      * therefore safe before `listen()` settles. **Qualification:** a
      * `close({ signal })` whose signal is **already aborted** rejects
-     * immediately with `AbortError` and performs no work — it does NOT close
+     * immediately with `AbortError` and performs no work, it does NOT close
      * the server and does NOT settle the in-flight `listen()`, which simply
      * continues and settles on its own bind outcome.
      *
@@ -1876,7 +1875,7 @@ declare class MllpServer extends EventEmitter {
     /**
      * Drain all active connections with a shared timeout.
      *
-     * Uses Promise.all (not Promise.race) for coordination — the timeout is a
+     * Uses Promise.all (not Promise.race) for coordination, the timeout is a
      * side effect that calls `conn.destroy()` on stragglers after `drainTimeoutMs`.
      * Promise.all resolves when all `conn.close()` promises settle (which happens
      * because `conn.destroy()` transitions connections to CLOSED).
@@ -1885,7 +1884,7 @@ declare class MllpServer extends EventEmitter {
      */
     private _drainAll;
     /**
-     * Async disposal — delegates to `close()` for `await using` support.
+     * Async disposal, delegates to `close()` for `await using` support.
      *
      * @example
      * ```typescript
@@ -1896,10 +1895,9 @@ declare class MllpServer extends EventEmitter {
      */
     [Symbol.asyncDispose](): Promise<void>;
     /**
-     * Return a JSON-serializable observability snapshot (OBS-02).
+     * Return a JSON-serializable observability snapshot.
      *
      * `totalBytesIn` and `totalBytesOut` aggregate from live connections at call time.
-     * Plan 04 adds full aggregation; at Plan 01 scope they return 0.
      *
      * @example
      * ```typescript
@@ -1909,7 +1907,7 @@ declare class MllpServer extends EventEmitter {
      */
     getStats(): ServerStats;
     /**
-     * Emit on `'error'` only when a listener is attached — an unlistened
+     * Emit on `'error'` only when a listener is attached, an unlistened
      * `EventEmitter` `'error'` emission throws (see the class JSDoc error
      * contract). The single guard shared by the optional-tap forwarding sites
      * in this class; the constructor's net.Server forwarder deliberately does
@@ -1919,7 +1917,7 @@ declare class MllpServer extends EventEmitter {
     /**
      * Emit a server event, containing a throwing subscriber.
      *
-     * Every event this server emits is reachable from a callback we do not own — the `net.Server`
+     * Every event this server emits is reachable from a callback we do not own, the `net.Server`
      * `'connection'` listener, the `tls.Server` `'tlsClientError'` listener, a socket's `'data'`
      * listener (via `Connection`), or the `catch` block of a `void`-ed async ACK task. A throwing
      * subscriber would therefore unwind into that callback and kill the process (or reject a void-ed
@@ -1931,8 +1929,8 @@ declare class MllpServer extends EventEmitter {
     private _emitErrorIfListened;
     private _onSocketAccepted;
     /**
-     * Extract a minimal, content-free peer-certificate summary (Phase 8, ATNA
-     * ITI-19 mutual authentication) — CN strings, expiry, and the verification
+     * Extract a minimal, content-free peer-certificate summary (ATNA ITI-19
+     * mutual authentication), CN strings, expiry, and the verification
      * outcome (`authorized`) only; never the full certificate object. Returns
      * `null` when no peer certificate was presented (e.g. `clientAuth: 'WANT'`
      * with no client cert).
@@ -1945,29 +1943,29 @@ declare class MllpServer extends EventEmitter {
      * then dispatches: resolve ⇒ `AA`; throw/reject ⇒ a negative ACK (`AE` by default,
      * `AR` via {@link MllpAckError}). A positive ACK can never precede a successful commit.
      *
-     * Without an `onMessage` handler, `'AA'` degrades to a **transport-accept** — `AA`
+     * Without an `onMessage` handler, `'AA'` degrades to a **transport-accept**, `AA`
      * meaning "bytes received and framed", not "application-processed".
      *
      * A handler failure is **expected flow**, not a server error: it produces a negative
      * ACK and a `'nack'` event. The thrown error's message is never placed on the wire or
-     * in the event (it may carry PHI) — only the static `ackCode` and the inbound control
+     * in the event (it may carry PHI), only the static `ackCode` and the inbound control
      * metadata reach the peer.
      */
     private _sendCommitAck;
     /**
      * Resolve the auto-ACK code for a message the server would otherwise acknowledge
-     * **positively** (`AA`) — the no-handler transport-accept and the post-commit success
+     * **positively** (`AA`), the no-handler transport-accept and the post-commit success
      * paths. Fail-safe: downgrade to `AE` and emit a PHI-safe `'nack'` whenever the message
      * cannot carry a correlatable positive ACK, so `AA` never names a control ID the sender
      * cannot match (→ timeout → resend → **duplicate clinical message**).
      *
      * Two independent disqualifiers, one from the bytes and one from the frame:
      *
-     *   - **`rawAckUncorrelatable(payload)`** — no readable `MSH`, an empty MSH-10, or a
+     *   - **`rawAckUncorrelatable(payload)`**, no readable `MSH`, an empty MSH-10, or a
      *     batch/concatenated-message shape. This is the SAME predicate `buildRawAck` enforces
      *     on the wire; it is re-checked here so the downgrade is **observable** (a `'nack'`
      *     event) rather than a silent code change inside the builder.
-     *   - **`MLLP_TRAILING_BYTES`** in the frame's warnings — a mid-payload `VT` made the
+     *   - **`MLLP_TRAILING_BYTES`** in the frame's warnings, a mid-payload `VT` made the
      *     decoder discard accumulated bytes and deliver only the fragment after it. The
      *     clinical message was destroyed in transit, so even a fragment that happens to carry
      *     a readable MSH must not be positively acknowledged. This condition is invisible to
@@ -1976,33 +1974,33 @@ declare class MllpServer extends EventEmitter {
      *     accumulating the delivered frame, so it is frame-scoped: it names *this* payload's own
      *     discard, never a neighbouring frame's trailing junk.
      *
-     * `'discarded-bytes'` takes precedence in the reason when both hold — it is the root cause.
+     * `'discarded-bytes'` takes precedence in the reason when both hold, it is the root cause.
      */
     private _resolveAutoAckPositive;
     /**
      * Run `onMessage` for its side effects only (custom-ACK and manual modes), guarding
      * against a synchronous throw or a rejected promise. In these modes the handler does
      * **not** gate the ACK, so a failure is re-emitted as a PHI-safe `'error'` on the
-     * connection (D-04: a handler error never crashes the server) rather than escaping as
+     * connection (a handler error never crashes the server) rather than escaping as
      * an unhandled rejection. The error text is never placed on the wire.
      */
     private _observeMessage;
     /**
      * The custom-builder path for `autoAck: fn`. Awaits the builder and dispatches its
      * Buffer as the ACK; the caller owns MSA-1. A builder error is re-emitted as `'error'`
-     * on the connection — the server never crashes (D-04).
+     * on the connection, the server never crashes.
      */
     private _sendCustomAck;
     /**
      * Frame an ACK payload and write it to the connection. `Connection.send()` returns
      * `false` under backpressure (socket write buffer full); that drops the ACK and emits
-     * a `MllpConnectionError({ phase: 'send' })` on the connection (D-04) — the peer will
+     * a `MllpConnectionError({ phase: 'send' })` on the connection, the peer will
      * time out waiting and may retry. The server never crashes.
      */
     private _dispatchAck;
 }
 /**
- * Factory function — creates a new `MllpServer` with the supplied options.
+ * Factory function, creates a new `MllpServer` with the supplied options.
  *
  * Prefer `createServer()` over `new MllpServer()` for forward-compatible construction.
  *
@@ -2020,13 +2018,11 @@ declare class MllpServer extends EventEmitter {
  */
 declare function createServer(opts?: ServerOptions): MllpServer;
 /**
- * Starter factory — creates, configures, and starts an `MllpServer` in one call.
+ * Starter factory, creates, configures, and starts an `MllpServer` in one call.
  *
  * Provides the "three lines of code" north-star experience with sensible defaults:
  * `autoAck: 'AA'`, `drainTimeoutMs: 30_000`, `Symbol.asyncDispose` wired.
  *
- * NOTE: Stub at Plan 01 scope — Plan 04 fills in the full implementation.
- *
  * @example
  * ```typescript
  * import { createStarterServer } from '@cosyte/mllp';
@@ -2040,18 +2036,15 @@ declare function createServer(opts?: ServerOptions): MllpServer;
 declare function createStarterServer(opts: StarterServerOptions): Promise<MllpServer>;
 
 /**
- * MLLP Client — `createClient()` factory and `MllpClient` class.
+ * MLLP Client, `createClient()` factory and `MllpClient` class.
  *
  * Provides the client-side MLLP transport: connect to an MLLP server over TCP,
  * encode and send framed messages, decode inbound ACKs, and surface lifecycle
  * events with frozen payloads. Supports `AbortSignal` cancellation on every
  * awaitable and `Symbol.asyncDispose` for `await using` ergonomics.
  *
- * Phase 5 PLAN-01 shipped the lifecycle scaffolding — `connect()`, `close()`,
- * `destroy()`, event re-emission. PLAN-02 added `send()` + `MllpTimeoutError`.
- * The `correlateByControlId` option (MSH-10 → MSA-2 ACK matching) lights up
- * out-of-order ACK handling. Subsequent plans add auto-reconnect (Plan 04),
- * backpressure (Plan 05), and `createStarterClient` + `getStats()` (PLAN-06).
+ * The `correlateByControlId` option (MSH-10 → MSA-2 ACK matching) enables
+ * out-of-order ACK handling.
  *
  * @example
  * ```typescript
@@ -2059,7 +2052,7 @@ declare function createStarterServer(opts: StarterServerOptions): Promise<MllpSe
  *
  * const client = createClient({ host: 'localhost', port: 2575 });
  * await client.connect();
- * // PLAN-02 will add: const ack = await client.send(payloadBuffer);
+ * const ack = await client.send(payloadBuffer);
  * await client.close();
  * ```
  *
@@ -2067,11 +2060,9 @@ declare function createStarterServer(opts: StarterServerOptions): Promise<MllpSe
  */
 
 /**
- * Context passed to a custom `retryStrategy` hook on each reconnect attempt
- * (CLIENT-12, D-15).
+ * Context passed to a custom `retryStrategy` hook on each reconnect attempt.
  *
- * Frozen via `Object.freeze` before invocation — handlers cannot mutate
- * (T-05-04-04 mitigation).
+ * Frozen via `Object.freeze` before invocation, handlers cannot mutate.
  *
  * @example
  * ```typescript
@@ -2093,26 +2084,26 @@ interface RetryContext {
     readonly totalElapsedMs: number;
     /** Ms since the last successful ACK. `Infinity` if no success seen. */
     readonly sinceLastSuccessMs: number;
-    /** CLIENT-18 classification (Composition A — D-16). */
+    /** How the failure that triggered this reconnect attempt was classified. */
     readonly classifiedAs: "transient" | "permanent";
     /**
      * The same `AbortSignal` passed into `connect()`. If no signal was
      * supplied, the module-level `NEVER_ABORTING_SIGNAL` sentinel is provided
-     * so handlers always have a real `AbortSignal` to inspect. (D-18, W-07)
+     * so handlers always have a real `AbortSignal` to inspect.
      */
     readonly signal: AbortSignal;
 }
 /**
- * Custom reconnect-backoff hook (CLIENT-12). Return `null` to halt
- * reconnection (D-17) — the FSM transitions to `CLOSED`.
+ * Custom reconnect-backoff hook. Return `null` to halt
+ * reconnection, the FSM transitions to `CLOSED`.
  */
 type RetryStrategy = (ctx: RetryContext) => number | null;
 /**
- * Combined count + byte-based queue cap. Stricter-of-two wins (D-23).
+ * Combined count + byte-based queue cap. Stricter-of-two wins.
  *
- * - `number` — count cap only (default 64).
- * - `{ bytes }` — byte cap only.
- * - `{ count, bytes }` — both caps; whichever trips first wins.
+ * - `number`, count cap only (default 64).
+ * - `{ bytes }`, byte cap only.
+ * - `{ count, bytes }`, both caps; whichever trips first wins.
  *
  * @example
  * ```typescript
@@ -2129,8 +2120,6 @@ type HighWaterMark = number | {
 /**
  * Options for {@link createClient} and the {@link MllpClient} constructor.
  *
- * Phase 5 plans extend this incrementally — new fields are additive and optional.
- *
  * @example
  * ```typescript
  * const opts: ClientOptions = { host: 'localhost', port: 2575, drainTimeoutMs: 10_000 };
@@ -2146,54 +2135,54 @@ interface ClientOptions {
     /** Drain timeout for {@link MllpClient.close} (default: `30_000` ms). */
     readonly drainTimeoutMs?: number;
     /**
-     * Per-message ACK timeout in milliseconds (CLIENT-04). The clock starts at
-     * the underlying `write()` flush callback, NOT at the `send()` call —
+     * Per-message ACK timeout in milliseconds. The clock starts at
+     * the underlying `write()` flush callback, NOT at the `send()` call,
      * pre-flush queue time is not charged to the peer. Default: `30_000`.
      */
     readonly ackTimeoutMs?: number;
     /**
-     * If `true`, ACKs are matched against outgoing sends by MSH-10 → MSA-2
-     * (CLIENT-03 controlId branch). Default `false` (FIFO mode).
+     * If `true`, ACKs are matched against outgoing sends by MSH-10 → MSA-2.
+     * Default `false` (FIFO mode).
      *
      * Out-of-order ACKs from the peer are supported in this mode. MSH-10 is
      * extracted from the outbound payload before send; MSA-2 is extracted from
      * the inbound ACK payload. An ACK whose MSA-2 matches no pending send
      * (and is not in the late-ACK graveyard) emits a frozen
-     * `MllpFramingError('MLLP_ACK_UNMATCHED_CONTROL_ID')` to the `'error'` event
-     * (CLIENT-15). A late ACK whose MSA-2 matches a graveyard entry emits a
-     * `MLLP_ACK_AFTER_TIMEOUT` warning (CLIENT-16) and is dropped.
+     * `MllpFramingError('MLLP_ACK_UNMATCHED_CONTROL_ID')` to the `'error'` event.
+     * A late ACK whose MSA-2 matches a graveyard entry emits a
+     * `MLLP_ACK_AFTER_TIMEOUT` warning and is dropped.
      *
      * @default false
      */
     readonly correlateByControlId?: boolean;
     /**
-     * Auto-reconnect on transient disconnect (CLIENT-05). Default `false`.
+     * Auto-reconnect on transient disconnect. Default `false`.
      *
      * When `true`, dropped connections caused by transient errors (per
      * {@link isTransientConnectionError}) trigger the FSM cycle
      * `CONNECTED → DISCONNECTED → RECONNECTING → CONNECTING → CONNECTED`
-     * with exponential backoff per D-19 unless overridden by
+     * with exponential backoff unless overridden by
      * {@link ClientOptions.retryStrategy}. Permanent errors halt and
-     * transition directly to `CLOSED` (Composition A — D-16).
+     * transition directly to `CLOSED`.
      */
     readonly autoReconnect?: boolean;
     /**
-     * Custom reconnect-backoff hook (CLIENT-12, D-15). Return `null` to halt
-     * reconnection (D-17). Receives a frozen {@link RetryContext}. Defaults
-     * to the exponential strategy described in D-19.
+     * Custom reconnect-backoff hook. Return `null` to halt
+     * reconnection. Receives a frozen {@link RetryContext}. Defaults
+     * to the exponential strategy.
      */
     readonly retryStrategy?: RetryStrategy;
-    /** First delay (ms) on auto-reconnect; default 100. (CLIENT-05, D-19) */
+    /** First delay (ms) on auto-reconnect; default 100. */
     readonly initialDelayMs?: number;
-    /** Maximum backoff cap (ms); default 30_000. (CLIENT-05, D-19) */
+    /** Maximum backoff cap (ms); default 30_000. */
     readonly maxDelayMs?: number;
-    /** Backoff multiplier; default 2. (CLIENT-05, D-19) */
+    /** Backoff multiplier; default 2. */
     readonly multiplier?: number;
-    /** Jitter fraction, e.g. 0.2 = ±20%; default 0.2. (CLIENT-05, D-19) */
+    /** Jitter fraction, e.g. 0.2 = ±20%; default 0.2. */
     readonly jitter?: number;
     /**
-     * Application-level high-water mark on the in-flight + queued send set
-     * (CLIENT-07, D-23). `number` configures a count cap (default 64);
+     * Application-level high-water mark on the in-flight + queued send set.
+     * `number` configures a count cap (default 64);
      * `{ bytes }` configures a byte cap; `{ count, bytes }` configures
      * both, with the stricter-of-two trigger winning.
      *
@@ -2204,21 +2193,21 @@ interface ClientOptions {
      */
     readonly highWaterMark?: HighWaterMark;
     /**
-     * Behavior when the high-water mark is exceeded (CLIENT-07).
+     * Behavior when the high-water mark is exceeded.
      *
-     * - `'reject'` (default) — `send()` rejects with `MllpBackpressureError`.
-     * - `'wait'` — `send()` awaits the `'drain'` event OR the per-message
-     *   `ackTimeoutMs` OR `signal` abort, whichever fires first (CLIENT-11).
+     * - `'reject'` (default), `send()` rejects with `MllpBackpressureError`.
+     * - `'wait'`, `send()` awaits the `'drain'` event OR the per-message
+     *   `ackTimeoutMs` OR `signal` abort, whichever fires first.
      *
      * @default 'reject'
      */
     readonly onBackpressure?: "reject" | "wait";
     /**
-     * Strict serialization send → await-ACK → send (CLIENT-19, D-06).
+     * Strict serialization send → await-ACK → send.
      *
-     * - `true` (default) — concurrent in-flight sends up to
+     * - `true` (default), concurrent in-flight sends up to
      *   {@link ClientOptions.highWaterMark}.
-     * - `false` — collapses the in-flight set to ≤1 (the unified Correlator's
+     * - `false`, collapses the in-flight set to ≤1 (the unified Correlator's
      *   `maxInFlight=1`); the next `send()` waits for the prior ACK before
      *   reaching the wire.
      *
@@ -2229,24 +2218,24 @@ interface ClientOptions {
      * TCP keepalive interval (ms). Sets `socket.setKeepAlive(true, ms)` on
      * the underlying `net.Socket` BEFORE wrapping in `NetTransport`. OS-level
      * half-open detection (network partitions, NAT-table eviction). Independent
-     * of {@link ClientOptions.deadPeerTimeoutMs} (CLIENT-08, D-11/A3).
+     * of {@link ClientOptions.deadPeerTimeoutMs}.
      *
      * @default undefined (off)
      */
     readonly keepaliveIntervalMs?: number;
     /**
-     * Application-idle timeout (ms) keyed on last inbound bytes / ACK / warning
-     * (CLIENT-08, D-11). On trip, calls `connection.destroy(new Error('dead
+     * Application-idle timeout (ms) keyed on last inbound bytes / ACK / warning.
+     * On trip, calls `connection.destroy(new Error('dead
      * peer timeout'))` which surfaces as `MllpConnectionError({ phase: 'receive' })`.
-     * Trip honors {@link ClientOptions.autoReconnect} (D-13). Independent of
-     * {@link ClientOptions.keepaliveIntervalMs} (D-11/A3).
+     * Trip honors {@link ClientOptions.autoReconnect}. Independent of
+     * {@link ClientOptions.keepaliveIntervalMs}.
      *
      * @default undefined (off)
      */
     readonly deadPeerTimeoutMs?: number;
     /**
-     * Enable TLS (MLLPS) for this connection (Phase 8). `true` enables TLS with
-     * all defaults — including certificate verification **on**. Pass a
+     * Enable TLS (MLLPS) for this connection. `true` enables TLS with
+     * all defaults, including certificate verification **on**. Pass a
      * {@link TlsOptions} object to customize (`ca`/`cert`/`key`, minimum
      * version, ciphers, `allowUnverified`, …).
      *
@@ -2257,16 +2246,16 @@ interface ClientOptions {
     readonly tls?: TlsOptions | true;
 }
 /**
- * Observability snapshot returned by {@link MllpClient.getStats} (OBS-01, D-26).
+ * Observability snapshot returned by {@link MllpClient.getStats}.
  *
- * All fields are JSON-serializable (OBS-04) — no Buffers, no class instances,
+ * All fields are JSON-serializable, no Buffers, no class instances,
  * no Maps, no circular references. `lastConnectedAt` and `lastAckAt` are
- * **epoch milliseconds** (numbers), NOT `Date` instances — log-pipeline
- * friendly per D-26.
+ * **epoch milliseconds** (numbers), NOT `Date` instances, log-pipeline
+ * friendly.
  *
  * `warningsByCode` keys are constrained to the public {@link WarningCode}
- * union — adding/removing a code is a breaking change (CLAUDE.md
- * stable-codes guardrail enforced at the type boundary, B-05).
+ * union, adding/removing a code is a breaking change (CLAUDE.md
+ * stable-codes guardrail enforced at the type boundary).
  *
  * @example
  * ```typescript
@@ -2276,7 +2265,7 @@ interface ClientOptions {
  * ```
  */
 interface ClientStats {
-    /** Current FSM state — mirrors `client.state`. */
+    /** Current FSM state, mirrors `client.state`. */
     readonly state: ConnectionState;
     /** Live Connection's id, or `null` before the first connect (or post-CLOSED). */
     readonly connectionId: string | null;
@@ -2284,11 +2273,11 @@ interface ClientStats {
     readonly queueDepth: number;
     /** Sum of `frame.length` across live correlator entries. */
     readonly queueBytes: number;
-    /** Entries with `sentAt !== null` — actually written to the wire / awaiting ACK. */
+    /** Entries with `sentAt !== null`, actually written to the wire / awaiting ACK. */
     readonly inFlight: number;
     /**
      * Aggregated warning counts. Keys are constrained to the public
-     * {@link WarningCode} union (B-05). Connection-level warnings + Correlator
+     * {@link WarningCode} union. Connection-level warnings + Correlator
      * `MLLP_ACK_*` warnings are merged.
      */
     readonly warningsByCode: Partial<Record<WarningCode, number>>;
@@ -2302,31 +2291,31 @@ interface ClientStats {
     readonly ackedTotal: number;
     /** Total ACK timeouts since construction. */
     readonly timedOutTotal: number;
-    /** Total reconnect attempts since construction (W-02). */
+    /** Total reconnect attempts since construction. */
     readonly reconnectAttempts: number;
     /** Epoch ms of the last `CONNECTED` transition. `null` until first connect. */
     readonly lastConnectedAt: number | null;
     /** Epoch ms of the most recent successful ACK. `null` until first ACK. */
     readonly lastAckAt: number | null;
-    /** Whether this client is configured for TLS (Phase 8). Mirrors `ClientOptions.tls` being set. */
+    /** Whether this client is configured for TLS. Mirrors `ClientOptions.tls` being set. */
     readonly tls: boolean;
 }
 /**
- * MLLP client — composes a single Phase 3 {@link Connection} over a {@link NetTransport}
+ * MLLP client, composes a single {@link Connection} over a {@link NetTransport}
  * (production) or any other `Transport` (testing via {@link InMemoryTransport}).
  *
- * Public events — every payload `Object.freeze`'d before emission (D-25):
- * - `'stateChange'` — `{ from, to, reason? }` from the underlying Connection FSM
- * - `'connect'` — `{ connectionId }` once the FSM enters `CONNECTED`
- * - `'disconnect'` — `{ connectionId }` once the FSM enters `DISCONNECTED`
- * - `'reconnecting'` — `{ connectionId, attempt?, delayMs? }` (Plan 04 populates)
- * - `'close'` — `{ connectionId }` once the FSM enters terminal `CLOSED`
- * - `'message'` — `{ payload, connectionId, byteOffset, warnings }` for every inbound frame
- * - `'warning'` — `MllpWarning` enriched with `connectionId` from the Connection layer
- * - `'securityWarning'` — `SecurityWarning` (Phase 8). Emitted on every successful
+ * Public events, every payload `Object.freeze`'d before emission:
+ * - `'stateChange'`, `{ from, to, reason? }` from the underlying Connection FSM
+ * - `'connect'`, `{ connectionId }` once the FSM enters `CONNECTED`
+ * - `'disconnect'`, `{ connectionId }` once the FSM enters `DISCONNECTED`
+ * - `'reconnecting'`, `{ connectionId, attempt?, delayMs? }`
+ * - `'close'`, `{ connectionId }` once the FSM enters terminal `CLOSED`
+ * - `'message'`, `{ payload, connectionId, byteOffset, warnings }` for every inbound frame
+ * - `'warning'`, `MllpWarning` enriched with `connectionId` from the Connection layer
+ * - `'securityWarning'`, `SecurityWarning`. Emitted on every successful
  *   `secureConnect` (initial + every reconnect) when `tls.allowUnverified` is `true`
- *   — code `MLLP_TLS_VERIFY_DISABLED`. Also mirrored to `process.emitWarning`.
- * - `'error'` — re-emitted from Connection. Guarded by `listenerCount('error') > 0` so
+ *   with code `MLLP_TLS_VERIFY_DISABLED`. Also mirrored to `process.emitWarning`.
+ * - `'error'`, re-emitted from Connection. Guarded by `listenerCount('error') > 0` so
  *   absence of a listener does NOT crash the process (server precedent).
  *
  * @example
@@ -2335,7 +2324,7 @@ interface ClientStats {
  * client.on('stateChange', ({ from, to }) => logger.info({ from, to }));
  * client.on('message', ({ payload }) => logger.info({ bytes: payload.length }));
  * await client.connect();
- * // PLAN-02 will add: const ack = await client.send(payloadBuffer);
+ * const ack = await client.send(payloadBuffer);
  * await client.close();
  * ```
  */
@@ -2348,15 +2337,15 @@ declare class MllpClient extends EventEmitter {
      * is attached, `state` mirrors `_connection.state`.
      */
     private _state;
-    /** Per-message ACK timeout in ms (CLIENT-04). Resolved at construction. */
+    /** Per-message ACK timeout in ms. Resolved at construction. */
     private readonly _ackTimeoutMs;
-    /** controlId-mode flag (CLIENT-03 branch). `false` → FIFO. */
+    /** controlId-mode flag. `false` → FIFO. */
     private readonly _correlateByControlId;
-    /** Unified ACK correlator (D-03/A1). Built during `_attachConnection`. */
+    /** Unified ACK correlator. Built during `_attachConnection`. */
     private _correlator;
     /**
      * Periodic ACK-timeout sweep timer. Drives `_correlator.expireDue()` because
-     * the Correlator is timer-free per D-03. Cleared on close/destroy.
+     * the Correlator is timer-free. Cleared on close/destroy.
      */
     private _ackSweepTimer;
     private readonly _autoReconnect;
@@ -2368,12 +2357,12 @@ declare class MllpClient extends EventEmitter {
     /** 0-indexed attempt counter for the current reconnect cycle. */
     private _attempt;
     /**
-     * W-02 — total reconnect attempts since construction. Read by PLAN-06 for
+     * Total reconnect attempts since construction, surfaced as
      * `getStats().reconnectAttempts`. Incremented at the entry of every
      * `_handleDisconnect` invocation that proceeds to schedule a backoff.
      */
     private _reconnectAttempts;
-    /** Epoch ms of the last successful ACK. Drives W-01 backoff-reset. */
+    /** Epoch ms of the last successful ACK. Drives backoff-reset. */
     private _lastSuccessAt;
     /** Epoch ms when the current reconnect cycle began. `null` outside a cycle. */
     private _reconnectCycleStartedAt;
@@ -2389,12 +2378,12 @@ declare class MllpClient extends EventEmitter {
     private readonly _onBackpressure;
     /** Pipeline flag; default `true` (parallel up to highWaterMark). */
     private readonly _pipeline;
-    /** Dead-peer idle timer (Plan 05 — D-11). `null` when not armed. */
+    /** Dead-peer idle timer. `null` when not armed. */
     private _deadPeerTimer;
     /** True once the self-'ack' listener that resets the dead-peer timer
      * has been attached. Guards against duplicate listeners on reconnect. */
     private _ackResetWired;
-    /** Most recently bound `connect()` signal. Reread on every RetryContext build (W-07). */
+    /** Most recently bound `connect()` signal. Reread on every RetryContext build. */
     private _connectSignal;
     /** Set when close()/destroy()/abort fires; reconnect handler short-circuits. */
     private _userClosed;
@@ -2403,7 +2392,7 @@ declare class MllpClient extends EventEmitter {
     /** Listener-removal handle for the abort listener bound in connect(). */
     private _abortListener;
     /**
-     * Test-only seam — when set, `_beginReconnectAttempt` builds the new
+     * Test-only seam, when set, `_beginReconnectAttempt` builds the new
      * Connection through this factory instead of opening a real net.Socket.
      *
      * @internal
@@ -2422,7 +2411,7 @@ declare class MllpClient extends EventEmitter {
     /**
      * Aggregated Correlator-emitted warning counts (MLLP_ACK_*). Connection-level
      * warnings are read directly from `_connection.getStats().warningsByCode`
-     * at observation time and merged into the snapshot (D-26).
+     * at observation time and merged into the snapshot.
      */
     private _aggregatedWarningsByCode;
     /**
@@ -2439,9 +2428,9 @@ declare class MllpClient extends EventEmitter {
      */
     get state(): ConnectionState;
     /**
-     * Open a TCP (or TLS — Phase 8) connection to the configured `host:port`
-     * and attach a Phase 3 {@link Connection} to it. Resolves once the FSM
-     * enters `CONNECTED` — for TLS, on `'secureConnect'` (handshake complete,
+     * Open a TCP (or TLS) connection to the configured `host:port`
+     * and attach a {@link Connection} to it. Resolves once the FSM
+     * enters `CONNECTED`, for TLS, on `'secureConnect'` (handshake complete,
      * including certificate verification when it is on).
      *
      * Rejects with:
@@ -2461,11 +2450,11 @@ declare class MllpClient extends EventEmitter {
      *
      * **TLS 1.3 + mutual TLS caveat (RFC 8446 §4.4.2):** `connect()` resolving
      * does NOT guarantee that a `clientAuth: 'MUST'` server accepted your
-     * client certificate. Under TLS 1.3 the client's handshake — and its
-     * `'secureConnect'` — can complete before the server finishes validating
+     * client certificate. Under TLS 1.3 the client's handshake, and its
+     * `'secureConnect'`, can complete before the server finishes validating
      * the certificate; a rejection then surfaces moments later as a typed
      * post-connect error (`'error'` event with an `ERR_SSL_*`/alert cause,
-     * classified **permanent** — no auto-reconnect loop). ACK correlation via
+     * classified **permanent**, no auto-reconnect loop). ACK correlation via
      * {@link MllpClient.send} remains the delivery guarantee: no send resolves
      * without its ACK, so a rejected session can never silently "deliver".
      *
@@ -2483,8 +2472,8 @@ declare class MllpClient extends EventEmitter {
      * Build the raw socket + `Transport` pair for a connect / reconnect attempt.
      *
      * Plaintext (`ClientOptions.tls` unset): a `net.Socket` wrapped in
-     * `NetTransport`. TLS (Phase 8): a `tls.TLSSocket` wrapped in
-     * `TlsTransport` — verification defaults **on**
+     * `NetTransport`. TLS: a `tls.TLSSocket` wrapped in
+     * `TlsTransport`, verification defaults **on**
      * (`rejectUnauthorized: !allowUnverified`), floor `minVersion: 'TLSv1.2'`
      * (the IHE ATNA ITI-19 BCP195 floor), `servername` defaulting to
      * `ClientOptions.host`.
@@ -2492,14 +2481,14 @@ declare class MllpClient extends EventEmitter {
     private _createSocketAndTransport;
     /**
      * Wrap a connect-phase socket error as `MllpConnectionError`, classifying
-     * TLS failures (Phase 8) into the additive `connectionCause`:
+     * TLS failures into the additive `connectionCause`:
      *
-     * - `'tls-verify'` — certificate-verification failures
+     * - `'tls-verify'`, certificate-verification failures
      *   ({@link isTlsVerificationErrorCode}).
-     * - `'tls-handshake'` — TLS-**protocol**-shaped failures only
+     * - `'tls-handshake'`, TLS-**protocol**-shaped failures only
      *   ({@link isTlsProtocolError}): `ERR_SSL_*`, `EPROTO`, OpenSSL
      *   alert-bearing errors.
-     * - **No `connectionCause`** — pure TCP-level failures (`ECONNREFUSED`,
+     * - **No `connectionCause`**, pure TCP-level failures (`ECONNREFUSED`,
      *   `ETIMEDOUT`, …) even on a TLS-configured connection; these carry the
      *   same shape as plaintext connect failures.
      */
@@ -2507,7 +2496,7 @@ declare class MllpClient extends EventEmitter {
     /**
      * Emit a client event, containing a throwing subscriber.
      *
-     * Every event this client emits is reached from a callback we do not own — a socket's
+     * Every event this client emits is reached from a callback we do not own, a socket's
      * `'connect'`/`'secureConnect'`/`'data'`/`'error'` listener, or a backoff timer. A throwing
      * subscriber would unwind into it and kill the process, and on several paths it would also skip
      * the work queued after the emit (the `resolve()` of `connect()`, the backoff scheduling).
@@ -2516,8 +2505,8 @@ declare class MllpClient extends EventEmitter {
      */
     private _emitContained;
     /**
-     * Emit the per-connection insecure-TLS warning (Phase 8) when
-     * `tls.allowUnverified === true` — fires on EVERY successful
+     * Emit the per-connection insecure-TLS warning when
+     * `tls.allowUnverified === true`, fires on EVERY successful
      * `secureConnect`, initial connect and every reconnect. Emits both a frozen
      * `'securityWarning'` event and `process.emitWarning`. No-op for plaintext
      * connections or when verification is on.
@@ -2525,11 +2514,11 @@ declare class MllpClient extends EventEmitter {
     private _emitInsecureWarningIfNeeded;
     /**
      * Wire a Connection's events through to this MllpClient. Every re-emitted
-     * payload is `Object.freeze`'d before emission (D-25), even though the
-     * Connection layer already freezes — defense-in-depth, harmless on
+     * payload is `Object.freeze`'d before emission, even though the
+     * Connection layer already freezes, defense-in-depth, harmless on
      * already-frozen objects.
      *
-     * Builds the unified `Correlator` (D-03/A1) bound to this Connection and
+     * Builds the unified `Correlator` bound to this Connection and
      * arms the periodic ACK-timeout sweep. The Correlator is teardown-aware:
      * `close()` / `destroy()` clear the sweep timer and reject pending sends.
      *
@@ -2537,37 +2526,36 @@ declare class MllpClient extends EventEmitter {
      */
     private _attachConnection;
     /**
-     * Arm (or re-arm) the dead-peer idle timer (Plan 05 — CLIENT-08, D-11).
+     * Arm (or re-arm) the dead-peer idle timer.
      * No-op when `deadPeerTimeoutMs` is unset.
      */
     private _armDeadPeerTimer;
     /**
-     * Clear the dead-peer idle timer (Plan 05 — D-14 timer cleanup on
-     * every transition out of CONNECTED).
+     * Clear the dead-peer idle timer on every transition out of CONNECTED.
      */
     private _clearDeadPeerTimer;
     /**
-     * Disconnect handler — Plan 04 reconnect FSM core.
+     * Disconnect handler, reconnect FSM core.
      *
      * Implements:
-     * - CLIENT-17 hybrid in-flight handling (D-08): controlId mode preserves
+     * - Hybrid in-flight handling: controlId mode preserves
      *   pending sends for resend; FIFO mode rejects in-flight with
      *   `connectionCause: 'in-flight-orphan'` and queued with `'fifo-unsafe'`.
-     * - CLIENT-18 classifier-first (Composition A — D-16): permanent errors
+     * - Classifier-first: permanent errors
      *   transition straight to CLOSED without invoking `retryStrategy`.
-     * - W-01 backoff-reset on recent success: first disconnect after a
+     * - Backoff-reset on recent success: first disconnect after a
      *   successful ACK on the prior session resets `_attempt` to 0.
-     * - W-02 `_reconnectAttempts` counter increment.
-     * - D-15 frozen RetryContext + D-17 null-return halts.
-     * - D-19 default exponential strategy.
+     * - `_reconnectAttempts` counter increment.
+     * - Frozen RetryContext; a `null` return from the strategy halts reconnection.
+     * - Default exponential strategy.
      *
-     * Invoked from the SINGLE `_onStateChange` hook — no parallel listener
-     * (B-04). Idempotent across same-cycle re-entry: cycle-start flag
+     * Invoked from the SINGLE `_onStateChange` hook, no parallel listener.
+     * Idempotent across same-cycle re-entry: cycle-start flag
      * coordinates first-disconnect vs subsequent-within-cycle behavior.
      */
     private _handleDisconnect;
     /**
-     * Default retry strategy (D-19): `min(maxDelay, initialDelay * multiplier^attempt)`
+     * Default retry strategy: `min(maxDelay, initialDelay * multiplier^attempt)`
      * with ±jitter applied.
      */
     private _defaultRetryStrategy;
@@ -2594,7 +2582,7 @@ declare class MllpClient extends EventEmitter {
      */
     private _afterReconnectArmed;
     /**
-     * Test seam — install a factory that produces the next reconnect Connection.
+     * Test seam, install a factory that produces the next reconnect Connection.
      *
      * @internal
      */
@@ -2603,7 +2591,7 @@ declare class MllpClient extends EventEmitter {
         arm: () => void;
     }): void;
     /**
-     * Test seam — capture or rebind the connect-signal mid-flight (W-07).
+     * Test seam, capture or rebind the connect-signal mid-flight.
      *
      * @internal
      */
@@ -2613,57 +2601,50 @@ declare class MllpClient extends EventEmitter {
      *
      * - FIFO mode: passes `null` controlId so `matchAck` returns the head of
      *   the live store.
-     * - controlId mode: extracts MSA-2 at the `HOOK_EXTENSION_POINT: ack-payload`
-     *   anchor and passes it to `matchAck` for keyed lookup.
+     * - controlId mode: extracts MSA-2 and passes it to `matchAck` for keyed
+     *   lookup.
      *
      * Called from the SINGLE `'message'` listener registered in `_attachConnection`.
-     * No parallel listener is registered — downstream plans extend at the named
-     * anchor (B-04).
+     * No parallel listener is registered.
      */
     private _onAckPayload;
     /**
      * Single source-of-truth for a successfully matched ACK (live-store hit).
      *
-     * PLAN-02: emit frozen 'ack' event, call matched.resolve().
-     * Plan 04 extends at HOOK_EXTENSION_POINT: ack-matched to update _lastSuccessAt.
-     * PLAN-06 extends at HOOK_EXTENSION_POINT: ack-matched to bump _ackedTotal and
-     *   set _lastAckAt.
+     * Emits the frozen 'ack' event and resolves the pending send. Updates
+     * `_lastSuccessAt`, `_ackedTotal` and `_lastAckAt`.
      *
      * Called from _onAckPayload when matchAck() returns a non-null PendingAck.
      */
     private _onAckMatched;
     /**
      * Emit a frozen `'drain'` event when the queue depth and bytes fall below
-     * both configured caps (Plan 05 — D-24). Called from `_onAckMatched`
+     * both configured caps. Called from `_onAckMatched`
      * (every successful ACK) and from the Correlator's `onTimeout` callback
-     * (every expired send) — both code paths free a live-store slot.
+     * (every expired send), both code paths free a live-store slot.
      */
     private _maybeEmitDrain;
     /**
      * Single source-of-truth for Connection FSM transitions.
      *
-     * PLAN-02: re-emit frozen 'stateChange' (was inline in PLAN-01; centralized
-     * here so Plan 04 / Plan 05 can extend at named anchors).
-     * Plan 04 extends at HOOK_EXTENSION_POINT: state-change to detect
-     *   CONNECTED → DISCONNECTED|RECONNECTING and trigger _handleDisconnect.
-     * Plan 05 extends at HOOK_EXTENSION_POINT: state-change to clear/arm
-     *   dead-peer timer on transitions out of / into CONNECTED.
+     * Re-emits a frozen 'stateChange' event, detects
+     * CONNECTED → DISCONNECTED|RECONNECTING to trigger `_handleDisconnect`, and
+     * clears or arms the dead-peer timer on transitions out of / into CONNECTED.
      *
      * Called from the SINGLE 'stateChange' listener registered in _attachConnection.
      */
     private _onStateChange;
     /**
-     * Send an MLLP-framed payload and await the inbound ACK (CLIENT-02).
+     * Send an MLLP-framed payload and await the inbound ACK.
      *
      * Resolves with the ACK Buffer (framing stripped). Rejects with:
-     * - `DOMException('Aborted', 'AbortError')` if `signal` aborts before ACK
-     *   (CLIENT-11 send branch).
-     * - `MllpTimeoutError` if no ACK arrives within `ackTimeoutMs` (ERR-02).
+     * - `DOMException('Aborted', 'AbortError')` if `signal` aborts before the ACK.
+     * - `MllpTimeoutError` if no ACK arrives within `ackTimeoutMs`.
      *   The clock starts at the underlying `write()` flush callback, NOT at
-     *   the `send()` call (CLIENT-04, D-19).
+     *   the `send()` call.
      * - `MllpConnectionError({ phase: 'send' })` if the client is not connected.
      *
-     * Emits a frozen `'ack'` event on every successful match (D-25 + Specifics).
+     * Emits a frozen `'ack'` event on every successful match.
      *
      * @example
      * ```typescript
@@ -2672,19 +2653,19 @@ declare class MllpClient extends EventEmitter {
      * ```
      *
      * @param payload Raw bytes; MLLP framing is added internally via `encodeFrame`.
-     * @param opts.signal AbortSignal — aborting cancels the ACK wait (CLIENT-11).
+     * @param opts.signal AbortSignal, aborting cancels the ACK wait.
      */
     send(payload: Buffer, opts?: {
         signal?: AbortSignal;
         ackTimeoutMs?: number;
     }): Promise<Buffer>;
     /**
-     * 'wait'-mode backpressure handler (Plan 05 — CLIENT-07/CLIENT-11).
+     * 'wait'-mode backpressure handler.
      *
      * Awaits one of three terminating signals, in order:
      * - `'drain'` event → re-enter `send()` (the gate will now pass).
      * - `ackTimeoutMs` elapses → reject with `MllpTimeoutError`.
-     * - Caller's `signal` aborts → reject with `AbortError` (B-06). Cleanup
+     * - Caller's `signal` aborts → reject with `AbortError`. Cleanup
      *   removes the drain listener AND the abort listener AND clears the
      *   timer to prevent leaks.
      */
@@ -2695,7 +2676,7 @@ declare class MllpClient extends EventEmitter {
      */
     private _teardownCorrelator;
     /**
-     * **Test seam** — attach an externally-built {@link Connection} directly,
+     * **Test seam**, attach an externally-built {@link Connection} directly,
      * bypassing the `net.createConnection` + `NetTransport` path. Used by
      * lifecycle tests driving `InMemoryTransport.pair()` for determinism.
      *
@@ -2722,7 +2703,7 @@ declare class MllpClient extends EventEmitter {
         signal?: AbortSignal;
     }): Promise<void>;
     /**
-     * Abruptly destroy the client — force-transitions the underlying Connection
+     * Abruptly destroy the client, force-transitions the underlying Connection
      * to `CLOSED` immediately. No-op if no Connection is attached. Idempotent.
      *
      * @example
@@ -2732,9 +2713,9 @@ declare class MllpClient extends EventEmitter {
      */
     destroy(reason?: Error): void;
     /**
-     * Returns a JSON-serializable observability snapshot (OBS-01, D-26).
+     * Returns a JSON-serializable observability snapshot.
      *
-     * All fields are plain values — no Buffers, no class instances, no Maps,
+     * All fields are plain values, no Buffers, no class instances, no Maps,
      * no circular refs. Safe to `JSON.stringify` directly.
      *
      * `inFlight` is the count of correlator entries with `sentAt !== null`
@@ -2749,7 +2730,7 @@ declare class MllpClient extends EventEmitter {
      */
     getStats(): ClientStats;
     /**
-     * Async disposal — delegates to {@link MllpClient.close} for `await using` support.
+     * Async disposal, delegates to {@link MllpClient.close} for `await using` support.
      *
      * @example
      * ```typescript
@@ -2769,15 +2750,15 @@ declare class MllpClient extends EventEmitter {
  *
  * const client = createClient({ host: 'localhost', port: 2575 });
  * await client.connect();
- * // PLAN-02 will add: const ack = await client.send(payloadBuffer);
+ * const ack = await client.send(payloadBuffer);
  * await client.close();
  * ```
  */
 declare function createClient(opts: ClientOptions): MllpClient;
 /**
- * Options for {@link createStarterClient} (PLAN-06, CLIENT-10).
+ * Options for {@link createStarterClient}.
  *
- * The starter applies opinionated D-22 defaults on top of `ClientOptions`,
+ * The starter applies opinionated defaults on top of `ClientOptions`,
  * so every override here is optional except `host` + `port`. The
  * starter-specific addition is `handleSignals` (mirrors `createStarterServer`).
  *
@@ -2814,41 +2795,40 @@ interface StarterClientOptions {
     readonly onBackpressure?: "reject" | "wait";
     /** Override default `true` (auto-reconnect on transient errors). */
     readonly autoReconnect?: boolean;
-    /** Custom reconnect-backoff hook (CLIENT-12). */
+    /** Custom reconnect-backoff hook. */
     readonly retryStrategy?: RetryStrategy;
     /** Drain timeout for `close()` (default `30_000`). */
     readonly drainTimeoutMs?: number;
     /** FrameReader options (passthrough). */
     readonly framing?: ClientOptions["framing"];
-    /** TCP keepalive interval ms (CLIENT-08). */
+    /** TCP keepalive interval ms. */
     readonly keepaliveIntervalMs?: number;
-    /** Application-idle dead-peer timeout ms (CLIENT-08). */
+    /** Application-idle dead-peer timeout ms. */
     readonly deadPeerTimeoutMs?: number;
-    /** Enable TLS (MLLPS) for this connection (Phase 8). Passthrough to `ClientOptions.tls`. */
+    /** Enable TLS (MLLPS) for this connection. Passthrough to `ClientOptions.tls`. */
     readonly tls?: TlsOptions | true;
     /**
      * Register process SIGTERM/SIGINT handlers that close the client. Default
-     * `false` (D-22). When `true`, SIGTERM/SIGINT both call `client.close()`
-     * and exit the process. Handlers self-deregister on `'close'` (T-05-06-01).
+     * `false`. When `true`, SIGTERM/SIGINT both call `client.close()`
+     * and exit the process. Handlers self-deregister on `'close'`.
      */
     readonly handleSignals?: boolean;
 }
 /**
- * Three-line MLLP client with batteries-included defaults (PLAN-06,
- * CLIENT-10, D-22). The returned client is already CONNECTED — `connect()`
- * has been awaited.
+ * Three-line MLLP client with batteries-included defaults. The returned
+ * client is already CONNECTED, `connect()` has been awaited.
  *
- * D-22 defaults:
+ * Defaults:
  * - `autoReconnect: true`
  * - `ackTimeoutMs: 30_000`
- * - `correlateByControlId: false` (FIFO mode — simplest mental model)
+ * - `correlateByControlId: false` (FIFO mode, simplest mental model)
  * - `pipeline: true`
  * - `highWaterMark: 64`
  * - `onBackpressure: 'reject'`
  * - `handleSignals: false` (opt-in)
  *
  * The factory is **async**, so the literal three-line north-star snippet
- * has an explicit `await` BEFORE `createStarterClient(...)` — without it,
+ * has an explicit `await` BEFORE `createStarterClient(...)`, without it,
  * the `using` declaration would receive a `Promise`, not an `MllpClient`,
  * and `Symbol.asyncDispose` would not run at scope exit.
  *
@@ -2865,9 +2845,9 @@ declare function createStarterClient(opts: StarterClientOptions): Promise<MllpCl
  * MLLP Client typed errors and classifiers.
  *
  * Exports:
- * - `MllpTimeoutError` (PLAN-02) — ACK timeout (ERR-02)
- * - `MllpBackpressureError` — high-water mark exceeded (ERR-04, plan 05)
- * - `isTransientConnectionError` (PLAN-04) — transient/permanent classifier (CLIENT-18)
+ * - `MllpTimeoutError`, ACK timeout
+ * - `MllpBackpressureError`, high-water mark exceeded
+ * - `isTransientConnectionError`, transient/permanent classifier
  *
  * Re-exported from `src/client/index.ts` and `src/index.ts`.
  *
@@ -2875,11 +2855,10 @@ declare function createStarterClient(opts: StarterClientOptions): Promise<MllpCl
  */
 /**
  * Thrown (or rejects the `send()` promise) when an ACK does not arrive within
- * the configured `ackTimeoutMs` (ERR-02).
+ * the configured `ackTimeoutMs`.
  *
  * The timeout clock starts at the underlying `write()` flush callback, NOT
- * at the `send()` call — pre-flush queue time is not charged to the peer
- * (CLIENT-04).
+ * at the `send()` call, pre-flush queue time is not charged to the peer.
  *
  * @example
  * ```typescript
@@ -2914,10 +2893,10 @@ declare class MllpTimeoutError extends Error {
 }
 /**
  * Set of Node/OpenSSL error codes that indicate a **certificate-verification**
- * failure (as opposed to some other TLS handshake failure) — untrusted chain,
+ * failure (as opposed to some other TLS handshake failure), untrusted chain,
  * expired/not-yet-valid certificate, hostname mismatch, revocation, etc.
  *
- * Used by `MllpClient` (Phase 8) to classify a TLS connect failure's
+ * Used by `MllpClient` to classify a TLS connect failure's
  * `connectionCause` as `'tls-verify'` (this set) vs `'tls-handshake'`
  * (everything else observed before `'secureConnect'`). Exported so callers
  * can apply the same classification to their own error handling.
@@ -2932,8 +2911,8 @@ declare class MllpTimeoutError extends Error {
  */
 declare function isTlsVerificationErrorCode(code: string): boolean;
 /**
- * Detects **TLS-protocol-shaped** errors — failures of the TLS protocol
- * itself, as opposed to plain TCP-level network failures (Phase 8).
+ * Detects **TLS-protocol-shaped** errors, failures of the TLS protocol
+ * itself, as opposed to plain TCP-level network failures.
  *
  * Apply this only to errors raised on a **TLS** connection; `MllpClient`
  * does exactly that (the predicate is consulted only when `ClientOptions.tls`
@@ -2941,12 +2920,12 @@ declare function isTlsVerificationErrorCode(code: string): boolean;
  *
  * **TLS-protocol-shaped (`true`):**
  * - `code` starting `ERR_SSL_` (Node's TLS alert codes, e.g.
- *   `ERR_SSL_TLSV13_ALERT_CERTIFICATE_REQUIRED` — a `clientAuth: 'MUST'`
+ *   `ERR_SSL_TLSV13_ALERT_CERTIFICATE_REQUIRED`, a `clientAuth: 'MUST'`
  *   server rejecting the client's certificate).
- * - `code === 'EPROTO'` — on a TLS connection this is OpenSSL failing the
+ * - `code === 'EPROTO'`, on a TLS connection this is OpenSSL failing the
  *   handshake (protocol version mismatch, no shared cipher, a TLS ≤1.2
  *   mTLS rejection).
- * - `message` containing `ssl` or `alert` (`/\bssl\b|\balert\b/i` — "SSL
+ * - `message` containing `ssl` or `alert` (`/\bssl\b|\balert\b/i`, "SSL
  *   routines", "tlsv13 alert certificate required", …). This message check
  *   is a **heuristic backstop** over the code-based checks above, not a
  *   precise boundary: it exists to catch OpenSSL errors that surface without
@@ -2954,19 +2933,19 @@ declare function isTlsVerificationErrorCode(code: string): boolean;
  *   TLS is configured. An arbitrary non-TLS error whose message happens to
  *   contain those words would also match.
  *
- * **NOT TLS-protocol-shaped (`false`) — plain network failures, which stay
+ * **NOT TLS-protocol-shaped (`false`), plain network failures, which stay
  * transient for the reconnect classifier:** `ECONNREFUSED`, `ETIMEDOUT`,
  * `EHOSTUNREACH`, `ENETUNREACH`, `EPIPE`, and a plain `ECONNRESET` carrying
- * no TLS alert context — a network blip during (or after) a handshake
+ * no TLS alert context, a network blip during (or after) a handshake
  * should still auto-heal.
  *
- * Certificate-**verification** failures are a separate class — see
+ * Certificate-**verification** failures are a separate class, see
  * {@link isTlsVerificationErrorCode}; `MllpClient` checks that first and
  * labels those `connectionCause: 'tls-verify'`.
  *
  * Why this matters: under TLS 1.3 (RFC 8446 §4.4.2) a `clientAuth: 'MUST'`
  * server can reject the client's certificate AFTER the client's own
- * `'secureConnect'` — the rejection then surfaces as a post-connect socket
+ * `'secureConnect'`, the rejection then surfaces as a post-connect socket
  * error. A misconfigured mTLS client must never auto-reconnect-loop against
  * a server that will always reject it, so `MllpClient` classifies
  * TLS-protocol-shaped errors as **permanent**.
@@ -2976,7 +2955,7 @@ declare function isTlsVerificationErrorCode(code: string): boolean;
  * import { isTlsProtocolError, MllpConnectionError } from '@cosyte/mllp';
  * client.on('error', ({ error }) => {
  *   if (error instanceof MllpConnectionError && isTlsProtocolError(error.cause)) {
- *     // TLS protocol failure — a configuration problem, not a network blip.
+ *     // TLS protocol failure, a configuration problem, not a network blip.
  *   }
  * });
  * ```
@@ -2986,32 +2965,32 @@ declare function isTlsProtocolError(err: unknown): boolean;
  * Classifies a connection error as transient (eligible for auto-reconnect)
  * or permanent (halts auto-reconnect, transitions to CLOSED).
  *
- * Used internally by `MllpClient` BEFORE invoking `retryStrategy` (Composition A
- * — see `RetryContext.classifiedAs`). Re-exported so callers can implement
+ * Used internally by `MllpClient` BEFORE invoking `retryStrategy`
+ * (see `RetryContext.classifiedAs`). Re-exported so callers can implement
  * their own retry policies.
  *
- * Classification table (CLIENT-18, D-16):
+ * Classification table:
  * - `ENOTFOUND`, `EACCES` → **permanent** (`false`)
  * - `ECONNREFUSED`, `ECONNRESET`, `ETIMEDOUT`, `EHOSTUNREACH`,
  *   `ENETUNREACH`, `EPIPE` → **transient** (`true`)
  * - `CERT_*` and `UNABLE_TO_VERIFY_LEAF_SIGNATURE` /
  *   `DEPTH_ZERO_SELF_SIGNED_CERT` / `SELF_SIGNED_CERT_IN_CHAIN`
- *   (any {@link isTlsVerificationErrorCode} code) → **permanent** (`false`) —
- *   never auto-reconnect-loop into a misconfigured or MITM'd endpoint (Phase 8).
- * - `ERR_SSL_*` (Node TLS alert codes) → **permanent** (`false`) — a TLS
+ *   (any {@link isTlsVerificationErrorCode} code) → **permanent** (`false`),
+ *   never auto-reconnect-loop into a misconfigured or MITM'd endpoint.
+ * - `ERR_SSL_*` (Node TLS alert codes) → **permanent** (`false`), a TLS
  *   protocol failure such as a `clientAuth: 'MUST'` server rejecting the
- *   client certificate recurs on every attempt (Phase 8). On TLS-configured
+ *   client certificate recurs on every attempt. On TLS-configured
  *   connections `MllpClient` additionally consults {@link isTlsProtocolError},
  *   which also catches `EPROTO`/alert-bearing OpenSSL errors that this
  *   generic classifier (which cannot know the connection was TLS) leaves
  *   transient.
- * - `MLLP_*` (any {@link MllpFramingError} code — a fatal decoder throw, surfaced with
- *   `connectionCause: 'framing-fatal'`) → **permanent** (`false`) (MLLP-10). The peer is not
- *   speaking MLLP — an HTTP probe, a health check, a wrong-port misconfiguration — or is emitting
+ * - `MLLP_*` (any {@link MllpFramingError} code, a fatal decoder throw, surfaced with
+ *   `connectionCause: 'framing-fatal'`) → **permanent** (`false`). The peer is not
+ *   speaking MLLP, an HTTP probe, a health check, a wrong-port misconfiguration, or is emitting
  *   frames past `maxFrameSizeBytes`. Every reconnect meets the same bytes, so retrying is an
  *   unbounded storm against a peer that is already misconfigured. If a peer's quirk is *expected*,
- *   the decoder's tolerance opt-ins are the supported answer — they make it a warning, not a fatal.
- * - non-Error / unknown / no-code → **transient** (`true`) — Postel's Law
+ *   the decoder's tolerance opt-ins are the supported answer, they make it a warning, not a fatal.
+ * - non-Error / unknown / no-code → **transient** (`true`), Postel's Law
  *   default. Reconnect attempts are bounded by `retryStrategy` and the
  *   30s backoff cap, so the default is safe.
  *
@@ -3030,11 +3009,10 @@ declare function isTlsProtocolError(err: unknown): boolean;
 declare function isTransientConnectionError(err: unknown): boolean;
 /**
  * Thrown (or rejects the `send()` promise) when the in-flight queue exceeds
- * the configured high-water mark and `onBackpressure: 'reject'` is set
- * (CLIENT-07, ERR-04).
+ * the configured high-water mark and `onBackpressure: 'reject'` is set.
  *
- * `highWaterMark` accepts a count cap, a byte cap, or both — when both are
- * present, the stricter-of-two trigger wins (D-23).
+ * `highWaterMark` accepts a count cap, a byte cap, or both, when both are
+ * present, the stricter-of-two trigger wins.
  *
  * @example
  * ```typescript
@@ -3057,7 +3035,7 @@ declare class MllpBackpressureError extends Error {
     readonly queueDepth: number;
     /** Total bytes of in-flight + queued frames at the moment of rejection. */
     readonly queueBytes: number;
-    /** The high-water-mark configuration that was triggered (D-23). */
+    /** The high-water-mark configuration that was triggered. */
     readonly highWaterMark: {
         readonly count?: number;
         readonly bytes?: number;
@@ -3079,7 +3057,7 @@ declare class MllpBackpressureError extends Error {
 }
 
 /**
- * `@cosyte/mllp` — Production-grade MLLP client and server for Node.js.
+ * `@cosyte/mllp`, Production-grade MLLP client and server for Node.js.
  *
  * Transport-only sibling to `@cosyte/hl7`. Handles framing, ACKs, reconnects,
  * backpressure, and TLS without requiring knowledge of the MLLP spec.
@@ -3096,7 +3074,7 @@ declare class MllpBackpressureError extends Error {
  * Package version marker exported from the `@cosyte/mllp` root.
  *
  * Kept in lockstep with `package.json` by `scripts/sync-version.mjs`, which the `version` script
- * runs immediately after `changeset version`. The `: string` annotation is deliberate — without it
+ * runs immediately after `changeset version`. The `: string` annotation is deliberate, without it
  * TypeScript infers the *literal* type (`declare const VERSION = "0.0.0"`), which leaks the current
  * release into consumers' types and makes an equality check against any other version a compile
  * error.