postal-transport-uds 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-Present Jim Cowart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# postal-transport-uds
+
+Unix domain socket transport for [postal](https://github.com/postaljs/postal.js) — bridges pub/sub across independent Node.js processes via a UDS with NDJSON framing. Any process can connect to a known socket path; no parent/child relationship required.
+
+## Installation
+
+```bash
+npm install postal postal-transport-uds
+```
+
+## Usage
+
+### Server
+
+One process listens on a socket path and accepts connections from any number of clients:
+
+```ts
+import { getChannel } from "postal";
+import { listenOnSocket } from "postal-transport-uds";
+
+const { dispose } = await listenOnSocket("/tmp/postal.sock");
+
+// Messages published here are forwarded to all connected clients
+getChannel("jobs").publish("task.start", { id: 1 });
+
+// Tear down when done
+dispose();
+```
+
+### Client
+
+Other processes connect to the server's socket path:
+
+```ts
+import { getChannel } from "postal";
+import { connectToSocket } from "postal-transport-uds";
+
+const removeTransport = await connectToSocket("/tmp/postal.sock", {
+    onDisconnect: () => {
+        console.log("Server went away");
+    },
+});
+
+getChannel("jobs").subscribe("task.start", env => {
+    console.log("Got task:", env.payload);
+});
+
+// Disconnect when done
+removeTransport();
+```
+
+### Filtering
+
+Restrict which envelopes the server forwards:
+
+```ts
+const { dispose } = await listenOnSocket("/tmp/postal.sock", {
+    filter: {
+        channels: ["jobs"],
+        topics: ["task.#"],
+    },
+});
+```
+
+### Low-level transport
+
+If you manage the socket and handshake yourself, use the low-level factory:
+
+```ts
+import { createSocketTransport } from "postal-transport-uds";
+import { addTransport } from "postal";
+
+const transport = createSocketTransport(myConnectedSocket);
+addTransport(transport);
+```
+
+## API
+
+### `listenOnSocket(socketPath, options?)`
+
+Creates a `net.Server` on the given Unix domain socket path. For each connecting client, performs a SYN/ACK handshake and registers a transport with postal. Returns `Promise<{ dispose }>`.
+
+### `connectToSocket(socketPath, options?)`
+
+Connects to a postal UDS server. Performs a SYN/ACK handshake and registers a transport. Returns `Promise<() => void>` (the remove function).
+
+### `createSocketTransport(socket, serializer?)`
+
+Low-level factory. Wraps any object with `write()`, `on('data')`, and `removeListener('data')` in a postal `Transport`. Handles NDJSON framing, buffering, and dispatch. Does not own the socket lifecycle.
+
+### Options
+
+| Option         | Type              | Default | Used by        | Description                                  |
+| -------------- | ----------------- | ------- | -------------- | -------------------------------------------- |
+| `timeout`      | `number`          | `5000`  | server, client | Handshake timeout in milliseconds            |
+| `filter`       | `TransportFilter` | —       | server         | Restrict forwarded channels/topics           |
+| `unlinkStale`  | `boolean`         | `true`  | server         | Unlink existing socket file before listening |
+| `onDisconnect` | `() => void`      | —       | client         | Called on unexpected socket close            |
+
+## How It Works
+
+- **Topology**: Hub-and-spoke. One server, N clients. The server registers each client as a separate transport; postal's core `broadcastToTransports()` handles fan-out and echo prevention via the `source` field.
+- **Wire format**: NDJSON — `JSON.stringify(message) + "\n"`. Self-delimiting, debuggable with `socat`/`netcat`, zero dependencies.
+- **Handshake**: Client sends `{ type: "postal:uds-syn" }`, server responds with `{ type: "postal:uds-ack" }`. Both happen over the same NDJSON stream as envelopes.
+- **Serialization**: Abstracted behind a `Serializer` interface (`encode`/`decode`). The default is NDJSON; swap in MessagePack or similar without restructuring the transport.
+
+## Known Limitations
+
+- **Binary payloads**: NDJSON uses JSON serialization. `Buffer` and `ArrayBuffer` values would need base64 encoding. Acceptable for typical pub/sub payloads.
+- **No auto-reconnection**: The transport exposes `onDisconnect`; the consumer decides what to do. Reconnection policy (backoff, retries, state reconciliation) is a userland concern.
+- **Single-user socket**: The socket file inherits default permissions. All connecting processes must run as the same OS user (or adjust permissions manually).
+- **Node.js only**: Uses `node:net` and `node:fs`. Not available in browsers.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,394 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_net = require("node:net");
+node_net = __toESM(node_net);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let postal = require("postal");
+
+//#region src/protocol.ts
+/** Protocol version — bump if the handshake format changes. */
+const PROTOCOL_VERSION = 1;
+/** Default handshake timeout in milliseconds. */
+const DEFAULT_TIMEOUT = 5e3;
+const POSTAL_NAMESPACE = "postal:";
+const isPostalMessage = (data) => {
+	return typeof data === "object" && data !== null && "type" in data && typeof data.type === "string" && data.type.startsWith(POSTAL_NAMESPACE);
+};
+/** Narrows unknown data to a SYN message. Safe to call on any input. */
+const isUdsSyn = (data) => {
+	return isPostalMessage(data) && data.type === "postal:uds-syn" && data.version === PROTOCOL_VERSION;
+};
+/** Narrows unknown data to an ACK message. Safe to call on any input. */
+const isUdsAck = (data) => {
+	return isPostalMessage(data) && data.type === "postal:uds-ack" && data.version === PROTOCOL_VERSION;
+};
+/**
+* Loose check — matches the SYN type string without version validation.
+* Used to distinguish "wrong version" from "not a SYN at all".
+*/
+const looksLikeSyn = (data) => {
+	return isPostalMessage(data) && data.type === "postal:uds-syn";
+};
+/**
+* Loose check — matches the ACK type string without version validation.
+* Used to distinguish "wrong version" from "not an ACK at all".
+*/
+const looksLikeAck = (data) => {
+	return isPostalMessage(data) && data.type === "postal:uds-ack";
+};
+/** Narrows unknown data to an envelope wrapper. Validates type, version, and that envelope is a non-null object. */
+const isUdsEnvelopeMessage = (data) => {
+	return isPostalMessage(data) && data.type === "postal:envelope" && data.version === PROTOCOL_VERSION && "envelope" in data && typeof data.envelope === "object" && data.envelope !== null;
+};
+/** Creates a SYN message stamped with the current protocol version. */
+const createUdsSyn = () => ({
+	type: "postal:uds-syn",
+	version: PROTOCOL_VERSION
+});
+/** Creates an ACK message stamped with the current protocol version. */
+const createUdsAck = () => ({
+	type: "postal:uds-ack",
+	version: PROTOCOL_VERSION
+});
+/** Wraps a postal Envelope in a protocol message for wire transmission. */
+const createUdsEnvelopeMessage = (envelope) => ({
+	type: "postal:envelope",
+	version: PROTOCOL_VERSION,
+	envelope
+});
+
+//#endregion
+//#region src/serialization.ts
+/**
+* NDJSON serializer — JSON.stringify + "\n" on encode, JSON.parse on decode.
+*
+* JSON's escaping rules guarantee no unescaped newlines in the output,
+* so "\n" is an unambiguous delimiter.
+*/
+const ndjsonSerializer = {
+	encode: (msg) => JSON.stringify(msg) + "\n",
+	decode: (line) => JSON.parse(line)
+};
+/**
+* Creates a stateful line-parser that buffers incoming chunks, splits on
+* newlines, decodes each complete line, and calls `onMessage` with the result.
+*
+* TCP delivers bytes, not messages — a single `data` event can contain
+* half a line, multiple lines, or 1.5 lines. The parser keeps the trailing
+* partial as its buffer for the next chunk.
+*/
+const createLineParser = (onMessage, serializer = ndjsonSerializer) => {
+	let buffer = "";
+	return (chunk) => {
+		buffer += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+		const lines = buffer.split("\n");
+		buffer = lines.pop();
+		for (const line of lines) {
+			if (line.length === 0) continue;
+			try {
+				onMessage(serializer.decode(line));
+			} catch {}
+		}
+	};
+};
+
+//#endregion
+//#region src/socketTransport.ts
+/**
+* Creates a Transport from a socket with NDJSON framing.
+*
+* Buffers incoming data events, splits on newlines, parses each complete
+* line as JSON, and dispatches postal envelope messages to subscribers.
+*
+* @param socket - A connected net.Socket (or compatible mock)
+* @param serializer - Encode/decode strategy (defaults to NDJSON)
+* @returns A Transport suitable for postal's addTransport()
+*/
+const createSocketTransport = (socket, serializer = ndjsonSerializer) => {
+	let disposed = false;
+	const listeners = [];
+	const onData = createLineParser((parsed) => {
+		if (disposed) return;
+		if (isUdsEnvelopeMessage(parsed)) {
+			const { envelope } = parsed;
+			for (const listener of [...listeners]) try {
+				listener(envelope);
+			} catch (err) {
+				queueMicrotask(() => {
+					throw err;
+				});
+			}
+		}
+	}, serializer);
+	socket.on("data", onData);
+	const send = (envelope) => {
+		if (disposed) return;
+		socket.write(serializer.encode(createUdsEnvelopeMessage(envelope)));
+	};
+	const subscribe = (callback) => {
+		if (disposed) return () => {};
+		listeners.push(callback);
+		let removed = false;
+		return () => {
+			if (removed) return;
+			removed = true;
+			const index = listeners.indexOf(callback);
+			if (index !== -1) listeners.splice(index, 1);
+		};
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		socket.removeListener("data", onData);
+		listeners.splice(0, listeners.length);
+	};
+	return {
+		send,
+		subscribe,
+		dispose
+	};
+};
+
+//#endregion
+//#region src/server.ts
+/**
+* UDS server — listens for incoming client connections on a Unix domain socket.
+*
+* For each connecting client, completes a SYN/ACK handshake, wraps the socket
+* in a Transport, and registers it with postal via addTransport(). Postal's
+* core handles fan-out and echo prevention automatically.
+*
+* @module
+*/
+/**
+* Creates a net.Server, unlinks stale socket file, listens on the path,
+* and handles incoming postal client connections.
+*
+* @param socketPath - Path for the Unix domain socket file
+* @param options - Server configuration
+* @returns Promise resolving with a dispose function for full teardown
+*/
+const listenOnSocket = (socketPath, options = {}) => {
+	const { filter, unlinkStale = true, timeout = DEFAULT_TIMEOUT } = options;
+	const connections = /* @__PURE__ */ new Map();
+	let disposed = false;
+	if (unlinkStale) try {
+		node_fs.unlinkSync(socketPath);
+	} catch (err) {
+		if (err.code !== "ENOENT") throw err;
+	}
+	const server = node_net.createServer();
+	server.on("connection", (clientSocket) => {
+		if (disposed) {
+			clientSocket.destroy();
+			return;
+		}
+		let handshakeComplete = false;
+		const timer = setTimeout(() => {
+			if (!handshakeComplete) clientSocket.destroy();
+		}, timeout);
+		const onData = createLineParser((parsed) => {
+			if (handshakeComplete) return;
+			if (!isUdsSyn(parsed) && looksLikeSyn(parsed)) {
+				handshakeComplete = true;
+				clearTimeout(timer);
+				clientSocket.removeListener("data", onData);
+				clientSocket.destroy();
+				return;
+			}
+			if (isUdsSyn(parsed)) {
+				handshakeComplete = true;
+				clearTimeout(timer);
+				clientSocket.removeListener("data", onData);
+				clientSocket.write(ndjsonSerializer.encode(createUdsAck()));
+				const removeTransport = (0, postal.addTransport)(createSocketTransport(clientSocket), { filter });
+				connections.set(clientSocket, removeTransport);
+				const onClose = () => {
+					const removeFn = connections.get(clientSocket);
+					if (removeFn) {
+						removeFn();
+						connections.delete(clientSocket);
+					}
+				};
+				clientSocket.on("close", onClose);
+				clientSocket.on("error", onClose);
+			}
+		});
+		clientSocket.on("data", onData);
+	});
+	return new Promise((resolve, reject) => {
+		const onStartupError = (err) => {
+			reject(err);
+		};
+		server.on("error", onStartupError);
+		server.listen(socketPath, () => {
+			server.removeListener("error", onStartupError);
+			server.on("error", (err) => {
+				queueMicrotask(() => {
+					throw err;
+				});
+			});
+			const dispose = () => {
+				if (disposed) return;
+				disposed = true;
+				server.close();
+				for (const [socket, removeTransport] of connections) {
+					removeTransport();
+					socket.destroy();
+				}
+				connections.clear();
+			};
+			resolve({ dispose });
+		});
+	});
+};
+
+//#endregion
+//#region src/errors.ts
+/**
+* Thrown when the UDS handshake does not complete within the configured timeout.
+*
+* On the client side, this means the server did not respond with an ACK.
+* On the server side, this means a connecting client did not send a SYN.
+* In either case, the socket is destroyed before the error is thrown.
+*
+* The {@link timeout} property preserves the configured value for diagnostics.
+*/
+var PostalUdsHandshakeTimeoutError = class extends Error {
+	/** The timeout duration (ms) that was exceeded. */
+	timeout;
+	constructor(timeout) {
+		super(`Postal UDS handshake timed out after ${timeout}ms`);
+		this.name = "PostalUdsHandshakeTimeoutError";
+		this.timeout = timeout;
+	}
+};
+/**
+* Thrown when a SYN or ACK arrives with a protocol version that doesn't
+* match the local PROTOCOL_VERSION. This is a clear signal that the
+* remote side needs to be updated — not a transient network issue.
+*/
+var PostalUdsVersionMismatchError = class extends Error {
+	/** The version received from the remote side. */
+	received;
+	/** The version this side expected (i.e. PROTOCOL_VERSION). */
+	expected;
+	constructor(received, expected) {
+		super(`Postal UDS protocol version mismatch: received ${received}, expected ${expected}`);
+		this.name = "PostalUdsVersionMismatchError";
+		this.received = received;
+		this.expected = expected;
+	}
+};
+
+//#endregion
+//#region src/client.ts
+/**
+* UDS client — connects to a postal server via Unix domain socket.
+*
+* Sends SYN, waits for ACK, wraps the socket in a Transport, and registers
+* it with postal via addTransport(). Returns a function to remove the transport.
+*
+* @module
+*/
+/**
+* Connects to a postal UDS server at the given socket path.
+*
+* Performs a SYN/ACK handshake, wraps the connection in a Transport,
+* and registers it with postal. Returns a function that removes the
+* transport and cleans up the socket.
+*
+* @param socketPath - Path to the server's Unix domain socket
+* @param options - Client configuration
+* @returns Promise resolving with a remove function
+* @throws PostalUdsHandshakeTimeoutError if the server doesn't ACK in time
+*/
+const connectToSocket = (socketPath, options = {}) => {
+	const { timeout = DEFAULT_TIMEOUT, onDisconnect } = options;
+	return new Promise((resolve, reject) => {
+		const socket = node_net.connect(socketPath);
+		let settled = false;
+		const timer = setTimeout(() => {
+			if (!settled) {
+				settled = true;
+				socket.destroy();
+				reject(new PostalUdsHandshakeTimeoutError(timeout));
+			}
+		}, timeout);
+		const onError = (err) => {
+			if (!settled) {
+				settled = true;
+				clearTimeout(timer);
+				socket.destroy();
+				reject(err);
+			}
+		};
+		socket.on("error", onError);
+		const onData = createLineParser((parsed) => {
+			if (settled) return;
+			if (!isUdsAck(parsed) && looksLikeAck(parsed)) {
+				settled = true;
+				clearTimeout(timer);
+				socket.removeListener("data", onData);
+				socket.removeListener("error", onError);
+				socket.destroy();
+				reject(new PostalUdsVersionMismatchError(parsed.version, PROTOCOL_VERSION));
+				return;
+			}
+			if (isUdsAck(parsed)) {
+				settled = true;
+				clearTimeout(timer);
+				socket.removeListener("data", onData);
+				socket.removeListener("error", onError);
+				const removeTransport = (0, postal.addTransport)(createSocketTransport(socket));
+				const onClose = onDisconnect ? () => onDisconnect() : void 0;
+				if (onClose) socket.on("close", onClose);
+				resolve(() => {
+					if (onClose) socket.removeListener("close", onClose);
+					removeTransport();
+					socket.destroy();
+				});
+			}
+		});
+		socket.on("data", onData);
+		socket.on("connect", () => {
+			if (!settled) socket.write(ndjsonSerializer.encode(createUdsSyn()));
+		});
+	});
+};
+
+//#endregion
+exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
+exports.PostalUdsHandshakeTimeoutError = PostalUdsHandshakeTimeoutError;
+exports.PostalUdsVersionMismatchError = PostalUdsVersionMismatchError;
+exports.connectToSocket = connectToSocket;
+exports.createSocketTransport = createSocketTransport;
+exports.listenOnSocket = listenOnSocket;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["net","net"],"sources":["../src/protocol.ts","../src/serialization.ts","../src/socketTransport.ts","../src/server.ts","../src/errors.ts","../src/client.ts"],"sourcesContent":["/**\n * Postal UDS handshake protocol.\n *\n * Namespaced to \"postal:uds-\" for handshake messages to avoid collisions\n * with other transport types sharing a process. Envelope messages use\n * the shared \"postal:envelope\" type.\n *\n * Sequence:\n *   1. Client connects to socket, sends { type: \"postal:uds-syn\" }\n *   2. Server receives SYN, responds with { type: \"postal:uds-ack\" }\n *   3. Both sides wrap the socket in createSocketTransport()\n *\n * @module\n */\n\nimport type { Envelope } from \"postal\";\n\n/** Protocol version — bump if the handshake format changes. */\nexport const PROTOCOL_VERSION = 1;\n\n/** Default handshake timeout in milliseconds. */\nexport const DEFAULT_TIMEOUT = 5000;\n\nconst POSTAL_NAMESPACE = \"postal:\";\n\n// --- Message shapes ---\n\n/** Client-to-server handshake initiation. */\nexport type UdsSynMessage = {\n    type: \"postal:uds-syn\";\n    version: number;\n};\n\n/** Server-to-client handshake acknowledgment. */\nexport type UdsAckMessage = {\n    type: \"postal:uds-ack\";\n    version: number;\n};\n\n/** Wraps a postal Envelope for transmission over the socket. */\nexport type UdsEnvelopeMessage = {\n    type: \"postal:envelope\";\n    version: number;\n    envelope: Envelope;\n};\n\n/** Union of all messages that can appear on the wire. */\nexport type UdsProtocolMessage = UdsSynMessage | UdsAckMessage | UdsEnvelopeMessage;\n\n// --- Type guards ---\n// Three-step validation: check it's an object, has a string `type` field,\n// and the type starts with the postal namespace. This rejects nulls, arrays,\n// primitives, and non-postal traffic without throwing.\n\nconst isPostalMessage = (data: unknown): data is UdsProtocolMessage => {\n    return (\n        typeof data === \"object\" &&\n        data !== null &&\n        \"type\" in data &&\n        typeof (data as UdsProtocolMessage).type === \"string\" &&\n        (data as UdsProtocolMessage).type.startsWith(POSTAL_NAMESPACE)\n    );\n};\n\n/** Narrows unknown data to a SYN message. Safe to call on any input. */\nexport const isUdsSyn = (data: unknown): data is UdsSynMessage => {\n    return (\n        isPostalMessage(data) &&\n        (data as UdsSynMessage).type === \"postal:uds-syn\" &&\n        (data as UdsSynMessage).version === PROTOCOL_VERSION\n    );\n};\n\n/** Narrows unknown data to an ACK message. Safe to call on any input. */\nexport const isUdsAck = (data: unknown): data is UdsAckMessage => {\n    return (\n        isPostalMessage(data) &&\n        (data as UdsAckMessage).type === \"postal:uds-ack\" &&\n        (data as UdsAckMessage).version === PROTOCOL_VERSION\n    );\n};\n\n/**\n * Loose check — matches the SYN type string without version validation.\n * Used to distinguish \"wrong version\" from \"not a SYN at all\".\n */\nexport const looksLikeSyn = (data: unknown): data is UdsSynMessage => {\n    return isPostalMessage(data) && (data as UdsSynMessage).type === \"postal:uds-syn\";\n};\n\n/**\n * Loose check — matches the ACK type string without version validation.\n * Used to distinguish \"wrong version\" from \"not an ACK at all\".\n */\nexport const looksLikeAck = (data: unknown): data is UdsAckMessage => {\n    return isPostalMessage(data) && (data as UdsAckMessage).type === \"postal:uds-ack\";\n};\n\n/** Narrows unknown data to an envelope wrapper. Validates type, version, and that envelope is a non-null object. */\nexport const isUdsEnvelopeMessage = (data: unknown): data is UdsEnvelopeMessage => {\n    return (\n        isPostalMessage(data) &&\n        (data as UdsEnvelopeMessage).type === \"postal:envelope\" &&\n        (data as UdsEnvelopeMessage).version === PROTOCOL_VERSION &&\n        \"envelope\" in data &&\n        typeof (data as UdsEnvelopeMessage).envelope === \"object\" &&\n        (data as UdsEnvelopeMessage).envelope !== null\n    );\n};\n\n// --- Message factories ---\n\n/** Creates a SYN message stamped with the current protocol version. */\nexport const createUdsSyn = (): UdsSynMessage => ({\n    type: \"postal:uds-syn\",\n    version: PROTOCOL_VERSION,\n});\n\n/** Creates an ACK message stamped with the current protocol version. */\nexport const createUdsAck = (): UdsAckMessage => ({\n    type: \"postal:uds-ack\",\n    version: PROTOCOL_VERSION,\n});\n\n/** Wraps a postal Envelope in a protocol message for wire transmission. */\nexport const createUdsEnvelopeMessage = (envelope: Envelope): UdsEnvelopeMessage => ({\n    type: \"postal:envelope\",\n    version: PROTOCOL_VERSION,\n    envelope,\n});\n","/**\n * Serialization abstraction for the UDS transport.\n *\n * The default NDJSON implementation is the only built-in serializer.\n * The interface exists so MessagePack (or similar) can be swapped in\n * without restructuring the transport.\n *\n * @module\n */\n\n/** Encode/decode contract for wire serialization. */\nexport type Serializer = {\n    /** Serialize a message to a newline-terminated string. */\n    encode: (msg: unknown) => string;\n    /** Deserialize a single line (without trailing newline) back to a value. */\n    decode: (line: string) => unknown;\n};\n\n/**\n * NDJSON serializer — JSON.stringify + \"\\n\" on encode, JSON.parse on decode.\n *\n * JSON's escaping rules guarantee no unescaped newlines in the output,\n * so \"\\n\" is an unambiguous delimiter.\n */\nexport const ndjsonSerializer: Serializer = {\n    encode: (msg: unknown): string => JSON.stringify(msg) + \"\\n\",\n    decode: (line: string): unknown => JSON.parse(line),\n};\n\n/**\n * Creates a stateful line-parser that buffers incoming chunks, splits on\n * newlines, decodes each complete line, and calls `onMessage` with the result.\n *\n * TCP delivers bytes, not messages — a single `data` event can contain\n * half a line, multiple lines, or 1.5 lines. The parser keeps the trailing\n * partial as its buffer for the next chunk.\n */\nexport const createLineParser = (\n    onMessage: (parsed: unknown) => void,\n    serializer: Serializer = ndjsonSerializer\n): ((chunk: Buffer | string) => void) => {\n    let buffer = \"\";\n    return (chunk: Buffer | string): void => {\n        buffer += typeof chunk === \"string\" ? chunk : chunk.toString(\"utf-8\");\n        const lines = buffer.split(\"\\n\");\n        buffer = lines.pop()!;\n        for (const line of lines) {\n            if (line.length === 0) {\n                continue;\n            }\n            try {\n                onMessage(serializer.decode(line));\n            } catch {\n                // Malformed line — skip\n            }\n        }\n    };\n};\n","/**\n * Low-level Transport backed by a net.Socket with NDJSON framing.\n *\n * Works with any object that satisfies the UdsSocket shape — real\n * net.Socket instances or test mocks based on EventEmitter.\n *\n * The transport does NOT own the socket lifecycle. dispose() removes\n * the data listener and clears subscribers, but does NOT call\n * socket.destroy(). The server/client modules own their sockets.\n *\n * @module\n */\n\nimport type { Transport, Envelope } from \"postal\";\nimport { isUdsEnvelopeMessage, createUdsEnvelopeMessage } from \"./protocol\";\nimport { createLineParser, ndjsonSerializer, type Serializer } from \"./serialization\";\n\n/**\n * Minimal socket surface — anything with write, on, and removeListener\n * for the \"data\" event. Typed loosely to avoid importing @types/node.\n */\nexport type UdsSocket = {\n    write: (data: string) => void;\n    on: (event: \"data\", handler: (chunk: string | Buffer) => void) => void;\n    removeListener: (event: \"data\", handler: (chunk: string | Buffer) => void) => void;\n};\n\n/**\n * Creates a Transport from a socket with NDJSON framing.\n *\n * Buffers incoming data events, splits on newlines, parses each complete\n * line as JSON, and dispatches postal envelope messages to subscribers.\n *\n * @param socket - A connected net.Socket (or compatible mock)\n * @param serializer - Encode/decode strategy (defaults to NDJSON)\n * @returns A Transport suitable for postal's addTransport()\n */\nexport const createSocketTransport = (\n    socket: UdsSocket,\n    serializer: Serializer = ndjsonSerializer\n): Transport => {\n    let disposed = false;\n    const listeners: ((envelope: Envelope) => void)[] = [];\n\n    const onData = createLineParser(parsed => {\n        if (disposed) {\n            return;\n        }\n\n        if (isUdsEnvelopeMessage(parsed)) {\n            const { envelope } = parsed;\n            // Snapshot — safe if a listener unsubscribes during iteration\n            for (const listener of [...listeners]) {\n                try {\n                    listener(envelope);\n                } catch (err) {\n                    // Re-throw asynchronously so a single bad listener doesn't\n                    // kill delivery to the rest.\n                    queueMicrotask(() => {\n                        throw err;\n                    });\n                }\n            }\n        }\n    }, serializer);\n\n    socket.on(\"data\", onData);\n\n    const send = (envelope: Envelope): void => {\n        if (disposed) {\n            return;\n        }\n        socket.write(serializer.encode(createUdsEnvelopeMessage(envelope)));\n    };\n\n    const subscribe = (callback: (envelope: Envelope) => void): (() => void) => {\n        if (disposed) {\n            return () => {};\n        }\n\n        listeners.push(callback);\n\n        let removed = false;\n        return () => {\n            if (removed) {\n                return;\n            }\n            removed = true;\n            const index = listeners.indexOf(callback);\n            if (index !== -1) {\n                listeners.splice(index, 1);\n            }\n        };\n    };\n\n    const dispose = (): void => {\n        if (disposed) {\n            return;\n        }\n        disposed = true;\n        socket.removeListener(\"data\", onData);\n        listeners.splice(0, listeners.length);\n        // Intentionally NOT calling socket.destroy().\n        // The transport is a consumer of the socket, not its owner.\n    };\n\n    return { send, subscribe, dispose };\n};\n","/**\n * UDS server — listens for incoming client connections on a Unix domain socket.\n *\n * For each connecting client, completes a SYN/ACK handshake, wraps the socket\n * in a Transport, and registers it with postal via addTransport(). Postal's\n * core handles fan-out and echo prevention automatically.\n *\n * @module\n */\n\nimport * as net from \"node:net\";\nimport * as fs from \"node:fs\";\nimport { addTransport } from \"postal\";\nimport { createSocketTransport } from \"./socketTransport\";\nimport { isUdsSyn, looksLikeSyn, createUdsAck, DEFAULT_TIMEOUT } from \"./protocol\";\nimport { createLineParser, ndjsonSerializer } from \"./serialization\";\nimport type { UdsServerOptions } from \"./types\";\n\n/** Maps each connected client socket to its transport-removal function. */\ntype ConnectionMap = Map<net.Socket, () => void>;\n\n/**\n * Creates a net.Server, unlinks stale socket file, listens on the path,\n * and handles incoming postal client connections.\n *\n * @param socketPath - Path for the Unix domain socket file\n * @param options - Server configuration\n * @returns Promise resolving with a dispose function for full teardown\n */\nexport const listenOnSocket = (\n    socketPath: string,\n    options: UdsServerOptions = {}\n): Promise<{ dispose: () => void }> => {\n    const { filter, unlinkStale = true, timeout = DEFAULT_TIMEOUT } = options;\n    const connections: ConnectionMap = new Map();\n    let disposed = false;\n\n    // Attempt to unlink a stale socket file left by a crashed process\n    if (unlinkStale) {\n        try {\n            fs.unlinkSync(socketPath);\n        } catch (err: unknown) {\n            // ENOENT is fine — no stale file to clean up\n            if ((err as NodeJS.ErrnoException).code !== \"ENOENT\") {\n                throw err;\n            }\n        }\n    }\n\n    const server = net.createServer();\n\n    server.on(\"connection\", (clientSocket: net.Socket) => {\n        if (disposed) {\n            clientSocket.destroy();\n            return;\n        }\n\n        let handshakeComplete = false;\n\n        // Timeout for slow/non-postal clients that never send SYN\n        const timer = setTimeout(() => {\n            if (!handshakeComplete) {\n                clientSocket.destroy();\n            }\n        }, timeout);\n\n        const onData = createLineParser(parsed => {\n            if (handshakeComplete) {\n                return;\n            }\n\n            // Detect version mismatch before it times out with an unhelpful error\n            if (!isUdsSyn(parsed) && looksLikeSyn(parsed)) {\n                handshakeComplete = true;\n                clearTimeout(timer);\n                clientSocket.removeListener(\"data\", onData);\n                clientSocket.destroy();\n                return;\n            }\n\n            if (isUdsSyn(parsed)) {\n                handshakeComplete = true;\n                clearTimeout(timer);\n                clientSocket.removeListener(\"data\", onData);\n\n                // Send ACK before creating the transport so the client's\n                // ACK listener sees it before any envelope messages arrive\n                clientSocket.write(ndjsonSerializer.encode(createUdsAck()));\n\n                const transport = createSocketTransport(clientSocket);\n                const removeTransport = addTransport(transport, { filter });\n\n                connections.set(clientSocket, removeTransport);\n\n                // Both close and error can fire for the same socket death,\n                // so the handler is idempotent — the Map lookup guards against\n                // double-removal.\n                const onClose = (): void => {\n                    const removeFn = connections.get(clientSocket);\n                    if (removeFn) {\n                        removeFn();\n                        connections.delete(clientSocket);\n                    }\n                };\n\n                clientSocket.on(\"close\", onClose);\n                clientSocket.on(\"error\", onClose);\n            }\n        });\n\n        clientSocket.on(\"data\", onData);\n    });\n\n    return new Promise<{ dispose: () => void }>((resolve, reject) => {\n        const onStartupError = (err: Error): void => {\n            reject(err);\n        };\n\n        server.on(\"error\", onStartupError);\n\n        server.listen(socketPath, () => {\n            // Swap the pre-listen error handler for one that surfaces\n            // post-startup errors instead of silently dropping them\n            server.removeListener(\"error\", onStartupError);\n            server.on(\"error\", (err: Error) => {\n                queueMicrotask(() => {\n                    throw err;\n                });\n            });\n\n            const dispose = (): void => {\n                if (disposed) {\n                    return;\n                }\n                disposed = true;\n\n                server.close();\n\n                for (const [socket, removeTransport] of connections) {\n                    removeTransport();\n                    socket.destroy();\n                }\n                connections.clear();\n            };\n\n            resolve({ dispose });\n        });\n    });\n};\n","/**\n * Thrown when the UDS handshake does not complete within the configured timeout.\n *\n * On the client side, this means the server did not respond with an ACK.\n * On the server side, this means a connecting client did not send a SYN.\n * In either case, the socket is destroyed before the error is thrown.\n *\n * The {@link timeout} property preserves the configured value for diagnostics.\n */\nexport class PostalUdsHandshakeTimeoutError extends Error {\n    /** The timeout duration (ms) that was exceeded. */\n    readonly timeout: number;\n\n    constructor(timeout: number) {\n        super(`Postal UDS handshake timed out after ${timeout}ms`);\n        this.name = \"PostalUdsHandshakeTimeoutError\";\n        this.timeout = timeout;\n    }\n}\n\n/**\n * Thrown when a SYN or ACK arrives with a protocol version that doesn't\n * match the local PROTOCOL_VERSION. This is a clear signal that the\n * remote side needs to be updated — not a transient network issue.\n */\nexport class PostalUdsVersionMismatchError extends Error {\n    /** The version received from the remote side. */\n    readonly received: number;\n    /** The version this side expected (i.e. PROTOCOL_VERSION). */\n    readonly expected: number;\n\n    constructor(received: number, expected: number) {\n        super(`Postal UDS protocol version mismatch: received ${received}, expected ${expected}`);\n        this.name = \"PostalUdsVersionMismatchError\";\n        this.received = received;\n        this.expected = expected;\n    }\n}\n","/**\n * UDS client — connects to a postal server via Unix domain socket.\n *\n * Sends SYN, waits for ACK, wraps the socket in a Transport, and registers\n * it with postal via addTransport(). Returns a function to remove the transport.\n *\n * @module\n */\n\nimport * as net from \"node:net\";\nimport { addTransport } from \"postal\";\nimport { createSocketTransport } from \"./socketTransport\";\nimport {\n    createUdsSyn,\n    isUdsAck,\n    looksLikeAck,\n    PROTOCOL_VERSION,\n    DEFAULT_TIMEOUT,\n} from \"./protocol\";\nimport { createLineParser, ndjsonSerializer } from \"./serialization\";\nimport { PostalUdsHandshakeTimeoutError, PostalUdsVersionMismatchError } from \"./errors\";\nimport type { UdsConnectOptions } from \"./types\";\n\n/**\n * Connects to a postal UDS server at the given socket path.\n *\n * Performs a SYN/ACK handshake, wraps the connection in a Transport,\n * and registers it with postal. Returns a function that removes the\n * transport and cleans up the socket.\n *\n * @param socketPath - Path to the server's Unix domain socket\n * @param options - Client configuration\n * @returns Promise resolving with a remove function\n * @throws PostalUdsHandshakeTimeoutError if the server doesn't ACK in time\n */\nexport const connectToSocket = (\n    socketPath: string,\n    options: UdsConnectOptions = {}\n): Promise<() => void> => {\n    const { timeout = DEFAULT_TIMEOUT, onDisconnect } = options;\n\n    return new Promise<() => void>((resolve, reject) => {\n        const socket = net.connect(socketPath);\n        // Guards the promise from double-settlement — timeout, error, and\n        // successful ACK are all racing to resolve/reject.\n        let settled = false;\n\n        const timer = setTimeout(() => {\n            if (!settled) {\n                settled = true;\n                socket.destroy();\n                reject(new PostalUdsHandshakeTimeoutError(timeout));\n            }\n        }, timeout);\n\n        const onError = (err: Error): void => {\n            if (!settled) {\n                settled = true;\n                clearTimeout(timer);\n                socket.destroy();\n                reject(err);\n            }\n        };\n\n        socket.on(\"error\", onError);\n\n        const onData = createLineParser(parsed => {\n            if (settled) {\n                return;\n            }\n\n            // Detect version mismatch before it times out with an unhelpful error\n            if (!isUdsAck(parsed) && looksLikeAck(parsed)) {\n                settled = true;\n                clearTimeout(timer);\n                socket.removeListener(\"data\", onData);\n                socket.removeListener(\"error\", onError);\n                socket.destroy();\n                reject(new PostalUdsVersionMismatchError(parsed.version, PROTOCOL_VERSION));\n                return;\n            }\n\n            if (isUdsAck(parsed)) {\n                settled = true;\n                clearTimeout(timer);\n                socket.removeListener(\"data\", onData);\n                socket.removeListener(\"error\", onError);\n\n                const transport = createSocketTransport(socket);\n                const removeTransport = addTransport(transport);\n\n                // Wire up onDisconnect callback — remove the close listener\n                // during cleanup so that calling the returned function doesn't\n                // fire onDisconnect spuriously (socket.destroy() triggers close).\n                const onClose = onDisconnect ? () => onDisconnect() : undefined;\n                if (onClose) {\n                    socket.on(\"close\", onClose);\n                }\n\n                resolve(() => {\n                    if (onClose) {\n                        socket.removeListener(\"close\", onClose);\n                    }\n                    removeTransport();\n                    socket.destroy();\n                });\n            }\n        });\n\n        socket.on(\"data\", onData);\n\n        // Send SYN once the connection is established\n        socket.on(\"connect\", () => {\n            if (!settled) {\n                socket.write(ndjsonSerializer.encode(createUdsSyn()));\n            }\n        });\n    });\n};\n"],"mappings":"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"}