@dxos/client-services 0.5.9-main.4ed8273 → 0.5.9-main.72c50cd

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

@@ -24,7 +24,11 @@ describe('IdentityService', () => {
   beforeEach(async () => {
     serviceContext = await createServiceContext();
     await serviceContext.open(new Context());
-    identityService = createIdentityService(serviceContext);
+    identityService = new IdentityServiceImpl(
+      (options) => serviceContext.createIdentity(options),
+      serviceContext.identityManager,
+      serviceContext.keyring,
+    );
   });
 
   afterEach(async () => {
@@ -91,37 +95,3 @@ describe('IdentityService', () => {
     });
   });
 });
-
-describe('open', () => {
-  test('identity without default space fixed', async () => {
-    const serviceContext = await createServiceContext();
-    await serviceContext.open(new Context());
-    const identity = await serviceContext.createIdentity();
-    const identityService = createIdentityService(serviceContext);
-    const getDataSpaces = () => [...(serviceContext.dataSpaceManager?.spaces?.values() ?? [])];
-    expect(getDataSpaces().length).to.eq(0);
-    expect(identity.defaultSpaceId).to.be.undefined;
-    await identityService.open();
-    expect(getDataSpaces()[0].id === identity.defaultSpaceId).to.be.true;
-  });
-
-  test('identity without default space credential fixed', async () => {
-    const serviceContext = await createServiceContext();
-    await serviceContext.open(new Context());
-    const identity = await serviceContext.createIdentity();
-    const space = await serviceContext.dataSpaceManager!.createDefaultSpace();
-    const identityService = createIdentityService(serviceContext);
-    expect(identity.defaultSpaceId).to.be.undefined;
-    await identityService.open();
-    expect(identity.defaultSpaceId === space.id).to.be.true;
-  });
-});
-
-const createIdentityService = (serviceContext: ServiceContext) => {
-  return new IdentityServiceImpl(
-    serviceContext.identityManager,
-    serviceContext.keyring,
-    () => serviceContext.dataSpaceManager!,
-    (options) => serviceContext.createIdentity(options),
-  );
-};

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

@@ -3,59 +3,36 @@
 //
 
 import { Stream } from '@dxos/codec-protobuf';
-import { Resource } from '@dxos/context';
 import { signPresentation } from '@dxos/credentials';
 import { todo } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import {
   type CreateIdentityRequest,
-  type Identity as IdentityProto,
+  type Identity,
   type IdentityService,
   type QueryIdentityResponse,
   type RecoverIdentityRequest,
   type SignPresentationRequest,
-  SpaceState,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Presentation, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 
-import { type Identity } from './identity';
 import { type CreateIdentityOptions, type IdentityManager } from './identity-manager';
-import { type DataSpaceManager } from '../spaces';
 
-export class IdentityServiceImpl extends Resource implements IdentityService {
+export class IdentityServiceImpl implements IdentityService {
   constructor(
+    private readonly _createIdentity: (params: CreateIdentityOptions) => Promise<Identity>,
     private readonly _identityManager: IdentityManager,
     private readonly _keyring: Keyring,
-    private readonly _dataSpaceManagerProvider: () => DataSpaceManager,
-    private readonly _createIdentity: (params: CreateIdentityOptions) => Promise<Identity>,
     private readonly _onProfileUpdate?: (profile: ProfileDocument | undefined) => Promise<void>,
-  ) {
-    super();
-  }
-
-  protected override async _open() {
-    const identity = this._identityManager.identity;
-    if (identity && !identity.defaultSpaceId) {
-      await this._fixIdentityWithoutDefaultSpace(identity);
-    }
-  }
+  ) {}
 
-  async createIdentity(request: CreateIdentityRequest): Promise<IdentityProto> {
+  async createIdentity(request: CreateIdentityRequest): Promise<Identity> {
     await this._createIdentity({ displayName: request.profile?.displayName, deviceProfile: request.deviceProfile });
-    const dataSpaceManager = this._dataSpaceManagerProvider();
-    await this._createDefaultSpace(dataSpaceManager);
     return this._getIdentity()!;
   }
 
-  private async _createDefaultSpace(dataSpaceManager: DataSpaceManager) {
-    const space = await dataSpaceManager!.createDefaultSpace();
-    const identity = this._identityManager.identity;
-    invariant(identity);
-    await identity.updateDefaultSpace(space.id);
-  }
-
-  async recoverIdentity(request: RecoverIdentityRequest): Promise<IdentityProto> {
+  async recoverIdentity(request: RecoverIdentityRequest): Promise<Identity> {
     return todo();
   }
 
@@ -68,7 +45,7 @@ export class IdentityServiceImpl extends Resource implements IdentityService {
     });
   }
 
-  private _getIdentity(): IdentityProto | undefined {
+  private _getIdentity(): Identity | undefined {
     if (!this._identityManager.identity) {
       return undefined;
     }
@@ -80,7 +57,7 @@ export class IdentityServiceImpl extends Resource implements IdentityService {
     };
   }
 
-  async updateProfile(profile: ProfileDocument): Promise<IdentityProto> {
+  async updateProfile(profile: ProfileDocument): Promise<Identity> {
     invariant(this._identityManager.identity, 'Identity not initialized.');
     await this._identityManager.updateProfile(profile);
     await this._onProfileUpdate?.(this._identityManager.identity.profileDocument);
@@ -98,23 +75,4 @@ export class IdentityServiceImpl extends Resource implements IdentityService {
       nonce,
     });
   }
-
-  private async _fixIdentityWithoutDefaultSpace(identity: Identity) {
-    let hasDefaultSpace = false;
-    const dataSpaceManager = this._dataSpaceManagerProvider();
-    for (const space of dataSpaceManager.spaces.values()) {
-      if (space.state === SpaceState.CLOSED) {
-        await space.open();
-        await space.initializeDataPipeline();
-      }
-      if (await dataSpaceManager.isDefaultSpace(space)) {
-        await identity.updateDefaultSpace(space.id);
-        hasDefaultSpace = true;
-        break;
-      }
-    }
-    if (!hasDefaultSpace) {
-      await this._createDefaultSpace(dataSpaceManager);
-    }
-  }
 }

package/src/packlets/identity/identity.ts

@@ -16,7 +16,7 @@ import { type Signer } from '@dxos/crypto';
 import { type Space } from '@dxos/echo-pipeline';
 import { writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
-import { PublicKey, type SpaceId } from '@dxos/keys';
+import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import {
@@ -26,12 +26,10 @@ import {
 } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type DeviceAdmissionRequest } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type Presence } from '@dxos/teleport-extension-gossip';
-import { Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
 import { type ComplexMap, ComplexSet } from '@dxos/util';
 
 import { TrustedKeySetAuthVerifier } from './authenticator';
-import { DefaultSpaceStateMachine } from './default-space-state-machine';
 
 export type IdentityParams = {
   identityKey: PublicKey;
@@ -51,7 +49,6 @@ export class Identity {
   private readonly _presence?: Presence;
   private readonly _deviceStateMachine: DeviceStateMachine;
   private readonly _profileStateMachine: ProfileStateMachine;
-  private readonly _defaultSpaceStateMachine: DefaultSpaceStateMachine;
   public readonly authVerifier: TrustedKeySetAuthVerifier;
 
   public readonly identityKey: PublicKey;
@@ -78,10 +75,6 @@ export class Identity {
       identityKey: this.identityKey,
       onUpdate: () => this.stateUpdate.emit(),
     });
-    this._defaultSpaceStateMachine = new DefaultSpaceStateMachine({
-      identityKey: this.identityKey,
-      onUpdate: () => this.stateUpdate.emit(),
-    });
 
     this.authVerifier = new TrustedKeySetAuthVerifier({
       trustedKeysProvider: () => new ComplexSet(PublicKey.hash, this.authorizedDeviceKeys.keys()),
@@ -95,24 +88,17 @@ export class Identity {
     return this._deviceStateMachine.authorizedDeviceKeys;
   }
 
-  get defaultSpaceId(): SpaceId | undefined {
-    return this._defaultSpaceStateMachine.spaceId;
-  }
-
   @trace.span()
   async open(ctx: Context) {
-    await this._presence?.open();
     await this.space.spaceState.addCredentialProcessor(this._deviceStateMachine);
     await this.space.spaceState.addCredentialProcessor(this._profileStateMachine);
-    await this.space.spaceState.addCredentialProcessor(this._defaultSpaceStateMachine);
     await this.space.open(ctx);
   }
 
   @trace.span()
   async close(ctx: Context) {
-    await this._presence?.close();
+    await this._presence?.destroy();
     await this.authVerifier.close();
-    await this.space.spaceState.removeCredentialProcessor(this._defaultSpaceStateMachine);
     await this.space.spaceState.removeCredentialProcessor(this._profileStateMachine);
     await this.space.spaceState.removeCredentialProcessor(this._deviceStateMachine);
     await this.space.close();
@@ -171,15 +157,6 @@ export class Identity {
     return createCredentialSignerWithKey(this._signer, this.deviceKey);
   }
 
-  async updateDefaultSpace(spaceId: SpaceId) {
-    const credential = await this.getDeviceCredentialSigner().createCredential({
-      subject: this.identityKey,
-      assertion: { '@type': 'dxos.halo.credentials.DefaultSpace', spaceId },
-    });
-    const receipt = await this.controlPipeline.writer.write({ credential: { credential } });
-    await this.controlPipeline.state.waitUntilTimeframe(new Timeframe([[receipt.feedKey, receipt.seq]]));
-  }
-
   async admitDevice({ deviceKey, controlFeedKey, dataFeedKey }: DeviceAdmissionRequest) {
     log('Admitting device:', {
       identityKey: this.identityKey,

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

@@ -3,9 +3,11 @@
 //
 
 import { Event, synchronized } from '@dxos/async';
-import { clientServiceBundle, type ClientServices } from '@dxos/client-protocol';
+import { clientServiceBundle, defaultKey, type ClientServices, PropertiesType } from '@dxos/client-protocol';
 import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
+import { type ObjectStructure, encodeReference, type SpaceDoc } from '@dxos/echo-protocol';
+import { getTypeReference } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { type LevelDB } from '@dxos/kv-store';
@@ -16,6 +18,7 @@ import { trace } from '@dxos/protocols';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { type Storage } from '@dxos/random-access-storage';
 import { TRACE_PROCESSOR, trace as Trace } from '@dxos/tracing';
+import { assignDeep } from '@dxos/util';
 import { WebsocketRpcClient } from '@dxos/websocket-rpc';
 
 import { ServiceContext, type ServiceContextRuntimeParams } from './service-context';
@@ -83,7 +86,7 @@ export class ClientServicesHost {
   private _devtoolsProxy?: WebsocketRpcClient<{}, ClientServices>;
 
   private _serviceContext!: ServiceContext;
-  private readonly _runtimeParams: ServiceContextRuntimeParams;
+  private readonly _runtimeParams?: ServiceContextRuntimeParams;
   private diagnosticsBroadcastHandler: CollectDiagnosticsBroadcastHandler;
 
   @Trace.info()
@@ -106,7 +109,7 @@ export class ClientServicesHost {
     this._storage = storage;
     this._level = level;
     this._callbacks = callbacks;
-    this._runtimeParams = runtimeParams ?? {};
+    this._runtimeParams = runtimeParams;
 
     if (config) {
       this.initialize({ config, transportFactory, signalManager });
@@ -251,17 +254,15 @@ export class ClientServicesHost {
       this._runtimeParams,
     );
 
-    const identityService = new IdentityServiceImpl(
-      this._serviceContext.identityManager,
-      this._serviceContext.keyring,
-      () => this._serviceContext.dataSpaceManager!,
-      (params) => this._createIdentity(params),
-      (profile) => this._serviceContext.broadcastProfileUpdate(profile),
-    );
-
     this._serviceRegistry.setServices({
       SystemService: this._systemService,
-      IdentityService: identityService,
+
+      IdentityService: new IdentityServiceImpl(
+        (params) => this._createIdentity(params),
+        this._serviceContext.identityManager,
+        this._serviceContext.keyring,
+        (profile) => this._serviceContext.broadcastProfileUpdate(profile),
+      ),
 
       InvitationsService: new InvitationsServiceImpl(this._serviceContext.invitationsManager),
 
@@ -293,7 +294,6 @@ export class ClientServicesHost {
     });
 
     await this._serviceContext.open(ctx);
-    await identityService.open();
 
     const devtoolsProxy = this._config?.get('runtime.client.devtoolsProxy');
     if (devtoolsProxy) {
@@ -349,7 +349,34 @@ export class ClientServicesHost {
 
   private async _createIdentity(params: CreateIdentityOptions) {
     const identity = await this._serviceContext.createIdentity(params);
+
+    // Setup default space.
     await this._serviceContext.initialized.wait();
+    const space = await this._serviceContext.dataSpaceManager!.createSpace();
+
+    const automergeIndex = space.automergeSpaceState.rootUrl;
+    invariant(automergeIndex);
+    const document = this._serviceContext.echoHost.automergeRepo.find<SpaceDoc>(automergeIndex as any);
+    await document.whenReady();
+
+    // TODO(dmaretskyi): Better API for low-level data access.
+    const properties: ObjectStructure = {
+      system: {
+        type: encodeReference(getTypeReference(PropertiesType)!),
+      },
+      data: {
+        [defaultKey]: identity.identityKey.toHex(),
+      },
+      meta: {
+        keys: [],
+      },
+    };
+    const propertiesId = PublicKey.random().toHex();
+    document.change((doc: SpaceDoc) => {
+      assignDeep(doc, ['objects', propertiesId], properties);
+    });
+
+    await this._serviceContext.echoHost.flush();
     return identity;
   }
 }

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

@@ -12,7 +12,7 @@ import { log } from '@dxos/log';
 import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, openAndClose, test } from '@dxos/test';
 
-import { TestBuilder, type TestPeer } from '../testing';
+import { TestBuilder } from '../testing';
 
 describe('DataSpaceManager', () => {
   test('create space', async () => {
@@ -168,50 +168,5 @@ describe('DataSpaceManager', () => {
         500,
       );
     });
-
-    test('activate opens a lazily loaded space', async () => {
-      const builder = new TestBuilder();
-
-      const peer = builder.createPeer();
-      await peer.createIdentity();
-      await openAndClose(peer.echoHost, peer.dataSpaceManager);
-
-      await peer.dataSpaceManager.createSpace();
-      await reloadDataSpaces(peer);
-
-      const space = getFirstSpace(peer);
-      expect(space.state).to.equal(SpaceState.CLOSED);
-      await space.activate();
-      await asyncTimeout(
-        space.stateUpdate.waitForCondition(() => space.state === SpaceState.READY),
-        500,
-      );
-    });
-
-    test('deactivate lazily loaded space ', async () => {
-      const builder = new TestBuilder();
-
-      const peer = builder.createPeer();
-      await peer.createIdentity();
-      await openAndClose(peer.echoHost, peer.dataSpaceManager);
-
-      await peer.dataSpaceManager.createSpace();
-      await reloadDataSpaces(peer);
-
-      await getFirstSpace(peer).deactivate();
-
-      await reloadDataSpaces(peer);
-
-      expect(getFirstSpace(peer).state).to.eq(SpaceState.INACTIVE);
-    });
   });
-
-  const reloadDataSpaces = async (peer: TestPeer) => {
-    await peer.dataSpaceManager.close();
-    await peer.dataSpaceManager.open();
-  };
-
-  const getFirstSpace = (peer: TestPeer) => {
-    return Array.from(peer.dataSpaceManager.spaces.values())[0];
-  };
 });

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

@@ -4,8 +4,7 @@
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { type Doc } from '@dxos/automerge/automerge';
-import { type DocHandle, type AutomergeUrl } from '@dxos/automerge/automerge-repo';
-import { PropertiesType } from '@dxos/client-protocol';
+import { type AutomergeUrl } from '@dxos/automerge/automerge-repo';
 import { cancelWithContext, Context } from '@dxos/context';
 import {
   type CredentialSigner,
@@ -22,8 +21,7 @@ import {
   type SpaceProtocol,
   type SpaceProtocolSession,
 } from '@dxos/echo-pipeline';
-import { encodeReference, type ObjectStructure, type SpaceDoc } from '@dxos/echo-protocol';
-import { getTypeReference } from '@dxos/echo-schema';
+import { type SpaceDoc } from '@dxos/echo-protocol';
 import { type FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -39,7 +37,7 @@ import { type PeerState } from '@dxos/protocols/proto/dxos/mesh/presence';
 import { Gossip, Presence } from '@dxos/teleport-extension-gossip';
 import { type Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
-import { assignDeep, ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
+import { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
 
 import { DataSpace, findPropertiesObject } from './data-space';
 import { spaceGenesis } from './genesis';
@@ -49,9 +47,6 @@ import { type InvitationsManager } from '../invitations';
 const PRESENCE_ANNOUNCE_INTERVAL = 10_000;
 const PRESENCE_OFFLINE_TIMEOUT = 20_000;
 
-// Space properties key for default metadata.
-const DEFAULT_SPACE_KEY = '__DEFAULT__';
-
 export interface SigningContext {
   identityKey: PublicKey;
   deviceKey: PublicKey;
@@ -93,6 +88,8 @@ export class DataSpaceManager {
 
   private _isOpen = false;
   private readonly _instanceId = PublicKey.random().toHex();
+  private readonly _spaceMemberPresenceAnnounceInterval: number;
+  private readonly _spaceMemberPresenceOfflineTimeout: number;
 
   constructor(
     private readonly _spaceManager: SpaceManager,
@@ -102,8 +99,15 @@ export class DataSpaceManager {
     private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _echoHost: EchoHost,
     private readonly _invitationsManager: InvitationsManager,
-    private readonly _params?: DataSpaceManagerRuntimeParams,
+    params?: DataSpaceManagerRuntimeParams,
   ) {
+    const {
+      spaceMemberPresenceAnnounceInterval = PRESENCE_ANNOUNCE_INTERVAL,
+      spaceMemberPresenceOfflineTimeout = PRESENCE_OFFLINE_TIMEOUT,
+    } = params ?? {};
+    this._spaceMemberPresenceAnnounceInterval = spaceMemberPresenceAnnounceInterval;
+    this._spaceMemberPresenceOfflineTimeout = spaceMemberPresenceOfflineTimeout;
+
     trace.diagnostic({
       id: 'spaces',
       name: 'Spaces',
@@ -153,6 +157,12 @@ export class DataSpaceManager {
     this._isOpen = true;
     this.updated.emit();
 
+    for (const space of this._spaces.values()) {
+      if (space.state !== SpaceState.INACTIVE) {
+        space.initializeDataPipelineAsync();
+      }
+    }
+
     log.trace('dxos.echo.data-space-manager.open', Trace.end({ id: this._instanceId }));
   }
 
@@ -164,7 +174,6 @@ export class DataSpaceManager {
     for (const space of this._spaces.values()) {
       await space.close();
     }
-    this._spaces.clear();
   }
 
   /**
@@ -188,7 +197,6 @@ export class DataSpaceManager {
 
     const root = await this._echoHost.createSpaceRoot(spaceKey);
     const space = await this._constructSpace(metadata);
-    await space.open();
 
     const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner, root.url);
     await this._metadataStore.addSpace(metadata);
@@ -203,46 +211,6 @@ export class DataSpaceManager {
     return space;
   }
 
-  async isDefaultSpace(space: DataSpace): Promise<boolean> {
-    const rootDoc = await this._getSpaceRootDocument(space);
-    const [_, properties] = findPropertiesObject(rootDoc.docSync()) ?? [];
-    return properties?.data?.[DEFAULT_SPACE_KEY] === this._signingContext.identityKey.toHex();
-  }
-
-  async createDefaultSpace() {
-    const space = await this.createSpace();
-    const document = await this._getSpaceRootDocument(space);
-
-    // TODO(dmaretskyi): Better API for low-level data access.
-    const properties: ObjectStructure = {
-      system: {
-        type: encodeReference(getTypeReference(PropertiesType)!),
-      },
-      data: {
-        [DEFAULT_SPACE_KEY]: this._signingContext.identityKey.toHex(),
-      },
-      meta: {
-        keys: [],
-      },
-    };
-
-    const propertiesId = PublicKey.random().toHex();
-    document.change((doc: SpaceDoc) => {
-      assignDeep(doc, ['objects', propertiesId], properties);
-    });
-
-    await this._echoHost.flush();
-    return space;
-  }
-
-  private async _getSpaceRootDocument(space: DataSpace): Promise<DocHandle<SpaceDoc>> {
-    const automergeIndex = space.automergeSpaceState.rootUrl;
-    invariant(automergeIndex);
-    const document = this._echoHost.automergeRepo.find<SpaceDoc>(automergeIndex as any);
-    await document.whenReady();
-    return document;
-  }
-
   // TODO(burdon): Rename join space.
   @synchronized
   async acceptSpace(opts: AcceptSpaceOptions): Promise<DataSpace> {
@@ -258,7 +226,6 @@ export class DataSpaceManager {
     };
 
     const space = await this._constructSpace(metadata);
-    await space.open();
     await this._metadataStore.addSpace(metadata);
     space.initializeDataPipelineAsync();
 
@@ -287,8 +254,8 @@ export class DataSpaceManager {
       localPeerId: this._signingContext.deviceKey,
     });
     const presence = new Presence({
-      announceInterval: this._params?.spaceMemberPresenceAnnounceInterval ?? PRESENCE_ANNOUNCE_INTERVAL,
-      offlineTimeout: this._params?.spaceMemberPresenceOfflineTimeout ?? PRESENCE_OFFLINE_TIMEOUT,
+      announceInterval: this._spaceMemberPresenceAnnounceInterval,
+      offlineTimeout: this._spaceMemberPresenceOfflineTimeout,
       identityKey: this._signingContext.identityKey,
       gossip,
     });
@@ -369,6 +336,10 @@ export class DataSpaceManager {
       }
     });
 
+    if (metadata.state !== SpaceState.INACTIVE) {
+      await dataSpace.open();
+    }
+
     if (metadata.controlTimeframe) {
       dataSpace.inner.controlPipeline.state.setTargetTimeframe(metadata.controlTimeframe);
     }

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

@@ -193,13 +193,10 @@ export class DataSpace {
 
   @synchronized
   async open() {
-    if (this._state === SpaceState.CLOSED) {
-      await this._open();
-    }
+    await this._open();
   }
 
   private async _open() {
-    await this._presence.open();
     await this._gossip.open();
     await this._notarizationPlugin.open();
     await this._inner.spaceState.addCredentialProcessor(this._notarizationPlugin);
@@ -231,7 +228,7 @@ export class DataSpace {
     await this._inner.spaceState.removeCredentialProcessor(this._notarizationPlugin);
     await this._notarizationPlugin.close();
 
-    await this._presence.close();
+    await this._presence.destroy();
     await this._gossip.close();
   }
 
@@ -456,7 +453,6 @@ export class DataSpace {
           const rootHandle = this._echoHost.automergeRepo.find(currentRootUrl as any);
           await cancelWithContext(this._ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
           const newRoot = this._echoHost.automergeRepo.create(rootHandle.docSync());
-          await this._echoHost.automergeRepo.flush([newRoot.documentId]);
           invariant(typeof newRoot.url === 'string' && newRoot.url.length > 0);
           // TODO(dmaretskyi): Unify epoch construction.
           epoch = {
@@ -548,7 +544,7 @@ export class DataSpace {
 
   @synchronized
   async activate() {
-    if (![SpaceState.CLOSED, SpaceState.INACTIVE].includes(this._state)) {
+    if (this._state !== SpaceState.INACTIVE) {
       return;
     }
 
@@ -562,11 +558,10 @@ export class DataSpace {
     if (this._state === SpaceState.INACTIVE) {
       return;
     }
+
     // Unregister from data service.
     await this._metadataStore.setSpaceState(this.key, SpaceState.INACTIVE);
-    if (this._state !== SpaceState.CLOSED) {
-      await this._close();
-    }
+    await this._close();
     this._state = SpaceState.INACTIVE;
     log('new state', { state: SpaceState[this._state] });
     this.stateUpdate.emit();