@dxos/client-services 0.5.9-main.ea1d25b → 0.5.9-main.f099efe

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

@@ -4,15 +4,17 @@
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { type Doc } from '@dxos/automerge/automerge';
-import { type AutomergeUrl } from '@dxos/automerge/automerge-repo';
-import { cancelWithContext, Context } from '@dxos/context';
+import { type AutomergeUrl, type DocHandle } from '@dxos/automerge/automerge-repo';
+import { PropertiesType } from '@dxos/client-protocol';
+import { Context, cancelWithContext } from '@dxos/context';
 import {
+  getCredentialAssertion,
   type CredentialSigner,
   type DelegateInvitationCredential,
-  getCredentialAssertion,
+  createAdmissionCredentials,
   type MemberInfo,
 } from '@dxos/credentials';
-import { type EchoHost } from '@dxos/echo-db';
+import { convertLegacyReferences, findInlineObjectOfType, type EchoHost } from '@dxos/echo-db';
 import {
   AuthStatus,
   type MetadataStore,
@@ -21,25 +23,33 @@ import {
   type SpaceProtocol,
   type SpaceProtocolSession,
 } from '@dxos/echo-pipeline';
-import { type SpaceDoc } from '@dxos/echo-protocol';
-import { type FeedStore } from '@dxos/feed-store';
+import { CredentialServerExtension } from '@dxos/echo-pipeline';
+import {
+  LEGACY_TYPE_PROPERTIES,
+  SpaceDocVersion,
+  encodeReference,
+  type ObjectStructure,
+  type SpaceDoc,
+} from '@dxos/echo-protocol';
+import { TYPE_PROPERTIES, generateEchoId, getTypeReference } from '@dxos/echo-schema';
+import { type FeedStore, writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { trace as Trace } from '@dxos/protocols';
+import { trace as Trace, AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation, SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
-import { type Credential, type ProfileDocument, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { SpaceMember, type Credential, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type DelegateSpaceInvitation } from '@dxos/protocols/proto/dxos/halo/invitations';
 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 { ComplexMap, deferFunction, forEachAsync } from '@dxos/util';
+import { ComplexMap, assignDeep, deferFunction, forEachAsync } from '@dxos/util';
 
-import { DataSpace, findPropertiesObject } from './data-space';
+import { DataSpace } from './data-space';
 import { spaceGenesis } from './genesis';
 import { createAuthProvider } from '../identity';
 import { type InvitationsManager } from '../invitations';
@@ -47,6 +57,9 @@ 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;
@@ -73,6 +86,14 @@ export type AcceptSpaceOptions = {
   dataTimeframe?: Timeframe;
 };
 
+export type AdmitMemberOptions = {
+  spaceKey: PublicKey;
+  identityKey: PublicKey;
+  role: SpaceMember.Role;
+  profile?: ProfileDocument;
+  delegationCredentialId?: PublicKey;
+};
+
 export type DataSpaceManagerRuntimeParams = {
   spaceMemberPresenceAnnounceInterval?: number;
   spaceMemberPresenceOfflineTimeout?: number;
@@ -88,8 +109,6 @@ 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,
@@ -99,15 +118,8 @@ export class DataSpaceManager {
     private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _echoHost: EchoHost,
     private readonly _invitationsManager: InvitationsManager,
-    params?: DataSpaceManagerRuntimeParams,
+    private readonly _params?: DataSpaceManagerRuntimeParams,
   ) {
-    const {
-      spaceMemberPresenceAnnounceInterval = PRESENCE_ANNOUNCE_INTERVAL,
-      spaceMemberPresenceOfflineTimeout = PRESENCE_OFFLINE_TIMEOUT,
-    } = params ?? {};
-    this._spaceMemberPresenceAnnounceInterval = spaceMemberPresenceAnnounceInterval;
-    this._spaceMemberPresenceOfflineTimeout = spaceMemberPresenceOfflineTimeout;
-
     trace.diagnostic({
       id: 'spaces',
       name: 'Spaces',
@@ -117,7 +129,7 @@ export class DataSpaceManager {
           const rootHandle = rootUrl ? this._echoHost.automergeRepo.find(rootUrl as AutomergeUrl) : undefined;
           const rootDoc = rootHandle?.docSync() as Doc<SpaceDoc> | undefined;
 
-          const properties = rootDoc && findPropertiesObject(rootDoc);
+          const properties = rootDoc && findInlineObjectOfType(rootDoc, TYPE_PROPERTIES);
 
           return {
             key: space.key.toHex(),
@@ -157,12 +169,6 @@ 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 }));
   }
 
@@ -174,6 +180,7 @@ export class DataSpaceManager {
     for (const space of this._spaces.values()) {
       await space.close();
     }
+    this._spaces.clear();
   }
 
   /**
@@ -197,6 +204,7 @@ 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);
@@ -211,6 +219,61 @@ export class DataSpaceManager {
     return space;
   }
 
+  async isDefaultSpace(space: DataSpace): Promise<boolean> {
+    if (!space.databaseRoot) {
+      return false;
+    }
+    switch (space.databaseRoot.getVersion()) {
+      case SpaceDocVersion.CURRENT: {
+        const [_, properties] = findInlineObjectOfType(space.databaseRoot.docSync()!, TYPE_PROPERTIES) ?? [];
+        return properties?.data?.[DEFAULT_SPACE_KEY] === this._signingContext.identityKey.toHex();
+      }
+      case SpaceDocVersion.LEGACY: {
+        const convertedDoc = await convertLegacyReferences(space.databaseRoot.docSync()!);
+        const [_, properties] = findInlineObjectOfType(convertedDoc, LEGACY_TYPE_PROPERTIES) ?? [];
+        return properties?.data?.[DEFAULT_SPACE_KEY] === this._signingContext.identityKey.toHex();
+      }
+
+      default:
+        log.warn('unknown space version', { version: space.databaseRoot.getVersion(), spaceId: space.id });
+        return false;
+    }
+  }
+
+  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 = generateEchoId();
+    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> {
@@ -226,6 +289,7 @@ export class DataSpaceManager {
     };
 
     const space = await this._constructSpace(metadata);
+    await space.open();
     await this._metadataStore.addSpace(metadata);
     space.initializeDataPipelineAsync();
 
@@ -233,6 +297,35 @@ export class DataSpaceManager {
     return space;
   }
 
+  async admitMember(options: AdmitMemberOptions): Promise<Credential> {
+    const space = this._spaceManager.spaces.get(options.spaceKey);
+    invariant(space);
+
+    if (space.spaceState.getMemberRole(options.identityKey) !== SpaceMember.Role.REMOVED) {
+      throw new AlreadyJoinedError();
+    }
+
+    // TODO(burdon): Check if already admitted.
+    const credentials: FeedMessage.Payload[] = await createAdmissionCredentials(
+      this._signingContext.credentialSigner,
+      options.identityKey,
+      space.key,
+      space.genesisFeedKey,
+      options.role,
+      space.spaceState.membershipChainHeads,
+      options.profile,
+      options.delegationCredentialId,
+    );
+
+    // TODO(dmaretskyi): Refactor.
+    invariant(credentials[0].credential);
+    const spaceMemberCredential = credentials[0].credential.credential;
+    invariant(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+    await writeMessages(space.controlPipeline.writer, credentials);
+
+    return spaceMemberCredential;
+  }
+
   /**
    * Wait until the space data pipeline is fully initialized.
    * Used by invitation handler.
@@ -248,14 +341,27 @@ export class DataSpaceManager {
     );
   }
 
+  public async requestSpaceAdmissionCredential(spaceKey: PublicKey): Promise<Credential> {
+    return this._spaceManager.requestSpaceAdmissionCredential({
+      spaceKey,
+      identityKey: this._signingContext.identityKey,
+      timeout: 15_000,
+      swarmIdentity: {
+        peerKey: this._signingContext.deviceKey,
+        credentialProvider: createAuthProvider(this._signingContext.credentialSigner),
+        credentialAuthenticator: async () => true,
+      },
+    });
+  }
+
   private async _constructSpace(metadata: SpaceMetadata) {
     log('construct space', { metadata });
     const gossip = new Gossip({
       localPeerId: this._signingContext.deviceKey,
     });
     const presence = new Presence({
-      announceInterval: this._spaceMemberPresenceAnnounceInterval,
-      offlineTimeout: this._spaceMemberPresenceOfflineTimeout,
+      announceInterval: this._params?.spaceMemberPresenceAnnounceInterval ?? PRESENCE_ANNOUNCE_INTERVAL,
+      offlineTimeout: this._params?.spaceMemberPresenceOfflineTimeout ?? PRESENCE_OFFLINE_TIMEOUT,
       identityKey: this._signingContext.identityKey,
       gossip,
     });
@@ -277,6 +383,7 @@ export class DataSpaceManager {
         credentialAuthenticator: deferFunction(() => dataSpace.authVerifier.verifier),
       },
       onAuthorizedConnection: (session) => {
+        session.addExtension('dxos.mesh.teleport.admission-discovery', new CredentialServerExtension(space));
         session.addExtension(
           'dxos.mesh.teleport.gossip',
           gossip.createExtension({ remotePeerId: session.remotePeerId }),
@@ -336,10 +443,6 @@ 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

@@ -2,27 +2,25 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Event, asyncTimeout, scheduleTask, sleep, synchronized, trackLeaks } from '@dxos/async';
+import { Event, Mutex, scheduleTask, sleep, synchronized, trackLeaks } from '@dxos/async';
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
 import { Context, ContextDisposedError, cancelWithContext } from '@dxos/context';
+import type { SpecificCredential } from '@dxos/credentials';
 import { timed, warnAfterTimeout } from '@dxos/debug';
-import { type EchoHost } from '@dxos/echo-db';
-import {
-  AutomergeDocumentLoaderImpl,
-  createIdFromSpaceKey,
-  createMappedFeedWriter,
-  type MetadataStore,
-  type Space,
-} from '@dxos/echo-pipeline';
-import { type ObjectStructure, type SpaceDoc } from '@dxos/echo-protocol';
-import { TYPE_PROPERTIES } from '@dxos/echo-schema';
+import { type EchoHost, type DatabaseRoot } from '@dxos/echo-db';
+import { createMappedFeedWriter, type MetadataStore, type Space } from '@dxos/echo-pipeline';
+import { SpaceDocVersion } from '@dxos/echo-protocol';
 import { type FeedStore } from '@dxos/feed-store';
-import { failedInvariant, invariant } from '@dxos/invariant';
+import { failedInvariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { CancelledError, SystemError } from '@dxos/protocols';
-import { CreateEpochRequest, SpaceState, type Space as SpaceProto } from '@dxos/protocols/proto/dxos/client/services';
+import {
+  type CreateEpochRequest,
+  SpaceState,
+  type Space as SpaceProto,
+} from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceCache } from '@dxos/protocols/proto/dxos/echo/metadata';
 import {
@@ -36,10 +34,11 @@ import { type GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gos
 import { type Gossip, type Presence } from '@dxos/teleport-extension-gossip';
 import { Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
-import { ComplexSet, assignDeep } from '@dxos/util';
+import { ComplexSet } from '@dxos/util';
 
 import { AutomergeSpaceState } from './automerge-space-state';
 import { type SigningContext } from './data-space-manager';
+import { runEpochMigration } from './epoch-migrations';
 import { NotarizationPlugin } from './notarization-plugin';
 import { TrustedKeySetAuthVerifier } from '../identity';
 
@@ -100,8 +99,12 @@ export class DataSpace {
   // TODO(dmaretskyi): Move into Space?
   private readonly _automergeSpaceState = new AutomergeSpaceState((rootUrl) => this._onNewAutomergeRoot(rootUrl));
 
+  private readonly _epochProcessingMutex = new Mutex();
+
   private _state = SpaceState.CLOSED;
 
+  private _databaseRoot: DatabaseRoot | null = null;
+
   /**
    * Error for _state === SpaceState.ERROR.
    */
@@ -183,6 +186,10 @@ export class DataSpace {
     return this._automergeSpaceState;
   }
 
+  get databaseRoot(): DatabaseRoot | null {
+    return this._databaseRoot;
+  }
+
   @trace.info({ depth: null })
   private get _automergeInfo() {
     return {
@@ -193,13 +200,17 @@ export class DataSpace {
 
   @synchronized
   async open() {
-    await this._open();
+    if (this._state === SpaceState.CLOSED) {
+      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);
+    await this._automergeSpaceState.open();
     await this._inner.spaceState.addCredentialProcessor(this._automergeSpaceState);
     await this._inner.open(new Context());
     this._state = SpaceState.CONTROL_ONLY;
@@ -225,10 +236,11 @@ export class DataSpace {
 
     await this._inner.close();
     await this._inner.spaceState.removeCredentialProcessor(this._automergeSpaceState);
+    await this._automergeSpaceState.close();
     await this._inner.spaceState.removeCredentialProcessor(this._notarizationPlugin);
     await this._notarizationPlugin.close();
 
-    await this._presence.destroy();
+    await this._presence.close();
     await this._gossip.close();
   }
 
@@ -279,12 +291,15 @@ export class DataSpace {
     // Allow other tasks to run before loading the data pipeline.
     await sleep(1);
 
+    const ready = this.stateUpdate.waitForCondition(() => this._state === SpaceState.READY);
+
     this._automergeSpaceState.startProcessingRootDocs();
 
-    // Wait for the first epoch.
-    await cancelWithContext(this._ctx, this.automergeSpaceState.ensureEpochInitialized());
+    // TODO(dmaretskyi): Change so `initializeDataPipeline` doesn't wait for the space to be READY, but rather any state with a valid root.
+    await ready;
+  }
 
-    log('data pipeline ready');
+  private async _enterReadyState() {
     await this._callbacks.beforeReady?.();
 
     this._state = SpaceState.READY;
@@ -371,11 +386,10 @@ export class DataSpace {
 
   private _onNewAutomergeRoot(rootUrl: string) {
     log('loading automerge root doc for space', { space: this.key, rootUrl });
-    // Override share policy = true for the root document.
-    // Workaround for https://github.com/automerge/automerge-repo/pull/292
-    this._echoHost.replicateDocument(rootUrl);
+
     const handle = this._echoHost.automergeRepo.find(rootUrl as any);
 
+    // TODO(dmaretskyi): Make this single-threaded (but doc loading should still be parallel to not block epoch processing).
     queueMicrotask(async () => {
       try {
         await warnAfterTimeout(5_000, 'Automerge root doc load timeout (DataSpace)', async () => {
@@ -385,6 +399,10 @@ export class DataSpace {
           return;
         }
 
+        // Ensure only one root is processed at a time.
+        using _guard = await this._epochProcessingMutex.acquire();
+
+        // Attaching space keys to legacy documents.
         const doc = handle.docSync() ?? failedInvariant();
         if (!doc.access?.spaceKey) {
           handle.change((doc: any) => {
@@ -394,10 +412,17 @@ export class DataSpace {
 
         // TODO(dmaretskyi): Close roots.
         // TODO(dmaretskyi): How do we handle changing to the next EPOCH?
-        if (!this._echoHost.roots.has(handle.documentId)) {
-          await this._echoHost.openSpaceRoot(handle.url);
+        const root = await this._echoHost.openSpaceRoot(handle.url);
+        this._databaseRoot = root;
+        if (root.getVersion() !== SpaceDocVersion.CURRENT) {
+          if (this._state !== SpaceState.REQUIRES_MIGRATION) {
+            this._state = SpaceState.REQUIRES_MIGRATION;
+            this.stateUpdate.emit();
+          }
         } else {
-          log.warn('echo database root already exists', { space: this.key, rootUrl });
+          if (this._state !== SpaceState.READY) {
+            await this._enterReadyState();
+          }
         }
       } catch (err) {
         if (err instanceof ContextDisposedError) {
@@ -420,131 +445,51 @@ export class DataSpace {
     await this.inner.controlPipeline.writer.write({ credential: { credential } });
   }
 
-  async createEpoch(options?: CreateEpochOptions) {
-    let epoch: Epoch | undefined;
-    switch (options?.migration) {
-      case undefined:
-      case CreateEpochRequest.Migration.NONE:
-        {
-          // TODO(dmaretskyi): Unify epoch construction.
-          epoch = {
-            previousId: this._automergeSpaceState.lastEpoch?.id,
-            number: (this._automergeSpaceState.lastEpoch?.subject.assertion.number ?? -1) + 1,
-            timeframe: this._automergeSpaceState.lastEpoch?.subject.assertion.timeframe ?? new Timeframe(),
-            automergeRoot: this._automergeSpaceState.lastEpoch?.subject.assertion?.automergeRoot,
-          };
-        }
-        break;
-      case CreateEpochRequest.Migration.INIT_AUTOMERGE:
-        {
-          const document = this._echoHost.automergeRepo.create();
-          // TODO(dmaretskyi): Unify epoch construction.
-          epoch = {
-            previousId: this._automergeSpaceState.lastEpoch?.id,
-            number: (this._automergeSpaceState.lastEpoch?.subject.assertion.number ?? -1) + 1,
-            timeframe: this._automergeSpaceState.lastEpoch?.subject.assertion.timeframe ?? new Timeframe(),
-            automergeRoot: document.url,
-          };
-        }
-        break;
-      case CreateEpochRequest.Migration.PRUNE_AUTOMERGE_ROOT_HISTORY:
-        {
-          const currentRootUrl = this._automergeSpaceState.rootUrl;
-          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());
-          invariant(typeof newRoot.url === 'string' && newRoot.url.length > 0);
-          // TODO(dmaretskyi): Unify epoch construction.
-          epoch = {
-            previousId: this._automergeSpaceState.lastEpoch?.id,
-            number: (this._automergeSpaceState.lastEpoch?.subject.assertion.number ?? -1) + 1,
-            timeframe: this._automergeSpaceState.lastEpoch?.subject.assertion.timeframe ?? new Timeframe(),
-            automergeRoot: newRoot.url,
-          };
-        }
-        break;
-      case CreateEpochRequest.Migration.FRAGMENT_AUTOMERGE_ROOT:
-        {
-          log.info('Fragmenting');
-
-          const currentRootUrl = this._automergeSpaceState.rootUrl;
-          const rootHandle = this._echoHost.automergeRepo.find<SpaceDoc>(currentRootUrl as any);
-          await cancelWithContext(this._ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
-
-          // Find properties object.
-          const objects = Object.entries((rootHandle.docSync() as SpaceDoc).objects!);
-          const properties = findPropertiesObject(rootHandle.docSync() as SpaceDoc);
-          const otherObjects = objects.filter(([key]) => key !== properties?.[0]);
-          invariant(properties, 'Properties not found');
-
-          // Create a new space doc with the properties object.
-          const newSpaceDoc: SpaceDoc = { ...rootHandle.docSync(), objects: Object.fromEntries([properties]) };
-          const newRoot = this._echoHost.automergeRepo.create(newSpaceDoc);
-          invariant(typeof newRoot.url === 'string' && newRoot.url.length > 0);
-
-          // Create new automerge documents for all objects.
-          const docLoader = new AutomergeDocumentLoaderImpl(
-            await createIdFromSpaceKey(this.key),
-            this._echoHost.automergeRepo,
-            this.key,
-          );
-          await docLoader.loadSpaceRootDocHandle(this._ctx, { rootUrl: newRoot.url });
-
-          otherObjects.forEach(([key, value]) => {
-            const handle = docLoader.createDocumentForObject(key);
-            handle.change((doc: any) => {
-              assignDeep(doc, ['objects', key], value);
-            });
-          });
-
-          // TODO(mykola): Delete old root.
+  async createEpoch(options?: CreateEpochOptions): Promise<SpecificCredential<Epoch> | null> {
+    const ctx = this._ctx.derive();
 
-          // TODO(dmaretskyi): Unify epoch construction.
-          epoch = {
-            previousId: this._automergeSpaceState.lastEpoch?.id,
-            number: (this._automergeSpaceState.lastEpoch?.subject.assertion.number ?? -1) + 1,
-            timeframe: this._automergeSpaceState.lastEpoch?.subject.assertion.timeframe ?? new Timeframe(),
-            automergeRoot: newRoot.url,
-          };
-        }
-        break;
-      case CreateEpochRequest.Migration.REPLACE_AUTOMERGE_ROOT:
-        {
-          invariant(options.newAutomergeRoot);
-          // TODO(dmaretskyi): Unify epoch construction.
-          epoch = {
-            previousId: this._automergeSpaceState.lastEpoch?.id,
-            number: (this._automergeSpaceState.lastEpoch?.subject.assertion.number ?? -1) + 1,
-            timeframe: this._automergeSpaceState.lastEpoch?.subject.assertion.timeframe ?? new Timeframe(),
-            automergeRoot: options.newAutomergeRoot,
-          };
-        }
-        break;
+    // Preserving existing behavior.
+    if (!options?.migration) {
+      return null;
     }
 
-    if (!epoch) {
-      return;
-    }
+    const { newRoot } = await runEpochMigration(ctx, {
+      repo: this._echoHost.automergeRepo,
+      spaceId: this.id,
+      spaceKey: this.key,
+      migration: options.migration,
+      currentRoot: this._automergeSpaceState.rootUrl ?? null,
+      newAutomergeRoot: options.newAutomergeRoot,
+    });
 
-    const receipt = await this.inner.controlPipeline.writer.write({
-      credential: {
-        credential: await this._signingContext.credentialSigner.createCredential({
-          subject: this.key,
-          assertion: {
-            '@type': 'dxos.halo.credentials.Epoch',
-            ...epoch,
-          },
-        }),
+    const epoch: Epoch = {
+      previousId: this._automergeSpaceState.lastEpoch?.id,
+      number: (this._automergeSpaceState.lastEpoch?.subject.assertion.number ?? -1) + 1,
+      timeframe: this._automergeSpaceState.lastEpoch?.subject.assertion.timeframe ?? new Timeframe(),
+      automergeRoot: newRoot ?? this._automergeSpaceState.rootUrl,
+    };
+
+    const credential = (await this._signingContext.credentialSigner.createCredential({
+      subject: this.key,
+      assertion: {
+        '@type': 'dxos.halo.credentials.Epoch',
+        ...epoch,
       },
+    })) as SpecificCredential<Epoch>;
+
+    const receipt = await this.inner.controlPipeline.writer.write({
+      credential: { credential },
     });
 
     await this.inner.controlPipeline.state.waitUntilTimeframe(new Timeframe([[receipt.feedKey, receipt.seq]]));
     await this._echoHost.updateIndexes();
+
+    return credential;
   }
 
   @synchronized
   async activate() {
-    if (this._state !== SpaceState.INACTIVE) {
+    if (![SpaceState.CLOSED, SpaceState.INACTIVE].includes(this._state)) {
       return;
     }
 
@@ -558,25 +503,13 @@ export class DataSpace {
     if (this._state === SpaceState.INACTIVE) {
       return;
     }
-
     // Unregister from data service.
     await this._metadataStore.setSpaceState(this.key, SpaceState.INACTIVE);
-    await this._close();
+    if (this._state !== SpaceState.CLOSED) {
+      await this._close();
+    }
     this._state = SpaceState.INACTIVE;
     log('new state', { state: SpaceState[this._state] });
     this.stateUpdate.emit();
   }
 }
-
-/**
- * Assumes properties are at root.
- */
-export const findPropertiesObject = (spaceDoc: SpaceDoc): [string, ObjectStructure] | undefined => {
-  for (const id in spaceDoc.objects ?? {}) {
-    const obj = spaceDoc.objects![id];
-    if (obj.system.type?.itemId === TYPE_PROPERTIES) {
-      return [id, obj];
-    }
-  }
-  return undefined;
-};