@glion/mllp-client 0.16.0 → 0.19.0

package/dist/assertions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Option validation. Each `assert*` throws {@link MllpInvalidOptionError} for
+ * an option a caller passed out of range, before anything happens.
+ *
+ * @module
+ */
+export declare function assertTimeoutMs(option: string, ms: number): void;
+export declare function assertByteCap(bytes: number): void;
+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;;;;;GAKG;AAKH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAMhE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMjD;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAO9D"}

package/dist/client.d.ts

@@ -0,0 +1,108 @@
+import type { Root } from "@glion/ast";
+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 sends one message at a time. `send()` writes
+ * the message, waits for the acknowledgment, checks that it answers this
+ * message, and resolves with it.
+ *
+ * ```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;
+    /** 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()` 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.
+     *
+     * Nothing is written when an option, phase, or message error is thrown.
+     * Every other failure also closes the client.
+     *
+     * @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.
+     * @throws {MllpAlreadySendingError} Another send is in flight.
+     * @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 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.
+     */
+    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.
+     *
+     * Resolves from any phase. Never rejects. Idempotent.
+     */
+    destroy(): 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;AAsBvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAO7C,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,eAAe,EAEhB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,UAAW,SAAQ,iBAAiB;;IAO/C;;;OAGG;gBACS,IAAI,EAAE,iBAAiB;IA0BnC;;;OAGG;IACH,IAAI,KAAK,IAAI,eAAe,CAE3B;IAED,8EAA8E;IAC9E,IAAI,SAAS,IAAI,OAAO,CAGvB;IAED;;;;;;;;;;;;OAYG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B9B;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,IAAI,CACR,OAAO,EAAE,IAAI,EACb,IAAI,GAAE,eAAoB,GACzB,OAAO,CAAC,kBAAkB,CAAC;IA2C9B;;;;;;;OAOG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;;;;;OAMG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB9B,kDAAkD;IAC5C,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAmK7C"}

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,31 @@
+/**
+ * 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 ALREADY_SENDING: "ALREADY_SENDING";
+    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;;;;;;;;;;;CAWhB,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,15 @@
+export { MllpAlreadySendingError } from "./mllp-already-sending-error";
+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,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,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-already-sending-error.d.ts

@@ -0,0 +1,14 @@
+import { MllpClientError } from "./base";
+/**
+ * `send()` was called while another message was still waiting for its
+ * acknowledgment. The client sends one message at a time.
+ */
+export declare class MllpAlreadySendingError extends MllpClientError {
+    readonly name = "MllpAlreadySendingError";
+    readonly code: "ALREADY_SENDING";
+    readonly delivery = "not-sent";
+    /** MSH-10 of the message that is still waiting. */
+    readonly controlId: string;
+    constructor(controlId: string);
+}
+//# sourceMappingURL=mllp-already-sending-error.d.ts.map

package/dist/errors/mllp-already-sending-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mllp-already-sending-error.d.ts","sourceRoot":"","sources":["../../src/errors/mllp-already-sending-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiB,MAAM,QAAQ,CAAC;AAExD;;;GAGG;AACH,qBAAa,uBAAwB,SAAQ,eAAe;IAC1D,SAAkB,IAAI,6BAA6B;IACnD,QAAQ,CAAC,IAAI,oBAAiC;IAC9C,QAAQ,CAAC,QAAQ,cAAc;IAC/B,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAM9B"}

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

@@ -0,0 +1,13 @@
+import { MllpClientError } from "./base";
+/**
+ * The call cannot be served: the client is closed, by `close()`, by
+ * `destroy()`, or by a lost connection the reconnect policy did not restore.
+ * That last 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;;;;GAIG;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 client is done and will not connect again. `error` is the failure the
+     * reconnect policy did not recover from, or `null` when it closes normally.
+     */
+    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 { MllpAlreadySendingError, 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,uBAAuB,EACvB,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"}