@dxos/plugin-space 0.8.4-main.422d1c7879 → 0.8.4-main.43cb759274

package/src/capabilities/app-graph-builder/extensions/{types.ts → database.ts}

@@ -6,27 +6,26 @@ import { type Atom } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
 import * as Match from 'effect/Match';
 import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
 
-import { Capability } from '@dxos/app-framework';
-import { AppCapabilities, AppNode, LayoutOperation, Segments } from '@dxos/app-toolkit';
+import { Capability, type CapabilityManager } from '@dxos/app-framework';
+import { AppNode, AppNodeMatcher, LayoutOperation, Segments } from '@dxos/app-toolkit';
 import { type Space, SpaceState, isSpace } from '@dxos/client/echo';
-import { Collection, Filter, Obj, Query, Type } from '@dxos/echo';
+import { Operation } from '@dxos/compute';
+import { Annotation, Collection, Filter, Obj, Query, Scope, Type } from '@dxos/echo';
 import { AtomObj, AtomQuery } from '@dxos/echo-atom';
-import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
-import { Operation } from '@dxos/operation';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { HiddenAnnotation } from '@dxos/echo/internal';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { CreateAtom, GraphBuilder, Node } from '@dxos/plugin-graph';
 import { ViewAnnotation } from '@dxos/schema';
 import { createFilename, isNonNullable } from '@dxos/util';
 
 import { meta } from '#meta';
 import { SpaceOperation } from '#operations';
+import { SpaceCapabilities } from '#types';
 
 import {
   ADD_VIEW_TO_SCHEMA_LABEL,
   BLOCK_REORDER_ABOVE,
-  type MetadataResolver,
   SNAPSHOT_BY_SCHEMA_LABEL,
   STATIC_SCHEMA_TYPE,
   TYPES_SECTION_TYPE,
@@ -35,25 +34,21 @@ import {
   createObjectNode,
   downloadBlob,
   getDynamicLabel,
-  whenSpace,
 } from './shared';
 
 //
 // Extension Factory
 //
 
-/** Creates type-related extensions: types section, schema nodes, schema children, and schema actions. */
-export const createTypeExtensions = Effect.fnUntraced(function* () {
+/** Creates database extensions: types section, schema nodes, schema children, and schema actions. */
+export const createDatabaseExtensions = Effect.fnUntraced(function* () {
   const capabilities = yield* Capability.Service;
 
-  const resolve = (_get: any) => (typename: string) =>
-    capabilities.getAll(AppCapabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
-
   return yield* Effect.all([
     // Types section virtual node under each space.
     GraphBuilder.createExtension({
-      id: 'types-section',
-      match: whenSpace,
+      id: 'typesSection',
+      match: AppNodeMatcher.whenSpace,
       connector: (space, get) => {
         const spaceState = get(CreateAtom.fromObservable(space.state));
         if (spaceState !== SpaceState.SPACE_READY) {
@@ -65,8 +60,9 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
             id: Segments.types,
             type: TYPES_SECTION_TYPE,
             label: ['types-section.label', { ns: meta.id }],
-            icon: 'ph--shapes--regular',
+            icon: 'ph--database--regular',
             space,
+            position: 'last',
             testId: 'spacePlugin.typesSection',
           }),
         ]);
@@ -81,21 +77,24 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
         return node.type === TYPES_SECTION_TYPE && space ? Option.some(space) : Option.none();
       },
       connector: (space, get) => {
+        // Persisted types live in the space db; static/runtime types live in the shared registry.
+        // Fan across both so the space's own types appear without leaking other spaces' types.
         const allSchemas = get(
-          AtomQuery.fromQuery(space.db.schemaRegistry.query({ location: ['database', 'runtime'] })),
+          AtomQuery.make(space.db, Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry())),
         );
 
-        const userSchemas = allSchemas.filter((schema) => {
-          if (getTypeAnnotation(schema)?.kind === EntityKind.Relation) {
+        const userSchemas = allSchemas.filter((type) => {
+          if (Type.isRelation(type)) {
             return false;
           }
-          if (SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false))) {
+          if (Type.isTypeKind(type)) {
             return false;
           }
-          if (ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false))) {
+          const schema = Type.getSchema(type);
+          if (HiddenAnnotation.get(schema).pipe(Option.getOrElse(() => false))) {
             return false;
           }
-          if (Type.getTypename(schema) === Collection.Collection.typename) {
+          if (Type.getTypename(type) === Type.getTypename(Collection.Collection)) {
             return false;
           }
           return true;
@@ -104,36 +103,33 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
         const viewIndex = buildViewIndex(get, space, allSchemas);
 
         const visibleSchemas = userSchemas.filter((schema) => {
-          if (Type.isMutable(schema)) {
+          if (Type.getDatabase(schema) != null) {
             return true;
           }
           const typename = Type.getTypename(schema);
           const objects = get(AtomQuery.make(space.db, Filter.typename(typename)));
+          if (ViewAnnotation.has(schema)) {
+            return objects.some((obj) => !viewIndex.isView(obj));
+          }
           return objects.length > 0 || viewIndex.typenamesWithViews.has(typename);
         });
 
-        return Effect.succeed(
-          visibleSchemas.map((schema) => createSchemaNode({ schema, space, resolve: resolve(get), get })),
-        );
+        return Effect.succeed(visibleSchemas.map((schema) => createSchemaNode({ schema, space, get })));
       },
     }),
 
     // {All} virtual node + view objects under each schema node.
     GraphBuilder.createExtension({
-      id: 'schema-children',
+      id: 'schemaChildren',
       match: (node) => {
         const space = isSpace(node.properties.space) ? node.properties.space : undefined;
-        return space && (Obj.instanceOf(Type.PersistentType, node.data) || Schema.isSchema(node.data))
-          ? Option.some({ space, schema: node.data })
-          : Option.none();
+        return space && Type.isType(node.data) ? Option.some({ space, schema: node.data }) : Option.none();
       },
       connector: ({ space, schema }, get) => {
         const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
-        const schemas = client
-          ? get(AtomQuery.fromQuery(client.graph.schemaRegistry.query({ location: ['runtime'] })))
-          : [];
+        const schemas = client ? get(AtomQuery.make(client.graph.registry, Filter.type(Type.Type))) : [];
 
-        const typename = Schema.isSchema(schema) ? Type.getTypename(schema as Type.AnyObj) : schema.typename;
+        const typename = Type.getTypename(schema);
 
         // {All} virtual node.
         const allNode = Node.make({
@@ -157,12 +153,11 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
         // View objects for this schema.
         const viewIndex = buildViewIndex(get, space, schemas);
         const viewNodes = viewIndex
-          .getViewsForTypename(typename)
+          .getViewsForTypename(typename!)
           .map((object: Obj.Unknown) =>
             createObjectNode({
               db: space.db,
               object,
-              resolve: resolve(get),
               droppable: false,
             }),
           )
@@ -174,7 +169,7 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
 
     // Objects of the schema type under the {All} node.
     GraphBuilder.createExtension({
-      id: 'type-collection-objects',
+      id: 'typeCollectionObjects',
       match: (node) => {
         if (node.type !== TYPE_COLLECTION_TYPE || !node.data?.space || !node.data?.typename) {
           return Option.none();
@@ -182,7 +177,12 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
         return Option.some({ space: node.data.space as Space, typename: node.data.typename as string });
       },
       connector: ({ space, typename }, get) => {
-        const objects = get(AtomQuery.make(space.db, Filter.typename(typename)));
+        const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
+        const schemas = client ? get(AtomQuery.make(client.graph.registry, Filter.type(Type.Type))) : [];
+        const viewIndex = buildViewIndex(get, space, schemas);
+        const objects = get(AtomQuery.make(space.db, Filter.typename(typename))).filter(
+          (object: Obj.Unknown) => !viewIndex.isView(object) && !Obj.getParent(object),
+        );
 
         return Effect.succeed(
           objects
@@ -191,7 +191,6 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
               return createObjectNode({
                 db: space.db,
                 object,
-                resolve: resolve(get),
                 droppable: false,
               });
             })
@@ -207,30 +206,21 @@ export const createTypeExtensions = Effect.fnUntraced(function* () {
 
     // Actions for schema nodes.
     GraphBuilder.createExtension({
-      id: 'schema-actions',
+      id: 'schemaActions',
       match: (node) => {
         const space = isSpace(node.properties.space) ? node.properties.space : undefined;
-        return space && Schema.isSchema(node.data) ? Option.some({ space, schema: node.data }) : Option.none();
+        return space && Type.isType(node.data) ? Option.some({ space, schema: node.data }) : Option.none();
       },
       actions: ({ space, schema }, get) => {
         const client = get(capabilities.atom(ClientCapabilities.Client)).at(0);
-        const schemas = client
-          ? get(AtomQuery.fromQuery(client.graph.schemaRegistry.query({ location: ['runtime'] })))
-          : [];
+        const schemas = client ? get(AtomQuery.make(client.graph.registry, Filter.type(Type.Type))) : [];
 
-        const targetTypename = Type.getTypename(schema as Type.AnyObj);
+        const targetTypename = Type.getTypename(schema);
         const viewIndex = buildViewIndex(get, space, schemas);
         const deletable =
-          Type.isMutable(schema as Type.AnyObj) && viewIndex.getViewsForTypename(targetTypename).length === 0;
+          Type.getDatabase(schema) != null && viewIndex.getViewsForTypename(targetTypename).length === 0;
 
-        return Effect.succeed(
-          createSchemaActions({
-            schema: schema as Type.AnyObj,
-            space,
-            deletable,
-            resolve: resolve(get),
-          }),
-        );
+        return Effect.succeed(createSchemaActions({ type: schema, space, deletable, capabilities }));
       },
     }),
   ]);
@@ -254,32 +244,39 @@ const uniqueSchemasByTypename = <TSchema extends Type.AnyEntity>(schemas: TSchem
 const createSchemaNode = ({
   schema,
   space,
-  resolve,
   get,
 }: {
   schema: Type.AnyEntity;
   space: Space;
-  resolve: MetadataResolver;
   get: Atom.Context;
 }): Node.NodeArg<Type.AnyEntity> => {
   const typename = Type.getTypename(schema);
-  const metadata = resolve(typename);
+  const iconAnnotation =
+    Type.getDatabase(schema) == null
+      ? Option.getOrUndefined(Annotation.IconAnnotation.get(Type.getSchema(schema)))
+      : undefined;
   const { label, nodeId } = Match.value(schema).pipe(
-    Match.when(Type.isMutable, (mutableSchema) => {
-      const persistentSchema = mutableSchema.persistentSchema;
-      const snapshot = get(AtomObj.make(persistentSchema));
-      return {
-        label: snapshot.name || ['object-name.placeholder', { ns: Type.PersistentType.typename }],
-        nodeId: typename,
-      };
-    }),
+    Match.when(
+      (value: Type.AnyEntity) => Type.getDatabase(value) != null,
+      (mutableSchema) => {
+        const snapshot = get(AtomObj.make(mutableSchema));
+        return {
+          label: (snapshot as { name?: string }).name || [
+            'object-name.placeholder',
+            { ns: Type.getTypename(Type.Type) },
+          ],
+          nodeId: typename,
+        };
+      },
+    ),
     Match.orElse(() => ({
-      label: getDynamicLabel('typename.label', typename, { count: 2, default: typename }),
+      label: getDynamicLabel('typename.label', typename, { count: 2, defaultValue: typename }),
       nodeId: typename,
     })),
   );
-  const icon = Type.isMutable(schema) ? 'ph--cube--regular' : (metadata.icon ?? 'ph--placeholder--regular');
-  const iconHue = Type.isMutable(schema) ? 'neutral' : metadata.iconHue;
+  const icon =
+    Type.getDatabase(schema) != null ? 'ph--cube--regular' : (iconAnnotation?.icon ?? 'ph--circle-dashed--regular');
+  const iconHue = Type.getDatabase(schema) != null ? 'neutral' : iconAnnotation?.hue;
   return Node.make({
     id: nodeId,
     type: STATIC_SCHEMA_TYPE,
@@ -301,20 +298,22 @@ const createSchemaNode = ({
 
 /** Builds schema actions (add view, rename, delete, snapshot). */
 const createSchemaActions = ({
-  schema,
+  type,
   space,
   deletable,
-  resolve,
+  capabilities,
 }: {
-  schema: Type.AnyObj;
+  type: Type.AnyEntity;
   space: Space;
   deletable: boolean;
-  resolve: MetadataResolver;
+  capabilities: CapabilityManager.CapabilityManager;
 }) => {
-  const typename = Type.getTypename(schema);
-  const metadata = resolve(typename);
-  const createObjectFn = metadata.createObject;
-  const inputSchema = metadata.inputSchema;
+  const typename = Type.getTypename(type);
+  const createEntry = capabilities
+    .getAll(SpaceCapabilities.CreateObjectEntry)
+    .find((entry: SpaceCapabilities.CreateObjectEntry) => entry.id === typename);
+  const createObjectFn = createEntry?.createObject;
+  const inputSchema = createEntry?.inputSchema;
 
   const actions: Node.NodeArg<Node.ActionData<Operation.Service>>[] = [
     ...(createObjectFn
@@ -328,11 +327,9 @@ const createSchemaActions = ({
                   typename,
                 });
               } else {
-                const result = yield* createObjectFn({}, { db: space.db, target: space.db }) as Effect.Effect<
-                  { subject: readonly string[] },
-                  Error,
-                  never
-                >;
+                const result = yield* createObjectFn({}, { db: space.db, target: space.db }).pipe(
+                  Effect.provideService(Capability.Service, capabilities),
+                );
                 if (result.subject.length > 0) {
                   yield* Operation.invoke(LayoutOperation.Open, {
                     subject: [...result.subject],
@@ -356,7 +353,7 @@ const createSchemaActions = ({
         Operation.invoke(SpaceOperation.OpenCreateObject, {
           target: space.db,
           views: true,
-          initialFormValues: { typename: Type.getTypename(schema) },
+          initialFormValues: { typename: Type.getTypename(type) },
         }),
       properties: {
         label: ADD_VIEW_TO_SCHEMA_LABEL,
@@ -368,16 +365,16 @@ const createSchemaActions = ({
     Node.makeAction({
       id: SpaceOperation.RenameObject.meta.key,
       data: (params?: Node.InvokeProps) =>
-        Type.isMutable(schema)
+        Type.getDatabase(type) != null
           ? Operation.invoke(SpaceOperation.RenameObject, {
-              object: (schema as Type.RuntimeType).persistentSchema as any,
+              object: type,
               caller: `${params?.caller}:${params?.parent?.id}`,
             })
           : Effect.fail(new Error('Cannot rename immutable schema')),
       properties: {
-        label: getDynamicLabel('rename object label', Type.getTypename(Type.PersistentType)),
+        label: getDynamicLabel('rename-object.label', Type.getTypename(Type.Type)),
         icon: 'ph--pencil-simple-line--regular',
-        disabled: !Type.isMutable(schema),
+        disabled: Type.getDatabase(type) == null,
         disposition: 'list-item',
         testId: 'spacePlugin.renameObject',
       },
@@ -385,13 +382,13 @@ const createSchemaActions = ({
     Node.makeAction({
       id: SpaceOperation.RemoveObjects.meta.key,
       data: () =>
-        Type.isMutable(schema)
+        Type.getDatabase(type) != null
           ? Operation.invoke(SpaceOperation.RemoveObjects, {
-              objects: [(schema as Type.RuntimeType).persistentSchema as Obj.Unknown],
+              objects: [type],
             })
           : Effect.succeed(undefined),
       properties: {
-        label: getDynamicLabel('delete object label', Type.getTypename(Type.PersistentType)),
+        label: getDynamicLabel('delete object label', Type.getTypename(Type.Type)),
         icon: 'ph--trash--regular',
         disposition: 'list-item',
         disabled: !deletable,
@@ -403,11 +400,11 @@ const createSchemaActions = ({
       data: Effect.fnUntraced(function* () {
         const result = yield* Operation.invoke(SpaceOperation.Snapshot, {
           db: space.db,
-          query: Query.select(Filter.type(schema)).ast,
+          query: Query.select(Filter.type(type)).ast,
         });
         if (result.snapshot) {
           yield* Effect.tryPromise(() =>
-            downloadBlob(result.snapshot, createFilename({ parts: [space.id, Type.getTypename(schema)], ext: 'json' })),
+            downloadBlob(result.snapshot, createFilename({ parts: [space.id, Type.getTypename(type)], ext: 'json' })),
           );
         }
       }),

package/src/capabilities/app-graph-builder/extensions/index.ts

@@ -3,7 +3,7 @@
 //
 
 export { createSpaceExtensions } from './spaces';
-export { createTypeExtensions } from './types';
+export { createDatabaseExtensions } from './database';
 export { createCollectionExtensions } from './collections';
 export { createCompanionExtensions } from './companions';
 export { createSettingsExtensions } from './settings';

package/src/capabilities/app-graph-builder/extensions/settings.ts

@@ -3,23 +3,54 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 
-import { isPersonalSpace } from '@dxos/app-toolkit';
-import { GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
+import { AppNode, AppNodeMatcher, isPersonalSpace } from '@dxos/app-toolkit';
+import { type Space, isSpace } from '@dxos/client/echo';
+import { GraphBuilder, Node } from '@dxos/plugin-graph';
 
 import { meta } from '#meta';
+import { SETTINGS_SECTION_ID, SETTINGS_SECTION_TYPE } from '#types';
 
 //
 // Extension Factory
 //
 
-/** Creates the settings-sections extension for space settings panel. */
+/**
+ * Settings section attached directly under each Space node, plus its children.
+ *
+ * The virtual `settings` section is pinned to the top via `position: 'first'`
+ * so it sits above the un-positioned middle band (collections, mailboxes,
+ * automations, integrations, etc.). It groups the panels contributed by this
+ * plugin (general, members) and by other plugins (automation, functions).
+ */
 export const createSettingsExtensions = Effect.fnUntraced(function* () {
-  const extension = yield* GraphBuilder.createExtension({
-    id: 'settings-sections',
-    match: NodeMatcher.whenNodeType(`${meta.id}.settings`),
-    connector: (node) => {
-      const personal = node.properties.space && isPersonalSpace(node.properties.space);
+  const sectionExtension = yield* GraphBuilder.createExtension({
+    id: 'settingsSection',
+    match: AppNodeMatcher.whenSpace,
+    connector: (space) =>
+      Effect.succeed([
+        AppNode.makeSection({
+          id: SETTINGS_SECTION_ID,
+          type: SETTINGS_SECTION_TYPE,
+          label: ['settings-section.label', { ns: meta.id }],
+          icon: 'ph--sliders--regular',
+          iconHue: 'indigo',
+          space,
+          position: 'first',
+          testId: 'spacePlugin.settings',
+        }),
+      ]),
+  });
+
+  const childrenExtension = yield* GraphBuilder.createExtension({
+    id: 'settingsSections',
+    match: (node) => {
+      const space = isSpace(node.properties.space) ? (node.properties.space as Space) : undefined;
+      return node.type === SETTINGS_SECTION_TYPE && space ? Option.some(space) : Option.none();
+    },
+    connector: (space) => {
+      const personal = isPersonalSpace(space);
       return Effect.succeed([
         Node.make({
           id: 'general',
@@ -27,8 +58,9 @@ export const createSettingsExtensions = Effect.fnUntraced(function* () {
           data: `${meta.id}.general`,
           properties: {
             label: ['space-settings-properties.label', { ns: meta.id }],
-            icon: 'ph--sliders--regular',
-            position: 'hoist',
+            icon: 'ph--brackets-curly--regular',
+            iconHue: 'indigo',
+            space,
             testId: 'spacePlugin.general',
           },
         }),
@@ -41,24 +73,16 @@ export const createSettingsExtensions = Effect.fnUntraced(function* () {
                 properties: {
                   label: ['members-panel.label', { ns: meta.id }],
                   icon: 'ph--users--regular',
-                  position: 'hoist',
+                  iconHue: 'indigo',
+                  space,
                   testId: 'spacePlugin.members',
                 },
               }),
             ]
           : []),
-        Node.make({
-          id: 'schema',
-          type: `${meta.id}.schema`,
-          data: `${meta.id}.schema`,
-          properties: {
-            label: ['space-settings-schema.label', { ns: meta.id }],
-            icon: 'ph--shapes--regular',
-            testId: 'spacePlugin.schema',
-          },
-        }),
       ]);
     },
   });
-  return [extension];
+
+  return [sectionExtension, childrenExtension];
 });

package/src/capabilities/app-graph-builder/extensions/shared.test.ts

@@ -6,32 +6,23 @@ import * as Registry from '@effect-atom/atom/Registry';
 import * as Schema from 'effect/Schema';
 import { afterEach, beforeEach, describe, test } from 'vitest';
 
-import { Filter, Obj, Query, Ref, Type, View } from '@dxos/echo';
+import { type Space, SpaceState } from '@dxos/client/echo';
+import { Annotation, DXN, Entity, Filter, Obj, Query, Ref, Type, View } from '@dxos/echo';
 import { type EchoDatabase } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { MigrationVersionAnnotation, Migrations } from '@dxos/migrations';
 import { ViewAnnotation } from '@dxos/schema';
 
-import { buildViewIndex } from './shared';
+import { buildViewIndex, checkPendingMigration } from './shared';
 
 const TestContact = Schema.Struct({
   name: Schema.String,
-}).pipe(
-  Type.object({
-    typename: 'test/Contact',
-    version: '0.1.0',
-  }),
-);
+}).pipe(Type.makeObject(DXN.make('com.example.type.contact', '0.1.0')));
 
 const TestViewWrapper = Schema.Struct({
   name: Schema.optional(Schema.String),
   view: Ref.Ref(View.View),
-}).pipe(
-  Type.object({
-    typename: 'test/ViewWrapper',
-    version: '0.1.0',
-  }),
-  ViewAnnotation.set(true),
-);
+}).pipe(ViewAnnotation.set(['view']), Type.makeObject(DXN.make('com.example.type.viewWrapper', '0.1.0')));
 
 describe('buildViewIndex', () => {
   let testBuilder: EchoTestBuilder;
@@ -58,7 +49,10 @@ describe('buildViewIndex', () => {
     db.add(Obj.make(TestViewWrapper, { view: Ref.make(viewObj) }));
     await db.flush();
 
-    const allSchemas = db.schemaRegistry.query({ location: ['runtime'] }).runSync();
+    const allSchemas = db.graph.registry
+      .list()
+      .filter(Type.isType)
+      .filter((t) => !Type.isTypeKind(t));
     const viewIndex = buildViewIndex(registry.get.bind(registry) as any, { db } as any, allSchemas);
 
     expect(viewIndex.typenamesWithViews.has(Type.getTypename(TestContact))).toBe(true);
@@ -73,7 +67,10 @@ describe('buildViewIndex', () => {
     db.add(Obj.make(TestViewWrapper, { view: Ref.make(viewObj) }));
     await db.flush();
 
-    const allSchemas = db.schemaRegistry.query({ location: ['runtime'] }).runSync();
+    const allSchemas = db.graph.registry
+      .list()
+      .filter(Type.isType)
+      .filter((t) => !Type.isTypeKind(t));
     const viewIndex = buildViewIndex(registry.get.bind(registry) as any, { db } as any, allSchemas);
 
     expect(viewIndex.typenamesWithViews.has(Type.getTypename(TestContact))).toBe(false);
@@ -89,7 +86,10 @@ describe('buildViewIndex', () => {
     const tableView = db.add(Obj.make(TestViewWrapper, { view: Ref.make(viewObj) }));
     await db.flush();
 
-    const allSchemas = db.schemaRegistry.query({ location: ['runtime'] }).runSync();
+    const allSchemas = db.graph.registry
+      .list()
+      .filter(Type.isType)
+      .filter((t) => !Type.isTypeKind(t));
     const viewIndex = buildViewIndex(registry.get.bind(registry) as any, { db } as any, allSchemas);
 
     const views = viewIndex.getViewsForTypename(Type.getTypename(TestContact));
@@ -100,13 +100,71 @@ describe('buildViewIndex', () => {
   test('returns empty index when no view schemas exist', async ({ expect }) => {
     await db.flush();
 
-    const userSchemas = db.schemaRegistry
-      .query({ location: ['runtime'] })
-      .runSync()
-      .filter((schema) => !ViewAnnotation.get(schema).pipe((opt) => opt._tag === 'Some' && opt.value));
+    const userSchemas = db.graph.registry
+      .list()
+      .filter(Type.isType)
+      .filter((t) => !Type.isTypeKind(t))
+      .filter((schema) => !ViewAnnotation.has(schema));
     const viewIndex = buildViewIndex(registry.get.bind(registry) as any, { db } as any, userSchemas);
 
     expect(viewIndex.typenamesWithViews.size).toBe(0);
     expect(viewIndex.getViewsForTypename(Type.getTypename(TestContact))).toHaveLength(0);
   });
 });
+
+describe('checkPendingMigration', () => {
+  const TARGET = '1970-01-02';
+
+  // Minimal fake exercising only the fields checkPendingMigration reads (state, properties).
+  // Must pass isEntity (checks for Entity.KindId) and have Obj.Meta so Annotation.get works.
+  const makeFakeProperties = (version?: string): Record<string | symbol, unknown> => {
+    const annotations: Record<string, unknown> = {};
+    if (version !== undefined) {
+      Annotation.setDictionary(annotations as any, MigrationVersionAnnotation, version);
+    }
+    return {
+      [Entity.KindId]: Entity.Kind.Object,
+      [Obj.Meta]: { keys: [], annotations },
+    };
+  };
+
+  const makeFakeSpace = (state: SpaceState, version?: string): Space =>
+    ({ state: { get: () => state }, properties: makeFakeProperties(version) }) as unknown as Space;
+
+  let savedNamespace: string | undefined;
+  let savedMigrations: typeof Migrations.migrations;
+
+  beforeEach(() => {
+    savedNamespace = Migrations.namespace;
+    savedMigrations = Migrations.migrations;
+    Migrations.define('test', [
+      { version: '1970-01-01', next: async () => {} },
+      { version: TARGET, next: async () => {} },
+    ]);
+  });
+
+  afterEach(() => {
+    Migrations.namespace = savedNamespace;
+    Migrations.migrations = savedMigrations;
+  });
+
+  test('SPACE_REQUIRES_MIGRATION is pending regardless of version property', ({ expect }) => {
+    const space = makeFakeSpace(SpaceState.SPACE_REQUIRES_MIGRATION, TARGET);
+    expect(checkPendingMigration(space)).toBe(true);
+  });
+
+  test('READY with version matching target is not pending', ({ expect }) => {
+    const space = makeFakeSpace(SpaceState.SPACE_READY, TARGET);
+    expect(checkPendingMigration(space)).toBe(false);
+  });
+
+  test('READY with undefined version is pending (legacy property-migration preserved)', ({ expect }) => {
+    const space = makeFakeSpace(SpaceState.SPACE_READY);
+    expect(checkPendingMigration(space)).toBe(true);
+  });
+
+  test('READY with stale version is pending', ({ expect }) => {
+    const space = makeFakeSpace(SpaceState.SPACE_READY, '1970-01-01');
+    expect(checkPendingMigration(space)).toBe(true);
+  });
+});