@hediet/linkrpc-infra 0.0.1

package/dist/json-rpc/index.js

@@ -0,0 +1,439 @@
+import { discriminatedUnion, enum as enum$1, literal, object, optional, unknown } from "zod/mini";
+import { defineInterface, requestType } from "@hediet/linkrpc";
+import * as readline from "node:readline";
+//#region src/json-rpc/client.ts
+const MAX_RAW_FRAME_BACKLOG = 1024;
+async function connectRawJsonRpcTransport(client, params) {
+	const messageListeners = /* @__PURE__ */ new Set();
+	const closeListeners = /* @__PURE__ */ new Set();
+	const backlog = [];
+	let buffering = true;
+	let closed = false;
+	let closeReason;
+	const finish = (reason) => {
+		if (closed) return;
+		closed = true;
+		closeReason = reason;
+		rejectReady(/* @__PURE__ */ new Error(`Raw JSON-RPC transport closed before ready: ${reason ?? "closed"}`));
+		for (const listener of closeListeners) listener(reason);
+	};
+	let resolveReady;
+	let rejectReady;
+	const ready = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
+	});
+	const call = client.connectRaw(params === void 0 ? {} : { params }, { onMessage: (event) => {
+		if (event.type === "ready") {
+			resolveReady();
+			return;
+		}
+		const frame = event.frame;
+		if (buffering) {
+			if (backlog.length >= MAX_RAW_FRAME_BACKLOG) {
+				const reason = "Raw JSON-RPC frame backlog exceeded";
+				finish(reason);
+				call.cancel(reason);
+				return;
+			}
+			backlog.push(frame);
+			return;
+		}
+		for (const listener of messageListeners) listener(frame);
+	} });
+	call.then(({ reason }) => finish(reason), (error) => {
+		rejectReady(error);
+		finish(error instanceof Error ? error.message : String(error));
+	});
+	await ready;
+	return {
+		get closed() {
+			return closed;
+		},
+		async send(frame) {
+			if (closed) throw new Error(`JSON-RPC transport is closed: ${closeReason ?? "closed"}`);
+			await call.send({ frame });
+		},
+		onMessage(listener) {
+			const registration = addListener(messageListeners, listener);
+			if (buffering) {
+				buffering = false;
+				for (const frame of backlog.splice(0)) listener(frame);
+			}
+			return registration;
+		},
+		onClose(listener) {
+			if (closed) {
+				let disposed = false;
+				queueMicrotask(() => {
+					if (!disposed) listener(closeReason);
+				});
+				return { dispose: () => {
+					disposed = true;
+				} };
+			}
+			return addListener(closeListeners, listener);
+		},
+		close(reason) {
+			finish(reason ?? "cancelled");
+			call.cancel(reason);
+		}
+	};
+}
+function addListener(listeners, listener) {
+	listeners.add(listener);
+	return { dispose: () => listeners.delete(listener) };
+}
+//#endregion
+//#region src/json-rpc/interface.ts
+const jsonRpcConnectionCloseReasonSchema = enum$1([
+	"cancelled",
+	"closed",
+	"disposed",
+	"remoteClosed"
+]);
+const rawFrameSchema = object({ frame: unknown() });
+/**
+* Opens a transparent JSON-RPC transport over one duplex LinkRPC request.
+* Frames are intentionally opaque; the endpoint owns JSON-RPC semantics.
+*/
+const jsonRpcConnectionInterface = defineInterface({
+	id: "jsonRpcConnection",
+	description: "Opens transparent JSON-RPC transports over LinkRPC streams."
+}, { connectRaw: requestType(object({ params: optional(unknown()) }), object({ reason: jsonRpcConnectionCloseReasonSchema }), { description: "Open a transparent JSON-RPC transport tied to this request. Cancellation closes the transport." }).withStream({
+	client: rawFrameSchema,
+	server: discriminatedUnion("type", [object({ type: literal("ready") }), object({
+		type: literal("frame"),
+		frame: unknown()
+	})])
+}) });
+//#endregion
+//#region src/json-rpc/messageTransport.ts
+/** Adapt a parsed JSON-RPC transport to the transport consumed by LinkRpcConnection. */
+function adaptJsonRpcTransport(transport, options = {}) {
+	const maxPendingMessages = options.maxPendingMessages ?? 1024;
+	if (!Number.isSafeInteger(maxPendingMessages) || maxPendingMessages < 1) throw new Error("maxPendingMessages must be a positive safe integer");
+	let listener;
+	const backlog = [];
+	const closeListeners = /* @__PURE__ */ new Set();
+	let closeReason;
+	let disposed = false;
+	const messages = transport.onMessage((frame) => {
+		if (transport.closed || disposed) return;
+		try {
+			const message = assertJsonRpcMessage(frame);
+			if (listener) listener(message);
+			else if (backlog.length < maxPendingMessages) backlog.push(message);
+			else transport.close(`JSON-RPC message backlog exceeded ${maxPendingMessages}`);
+		} catch (error) {
+			transport.close(error instanceof Error ? error.message : String(error));
+		}
+	});
+	const closeSubscription = transport.onClose((reason) => {
+		closeReason = reason;
+		listener = void 0;
+		backlog.length = 0;
+		for (const closeListener of closeListeners) closeListener(reason);
+		closeListeners.clear();
+	});
+	return {
+		get closed() {
+			return transport.closed;
+		},
+		get closeReason() {
+			return closeReason;
+		},
+		send(message) {
+			assertJsonRpcMessage(message);
+			return transport.send(message);
+		},
+		setListener(value) {
+			if (disposed || transport.closed) return;
+			listener = value;
+			while (listener && backlog.length > 0) listener(backlog.shift());
+		},
+		onClose(closeListener) {
+			if (transport.closed) {
+				let disposed = false;
+				queueMicrotask(() => {
+					if (!disposed) closeListener(closeReason);
+				});
+				return { dispose: () => {
+					disposed = true;
+				} };
+			}
+			closeListeners.add(closeListener);
+			return { dispose: () => closeListeners.delete(closeListener) };
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			messages.dispose();
+			listener = void 0;
+			backlog.length = 0;
+			transport.close("disposed");
+			closeSubscription.dispose();
+			closeListeners.clear();
+		}
+	};
+}
+function assertJsonRpcMessage(value) {
+	if (!isObject(value) || value.jsonrpc !== "2.0") throw new Error("Invalid external JSON-RPC message: expected jsonrpc \"2.0\"");
+	const hasMethod = typeof value.method === "string";
+	const hasId = Object.prototype.hasOwnProperty.call(value, "id");
+	if (hasMethod) {
+		if (hasId && !isRequestId(value.id)) throw new Error("Invalid external JSON-RPC request id");
+		if ("params" in value && value.params === void 0) throw new Error("Invalid external JSON-RPC params");
+		return value;
+	}
+	if (!hasId || !(value.id === null || isRequestId(value.id))) throw new Error("Invalid external JSON-RPC response id");
+	const hasResult = Object.prototype.hasOwnProperty.call(value, "result");
+	const hasError = Object.prototype.hasOwnProperty.call(value, "error");
+	if (hasResult === hasError) throw new Error("Invalid external JSON-RPC response: expected exactly one of result or error");
+	if (hasError) {
+		const error = value.error;
+		if (!isObject(error) || typeof error.code !== "number" || typeof error.message !== "string") throw new Error("Invalid external JSON-RPC error object");
+	}
+	return value;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRequestId(value) {
+	return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+//#endregion
+//#region src/json-rpc/server.ts
+/** Register a raw JSON-RPC transport factory on a LinkRPC connection. */
+function registerJsonRpcConnectionService(options) {
+	return options.connection.register(jsonRpcConnectionInterface, { connectRaw: async ({ params }, _ctx, stream) => {
+		const transport = await options.openTransport(params, stream.signal);
+		if (stream.signal.aborted) {
+			transport.close("cancelled");
+			return { reason: "cancelled" };
+		}
+		if (transport.closed) throw new Error("JSON-RPC transport closed before it was ready");
+		let settle;
+		const closed = new Promise((resolve) => {
+			let settled = false;
+			settle = (reason) => {
+				if (settled) return;
+				settled = true;
+				resolve(reason);
+			};
+		});
+		let outbound = Promise.resolve();
+		const messages = transport.onMessage((frame) => {
+			outbound = outbound.then(() => stream.send({
+				type: "frame",
+				frame
+			})).catch(() => settle("remoteClosed"));
+		});
+		const closure = transport.onClose(() => settle("remoteClosed"));
+		let inbound = Promise.resolve();
+		stream.onMessage(({ frame }) => {
+			inbound = inbound.then(() => transport.send(frame)).catch(() => settle("remoteClosed"));
+		});
+		await stream.send({ type: "ready" });
+		const abort = waitForAbort(stream.signal);
+		const reason = await Promise.race([closed, abort.promise.then(() => "cancelled")]);
+		abort.dispose();
+		messages.dispose();
+		closure.dispose();
+		transport.close(reason);
+		return { reason };
+	} }, options.serviceId === void 0 ? {} : { serviceId: options.serviceId });
+}
+function waitForAbort(signal) {
+	if (signal.aborted) return {
+		promise: Promise.resolve(),
+		dispose() {}
+	};
+	let resolve;
+	const promise = new Promise((r) => {
+		resolve = r;
+	});
+	const onAbort = () => resolve();
+	signal.addEventListener("abort", onAbort, { once: true });
+	return {
+		promise,
+		dispose() {
+			signal.removeEventListener("abort", onAbort);
+		}
+	};
+}
+//#endregion
+//#region src/json-rpc/stdio.ts
+const MAX_FRAME_BACKLOG = 1024;
+/** Adapt newline-delimited JSON-RPC stdio streams to a message transport. */
+function createNdjsonJsonRpcTransport(options) {
+	const messageListeners = /* @__PURE__ */ new Set();
+	const closeListeners = /* @__PURE__ */ new Set();
+	const backlog = [];
+	const lines = readline.createInterface({ input: options.input });
+	let closed = false;
+	let closeReason;
+	const finish = (reason) => {
+		if (closed) return;
+		closed = true;
+		closeReason = reason;
+		lines.close();
+		for (const listener of closeListeners) listener(reason);
+	};
+	lines.on("line", (line) => {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) return;
+		let frame;
+		try {
+			frame = JSON.parse(trimmed);
+		} catch (error) {
+			finish(`Invalid JSON-RPC NDJSON frame: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		if (messageListeners.size === 0) {
+			if (backlog.length >= MAX_FRAME_BACKLOG) {
+				finish("JSON-RPC stdio frame backlog exceeded");
+				return;
+			}
+			backlog.push(frame);
+			return;
+		}
+		for (const listener of messageListeners) listener(frame);
+	});
+	lines.on("close", () => finish("closed"));
+	options.input.on("error", (error) => finish(error.message));
+	options.output.on("error", (error) => finish(error.message));
+	return {
+		get closed() {
+			return closed;
+		},
+		send(frame) {
+			if (closed) return Promise.reject(/* @__PURE__ */ new Error("JSON-RPC stdio transport is closed"));
+			return new Promise((resolve, reject) => {
+				options.output.write(`${JSON.stringify(frame)}\n`, (error) => {
+					if (error) reject(error);
+					else resolve();
+				});
+			});
+		},
+		onMessage(listener) {
+			messageListeners.add(listener);
+			for (const frame of backlog.splice(0)) listener(frame);
+			return { dispose: () => messageListeners.delete(listener) };
+		},
+		onClose(listener) {
+			if (closed) {
+				let disposed = false;
+				queueMicrotask(() => {
+					if (!disposed) listener(closeReason);
+				});
+				return { dispose: () => {
+					disposed = true;
+				} };
+			}
+			closeListeners.add(listener);
+			return { dispose: () => closeListeners.delete(listener) };
+		},
+		close(reason) {
+			finish(reason);
+		}
+	};
+}
+//#endregion
+//#region src/json-rpc/transport.ts
+function connectJsonRpcTransports(left, right) {
+	let disposed = false;
+	const subscriptions = [
+		left.onMessage((frame) => {
+			right.send(frame).catch((error) => closeBoth(String(error)));
+		}),
+		right.onMessage((frame) => {
+			left.send(frame).catch((error) => closeBoth(String(error)));
+		}),
+		left.onClose((reason) => closeBoth(reason)),
+		right.onClose((reason) => closeBoth(reason))
+	];
+	const closeBoth = (reason) => {
+		if (disposed) return;
+		disposed = true;
+		for (const subscription of subscriptions) subscription.dispose();
+		left.close(reason);
+		right.close(reason);
+	};
+	return { dispose() {
+		if (disposed) return;
+		disposed = true;
+		for (const subscription of subscriptions) subscription.dispose();
+	} };
+}
+var JsonRpcTransportPair = class {
+	a;
+	b;
+	constructor() {
+		const a = new InMemoryJsonRpcTransport();
+		const b = new InMemoryJsonRpcTransport();
+		a.peer = b;
+		b.peer = a;
+		this.a = a;
+		this.b = b;
+	}
+};
+var InMemoryJsonRpcTransport = class {
+	peer;
+	_messageListeners = /* @__PURE__ */ new Set();
+	_closeListeners = /* @__PURE__ */ new Set();
+	_backlog = [];
+	_closed = false;
+	_closeReason;
+	send(frame) {
+		if (this._closed || this.peer._closed) return Promise.reject(/* @__PURE__ */ new Error("JSON-RPC transport is closed"));
+		queueMicrotask(() => this.peer._deliver(structuredClone(frame)));
+		return Promise.resolve();
+	}
+	get closed() {
+		return this._closed;
+	}
+	onMessage(listener) {
+		this._messageListeners.add(listener);
+		for (const frame of this._backlog.splice(0)) listener(frame);
+		return { dispose: () => this._messageListeners.delete(listener) };
+	}
+	onClose(listener) {
+		if (this._closed) {
+			let disposed = false;
+			queueMicrotask(() => {
+				if (!disposed) listener(this._closeReason);
+			});
+			return { dispose: () => {
+				disposed = true;
+			} };
+		}
+		this._closeListeners.add(listener);
+		return { dispose: () => this._closeListeners.delete(listener) };
+	}
+	close(reason) {
+		if (this._closed) return;
+		this._closed = true;
+		this._closeReason = reason;
+		for (const listener of this._closeListeners) listener(reason);
+		this.peer._remoteClosed(reason);
+	}
+	_deliver(frame) {
+		if (this._closed) return;
+		if (this._messageListeners.size === 0) {
+			this._backlog.push(frame);
+			return;
+		}
+		for (const listener of this._messageListeners) listener(frame);
+	}
+	_remoteClosed(reason) {
+		if (this._closed) return;
+		this._closed = true;
+		this._closeReason = reason;
+		for (const listener of this._closeListeners) listener(reason);
+	}
+};
+//#endregion
+export { JsonRpcTransportPair, adaptJsonRpcTransport, assertJsonRpcMessage, connectJsonRpcTransports, connectRawJsonRpcTransport, createNdjsonJsonRpcTransport, jsonRpcConnectionCloseReasonSchema, jsonRpcConnectionInterface, registerJsonRpcConnectionService };
+
+//# sourceMappingURL=index.js.map

package/dist/json-rpc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["zEnum"],"sources":["../../src/json-rpc/client.ts","../../src/json-rpc/interface.ts","../../src/json-rpc/messageTransport.ts","../../src/json-rpc/server.ts","../../src/json-rpc/stdio.ts","../../src/json-rpc/transport.ts"],"sourcesContent":["import type { InterfaceClient, JsonValue } from '@hediet/linkrpc';\nimport { jsonRpcConnectionInterface } from './interface';\nimport type { Disposable, JsonRpcTransport } from './transport';\n\ntype JsonRpcConnectionClient = InterfaceClient<typeof jsonRpcConnectionInterface>;\nconst MAX_RAW_FRAME_BACKLOG = 1_024;\n\nexport async function connectRawJsonRpcTransport(\n    client: JsonRpcConnectionClient,\n    params?: JsonValue,\n): Promise<JsonRpcTransport> {\n    const messageListeners = new Set<(frame: JsonValue) => void>();\n    const closeListeners = new Set<(reason?: string) => void>();\n    const backlog: JsonValue[] = [];\n    let buffering = true;\n    let closed = false;\n    let closeReason: string | undefined;\n\n    const finish = (reason?: string): void => {\n        if (closed) return;\n        closed = true;\n        closeReason = reason;\n        rejectReady(new Error(`Raw JSON-RPC transport closed before ready: ${reason ?? 'closed'}`));\n        for (const listener of closeListeners) listener(reason);\n    };\n\n    let resolveReady!: () => void;\n    let rejectReady!: (error: unknown) => void;\n    const ready = new Promise<void>((resolve, reject) => {\n        resolveReady = resolve;\n        rejectReady = reject;\n    });\n    const call = client.connectRaw(\n        params === undefined ? {} : { params },\n        {\n            onMessage: (event) => {\n                if (event.type === 'ready') {\n                    resolveReady();\n                    return;\n                }\n                const frame = event.frame as JsonValue;\n                if (buffering) {\n                    if (backlog.length >= MAX_RAW_FRAME_BACKLOG) {\n                        const reason = 'Raw JSON-RPC frame backlog exceeded';\n                        finish(reason);\n                        void call.cancel(reason);\n                        return;\n                    }\n                    backlog.push(frame);\n                    return;\n                }\n                for (const listener of messageListeners) listener(frame);\n            },\n        },\n    );\n    void call.then(\n        ({ reason }) => finish(reason),\n        (error) => {\n            rejectReady(error);\n            finish(error instanceof Error ? error.message : String(error));\n        },\n    );\n    await ready;\n\n    return {\n        get closed(): boolean {\n            return closed;\n        },\n        async send(frame): Promise<void> {\n            if (closed) {\n                throw new Error(`JSON-RPC transport is closed: ${closeReason ?? 'closed'}`);\n            }\n            await call.send({ frame });\n        },\n        onMessage(listener): Disposable {\n            const registration = addListener(messageListeners, listener);\n            if (buffering) {\n                buffering = false;\n                for (const frame of backlog.splice(0)) listener(frame);\n            }\n            return registration;\n        },\n        onClose(listener): Disposable {\n            if (closed) {\n                let disposed = false;\n                queueMicrotask(() => {\n                    if (!disposed) listener(closeReason);\n                });\n                return { dispose: () => { disposed = true; } };\n            }\n            return addListener(closeListeners, listener);\n        },\n        close(reason): void {\n            finish(reason ?? 'cancelled');\n            void call.cancel(reason);\n        },\n    };\n}\n\nfunction addListener<T>(listeners: Set<T>, listener: T): Disposable {\n    listeners.add(listener);\n    return { dispose: () => listeners.delete(listener) };\n}\n","import { defineInterface, requestType } from '@hediet/linkrpc';\nimport {\n    discriminatedUnion,\n    enum as zEnum,\n    literal,\n    object,\n    optional,\n    unknown,\n} from 'zod/mini';\n\nexport const jsonRpcConnectionCloseReasonSchema = zEnum([\n    'cancelled',\n    'closed',\n    'disposed',\n    'remoteClosed',\n]);\n\nexport type JsonRpcConnectionCloseReason =\n    | 'cancelled'\n    | 'closed'\n    | 'disposed'\n    | 'remoteClosed';\n\nconst rawFrameSchema = object({ frame: unknown() });\n\n/**\n * Opens a transparent JSON-RPC transport over one duplex LinkRPC request.\n * Frames are intentionally opaque; the endpoint owns JSON-RPC semantics.\n */\nexport const jsonRpcConnectionInterface = defineInterface(\n    {\n        id: 'jsonRpcConnection',\n        description: 'Opens transparent JSON-RPC transports over LinkRPC streams.',\n    },\n    {\n        connectRaw: requestType(\n            object({ params: optional(unknown()) }),\n            object({ reason: jsonRpcConnectionCloseReasonSchema }),\n            {\n                description:\n                    'Open a transparent JSON-RPC transport tied to this request. '\n                    + 'Cancellation closes the transport.',\n            },\n        ).withStream({\n            client: rawFrameSchema,\n            server: discriminatedUnion('type', [\n                object({ type: literal('ready') }),\n                object({ type: literal('frame'), frame: unknown() }),\n            ]),\n        }),\n    },\n);\n","import type {\n    IMessageTransport,\n    JsonRpcMessage,\n    JsonValue,\n} from '@hediet/linkrpc';\nimport type { Disposable, JsonRpcTransport } from './transport';\n\nexport interface CloseAwareMessageTransport<\n    TIncoming = JsonRpcMessage,\n    TOutgoing = JsonRpcMessage,\n> extends IMessageTransport<TIncoming, TOutgoing> {\n    readonly closed: boolean;\n    readonly closeReason: string | undefined;\n    onClose(listener: (reason?: string) => void): Disposable;\n}\n\n/** Adapt a parsed JSON-RPC transport to the transport consumed by LinkRpcConnection. */\nexport function adaptJsonRpcTransport(\n    transport: JsonRpcTransport,\n    options: { maxPendingMessages?: number } = {},\n): CloseAwareMessageTransport<JsonRpcMessage, JsonRpcMessage> {\n    const maxPendingMessages = options.maxPendingMessages ?? 1_024;\n    if (!Number.isSafeInteger(maxPendingMessages) || maxPendingMessages < 1) {\n        throw new Error('maxPendingMessages must be a positive safe integer');\n    }\n    let listener: ((message: JsonRpcMessage) => void) | undefined;\n    const backlog: JsonRpcMessage[] = [];\n    const closeListeners = new Set<(reason?: string) => void>();\n    let closeReason: string | undefined;\n    let disposed = false;\n    const messages = transport.onMessage((frame) => {\n        if (transport.closed || disposed) return;\n        try {\n            const message = assertJsonRpcMessage(frame);\n            if (listener) listener(message);\n            else if (backlog.length < maxPendingMessages) backlog.push(message);\n            else transport.close(`JSON-RPC message backlog exceeded ${maxPendingMessages}`);\n        } catch (error) {\n            transport.close(error instanceof Error ? error.message : String(error));\n        }\n    });\n    const closeSubscription = transport.onClose((reason) => {\n        closeReason = reason;\n        listener = undefined;\n        backlog.length = 0;\n        for (const closeListener of closeListeners) closeListener(reason);\n        closeListeners.clear();\n    });\n\n    return {\n        get closed(): boolean { return transport.closed; },\n        get closeReason(): string | undefined { return closeReason; },\n        send(message): Promise<void> {\n            assertJsonRpcMessage(message);\n            return transport.send(message as unknown as JsonValue);\n        },\n        setListener(value): void {\n            if (disposed || transport.closed) return;\n            listener = value;\n            while (listener && backlog.length > 0) listener(backlog.shift()!);\n        },\n        onClose(closeListener): Disposable {\n            if (transport.closed) {\n                let disposed = false;\n                queueMicrotask(() => { if (!disposed) closeListener(closeReason); });\n                return { dispose: () => { disposed = true; } };\n            }\n            closeListeners.add(closeListener);\n            return { dispose: () => closeListeners.delete(closeListener) };\n        },\n        dispose(): void {\n            if (disposed) return;\n            disposed = true;\n            messages.dispose();\n            listener = undefined;\n            backlog.length = 0;\n            transport.close('disposed');\n            closeSubscription.dispose();\n            closeListeners.clear();\n        },\n    };\n}\n\nexport function assertJsonRpcMessage(value: unknown): JsonRpcMessage {\n    if (!isObject(value) || value.jsonrpc !== '2.0') {\n        throw new Error('Invalid external JSON-RPC message: expected jsonrpc \"2.0\"');\n    }\n    const hasMethod = typeof value.method === 'string';\n    const hasId = Object.prototype.hasOwnProperty.call(value, 'id');\n    if (hasMethod) {\n        if (hasId && !isRequestId(value.id)) {\n            throw new Error('Invalid external JSON-RPC request id');\n        }\n        if ('params' in value && value.params === undefined) {\n            throw new Error('Invalid external JSON-RPC params');\n        }\n        return value as unknown as JsonRpcMessage;\n    }\n    if (!hasId || !(value.id === null || isRequestId(value.id))) {\n        throw new Error('Invalid external JSON-RPC response id');\n    }\n    const hasResult = Object.prototype.hasOwnProperty.call(value, 'result');\n    const hasError = Object.prototype.hasOwnProperty.call(value, 'error');\n    if (hasResult === hasError) {\n        throw new Error('Invalid external JSON-RPC response: expected exactly one of result or error');\n    }\n    if (hasError) {\n        const error = value.error;\n        if (!isObject(error) || typeof error.code !== 'number' || typeof error.message !== 'string') {\n            throw new Error('Invalid external JSON-RPC error object');\n        }\n    }\n    return value as unknown as JsonRpcMessage;\n}\n\nfunction isObject(value: unknown): value is Record<string, JsonValue> {\n    return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction isRequestId(value: unknown): value is string | number {\n    return typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value));\n}\n","import type {\n    InterfaceRegistration,\n    JsonValue,\n    LinkRpcConnection,\n} from '@hediet/linkrpc';\nimport {\n    jsonRpcConnectionInterface,\n    type JsonRpcConnectionCloseReason,\n} from './interface';\nimport type { JsonRpcTransport } from './transport';\n\nexport interface RegisterJsonRpcConnectionServiceOptions {\n    readonly connection: LinkRpcConnection<unknown>;\n    readonly serviceId?: string;\n    readonly openTransport: (\n        params: JsonValue | undefined,\n        signal: AbortSignal,\n    ) => Promise<JsonRpcTransport>;\n}\n\n/** Register a raw JSON-RPC transport factory on a LinkRPC connection. */\nexport function registerJsonRpcConnectionService(\n    options: RegisterJsonRpcConnectionServiceOptions,\n): InterfaceRegistration {\n    return options.connection.register(\n        jsonRpcConnectionInterface,\n        {\n            connectRaw: async ({ params }, _ctx, stream) => {\n                const transport = await options.openTransport(\n                    params as JsonValue | undefined,\n                    stream.signal,\n                );\n                if (stream.signal.aborted) {\n                    transport.close('cancelled');\n                    return { reason: 'cancelled' as const };\n                }\n                if (transport.closed) {\n                    throw new Error('JSON-RPC transport closed before it was ready');\n                }\n\n                let settle!: (reason: JsonRpcConnectionCloseReason) => void;\n                const closed = new Promise<JsonRpcConnectionCloseReason>((resolve) => {\n                    let settled = false;\n                    settle = (reason) => {\n                        if (settled) return;\n                        settled = true;\n                        resolve(reason);\n                    };\n                });\n                let outbound = Promise.resolve();\n                const messages = transport.onMessage((frame) => {\n                    outbound = outbound\n                        .then(() => stream.send({ type: 'frame', frame }))\n                        .catch(() => settle('remoteClosed'));\n                });\n                const closure = transport.onClose(() => settle('remoteClosed'));\n                let inbound = Promise.resolve();\n                stream.onMessage(({ frame }) => {\n                    inbound = inbound\n                        .then(() => transport.send(frame as JsonValue))\n                        .catch(() => settle('remoteClosed'));\n                });\n                await stream.send({ type: 'ready' });\n\n                const abort = waitForAbort(stream.signal);\n                const reason = await Promise.race([\n                    closed,\n                    abort.promise.then(() => 'cancelled' as const),\n                ]);\n                abort.dispose();\n                messages.dispose();\n                closure.dispose();\n                transport.close(reason);\n                return { reason };\n            },\n        },\n        options.serviceId === undefined ? {} : { serviceId: options.serviceId },\n    );\n}\n\nfunction waitForAbort(signal: AbortSignal): { promise: Promise<void>; dispose(): void; } {\n    if (signal.aborted) return { promise: Promise.resolve(), dispose() {} };\n    let resolve!: () => void;\n    const promise = new Promise<void>((r) => { resolve = r; });\n    const onAbort = (): void => resolve();\n    signal.addEventListener('abort', onAbort, { once: true });\n    return {\n        promise,\n        dispose(): void {\n            signal.removeEventListener('abort', onAbort);\n        },\n    };\n}\n","import * as readline from 'node:readline';\nimport type { JsonValue } from '@hediet/linkrpc';\nimport type { Disposable, JsonRpcTransport } from './transport';\n\nconst MAX_FRAME_BACKLOG = 1_024;\n\nexport interface NdjsonJsonRpcTransportOptions {\n    readonly input: NodeJS.ReadableStream;\n    readonly output: NodeJS.WritableStream;\n}\n\n/** Adapt newline-delimited JSON-RPC stdio streams to a message transport. */\nexport function createNdjsonJsonRpcTransport(\n    options: NdjsonJsonRpcTransportOptions,\n): JsonRpcTransport {\n    const messageListeners = new Set<(frame: JsonValue) => void>();\n    const closeListeners = new Set<(reason?: string) => void>();\n    const backlog: JsonValue[] = [];\n    const lines = readline.createInterface({ input: options.input });\n    let closed = false;\n    let closeReason: string | undefined;\n\n    const finish = (reason?: string): void => {\n        if (closed) return;\n        closed = true;\n        closeReason = reason;\n        lines.close();\n        for (const listener of closeListeners) listener(reason);\n    };\n\n    lines.on('line', (line) => {\n        const trimmed = line.trim();\n        if (trimmed.length === 0) return;\n        let frame: JsonValue;\n        try {\n            frame = JSON.parse(trimmed) as JsonValue;\n        } catch (error) {\n            finish(`Invalid JSON-RPC NDJSON frame: ${error instanceof Error ? error.message : String(error)}`);\n            return;\n        }\n        if (messageListeners.size === 0) {\n            if (backlog.length >= MAX_FRAME_BACKLOG) {\n                finish('JSON-RPC stdio frame backlog exceeded');\n                return;\n            }\n            backlog.push(frame);\n            return;\n        }\n        for (const listener of messageListeners) listener(frame);\n    });\n    lines.on('close', () => finish('closed'));\n    options.input.on('error', (error) => finish(error.message));\n    options.output.on('error', (error) => finish(error.message));\n\n    return {\n        get closed(): boolean {\n            return closed;\n        },\n        send(frame): Promise<void> {\n            if (closed) return Promise.reject(new Error('JSON-RPC stdio transport is closed'));\n            return new Promise<void>((resolve, reject) => {\n                options.output.write(`${JSON.stringify(frame)}\\n`, (error?: Error | null) => {\n                    if (error) reject(error);\n                    else resolve();\n                });\n            });\n        },\n        onMessage(listener): Disposable {\n            messageListeners.add(listener);\n            for (const frame of backlog.splice(0)) listener(frame);\n            return { dispose: () => messageListeners.delete(listener) };\n        },\n        onClose(listener): Disposable {\n            if (closed) {\n                let disposed = false;\n                queueMicrotask(() => {\n                    if (!disposed) listener(closeReason);\n                });\n                return { dispose: () => { disposed = true; } };\n            }\n            closeListeners.add(listener);\n            return { dispose: () => closeListeners.delete(listener) };\n        },\n        close(reason): void {\n            finish(reason);\n        },\n    };\n}\n","import type { JsonValue } from '@hediet/linkrpc';\n\nexport interface Disposable {\n    dispose(): void;\n}\n\n/** A message-oriented transport carrying already parsed JSON-RPC frames. */\nexport interface JsonRpcTransport {\n    readonly closed: boolean;\n    send(frame: JsonValue): Promise<void>;\n    onMessage(listener: (frame: JsonValue) => void): Disposable;\n    onClose(listener: (reason?: string) => void): Disposable;\n    close(reason?: string): void;\n}\n\nexport function connectJsonRpcTransports(\n    left: JsonRpcTransport,\n    right: JsonRpcTransport,\n): Disposable {\n    let disposed = false;\n    const subscriptions = [\n        left.onMessage((frame) => {\n            void right.send(frame).catch((error) => closeBoth(String(error)));\n        }),\n        right.onMessage((frame) => {\n            void left.send(frame).catch((error) => closeBoth(String(error)));\n        }),\n        left.onClose((reason) => closeBoth(reason)),\n        right.onClose((reason) => closeBoth(reason)),\n    ];\n    const closeBoth = (reason?: string): void => {\n        if (disposed) return;\n        disposed = true;\n        for (const subscription of subscriptions) subscription.dispose();\n        left.close(reason);\n        right.close(reason);\n    };\n    return {\n        dispose(): void {\n            if (disposed) return;\n            disposed = true;\n            for (const subscription of subscriptions) subscription.dispose();\n        },\n    };\n}\n\nexport class JsonRpcTransportPair {\n    public readonly a: JsonRpcTransport;\n    public readonly b: JsonRpcTransport;\n\n    public constructor() {\n        const a = new InMemoryJsonRpcTransport();\n        const b = new InMemoryJsonRpcTransport();\n        a.peer = b;\n        b.peer = a;\n        this.a = a;\n        this.b = b;\n    }\n}\n\nclass InMemoryJsonRpcTransport implements JsonRpcTransport {\n    public peer!: InMemoryJsonRpcTransport;\n    private readonly _messageListeners = new Set<(frame: JsonValue) => void>();\n    private readonly _closeListeners = new Set<(reason?: string) => void>();\n    private readonly _backlog: JsonValue[] = [];\n    private _closed = false;\n    private _closeReason: string | undefined;\n\n    public send(frame: JsonValue): Promise<void> {\n        if (this._closed || this.peer._closed) {\n            return Promise.reject(new Error('JSON-RPC transport is closed'));\n        }\n        queueMicrotask(() => this.peer._deliver(structuredClone(frame)));\n        return Promise.resolve();\n    }\n\n    public get closed(): boolean {\n        return this._closed;\n    }\n\n    public onMessage(listener: (frame: JsonValue) => void): Disposable {\n        this._messageListeners.add(listener);\n        for (const frame of this._backlog.splice(0)) listener(frame);\n        return { dispose: () => this._messageListeners.delete(listener) };\n    }\n\n    public onClose(listener: (reason?: string) => void): Disposable {\n        if (this._closed) {\n            let disposed = false;\n            queueMicrotask(() => {\n                if (!disposed) listener(this._closeReason);\n            });\n            return { dispose: () => { disposed = true; } };\n        }\n        this._closeListeners.add(listener);\n        return { dispose: () => this._closeListeners.delete(listener) };\n    }\n\n    public close(reason?: string): void {\n        if (this._closed) return;\n        this._closed = true;\n        this._closeReason = reason;\n        for (const listener of this._closeListeners) listener(reason);\n        this.peer._remoteClosed(reason);\n    }\n\n    private _deliver(frame: JsonValue): void {\n        if (this._closed) return;\n        if (this._messageListeners.size === 0) {\n            this._backlog.push(frame);\n            return;\n        }\n        for (const listener of this._messageListeners) listener(frame);\n    }\n\n    private _remoteClosed(reason?: string): void {\n        if (this._closed) return;\n        this._closed = true;\n        this._closeReason = reason;\n        for (const listener of this._closeListeners) listener(reason);\n    }\n}\n"],"mappings":"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"}

package/dist/logging/index.d.ts

@@ -0,0 +1,118 @@
+import { Schema } from "@hediet/linkrpc";
+import { output } from "zod/v4/core";
+//#region src/logging/index.d.ts
+declare const logLevelSchema: import("zod/mini").ZodMiniEnum<{
+  trace: "trace";
+  debug: "debug";
+  info: "info";
+  warn: "warn";
+  error: "error";
+  off: "off";
+}>;
+type LogLevel = output<typeof logLevelSchema>;
+type EmittedLogLevel = Exclude<LogLevel, 'off'>;
+interface LogError {
+  readonly name?: string;
+  readonly message: string;
+  readonly stack?: string;
+}
+interface LogEntry {
+  readonly timestamp: string;
+  readonly level: EmittedLogLevel;
+  readonly message: string;
+  readonly attributes?: Readonly<Record<string, unknown>>;
+  readonly entries?: readonly LogEntry[];
+  readonly durationMs?: number;
+  readonly error?: LogError;
+}
+interface LogDocument {
+  readonly schemaVersion: 1;
+  readonly service: string;
+  readonly startedAt: string;
+  readonly state: Readonly<Record<string, unknown>>;
+  readonly entries: readonly LogEntry[];
+}
+declare const logEntrySchema: Schema<LogEntry>;
+declare const logDocumentSchema: Schema<LogDocument>;
+declare const logStreamEventSchema: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+  type: import("zod/mini").ZodMiniLiteral<"snapshot">;
+  revision: import("zod/mini").ZodMiniNumber<number>;
+  document: Schema<LogDocument>;
+}, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+  type: import("zod/mini").ZodMiniLiteral<"patch">;
+  revision: import("zod/mini").ZodMiniNumber<number>;
+  edits: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+    op: import("zod/mini").ZodMiniLiteral<"set">;
+    path: import("zod/mini").ZodMiniString<string>;
+    value: import("zod/mini").ZodMiniUnknown;
+  }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+    op: import("zod/mini").ZodMiniLiteral<"remove">;
+    path: import("zod/mini").ZodMiniString<string>;
+  }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+    op: import("zod/mini").ZodMiniLiteral<"append">;
+    path: import("zod/mini").ZodMiniString<string>;
+    value: import("zod/mini").ZodMiniString<string>;
+  }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+    op: import("zod/mini").ZodMiniLiteral<"splice">;
+    path: import("zod/mini").ZodMiniString<string>;
+    offset: import("zod/mini").ZodMiniNumber<number>;
+    delete: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+    insert: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+  }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+    op: import("zod/mini").ZodMiniLiteral<"insert">;
+    path: import("zod/mini").ZodMiniString<string>;
+    index: import("zod/mini").ZodMiniNumber<number>;
+    value: import("zod/mini").ZodMiniUnknown;
+  }, import("zod/v4/core").$strip>], "op">>;
+}, import("zod/v4/core").$strip>], "type">;
+type LogStreamEvent = output<typeof logStreamEventSchema>;
+/**
+ * Standard structured-log protocol. Implementations choose their own storage,
+ * retention, and sinks; this definition specifies only the LinkRPC wire API.
+ */
+declare const loggingInterface: import("@hediet/linkrpc").InterfaceDefinition<{
+  getLogLevel: import("@hediet/linkrpc").RequestType<Record<string, never>, {
+    level: "trace" | "debug" | "info" | "warn" | "error" | "off";
+  }, any, never, never>;
+  getLogSnapshot: import("@hediet/linkrpc").RequestType<Record<string, never>, {
+    revision: number;
+    document: LogDocument;
+  }, any, never, never>;
+  setLogLevel: import("@hediet/linkrpc").RequestType<{
+    level: "trace" | "debug" | "info" | "warn" | "error" | "off";
+  }, Record<string, never>, any, never, never>;
+  watchLog: import("@hediet/linkrpc").RequestType<Record<string, never>, Record<string, never>, void, any, {
+    type: "snapshot";
+    revision: number;
+    document: LogDocument;
+  } | {
+    type: "patch";
+    revision: number;
+    edits: ({
+      op: "set";
+      path: string;
+      value: unknown;
+    } | {
+      op: "remove";
+      path: string;
+    } | {
+      op: "append";
+      path: string;
+      value: string;
+    } | {
+      op: "splice";
+      path: string;
+      offset: number;
+      delete?: number | undefined;
+      insert?: string | undefined;
+    } | {
+      op: "insert";
+      path: string;
+      index: number;
+      value: unknown;
+    })[];
+  }>;
+}>;
+//#endregion
+export { EmittedLogLevel, LogDocument, LogEntry, LogError, LogLevel, LogStreamEvent, logDocumentSchema, logEntrySchema, logLevelSchema, logStreamEventSchema, loggingInterface };
+//# sourceMappingURL=index.d.ts.map