@dxos/migrations 0.8.4-main.fffef41 → 0.9.0

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@dxos/migrations",
-  "version": "0.8.4-main.fffef41",
+  "version": "0.9.0",
   "description": "",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
-  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
@@ -17,26 +21,23 @@
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {}
-  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@automerge/automerge": "3.1.2",
-    "@automerge/automerge-repo": "2.4.0",
-    "@dxos/client": "0.8.4-main.fffef41",
-    "@dxos/echo": "0.8.4-main.fffef41",
-    "@dxos/echo-db": "0.8.4-main.fffef41",
-    "@dxos/echo-protocol": "0.8.4-main.fffef41",
-    "@dxos/invariant": "0.8.4-main.fffef41",
-    "@dxos/log": "0.8.4-main.fffef41",
-    "@dxos/protocols": "0.8.4-main.fffef41",
-    "@dxos/util": "0.8.4-main.fffef41"
+    "@automerge/automerge": "3.3.0-fragments.1",
+    "@automerge/automerge-repo": "2.6.0-subduction.23",
+    "@effect-atom/atom": "^0.5.3",
+    "effect": "3.21.3",
+    "@dxos/client": "0.9.0",
+    "@dxos/echo": "0.9.0",
+    "@dxos/echo-client": "0.9.0",
+    "@dxos/echo-protocol": "0.9.0",
+    "@dxos/invariant": "0.9.0",
+    "@dxos/keys": "0.9.0",
+    "@dxos/util": "0.9.0"
   },
-  "devDependencies": {},
   "publishConfig": {
     "access": "public"
   }

package/src/annotations.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Annotation } from '@dxos/echo';
+
+/** Migration version stored on space properties meta. */
+export const MigrationVersionAnnotation = Annotation.make({
+  id: 'org.dxos.migrations.version',
+  schema: Schema.String,
+});

package/src/document-compaction.test.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { Client } from '@dxos/client';
+import { TestBuilder } from '@dxos/client/testing';
+import { Filter, Obj } from '@dxos/echo';
+import { TestSchema } from '@dxos/echo/testing';
+
+import { compactDocumentsEpochMigration } from './document-compaction';
+
+describe('document compaction', () => {
+  test('compacts linked documents and creates a new epoch', async () => {
+    const testBuilder = new TestBuilder();
+    const client = new Client({ services: testBuilder.createLocalClientServices() });
+    await client.initialize();
+    await client.halo.createIdentity();
+    await client.addTypes([TestSchema.Expando]);
+
+    try {
+      const space = await client.spaces.create();
+      await space.waitUntilReady();
+
+      const object = space.db.add(Obj.make(TestSchema.Expando, { title: 'before compaction' }));
+      await space.db.flush();
+
+      const epochsBefore = await space.internal.getEpochs();
+      const result = await compactDocumentsEpochMigration(space);
+
+      expect(result.compacted.length).toBeGreaterThan(0);
+      expect(result.epochNumber).toBe(epochsBefore.length);
+
+      const objects = await space.db.query(Filter.type(TestSchema.Expando)).run();
+      expect(objects).toHaveLength(1);
+      expect(objects[0]?.title).toBe('before compaction');
+      expect(objects[0]?.id).toBe(object.id);
+
+      const epochsAfter = await space.internal.getEpochs();
+      expect(epochsAfter.length).toBe(epochsBefore.length + 1);
+    } finally {
+      await client.destroy();
+    }
+  });
+});

package/src/document-compaction.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Space, SpaceState } from '@dxos/client/echo';
+import { invariant } from '@dxos/invariant';
+
+import { MigrationBuilder } from './migration-builder';
+
+export type CompactDocumentsOptions = {
+  /**
+   * Entity ids whose linked Automerge documents should be compacted.
+   * Defaults to all ids in the space root `links` map.
+   */
+  objectIds?: string[];
+};
+
+export type CompactDocumentsResult = {
+  compacted: string[];
+  skipped: string[];
+  epochNumber: number;
+};
+
+/**
+ * Re-materializes linked object documents into fresh Automerge docs (no history) and commits
+ * a new space epoch with {@link CreateEpochRequest.Migration.REPLACE_AUTOMERGE_ROOT}.
+ */
+export const compactDocumentsEpochMigration = async (
+  space: Space,
+  options: CompactDocumentsOptions = {},
+): Promise<CompactDocumentsResult> => {
+  invariant(space.state.get() === SpaceState.SPACE_READY, 'Space must be open and ready before compaction.');
+
+  const builder = new MigrationBuilder(space);
+  const { compacted, skipped } = await builder.compactLinkedDocuments(options.objectIds);
+  await builder._commit();
+
+  const epochs = await space.internal.getEpochs();
+  const lastEpoch = epochs[epochs.length - 1];
+  const epochNumber = lastEpoch?.subject.assertion.number ?? 0;
+
+  return { compacted, skipped, epochNumber };
+};

package/src/index.ts

@@ -2,7 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-export type { ObjectStructure } from '@dxos/echo-protocol';
+export type { EntityStructure } from '@dxos/echo-protocol';
 
+export * from './annotations';
+export * from './document-compaction';
 export * from './migration-builder';
 export * from './migrations';

package/src/migration-builder.ts

@@ -2,22 +2,18 @@
 // Copyright 2024 DXOS.org
 //
 
-import { next as A, type Doc } from '@automerge/automerge';
+import { next as A, type Doc, toJS } from '@automerge/automerge';
 import { type AnyDocumentId, type DocumentId } from '@automerge/automerge-repo';
 import type * as Schema from 'effect/Schema';
 
 import { type Space } from '@dxos/client/echo';
 import { CreateEpochRequest } from '@dxos/client/halo';
-import { requireTypeReference } from '@dxos/echo/internal';
-import { type DocHandleProxy, ObjectCore, type RepoProxy, migrateDocument } from '@dxos/echo-db';
-import {
-  type DatabaseDirectory,
-  type ObjectStructure,
-  Reference,
-  SpaceDocVersion,
-  encodeReference,
-} from '@dxos/echo-protocol';
+import { type DocHandleProxy, ObjectCore, type RepoProxy, migrateDocument } from '@dxos/echo-client/internal';
+import { type DatabaseDirectory, EncodedReference, type EntityStructure, SpaceDocVersion } from '@dxos/echo-protocol';
+import { getSchemaURI } from '@dxos/echo/internal';
+import * as Type from '@dxos/echo/Type';
 import { invariant } from '@dxos/invariant';
+import { EID, EntityId } from '@dxos/keys';
 import { type MaybePromise } from '@dxos/util';
 
 /*
@@ -42,7 +38,7 @@ export class MigrationBuilder {
   private readonly _repo: RepoProxy;
   private readonly _rootDoc: Doc<DatabaseDirectory>;
 
-  // echoId -> automergeUrl
+  // echoUri -> automergeUrl
   private readonly _newLinks: Record<string, string> = {};
   private readonly _flushIds: DocumentId[] = [];
   private readonly _deleteObjects: string[] = [];
@@ -50,14 +46,13 @@ export class MigrationBuilder {
   private _newRoot?: DocHandleProxy<DatabaseDirectory> = undefined;
 
   constructor(private readonly _space: Space) {
-    this._repo = this._space.db.coreDatabase._repo;
-    // TODO(wittjosiah): Accessing private API.
-    this._rootDoc = (this._space.db.coreDatabase as any)._automergeDocLoader
-      .getSpaceRootDocHandle()
-      .doc() as Doc<DatabaseDirectory>;
+    this._repo = this._space.internal.db._repo;
+    const rootDoc = this._space.internal.db._getSpaceRootDocHandle().doc();
+    invariant(rootDoc, 'Space root document must be available when creating MigrationBuilder');
+    this._rootDoc = rootDoc;
   }
 
-  async findObject(id: string): Promise<ObjectStructure | undefined> {
+  async findObject(id: string): Promise<EntityStructure | undefined> {
     const documentId = (this._rootDoc.links?.[id] || this._newLinks[id])?.toString() as AnyDocumentId | undefined;
     const docHandle = documentId && this._repo.find(documentId);
     if (!docHandle) {
@@ -71,14 +66,15 @@ export class MigrationBuilder {
 
   async migrateObject(
     id: string,
-    migrate: (objectStructure: ObjectStructure) => MaybePromise<{ schema: Schema.Schema.AnyNoContext; props: any }>,
+    migrate: (objectStructure: EntityStructure) => MaybePromise<{ type: Type.AnyEntity; props: any }>,
   ): Promise<void> {
     const objectStructure = await this.findObject(id);
     if (!objectStructure) {
       return;
     }
 
-    const { schema, props } = await migrate(objectStructure);
+    const { type, props } = await migrate(objectStructure);
+    const schema = Type.getSchema(type);
 
     const oldHandle = await this._findObjectContainingHandle(id);
     invariant(oldHandle);
@@ -91,7 +87,7 @@ export class MigrationBuilder {
       objects: {
         [id]: {
           system: {
-            type: encodeReference(requireTypeReference(schema)),
+            type: EncodedReference.fromURI(getSchemaURI(schema)!),
           },
           data: props,
           meta: {
@@ -102,26 +98,59 @@ export class MigrationBuilder {
     };
     const migratedDoc = migrateDocument(oldHandle.doc() as Doc<DatabaseDirectory>, newState);
     const newHandle = this._repo.import<DatabaseDirectory>(A.save(migratedDoc));
+    await newHandle.whenReady();
+    invariant(newHandle.url, 'Migrated document URL not available after whenReady');
     this._newLinks[id] = newHandle.url;
-    this._addHandleToFlushList(newHandle);
+    this._addHandleToFlushList(newHandle.documentId!);
   }
 
-  async addObject(schema: Schema.Schema.AnyNoContext, props: any): Promise<string> {
-    const core = this._createObject({ schema, props });
+  async addObject(type: Type.AnyEntity, props: any): Promise<string> {
+    const resolved = Type.getSchema(type);
+    const core = await this._createObject({ schema: resolved, props });
     return core.id;
   }
 
   createReference(id: string) {
-    return encodeReference(Reference.localObjectReference(id));
+    invariant(EntityId.isValid(id), 'Invalid EntityId.');
+    return EncodedReference.fromURI(EID.make({ entityId: id }));
   }
 
   deleteObject(id: string): void {
     this._deleteObjects.push(id);
   }
 
-  changeProperties(changeFn: (properties: ObjectStructure) => void): void {
+  /**
+   * Re-materializes linked object documents into fresh Automerge docs without history.
+   * Call {@link _commit} to publish a new space epoch with updated root links.
+   */
+  async compactLinkedDocuments(objectIds?: string[]): Promise<{ compacted: string[]; skipped: string[] }> {
+    const linkIds = objectIds ?? Object.keys(this._rootDoc.links ?? {});
+    const compacted: string[] = [];
+    const skipped: string[] = [];
+
+    for (const id of linkIds) {
+      const oldHandle = await this._findObjectContainingHandle(id);
+      if (!oldHandle) {
+        skipped.push(id);
+        continue;
+      }
+
+      await oldHandle.whenReady();
+      const materialized = toJS(oldHandle.doc()!) as DatabaseDirectory;
+      const newHandle = this._repo.create<DatabaseDirectory>(materialized);
+      await newHandle.whenReady();
+      invariant(newHandle.url, 'Compacted document URL not available after whenReady');
+      this._newLinks[id] = newHandle.url;
+      this._addHandleToFlushList(newHandle.documentId!);
+      compacted.push(id);
+    }
+
+    return { compacted, skipped };
+  }
+
+  async changeProperties(changeFn: (properties: EntityStructure) => void): Promise<void> {
     if (!this._newRoot) {
-      this._buildNewRoot();
+      await this._buildNewRoot();
     }
     invariant(this._newRoot, 'New root not created');
 
@@ -129,7 +158,8 @@ export class MigrationBuilder {
       const propertiesStructure = doc.objects?.[this._space.properties.id];
       propertiesStructure && changeFn(propertiesStructure);
     });
-    this._addHandleToFlushList(this._newRoot);
+    await this._newRoot.whenReady();
+    this._addHandleToFlushList(this._newRoot.documentId!);
   }
 
   /**
@@ -137,13 +167,14 @@ export class MigrationBuilder {
    */
   async _commit(): Promise<void> {
     if (!this._newRoot) {
-      this._buildNewRoot();
+      await this._buildNewRoot();
     }
     invariant(this._newRoot, 'New root not created');
 
     await this._space.db.flush();
 
     // Create new epoch.
+    invariant(this._newRoot.url, 'New root URL not available');
     await this._space.internal.createEpoch({
       migration: CreateEpochRequest.Migration.REPLACE_AUTOMERGE_ROOT,
       automergeRootUrl: this._newRoot.url,
@@ -161,7 +192,7 @@ export class MigrationBuilder {
     return docHandle;
   }
 
-  private _buildNewRoot(): void {
+  private async _buildNewRoot(): Promise<void> {
     const links = { ...(this._rootDoc.links ?? {}) };
     for (const id of this._deleteObjects) {
       delete links[id];
@@ -179,10 +210,11 @@ export class MigrationBuilder {
       objects: this._rootDoc.objects,
       links,
     });
-    this._addHandleToFlushList(this._newRoot);
+    await this._newRoot.whenReady();
+    this._addHandleToFlushList(this._newRoot.documentId!);
   }
 
-  private _createObject({
+  private async _createObject({
     id,
     schema,
     props,
@@ -190,30 +222,31 @@ export class MigrationBuilder {
     id?: string;
     schema: Schema.Schema.AnyNoContext;
     props: any;
-  }): ObjectCore {
+  }): Promise<ObjectCore> {
     const core = new ObjectCore();
     if (id) {
       core.id = id;
     }
 
     core.initNewObject(props);
-    core.setType(requireTypeReference(schema));
+    core.setType(EncodedReference.fromURI(getSchemaURI(schema)!));
     const newHandle = this._repo.create<DatabaseDirectory>({
       version: SpaceDocVersion.CURRENT,
       access: {
         spaceKey: this._space.key.toHex(),
       },
       objects: {
-        [core.id]: core.getDoc() as ObjectStructure,
+        [core.id]: core.getDoc() as EntityStructure,
       },
     });
-    this._newLinks[core.id] = newHandle.url;
-    this._addHandleToFlushList(newHandle);
+    await newHandle.whenReady();
+    this._newLinks[core.id] = newHandle.url!;
+    this._addHandleToFlushList(newHandle.documentId!);
 
     return core;
   }
 
-  private _addHandleToFlushList(handle: DocHandleProxy<any>): void {
-    this._flushIds.push(handle.documentId);
+  private _addHandleToFlushList(id: DocumentId): void {
+    this._flushIds.push(id);
   }
 }

package/src/migrations.test.ts

@@ -2,31 +2,33 @@
 // Copyright 2023 DXOS.org
 //
 
+import * as Option from 'effect/Option';
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'vitest';
 
 import { Client } from '@dxos/client';
-import { Filter, type Space } from '@dxos/client/echo';
+import { type Space } from '@dxos/client/echo';
 import { TestBuilder } from '@dxos/client/testing';
-import { Obj, Type } from '@dxos/echo';
-import { Expando } from '@dxos/echo/internal';
+import { Annotation, Filter, Obj } from '@dxos/echo';
+import { TestSchema } from '@dxos/echo/testing';
 
+import { MigrationVersionAnnotation } from './annotations';
 import { Migrations } from './migrations';
 
 Migrations.define('test', [
   {
     version: '1970-01-01',
     next: async ({ builder }) => {
-      await builder.addObject(Expando, { namespace: 'test', count: 1 });
+      await builder.addObject(TestSchema.Expando, { namespace: 'test', count: 1 });
     },
   },
   {
     version: '1970-01-02',
     next: async ({ space, builder }) => {
-      // TODO(dmaretskyi): Is this intended to query only expando objects? Change to `Filter.type(Expando, { namespace: 'test' })`
-      const { objects } = await space.db.query(Filter.props<any>({ namespace: 'test' })).run();
+      // TODO(dmaretskyi): Is this intended to query only expando objects? Change to `Filter.type(TestSchema.Expando, { namespace: 'test' })`
+      const objects = await space.db.query(Filter.props<any>({ namespace: 'test' })).run();
       for (const object of objects) {
         await builder.migrateObject(object.id, ({ data }) => ({
-          schema: Expando,
+          type: TestSchema.Expando,
           props: { namespace: data.namespace, count: 2 },
         }));
       }
@@ -35,11 +37,11 @@ Migrations.define('test', [
   {
     version: '1970-01-03',
     next: async ({ space, builder }) => {
-      // TODO(dmaretskyi): Is this intended to query only expando objects? Change to `Filter.type(Expando, { namespace: 'test' })`
-      const { objects } = await space.db.query(Filter.props<any>({ namespace: 'test' })).run();
+      // TODO(dmaretskyi): Is this intended to query only expando objects? Change to `Filter.type(TestSchema.Expando, { namespace: 'test' })`
+      const objects = await space.db.query(Filter.props<any>({ namespace: 'test' })).run();
       for (const object of objects) {
         await builder.migrateObject(object.id, ({ data }) => ({
-          schema: Expando,
+          type: TestSchema.Expando,
           props: { namespace: data.namespace, count: data.count * 3 },
         }));
       }
@@ -47,7 +49,8 @@ Migrations.define('test', [
   },
 ]);
 
-describe('Migrations', () => {
+// Flaky. We wanna depreacate and rewrite migration builder anyway.
+describe.skip('Migrations', () => {
   let client: Client;
   let space: Space;
 
@@ -68,34 +71,46 @@ describe('Migrations', () => {
 
   test('if no migrations have been run before, runs all migrations', async () => {
     await Migrations.migrate(space);
-    const { objects } = await space.db.query(Filter.type(Expando, { namespace: 'test' })).run();
+    const objects = await space.db.query(Filter.type(TestSchema.Expando, { namespace: 'test' })).run();
     expect(objects).to.have.length(1);
     expect(objects[0].count).to.equal(6);
-    expect(space.properties['test.version']).to.equal('1970-01-03');
+    expect(Annotation.get(space.properties, MigrationVersionAnnotation).pipe(Option.getOrUndefined)).to.equal(
+      '1970-01-03',
+    );
   });
 
   test('if some migrations have been run before, runs only the remaining migrations', async () => {
-    space.properties['test.version'] = '1970-01-02';
-    space.db.add(Obj.make(Type.Expando, { namespace: 'test', count: 5 }));
+    Obj.update(space.properties, (properties) => {
+      Annotation.set(properties, MigrationVersionAnnotation, '1970-01-02');
+    });
+    space.db.graph.registry.add([TestSchema.Expando]);
+    space.db.add(Obj.make(TestSchema.Expando, { namespace: 'test', count: 5 }));
+    await space.db.flush();
     await Migrations.migrate(space);
-    const { objects } = await space.db.query(Filter.type(Expando, { namespace: 'test' })).run();
+    const objects = await space.db.query(Filter.type(TestSchema.Expando, { namespace: 'test' })).run();
     expect(objects).to.have.length(1);
     expect(objects[0].count).to.equal(15);
-    expect(space.properties['test.version']).to.equal('1970-01-03');
+    expect(Annotation.get(space.properties, MigrationVersionAnnotation).pipe(Option.getOrUndefined)).to.equal(
+      '1970-01-03',
+    );
   });
 
   test('if all migrations have been run before, does nothing', async () => {
-    space.properties['test.version'] = '1970-01-03';
+    Obj.update(space.properties, (properties) => {
+      Annotation.set(properties, MigrationVersionAnnotation, '1970-01-03');
+    });
     await Migrations.migrate(space);
-    const { objects } = await space.db.query(Filter.type(Expando, { namespace: 'test' })).run();
+    const objects = await space.db.query(Filter.type(TestSchema.Expando, { namespace: 'test' })).run();
     expect(objects).to.have.length(0);
   });
 
   test('if target version is specified, runs only the migrations up to that version', async () => {
     await Migrations.migrate(space, '1970-01-02');
-    const { objects } = await space.db.query(Filter.type(Expando, { namespace: 'test' })).run();
+    const objects = await space.db.query(Filter.type(TestSchema.Expando, { namespace: 'test' })).run();
     expect(objects).to.have.length(1);
     expect(objects[0].count).to.equal(2);
-    expect(space.properties['test.version']).to.equal('1970-01-02');
+    expect(Annotation.get(space.properties, MigrationVersionAnnotation).pipe(Option.getOrUndefined)).to.equal(
+      '1970-01-02',
+    );
   });
 });

package/src/migrations.ts

@@ -2,10 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Space, SpaceState, live } from '@dxos/client/echo';
+import { Atom } from '@effect-atom/atom';
+import * as Registry from '@effect-atom/atom/Registry';
+import * as Option from 'effect/Option';
+
+import { type Space, SpaceState } from '@dxos/client/echo';
+import { Annotation, Obj } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { type MaybePromise } from '@dxos/util';
 
+import { MigrationVersionAnnotation } from './annotations';
 import { MigrationBuilder } from './migration-builder';
 
 export type MigrationContext = {
@@ -21,8 +27,12 @@ export type Migration = {
 export class Migrations {
   static namespace?: string;
   static migrations: Migration[] = [];
-  private static _state = live<{ running: string[] }>({ running: [] });
+  private static _registry = Registry.make();
+  private static _stateAtom = Atom.make<{ running: string[] }>({ running: [] }).pipe(Atom.keepAlive);
 
+  /**
+   * @deprecated Use `MigrationVersionAnnotation` via `Annotation.get/set` on space properties.
+   */
   static get versionProperty() {
     return this.namespace && `${this.namespace}.version`;
   }
@@ -32,7 +42,8 @@ export class Migrations {
   }
 
   static running(space: Space): boolean {
-    return this._state.running.includes(space.key.toHex());
+    const state = this._registry.get(this._stateAtom);
+    return state.running.includes(space.key.toHex());
   }
 
   static define(namespace: string, migrations: Migration[]): void {
@@ -42,9 +53,8 @@ export class Migrations {
 
   static async migrate(space: Space, targetVersion?: string | number): Promise<boolean> {
     invariant(!this.running(space), 'Migration already running');
-    invariant(this.versionProperty, 'Migrations namespace not set');
     invariant(space.state.get() === SpaceState.SPACE_READY, 'Space not ready');
-    const currentVersion = space.properties[this.versionProperty];
+    const currentVersion = Annotation.get(space.properties, MigrationVersionAnnotation).pipe(Option.getOrUndefined);
     const currentIndex = this.migrations.findIndex((m) => m.version === currentVersion) + 1;
     const i = this.migrations.findIndex((m) => m.version === targetVersion);
     const targetIndex = i === -1 ? this.migrations.length : i + 1;
@@ -52,20 +62,25 @@ export class Migrations {
       return false;
     }
 
-    this._state.running.push(space.key.toHex());
-    if (targetIndex > currentIndex) {
-      const migrations = this.migrations.slice(currentIndex, targetIndex);
-      for (const migration of migrations) {
-        const builder = new MigrationBuilder(space);
-        await migration.next({ space, builder });
-        builder.changeProperties((propertiesStructure) => {
-          invariant(this.versionProperty, 'Migrations namespace not set');
-          propertiesStructure.data[this.versionProperty] = migration.version;
-        });
-        await builder._commit();
+    const spaceKey = space.key.toHex();
+    const currentState = this._registry.get(this._stateAtom);
+    this._registry.set(this._stateAtom, { running: [...currentState.running, spaceKey] });
+    try {
+      if (targetIndex > currentIndex) {
+        const migrations = this.migrations.slice(currentIndex, targetIndex);
+        for (const migration of migrations) {
+          const builder = new MigrationBuilder(space);
+          await migration.next({ space, builder });
+          await builder._commit();
+          Obj.update(space.properties, (properties) => {
+            Annotation.set(properties, MigrationVersionAnnotation, migration.version);
+          });
+        }
       }
+    } finally {
+      const finalState = this._registry.get(this._stateAtom);
+      this._registry.set(this._stateAtom, { running: finalState.running.filter((key) => key !== spaceKey) });
     }
-    this._state.running.splice(this._state.running.indexOf(space.key.toHex()), 1);
 
     return true;
   }