@dxos/rpc 0.8.4-main.b97322e → 0.8.4-main.bc2380dfbc

package/dist/lib/{browser → neutral}/index.mjs

@@ -10,26 +10,30 @@ var decodeRpcError = (err, rpcMethod) => decodeError(err, {
 });
 
 // src/rpc.ts
-import { asyncTimeout, synchronized, Trigger } from "@dxos/async";
+import { Trigger, asyncTimeout, synchronized } from "@dxos/async";
 import { Stream } from "@dxos/codec-protobuf";
+import { ContextRpcCodec } from "@dxos/context";
 import { StackTrace as StackTrace2 } from "@dxos/debug";
 import { invariant } from "@dxos/invariant";
 import { log } from "@dxos/log";
-import { encodeError, RpcClosedError, RpcNotOpenError } from "@dxos/protocols";
+import { RpcClosedError, RpcNotOpenError, encodeError } from "@dxos/protocols";
 import { schema } from "@dxos/protocols/proto";
 import { exponentialBackoffInterval } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/mesh/rpc/src/rpc.ts";
 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 = "/__w/dxos/dxos/packages/core/mesh/rpc/src/rpc.ts";
-var DEFAULT_TIMEOUT = 3e3;
+var DEFAULT_TIMEOUT = 3e4;
 var BYE_SEND_TIMEOUT = 2e3;
 var DEBUG_CALLS = true;
 var CLOSE_TIMEOUT = 3e3;
 var PendingRpcRequest = class {
+  resolve;
+  reject;
+  stream;
   constructor(resolve, reject, stream) {
     this.resolve = resolve;
     this.reject = reject;
@@ -39,22 +43,23 @@ var PendingRpcRequest = class {
 var RpcMessageCodec;
 var getRpcMessageCodec = () => RpcMessageCodec ??= schema.getCodecForType("dxos.rpc.RpcMessage");
 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._outgoingRequests = /* @__PURE__ */ new Map();
-    this._localStreams = /* @__PURE__ */ new Map();
-    this._remoteOpenTrigger = new Trigger();
-    /**
-    * Triggered when the peer starts closing.
-    */
-    this._closingTrigger = new Trigger();
-    /**
-    * Triggered when peer receives a bye message.
-    */
-    this._byeTrigger = new Trigger();
-    this._nextId = 0;
-    this._state = "INITIAL";
-    this._unsubscribeFromPort = void 0;
-    this._clearOpenInterval = void 0;
     this._params = {
       timeout: void 0,
       streamHandler: void 0,
@@ -75,12 +80,7 @@ var RpcPeer = class {
       try {
         await this._receive(msg);
       } catch (err) {
-        log.catch(err, void 0, {
-          F: __dxlog_file,
-          L: 156,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 100, S: this });
       }
     });
     this._state = "OPENING";
@@ -91,12 +91,7 @@ var RpcPeer = class {
     }
     log("sending open message", {
       state: this._state
-    }, {
-      F: __dxlog_file,
-      L: 168,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 109, S: this });
     await this._sendMessage({
       open: true
     });
@@ -106,12 +101,7 @@ var RpcPeer = class {
     this._clearOpenInterval = exponentialBackoffInterval(() => {
       void this._sendMessage({
         open: true
-      }).catch((err) => log.warn(err, void 0, {
-        F: __dxlog_file,
-        L: 177,
-        S: this,
-        C: (f, a) => f(...a)
-      }));
+      }).catch((err) => log.warn(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 122, S: this }));
     }, 50);
     await Promise.race([
       this._remoteOpenTrigger.wait(),
@@ -123,12 +113,7 @@ var RpcPeer = class {
     }
     log("resending open message", {
       state: this._state
-    }, {
-      F: __dxlog_file,
-      L: 191,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 135, S: this });
     await this._sendMessage({
       openAck: true
     });
@@ -153,32 +138,17 @@ var RpcPeer = class {
       } catch (err) {
         log("error closing peer, sending bye", {
           err
-        }, {
-          F: __dxlog_file,
-          L: 213,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 159, S: this });
       }
       try {
-        log("closing waiting on bye", void 0, {
-          F: __dxlog_file,
-          L: 216,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log("closing waiting on bye", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 164, S: this });
         await this._byeTrigger.wait({
           timeout
         });
       } catch (err) {
         log("error closing peer", {
           err
-        }, {
-          F: __dxlog_file,
-          L: 219,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 169, S: this });
         return;
       }
     }
@@ -215,22 +185,12 @@ var RpcPeer = class {
     const decoded = getRpcMessageCodec().decode(msg, {
       preserveAny: true
     });
-    DEBUG_CALLS && log("received message", {
+    DEBUG_CALLS && log.trace("received message", {
       type: Object.keys(decoded)[0]
-    }, {
-      F: __dxlog_file,
-      L: 263,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 208, S: this });
     if (decoded.request) {
       if (this._state !== "OPENED" && this._state !== "OPENING") {
-        log("received request while closed", void 0, {
-          F: __dxlog_file,
-          L: 267,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log("received request while closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 213, S: this });
         await this._sendMessage({
           response: {
             id: decoded.request.id,
@@ -243,112 +203,59 @@ var RpcPeer = class {
       if (req.stream) {
         log("stream request", {
           method: req.method
-        }, {
-          F: __dxlog_file,
-          L: 279,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 224, S: this });
         this._callStreamHandler(req, (response) => {
           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)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 228, S: this });
           void this._sendMessage({
             response
           }).catch((err) => {
-            log.warn("failed during close", err, {
-              F: __dxlog_file,
-              L: 289,
-              S: this,
-              C: (f, a) => f(...a)
-            });
+            log.warn("failed during close", err, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 237, S: this });
           });
         });
       } else {
-        DEBUG_CALLS && log("requesting...", {
+        DEBUG_CALLS && log.trace("requesting...", {
           method: req.method
-        }, {
-          F: __dxlog_file,
-          L: 293,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 241, S: this });
         const response = await this._callHandler(req);
-        DEBUG_CALLS && log("sending response", {
+        DEBUG_CALLS && log.trace("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)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 245, S: this });
         await this._sendMessage({
           response
         });
       }
     } else if (decoded.response) {
       if (this._state !== "OPENED") {
-        log("received response while closed", void 0, {
-          F: __dxlog_file,
-          L: 305,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log("received response while closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 256, S: this });
         return;
       }
       const responseId = decoded.response.id;
-      invariant(typeof responseId === "number", void 0, {
-        F: __dxlog_file,
-        L: 310,
-        S: this,
-        A: [
-          "typeof responseId === 'number'",
-          ""
-        ]
-      });
+      invariant(typeof responseId === "number", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 260, S: this, A: ["typeof responseId === 'number'", ""] });
       if (!this._outgoingRequests.has(responseId)) {
-        log("received response with invalid id", {
+        log.trace("received response with invalid id", {
           responseId
-        }, {
-          F: __dxlog_file,
-          L: 312,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 262, S: this });
         return;
       }
       const item = this._outgoingRequests.get(responseId);
       if (!item.stream) {
         this._outgoingRequests.delete(responseId);
       }
-      DEBUG_CALLS && log("response", {
+      DEBUG_CALLS && log.trace("response", {
         type_url: decoded.response.payload?.type_url
-      }, {
-        F: __dxlog_file,
-        L: 322,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 272, S: this });
       item.resolve(decoded.response);
     } else if (decoded.open) {
       log("received open message", {
         state: this._state
-      }, {
-        F: __dxlog_file,
-        L: 325,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 277, S: this });
       if (this._params.noHandshake) {
         return;
       }
@@ -358,12 +265,7 @@ var RpcPeer = class {
     } else if (decoded.openAck) {
       log("received openAck message", {
         state: this._state
-      }, {
-        F: __dxlog_file,
-        L: 332,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 287, S: this });
       if (this._params.noHandshake) {
         return;
       }
@@ -371,41 +273,18 @@ var RpcPeer = class {
       this._remoteOpenTrigger.wake();
     } else if (decoded.streamClose) {
       if (this._state !== "OPENED") {
-        log("received stream close while closed", void 0, {
-          F: __dxlog_file,
-          L: 341,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log("received stream close while closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 297, S: this });
         return;
       }
       log("received stream close", {
         id: decoded.streamClose.id
-      }, {
-        F: __dxlog_file,
-        L: 345,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      invariant(typeof decoded.streamClose.id === "number", void 0, {
-        F: __dxlog_file,
-        L: 346,
-        S: this,
-        A: [
-          "typeof decoded.streamClose.id === 'number'",
-          ""
-        ]
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 300, S: this });
+      invariant(typeof decoded.streamClose.id === "number", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 303, 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
-        }, {
-          F: __dxlog_file,
-          L: 349,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 306, S: this });
         return;
       }
       this._localStreams.delete(decoded.streamClose.id);
@@ -413,12 +292,7 @@ var RpcPeer = class {
     } else if (decoded.bye) {
       this._byeTrigger.wake();
       if (this._state !== "CLOSING" && this._state !== "CLOSED") {
-        log("replying to bye", void 0, {
-          F: __dxlog_file,
-          L: 359,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log("replying to bye", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 317, S: this });
         this._state = "CLOSING";
         await this._sendMessage({
           bye: {}
@@ -429,12 +303,7 @@ var RpcPeer = class {
     } else {
       log.error("received malformed message", {
         msg
-      }, {
-        F: __dxlog_file,
-        L: 367,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 326, S: this });
       throw new Error("Malformed message.");
     }
   }
@@ -443,14 +312,9 @@ var RpcPeer = class {
   * Peer should be open before making this call.
   */
   async call(method, request, options) {
-    DEBUG_CALLS && log("calling...", {
+    DEBUG_CALLS && log.trace("calling...", {
       method
-    }, {
-      F: __dxlog_file,
-      L: 377,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 336, S: this });
     throwIfNotOpen(this._state);
     let response;
     try {
@@ -458,12 +322,23 @@ var RpcPeer = class {
       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, L: 351, S: this });
+      }
       const sending = this._sendMessage({
         request: {
           id,
           method,
           payload: request,
-          stream: false
+          stream: false,
+          ...traceContext ? {
+            traceContext
+          } : {}
         }
       });
       const timeout = options?.timeout ?? this._params.timeout;
@@ -473,15 +348,7 @@ var RpcPeer = class {
         waiting
       ]);
       response = await waiting;
-      invariant(response.id === id, void 0, {
-        F: __dxlog_file,
-        L: 405,
-        S: this,
-        A: [
-          "response.id === id",
-          ""
-        ]
-      });
+      invariant(response.id === id, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 375, S: this, A: ["response.id === id", ""] });
     } catch (err) {
       if (err instanceof RpcClosedError) {
         const error = new RpcClosedError();
@@ -536,76 +403,81 @@ ${stack.getStack()}`;
         }
       };
       this._outgoingRequests.set(id, new PendingRpcRequest(onResponse, closeStream, true));
-      this._sendMessage({
-        request: {
-          id,
-          method,
-          payload: request,
-          stream: true
-        }
-      }).catch((err) => {
-        close(err);
-      });
+      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, L: 429, 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, {
-            F: __dxlog_file,
-            L: 478,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          log.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 458, S: this });
         });
         this._outgoingRequests.delete(id);
       };
     });
   }
   async _sendMessage(message, timeout) {
-    DEBUG_CALLS && log("sending message", {
+    DEBUG_CALLS && log.trace("sending message", {
       type: Object.keys(message)[0]
-    }, {
-      F: __dxlog_file,
-      L: 486,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 465, 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, L: 478, S: this });
+      }
+    }
+    if (!traceCtx && !this._params.handlerRpcOptions) {
+      return void 0;
+    }
+    return {
+      ...this._params.handlerRpcOptions,
+      ...traceCtx ? {
+        ctx: traceCtx
+      } : {}
+    };
+  }
   async _callHandler(req) {
     try {
-      invariant(typeof req.id === "number", void 0, {
-        F: __dxlog_file,
-        L: 492,
-        S: this,
-        A: [
-          "typeof req.id === 'number'",
-          ""
-        ]
-      });
-      invariant(req.payload, void 0, {
-        F: __dxlog_file,
-        L: 493,
-        S: this,
-        A: [
-          "req.payload",
-          ""
-        ]
-      });
-      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);
+      invariant(typeof req.id === "number", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 496, S: this, A: ["typeof req.id === 'number'", ""] });
+      invariant(req.payload, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 497, S: this, A: ["req.payload", ""] });
+      invariant(req.method, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 498, S: this, A: ["req.method", ""] });
+      const response = await this._params.callHandler(req.method, req.payload, this._getHandlerRpcOptions(req));
       return {
         id: req.id,
         payload: response
@@ -619,43 +491,11 @@ ${stack.getStack()}`;
   }
   _callStreamHandler(req, callback) {
     try {
-      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.'"
-        ]
-      });
-      invariant(typeof req.id === "number", void 0, {
-        F: __dxlog_file,
-        L: 512,
-        S: this,
-        A: [
-          "typeof req.id === 'number'",
-          ""
-        ]
-      });
-      invariant(req.payload, void 0, {
-        F: __dxlog_file,
-        L: 513,
-        S: this,
-        A: [
-          "req.payload",
-          ""
-        ]
-      });
-      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);
+      invariant(this._params.streamHandler, "Requests with streaming responses are not supported.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 513, 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, L: 514, S: this, A: ["typeof req.id === 'number'", ""] });
+      invariant(req.payload, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 515, S: this, A: ["req.payload", ""] });
+      invariant(req.method, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 516, S: this, A: ["req.method", ""] });
+      const responseStream = this._params.streamHandler(req.method, req.payload, this._getHandlerRpcOptions(req));
       responseStream.onReady(() => {
         callback({
           id: req.id,
@@ -711,6 +551,8 @@ import { invariant as invariant2 } from "@dxos/invariant";
 var __dxlog_file2 = "/__w/dxos/dxos/packages/core/mesh/rpc/src/service.ts";
 var createServiceBundle = (services) => services;
 var ProtoRpcPeer = class {
+  rpc;
+  _peer;
   constructor(rpc, _peer) {
     this.rpc = rpc;
     this._peer = _peer;
@@ -728,15 +570,7 @@ var ProtoRpcPeer = class {
 var createProtoRpcPeer = ({ requested, exposed, handlers, encodingOptions, ...rest }) => {
   const exposedRpcs = {};
   if (exposed) {
-    invariant2(handlers, void 0, {
-      F: __dxlog_file2,
-      L: 93,
-      S: void 0,
-      A: [
-        "handlers",
-        ""
-      ]
-    });
+    invariant2(handlers, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 37, S: void 0, A: ["handlers", ""] });
     for (const serviceName of Object.keys(exposed)) {
       const serviceFqn = exposed[serviceName].serviceProto.fullName.slice(1);
       const serviceProvider = handlers[serviceName];
@@ -871,9 +705,11 @@ var encodeMessage = (msg) => isNode() ? Buffer.from(msg) : new TextEncoder().enc
 import { Event } from "@dxos/async";
 import { MessageTrace } from "@dxos/protocols/proto/dxos/rpc";
 var PortTracer = class {
+  _wrappedPort;
+  message = new Event();
+  _port;
   constructor(_wrappedPort) {
     this._wrappedPort = _wrappedPort;
-    this.message = new Event();
     this._port = {
       send: (msg) => {
         this.message.emit({