@glion/mllp-client 0.19.0 → 0.20.0

package/README.md

@@ -1,16 +1,14 @@
 # @glion/mllp-client
 
-A simple HL7v2 MLLP client for Node.js and Cloudflare Workers.
+An HL7v2 MLLP client for Node.js, Bun, Deno, and Cloudflare Workers.
 
 - 📦 **MLLP built in.** Framing, message boundaries and acknowledgment matching are handled. You send a parsed message and get one back.
 - 🔄 **Predictable connection lifecycle.** Timeouts on connecting and on waiting for a reply, connection attempts retried with backoff, TCP keepalive by default, and explicit states you can read.
-- ⚡ **Thin over TCP.** One socket, one message at a time. No queue, no worker threads, no polling.
+- ⚡ **Thin over TCP.** One socket, one message on the wire at a time. Further sends queue in call order. No worker threads, no polling.
 - 🧯 **Errors you can act on.** Every failure carries a stable code and says whether the connection is still usable.
-- 🧩 **Any transport.** TCP included. TLS, Cloudflare Workers or an in-memory socket plug in behind it.
+- 🧩 **Any transport.** TCP and TLS on Node.js, Bun, Deno, and Cloudflare Workers included. An in-memory or custom socket plugs in behind the same two-method interface.
 - 🔤 **Typed end to end.** TypeScript throughout, with parsed HL7v2 going in and coming out.
 
-> **Coming soon** — TLS and Cloudflare Workers adapters. Today the only bundled adapter is Node.js over TCP.
-
 ## Install
 
 ```bash
@@ -171,22 +169,23 @@ Sends one message and resolves with the acknowledgment that answers it. Connects
 - `AckException` — the receiver refused the message. The connection stays open.
 - `MllpInvalidMessageError` — no MSH-10, or the message could not be serialized. Nothing was sent.
 - `MllpInvalidOptionError` — `timeoutMs` is out of range. Nothing was sent.
-- `MllpAlreadySendingError` — another send is in flight.
-- `MllpClientClosedError` — the client is closed.
+- `MllpClientClosedError` — the client is closed, or closed while this send was waiting its turn.
 - `MllpConnectionFailedError`, `MllpConnectionTimeoutError` — the connection could not be opened.
 - `MllpSendTimeoutError`, `MllpConnectionLostError`, `MllpInvalidResponseError` — the exchange failed. These close the connection; see [Errors](#errors).
+- `MllpSendAbortedError` — `destroy()` cut the send off. Delivery is unknown.
 
 Every error carries `delivery`, `not-sent` or `unknown`, the one fact a retry needs; see [Errors](#errors).
 
-One message at a time. To send several, await each in turn:
+One message is on the wire at a time. A `send()` arriving while another is in flight waits its turn, and sends go out in the order they were called, so a batch may be fired at once:
 
 ```ts
-for (const message of batch) {
-  const ack = await client.send(message);
-  record(ack.controlId, ack.code);
-}
+const outcomes = await Promise.allSettled(
+  batch.map((message) => client.send(message))
+);
 ```
 
+The queue is in memory and has no bound. `timeoutMs` runs from the moment the write starts, not from the call. A send still waiting when `close()` or `destroy()` is called, or when a failure closes the client, rejects at once with `delivery: "not-sent"`: with `MllpClientClosedError`, or with the failure itself when the failure is one of not being sent, such as the dial's `MllpConnectionFailedError` or `MllpConnectionTimeoutError`, as `connect()` gets. Nothing behind a failed message goes out. See [Does `send()` queue?](#does-send-queue).
+
 ### `client.connect()`
 
 ```ts
@@ -197,7 +196,7 @@ Opens the connection without sending anything, dialing again under the [reconnec
 
 Idempotent. On a connected client it resolves at once; while an attempt is in flight it waits for the outcome and shares it.
 
-**Throws** the last attempt's `MllpConnectionFailedError` or `MllpConnectionTimeoutError`, or `MllpClientClosedError` when the client is already closed or `close()` cancelled the attempt.
+**Throws** the last attempt's `MllpConnectionFailedError` or `MllpConnectionTimeoutError`, or `MllpClientClosedError` when the client is already closed or `close()` or `destroy()` cancelled the attempt.
 
 ### `client.close()`
 
@@ -205,9 +204,9 @@ Idempotent. On a connected client it resolves at once; while an attempt is in fl
 close(): Promise<void>
 ```
 
-Closes the connection once the message in flight has been acknowledged. New sends are refused from the moment it is called, so an in-flight message is never cut off. An attempt to connect stops at once.
+Closes the connection once the message in flight has been acknowledged. New sends, and sends still waiting their turn, are refused from the moment it is called with `MllpClientClosedError`; the message in flight is never cut off. Await the sends you want delivered before calling it. An attempt to connect stops at once.
 
-Resolves when the connection is down, from any phase. Never throws. Idempotent. The wait is bounded by the in-flight send's own deadline.
+Resolves when the connection is down, from any phase. Never throws. Idempotent. The wait is bounded by the in-flight send's own deadline. If the message it waits for fails, the client closes with that failure; otherwise with `null`, the owner's decision.
 
 ```ts
 process.on("SIGTERM", async () => {
@@ -216,13 +215,13 @@ process.on("SIGTERM", async () => {
 });
 ```
 
-### `client.destroy()`
+### `client.destroy(reason?)`
 
 ```ts
-destroy(): Promise<void>
+destroy(reason?: MllpClientError | null): Promise<void>
 ```
 
-Closes the connection now, without waiting for anything in flight. A message in flight rejects with `MllpSendAbortedError`. An attempt to connect stops at once.
+Closes the connection now, without waiting for anything in flight. A message in flight rejects with `MllpSendAbortedError`. An attempt to connect stops at once. The client closes with `reason`: the `close` event carries it, and so does `cause` on every later call's `MllpClientClosedError`. Omitted or `null`, the client closed by its owner's decision, as `net.Socket.destroy(error)` does. Sends waiting their turn are rejected with `reason` itself when its delivery is `not-sent`, and with `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.
 
 Resolves when the connection is down, from any phase. Never throws. Idempotent.
 
@@ -243,17 +242,25 @@ Calls `close()`. Lets a client be scoped with `await using`:
 readonly state: MllpClientState
 ```
 
-| Value        | Meaning                                                                     |
-| ------------ | --------------------------------------------------------------------------- |
-| `idle`       | Nothing opened yet. The first `send()` or `connect()` opens the connection. |
-| `connecting` | The connection is being opened, further attempts included.                  |
-| `connected`  | Open, with no message in flight.                                            |
-| `sending`    | A message is on the wire, waiting for its acknowledgment.                   |
-| `closing`    | `close()` is waiting out the message in flight.                             |
-| `closed`     | Done.                                                                       |
+| Value        | Meaning                                                                          |
+| ------------ | -------------------------------------------------------------------------------- |
+| `idle`       | Nothing opened yet. The first `send()` or `connect()` opens the connection.      |
+| `connecting` | The connection is being opened, further attempts included.                       |
+| `connected`  | Open, with no message in flight.                                                 |
+| `sending`    | A message is on the wire, waiting for its acknowledgment. Further sends wait.    |
+| `closing`    | The client is ending: a message being waited out, or the connection coming down. |
+| `closed`     | The connection is down.                                                          |
 
 A client closes once. After `close()`, `destroy()`, a connection the reconnect policy could not open, or a connection that was lost, every call throws `MllpClientClosedError`; construct a new client to send again.
 
+### `client.pending`
+
+```ts
+readonly pending: number
+```
+
+How many sends wait their turn, the one in flight excluded. The queue's backlog, for a metric or a backpressure decision; `0` whenever nothing waits.
+
 ### `client.connected`
 
 ```ts
@@ -271,10 +278,10 @@ off<E>(event: E, listener: MllpClientListener<E>): this
 
 Adds or removes a listener. Both return the client, so calls chain.
 
-| Event     | Listener                                   | Fires when                                                                                                                                                  |
-| --------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `connect` | `() => void`                               | The connection opened.                                                                                                                                      |
-| `close`   | `(error: MllpClientError \| null) => void` | The client is done. Fires once, from any phase, even if it never connected. `error` is the failure it could not recover from, or `null` when you closed it. |
+| Event     | Listener                                   | Fires when                                                                                                                                                   |
+| --------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `connect` | `() => void`                               | The connection opened.                                                                                                                                       |
+| `close`   | `(error: MllpClientError \| null) => void` | The connection is down. Fires once, from any phase, even if it never connected. `error` is the failure that closed the client, or `null` when you closed it. |
 
 A lost connection is not an event of its own: it closes the client, so `close` fires with the failure. Listeners are synchronous, and one that throws propagates to whatever triggered the event.
 
@@ -288,9 +295,16 @@ client
 
 ## Runtimes
 
-The client speaks MLLP over a pair of byte streams and knows nothing else about the transport. That whole dependency is [`MllpSocket`](#custom-socket) — two methods — so supporting a new runtime means writing an adapter, not forking the client.
+The client speaks MLLP over a pair of byte streams and knows nothing else about the transport. That whole dependency is [`MllpSocket`](#custom-socket) — two methods — so supporting a runtime means an adapter, not a fork of the client.
 
-Node.js is the only adapter that ships today.
+| Runtime            | Adapter                                | Import                       | TLS                                         | Proven by                                                                                                                               |
+| ------------------ | -------------------------------------- | ---------------------------- | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| Node.js ≥ 22       | [`nodeSocket`](#nodejs)                | `@glion/mllp-client/node`    | [Trust store, CA, client certificate](#tls) | Conformance suite in CI, Node 22 and 24                                                                                                 |
+| Bun                | [`nodeSocket`](#nodejs)                | `@glion/mllp-client/node`    | [Trust store, CA, client certificate](#tls) | Conformance suite in CI, Bun 1.4                                                                                                        |
+| Deno               | [`nodeSocket`](#nodejs)                | `@glion/mllp-client/node`    | [Trust store, CA, client certificate](#tls) | Conformance suite in CI, Deno 2.9                                                                                                       |
+| Cloudflare Workers | [`workersSocket`](#cloudflare-workers) | `@glion/mllp-client/workers` | Public trust store only                     | Integration suite in CI, inside `workerd`; TCP only, TLS handshake untested ([#626](https://github.com/rethinkhealth/glion/issues/626)) |
+
+Every adapter runs the same conformance suite: the [`MllpSocket` contract](#custom-socket) case by case, and the client's behaviour over a real socket scenario by scenario. On Node.js, Bun, and Deno it runs twice, over TCP and over TLS. A custom socket can run it too; see `tests/integration/conformance/` in the package source.
 
 ### Node.js
 
@@ -300,16 +314,17 @@ import { nodeSocket } from "@glion/mllp-client/node";
 nodeSocket(options: NodeSocketOptions): MllpSocket
 ```
 
-Plain TCP over `net.Socket`.
+TCP over `net.Socket`, or TLS over `tls.TLSSocket` when `tls` is set. The same adapter runs on Bun and Deno through their `node:net` and `node:tls` compatibility; no separate import is needed there.
 
-| Option            | Type     | Default  | Description                                                                                                 |
-| ----------------- | -------- | -------- | ----------------------------------------------------------------------------------------------------------- |
-| `host`            | `string` | required | Host name or address of the receiver.                                                                       |
-| `port`            | `number` | required | TCP port of the receiver.                                                                                   |
-| `gracefulCloseMs` | `number` | `1000`   | How long a socket gets to end cleanly before it is destroyed.                                               |
-| `keepAliveIdleMs` | `number` | `30000`  | Idle time before the first keepalive probe, so a silent NAT or firewall drop surfaces before the next send. |
+| Option            | Type                        | Default  | Description                                                                                                                                                                              |
+| ----------------- | --------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `host`            | `string`                    | required | Host name or address of the receiver.                                                                                                                                                    |
+| `port`            | `number`                    | required | TCP port of the receiver.                                                                                                                                                                |
+| `tls`             | `boolean \| NodeTlsOptions` | `false`  | TLS for the connection. See [TLS](#tls).                                                                                                                                                 |
+| `gracefulCloseMs` | `number`                    | `1000`   | How long a socket gets to end cleanly before it is destroyed.                                                                                                                            |
+| `keepAliveIdleMs` | `number`                    | `30000`  | Idle time before the first keepalive probe. Once the probes fail, the OS ends the socket, and the next send fails at once with `CONNECTION_LOST` instead of waiting out `sendTimeoutMs`. |
 
-`TCP_NODELAY` is set, so a message goes out immediately rather than waiting on Nagle's algorithm.
+`TCP_NODELAY` is set, so a message goes out immediately rather than waiting on Nagle's algorithm. On Bun and Deno the keepalive delay is passed through to the runtime; whether the runtime honours it is not verified.
 
 ```ts
 const client = new MllpClient({
@@ -317,6 +332,91 @@ const client = new MllpClient({
 });
 ```
 
+Deno needs `--allow-net` for the receiver's host and port.
+
+#### TLS
+
+`tls: true` verifies the receiver's certificate against the runtime's trusted CAs, for `host`, and needs no certificate files. `host` is sent as the server name (SNI) unless it is an IP address.
+
+```ts
+nodeSocket({ host: "hl7.example.org", port: 2575, tls: true });
+```
+
+An object passes Node's `tls.connect()` options:
+
+| Option               | Type                        | Default                      | Description                                                                                      |
+| -------------------- | --------------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------ |
+| `ca`                 | `string \| Buffer \| Array` | Runtime CAs                  | CA certificates that issued the receiver's certificate, PEM. Replaces the runtime's trusted CAs. |
+| `cert`               | `string \| Buffer \| Array` | none                         | Client certificate chain for mutual TLS, PEM.                                                    |
+| `key`                | `string \| Buffer \| Array` | none                         | Private key for `cert`, PEM.                                                                     |
+| `passphrase`         | `string`                    | none                         | Passphrase for an encrypted `key` or `pfx`.                                                      |
+| `pfx`                | `string \| Buffer \| Array` | none                         | Client certificate and key as PKCS#12.                                                           |
+| `servername`         | `string`                    | `host`, unless an IP address | Name the receiver's certificate is verified against, and the SNI name.                           |
+| `rejectUnauthorized` | `boolean`                   | `true`                       | `false` accepts any certificate, including one presented by an attacker.                         |
+
+```ts
+import { readFileSync } from "node:fs";
+
+nodeSocket({
+  host: "10.20.0.15",
+  port: 2575,
+  tls: {
+    ca: readFileSync("hospital-ca.pem"),
+    cert: readFileSync("client.pem"),
+    key: readFileSync("client-key.pem"),
+    servername: "hl7.hospital.internal",
+  },
+});
+```
+
+A receiver dialed by IP address must present a certificate that lists that address, or `servername` must name one the certificate lists.
+
+A handshake that fails rejects with [`CONNECTION_FAILED`](#connection_failed), with Node's TLS error on `cause`: for example `UNABLE_TO_VERIFY_LEAF_SIGNATURE` or `ERR_TLS_CERT_ALTNAME_INVALID`.
+
+A receiver that refuses the client certificate over TLS 1.2 fails the handshake: [`CONNECTION_FAILED`](#connection_failed), nothing sent. Over TLS 1.3 it refuses after the handshake, so the connection opens and the first `send()` rejects with `CONNECTION_LOST`, delivery `unknown`.
+
+On Deno, a wrong `passphrase` does not fail the handshake; the connection opens without the client certificate and fails as a refused client certificate.
+
+### Cloudflare Workers
+
+```ts
+import { workersSocket } from "@glion/mllp-client/workers";
+
+workersSocket(options: WorkersSocketOptions): MllpSocket
+```
+
+TCP or TLS over `cloudflare:sockets`. The module resolves only inside the Workers runtime; import it from the `./workers` subpath, never from `.`.
+
+| Option | Type      | Default  | Description                                                                                   |
+| ------ | --------- | -------- | --------------------------------------------------------------------------------------------- |
+| `host` | `string`  | required | Host name or address of the receiver.                                                         |
+| `port` | `number`  | required | TCP port of the receiver.                                                                     |
+| `tls`  | `boolean` | `false`  | `true` verifies the receiver's certificate against the public CAs Workers trusts, for `host`. |
+
+```ts
+import { MllpClient } from "@glion/mllp-client";
+import { workersSocket } from "@glion/mllp-client/workers";
+
+export default {
+  async fetch(request: Request): Promise<Response> {
+    await using client = new MllpClient({
+      socket: workersSocket({ host: "hl7.example.org", port: 2575 }),
+    });
+    const ack = await client.send(await messageFrom(request));
+    return Response.json({ code: ack.code, controlId: ack.controlId });
+  },
+};
+```
+
+What differs from Node:
+
+- A Worker reaches only endpoints routable from Cloudflare's network. A receiver on a private network needs a publicly reachable endpoint in front of it.
+- `close()` resolves as soon as the runtime has ended the socket; there is no grace window.
+- Locally, under Miniflare (`wrangler dev` or the Vitest integration), connections go through a proxy, so `MllpConnectionFailedError.cause` carries the proxy's message rather than a socket error code. `code` is the same in both.
+- Locally, under Miniflare, a `tls: true` connection fails with the proxy's message, whatever certificate the receiver presents. TLS to a receiver works only when the Worker runs on Cloudflare.
+- Cloudflare blocks some destination ports.
+- `tls` takes no CA, client certificate, or server name. The receiver must present a publicly trusted certificate for `host`, so dial a host name rather than an address. Any value other than a boolean throws `MllpInvalidOptionError`.
+
 ### Custom Socket
 
 You can expand `MllpSocket` to build a custom socket to one remote system, which the client opens, uses, and ends.
@@ -350,10 +450,10 @@ A rejection from the receiver is **not** an `MllpClientError` — see [`AckExcep
 
 `delivery` is the one fact a retry decision needs:
 
-| `delivery` | Meaning                                                                           | Codes                                                                                                       |
-| ---------- | --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| `not-sent` | Nothing reached the wire. The message may be sent again as it is.                 | `INVALID_OPTION`, `INVALID_MESSAGE`, `ALREADY_SENDING`, `CLOSED`, `CONNECTION_FAILED`, `CONNECTION_TIMEOUT` |
-| `unknown`  | The message may have reached the receiver. Sending it again may deliver it twice. | `SEND_TIMEOUT`, `CONNECTION_LOST`, `SEND_ABORTED`, `INVALID_RESPONSE`                                       |
+| `delivery` | Meaning                                                                           | Codes                                                                                    |
+| ---------- | --------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `not-sent` | Nothing reached the wire. The message may be sent again as it is.                 | `INVALID_OPTION`, `INVALID_MESSAGE`, `CLOSED`, `CONNECTION_FAILED`, `CONNECTION_TIMEOUT` |
+| `unknown`  | The message may have reached the receiver. Sending it again may deliver it twice. | `SEND_TIMEOUT`, `CONNECTION_LOST`, `SEND_ABORTED`, `INVALID_RESPONSE`                    |
 
 ```ts
 import { MllpClientError, MllpErrorCode } from "@glion/mllp-client";
@@ -381,7 +481,7 @@ The four failures of the wire — `CONNECTION_FAILED`, `CONNECTION_TIMEOUT`, `SE
 
 `MllpInvalidOptionError` · delivery `not-sent`
 
-A constructor option or a per-send `timeoutMs` is out of range — a timeout that is not a positive number of milliseconds, a `maxBufferedBytes` that is not a positive integer, or a `reconnect.attempts` that is not a non-negative integer or `Infinity`. The message names which one.
+A constructor option or a per-send `timeoutMs` is out of range — a timeout that is not a positive number of milliseconds, a `maxBufferedBytes` that is not a positive integer, or a `reconnect.attempts` that is not a non-negative integer or `Infinity`. `workersSocket()` also throws it for a `tls` that is not a boolean. The message names which one.
 
 Thrown before anything is opened or sent. A configuration bug, not a runtime condition.
 
@@ -393,29 +493,21 @@ The message cannot be sent as it stands: no MSH-10 control ID, or it could not b
 
 **Nothing reached the wire and the connection is still in step**, so the next message can go out on it. Fix or quarantine the message; do not reconnect.
 
-### `ALREADY_SENDING`
-
-`MllpAlreadySendingError` · delivery `not-sent` · field: `controlId`
-
-`send()` was called while another send was in flight. `controlId` identifies the message already on the wire.
-
-The client is lockstep by design. Await each send before starting the next, or give each concurrent stream its own client.
-
 ### `CLOSED`
 
 `MllpClientClosedError` · delivery `not-sent` · field: `cause`
 
-The client is closed, so the call cannot be served. Also the error a `connect()` gets when `close()` cancelled the attempt it was waiting for.
+The client is closed or closing, so the call cannot be served. Also the error a `connect()` gets when `close()` or `destroy()` cancelled the attempt it was waiting for, and the error a `send()` gets when the client closed while it was waiting its turn; a send waiting behind a dial that failed gets the dial's error instead.
 
-A client closes once. Construct a new one to send again. When the client closed because the reconnect policy gave up, `cause` is the last attempt's failure.
+A client closes once. Construct a new one to send again. When the client closed on a failure, `cause` is that failure: the last attempt's `CONNECTION_FAILED` or `CONNECTION_TIMEOUT` when the reconnect policy gave up, the `CONNECTION_LOST`, `SEND_TIMEOUT`, or `INVALID_RESPONSE` that ended an earlier message, including one `close()` was waiting out, or the `reason` given to `destroy()`.
 
 ### `CONNECTION_FAILED`
 
 `MllpConnectionFailedError` · delivery `not-sent` · field: `cause`
 
-The socket could not be opened. `cause` carries the underlying error — `ECONNREFUSED`, `ENOTFOUND`, `EHOSTUNREACH` and the like.
+The socket could not be opened. `cause` carries the underlying error — `ECONNREFUSED`, `ENOTFOUND`, `EHOSTUNREACH`, or a TLS error such as `UNABLE_TO_VERIFY_LEAF_SIGNATURE`.
 
-Check host, port, and whether a firewall allows the route. Nothing was opened, so there is nothing to close.
+Check host, port, whether a firewall allows the route, and, over TLS, the certificate the receiver presents. Nothing was opened, so there is nothing to close.
 
 ### `CONNECTION_TIMEOUT`
 
@@ -423,7 +515,7 @@ Check host, port, and whether a firewall allows the route. Nothing was opened, s
 
 The receiver did not accept the connection within `connectTimeoutMs`.
 
-Typically a packet-dropping firewall rather than a refused connection — a refusal arrives fast and surfaces as `CONNECTION_FAILED`.
+Typically a packet-dropping firewall rather than a refused connection — a refusal arrives fast and surfaces as `CONNECTION_FAILED`. With `tls` set, also a receiver that speaks plain TCP and never answers the TLS handshake.
 
 ### `SEND_TIMEOUT`
 
@@ -489,6 +581,12 @@ Clients that pipeline can survive a timeout, because they keep a table of outsta
 
 The client closes with the failure, and never sends the failed message again — only you know whether the receiver already has it. Construct a new client to go on, as you would open a new socket.
 
+### Does `send()` queue?
+
+Yes, in memory and without a bound. A `send()` arriving while a message is on the wire waits for that message's acknowledgment, then goes out; sends leave in the order they were called, one at a time, so an A01 fired before its A03 reaches the receiver first. Nothing goes out behind a message whose delivery is unknown: a failure closes the client, and every send still waiting rejects with `CLOSED` and `delivery: "not-sent"`. A send waiting behind a dial that fails rejects with the dial's error, as `connect()` does.
+
+The queue exists only in this process. A message waiting in it is not on disk, so a crash loses it without a trace, and a producer faster than the receiver grows it without limit. An interface that must not lose events keeps its own persistent outbound queue and hands the client one message at a time; the client's line is for a batch whose outcomes the caller is awaiting.
+
 ### Why a socket rather than a host and port?
 
 The client handles MLLP and deliberately handles no transport. Putting the whole runtime dependency behind two methods means the same client runs over TCP, TLS, a Unix socket, or a pair of in-memory streams — and the test suite covers every lifecycle path without opening a port.

package/dist/assertions.d.ts

@@ -1,10 +1,17 @@
 /**
- * Option validation. Each `assert*` throws {@link MllpInvalidOptionError} for
- * an option a caller passed out of range, before anything happens.
+ * 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

@@ -1 +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"}
+{"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

@@ -1,13 +1,15 @@
 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 sends one message at a time. `send()` writes
- * the message, waits for the acknowledgment, checks that it answers this
- * message, and resolves with it.
+ * 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";
@@ -47,6 +49,8 @@ export declare class MllpClient extends MllpClientEmitter {
      * `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;
     /**
@@ -59,23 +63,30 @@ export declare class MllpClient extends MllpClientEmitter {
      * @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.
+     * @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.
+     * 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 other failure also closes the client.
+     * 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.
-     * @throws {MllpAlreadySendingError} Another send is in flight.
+     * @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.
@@ -87,21 +98,29 @@ export declare class MllpClient extends MllpClientEmitter {
     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 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.
+     * 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.
+     * 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(): Promise<void>;
+    destroy(reason?: MllpClientError | null): Promise<void>;
     /** Calls {@link close}. Enables `await using`. */
     [Symbol.asyncDispose](): Promise<void>;
 }

package/dist/client.d.ts.map

@@ -1 +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"}
+{"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/errors/base.d.ts

@@ -6,7 +6,6 @@
  * @module
  */
 export declare const MllpErrorCode: {
-    readonly ALREADY_SENDING: "ALREADY_SENDING";
     readonly CLOSED: "CLOSED";
     readonly CONNECTION_FAILED: "CONNECTION_FAILED";
     readonly CONNECTION_LOST: "CONNECTION_LOST";

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

@@ -1 +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"}
+{"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

@@ -1,4 +1,3 @@
-export { MllpAlreadySendingError } from "./mllp-already-sending-error";
 export { MllpClientError, MllpErrorCode } from "./base";
 export type { MllpDelivery } from "./base";
 export { MllpClientClosedError } from "./mllp-client-closed-error";

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

@@ -1 +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"}
+{"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

@@ -1,8 +1,7 @@
 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`.
+ * `destroy()`, or by a failure. The failure is on `cause`.
  */
 export declare class MllpClientClosedError extends MllpClientError {
     readonly name = "MllpClientClosedError";

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

@@ -1 +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"}
+{"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/events.d.ts

@@ -8,8 +8,8 @@ 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.
+     * 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;
 }

package/dist/index.d.ts

@@ -15,6 +15,6 @@ 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 { 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;;;;;;;;;;;;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"}
+{"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"}