@dxos/plugin-space 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/src/operations/join.ts

@@ -0,0 +1,26 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { JOIN_DIALOG } from '../constants';
+import { type JoinDialogProps } from '../containers/JoinDialog';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Join> = SpaceOperation.Join.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: JOIN_DIALOG,
+        blockAlign: 'start',
+        props: {
+          initialInvitationCode: input.invitationCode,
+          onDone: input.onDone,
+        } satisfies Partial<JoinDialogProps>,
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/migrate.ts

@@ -0,0 +1,45 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities } from '@dxos/app-framework';
+import { SpaceState } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Migrations } from '@dxos/migrations';
+import { ObservabilityOperation } from '@dxos/plugin-observability';
+
+import { SpaceCapabilities } from '../types';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Migrate> = SpaceOperation.Migrate.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const { space, version: targetVersion } = input;
+
+      if (space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
+        yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+          ...current,
+          sdkMigrationRunning: { ...current.sdkMigrationRunning, [space.id]: true },
+        }));
+        yield* Effect.promise(() => space.internal.migrate());
+        yield* Capabilities.updateAtomValue(SpaceCapabilities.EphemeralState, (current) => ({
+          ...current,
+          sdkMigrationRunning: { ...current.sdkMigrationRunning, [space.id]: false },
+        }));
+      }
+      const result = yield* Effect.promise(() => Migrations.migrate(space, targetVersion));
+
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: 'space.migrate',
+        properties: {
+          spaceId: space.id,
+          targetVersion,
+          version: Migrations.versionProperty ? space.properties[Migrations.versionProperty] : undefined,
+        },
+      });
+
+      return result;
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-create-object.ts

@@ -0,0 +1,40 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Collection, Obj } from '@dxos/echo';
+
+import { CREATE_OBJECT_DIALOG } from '../constants';
+import { SpaceCapabilities } from '../types';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenCreateObject> = SpaceOperation.OpenCreateObject.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const ephemeralState = yield* Capabilities.getAtomValue(SpaceCapabilities.EphemeralState);
+      const navigable = input.navigable ?? true;
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: CREATE_OBJECT_DIALOG,
+        blockAlign: 'start',
+        props: {
+          target: input.target,
+          views: input.views,
+          typename: input.typename,
+          initialFormValues: input.initialFormValues,
+          onCreateObject: input.onCreateObject,
+          targetNodeId: input.targetNodeId,
+          shouldNavigate: navigable
+            ? (object: Obj.Unknown) => {
+                const isCollection = Obj.instanceOf(Collection.Collection, object);
+                return !isCollection || ephemeralState.navigableCollections;
+              }
+            : () => false,
+        },
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-create-space.ts

@@ -0,0 +1,21 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { CREATE_SPACE_DIALOG } from '../constants';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenCreateSpace> = SpaceOperation.OpenCreateSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: CREATE_SPACE_DIALOG,
+        blockAlign: 'start',
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-import-space.ts

@@ -0,0 +1,21 @@
+// Copyright 2026 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { IMPORT_SPACE_DIALOG } from '../constants';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenImportSpace> = SpaceOperation.OpenImportSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: IMPORT_SPACE_DIALOG,
+        blockAlign: 'start',
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-members.ts

@@ -0,0 +1,20 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenMembers> = SpaceOperation.OpenMembers.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Operation.invoke(LayoutOperation.Open, {
+        subject: [`${getSpacePath(input.space.id)}/settings`],
+        workspace: getSpacePath(input.space.id),
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open-settings.ts

@@ -0,0 +1,20 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.OpenSettings> = SpaceOperation.OpenSettings.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Operation.invoke(LayoutOperation.Open, {
+        subject: [`${getSpacePath(input.space.id)}/general`],
+        workspace: getSpacePath(input.space.id),
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/open.ts

@@ -0,0 +1,16 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Open> = SpaceOperation.Open.pipe(
+  Operation.withHandler((input) =>
+    Effect.promise(async () => {
+      await input.space.open();
+    }),
+  ),
+);
+export default handler;

package/src/operations/remove-objects.ts

@@ -0,0 +1,63 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+import { getSpace } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Collection, Obj } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { isNonNullable } from '@dxos/util';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.RemoveObjects> = SpaceOperation.RemoveObjects.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const layout = yield* Capabilities.getAtomValue(AppCapabilities.Layout);
+      const objects = input.objects as Obj.Unknown[];
+
+      const space = getSpace(objects[0]);
+      invariant(space && objects.every((obj) => Obj.isObject(obj) && getSpace(obj) === space));
+
+      const parentCollection: Collection.Collection =
+        input.target ?? space.properties[Collection.Collection.typename]?.target;
+
+      const indices = objects.map((obj) =>
+        Obj.instanceOf(Collection.Collection, parentCollection)
+          ? parentCollection.objects.findIndex((ref) => ref.target === obj)
+          : -1,
+      );
+
+      const wasActive = objects
+        .filter(Obj.isObject)
+        .map((object) => layout.active.find((graphId) => graphId.endsWith(object.id)))
+        .filter(isNonNullable);
+
+      for (const obj of objects) {
+        const index = parentCollection.objects.findIndex((ref) => ref.target === obj);
+        if (index !== -1) {
+          Obj.update(parentCollection, (parentCollection) => {
+            parentCollection.objects.splice(index, 1);
+          });
+        }
+
+        const db = Obj.getDatabase(obj);
+        db?.remove(obj);
+      }
+
+      if (wasActive.length > 0) {
+        yield* Operation.invoke(LayoutOperation.Close, { subject: wasActive });
+      }
+
+      return {
+        objects,
+        parentCollection,
+        indices,
+        wasActive,
+      };
+    }),
+  ),
+);
+export default handler;

package/src/operations/rename-object.ts

@@ -0,0 +1,24 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+
+import { OBJECT_RENAME_POPOVER } from '../constants';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.RenameObject> = SpaceOperation.RenameObject.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const object = input.object as Obj.Unknown;
+      yield* Operation.invoke(LayoutOperation.UpdatePopover, {
+        subject: OBJECT_RENAME_POPOVER,
+        anchorId: input.caller ?? '',
+        props: object,
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/rename.ts

@@ -0,0 +1,22 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { SPACE_RENAME_POPOVER } from '../constants';
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Rename> = SpaceOperation.Rename.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      yield* Operation.invoke(LayoutOperation.UpdatePopover, {
+        subject: SPACE_RENAME_POPOVER,
+        anchorId: input.caller ?? '',
+        props: input.space,
+      });
+    }),
+  ),
+);
+export default handler;

package/src/operations/reset.test.ts

@@ -0,0 +1,131 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import { describe, onTestFinished, test } from 'vitest';
+
+import { Capability } from '@dxos/app-framework';
+import { Client } from '@dxos/client';
+import { TestBuilder } from '@dxos/client/testing';
+import { Filter, Obj, Relation } from '@dxos/echo';
+import { TestSchema } from '@dxos/echo/testing';
+import { runAndForwardErrors } from '@dxos/effect';
+import { type Space } from '@dxos/react-client/echo';
+
+import reset from './reset';
+
+// The handler is wired against `Capability.Service` because the operation definition declares it,
+// but `reset.ts` does not consume the service. A stub keeps the effect's requirement satisfied for
+// direct invocation outside the framework runtime.
+const invokeReset = (space: Space) =>
+  runAndForwardErrors(reset.handler({ space }).pipe(Effect.provideService(Capability.Service, {} as any)));
+
+describe('SpaceOperation.Reset', () => {
+  test('removes all user objects from the space', async ({ expect }) => {
+    const space = await createSpaceWithObjects(3);
+
+    const beforeAll = await space.db.query(Filter.everything()).run();
+    const beforeUser = beforeAll.filter((object) => Obj.getTypename(object) === TestSchema.Expando.typename);
+    expect(beforeUser).toHaveLength(3);
+
+    await invokeReset(space);
+    await space.db.flush();
+
+    const afterAll = await space.db.query(Filter.everything()).run();
+    const afterUser = afterAll.filter((object) => Obj.getTypename(object) === TestSchema.Expando.typename);
+    expect(afterUser, `expected no user objects after reset, got ${afterAll.length} total entities`).toHaveLength(0);
+  });
+
+  test('removes relations from the space', async ({ expect }) => {
+    const builder = new TestBuilder();
+    onTestFinished(() => builder.destroy());
+    const client = new Client({ services: builder.createLocalClientServices() });
+    await client.initialize();
+    onTestFinished(() => client.destroy());
+
+    await client.halo.createIdentity({ displayName: 'tester' });
+    await client.addTypes([TestSchema.Person, TestSchema.Task, TestSchema.HasManager]);
+    const space = await client.spaces.create();
+    await space.waitUntilReady();
+
+    const alice = space.db.add(
+      Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        username: 'alice',
+        email: 'a@x',
+        tasks: [],
+        address: { coordinates: {} },
+      }),
+    );
+    const bob = space.db.add(
+      Obj.make(TestSchema.Person, {
+        name: 'Bob',
+        username: 'bob',
+        email: 'b@x',
+        tasks: [],
+        address: { coordinates: {} },
+      }),
+    );
+    space.db.add(
+      Relation.make(TestSchema.HasManager, {
+        [Relation.Source]: alice,
+        [Relation.Target]: bob,
+      }),
+    );
+    await space.db.flush();
+
+    const beforeEntities = await space.db.query(Filter.everything()).run();
+    const beforeRelations = beforeEntities.filter(Relation.isRelation);
+    expect(beforeRelations).toHaveLength(1);
+
+    await invokeReset(space);
+    await space.db.flush();
+
+    const afterEntities = await space.db.query(Filter.everything()).run();
+    const afterRelations = afterEntities.filter(Relation.isRelation);
+    expect(afterRelations, `expected no relations after reset, got ${afterRelations.length}`).toHaveLength(0);
+    const afterPersons = afterEntities.filter((object) => Obj.getTypename(object) === TestSchema.Person.typename);
+    expect(afterPersons, `expected no person objects after reset, got ${afterPersons.length}`).toHaveLength(0);
+  });
+
+  test('removes registered schemas from the space', async ({ expect }) => {
+    const space = await createSpaceWithObjects(0);
+    await space.db.schemaRegistry.register([TestSchema.Expando]);
+    await space.db.flush();
+
+    const beforeSchemas = space.db.schemaRegistry.query().runSync();
+    expect(
+      beforeSchemas.length,
+      'expected the registered Expando schema to be present in the space schema registry before reset',
+    ).toBeGreaterThan(0);
+
+    await invokeReset(space);
+    await space.db.flush();
+
+    const afterSchemas = space.db.schemaRegistry.query().runSync();
+    expect(
+      afterSchemas,
+      `expected no schemas after reset, got ${afterSchemas.map((s) => s.typename).join(', ')}`,
+    ).toHaveLength(0);
+  });
+});
+
+const createSpaceWithObjects = async (count: number) => {
+  const builder = new TestBuilder();
+  onTestFinished(() => builder.destroy());
+  const client = new Client({ services: builder.createLocalClientServices() });
+  await client.initialize();
+  onTestFinished(() => client.destroy());
+
+  await client.halo.createIdentity({ displayName: 'tester' });
+  await client.addTypes([TestSchema.Expando]);
+
+  const space = await client.spaces.create();
+  await space.waitUntilReady();
+  for (let i = 0; i < count; i += 1) {
+    space.db.add(Obj.make(TestSchema.Expando, { index: i }));
+  }
+  await space.db.flush();
+  return space;
+};

package/src/operations/reset.ts

@@ -0,0 +1,187 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { LegacySpaceProperties, SpaceProperties } from '@dxos/client-protocol';
+import { type Space } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
+import { Collection, Filter, Obj, Ref, Relation } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { Migrations } from '@dxos/migrations';
+
+import { SpaceOperation } from './definitions';
+
+/**
+ * Typenames the reset operation must NOT remove. Without `SpaceProperties` (or
+ * `LegacySpaceProperties`), `SpaceProxy._initializeDb` never wakes its `propertiesAvailable`
+ * trigger on the next session start, so `space.properties` throws "Space is not initialized."
+ * and every container that reads it crashes.
+ */
+const SYSTEM_TYPENAMES = new Set<string>([SpaceProperties.typename, LegacySpaceProperties.typename]);
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Reset> = SpaceOperation.Reset.pipe(
+  Operation.withHandler((input) =>
+    Effect.promise(async () => {
+      const { space } = input;
+      log.info('reset: invoked', { spaceId: space.id });
+
+      log.info('reset: snapshotting entities');
+      const allEntities = snapshotEntities(space);
+      const entities = allEntities.filter((entity) => !SYSTEM_TYPENAMES.has(Obj.getTypename(entity) ?? ''));
+      const preserved = allEntities.length - entities.length;
+      const relations = entities.filter(Relation.isRelation);
+      const objects = entities.filter((entity) => !Relation.isRelation(entity));
+      if (preserved > 0) {
+        log.info('reset: preserving system entities', { preserved });
+      }
+
+      log.info('reset: reading schema registry');
+      const schemas = space.db.schemaRegistry.query().runSync();
+
+      const feeds =
+        (space.internal.data.pipeline?.controlFeeds?.length ?? 0) +
+        (space.internal.data.pipeline?.dataFeeds?.length ?? 0);
+      log.info('reset: counts', {
+        spaceId: space.id,
+        entities: entities.length,
+        objects: objects.length,
+        relations: relations.length,
+        schemas: schemas.length,
+        feeds,
+        types: entities.map((entity) => Obj.getTypename(entity) ?? '<unknown>'),
+      });
+
+      let removed = 0;
+      const failures: Array<{ id: string; typename: string; error: string }> = [];
+      let firstError: unknown;
+      for (const entity of entities) {
+        try {
+          space.db.remove(entity);
+          removed += 1;
+        } catch (err) {
+          firstError ??= err;
+          const typename = Obj.getTypename(entity) ?? '<unknown>';
+          const message = err instanceof Error ? err.message : String(err);
+          failures.push({ id: entity.id, typename, error: message });
+          log.warn('reset: remove threw', { id: entity.id, typename, error: message });
+        }
+      }
+      log.info('reset: removed', { removed, failed: failures.length, total: entities.length });
+      if (failures.length > 0) {
+        // Bail before flush/createEpoch — proceeding would leave a partially reset space while the
+        // caller saw success.
+        throw new Error(
+          `reset failed: ${failures.length}/${entities.length} entities could not be removed` +
+            ` (first failure on ${failures[0].id} [${failures[0].typename}]: ${failures[0].error})`,
+          { cause: firstError instanceof Error ? firstError : undefined },
+        );
+      }
+
+      // Rebuild the minimum structure the rest of Composer depends on so the space stays usable.
+      log.info('reset: rebuilding space root');
+      rebuildSpaceRoot(space);
+
+      log.info('reset: flushing');
+      await space.db.flush();
+      log.info('reset: flushed');
+
+      log.info('reset: creating epoch');
+      try {
+        await space.internal.createEpoch();
+        log.info('reset: epoch created');
+      } catch (err) {
+        log.error('reset: createEpoch threw', {
+          error: err instanceof Error ? err.message : String(err),
+        });
+        throw err;
+      }
+
+      const afterEntities = snapshotEntities(space);
+      const afterSchemas = space.db.schemaRegistry.query().runSync();
+      const afterFeeds =
+        (space.internal.data.pipeline?.controlFeeds?.length ?? 0) +
+        (space.internal.data.pipeline?.dataFeeds?.length ?? 0);
+      log.info('reset: done', {
+        spaceId: space.id,
+        remainingEntities: afterEntities.length,
+        remainingSchemas: afterSchemas.length,
+        remainingFeeds: afterFeeds,
+        remainingTypes: afterEntities.map((entity) => Obj.getTypename(entity) ?? '<unknown>'),
+      });
+    }),
+  ),
+);
+export default handler;
+
+/**
+ * Returns a synchronous snapshot of every entity in the space's database.
+ *
+ * We deliberately avoid `query.run()` here. In a live Composer environment,
+ * `space.db.query(Filter.everything()).run()` never resolves (the call hangs until the
+ * operation runtime cancels it at 30s), even though it works fine in node unit tests
+ * against a fresh in-memory client. `run()` waits for every query source to reach a
+ * stable state, and the indexed-storage source apparently never reports "done" for the
+ * everything-filter. Subscribing primes the local source and `runSync()` then returns
+ * the in-memory results immediately.
+ */
+const snapshotEntities = (space: Space): Obj.Unknown[] => {
+  const query = space.db.query(Filter.everything());
+  const unsubscribe = query.subscribe(() => {}, { fire: true });
+  try {
+    return query.runSync() as Obj.Unknown[];
+  } finally {
+    unsubscribe();
+  }
+};
+
+/**
+ * Schema-defined keys on `SpaceProperties` that survive a reset. Anything else on the open
+ * `{ key: string, value: any }` record (Ref to the root Collection, plugin-specific anchors, etc.)
+ * points to objects we just removed — leaving those refs in place produces "not found" errors in
+ * containers that load them. We blank them out and re-seed the root Collection so the navtree
+ * has something to render.
+ */
+const SPACE_PROPERTY_TYPED_KEYS = new Set<string>([
+  'archived',
+  'edgeReplication',
+  'invocationTraceFeed',
+  'computeEnvironment',
+  'name',
+  'icon',
+  'hue',
+]);
+
+const rebuildSpaceRoot = (space: Space): void => {
+  const properties = space.properties;
+  const versionKey = Migrations.versionProperty;
+  const preservedVersion = versionKey ? (properties as Record<string, any>)[versionKey] : undefined;
+  const cleared: string[] = [];
+
+  Obj.update(properties, (properties) => {
+    const record = properties as unknown as Record<string, any>;
+    for (const key of Object.keys(record)) {
+      if (key === 'id' || key === '@meta') {
+        continue;
+      }
+      if (SPACE_PROPERTY_TYPED_KEYS.has(key)) {
+        continue;
+      }
+      if (versionKey && key === versionKey) {
+        continue;
+      }
+      delete record[key];
+      cleared.push(key);
+    }
+
+    // Re-seed the root Collection (the navtree anchor).
+    record[Collection.Collection.typename] = Ref.make(Collection.make());
+
+    // Make sure the migrations version still pins the schema at the latest known target so the
+    // reloaded space doesn't fall into SPACE_REQUIRES_MIGRATION.
+    if (versionKey) {
+      record[versionKey] = preservedVersion ?? Migrations.targetVersion;
+    }
+  });
+
+  log.info('reset: space root rebuilt', { cleared });
+};

package/src/operations/restore-field.ts

@@ -0,0 +1,36 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from '@dxos/schema';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.RestoreField> = SpaceOperation.RestoreField.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (input) {
+      const registry = yield* Capability.get(Capabilities.AtomRegistry);
+      const view = input.view as any;
+      const db = Obj.getDatabase(view);
+      invariant(db);
+      const typename = getTypenameFromQuery(view.query.ast);
+      invariant(typename);
+      const schema = yield* Effect.promise(() => db.schemaRegistry.query({ typename }).firstOrUndefined());
+      invariant(schema);
+
+      const projection = new ProjectionModel({
+        registry,
+        view,
+        baseSchema: schema.jsonSchema,
+        change: createEchoChangeCallback(view, schema),
+      });
+
+      projection.setFieldProjection({ field: input.field, props: input.props }, input.index);
+    }),
+  ),
+);
+export default handler;