@cosyte/mllp 0.0.1

package/dist/testing/index.mjs

@@ -0,0 +1,241 @@
+// src/testing/in-memory-transport.ts
+var InMemoryTransport = class _InMemoryTransport {
+  _peer = null;
+  _onDataFn = null;
+  _onConnectFn = null;
+  _onCloseFn = null;
+  _onErrorFn = null;
+  _destroyed = false;
+  _paused = false;
+  _splitBytes = 0;
+  _pendingChunks = [];
+  _writeDepth = 0;
+  constructor() {
+  }
+  /**
+   * Create two connected InMemoryTransport ends.
+   *
+   * Writes to `a` deliver to `b`'s `onData` handler synchronously (and vice versa).
+   * Call `a.simulateConnect()` after `pair()` to fire the `onConnect` handler,
+   * simulating TCP connect completion.
+   *
+   * @returns Tuple `[a, b]` of two connected transports.
+   *
+   * @example
+   * ```typescript
+   * const [a, b] = InMemoryTransport.pair();
+   * b.onData((chunk) => b.write(chunk)); // echo server
+   * a.write(Buffer.from([0x0b, 0x41, 0x1c, 0x0d]));
+   * ```
+   */
+  static pair() {
+    const a = new _InMemoryTransport();
+    const b = new _InMemoryTransport();
+    a._peer = b;
+    b._peer = a;
+    return [a, b];
+  }
+  /**
+   * Write `buf` to the peer transport.
+   *
+   * If the peer is paused, the buffer is copied and queued — returns `false`
+   * (backpressure signal). Otherwise, the peer's `onData` handler fires
+   * synchronously before this method returns.
+   *
+   * @returns `true` if delivered immediately; `false` if queued or transport is destroyed.
+   */
+  write(buf) {
+    if (this._destroyed) return false;
+    const peer = this._peer;
+    if (peer === null || peer._destroyed) return false;
+    if (peer._paused) {
+      peer._pendingChunks.push(Buffer.from(buf));
+      return false;
+    }
+    peer._deliverChunk(buf);
+    return true;
+  }
+  /**
+   * Initiate graceful close — fires `onClose` on this end and on the peer,
+   * simulating a TCP FIN exchange.
+   */
+  close() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    if (this._onCloseFn !== null) {
+      try {
+        this._onCloseFn();
+      } catch {
+      }
+    }
+    const peer = this._peer;
+    if (peer !== null && !peer._destroyed) {
+      peer._destroyed = true;
+      if (peer._onCloseFn !== null) {
+        try {
+          peer._onCloseFn();
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Abruptly destroy this transport end.
+   *
+   * Fires `onError(reason)` then `onClose` on this end only. Does NOT affect
+   * the peer (simulates one-sided abrupt disconnect, e.g., ECONNRESET on
+   * just one socket).
+   *
+   * @param reason - Optional error; defaults to `new Error('InMemoryTransport destroyed')`.
+   */
+  destroy(reason) {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    const err = reason ?? new Error("InMemoryTransport destroyed");
+    if (this._onErrorFn !== null) {
+      try {
+        this._onErrorFn(err);
+      } catch {
+      }
+    }
+    if (this._onCloseFn !== null) {
+      try {
+        this._onCloseFn();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Register the data handler. Replaces any previously registered handler.
+   *
+   * @param fn - Called with each chunk delivered by the peer.
+   */
+  onData(fn) {
+    this._onDataFn = fn;
+  }
+  /**
+   * Register the connect handler. Replaces any previously registered handler.
+   * Use `simulateConnect()` to trigger this in tests.
+   *
+   * @param fn - Called when `simulateConnect()` is invoked on this end.
+   */
+  onConnect(fn) {
+    this._onConnectFn = fn;
+  }
+  /**
+   * Register the close handler. Replaces any previously registered handler.
+   *
+   * @param fn - Called when `close()` or `destroy()` is invoked on this end,
+   *   or when the peer calls `close()`.
+   */
+  onClose(fn) {
+    this._onCloseFn = fn;
+  }
+  /**
+   * Register the error handler. Replaces any previously registered handler.
+   *
+   * @param fn - Called when `destroy(reason)` is invoked on this end.
+   */
+  onError(fn) {
+    this._onErrorFn = fn;
+  }
+  /**
+   * Simulate chunked TCP reads.
+   *
+   * After calling `split(n)`, any `write()` directed at this transport will be
+   * delivered to the `onData` handler in chunks of `n` bytes rather than
+   * all at once. Useful for verifying that a `FrameReader` reassembles frames
+   * correctly across chunk boundaries.
+   *
+   * @param bytesPerChunk - Chunk size in bytes. Pass `0` to disable chunking.
+   *
+   * @example
+   * ```typescript
+   * const [a, b] = InMemoryTransport.pair();
+   * b.split(1); // b receives one byte at a time
+   * a.write(Buffer.from([0x0b, 0x41, 0x1c, 0x0d])); // fires b.onData 4 times
+   * ```
+   */
+  split(bytesPerChunk) {
+    this._splitBytes = bytesPerChunk;
+  }
+  /**
+   * Pause delivery.
+   *
+   * While paused, writes directed at this transport are queued internally and
+   * the `onData` handler is NOT called. The queued chunks are flushed on `resume()`.
+   *
+   * @example
+   * ```typescript
+   * b.pause();
+   * a.write(buf); // queued, b.onData not called
+   * b.resume();   // flushes queue synchronously
+   * ```
+   */
+  pause() {
+    this._paused = true;
+  }
+  /**
+   * Resume delivery — flushes all queued chunks to the `onData` handler,
+   * synchronously, in the order they were written.
+   */
+  resume() {
+    this._paused = false;
+    const pending = this._pendingChunks.splice(0);
+    for (const chunk of pending) {
+      this._deliverChunk(chunk);
+    }
+  }
+  /**
+   * Fire the `onConnect` handler on this end.
+   *
+   * Call after `pair()` to simulate TCP connect completion. In production code,
+   * `NetTransport` fires the handler automatically when the socket emits `'connect'`.
+   *
+   * @example
+   * ```typescript
+   * const [a] = InMemoryTransport.pair();
+   * a.onConnect(() => console.log('connected'));
+   * a.simulateConnect(); // fires immediately
+   * ```
+   */
+  simulateConnect() {
+    if (this._onConnectFn !== null) {
+      try {
+        this._onConnectFn();
+      } catch {
+      }
+    }
+  }
+  _deliverChunk(buf) {
+    if (this._onDataFn === null) return;
+    if (this._writeDepth > 0) {
+      throw new Error("InMemoryTransport: re-entrant write detected");
+    }
+    if (this._splitBytes > 0) {
+      let offset = 0;
+      while (offset < buf.length) {
+        const end = Math.min(offset + this._splitBytes, buf.length);
+        const chunk = buf.subarray(offset, end);
+        this._writeDepth++;
+        try {
+          this._onDataFn(chunk);
+        } finally {
+          this._writeDepth--;
+        }
+        offset = end;
+      }
+    } else {
+      this._writeDepth++;
+      try {
+        this._onDataFn(buf);
+      } finally {
+        this._writeDepth--;
+      }
+    }
+  }
+};
+
+export { InMemoryTransport };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/testing/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/testing/in-memory-transport.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * InMemoryTransport — deterministic, socket-free Transport for tests.\n *\n * Two connected ends are created via `InMemoryTransport.pair()`.\n * Writes to end A fire end B's registered `onData` handler **synchronously**\n * before `write()` returns — no async ceremony, no `await` in tests.\n *\n * @example\n * ```typescript\n * import { InMemoryTransport } from '@cosyte/mllp/testing';\n * const [a, b] = InMemoryTransport.pair();\n * b.onData((chunk) => console.log('received:', chunk));\n * a.write(Buffer.from([0x0b, 0x41, 0x1c, 0x0d]));\n * // b's onData fired synchronously — log printed before this line\n * ```\n *\n * @packageDocumentation\n */\n\nimport type { Transport } from \"../transport/index.js\";\n\n/**\n * Deterministic in-memory transport for socket-free tests.\n *\n * Create connected pairs with `InMemoryTransport.pair()`. Writes to one end\n * deliver synchronously to the other end's `onData` handler — no async ceremony,\n * no `await` needed in tests.\n *\n * Supports `split(n)` for chunked-read simulation, `pause()`/`resume()` for\n * backpressure simulation, and `destroy(reason)` for abrupt-disconnect simulation.\n *\n * @example\n * ```typescript\n * const [client, server] = InMemoryTransport.pair();\n * server.onData((chunk) => server.write(chunk)); // echo\n * client.onData((echo) => console.log('echo:', echo));\n * client.write(Buffer.from('hello'));\n * ```\n */\nexport class InMemoryTransport implements Transport {\n  private _peer: InMemoryTransport | null = null;\n\n  private _onDataFn: ((chunk: Buffer) => void) | null = null;\n  private _onConnectFn: (() => void) | null = null;\n  private _onCloseFn: (() => void) | null = null;\n  private _onErrorFn: ((err: Error) => void) | null = null;\n\n  private _destroyed = false;\n  private _paused = false;\n  private _splitBytes = 0;\n  private _pendingChunks: Buffer[] = [];\n  private _writeDepth = 0;\n\n  private constructor() {}\n\n  /**\n   * Create two connected InMemoryTransport ends.\n   *\n   * Writes to `a` deliver to `b`'s `onData` handler synchronously (and vice versa).\n   * Call `a.simulateConnect()` after `pair()` to fire the `onConnect` handler,\n   * simulating TCP connect completion.\n   *\n   * @returns Tuple `[a, b]` of two connected transports.\n   *\n   * @example\n   * ```typescript\n   * const [a, b] = InMemoryTransport.pair();\n   * b.onData((chunk) => b.write(chunk)); // echo server\n   * a.write(Buffer.from([0x0b, 0x41, 0x1c, 0x0d]));\n   * ```\n   */\n  static pair(): [InMemoryTransport, InMemoryTransport] {\n    const a = new InMemoryTransport();\n    const b = new InMemoryTransport();\n    a._peer = b;\n    b._peer = a;\n    return [a, b];\n  }\n\n  /**\n   * Write `buf` to the peer transport.\n   *\n   * If the peer is paused, the buffer is copied and queued — returns `false`\n   * (backpressure signal). Otherwise, the peer's `onData` handler fires\n   * synchronously before this method returns.\n   *\n   * @returns `true` if delivered immediately; `false` if queued or transport is destroyed.\n   */\n  write(buf: Buffer): boolean {\n    if (this._destroyed) return false;\n    const peer = this._peer;\n    if (peer === null || peer._destroyed) return false;\n\n    if (peer._paused) {\n      // Queue a copy — caller may reuse buf after write() returns (T-03-02-02)\n      peer._pendingChunks.push(Buffer.from(buf));\n      return false;\n    }\n\n    peer._deliverChunk(buf);\n    return true;\n  }\n\n  /**\n   * Initiate graceful close — fires `onClose` on this end and on the peer,\n   * simulating a TCP FIN exchange.\n   */\n  close(): void {\n    if (this._destroyed) return;\n    this._destroyed = true;\n    // Fire onClose on this end\n    if (this._onCloseFn !== null) {\n      try {\n        this._onCloseFn();\n      } catch {\n        /* swallow — test handlers must not break transport logic */\n      }\n    }\n    // Simulate peer receiving FIN — fire peer's onClose\n    const peer = this._peer;\n    if (peer !== null && !peer._destroyed) {\n      peer._destroyed = true;\n      if (peer._onCloseFn !== null) {\n        try {\n          peer._onCloseFn();\n        } catch {\n          /* swallow */\n        }\n      }\n    }\n  }\n\n  /**\n   * Abruptly destroy this transport end.\n   *\n   * Fires `onError(reason)` then `onClose` on this end only. Does NOT affect\n   * the peer (simulates one-sided abrupt disconnect, e.g., ECONNRESET on\n   * just one socket).\n   *\n   * @param reason - Optional error; defaults to `new Error('InMemoryTransport destroyed')`.\n   */\n  destroy(reason?: Error): void {\n    if (this._destroyed) return;\n    this._destroyed = true;\n    const err = reason ?? new Error(\"InMemoryTransport destroyed\");\n    if (this._onErrorFn !== null) {\n      try {\n        this._onErrorFn(err);\n      } catch {\n        /* swallow */\n      }\n    }\n    if (this._onCloseFn !== null) {\n      try {\n        this._onCloseFn();\n      } catch {\n        /* swallow */\n      }\n    }\n  }\n\n  /**\n   * Register the data handler. Replaces any previously registered handler.\n   *\n   * @param fn - Called with each chunk delivered by the peer.\n   */\n  onData(fn: (chunk: Buffer) => void): void {\n    this._onDataFn = fn;\n  }\n\n  /**\n   * Register the connect handler. Replaces any previously registered handler.\n   * Use `simulateConnect()` to trigger this in tests.\n   *\n   * @param fn - Called when `simulateConnect()` is invoked on this end.\n   */\n  onConnect(fn: () => void): void {\n    this._onConnectFn = fn;\n  }\n\n  /**\n   * Register the close handler. Replaces any previously registered handler.\n   *\n   * @param fn - Called when `close()` or `destroy()` is invoked on this end,\n   *   or when the peer calls `close()`.\n   */\n  onClose(fn: () => void): void {\n    this._onCloseFn = fn;\n  }\n\n  /**\n   * Register the error handler. Replaces any previously registered handler.\n   *\n   * @param fn - Called when `destroy(reason)` is invoked on this end.\n   */\n  onError(fn: (err: Error) => void): void {\n    this._onErrorFn = fn;\n  }\n\n  /**\n   * Simulate chunked TCP reads.\n   *\n   * After calling `split(n)`, any `write()` directed at this transport will be\n   * delivered to the `onData` handler in chunks of `n` bytes rather than\n   * all at once. Useful for verifying that a `FrameReader` reassembles frames\n   * correctly across chunk boundaries.\n   *\n   * @param bytesPerChunk - Chunk size in bytes. Pass `0` to disable chunking.\n   *\n   * @example\n   * ```typescript\n   * const [a, b] = InMemoryTransport.pair();\n   * b.split(1); // b receives one byte at a time\n   * a.write(Buffer.from([0x0b, 0x41, 0x1c, 0x0d])); // fires b.onData 4 times\n   * ```\n   */\n  split(bytesPerChunk: number): void {\n    this._splitBytes = bytesPerChunk;\n  }\n\n  /**\n   * Pause delivery.\n   *\n   * While paused, writes directed at this transport are queued internally and\n   * the `onData` handler is NOT called. The queued chunks are flushed on `resume()`.\n   *\n   * @example\n   * ```typescript\n   * b.pause();\n   * a.write(buf); // queued, b.onData not called\n   * b.resume();   // flushes queue synchronously\n   * ```\n   */\n  pause(): void {\n    this._paused = true;\n  }\n\n  /**\n   * Resume delivery — flushes all queued chunks to the `onData` handler,\n   * synchronously, in the order they were written.\n   */\n  resume(): void {\n    this._paused = false;\n    const pending = this._pendingChunks.splice(0);\n    for (const chunk of pending) {\n      this._deliverChunk(chunk);\n    }\n  }\n\n  /**\n   * Fire the `onConnect` handler on this end.\n   *\n   * Call after `pair()` to simulate TCP connect completion. In production code,\n   * `NetTransport` fires the handler automatically when the socket emits `'connect'`.\n   *\n   * @example\n   * ```typescript\n   * const [a] = InMemoryTransport.pair();\n   * a.onConnect(() => console.log('connected'));\n   * a.simulateConnect(); // fires immediately\n   * ```\n   */\n  simulateConnect(): void {\n    if (this._onConnectFn !== null) {\n      try {\n        this._onConnectFn();\n      } catch {\n        /* swallow */\n      }\n    }\n  }\n\n  private _deliverChunk(buf: Buffer): void {\n    if (this._onDataFn === null) return;\n\n    // Re-entrancy guard (D-03): writing from inside an onData handler would cause\n    // infinite recursion or corrupt frame ordering. Detect and throw.\n    if (this._writeDepth > 0) {\n      throw new Error(\"InMemoryTransport: re-entrant write detected\");\n    }\n\n    if (this._splitBytes > 0) {\n      let offset = 0;\n      while (offset < buf.length) {\n        const end = Math.min(offset + this._splitBytes, buf.length);\n        const chunk = buf.subarray(offset, end);\n        this._writeDepth++;\n        try {\n          this._onDataFn(chunk);\n        } finally {\n          this._writeDepth--;\n        }\n        offset = end;\n      }\n    } else {\n      this._writeDepth++;\n      try {\n        this._onDataFn(buf);\n      } finally {\n        this._writeDepth--;\n      }\n    }\n  }\n}\n"]}

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "@cosyte/mllp",
+  "version": "0.0.1",
+  "description": "Production-grade MLLP client and server for Node.js — transport-only sibling to @cosyte/hl7",
+  "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "license": "MIT",
+  "author": "Cosyte <hello@cosyte.com> (https://cosyte.com)",
+  "homepage": "https://github.com/cosyte/mllp#readme",
+  "bugs": {
+    "url": "https://github.com/cosyte/mllp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cosyte/mllp.git"
+  },
+  "keywords": [
+    "hl7",
+    "mllp",
+    "healthcare",
+    "hl7v2",
+    "tcp"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./testing": {
+      "import": {
+        "types": "./dist/testing/index.d.ts",
+        "default": "./dist/testing/index.mjs"
+      },
+      "require": {
+        "types": "./dist/testing/index.d.cts",
+        "default": "./dist/testing/index.cjs"
+      }
+    },
+    "./ack-from-hl7": {
+      "import": {
+        "types": "./dist/ack-from-hl7/index.d.ts",
+        "default": "./dist/ack-from-hl7/index.mjs"
+      },
+      "require": {
+        "types": "./dist/ack-from-hl7/index.d.cts",
+        "default": "./dist/ack-from-hl7/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "prettier": "@cosyte/prettier-config",
+  "peerDependencies": {
+    "@cosyte/hl7": ">=0.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@cosyte/hl7": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.4",
+    "@changesets/cli": "2.31.0",
+    "@cosyte/eslint-config": "^0.0.3",
+    "@cosyte/hl7": "file:vendor/cosyte-hl7-0.0.0.tgz",
+    "@cosyte/prettier-config": "^0.0.2",
+    "@cosyte/test-utils": "^0.0.1",
+    "@cosyte/tsconfig": "^0.0.2",
+    "@cosyte/tsup-config": "^0.0.1",
+    "@cosyte/vitest-config": "^0.0.1",
+    "@types/node": "^22.0.0",
+    "@types/node-forge": "1.3.14",
+    "@vitest/coverage-v8": "4.1.4",
+    "eslint": "10.5.0",
+    "fast-check": "3.23.2",
+    "node-forge": "1.4.0",
+    "prettier": "3.8.3",
+    "selfsigned": "2.4.1",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "vite": "7.3.6",
+    "vitest": "4.1.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "changeset": "changeset",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\" --max-warnings=0",
+    "lint:fix": "eslint \"src/**/*.ts\" \"test/**/*.ts\" --fix",
+    "format": "prettier --write \"src/**/*.{ts,md}\" \"test/**/*.ts\" \"*.{json,md,yml}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,md}\" \"test/**/*.ts\" \"*.{json,md,yml}\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "certs:gen": "node scripts/generate-test-certs.mjs",
+    "clean": "rm -rf dist coverage",
+    "attw": "attw --pack . --profile node16",
+    "pack:docs": "bash scripts/build-docs-artifacts.sh",
+    "version": "changeset version && node scripts/sync-version.mjs && prettier --write package.json src/index.ts",
+    "publish:dry": "pnpm publish --dry-run --no-git-checks",
+    "release": "changeset publish"
+  }
+}