@glion/mllp-client 0.16.0 → 0.19.0

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@glion/mllp-client",
-  "version": "0.16.0",
-  "description": "MLLP client for sending HL7v2 messages and receiving acknowledgments",
+  "version": "0.19.0",
+  "description": "Persistent, single-flight MLLP client for HL7v2",
   "keywords": [
-    "client",
     "health",
     "healthcare",
     "hl7",
@@ -29,67 +28,42 @@
   "type": "module",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "workerd": {
-        "types": "./dist/runtimes/workers.d.ts",
-        "import": "./dist/runtimes/workers.js"
-      },
-      "default": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/index.js"
-      }
-    },
-    "./core": {
-      "types": "./dist/core/index.d.ts",
-      "import": "./dist/core/index.js"
-    },
-    "./node": {
-      "types": "./dist/runtimes/node.d.ts",
-      "import": "./dist/runtimes/node.js"
-    },
-    "./workers": {
-      "types": "./dist/runtimes/workers.d.ts",
-      "import": "./dist/runtimes/workers.js"
-    }
+    ".": "./dist/index.js",
+    "./node": "./dist/runtime/node.js"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@glion/ack": "0.16.0",
-    "@glion/ast": "0.16.0",
-    "@glion/mllp-transport": "0.16.0",
-    "@glion/util-query": "0.16.0",
-    "@glion/parser": "0.16.0"
+    "@glion/ack": "0.19.0",
+    "@glion/ast": "0.19.0",
+    "@glion/mllp-codec": "0.19.0",
+    "@glion/to-hl7v2": "0.19.0",
+    "@glion/util-charset": "0.19.0",
+    "@glion/parser": "0.19.0",
+    "@glion/util-query": "0.19.0"
   },
   "devDependencies": {
     "@types/node": "25.6.0",
-    "@vitest/coverage-v8": "4.1.5",
+    "@vitest/coverage-v8": "4.1.11",
     "publint": "0.3.18",
     "tsdown": "0.21.10",
     "typescript": "6.0.3",
-    "vitest": "4.1.5",
-    "wrangler": "^4.86.0",
-    "@glion/hl7v2": "0.16.0",
-    "@glion/mllp": "0.16.0",
-    "@glion/mllp-ack": "0.16.0",
-    "@glion/testing": "0.16.0",
-    "@glion/tsconfig": "0.16.0",
-    "@glion/check-readme": "0.16.0"
+    "vitest": "4.1.11",
+    "@glion/check-readme": "0.18.0",
+    "@glion/testing": "0.18.0",
+    "@glion/tsconfig": "0.18.0"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "scripts": {
     "build": "tsdown && tsc --emitDeclarationOnly",
-    "check-types": "tsc --noEmit",
+    "check-types": "tsc --noEmit && tsc --noEmit -p tests/tsconfig.json",
     "check:readme": "glion-check-readme",
-    "publint": "publint --strict",
-    "test": "vitest run --project 'hl7v2-mllp-client (node)'",
-    "test:bun": "bun --bun test test/core.test.ts",
-    "test:cf": "vitest run --project 'hl7v2-mllp-client (workerd)'",
-    "test:coverage": "vitest run --coverage --project 'hl7v2-mllp-client (node)'",
-    "test:node": "vitest run --project 'hl7v2-mllp-client (node)'",
-    "test:watch": "vitest"
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "publint": "publint --strict"
   }
 }

package/dist/client.js

@@ -1,549 +0,0 @@
-import { AckApplicationError, AckApplicationReject, AckCode, AckCommitError, AckCommitReject, AckException, Hl7ErrorCode, Severity } from "@glion/ack";
-import { MllpError, createDecoderStream, encode } from "@glion/mllp-transport";
-import { parseHL7v2 } from "@glion/parser";
-import { value } from "@glion/util-query";
-//#region src/core/errors.ts
-/**
-* Machine-readable codes for `MllpClient` transport failures.
-*
-* These cover everything that can go wrong between the moment
-* `MllpClient.send()` is called and the moment a complete ACK frame
-* has been decoded — i.e. everything that is not an HL7v2
-* application-level NAK. NAK responses (MSA-1 ∈ {AE, AR, CE, CR})
-* surface as `AckException` subclasses thrown directly from
-* `@glion/ack`, not as transport errors.
-*/
-const MllpClientErrorCode = {
-	/** No ACK arrived within the configured `timeout`. */
-	/** The peer closed the connection before a complete ACK arrived. */
-	CONNECTION_CLOSED: "CONNECTION_CLOSED",
-	/** TCP connection could not be established (refused, DNS, routing). */
-	CONNECTION_REFUSED: "CONNECTION_REFUSED",
-	/**
-	* The caller passed a payload that could not be MLLP-encoded —
-	* typically because it was not a `string` or `Uint8Array`. Also
-	* surfaced when constructor options fail validation (bad
-	* host/port/timeout/etc). Thrown before any socket is opened, so
-	* no connection is made and no resources need cleanup.
-	*/
-	INVALID_INPUT: "INVALID_INPUT",
-	MALFORMED_ACK: "MALFORMED_ACK",
-	/** The remote sent bytes that did not form a valid MLLP frame. */
-	MALFORMED_FRAME: "MALFORMED_FRAME",
-	/** A frame was received but could not be parsed as a valid HL7v2 ACK. */
-	TIMEOUT: "TIMEOUT",
-	/**
-	* TLS handshake failed — typically because of certificate
-	* verification, hostname mismatch, expired cert, untrusted CA, or
-	* a TLS protocol error. Distinct from `CONNECTION_REFUSED` (the
-	* TCP connection succeeded but the TLS upgrade failed) so
-	* operators can identify TLS misconfiguration quickly in
-	* healthcare deployments where it is a recurring incident class.
-	*/
-	TLS_HANDSHAKE_FAILED: "TLS_HANDSHAKE_FAILED"
-};
-/**
-* Error thrown by `MllpClient.send()` for transport-level failures.
-*
-* Extends {@link MllpError} so callers can catch any MLLP error —
-* server- or client-side — with a single `instanceof MllpError`
-* check. The {@link MllpClientErrorCode | code} field discriminates
-* the failure mode for typed handling.
-*
-* Application-level NAK responses are **not** thrown as
-* `MllpClientError`; they are thrown as `AckException` subclasses
-* from `@glion/ack`. A typical `catch` block handles both:
-*
-* ```ts
-* import { AckException } from "@glion/ack";
-* import { MllpClientError } from "@glion/mllp-client";
-*
-* try {
-*   await client.send(message);
-* } catch (error) {
-*   if (error instanceof AckException) {
-*     // Application-level NAK.
-*   } else if (error instanceof MllpClientError) {
-*     // Transport-level failure.
-*   }
-* }
-* ```
-*/
-var MllpClientError = class extends MllpError {
-	constructor(code, message, options) {
-		super(code, message, options);
-		this.name = "MllpClientError";
-	}
-};
-//#endregion
-//#region src/core/acknowledgment.ts
-/**
-* Acknowledgment parsing for the MLLP client.
-*
-* This module owns three things:
-*
-* 1. The {@link Acknowledgment} interface — a structured view of an ACK message
-*    exposing the fields callers most often need (MSA-1/2/3, ERR-3/4) without
-*    forcing them to walk the AST themselves.
-* 2. {@link parseAck} — turns a raw wire-format ACK string into an
-*    {@link Acknowledgment}, or throws {@link MllpClientError} when the payload
-*    is not a recognisable ACK.
-* 3. {@link throwOnNak} — inspects an {@link Acknowledgment} and throws the
-*    matching `AckException` subclass when MSA-1 indicates a NAK.
-*
-* Both helpers are internal to the package — only the {@link Acknowledgment}
-* type is re-exported from `@glion/mllp-client`. Application code interacts
-* with parsed acknowledgments through the return value (and thrown errors)
-* of `MllpClient.send()`.
-*
-* The HL7v2 ACK structure used here (Section 2.9.2 of the HL7v2 standard):
-*
-* MSH | header (sender, receiver, timestamp, message control id) MSA |
-* acknowledgment code (MSA-1), original control id (MSA-2), text (MSA-3) ERR |
-* optional error segment with HL7 condition code (ERR-3) and severity (ERR-4)
-*
-* @module
-*/
-/**
-* MSA-1 codes that mean "the receiver accepted the message". Anything
-* outside this set is a NAK and produces a thrown `AckException`.
-*
-* See HL7v2 Table 0008 — Acknowledgment Codes.
-*/
-const SUCCESS_CODES = new Set([AckCode.ApplicationAccept, AckCode.CommitAccept]);
-/**
-* MSA-1 codes that are **intermediate** in HL7v2 enhanced
-* acknowledgment mode — the receiver will follow up with a separate
-* final acknowledgment later in the exchange. The MLLP client's read
-* loop continues past these by default and only resolves on a final
-* code.
-*
-* Per HL7v2 Section 2.9.2, only `CA` (Commit Accept) is intermediate;
-* `CE` and `CR` are final at the commit level. `AA`, `AE`, `AR` are
-* final at the application level.
-*/
-const INTERMEDIATE_ACK_CODES = new Set([AckCode.CommitAccept]);
-/**
-* Returns `true` for any acknowledgment code that should terminate the
-* client's read loop. Intermediate codes (CA) return `false`; every
-* other code — including vendor-specific values — is treated as final
-* to avoid hanging on responses we do not recognise.
-*/
-function isFinalAckCode(code) {
-	return !INTERMEDIATE_ACK_CODES.has(code);
-}
-/**
-* Parse a raw ACK frame string into an {@link Acknowledgment}.
-*
-* Field extraction is delegated to `@glion/util-query`'s `value()` helper —
-* this is the same path used elsewhere in the Glion stack and avoids
-* hand-rolling AST traversal here.
-*
-* Throws `MllpClientError(MALFORMED_ACK)` when:
-*
-* - The parser fails to produce a tree (malformed HL7v2), or
-* - MSA-1 is missing (the message is not a valid acknowledgment).
-*
-* Other missing fields (MSA-3, ERR-3, ERR-4) are not fatal — they are
-* exposed as `undefined` because real-world ACKs frequently omit them.
-*/
-function parseAck(raw) {
-	const tree = parseTreeOrThrow(raw);
-	const code = value(tree, "MSA-1")?.value;
-	if (!code) throw new MllpClientError(MllpClientErrorCode.MALFORMED_ACK, "ACK response is missing MSA-1 acknowledgment code");
-	return {
-		code,
-		controlId: value(tree, "MSA-2")?.value ?? "",
-		errorCode: value(tree, "ERR-3")?.value ?? void 0,
-		raw,
-		severity: value(tree, "ERR-4")?.value ?? void 0,
-		textMessage: value(tree, "MSA-3")?.value ?? void 0,
-		tree
-	};
-}
-/**
-* Run the HL7v2 parser, wrapping any thrown error in
-* `MllpClientError(MALFORMED_ACK)` so callers see one error shape
-* regardless of which lower-level component failed.
-*/
-function parseTreeOrThrow(raw) {
-	try {
-		return parseHL7v2(raw);
-	} catch (error) {
-		throw new MllpClientError(MllpClientErrorCode.MALFORMED_ACK, `Failed to parse ACK response: ${formatCause(error)}`, { cause: error });
-	}
-}
-/**
-* Inspect an {@link Acknowledgment} and throw the matching `AckException`
-* subclass when MSA-1 indicates a NAK. Returns the acknowledgment unchanged
-* on AA/CA.
-*
-* The thrown exception mirrors the receiver-side exception types — a
-* caller that already handles `AckApplicationError` from a server's
-* middleware can reuse the same `catch` blocks here.
-*/
-function throwOnNak(ack) {
-	if (SUCCESS_CODES.has(ack.code)) return ack;
-	throw buildAckException(ack);
-}
-/**
-* Convert a NAK acknowledgment into an `AckException` subclass.
-*
-* The fallbacks below preserve a useful exception even when the receiver
-* sent a sparse NAK: a missing MSA-3 yields a synthesised message; a
-* missing ERR segment yields the catch-all `ApplicationInternalError`
-* code (`207`) and severity Error (`E`). This matches the receiver-side
-* conventions in `@glion/ack`.
-*/
-function buildAckException(ack) {
-	const message = ack.textMessage ?? `Acknowledgment ${ack.code} from receiver`;
-	const options = {
-		errorCode: coerceErrorCode(ack.errorCode),
-		raw: ack.raw,
-		severity: coerceSeverity(ack.severity)
-	};
-	switch (ack.code) {
-		case AckCode.ApplicationError: return new AckApplicationError(message, options);
-		case AckCode.ApplicationReject: return new AckApplicationReject(message, options);
-		case AckCode.CommitError: return new AckCommitError(message, options);
-		case AckCode.CommitReject: return new AckCommitReject(message, options);
-		default: return new AckApplicationError(message, options);
-	}
-}
-/**
-* Set of HL7 condition codes (Table 0357) we recognise. Built once from
-* the `Hl7ErrorCode` enum so the lookup stays cheap and the membership
-* stays in sync with the source of truth in `@glion/ack`.
-*/
-const KNOWN_ERROR_CODES = new Set(Object.values(Hl7ErrorCode));
-/**
-* Set of severity codes (Table 0516) we recognise.
-*/
-const KNOWN_SEVERITIES = new Set(Object.values(Severity));
-/**
-* Map an ERR-3 string to a typed {@link Hl7ErrorCodeValue}. Unknown or
-* missing values fall back to `ApplicationInternalError` (`207`) so the
-* exception always carries a well-defined code, mirroring receiver-side
-* conventions in `@glion/ack`.
-*
-* The widening cast is intentional and confined here — receivers
-* occasionally send vendor-specific codes outside Table 0357, and the
-* client must still produce a usable exception rather than reject the
-* NAK over an unknown code.
-*/
-function coerceErrorCode(input) {
-	if (input !== void 0 && KNOWN_ERROR_CODES.has(input)) return input;
-	return Hl7ErrorCode.ApplicationInternalError;
-}
-/**
-* Map an ERR-4 string to a typed {@link SeverityValue}. Unknown or
-* missing values fall back to `Severity.Error` (`E`).
-*/
-function coerceSeverity(input) {
-	if (input !== void 0 && KNOWN_SEVERITIES.has(input)) return input;
-	return Severity.Error;
-}
-/** Render an unknown thrown value as a human-readable string for error messages. */
-function formatCause(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-//#endregion
-//#region src/core/internal/ack-parser-stream.ts
-/**
-* Build a transform that consumes decoded MLLP frames and produces
-* parsed `Acknowledgment` objects. A parse failure errors the
-* readable side rather than enqueuing — the consumer's `for await`
-* loop rejects with the typed error.
-*/
-function createAckParserStream() {
-	return new TransformStream({ transform(frame, controller) {
-		try {
-			controller.enqueue(parseAck(frame.text));
-		} catch (error) {
-			controller.error(error);
-		}
-	} });
-}
-//#endregion
-//#region src/core/internal/subscribe-abort.ts
-/**
-* Subscribe to an `AbortSignal` and run a callback once if it
-* aborts. Returns a disposer that unsubscribes — call it from a
-* `finally` block so we never leak listeners.
-*
-* If the signal is already aborted at subscription time, the
-* callback fires synchronously and the returned disposer is a
-* no-op. This collapses the "aborted vs aborting" branch every
-* caller would otherwise need to write by hand.
-*
-* Internal to `@glion/mllp-client`.
-*
-* @module
-*/
-/**
-* Subscribe `onAbort` to fire once when `signal` aborts. Returns a
-* disposer that removes the listener.
-*
-* @example
-*   ```ts
-*   const dispose = subscribeAbort(signal, () => socket.destroy());
-*   try {
-*     await waitForReady(socket);
-*   } finally {
-*     dispose();
-*   }
-*   ```;
-*/
-function subscribeAbort(signal, onAbort) {
-	if (signal.aborted) {
-		onAbort();
-		return noop;
-	}
-	signal.addEventListener("abort", onAbort, { once: true });
-	return () => signal.removeEventListener("abort", onAbort);
-}
-function noop() {}
-//#endregion
-//#region src/core/client.ts
-/**
-* Runtime-free core of `@glion/mllp-client`.
-*
-* This module owns {@link MllpClient}, the class application code
-* instantiates to send HL7v2 messages and receive acknowledgments.
-* The class is **transport-agnostic**: it composes a Web-Streams
-* pipeline (`socket → decoder → ack-parser`) and consumes parsed
-* acknowledgments from the readable side. It does **not** know how
-* to open a TCP/TLS connection. That concern is supplied by a
-* {@link MllpConnect} function passed in via
-* {@link MllpClientOptions.connect}. Per-runtime adapters
-* (`@glion/mllp-client/node`, `/deno`, `/workers`) ship pre-wired
-* `MllpClient` subclasses so the common case stays a single import.
-*
-* Each call to `client.send()` performs one short-lived round trip:
-*
-*     ┌─────────────┐  ① connect       ┌──────────┐
-*     │   client    │ ───────────────▶ │  duplex  │
-*     │             │                  └────┬─────┘
-*     │             │  ② write MLLP frame   │
-*     │             │ ─────────────────────▶│  <VT> ... <FS><CR>
-*     │             │                       │
-*     │             │  ③ read frames via    │
-*     │             │     decoder + parser  │
-*     │             │ ◀─────────────────────│  <VT> ACK <FS><CR> ...
-*     │             │                  ┌────┴─────┐
-*     │             │  ④ close + parse │  duplex  │ closed
-*     └─────────────┘                  └──────────┘
-*
-* The four phases share a single deadline ({@link MllpClientOptions.timeout}).
-* If any phase exceeds the budget, the duplex is closed and a typed
-* `MllpClientError(TIMEOUT)` is thrown. Connections are deliberately
-* **not** pooled or reused — each `send()` opens its own duplex.
-*
-* @module
-*/
-/** Default `timeout` when {@link MllpClientOptions.timeout} is omitted. */
-const DEFAULT_TIMEOUT_MS = 3e4;
-/**
-* Runtime-free MLLP client. Instantiate via a runtime adapter
-* (`@glion/mllp-client/node`, `/deno`, `/workers`) for the common
-* case.
-*
-* **TLS-on by default.** `MllpClientOptions.tls` defaults to `true`;
-* pass `tls: false` for plain TCP. See {@link MllpClientOptions.tls}.
-*
-* @example
-*   Send a message and read the ACK on Node:
-*
-*   ```ts
-*   import { MllpClient } from "@glion/mllp-client/node";
-*
-*   const client = new MllpClient({ host: "127.0.0.1", port: 2575 });
-*   const ack = await client.send(rawHl7Message);
-*   console.log(ack.code, ack.controlId); // "AA" "MSG001"
-*   ```
-*/
-var MllpClient = class {
-	#host;
-	#port;
-	#timeout;
-	#maxAckSize;
-	#tls;
-	#connect;
-	constructor(options) {
-		validateOptions(options);
-		this.#host = options.host;
-		this.#port = options.port;
-		this.#connect = options.connect;
-		this.#timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
-		this.#maxAckSize = options.maxAckSize;
-		if (options.tls === false) this.#tls = void 0;
-		else if (options.tls === true || options.tls === void 0) this.#tls = {};
-		else this.#tls = options.tls;
-	}
-	/** The host this client connects to. */
-	get host() {
-		return this.#host;
-	}
-	/** The port this client connects to. */
-	get port() {
-		return this.#port;
-	}
-	/**
-	* Send a single HL7v2 message and resolve with the resolving accept ACK.
-	*
-	* Throws:
-	*
-	* - {@link MllpClientError} for transport failures. `code` identifies the mode:
-	*   `INVALID_INPUT`, `CONNECTION_REFUSED`, `TIMEOUT`, `CONNECTION_CLOSED`,
-	*   `MALFORMED_FRAME`, or `MALFORMED_ACK`.
-	* - An `AckException` subclass from `@glion/ack` (`AckApplicationError`,
-	*   `AckApplicationReject`, `AckCommitError`, `AckCommitReject`) when MSA-1 ∈
-	*   {AE, AR, CE, CR}. The thrown exception's `raw` attribute holds the
-	*   wire-format ACK.
-	*
-	* To observe each accept ACK as it arrives (e.g. seeing the
-	* intermediate `CA` frame in HL7v2 enhanced mode), use
-	* {@link MllpClient.stream} instead.
-	*/
-	async send(message, options = {}) {
-		let last;
-		for await (const ack of this.#exchange(message, options)) last = ack;
-		if (!last) throw new MllpClientError(MllpClientErrorCode.CONNECTION_CLOSED, "Connection closed before a complete ACK was received");
-		return last;
-	}
-	/**
-	* Send a single HL7v2 message and yield each accept ACK as it
-	* arrives. The iterable completes after the resolving frame.
-	*
-	* In HL7v2 enhanced mode the iterable yields `CA` then the
-	* application-level ACK; in basic mode it yields a single
-	* application-level ACK. NAK codes (`AE`/`AR`/`CE`/`CR`) throw the
-	* matching `AckException` from the iterator with the wire-format
-	* ACK on `error.raw`.
-	*
-	* Use {@link MllpClient.send} for the simple "give me the resolving
-	* answer" case.
-	*/
-	stream(message, options = {}) {
-		return this.#exchange(message, options);
-	}
-	/**
-	* Internal exchange generator shared by {@link send} and {@link stream}.
-	*
-	* Owns the connect → write → read loop. NAK codes throw
-	* `AckException` instead of yielding so both consumption shapes see
-	* the same exception. Cleanup (socket teardown, abort
-	* unsubscription) runs in the generator's `finally`, so a consumer
-	* that breaks out of iteration still releases the socket.
-	*
-	* @yields Each accept ACK in arrival order. `return`s after the
-	*   resolving frame.
-	*/
-	async *#exchange(message, options) {
-		const frame = encodeOrThrow(message);
-		const mode = options.mode ?? "OnApplication";
-		const sources = [AbortSignal.timeout(this.#timeout)];
-		if (options.signal) sources.push(options.signal);
-		const signal = AbortSignal.any(sources);
-		const duplex = await this.#connect({
-			host: this.#host,
-			port: this.#port,
-			signal,
-			tls: this.#tls
-		});
-		const reader = duplex.readable.pipeThrough(createDecoderStream({
-			maxMessageSize: this.#maxAckSize,
-			onError: (frameError) => {
-				throw new MllpClientError(MllpClientErrorCode.MALFORMED_FRAME, `Invalid ACK frame: ${frameError.message}`, { cause: frameError });
-			}
-		})).pipeThrough(createAckParserStream()).getReader();
-		const writer = duplex.writable.getWriter();
-		const unsubscribe = subscribeAbort(signal, () => {
-			duplex.close();
-		});
-		try {
-			await writer.write(frame);
-			while (true) {
-				const { done, value: ack } = await reader.read();
-				if (done) throw new MllpClientError(MllpClientErrorCode.CONNECTION_CLOSED, "Connection closed before a complete ACK was received");
-				throwOnNak(ack);
-				yield ack;
-				if (mode === "OnCommit" || isFinalAckCode(ack.code)) return;
-			}
-		} catch (error) {
-			if (error instanceof AckException) throw error;
-			throw normaliseSendError(error, signal, this.#timeout);
-		} finally {
-			unsubscribe();
-			await duplex.close();
-		}
-	}
-};
-/**
-* MLLP-encode a payload, mapping any failure to a typed
-* {@link MllpClientError} with code `INVALID_INPUT`.
-*/
-function encodeOrThrow(message) {
-	try {
-		return encode(message);
-	} catch (error) {
-		throw new MllpClientError(MllpClientErrorCode.INVALID_INPUT, `Invalid message payload: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : void 0 });
-	}
-}
-/**
-* Translate a thrown value from any phase of {@link readAck} into a
-* typed client error.
-*
-* Precedence:
-*
-* 1. If the signal aborted with a typed {@link MllpClientError} reason, surface it
-*    verbatim. (Connector or pipeline-internal failures keep their original
-*    code.)
-* 2. Else if the signal aborted with the standard timeout `DOMException` produced
-*    by `AbortSignal.timeout(ms)`, wrap as `TIMEOUT` with the original budget
-*    in the message.
-* 3. Else if the signal aborted with any other reason (a caller's own
-*    `AbortController.abort(reason)`), wrap as `TIMEOUT` with the caller's
-*    reason chained as `cause` — caller cancellation conceptually IS a timeout
-*    from the protocol's perspective.
-* 4. Else if the underlying stream rejection is already typed, return it unchanged
-*    so adapter-specific failures are preserved.
-* 5. Otherwise wrap as `CONNECTION_CLOSED`.
-*/
-function normaliseSendError(error, signal, timeoutMs) {
-	if (signal.aborted) {
-		if (signal.reason instanceof MllpClientError) return signal.reason;
-		if (isTimeoutAbort(signal.reason)) return new MllpClientError(MllpClientErrorCode.TIMEOUT, `MLLP round trip exceeded ${timeoutMs}ms`);
-		return new MllpClientError(MllpClientErrorCode.TIMEOUT, "Send aborted by caller", { cause: signal.reason instanceof Error ? signal.reason : void 0 });
-	}
-	if (error instanceof MllpClientError) return error;
-	const wrapped = error instanceof Error ? error : new Error(String(error));
-	return new MllpClientError(MllpClientErrorCode.CONNECTION_CLOSED, `Connection failed during MLLP exchange: ${wrapped.message}`, { cause: wrapped });
-}
-/**
-* Detect the standard `DOMException` produced by
-* `AbortSignal.timeout(ms)` when the timer fires. The runtime
-* convention is `name: "TimeoutError"` — duck-typed because
-* `DOMException` exists in Node, Bun, Deno, and Workers but tests
-* run in environments where the constructor identity may differ.
-*/
-function isTimeoutAbort(reason) {
-	return reason !== null && typeof reason === "object" && reason.name === "TimeoutError";
-}
-/**
-* Validate {@link MllpClientOptions} at construction time. Catches
-* the sharp edges that would otherwise surface as confusing runtime
-* symptoms.
-*/
-function validateOptions(options) {
-	if (typeof options.host !== "string" || options.host.length === 0) throw new MllpClientError(MllpClientErrorCode.INVALID_INPUT, "MllpClientOptions.host must be a non-empty string");
-	if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65535) throw new MllpClientError(MllpClientErrorCode.INVALID_INPUT, `MllpClientOptions.port must be an integer in 1..65535, got ${options.port}`);
-	if (typeof options.connect !== "function") throw new MllpClientError(MllpClientErrorCode.INVALID_INPUT, "MllpClientOptions.connect must be a function — import the adapter for your runtime (`@glion/mllp-client/node`, `/deno`, `/workers`)");
-	if (options.timeout !== void 0 && (!Number.isFinite(options.timeout) || options.timeout <= 0)) throw new MllpClientError(MllpClientErrorCode.INVALID_INPUT, `MllpClientOptions.timeout must be a positive finite number of milliseconds, got ${options.timeout}`);
-	if (options.maxAckSize !== void 0 && (!Number.isInteger(options.maxAckSize) || options.maxAckSize <= 0)) throw new MllpClientError(MllpClientErrorCode.INVALID_INPUT, `MllpClientOptions.maxAckSize must be a positive integer, got ${options.maxAckSize}`);
-	if (options.tls !== void 0 && typeof options.tls !== "boolean" && (typeof options.tls !== "object" || options.tls === null)) throw new MllpClientError(MllpClientErrorCode.INVALID_INPUT, "MllpClientOptions.tls must be `true`, `false`, or an MllpClientTlsOptions object");
-}
-//#endregion
-export { MllpClientErrorCode as i, subscribeAbort as n, MllpClientError as r, MllpClient as t };
-
-//# sourceMappingURL=client.js.map