@glion/mllp 0.14.1

package/dist/server/types.d.ts

@@ -0,0 +1,139 @@
+import type { Root } from "@glion/ast";
+import type { Processor } from "unified";
+import type { VFile } from "vfile";
+/**
+ * Connection metadata for an MLLP socket.
+ */
+export interface ConnectionInfo {
+    readonly id: number;
+    readonly remoteAddress: string;
+    readonly remotePort: number;
+    readonly localPort: number;
+    readonly secure: boolean;
+    readonly state: Map<string, unknown>;
+}
+/**
+ * MLLP response — a raw HL7v2 string that the server encodes
+ * with MLLP framing before sending back over TCP.
+ *
+ * Acknowledgment helpers (ack/nak) are not built in — register
+ * an acknowledgment middleware via `.use()` to generate ACK/NAK responses.
+ */
+export interface Response {
+    readonly raw: string;
+}
+/**
+ * The MLLP context object.
+ *
+ * Routing fields (messageType, triggerEvent, etc.) are extracted from
+ * the **pre-transform** parsed tree and are always available synchronously.
+ *
+ * The transformed tree, VFile, and compiled result are lazy — they
+ * trigger pipeline stages on first access. See ADR-0013.
+ */
+export interface Context {
+    /** Incoming message data */
+    readonly req: {
+        /** Original HL7 message string (without MLLP framing) */
+        readonly raw: string;
+        /** Raw bytes from MLLP frame payload */
+        readonly bytes: Uint8Array;
+    };
+    /** TCP connection metadata */
+    readonly connection: ConnectionInfo;
+    /**
+     * Parsed AST — always available synchronously. Use this for reading
+     * MSH fields, building ACKs, routing, or any operation that doesn't
+     * need to wait for transforms to complete.
+     *
+     * Note: this is the same object reference as the tree returned by
+     * `tree()`. After `tree()` resolves, transformers may have enriched
+     * it in-place (e.g., decoded escapes, resolved message structure).
+     * The routing fields (messageType, triggerEvent, etc.) are cached
+     * as separate string properties and always reflect the original
+     * wire values regardless of transforms.
+     */
+    readonly ast: Root;
+    /**
+     * Transformed AST. Triggers `run()` (transformers) on first call.
+     * Cached after first access — subsequent calls return the same tree.
+     */
+    tree(): Promise<Root>;
+    /**
+     * VFile with diagnostics and lint messages. Created during context
+     * creation. Diagnostics accumulate after `tree()` triggers transformers.
+     */
+    file: VFile;
+    /**
+     * Compiled result from the processor's compiler (e.g., JSON from
+     * hl7v2Jsonify). Triggers both `run()` and `stringify()` on first call.
+     * Undefined when the processor has no compiler.
+     * Cached after first access.
+     */
+    result(): Promise<unknown | undefined>;
+    /** Response to send back. Set by middleware or handler. */
+    res: Response | undefined;
+    /** MSH-9.1 message type (e.g., "ADT") — from pre-transform parse */
+    messageType: string;
+    /** MSH-9.2 trigger event (e.g., "A01") — from pre-transform parse */
+    triggerEvent: string;
+    /** MSH-9.3 message structure (e.g., "ADT_A01") — from pre-transform parse */
+    messageStructure: string;
+    /** MSH-12 version (e.g., "2.5.1") — from pre-transform parse */
+    version: string;
+    /** MSH-10 message control ID — from pre-transform parse */
+    controlId: string;
+    /** Store a variable */
+    set<K extends string>(key: K, value: unknown): void;
+    /** Retrieve a variable */
+    get<K extends string>(key: K): unknown;
+    /** Read-only snapshot of all variables */
+    readonly var: Readonly<Record<string, unknown>>;
+}
+/**
+ * A unified `Processor` that parses HL7v2 messages into `Root` trees.
+ *
+ * Only `ParseTree` is constrained — the remaining type params are left
+ * loose so that any processor built with `unified().use(hl7v2Parser)`
+ * is assignable regardless of which transformer/compiler plugins are added.
+ */
+export type Hl7v2Processor = Processor<Root, Root, Root>;
+/**
+ * Middleware function signature (Hono/Koa onion model).
+ */
+export type MiddlewareReturn = Promise<Response | undefined | void> | Promise<void> | Response | undefined | void;
+export type Middleware = (ctx: Context, next: () => Promise<void>) => MiddlewareReturn;
+/**
+ * Terminal route handler — may return a response or void (no response).
+ */
+export type Handler = (ctx: Context) => Promise<Response | undefined | void> | Response | undefined | void;
+/**
+ * Error handler — receives the error and context, returns a response.
+ */
+export type ErrorHandler = (err: Error, ctx: Context) => Promise<Response | undefined | void> | Response | undefined | void;
+/**
+ * A filter function for route or middleware matching.
+ * Receives the full context and returns true if the route/middleware applies.
+ */
+export type RouteFilter = (ctx: Context) => boolean;
+/**
+ * Parsed route pattern for matching against incoming messages.
+ */
+export interface RoutePattern {
+    /** Original pattern string (e.g., "ADT^A01") */
+    readonly source: string;
+    /** Message type to match, or "*" for wildcard */
+    readonly messageType: string;
+    /** Trigger event to match, or "*" for wildcard */
+    readonly triggerEvent: string;
+}
+/**
+ * Parse a pattern string like "ADT^A01", "ADT^*", "*^A01", or "*"
+ * into a structured RoutePattern.
+ */
+export declare function parsePattern(pattern: string): RoutePattern;
+/**
+ * Test whether a route pattern matches a given message type and trigger event.
+ */
+export declare function matchPattern(pattern: RoutePattern, messageType: string, triggerEvent: string): boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/server/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/server/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEnC;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB,4BAA4B;IAC5B,QAAQ,CAAC,GAAG,EAAE;QACZ,yDAAyD;QACzD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,wCAAwC;QACxC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;KAC5B,CAAC;IAEF,8BAA8B;IAC9B,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IAEpC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;IAEnB;;;OAGG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtB;;;OAGG;IACH,IAAI,EAAE,KAAK,CAAC;IAEZ;;;;;OAKG;IACH,MAAM,IAAI,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;IAEvC,2DAA2D;IAC3D,GAAG,EAAE,QAAQ,GAAG,SAAS,CAAC;IAE1B,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;IACrB,6EAA6E;IAC7E,gBAAgB,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAElB,uBAAuB;IACvB,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IACpD,0BAA0B;IAC1B,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IACvC,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACjD;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAEzD;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAExB,OAAO,CAAC,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,GACb,QAAQ,GACR,SAAS,GAET,IAAI,CAAC;AAET,MAAM,MAAM,UAAU,GAAG,CACvB,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KACtB,gBAAgB,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,CACpB,GAAG,EAAE,OAAO,KAET,OAAO,CAAC,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC,GAAG,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC;AAExE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CACzB,GAAG,EAAE,KAAK,EACV,GAAG,EAAE,OAAO,KAET,OAAO,CAAC,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC,GAAG,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC;AAExE;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,kDAAkD;IAClD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAe1D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GACnB,OAAO,CAMT"}

package/dist/transport/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * MLLP Start Byte - Vertical Tab (VT)
+ * Marks the beginning of an MLLP frame
+ */
+export declare const MLLP_START_BYTE = 11;
+/**
+ * MLLP End Byte 1 - File Separator (FS)
+ * First byte of the end sequence
+ */
+export declare const MLLP_END_BYTE_1 = 28;
+/**
+ * MLLP End Byte 2 - Carriage Return (CR)
+ * Second byte of the end sequence
+ */
+export declare const MLLP_END_BYTE_2 = 13;
+/**
+ * MLLP header as a Uint8Array containing the start byte
+ */
+export declare const MLLP_HEADER: Uint8Array<ArrayBuffer>;
+/**
+ * MLLP trailer as a Uint8Array containing the end sequence
+ */
+export declare const MLLP_TRAILER: Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/transport/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/transport/constants.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,eAAO,MAAM,eAAe,KAAO,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,eAAe,KAAO,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,eAAe,KAAO,CAAC;AAMpC;;GAEG;AACH,eAAO,MAAM,WAAW,yBAAoC,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,YAAY,yBAAqD,CAAC"}

package/dist/transport/decoder-stream.d.ts

@@ -0,0 +1,49 @@
+import type { DecodedMessage, DecoderOptions } from "./types";
+/**
+ * Create a `TransformStream` that extracts MLLP messages from a raw
+ * byte stream.
+ *
+ * Pipe a TCP socket's `ReadableStream<Uint8Array>` through this stream
+ * to receive one {@link DecodedMessage} per MLLP frame, regardless of
+ * how the bytes are chunked on the wire.
+ *
+ * @example
+ *   ```typescript
+ *   import { createDecoderStream } from "@glion/mllp";
+ *
+ *   const decoder = createDecoderStream({
+ *     maxMessageSize: 1024 * 1024, // 1 MB limit
+ *     onError: (err) => log.warn(err), // custom error handler
+ *   });
+ *
+ *   const messages = socket.readable.pipeThrough(decoder).getReader();
+ *
+ *   while (true) {
+ *     const { done, value } = await messages.read();
+ *     if (done) break;
+ *     console.log(value.text); // HL7v2 message string
+ *   }
+ *   ```;
+ *
+ * @param options - Optional decoder settings (max size, encoding, error
+ *   handler).
+ * @returns A `TransformStream<Uint8Array, DecodedMessage>`.
+ */
+export declare function createDecoderStream(options?: DecoderOptions): TransformStream<Uint8Array, DecodedMessage>;
+/**
+ * Class-based variant of {@link createDecoderStream} for cases where
+ * a reusable instance is preferred over the factory function.
+ *
+ * Functionally identical — both delegate to the same internal
+ * transformer.
+ *
+ * @example
+ *   ```typescript
+ *   const decoder = new MLLPDecoderStream({ maxMessageSize: 512_000 });
+ *   socket.readable.pipeThrough(decoder);
+ *   ```;
+ */
+export declare class MLLPDecoderStream extends TransformStream<Uint8Array, DecodedMessage> {
+    constructor(options?: DecoderOptions);
+}
+//# sourceMappingURL=decoder-stream.d.ts.map

package/dist/transport/decoder-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder-stream.d.ts","sourceRoot":"","sources":["../../src/transport/decoder-stream.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AA0W9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,CAAC,EAAE,cAAc,GACvB,eAAe,CAAC,UAAU,EAAE,cAAc,CAAC,CAE7C;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAkB,SAAQ,eAAe,CACpD,UAAU,EACV,cAAc,CACf;gBACa,OAAO,CAAC,EAAE,cAAc;CAGrC"}

package/dist/transport/decoder.d.ts

@@ -0,0 +1,18 @@
+import type { DecodedMessage, DecoderOptions } from "./types";
+/**
+ * Decode a single MLLP frame (VT ... FS CR) into a message.
+ *
+ * Validates framing, strips the envelope, and returns the payload as
+ * both raw bytes and decoded text. Throws {@link TransportError} on
+ * any structural issue.
+ *
+ * For streaming / chunked TCP data, use {@link createDecoderStream} instead.
+ *
+ * @throws TransportError with `INVALID_START_BYTE` if byte 0 is not 0x0B
+ * @throws TransportError with `INVALID_END_SEQUENCE` if frame doesn't end with
+ *   0x1C 0x0D
+ * @throws TransportError with `MESSAGE_TOO_LARGE` if payload exceeds
+ *   `maxMessageSize`
+ */
+export declare function decode(frame: Uint8Array, options?: DecoderOptions): DecodedMessage;
+//# sourceMappingURL=decoder.d.ts.map

package/dist/transport/decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../src/transport/decoder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE,UAAU,EACjB,OAAO,CAAC,EAAE,cAAc,GACvB,cAAc,CAiDhB"}

package/dist/transport/dynamic-buffer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A growable byte buffer with geometric capacity doubling.
+ *
+ * Designed for protocol decoders that accumulate bytes from arbitrarily
+ * chunked TCP streams. Amortizes copy cost to O(n) total — the same
+ * strategy used by pg-protocol, NATS.js, and Java's ArrayList.
+ *
+ * The buffer maintains a read offset so consumed bytes can be skipped
+ * without shifting data. When the wasted prefix exceeds half the
+ * capacity, the buffer auto-compacts by shifting remaining bytes to
+ * the front.
+ *
+ * @internal
+ */
+export declare class DynamicBuffer {
+    private _buffer;
+    private _length;
+    private _offset;
+    constructor(initialCapacity?: number);
+    get capacity(): number;
+    get available(): number;
+    append(chunk: Uint8Array): void;
+    view(): Uint8Array;
+    consume(n: number): void;
+    reset(): void;
+    private _compact;
+}
+//# sourceMappingURL=dynamic-buffer.d.ts.map

package/dist/transport/dynamic-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-buffer.d.ts","sourceRoot":"","sources":["../../src/transport/dynamic-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;gBAER,eAAe,SAAO;IAIlC,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAY/B,IAAI,IAAI,UAAU;IAIlB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAYxB,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,QAAQ;CAMjB"}

package/dist/transport/encoder.d.ts

@@ -0,0 +1,14 @@
+import type { EncoderInput, EncoderOptions } from "./types";
+/**
+ * Encode a single HL7v2 message into an MLLP frame.
+ *
+ * Wraps the message with MLLP framing:
+ * - Start byte: 0x0B (VT)
+ * - End sequence: 0x1C 0x0D (FS + CR)
+ */
+export declare function encode(message: EncoderInput, _options?: EncoderOptions): Uint8Array;
+/**
+ * Encode multiple HL7v2 messages into concatenated MLLP frames.
+ */
+export declare function encodeMultiple(messages: EncoderInput[], options?: EncoderOptions): Uint8Array;
+//# sourceMappingURL=encoder.d.ts.map

package/dist/transport/encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../src/transport/encoder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAK5D;;;;;;GAMG;AACH,wBAAgB,MAAM,CACpB,OAAO,EAAE,YAAY,EACrB,QAAQ,CAAC,EAAE,cAAc,GACxB,UAAU,CAWZ;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,YAAY,EAAE,EACxB,OAAO,CAAC,EAAE,cAAc,GACvB,UAAU,CAaZ"}

package/dist/transport/errors.d.ts

@@ -0,0 +1,13 @@
+import { MllpError } from "../errors";
+import type { TransportErrorCode } from "./types";
+/**
+ * Transport-level error for MLLP framing issues (invalid framing, incomplete
+ * messages, etc.)
+ */
+export declare class TransportError extends MllpError {
+    readonly code: TransportErrorCode;
+    /** Position in the data where the error occurred (if applicable) */
+    readonly position?: number;
+    constructor(code: TransportErrorCode, message: string, position?: number);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/transport/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC3C,SAAiB,IAAI,EAAE,kBAAkB,CAAC;IAC1C,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;gBAEf,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAKzE"}

package/dist/transport/index.d.ts

@@ -0,0 +1,8 @@
+export { MLLP_END_BYTE_1, MLLP_END_BYTE_2, MLLP_HEADER, MLLP_START_BYTE, MLLP_TRAILER, } from "./constants";
+export { decode } from "./decoder";
+export { createDecoderStream, MLLPDecoderStream } from "./decoder-stream";
+export { encode, encodeMultiple } from "./encoder";
+export { TransportError } from "./errors";
+export { TransportErrorCode as ErrorCode } from "./types";
+export type { DecodedMessage, DecoderOptions, EncoderInput, EncoderOptions, } from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,eAAe,EACf,WAAW,EACX,eAAe,EACf,YAAY,GACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,kBAAkB,IAAI,SAAS,EAAE,MAAM,SAAS,CAAC;AAC1D,YAAY,EACV,cAAc,EACd,cAAc,EACd,YAAY,EACZ,cAAc,GACf,MAAM,SAAS,CAAC"}

package/dist/transport/types.d.ts

@@ -0,0 +1,49 @@
+import type { TransportError } from "./errors";
+/**
+ * Input types for encoding - supports both string and binary
+ */
+export type EncoderInput = string | Uint8Array;
+/**
+ * Decoded message result from MLLP frame
+ */
+export interface DecodedMessage {
+    /** The raw message payload (without MLLP framing) */
+    data: Uint8Array;
+    /** Message decoded as string (convenience) */
+    text: string;
+    /** Byte length of the original message */
+    byteLength: number;
+}
+/**
+ * Options for the MLLP encoder
+ */
+export interface EncoderOptions {
+    /** Encoding for string input (default: 'utf-8') */
+    encoding?: string;
+}
+/**
+ * Options for the MLLP decoder
+ */
+export interface DecoderOptions {
+    /** Maximum message size in bytes (optional, no default limit) */
+    maxMessageSize?: number;
+    /** Encoding for text conversion (default: 'utf-8') */
+    encoding?: string;
+    /** Error callback for logging/handling errors */
+    onError?: (error: TransportError) => void;
+}
+/**
+ * Error codes for MLLP frame-level errors
+ */
+export declare const TransportErrorCode: {
+    /** Stream ended with incomplete MLLP message */
+    readonly INCOMPLETE_MESSAGE: "INCOMPLETE_MESSAGE";
+    /** Frame does not end with MLLP end sequence (0x1C 0x0D) */
+    readonly INVALID_END_SEQUENCE: "INVALID_END_SEQUENCE";
+    /** Frame does not start with MLLP start byte (0x0B) */
+    readonly INVALID_START_BYTE: "INVALID_START_BYTE";
+    /** Message exceeds configured maximum size */
+    readonly MESSAGE_TOO_LARGE: "MESSAGE_TOO_LARGE";
+};
+export type TransportErrorCode = (typeof TransportErrorCode)[keyof typeof TransportErrorCode];
+//# sourceMappingURL=types.d.ts.map

package/dist/transport/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/transport/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,qDAAqD;IACrD,IAAI,EAAE,UAAU,CAAC;IACjB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;CAC3C;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,gDAAgD;;IAEhD,4DAA4D;;IAE5D,uDAAuD;;IAEvD,8CAA8C;;CAEtC,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAC5B,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@glion/mllp",
+  "version": "0.14.1",
+  "description": "Transport-agnostic MLLP (Minimal Lower Layer Protocol) engine for HL7v2 messaging",
+  "keywords": [
+    "health",
+    "healthcare",
+    "hl7",
+    "hl7v2",
+    "mllp",
+    "nodejs",
+    "streaming",
+    "typescript"
+  ],
+  "homepage": "https://glion.dev",
+  "license": "MIT",
+  "author": {
+    "name": "Melek Somai",
+    "email": "melek@rethinkhealth.io"
+  },
+  "repository": "rethinkhealth/glion.git",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "unified": "11.0.5",
+    "vfile": "6.0.3",
+    "@glion/ast": "0.14.1",
+    "@glion/parser": "0.14.1",
+    "@glion/util-query": "0.14.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@vitest/coverage-v8": "4.1.2",
+    "tsdown": "0.21.7",
+    "typescript": "^5.9.3",
+    "vitest": "4.1.2",
+    "@glion/hl7v2": "0.14.1",
+    "@glion/tsconfig": "0.0.1",
+    "@glion/testing": "0.0.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsdown && tsc --emitDeclarationOnly",
+    "check-types": "tsc --noEmit",
+    "bench": "vitest bench --run",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest"
+  }
+}