@dxos/client-services 0.1.20 → 0.1.21

package/src/packlets/identity/identity-manager.ts

@@ -6,12 +6,11 @@ import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
 import { createCredentialSignerWithKey, CredentialGenerator } from '@dxos/credentials';
-import { MetadataStore, NoopDataPipelineController, SpaceManager, SwarmIdentity } from '@dxos/echo-db';
+import { MetadataStore, SpaceManager, SwarmIdentity } from '@dxos/echo-db';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { AdmittedFeed, IdentityRecord, SpaceRecord } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { Presence } from '@dxos/teleport-extension-presence';
 import { deferFunction } from '@dxos/util';
 
 import { Identity } from '../identity';
@@ -55,6 +54,7 @@ export class IdentityManager {
     await this._metadataStore.load();
 
     const identityRecord = this._metadataStore.getIdentityRecord();
+    log('identity record', { identityRecord });
     if (identityRecord) {
       this._identity = await this._constructIdentity(identityRecord);
       await this._identity.open();
@@ -192,14 +192,8 @@ export class IdentityManager {
         controlFeedKey: spaceRecord.writeControlFeedKey,
         dataFeedKey: spaceRecord.writeDataFeedKey
       },
-      dataPipelineControllerProvider: () => new NoopDataPipelineController(),
       swarmIdentity,
-      presence: new Presence({
-        localPeerId: swarmIdentity.peerKey,
-        announceInterval: 1_000,
-        offlineTimeout: 30_000,
-        identityKey
-      })
+      onNetworkConnection: () => {}
     });
   }
 }

package/src/packlets/identity/identity.test.ts

@@ -5,14 +5,7 @@
 import expect from 'expect';
 
 import { CredentialGenerator, verifyCredential } from '@dxos/credentials';
-import {
-  MOCK_AUTH_PROVIDER,
-  MOCK_AUTH_VERIFIER,
-  NoopDataPipelineController,
-  Space,
-  SpaceProtocol,
-  valueEncoding
-} from '@dxos/echo-db';
+import { MOCK_AUTH_PROVIDER, MOCK_AUTH_VERIFIER, Space, SpaceProtocol, valueEncoding } from '@dxos/echo-db';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
@@ -21,7 +14,6 @@ import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
 import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { createStorage, StorageType } from '@dxos/random-access-storage';
-import { Presence } from '@dxos/teleport-extension-presence';
 import { afterTest, describe, test } from '@dxos/test';
 
 import { Identity } from './identity';
@@ -61,12 +53,6 @@ describe('identity/identity', () => {
       networkManager: new NetworkManager({
         signalManager: new MemorySignalManager(new MemorySignalManagerContext()),
         transportFactory: MemoryTransportFactory
-      }),
-      presence: new Presence({
-        localPeerId: deviceKey,
-        announceInterval: 30,
-        offlineTimeout: 200,
-        identityKey
       })
     });
 
@@ -76,8 +62,7 @@ describe('identity/identity', () => {
       genesisFeed: controlFeed,
       controlFeed,
       dataFeed,
-      feedProvider: (feedKey) => feedStore.openFeed(feedKey),
-      dataPipelineControllerProvider: () => new NoopDataPipelineController()
+      feedProvider: (feedKey) => feedStore.openFeed(feedKey)
     });
 
     const identity = new Identity({
@@ -174,12 +159,6 @@ describe('identity/identity', () => {
         networkManager: new NetworkManager({
           signalManager: new MemorySignalManager(signalContext),
           transportFactory: MemoryTransportFactory
-        }),
-        presence: new Presence({
-          localPeerId: deviceKey,
-          announceInterval: 30,
-          offlineTimeout: 200,
-          identityKey
         })
       });
 
@@ -189,8 +168,7 @@ describe('identity/identity', () => {
         genesisFeed: controlFeed,
         controlFeed,
         dataFeed,
-        feedProvider: (feedKey) => feedStore.openFeed(feedKey),
-        dataPipelineControllerProvider: () => new NoopDataPipelineController()
+        feedProvider: (feedKey) => feedStore.openFeed(feedKey)
       });
 
       const identity = (identity1 = new Identity({
@@ -261,12 +239,6 @@ describe('identity/identity', () => {
         networkManager: new NetworkManager({
           signalManager: new MemorySignalManager(signalContext),
           transportFactory: MemoryTransportFactory
-        }),
-        presence: new Presence({
-          localPeerId: deviceKey,
-          announceInterval: 30,
-          offlineTimeout: 200,
-          identityKey
         })
       });
 
@@ -276,8 +248,7 @@ describe('identity/identity', () => {
         genesisFeed: await feedStore.openFeed(genesisFeedKey),
         controlFeed,
         dataFeed,
-        feedProvider: (feedKey) => feedStore.openFeed(feedKey),
-        dataPipelineControllerProvider: () => new NoopDataPipelineController()
+        feedProvider: (feedKey) => feedStore.openFeed(feedKey)
       });
 
       const identity = (identity2 = new Identity({

package/src/packlets/identity/identity.ts

@@ -10,7 +10,8 @@ import {
   CredentialSigner,
   createCredentialSignerWithKey,
   createCredentialSignerWithChain,
-  ProfileStateMachine
+  ProfileStateMachine,
+  CredentialConsumer
 } from '@dxos/credentials';
 import { Signer } from '@dxos/crypto';
 import { Space } from '@dxos/echo-db';
@@ -42,8 +43,8 @@ export type IdentityParams = {
 export class Identity {
   public readonly space: Space;
   private readonly _signer: Signer;
-  private readonly _deviceStateMachine: DeviceStateMachine;
-  private readonly _profileStateMachine: ProfileStateMachine;
+  private readonly _deviceStateMachine: CredentialConsumer<DeviceStateMachine>;
+  private readonly _profileStateMachine: CredentialConsumer<ProfileStateMachine>;
   public readonly authVerifier: HaloAuthVerifier;
 
   public readonly identityKey: PublicKey;
@@ -58,16 +59,19 @@ export class Identity {
     this.identityKey = identityKey;
     this.deviceKey = deviceKey;
 
-    this._deviceStateMachine = new DeviceStateMachine(this.identityKey, this.deviceKey);
-    this._profileStateMachine = new ProfileStateMachine(this.identityKey);
-
-    // Process halo-specific credentials.
-    this.space.onCredentialProcessed.set(async (credential) => {
-      // Save device keychain credential when processed by the space state machine.
-      await this._deviceStateMachine.process(credential);
-      await this._profileStateMachine.process(credential);
-      this.stateUpdate.emit();
-    });
+    this._deviceStateMachine = this.space.spaceState.registerProcessor(
+      new DeviceStateMachine({
+        identityKey: this.identityKey,
+        deviceKey: this.deviceKey,
+        onUpdate: () => this.stateUpdate.emit()
+      })
+    );
+    this._profileStateMachine = this.space.spaceState.registerProcessor(
+      new ProfileStateMachine({
+        identityKey: this.identityKey,
+        onUpdate: () => this.stateUpdate.emit()
+      })
+    );
 
     this.authVerifier = new HaloAuthVerifier({
       trustedDevicesProvider: () => this.authorizedDeviceKeys,
@@ -78,26 +82,30 @@ export class Identity {
 
   // TODO(burdon): Expose state object?
   get authorizedDeviceKeys(): ComplexSet<PublicKey> {
-    return this._deviceStateMachine.authorizedDeviceKeys;
+    return this._deviceStateMachine.processor.authorizedDeviceKeys;
   }
 
   async open() {
+    await this._deviceStateMachine.open();
+    await this._profileStateMachine.open();
     await this.space.open();
   }
 
   async close() {
     await this.authVerifier.close();
+    await this._deviceStateMachine.close();
+    await this._profileStateMachine.close();
     await this.space.close();
   }
 
   async ready() {
-    await this._deviceStateMachine.deviceChainReady.wait();
+    await this._deviceStateMachine.processor.deviceChainReady.wait();
 
     // TODO(dmaretskyi): Should we also wait for our feeds to be admitted?
   }
 
   get profileDocument(): ProfileDocument | undefined {
-    return this._profileStateMachine.profile;
+    return this._profileStateMachine.processor.profile;
   }
 
   /**
@@ -128,10 +136,10 @@ export class Identity {
    * Requires identity to be ready.
    */
   getIdentityCredentialSigner(): CredentialSigner {
-    assert(this._deviceStateMachine.deviceCredentialChain, 'Device credential chain is not ready.');
+    assert(this._deviceStateMachine.processor.deviceCredentialChain, 'Device credential chain is not ready.');
     return createCredentialSignerWithChain(
       this._signer,
-      this._deviceStateMachine.deviceCredentialChain,
+      this._deviceStateMachine.processor.deviceCredentialChain,
       this.deviceKey
     );
   }

package/src/packlets/invitations/space-invitations-handler.test.ts

@@ -5,12 +5,13 @@
 import { expect } from 'chai';
 import assert from 'node:assert';
 
-import { asyncChain, Trigger } from '@dxos/async';
+import { asyncChain, latch, Trigger } from '@dxos/async';
 import { raise } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { ObjectModel } from '@dxos/object-model';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, test, afterTest } from '@dxos/test';
+import { range } from '@dxos/util';
 
 import { ServiceContext } from '../services';
 import { createIdentity, createPeers, syncItems } from '../testing';
@@ -157,4 +158,55 @@ describe('services/space-invitations-handler', () => {
     await cancelled.wait();
     await space1.close();
   });
+
+  test('test multi-use invitation', async () => {
+    const GUEST_COUNT = 3;
+    const [host, ...guests] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(
+      createPeers(GUEST_COUNT + 1)
+    );
+
+    const hostSpace = await host.dataSpaceManager!.createSpace();
+    const swarmKey = PublicKey.random();
+    const hostObservable = await host.spaceInvitations!.createInvitation(hostSpace, {
+      swarmKey,
+      type: Invitation.Type.MULTIUSE_TESTING
+    });
+
+    const [done, count] = latch({ count: GUEST_COUNT });
+    hostObservable.subscribe({
+      onConnecting: async (invitation2: Invitation) => {},
+      onConnected: async (invitation2: Invitation) => {},
+      onSuccess: () => {
+        count();
+      },
+      onCancelled: () => {},
+      onTimeout: (err: Error) => raise(new Error(err.message)),
+      onError: (err: Error) => raise(new Error(err.message))
+    });
+
+    await Promise.all(
+      range(GUEST_COUNT).map(async (idx) => {
+        const observable = await guests[idx].spaceInvitations!.acceptInvitation({
+          swarmKey,
+          type: Invitation.Type.MULTIUSE_TESTING
+        });
+        const success = new Trigger();
+        observable.subscribe({
+          onConnecting: async (invitation2: Invitation) => {},
+          onConnected: async (invitation2: Invitation) => {},
+          onSuccess: () => {
+            success.wake();
+          },
+          onCancelled: () => raise(new Error()),
+          onTimeout: (err: Error) => raise(new Error(err.message)),
+          onError: (err: Error) => raise(new Error(err.message))
+        });
+        await success.wait({ timeout: 300 });
+      })
+    );
+    await done();
+
+    await hostObservable.cancel();
+    await hostSpace.close();
+  });
 });

package/src/packlets/invitations/space-invitations-handler.ts

@@ -87,10 +87,9 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
     let authenticationCode: string;
     let authenticationRetry = 0;
 
-    const complete = new Trigger<PublicKey>();
-
     // Called for every connecting peer.
     const createExtension = (): HostSpaceInvitationExtension => {
+      const complete = new Trigger<PublicKey>();
       let guestProfile: ProfileDocument | undefined;
 
       const hostInvitationExtension = new HostSpaceInvitationExtension({
@@ -127,7 +126,10 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
         requestAdmission: async ({ identityKey, deviceKey, controlFeedKey, dataFeedKey }) => {
           try {
             // Check authenticated.
-            if (invitation.type !== Invitation.Type.INTERACTIVE_TESTING) {
+            if (
+              invitation.type !== Invitation.Type.INTERACTIVE_TESTING &&
+              invitation.type !== Invitation.Type.MULTIUSE_TESTING
+            ) {
               if (invitation.authenticationCode === undefined || invitation.authenticationCode !== authenticationCode) {
                 throw new Error(`invalid authentication code: ${authenticationCode}`);
               }
@@ -178,8 +180,10 @@ export class SpaceInvitationsHandler extends AbstractInvitationsHandler<DataSpac
                 observable.callback.onError(err);
               }
             } finally {
-              await sleep(ON_CLOSE_DELAY);
-              await ctx.dispose();
+              if (type !== Invitation.Type.MULTIUSE_TESTING) {
+                await sleep(ON_CLOSE_DELAY);
+                await ctx.dispose();
+              }
             }
           });
         }

package/src/packlets/network/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * from './network-service';

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

@@ -0,0 +1,24 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Stream } from '@dxos/codec-protobuf';
+import { NetworkManager } from '@dxos/network-manager';
+import { NetworkService, NetworkStatus, SetNetworkOptionsRequest } from '@dxos/protocols/proto/dxos/client/services';
+
+export class NetworkServiceImpl implements NetworkService {
+  constructor(private readonly networkManager: NetworkManager) {}
+
+  subscribeToNetworkStatus() {
+    return new Stream<NetworkStatus>(({ next }) => {
+      const unsubscribe = this.networkManager.connectionStateChanged.on((state) => next({ state }));
+      next({ state: this.networkManager.connectionState });
+
+      return unsubscribe;
+    });
+  }
+
+  async setNetworkOptions(request: SetNetworkOptionsRequest) {
+    await this.networkManager.setConnectionState(request.state);
+  }
+}

package/src/packlets/services/service-context.ts

@@ -11,7 +11,8 @@ import {
   DataServiceSubscriptions,
   MetadataStore,
   SpaceManager,
-  SigningContext
+  SigningContext,
+  SnapshotStore
 } from '@dxos/echo-db';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
@@ -34,6 +35,7 @@ export class ServiceContext {
   public readonly initialized = new Trigger();
   public readonly dataServiceSubscriptions = new DataServiceSubscriptions();
   public readonly metadataStore: MetadataStore;
+  public readonly snapshotStore: SnapshotStore;
   public readonly feedStore: FeedStore<FeedMessage>;
   public readonly keyring: Keyring;
   public readonly spaceManager: SpaceManager;
@@ -52,6 +54,8 @@ export class ServiceContext {
   ) {
     // TODO(burdon): Move strings to constants.
     this.metadataStore = new MetadataStore(storage.createDirectory('metadata'));
+    this.snapshotStore = new SnapshotStore(storage.createDirectory('snapshots'));
+
     this.keyring = new Keyring(storage.createDirectory('keyring'));
     this.feedStore = new FeedStore<FeedMessage>({
       factory: new FeedFactory<FeedMessage>({
@@ -79,6 +83,7 @@ export class ServiceContext {
 
   async open() {
     log('opening...');
+    await this.networkManager.open();
     await this.spaceManager.open();
     await this.identityManager.open();
     if (this.identityManager.identity) {
@@ -114,6 +119,7 @@ export class ServiceContext {
 
   // Called when identity is created.
   private async _initialize() {
+    log('initializing spaces...');
     const identity = this.identityManager.identity ?? failUndefined();
     const signingContext: SigningContext = {
       credentialProvider: MOCK_AUTH_PROVIDER,
@@ -130,7 +136,8 @@ export class ServiceContext {
       this.dataServiceSubscriptions,
       this.keyring,
       signingContext,
-      this.modelFactory
+      this.modelFactory,
+      this.snapshotStore
     );
     await this.dataSpaceManager.open();
     this.spaceInvitations = new SpaceInvitationsHandler(

package/src/packlets/services/service-definitions.ts

@@ -8,7 +8,8 @@ import {
   HaloInvitationsService,
   SpaceInvitationsService,
   SpacesService,
-  DevicesService
+  DevicesService,
+  NetworkService
 } from '@dxos/protocols/proto/dxos/client/services';
 import { DevtoolsHost, TracingService } from '@dxos/protocols/proto/dxos/devtools/host';
 import { DataService } from '@dxos/protocols/proto/dxos/echo/service';
@@ -25,6 +26,8 @@ export type ClientServices = {
   SpaceInvitationsService: SpaceInvitationsService;
   SpacesService: SpacesService;
 
+  NetworkService: NetworkService;
+
   // TODO(burdon): Deprecated.
   SpaceService: SpaceService;
   DataService: DataService;
@@ -53,6 +56,7 @@ export const clientServiceBundle = createServiceBundle<ClientServices>({
   DevicesService: schema.getService('dxos.client.services.DevicesService'),
   SpaceInvitationsService: schema.getService('dxos.client.services.SpaceInvitationsService'),
   SpacesService: schema.getService('dxos.client.services.SpacesService'),
+  NetworkService: schema.getService('dxos.client.services.NetworkService'),
 
   // TODO(burdon): Deprecated.
   SpaceService: schema.getService('dxos.client.SpaceService'),

package/src/packlets/services/service-host.test.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { latch } from '@dxos/async';
+import { Config } from '@dxos/config';
+import { MemorySignalManagerContext } from '@dxos/messaging';
+import { afterTest, describe, test } from '@dxos/test';
+
+import { createServiceHost } from '../testing';
+
+describe('ClientServicesHost', () => {
+  test('queryCredentials', async () => {
+    const host = createServiceHost(new Config(), new MemorySignalManagerContext());
+    await host.open();
+    afterTest(() => host.close());
+
+    await host.services.ProfileService.createProfile({});
+    const { publicKey: spaceKey } = await host.services.SpaceService.createSpace();
+
+    const stream = host.services.SpacesService.queryCredentials({ spaceKey });
+    const [done, tick] = latch({ count: 3 });
+    stream.subscribe((credential) => {
+      tick();
+      // console.log(credential);
+    });
+    afterTest(() => stream.close());
+
+    await done();
+  });
+});

package/src/packlets/services/service-host.ts

@@ -9,12 +9,14 @@ import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import { ObjectModel } from '@dxos/object-model';
+import { Storage } from '@dxos/random-access-storage';
 import { TextModel } from '@dxos/text-model';
 
 import { SpaceServiceImpl, ProfileServiceImpl, SystemServiceImpl, TracingServiceImpl } from '../deprecated';
 import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
 import { DevicesServiceImpl } from '../identity/devices-service-impl';
 import { HaloInvitationsServiceImpl, SpaceInvitationsServiceImpl } from '../invitations';
+import { NetworkServiceImpl } from '../network';
 import { SpacesServiceImpl } from '../spaces';
 import { createStorageObjects } from '../storage';
 import { ServiceContext } from './service-context';
@@ -31,6 +33,7 @@ type ClientServicesHostParams = {
   config: Config;
   modelFactory?: ModelFactory;
   networkManager: NetworkManager;
+  storage?: Storage;
 };
 
 /**
@@ -43,16 +46,19 @@ export class ClientServicesHost implements ClientServicesProvider {
   private readonly _config: Config;
   private readonly _modelFactory: ModelFactory;
   private readonly _networkManager: NetworkManager;
+  private _storage: Storage;
 
   constructor({
     config,
     modelFactory = createDefaultModelFactory(),
     // TODO(burdon): Create ApolloLink abstraction (see Client).
-    networkManager
+    networkManager,
+    storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage
   }: ClientServicesHostParams) {
     this._config = config;
     this._modelFactory = modelFactory;
     this._networkManager = networkManager;
+    this._storage = storage;
   }
 
   get descriptors() {
@@ -64,11 +70,10 @@ export class ClientServicesHost implements ClientServicesProvider {
   }
 
   async open() {
-    await this._initialize();
-    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
-    log('opening...', { deviceKey });
+    log('opening...');
     await this._initialize();
     await this._serviceContext.open();
+    const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
     log('opened', { deviceKey });
   }
 
@@ -81,11 +86,8 @@ export class ClientServicesHost implements ClientServicesProvider {
 
   // TODO(burdon): Move into open.
   async _initialize() {
-    // TODO(dmaretskyi): Remove keyStorage.
-    const { storage } = createStorageObjects(this._config.get('runtime.client.storage', {})!);
-
     // TODO(burdon): Break into components.
-    this._serviceContext = new ServiceContext(storage, this._networkManager, this._modelFactory);
+    this._serviceContext = new ServiceContext(this._storage, this._networkManager, this._modelFactory);
 
     // TODO(burdon): Start to think of DMG (dynamic services).
     this._serviceRegistry = new ServiceRegistry<ClientServices>(clientServiceBundle, {
@@ -102,10 +104,12 @@ export class ClientServicesHost implements ClientServicesProvider {
         () => this._serviceContext.dataSpaceManager ?? raise(new Error('SpaceManager not initialized'))
       ),
 
-      SpacesService: new SpacesServiceImpl(),
+      SpacesService: new SpacesServiceImpl(this._serviceContext.spaceManager),
 
       DataService: new DataServiceImpl(this._serviceContext.dataServiceSubscriptions),
 
+      NetworkService: new NetworkServiceImpl(this._serviceContext.networkManager),
+
       // TODO(burdon): Move to new protobuf definitions.
       ProfileService: new ProfileServiceImpl(this._serviceContext),
       SpaceService: new SpaceServiceImpl(this._serviceContext),

package/src/packlets/spaces/data-space-manager.ts

@@ -2,15 +2,18 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Event, synchronized } from '@dxos/async';
+import { Event, synchronized, trackLeaks } from '@dxos/async';
+import { Context } from '@dxos/context';
 import {
   AcceptSpaceOptions,
   DataServiceSubscriptions,
   MetadataStore,
   SigningContext,
+  SnapshotStore,
   Space,
+  spaceGenesis,
   SpaceManager,
-  spaceGenesis
+  SnapshotManager
 } from '@dxos/echo-db';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
@@ -22,7 +25,10 @@ import { ComplexMap } from '@dxos/util';
 
 import { DataSpace } from './data-space';
 
+@trackLeaks('open', 'close')
 export class DataSpaceManager {
+  private readonly _ctx = new Context();
+
   public readonly updated = new Event();
 
   private readonly _spaces = new ComplexMap<PublicKey, DataSpace>(PublicKey.hash);
@@ -33,7 +39,8 @@ export class DataSpaceManager {
     private readonly _dataServiceSubscriptions: DataServiceSubscriptions,
     private readonly _keyring: Keyring,
     private readonly _signingContext: SigningContext,
-    private readonly _modelFactory: ModelFactory
+    private readonly _modelFactory: ModelFactory,
+    private readonly _snapshotStore: SnapshotStore
   ) {}
 
   // TODO(burdon): Remove.
@@ -44,18 +51,30 @@ export class DataSpaceManager {
   @synchronized
   async open() {
     await this._metadataStore.load();
+    log('metadata loaded', { spaces: this._metadataStore.spaces.length });
 
     for (const spaceMetadata of this._metadataStore.spaces) {
-      await this._constructSpace(spaceMetadata);
+      log('load space', { spaceMetadata });
+      const space = await this._constructSpace(spaceMetadata);
+      if (spaceMetadata.latestTimeframe) {
+        log('waiting for latest timeframe', { spaceMetadata });
+        await space.dataPipelineController.waitUntilTimeframe(spaceMetadata.latestTimeframe);
+      }
     }
   }
 
   @synchronized
-  async close() {}
+  async close() {
+    await this._ctx.dispose();
+    for (const space of this._spaces.values()) {
+      await space.close();
+    }
+  }
 
   /**
    * Creates a new space writing the genesis credentials to the control feed.
    */
+  @synchronized
   async createSpace() {
     const spaceKey = await this._keyring.createKey();
     const controlFeedKey = await this._keyring.createKey();
@@ -78,6 +97,7 @@ export class DataSpaceManager {
   }
 
   // TODO(burdon): Rename join space.
+  @synchronized
   async acceptSpace(opts: AcceptSpaceOptions): Promise<DataSpace> {
     const metadata: SpaceMetadata = {
       key: opts.spaceKey,
@@ -99,6 +119,8 @@ export class DataSpaceManager {
       offlineTimeout: 30_000,
       identityKey: this._signingContext.identityKey
     });
+    const snapshotManager = new SnapshotManager(this._snapshotStore);
+
     const space: Space = await this._spaceManager.constructSpace({
       metadata,
       swarmIdentity: {
@@ -106,11 +128,26 @@ export class DataSpaceManager {
         credentialProvider: this._signingContext.credentialProvider,
         credentialAuthenticator: this._signingContext.credentialAuthenticator
       },
-      dataPipelineControllerProvider: () => dataSpace.dataPipelineController,
-      presence
+      onNetworkConnection: (session) => {
+        session.addExtension(
+          'dxos.mesh.teleport.presence',
+          presence.createExtension({ remotePeerId: session.remotePeerId })
+        );
+        session.addExtension('dxos.mesh.teleport.objectsync', snapshotManager.objectSync.createExtension());
+      }
+    });
+
+    const dataSpace = new DataSpace({
+      inner: space,
+      modelFactory: this._modelFactory,
+      metadataStore: this._metadataStore,
+      snapshotManager,
+      presence,
+      memberKey: this._signingContext.identityKey,
+      snapshotId: metadata.snapshot
     });
-    const dataSpace = new DataSpace(space, this._modelFactory, this._signingContext.identityKey, presence);
-    await space.open();
+
+    await dataSpace.open();
     this._dataServiceSubscriptions.registerSpace(space.key, dataSpace.database.createDataServiceHost());
     this._spaces.set(metadata.key, dataSpace);
     return dataSpace;