@dxos/client-services 0.6.13 → 0.6.14-main.2b6a0f3

package/dist/lib/node/index.cjs

@@ -18,78 +18,351 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  ClientRpcServer: () => import_chunk_PZ3JJJ3K.ClientRpcServer,
-  ClientServicesHost: () => import_chunk_PZ3JJJ3K.ClientServicesHost,
-  DataSpace: () => import_chunk_PZ3JJJ3K.DataSpace,
-  DataSpaceManager: () => import_chunk_PZ3JJJ3K.DataSpaceManager,
-  DeviceInvitationProtocol: () => import_chunk_PZ3JJJ3K.DeviceInvitationProtocol,
-  DevtoolsHostEvents: () => import_chunk_PZ3JJJ3K.DevtoolsHostEvents,
-  DevtoolsServiceImpl: () => import_chunk_PZ3JJJ3K.DevtoolsServiceImpl,
-  DiagnosticsCollector: () => import_chunk_PZ3JJJ3K.DiagnosticsCollector,
-  EdgeFeedReplicator: () => import_chunk_PZ3JJJ3K.EdgeFeedReplicator,
-  Identity: () => import_chunk_PZ3JJJ3K.Identity,
-  IdentityManager: () => import_chunk_PZ3JJJ3K.IdentityManager,
-  IdentityServiceImpl: () => import_chunk_PZ3JJJ3K.IdentityServiceImpl,
-  InvitationsHandler: () => import_chunk_PZ3JJJ3K.InvitationsHandler,
-  InvitationsManager: () => import_chunk_PZ3JJJ3K.InvitationsManager,
-  InvitationsServiceImpl: () => import_chunk_PZ3JJJ3K.InvitationsServiceImpl,
-  Lock: () => import_chunk_PZ3JJJ3K.Lock,
-  ServiceContext: () => import_chunk_PZ3JJJ3K.ServiceContext,
-  ServiceRegistry: () => import_chunk_PZ3JJJ3K.ServiceRegistry,
-  SpaceInvitationProtocol: () => import_chunk_PZ3JJJ3K.SpaceInvitationProtocol,
-  SpacesServiceImpl: () => import_chunk_PZ3JJJ3K.SpacesServiceImpl,
-  TrustedKeySetAuthVerifier: () => import_chunk_PZ3JJJ3K.TrustedKeySetAuthVerifier,
+  ClientRpcServer: () => ClientRpcServer,
+  ClientServicesHost: () => import_chunk_SJEDBF7U.ClientServicesHost,
+  DataSpace: () => import_chunk_SJEDBF7U.DataSpace,
+  DataSpaceManager: () => import_chunk_SJEDBF7U.DataSpaceManager,
+  DeviceInvitationProtocol: () => import_chunk_SJEDBF7U.DeviceInvitationProtocol,
+  DevtoolsHostEvents: () => import_chunk_SJEDBF7U.DevtoolsHostEvents,
+  DevtoolsServiceImpl: () => import_chunk_SJEDBF7U.DevtoolsServiceImpl,
+  DiagnosticsCollector: () => DiagnosticsCollector,
+  EdgeAgentManager: () => import_chunk_SJEDBF7U.EdgeAgentManager,
+  EdgeAgentServiceImpl: () => import_chunk_SJEDBF7U.EdgeAgentServiceImpl,
+  EdgeFeedReplicator: () => import_chunk_SJEDBF7U.EdgeFeedReplicator,
+  Identity: () => import_chunk_SJEDBF7U.Identity,
+  IdentityManager: () => import_chunk_SJEDBF7U.IdentityManager,
+  IdentityServiceImpl: () => import_chunk_SJEDBF7U.IdentityServiceImpl,
+  InvitationsHandler: () => import_chunk_SJEDBF7U.InvitationsHandler,
+  InvitationsManager: () => import_chunk_SJEDBF7U.InvitationsManager,
+  InvitationsServiceImpl: () => import_chunk_SJEDBF7U.InvitationsServiceImpl,
+  Lock: () => import_chunk_SJEDBF7U.Lock,
+  ServiceContext: () => import_chunk_SJEDBF7U.ServiceContext,
+  ServiceRegistry: () => import_chunk_SJEDBF7U.ServiceRegistry,
+  SpaceInvitationProtocol: () => import_chunk_SJEDBF7U.SpaceInvitationProtocol,
+  SpacesServiceImpl: () => import_chunk_SJEDBF7U.SpacesServiceImpl,
+  TrustedKeySetAuthVerifier: () => import_chunk_SJEDBF7U.TrustedKeySetAuthVerifier,
   WorkerRuntime: () => WorkerRuntime,
   WorkerSession: () => WorkerSession,
-  createAdmissionKeypair: () => import_chunk_PZ3JJJ3K.createAdmissionKeypair,
-  createAuthProvider: () => import_chunk_PZ3JJJ3K.createAuthProvider,
-  createCollectDiagnosticsBroadcastHandler: () => import_chunk_PZ3JJJ3K.createCollectDiagnosticsBroadcastHandler,
-  createCollectDiagnosticsBroadcastSender: () => import_chunk_PZ3JJJ3K.createCollectDiagnosticsBroadcastSender,
-  createDiagnostics: () => import_chunk_PZ3JJJ3K.createDiagnostics,
-  createLevel: () => import_chunk_PZ3JJJ3K.createLevel,
-  createStorageObjects: () => import_chunk_PZ3JJJ3K.createStorageObjects,
-  decodeProfileArchive: () => import_chunk_PZ3JJJ3K.decodeProfileArchive,
-  encodeProfileArchive: () => import_chunk_PZ3JJJ3K.encodeProfileArchive,
-  exportProfileData: () => import_chunk_PZ3JJJ3K.exportProfileData,
-  getNetworkPeers: () => import_chunk_PZ3JJJ3K.getNetworkPeers,
-  importProfileData: () => import_chunk_PZ3JJJ3K.importProfileData,
-  isLocked: () => import_chunk_PZ3JJJ3K.isLocked,
-  subscribeToFeedBlocks: () => import_chunk_PZ3JJJ3K.subscribeToFeedBlocks,
-  subscribeToFeeds: () => import_chunk_PZ3JJJ3K.subscribeToFeeds,
-  subscribeToNetworkStatus: () => import_chunk_PZ3JJJ3K.subscribeToNetworkStatus,
-  subscribeToNetworkTopics: () => import_chunk_PZ3JJJ3K.subscribeToNetworkTopics,
-  subscribeToSignal: () => import_chunk_PZ3JJJ3K.subscribeToSignal,
-  subscribeToSpaces: () => import_chunk_PZ3JJJ3K.subscribeToSpaces,
-  subscribeToSwarmInfo: () => import_chunk_PZ3JJJ3K.subscribeToSwarmInfo
+  createAdmissionKeypair: () => import_chunk_SJEDBF7U.createAdmissionKeypair,
+  createAuthProvider: () => import_chunk_SJEDBF7U.createAuthProvider,
+  createCollectDiagnosticsBroadcastHandler: () => import_chunk_SJEDBF7U.createCollectDiagnosticsBroadcastHandler,
+  createCollectDiagnosticsBroadcastSender: () => import_chunk_SJEDBF7U.createCollectDiagnosticsBroadcastSender,
+  createDiagnostics: () => import_chunk_SJEDBF7U.createDiagnostics,
+  createLevel: () => import_chunk_SJEDBF7U.createLevel,
+  createStorageObjects: () => import_chunk_SJEDBF7U.createStorageObjects,
+  decodeProfileArchive: () => decodeProfileArchive,
+  encodeProfileArchive: () => encodeProfileArchive,
+  exportProfileData: () => exportProfileData,
+  getNetworkPeers: () => import_chunk_SJEDBF7U.getNetworkPeers,
+  importProfileData: () => importProfileData,
+  isLocked: () => import_chunk_SJEDBF7U.isLocked,
+  subscribeToFeedBlocks: () => import_chunk_SJEDBF7U.subscribeToFeedBlocks,
+  subscribeToFeeds: () => import_chunk_SJEDBF7U.subscribeToFeeds,
+  subscribeToNetworkStatus: () => import_chunk_SJEDBF7U.subscribeToNetworkStatus,
+  subscribeToNetworkTopics: () => import_chunk_SJEDBF7U.subscribeToNetworkTopics,
+  subscribeToSignal: () => import_chunk_SJEDBF7U.subscribeToSignal,
+  subscribeToSpaces: () => import_chunk_SJEDBF7U.subscribeToSpaces,
+  subscribeToSwarmInfo: () => import_chunk_SJEDBF7U.subscribeToSwarmInfo
 });
 module.exports = __toCommonJS(node_exports);
-var import_chunk_PZ3JJJ3K = require("./chunk-PZ3JJJ3K.cjs");
-var import_async = require("@dxos/async");
+var import_chunk_SJEDBF7U = require("./chunk-SJEDBF7U.cjs");
 var import_client_protocol = require("@dxos/client-protocol");
-var import_context = require("@dxos/context");
+var import_config = require("@dxos/config");
+var import_services = require("@dxos/protocols/proto/dxos/client/services");
+var import_tracing = require("@dxos/tracing");
+var import_util = require("@dxos/util");
+var import_codec_protobuf = require("@dxos/codec-protobuf");
+var import_debug = require("@dxos/debug");
+var import_rpc = require("@dxos/rpc");
+var import_tracing2 = require("@dxos/tracing");
+var import_automerge_repo = require("@dxos/automerge/automerge-repo");
 var import_invariant = require("@dxos/invariant");
 var import_log = require("@dxos/log");
-var import_messaging = require("@dxos/messaging");
-var import_network_manager = require("@dxos/network-manager");
-var import_async2 = require("@dxos/async");
+var import_protocols = require("@dxos/protocols");
+var import_util2 = require("@dxos/util");
+var import_async = require("@dxos/async");
 var import_client_protocol2 = require("@dxos/client-protocol");
+var import_context = require("@dxos/context");
 var import_invariant2 = require("@dxos/invariant");
 var import_log2 = require("@dxos/log");
-var import_rpc = require("@dxos/rpc");
-var import_util = require("@dxos/util");
+var import_messaging = require("@dxos/messaging");
+var import_network_manager = require("@dxos/network-manager");
+var import_async2 = require("@dxos/async");
+var import_client_protocol3 = require("@dxos/client-protocol");
+var import_invariant3 = require("@dxos/invariant");
+var import_log3 = require("@dxos/log");
+var import_rpc2 = require("@dxos/rpc");
+var import_util3 = require("@dxos/util");
+var GET_DIAGNOSTICS_RPC_TIMEOUT = 1e4;
+var DiagnosticsCollector = class {
+  static {
+    this.broadcastSender = (0, import_chunk_SJEDBF7U.createCollectDiagnosticsBroadcastSender)();
+  }
+  static async collect(config = findConfigs(), services = findSystemServiceProvider(), options = {}) {
+    const serviceDiagnostics = await services?.services?.SystemService?.getDiagnostics({
+      keys: options.humanize ? import_services.GetDiagnosticsRequest.KEY_OPTION.HUMANIZE : options.truncate ? import_services.GetDiagnosticsRequest.KEY_OPTION.TRUNCATE : void 0
+    }, {
+      timeout: GET_DIAGNOSTICS_RPC_TIMEOUT
+    });
+    const clientDiagnostics = {
+      config,
+      trace: import_tracing.TRACE_PROCESSOR.getDiagnostics()
+    };
+    const diagnostics = serviceDiagnostics != null ? {
+      client: clientDiagnostics,
+      services: serviceDiagnostics
+    } : {
+      client: clientDiagnostics,
+      broadcast: await this.broadcastSender.broadcastDiagnosticsRequest()
+    };
+    return JSON.parse(JSON.stringify(diagnostics, (0, import_util.jsonKeyReplacer)(options)));
+  }
+};
+var findSystemServiceProvider = () => {
+  const serviceProviders = import_tracing.TRACE_PROCESSOR.findResourcesByAnnotation(import_client_protocol.ClientServicesProviderResource);
+  const providerResource = serviceProviders.find((r) => r.instance.deref()?.services?.SystemService != null);
+  return providerResource?.instance?.deref() ?? null;
+};
+var findConfigs = () => {
+  const configs = import_tracing.TRACE_PROCESSOR.findResourcesByAnnotation(import_config.ConfigResource);
+  return configs.map((r) => r.instance.deref()).filter(import_util.nonNullable);
+};
 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/sdk/client-services/src/packlets/worker/worker-session.ts";
+var ClientRpcServer = class {
+  constructor(params) {
+    this._handlerCache = /* @__PURE__ */ new Map();
+    this._callMetrics = new import_tracing2.MapCounter();
+    const { serviceRegistry, handleCall, handleStream, ...rpcOptions } = params;
+    this._handleCall = handleCall;
+    this._handleStream = handleStream;
+    this._serviceRegistry = serviceRegistry;
+    this._rpcPeer = new import_rpc.RpcPeer({
+      ...rpcOptions,
+      callHandler: (method, params2) => {
+        const [serviceName, methodName] = (0, import_rpc.parseMethodName)(method);
+        const handler = (method2, params3) => this._getServiceHandler(serviceName).call(method2, params3);
+        this._callMetrics.inc(`${serviceName}.${methodName} request`);
+        if (this._handleCall) {
+          return this._handleCall(methodName, params2, handler);
+        } else {
+          return handler(methodName, params2);
+        }
+      },
+      streamHandler: (method, params2) => {
+        const [serviceName, methodName] = (0, import_rpc.parseMethodName)(method);
+        const handler = (method2, params3) => this._getServiceHandler(serviceName).callStream(method2, params3);
+        this._callMetrics.inc(`${serviceName}.${methodName} request stream`);
+        if (this._handleStream) {
+          return import_codec_protobuf.Stream.map(import_codec_protobuf.Stream.unwrapPromise(this._handleStream(methodName, params2, handler)), (data) => {
+            this._callMetrics.inc(`${serviceName}.${methodName} response stream`);
+            return data;
+          });
+        } else {
+          return handler(methodName, params2);
+        }
+      }
+    });
+  }
+  get _services() {
+    return Object.keys(this._serviceRegistry.services);
+  }
+  async open() {
+    await this._rpcPeer.open();
+  }
+  async close() {
+    await this._rpcPeer.close();
+  }
+  _getServiceHandler(serviceName) {
+    if (!this._handlerCache.has(serviceName)) {
+      const [key, descriptor] = Object.entries(this._serviceRegistry.descriptors).find(([key2, descriptor2]) => descriptor2.name === serviceName) ?? (0, import_debug.raise)(new Error(`Service not available: ${serviceName}`));
+      const service = this._serviceRegistry.services[key];
+      if (!service) {
+        throw new Error(`Service not available: ${serviceName}`);
+      }
+      this._handlerCache.set(serviceName, descriptor.createServer(service));
+    }
+    return this._handlerCache.get(serviceName);
+  }
+};
+_ts_decorate([
+  import_tracing2.trace.metricsCounter()
+], ClientRpcServer.prototype, "_callMetrics", void 0);
+_ts_decorate([
+  import_tracing2.trace.info()
+], ClientRpcServer.prototype, "_services", null);
+ClientRpcServer = _ts_decorate([
+  import_tracing2.trace.resource()
+], ClientRpcServer);
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/storage/profile-archive.ts";
+var encodeProfileArchive = (profile) => import_automerge_repo.cbor.encode(profile);
+var decodeProfileArchive = (data) => import_automerge_repo.cbor.decode(data);
+var exportProfileData = async ({ storage, level }) => {
+  const archive = {
+    storage: [],
+    meta: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  {
+    const directory = await storage.createDirectory();
+    const files = await directory.list();
+    import_log.log.info("begin exporting files", {
+      count: files.length
+    }, {
+      F: __dxlog_file,
+      L: 30,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    for (const filename of files) {
+      const file = await directory.getOrCreateFile(filename);
+      const { size } = await file.stat();
+      const data = await file.read(0, size);
+      archive.storage.push({
+        type: import_protocols.ProfileArchiveEntryType.FILE,
+        key: filename,
+        value: data
+      });
+    }
+    import_log.log.info("done exporting files", {
+      count: files.length
+    }, {
+      F: __dxlog_file,
+      L: 41,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+  {
+    import_log.log.info("begin exporting kv pairs", void 0, {
+      F: __dxlog_file,
+      L: 45,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    const iter = await level.iterator({
+      keyEncoding: "binary",
+      valueEncoding: "binary"
+    });
+    let count = 0;
+    for await (const [key, value] of iter) {
+      archive.storage.push({
+        type: import_protocols.ProfileArchiveEntryType.KEY_VALUE,
+        key,
+        value
+      });
+      count++;
+    }
+    import_log.log.info("done exporting kv pairs", {
+      count
+    }, {
+      F: __dxlog_file,
+      L: 56,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+  return archive;
+};
+var importProfileData = async ({ storage, level }, archive) => {
+  let batch = level.batch();
+  let count = 0;
+  for (const entry of archive.storage) {
+    switch (entry.type) {
+      case import_protocols.ProfileArchiveEntryType.FILE: {
+        const directory = await storage.createDirectory();
+        (0, import_invariant.invariant)(typeof entry.key === "string", "Invalid key type", {
+          F: __dxlog_file,
+          L: 79,
+          S: void 0,
+          A: [
+            "typeof entry.key === 'string'",
+            "'Invalid key type'"
+          ]
+        });
+        const file = await directory.getOrCreateFile(entry.key);
+        (0, import_invariant.invariant)(entry.value instanceof Uint8Array, "Invalid value type", {
+          F: __dxlog_file,
+          L: 81,
+          S: void 0,
+          A: [
+            "entry.value instanceof Uint8Array",
+            "'Invalid value type'"
+          ]
+        });
+        await file.write(0, (0, import_util2.arrayToBuffer)(entry.value));
+        await file.close();
+        break;
+      }
+      case import_protocols.ProfileArchiveEntryType.KEY_VALUE: {
+        (0, import_invariant.invariant)(entry.key instanceof Uint8Array, "Invalid key type", {
+          F: __dxlog_file,
+          L: 87,
+          S: void 0,
+          A: [
+            "entry.key instanceof Uint8Array",
+            "'Invalid key type'"
+          ]
+        });
+        (0, import_invariant.invariant)(entry.value instanceof Uint8Array, "Invalid value type", {
+          F: __dxlog_file,
+          L: 88,
+          S: void 0,
+          A: [
+            "entry.value instanceof Uint8Array",
+            "'Invalid value type'"
+          ]
+        });
+        batch.put(entry.key, entry.value, {
+          keyEncoding: "binary",
+          valueEncoding: "binary"
+        });
+        break;
+      }
+      default:
+        throw new Error(`Invalid entry type: ${entry.type}`);
+    }
+    if (++count % 1e3 === 0) {
+      await batch.write();
+      batch = level.batch();
+      import_log.log.info("importing", {
+        count,
+        total: archive.storage.length,
+        progress: `${(count / archive.storage.length * 100).toFixed()}%`
+      }, {
+        F: __dxlog_file,
+        L: 101,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  import_log.log.info("committing changes..", void 0, {
+    F: __dxlog_file,
+    L: 109,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  await batch.write();
+};
+function _ts_decorate2(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_file2 = "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-session.ts";
 var WorkerSession = class {
   constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }) {
     this._startTrigger = new import_async2.Trigger();
-    this.onClose = new import_util.Callback();
-    (0, import_invariant2.invariant)(serviceHost, void 0, {
-      F: __dxlog_file,
+    this.onClose = new import_util3.Callback();
+    (0, import_invariant3.invariant)(serviceHost, void 0, {
+      F: __dxlog_file2,
       L: 54,
       S: this,
       A: [
@@ -101,7 +374,7 @@ var WorkerSession = class {
     const middleware = {
       handleCall: async (method, params, handler) => {
         const error = await readySignal.wait({
-          timeout: import_client_protocol2.PROXY_CONNECTION_TIMEOUT
+          timeout: import_client_protocol3.PROXY_CONNECTION_TIMEOUT
         });
         if (error) {
           throw error;
@@ -110,7 +383,7 @@ var WorkerSession = class {
       },
       handleStream: async (method, params, handler) => {
         const error = await readySignal.wait({
-          timeout: import_client_protocol2.PROXY_CONNECTION_TIMEOUT
+          timeout: import_client_protocol3.PROXY_CONNECTION_TIMEOUT
         });
         if (error) {
           throw error;
@@ -118,19 +391,19 @@ var WorkerSession = class {
         return handler(method, params);
       }
     };
-    this._clientRpc = new import_chunk_PZ3JJJ3K.ClientRpcServer({
+    this._clientRpc = new ClientRpcServer({
       serviceRegistry: this._serviceHost.serviceRegistry,
       port: appPort,
       ...middleware
     });
-    this._shellClientRpc = shellPort ? new import_chunk_PZ3JJJ3K.ClientRpcServer({
+    this._shellClientRpc = shellPort ? new ClientRpcServer({
       serviceRegistry: this._serviceHost.serviceRegistry,
       port: shellPort,
       ...middleware
     }) : void 0;
-    this._iframeRpc = (0, import_rpc.createProtoRpcPeer)({
-      requested: import_client_protocol2.iframeServiceBundle,
-      exposed: import_client_protocol2.workerServiceBundle,
+    this._iframeRpc = (0, import_rpc2.createProtoRpcPeer)({
+      requested: import_client_protocol3.iframeServiceBundle,
+      exposed: import_client_protocol3.workerServiceBundle,
       handlers: {
         WorkerService: {
           start: async (request) => {
@@ -145,8 +418,8 @@ var WorkerSession = class {
               try {
                 await this.close();
               } catch (err) {
-                import_log2.log.catch(err, void 0, {
-                  F: __dxlog_file,
+                import_log3.log.catch(err, void 0, {
+                  F: __dxlog_file2,
                   L: 108,
                   S: this,
                   C: (f, a) => f(...a)
@@ -162,8 +435,8 @@ var WorkerSession = class {
     this.bridgeService = this._iframeRpc.rpc.BridgeService;
   }
   async open() {
-    import_log2.log.info("opening...", void 0, {
-      F: __dxlog_file,
+    import_log3.log.info("opening...", void 0, {
+      F: __dxlog_file2,
       L: 122,
       S: this,
       C: (f, a) => f(...a)
@@ -174,21 +447,21 @@ var WorkerSession = class {
       this._maybeOpenShell()
     ]);
     await this._startTrigger.wait({
-      timeout: import_client_protocol2.PROXY_CONNECTION_TIMEOUT
+      timeout: import_client_protocol3.PROXY_CONNECTION_TIMEOUT
     });
     if (this.lockKey) {
       void this._afterLockReleases(this.lockKey, () => this.close());
     }
-    import_log2.log.info("opened", void 0, {
-      F: __dxlog_file,
+    import_log3.log.info("opened", void 0, {
+      F: __dxlog_file2,
       L: 133,
       S: this,
       C: (f, a) => f(...a)
     });
   }
   async close() {
-    import_log2.log.info("closing...", void 0, {
-      F: __dxlog_file,
+    import_log3.log.info("closing...", void 0, {
+      F: __dxlog_file2,
       L: 137,
       S: this,
       C: (f, a) => f(...a)
@@ -196,8 +469,8 @@ var WorkerSession = class {
     try {
       await this.onClose.callIfSet();
     } catch (err) {
-      import_log2.log.catch(err, void 0, {
-        F: __dxlog_file,
+      import_log3.log.catch(err, void 0, {
+        F: __dxlog_file2,
         L: 141,
         S: this,
         C: (f, a) => f(...a)
@@ -207,8 +480,8 @@ var WorkerSession = class {
       this._clientRpc.close(),
       this._iframeRpc.close()
     ]);
-    import_log2.log.info("closed", void 0, {
-      F: __dxlog_file,
+    import_log3.log.info("closed", void 0, {
+      F: __dxlog_file2,
       L: 145,
       S: this,
       C: (f, a) => f(...a)
@@ -218,8 +491,8 @@ var WorkerSession = class {
     try {
       this._shellClientRpc && await (0, import_async2.asyncTimeout)(this._shellClientRpc.open(), 1e3);
     } catch {
-      import_log2.log.info("No shell connected.", void 0, {
-        F: __dxlog_file,
+      import_log3.log.info("No shell connected.", void 0, {
+        F: __dxlog_file2,
         L: 152,
         S: this,
         C: (f, a) => f(...a)
@@ -231,16 +504,16 @@ var WorkerSession = class {
     }).then(callback);
   }
 };
-_ts_decorate([
-  import_log2.logInfo
+_ts_decorate2([
+  import_log3.logInfo
 ], WorkerSession.prototype, "origin", void 0);
-_ts_decorate([
-  import_log2.logInfo
+_ts_decorate2([
+  import_log3.logInfo
 ], WorkerSession.prototype, "lockKey", void 0);
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-runtime.ts";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-runtime.ts";
 var WorkerRuntime = class {
-  constructor({ channel = import_client_protocol.DEFAULT_WORKER_BROADCAST_CHANNEL, configProvider, acquireLock, releaseLock, onStop }) {
-    this._transportFactory = new import_network_manager.SimplePeerTransportProxyFactory();
+  constructor({ channel = import_client_protocol2.DEFAULT_WORKER_BROADCAST_CHANNEL, configProvider, acquireLock, releaseLock, onStop }) {
+    this._transportFactory = new import_network_manager.RtcTransportProxyFactory();
     this._ready = new import_async.Trigger();
     this._sessions = /* @__PURE__ */ new Set();
     this._signalMetadataTags = {
@@ -252,7 +525,7 @@ var WorkerRuntime = class {
     this._releaseLock = releaseLock;
     this._onStop = onStop;
     this._channel = channel;
-    this._clientServices = new import_chunk_PZ3JJJ3K.ClientServicesHost({
+    this._clientServices = new import_chunk_SJEDBF7U.ClientServicesHost({
       callbacks: {
         onReset: async () => this.stop()
       }
@@ -262,8 +535,8 @@ var WorkerRuntime = class {
     return this._clientServices;
   }
   async start() {
-    (0, import_log.log)("starting...", void 0, {
-      F: __dxlog_file2,
+    (0, import_log2.log)("starting...", void 0, {
+      F: __dxlog_file3,
       L: 84,
       S: this,
       C: (f, a) => f(...a)
@@ -287,12 +560,12 @@ var WorkerRuntime = class {
         transportFactory: this._transportFactory
       });
       await this._clientServices.open(new import_context.Context(void 0, {
-        F: __dxlog_file2,
+        F: __dxlog_file3,
         L: 107
       }));
       this._ready.wake(void 0);
-      (0, import_log.log)("started", void 0, {
-        F: __dxlog_file2,
+      (0, import_log2.log)("started", void 0, {
+        F: __dxlog_file3,
         L: 109,
         S: this,
         C: (f, a) => f(...a)
@@ -306,8 +579,8 @@ var WorkerRuntime = class {
       });
     } catch (err) {
       this._ready.wake(err);
-      import_log.log.error("starting", err, {
-        F: __dxlog_file2,
+      import_log2.log.error("starting", err, {
+        F: __dxlog_file3,
         L: 119,
         S: this,
         C: (f, a) => f(...a)
@@ -341,8 +614,8 @@ var WorkerRuntime = class {
       }
     });
     await session.open();
-    (0, import_invariant.invariant)(!this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin, `worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`, {
-      F: __dxlog_file2,
+    (0, import_invariant2.invariant)(!this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin, `worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`, {
+      F: __dxlog_file3,
       L: 157,
       S: this,
       A: [
@@ -362,8 +635,8 @@ var WorkerRuntime = class {
   * Selects one of the existing session for WebRTC networking.
   */
   _reconnectWebrtc() {
-    (0, import_log.log)("reconnecting webrtc...", void 0, {
-      F: __dxlog_file2,
+    (0, import_log2.log)("reconnecting webrtc...", void 0, {
+      F: __dxlog_file3,
       L: 175,
       S: this,
       C: (f, a) => f(...a)
@@ -394,6 +667,8 @@ var WorkerRuntime = class {
   DevtoolsHostEvents,
   DevtoolsServiceImpl,
   DiagnosticsCollector,
+  EdgeAgentManager,
+  EdgeAgentServiceImpl,
   EdgeFeedReplicator,
   Identity,
   IdentityManager,