@dxos/plugin-space 0.8.4-main.84f28bd → 0.8.4-main.a4bbb77

package/src/capabilities/intent-resolver.ts

@@ -12,31 +12,32 @@ import {
   createIntent,
   createResolver,
 } from '@dxos/app-framework';
-import { Obj, Ref, Relation, type Type } from '@dxos/echo';
+import { Filter, Obj, Query, Ref, Relation, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { Migrations } from '@dxos/migrations';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
-import { isSpace, getSpace, SpaceState, fullyQualifiedId } from '@dxos/react-client/echo';
+import { SpaceState, fullyQualifiedId, getSpace, isSpace } from '@dxos/react-client/echo';
 import { Invitation, InvitationEncoder } from '@dxos/react-client/invitations';
 import { ATTENDABLE_PATH_SEPARATOR } from '@dxos/react-ui-attention';
-import { DataType } from '@dxos/schema';
+import { DataType, ProjectionModel, typenameFromQuery } from '@dxos/schema';
 
-import { SpaceCapabilities } from './capabilities';
 import {
   CREATE_OBJECT_DIALOG,
   CREATE_SPACE_DIALOG,
+  type CreateObjectDialogProps,
   JOIN_DIALOG,
+  type JoinDialogProps,
   POPOVER_RENAME_OBJECT,
   POPOVER_RENAME_SPACE,
-  type CreateObjectDialogProps,
-  type JoinDialogProps,
 } from '../components';
 import { SpaceEvents } from '../events';
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { CollectionAction, SpaceAction } from '../types';
-import { cloneObject, COMPOSER_SPACE_LOCK, getNestedObjects } from '../util';
+import { COMPOSER_SPACE_LOCK, cloneObject, getNestedObjects } from '../util';
+
+import { SpaceCapabilities } from './capabilities';
 
 // TODO(wittjosiah): Remove.
 const SPACE_MAX_OBJECTS = 500;
@@ -75,17 +76,27 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           await space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED);
         }
         await space.waitUntilReady();
+
+        // Create root collection.
         const collection = Obj.make(DataType.Collection, { objects: [] });
         space.properties[DataType.Collection.typename] = Ref.make(collection);
 
+        // Set current migration version.
         if (Migrations.versionProperty) {
           space.properties[Migrations.versionProperty] = Migrations.targetVersion;
         }
 
+        // Create records smart collection.
+        const records = Obj.make(DataType.QueryCollection, {
+          query: Query.select(Filter.typename(DataType.StoredSchema.typename)).ast,
+        });
+        collection.objects.push(Ref.make(records));
+
+        // Allow other plugins to add default content.
         await context.activatePromise(SpaceEvents.SpaceCreated);
-        const onSpaceCreatedCallbacks = context.getCapabilities(SpaceCapabilities.OnSpaceCreated);
-        await Promise.all(
-          onSpaceCreatedCallbacks.map((onSpaceCreated) => onSpaceCreated({ space, rootCollection: collection })),
+        const onCreateSpaceCallbacks = context.getCapabilities(SpaceCapabilities.onCreateSpace);
+        const spaceCreatedIntents = onCreateSpaceCallbacks.map((onCreateSpace) =>
+          onCreateSpace({ space, rootCollection: collection }),
         );
 
         return {
@@ -95,6 +106,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
             space,
           },
           intents: [
+            ...spaceCreatedIntents,
             ...(observability
               ? [
                   createIntent(ObservabilityAction.SendEvent, {
@@ -309,9 +321,113 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         };
       },
     }),
+    createResolver({
+      intent: SpaceAction.UseStaticSchema,
+      resolve: async ({ space, typename }) => {
+        const client = context.getCapability(ClientCapabilities.Client);
+        const schema = client.graph.schemaRegistry.schemas.find((schema) => Type.getTypename(schema) === typename);
+        invariant(schema, `Schema not found: ${typename}`);
+
+        if (!space.properties.staticRecords) {
+          space.properties.staticRecords = [];
+        }
+
+        if (!space.properties.staticRecords.includes(typename)) {
+          space.properties.staticRecords.push(typename);
+        }
+
+        await context.activatePromise(SpaceEvents.SchemaAdded);
+        const onSchemaAdded = context.getCapabilities(SpaceCapabilities.OnSchemaAdded);
+        const schemaAddedIntents = onSchemaAdded.map((onSchemaAdded) => onSchemaAdded({ space, schema }));
+
+        return {
+          data: {},
+          intents: [
+            ...schemaAddedIntents,
+            ...(observability
+              ? [
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.schema.use',
+                    properties: {
+                      spaceId: space.id,
+                      typename: Type.getTypename(schema),
+                    },
+                  }),
+                ]
+              : []),
+          ],
+        };
+      },
+    }),
+    createResolver({
+      intent: SpaceAction.AddSchema,
+      resolve: async ({ space, name, typename, version, schema: schemaInput }) => {
+        const [schema] = await space.db.schemaRegistry.register([schemaInput]);
+        if (name) {
+          schema.storedSchema.name = name;
+        }
+        if (typename) {
+          schema.storedSchema.typename = typename;
+        }
+        if (version) {
+          schema.storedSchema.version = version;
+        }
+
+        await context.activatePromise(SpaceEvents.SchemaAdded);
+        const onSchemaAdded = context.getCapabilities(SpaceCapabilities.OnSchemaAdded);
+        const schemaAddedIntents = onSchemaAdded.map((onSchemaAdded) => onSchemaAdded({ space, schema }));
+
+        return {
+          data: {
+            id: schema.id,
+            object: schema.storedSchema,
+            schema,
+          },
+          intents: [
+            ...schemaAddedIntents,
+            ...(observability
+              ? [
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.schema.add',
+                    properties: {
+                      spaceId: space.id,
+                      objectId: schema.id,
+                      typename: schema.typename,
+                    },
+                  }),
+                ]
+              : []),
+          ],
+        };
+      },
+    }),
+    createResolver({
+      intent: SpaceAction.DeleteField,
+      resolve: async ({ view, fieldId, deletionData }, undo) => {
+        const space = getSpace(view);
+        invariant(space);
+        const typename = typenameFromQuery(view.query.ast);
+        invariant(typename);
+        const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();
+        invariant(schema);
+        const projection = new ProjectionModel(schema.jsonSchema, view.projection);
+        if (!undo) {
+          const { deleted, index } = projection.deleteFieldProjection(fieldId);
+          return {
+            undoable: {
+              message: ['field deleted label', { ns: meta.id }],
+              data: { deletionData: { ...deleted, index } },
+            },
+          };
+        } else if (undo && deletionData) {
+          const { field, props, index } = deletionData;
+          projection.setFieldProjection({ field, props }, index);
+        }
+      },
+    }),
     createResolver({
       intent: SpaceAction.OpenCreateObject,
-      resolve: ({ target, typename, navigable = true }) => {
+      resolve: ({ target, views, typename, initialFormValues, navigable = true, onCreateObject }) => {
         const state = context.getCapability(SpaceCapabilities.State);
 
         return {
@@ -323,7 +439,10 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
                 blockAlign: 'start',
                 props: {
                   target,
+                  views,
                   typename,
+                  initialFormValues,
+                  onCreateObject,
                   shouldNavigate: navigable
                     ? (object: Obj.Any) => {
                         const isCollection = Obj.instanceOf(DataType.Collection, object);
@@ -351,13 +470,13 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
               createIntent(LayoutAction.AddToast, {
                 part: 'toast',
                 subject: {
-                  id: `${SPACE_PLUGIN}/space-limit`,
-                  title: ['space limit label', { ns: SPACE_PLUGIN }],
-                  description: ['space limit description', { ns: SPACE_PLUGIN }],
+                  id: `${meta.id}/space-limit`,
+                  title: ['space limit label', { ns: meta.id }],
+                  description: ['space limit description', { ns: meta.id }],
                   duration: 5_000,
                   icon: 'ph--warning--regular',
-                  actionLabel: ['remove deleted objects label', { ns: SPACE_PLUGIN }],
-                  actionAlt: ['remove deleted objects alt', { ns: SPACE_PLUGIN }],
+                  actionLabel: ['remove deleted objects label', { ns: meta.id }],
+                  actionAlt: ['remove deleted objects alt', { ns: meta.id }],
                   closeLabel: ['close label', { ns: 'os' }],
                   onAction: () => space.db.coreDatabase.unlinkDeletedObjects(),
                 },
@@ -486,7 +605,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           return {
             undoable: {
               // TODO(ZaymonFC): Pluralize if more than one object.
-              message: [undoMessageKey, { ns: SPACE_PLUGIN }],
+              message: [undoMessageKey, { ns: meta.id }],
               data: { deletionData },
             },
             intents:
@@ -578,7 +697,9 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
     createResolver({
       intent: CollectionAction.CreateQueryCollection,
       resolve: async ({ name, typename }) => ({
-        data: { object: Obj.make(DataType.QueryCollection, { name, query: { typename } }) },
+        data: {
+          object: Obj.make(DataType.QueryCollection, { name, query: Query.select(Filter.typename(typename)).ast }),
+        },
       }),
     }),
   ]);

package/src/capabilities/react-root.tsx

@@ -6,13 +6,14 @@ import React from 'react';
 
 import { Capabilities, contributes, useCapability } from '@dxos/app-framework';
 
-import { SpaceCapabilities } from './capabilities';
 import { AwaitingObject } from '../components';
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
+
+import { SpaceCapabilities } from './capabilities';
 
 export default () =>
   contributes(Capabilities.ReactRoot, {
-    id: SPACE_PLUGIN,
+    id: meta.id,
     root: () => {
       const state = useCapability(SpaceCapabilities.State);
       return state.awaiting ? <AwaitingObject id={state.awaiting} /> : null;

package/src/capabilities/react-surface.tsx

@@ -7,9 +7,9 @@ import React, { useCallback, useMemo } from 'react';
 
 import {
   Capabilities,
+  Surface,
   contributes,
   createSurface,
-  Surface,
   useCapabilities,
   useCapability,
   useLayout,
@@ -19,52 +19,65 @@ import { findAnnotation } from '@dxos/effect';
 import { SettingsStore } from '@dxos/local-storage';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { useClient } from '@dxos/react-client';
-import { getSpace, isLiveObject, isSpace, parseId, SpaceState, useSpace, type Space } from '@dxos/react-client/echo';
+import {
+  type Space,
+  SpaceState,
+  fullyQualifiedId,
+  getSpace,
+  isLiveObject,
+  isSpace,
+  parseId,
+  useSpace,
+} from '@dxos/react-client/echo';
 import { Input, useTranslation } from '@dxos/react-ui';
 import { type InputProps, SelectInput } from '@dxos/react-ui-form';
 import { HuePicker, IconPicker } from '@dxos/react-ui-pickers';
 import { DataType, type TypenameAnnotation, TypenameAnnotationId } from '@dxos/schema';
 import { type JoinPanelProps } from '@dxos/shell/react';
 
-import { SpaceCapabilities } from './capabilities';
 import {
-  CollectionMain,
-  CollectionSection,
   CREATE_OBJECT_DIALOG,
   CREATE_SPACE_DIALOG,
+  CollectionMain,
+  CollectionSection,
   CreateObjectDialog,
+  type CreateObjectDialogProps,
   CreateSpaceDialog,
   InlineSyncStatus,
   JOIN_DIALOG,
   JoinDialog,
   MembersContainer,
   MenuFooter,
+  ObjectDetailsPanel,
   ObjectSettingsContainer,
   POPOVER_RENAME_OBJECT,
   POPOVER_RENAME_SPACE,
   PopoverRenameObject,
   PopoverRenameSpace,
+  RecordMain,
   SchemaContainer,
   SmallPresenceLive,
   SpacePluginSettings,
   SpacePresence,
   SpaceSettingsContainer,
   SyncStatus,
-  type CreateObjectDialogProps,
+  ViewEditor,
 } from '../components';
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { HueAnnotationId, IconAnnotationId, type SpaceSettingsProps } from '../types';
 
+import { SpaceCapabilities } from './capabilities';
+
 type ReactSurfaceOptions = {
   createInvitationUrl: (invitationCode: string) => string;
 };
 
-const OMIT = [DataType.Collection.typename, DataType.QueryCollection.typename];
+const OMIT = [DataType.Collection.typename, Type.getTypename(DataType.QueryCollection)];
 
 export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
   contributes(Capabilities.ReactSurface, [
     createSurface({
-      id: `${SPACE_PLUGIN}/article`,
+      id: `${meta.id}/article`,
       role: 'article',
       filter: (data): data is { subject: Space } =>
         // TODO(wittjosiah): Need to avoid shotgun parsing space state everywhere.
@@ -81,29 +94,36 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       ),
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/collection-fallback`,
+      id: `${meta.id}/record-article`,
+      role: 'article',
+      position: 'fallback',
+      filter: (data): data is { subject: Obj.Any } => Obj.isObject(data.subject),
+      component: ({ data }) => <RecordMain record={data.subject} />,
+    }),
+    createSurface({
+      id: `${meta.id}/collection-fallback`,
       role: 'article',
       position: 'fallback',
       filter: (data): data is { subject: DataType.Collection } => Obj.instanceOf(DataType.Collection, data.subject),
       component: ({ data }) => <CollectionMain collection={data.subject} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/plugin-settings`,
+      id: `${meta.id}/plugin-settings`,
       role: 'article',
       filter: (data): data is { subject: SettingsStore<SpaceSettingsProps> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === SPACE_PLUGIN,
+        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
       component: ({ data: { subject } }) => <SpacePluginSettings settings={subject.value} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/companion/object-settings`,
+      id: `${meta.id}/companion/object-settings`,
       role: 'article',
       filter: (data): data is { companionTo: Obj.Any } => Obj.isObject(data.companionTo) && data.subject === 'settings',
       component: ({ data, role }) => <ObjectSettingsContainer object={data.companionTo} role={role} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/space-settings-properties`,
+      id: `${meta.id}/space-settings-properties`,
       role: 'article',
-      filter: (data): data is { subject: string } => data.subject === `${SPACE_PLUGIN}/properties`,
+      filter: (data): data is { subject: string } => data.subject === `${meta.id}/properties`,
       component: () => {
         const layout = useLayout();
         const { spaceId } = parseId(layout.workspace);
@@ -116,10 +136,10 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       },
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/space-settings-members`,
+      id: `${meta.id}/space-settings-members`,
       role: 'article',
       position: 'hoist',
-      filter: (data): data is { subject: string } => data.subject === `${SPACE_PLUGIN}/members`,
+      filter: (data): data is { subject: string } => data.subject === `${meta.id}/members`,
       component: () => {
         const layout = useLayout();
         const { spaceId } = parseId(layout.workspace);
@@ -132,9 +152,9 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       },
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/space-settings-schema`,
+      id: `${meta.id}/space-settings-schema`,
       role: 'article',
-      filter: (data): data is { subject: string } => data.subject === `${SPACE_PLUGIN}/schema`,
+      filter: (data): data is { subject: string } => data.subject === `${meta.id}/schema`,
       component: () => {
         const layout = useLayout();
         const { spaceId } = parseId(layout.workspace);
@@ -146,6 +166,19 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
         return <SchemaContainer space={space} />;
       },
     }),
+    createSurface({
+      id: `${meta.id}/selected-objects`,
+      role: 'article',
+      filter: (data): data is { companionTo: DataType.View; subject: 'selected-objects' } =>
+        Obj.instanceOf(DataType.View, data.companionTo) && data.subject === 'selected-objects',
+      component: ({ data }) => (
+        <ObjectDetailsPanel
+          key={fullyQualifiedId(data.companionTo)}
+          objectId={fullyQualifiedId(data.companionTo)}
+          view={data.companionTo}
+        />
+      ),
+    }),
     createSurface({
       id: JOIN_DIALOG,
       role: 'dialog',
@@ -165,45 +198,45 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       component: ({ data }) => <CreateObjectDialog {...data.props} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/create-initial-space-form-[hue]`,
+      id: `${meta.id}/create-initial-space-form-[hue]`,
       role: 'form-input',
       filter: (data): data is { prop: string; schema: Schema.Schema<any> } => {
         const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, HueAnnotationId);
         return !!annotation;
       },
       component: ({ data: _, ...inputProps }) => {
-        const { label, disabled, type, getValue, onValueChange } = inputProps as any as InputProps;
+        const { label, readonly, type, getValue, onValueChange } = inputProps as any as InputProps;
         const handleChange = useCallback((nextHue: string) => onValueChange(type, nextHue), [onValueChange]);
         const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange]);
         return (
           <Input.Root>
             <Input.Label>{label}</Input.Label>
-            <HuePicker disabled={disabled} value={getValue() ?? ''} onChange={handleChange} onReset={handleReset} />
+            <HuePicker disabled={!!readonly} value={getValue() ?? ''} onChange={handleChange} onReset={handleReset} />
           </Input.Root>
         );
       },
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/create-initial-space-form-[icon]`,
+      id: `${meta.id}/create-initial-space-form-[icon]`,
       role: 'form-input',
       filter: (data): data is { prop: string; schema: Schema.Schema<any> } => {
         const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, IconAnnotationId);
         return !!annotation;
       },
       component: ({ data: _, ...inputProps }) => {
-        const { label, disabled, type, getValue, onValueChange } = inputProps as any as InputProps;
+        const { label, readonly, type, getValue, onValueChange } = inputProps as any as InputProps;
         const handleChange = useCallback((nextIcon: string) => onValueChange(type, nextIcon), [onValueChange]);
         const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange]);
         return (
           <Input.Root>
             <Input.Label>{label}</Input.Label>
-            <IconPicker disabled={disabled} value={getValue() ?? ''} onChange={handleChange} onReset={handleReset} />
+            <IconPicker disabled={!!readonly} value={getValue() ?? ''} onChange={handleChange} onReset={handleReset} />
           </Input.Root>
         );
       },
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/typename-form-input`,
+      id: `${meta.id}/typename-form-input`,
       role: 'form-input',
       filter: (
         data,
@@ -228,7 +261,7 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
 
         const schemaWhitelists = useCapabilities(ClientCapabilities.SchemaWhiteList);
         const whitelistedTypenames = useMemo(
-          () => new Set(schemaWhitelists.flatMap((typeArray) => typeArray.map((type) => type.typename))),
+          () => new Set(schemaWhitelists.flatMap((typeArray) => typeArray.map((type) => Type.getTypename(type)))),
           [schemaWhitelists],
         );
 
@@ -239,7 +272,7 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
               objectForms
                 .map((form) => Type.getTypename(form.objectSchema))
                 // TODO(wittjosiah): Remove.
-                .filter((typename) => !OMIT.includes(typename)),
+                .filter((typename) => !OMIT.includes(typename) && !typename.endsWith('View')),
             ),
           [objectForms],
         );
@@ -247,13 +280,23 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
         const fixed = client.graph.schemaRegistry.schemas.filter((schema) => {
           const limitedStatic =
             annotation.includes('limited-static') && whitelistedTypenames.has(Type.getTypename(schema));
+          const unusedStatic =
+            annotation.includes('unused-static') &&
+            whitelistedTypenames.has(Type.getTypename(schema)) &&
+            !space.properties.staticRecords?.includes(Type.getTypename(schema));
+          const usedStatic =
+            annotation.includes('used-static') &&
+            whitelistedTypenames.has(Type.getTypename(schema)) &&
+            space.properties.staticRecords?.includes(Type.getTypename(schema));
           const objectForm = annotation.includes('object-form') && objectFormTypenames.has(Type.getTypename(schema));
-          return annotation.includes('static') || limitedStatic || objectForm;
+          return annotation.includes('static') || limitedStatic || unusedStatic || usedStatic || objectForm;
         });
         const dynamic = space?.db.schemaRegistry.query().runSync();
         const typenames = Array.from(
           new Set<string>([
             ...(annotation.includes('limited-static') ||
+            annotation.includes('unused-static') ||
+            annotation.includes('used-static') ||
             annotation.includes('static') ||
             annotation.includes('object-form')
               ? fixed.map((schema) => Type.getTypename(schema))
@@ -264,37 +307,45 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
 
         const options = useMemo(
           () =>
-            typenames.map((typename) => ({
-              value: typename,
-              label: t('typename label', { ns: typename, defaultValue: typename }),
-            })),
+            typenames
+              .map((typename) => ({
+                value: typename,
+                label: t('typename label', { ns: typename, defaultValue: typename }),
+              }))
+              .toSorted((a, b) => a.label.localeCompare(b.label)),
           [t, typenames],
         );
 
         return <SelectInput {...props} options={options} />;
       },
     }),
+    createSurface({
+      id: `${meta.id}/object-settings`,
+      role: 'object-settings',
+      filter: (data): data is { subject: DataType.View } => Obj.instanceOf(DataType.View, data.subject),
+      component: ({ data }) => <ViewEditor view={data.subject} />,
+    }),
     createSurface({
       id: POPOVER_RENAME_SPACE,
-      role: 'popover',
+      role: 'card--popover',
       filter: (data): data is { props: Space } => data.component === POPOVER_RENAME_SPACE && isSpace(data.props),
       component: ({ data }) => <PopoverRenameSpace space={data.props} />,
     }),
     createSurface({
       id: POPOVER_RENAME_OBJECT,
-      role: 'popover',
+      role: 'card--popover',
       filter: (data): data is { props: Obj.Any } =>
         data.component === POPOVER_RENAME_OBJECT && isLiveObject(data.props),
       component: ({ data }) => <PopoverRenameObject object={data.props} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/menu-footer`,
+      id: `${meta.id}/menu-footer`,
       role: 'menu-footer',
       filter: (data): data is { subject: Obj.Any } => Obj.isObject(data.subject),
       component: ({ data }) => <MenuFooter object={data.subject} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/navtree-presence`,
+      id: `${meta.id}/navtree-presence`,
       role: 'navtree-item-end',
       filter: (data): data is { id: string; subject: Obj.Any; open?: boolean } =>
         typeof data.id === 'string' && Obj.isObject(data.subject),
@@ -306,7 +357,7 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
     }),
     // TODO(wittjosiah): Attention glyph for non-echo items should be handled elsewhere.
     createSurface({
-      id: `${SPACE_PLUGIN}/navtree-presence-fallback`,
+      id: `${meta.id}/navtree-presence-fallback`,
       role: 'navtree-item-end',
       position: 'fallback',
       filter: (data): data is { id: string; open?: boolean } => typeof data.id === 'string',
@@ -314,13 +365,13 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
     }),
     // TODO(wittjosiah): Broken?
     createSurface({
-      id: `${SPACE_PLUGIN}/navtree-sync-status`,
+      id: `${meta.id}/navtree-sync-status`,
       role: 'navtree-item-end',
       filter: (data): data is { subject: Space; open?: boolean } => isSpace(data.subject),
       component: ({ data }) => <InlineSyncStatus space={data.subject} open={data.open} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/navbar-presence`,
+      id: `${meta.id}/navbar-presence`,
       role: 'navbar-end',
       position: 'hoist',
       filter: (data): data is { subject: Space | Obj.Any } => isSpace(data.subject) || Obj.isObject(data.subject),
@@ -336,13 +387,13 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       },
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/collection-section`,
+      id: `${meta.id}/collection-section`,
       role: 'section',
       filter: (data): data is { subject: DataType.Collection } => Obj.instanceOf(DataType.Collection, data.subject),
       component: ({ data }) => <CollectionSection collection={data.subject} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/status`,
+      id: `${meta.id}/status`,
       role: 'status',
       component: () => <SyncStatus />,
     }),

package/src/capabilities/schema-defs.ts

@@ -2,12 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, type PluginContext } from '@dxos/app-framework';
+import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
 import { ClientCapabilities } from '@dxos/plugin-client';
 
-import { SpaceCapabilities } from './capabilities';
 import { type ObjectForm } from '../types';
 
+import { SpaceCapabilities } from './capabilities';
+
 export default (context: PluginContext) => {
   const registry = context.getCapability(Capabilities.RxRegistry);
   const client = context.getCapability(ClientCapabilities.Client);