@dxos/rpc 0.8.3 → 0.8.4-main.84f28bd

package/dist/lib/node/index.cjs

@@ -1,934 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var node_exports = {};
-__export(node_exports, {
-  PortTracer: () => PortTracer,
-  ProtoRpcPeer: () => ProtoRpcPeer,
-  RpcPeer: () => RpcPeer,
-  createBundledRpcClient: () => createBundledRpcClient,
-  createBundledRpcServer: () => createBundledRpcServer,
-  createLinkedPorts: () => createLinkedPorts,
-  createProtoRpcPeer: () => createProtoRpcPeer,
-  createRpcClient: () => createRpcClient,
-  createRpcServer: () => createRpcServer,
-  createServiceBundle: () => createServiceBundle,
-  decodeRpcError: () => decodeRpcError,
-  encodeMessage: () => encodeMessage,
-  parseMethodName: () => parseMethodName
-});
-module.exports = __toCommonJS(node_exports);
-var import_async = require("@dxos/async");
-var import_codec_protobuf = require("@dxos/codec-protobuf");
-var import_debug = require("@dxos/debug");
-var import_invariant = require("@dxos/invariant");
-var import_log = require("@dxos/log");
-var import_protocols = require("@dxos/protocols");
-var import_proto = require("@dxos/protocols/proto");
-var import_util = require("@dxos/util");
-var import_debug2 = require("@dxos/debug");
-var import_protocols2 = require("@dxos/protocols");
-var import_invariant2 = require("@dxos/invariant");
-var import_util2 = require("@dxos/util");
-var import_async2 = require("@dxos/async");
-var import_rpc = require("@dxos/protocols/proto/dxos/rpc");
-var decodeRpcError = (err, rpcMethod) => (0, import_protocols2.decodeError)(err, {
-  appendStack: `
-    at RPC ${rpcMethod} 
-` + new import_debug2.StackTrace().getStack(1)
-});
-function _ts_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;
-}
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/rpc/src/rpc.ts";
-var DEFAULT_TIMEOUT = 3e3;
-var BYE_SEND_TIMEOUT = 2e3;
-var DEBUG_CALLS = true;
-var CLOSE_TIMEOUT = 3e3;
-var PendingRpcRequest = class {
-  constructor(resolve, reject, stream) {
-    this.resolve = resolve;
-    this.reject = reject;
-    this.stream = stream;
-  }
-};
-var RpcMessageCodec;
-var getRpcMessageCodec = () => RpcMessageCodec ??= import_proto.schema.getCodecForType("dxos.rpc.RpcMessage");
-var RpcPeer = class {
-  constructor(params) {
-    this._outgoingRequests = /* @__PURE__ */ new Map();
-    this._localStreams = /* @__PURE__ */ new Map();
-    this._remoteOpenTrigger = new import_async.Trigger();
-    this._closingTrigger = new import_async.Trigger();
-    this._byeTrigger = new import_async.Trigger();
-    this._nextId = 0;
-    this._state = "INITIAL";
-    this._unsubscribeFromPort = void 0;
-    this._clearOpenInterval = void 0;
-    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) {
-        import_log.log.catch(err, void 0, {
-          F: __dxlog_file,
-          L: 156,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    });
-    this._state = "OPENING";
-    if (this._params.noHandshake) {
-      this._state = "OPENED";
-      this._remoteOpenTrigger.wake();
-      return;
-    }
-    (0, import_log.log)("sending open message", {
-      state: this._state
-    }, {
-      F: __dxlog_file,
-      L: 168,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this._sendMessage({
-      open: true
-    });
-    if (this._state !== "OPENING") {
-      return;
-    }
-    this._clearOpenInterval = (0, import_util.exponentialBackoffInterval)(() => {
-      void this._sendMessage({
-        open: true
-      }).catch((err) => import_log.log.warn(err, void 0, {
-        F: __dxlog_file,
-        L: 177,
-        S: this,
-        C: (f, a) => f(...a)
-      }));
-    }, 50);
-    await Promise.race([
-      this._remoteOpenTrigger.wait(),
-      this._closingTrigger.wait()
-    ]);
-    this._clearOpenInterval?.();
-    if (this._state !== "OPENED") {
-      return;
-    }
-    (0, import_log.log)("resending open message", {
-      state: this._state
-    }, {
-      F: __dxlog_file,
-      L: 191,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    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) {
-        (0, import_log.log)("error closing peer, sending bye", {
-          err
-        }, {
-          F: __dxlog_file,
-          L: 213,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-      try {
-        (0, import_log.log)("closing waiting on bye", void 0, {
-          F: __dxlog_file,
-          L: 216,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        await this._byeTrigger.wait({
-          timeout
-        });
-      } catch (err) {
-        (0, import_log.log)("error closing peer", {
-          err
-        }, {
-          F: __dxlog_file,
-          L: 219,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        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 import_protocols.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
-    });
-    DEBUG_CALLS && (0, import_log.log)("received message", {
-      type: Object.keys(decoded)[0]
-    }, {
-      F: __dxlog_file,
-      L: 263,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (decoded.request) {
-      if (this._state !== "OPENED" && this._state !== "OPENING") {
-        (0, import_log.log)("received request while closed", void 0, {
-          F: __dxlog_file,
-          L: 267,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        await this._sendMessage({
-          response: {
-            id: decoded.request.id,
-            error: (0, import_protocols.encodeError)(new import_protocols.RpcClosedError())
-          }
-        });
-        return;
-      }
-      const req = decoded.request;
-      if (req.stream) {
-        (0, import_log.log)("stream request", {
-          method: req.method
-        }, {
-          F: __dxlog_file,
-          L: 279,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._callStreamHandler(req, (response) => {
-          (0, import_log.log)("sending stream response", {
-            method: req.method,
-            response: response.payload?.type_url,
-            error: response.error,
-            close: response.close
-          }, {
-            F: __dxlog_file,
-            L: 281,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          void this._sendMessage({
-            response
-          }).catch((err) => {
-            import_log.log.warn("failed during close", err, {
-              F: __dxlog_file,
-              L: 289,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          });
-        });
-      } else {
-        DEBUG_CALLS && (0, import_log.log)("requesting...", {
-          method: req.method
-        }, {
-          F: __dxlog_file,
-          L: 293,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        const response = await this._callHandler(req);
-        DEBUG_CALLS && (0, import_log.log)("sending response", {
-          method: req.method,
-          response: response.payload?.type_url,
-          error: response.error
-        }, {
-          F: __dxlog_file,
-          L: 296,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        await this._sendMessage({
-          response
-        });
-      }
-    } else if (decoded.response) {
-      if (this._state !== "OPENED") {
-        (0, import_log.log)("received response while closed", void 0, {
-          F: __dxlog_file,
-          L: 305,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return;
-      }
-      const responseId = decoded.response.id;
-      (0, import_invariant.invariant)(typeof responseId === "number", void 0, {
-        F: __dxlog_file,
-        L: 310,
-        S: this,
-        A: [
-          "typeof responseId === 'number'",
-          ""
-        ]
-      });
-      if (!this._outgoingRequests.has(responseId)) {
-        (0, import_log.log)("received response with invalid id", {
-          responseId
-        }, {
-          F: __dxlog_file,
-          L: 312,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return;
-      }
-      const item = this._outgoingRequests.get(responseId);
-      if (!item.stream) {
-        this._outgoingRequests.delete(responseId);
-      }
-      DEBUG_CALLS && (0, import_log.log)("response", {
-        type_url: decoded.response.payload?.type_url
-      }, {
-        F: __dxlog_file,
-        L: 322,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      item.resolve(decoded.response);
-    } else if (decoded.open) {
-      (0, import_log.log)("received open message", {
-        state: this._state
-      }, {
-        F: __dxlog_file,
-        L: 325,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      if (this._params.noHandshake) {
-        return;
-      }
-      await this._sendMessage({
-        openAck: true
-      });
-    } else if (decoded.openAck) {
-      (0, import_log.log)("received openAck message", {
-        state: this._state
-      }, {
-        F: __dxlog_file,
-        L: 332,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      if (this._params.noHandshake) {
-        return;
-      }
-      this._state = "OPENED";
-      this._remoteOpenTrigger.wake();
-    } else if (decoded.streamClose) {
-      if (this._state !== "OPENED") {
-        (0, import_log.log)("received stream close while closed", void 0, {
-          F: __dxlog_file,
-          L: 341,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return;
-      }
-      (0, import_log.log)("received stream close", {
-        id: decoded.streamClose.id
-      }, {
-        F: __dxlog_file,
-        L: 345,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      (0, import_invariant.invariant)(typeof decoded.streamClose.id === "number", void 0, {
-        F: __dxlog_file,
-        L: 346,
-        S: this,
-        A: [
-          "typeof decoded.streamClose.id === 'number'",
-          ""
-        ]
-      });
-      const stream = this._localStreams.get(decoded.streamClose.id);
-      if (!stream) {
-        (0, import_log.log)("no local stream", {
-          id: decoded.streamClose.id
-        }, {
-          F: __dxlog_file,
-          L: 349,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return;
-      }
-      this._localStreams.delete(decoded.streamClose.id);
-      await stream.close();
-    } else if (decoded.bye) {
-      this._byeTrigger.wake();
-      if (this._state !== "CLOSING" && this._state !== "CLOSED") {
-        (0, import_log.log)("replying to bye", void 0, {
-          F: __dxlog_file,
-          L: 359,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._state = "CLOSING";
-        await this._sendMessage({
-          bye: {}
-        });
-        this._abortRequests();
-        this._disposeAndClose();
-      }
-    } else {
-      import_log.log.error("received malformed message", {
-        msg
-      }, {
-        F: __dxlog_file,
-        L: 367,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      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) {
-    DEBUG_CALLS && (0, import_log.log)("calling...", {
-      method
-    }, {
-      F: __dxlog_file,
-      L: 377,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    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));
-      });
-      const sending = this._sendMessage({
-        request: {
-          id,
-          method,
-          payload: request,
-          stream: false
-        }
-      });
-      const timeout = options?.timeout ?? this._params.timeout;
-      const waiting = timeout === 0 ? responseReceived : (0, import_async.asyncTimeout)(responseReceived, timeout ?? DEFAULT_TIMEOUT);
-      await Promise.race([
-        sending,
-        waiting
-      ]);
-      response = await waiting;
-      (0, import_invariant.invariant)(response.id === id, void 0, {
-        F: __dxlog_file,
-        L: 405,
-        S: this,
-        A: [
-          "response.id === id",
-          ""
-        ]
-      });
-    } catch (err) {
-      if (err instanceof import_protocols.RpcClosedError) {
-        const error = new import_protocols.RpcClosedError();
-        error.stack += `
-
- info: RPC client was closed at:
-${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 import_codec_protobuf.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 import_debug.StackTrace();
-      const closeStream = (err) => {
-        if (!err) {
-          close();
-        } else {
-          err.stack += `
-
-Error happened in the stream at:
-${stack.getStack()}`;
-          close(err);
-        }
-      };
-      this._outgoingRequests.set(id, new PendingRpcRequest(onResponse, closeStream, true));
-      this._sendMessage({
-        request: {
-          id,
-          method,
-          payload: request,
-          stream: true
-        }
-      }).catch((err) => {
-        close(err);
-      });
-      return () => {
-        this._sendMessage({
-          streamClose: {
-            id
-          }
-        }).catch((err) => {
-          import_log.log.catch(err, void 0, {
-            F: __dxlog_file,
-            L: 478,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-        });
-        this._outgoingRequests.delete(id);
-      };
-    });
-  }
-  async _sendMessage(message, timeout) {
-    DEBUG_CALLS && (0, import_log.log)("sending message", {
-      type: Object.keys(message)[0]
-    }, {
-      F: __dxlog_file,
-      L: 486,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this._params.port.send(getRpcMessageCodec().encode(message, {
-      preserveAny: true
-    }), timeout);
-  }
-  async _callHandler(req) {
-    try {
-      (0, import_invariant.invariant)(typeof req.id === "number", void 0, {
-        F: __dxlog_file,
-        L: 492,
-        S: this,
-        A: [
-          "typeof req.id === 'number'",
-          ""
-        ]
-      });
-      (0, import_invariant.invariant)(req.payload, void 0, {
-        F: __dxlog_file,
-        L: 493,
-        S: this,
-        A: [
-          "req.payload",
-          ""
-        ]
-      });
-      (0, import_invariant.invariant)(req.method, void 0, {
-        F: __dxlog_file,
-        L: 494,
-        S: this,
-        A: [
-          "req.method",
-          ""
-        ]
-      });
-      const response = await this._params.callHandler(req.method, req.payload, this._params.handlerRpcOptions);
-      return {
-        id: req.id,
-        payload: response
-      };
-    } catch (err) {
-      return {
-        id: req.id,
-        error: (0, import_protocols.encodeError)(err)
-      };
-    }
-  }
-  _callStreamHandler(req, callback) {
-    try {
-      (0, import_invariant.invariant)(this._params.streamHandler, "Requests with streaming responses are not supported.", {
-        F: __dxlog_file,
-        L: 511,
-        S: this,
-        A: [
-          "this._params.streamHandler",
-          "'Requests with streaming responses are not supported.'"
-        ]
-      });
-      (0, import_invariant.invariant)(typeof req.id === "number", void 0, {
-        F: __dxlog_file,
-        L: 512,
-        S: this,
-        A: [
-          "typeof req.id === 'number'",
-          ""
-        ]
-      });
-      (0, import_invariant.invariant)(req.payload, void 0, {
-        F: __dxlog_file,
-        L: 513,
-        S: this,
-        A: [
-          "req.payload",
-          ""
-        ]
-      });
-      (0, import_invariant.invariant)(req.method, void 0, {
-        F: __dxlog_file,
-        L: 514,
-        S: this,
-        A: [
-          "req.method",
-          ""
-        ]
-      });
-      const responseStream = this._params.streamHandler(req.method, req.payload, this._params.handlerRpcOptions);
-      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: (0, import_protocols.encodeError)(error)
-          });
-        } else {
-          callback({
-            id: req.id,
-            close: true
-          });
-        }
-      });
-      this._localStreams.set(req.id, responseStream);
-    } catch (err) {
-      callback({
-        id: req.id,
-        error: (0, import_protocols.encodeError)(err)
-      });
-    }
-  }
-};
-_ts_decorate([
-  import_async.synchronized
-], RpcPeer.prototype, "open", null);
-var throwIfNotOpen = (state) => {
-  switch (state) {
-    case "OPENED": {
-      return;
-    }
-    case "INITIAL": {
-      throw new import_protocols.RpcNotOpenError();
-    }
-    case "CLOSED": {
-      throw new import_protocols.RpcClosedError();
-    }
-  }
-};
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/rpc/src/service.ts";
-var createServiceBundle = (services) => services;
-var ProtoRpcPeer = class {
-  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();
-  }
-};
-var createProtoRpcPeer = ({ requested, exposed, handlers, encodingOptions, ...rest }) => {
-  const exposedRpcs = {};
-  if (exposed) {
-    (0, import_invariant2.invariant)(handlers, void 0, {
-      F: __dxlog_file2,
-      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
-  ];
-};
-var createRpcClient = (serviceDef, options) => {
-  const peer = new RpcPeer({
-    ...options,
-    callHandler: () => {
-      throw new Error("Requests to client are not supported.");
-    }
-  });
-  const client = serviceDef.createClient({
-    call: peer.call.bind(peer),
-    callStream: peer.callStream.bind(peer)
-  });
-  return new ProtoRpcPeer(client, peer);
-};
-var createRpcServer = ({ service, handlers, ...rest }) => {
-  const server = service.createServer(handlers);
-  return new RpcPeer({
-    ...rest,
-    callHandler: server.call.bind(server),
-    streamHandler: server.callStream.bind(server)
-  });
-};
-var createBundledRpcClient = (descriptors, options) => {
-  return createProtoRpcPeer({
-    requested: descriptors,
-    ...options
-  });
-};
-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);
-    }
-  });
-};
-var createLinkedPorts = ({ delay } = {}) => {
-  let port1Received;
-  let port2Received;
-  const send = (handler, msg) => {
-    if (delay) {
-      setTimeout(() => handler?.(msg), delay);
-    } else {
-      void handler?.(msg);
-    }
-  };
-  const port1 = {
-    send: (msg) => send(port2Received, msg),
-    subscribe: (cb) => {
-      port1Received = cb;
-    }
-  };
-  const port2 = {
-    send: (msg) => send(port1Received, msg),
-    subscribe: (cb) => {
-      port2Received = cb;
-    }
-  };
-  return [
-    port1,
-    port2
-  ];
-};
-var encodeMessage = (msg) => (0, import_util2.isNode)() ? Buffer.from(msg) : new TextEncoder().encode(msg);
-var PortTracer = class {
-  constructor(_wrappedPort) {
-    this._wrappedPort = _wrappedPort;
-    this.message = new import_async2.Event();
-    this._port = {
-      send: (msg) => {
-        this.message.emit({
-          direction: import_rpc.MessageTrace.Direction.OUTGOING,
-          data: msg
-        });
-        return this._wrappedPort.send(msg);
-      },
-      subscribe: (cb) => {
-        return this._wrappedPort.subscribe((msg) => {
-          this.message.emit({
-            direction: import_rpc.MessageTrace.Direction.INCOMING,
-            data: msg
-          });
-          cb(msg);
-        });
-      }
-    };
-  }
-  get port() {
-    return this._port;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PortTracer,
-  ProtoRpcPeer,
-  RpcPeer,
-  createBundledRpcClient,
-  createBundledRpcServer,
-  createLinkedPorts,
-  createProtoRpcPeer,
-  createRpcClient,
-  createRpcServer,
-  createServiceBundle,
-  decodeRpcError,
-  encodeMessage,
-  parseMethodName
-});
-//# sourceMappingURL=index.cjs.map