@dxos/context 0.8.4-main.dedc0f3 → 0.8.4-main.e00bdcdb52

package/dist/lib/node-esm/index.mjs

@@ -14,66 +14,12 @@ var ContextDisposedError = class extends Error {
 };
 
 // src/context.ts
-function _check_private_redeclaration(obj, privateCollection) {
-  if (privateCollection.has(obj)) {
-    throw new TypeError("Cannot initialize the same private elements twice on an object");
-  }
-}
-function _class_apply_descriptor_get(receiver, descriptor) {
-  if (descriptor.get) {
-    return descriptor.get.call(receiver);
-  }
-  return descriptor.value;
-}
-function _class_apply_descriptor_set(receiver, descriptor, value) {
-  if (descriptor.set) {
-    descriptor.set.call(receiver, value);
-  } else {
-    if (!descriptor.writable) {
-      throw new TypeError("attempted to set read only private field");
-    }
-    descriptor.value = value;
-  }
-}
-function _class_extract_field_descriptor(receiver, privateMap, action) {
-  if (!privateMap.has(receiver)) {
-    throw new TypeError("attempted to " + action + " private field on non-instance");
-  }
-  return privateMap.get(receiver);
-}
-function _class_private_field_get(receiver, privateMap) {
-  var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
-  return _class_apply_descriptor_get(receiver, descriptor);
-}
-function _class_private_field_init(obj, privateMap, value) {
-  _check_private_redeclaration(obj, privateMap);
-  privateMap.set(obj, value);
-}
-function _class_private_field_set(receiver, privateMap, value) {
-  var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
-  _class_apply_descriptor_set(receiver, descriptor, value);
-  return value;
-}
-function _define_property(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 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/common/context/src/context.ts";
 var DEBUG_LOG_DISPOSE = false;
 var MAX_SAFE_DISPOSE_CALLBACKS = 300;
 var DEFAULT_ERROR_HANDLER = (error, ctx) => {
@@ -85,25 +31,51 @@ var DEFAULT_ERROR_HANDLER = (error, ctx) => {
 };
 var CONTEXT_FLAG_IS_DISPOSED = 1 << 0;
 var CONTEXT_FLAG_LEAK_DETECTED = 1 << 1;
-var _disposeCallbacks = /* @__PURE__ */ new WeakMap();
-var _name = /* @__PURE__ */ new WeakMap();
-var _parent = /* @__PURE__ */ new WeakMap();
-var _attributes = /* @__PURE__ */ new WeakMap();
-var _onError = /* @__PURE__ */ new WeakMap();
-var _flags = /* @__PURE__ */ new WeakMap();
-var _disposePromise = /* @__PURE__ */ new WeakMap();
-var _isDisposed = /* @__PURE__ */ new WeakMap();
-var _leakDetected = /* @__PURE__ */ new WeakMap();
-var _inspect_custom = inspect.custom;
 var Context = class _Context {
   static default() {
     return new _Context();
   }
+  #disposeCallbacks = [];
+  #name = void 0;
+  #parent = void 0;
+  #attributes;
+  #onError;
+  #flags = 0;
+  #disposePromise = void 0;
+  #signal = void 0;
+  maxSafeDisposeCallbacks = MAX_SAFE_DISPOSE_CALLBACKS;
+  constructor(params = {}, callMeta) {
+    this.#name = getContextName(params, callMeta);
+    this.#parent = params.parent;
+    this.#attributes = params.attributes ?? {};
+    this.#onError = params.onError ?? DEFAULT_ERROR_HANDLER;
+  }
+  get #isDisposed() {
+    return !!(this.#flags & CONTEXT_FLAG_IS_DISPOSED);
+  }
+  set #isDisposed(value) {
+    this.#flags = value ? this.#flags | CONTEXT_FLAG_IS_DISPOSED : this.#flags & ~CONTEXT_FLAG_IS_DISPOSED;
+  }
+  get #leakDetected() {
+    return !!(this.#flags & CONTEXT_FLAG_LEAK_DETECTED);
+  }
+  set #leakDetected(value) {
+    this.#flags = value ? this.#flags | CONTEXT_FLAG_LEAK_DETECTED : this.#flags & ~CONTEXT_FLAG_LEAK_DETECTED;
+  }
   get disposed() {
-    return _class_private_field_get(this, _isDisposed);
+    return this.#isDisposed;
   }
   get disposeCallbacksLength() {
-    return _class_private_field_get(this, _disposeCallbacks).length;
+    return this.#disposeCallbacks.length;
+  }
+  get signal() {
+    if (this.#signal) {
+      return this.#signal;
+    }
+    const controller = new AbortController();
+    this.#signal = controller.signal;
+    this.onDispose(() => controller.abort());
+    return this.#signal;
   }
   /**
   * Schedules a callback to run when the context is disposed.
@@ -115,41 +87,31 @@ var Context = class _Context {
   * @returns A function that can be used to remove the callback from the dispose list.
   */
   onDispose(callback) {
-    if (_class_private_field_get(this, _isDisposed)) {
+    if (this.#isDisposed) {
       void (async () => {
         try {
           await callback();
         } catch (error) {
           log.catch(error, {
-            context: _class_private_field_get(this, _name)
-          }, {
-            F: __dxlog_file,
-            L: 119,
-            S: this,
-            C: (f, a) => f(...a)
+            context: this.#name
           });
         }
       })();
     }
-    _class_private_field_get(this, _disposeCallbacks).push(callback);
-    if (_class_private_field_get(this, _disposeCallbacks).length > this.maxSafeDisposeCallbacks && !_class_private_field_get(this, _leakDetected)) {
-      _class_private_field_set(this, _leakDetected, true);
+    this.#disposeCallbacks.push(callback);
+    if (this.#disposeCallbacks.length > this.maxSafeDisposeCallbacks && !this.#leakDetected) {
+      this.#leakDetected = true;
       const callSite = new StackTrace().getStackArray(1)[0].trim();
       log.warn("Context has a large number of dispose callbacks (this might be a memory leak).", {
-        context: _class_private_field_get(this, _name),
+        context: this.#name,
         callSite,
-        count: _class_private_field_get(this, _disposeCallbacks).length
-      }, {
-        F: __dxlog_file,
-        L: 128,
-        S: this,
-        C: (f, a) => f(...a)
+        count: this.#disposeCallbacks.length
       });
     }
     return () => {
-      const index = _class_private_field_get(this, _disposeCallbacks).indexOf(callback);
+      const index = this.#disposeCallbacks.indexOf(callback);
       if (index !== -1) {
-        _class_private_field_get(this, _disposeCallbacks).splice(index, 1);
+        this.#disposeCallbacks.splice(index, 1);
       }
     };
   }
@@ -162,26 +124,21 @@ var Context = class _Context {
   * @returns true if there were no errors during the dispose process.
   */
   async dispose(throwOnError = false) {
-    if (_class_private_field_get(this, _disposePromise)) {
-      return _class_private_field_get(this, _disposePromise);
+    if (this.#disposePromise) {
+      return this.#disposePromise;
     }
-    _class_private_field_set(this, _isDisposed, true);
+    this.#isDisposed = true;
     let resolveDispose;
     const promise = new Promise((resolve) => {
       resolveDispose = resolve;
     });
-    _class_private_field_set(this, _disposePromise, promise);
-    const callbacks = Array.from(_class_private_field_get(this, _disposeCallbacks)).reverse();
-    _class_private_field_get(this, _disposeCallbacks).length = 0;
+    this.#disposePromise = promise;
+    const callbacks = Array.from(this.#disposeCallbacks).reverse();
+    this.#disposeCallbacks.length = 0;
     if (DEBUG_LOG_DISPOSE) {
       log("disposing", {
-        context: _class_private_field_get(this, _name),
+        context: this.#name,
         count: callbacks.length
-      }, {
-        F: __dxlog_file,
-        L: 173,
-        S: this,
-        C: (f, a) => f(...a)
       });
     }
     let i = 0;
@@ -197,14 +154,9 @@ var Context = class _Context {
           errors.push(err);
         } else {
           log.catch(err, {
-            context: _class_private_field_get(this, _name),
+            context: this.#name,
             callback: i,
             count: callbacks.length
-          }, {
-            F: __dxlog_file,
-            L: 188,
-            S: this,
-            C: (f, a) => f(...a)
           });
         }
       }
@@ -215,12 +167,7 @@ var Context = class _Context {
     resolveDispose(clean);
     if (DEBUG_LOG_DISPOSE) {
       log("disposed", {
-        context: _class_private_field_get(this, _name)
-      }, {
-        F: __dxlog_file,
-        L: 199,
-        S: this,
-        C: (f, a) => f(...a)
+        context: this.#name
       });
     }
     return clean;
@@ -231,17 +178,18 @@ var Context = class _Context {
   * IF the error handler is not set, the error will dispose the context and cause an unhandled rejection.
   */
   raise(error) {
-    if (_class_private_field_get(this, _isDisposed)) {
+    if (this.#isDisposed) {
       return;
     }
     try {
-      _class_private_field_get(this, _onError).call(this, error, this);
+      this.#onError(error, this);
     } catch (err) {
       void Promise.reject(err);
     }
   }
   derive({ onError, attributes } = {}) {
     const newCtx = new _Context({
+      parent: this,
       // TODO(dmaretskyi): Optimize to not require allocating a new closure for every context.
       onError: async (error) => {
         if (!onError) {
@@ -261,78 +209,23 @@ var Context = class _Context {
     return newCtx;
   }
   getAttribute(key) {
-    if (key in _class_private_field_get(this, _attributes)) {
-      return _class_private_field_get(this, _attributes)[key];
+    if (key in this.#attributes) {
+      return this.#attributes[key];
     }
-    if (_class_private_field_get(this, _parent)) {
-      return _class_private_field_get(this, _parent).getAttribute(key);
+    if (this.#parent) {
+      return this.#parent.getAttribute(key);
     }
     return void 0;
   }
+  [Symbol.toStringTag] = "Context";
+  [inspect.custom] = () => this.toString();
   toString() {
-    return `Context(${_class_private_field_get(this, _isDisposed) ? "disposed" : "active"})`;
+    return `Context(${this.#isDisposed ? "disposed" : "active"})`;
   }
   async [Symbol.asyncDispose]() {
     await this.dispose();
   }
-  constructor(params = {}, callMeta) {
-    _class_private_field_init(this, _isDisposed, {
-      get: get_isDisposed,
-      set: set_isDisposed
-    });
-    _class_private_field_init(this, _leakDetected, {
-      get: get_leakDetected,
-      set: set_leakDetected
-    });
-    _class_private_field_init(this, _disposeCallbacks, {
-      writable: true,
-      value: []
-    });
-    _class_private_field_init(this, _name, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_init(this, _parent, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_init(this, _attributes, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_init(this, _onError, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_init(this, _flags, {
-      writable: true,
-      value: 0
-    });
-    _class_private_field_init(this, _disposePromise, {
-      writable: true,
-      value: void 0
-    });
-    _define_property(this, "maxSafeDisposeCallbacks", MAX_SAFE_DISPOSE_CALLBACKS);
-    _define_property(this, Symbol.toStringTag, "Context");
-    _define_property(this, _inspect_custom, () => this.toString());
-    _class_private_field_set(this, _name, getContextName(params, callMeta));
-    _class_private_field_set(this, _parent, params.parent);
-    _class_private_field_set(this, _attributes, params.attributes ?? {});
-    _class_private_field_set(this, _onError, params.onError ?? DEFAULT_ERROR_HANDLER);
-  }
 };
-function get_isDisposed() {
-  return !!(_class_private_field_get(this, _flags) & CONTEXT_FLAG_IS_DISPOSED);
-}
-function set_isDisposed(value) {
-  _class_private_field_set(this, _flags, value ? _class_private_field_get(this, _flags) | CONTEXT_FLAG_IS_DISPOSED : _class_private_field_get(this, _flags) & ~CONTEXT_FLAG_IS_DISPOSED);
-}
-function get_leakDetected() {
-  return !!(_class_private_field_get(this, _flags) & CONTEXT_FLAG_LEAK_DETECTED);
-}
-function set_leakDetected(value) {
-  _class_private_field_set(this, _flags, value ? _class_private_field_get(this, _flags) | CONTEXT_FLAG_LEAK_DETECTED : _class_private_field_get(this, _flags) & ~CONTEXT_FLAG_LEAK_DETECTED);
-}
 Context = _ts_decorate([
   safeInstanceof("Context")
 ], Context);
@@ -362,93 +255,61 @@ var cancelWithContext = (ctx, promise) => {
 };
 
 // src/resource.ts
+import "@hazae41/symbol-dispose-polyfill";
 import { throwUnhandledError } from "@dxos/util";
-function _check_private_redeclaration2(obj, privateCollection) {
-  if (privateCollection.has(obj)) {
-    throw new TypeError("Cannot initialize the same private elements twice on an object");
-  }
-}
-function _class_apply_descriptor_get2(receiver, descriptor) {
-  if (descriptor.get) {
-    return descriptor.get.call(receiver);
-  }
-  return descriptor.value;
-}
-function _class_apply_descriptor_set2(receiver, descriptor, value) {
-  if (descriptor.set) {
-    descriptor.set.call(receiver, value);
-  } else {
-    if (!descriptor.writable) {
-      throw new TypeError("attempted to set read only private field");
-    }
-    descriptor.value = value;
-  }
-}
-function _class_extract_field_descriptor2(receiver, privateMap, action) {
-  if (!privateMap.has(receiver)) {
-    throw new TypeError("attempted to " + action + " private field on non-instance");
-  }
-  return privateMap.get(receiver);
-}
-function _class_private_field_get2(receiver, privateMap) {
-  var descriptor = _class_extract_field_descriptor2(receiver, privateMap, "get");
-  return _class_apply_descriptor_get2(receiver, descriptor);
-}
-function _class_private_field_init2(obj, privateMap, value) {
-  _check_private_redeclaration2(obj, privateMap);
-  privateMap.set(obj, value);
-}
-function _class_private_field_set2(receiver, privateMap, value) {
-  var descriptor = _class_extract_field_descriptor2(receiver, privateMap, "set");
-  _class_apply_descriptor_set2(receiver, descriptor, value);
-  return value;
-}
-function _class_private_method_get(receiver, privateSet, fn) {
-  if (!privateSet.has(receiver)) {
-    throw new TypeError("attempted to get private field on non-instance");
-  }
-  return fn;
-}
-function _class_private_method_init(obj, privateSet) {
-  _check_private_redeclaration2(obj, privateSet);
-  privateSet.add(obj);
-}
-var LifecycleState = /* @__PURE__ */ function(LifecycleState2) {
+var LifecycleState = /* @__PURE__ */ (function(LifecycleState2) {
   LifecycleState2["CLOSED"] = "CLOSED";
   LifecycleState2["OPEN"] = "OPEN";
   LifecycleState2["ERROR"] = "ERROR";
   return LifecycleState2;
-}({});
+})({});
 var CLOSE_RESOURCE_ON_UNHANDLED_ERROR = false;
-var _lifecycleState = /* @__PURE__ */ new WeakMap();
-var _openPromise = /* @__PURE__ */ new WeakMap();
-var _closePromise = /* @__PURE__ */ new WeakMap();
-var _internalCtx = /* @__PURE__ */ new WeakMap();
-var _parentCtx = /* @__PURE__ */ new WeakMap();
-var _name2 = /* @__PURE__ */ new WeakMap();
-var _open = /* @__PURE__ */ new WeakSet();
-var _close = /* @__PURE__ */ new WeakSet();
-var _createContext = /* @__PURE__ */ new WeakSet();
-var _createParentContext = /* @__PURE__ */ new WeakSet();
 var Resource = class {
+  #lifecycleState = "CLOSED";
+  #openPromise = null;
+  #closePromise = null;
+  /**
+  * Managed internally by the resource.
+  * Recreated on close.
+  * Errors are propagated to the `_catch` method and the parent context.
+  */
+  #internalCtx = this.#createContext();
+  /**
+  * Context that is used to bubble up errors that are not handled by the resource.
+  * Provided in the open method.
+  */
+  #parentCtx = this.#createParentContext();
+  /**
+  * ```ts
+  * await using resource = new Resource();
+  * await resource.open();
+  * ```
+  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/using
+  */
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  get #name() {
+    return Object.getPrototypeOf(this).constructor.name;
+  }
   get isOpen() {
-    return _class_private_field_get2(this, _lifecycleState) === "OPEN" && _class_private_field_get2(this, _closePromise) == null;
+    return this.#lifecycleState === "OPEN" && this.#closePromise == null;
   }
   get _lifecycleState() {
-    return _class_private_field_get2(this, _lifecycleState);
+    return this.#lifecycleState;
   }
   get _ctx() {
-    return _class_private_field_get2(this, _internalCtx);
+    return this.#internalCtx;
   }
   /**
   * To be overridden by subclasses.
   */
-  async _open(ctx) {
+  async _open(_ctx) {
   }
   /**
   * To be overridden by subclasses.
   */
-  async _close(ctx) {
+  async _close(_ctx) {
   }
   /**
   * Error handler for errors that are caught by the context.
@@ -465,6 +326,19 @@ var Resource = class {
     throw err;
   }
   /**
+  * Calls the provided function, opening and closing the resource.
+  * NOTE: Consider using `using` instead.
+  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/using
+  */
+  async use(fn) {
+    try {
+      await this.open();
+      return await fn(this);
+    } finally {
+      await this.close();
+    }
+  }
+  /**
   * Opens the resource.
   * If the resource is already open, it does nothing.
   * If the resource is in an error state, it throws an error.
@@ -472,15 +346,15 @@ var Resource = class {
   * @param ctx - Context to use for opening the resource. This context will receive errors that are not handled in `_catch`.
   */
   async open(ctx) {
-    switch (_class_private_field_get2(this, _lifecycleState)) {
+    switch (this.#lifecycleState) {
       case "OPEN":
         return this;
       case "ERROR":
-        throw new Error(`Invalid state: ${_class_private_field_get2(this, _lifecycleState)}`);
+        throw new Error(`Invalid state: ${this.#lifecycleState}`);
       default:
     }
-    await _class_private_field_get2(this, _closePromise);
-    await _class_private_field_set2(this, _openPromise, _class_private_field_get2(this, _openPromise) ?? _class_private_method_get(this, _open, open).call(this, ctx));
+    await this.#closePromise;
+    await (this.#openPromise ??= this.#open(ctx));
     return this;
   }
   /**
@@ -488,108 +362,111 @@ var Resource = class {
   * If the resource is already closed, it does nothing.
   */
   async close(ctx) {
-    if (_class_private_field_get2(this, _lifecycleState) === "CLOSED") {
+    if (this.#lifecycleState === "CLOSED") {
       return this;
     }
-    await _class_private_field_get2(this, _openPromise);
-    await _class_private_field_set2(this, _closePromise, _class_private_field_get2(this, _closePromise) ?? _class_private_method_get(this, _close, close).call(this, ctx));
+    await this.#openPromise;
+    await (this.#closePromise ??= this.#close(ctx));
     return this;
   }
   /**
   * Waits until the resource is open.
   */
   async waitUntilOpen() {
-    switch (_class_private_field_get2(this, _lifecycleState)) {
+    switch (this.#lifecycleState) {
       case "OPEN":
         return;
       case "ERROR":
-        throw new Error(`Invalid state: ${_class_private_field_get2(this, _lifecycleState)}`);
+        throw new Error(`Invalid state: ${this.#lifecycleState}`);
     }
-    if (!_class_private_field_get2(this, _openPromise)) {
+    if (!this.#openPromise) {
       throw new Error("Resource is not being opened");
     }
-    await _class_private_field_get2(this, _openPromise);
-  }
-  async [Symbol.asyncDispose]() {
-    await this.close();
-  }
-  constructor() {
-    _class_private_field_init2(this, _name2, {
-      get: get_name,
-      set: void 0
-    });
-    _class_private_method_init(this, _open);
-    _class_private_method_init(this, _close);
-    _class_private_method_init(this, _createContext);
-    _class_private_method_init(this, _createParentContext);
-    _class_private_field_init2(this, _lifecycleState, {
-      writable: true,
-      value: "CLOSED"
-    });
-    _class_private_field_init2(this, _openPromise, {
-      writable: true,
-      value: null
-    });
-    _class_private_field_init2(this, _closePromise, {
-      writable: true,
-      value: null
-    });
-    _class_private_field_init2(this, _internalCtx, {
-      writable: true,
-      value: _class_private_method_get(this, _createContext, createContext).call(this)
+    await this.#openPromise;
+  }
+  async #open(ctx) {
+    this.#closePromise = null;
+    this.#parentCtx = ctx?.derive({
+      name: this.#name
+    }) ?? this.#createParentContext();
+    this.#internalCtx = this.#createContext(this.#parentCtx);
+    await this._open(this.#parentCtx);
+    this.#lifecycleState = "OPEN";
+  }
+  async #close(ctx = Context.default()) {
+    this.#openPromise = null;
+    await this.#internalCtx.dispose();
+    await this._close(ctx);
+    this.#internalCtx = this.#createContext();
+    this.#lifecycleState = "CLOSED";
+  }
+  #createContext(attributeParent) {
+    return new Context({
+      name: this.#name,
+      parent: attributeParent,
+      onError: (error) => queueMicrotask(async () => {
+        try {
+          await this._catch(error);
+        } catch (err) {
+          this.#lifecycleState = "ERROR";
+          this.#parentCtx.raise(err);
+        }
+      })
     });
-    _class_private_field_init2(this, _parentCtx, {
-      writable: true,
-      value: _class_private_method_get(this, _createParentContext, createParentContext).call(this)
+  }
+  #createParentContext() {
+    return new Context({
+      name: this.#name
     });
   }
 };
-function get_name() {
-  return Object.getPrototypeOf(this).constructor.name;
-}
-async function open(ctx) {
-  _class_private_field_set2(this, _closePromise, null);
-  _class_private_field_set2(this, _parentCtx, ctx?.derive({
-    name: _class_private_field_get2(this, _name2)
-  }) ?? _class_private_method_get(this, _createParentContext, createParentContext).call(this));
-  await this._open(_class_private_field_get2(this, _parentCtx));
-  _class_private_field_set2(this, _lifecycleState, "OPEN");
-}
-async function close(ctx = Context.default()) {
-  _class_private_field_set2(this, _openPromise, null);
-  await _class_private_field_get2(this, _internalCtx).dispose();
-  await this._close(ctx);
-  _class_private_field_set2(this, _internalCtx, _class_private_method_get(this, _createContext, createContext).call(this));
-  _class_private_field_set2(this, _lifecycleState, "CLOSED");
-}
-function createContext() {
-  return new Context({
-    name: _class_private_field_get2(this, _name2),
-    onError: (error) => queueMicrotask(async () => {
-      try {
-        await this._catch(error);
-      } catch (err) {
-        _class_private_field_set2(this, _lifecycleState, "ERROR");
-        _class_private_field_get2(this, _parentCtx).raise(err);
-      }
-    })
-  });
-}
-function createParentContext() {
-  return new Context({
-    name: _class_private_field_get2(this, _name2)
-  });
-}
 var openInContext = async (ctx, resource) => {
   await resource.open?.(ctx);
   ctx.onDispose(() => resource.close?.());
   return resource;
 };
+
+// src/trace-context.ts
+var TRACE_SPAN_ATTRIBUTE = "dxos.trace-span";
+var ContextRpcCodec = class {
+  /**
+  * Read the W3C trace context from a DXOS `Context` for an outgoing RPC.
+  *
+  * @returns `TraceContextData` to attach to the wire message, or `undefined`
+  *          if the context has no active trace.
+  */
+  static encode(ctx) {
+    const traceCtx = ctx.getAttribute(TRACE_SPAN_ATTRIBUTE);
+    if (traceCtx == null || typeof traceCtx.traceparent !== "string") {
+      return void 0;
+    }
+    return traceCtx;
+  }
+  /**
+  * Reconstruct a DXOS `Context` from W3C trace context received in an
+  * incoming RPC request.
+  *
+  * @returns A `Context` carrying the trace context, or `Context.default()`
+  *          if the data is missing/invalid.
+  */
+  static decode(traceContext) {
+    if (typeof traceContext.traceparent !== "string" || traceContext.traceparent.length === 0) {
+      return Context.default();
+    }
+    return new Context({
+      attributes: {
+        [TRACE_SPAN_ATTRIBUTE]: traceContext
+      }
+    });
+  }
+};
 export {
   Context,
   ContextDisposedError,
+  ContextRpcCodec,
   LifecycleState,
   Resource,
+  TRACE_SPAN_ATTRIBUTE,
   cancelWithContext,
   openInContext,
   rejectOnDispose