@dxos/client-services 0.8.3 → 0.8.4-main.05e74ebcff

package/dist/lib/browser/index.mjs

@@ -1,6 +1,5 @@
 import "@dxos/node-std/globals";
 import {
-  ClientRpcServer,
   ClientServicesHost,
   DataSpace,
   DataSpaceManager,
@@ -17,89 +16,339 @@ import {
   InvitationsHandler,
   InvitationsManager,
   InvitationsServiceImpl,
-  Lock,
   ServiceContext,
   ServiceRegistry,
+  SpaceArchiveWriter,
   SpaceInvitationProtocol,
   SpacesServiceImpl,
   TrustedKeySetAuthVerifier,
+  buildDatabaseDirectoryFromObjects,
   createAdmissionKeypair,
   createAuthProvider,
-  createCollectDiagnosticsBroadcastHandler,
-  createCollectDiagnosticsBroadcastSender,
   createDiagnostics,
   createLevel,
   createStorageObjects,
-  decodeProfileArchive,
-  encodeProfileArchive,
-  exportProfileData,
+  detectSpaceArchiveFormat,
+  diagnostics_exports,
+  extractSpaceArchive,
   getNetworkPeers,
-  importProfileData,
-  isLocked,
+  locks_exports,
+  objJsonToObjectStructure,
+  objectStructureToObjJson,
+  orderObjJsonFields,
+  readSerializedSpaceArchive,
   subscribeToFeedBlocks,
   subscribeToFeeds,
   subscribeToNetworkStatus,
   subscribeToNetworkTopics,
   subscribeToSignal,
   subscribeToSpaces,
-  subscribeToSwarmInfo
-} from "./chunk-LBG3C332.mjs";
+  subscribeToSwarmInfo,
+  writeSerializedSpaceArchive
+} from "./chunk-U2YFOK57.mjs";
+import "./chunk-XJRPB3GA.mjs";
+import {
+  __export,
+  __reExport
+} from "./chunk-QCWEHHJW.mjs";
 
-// packages/sdk/client-services/src/packlets/worker/worker-runtime.ts
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ClientRpcServer: () => ClientRpcServer,
+  ClientServicesHost: () => ClientServicesHost,
+  DataSpace: () => DataSpace,
+  DataSpaceManager: () => DataSpaceManager,
+  DeviceInvitationProtocol: () => DeviceInvitationProtocol,
+  DevtoolsHostEvents: () => DevtoolsHostEvents,
+  DevtoolsServiceImpl: () => DevtoolsServiceImpl,
+  DiagnosticsCollector: () => DiagnosticsCollector,
+  EdgeAgentManager: () => EdgeAgentManager,
+  EdgeAgentServiceImpl: () => EdgeAgentServiceImpl,
+  EdgeFeedReplicator: () => EdgeFeedReplicator,
+  Identity: () => Identity,
+  IdentityManager: () => IdentityManager,
+  IdentityServiceImpl: () => IdentityServiceImpl,
+  InvitationsHandler: () => InvitationsHandler,
+  InvitationsManager: () => InvitationsManager,
+  InvitationsServiceImpl: () => InvitationsServiceImpl,
+  ServiceContext: () => ServiceContext,
+  ServiceRegistry: () => ServiceRegistry,
+  SpaceArchiveWriter: () => SpaceArchiveWriter,
+  SpaceInvitationProtocol: () => SpaceInvitationProtocol,
+  SpacesServiceImpl: () => SpacesServiceImpl,
+  TrustedKeySetAuthVerifier: () => TrustedKeySetAuthVerifier,
+  WorkerRuntime: () => WorkerRuntime,
+  WorkerSession: () => WorkerSession,
+  buildDatabaseDirectoryFromObjects: () => buildDatabaseDirectoryFromObjects,
+  createAdmissionKeypair: () => createAdmissionKeypair,
+  createAuthProvider: () => createAuthProvider,
+  createDiagnostics: () => createDiagnostics,
+  createLevel: () => createLevel,
+  createStorageObjects: () => createStorageObjects,
+  decodeProfileArchive: () => decodeProfileArchive,
+  detectSpaceArchiveFormat: () => detectSpaceArchiveFormat,
+  encodeProfileArchive: () => encodeProfileArchive,
+  exportProfileData: () => exportProfileData,
+  extractSpaceArchive: () => extractSpaceArchive,
+  getNetworkPeers: () => getNetworkPeers,
+  importProfileData: () => importProfileData,
+  objJsonToObjectStructure: () => objJsonToObjectStructure,
+  objectStructureToObjJson: () => objectStructureToObjJson,
+  orderObjJsonFields: () => orderObjJsonFields,
+  readSerializedSpaceArchive: () => readSerializedSpaceArchive,
+  subscribeToFeedBlocks: () => subscribeToFeedBlocks,
+  subscribeToFeeds: () => subscribeToFeeds,
+  subscribeToNetworkStatus: () => subscribeToNetworkStatus,
+  subscribeToNetworkTopics: () => subscribeToNetworkTopics,
+  subscribeToSignal: () => subscribeToSignal,
+  subscribeToSpaces: () => subscribeToSpaces,
+  subscribeToSwarmInfo: () => subscribeToSwarmInfo,
+  writeSerializedSpaceArchive: () => writeSerializedSpaceArchive
+});
+__reExport(index_exports, diagnostics_exports);
+__reExport(index_exports, locks_exports);
+
+// src/packlets/services/client-rpc-server.ts
+import { Stream } from "@dxos/codec-protobuf";
+import { raise } from "@dxos/debug";
+import { RpcPeer, parseMethodName } from "@dxos/rpc";
+import { MapCounter, trace } from "@dxos/tracing";
+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 ClientRpcServer = class {
+  _serviceRegistry;
+  _rpcPeer;
+  _handlerCache = /* @__PURE__ */ new Map();
+  _handleCall;
+  _handleStream;
+  _callMetrics = new MapCounter();
+  get _services() {
+    return Object.keys(this._serviceRegistry.services);
+  }
+  constructor(params) {
+    const { serviceRegistry, handleCall, handleStream, ...rpcOptions } = params;
+    this._handleCall = handleCall;
+    this._handleStream = handleStream;
+    this._serviceRegistry = serviceRegistry;
+    this._rpcPeer = new RpcPeer({
+      ...rpcOptions,
+      callHandler: (method, params2, options) => {
+        const [serviceName, methodName] = parseMethodName(method);
+        const handler = (method2, params3, handlerOptions) => this._getServiceHandler(serviceName).call(method2, params3, handlerOptions);
+        this._callMetrics.inc(`${serviceName}.${methodName} request`);
+        if (this._handleCall) {
+          return this._handleCall(methodName, params2, handler, options);
+        } else {
+          return handler(methodName, params2, options);
+        }
+      },
+      streamHandler: (method, params2, options) => {
+        const [serviceName, methodName] = parseMethodName(method);
+        const handler = (method2, params3, handlerOptions) => this._getServiceHandler(serviceName).callStream(method2, params3, handlerOptions);
+        this._callMetrics.inc(`${serviceName}.${methodName} request stream`);
+        if (this._handleStream) {
+          return Stream.map(Stream.unwrapPromise(this._handleStream(methodName, params2, handler, options)), (data) => {
+            this._callMetrics.inc(`${serviceName}.${methodName} response stream`);
+            return data;
+          });
+        } else {
+          return handler(methodName, params2, options);
+        }
+      }
+    });
+  }
+  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) ?? 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([
+  trace.metricsCounter()
+], ClientRpcServer.prototype, "_callMetrics", void 0);
+_ts_decorate([
+  trace.info()
+], ClientRpcServer.prototype, "_services", null);
+ClientRpcServer = _ts_decorate([
+  trace.resource()
+], ClientRpcServer);
+
+// src/packlets/storage/profile-archive.ts
+import { cbor } from "@automerge/automerge-repo";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { ProfileArchiveEntryType } from "@dxos/protocols";
+import { arrayToBuffer } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/client-services/src/packlets/storage/profile-archive.ts";
+var encodeProfileArchive = (profile) => cbor.encode(profile);
+var decodeProfileArchive = (data) => 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();
+    log.info("begin exporting files", {
+      count: files.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 21, S: void 0 });
+    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: ProfileArchiveEntryType.FILE,
+        key: filename,
+        value: data
+      });
+    }
+    log.info("done exporting files", {
+      count: files.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 34, S: void 0 });
+  }
+  {
+    log.info("begin exporting kv pairs", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 39, S: void 0 });
+    const iter = await level.iterator({
+      keyEncoding: "binary",
+      valueEncoding: "binary"
+    });
+    let count = 0;
+    for await (const [key, value] of iter) {
+      archive.storage.push({
+        type: ProfileArchiveEntryType.KEY_VALUE,
+        key,
+        value
+      });
+      count++;
+    }
+    log.info("done exporting kv pairs", {
+      count
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 53, S: void 0 });
+  }
+  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 ProfileArchiveEntryType.FILE: {
+        const directory = await storage.createDirectory();
+        invariant(typeof entry.key === "string", "Invalid key type", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 67, S: void 0, A: ["typeof entry.key === 'string'", "'Invalid key type'"] });
+        const file = await directory.getOrCreateFile(entry.key);
+        invariant(entry.value instanceof Uint8Array, "Invalid value type", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 69, S: void 0, A: ["entry.value instanceof Uint8Array", "'Invalid value type'"] });
+        await file.write(0, arrayToBuffer(entry.value));
+        await file.close();
+        break;
+      }
+      case ProfileArchiveEntryType.KEY_VALUE: {
+        invariant(entry.key instanceof Uint8Array, "Invalid key type", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 76, S: void 0, A: ["entry.key instanceof Uint8Array", "'Invalid key type'"] });
+        invariant(entry.value instanceof Uint8Array, "Invalid value type", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 77, 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();
+      log.info("importing", {
+        count,
+        total: archive.storage.length,
+        progress: `${(count / archive.storage.length * 100).toFixed()}%`
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 91, S: void 0 });
+    }
+  }
+  log.info("committing changes..", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 98, S: void 0 });
+  await batch.write();
+};
+
+// src/packlets/worker/worker-runtime.ts
+import * as Reactivity from "@effect/experimental/Reactivity";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
 import { Trigger as Trigger2 } from "@dxos/async";
 import { DEFAULT_WORKER_BROADCAST_CHANNEL } from "@dxos/client-protocol";
 import { Context } from "@dxos/context";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { log as log3 } from "@dxos/log";
 import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager, setIdentityTags } from "@dxos/messaging";
 import { RtcTransportProxyFactory } from "@dxos/network-manager";
+import * as OpfsWorker from "@dxos/sql-sqlite/OpfsWorker";
+import * as SqlExport from "@dxos/sql-sqlite/SqlExport";
+import * as SqliteClient from "@dxos/sql-sqlite/SqliteClient";
+import * as SqlTransaction from "@dxos/sql-sqlite/SqlTransaction";
 
-// packages/sdk/client-services/src/packlets/worker/worker-session.ts
-import { asyncTimeout, Trigger } from "@dxos/async";
-import { iframeServiceBundle, PROXY_CONNECTION_TIMEOUT, workerServiceBundle } from "@dxos/client-protocol";
-import { invariant } from "@dxos/invariant";
-import { log, logInfo } from "@dxos/log";
+// src/packlets/worker/worker-session.ts
+import { Trigger, asyncTimeout } from "@dxos/async";
+import { PROXY_CONNECTION_TIMEOUT, iframeServiceBundle, workerServiceBundle } from "@dxos/client-protocol";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log2, logInfo } from "@dxos/log";
 import { createProtoRpcPeer } from "@dxos/rpc";
 import { Callback } from "@dxos/util";
-function _ts_decorate(decorators, target, key, desc) {
+var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-session.ts";
+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_file = "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-session.ts";
 var WorkerSession = class {
+  _clientRpc;
+  _shellClientRpc;
+  _iframeRpc;
+  _startTrigger = new Trigger();
+  _serviceHost;
+  onClose = new Callback();
+  origin;
+  lockKey;
+  bridgeService;
   constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }) {
-    this._startTrigger = new Trigger();
-    this.onClose = new Callback();
-    invariant(serviceHost, void 0, {
-      F: __dxlog_file,
-      L: 54,
-      S: this,
-      A: [
-        "serviceHost",
-        ""
-      ]
-    });
+    invariant2(serviceHost, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 30, S: this, A: ["serviceHost", ""] });
     this._serviceHost = serviceHost;
     const middleware = {
-      handleCall: async (method, params, handler) => {
+      handleCall: async (method, params, handler, options) => {
         const error = await readySignal.wait({
           timeout: PROXY_CONNECTION_TIMEOUT
         });
         if (error) {
           throw error;
         }
-        return handler(method, params);
+        return handler(method, params, options);
       },
-      handleStream: async (method, params, handler) => {
+      handleStream: async (method, params, handler, options) => {
         const error = await readySignal.wait({
           timeout: PROXY_CONNECTION_TIMEOUT
         });
         if (error) {
           throw error;
         }
-        return handler(method, params);
+        return handler(method, params, options);
       }
     };
     this._clientRpc = new ClientRpcServer({
@@ -120,8 +369,6 @@ var WorkerSession = class {
           start: async (request) => {
             this.origin = request.origin;
             this.lockKey = request.lockKey;
-            this.observabilityGroup = request.observabilityGroup;
-            this.signalTelemetryEnabled = request.signalTelemetryEnabled;
             this._startTrigger.wake();
           },
           stop: async () => {
@@ -129,12 +376,7 @@ var WorkerSession = class {
               try {
                 await this.close();
               } catch (err) {
-                log.catch(err, void 0, {
-                  F: __dxlog_file,
-                  L: 108,
-                  S: this,
-                  C: (f, a) => f(...a)
-                });
+                log2.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 77, S: this });
               }
             });
           }
@@ -146,12 +388,7 @@ var WorkerSession = class {
     this.bridgeService = this._iframeRpc.rpc.BridgeService;
   }
   async open() {
-    log.info("opening...", void 0, {
-      F: __dxlog_file,
-      L: 122,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log2("opening...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 89, S: this });
     await Promise.all([
       this._clientRpc.open(),
       this._iframeRpc.open(),
@@ -163,51 +400,26 @@ var WorkerSession = class {
     if (this.lockKey) {
       void this._afterLockReleases(this.lockKey, () => this.close());
     }
-    log.info("opened", void 0, {
-      F: __dxlog_file,
-      L: 133,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log2("opened", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 103, S: this });
   }
   async close() {
-    log.info("closing...", void 0, {
-      F: __dxlog_file,
-      L: 137,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log2.debug("closing...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 106, S: this });
     try {
       await this.onClose.callIfSet();
     } catch (err) {
-      log.catch(err, void 0, {
-        F: __dxlog_file,
-        L: 141,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log2.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 110, S: this });
     }
     await Promise.all([
       this._clientRpc.close(),
       this._iframeRpc.close()
     ]);
-    log.info("closed", void 0, {
-      F: __dxlog_file,
-      L: 145,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log2.debug("closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 116, S: this });
   }
   async _maybeOpenShell() {
     try {
       this._shellClientRpc && await asyncTimeout(this._shellClientRpc.open(), 1e3);
     } catch {
-      log.info("No shell connected.", void 0, {
-        F: __dxlog_file,
-        L: 152,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log2.info("No shell connected.", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 122, S: this });
     }
   }
   _afterLockReleases(lockKey, callback) {
@@ -215,74 +427,101 @@ var WorkerSession = class {
     }).then(callback);
   }
 };
-_ts_decorate([
+_ts_decorate2([
   logInfo
 ], WorkerSession.prototype, "origin", void 0);
-_ts_decorate([
+_ts_decorate2([
   logInfo
 ], WorkerSession.prototype, "lockKey", void 0);
 
-// packages/sdk/client-services/src/packlets/worker/worker-runtime.ts
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-runtime.ts";
+// src/packlets/worker/worker-runtime.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-runtime.ts";
 var WorkerRuntime = class {
-  constructor({ channel = DEFAULT_WORKER_BROADCAST_CHANNEL, configProvider, acquireLock, releaseLock, onStop }) {
-    this._transportFactory = new RtcTransportProxyFactory();
-    this._ready = new Trigger2();
-    this._sessions = /* @__PURE__ */ new Set();
-    this._signalMetadataTags = {
-      runtime: "worker-runtime"
-    };
-    this._signalTelemetryEnabled = false;
+  _configProvider;
+  _acquireLock;
+  _releaseLock;
+  _onStop;
+  _transportFactory = new RtcTransportProxyFactory();
+  _ready = new Trigger2();
+  _sessions = /* @__PURE__ */ new Set();
+  _clientServices;
+  _channel;
+  _automaticallyConnectWebrtc;
+  _livenessLock = new WebLockWrapper(`@dxos/client-services/WorkerRuntime/${crypto.randomUUID()}`);
+  _broadcastChannel;
+  _sessionForNetworking;
+  _config;
+  _signalMetadataTags = {
+    runtime: "worker-runtime"
+  };
+  _signalTelemetryEnabled = false;
+  _runtime;
+  constructor({ channel = DEFAULT_WORKER_BROADCAST_CHANNEL, configProvider, acquireLock, releaseLock, onStop, automaticallyConnectWebrtc = true, sqliteLayer }) {
     this._configProvider = configProvider;
     this._acquireLock = acquireLock;
     this._releaseLock = releaseLock;
     this._onStop = onStop;
     this._channel = channel;
+    if (sqliteLayer) {
+      log3.warn("Using testing SQLite layer", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 52, S: this });
+    }
+    this._runtime = ManagedRuntime.make(SqlTransaction.layer.pipe(Layer.provideMerge(sqliteLayer ?? LocalSqliteOpfsLayer), Layer.provideMerge(Reactivity.layer)).pipe(Layer.orDie));
     this._clientServices = new ClientServicesHost({
       callbacks: {
         onReset: async () => this.stop()
+      },
+      runtime: this._runtime.runtimeEffect,
+      runtimeProps: {
+        // Auto-activate spaces that were previously active after leader changeover.
+        autoActivateSpaces: true
       }
     });
+    this._automaticallyConnectWebrtc = automaticallyConnectWebrtc;
   }
   get host() {
     return this._clientServices;
   }
+  get livenessLockKey() {
+    return this._livenessLock.key;
+  }
   async start() {
-    log2("starting...", void 0, {
-      F: __dxlog_file2,
-      L: 84,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log3("starting...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 74, S: this });
     try {
+      log3("worker-runtime: acquiring liveness lock (background)", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 76, S: this });
+      void this._livenessLock.acquire();
+      log3("worker-runtime: broadcasting stop to displace previous worker", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 79, S: this });
       this._broadcastChannel = new BroadcastChannel(this._channel);
       this._broadcastChannel.postMessage({
         action: "stop"
       });
       this._broadcastChannel.onmessage = async (event) => {
         if (event.data?.action === "stop") {
+          log3("worker-runtime: received stop broadcast", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 86, S: this });
           await this.stop();
         }
       };
+      log3("worker-runtime: acquiring storage lock", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 90, S: this });
       await this._acquireLock();
+      log3("worker-runtime: storage lock acquired, resolving config", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 92, S: this });
       this._config = await this._configProvider();
+      log3("worker-runtime: config resolved", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 94, S: this });
+      this._signalTelemetryEnabled = this._config.get("runtime.client.signalTelemetryEnabled") ?? false;
+      const observabilityGroup = this._config.get("runtime.client.observabilityGroup");
+      if (observabilityGroup) {
+        this._signalMetadataTags.group = observabilityGroup;
+      }
       const signals = this._config.get("runtime.services.signaling");
+      log3("worker-runtime: initializing client services host", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 101, S: this });
       this._clientServices.initialize({
         config: this._config,
         signalManager: this._config.get("runtime.client.edgeFeatures")?.signaling ? void 0 : signals ? new WebsocketSignalManager(signals, () => this._signalTelemetryEnabled ? this._signalMetadataTags : {}) : new MemorySignalManager(new MemorySignalManagerContext()),
         transportFactory: this._transportFactory
       });
-      await this._clientServices.open(new Context(void 0, {
-        F: __dxlog_file2,
-        L: 107
-      }));
+      log3("worker-runtime: client services host initialized, opening", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 107, S: this });
+      await this._clientServices.open(new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 108 }));
+      log3("worker-runtime: client services host opened, signalling ready", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 109, S: this });
       this._ready.wake(void 0);
-      log2("started", void 0, {
-        F: __dxlog_file2,
-        L: 109,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log3("started", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 111, S: this });
       setIdentityTags({
         identityService: this._clientServices.services.IdentityService,
         devicesService: this._clientServices.services.DevicesService,
@@ -292,25 +531,43 @@ var WorkerRuntime = class {
       });
     } catch (err) {
       this._ready.wake(err);
-      log2.error("starting", err, {
-        F: __dxlog_file2,
-        L: 119,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log3.error("starting", err, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 121, S: this });
     }
   }
   async stop() {
     this._releaseLock();
     this._broadcastChannel?.close();
     this._broadcastChannel = void 0;
-    await this._clientServices.close();
+    await this._clientServices.close(Context.default(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 129 }));
+    await this._runtime.dispose();
     await this._onStop?.();
+    await this._livenessLock.release();
+  }
+  /**
+  * Update signaling telemetry tags from a client-supplied config overlay.
+  *
+  * The worker services outlive individual client connections, so the first client seeds the
+  * worker's core config (storage, signaling, edge features). For fields that can legitimately
+  * differ per tab — `observabilityGroup` and `signalTelemetryEnabled` — this method lets later
+  * connections refresh the signal metadata the worker attaches to its signaling requests
+  * (last-writer-wins, matching the pre-DX-930 per-session RPC behaviour).
+  */
+  updateSignalMetadata(config) {
+    const observabilityGroup = config.get("runtime.client.observabilityGroup");
+    if (observabilityGroup) {
+      this._signalMetadataTags.group = observabilityGroup;
+    } else {
+      delete this._signalMetadataTags.group;
+    }
+    const signalTelemetryEnabled = config.get("runtime.client.signalTelemetryEnabled");
+    if (signalTelemetryEnabled !== void 0) {
+      this._signalTelemetryEnabled = signalTelemetryEnabled;
+    }
   }
   /**
   * Create a new session.
   */
-  async createSession({ appPort, systemPort, shellPort }) {
+  async createSession({ appPort, systemPort, shellPort, onClose }) {
     const session = new WorkerSession({
       serviceHost: this._clientServices,
       appPort,
@@ -323,37 +580,38 @@ var WorkerRuntime = class {
       if (this._sessions.size === 0) {
         await this.stop();
       } else {
-        this._reconnectWebrtc();
+        if (this._automaticallyConnectWebrtc) {
+          this._reconnectWebrtc();
+        }
       }
+      await onClose?.();
     });
     await session.open();
-    invariant2(!this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin, `worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`, {
-      F: __dxlog_file2,
-      L: 157,
-      S: this,
-      A: [
-        "!this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin",
-        "`worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`"
-      ]
-    });
-    if (session.observabilityGroup) {
-      this._signalMetadataTags.group = session.observabilityGroup;
-    }
-    this._signalTelemetryEnabled = session.signalTelemetryEnabled ?? false;
+    invariant3(!this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin, `worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 181, S: this, A: ["!this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin", "`worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`"] });
     this._signalMetadataTags.origin = session.origin;
     this._sessions.add(session);
-    this._reconnectWebrtc();
+    if (this._automaticallyConnectWebrtc) {
+      this._reconnectWebrtc();
+    }
+    return session;
+  }
+  /**
+  * Connects the WebRTC bridge to the specified session.
+  * If no session is provided, disconnects the WebRTC bridge.
+  *
+  * Called automatically if `automaticallyConnectWebrtc` is true.
+  *
+  * @param session The session to connect the WebRTC bridge to.
+  */
+  connectWebrtcBridge(session) {
+    this._sessionForNetworking = session;
+    this._transportFactory.setBridgeService(session?.bridgeService);
   }
   /**
   * Selects one of the existing session for WebRTC networking.
   */
   _reconnectWebrtc() {
-    log2("reconnecting webrtc...", void 0, {
-      F: __dxlog_file2,
-      L: 175,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log3("reconnecting webrtc...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 203, S: this });
     if (this._sessionForNetworking) {
       if (!this._sessions.has(this._sessionForNetworking)) {
         this._sessionForNetworking = void 0;
@@ -361,15 +619,58 @@ var WorkerRuntime = class {
     }
     if (!this._sessionForNetworking) {
       const selected = Array.from(this._sessions).find((session) => session.bridgeService);
-      if (selected) {
-        this._sessionForNetworking = selected;
-        this._transportFactory.setBridgeService(selected.bridgeService);
-      } else {
-        this._transportFactory.setBridgeService(void 0);
-      }
+      this.connectWebrtcBridge(selected);
     }
   }
 };
+var DB_NAME = "DXOS";
+var SqlExportLayer = Layer.effect(SqlExport.SqlExport, Effect.gen(function* () {
+  const sql = yield* SqliteClient.SqliteClient;
+  return {
+    export: sql.export
+  };
+}));
+var LocalSqliteOpfsLayer = Layer.unwrapScoped(Effect.gen(function* () {
+  const { port1: clientPort, port2: serverPort } = new MessageChannel();
+  clientPort.start();
+  serverPort.start();
+  yield* Effect.addFinalizer(() => Effect.sync(() => {
+    clientPort.close();
+    serverPort.close();
+  }));
+  yield* Effect.forkScoped(OpfsWorker.run({
+    port: serverPort,
+    dbName: DB_NAME
+  }));
+  return SqlExportLayer.pipe(Layer.provideMerge(SqliteClient.layer({
+    worker: Effect.succeed(clientPort)
+  })));
+}));
+var WebLockWrapper = class {
+  #key;
+  #release;
+  constructor(key) {
+    this.#key = key;
+  }
+  get key() {
+    return this.#key;
+  }
+  acquire(options = {}) {
+    return navigator.locks.request(this.#key, options, async () => {
+      await new Promise((resolve) => {
+        this.#release = resolve;
+      });
+      this.#release = void 0;
+    });
+  }
+  release() {
+    this.#release?.();
+    this.#release = void 0;
+  }
+  [Symbol.dispose]() {
+    this.release();
+  }
+};
 export {
   ClientRpcServer,
   ClientServicesHost,
@@ -388,33 +689,38 @@ export {
   InvitationsHandler,
   InvitationsManager,
   InvitationsServiceImpl,
-  Lock,
   ServiceContext,
   ServiceRegistry,
+  SpaceArchiveWriter,
   SpaceInvitationProtocol,
   SpacesServiceImpl,
   TrustedKeySetAuthVerifier,
   WorkerRuntime,
   WorkerSession,
+  buildDatabaseDirectoryFromObjects,
   createAdmissionKeypair,
   createAuthProvider,
-  createCollectDiagnosticsBroadcastHandler,
-  createCollectDiagnosticsBroadcastSender,
   createDiagnostics,
   createLevel,
   createStorageObjects,
   decodeProfileArchive,
+  detectSpaceArchiveFormat,
   encodeProfileArchive,
   exportProfileData,
+  extractSpaceArchive,
   getNetworkPeers,
   importProfileData,
-  isLocked,
+  objJsonToObjectStructure,
+  objectStructureToObjJson,
+  orderObjJsonFields,
+  readSerializedSpaceArchive,
   subscribeToFeedBlocks,
   subscribeToFeeds,
   subscribeToNetworkStatus,
   subscribeToNetworkTopics,
   subscribeToSignal,
   subscribeToSpaces,
-  subscribeToSwarmInfo
+  subscribeToSwarmInfo,
+  writeSerializedSpaceArchive
 };
 //# sourceMappingURL=index.mjs.map