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

package/src/packlets/spaces/spaces-service.ts

@@ -19,44 +19,45 @@ import { assertArgument, assertState, invariant } from '@dxos/invariant';
 import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
-  encodeError,
   ApiError,
   AuthorizationError,
   IdentityNotInitializedError,
   SpaceNotFoundError,
+  encodeError,
 } from '@dxos/protocols';
 import {
-  SpaceMember,
-  SpaceState,
+  type AdmitContactRequest,
+  type ContactAdmission,
   type CreateEpochRequest,
+  type CreateEpochResponse,
+  type ExportSpaceRequest,
+  type ExportSpaceResponse,
+  type ImportSpaceRequest,
+  type ImportSpaceResponse,
+  type JoinBySpaceKeyRequest,
+  type JoinSpaceResponse,
   type PostMessageRequest,
   type QueryCredentialsRequest,
   type QuerySpacesResponse,
   type Space,
+  SpaceMember,
+  SpaceState,
   type SpacesService,
   type SubscribeMessagesRequest,
+  type UpdateMemberRoleRequest,
   type UpdateSpaceRequest,
   type WriteCredentialsRequest,
-  type UpdateMemberRoleRequest,
-  type AdmitContactRequest,
-  type ContactAdmission,
-  type JoinSpaceResponse,
-  type JoinBySpaceKeyRequest,
-  type CreateEpochResponse,
-  type ExportSpaceResponse,
-  type ExportSpaceRequest,
-  type ImportSpaceRequest,
-  type ImportSpaceResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
 import { trace } from '@dxos/tracing';
 import { type Provider } from '@dxos/util';
 
+import { type IdentityManager } from '../identity';
+import { SpaceArchiveWriter, extractSpaceArchive } from '../space-export';
+
 import { type DataSpace } from './data-space';
 import { type DataSpaceManager } from './data-space-manager';
-import { type IdentityManager } from '../identity';
-import { extractSpaceArchive, SpaceArchiveWriter } from '../space-export';
 
 export class SpacesServiceImpl implements SpacesService {
   constructor(
@@ -87,7 +88,7 @@ export class SpacesServiceImpl implements SpacesService {
           await space.deactivate();
           break;
         default:
-          throw new ApiError('Invalid space state');
+          throw new ApiError({ message: 'Invalid space state' });
       }
     }
 
@@ -103,9 +104,12 @@ export class SpacesServiceImpl implements SpacesService {
       throw new SpaceNotFoundError(request.spaceKey);
     }
     if (!space.spaceState.hasMembershipManagementPermission(identity.identityKey)) {
-      throw new AuthorizationError('No member management permission.', {
-        spaceKey: space.key,
-        role: space.spaceState.getMemberRole(identity.identityKey),
+      throw new AuthorizationError({
+        message: 'No member management permission.',
+        context: {
+          spaceKey: space.key,
+          role: space.spaceState.getMemberRole(identity.identityKey),
+        },
       });
     }
     const credentials = await createAdmissionCredentials(
@@ -266,7 +270,7 @@ export class SpacesServiceImpl implements SpacesService {
 
   async exportSpace(request: ExportSpaceRequest): Promise<ExportSpaceResponse> {
     await using writer = await new SpaceArchiveWriter().open();
-    assertArgument(SpaceId.isValid(request.spaceId), 'Invalid space ID');
+    assertArgument(SpaceId.isValid(request.spaceId), 'spaceId', 'Invalid space ID');
 
     const dataSpaceManager = await this._getDataSpaceManager();
     const space = dataSpaceManager.getSpaceById(request.spaceId) ?? raise(new Error('Space not found'));
@@ -367,9 +371,9 @@ export class SpacesServiceImpl implements SpacesService {
 
   private _requireIdentity() {
     if (!this._identityManager.identity) {
-      throw new IdentityNotInitializedError(
-        'This device has no HALO identity available. See https://docs.dxos.org/guide/platform/halo',
-      );
+      throw new IdentityNotInitializedError({
+        message: 'This device has no HALO identity available. See https://docs.dxos.org/guide/platform/halo',
+      });
     }
     return this._identityManager.identity;
   }

package/src/packlets/storage/profile-archive.ts

@@ -7,7 +7,7 @@ import { cbor } from '@automerge/automerge-repo';
 import { invariant } from '@dxos/invariant';
 import type { LevelDB } from '@dxos/kv-store';
 import { log } from '@dxos/log';
-import { ProfileArchiveEntryType, type ProfileArchive } from '@dxos/protocols';
+import { type ProfileArchive, ProfileArchiveEntryType } from '@dxos/protocols';
 import type { Storage } from '@dxos/random-access-storage';
 import { arrayToBuffer } from '@dxos/util';
 

package/src/packlets/storage/storage.ts

@@ -1,30 +1,29 @@
-//
-
 //
 // Copyright 2023 DXOS.org
 //
 
 import { InvalidConfigError } from '@dxos/protocols';
 import { Runtime } from '@dxos/protocols/proto/dxos/config';
-import { createStorage, StorageType } from '@dxos/random-access-storage';
+import { StorageType, createStorage } from '@dxos/random-access-storage';
 
-import StorageDriver = Runtime.Client.Storage.StorageDriver;
 import { getRootPath } from './util';
 
+import StorageDriver = Runtime.Client.Storage.StorageDriver;
+
 // TODO(burdon): Factor out.
 export const createStorageObjects = (config: Runtime.Client.Storage) => {
   const { persistent = false, keyStore, dataStore } = config ?? {};
   if (persistent && dataStore === StorageDriver.RAM) {
-    throw new InvalidConfigError('RAM storage cannot be used in persistent mode.');
+    throw new InvalidConfigError({ message: 'RAM storage cannot be used in persistent mode.' });
   }
   if (!persistent && dataStore !== undefined && dataStore !== StorageDriver.RAM) {
-    throw new InvalidConfigError('Cannot use a persistent storage in not persistent mode.');
+    throw new InvalidConfigError({ message: 'Cannot use a persistent storage in not persistent mode.' });
   }
   if (persistent && keyStore === StorageDriver.RAM) {
-    throw new InvalidConfigError('RAM key storage cannot be used in persistent mode.');
+    throw new InvalidConfigError({ message: 'RAM key storage cannot be used in persistent mode.' });
   }
   if (!persistent && keyStore !== StorageDriver.RAM && keyStore !== undefined) {
-    throw new InvalidConfigError('Cannot use a persistent key storage in not persistent mode.');
+    throw new InvalidConfigError({ message: 'Cannot use a persistent key storage in not persistent mode.' });
   }
 
   return {

package/src/packlets/system/system-service.test.ts

@@ -6,7 +6,7 @@ import { beforeEach, describe, expect, test } from 'vitest';
 
 import { Event, Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
-import { type SystemService, SystemStatus, type QueryStatusResponse } from '@dxos/protocols/proto/dxos/client/services';
+import { type QueryStatusResponse, type SystemService, SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 
 import { SystemServiceImpl } from './system-service';
 

package/src/packlets/system/system-service.ts

@@ -7,14 +7,14 @@ import { Stream } from '@dxos/codec-protobuf/stream';
 import { type Config } from '@dxos/config';
 import {
   GetDiagnosticsRequest,
+  type Platform,
+  type QueryStatusRequest,
+  type QueryStatusResponse,
   type SystemService,
   type SystemStatus,
   type UpdateStatusRequest,
-  type QueryStatusRequest,
-  type QueryStatusResponse,
-  type Platform,
 } from '@dxos/protocols/proto/dxos/client/services';
-import { jsonKeyReplacer, type MaybePromise } from '@dxos/util';
+import { type MaybePromise, jsonKeyReplacer } from '@dxos/util';
 
 import { type Diagnostics } from '../diagnostics';
 import { getPlatform } from '../services/platform';

package/src/packlets/testing/invitation-utils.ts

@@ -3,7 +3,7 @@
 //
 
 import { Trigger } from '@dxos/async';
-import { InvitationEncoder, type AuthenticatingInvitation, type CancellableInvitation } from '@dxos/client-protocol';
+import { type AuthenticatingInvitation, type CancellableInvitation, InvitationEncoder } from '@dxos/client-protocol';
 import { invariant } from '@dxos/invariant';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
@@ -36,15 +36,15 @@ export type PerformInvitationCallbacks<T> = {
   onError?: (value: T) => boolean | void;
 };
 
-export type PerformInvitationParams = {
+export type PerformInvitationProps = {
   host: ServiceContext | InvitationHost;
   guest: ServiceContext | InvitationGuest;
+  guestDeviceProfile?: DeviceProfileDocument;
   options?: Partial<Invitation>;
   hooks?: {
     host?: PerformInvitationCallbacks<CancellableInvitation>;
     guest?: PerformInvitationCallbacks<AuthenticatingInvitation>;
   };
-  guestDeviceProfile?: DeviceProfileDocument;
   codeInputDelay?: number;
 };
 
@@ -52,14 +52,17 @@ export type Result = { invitation?: Invitation; error?: Error };
 
 // TODO(burdon): Make async.
 // TODO(burdon): Rename startInvitation.
+/**
+ *
+ */
 export const performInvitation = ({
   host,
   guest,
+  guestDeviceProfile,
   options,
   hooks,
-  guestDeviceProfile,
   codeInputDelay,
-}: PerformInvitationParams): [Promise<Result>, Promise<Result>] => {
+}: PerformInvitationProps): [Promise<Result>, Promise<Result>] => {
   let guestError = false;
   let guestConnected = false;
   let wereConnected = false;

package/src/packlets/testing/test-builder.ts

@@ -2,11 +2,15 @@
 // Copyright 2022 DXOS.org
 //
 
+import * as Reactivity from '@effect/experimental/Reactivity';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+
 import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
-import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
+import { CredentialGenerator, createCredentialSignerWithChain } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
-import { EchoHost, MetadataStore, SpaceManager, valueEncoding, MeshEchoReplicator } from '@dxos/echo-pipeline';
+import { EchoHost, MeshEchoReplicator, MetadataStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { type LevelDB } from '@dxos/kv-store';
@@ -14,12 +18,14 @@ import { createTestLevel } from '@dxos/kv-store/testing';
 import { MemorySignalManager, MemorySignalManagerContext, type SignalManager } from '@dxos/messaging';
 import { MemoryTransportFactory, SwarmNetworkManager } from '@dxos/network-manager';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { createStorage, StorageType, type Storage } from '@dxos/random-access-storage';
+import { type Storage, StorageType, createStorage } from '@dxos/random-access-storage';
+import { layerMemory as sqliteLayerMemory } from '@dxos/sql-sqlite/platform';
+import * as SqlTransaction from '@dxos/sql-sqlite/SqlTransaction';
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
 
 import { InvitationsHandler, InvitationsManager, SpaceInvitationProtocol } from '../invitations';
-import { ClientServicesHost, ServiceContext, type ServiceContextRuntimeParams } from '../services';
-import { DataSpaceManager, type DataSpaceManagerRuntimeParams, type SigningContext } from '../spaces';
+import { ClientServicesHost, ServiceContext, type ServiceContextRuntimeProps } from '../services';
+import { DataSpaceManager, type DataSpaceManagerRuntimeProps, type SigningContext } from '../spaces';
 
 //
 // TODO(burdon): Replace with test builder.
@@ -30,6 +36,11 @@ export const createServiceHost = (config: Config, signalManagerContext: MemorySi
     config,
     signalManager: new MemorySignalManager(signalManagerContext),
     transportFactory: MemoryTransportFactory,
+    runtime: ManagedRuntime.make(
+      SqlTransaction.layer
+        .pipe(Layer.provideMerge(sqliteLayerMemory), Layer.provideMerge(Reactivity.layer))
+        .pipe(Layer.orDie),
+    ).runtimeEffect,
   });
 };
 
@@ -39,11 +50,11 @@ export const createServiceContext = async ({
     return new MemorySignalManager(signalContext);
   },
   storage = createStorage({ type: StorageType.RAM }),
-  runtimeParams,
+  runtimeProps,
 }: {
   signalManagerFactory?: () => Promise<SignalManager>;
   storage?: Storage;
-  runtimeParams?: ServiceContextRuntimeParams;
+  runtimeProps?: ServiceContextRuntimeProps;
 } = {}) => {
   const signalManager = await signalManagerFactory();
   const networkManager = new SwarmNetworkManager({
@@ -53,9 +64,15 @@ export const createServiceContext = async ({
   const level = createTestLevel();
   await level.open();
 
-  return new ServiceContext(storage, level, networkManager, signalManager, undefined, undefined, {
-    invitationConnectionDefaultParams: { teleport: { controlHeartbeatInterval: 200 } },
-    ...runtimeParams,
+  const runtime = ManagedRuntime.make(
+    SqlTransaction.layer
+      .pipe(Layer.provideMerge(sqliteLayerMemory), Layer.provideMerge(Reactivity.layer))
+      .pipe(Layer.orDie),
+  ).runtimeEffect;
+
+  return new ServiceContext(storage, level, networkManager, signalManager, undefined, undefined, runtime, {
+    invitationConnectionDefaultProps: { teleport: { controlHeartbeatInterval: 200 } },
+    ...runtimeProps,
   });
 };
 
@@ -95,7 +112,7 @@ export class TestBuilder {
 
 export type TestPeerOpts = {
   dataStore?: StorageType;
-  dataSpaceParams?: DataSpaceManagerRuntimeParams;
+  dataSpaceProps?: DataSpaceManagerRuntimeProps;
 };
 
 export type TestPeerProps = {
@@ -116,6 +133,11 @@ export type TestPeerProps = {
 
 export class TestPeer {
   private _props: TestPeerProps = {};
+  private readonly _runtime = ManagedRuntime.make(
+    SqlTransaction.layer
+      .pipe(Layer.provideMerge(sqliteLayerMemory), Layer.provideMerge(Reactivity.layer))
+      .pipe(Layer.orDie),
+  );
 
   constructor(
     private readonly _signalContext: MemorySignalManagerContext,
@@ -179,7 +201,10 @@ export class TestPeer {
   }
 
   get echoHost() {
-    return (this._props.echoHost ??= new EchoHost({ kv: this.level }));
+    return (this._props.echoHost ??= new EchoHost({
+      kv: this.level,
+      runtime: this._runtime.runtimeEffect,
+    }));
   }
 
   get meshEchoReplicator() {
@@ -198,7 +223,7 @@ export class TestPeer {
       edgeConnection: undefined,
       meshReplicator: this.meshEchoReplicator,
       echoEdgeReplicator: undefined,
-      runtimeParams: this._opts.dataSpaceParams,
+      runtimeProps: this._opts.dataSpaceProps,
     }));
   }
 
@@ -227,6 +252,7 @@ export class TestPeer {
   async destroy(): Promise<void> {
     await this.level.close();
     await this.storage.reset();
+    await this._runtime.dispose();
   }
 }
 

package/src/packlets/worker/worker-runtime.ts

@@ -2,6 +2,12 @@
 // Copyright 2022 DXOS.org
 //
 
+import * as Reactivity from '@effect/experimental/Reactivity';
+import type * as SqlClient from '@effect/sql/SqlClient';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+
 import { Trigger } from '@dxos/async';
 import { DEFAULT_WORKER_BROADCAST_CHANNEL } from '@dxos/client-protocol';
 import { type Config } from '@dxos/config';
@@ -16,16 +22,22 @@ import {
 } from '@dxos/messaging';
 import { RtcTransportProxyFactory } from '@dxos/network-manager';
 import { type RpcPort } from '@dxos/rpc';
+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';
 import { type MaybePromise } from '@dxos/util';
 
-import { WorkerSession } from './worker-session';
 import { ClientServicesHost } from '../services';
 
+import { WorkerSession } from './worker-session';
+
 // NOTE: Keep as RpcPorts to avoid dependency on @dxos/rpc-tunnel so we don't depend on browser-specific apis.
-export type CreateSessionParams = {
+export type CreateSessionProps = {
   appPort: RpcPort;
   systemPort: RpcPort;
   shellPort?: RpcPort;
+  onClose?: () => Promise<void>;
 };
 
 export type WorkerRuntimeOptions = {
@@ -34,10 +46,20 @@ export type WorkerRuntimeOptions = {
   acquireLock: () => Promise<void>;
   releaseLock: () => void;
   onStop?: () => Promise<void>;
+  /**
+   * @default true
+   */
+  automaticallyConnectWebrtc?: boolean;
+
+  /**
+   * Optional SQLite layer for Effect. Defaults to LocalSqliteOpfsLayer.
+   * For testing in Node.js, use `sqliteLayerMemory` from `@dxos/sql-sqlite/platform`.
+   */
+  sqliteLayer?: Layer.Layer<SqlClient.SqlClient | SqlExport.SqlExport, unknown>;
 };
 
 /**
- * Runtime for the shared worker.
+ * Runtime for the shared and dedciated worker.
  * Manages connections from proxies (in tabs).
  * Tabs make requests to the `ClientServicesHost`, and provide a WebRTC gateway.
  */
@@ -51,11 +73,17 @@ export class WorkerRuntime {
   private readonly _sessions = new Set<WorkerSession>();
   private readonly _clientServices!: ClientServicesHost;
   private readonly _channel: string;
+  private readonly _automaticallyConnectWebrtc: boolean;
+  private readonly _livenessLock = new WebLockWrapper(`@dxos/client-services/WorkerRuntime/${crypto.randomUUID()}`);
   private _broadcastChannel?: BroadcastChannel;
   private _sessionForNetworking?: WorkerSession; // TODO(burdon): Expose to client QueryStatusResponse.
   private _config!: Config;
   private _signalMetadataTags: any = { runtime: 'worker-runtime' };
   private _signalTelemetryEnabled: boolean = false;
+  private _runtime!: ManagedRuntime.ManagedRuntime<
+    SqlTransaction.SqlTransaction | SqlClient.SqlClient | SqlExport.SqlExport,
+    never
+  >;
 
   constructor({
     channel = DEFAULT_WORKER_BROADCAST_CHANNEL,
@@ -63,26 +91,49 @@ export class WorkerRuntime {
     acquireLock,
     releaseLock,
     onStop,
+    automaticallyConnectWebrtc = true,
+    sqliteLayer,
   }: WorkerRuntimeOptions) {
     this._configProvider = configProvider;
     this._acquireLock = acquireLock;
     this._releaseLock = releaseLock;
     this._onStop = onStop;
     this._channel = channel;
+    if (sqliteLayer) {
+      log.warn('Using testing SQLite layer');
+    }
+    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(): string {
+    return this._livenessLock.key;
+  }
+
   async start(): Promise<void> {
     log('starting...');
     try {
+      void this._livenessLock.acquire();
+
+      // Steal the lock from the other worker.
       this._broadcastChannel = new BroadcastChannel(this._channel);
       this._broadcastChannel.postMessage({ action: 'stop' });
       this._broadcastChannel.onmessage = async (event) => {
@@ -126,13 +177,15 @@ export class WorkerRuntime {
     this._broadcastChannel?.close();
     this._broadcastChannel = undefined;
     await this._clientServices.close();
+    await this._runtime.dispose();
     await this._onStop?.();
+    await this._livenessLock.release();
   }
 
   /**
    * Create a new session.
    */
-  async createSession({ appPort, systemPort, shellPort }: CreateSessionParams): Promise<void> {
+  async createSession({ appPort, systemPort, shellPort, onClose }: CreateSessionProps): Promise<WorkerSession> {
     const session = new WorkerSession({
       serviceHost: this._clientServices,
       appPort,
@@ -148,8 +201,11 @@ export class WorkerRuntime {
         // Terminate the worker when all sessions are closed.
         await this.stop();
       } else {
-        this._reconnectWebrtc();
+        if (this._automaticallyConnectWebrtc) {
+          this._reconnectWebrtc();
+        }
       }
+      await onClose?.();
     });
 
     await session.open();
@@ -165,7 +221,24 @@ export class WorkerRuntime {
     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: WorkerSession | undefined): void {
+    this._sessionForNetworking = session;
+    this._transportFactory.setBridgeService(session?.bridgeService);
   }
 
   /**
@@ -183,12 +256,78 @@ export class WorkerRuntime {
     // Select existing session.
     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(undefined);
-      }
+      this.connectWebrtcBridge(selected);
     }
   }
 }
+
+const DB_NAME = 'DXOS';
+
+/**
+ * SqlExport layer that wraps SqliteClient to provide export functionality.
+ */
+const SqlExportLayer: Layer.Layer<SqlExport.SqlExport, never, SqliteClient.SqliteClient> = Layer.effect(
+  SqlExport.SqlExport,
+  Effect.gen(function* () {
+    const sql = yield* SqliteClient.SqliteClient;
+    return {
+      export: sql.export,
+    } satisfies SqlExport.Service;
+  }),
+);
+
+/**
+ * Local SQLite layer for the worker.
+ * Uses OPFS sync API as an FS backend.
+ * Does NOT spawn a new worker.
+ * NOTE: Only usable within a worker.
+ * TODO(mykola): This does not work right now. Fix.
+ */
+const 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) })));
+  }),
+);
+
+// TODO(wittjosiah): Factor out to a separate module.
+class WebLockWrapper {
+  readonly #key: string;
+  #release?: () => void;
+
+  constructor(key: string) {
+    this.#key = key;
+  }
+
+  get key(): string {
+    return this.#key;
+  }
+
+  acquire(options: LockOptions = {}) {
+    return navigator.locks.request(this.#key, options, async () => {
+      await new Promise<void>((resolve) => {
+        this.#release = resolve;
+      }); // Blocks for the duration of the worker's lifetime.
+      this.#release = undefined;
+    });
+  }
+
+  release() {
+    this.#release?.();
+    this.#release = undefined;
+  }
+
+  [Symbol.dispose]() {
+    this.release();
+  }
+}

package/src/packlets/worker/worker-session.ts

@@ -2,22 +2,22 @@
 // Copyright 2022 DXOS.org
 //
 
-import { asyncTimeout, Trigger } from '@dxos/async';
+import { Trigger, asyncTimeout } from '@dxos/async';
 import {
-  iframeServiceBundle,
   type IframeServiceBundle,
   PROXY_CONNECTION_TIMEOUT,
+  iframeServiceBundle,
   workerServiceBundle,
 } from '@dxos/client-protocol';
 import { invariant } from '@dxos/invariant';
 import { log, logInfo } from '@dxos/log';
 import { type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
-import { createProtoRpcPeer, type ProtoRpcPeer, type RpcPort } from '@dxos/rpc';
+import { type ProtoRpcPeer, type RpcPort, createProtoRpcPeer } from '@dxos/rpc';
 import { Callback, type MaybePromise } from '@dxos/util';
 
-import { type ClientServicesHost, ClientRpcServer, type ClientRpcServerParams } from '../services';
+import { ClientRpcServer, type ClientRpcServerProps, type ClientServicesHost } from '../services';
 
-export type WorkerSessionParams = {
+export type WorkerSessionProps = {
   serviceHost: ClientServicesHost;
   systemPort: RpcPort;
   appPort: RpcPort;
@@ -50,11 +50,11 @@ export class WorkerSession {
 
   public bridgeService?: BridgeService;
 
-  constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }: WorkerSessionParams) {
+  constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }: WorkerSessionProps) {
     invariant(serviceHost);
     this._serviceHost = serviceHost;
 
-    const middleware: Pick<ClientRpcServerParams, 'handleCall' | 'handleStream'> = {
+    const middleware: Pick<ClientRpcServerProps, 'handleCall' | 'handleStream'> = {
       handleCall: async (method, params, handler) => {
         const error = await readySignal.wait({ timeout: PROXY_CONNECTION_TIMEOUT });
         if (error) {

package/src/version.ts

@@ -1,5 +1 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-export const DXOS_VERSION = '0.8.3'; // {x-release-please-version}
+export const DXOS_VERSION = "0.8.4-main.1068cf700f";