@dxos/client-services 0.8.3 → 0.8.4-main.1068cf700f

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

@@ -1,6 +1,5 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  ClientRpcServer,
   ClientServicesHost,
   DataSpace,
   DataSpaceManager,
@@ -17,7 +16,6 @@ import {
   InvitationsHandler,
   InvitationsManager,
   InvitationsServiceImpl,
-  Lock,
   ServiceContext,
   ServiceRegistry,
   SpaceInvitationProtocol,
@@ -25,17 +23,12 @@ import {
   TrustedKeySetAuthVerifier,
   createAdmissionKeypair,
   createAuthProvider,
-  createCollectDiagnosticsBroadcastHandler,
-  createCollectDiagnosticsBroadcastSender,
   createDiagnostics,
   createLevel,
   createStorageObjects,
-  decodeProfileArchive,
-  encodeProfileArchive,
-  exportProfileData,
+  diagnostics_exports,
   getNetworkPeers,
-  importProfileData,
-  isLocked,
+  locks_exports,
   subscribeToFeedBlocks,
   subscribeToFeeds,
   subscribeToNetworkStatus,
@@ -43,37 +36,348 @@ import {
   subscribeToSignal,
   subscribeToSpaces,
   subscribeToSwarmInfo
-} from "./chunk-SKGQLRKS.mjs";
+} from "./chunk-RXHISBCS.mjs";
+import "./chunk-PKEGMOQ4.mjs";
+import {
+  __export,
+  __reExport
+} from "./chunk-2SZHAWBN.mjs";
+
+// 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,
+  SpaceInvitationProtocol: () => SpaceInvitationProtocol,
+  SpacesServiceImpl: () => SpacesServiceImpl,
+  TrustedKeySetAuthVerifier: () => TrustedKeySetAuthVerifier,
+  WorkerRuntime: () => WorkerRuntime,
+  WorkerSession: () => WorkerSession,
+  createAdmissionKeypair: () => createAdmissionKeypair,
+  createAuthProvider: () => createAuthProvider,
+  createDiagnostics: () => createDiagnostics,
+  createLevel: () => createLevel,
+  createStorageObjects: () => createStorageObjects,
+  decodeProfileArchive: () => decodeProfileArchive,
+  encodeProfileArchive: () => encodeProfileArchive,
+  exportProfileData: () => exportProfileData,
+  getNetworkPeers: () => getNetworkPeers,
+  importProfileData: () => importProfileData,
+  subscribeToFeedBlocks: () => subscribeToFeedBlocks,
+  subscribeToFeeds: () => subscribeToFeeds,
+  subscribeToNetworkStatus: () => subscribeToNetworkStatus,
+  subscribeToNetworkTopics: () => subscribeToNetworkTopics,
+  subscribeToSignal: () => subscribeToSignal,
+  subscribeToSpaces: () => subscribeToSpaces,
+  subscribeToSwarmInfo: () => subscribeToSwarmInfo
+});
+__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) => {
+        const [serviceName, methodName] = 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] = parseMethodName(method);
+        const handler = (method2, params3) => this._getServiceHandler(serviceName).callStream(method2, params3);
+        this._callMetrics.inc(`${serviceName}.${methodName} request stream`);
+        if (this._handleStream) {
+          return Stream.map(Stream.unwrapPromise(this._handleStream(methodName, params2, handler)), (data) => {
+            this._callMetrics.inc(`${serviceName}.${methodName} response stream`);
+            return data;
+          });
+        } else {
+          return handler(methodName, params2);
+        }
+      }
+    });
+  }
+  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
+    }, {
+      F: __dxlog_file,
+      L: 31,
+      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: ProfileArchiveEntryType.FILE,
+        key: filename,
+        value: data
+      });
+    }
+    log.info("done exporting files", {
+      count: files.length
+    }, {
+      F: __dxlog_file,
+      L: 42,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+  {
+    log.info("begin exporting kv pairs", void 0, {
+      F: __dxlog_file,
+      L: 46,
+      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: ProfileArchiveEntryType.KEY_VALUE,
+        key,
+        value
+      });
+      count++;
+    }
+    log.info("done exporting kv pairs", {
+      count
+    }, {
+      F: __dxlog_file,
+      L: 57,
+      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 ProfileArchiveEntryType.FILE: {
+        const directory = await storage.createDirectory();
+        invariant(typeof entry.key === "string", "Invalid key type", {
+          F: __dxlog_file,
+          L: 80,
+          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", {
+          F: __dxlog_file,
+          L: 82,
+          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", {
+          F: __dxlog_file,
+          L: 88,
+          S: void 0,
+          A: [
+            "entry.key instanceof Uint8Array",
+            "'Invalid key type'"
+          ]
+        });
+        invariant(entry.value instanceof Uint8Array, "Invalid value type", {
+          F: __dxlog_file,
+          L: 89,
+          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()}%`
+      }, {
+        F: __dxlog_file,
+        L: 102,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  log.info("committing changes..", void 0, {
+    F: __dxlog_file,
+    L: 110,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  await batch.write();
+};
 
-// packages/sdk/client-services/src/packlets/worker/worker-runtime.ts
+// 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) {
+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 __dxlog_file2 = "/__w/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;
+  // TODO(nf): factor out?
+  observabilityGroup;
+  signalTelemetryEnabled;
+  lockKey;
+  bridgeService;
   constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }) {
-    this._startTrigger = new Trigger();
-    this.onClose = new Callback();
-    invariant(serviceHost, void 0, {
-      F: __dxlog_file,
+    invariant2(serviceHost, void 0, {
+      F: __dxlog_file2,
       L: 54,
       S: this,
       A: [
@@ -129,8 +433,8 @@ var WorkerSession = class {
               try {
                 await this.close();
               } catch (err) {
-                log.catch(err, void 0, {
-                  F: __dxlog_file,
+                log2.catch(err, void 0, {
+                  F: __dxlog_file2,
                   L: 108,
                   S: this,
                   C: (f, a) => f(...a)
@@ -146,8 +450,8 @@ var WorkerSession = class {
     this.bridgeService = this._iframeRpc.rpc.BridgeService;
   }
   async open() {
-    log.info("opening...", void 0, {
-      F: __dxlog_file,
+    log2.info("opening...", void 0, {
+      F: __dxlog_file2,
       L: 122,
       S: this,
       C: (f, a) => f(...a)
@@ -163,16 +467,16 @@ var WorkerSession = class {
     if (this.lockKey) {
       void this._afterLockReleases(this.lockKey, () => this.close());
     }
-    log.info("opened", void 0, {
-      F: __dxlog_file,
+    log2.info("opened", void 0, {
+      F: __dxlog_file2,
       L: 133,
       S: this,
       C: (f, a) => f(...a)
     });
   }
   async close() {
-    log.info("closing...", void 0, {
-      F: __dxlog_file,
+    log2.info("closing...", void 0, {
+      F: __dxlog_file2,
       L: 137,
       S: this,
       C: (f, a) => f(...a)
@@ -180,8 +484,8 @@ var WorkerSession = class {
     try {
       await this.onClose.callIfSet();
     } catch (err) {
-      log.catch(err, void 0, {
-        F: __dxlog_file,
+      log2.catch(err, void 0, {
+        F: __dxlog_file2,
         L: 141,
         S: this,
         C: (f, a) => f(...a)
@@ -191,8 +495,8 @@ var WorkerSession = class {
       this._clientRpc.close(),
       this._iframeRpc.close()
     ]);
-    log.info("closed", void 0, {
-      F: __dxlog_file,
+    log2.info("closed", void 0, {
+      F: __dxlog_file2,
       L: 145,
       S: this,
       C: (f, a) => f(...a)
@@ -202,8 +506,8 @@ var WorkerSession = class {
     try {
       this._shellClientRpc && await asyncTimeout(this._shellClientRpc.open(), 1e3);
     } catch {
-      log.info("No shell connected.", void 0, {
-        F: __dxlog_file,
+      log2.info("No shell connected.", void 0, {
+        F: __dxlog_file2,
         L: 152,
         S: this,
         C: (f, a) => f(...a)
@@ -215,46 +519,77 @@ 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, {
+        F: __dxlog_file3,
+        L: 103,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+    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,
+    log3("starting...", void 0, {
+      F: __dxlog_file3,
+      L: 132,
       S: this,
       C: (f, a) => f(...a)
     });
     try {
+      void this._livenessLock.acquire();
       this._broadcastChannel = new BroadcastChannel(this._channel);
       this._broadcastChannel.postMessage({
         action: "stop"
@@ -273,13 +608,13 @@ var WorkerRuntime = class {
         transportFactory: this._transportFactory
       });
       await this._clientServices.open(new Context(void 0, {
-        F: __dxlog_file2,
-        L: 107
+        F: __dxlog_file3,
+        L: 158
       }));
       this._ready.wake(void 0);
-      log2("started", void 0, {
-        F: __dxlog_file2,
-        L: 109,
+      log3("started", void 0, {
+        F: __dxlog_file3,
+        L: 160,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -292,9 +627,9 @@ var WorkerRuntime = class {
       });
     } catch (err) {
       this._ready.wake(err);
-      log2.error("starting", err, {
-        F: __dxlog_file2,
-        L: 119,
+      log3.error("starting", err, {
+        F: __dxlog_file3,
+        L: 170,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -305,12 +640,14 @@ var WorkerRuntime = class {
     this._broadcastChannel?.close();
     this._broadcastChannel = void 0;
     await this._clientServices.close();
+    await this._runtime.dispose();
     await this._onStop?.();
+    await this._livenessLock.release();
   }
   /**
   * Create a new session.
   */
-  async createSession({ appPort, systemPort, shellPort }) {
+  async createSession({ appPort, systemPort, shellPort, onClose }) {
     const session = new WorkerSession({
       serviceHost: this._clientServices,
       appPort,
@@ -323,13 +660,16 @@ 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,
+    invariant3(!this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin, `worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`, {
+      F: __dxlog_file3,
+      L: 213,
       S: this,
       A: [
         "!this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin",
@@ -342,15 +682,30 @@ var WorkerRuntime = class {
     this._signalTelemetryEnabled = session.signalTelemetryEnabled ?? false;
     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,
+    log3("reconnecting webrtc...", void 0, {
+      F: __dxlog_file3,
+      L: 248,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -361,15 +716,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,7 +786,6 @@ export {
   InvitationsHandler,
   InvitationsManager,
   InvitationsServiceImpl,
-  Lock,
   ServiceContext,
   ServiceRegistry,
   SpaceInvitationProtocol,
@@ -398,8 +795,6 @@ export {
   WorkerSession,
   createAdmissionKeypair,
   createAuthProvider,
-  createCollectDiagnosticsBroadcastHandler,
-  createCollectDiagnosticsBroadcastSender,
   createDiagnostics,
   createLevel,
   createStorageObjects,
@@ -408,7 +803,6 @@ export {
   exportProfileData,
   getNetworkPeers,
   importProfileData,
-  isLocked,
   subscribeToFeedBlocks,
   subscribeToFeeds,
   subscribeToNetworkStatus,