@cosyte/mllp 0.0.1 → 0.0.2

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { T as Transport } from './index-DjGQJtYE.cjs';
+import { T as Transport } from './index-DAZ4BvJE.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
@@ -62,7 +62,7 @@ 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
+ * `connectionId` is always `undefined` here, Phase 3 enriches via
  * `{ ...w, connectionId: this.connectionId }` then re-freezes (D-08).
  *
  * @example
@@ -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
      * 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 (WARN-06).
      *
      * @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,7 +252,7 @@ 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.
  *
@@ -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,7 +337,7 @@ 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;
@@ -349,7 +349,7 @@ declare class FrameReader {
     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.
@@ -396,7 +396,7 @@ declare class FrameReader {
 }
 
 /**
- * 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` (Phase 8).
  *
  * 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}. */
@@ -524,7 +524,7 @@ declare class TlsTransport implements Transport {
 /**
  * Security-warning codes and payload shape shared by the client and server (Phase 8).
  *
- * 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
@@ -612,14 +612,14 @@ interface SecurityWarning {
  *
  * 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
@@ -644,7 +644,7 @@ type PemInput = string | Buffer | Array<string | Buffer>;
 /**
  * Client-side TLS options (Phase 8, `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.
  *
@@ -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
@@ -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 per OBS-04.
  *
  * All timestamps are `Date | null` (not epoch milliseconds). `JSON.stringify()`
  * serialises them to ISO 8601 strings by default with no information loss.
@@ -921,14 +921,14 @@ declare class Connection extends EventEmitter {
     private _lastByteOutAt;
     /** Ring buffer: last MAX_WARNINGS entries (OBS-05). */
     private _warningBuffer;
-    /** Accurate total counts per code — unaffected by ring buffer truncation (OBS-05). */
+    /** Accurate total counts per code, unaffected by ring buffer truncation (OBS-05). */
     private readonly _warningsByCode;
     /** Set to true once the ring buffer overflows (OBS-05). */
     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).
@@ -1024,7 +1024,7 @@ declare class Connection extends EventEmitter {
      * 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.
@@ -1059,12 +1059,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 +1077,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 +1089,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;
@@ -1141,33 +1141,33 @@ type ConnectionErrorPhase = "connect" | "send" | "receive" | "close" | "reconnec
 /**
  * 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-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,
+ * - `'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
+ * - `'tls-verify'` (Phase 8), 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'` (Phase 8), 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 +1184,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 +1231,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 +1247,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 +1284,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 +1320,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 +1338,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`) —
+ *      {@link containsBatchOrExtraMessage}). Batch ACK is its own feature (`MLLP-BATCH`),
  *      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 +1375,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 +1390,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 +1404,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 +1433,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 +1444,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 +1455,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
@@ -1479,7 +1479,7 @@ declare function buildRawAck(payload: Buffer, code: AckCode): Buffer;
 /**
  * Metadata attached to each decoded MLLP message (SERVER-03).
  *
- * 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 +1498,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.
  *
@@ -1600,11 +1600,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
@@ -1617,7 +1617,7 @@ 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.
+     * 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,21 +1628,21 @@ 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.
+     * `conn.send()` in `onMessage` when `autoAck` is set, this results in two ACKs.
      */
     autoAck?: "AA" | ((payload: Buffer, meta: MessageMeta, conn: Connection) => Buffer | Promise<Buffer>);
     /**
@@ -1676,14 +1676,14 @@ interface ServerOptions {
      */
     tls?: ServerTlsOptions;
     /**
-     * Opt-in required to bind a wildcard host — a bind-safety guardrail
+     * Opt-in required to bind a wildcard host, a bind-safety guardrail
      * (Phase 8). 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 +1694,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 (SERVER-08).
  *
  * Extends `ServerOptions` with `port`, `host`, and `handleSignals`. Defaults:
  * `autoAck: 'AA'`, `drainTimeoutMs: 30_000`, `Symbol.asyncDispose` wired.
@@ -1715,7 +1715,7 @@ 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'` (Phase 8 bind-safety hardening,
      * was `'0.0.0.0'`; binding all interfaces now requires
      * `ServerOptions.allowWildcardBind: true`).
      */
@@ -1725,13 +1725,13 @@ interface StarterServerOptions extends ServerOptions {
      * call `server.close()` then `process.exit(0)` (D-09). 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 (D-02).
  *
  * 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 +1739,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,16 +1747,16 @@ 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
+ * Phase 8 (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).
@@ -1778,13 +1778,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. */
+    /** Phase 8, 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
+     * Phase 8, 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 +1794,7 @@ declare class MllpServer extends EventEmitter {
     private _host;
     private _acceptedTotal;
     private _closedTotal;
-    /** Phase 8 — count of `'tlsClientError'` events since listen(). */
+    /** Phase 8, count of `'tlsClientError'` events since listen(). */
     private _tlsClientErrorsTotal;
     /**
      * Construct an MLLP server. Created idle; call `listen()` (or use
@@ -1810,23 +1810,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
+     *   are rejected unless `ServerOptions.allowWildcardBind: true`, literal
      *   spellings pre-bind, resolver-only shorthands post-bind via the
      *   OS-normalized bound address.
      *
@@ -1845,18 +1845,18 @@ 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
+     * 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 +1876,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 +1885,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
@@ -1909,7 +1909,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 +1919,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
@@ -1932,7 +1932,7 @@ declare class MllpServer extends EventEmitter {
     private _onSocketAccepted;
     /**
      * Extract a minimal, content-free peer-certificate summary (Phase 8, ATNA
-     * ITI-19 mutual authentication) — CN strings, expiry, and the verification
+     * 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 +1945,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,7 +1976,7 @@ 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;
     /**
@@ -1990,19 +1990,19 @@ declare class MllpServer extends EventEmitter {
     /**
      * 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 (D-04).
      */
     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 (D-04), 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,12 +2020,12 @@ 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.
+ * NOTE: Stub at Plan 01 scope, Plan 04 fills in the full implementation.
  *
  * @example
  * ```typescript
@@ -2040,14 +2040,14 @@ 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()`,
+ * 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),
@@ -2070,7 +2070,7 @@ declare function createStarterServer(opts: StarterServerOptions): Promise<MllpSe
  * Context passed to a custom `retryStrategy` hook on each reconnect attempt
  * (CLIENT-12, D-15).
  *
- * Frozen via `Object.freeze` before invocation — handlers cannot mutate
+ * Frozen via `Object.freeze` before invocation, handlers cannot mutate
  * (T-05-04-04 mitigation).
  *
  * @example
@@ -2093,7 +2093,7 @@ 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). */
+    /** CLIENT-18 classification (Composition A, D-16). */
     readonly classifiedAs: "transient" | "permanent";
     /**
      * The same `AbortSignal` passed into `connect()`. If no signal was
@@ -2104,15 +2104,15 @@ interface RetryContext {
 }
 /**
  * Custom reconnect-backoff hook (CLIENT-12). Return `null` to halt
- * reconnection (D-17) — the FSM transitions to `CLOSED`.
+ * reconnection (D-17), the FSM transitions to `CLOSED`.
  */
 type RetryStrategy = (ctx: RetryContext) => number | null;
 /**
  * Combined count + byte-based queue cap. Stricter-of-two wins (D-23).
  *
- * - `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,7 +2129,7 @@ type HighWaterMark = number | {
 /**
  * Options for {@link createClient} and the {@link MllpClient} constructor.
  *
- * Phase 5 plans extend this incrementally — new fields are additive and optional.
+ * Phase 5 plans extend this incrementally, new fields are additive and optional.
  *
  * @example
  * ```typescript
@@ -2147,7 +2147,7 @@ interface ClientOptions {
     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 —
+     * 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;
@@ -2174,7 +2174,7 @@ interface ClientOptions {
      * `CONNECTED → DISCONNECTED → RECONNECTING → CONNECTING → CONNECTED`
      * with exponential backoff per D-19 unless overridden by
      * {@link ClientOptions.retryStrategy}. Permanent errors halt and
-     * transition directly to `CLOSED` (Composition A — D-16).
+     * transition directly to `CLOSED` (Composition A, D-16).
      */
     readonly autoReconnect?: boolean;
     /**
@@ -2206,8 +2206,8 @@ interface ClientOptions {
     /**
      * Behavior when the high-water mark is exceeded (CLIENT-07).
      *
-     * - `'reject'` (default) — `send()` rejects with `MllpBackpressureError`.
-     * - `'wait'` — `send()` awaits the `'drain'` event OR the per-message
+     * - `'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).
      *
      * @default 'reject'
@@ -2216,9 +2216,9 @@ interface ClientOptions {
     /**
      * Strict serialization send → await-ACK → send (CLIENT-19, D-06).
      *
-     * - `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.
      *
@@ -2246,7 +2246,7 @@ interface ClientOptions {
     readonly deadPeerTimeoutMs?: number;
     /**
      * Enable TLS (MLLPS) for this connection (Phase 8). `true` enables TLS with
-     * all defaults — including certificate verification **on**. Pass a
+     * all defaults, including certificate verification **on**. Pass a
      * {@link TlsOptions} object to customize (`ca`/`cert`/`key`, minimum
      * version, ciphers, `allowUnverified`, …).
      *
@@ -2259,13 +2259,13 @@ interface ClientOptions {
 /**
  * Observability snapshot returned by {@link MllpClient.getStats} (OBS-01, D-26).
  *
- * All fields are JSON-serializable (OBS-04) — no Buffers, no class instances,
+ * All fields are JSON-serializable (OBS-04), no Buffers, no class instances,
  * no Maps, no circular references. `lastConnectedAt` and `lastAckAt` are
- * **epoch milliseconds** (numbers), NOT `Date` instances — log-pipeline
+ * **epoch milliseconds** (numbers), NOT `Date` instances, log-pipeline
  * friendly per D-26.
  *
  * `warningsByCode` keys are constrained to the public {@link WarningCode}
- * union — adding/removing a code is a breaking change (CLAUDE.md
+ * union, adding/removing a code is a breaking change (CLAUDE.md
  * stable-codes guardrail enforced at the type boundary, B-05).
  *
  * @example
@@ -2276,7 +2276,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,7 +2284,7 @@ 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
@@ -2312,21 +2312,21 @@ interface ClientStats {
     readonly tls: boolean;
 }
 /**
- * MLLP client — composes a single Phase 3 {@link Connection} over a {@link NetTransport}
+ * MLLP client, composes a single Phase 3 {@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 (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
  *   `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
@@ -2368,7 +2368,7 @@ 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
+     * W-02, total reconnect attempts since construction. Read by PLAN-06 for
      * `getStats().reconnectAttempts`. Incremented at the entry of every
      * `_handleDisconnect` invocation that proceeds to schedule a backoff.
      */
@@ -2389,7 +2389,7 @@ 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 (Plan 05, D-11). `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. */
@@ -2403,7 +2403,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
@@ -2439,9 +2439,9 @@ declare class MllpClient extends EventEmitter {
      */
     get state(): ConnectionState;
     /**
-     * Open a TCP (or TLS — Phase 8) connection to the configured `host:port`
+     * 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,
+     * enters `CONNECTED`, for TLS, on `'secureConnect'` (handshake complete,
      * including certificate verification when it is on).
      *
      * Rejects with:
@@ -2461,11 +2461,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".
      *
@@ -2484,7 +2484,7 @@ declare class MllpClient extends EventEmitter {
      *
      * Plaintext (`ClientOptions.tls` unset): a `net.Socket` wrapped in
      * `NetTransport`. TLS (Phase 8): a `tls.TLSSocket` wrapped in
-     * `TlsTransport` — verification defaults **on**
+     * `TlsTransport`, verification defaults **on**
      * (`rejectUnauthorized: !allowUnverified`), floor `minVersion: 'TLSv1.2'`
      * (the IHE ATNA ITI-19 BCP195 floor), `servername` defaulting to
      * `ClientOptions.host`.
@@ -2494,12 +2494,12 @@ declare class MllpClient extends EventEmitter {
      * Wrap a connect-phase socket error as `MllpConnectionError`, classifying
      * TLS failures (Phase 8) 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 +2507,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).
@@ -2517,7 +2517,7 @@ declare class MllpClient extends EventEmitter {
     private _emitContained;
     /**
      * Emit the per-connection insecure-TLS warning (Phase 8) when
-     * `tls.allowUnverified === true` — fires on EVERY successful
+     * `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.
@@ -2526,7 +2526,7 @@ declare class MllpClient extends EventEmitter {
     /**
      * 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
+     * Connection layer already freezes, defense-in-depth, harmless on
      * already-frozen objects.
      *
      * Builds the unified `Correlator` (D-03/A1) bound to this Connection and
@@ -2537,23 +2537,23 @@ 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 (Plan 05, CLIENT-08, D-11).
      * No-op when `deadPeerTimeoutMs` is unset.
      */
     private _armDeadPeerTimer;
     /**
-     * Clear the dead-peer idle timer (Plan 05 — D-14 timer cleanup on
+     * Clear the dead-peer idle timer (Plan 05, D-14 timer cleanup on
      * every transition out of CONNECTED).
      */
     private _clearDeadPeerTimer;
     /**
-     * Disconnect handler — Plan 04 reconnect FSM core.
+     * Disconnect handler, Plan 04 reconnect FSM core.
      *
      * Implements:
      * - CLIENT-17 hybrid in-flight handling (D-08): 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
+     * - CLIENT-18 classifier-first (Composition A, D-16): permanent errors
      *   transition straight to CLOSED without invoking `retryStrategy`.
      * - W-01 backoff-reset on recent success: first disconnect after a
      *   successful ACK on the prior session resets `_attempt` to 0.
@@ -2561,7 +2561,7 @@ declare class MllpClient extends EventEmitter {
      * - D-15 frozen RetryContext + D-17 null-return halts.
      * - D-19 default exponential strategy.
      *
-     * Invoked from the SINGLE `_onStateChange` hook — no parallel listener
+     * Invoked from the SINGLE `_onStateChange` hook, no parallel listener
      * (B-04). Idempotent across same-cycle re-entry: cycle-start flag
      * coordinates first-disconnect vs subsequent-within-cycle behavior.
      */
@@ -2594,7 +2594,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 +2603,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 (W-07).
      *
      * @internal
      */
@@ -2617,7 +2617,7 @@ declare class MllpClient extends EventEmitter {
      *   anchor 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
+     * No parallel listener is registered, downstream plans extend at the named
      * anchor (B-04).
      */
     private _onAckPayload;
@@ -2634,9 +2634,9 @@ declare class MllpClient extends EventEmitter {
     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 (Plan 05, D-24). 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;
     /**
@@ -2672,14 +2672,14 @@ 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 (CLIENT-11).
      */
     send(payload: Buffer, opts?: {
         signal?: AbortSignal;
         ackTimeoutMs?: number;
     }): Promise<Buffer>;
     /**
-     * 'wait'-mode backpressure handler (Plan 05 — CLIENT-07/CLIENT-11).
+     * 'wait'-mode backpressure handler (Plan 05, CLIENT-07/CLIENT-11).
      *
      * Awaits one of three terminating signals, in order:
      * - `'drain'` event → re-enter `send()` (the gate will now pass).
@@ -2695,7 +2695,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 +2722,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
@@ -2734,7 +2734,7 @@ declare class MllpClient extends EventEmitter {
     /**
      * Returns a JSON-serializable observability snapshot (OBS-01, D-26).
      *
-     * 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 +2749,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
@@ -2835,20 +2835,20 @@ interface StarterClientOptions {
 }
 /**
  * Three-line MLLP client with batteries-included defaults (PLAN-06,
- * CLIENT-10, D-22). The returned client is already CONNECTED — `connect()`
+ * CLIENT-10, D-22). The returned client is already CONNECTED, `connect()`
  * has been awaited.
  *
  * D-22 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 +2865,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` (PLAN-02), ACK timeout (ERR-02)
+ * - `MllpBackpressureError`, high-water mark exceeded (ERR-04, plan 05)
+ * - `isTransientConnectionError` (PLAN-04), transient/permanent classifier (CLIENT-18)
  *
  * Re-exported from `src/client/index.ts` and `src/index.ts`.
  *
@@ -2878,7 +2878,7 @@ declare function createStarterClient(opts: StarterClientOptions): Promise<MllpCl
  * the configured `ackTimeoutMs` (ERR-02).
  *
  * 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
+ * at the `send()` call, pre-flush queue time is not charged to the peer
  * (CLIENT-04).
  *
  * @example
@@ -2914,7 +2914,7 @@ 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
@@ -2932,7 +2932,7 @@ declare class MllpTimeoutError extends Error {
  */
 declare function isTlsVerificationErrorCode(code: string): boolean;
 /**
- * Detects **TLS-protocol-shaped** errors — failures of the TLS protocol
+ * Detects **TLS-protocol-shaped** errors, failures of the TLS protocol
  * itself, as opposed to plain TCP-level network failures (Phase 8).
  *
  * Apply this only to errors raised on a **TLS** connection; `MllpClient`
@@ -2941,12 +2941,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 +2954,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 +2976,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.
  *   }
  * });
  * ```
@@ -2987,7 +2987,7 @@ declare function isTlsProtocolError(err: unknown): boolean;
  * 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
+ * see `RetryContext.classifiedAs`). Re-exported so callers can implement
  * their own retry policies.
  *
  * Classification table (CLIENT-18, D-16):
@@ -2996,22 +2996,22 @@ declare function isTlsProtocolError(err: unknown): boolean;
  *   `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`) —
+ *   (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
+ * - `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
  *   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
+ * - `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
+ *   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.
  *
@@ -3033,7 +3033,7 @@ declare function isTransientConnectionError(err: unknown): boolean;
  * the configured high-water mark and `onBackpressure: 'reject'` is set
  * (CLIENT-07, ERR-04).
  *
- * `highWaterMark` accepts a count cap, a byte cap, or both — when both are
+ * `highWaterMark` accepts a count cap, a byte cap, or both, when both are
  * present, the stricter-of-two trigger wins (D-23).
  *
  * @example
@@ -3079,7 +3079,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 +3096,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.