@aztec-foundation/ipc-runtime 0.0.1-commit.b66364b

package/dest/uds.test.js

@@ -0,0 +1,182 @@
+// In-process UDS transport tests: UdsIpcServer + UdsIpcClient round-trips,
+// zero-length responses, disconnect handling and oversized-frame rejection.
+// Run via `yarn test` (node --test against the compiled dest/ output).
+import { test } from "node:test";
+import * as assert from "node:assert/strict";
+import * as net from "node:net";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { UdsIpcClient } from "./uds_client.js";
+import { UdsIpcServer } from "./uds_server.js";
+function tmpSocketPath(tag) {
+    return path.join(os.tmpdir(), `ipc_ts_test_${tag}_${process.pid}.sock`);
+}
+test("echo round-trip", async () => {
+    const socketPath = tmpSocketPath("echo");
+    const server = await UdsIpcServer.listen(socketPath, (_id, req) => req);
+    const client = await UdsIpcClient.connect(socketPath);
+    try {
+        const payload = new Uint8Array([1, 2, 3, 4, 5]);
+        const resp = await client.call(payload);
+        assert.deepEqual(resp, payload);
+        // Pipelined calls resolve FIFO.
+        const [a, b] = await Promise.all([
+            client.call(new Uint8Array([7])),
+            client.call(new Uint8Array([8, 9])),
+        ]);
+        assert.deepEqual(a, new Uint8Array([7]));
+        assert.deepEqual(b, new Uint8Array([8, 9]));
+    }
+    finally {
+        await client.destroy();
+        await server.close();
+    }
+    assert.equal(fs.existsSync(socketPath), false, "socket unlinked on close");
+});
+test("socket file is chmod 0600", async () => {
+    const socketPath = tmpSocketPath("chmod");
+    const server = await UdsIpcServer.listen(socketPath, (_id, req) => req);
+    try {
+        const mode = fs.statSync(socketPath).mode & 0o777;
+        assert.equal(mode, 0o600);
+    }
+    finally {
+        await server.close();
+    }
+});
+test("zero-length response resolves (not a hang/error)", async () => {
+    const socketPath = tmpSocketPath("zlen");
+    const server = await UdsIpcServer.listen(socketPath, () => new Uint8Array(0));
+    const client = await UdsIpcClient.connect(socketPath);
+    try {
+        const resp = await client.call(new Uint8Array([42]));
+        assert.equal(resp.length, 0);
+    }
+    finally {
+        await client.destroy();
+        await server.close();
+    }
+});
+test("disconnect rejects pending calls and fails fast afterwards", async () => {
+    const socketPath = tmpSocketPath("disc");
+    // Raw server that accepts, reads, then kills the connection without
+    // responding.
+    const rawServer = net.createServer((conn) => {
+        conn.once("data", () => conn.destroy());
+    });
+    await new Promise((resolve) => rawServer.listen(socketPath, () => resolve()));
+    const client = await UdsIpcClient.connect(socketPath);
+    try {
+        await assert.rejects(client.call(new Uint8Array([1])));
+        // Socket is dead — further calls fail fast instead of queueing.
+        await assert.rejects(client.call(new Uint8Array([2])), /closed/);
+    }
+    finally {
+        await client.destroy();
+        rawServer.close();
+        fs.rmSync(socketPath, { force: true });
+    }
+});
+test("client rejects oversized frame from server", async () => {
+    const socketPath = tmpSocketPath("oversize_cli");
+    // Raw server that answers any request with a corrupt 0xFFFFFFFF length
+    // prefix.
+    const rawServer = net.createServer((conn) => {
+        conn.once("data", () => {
+            const bogus = Buffer.allocUnsafe(4);
+            bogus.writeUInt32LE(0xffffffff, 0);
+            conn.write(bogus);
+        });
+    });
+    await new Promise((resolve) => rawServer.listen(socketPath, () => resolve()));
+    const client = await UdsIpcClient.connect(socketPath);
+    try {
+        await assert.rejects(client.call(new Uint8Array([1])), /oversized frame/);
+    }
+    finally {
+        await client.destroy();
+        rawServer.close();
+        fs.rmSync(socketPath, { force: true });
+    }
+});
+test("client fails all pending calls on a response with an unknown request id", async () => {
+    const socketPath = tmpSocketPath("unknown_id");
+    // Raw server that answers with a well-formed frame whose request id matches
+    // nothing the client sent — the correlation-desync case.
+    const rawServer = net.createServer((conn) => {
+        conn.once("data", () => {
+            const frame = Buffer.allocUnsafe(12 + 1);
+            frame.writeUInt32LE(1 + 8, 0);
+            frame.writeBigUInt64LE(0xdeadbeefn, 4);
+            frame.writeUInt8(42, 12);
+            conn.write(frame);
+        });
+    });
+    await new Promise((resolve) => rawServer.listen(socketPath, () => resolve()));
+    const client = await UdsIpcClient.connect(socketPath);
+    try {
+        await assert.rejects(client.call(new Uint8Array([1])), /unknown request id/);
+    }
+    finally {
+        await client.destroy();
+        rawServer.close();
+        fs.rmSync(socketPath, { force: true });
+    }
+});
+test("client fails loudly on an id-less (old-protocol) frame", async () => {
+    const socketPath = tmpSocketPath("idless");
+    // Raw server speaking the pre-envelope-id protocol: [4B len][payload] with
+    // len < 8.
+    const rawServer = net.createServer((conn) => {
+        conn.once("data", () => {
+            const frame = Buffer.allocUnsafe(4 + 1);
+            frame.writeUInt32LE(1, 0);
+            frame.writeUInt8(42, 4);
+            conn.write(frame);
+        });
+    });
+    await new Promise((resolve) => rawServer.listen(socketPath, () => resolve()));
+    const client = await UdsIpcClient.connect(socketPath);
+    try {
+        await assert.rejects(client.call(new Uint8Array([1])), /protocol mismatch/);
+    }
+    finally {
+        await client.destroy();
+        rawServer.close();
+        fs.rmSync(socketPath, { force: true });
+    }
+});
+test("server drops connection on oversized frame", async () => {
+    const socketPath = tmpSocketPath("oversize_srv");
+    const server = await UdsIpcServer.listen(socketPath, (_id, req) => req);
+    const conn = net.createConnection(socketPath);
+    try {
+        await new Promise((resolve, reject) => {
+            conn.once("connect", () => resolve());
+            conn.once("error", reject);
+        });
+        const bogus = Buffer.allocUnsafe(4);
+        bogus.writeUInt32LE(0xffffffff, 0);
+        conn.write(bogus);
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("server did not close the connection")), 5000);
+            conn.once("close", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            conn.once("error", () => {
+                /* RST is fine — close follows */
+            });
+        });
+    }
+    finally {
+        conn.destroy();
+        await server.close();
+    }
+});
+test("connect times out against a bound-but-unresponsive path", async () => {
+    const socketPath = tmpSocketPath("noaccept");
+    fs.rmSync(socketPath, { force: true });
+    await assert.rejects(UdsIpcClient.connect(socketPath, { connectTimeoutMs: 300 }), /timed out/);
+});

package/dest/uds_client.d.ts

@@ -0,0 +1,42 @@
+import * as net from "node:net";
+import { IpcClientAsync } from "./types.js";
+export interface UdsIpcClientConnectOptions {
+    /** Mark the socket as unref'd so it doesn't keep the Node event loop alive when idle. */
+    unref?: boolean;
+    /**
+     * Retry budget (ms) for the initial connect when the server has bound the
+     * path but not yet called listen(). Set to 0 to fail immediately on
+     * ECONNREFUSED. Default CONNECT_RETRY_BUDGET_MS (5000).
+     */
+    connectTimeoutMs?: number;
+}
+/**
+ * Async IPC client over a Unix Domain Socket. Wire format matches the C++
+ * ipc::IpcServer/IpcClient socket transport: 4-byte little-endian length
+ * prefix, 8-byte little-endian request id, then the msgpack payload (the
+ * length counts the id plus the payload), per direction.
+ *
+ * Supports pipelining: each call carries a unique request id which the
+ * server echoes on the response, so responses are paired to callers by id
+ * and the server may complete requests in any order. Ids start at a random
+ * point per connection.
+ */
+export declare class UdsIpcClient implements IpcClientAsync {
+    private conn;
+    private buffer;
+    private pending;
+    private nextRequestId;
+    private destroyed;
+    /** Set once the socket has errored/closed; new calls fail fast. */
+    private closed;
+    private constructor();
+    static connect(socketPath: string, opts?: UdsIpcClientConnectOptions): Promise<UdsIpcClient>;
+    /** Number of in-flight calls awaiting a response. */
+    get inflight(): number;
+    /** Underlying socket — exposed for ref/unref control (event-loop tuning). */
+    get socket(): net.Socket;
+    call(input: Uint8Array): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+    private onData;
+    private failAll;
+}

package/dest/uds_client.js

@@ -0,0 +1,183 @@
+import * as net from "node:net";
+import { IpcTransportError } from "./errors.js";
+import { CONNECT_RETRY_BUDGET_MS, MAX_FRAME_SIZE, } from "./types.js";
+/**
+ * Async IPC client over a Unix Domain Socket. Wire format matches the C++
+ * ipc::IpcServer/IpcClient socket transport: 4-byte little-endian length
+ * prefix, 8-byte little-endian request id, then the msgpack payload (the
+ * length counts the id plus the payload), per direction.
+ *
+ * Supports pipelining: each call carries a unique request id which the
+ * server echoes on the response, so responses are paired to callers by id
+ * and the server may complete requests in any order. Ids start at a random
+ * point per connection.
+ */
+export class UdsIpcClient {
+    conn;
+    buffer = Buffer.alloc(0);
+    pending = new Map();
+    nextRequestId = (BigInt(Math.floor(Math.random() * 0xffffffff)) << 16n) + 1n;
+    destroyed = false;
+    /** Set once the socket has errored/closed; new calls fail fast. */
+    closed = false;
+    constructor(conn) {
+        this.conn = conn;
+        conn.on("data", (chunk) => this.onData(chunk));
+        conn.on("error", (err) => this.failAll(new IpcTransportError(`UdsIpcClient: socket error: ${err.message}`, {
+            cause: err,
+        })));
+        conn.on("close", () => this.failAll(new IpcTransportError("socket closed")));
+    }
+    static async connect(socketPath, opts) {
+        const conn = await connectWithRetry(socketPath, opts?.connectTimeoutMs ?? CONNECT_RETRY_BUDGET_MS);
+        conn.setNoDelay(true);
+        if (opts?.unref)
+            conn.unref();
+        return new UdsIpcClient(conn);
+    }
+    /** Number of in-flight calls awaiting a response. */
+    get inflight() {
+        return this.pending.size;
+    }
+    /** Underlying socket — exposed for ref/unref control (event-loop tuning). */
+    get socket() {
+        return this.conn;
+    }
+    async call(input) {
+        if (this.destroyed) {
+            throw new IpcTransportError("UdsIpcClient: call() after destroy()");
+        }
+        if (this.closed) {
+            throw new IpcTransportError("UdsIpcClient: call() on a closed/errored socket");
+        }
+        return new Promise((resolve, reject) => {
+            const requestId = this.nextRequestId++;
+            this.pending.set(requestId, { resolve, reject });
+            const header = Buffer.allocUnsafe(12);
+            header.writeUInt32LE(input.length + 8, 0); // length counts id + payload
+            header.writeBigUInt64LE(requestId, 4);
+            this.conn.write(header);
+            this.conn.write(input);
+        });
+    }
+    async destroy() {
+        this.destroyed = true;
+        this.conn.removeAllListeners();
+        this.conn.destroy();
+        this.failAll(new IpcTransportError("UdsIpcClient destroyed"));
+    }
+    onData(chunk) {
+        this.buffer =
+            this.buffer.length === 0
+                ? Buffer.from(chunk)
+                : Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length >= 4) {
+            const len = this.buffer.readUInt32LE(0);
+            if (len > MAX_FRAME_SIZE) {
+                // Corrupt/malicious frame — close instead of buffering up to the
+                // claimed size.
+                this.conn.destroy();
+                this.failAll(new IpcTransportError(`UdsIpcClient: oversized frame (${len} bytes exceeds MAX_FRAME_SIZE)`));
+                return;
+            }
+            if (len < 8) {
+                // Shorter than the request-id field: the server speaks the id-less
+                // protocol. Fail loudly instead of misparsing.
+                this.conn.destroy();
+                this.failAll(new IpcTransportError(`UdsIpcClient: ${len}-byte frame is shorter than the request-id field — ` +
+                    "IPC protocol mismatch (envelope ids); update the peer binary/package"));
+                return;
+            }
+            if (this.buffer.length < 4 + len)
+                return;
+            const requestId = this.buffer.readBigUInt64LE(4);
+            const payload = this.buffer.subarray(12, 4 + len);
+            this.buffer = this.buffer.subarray(4 + len);
+            const next = this.pending.get(requestId);
+            if (next) {
+                this.pending.delete(requestId);
+                next.resolve(new Uint8Array(payload));
+            }
+            else {
+                // A response that pairs with no pending call means the stream's
+                // correlation is broken — fail everything loudly rather than
+                // continuing on a connection we can no longer trust.
+                this.conn.destroy();
+                this.failAll(new IpcTransportError(`UdsIpcClient: response for unknown request id ${requestId} — protocol desync`));
+                return;
+            }
+        }
+    }
+    failAll(err) {
+        this.closed = true;
+        const pending = [...this.pending.values()];
+        this.pending.clear();
+        for (const p of pending)
+            p.reject(err);
+    }
+}
+/**
+ * Connect to `socketPath`, retrying "server not ready" errors until
+ * `timeoutMs` elapses: ENOENT (socket file not created yet), ECONNREFUSED
+ * (the window between the server's bind() and listen()), EAGAIN (Linux
+ * reports this for a UDS connect when the accept backlog is momentarily
+ * full), and ECONNRESET (a connect racing the server's accept loop under
+ * connection churn). Other errors fail immediately. Each attempt is also
+ * capped at the remaining budget, so a bound-but-never-accepting server
+ * cannot hang the connect past the deadline.
+ */
+async function connectWithRetry(socketPath, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let attempt = 0;
+    let lastErr;
+    while (true) {
+        try {
+            const remainingMs = Math.max(1, deadline - Date.now());
+            return await attemptConnect(socketPath, remainingMs);
+        }
+        catch (err) {
+            lastErr = err;
+            const code = err.code;
+            if (code !== "ECONNREFUSED" &&
+                code !== "ECONNRESET" &&
+                code !== "ENOENT" &&
+                code !== "ETIMEDOUT" &&
+                code !== "EAGAIN") {
+                throw new IpcTransportError(`UdsIpcClient: connect failed: ${lastErr.message}`, { cause: lastErr });
+            }
+            if (Date.now() >= deadline) {
+                throw new IpcTransportError(`UdsIpcClient: connect timed out: ${lastErr.message}`, { cause: lastErr });
+            }
+            const delay = Math.min(50, 5 * 2 ** attempt++);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+}
+function attemptConnect(socketPath, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const conn = net.createConnection(socketPath);
+        const cleanup = () => {
+            conn.removeListener("connect", onConnect);
+            conn.removeListener("error", onError);
+            clearTimeout(timer);
+        };
+        const onError = (err) => {
+            cleanup();
+            conn.destroy();
+            reject(err);
+        };
+        const onConnect = () => {
+            cleanup();
+            resolve(conn);
+        };
+        const timer = setTimeout(() => {
+            cleanup();
+            conn.destroy();
+            const err = new Error(`connect attempt timed out after ${timeoutMs}ms`);
+            err.code = "ETIMEDOUT";
+            reject(err);
+        }, timeoutMs);
+        conn.once("connect", onConnect);
+        conn.once("error", onError);
+    });
+}

package/dest/uds_server.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Handler signature mirrors the C++ ipc::IpcServer::Handler: receive raw
+ * bytes, return raw bytes. msgpack decode/encode and command dispatch are
+ * the caller's responsibility (or the codegen's, when a generated dispatcher
+ * is wired in).
+ */
+export type IpcServerHandler = (clientId: number, request: Uint8Array) => Promise<Uint8Array> | Uint8Array;
+/**
+ * UDS server with the same wire format as UdsIpcClient and the C++
+ * ipc::IpcServer socket transport: 4-byte LE length prefix, 8-byte LE request
+ * id (echoed on the response), then the payload; the length counts the id
+ * plus the payload. Accepts multiple concurrent connections; handler
+ * invocations are serialised per-connection.
+ *
+ * Signal handling is the caller's responsibility (unlike the C++ server's
+ * install_default_signal_handlers); the socket file is unlinked on close()
+ * and best-effort on process exit.
+ */
+export declare class UdsIpcServer {
+    private socketPath;
+    private server;
+    private nextClientId;
+    private connections;
+    private readonly unlinkOnExit;
+    private constructor();
+    static listen(socketPath: string, handler: IpcServerHandler): Promise<UdsIpcServer>;
+    close(): Promise<void>;
+    private handleConnection;
+}

package/dest/uds_server.js

@@ -0,0 +1,135 @@
+import * as net from "node:net";
+import * as fs from "node:fs";
+import { MAX_FRAME_SIZE } from "./types.js";
+/**
+ * UDS server with the same wire format as UdsIpcClient and the C++
+ * ipc::IpcServer socket transport: 4-byte LE length prefix, 8-byte LE request
+ * id (echoed on the response), then the payload; the length counts the id
+ * plus the payload. Accepts multiple concurrent connections; handler
+ * invocations are serialised per-connection.
+ *
+ * Signal handling is the caller's responsibility (unlike the C++ server's
+ * install_default_signal_handlers); the socket file is unlinked on close()
+ * and best-effort on process exit.
+ */
+export class UdsIpcServer {
+    socketPath;
+    server;
+    nextClientId = 0;
+    connections = new Set();
+    unlinkOnExit = () => {
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch {
+            /* may already be gone */
+        }
+    };
+    constructor(server, socketPath) {
+        this.socketPath = socketPath;
+        this.server = server;
+    }
+    static async listen(socketPath, handler) {
+        try {
+            fs.unlinkSync(socketPath);
+        }
+        catch {
+            /* socket file may not exist; ignore */
+        }
+        const server = net.createServer();
+        const instance = new UdsIpcServer(server, socketPath);
+        server.on("connection", (conn) => instance.handleConnection(conn, handler));
+        await new Promise((resolve, reject) => {
+            const onError = (err) => {
+                server.removeListener("listening", onListening);
+                reject(err);
+            };
+            const onListening = () => {
+                server.removeListener("error", onError);
+                resolve();
+            };
+            server.once("error", onError);
+            server.once("listening", onListening);
+            server.listen(socketPath);
+        });
+        // Restrict the socket to the owner, matching the C++ server (and the
+        // 0600 mode used for SHM segments).
+        fs.chmodSync(socketPath, 0o600);
+        // Best-effort cleanup if the process exits without close().
+        process.on("exit", instance.unlinkOnExit);
+        return instance;
+    }
+    async close() {
+        // Force-close live connections (matching the C++ server's shutdown) so close()
+        // resolves promptly instead of blocking until every client happens to disconnect.
+        for (const conn of this.connections) {
+            conn.destroy();
+        }
+        this.connections.clear();
+        await new Promise((resolve) => this.server.close(() => resolve()));
+        process.removeListener("exit", this.unlinkOnExit);
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch {
+            /* may already be gone */
+        }
+    }
+    handleConnection(conn, handler) {
+        const clientId = this.nextClientId++;
+        this.connections.add(conn);
+        conn.on("close", () => this.connections.delete(conn));
+        let buffer = Buffer.alloc(0);
+        let chain = Promise.resolve();
+        conn.on("data", (chunk) => {
+            buffer =
+                buffer.length === 0
+                    ? Buffer.from(chunk)
+                    : Buffer.concat([buffer, chunk]);
+            while (buffer.length >= 4) {
+                const len = buffer.readUInt32LE(0);
+                if (len > MAX_FRAME_SIZE) {
+                    // Corrupt/malicious frame — drop the connection instead of
+                    // buffering up to the claimed size.
+                    conn.destroy(new Error(`UdsIpcServer: oversized frame (${len} bytes exceeds MAX_FRAME_SIZE)`));
+                    return;
+                }
+                if (len < 8) {
+                    // Shorter than the request-id field: the peer speaks the id-less
+                    // protocol. Drop the connection with a clear reason.
+                    conn.destroy(new Error(`UdsIpcServer: ${len}-byte frame is shorter than the request-id field — ` +
+                        "IPC protocol mismatch (envelope ids); update the peer binary/package"));
+                    return;
+                }
+                if (buffer.length < 4 + len)
+                    break;
+                const requestId = buffer.readBigUInt64LE(4);
+                // Copy into a standalone Buffer (not a subarray view, and not a plain Uint8Array): handlers
+                // decode with msgpackr, which relies on Buffer semantics for correct string/binary decoding.
+                const payload = Buffer.from(buffer.subarray(12, 4 + len));
+                buffer = buffer.subarray(4 + len);
+                const prev = chain;
+                chain = (async () => {
+                    await prev;
+                    try {
+                        const resp = await handler(clientId, payload);
+                        const header = Buffer.allocUnsafe(12);
+                        header.writeUInt32LE(resp.length + 8, 0); // length counts id + payload
+                        header.writeBigUInt64LE(requestId, 4);
+                        conn.write(header);
+                        conn.write(resp);
+                    }
+                    catch (err) {
+                        conn.destroy(err);
+                    }
+                })();
+                void chain.catch(() => {
+                    /* errors already handled by destroying the connection */
+                });
+            }
+        });
+        conn.on("error", () => {
+            /* swallowed — clients reconnect */
+        });
+    }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@aztec-foundation/ipc-runtime",
+  "packageManager": "yarn@4.13.0",
+  "version": "0.0.1-commit.b66364b",
+  "type": "module",
+  "main": "dest/index.js",
+  "types": "dest/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dest/index.d.ts",
+      "import": "./dest/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dest",
+    "test": "tsc -p tsconfig.json && node --test dest/*.test.js"
+  },
+  "files": [
+    "dest",
+    "src",
+    "build"
+  ],
+  "devDependencies": {
+    "@types/node": "^22",
+    "typescript": "^5.6.3"
+  }
+}

package/src/errors.ts

@@ -0,0 +1,46 @@
+/**
+ * Errors thrown by the ipc-runtime transports and process backends.
+ *
+ * The cross-layer contract is the bare `retry` property, not these classes:
+ * an error with `retry === true` failed for environmental reasons (process
+ * death, machine load, a broken connection) and the operation may be retried;
+ * `retry === false` (or no `retry` property at all) means retrying cannot
+ * help. Consumers should feature-detect the property rather than import
+ * these types, so the convention survives package boundaries.
+ */
+export class IpcError extends Error {
+  constructor(
+    message: string,
+    public readonly retry: boolean,
+    options?: { cause?: unknown },
+  ) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+}
+
+/** The connection to the server broke while calls were in flight or before they could be sent. */
+export class IpcTransportError extends IpcError {
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, /*retry=*/ true, options);
+  }
+}
+
+/** The spawned server process exited; carries the exit cause and, when captured, the log path. */
+export class IpcProcessExitedError extends IpcError {
+  constructor(
+    message: string,
+    public readonly code: number | null,
+    public readonly signal: NodeJS.Signals | null,
+    public readonly logPath?: string,
+  ) {
+    super(message, /*retry=*/ true);
+  }
+}
+
+/**
+ * The server process could not be started. Environmental failures (spawn
+ * raced a loaded machine, a wedged process hit the connect backstop) are
+ * retryable; configuration failures (binary not found) are not.
+ */
+export class IpcSpawnError extends IpcError {}

package/src/index.ts

@@ -0,0 +1,34 @@
+export type { IpcClientAsync, IpcClientSync } from "./types.js";
+export {
+  MAX_FRAME_SIZE,
+  CONNECT_RETRY_BUDGET_MS,
+  DEFAULT_RING_SIZE,
+  SOCKET_BACKLOG,
+  DEFAULT_CALL_TIMEOUT_NS,
+} from "./types.js";
+export {
+  IpcError,
+  IpcTransportError,
+  IpcProcessExitedError,
+  IpcSpawnError,
+} from "./errors.js";
+export {
+  SpawnedProcessBackend,
+  type SpawnedProcessBackendOptions,
+  type SpawnedTransport,
+} from "./spawned_backend.js";
+export { UdsIpcClient, type UdsIpcClientConnectOptions } from "./uds_client.js";
+export { UdsIpcServer, type IpcServerHandler } from "./uds_server.js";
+export {
+  NapiShmSyncClient,
+  NapiShmAsyncClient,
+  createNapiShmSyncClient,
+  createNapiShmAsyncClient,
+  type NapiMsgpackClientSync,
+  type NapiMsgpackClientAsync,
+} from "./shm_client.js";
+export {
+  findIpcRuntimeNapi,
+  loadIpcRuntimeNapi,
+  type Platform,
+} from "./native_loader.js";