@dxos/client-services 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

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

@@ -2,24 +2,32 @@
 // Copyright 2022 DXOS.org
 //
 
+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 { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
 import { CredentialGenerator, createCredentialSignerWithChain } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
-import { EchoHost, MeshEchoReplicator, MetadataStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
+import { EchoHost, MeshEchoReplicator, SpaceManager, valueEncoding } from '@dxos/echo-host';
+import { SqliteMetadataStore } from '@dxos/echo-host';
+import { RuntimeProvider } from '@dxos/effect';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
-import { Keyring } from '@dxos/keyring';
-import { type LevelDB } from '@dxos/kv-store';
-import { createTestLevel } from '@dxos/kv-store/testing';
+import { SqliteKeyring } from '@dxos/keyring';
 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 { type Storage, StorageType, createStorage } from '@dxos/random-access-storage';
-import { BlobStore } from '@dxos/teleport-extension-object-sync';
+import { StorageType } from '@dxos/random-access-storage';
+import { layerMemory as sqliteLayerMemory } from '@dxos/sql-sqlite/platform';
+import * as SqlTransaction from '@dxos/sql-sqlite/SqlTransaction';
+import { SqliteBlobStore } 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 { SqliteStorage } from '../services/sqlite-storage';
+import { DataSpaceManager, type DataSpaceManagerRuntimeProps, type SigningContext } from '../spaces';
 
 //
 // TODO(burdon): Replace with test builder.
@@ -30,6 +38,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,
   });
 };
 
@@ -38,24 +51,26 @@ export const createServiceContext = async ({
     const signalContext = new MemorySignalManagerContext();
     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({
     signalManager,
     transportFactory: MemoryTransportFactory,
   });
-  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(networkManager, signalManager, undefined, undefined, runtime, {
+    invitationConnectionDefaultProps: { teleport: { controlHeartbeatInterval: 200 } },
+    ...runtimeProps,
   });
 };
 
@@ -95,20 +110,18 @@ export class TestBuilder {
 
 export type TestPeerOpts = {
   dataStore?: StorageType;
-  dataSpaceParams?: DataSpaceManagerRuntimeParams;
+  dataSpaceProps?: DataSpaceManagerRuntimeProps;
 };
 
 export type TestPeerProps = {
-  storage?: Storage;
-  level?: LevelDB;
   feedStore?: FeedStore<any>;
-  metadataStore?: MetadataStore;
-  keyring?: Keyring;
+  metadataStore?: SqliteMetadataStore;
+  keyring?: SqliteKeyring;
   networkManager?: SwarmNetworkManager;
   spaceManager?: SpaceManager;
   dataSpaceManager?: DataSpaceManager;
   signingContext?: SigningContext;
-  blobStore?: BlobStore;
+  blobStore?: SqliteBlobStore;
   echoHost?: EchoHost;
   meshEchoReplicator?: MeshEchoReplicator;
   invitationsManager?: InvitationsManager;
@@ -116,6 +129,12 @@ 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),
+  );
+  private readonly _feedStorage = new SqliteStorage({ runtime: this._runtime.runtimeEffect });
 
   constructor(
     private readonly _signalContext: MemorySignalManagerContext,
@@ -126,22 +145,14 @@ export class TestPeer {
     return this._props;
   }
 
-  get storage() {
-    return (this._props.storage ??= createStorage({ type: this._opts.dataStore }));
-  }
-
   get keyring() {
-    return (this._props.keyring ??= new Keyring(this.storage.createDirectory('keyring')));
-  }
-
-  get level() {
-    return (this._props.level ??= createTestLevel());
+    return (this._props.keyring ??= new SqliteKeyring({ runtime: this._runtime.runtimeEffect }));
   }
 
   get feedStore() {
     return (this._props.feedStore ??= new FeedStore({
       factory: new FeedFactory({
-        root: this.storage.createDirectory('feeds'),
+        root: this._feedStorage.createDirectory('feeds'),
         signer: this.keyring,
         hypercore: {
           valueEncoding,
@@ -151,11 +162,11 @@ export class TestPeer {
   }
 
   get metadataStore() {
-    return (this._props.metadataStore ??= new MetadataStore(this.storage.createDirectory('metadata')));
+    return (this._props.metadataStore ??= new SqliteMetadataStore({ runtime: this._runtime.runtimeEffect }));
   }
 
   get blobStore() {
-    return (this._props.blobStore ??= new BlobStore(this.storage.createDirectory('blobs')));
+    return (this._props.blobStore ??= new SqliteBlobStore({ runtime: this._runtime.runtimeEffect }));
   }
 
   get networkManager() {
@@ -179,7 +190,9 @@ export class TestPeer {
   }
 
   get echoHost() {
-    return (this._props.echoHost ??= new EchoHost({ kv: this.level }));
+    return (this._props.echoHost ??= new EchoHost({
+      runtime: this._runtime.runtimeEffect,
+    }));
   }
 
   get meshEchoReplicator() {
@@ -198,7 +211,7 @@ export class TestPeer {
       edgeConnection: undefined,
       meshReplicator: this.meshEchoReplicator,
       echoEdgeReplicator: undefined,
-      runtimeParams: this._opts.dataSpaceParams,
+      runtimeProps: this._opts.dataSpaceProps,
     }));
   }
 
@@ -217,6 +230,7 @@ export class TestPeer {
   }
 
   async createIdentity(): Promise<void> {
+    await this.migrate();
     this._props.signingContext ??= await createSigningContext(this.keyring);
     this.networkManager.setPeerInfo({
       identityKey: this._props.signingContext.identityKey.toHex(),
@@ -224,13 +238,18 @@ export class TestPeer {
     });
   }
 
+  async migrate(): Promise<void> {
+    await RuntimeProvider.runPromise(this._runtime.runtimeEffect)(
+      Effect.all([this.metadataStore.migrate, this.blobStore.migrate, this.keyring.migrate, this._feedStorage.migrate]),
+    );
+  }
+
   async destroy(): Promise<void> {
-    await this.level.close();
-    await this.storage.reset();
+    await this._runtime.dispose();
   }
 }
 
-export const createSigningContext = async (keyring: Keyring): Promise<SigningContext> => {
+export const createSigningContext = async (keyring: SqliteKeyring): Promise<SigningContext> => {
   const identityKey = await keyring.createKey();
   const deviceKey = await keyring.createKey();
 

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,17 +22,20 @@ import {
 } from '@dxos/messaging';
 import { RtcTransportProxyFactory } from '@dxos/network-manager';
 import { type RpcPort } from '@dxos/rpc';
+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 { 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 = {
@@ -35,10 +44,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.
  */
@@ -52,11 +71,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,
@@ -64,37 +89,72 @@ 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 {
+      log('worker-runtime: acquiring liveness lock (background)');
+      void this._livenessLock.acquire();
+
+      // Steal the lock from the other worker.
+      log('worker-runtime: broadcasting stop to displace previous worker');
       this._broadcastChannel = new BroadcastChannel(this._channel);
       this._broadcastChannel.postMessage({ action: 'stop' });
       this._broadcastChannel.onmessage = async (event) => {
         if (event.data?.action === 'stop') {
+          log('worker-runtime: received stop broadcast');
           await this.stop();
         }
       };
 
+      log('worker-runtime: acquiring storage lock');
       await this._acquireLock();
+      log('worker-runtime: storage lock acquired, resolving config');
       this._config = await this._configProvider();
+      log('worker-runtime: config resolved');
+      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');
+      log('worker-runtime: initializing client services host');
       this._clientServices.initialize({
         config: this._config,
         signalManager: this._config.get('runtime.client.edgeFeatures')?.signaling
@@ -104,8 +164,10 @@ export class WorkerRuntime {
             : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
         transportFactory: this._transportFactory,
       });
+      log('worker-runtime: client services host initialized, opening');
 
       await this._clientServices.open(new Context());
+      log('worker-runtime: client services host opened, signalling ready');
       this._ready.wake(undefined);
       log('started');
       setIdentityTags({
@@ -126,14 +188,40 @@ export class WorkerRuntime {
     this._releaseLock();
     this._broadcastChannel?.close();
     this._broadcastChannel = undefined;
-    await this._clientServices.close();
+    await this._clientServices.close(Context.default());
+    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: Config): void {
+    const observabilityGroup = config.get('runtime.client.observabilityGroup');
+    if (observabilityGroup) {
+      this._signalMetadataTags.group = observabilityGroup;
+    } else {
+      // Clear stale group so a later config that removes observabilityGroup stops attributing
+      // telemetry to the previous client's group (last-writer-wins).
+      delete this._signalMetadataTags.group;
+    }
+    const signalTelemetryEnabled = config.get('runtime.client.signalTelemetryEnabled');
+    if (signalTelemetryEnabled !== undefined) {
+      this._signalTelemetryEnabled = signalTelemetryEnabled;
+    }
   }
 
   /**
    * 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,
@@ -149,8 +237,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();
@@ -159,14 +250,27 @@ export class WorkerRuntime {
       !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;
     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);
   }
 
   /**
@@ -184,12 +288,64 @@ 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 in-process OPFS via {@link SqliteClient.layerOpfs} (no MessagePort).
+ * NOTE: Only usable within a worker.
+ */
+const LocalSqliteOpfsLayer = SqlExportLayer.pipe(
+  Layer.provideMerge(SqliteClient.layerOpfs({ dbName: DB_NAME })),
+  Layer.provideMerge(Reactivity.layer),
+);
+
+// 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

@@ -15,9 +15,9 @@ import { type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { type ProtoRpcPeer, type RpcPort, createProtoRpcPeer } from '@dxos/rpc';
 import { Callback, type MaybePromise } from '@dxos/util';
 
-import { ClientRpcServer, type ClientRpcServerParams, type ClientServicesHost } from '../services';
+import { ClientRpcServer, type ClientRpcServerProps, type ClientServicesHost } from '../services';
 
-export type WorkerSessionParams = {
+export type WorkerSessionProps = {
   serviceHost: ClientServicesHost;
   systemPort: RpcPort;
   appPort: RpcPort;
@@ -41,35 +41,31 @@ export class WorkerSession {
   @logInfo
   public origin?: string;
 
-  // TODO(nf): factor out?
-  public observabilityGroup?: string;
-  public signalTelemetryEnabled?: boolean;
-
   @logInfo
   public lockKey?: string;
 
   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'> = {
-      handleCall: async (method, params, handler) => {
+    const middleware: Pick<ClientRpcServerProps, 'handleCall' | 'handleStream'> = {
+      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);
       },
     };
 
@@ -95,8 +91,6 @@ export class WorkerSession {
           start: async (request) => {
             this.origin = request.origin;
             this.lockKey = request.lockKey;
-            this.observabilityGroup = request.observabilityGroup;
-            this.signalTelemetryEnabled = request.signalTelemetryEnabled;
             this._startTrigger.wake();
           },
 
@@ -119,7 +113,7 @@ export class WorkerSession {
   }
 
   async open(): Promise<void> {
-    log.info('opening...');
+    log('opening...');
     await Promise.all([this._clientRpc.open(), this._iframeRpc.open(), this._maybeOpenShell()]);
 
     // Wait until the worker's RPC service has started.
@@ -130,11 +124,11 @@ export class WorkerSession {
       void this._afterLockReleases(this.lockKey, () => this.close());
     }
 
-    log.info('opened');
+    log('opened');
   }
 
   async close(): Promise<void> {
-    log.info('closing...');
+    log.debug('closing...');
     try {
       await this.onClose.callIfSet();
     } catch (err: any) {
@@ -142,7 +136,7 @@ export class WorkerSession {
     }
 
     await Promise.all([this._clientRpc.close(), this._iframeRpc.close()]);
-    log.info('closed');
+    log.debug('closed');
   }
 
   private async _maybeOpenShell(): Promise<void> {

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.8.4-main.fd6878d";
+export const DXOS_VERSION = "0.8.4-staging.60fe92afc8";