@dxos/client-services 0.1.31 → 0.1.32-next.77d513e

package/src/packlets/spaces/notarization-plugin.ts

@@ -5,7 +5,7 @@
 import assert from 'node:assert';
 
 import { DeferredTask, Event, scheduleTask, sleep, TimeoutError, Trigger } from '@dxos/async';
-import { Context } from '@dxos/context';
+import { Context, rejectOnDispose } from '@dxos/context';
 import { CredentialProcessor } from '@dxos/credentials';
 import { FeedWriter } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
@@ -16,14 +16,43 @@ import { NotarizationService, NotarizeRequest } from '@dxos/protocols/proto/dxos
 import { ExtensionContext, RpcExtension } from '@dxos/teleport';
 import { ComplexMap, ComplexSet, entry } from '@dxos/util';
 
-// Timeout for retrying notarization.
-const RETRY_TIMEOUT = 1_000;
+const DEFAULT_RETRY_TIMEOUT = 1_000;
 
-// Minimum wait time after a peer confirms successful notarization before attempting with a new peer.
-const SUCCESS_DELAY = 1_000;
+const DEFAULT_SUCCESS_DELAY = 1_000;
 
-// Timeout for the whole notarization process.
-const NOTARIZE_TIMEOUT = 10_000;
+const DEFAULT_NOTARIZE_TIMEOUT = 10_000;
+
+export type NotarizeParams = {
+  /**
+   * For cancellation.
+   */
+  ctx?: Context;
+
+  /**
+   * Credentials to notarize.
+   */
+  credentials: Credential[];
+
+  /**
+   * Timeout for the whole notarization process.
+   * Set to 0 to disable.
+   * @default {@link DEFAULT_NOTARIZE_TIMEOUT}
+   */
+  timeout?: number;
+
+  /**
+   * Retry timeout.
+   * @default {@link DEFAULT_RETRY_TIMEOUT}
+   */
+  retryTimeout?: number;
+
+  /**
+   * Minimum wait time after a peer confirms successful notarization before attempting with a new peer.
+   * This is to avoid spamming peers with notarization requests.
+   * @default {@link DEFAULT_SUCCESS_DELAY}
+   */
+  successDelay?: number;
+};
 
 /**
  * See NotarizationService proto.
@@ -46,7 +75,13 @@ export class NotarizationPlugin implements CredentialProcessor {
   /**
    * Request credentials to be notarized.
    */
-  async notarize(credentials: Credential[]) {
+  async notarize({
+    ctx: opCtx,
+    credentials,
+    timeout = DEFAULT_NOTARIZE_TIMEOUT,
+    retryTimeout = DEFAULT_RETRY_TIMEOUT,
+    successDelay = DEFAULT_SUCCESS_DELAY
+  }: NotarizeParams) {
     log('notarize', { credentials });
     assert(
       credentials.every((credential) => credential.id),
@@ -61,15 +96,23 @@ export class NotarizationPlugin implements CredentialProcessor {
         errors.throw(err);
       }
     });
-    scheduleTask(
-      ctx,
-      () => {
-        log.warn('Notarization timeout');
-        void ctx.dispose();
-        errors.throw(new TimeoutError(NOTARIZE_TIMEOUT, 'Notarization timed out'));
-      },
-      NOTARIZE_TIMEOUT
-    );
+    opCtx?.onDispose(() => ctx.dispose());
+
+    // Timeout/
+    if (timeout !== 0) {
+      scheduleTask(
+        ctx,
+        () => {
+          log.warn('Notarization timeout', {
+            timeout,
+            peers: Array.from(this._extensions).map((extension) => extension.remotePeerId)
+          });
+          void ctx.dispose();
+          errors.throw(new TimeoutError(timeout, 'Notarization timed out'));
+        },
+        timeout
+      );
+    }
 
     const allNotarized = Promise.all(credentials.map((credential) => this._waitUntilProcessed(credential.id!)));
 
@@ -79,16 +122,15 @@ export class NotarizationPlugin implements CredentialProcessor {
     const notarizeTask = new DeferredTask(ctx, async () => {
       try {
         if (this._extensions.size === 0) {
-          log.warn('No peers to notarize with');
           return; // No peers to try.
         }
 
         // Pick a peer that we haven't tried yet.
         const peer = [...this._extensions].find((peer) => !peersTried.has(peer));
         if (!peer) {
-          log.warn('Exhausted all peers to notarize with', { retryIn: RETRY_TIMEOUT });
+          log.warn('Exhausted all peers to notarize with', { retryIn: retryTimeout });
           peersTried.clear();
-          scheduleTask(ctx, () => notarizeTask.schedule(), RETRY_TIMEOUT); // retry with all peers again
+          scheduleTask(ctx, () => notarizeTask.schedule(), retryTimeout); // retry with all peers again
           return;
         }
 
@@ -98,7 +140,7 @@ export class NotarizationPlugin implements CredentialProcessor {
           credentials: credentials.filter((credential) => !this._processedCredentials.has(credential.id!))
         });
         log('success');
-        await sleep(SUCCESS_DELAY); // wait before trying with a new peer
+        await sleep(successDelay); // wait before trying with a new peer
       } catch (err) {
         log.warn('error notarizing (recoverable)', err);
         notarizeTask.schedule(); // retry immediately with next peer
@@ -109,8 +151,7 @@ export class NotarizationPlugin implements CredentialProcessor {
     this._extensionOpened.on(ctx, () => notarizeTask.schedule());
 
     try {
-      // TODO(dmaretskyi): Abort (context) & timeout.
-      await Promise.race([allNotarized, errors.wait()]);
+      await Promise.race([rejectOnDispose(ctx), allNotarized, errors.wait()]);
       log('done');
     } finally {
       await ctx.dispose();

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

@@ -81,7 +81,7 @@ describe('SpacesService', () => {
 
       const spaces = await result.wait();
       expect(spaces).to.be.length(3);
-      expect(spaces).to.deep.equal(existingSpaces);
+      expect(spaces?.map((s) => s.spaceKey)).to.deep.equal(existingSpaces?.map((s) => s.spaceKey));
     });
 
     test('updates when new space is added', async () => {

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

@@ -14,7 +14,6 @@ import {
   Space,
   SpaceMember,
   SpacesService,
-  SpaceStatus,
   SubscribeMessagesRequest,
   UpdateSpaceRequest,
   WriteCredentialsRequest
@@ -27,6 +26,8 @@ import { IdentityManager } from '../identity';
 import { DataSpace } from './data-space';
 import { DataSpaceManager } from './data-space-manager';
 
+const TIMEFRAME_UPDATE_DEBOUNCE_TIME = 500;
+
 /**
  *
  */
@@ -55,29 +56,36 @@ export class SpacesServiceImpl implements SpacesService {
     return new Stream<QuerySpacesResponse>(({ next, ctx }) => {
       const onUpdate = async () => {
         const dataSpaceManager = await this._getDataSpaceManager();
-        const spaces = Array.from(dataSpaceManager.spaces.values())
-          // Skip spaces without data service available.
-          .filter((space) => this._dataServiceSubscriptions.getDataService(space.key))
-          .map((space) => this._transformSpace(space));
+        const spaces = Array.from(dataSpaceManager.spaces.values()).map((space) => this._transformSpace(space));
         log('update', { spaces });
         next({ spaces });
       };
 
-      setTimeout(async () => {
+      scheduleTask(ctx, async () => {
         const dataSpaceManager = await this._getDataSpaceManager();
+
         const subscriptions = new EventSubscriptions();
+        ctx.onDispose(() => subscriptions.clear());
+
         // TODO(dmaretskyi): Create a pattern for subscribing to a set of objects.
         const subscribeSpaces = () => {
           subscriptions.clear();
 
           for (const space of dataSpaceManager.spaces.values()) {
-            if (!this._dataServiceSubscriptions.getDataService(space.key)) {
-              // Skip spaces without data service available.
-              continue;
-            }
-
             subscriptions.add(space.stateUpdate.on(ctx, onUpdate));
             subscriptions.add(space.presence.updated.on(ctx, onUpdate));
+
+            // Pipeline progress.
+            space.inner.controlPipeline.state.timeframeUpdate
+              .debounce(TIMEFRAME_UPDATE_DEBOUNCE_TIME)
+              .on(ctx, onUpdate);
+            if (space.dataPipeline.pipelineState) {
+              subscriptions.add(
+                space.dataPipeline.pipelineState.timeframeUpdate
+                  .debounce(TIMEFRAME_UPDATE_DEBOUNCE_TIME)
+                  .on(ctx, onUpdate)
+              );
+            }
           }
         };
 
@@ -85,12 +93,9 @@ export class SpacesServiceImpl implements SpacesService {
           subscribeSpaces();
           void onUpdate();
         });
+        subscribeSpaces();
 
-        ctx.onDispose(() => subscriptions.clear());
-        scheduleTask(ctx, () => {
-          subscribeSpaces();
-          void onUpdate();
-        });
+        void onUpdate();
       });
 
       if (!this._identityManager.identity) {
@@ -142,7 +147,13 @@ export class SpacesServiceImpl implements SpacesService {
   private _transformSpace(space: DataSpace): Space {
     return {
       spaceKey: space.key,
-      status: space.isOpen ? SpaceStatus.ACTIVE : SpaceStatus.INACTIVE,
+      state: space.state,
+      pipeline: {
+        targetControlTimeframe: space.inner.controlPipeline.state.targetTimeframe,
+        currentControlTimeframe: space.inner.controlPipeline.state.timeframe,
+        currentDataTimeframe: space.dataPipeline.pipelineState?.timeframe,
+        targetDataTimeframe: space.dataPipeline.pipelineState?.targetTimeframe
+      },
       members: Array.from(space.inner.spaceState.members.values()).map((member) => ({
         identity: {
           identityKey: member.key,

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

@@ -7,7 +7,7 @@ import { Config } from '@dxos/config';
 import { createCredentialSignerWithChain, CredentialGenerator } from '@dxos/credentials';
 import {
   SnapshotStore,
-  DataPipelineControllerImpl,
+  DataPipeline,
   MetadataStore,
   SigningContext,
   SpaceManager,
@@ -73,7 +73,7 @@ export const createIdentity = async (peer: ServiceContext) => {
 
 // TODO(burdon): Remove @dxos/client-testing.
 // TODO(burdon): Create builder and make configurable.
-export const syncItemsLocal = async (db1: DataPipelineControllerImpl, db2: DataPipelineControllerImpl) => {
+export const syncItemsLocal = async (db1: DataPipeline, db2: DataPipeline) => {
   await testLocalDatabase(db1, db2);
   await testLocalDatabase(db2, db1);
 };

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

@@ -142,7 +142,7 @@ export const syncItems = async (db1: DatabaseBackendProxy, db2: DatabaseBackendP
 };
 
 export const joinCommonSpace = async ([initialPeer, ...peers]: Client[], spaceKey?: PublicKey): Promise<PublicKey> => {
-  const rootSpace = spaceKey ? initialPeer.echo.getSpace(spaceKey) : await initialPeer.echo.createSpace();
+  const rootSpace = spaceKey ? initialPeer.getSpace(spaceKey) : await initialPeer.createSpace();
   assert(rootSpace, 'Space not found.');
 
   await Promise.all(
@@ -154,7 +154,7 @@ export const joinCommonSpace = async ([initialPeer, ...peers]: Client[], spaceKe
       log('invitation created');
       hostObservabli.subscribe({
         onConnecting: (invitation) => {
-          const guestObservable = peer.echo.acceptInvitation(invitation);
+          const guestObservable = peer.acceptInvitation(invitation);
           log('invitation accepted');
 
           guestObservable.subscribe({

package/src/packlets/tests/client-services.test.ts

@@ -7,7 +7,7 @@ import assert from 'node:assert';
 import waitForExpect from 'wait-for-expect';
 
 import { Trigger } from '@dxos/async';
-import { Space } from '@dxos/client';
+import { Client, Space } from '@dxos/client';
 import { raise } from '@dxos/debug';
 import { log } from '@dxos/log';
 import { Invitation, SpaceMember } from '@dxos/protocols/proto/dxos/client/services';
@@ -19,6 +19,19 @@ import { syncItems, TestBuilder } from '../testing';
 // TODO(burdon): Timeouts and progress callback/events.
 
 describe('Client services', () => {
+  test('creates client with local host', async () => {
+    const testBuilder = new TestBuilder();
+
+    const servicesProvider = testBuilder.createLocal();
+    await servicesProvider.open();
+    afterTest(() => servicesProvider.close());
+
+    const client = new Client({ services: servicesProvider });
+    await client.initialize();
+    afterTest(() => client.destroy());
+    expect(client.initialized).to.be.true;
+  });
+
   test('creates client with remote server', async () => {
     const testBuilder = new TestBuilder();
 
@@ -141,16 +154,16 @@ describe('Client services', () => {
     // Check same identity.
     const [invitation1, invitation2] = await Promise.all([success1.wait(), success2.wait()]);
     expect(invitation1.identityKey).not.to.exist;
-    expect(invitation2.identityKey).to.deep.eq(client1.halo.identity!.identityKey);
-    expect(invitation2.identityKey).to.deep.eq(client2.halo.identity!.identityKey);
+    expect(invitation2.identityKey).to.deep.eq(client1.halo.identity.get()!.identityKey);
+    expect(invitation2.identityKey).to.deep.eq(client2.halo.identity.get()!.identityKey);
     expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
     expect(invitation2.state).to.eq(Invitation.State.SUCCESS);
 
     // Check devices.
     // TODO(burdon): Incorrect number of devices.
     await waitForExpect(async () => {
-      expect(client1.halo.getDevices()).to.have.lengthOf(2);
-      expect(client2.halo.getDevices()).to.have.lengthOf(2);
+      expect(client1.halo.devices.get()).to.have.lengthOf(2);
+      expect(client2.halo.devices.get()).to.have.lengthOf(2);
     });
   });
 
@@ -184,13 +197,13 @@ describe('Client services', () => {
     const success1 = new Trigger<Invitation>();
     const success2 = new Trigger<Invitation>();
 
-    const space1 = await client1.echo.createSpace();
+    const space1 = await client1.createSpace();
     log('createSpace', { key: space1.key });
     const observable1 = space1.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
 
     observable1.subscribe({
       onConnecting: (invitation) => {
-        const observable2 = client2.echo.acceptInvitation(invitation);
+        const observable2 = client2.acceptInvitation(invitation);
         observable2.subscribe({
           onSuccess: (invitation: Invitation) => {
             success2.wake(invitation);
@@ -214,7 +227,7 @@ describe('Client services', () => {
     // TODO(burdon): Space should now be available?
     const trigger = new Trigger<Space>();
     await waitForExpect(() => {
-      const space2 = client2.echo.getSpace(invitation2.spaceKey!);
+      const space2 = client2.getSpace(invitation2.spaceKey!);
       assert(space2);
       expect(space2).to.exist;
       trigger.wake(space2);
@@ -224,10 +237,10 @@ describe('Client services', () => {
 
     for (const space of [space1, space2]) {
       await waitForExpect(() => {
-        expect(space.getMembers()).to.deep.equal([
+        expect(space.members.get()).to.deep.equal([
           {
             identity: {
-              identityKey: client1.halo.identity!.identityKey,
+              identityKey: client1.halo.identity.get()!.identityKey,
               profile: {
                 displayName: 'Peer 1'
               }
@@ -236,7 +249,7 @@ describe('Client services', () => {
           },
           {
             identity: {
-              identityKey: client2.halo.identity!.identityKey,
+              identityKey: client2.halo.identity.get()!.identityKey,
               profile: {
                 displayName: 'Peer 2'
               }

package/src/packlets/tests/client.test.ts

@@ -61,9 +61,7 @@ describe('Client', () => {
     const client = new Client({ services: testBuilder.createLocal() });
     await client.initialize();
     afterTest(() => client.destroy());
-    await expect(client.echo.createSpace()).to.eventually.be.rejectedWith(
-      'This device has no HALO identity available.'
-    );
+    await expect(client.createSpace()).to.eventually.be.rejectedWith('This device has no HALO identity available.');
   }).timeout(1_000);
 
   // TODO(burdon): Memory store is reset on close (feed store is closed).
@@ -109,13 +107,12 @@ const getNodeConfig = async (reset = false) => {
 const runTest = async (testBuilder: TestBuilder) => {
   const client = new Client({ services: testBuilder.createLocal() });
   const displayName = 'test-user';
-
   {
     // Create identity.
     await client.initialize();
-    expect(client.halo.identity).not.to.exist;
+    expect(client.halo.identity.get()).not.to.exist;
     const identity = await client.halo.createIdentity({ displayName });
-    expect(client.halo.identity).to.deep.eq(identity);
+    expect(client.halo.identity.get()).to.deep.eq(identity);
     await client.destroy();
   }
 

package/src/packlets/tests/halo-profile.test.ts

@@ -22,8 +22,8 @@ describe('Halo', () => {
     await client.halo.createIdentity({ displayName: 'test-user' });
     expect(client.halo.identity).exist;
 
-    expect(await client.halo.getDevices()).to.have.lengthOf(1);
-    expect(client.halo.identity!.profile?.displayName).to.equal('test-user');
+    expect(await client.halo.devices.get()).to.have.lengthOf(1);
+    expect(client.halo.identity.get()!.profile?.displayName).to.equal('test-user');
   });
 
   test('device invitations', async () => {
@@ -36,7 +36,7 @@ describe('Halo', () => {
     await client1.halo.createIdentity({ displayName: 'test-user' });
     expect(client1.halo.identity).exist;
 
-    expect(await client1.halo.getDevices()).to.have.lengthOf(1);
+    expect(await client1.halo.devices.get()).to.have.lengthOf(1);
 
     const client2 = new Client({ services: testBuilder.createLocal() });
     afterTest(() => client2.destroy());
@@ -68,7 +68,7 @@ describe('Halo', () => {
     await done1.wait();
     await done2.wait();
 
-    expect(await client1.halo.getDevices()).to.have.lengthOf(2);
-    expect(await client2.halo.getDevices()).to.have.lengthOf(2);
+    expect(await client1.halo.devices.get()).to.have.lengthOf(2);
+    expect(await client2.halo.devices.get()).to.have.lengthOf(2);
   });
 });

package/src/packlets/tests/spaces-invitations.test.ts

@@ -8,7 +8,7 @@ import { Trigger } from '@dxos/async';
 import { Client, Invitation } from '@dxos/client';
 import { raise } from '@dxos/debug';
 import { log } from '@dxos/log';
-import { describe, test, afterTest } from '@dxos/test';
+import { afterTest, describe, test } from '@dxos/test';
 
 import { TestBuilder, testSpace } from '../testing';
 
@@ -31,13 +31,13 @@ describe('Spaces/invitations', () => {
     const success1 = new Trigger<Invitation>();
     const success2 = new Trigger<Invitation>();
 
-    const space1 = await client1.echo.createSpace();
+    const space1 = await client1.createSpace();
     log('createSpace', { key: space1.key });
     const observable1 = space1.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
 
     observable1.subscribe({
       onConnecting: (invitation) => {
-        const observable2 = client2.echo.acceptInvitation(invitation);
+        const observable2 = client2.acceptInvitation(invitation);
         observable2.subscribe({
           onSuccess: (invitation: Invitation) => {
             success2.wake(invitation);
@@ -57,7 +57,7 @@ describe('Spaces/invitations', () => {
     expect(invitation1.state).to.eq(Invitation.State.SUCCESS);
 
     {
-      const space = client2.echo.getSpace(invitation2.spaceKey!)!;
+      const space = await client2.getSpace(invitation2.spaceKey!)!.waitUntilReady();
       await testSpace(space.internal.db);
     }
   });

package/src/packlets/tests/spaces.test.ts

@@ -5,7 +5,7 @@
 import { expect } from 'chai';
 
 import { asyncTimeout, Trigger } from '@dxos/async';
-import { Client, Invitation } from '@dxos/client';
+import { Client, Invitation, Space } from '@dxos/client';
 import { Config } from '@dxos/config';
 import { raise } from '@dxos/debug';
 import { log } from '@dxos/log';
@@ -25,10 +25,10 @@ describe('Spaces', () => {
     await client.halo.createIdentity({ displayName: 'test-user' });
 
     // TODO(burdon): Extend basic queries.
-    const space = await client.echo.createSpace();
+    const space = await client.createSpace();
     await testSpace(space.internal.db);
 
-    expect(space.getMembers()).to.be.length(1);
+    expect(space.members.get()).to.be.length(1);
   });
 
   test('creates a space re-opens the client', async () => {
@@ -42,12 +42,12 @@ describe('Spaces', () => {
     let itemId: string;
     {
       // TODO(burdon): API (client.echo/client.halo).
-      const space = await client.echo.createSpace();
+      const space = await client.createSpace();
       const {
         objectsUpdated: [item]
       } = await testSpace(space.internal.db);
       itemId = item.id;
-      expect(space.getMembers()).to.be.length(1);
+      expect(space.members.get()).to.be.length(1);
     }
 
     await client.destroy();
@@ -57,9 +57,18 @@ describe('Spaces', () => {
     await client.initialize();
 
     {
-      const result = client.echo.getSpaces();
-      expect(result).to.have.length(1);
-      const space = result[0];
+      // TODO(dmaretskyi): Replace with helper?.
+      const spaceTrigger = new Trigger<Space>();
+      if (client.spaces.get()[0]) {
+        spaceTrigger.wake(client.spaces.get()[0]);
+      }
+      client.spaces.subscribe(() => {
+        if (client.spaces.get()[0]) {
+          spaceTrigger.wake(client.spaces.get()[0]);
+        }
+      });
+      const space = await spaceTrigger.wait({ timeout: 500 });
+      await space.waitUntilReady();
 
       const item = space.internal.db._itemManager.getItem(itemId)!;
       expect(item).to.exist;
@@ -86,13 +95,13 @@ describe('Spaces', () => {
     const success1 = new Trigger<Invitation>();
     const success2 = new Trigger<Invitation>();
 
-    const space1 = await client1.echo.createSpace();
+    const space1 = await client1.createSpace();
     log('createSpace', { key: space1.key });
     const observable1 = space1.createInvitation({ type: Invitation.Type.INTERACTIVE_TESTING });
 
     observable1.subscribe({
       onConnecting: (invitation) => {
-        const observable2 = client2.echo.acceptInvitation(invitation);
+        const observable2 = client2.acceptInvitation(invitation);
         observable2.subscribe({
           onSuccess: (invitation: Invitation) => {
             success2.wake(invitation);
@@ -109,7 +118,7 @@ describe('Spaces', () => {
 
     const [_, invitation2] = await Promise.all([success1.wait(), success2.wait()]);
 
-    const space2 = client2.echo.getSpace(invitation2.spaceKey!)!;
+    const space2 = await client2.getSpace(invitation2.spaceKey!)!.waitUntilReady();
 
     const hello = new Trigger();
     {

package/src/packlets/tests/text.test.ts

@@ -6,7 +6,7 @@ import * as fc from 'fast-check';
 import { ModelRunSetup } from 'fast-check';
 import waitForExpect from 'wait-for-expect';
 
-import { Client, Document, Text } from '@dxos/client';
+import { Client, Expando, Text } from '@dxos/client';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { describe, test } from '@dxos/test';
@@ -34,7 +34,7 @@ const assertState = async (model: Model, real: Real) => {
   // Wait for replication.
   await waitForExpect(() => {
     for (const [peerId, peer] of real.peers.entries()) {
-      const space = peer.echo.getSpace(real.spaceKey);
+      const space = peer.getSpace(real.spaceKey);
       if (space) {
         if (!model.peers.has(peerId)) {
           throw new Error(`Expected peer to not be in space: ${peerId.truncate()}`);
@@ -73,10 +73,10 @@ class CreatePeerCommand implements fc.AsyncCommand<Model, Real> {
     await client.initialize();
     await client.halo.createIdentity();
     if (real.peers.size === 0) {
-      const space = await client.echo.createSpace();
+      const space = await client.createSpace();
       const content = new Text();
       content.doc?.getText('utf8').insert(0, initialContent);
-      await space.db.add(new Document({ content }));
+      await space.db.add(new Expando({ content }));
       real.spaceKey = space.key;
     } else {
       const host = Array.from(real.peers.values())[0];
@@ -114,7 +114,7 @@ class InsertTextCommand implements fc.AsyncCommand<Model, Real> {
     model.text = model.text.slice(0, this.index) + this.text + model.text.slice(this.index);
 
     const peer = real.peers.get(this.peerId);
-    const space = peer!.echo.getSpace(real.spaceKey)!;
+    const space = peer!.getSpace(real.spaceKey)!;
     const [document] = space.db.query((obj) => !!obj.content).objects;
     const text = (document.content.doc as Doc).getText('utf8');
     text.insert(this.index, this.text);
@@ -140,7 +140,7 @@ class RemoveTextCommand implements fc.AsyncCommand<Model, Real> {
     model.text = model.text.slice(0, this.index) + model.text.slice(this.index + this.length);
 
     const peer = real.peers.get(this.peerId);
-    const space = peer!.echo.getSpace(real.spaceKey)!;
+    const space = peer!.getSpace(real.spaceKey)!;
     const [document] = space.db.query((obj) => !!obj.content).objects;
     const text = (document.content.doc as Doc).getText('utf8');
     text.delete(this.index, this.length);

package/src/packlets/vault/vault-resource-lock.ts

@@ -3,7 +3,7 @@
 //
 
 import { asyncTimeout, Trigger } from '@dxos/async';
-import { log } from '@dxos/log';
+import { log, logInfo } from '@dxos/log';
 import { MaybePromise } from '@dxos/util';
 
 enum Message {
@@ -30,15 +30,24 @@ export class VaultResourceLock {
     this._broadcastChannel.onmessage = this._onMessage.bind(this);
   }
 
+  @logInfo
+  get lockKey() {
+    return this._lockKey;
+  }
+
   async acquire() {
     this._broadcastChannel.postMessage({
       message: Message.ACQUIRING
     });
 
     try {
+      log('aquiring lock...');
       await asyncTimeout(this._requestLock(), 3_000);
+      log('acquired lock');
     } catch {
+      log('stealing lock...');
       await this._requestLock(true);
+      log('stolen lock');
     }
   }