@glion/mllp-client 0.16.0 → 0.20.0

package/dist/assertions.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Option validation, and the client's invariants. Each option `assert*`
+ * throws {@link MllpInvalidOptionError} for an option a caller passed out of
+ * range, before anything happens. {@link assertPhase} throws for a phase the
+ * client cannot be in where it is asserted: a bug.
+ *
+ * @module
+ */
+import type { State } from "./state";
+export declare function assertTimeoutMs(option: string, ms: number): void;
+export declare function assertByteCap(bytes: number): void;
+/** `state` is in `phase`; `where` names the site for the report. */
+export declare function assertPhase<P extends State["phase"]>(state: State, phase: P, where: string): asserts state is Extract<State, {
+    phase: P;
+}>;
+export declare function assertReconnectAttempts(attempts: number): void;
+//# sourceMappingURL=assertions.d.ts.map

package/dist/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAMhE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMjD;AAED,oEAAoE;AACpE,wBAAgB,WAAW,CAAC,CAAC,SAAS,KAAK,CAAC,OAAO,CAAC,EAClD,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,CAAC,EACR,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC,CAM/C;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAO9D"}

package/dist/chunks/mllp-invalid-option-error.js

@@ -0,0 +1,32 @@
+//#region src/errors/base.ts
+/**
+* The base every client error extends, and what each one carries: a fixed
+* `code`, a fixed message, what became of the message, and the lower layer's
+* failure on `cause`.
+*
+* @module
+*/
+const MllpErrorCode = {
+	CLOSED: "CLOSED",
+	CONNECTION_FAILED: "CONNECTION_FAILED",
+	CONNECTION_LOST: "CONNECTION_LOST",
+	CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT",
+	INVALID_MESSAGE: "INVALID_MESSAGE",
+	INVALID_OPTION: "INVALID_OPTION",
+	INVALID_RESPONSE: "INVALID_RESPONSE",
+	SEND_ABORTED: "SEND_ABORTED",
+	SEND_TIMEOUT: "SEND_TIMEOUT"
+};
+var MllpClientError = class extends Error {};
+//#endregion
+//#region src/errors/mllp-invalid-option-error.ts
+/** An option is out of range. Raised before anything happens. */
+var MllpInvalidOptionError = class extends MllpClientError {
+	name = "MllpInvalidOptionError";
+	code = MllpErrorCode.INVALID_OPTION;
+	delivery = "not-sent";
+};
+//#endregion
+export { MllpClientError as n, MllpErrorCode as r, MllpInvalidOptionError as t };
+
+//# sourceMappingURL=mllp-invalid-option-error.js.map

package/dist/chunks/mllp-invalid-option-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-invalid-option-error.js","names":[],"sources":["../../src/errors/base.ts","../../src/errors/mllp-invalid-option-error.ts"],"sourcesContent":["/**\n * The base every client error extends, and what each one carries: a fixed\n * `code`, a fixed message, what became of the message, and the lower layer's\n * failure on `cause`.\n *\n * @module\n */\n\nexport const MllpErrorCode = {\n  CLOSED: \"CLOSED\",\n  CONNECTION_FAILED: \"CONNECTION_FAILED\",\n  CONNECTION_LOST: \"CONNECTION_LOST\",\n  CONNECTION_TIMEOUT: \"CONNECTION_TIMEOUT\",\n  INVALID_MESSAGE: \"INVALID_MESSAGE\",\n  INVALID_OPTION: \"INVALID_OPTION\",\n  INVALID_RESPONSE: \"INVALID_RESPONSE\",\n  SEND_ABORTED: \"SEND_ABORTED\",\n  SEND_TIMEOUT: \"SEND_TIMEOUT\",\n} as const;\n\nexport type MllpErrorCode = (typeof MllpErrorCode)[keyof typeof MllpErrorCode];\n\n/**\n * What became of the message. `not-sent`: nothing reached the wire, and the\n * message may be sent again as it is. `unknown`: it may have reached the\n * remote system, and sending it again may deliver it twice.\n */\nexport type MllpDelivery = \"not-sent\" | \"unknown\";\n\nexport abstract class MllpClientError extends Error {\n  abstract readonly code: MllpErrorCode;\n  abstract readonly delivery: MllpDelivery;\n}\n","import { MllpClientError, MllpErrorCode } from \"./base\";\n\n/** An option is out of range. Raised before anything happens. */\nexport class MllpInvalidOptionError extends MllpClientError {\n  override readonly name = \"MllpInvalidOptionError\";\n  readonly code = MllpErrorCode.INVALID_OPTION;\n  readonly delivery = \"not-sent\";\n}\n"],"mappings":";;;;;;;;AAQA,MAAa,gBAAgB;CAC3B,QAAQ;CACR,mBAAmB;CACnB,iBAAiB;CACjB,oBAAoB;CACpB,iBAAiB;CACjB,gBAAgB;CAChB,kBAAkB;CAClB,cAAc;CACd,cAAc;CACf;AAWD,IAAsB,kBAAtB,cAA8C,MAAM;;;;AC1BpD,IAAa,yBAAb,cAA4C,gBAAgB;CAC1D,OAAyB;CACzB,OAAgB,cAAc;CAC9B,WAAoB"}

package/dist/client.d.ts

@@ -0,0 +1,127 @@
+import type { Root } from "@glion/ast";
+import { MllpClientError } from "./errors";
+import { MllpClientEmitter } from "./events";
+import type { MllpClientOptions, MllpClientResponse, MllpClientState, MllpSendOptions } from "./types";
+/**
+ * Sends HL7v2 messages to one remote system over MLLP and returns each
+ * message's acknowledgment.
+ *
+ * One client owns one socket and puts one message on the wire at a time.
+ * `send()` writes the message, waits for the acknowledgment, checks that it
+ * answers this message, and resolves with it. A send arriving while another
+ * is in flight waits its turn; sends go out in the order they were called.
+ *
+ * ```ts
+ * import { MllpClient } from "@glion/mllp-client";
+ * import { nodeSocket } from "@glion/mllp-client/node";
+ *
+ * await using client = new MllpClient({
+ *   socket: nodeSocket({ host: "hl7.example.org", port: 2575 }),
+ * });
+ *
+ * const ack = await client.send(adtMessage);
+ * ack.code; // "AA" or "CA"
+ * ```
+ *
+ * ## Lifecycle
+ *
+ * `send()` connects on first use; `connect()` opens the connection ahead of
+ * time. `state` reports the phase. A connection that fails to open is dialed
+ * again under the `reconnect` policy. A connection that is lost closes the
+ * client: the message in flight rejects and is not sent again. After
+ * `close()`, or once the client has closed on a failure, every call rejects
+ * with {@link MllpClientClosedError}.
+ *
+ * ## Errors
+ *
+ * When the remote system answers `AE`, `AR`, `CE`, or `CR`, `send()` rejects
+ * with the matching `@glion/ack` exception and the connection stays open.
+ */
+export declare class MllpClient extends MllpClientEmitter {
+    #private;
+    /**
+     * @throws {MllpInvalidOptionError} A timeout, byte cap, or attempt count is
+     *   out of range.
+     */
+    constructor(opts: MllpClientOptions);
+    /**
+     * The current phase: `idle`, `connecting`, `connected`, `sending`,
+     * `closing`, or `closed`.
+     */
+    get state(): MllpClientState;
+    /** How many sends wait their turn, the one in flight excluded. */
+    get pending(): number;
+    /** Whether the connection is open. True in both `connected` and `sending`. */
+    get connected(): boolean;
+    /**
+     * Opens the connection ahead of the first `send()`, dialing again under the
+     * `reconnect` policy when an attempt fails.
+     *
+     * Idempotent: a connected client resolves at once, and a call arriving while
+     * an attempt is in flight waits for that attempt and shares its outcome.
+     *
+     * @throws {MllpConnectionFailedError} The last attempt could not open the
+     *   socket.
+     * @throws {MllpConnectionTimeoutError} The last attempt did not open in time.
+     * @throws {MllpClientClosedError} The client is closed, or `close()` or
+     *   `destroy()` arrived while the connection was still being established.
+     */
+    connect(): Promise<void>;
+    /**
+     * Sends one message and returns its acknowledgment. Connects first when the
+     * client is not connected yet, and waits for the send in flight, if any,
+     * before writing.
+     *
+     * Sends go out in the order `send()` was called. The queue has no bound.
+     * `timeoutMs` runs from the moment the write starts, not from the call. A
+     * send still waiting when the client closes rejects with
+     * {@link MllpClientClosedError}; one waiting behind a dial that fails
+     * rejects with the dial's error, as `connect()` does.
+     *
+     * Nothing is written when an option, phase, or message error is thrown.
+     * Every wire failure also closes the client; a NAK does not.
+     *
+     * @throws {AckException} The remote system answered with a NAK. The
+     *   connection stays open.
+     * @throws {MllpInvalidOptionError} `timeoutMs` is out of range.
+     * @throws {MllpInvalidMessageError} The message cannot be sent as-is.
+     * @throws {MllpClientClosedError} The client is closed, or closed while
+     *   this send was waiting its turn.
+     * @throws {MllpConnectionFailedError} The connection could not be opened.
+     * @throws {MllpConnectionTimeoutError} The connection did not open in time.
+     * @throws {MllpSendTimeoutError} No acknowledgment arrived in time.
+     * @throws {MllpConnectionLostError} The connection was lost.
+     * @throws {MllpSendAbortedError} `destroy()` cut the send off.
+     * @throws {MllpInvalidResponseError} The reply is not a usable
+     *   acknowledgment of this message.
+     */
+    send(message: Root, opts?: MllpSendOptions): Promise<MllpClientResponse>;
+    /**
+     * Ends the connection once the message in flight is acknowledged, and
+     * resolves when it is down. New sends, and sends waiting their turn, are
+     * refused from the moment this is called. An attempt to connect stops at
+     * once.
+     *
+     * Resolves from any phase. Never rejects. Idempotent. The wait is bounded by
+     * the in-flight send's own deadline; {@link destroy} does not wait at all.
+     * If the message it waits for fails, the client closes with that failure;
+     * otherwise with `null`.
+     */
+    close(): Promise<void>;
+    /**
+     * Ends the connection now, and resolves when it is down. A message in flight
+     * rejects with {@link MllpSendAbortedError}. An attempt to connect stops at
+     * once. The client closes with `reason`: the failure it reports on `close`
+     * and on every later call, or `null` for the owner's own decision.
+     *
+     * Resolves from any phase. Never rejects. Idempotent. Sends waiting their
+     * turn are rejected with `reason` when its delivery is `not-sent`, and with
+     * {@link MllpClientClosedError} carrying `reason` otherwise. Arriving while
+     * the client is already closing, it cuts the message in flight and joins
+     * the ending under way; `reason` is recorded when no failure is known yet.
+     */
+    destroy(reason?: MllpClientError | null): Promise<void>;
+    /** Calls {@link close}. Enables `await using`. */
+    [Symbol.asyncDispose](): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAevC,OAAO,EAEL,eAAe,EAIhB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAQ7C,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,eAAe,EAEhB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,UAAW,SAAQ,iBAAiB;;IAQ/C;;;OAGG;gBACS,IAAI,EAAE,iBAAiB;IA0BnC;;;OAGG;IACH,IAAI,KAAK,IAAI,eAAe,CAE3B;IAED,kEAAkE;IAClE,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,8EAA8E;IAC9E,IAAI,SAAS,IAAI,OAAO,CAGvB;IAED;;;;;;;;;;;;OAYG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAiC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,IAAI,CACR,OAAO,EAAE,IAAI,EACb,IAAI,GAAE,eAAoB,GACzB,OAAO,CAAC,kBAAkB,CAAC;IA0B9B;;;;;;;;;;OAUG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA+B5B;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,MAAM,GAAE,eAAe,GAAG,IAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA0CnE,kDAAkD;IAC5C,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAkJ7C"}

package/dist/constants.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The bounds and defaults the client is configured by. Constants only.
+ *
+ * @module
+ */
+/** Default time to wait for a connection to open, in milliseconds. */
+export declare const DEFAULT_CONNECT_TIMEOUT_MS = 10000;
+/** Default time to wait for an acknowledgment after sending, in milliseconds. */
+export declare const DEFAULT_SEND_TIMEOUT_MS = 30000;
+/** Default maximum bytes buffered while receiving one message (16 MiB). */
+export declare const DEFAULT_MAX_BUFFERED_BYTES: number;
+/**
+ * Default number of reconnect attempts after a failed one. With the default
+ * delay, the last one starts about 30 seconds after the first failure.
+ */
+export declare const DEFAULT_RECONNECT_ATTEMPTS = 5;
+/**
+ * Maximum timeout `setTimeout` supports, in milliseconds (2^31 − 1). Larger
+ * values, including `Infinity`, are rejected: the platform would clamp them
+ * to about 1 ms.
+ */
+export declare const MAX_TIMEOUT_MS: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,sEAAsE;AACtE,eAAO,MAAM,0BAA0B,QAAS,CAAC;AAEjD,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C,2EAA2E;AAC3E,eAAO,MAAM,0BAA0B,QAAmB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAc,CAAC"}

package/dist/errors/base.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The base every client error extends, and what each one carries: a fixed
+ * `code`, a fixed message, what became of the message, and the lower layer's
+ * failure on `cause`.
+ *
+ * @module
+ */
+export declare const MllpErrorCode: {
+    readonly CLOSED: "CLOSED";
+    readonly CONNECTION_FAILED: "CONNECTION_FAILED";
+    readonly CONNECTION_LOST: "CONNECTION_LOST";
+    readonly CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT";
+    readonly INVALID_MESSAGE: "INVALID_MESSAGE";
+    readonly INVALID_OPTION: "INVALID_OPTION";
+    readonly INVALID_RESPONSE: "INVALID_RESPONSE";
+    readonly SEND_ABORTED: "SEND_ABORTED";
+    readonly SEND_TIMEOUT: "SEND_TIMEOUT";
+};
+export type MllpErrorCode = (typeof MllpErrorCode)[keyof typeof MllpErrorCode];
+/**
+ * What became of the message. `not-sent`: nothing reached the wire, and the
+ * message may be sent again as it is. `unknown`: it may have reached the
+ * remote system, and sending it again may deliver it twice.
+ */
+export type MllpDelivery = "not-sent" | "unknown";
+export declare abstract class MllpClientError extends Error {
+    abstract readonly code: MllpErrorCode;
+    abstract readonly delivery: MllpDelivery;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/errors/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/errors/base.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;CAUhB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAE/E;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,SAAS,CAAC;AAElD,8BAAsB,eAAgB,SAAQ,KAAK;IACjD,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;CAC1C"}

package/dist/errors/index.d.ts

@@ -0,0 +1,14 @@
+export { MllpClientError, MllpErrorCode } from "./base";
+export type { MllpDelivery } from "./base";
+export { MllpClientClosedError } from "./mllp-client-closed-error";
+export { MllpConnectionFailedError } from "./mllp-connection-failed-error";
+export { MllpConnectionTimeoutError } from "./mllp-connection-timeout-error";
+export { MllpConnectionError } from "./mllp-connection-error";
+export { MllpConnectionLostError } from "./mllp-connection-lost-error";
+export { MllpInvalidMessageError } from "./mllp-invalid-message-error";
+export { MllpInvalidOptionError } from "./mllp-invalid-option-error";
+export { MllpInvalidResponseError } from "./mllp-invalid-response-error";
+export { nakException } from "./nak-exception";
+export { MllpSendAbortedError } from "./mllp-send-aborted-error";
+export { MllpSendTimeoutError } from "./mllp-send-timeout-error";
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACxD,YAAY,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/errors/mllp-client-closed-error.d.ts

@@ -0,0 +1,12 @@
+import { MllpClientError } from "./base";
+/**
+ * The call cannot be served: the client is closed, by `close()`, by
+ * `destroy()`, or by a failure. The failure is on `cause`.
+ */
+export declare class MllpClientClosedError extends MllpClientError {
+    readonly name = "MllpClientClosedError";
+    readonly code: "CLOSED";
+    readonly delivery = "not-sent";
+    constructor(cause?: MllpClientError | null);
+}
+//# sourceMappingURL=mllp-client-closed-error.d.ts.map

package/dist/errors/mllp-client-closed-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-client-closed-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-client-closed-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiB,MAAM,QAAQ,CAAC;AAExD;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,eAAe;IACxD,SAAkB,IAAI,2BAA2B;IACjD,QAAQ,CAAC,IAAI,WAAwB;IACrC,QAAQ,CAAC,QAAQ,cAAc;gBAEnB,KAAK,GAAE,eAAe,GAAG,IAAW;CAQjD"}

package/dist/errors/mllp-connection-error.d.ts

@@ -0,0 +1,9 @@
+import { MllpClientError } from "./base";
+/**
+ * A failure of the wire: the connection could not be opened, gave no reply in
+ * time, or was lost. Raised by the layer that holds the socket; the client
+ * relays it unchanged.
+ */
+export declare abstract class MllpConnectionError extends MllpClientError {
+}
+//# sourceMappingURL=mllp-connection-error.d.ts.map

package/dist/errors/mllp-connection-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-connection-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-connection-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAEzC;;;;GAIG;AACH,8BAAsB,mBAAoB,SAAQ,eAAe;CAAG"}

package/dist/errors/mllp-connection-failed-error.d.ts

@@ -0,0 +1,12 @@
+import { MllpConnectionError } from "./mllp-connection-error";
+/**
+ * The connection could not be opened: the host was unreachable, refused the
+ * connection, or failed DNS or TLS. The socket's error is on `cause`.
+ */
+export declare class MllpConnectionFailedError extends MllpConnectionError {
+    readonly name = "MllpConnectionFailedError";
+    readonly code: "CONNECTION_FAILED";
+    readonly delivery = "not-sent";
+    constructor(cause: unknown);
+}
+//# sourceMappingURL=mllp-connection-failed-error.d.ts.map

package/dist/errors/mllp-connection-failed-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-connection-failed-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-connection-failed-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D;;;GAGG;AACH,qBAAa,yBAA0B,SAAQ,mBAAmB;IAChE,SAAkB,IAAI,+BAA+B;IACrD,QAAQ,CAAC,IAAI,sBAAmC;IAChD,QAAQ,CAAC,QAAQ,cAAc;gBAEnB,KAAK,EAAE,OAAO;CAM3B"}

package/dist/errors/mllp-connection-lost-error.d.ts

@@ -0,0 +1,13 @@
+import { MllpConnectionError } from "./mllp-connection-error";
+/**
+ * The connection was lost during a send: the remote system hung up, or the
+ * network broke. The remote system may or may not have received the message.
+ * A stream error, when there was one, is on `cause`.
+ */
+export declare class MllpConnectionLostError extends MllpConnectionError {
+    readonly name = "MllpConnectionLostError";
+    readonly code: "CONNECTION_LOST";
+    readonly delivery = "unknown";
+    constructor(cause?: unknown);
+}
+//# sourceMappingURL=mllp-connection-lost-error.d.ts.map

package/dist/errors/mllp-connection-lost-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-connection-lost-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-connection-lost-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,mBAAmB;IAC9D,SAAkB,IAAI,6BAA6B;IACnD,QAAQ,CAAC,IAAI,oBAAiC;IAC9C,QAAQ,CAAC,QAAQ,aAAa;gBAElB,KAAK,CAAC,EAAE,OAAO;CAM5B"}

package/dist/errors/mllp-connection-timeout-error.d.ts

@@ -0,0 +1,13 @@
+import { MllpConnectionError } from "./mllp-connection-error";
+/**
+ * The remote system did not accept the connection within `connectTimeoutMs`.
+ * The host may be down, overloaded, or silently dropping packets.
+ */
+export declare class MllpConnectionTimeoutError extends MllpConnectionError {
+    readonly name = "MllpConnectionTimeoutError";
+    readonly code: "CONNECTION_TIMEOUT";
+    readonly delivery = "not-sent";
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+//# sourceMappingURL=mllp-connection-timeout-error.d.ts.map

package/dist/errors/mllp-connection-timeout-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-connection-timeout-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-connection-timeout-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,mBAAmB;IACjE,SAAkB,IAAI,gCAAgC;IACtD,QAAQ,CAAC,IAAI,uBAAoC;IACjD,QAAQ,CAAC,QAAQ,cAAc;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAM9B"}

package/dist/errors/mllp-invalid-message-error.d.ts

@@ -0,0 +1,13 @@
+import { MllpClientError } from "./base";
+/**
+ * The message cannot be sent as-is: it has no MSH-10 control ID, it could not
+ * be serialized, or it contains a byte MLLP reserves. Nothing was written; the
+ * reason is on `cause`. Fix the message and send again.
+ */
+export declare class MllpInvalidMessageError extends MllpClientError {
+    readonly name = "MllpInvalidMessageError";
+    readonly code: "INVALID_MESSAGE";
+    readonly delivery = "not-sent";
+    constructor(cause: unknown);
+}
+//# sourceMappingURL=mllp-invalid-message-error.d.ts.map

package/dist/errors/mllp-invalid-message-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-invalid-message-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-invalid-message-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiB,MAAM,QAAQ,CAAC;AAExD;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,eAAe;IAC1D,SAAkB,IAAI,6BAA6B;IACnD,QAAQ,CAAC,IAAI,oBAAiC;IAC9C,QAAQ,CAAC,QAAQ,cAAc;gBAEnB,KAAK,EAAE,OAAO;CAM3B"}

package/dist/errors/mllp-invalid-option-error.d.ts

@@ -0,0 +1,8 @@
+import { MllpClientError } from "./base";
+/** An option is out of range. Raised before anything happens. */
+export declare class MllpInvalidOptionError extends MllpClientError {
+    readonly name = "MllpInvalidOptionError";
+    readonly code: "INVALID_OPTION";
+    readonly delivery = "not-sent";
+}
+//# sourceMappingURL=mllp-invalid-option-error.d.ts.map

package/dist/errors/mllp-invalid-option-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-invalid-option-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-invalid-option-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiB,MAAM,QAAQ,CAAC;AAExD,iEAAiE;AACjE,qBAAa,sBAAuB,SAAQ,eAAe;IACzD,SAAkB,IAAI,4BAA4B;IAClD,QAAQ,CAAC,IAAI,mBAAgC;IAC7C,QAAQ,CAAC,QAAQ,cAAc;CAChC"}

package/dist/errors/mllp-invalid-response-error.d.ts

@@ -0,0 +1,16 @@
+import { MllpClientError } from "./base";
+/**
+ * The reply was not a usable acknowledgment of the message that was waiting:
+ * it could not be decoded, its acknowledgment code was missing or unknown, or
+ * it answered a different message. The connection is ended. The reason is on
+ * `cause`.
+ */
+export declare class MllpInvalidResponseError extends MllpClientError {
+    readonly name = "MllpInvalidResponseError";
+    readonly code: "INVALID_RESPONSE";
+    readonly delivery = "unknown";
+    /** MSH-10 of the message that was waiting, when the thrower knew it. */
+    readonly controlId?: string;
+    constructor(cause: unknown, controlId?: string);
+}
+//# sourceMappingURL=mllp-invalid-response-error.d.ts.map

package/dist/errors/mllp-invalid-response-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-invalid-response-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-invalid-response-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiB,MAAM,QAAQ,CAAC;AAExD;;;;;GAKG;AACH,qBAAa,wBAAyB,SAAQ,eAAe;IAC3D,SAAkB,IAAI,8BAA8B;IACpD,QAAQ,CAAC,IAAI,qBAAkC;IAC/C,QAAQ,CAAC,QAAQ,aAAa;IAC9B,wEAAwE;IACxE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAEhB,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM;CAO/C"}

package/dist/errors/mllp-send-aborted-error.d.ts

@@ -0,0 +1,12 @@
+import { MllpClientError } from "./base";
+/**
+ * `destroy()` cut off the message in flight. The remote system may or may not
+ * have received it.
+ */
+export declare class MllpSendAbortedError extends MllpClientError {
+    readonly name = "MllpSendAbortedError";
+    readonly code: "SEND_ABORTED";
+    readonly delivery = "unknown";
+    constructor();
+}
+//# sourceMappingURL=mllp-send-aborted-error.d.ts.map

package/dist/errors/mllp-send-aborted-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-send-aborted-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-send-aborted-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiB,MAAM,QAAQ,CAAC;AAExD;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,eAAe;IACvD,SAAkB,IAAI,0BAA0B;IAChD,QAAQ,CAAC,IAAI,iBAA8B;IAC3C,QAAQ,CAAC,QAAQ,aAAa;;CAO/B"}

package/dist/errors/mllp-send-timeout-error.d.ts

@@ -0,0 +1,13 @@
+import { MllpConnectionError } from "./mllp-connection-error";
+/**
+ * No acknowledgment arrived within the send timeout. The connection is ended.
+ * Whether the remote system received the message is unknown.
+ */
+export declare class MllpSendTimeoutError extends MllpConnectionError {
+    readonly name = "MllpSendTimeoutError";
+    readonly code: "SEND_TIMEOUT";
+    readonly delivery = "unknown";
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+//# sourceMappingURL=mllp-send-timeout-error.d.ts.map

package/dist/errors/mllp-send-timeout-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-send-timeout-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-send-timeout-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,mBAAmB;IAC3D,SAAkB,IAAI,0BAA0B;IAChD,QAAQ,CAAC,IAAI,iBAA8B;IAC3C,QAAQ,CAAC,QAAQ,aAAa;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAM9B"}

package/dist/errors/nak-exception.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The exception a NAK carries. Not an {@link MllpClientError}: the remote
+ * system understood the message and refused it, and the class is the one
+ * `@glion/ack` defines for that MSA-1 code.
+ *
+ * @module
+ */
+import type { AckException, AckNakCode } from "@glion/ack";
+import type { Root } from "@glion/ast";
+/**
+ * The exception a NAK of `code` carries, read from `tree`.
+ *
+ * `code` picks the class; MSA-2 gives `controlId`, ERR-3 `errorCode`, ERR-4
+ * `severity`, and MSA-3 (or ERR-8) `text`.
+ */
+export declare function nakException(tree: Root, code: AckNakCode): AckException;
+//# sourceMappingURL=nak-exception.d.ts.map

package/dist/errors/nak-exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nak-exception.d.ts","sourceRoot":"","sources":["../../src/errors/nak-exception.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAE,YAAY,EAAuB,UAAU,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AA8BvC;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,GAAG,YAAY,CASvE"}

package/dist/events.d.ts

@@ -0,0 +1,35 @@
+/**
+ * What a client reports as it runs, and the listeners that receive it.
+ *
+ * @module
+ */
+import type { MllpClientError } from "./errors";
+export interface MllpClientEvents {
+    /** The connection is open and ready for messages. */
+    connect(): void;
+    /**
+     * The connection is down and the client will not connect again. `error` is
+     * the failure that closed it, or `null` when the owner did.
+     */
+    close(error: MllpClientError | null): void;
+}
+/** The name of one thing a client reports. */
+export type MllpClientEvent = keyof MllpClientEvents;
+/** A listener for `event`. */
+export type MllpClientListener<E extends MllpClientEvent> = MllpClientEvents[E];
+/**
+ * The listeners of a client.
+ *
+ * A listener that throws propagates to whoever triggered the event, the same
+ * as Node's `EventEmitter`.
+ */
+export declare abstract class MllpClientEmitter {
+    #private;
+    /** Adds a listener for `event`, and returns the client so calls chain. */
+    on<E extends MllpClientEvent>(event: E, listener: MllpClientListener<E>): this;
+    /** Removes a listener added with {@link on}. */
+    off<E extends MllpClientEvent>(event: E, listener: MllpClientListener<E>): this;
+    /** Calls every listener for `event`, in the order they were added. */
+    protected emit<E extends MllpClientEvent>(event: E, ...args: Parameters<MllpClientEvents[E]>): void;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,OAAO,IAAI,IAAI,CAAC;IAChB;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI,CAAC;CAC5C;AAED,8CAA8C;AAC9C,MAAM,MAAM,eAAe,GAAG,MAAM,gBAAgB,CAAC;AAErD,8BAA8B;AAC9B,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,eAAe,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAEhF;;;;;GAKG;AACH,8BAAsB,iBAAiB;;IAMrC,0EAA0E;IAC1E,EAAE,CAAC,CAAC,SAAS,eAAe,EAC1B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,IAAI;IAOP,gDAAgD;IAChD,GAAG,CAAC,CAAC,SAAS,eAAe,EAC3B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,IAAI;IAKP,sEAAsE;IACtE,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,eAAe,EACtC,KAAK,EAAE,CAAC,EACR,GAAG,IAAI,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GACvC,IAAI;CAKR"}

package/dist/index.d.ts

@@ -1,27 +1,20 @@
 /**
- * Default entry point of `@glion/mllp-client`.
+ * `@glion/mllp-client` — persistent MLLP client for HL7v2.
  *
- * `import { MllpClient } from "@glion/mllp-client"` resolves here on
- * Node and Bun. This module is a thin re-export of
- * `@glion/mllp-client/node` so the common case stays a single
- * import line.
+ * One socket to one remote system, one message on the wire at a time.
+ * `send()` takes a parsed `Root`, writes it, and resolves with the
+ * acknowledgment that answers it. A NAK (`AE`, `AR`, `CE`, `CR`) rejects with
+ * the matching `@glion/ack` exception — the same type the server raises.
  *
- * For other runtimes:
- *
- * - Deno: `@glion/mllp-client/deno`
- * - Cloudflare Workers: `@glion/mllp-client/workers`
- * - Custom transport / browser via a bridge: `@glion/mllp-client/core`
- *
- * Bundlers that honour the `workerd` and `deno` keys in this
- * package's `exports` map will automatically pick the right entry
- * for the target runtime — the per-runtime subpaths are also
- * available as explicit imports for clarity.
+ * Runtime adapters implement {@link MllpSocket}; the Node adapter is in
+ * `@glion/mllp-client/node`.
  *
  * @module
  */
-export type { Acknowledgment } from "./core/acknowledgment";
-export type { MllpConnect, MllpConnectParams, MllpDuplexStream, } from "./core/connect";
-export { MllpClientError, MllpClientErrorCode } from "./core/errors";
-export { MllpClient, nodeConnect } from "./runtimes/node";
-export type { BoundMllpClientOptions, MllpClientOptions, MllpClientTlsOptions, SendMode, SendOptions, } from "./runtimes/node";
+export { MllpClient } from "./client";
+export { MllpClientEmitter } from "./events";
+export type { MllpClientEvent, MllpClientEvents, MllpClientListener, } from "./events";
+export type { MllpClientOptions, MllpClientResponse, MllpClientState, MllpReconnectOptions, MllpSendOptions, MllpSocket, MllpStreams, } from "./types";
+export { MllpClientClosedError, MllpClientError, MllpConnectionError, MllpConnectionFailedError, MllpConnectionLostError, MllpConnectionTimeoutError, MllpErrorCode, MllpInvalidMessageError, MllpInvalidOptionError, MllpInvalidResponseError, MllpSendAbortedError, MllpSendTimeoutError, } from "./errors";
+export type { MllpDelivery } from "./errors";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,YAAY,EACV,WAAW,EACX,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC1D,YAAY,EACV,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,QAAQ,EACR,WAAW,GACZ,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,eAAe,EACf,UAAU,EACV,WAAW,GACZ,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACvB,0BAA0B,EAC1B,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,wBAAwB,EACxB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC"}