@dxos/rpc 0.10.0 → 0.11.0

package/dist/lib/index.mjs

@@ -0,0 +1,948 @@
+import * as RpcClient from "@effect/rpc/RpcClient";
+import * as RpcClientError from "@effect/rpc/RpcClientError";
+import * as RpcMessage from "@effect/rpc/RpcMessage";
+import * as RpcSerialization from "@effect/rpc/RpcSerialization";
+import * as RpcServer from "@effect/rpc/RpcServer";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Mailbox from "effect/Mailbox";
+import * as Option from "effect/Option";
+import { log } from "@dxos/log";
+import { StackTrace } from "@dxos/debug";
+import { RpcClosedError, RpcNotOpenError, decodeError, encodeError } from "@dxos/protocols";
+import { Event, Trigger, asyncTimeout, synchronized } from "@dxos/async";
+import { Stream } from "@dxos/codec-protobuf";
+import { ContextRpcCodec } from "@dxos/context";
+import { invariant } from "@dxos/invariant";
+import { schema } from "@dxos/protocols/proto";
+import { exponentialBackoffInterval, isNode } from "@dxos/util";
+import { MessageTrace } from "@dxos/protocols/proto/dxos/rpc";
+//#region src/effect-rpc.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/core/mesh/rpc/src/effect-rpc.ts";
+/**
+* Interval at which the client re-sends the initial Ping while waiting for the server to attach.
+*/
+var HANDSHAKE_RETRY_INTERVAL = Duration.millis(50);
+/**
+* Effect RPC protocols over a {@link RpcPort} — a transport-agnostic, reliable, ordered,
+* binary message channel. Message envelopes are framed with msgpack; RPC payloads are expected
+* to already be binary-safe (e.g. protobuf-encoded by the payload schemas).
+*/
+var subscribePort = (port) => Effect.gen(function* () {
+	const mailbox = yield* Mailbox.make();
+	const unsubscribe = port.subscribe((message) => {
+		mailbox.unsafeOffer(message);
+	});
+	yield* Effect.addFinalizer(() => Effect.sync(() => {
+		unsubscribe?.();
+	}));
+	return mailbox;
+});
+var sendFrame = (port, frame) => frame === void 0 || typeof frame === "string" ? Effect.dieMessage("rpc-port protocol requires binary frames") : Effect.tryPromise({
+	try: async () => port.send(frame.slice()),
+	catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
+});
+/**
+* Client-side effect-rpc protocol over an {@link RpcPort}.
+*
+* Performs a Ping/Pong handshake on construction: the server answers Pings as soon as it is
+* running, so construction blocks until the peer is reachable and fails fast under an outer
+* timeout instead of buffering requests towards a peer that never attaches.
+*/
+var makeProtocolRpcPortClient = (port) => RpcClient.Protocol.make(Effect.fnUntraced(function* (writeResponse) {
+	const parser = RpcSerialization.msgPack.unsafeMake();
+	const mailbox = yield* subscribePort(port);
+	const decodeFrame = (frame) => Effect.try({
+		try: () => parser.decode(frame),
+		catch: (cause) => {
+			log.warn("rpc-port client: failed to decode frame", { cause }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 75,
+				S: this
+			});
+			return [];
+		}
+	}).pipe(Effect.merge);
+	const send = (request) => Effect.suspend(() => sendFrame(port, parser.encode(request))).pipe(Effect.mapError((cause) => new RpcClientError.RpcClientError({
+		reason: "Protocol",
+		message: "Failed to send message over RpcPort",
+		cause
+	})));
+	yield* Effect.gen(function* () {
+		let connected = false;
+		while (!connected) {
+			yield* send(RpcMessage.constPing);
+			const frame = yield* mailbox.take.pipe(Effect.timeoutOption(HANDSHAKE_RETRY_INTERVAL));
+			if (Option.isNone(frame)) continue;
+			for (const response of yield* decodeFrame(frame.value)) if (response._tag === "Pong") connected = true;
+			else yield* writeResponse(response);
+		}
+	}).pipe(Effect.orDie);
+	yield* mailbox.take.pipe(Effect.flatMap(decodeFrame), Effect.flatMap((responses) => Effect.forEach(responses, writeResponse, { discard: true })), Effect.forever, Effect.orDie, Effect.interruptible, Effect.forkScoped);
+	return {
+		send,
+		supportsAck: true,
+		supportsTransferables: false
+	};
+}));
+var layerProtocolRpcPortClient = (port) => Layer.scoped(RpcClient.Protocol, makeProtocolRpcPortClient(port));
+/**
+* Server-side effect-rpc protocol over an {@link RpcPort}.
+* The port carries a single logical client for the lifetime of the protocol.
+*/
+var makeProtocolRpcPortServer = (port) => RpcServer.Protocol.make(Effect.fnUntraced(function* (writeRequest) {
+	const parser = RpcSerialization.msgPack.unsafeMake();
+	const mailbox = yield* subscribePort(port);
+	const disconnects = yield* Mailbox.make();
+	const clientId = 0;
+	yield* mailbox.take.pipe(Effect.flatMap((frame) => Effect.try({
+		try: () => parser.decode(frame),
+		catch: (cause) => {
+			log.warn("rpc-port server: failed to decode frame", { cause }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 151,
+				S: this
+			});
+			return [];
+		}
+	}).pipe(Effect.merge)), Effect.flatMap((requests) => Effect.forEach(requests, (request) => writeRequest(clientId, request), { discard: true })), Effect.forever, Effect.interruptible, Effect.forkScoped);
+	return {
+		disconnects,
+		send: (_clientId, response) => Effect.suspend(() => sendFrame(port, parser.encode(response))).pipe(Effect.orDie),
+		end: (_clientId) => Effect.void,
+		clientIds: Effect.sync(() => /* @__PURE__ */ new Set([clientId])),
+		initialMessage: Effect.succeed(Option.none()),
+		supportsAck: true,
+		supportsTransferables: false,
+		supportsSpanPropagation: false
+	};
+}));
+var layerProtocolRpcPortServer = (port) => Layer.scoped(RpcServer.Protocol, makeProtocolRpcPortServer(port));
+//#endregion
+//#region src/errors.ts
+var decodeRpcError = (err, rpcMethod) => decodeError(err, { appendStack: `\n    at RPC ${rpcMethod} \n` + new StackTrace().getStack(1) });
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/rpc.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/core/mesh/rpc/src/rpc.ts";
+var DEFAULT_TIMEOUT = 3e4;
+var BYE_SEND_TIMEOUT = 2e3;
+var CLOSE_TIMEOUT = 3e3;
+var PendingRpcRequest = class {
+	resolve;
+	reject;
+	stream;
+	constructor(resolve, reject, stream) {
+		this.resolve = resolve;
+		this.reject = reject;
+		this.stream = stream;
+	}
+};
+var RpcMessageCodec;
+var getRpcMessageCodec = () => RpcMessageCodec ??= schema.getCodecForType("dxos.rpc.RpcMessage");
+/**
+* A remote procedure call peer.
+*
+* Provides a away to make RPC calls and get a response back as a promise.
+* Does not handle encoding/decoding and only works with byte buffers.
+* For type safe approach see `createRpcClient` and `createRpcServer`.
+*
+* Must be connected with another instance on the other side via `send`/`receive` methods.
+* Both sides must be opened before making any RPC calls.
+*
+* Errors inside the handler get serialized and sent to the other side.
+*
+* Inspired by JSON-RPC 2.0 https://www.jsonrpc.org/specification.
+*/
+var RpcPeer = class {
+	_params;
+	_outgoingRequests = /* @__PURE__ */ new Map();
+	_localStreams = /* @__PURE__ */ new Map();
+	_remoteOpenTrigger = new Trigger();
+	/**
+	* Triggered when the peer starts closing.
+	*/
+	_closingTrigger = new Trigger();
+	/**
+	* Triggered when peer receives a bye message.
+	*/
+	_byeTrigger = new Trigger();
+	_nextId = 0;
+	_state = "INITIAL";
+	_unsubscribeFromPort = void 0;
+	_clearOpenInterval = void 0;
+	constructor(params) {
+		this._params = {
+			timeout: void 0,
+			streamHandler: void 0,
+			noHandshake: false,
+			...params
+		};
+	}
+	/**
+	* Open the peer. Required before making any calls.
+	*
+	* Will block before the other peer calls `open`.
+	*/
+	async open() {
+		if (this._state !== "INITIAL") return;
+		this._unsubscribeFromPort = this._params.port.subscribe(async (msg) => {
+			try {
+				await this._receive(msg);
+			} catch (err) {
+				log.catch(err, void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 157,
+					S: this
+				});
+			}
+		});
+		this._state = "OPENING";
+		if (this._params.noHandshake) {
+			this._state = "OPENED";
+			this._remoteOpenTrigger.wake();
+			return;
+		}
+		log("sending open message", { state: this._state }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 169,
+			S: this
+		});
+		await this._sendMessage({ open: true });
+		if (this._state !== "OPENING") return;
+		this._clearOpenInterval = exponentialBackoffInterval(() => {
+			this._sendMessage({ open: true }).catch((err) => log.warn(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 178,
+				S: this
+			}));
+		}, 50);
+		await Promise.race([this._remoteOpenTrigger.wait(), this._closingTrigger.wait()]);
+		this._clearOpenInterval?.();
+		if (this._state !== "OPENED") return;
+		log("resending open message", { state: this._state }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 192,
+			S: this
+		});
+		await this._sendMessage({ openAck: true });
+	}
+	/**
+	* Close the peer.
+	* Stop taking or making requests.
+	* Will wait for confirmation from the other side.
+	* Any responses for RPC calls made before close will be delivered.
+	*/
+	async close({ timeout = CLOSE_TIMEOUT } = {}) {
+		if (this._state === "CLOSED") return;
+		this._abortRequests();
+		if (this._state === "OPENED" && !this._params.noHandshake) {
+			try {
+				this._state = "CLOSING";
+				await this._sendMessage({ bye: {} }, BYE_SEND_TIMEOUT);
+			} catch (err) {
+				log("error closing peer, sending bye", { err }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 214,
+					S: this
+				});
+			}
+			try {
+				log("closing waiting on bye", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 217,
+					S: this
+				});
+				await this._byeTrigger.wait({ timeout });
+			} catch (err) {
+				log("error closing peer", { err }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 220,
+					S: this
+				});
+				return;
+			}
+		}
+		this._disposeAndClose();
+	}
+	/**
+	* Dispose the connection without waiting for the other side.
+	*/
+	async abort() {
+		if (this._state === "CLOSED") return;
+		this._abortRequests();
+		this._disposeAndClose();
+	}
+	_abortRequests() {
+		this._clearOpenInterval?.();
+		this._closingTrigger.wake();
+		for (const req of this._outgoingRequests.values()) req.reject(new RpcClosedError());
+		this._outgoingRequests.clear();
+	}
+	_disposeAndClose() {
+		this._unsubscribeFromPort?.();
+		this._unsubscribeFromPort = void 0;
+		this._clearOpenInterval?.();
+		this._state = "CLOSED";
+	}
+	/**
+	* Handle incoming message. Should be called as the result of other peer's `send` callback.
+	*/
+	async _receive(msg) {
+		const decoded = getRpcMessageCodec().decode(msg, { preserveAny: true });
+		log.trace("received message", { type: Object.keys(decoded)[0] }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 264,
+			S: this
+		});
+		if (decoded.request) {
+			if (this._state !== "OPENED" && this._state !== "OPENING") {
+				log("received request while closed", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 268,
+					S: this
+				});
+				await this._sendMessage({ response: {
+					id: decoded.request.id,
+					error: encodeError(new RpcClosedError())
+				} });
+				return;
+			}
+			const req = decoded.request;
+			if (req.stream) {
+				log("stream request", { method: req.method }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 280,
+					S: this
+				});
+				this._callStreamHandler(req, (response) => {
+					log.trace("sending stream response", {
+						method: req.method,
+						response: response.payload?.type_url,
+						error: response.error,
+						close: response.close
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 282,
+						S: this
+					});
+					this._sendMessage({ response }).catch((err) => {
+						log.warn("failed during close", err, {
+							"~LogMeta": "~LogMeta",
+							F: __dxlog_file$1,
+							L: 290,
+							S: this
+						});
+					});
+				});
+			} else {
+				log.trace("requesting...", { method: req.method }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 294,
+					S: this
+				});
+				const response = await this._callHandler(req);
+				log.trace("sending response", {
+					method: req.method,
+					response: response.payload?.type_url,
+					error: response.error
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 297,
+					S: this
+				});
+				await this._sendMessage({ response });
+			}
+		} else if (decoded.response) {
+			if (this._state !== "OPENED") {
+				log("received response while closed", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 306,
+					S: this
+				});
+				return;
+			}
+			const responseId = decoded.response.id;
+			invariant(typeof responseId === "number", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 311,
+				S: this,
+				A: ["typeof responseId === 'number'", ""]
+			});
+			if (!this._outgoingRequests.has(responseId)) {
+				log.trace("received response with invalid id", { responseId }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 313,
+					S: this
+				});
+				return;
+			}
+			const item = this._outgoingRequests.get(responseId);
+			if (!item.stream) this._outgoingRequests.delete(responseId);
+			log.trace("response", { type_url: decoded.response.payload?.type_url }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 323,
+				S: this
+			});
+			item.resolve(decoded.response);
+		} else if (decoded.open) {
+			log("received open message", { state: this._state }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 326,
+				S: this
+			});
+			if (this._params.noHandshake) return;
+			await this._sendMessage({ openAck: true });
+		} else if (decoded.openAck) {
+			log("received openAck message", { state: this._state }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 333,
+				S: this
+			});
+			if (this._params.noHandshake) return;
+			this._state = "OPENED";
+			this._remoteOpenTrigger.wake();
+		} else if (decoded.streamClose) {
+			if (this._state !== "OPENED") {
+				log("received stream close while closed", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 342,
+					S: this
+				});
+				return;
+			}
+			log("received stream close", { id: decoded.streamClose.id }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 346,
+				S: this
+			});
+			invariant(typeof decoded.streamClose.id === "number", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 347,
+				S: this,
+				A: ["typeof decoded.streamClose.id === 'number'", ""]
+			});
+			const stream = this._localStreams.get(decoded.streamClose.id);
+			if (!stream) {
+				log("no local stream", { id: decoded.streamClose.id }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 350,
+					S: this
+				});
+				return;
+			}
+			this._localStreams.delete(decoded.streamClose.id);
+			await stream.close();
+		} else if (decoded.bye) {
+			this._byeTrigger.wake();
+			if (this._state !== "CLOSING" && this._state !== "CLOSED") {
+				log("replying to bye", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 360,
+					S: this
+				});
+				this._state = "CLOSING";
+				await this._sendMessage({ bye: {} });
+				this._abortRequests();
+				this._disposeAndClose();
+			}
+		} else {
+			log.error("received malformed message", { msg }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 368,
+				S: this
+			});
+			throw new Error("Malformed message.");
+		}
+	}
+	/**
+	* Make RPC call. Will trigger a handler on the other side.
+	* Peer should be open before making this call.
+	*/
+	async call(method, request, options) {
+		log.trace("calling...", { method }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 378,
+			S: this
+		});
+		throwIfNotOpen(this._state);
+		let response;
+		try {
+			const id = this._nextId++;
+			const responseReceived = new Promise((resolve, reject) => {
+				this._outgoingRequests.set(id, new PendingRpcRequest(resolve, reject, false));
+			});
+			let traceContext;
+			try {
+				traceContext = options?.ctx ? ContextRpcCodec.encode(options.ctx) : void 0;
+			} catch (err) {
+				log.warn("failed to encode trace context", { err }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 393,
+					S: this
+				});
+			}
+			const sending = this._sendMessage({ request: {
+				id,
+				method,
+				payload: request,
+				stream: false,
+				...traceContext ? { traceContext } : {}
+			} });
+			const timeout = options?.timeout ?? this._params.timeout;
+			const waiting = timeout === 0 ? responseReceived : asyncTimeout(responseReceived, timeout ?? DEFAULT_TIMEOUT);
+			await Promise.race([sending, waiting]);
+			response = await waiting;
+			invariant(response.id === id, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 414,
+				S: this,
+				A: ["response.id === id", ""]
+			});
+		} catch (err) {
+			if (err instanceof RpcClosedError) {
+				const error = new RpcClosedError();
+				error.stack += `\n\n info: RPC client was closed at:\n${err.stack?.split("\n").slice(1).join("\n")}`;
+				throw error;
+			}
+			throw err;
+		}
+		if (response.payload) return response.payload;
+		else if (response.error) throw decodeRpcError(response.error, method);
+		else throw new Error("Malformed response.");
+	}
+	/**
+	* Make RPC call with a streaming response.
+	* Will trigger a handler on the other side.
+	* Peer should be open before making this call.
+	*/
+	callStream(method, request, options) {
+		throwIfNotOpen(this._state);
+		const id = this._nextId++;
+		return new Stream(({ ready, next, close }) => {
+			const onResponse = (response) => {
+				if (response.streamReady) ready();
+				else if (response.close) close();
+				else if (response.error) close(decodeRpcError(response.error, method));
+				else if (response.payload) next(response.payload);
+				else throw new Error("Malformed response.");
+			};
+			const stack = new StackTrace();
+			const closeStream = (err) => {
+				if (!err) close();
+				else {
+					err.stack += `\n\nError happened in the stream at:\n${stack.getStack()}`;
+					close(err);
+				}
+			};
+			this._outgoingRequests.set(id, new PendingRpcRequest(onResponse, closeStream, true));
+			let traceContext;
+			try {
+				traceContext = options?.ctx ? ContextRpcCodec.encode(options.ctx) : void 0;
+			} catch (err) {
+				log.warn("failed to encode trace context", { err }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 476,
+					S: this
+				});
+			}
+			try {
+				this._sendMessage({ request: {
+					id,
+					method,
+					payload: request,
+					stream: true,
+					...traceContext ? { traceContext } : {}
+				} }).catch((err) => {
+					this._outgoingRequests.delete(id);
+					close(err);
+				});
+			} catch (err) {
+				this._outgoingRequests.delete(id);
+				throw err;
+			}
+			return () => {
+				this._sendMessage({ streamClose: { id } }).catch((err) => {
+					log.catch(err, void 0, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 501,
+						S: this
+					});
+				});
+				this._outgoingRequests.delete(id);
+			};
+		});
+	}
+	async _sendMessage(message, timeout) {
+		log.trace("sending message", { type: Object.keys(message)[0] }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 509,
+			S: this
+		});
+		await this._params.port.send(getRpcMessageCodec().encode(message, { preserveAny: true }), timeout);
+	}
+	_getHandlerRpcOptions(req) {
+		let traceCtx;
+		if (req.traceContext) try {
+			traceCtx = ContextRpcCodec.decode(req.traceContext);
+		} catch (err) {
+			log.warn("failed to decode trace context", {
+				traceContext: req.traceContext,
+				err
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 519,
+				S: this
+			});
+		}
+		if (!traceCtx && !this._params.handlerRpcOptions) return;
+		return {
+			...this._params.handlerRpcOptions,
+			...traceCtx ? { ctx: traceCtx } : {}
+		};
+	}
+	async _callHandler(req) {
+		try {
+			invariant(typeof req.id === "number", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 530,
+				S: this,
+				A: ["typeof req.id === 'number'", ""]
+			});
+			invariant(req.payload, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 531,
+				S: this,
+				A: ["req.payload", ""]
+			});
+			invariant(req.method, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 532,
+				S: this,
+				A: ["req.method", ""]
+			});
+			const response = await this._params.callHandler(req.method, req.payload, this._getHandlerRpcOptions(req));
+			return {
+				id: req.id,
+				payload: response
+			};
+		} catch (err) {
+			return {
+				id: req.id,
+				error: encodeError(err)
+			};
+		}
+	}
+	_callStreamHandler(req, callback) {
+		try {
+			invariant(this._params.streamHandler, "Requests with streaming responses are not supported.", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 549,
+				S: this,
+				A: ["this._params.streamHandler", "'Requests with streaming responses are not supported.'"]
+			});
+			invariant(typeof req.id === "number", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 550,
+				S: this,
+				A: ["typeof req.id === 'number'", ""]
+			});
+			invariant(req.payload, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 551,
+				S: this,
+				A: ["req.payload", ""]
+			});
+			invariant(req.method, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 552,
+				S: this,
+				A: ["req.method", ""]
+			});
+			const responseStream = this._params.streamHandler(req.method, req.payload, this._getHandlerRpcOptions(req));
+			responseStream.onReady(() => {
+				callback({
+					id: req.id,
+					streamReady: true
+				});
+			});
+			responseStream.subscribe((msg) => {
+				callback({
+					id: req.id,
+					payload: msg
+				});
+			}, (error) => {
+				if (error) callback({
+					id: req.id,
+					error: encodeError(error)
+				});
+				else callback({
+					id: req.id,
+					close: true
+				});
+			});
+			this._localStreams.set(req.id, responseStream);
+		} catch (err) {
+			callback({
+				id: req.id,
+				error: encodeError(err)
+			});
+		}
+	}
+};
+__decorate([synchronized], RpcPeer.prototype, "open", null);
+var throwIfNotOpen = (state) => {
+	switch (state) {
+		case "OPENED": return;
+		case "INITIAL": throw new RpcNotOpenError();
+		case "CLOSED": throw new RpcClosedError();
+	}
+};
+//#endregion
+//#region src/service.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/mesh/rpc/src/service.ts";
+/**
+* Groups multiple services together to be served by a single RPC peer.
+*/
+var createServiceBundle = (services) => services;
+/**
+* Type-safe RPC peer.
+*/
+var ProtoRpcPeer = class {
+	rpc;
+	_peer;
+	constructor(rpc, _peer) {
+		this.rpc = rpc;
+		this._peer = _peer;
+	}
+	async open() {
+		await this._peer.open();
+	}
+	async close() {
+		await this._peer.close();
+	}
+	async abort() {
+		await this._peer.abort();
+	}
+};
+/**
+* Create type-safe RPC peer from a service bundle.
+* Can both handle and issue requests.
+*/
+var createProtoRpcPeer = ({ requested, exposed, handlers, encodingOptions, ...rest }) => {
+	const exposedRpcs = {};
+	if (exposed) {
+		invariant(handlers, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 93,
+			S: void 0,
+			A: ["handlers", ""]
+		});
+		for (const serviceName of Object.keys(exposed)) {
+			const serviceFqn = exposed[serviceName].serviceProto.fullName.slice(1);
+			const serviceProvider = handlers[serviceName];
+			exposedRpcs[serviceFqn] = exposed[serviceName].createServer(serviceProvider, encodingOptions);
+		}
+	}
+	const peer = new RpcPeer({
+		...rest,
+		callHandler: (method, request, options) => {
+			const [serviceName, methodName] = parseMethodName(method);
+			if (!exposedRpcs[serviceName]) throw new Error(`Service not supported: ${serviceName}`);
+			return exposedRpcs[serviceName].call(methodName, request, options);
+		},
+		streamHandler: (method, request, options) => {
+			const [serviceName, methodName] = parseMethodName(method);
+			if (!exposedRpcs[serviceName]) throw new Error(`Service not supported: ${serviceName}`);
+			return exposedRpcs[serviceName].callStream(methodName, request, options);
+		}
+	});
+	const requestedRpcs = {};
+	if (requested) for (const serviceName of Object.keys(requested)) {
+		const serviceFqn = requested[serviceName].serviceProto.fullName.slice(1);
+		requestedRpcs[serviceName] = requested[serviceName].createClient({
+			call: (method, req, options) => peer.call(`${serviceFqn}.${method}`, req, options),
+			callStream: (method, req, options) => peer.callStream(`${serviceFqn}.${method}`, req, options)
+		}, encodingOptions);
+	}
+	return new ProtoRpcPeer(requestedRpcs, peer);
+};
+var parseMethodName = (method) => {
+	const separator = method.lastIndexOf(".");
+	const serviceName = method.slice(0, separator);
+	const methodName = method.slice(separator + 1);
+	if (serviceName.length === 0 || methodName.length === 0) throw new Error(`Invalid method: ${method}`);
+	return [serviceName, methodName];
+};
+/**
+* Create a type-safe RPC client.
+* @deprecated Use createProtoRpcPeer instead.
+*/
+var createRpcClient = (serviceDef, options) => {
+	const peer = new RpcPeer({
+		...options,
+		callHandler: () => {
+			throw new Error("Requests to client are not supported.");
+		}
+	});
+	return new ProtoRpcPeer(serviceDef.createClient({
+		call: peer.call.bind(peer),
+		callStream: peer.callStream.bind(peer)
+	}), peer);
+};
+/**
+* Create a type-safe RPC server.
+* @deprecated Use createProtoRpcPeer instead.
+*/
+var createRpcServer = ({ service, handlers, ...rest }) => {
+	const server = service.createServer(handlers);
+	return new RpcPeer({
+		...rest,
+		callHandler: server.call.bind(server),
+		streamHandler: server.callStream.bind(server)
+	});
+};
+/**
+* Create type-safe RPC client from a service bundle.
+* @deprecated Use createProtoRpcPeer instead.
+*/
+var createBundledRpcClient = (descriptors, options) => {
+	return createProtoRpcPeer({
+		requested: descriptors,
+		...options
+	});
+};
+/**
+* Create type-safe RPC server from a service bundle.
+* @deprecated Use createProtoRpcPeer instead.
+*/
+var createBundledRpcServer = ({ services, handlers, ...rest }) => {
+	const rpc = {};
+	for (const serviceName of Object.keys(services)) {
+		const serviceFqn = services[serviceName].serviceProto.fullName.slice(1);
+		rpc[serviceFqn] = services[serviceName].createServer(handlers[serviceName]);
+	}
+	return new RpcPeer({
+		...rest,
+		callHandler: (method, request) => {
+			const [serviceName, methodName] = parseMethodName(method);
+			if (!rpc[serviceName]) throw new Error(`Service not supported: ${serviceName}`);
+			return rpc[serviceName].call(methodName, request);
+		},
+		streamHandler: (method, request) => {
+			const [serviceName, methodName] = parseMethodName(method);
+			if (!rpc[serviceName]) throw new Error(`Service not supported: ${serviceName}`);
+			return rpc[serviceName].callStream(methodName, request);
+		}
+	});
+};
+//#endregion
+//#region src/testing.ts
+/**
+* Create bi-directionally linked ports.
+*/
+var createLinkedPorts = ({ delay } = {}) => {
+	let port1Received;
+	let port2Received;
+	const send = (handler, msg) => {
+		if (delay) setTimeout(() => handler?.(msg), delay);
+		else handler?.(msg);
+	};
+	return [{
+		send: (msg) => send(port2Received, msg),
+		subscribe: (cb) => {
+			port1Received = cb;
+		}
+	}, {
+		send: (msg) => send(port1Received, msg),
+		subscribe: (cb) => {
+			port2Received = cb;
+		}
+	}];
+};
+var encodeMessage = (msg) => isNode() ? Buffer.from(msg) : new TextEncoder().encode(msg);
+//#endregion
+//#region src/trace.ts
+var PortTracer = class {
+	_wrappedPort;
+	message = new Event();
+	_port;
+	constructor(_wrappedPort) {
+		this._wrappedPort = _wrappedPort;
+		this._port = {
+			send: (msg) => {
+				this.message.emit({
+					direction: MessageTrace.Direction.OUTGOING,
+					data: msg
+				});
+				return this._wrappedPort.send(msg);
+			},
+			subscribe: (cb) => {
+				return this._wrappedPort.subscribe((msg) => {
+					this.message.emit({
+						direction: MessageTrace.Direction.INCOMING,
+						data: msg
+					});
+					cb(msg);
+				});
+			}
+		};
+	}
+	get port() {
+		return this._port;
+	}
+};
+//#endregion
+export { PortTracer, ProtoRpcPeer, RpcPeer, createBundledRpcClient, createBundledRpcServer, createLinkedPorts, createProtoRpcPeer, createRpcClient, createRpcServer, createServiceBundle, decodeRpcError, encodeMessage, layerProtocolRpcPortClient, layerProtocolRpcPortServer, makeProtocolRpcPortClient, makeProtocolRpcPortServer, parseMethodName };
+
+//# sourceMappingURL=index.mjs.map