@dxos/plugin-space 0.8.4-main.4a85c3132b → 0.8.4-main.51f1e5ca51

package/src/capabilities/navigation-resolver.ts

@@ -0,0 +1,94 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capability } from '@dxos/app-framework';
+import {
+  AppCapabilities,
+  getObjectPath,
+  getSpaceIdFromPath,
+  getSpacePath,
+  type AppCapabilities as AppCaps,
+} from '@dxos/app-toolkit';
+import { Database, Entity, Key } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
+import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { SETTINGS_ID, SETTINGS_KEY } from '@dxos/plugin-settings/types';
+
+import { meta } from '#meta';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    // TODO(wittjosiah): Remove cast once NavigationTargetResolver type includes Database.Service.
+    const resolver: AppCaps.NavigationTargetResolver = ((query) =>
+      Effect.gen(function* () {
+        if (!query?.dxn) {
+          return [
+            {
+              path: `${getSpacePath(SETTINGS_ID)}/${SETTINGS_KEY}:${meta.id.replaceAll('/', ':')}`,
+              label: 'Spaces settings',
+              type: 'settings',
+            },
+          ];
+        }
+
+        const dxn = DXN.tryParse(query.dxn.startsWith('@dxn:') ? query.dxn.slice(1) : query.dxn);
+        if (!dxn) {
+          return [];
+        }
+
+        const { db } = yield* Database.Service;
+        const ref = db.makeRef(dxn);
+        const object = yield* Database.load(ref).pipe(Effect.catchAll(() => Effect.succeed(null)));
+        if (!object) {
+          return [];
+        }
+
+        const typename = Entity.getTypename(object);
+        if (!typename) {
+          return [];
+        }
+
+        return [
+          {
+            path: getObjectPath(db.spaceId, typename, object.id),
+            label: Entity.getLabel(object) ?? '',
+            type: typename,
+          },
+        ];
+      })) as AppCaps.NavigationTargetResolver;
+
+    // Resolve object paths to DXNs.
+    // Handles canonical type paths (root/<spaceId>/types/<typename>/all/<objectId>)
+    // and collection paths (root/<spaceId>/collections/<collectionId>/<objectId>).
+    // Validates that the object actually exists in the space before returning a DXN.
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const pathResolver: AppCaps.NavigationPathResolver = (qualifiedPath) => {
+      const segments = qualifiedPath.split('/');
+      const spaceId = getSpaceIdFromPath(qualifiedPath);
+      const objectId = segments[segments.length - 1];
+      if (!spaceId || !objectId || !Key.ObjectId.isValid(objectId)) {
+        return Effect.succeed(Option.none());
+      }
+
+      const space = client.spaces.get(spaceId);
+      if (!space) {
+        return Effect.succeed(Option.none());
+      }
+
+      const dxn = DXN.fromSpaceAndObjectId(spaceId, objectId as Key.ObjectId);
+      const ref = space.db.makeRef(dxn);
+      return Database.loadOption(ref).pipe(
+        Effect.map((option) => (Option.isSome(option) ? Option.some(dxn) : Option.none<DXN>())),
+      );
+    };
+
+    return [
+      Capability.contributes(AppCapabilities.NavigationTargetResolver, resolver),
+      Capability.contributes(AppCapabilities.NavigationPathResolver, pathResolver),
+    ];
+  }),
+);

package/src/capabilities/node.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const IdentityCreated = Capability.lazy('IdentityCreated', () => import('./identity-created'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const UndoMappings = Capability.lazy('UndoMappings', () => import('./undo-mappings'));

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,14 @@
+// Copyright 2025 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+
+import { SpaceOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, SpaceOperationHandlerSet);
+  }),
+);

package/src/capabilities/{react-root/react-root.tsx → react-root.tsx}

@@ -8,9 +8,9 @@ import React from 'react';
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { useAtomCapability } from '@dxos/app-framework/ui';
 
-import { AwaitingObject } from '../../components';
-import { meta } from '../../meta';
-import { SpaceCapabilities } from '../../types';
+import { AwaitingObject } from '#components';
+import { meta } from '#meta';
+import { SpaceCapabilities } from '#types';
 
 export default Capability.makeModule(() =>
   Effect.succeed(

package/src/capabilities/{react-surface/react-surface.tsx → react-surface.tsx}

@@ -5,62 +5,62 @@
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
-import React, { useCallback } from 'react';
+import * as SchemaAST from 'effect/SchemaAST';
+import React, { type ComponentProps, useCallback } from 'react';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { Surface, useAtomCapability, useSettingsState } from '@dxos/app-framework/ui';
-import { AppCapabilities } from '@dxos/app-toolkit';
-import { useLayout } from '@dxos/app-toolkit/ui';
-import { Database, Obj, type Ref } from '@dxos/echo';
-import { Collection, type View } from '@dxos/echo';
+import { Surface, useAtomCapability, useOperationInvoker, useSettingsState } from '@dxos/app-framework/ui';
+import { AppSurface, useActiveSpace, useTypeOptions } from '@dxos/app-toolkit/ui';
+import { Database, Obj } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
 import { findAnnotation } from '@dxos/effect';
-import { type Space, SpaceState, getSpace, isSpace, parseId, useSpace } from '@dxos/react-client/echo';
+import { type Space, SpaceState, getSpace, isSpace, useSpace, useSpaces } from '@dxos/react-client/echo';
 import { Input } from '@dxos/react-ui';
 import { type FormFieldComponentProps, SelectField } from '@dxos/react-ui-form';
 import { HuePicker, IconPicker } from '@dxos/react-ui-pickers';
-import { ManagedCollection, ViewAnnotation } from '@dxos/schema';
-import { type JoinPanelProps } from '@dxos/shell/react';
+import { ViewAnnotation } from '@dxos/schema';
 
-import {
-  CREATE_OBJECT_DIALOG,
-  CREATE_SPACE_DIALOG,
-  JOIN_DIALOG,
-  OBJECT_RENAME_POPOVER,
-  SPACE_RENAME_POPOVER,
-} from '../../constants';
+import { SpaceSettings } from '#components';
 import {
   CollectionArticle,
   CollectionSection,
   CreateObjectDialog,
-  type CreateObjectDialogProps,
   CreateSpaceDialog,
   InlineSyncStatus,
   JoinDialog,
   MembersContainer,
   MenuFooter,
   ObjectCardStack,
-  ObjectDetails,
+  ObjectProperties,
   ObjectRenamePopover,
   RecordArticle,
+  RelatedArticle,
   SchemaContainer,
   SmallPresenceLive,
-  SpacePluginSettings,
   SpacePresence,
   SpaceRenamePopover,
   SpaceSettingsContainer,
   SyncStatus,
   ViewEditor,
-} from '../../containers';
-import { useTypeOptions } from '../../hooks';
-import { meta } from '../../meta';
+} from '#containers';
+import { meta } from '#meta';
+import { SpaceOperation } from '#operations';
 import {
   HueAnnotationId,
   IconAnnotationId,
   SpaceCapabilities,
-  type SpaceSettingsProps,
+  type Settings,
   type TypeInputOptions,
   TypeInputOptionsAnnotationId,
-} from '../../types';
+} from '#types';
+
+import {
+  CREATE_OBJECT_DIALOG,
+  CREATE_SPACE_DIALOG,
+  JOIN_DIALOG,
+  OBJECT_RENAME_POPOVER,
+  SPACE_RENAME_POPOVER,
+} from '../constants';
 
 type ReactSurfaceOptions = {
   createInvitationUrl: (invitationCode: string) => string;
@@ -70,64 +70,56 @@ export default Capability.makeModule(
   Effect.fnUntraced(function* ({ createInvitationUrl }: ReactSurfaceOptions) {
     return Capability.contributes(Capabilities.ReactSurface, [
       Surface.create({
-        id: `${meta.id}/article`,
-        role: 'article',
-        filter: (data): data is { subject: Space } =>
-          // TODO(wittjosiah): Need to avoid shotgun parsing space state everywhere.
-          isSpace(data.subject) && data.subject.state.get() === SpaceState.SPACE_READY,
-        component: ({ data, role, ...rest }) => (
-          <Surface.Surface
-            data={{
-              id: data.subject.id,
-              subject: data.subject.properties[Collection.Collection.typename]?.target,
-            }}
-            role={role}
-            {...rest}
-          />
-        ),
-      }),
-      Surface.create({
-        id: `${meta.id}/collection-fallback`,
-        role: 'article',
+        id: 'collection-fallback',
         position: 'fallback',
-        filter: (data): data is { subject: Collection.Collection | ManagedCollection.ManagedCollection } =>
-          Obj.instanceOf(Collection.Collection, data.subject) ||
-          Obj.instanceOf(ManagedCollection.ManagedCollection, data.subject),
-        component: ({ data }) => <CollectionArticle subject={data.subject} />,
+        filter: AppSurface.object(AppSurface.Article, Collection.Collection),
+        component: ({ data }) => <CollectionArticle attendableId={data.attendableId} subject={data.subject} />,
       }),
       Surface.create({
-        id: `${meta.id}/record-article`,
-        role: 'article',
+        id: 'record-article',
         position: 'fallback',
-        filter: (data): data is { subject: Obj.Unknown } => Obj.isObject(data.subject),
+        filter: AppSurface.subject(AppSurface.Article, Obj.isObject),
         component: ({ data }) => <RecordArticle subject={data.subject} />,
       }),
       Surface.create({
-        id: `${meta.id}/plugin-settings`,
-        role: 'article',
-        filter: (data): data is { subject: AppCapabilities.Settings } =>
-          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
+        id: 'plugin-settings',
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
         component: ({ data: { subject } }) => {
-          const { settings, updateSettings } = useSettingsState<SpaceSettingsProps>(subject.atom);
-          return <SpacePluginSettings settings={settings} onSettingsChange={updateSettings} />;
+          const { settings, updateSettings } = useSettingsState<Settings.Settings>(subject.atom);
+          const spaces = useSpaces({ all: settings.showHidden });
+          const { invokePromise } = useOperationInvoker();
+          return (
+            <SpaceSettings
+              settings={settings}
+              onSettingsChange={updateSettings}
+              spaces={spaces}
+              onOpenSpaceSettings={(space: Space) => invokePromise(SpaceOperation.OpenSettings, { space })}
+            />
+          );
         },
       }),
       Surface.create({
-        id: `${meta.id}/companion/object-settings`,
-        role: 'article',
-        filter: (data): data is { companionTo: Obj.Unknown } =>
-          Obj.isObject(data.companionTo) && data.subject === 'settings',
-        component: ({ ref, data, role }) => <ObjectDetails subject={data.companionTo} role={role} ref={ref} />,
+        id: 'companion.object-properties',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'settings'),
+          AppSurface.companion(AppSurface.Article),
+        ),
+        component: ({ ref, data, role }) => <ObjectProperties role={role} subject={data.companionTo} ref={ref} />,
       }),
       Surface.create({
-        id: `${meta.id}/space-settings-properties`,
-        role: 'article',
-        filter: (data): data is { subject: string } => data.subject === `${meta.id}/properties`,
+        id: 'companion.related',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'related'),
+          AppSurface.companion(AppSurface.Article),
+        ),
+        component: ({ data, role }) => <RelatedArticle role={role} companionTo={data.companionTo} />,
+      }),
+      Surface.create({
+        id: 'space-settings-properties',
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.general`),
         component: ({ ref }) => {
-          const layout = useLayout();
-          const { spaceId } = parseId(layout.workspace);
-          const space = useSpace(spaceId);
-          if (!space || !spaceId) {
+          const space = useActiveSpace();
+          if (!space) {
             return null;
           }
 
@@ -135,15 +127,12 @@ export default Capability.makeModule(
         },
       }),
       Surface.create({
-        id: `${meta.id}/space-settings-members`,
-        role: 'article',
+        id: 'space-settings-members',
         position: 'hoist',
-        filter: (data): data is { subject: string } => data.subject === `${meta.id}/members`,
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.members`),
         component: () => {
-          const layout = useLayout();
-          const { spaceId } = parseId(layout.workspace);
-          const space = useSpace(spaceId);
-          if (!space || !spaceId) {
+          const space = useActiveSpace();
+          if (!space) {
             return null;
           }
 
@@ -151,14 +140,11 @@ export default Capability.makeModule(
         },
       }),
       Surface.create({
-        id: `${meta.id}/space-settings-schema`,
-        role: 'article',
-        filter: (data): data is { subject: string } => data.subject === `${meta.id}/schema`,
+        id: 'space-settings-schema',
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.schema`),
         component: () => {
-          const layout = useLayout();
-          const { spaceId } = parseId(layout.workspace);
-          const space = useSpace(spaceId);
-          if (!space || !spaceId) {
+          const space = useActiveSpace();
+          if (!space) {
             return null;
           }
 
@@ -166,61 +152,71 @@ export default Capability.makeModule(
         },
       }),
       Surface.create({
-        id: `${meta.id}/selected-objects`,
+        id: 'selected-objects',
         role: 'article',
-        filter: (
-          data,
-        ): data is { companionTo: Obj.OfShape<{ view: Ref.Ref<View.View> }>; subject: 'selected-objects' } => {
+        filter: (data): data is { companionTo: Obj.Unknown; subject: 'selected-objects' } => {
           if (data.subject !== 'selected-objects' || !Obj.isObject(data.companionTo)) {
             return false;
           }
 
-          // TODO(burdon): Check companionTo.view.target is valid.
           const schema = Obj.getSchema(data.companionTo);
-          return Option.fromNullable(schema).pipe(
-            Option.flatMap((schema) => ViewAnnotation.get(schema)),
-            Option.getOrElse(() => false),
-          );
+          const path = schema ? Option.getOrElse(ViewAnnotation.get(schema), () => [] as readonly string[]) : [];
+          const viewTarget = path.length > 0 ? ViewAnnotation.tryGetTargetAlongPath(data.companionTo, path) : undefined;
+          return !!viewTarget;
         },
         // TODO(burdon): Replace with mosaic.
-        component: ({ data, ref }) => (
-          <ObjectCardStack
-            key={Obj.getDXN(data.companionTo).toString()}
-            objectId={Obj.getDXN(data.companionTo).toString()}
-            view={data.companionTo.view.target!}
-            ref={ref}
-          />
-        ),
+        component: ({ data, ref }) => {
+          const schema = Obj.getSchema(data.companionTo);
+          const path = schema ? Option.getOrElse(ViewAnnotation.get(schema), () => [] as readonly string[]) : [];
+          const view = path.length > 0 ? ViewAnnotation.tryGetTargetAlongPath(data.companionTo, path) : undefined;
+          if (!view) {
+            return null;
+          }
+
+          return (
+            <ObjectCardStack
+              key={Obj.getDXN(data.companionTo).toString()}
+              objectId={Obj.getDXN(data.companionTo).toString()}
+              view={view}
+              ref={ref}
+            />
+          );
+        },
       }),
       Surface.create({
         id: JOIN_DIALOG,
-        role: 'dialog',
-        filter: (data): data is { props: JoinPanelProps } => data.component === JOIN_DIALOG,
+        filter: AppSurface.component<ComponentProps<typeof JoinDialog>>(AppSurface.Dialog, JOIN_DIALOG),
         component: ({ data }) => <JoinDialog {...data.props} />,
       }),
       Surface.create({
         id: CREATE_SPACE_DIALOG,
-        role: 'dialog',
-        filter: (data): data is any => data.component === CREATE_SPACE_DIALOG,
+        filter: AppSurface.component(AppSurface.Dialog, CREATE_SPACE_DIALOG),
         component: () => <CreateSpaceDialog />,
       }),
       Surface.create({
         id: CREATE_OBJECT_DIALOG,
-        role: 'dialog',
-        filter: (data): data is { props: CreateObjectDialogProps } => data.component === CREATE_OBJECT_DIALOG,
+        filter: AppSurface.component<ComponentProps<typeof CreateObjectDialog>>(
+          AppSurface.Dialog,
+          CREATE_OBJECT_DIALOG,
+        ),
         component: ({ data }) => <CreateObjectDialog {...data.props} />,
       }),
       Surface.create({
-        id: `${meta.id}/create-initial-space-form-[hue]`,
+        id: 'create-initial-space-form-[hue]',
         role: 'form-input',
-        filter: (data): data is { prop: string; schema: Schema.Schema<any> } => {
+        filter: (data): data is { prop: string; schema: Schema.Schema<any>; fieldPropertyAst?: SchemaAST.AST } => {
           const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, HueAnnotationId);
           return !!annotation;
         },
-        component: ({ data: _, ...inputProps }) => {
-          const { label, readonly, type, getValue, onValueChange } = inputProps as any as FormFieldComponentProps;
-          const handleChange = useCallback((nextHue: string) => onValueChange(type, nextHue), [onValueChange]);
-          const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange]);
+        component: ({ data, ...inputProps }) => {
+          const ast = data.fieldPropertyAst;
+          if (!ast) {
+            return null;
+          }
+
+          const { label, readonly, getValue, onValueChange } = inputProps as any as FormFieldComponentProps;
+          const handleChange = useCallback((nextHue: string) => onValueChange(ast, nextHue), [ast, onValueChange]);
+          const handleReset = useCallback(() => onValueChange(ast, undefined), [ast, onValueChange]);
           return (
             <Input.Root>
               <Input.Label>{label}</Input.Label>
@@ -230,16 +226,21 @@ export default Capability.makeModule(
         },
       }),
       Surface.create({
-        id: `${meta.id}/create-initial-space-form-[icon]`,
+        id: 'create-initial-space-form-[icon]',
         role: 'form-input',
-        filter: (data): data is { prop: string; schema: Schema.Schema<any> } => {
+        filter: (data): data is { prop: string; schema: Schema.Schema<any>; fieldPropertyAst?: SchemaAST.AST } => {
           const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, IconAnnotationId);
           return !!annotation;
         },
-        component: ({ data: _, ...inputProps }) => {
-          const { label, readonly, type, getValue, onValueChange } = inputProps as any as FormFieldComponentProps;
-          const handleChange = useCallback((nextIcon: string) => onValueChange(type, nextIcon), [onValueChange]);
-          const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange]);
+        component: ({ data, ...inputProps }) => {
+          const ast = data.fieldPropertyAst;
+          if (!ast) {
+            return null;
+          }
+
+          const { label, readonly, getValue, onValueChange } = inputProps as any as FormFieldComponentProps;
+          const handleChange = useCallback((nextIcon: string) => onValueChange(ast, nextIcon), [ast, onValueChange]);
+          const handleReset = useCallback(() => onValueChange(ast, undefined), [ast, onValueChange]);
           return (
             <Input.Root>
               <Input.Label>{label}</Input.Label>
@@ -254,7 +255,7 @@ export default Capability.makeModule(
         },
       }),
       Surface.create({
-        id: `${meta.id}/typename-form-input`,
+        id: 'typename-form-input',
         role: 'form-input',
         filter: (
           data,
@@ -262,6 +263,7 @@ export default Capability.makeModule(
           prop: string;
           schema: Schema.Schema.Any;
           target: Database.Database | Collection.Collection | undefined;
+          fieldPropertyAst?: SchemaAST.AST;
         } => {
           if (data.prop !== 'typename') {
             return false;
@@ -270,8 +272,13 @@ export default Capability.makeModule(
           const annotation = findAnnotation((data.schema as Schema.Schema.All).ast, TypeInputOptionsAnnotationId);
           return !!annotation;
         },
-        component: ({ data: { schema, target }, ...inputProps }) => {
-          const props = inputProps as any as FormFieldComponentProps;
+        component: ({ data: { schema, target, fieldPropertyAst }, ...inputProps }) => {
+          const ast = fieldPropertyAst;
+          if (!ast) {
+            return null;
+          }
+
+          const props = { ...inputProps, type: ast } as any as FormFieldComponentProps;
           const db = Database.isDatabase(target) ? target : target && Obj.getDatabase(target);
           const space = useSpace(db?.spaceId);
           const annotation = findAnnotation<TypeInputOptions>(schema.ast, TypeInputOptionsAnnotationId)!;
@@ -281,21 +288,23 @@ export default Capability.makeModule(
         },
       }),
       Surface.create({
-        id: `${meta.id}/object-settings`,
-        role: 'object-settings',
-        filter: (data): data is { subject: { view: Ref.Ref<View.View> } } => {
+        id: 'object-properties',
+        role: 'object-properties',
+        filter: (data): data is { subject: Obj.Unknown } => {
           if (!Obj.isObject(data.subject)) {
             return false;
           }
 
           const schema = Obj.getSchema(data.subject);
-          return Option.fromNullable(schema).pipe(
-            Option.flatMap((schema) => ViewAnnotation.get(schema)),
-            Option.getOrElse(() => false),
-          );
+          const path = schema ? Option.getOrElse(ViewAnnotation.get(schema), () => [] as readonly string[]) : [];
+          const viewTarget = path.length > 0 ? ViewAnnotation.tryGetTargetAlongPath(data.subject, path) : undefined;
+          return !!viewTarget;
         },
         component: ({ data }) => {
-          const view = data.subject.view.target;
+          const schema = Obj.getSchema(data.subject);
+          const path = schema ? Option.getOrElse(ViewAnnotation.get(schema), () => [] as readonly string[]) : [];
+          const view = path.length > 0 ? ViewAnnotation.tryGetTargetAlongPath(data.subject, path) : undefined;
+
           if (!view) {
             return null;
           }
@@ -317,13 +326,12 @@ export default Capability.makeModule(
         component: ({ data }) => <ObjectRenamePopover object={data.props} />,
       }),
       Surface.create({
-        id: `${meta.id}/menu-footer`,
-        role: 'menu-footer',
-        filter: (data): data is { subject: Obj.Unknown } => Obj.isObject(data.subject),
+        id: 'menu-footer',
+        filter: AppSurface.subject(AppSurface.MenuFooter, Obj.isObject),
         component: ({ data }) => <MenuFooter object={data.subject} />,
       }),
       Surface.create({
-        id: `${meta.id}/navtree-presence`,
+        id: 'navtree-presence',
         role: 'navtree-item-end',
         filter: (data): data is { id: string; subject: Obj.Unknown; open?: boolean } =>
           typeof data.id === 'string' && Obj.isObject(data.subject),
@@ -334,7 +342,7 @@ export default Capability.makeModule(
       }),
       // TODO(wittjosiah): Attention glyph for non-echo items should be handled elsewhere.
       Surface.create({
-        id: `${meta.id}/navtree-presence-fallback`,
+        id: 'navtree-presence-fallback',
         role: 'navtree-item-end',
         position: 'fallback',
         filter: (data): data is { id: string; open?: boolean } => typeof data.id === 'string',
@@ -342,13 +350,13 @@ export default Capability.makeModule(
       }),
       // TODO(wittjosiah): Broken?
       Surface.create({
-        id: `${meta.id}/navtree-sync-status`,
+        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} />,
       }),
       Surface.create({
-        id: `${meta.id}/navbar-presence`,
+        id: 'navbar-presence',
         role: 'navbar-end',
         position: 'hoist',
         filter: (data): data is { subject: Space | Obj.Unknown } => isSpace(data.subject) || Obj.isObject(data.subject),
@@ -364,15 +372,13 @@ export default Capability.makeModule(
         },
       }),
       Surface.create({
-        id: `${meta.id}/collection-section`,
-        role: 'section',
-        filter: (data): data is { subject: Collection.Collection } =>
-          Obj.instanceOf(Collection.Collection, data.subject),
+        id: 'collection-section',
+        filter: AppSurface.object(AppSurface.Section, Collection.Collection),
         component: ({ data }) => <CollectionSection subject={data.subject} />,
       }),
       Surface.create({
-        id: `${meta.id}/status`,
-        role: 'status',
+        id: 'status',
+        role: 'status-indicator',
         component: () => <SyncStatus />,
       }),
     ]);

package/src/capabilities/repair.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Collection, Obj, Ref } from '@dxos/echo';
+import { type Space } from '@dxos/react-client/echo';
+
+import { SpaceCapabilities } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(SpaceCapabilities.Repair, async ({ space }: { space: Space }) => {
+      await removeQueryCollections(space);
+    }),
+  ),
+);
+
+/**
+ * Remove all existing query collections from the root collection.
+ */
+const removeQueryCollections = async (space: Space) => {
+  const rootCollection: Collection.Collection = await space.properties[Collection.Collection.typename]?.load();
+  if (!rootCollection) {
+    return;
+  }
+
+  const objects = await Promise.all(rootCollection.objects.map((ref) => ref.load()));
+  const queryCollections = objects.filter((object) => Obj.getTypename(object) === 'org.dxos.type.queryCollection');
+  if (queryCollections.length === 0) {
+    return;
+  }
+
+  Obj.update(rootCollection, (rootCollection) => {
+    rootCollection.objects = objects
+      .filter((object) => Obj.getTypename(object) !== 'org.dxos.type.queryCollection')
+      .map((object) => Ref.make(object));
+  });
+  queryCollections.forEach((object) => space.db.remove(object));
+};