@dxos/plugin-space 0.8.4-main.2e9d522 → 0.8.4-main.3c1ae3b

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

@@ -2,38 +2,42 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
-import { Array, Option, pipe, Schema } from 'effect';
-
-import { Capabilities, contributes, createIntent, type PluginContext } from '@dxos/app-framework';
-import { getSpace, SpaceState, type Space, isSpace, type QueryResult } from '@dxos/client/echo';
-import { Filter, Obj, Query, Type } from '@dxos/echo';
+import { Atom } from '@effect-atom/atom-react';
+import * as Array from 'effect/Array';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+
+import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { type Space, SpaceState, getSpace, isSpace } from '@dxos/client/echo';
+import { DXN, type Entity, Filter, Obj, type QueryResult, Type } from '@dxos/echo';
 import { log } from '@dxos/log';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { PLANK_COMPANION_TYPE, ATTENDABLE_PATH_SEPARATOR } from '@dxos/plugin-deck/types';
-import { createExtension, rxFromObservable, ROOT_ID, rxFromSignal } from '@dxos/plugin-graph';
-import { DataType } from '@dxos/schema';
+import { ATTENDABLE_PATH_SEPARATOR, PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
+import { ROOT_ID, atomFromObservable, atomFromSignal, createExtension } from '@dxos/plugin-graph';
+import { Collection, ViewAnnotation, getTypenameFromQuery } from '@dxos/schema';
 import { isNonNullable } from '@dxos/util';
 
-import { SpaceCapabilities } from './capabilities';
 import { getActiveSpace } from '../hooks';
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { SPACE_TYPE, SpaceAction, type SpaceSettingsProps } from '../types';
 import {
+  SHARED,
+  SPACES,
+  atomFromQuery,
   constructObjectActions,
   constructSpaceActions,
   constructSpaceNode,
   createObjectNode,
   createStaticSchemaActions,
   createStaticSchemaNode,
-  rxFromQuery,
-  SHARED,
-  SPACES,
 } from '../util';
 
+import { SpaceCapabilities } from './capabilities';
+
 export default (context: PluginContext) => {
-  // TODO(wittjosiah): Make reactive.
-  const resolve = (typename: string) =>
+  // TODO(wittjosiah): Using `get` and being reactive seems to cause a bug with Atom where disposed atoms are accessed.
+  const resolve = (get: Atom.Context) => (typename: string) =>
     context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {};
 
   const spacesNode = {
@@ -41,7 +45,7 @@ export default (context: PluginContext) => {
     type: SPACES,
     cacheable: ['label', 'role'],
     properties: {
-      label: ['spaces label', { ns: SPACE_PLUGIN }],
+      label: ['spaces label', { ns: meta.id }],
       icon: 'ph--planet--regular',
       testId: 'spacePlugin.spaces',
       role: 'branch',
@@ -61,9 +65,7 @@ export default (context: PluginContext) => {
           nextOrder.map(({ id }) => id),
         );
 
-        const {
-          objects: [spacesOrder],
-        } = await client.spaces.default.db.query(Filter.type(Type.Expando, { key: SHARED })).run();
+        const [spacesOrder] = await client.spaces.default.db.query(Filter.type(Type.Expando, { key: SHARED })).run();
         if (spacesOrder) {
           spacesOrder.order = nextOrder.map(({ id }) => id);
         } else {
@@ -76,11 +78,11 @@ export default (context: PluginContext) => {
   return contributes(Capabilities.AppGraphBuilder, [
     // Primary actions.
     createExtension({
-      id: `${SPACE_PLUGIN}/primary-actions`,
+      id: `${meta.id}/primary-actions`,
       position: 'hoist',
       actions: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
             Option.map(() => [
@@ -91,7 +93,7 @@ export default (context: PluginContext) => {
                   await dispatch(createIntent(SpaceAction.OpenCreateSpace));
                 },
                 properties: {
-                  label: ['create space label', { ns: SPACE_PLUGIN }],
+                  label: ['create space label', { ns: meta.id }],
                   icon: 'ph--plus--regular',
                   testId: 'spacePlugin.createSpace',
                   disposition: 'menu',
@@ -104,7 +106,7 @@ export default (context: PluginContext) => {
                   await dispatch(createIntent(SpaceAction.Join));
                 },
                 properties: {
-                  label: ['join space label', { ns: SPACE_PLUGIN }],
+                  label: ['join space label', { ns: meta.id }],
                   icon: 'ph--sign-in--regular',
                   testId: 'spacePlugin.joinSpace',
                   disposition: 'menu',
@@ -119,7 +121,7 @@ export default (context: PluginContext) => {
                   await dispatch(createIntent(SpaceAction.OpenMembers, { space }));
                 },
                 properties: {
-                  label: ['share space label', { ns: SPACE_PLUGIN }],
+                  label: ['share space label', { ns: meta.id }],
                   icon: 'ph--users--regular',
                   testId: 'spacePlugin.shareSpace',
                   keyBinding: {
@@ -137,7 +139,7 @@ export default (context: PluginContext) => {
                   await dispatch(createIntent(SpaceAction.OpenSettings, { space }));
                 },
                 properties: {
-                  label: ['open current space settings label', { ns: SPACE_PLUGIN }],
+                  label: ['open current space settings label', { ns: meta.id }],
                   icon: 'ph--faders--regular',
                   keyBinding: {
                     macos: 'meta+shift+,',
@@ -153,44 +155,44 @@ export default (context: PluginContext) => {
 
     // Create spaces group node.
     createExtension({
-      id: `${SPACE_PLUGIN}/root`,
+      id: `${meta.id}/root`,
       position: 'hoist',
       connector: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
             Option.map(() => [spacesNode]),
             Option.getOrElse(() => []),
           ),
         ),
-      // resolver: ({ id }) => (id === SPACES ? spacesNode : undefined),
     }),
 
     // Create space nodes.
     createExtension({
       id: SPACES,
       connector: (node) => {
-        let query: QueryResult<Type.Expando> | undefined;
-        return Rx.make((get) =>
-          pipe(
+        // TODO(wittjosiah): Find a simpler way to define this type.
+        let query: QueryResult.QueryResult<Schema.Schema.Type<typeof Type.Expando>> | undefined;
+        return Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => (node.id === SPACES ? Option.some(node) : Option.none())),
             Option.map(() => {
               const state = context.getCapability(SpaceCapabilities.State);
               const client = context.getCapability(ClientCapabilities.Client);
-              const spacesRx = rxFromObservable(client.spaces);
-              const isReadyRx = rxFromObservable(client.spaces.isReady);
+              const spacesAtom = atomFromObservable(client.spaces);
+              const isReadyAtom = atomFromObservable(client.spaces.isReady);
 
-              const spaces = get(spacesRx);
-              const isReady = get(isReadyRx);
+              const spaces = get(spacesAtom);
+              const isReady = get(isReadyAtom);
 
               if (!spaces || !isReady) {
                 return [];
               }
 
               const settings = get(context.capabilities(Capabilities.SettingsStore))[0]?.getStore<SpaceSettingsProps>(
-                SPACE_PLUGIN,
+                meta.id,
               )?.value;
 
               // TODO(wittjosiah): During client reset, accessing default space throws.
@@ -198,9 +200,9 @@ export default (context: PluginContext) => {
                 if (!query) {
                   query = client.spaces.default.db.query(Filter.type(Type.Expando, { key: SHARED }));
                 }
-                const [spacesOrder] = get(rxFromQuery(query));
+                const [spacesOrder] = get(atomFromQuery(query));
                 return get(
-                  rxFromSignal(() => {
+                  atomFromSignal(() => {
                     const order: string[] = spacesOrder?.order ?? [];
                     const orderMap = new Map(order.map((id, index) => [id, index]));
                     return [
@@ -218,7 +220,7 @@ export default (context: PluginContext) => {
                           navigable: state.navigableCollections,
                           personal: space === client.spaces.default,
                           namesCache: state.spaceNames,
-                          resolve,
+                          resolve: resolve(get),
                         }),
                       );
                   }),
@@ -231,54 +233,14 @@ export default (context: PluginContext) => {
           ),
         );
       },
-      // resolver: ({ id }) => {
-      //   if (id.length !== SPACE_ID_LENGTH) {
-      //     return;
-      //   }
-
-      //   const client = context.requestCapability(ClientCapabilities.Client);
-      //   const spaces = toSignal(
-      //     (onChange) => client.spaces.subscribe(() => onChange()).unsubscribe,
-      //     () => client.spaces.get(),
-      //   );
-
-      //   const isReady = toSignal(
-      //     (onChange) => client.spaces.isReady.subscribe(() => onChange()).unsubscribe,
-      //     () => client.spaces.isReady.get(),
-      //   );
-
-      //   if (!spaces || !isReady) {
-      //     return;
-      //   }
-
-      //   const space = spaces.find((space) => space.id === id);
-      //   if (!space) {
-      //     return;
-      //   }
-
-      //   if (space.state.get() === SpaceState.SPACE_INACTIVE) {
-      //     return false;
-      //   } else if (space.state.get() !== SpaceState.SPACE_READY) {
-      //     return undefined;
-      //   } else {
-      //     const state = context.requestCapability(SpaceCapabilities.State);
-      //     return constructSpaceNode({
-      //       space,
-      //       navigable: state.navigableCollections,
-      //       personal: space === client.spaces.default,
-      //       namesCache: state.spaceNames,
-      //       resolve,
-      //     });
-      //   }
-      // },
     }),
 
     // Create space actions.
     createExtension({
-      id: `${SPACE_PLUGIN}/actions`,
+      id: `${meta.id}/actions`,
       actions: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) =>
               node.type === SPACE_TYPE && isSpace(node.data) ? Option.some(node.data) : Option.none(),
@@ -307,24 +269,24 @@ export default (context: PluginContext) => {
 
     // Create nodes for objects in the root collection of a space.
     createExtension({
-      id: `${SPACE_PLUGIN}/root-collection`,
+      id: `${meta.id}/root-collection`,
       connector: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) =>
               node.type === SPACE_TYPE && isSpace(node.data) ? Option.some(node.data) : Option.none(),
             ),
             Option.map((space) => {
               const state = context.getCapability(SpaceCapabilities.State);
-              const spaceState = get(rxFromObservable(space.state));
+              const spaceState = get(atomFromObservable(space.state));
               if (spaceState !== SpaceState.SPACE_READY) {
                 return [];
               }
 
               const collection = get(
-                rxFromSignal(
-                  () => space.properties[DataType.Collection.typename]?.target as DataType.Collection | undefined,
+                atomFromSignal(
+                  () => space.properties[Collection.Collection.typename]?.target as Collection.Collection | undefined,
                 ),
               );
               if (!collection) {
@@ -332,8 +294,8 @@ export default (context: PluginContext) => {
               }
 
               return get(
-                rxFromSignal(() =>
-                  pipe(
+                atomFromSignal(() =>
+                  Function.pipe(
                     collection.objects,
                     Array.map((object) => object.target),
                     Array.filter(isNonNullable),
@@ -341,7 +303,7 @@ export default (context: PluginContext) => {
                       createObjectNode({
                         space,
                         object,
-                        resolve,
+                        resolve: resolve(get),
                         navigable: state.navigableCollections,
                       }),
                     ),
@@ -355,29 +317,35 @@ export default (context: PluginContext) => {
         ),
     }),
 
-    // Create nodes for objects in a collection or by its fully qualified id.
+    // Create nodes for objects in a collection or by its DXN.
     createExtension({
-      id: `${SPACE_PLUGIN}/objects`,
+      id: `${meta.id}/objects`,
       connector: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) =>
-              Obj.instanceOf(DataType.Collection, node.data) ? Option.some(node.data) : Option.none(),
+              Obj.instanceOf(Collection.Collection, node.data) ? Option.some(node.data) : Option.none(),
             ),
             Option.map((collection) => {
               const state = context.getCapability(SpaceCapabilities.State);
               const space = getSpace(collection);
 
               return get(
-                rxFromSignal(() =>
-                  pipe(
+                atomFromSignal(() =>
+                  Function.pipe(
                     collection.objects,
                     Array.map((object) => object.target),
                     Array.filter(isNonNullable),
                     Array.map(
                       (object) =>
-                        space && createObjectNode({ object, space, resolve, navigable: state.navigableCollections }),
+                        space &&
+                        createObjectNode({
+                          object,
+                          space,
+                          resolve: resolve(get),
+                          navigable: state.navigableCollections,
+                        }),
                     ),
                     Array.filter(isNonNullable),
                   ),
@@ -387,110 +355,91 @@ export default (context: PluginContext) => {
             Option.getOrElse(() => []),
           ),
         ),
-      // resolver: ({ id }) => {
-      //   if (id.length !== FQ_ID_LENGTH) {
-      //     return;
-      //   }
-
-      //   const [spaceId, objectId] = id.split(':');
-      //   if (spaceId.length !== SPACE_ID_LENGTH && objectId.length !== OBJECT_ID_LENGTH) {
-      //     return;
-      //   }
-
-      //   const client = context.requestCapability(ClientCapabilities.Client);
-      //   const space = client.spaces.get().find((space) => space.id === spaceId);
-      //   if (!space) {
-      //     return;
-      //   }
-
-      //   const spaceState = toSignal(
-      //     (onChange) => space.state.subscribe(() => onChange()).unsubscribe,
-      //     () => space.state.get(),
-      //     space.id,
-      //   );
-      //   if (spaceState !== SpaceState.SPACE_READY) {
-      //     return;
-      //   }
-
-      //   const [object] = memoizeQuery(space, Query.select(Filter.ids(objectId)));
-      //   if (!object) {
-      //     return;
-      //   }
-
-      //   if (isDeleted(object)) {
-      //     return false;
-      //   } else {
-      //     const state = context.requestCapability(SpaceCapabilities.State);
-      //     return createObjectNode({ object, space, resolve, navigable: state.navigableCollections });
-      //   }
-      // },
+      resolver: (id) => {
+        let query: QueryResult.QueryResult<Entity.Unknown> | undefined;
+        return Atom.make((get) => {
+          const client = context.getCapability(ClientCapabilities.Client);
+          const dxn = DXN.tryParse(id)?.asEchoDXN();
+          if (!dxn || !dxn.spaceId) {
+            return null;
+          }
+
+          const space = client.spaces.get(dxn.spaceId);
+          if (!space) {
+            return null;
+          }
+
+          if (!query) {
+            query = space.db.query(Filter.id(dxn.echoId));
+          }
+
+          const object = get(atomFromQuery(query)).at(0);
+          if (!Obj.isObject(object)) {
+            return null;
+          }
+
+          return createObjectNode({
+            object,
+            space,
+            resolve: resolve(get),
+            disposition: 'hidden',
+          });
+        });
+      },
     }),
 
-    // Create nodes for objects in a query collection.
+    // Create object nodes for schema-based system collections.
     createExtension({
-      id: `${SPACE_PLUGIN}/query-collection-objects`,
+      id: `${meta.id}/system-collections`,
       connector: (node) => {
-        let query: QueryResult<Type.Expando> | undefined;
-        return Rx.make((get) =>
-          pipe(
+        // TODO(wittjosiah): Find a simpler way to define this type.
+        let query: QueryResult.QueryResult<Schema.Schema.Type<typeof Type.Expando>> | undefined;
+        return Atom.make((get) => {
+          const client = get(context.capabilities(ClientCapabilities.Client)).at(0);
+          return Function.pipe(
             get(node),
             Option.flatMap((node) =>
-              Obj.instanceOf(DataType.QueryCollection, node.data) ? Option.some(node.data) : Option.none(),
+              Obj.instanceOf(Collection.Managed, node.data) ? Option.some(node.data) : Option.none(),
             ),
             Option.flatMap((collection) => {
               const space = getSpace(collection);
-              return collection.query.typename && space
-                ? Option.some({ typename: collection.query.typename, space })
-                : Option.none();
+              // TODO(wittjosiah): Support reactive schema registry queries.
+              const schema = client?.graph.schemaRegistry
+                .query({ typename: collection.key, location: ['runtime'] })
+                .runSync()[0];
+              return space && schema ? Option.some({ space, schema }) : Option.none();
             }),
-            Option.map(({ typename, space }) => {
-              const state = context.getCapability(SpaceCapabilities.State);
+            Option.map(({ space, schema }) => {
               if (!query) {
-                query = space.db.query(
-                  Query.without(
-                    Query.select(Filter.typename(typename)),
-                    // TODO(wittjosiah): This query is broader than it should be.
-                    //   It will return all objects in the collection, not just the ones of the given type.
-                    //   However this works fine for now because this query is only used for exclusions.
-                    Query.select(Filter.typename(typename))
-                      .referencedBy(DataType.Collection, 'objects')
-                      .reference('objects'),
-                  ),
-                );
+                query = space.db.query(Filter.type(schema));
               }
-              return get(rxFromQuery(query))
+              return get(atomFromQuery(query))
                 .map((object) =>
-                  get(
-                    rxFromSignal(() =>
-                      createObjectNode({
-                        object,
-                        space,
-                        resolve,
-                        droppable: false, // Cannot rearrange query collections.
-                        navigable: state.navigableCollections,
-                      }),
-                    ),
-                  ),
+                  createObjectNode({
+                    object,
+                    space,
+                    managedCollectionChild: true,
+                    resolve: resolve(get),
+                  }),
                 )
                 .filter(isNonNullable);
             }),
             Option.getOrElse(() => []),
-          ),
-        );
+          );
+        });
       },
     }),
 
-    // Static schema records.
+    // Create branch nodes for static schema record types.
     createExtension({
-      id: `${SPACE_PLUGIN}/static-schemas`,
-      connector: (node) => {
-        const client = context.getCapability(ClientCapabilities.Client);
-        return Rx.make((get) =>
-          pipe(
+      id: `${meta.id}/static-schemas`,
+      connector: (node) =>
+        Atom.make((get) => {
+          const client = get(context.capabilities(ClientCapabilities.Client)).at(0);
+          return Function.pipe(
             get(node),
             Option.flatMap((node) =>
-              Obj.instanceOf(DataType.QueryCollection, node.data) &&
-              node.data.query.typename === DataType.StoredSchema.typename
+              Obj.instanceOf(Collection.Managed, node.data) && node.data.key === Type.getTypename(Type.PersistentType)
                 ? Option.some(node.data)
                 : Option.none(),
             ),
@@ -499,26 +448,36 @@ export default (context: PluginContext) => {
               return space?.properties.staticRecords ? Option.some(space) : Option.none();
             }),
             Option.map((space) => {
-              return get(rxFromSignal(() => (space.properties.staticRecords ?? []) as string[]))
-                .map((typename) =>
-                  client.graph.schemaRegistry.schemas.find((schema) => Type.getTypename(schema) === typename),
-                )
+              // TODO(wittjosiah): Support reactive schema registry queries.
+              return get(atomFromSignal(() => (space.properties.staticRecords ?? []) as string[]))
+                .map((typename) => client?.graph.schemaRegistry.query({ typename, location: ['runtime'] }).runSync()[0])
                 .filter(isNonNullable)
                 .map((schema) => createStaticSchemaNode({ schema, space }));
             }),
             Option.getOrElse(() => []),
-          ),
-        );
-      },
+          );
+        }),
     }),
 
-    // Create static schema actions.
+    // Create actions for static schema record types.
     createExtension({
-      id: `${SPACE_PLUGIN}/static-schema-actions`,
+      id: `${meta.id}/static-schema-actions`,
       actions: (node) => {
-        let query: QueryResult<DataType.View> | undefined;
-        return Rx.make((get) =>
-          pipe(
+        let query: QueryResult.QueryResult<Obj.Any> | undefined;
+        return Atom.make((get) => {
+          // TODO(wittjosiah): Support reactive schema registry queries.
+          const schemas =
+            get(context.capabilities(ClientCapabilities.Client))
+              .at(0)
+              ?.graph.schemaRegistry.query({ location: ['runtime'] })
+              .runSync() ?? [];
+          const filter = Filter.or(
+            ...schemas
+              .filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)))
+              .map((schema) => Filter.type(schema)),
+          );
+
+          return Function.pipe(
             get(node),
             Option.flatMap((node) => {
               const space = isSpace(node.properties.space) ? node.properties.space : undefined;
@@ -526,59 +485,88 @@ export default (context: PluginContext) => {
             }),
             Option.map(({ space, schema }) => {
               if (!query) {
-                // TODO(wittjosiah): Support filtering by nested properties (e.g. `query.typename`).
-                query = space.db.query(Filter.type(DataType.View));
+                // TODO(wittjosiah): Ideally this query would traverse the view reference & filter by the query ast.
+                // TODO(wittjosiah): Remove cast.
+                query = space.db.query(filter) as unknown as QueryResult.QueryResult<Obj.Any>;
               }
 
-              const views = get(rxFromQuery(query));
+              const objects = get(atomFromQuery(query));
               const filteredViews = get(
-                rxFromSignal(() =>
-                  // TODO(wittjosiah): Remove cast.
-                  views.filter((view) => view.query.typename === Type.getTypename(schema as Type.Obj.Any)),
+                atomFromSignal(() =>
+                  objects.filter(
+                    (viewObject) =>
+                      getTypenameFromQuery((viewObject as any).view.target?.query.ast) ===
+                      Type.getTypename(schema as Type.Obj.Any),
+                  ),
                 ),
               );
               const deletable = filteredViews.length === 0;
 
+              const [dispatcher] = get(context.capabilities(Capabilities.IntentDispatcher));
+              if (!dispatcher) {
+                return [];
+              }
+
               // TODO(wittjosiah): Remove cast.
-              return createStaticSchemaActions({ schema: schema as Type.Obj.Any, space, deletable });
+              return createStaticSchemaActions({
+                schema: schema as Type.Obj.Any,
+                space,
+                dispatch: dispatcher.dispatchPromise,
+                deletable,
+              });
             }),
             Option.getOrElse(() => []),
-          ),
-        );
+          );
+        });
       },
     }),
 
-    // Create nodes for schema views.
+    // Create nodes for views of record types.
     createExtension({
-      id: `${SPACE_PLUGIN}/schema-views`,
+      id: `${meta.id}/schema-views`,
       connector: (node) => {
-        let query: QueryResult<DataType.View> | undefined;
-        return Rx.make((get) =>
-          pipe(
+        let query: QueryResult.QueryResult<Obj.Any> | undefined;
+        return Atom.make((get) => {
+          // TODO(wittjosiah): Support reactive schema registry queries.
+          const schemas =
+            get(context.capabilities(ClientCapabilities.Client))
+              .at(0)
+              ?.graph.schemaRegistry.query({ location: ['runtime'] })
+              .runSync() ?? [];
+          const filter = Filter.or(
+            ...schemas
+              .filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)))
+              .map((schema) => Filter.type(schema)),
+          );
+
+          return Function.pipe(
             get(node),
             Option.flatMap((node) => {
               const space = getSpace(node.data) ?? (isSpace(node.properties.space) ? node.properties.space : undefined);
-              return space && (Obj.instanceOf(DataType.StoredSchema, node.data) || Schema.isSchema(node.data))
+              return space && (Obj.instanceOf(Type.PersistentType, node.data) || Schema.isSchema(node.data))
                 ? Option.some({ space, schema: node.data })
                 : Option.none();
             }),
             Option.map(({ space, schema }) => {
               if (!query) {
-                // TODO(wittjosiah): Support filtering by nested properties (e.g. `query.typename`).
-                query = space.db.query(Filter.type(DataType.View));
+                // TODO(wittjosiah): Ideally this query would traverse the view reference & filter by the query ast.
+                // TODO(wittjosiah): Remove cast.
+                query = space.db.query(filter) as unknown as QueryResult.QueryResult<Obj.Any>;
               }
 
-              // TODO(wittjosiah): Remove cast.
+              // TODO(wittjosiah): Remove casts.
               const typename = Schema.isSchema(schema) ? Type.getTypename(schema as Type.Obj.Any) : schema.typename;
-              return get(rxFromQuery(query))
-                .filter((view) => view.query.typename === typename)
-                .map((view) =>
+              return get(atomFromQuery(query))
+                .filter((object) =>
+                  get(atomFromSignal(() => getTypenameFromQuery((object as any).view.target?.query.ast) === typename)),
+                )
+                .map((object) =>
                   get(
-                    rxFromSignal(() =>
+                    atomFromSignal(() =>
                       createObjectNode({
-                        object: view,
+                        object,
                         space,
-                        resolve,
+                        resolve: resolve(get),
                         droppable: false,
                       }),
                     ),
@@ -587,35 +575,58 @@ export default (context: PluginContext) => {
                 .filter(isNonNullable);
             }),
             Option.getOrElse(() => []),
-          ),
-        );
+          );
+        });
       },
     }),
 
     // Create collection actions and action groups.
     createExtension({
-      id: `${SPACE_PLUGIN}/object-actions`,
+      id: `${meta.id}/object-actions`,
       actions: (node) => {
-        let query: QueryResult<DataType.View> | undefined;
-        return Rx.make((get) =>
-          pipe(
+        let query: QueryResult.QueryResult<Obj.Any> | undefined;
+        return Atom.make((get) => {
+          // TODO(wittjosiah): Support reactive schema registry queries.
+          const schemas =
+            get(context.capabilities(ClientCapabilities.Client))
+              .at(0)
+              ?.graph.schemaRegistry.query({ location: ['runtime'] })
+              .runSync() ?? [];
+          const filter = Filter.or(
+            ...schemas
+              .filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)))
+              .map((schema) => Filter.type(schema)),
+          );
+
+          return Function.pipe(
             get(node),
             Option.flatMap((node) => {
               const space = getSpace(node.data);
-              return space && Obj.isObject(node.data) ? Option.some({ space, object: node.data }) : Option.none();
+              return space && Obj.isObject(node.data) && Obj.getTypename(node.data) === node.type
+                ? Option.some({ space, object: node.data })
+                : Option.none();
             }),
             Option.flatMap(({ space, object }) => {
-              const isSchema = Obj.instanceOf(DataType.StoredSchema, object);
+              const isSchema = Obj.instanceOf(Type.PersistentType, object);
               if (!query && isSchema) {
-                // TODO(wittjosiah): Support filtering by nested properties (e.g. `query.typename`).
-                query = space.db.query(Filter.type(DataType.View));
+                // TODO(wittjosiah): Ideally this query would traverse the view reference & filter by the query ast.
+                // TODO(wittjosiah): Remove cast.
+                query = space.db.query(filter) as unknown as QueryResult.QueryResult<Obj.Any>;
               }
 
-              let deletable = !isSchema;
+              let deletable =
+                !isSchema &&
+                // Don't allow system collections to be deleted.
+                !Obj.instanceOf(Collection.Managed, object);
               if (isSchema && query) {
-                const views = get(rxFromQuery(query));
+                const objects = get(atomFromQuery(query));
                 const filteredViews = get(
-                  rxFromSignal(() => views.filter((view) => view.query.typename === object.typename)),
+                  atomFromSignal(() =>
+                    objects.filter(
+                      (viewObject) =>
+                        getTypenameFromQuery((viewObject as any).view.target?.query.ast) === object.typename,
+                    ),
+                  ),
                 );
                 deletable = filteredViews.length === 0;
               }
@@ -623,7 +634,6 @@ export default (context: PluginContext) => {
               const [dispatcher] = get(context.capabilities(Capabilities.IntentDispatcher));
               const [appGraph] = get(context.capabilities(Capabilities.AppGraph));
               const [state] = get(context.capabilities(SpaceCapabilities.State));
-              const objectForms = get(context.capabilities(SpaceCapabilities.ObjectForm));
 
               if (!dispatcher || !appGraph || !state) {
                 return Option.none();
@@ -632,34 +642,49 @@ export default (context: PluginContext) => {
                   object,
                   graph: appGraph.graph,
                   dispatch: dispatcher.dispatchPromise,
-                  objectForms,
+                  resolve: resolve(get),
                   deletable,
-                  navigable: get(rxFromSignal(() => state.navigableCollections)),
+                  navigable: get(atomFromSignal(() => state.navigableCollections)),
                 });
               }
             }),
             Option.map((params) => constructObjectActions(params)),
             Option.getOrElse(() => []),
-          ),
-        );
+          );
+        });
       },
     }),
 
     // View selected objects.
     createExtension({
-      id: `${SPACE_PLUGIN}/selected-objects`,
+      id: `${meta.id}/selected-objects`,
       connector: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
-            Option.flatMap((node) => (Obj.instanceOf(DataType.View, node.data) ? Option.some(node) : Option.none())),
+            Option.flatMap((node) => {
+              if (!Obj.isObject(node.data)) {
+                return Option.none();
+              }
+
+              const schema = Obj.getSchema(node.data);
+              const isView = Option.fromNullable(schema).pipe(
+                Option.flatMap((schema) => ViewAnnotation.get(schema)),
+                Option.getOrElse(() => false),
+              );
+              if (!isView) {
+                return Option.none();
+              }
+
+              return Option.some(node);
+            }),
             Option.map((node) => [
               {
                 id: [node.id, 'selected-objects'].join(ATTENDABLE_PATH_SEPARATOR),
                 type: PLANK_COMPANION_TYPE,
                 data: 'selected-objects',
                 properties: {
-                  label: ['companion selected objects label', { ns: SPACE_PLUGIN }],
+                  label: ['companion selected objects label', { ns: meta.id }],
                   icon: 'ph--tree-view--regular',
                   disposition: 'hidden',
                 },
@@ -672,10 +697,10 @@ export default (context: PluginContext) => {
 
     // Object settings plank companion.
     createExtension({
-      id: `${SPACE_PLUGIN}/settings`,
+      id: `${meta.id}/settings`,
       connector: (node) =>
-        Rx.make((get) =>
-          pipe(
+        Atom.make((get) =>
+          Function.pipe(
             get(node),
             Option.flatMap((node) => (Obj.isObject(node.data) ? Option.some(node) : Option.none())),
             Option.map((node) => [
@@ -684,7 +709,7 @@ export default (context: PluginContext) => {
                 type: PLANK_COMPANION_TYPE,
                 data: 'settings',
                 properties: {
-                  label: ['object settings label', { ns: SPACE_PLUGIN }],
+                  label: ['object settings label', { ns: meta.id }],
                   icon: 'ph--sliders--regular',
                   disposition: 'hidden',
                   position: 'fallback',