@dxos/plugin-space 0.8.4-main.72ec0f3 → 0.8.4-main.7ace549

package/src/capabilities/intent-resolver.ts

@@ -6,13 +6,15 @@ import * as Effect from 'effect/Effect';
 
 import {
   Capabilities,
+  type Label,
   LayoutAction,
   type PluginContext,
   contributes,
   createIntent,
   createResolver,
 } from '@dxos/app-framework';
-import { Filter, Obj, Query, Ref, Relation, Type } from '@dxos/echo';
+import { Obj, Query, Ref, Relation, Type } from '@dxos/echo';
+import { Serializer } from '@dxos/echo-db';
 import { DatabaseService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { Migrations } from '@dxos/migrations';
@@ -24,7 +26,7 @@ import { Invitation, InvitationEncoder } from '@dxos/react-client/invitations';
 import { ATTENDABLE_PATH_SEPARATOR } from '@dxos/react-ui-attention';
 import { iconValues } from '@dxos/react-ui-pickers';
 import { hues } from '@dxos/react-ui-theme';
-import { Collection, ProjectionModel, StoredSchema, getTypenameFromQuery } from '@dxos/schema';
+import { Collection, ProjectionModel, getTypenameFromQuery } from '@dxos/schema';
 
 import {
   CREATE_OBJECT_DIALOG,
@@ -43,7 +45,7 @@ import { COMPOSER_SPACE_LOCK, cloneObject, getNestedObjects } from '../util';
 import { SpaceCapabilities } from './capabilities';
 
 // TODO(wittjosiah): Remove.
-const SPACE_MAX_OBJECTS = 500;
+const SPACE_MAX_OBJECTS = 750;
 
 type IntentResolverOptions = {
   context: PluginContext;
@@ -92,20 +94,13 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         }
 
         // Create records smart collection.
-        collection.objects.push(
-          Ref.make(
-            Obj.make(Collection.QueryCollection, {
-              // NOTE: This is specifically Filter.typename due to current limitations in query collection parsing.
-              query: Query.select(Filter.typename(StoredSchema.typename)).ast,
-            }),
-          ),
-        );
+        collection.objects.push(Ref.make(Collection.makeManaged({ key: Type.getTypename(Type.PersistentType) })));
 
         // Allow other plugins to add default content.
         await context.activatePromise(SpaceEvents.SpaceCreated);
-        const onCreateSpaceCallbacks = context.getCapabilities(SpaceCapabilities.onCreateSpace);
+        const onCreateSpaceCallbacks = context.getCapabilities(SpaceCapabilities.OnCreateSpace);
         const spaceCreatedIntents = onCreateSpaceCallbacks.map((onCreateSpace) =>
-          onCreateSpace({ space, rootCollection: collection }),
+          onCreateSpace({ space, isDefault: false, rootCollection: collection }),
         );
 
         return {
@@ -330,6 +325,17 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         };
       },
     }),
+    createResolver({
+      intent: SpaceAction.Snapshot,
+      resolve: async ({ space, query }) => {
+        const backup = await new Serializer().export(space.db, query && Query.fromAst(query));
+        return {
+          data: {
+            snapshot: new Blob([JSON.stringify(backup, null, 2)], { type: 'application/json' }),
+          },
+        };
+      },
+    }),
     createResolver({
       intent: SpaceAction.UseStaticSchema,
       resolve: async ({ space, typename, show }) => {
@@ -455,8 +461,8 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
                   shouldNavigate: navigable
                     ? (object: Obj.Any) => {
                         const isCollection = Obj.instanceOf(Collection.Collection, object);
-                        const isQueryCollection = Obj.instanceOf(Collection.QueryCollection, object);
-                        return (!isCollection && !isQueryCollection) || state.navigableCollections;
+                        const isSystemCollection = Obj.instanceOf(Collection.Managed, object);
+                        return (!isCollection && !isSystemCollection) || state.navigableCollections;
                       }
                     : () => false,
                 } satisfies Partial<CreateObjectDialogProps>,
@@ -598,16 +604,17 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           });
           objects.forEach((obj) => space.db.remove(obj));
 
-          const undoMessageKey = objects.some((obj) => Obj.instanceOf(Collection.Collection, obj))
-            ? 'collection deleted label'
-            : objects.length > 1
-              ? 'objects deleted label'
-              : 'object deleted label';
+          // TODO(wittjosiah): Once we can compose translations outside of react, use count instead.
+          //   ['deleted label', { ns: meta.id, typename: ['typename label', { ns: typename, count: objects.length }] }]
+          const undoMessageLabel: Label =
+            objects.length === 1
+              ? ['object deleted label', { ns: Obj.getTypename(objects[0]) ?? meta.id, defaultValue: 'Object deleted' }]
+              : ['objects deleted label', { ns: meta.id }];
 
           return {
             undoable: {
               // TODO(ZaymonFC): Pluralize if more than one object.
-              message: [undoMessageKey, { ns: meta.id }],
+              message: undoMessageLabel,
               data: { deletionData },
             },
             intents:
@@ -628,16 +635,16 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
             Obj.instanceOf(Collection.Collection, deletionData.parentCollection)
           ) {
             // Restore the object to the space.
-            const restoredObjects = deletionData.objects.map((obj: Type.Expando) => space.db.add(obj));
+            const restoredObjects = deletionData.objects.map((obj: Obj.Any) => space.db.add(obj));
 
             // Restore nested objects to the space.
-            deletionData.nestedObjectsList.flat().forEach((obj: Type.Expando) => {
+            deletionData.nestedObjectsList.flat().forEach((obj: Obj.Any) => {
               space.db.add(obj);
             });
 
             deletionData.indices.forEach((index: number, i: number) => {
               if (index !== -1) {
-                deletionData.parentCollection.objects.splice(index, 0, Ref.make(restoredObjects[i] as Type.Expando));
+                deletionData.parentCollection.objects.splice(index, 0, Ref.make(restoredObjects[i] as Obj.Any));
               }
             });
 
@@ -695,16 +702,5 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         data: { object: Obj.make(Collection.Collection, { name, objects: [] }) },
       }),
     }),
-    createResolver({
-      intent: CollectionAction.CreateQueryCollection,
-      resolve: async ({ name, typename }) => ({
-        data: {
-          object: Obj.make(Collection.QueryCollection, {
-            name,
-            query: Query.select(Filter.typename(typename)).ast,
-          }),
-        },
-      }),
-    }),
   ]);
 };

package/src/capabilities/react-surface.tsx

@@ -2,19 +2,20 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
 import React, { useCallback } from 'react';
 
 import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
 import { Surface, useCapability, useLayout } from '@dxos/app-framework/react';
-import { Obj } from '@dxos/echo';
+import { Obj, type Ref } from '@dxos/echo';
 import { findAnnotation } from '@dxos/effect';
 import { SettingsStore } from '@dxos/local-storage';
 import { type Space, SpaceState, getSpace, isLiveObject, isSpace, parseId, useSpace } from '@dxos/react-client/echo';
 import { Input } from '@dxos/react-ui';
 import { type InputProps, SelectInput } from '@dxos/react-ui-form';
 import { HuePicker, IconPicker } from '@dxos/react-ui-pickers';
-import { Collection, type TypenameAnnotation, TypenameAnnotationId, View } from '@dxos/schema';
+import { Collection, View, ViewAnnotation } from '@dxos/schema';
 import { type JoinPanelProps } from '@dxos/shell/react';
 
 // TODO(burdon): Component name standard: NounVerbComponent.
@@ -48,7 +49,13 @@ import {
 } from '../components';
 import { useTypeOptions } from '../hooks';
 import { meta } from '../meta';
-import { HueAnnotationId, IconAnnotationId, type SpaceSettingsProps } from '../types';
+import {
+  HueAnnotationId,
+  IconAnnotationId,
+  type SpaceSettingsProps,
+  type TypeInputOptions,
+  TypeInputOptionsAnnotationId,
+} from '../types';
 
 import { SpaceCapabilities } from './capabilities';
 
@@ -224,20 +231,22 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
         data,
       ): data is {
         prop: string;
-        schema: Schema.Schema<any>;
+        schema: Schema.Schema.Any;
         target: Space | Collection.Collection | undefined;
       } => {
         if (data.prop !== 'typename') {
           return false;
         }
 
-        const annotation = findAnnotation((data.schema as Schema.Schema.All).ast, TypenameAnnotationId);
+        // TODO(wittjosiah): This doesn't work here.
+        // const annotation = TypeInputOptionsAnnotation.get(data.schema as Schema.Schema.Any);
+        const annotation = findAnnotation((data.schema as Schema.Schema.All).ast, TypeInputOptionsAnnotationId);
         return !!annotation;
       },
       component: ({ data: { schema, target }, ...inputProps }) => {
         const props = inputProps as any as InputProps;
         const space = isSpace(target) ? target : getSpace(target);
-        const annotation = findAnnotation<TypenameAnnotation[]>(schema.ast, TypenameAnnotationId)!;
+        const annotation = findAnnotation<TypeInputOptions>(schema.ast, TypeInputOptionsAnnotationId)!;
         const options = useTypeOptions({ space, annotation });
 
         return <SelectInput {...props} options={options} />;
@@ -246,8 +255,25 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
     createSurface({
       id: `${meta.id}/object-settings`,
       role: 'object-settings',
-      filter: (data): data is { subject: View.View } => Obj.instanceOf(View.View, data.subject),
-      component: ({ data }) => <ViewEditor view={data.subject} />,
+      filter: (data): data is { subject: { view: Ref.Ref<View.View> } } => {
+        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),
+        );
+      },
+      component: ({ data }) => {
+        const view = data.subject.view.target;
+        if (!view) {
+          return null;
+        }
+
+        return <ViewEditor view={view} />;
+      },
     }),
     createSurface({
       id: SPACE_RENAME_POPOVER,

package/src/capabilities/repair.ts

@@ -0,0 +1,57 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes } from '@dxos/app-framework';
+import { Obj, Ref, Type } from '@dxos/echo';
+import { type Space } from '@dxos/react-client/echo';
+import { Collection } from '@dxos/schema';
+
+import { SpaceCapabilities } from './capabilities';
+
+export default () =>
+  contributes(SpaceCapabilities.Repair, async ({ space }) => {
+    await removeQueryCollections(space);
+    await ensureSystemCollection(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) === 'dxos.org/type/QueryCollection');
+  if (queryCollections.length === 0) {
+    return;
+  }
+
+  rootCollection.objects = objects
+    .filter((object) => Obj.getTypename(object) !== 'dxos.org/type/QueryCollection')
+    .map((object) => Ref.make(object));
+  queryCollections.forEach((object) => space.db.remove(object));
+};
+
+/**
+ * Ensure the root collection has a system collection for StoredSchema.
+ */
+const ensureSystemCollection = 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 records = objects.find(
+    (object) => Obj.instanceOf(Collection.Managed, object) && object.key === Type.getTypename(Type.PersistentType),
+  );
+  if (records) {
+    return;
+  }
+
+  rootCollection.objects.push(Ref.make(Collection.makeManaged({ key: Type.getTypename(Type.PersistentType) })));
+};

package/src/capabilities/spaces-ready.ts

@@ -101,7 +101,13 @@ export default async (context: PluginContext) => {
           subscriptions.add(
             scheduledEffect(
               () => ({ name: space.properties.name }),
-              ({ name }) => (state.spaceNames[space.id] = name),
+              ({ name }) => {
+                if (!name) {
+                  delete state.spaceNames[space.id];
+                } else {
+                  state.spaceNames[space.id] = name;
+                }
+              },
             ),
           );
         });

package/src/components/CreateDialog/CreateObjectDialog.tsx

@@ -4,24 +4,24 @@
 
 import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
-import React, { useCallback, useRef, useState } from 'react';
+import * as Option from 'effect/Option';
+import React, { useCallback, useMemo, useRef, useState } from 'react';
 
 import { Capabilities, LayoutAction, chain, createIntent } from '@dxos/app-framework';
-import { useCapabilities, useIntentDispatcher, usePluginManager } from '@dxos/app-framework/react';
-import { Obj, Query, Type } from '@dxos/echo';
+import { useIntentDispatcher, usePluginManager } from '@dxos/app-framework/react';
+import { Obj, Type } from '@dxos/echo';
+import { EntityKind, SystemTypeAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
 import { useClient } from '@dxos/react-client';
-import { type Space, getSpace, isLiveObject, isSpace, useQuery, useSpaces } from '@dxos/react-client/echo';
+import { type Space, getSpace, isLiveObject, isSpace, useSpaces } from '@dxos/react-client/echo';
 import { Dialog, IconButton, useTranslation } from '@dxos/react-ui';
 import { cardDialogContent, cardDialogHeader } from '@dxos/react-ui-stack';
-import { Collection, StoredSchema, getTypenameFromQuery } from '@dxos/schema';
-import { isNonNullable } from '@dxos/util';
+import { type Collection } from '@dxos/schema';
 
-import { SpaceCapabilities } from '../../capabilities';
 import { meta } from '../../meta';
 import { SpaceAction } from '../../types';
 
-import { CreateObjectPanel, type CreateObjectPanelProps } from './CreateObjectPanel';
+import { CreateObjectPanel, type CreateObjectPanelProps, type Metadata } from './CreateObjectPanel';
 
 export const CREATE_OBJECT_DIALOG = `${meta.id}/CreateObjectDialog`;
 
@@ -44,26 +44,36 @@ export const CreateObjectDialog = ({
   const manager = usePluginManager();
   const { t } = useTranslation(meta.id);
   const { dispatch } = useIntentDispatcher();
-  const forms = useCapabilities(SpaceCapabilities.ObjectForm);
   const [target, setTarget] = useState<Space | Collection.Collection | undefined>(initialTarget);
   const [typename, setTypename] = useState<string | undefined>(initialTypename);
   const client = useClient();
   const spaces = useSpaces();
-  const space = isSpace(target) ? target : getSpace(target);
-  const queryCollections = useQuery(space, Query.type(Collection.QueryCollection));
-  const hiddenTypenames = queryCollections
-    .map((collection) => getTypenameFromQuery(collection.query))
-    .filter(isNonNullable);
   const closeRef = useRef<HTMLButtonElement | null>(null);
 
   const resolve = useCallback<NonNullable<CreateObjectPanelProps['resolve']>>(
-    (typename) =>
-      manager.context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {},
+    (typename) => {
+      const metadata = manager.context
+        .getCapabilities(Capabilities.Metadata)
+        .find(({ id }) => id === typename)?.metadata;
+      return metadata?.createObjectIntent ? (metadata as Metadata) : undefined;
+    },
     [manager],
   );
 
+  const space = isSpace(target) ? target : getSpace(target);
+  // TODO(wittjosiah): Support database schemas.
+  const schemas = space?.db.schemaRegistry.query({ location: ['runtime'] }).runSync();
+  const userSchemas = useMemo(
+    () =>
+      schemas
+        ?.filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation)
+        .filter((schema) => !!resolve(Type.getTypename(schema)))
+        .filter((schema) => !SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false))) ?? [],
+    [schemas],
+  );
+
   const handleCreateObject = useCallback<NonNullable<CreateObjectPanelProps['onCreateObject']>>(
-    ({ form, data = {} }) =>
+    ({ metadata, data = {} }) =>
       Effect.gen(function* () {
         if (!target) {
           // TODO(wittjosiah): UI feedback.
@@ -75,10 +85,10 @@ export const CreateObjectDialog = ({
 
         const space = isSpace(target) ? target : getSpace(target);
         invariant(space, 'Missing space');
-        const { object } = yield* dispatch(form.getIntent(data, { space }));
-        if (isLiveObject(object) && !Obj.instanceOf(StoredSchema, object)) {
+        const { object } = yield* dispatch(metadata.createObjectIntent(data, { space }));
+        if (isLiveObject(object) && !Obj.instanceOf(Type.PersistentType, object)) {
           // TODO(wittjosiah): Selection in navtree isn't working as expected when hidden typenames evals to true.
-          const hidden = form.hidden || hiddenTypenames.includes(Type.getTypename(form.objectSchema));
+          const hidden = !metadata.addToCollectionOnCreate;
           const addObjectIntent = createIntent(SpaceAction.AddObject, {
             target,
             object,
@@ -94,7 +104,7 @@ export const CreateObjectDialog = ({
           onCreateObject?.(object);
         }
       }).pipe(Effect.runPromise),
-    [dispatch, target, resolve, hiddenTypenames, _shouldNavigate],
+    [dispatch, target, resolve, _shouldNavigate],
   );
 
   return (
@@ -106,7 +116,7 @@ export const CreateObjectDialog = ({
           {t('create object dialog title', {
             object: t('typename label', {
               ns: typename,
-              defaultValue: views ? 'View' : 'Item',
+              defaultValue: views ? 'View' : 'Object',
             }),
           })}
         </Dialog.Title>
@@ -125,7 +135,7 @@ export const CreateObjectDialog = ({
       </div>
 
       <CreateObjectPanel
-        forms={forms}
+        schemas={userSchemas}
         spaces={spaces}
         target={target}
         views={views}

package/src/components/CreateDialog/CreateObjectPanel.tsx

@@ -3,39 +3,46 @@
 //
 
 import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
 import React, { useCallback } from 'react';
 
-import { Type } from '@dxos/echo';
-import { type BaseObject, type TypeAnnotation, ViewAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
+import { type AnyProperties, type TypeAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
 import { type Space, type SpaceId } from '@dxos/react-client/echo';
 import { Icon, toLocalizedString, useDefaultValue, useTranslation } from '@dxos/react-ui';
 import { Form } from '@dxos/react-ui-form';
 import { SearchList } from '@dxos/react-ui-searchlist';
 import { cardDialogOverflow, cardDialogPaddedOverflow, cardDialogSearchListRoot } from '@dxos/react-ui-stack';
-import { type Collection } from '@dxos/schema';
+import { type Collection, ViewAnnotation } from '@dxos/schema';
 import { type MaybePromise, isNonNullable } from '@dxos/util';
 
 import { useInputSurfaceLookup } from '../../hooks';
 import { meta } from '../../meta';
-import { type ObjectForm } from '../../types';
+import { type CreateObjectIntent } from '../../types';
 import { getSpaceDisplayName } from '../../util';
 
+export type Metadata = {
+  createObjectIntent: CreateObjectIntent;
+  inputSchema?: Schema.Schema.AnyNoContext;
+  addToCollectionOnCreate?: boolean;
+  icon?: string;
+};
+
 export type CreateObjectPanelProps = {
-  forms: ObjectForm[];
+  schemas: Schema.Schema.AnyNoContext[];
   spaces: Space[];
   typename?: string;
   target?: Space | Collection.Collection;
   views?: boolean;
-  initialFormValues?: Partial<BaseObject>;
+  initialFormValues?: Partial<AnyProperties>;
   defaultSpaceId?: SpaceId;
-  resolve?: (typename: string) => Record<string, any>;
+  resolve?: (typename: string) => Metadata | undefined;
   onTargetChange?: (target: Space) => void;
   onTypenameChange?: (typename: string) => void;
-  onCreateObject?: (params: { form: ObjectForm; data?: Record<string, any> }) => MaybePromise<void>;
+  onCreateObject?: (params: { metadata: Metadata; data?: Record<string, any> }) => MaybePromise<void>;
 };
 
 export const CreateObjectPanel = ({
-  forms,
+  schemas,
   spaces,
   typename,
   target,
@@ -49,16 +56,16 @@ export const CreateObjectPanel = ({
 }: CreateObjectPanelProps) => {
   const { t } = useTranslation(meta.id);
   const initialFormValues = useDefaultValue(_initialFormValues, () => ({}));
-  const form = forms.find((form) => Type.getTypename(form.objectSchema) === typename);
-  const options: TypeAnnotation[] = forms
-    .filter((form) => {
+  const metadata = typename && resolve?.(typename);
+  const options: TypeAnnotation[] = schemas
+    .filter((schema) => {
       if (views == null) {
         return true;
       } else {
-        return views === ViewAnnotation.get(form.objectSchema).pipe(Option.getOrElse(() => false));
+        return views === ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false));
       }
     })
-    .map((form) => getTypeAnnotation(form.objectSchema))
+    .map((schema) => getTypeAnnotation(schema))
     .filter(isNonNullable)
     .sort((a, b) => {
       const nameA = t('typename label', { ns: a.typename, defaultValue: a.typename });
@@ -68,39 +75,39 @@ export const CreateObjectPanel = ({
 
   const handleCreateObject = useCallback(
     async (props: Record<string, any>) => {
-      if (!form) {
+      if (!metadata) {
         return;
       }
-      await onCreateObject?.({ form, data: props });
+      await onCreateObject?.({ metadata, data: props });
     },
-    [onCreateObject, form],
+    [onCreateObject, metadata],
   );
 
   const handleSetTypename = useCallback(
     async (typename: string) => {
-      const form = forms.find((form) => getTypeAnnotation(form.objectSchema)?.typename === typename);
-      if (form && !form.formSchema) {
-        await onCreateObject?.({ form });
+      const metadata = resolve?.(typename);
+      if (metadata && !metadata.inputSchema) {
+        await onCreateObject?.({ metadata });
       } else {
         onTypenameChange?.(typename);
       }
     },
-    [forms, onCreateObject],
+    [resolve, onCreateObject],
   );
 
   const inputSurfaceLookup = useInputSurfaceLookup({ target });
 
   // TODO(wittjosiah): These inputs should be rolled into a `Form` once it supports the necessary variants.
-  return !form ? (
+  return !metadata ? (
     <SelectSchema options={options} resolve={resolve} onChange={handleSetTypename} />
   ) : !target ? (
     <SelectSpace spaces={spaces} defaultSpaceId={defaultSpaceId} onChange={onTargetChange} />
-  ) : form.formSchema ? (
+  ) : metadata.inputSchema ? (
     <div role='none' className={cardDialogOverflow}>
       <Form
         autoFocus
         values={initialFormValues}
-        schema={form.formSchema}
+        schema={metadata.inputSchema}
         testId='create-object-form'
         onSave={handleCreateObject}
         lookupComponent={inputSurfaceLookup}
@@ -174,7 +181,7 @@ const SelectSchema = ({
             classNames='flex items-center gap-2'
           >
             <span className='flex gap-2 items-center grow truncate'>
-              <Icon icon={resolve?.(option.typename).icon ?? 'ph--placeholder--regular'} size={5} />
+              <Icon icon={resolve?.(option.typename)?.icon ?? 'ph--placeholder--regular'} size={5} />
               {t('typename label', { ns: option.typename, defaultValue: option.typename })}
             </span>
           </SearchList.Item>

package/src/components/ObjectDetailsPanel/ObjectForm.tsx

@@ -28,7 +28,7 @@ export const ObjectForm = ({ object, schema }: ObjectFormProps) => {
   );
 
   const meta = Obj.getMeta(object);
-  const tags = (meta.tags ?? []).map((tag) => space?.db.ref(DXN.parse(tag))).filter(isNonNullable);
+  const tags = (meta.tags ?? []).map((tag) => space?.db.makeRef(DXN.parse(tag))).filter(isNonNullable);
   const values = useMemo(() => ({ tags, ...object }), [object, tags]);
 
   const handleCreateTag = useCallback((values: Schema.Schema.Type<typeof TagSchema>) => {

package/src/components/ObjectSettings/AdvancedObjectSettings.tsx

@@ -4,8 +4,7 @@
 
 import React, { useCallback, useState } from 'react';
 
-import { Obj } from '@dxos/echo';
-import { ForeignKey } from '@dxos/echo/internal';
+import { Key, Obj } from '@dxos/echo';
 import { IconButton, useTranslation } from '@dxos/react-ui';
 import { Form } from '@dxos/react-ui-form';
 
@@ -30,7 +29,7 @@ export const AdvancedObjectSettings = ({ object }: AdvancedObjectSettingsProps)
   const handleNew = useCallback(() => setAdding(true), []);
   const handleCancel = useCallback(() => setAdding(false), []);
   const handleSave = useCallback(
-    (key: ForeignKey) => {
+    (key: Key.ForeignKey) => {
       const index = keys.findIndex(({ source, id }) => source === key.source && id === key.id);
       if (index === -1) {
         keys.push(key);
@@ -40,7 +39,7 @@ export const AdvancedObjectSettings = ({ object }: AdvancedObjectSettingsProps)
     [keys],
   );
   const handleDelete = useCallback(
-    (key: ForeignKey) => {
+    (key: Key.ForeignKey) => {
       const index = keys.findIndex(({ source, id }) => source === key.source && id === key.id);
       if (index !== -1) {
         keys.splice(index, 1);
@@ -70,7 +69,7 @@ export const AdvancedObjectSettings = ({ object }: AdvancedObjectSettingsProps)
       {adding && (
         <Form
           outerSpacing={false}
-          schema={ForeignKey}
+          schema={Key.ForeignKey}
           values={initialValues}
           onSave={handleSave}
           onCancel={handleCancel}

package/src/components/ObjectSettings/BaseObjectSettings.tsx

@@ -47,7 +47,7 @@ export const BaseObjectSettings = ({ classNames, children, object }: BaseObjectS
   }, [object]);
 
   const meta = Obj.getMeta(object);
-  const tags = (meta.tags ?? []).map((tag) => space?.db.ref(DXN.parse(tag))).filter(isNonNullable);
+  const tags = (meta.tags ?? []).map((tag) => space?.db.makeRef(DXN.parse(tag))).filter(isNonNullable);
   const values = useMemo(
     () => ({
       tags,

package/src/components/ObjectSettings/ForeignKeys.tsx

@@ -4,14 +4,14 @@
 
 import React, { useCallback } from 'react';
 
-import { type ForeignKey } from '@dxos/echo/internal';
+import { type Key } from '@dxos/echo';
 import { IconButton, List, ListItem, useTranslation } from '@dxos/react-ui';
 
 import { meta } from '../../meta';
 
 export type ForeignKeysProps = {
-  keys: ForeignKey[];
-  onDelete?: (key: ForeignKey) => void;
+  keys: Key.ForeignKey[];
+  onDelete?: (key: Key.ForeignKey) => void;
 };
 
 // TODO(wittjosiah): This is a clone of `TokenManager`. Consider a form variant for arrays of read-only objects.
@@ -26,8 +26,8 @@ export const ForeignKeys = ({ keys, onDelete }: ForeignKeysProps) => {
 };
 
 type KeyItemProps = {
-  forignKey: ForeignKey;
-  onDelete?: (key: ForeignKey) => void;
+  forignKey: Key.ForeignKey;
+  onDelete?: (key: Key.ForeignKey) => void;
 };
 
 const KeyItem = ({ forignKey, onDelete }: KeyItemProps) => {