@dxos/plugin-space 0.7.4 → 0.7.5-main.937ce75

package/src/SpacePlugin.tsx

@@ -7,16 +7,18 @@ import React from 'react';
 
 import {
   type GraphProvides,
-  type IntentDispatcher,
   type IntentPluginProvides,
   LayoutAction,
   type LayoutProvides,
   type LocationProvides,
-  type MetadataResolverProvides,
   NavigationAction,
   type Plugin,
   type PluginDefinition,
+  type PromiseIntentDispatcher,
   Surface,
+  createIntent,
+  createResolver,
+  createSurface,
   filterPlugins,
   findPlugin,
   firstIdInPart,
@@ -29,17 +31,17 @@ import {
   resolvePlugin,
 } from '@dxos/app-framework';
 import { EventSubscriptions, type Trigger, type UnsubscribeCallback } from '@dxos/async';
-import { S, type AbstractTypedObject, type HasId } from '@dxos/echo-schema';
+import { type HasId, type TypedObject } from '@dxos/echo-schema';
 import { scheduledEffect } from '@dxos/echo-signals/core';
 import { invariant } from '@dxos/invariant';
-import { create, isDeleted, isReactiveObject } from '@dxos/live-object';
+import { type ReactiveObject, RefArray, create, isDeleted, isReactiveObject, makeRef } from '@dxos/live-object';
 import { LocalStorageStore } from '@dxos/local-storage';
 import { log } from '@dxos/log';
 import { Migrations } from '@dxos/migrations';
 import { type AttentionPluginProvides, parseAttentionPlugin } from '@dxos/plugin-attention';
-import { type ClientPluginProvides, parseClientPlugin } from '@dxos/plugin-client';
+import { type ClientPluginProvides, parseClientPlugin } from '@dxos/plugin-client/types';
 import { type Node, createExtension, memoize, toSignal } from '@dxos/plugin-graph';
-import { ObservabilityAction } from '@dxos/plugin-observability/meta';
+import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { type Client, PublicKey } from '@dxos/react-client';
 import {
@@ -47,6 +49,7 @@ import {
   FQ_ID_LENGTH,
   Filter,
   OBJECT_ID_LENGTH,
+  QueryOptions,
   type ReactiveEchoObject,
   SPACE_ID_LENGTH,
   type Space,
@@ -56,7 +59,6 @@ import {
   getTypename,
   isEchoObject,
   isSpace,
-  loadObjectReferences,
   parseFullyQualifiedId,
   parseId,
 } from '@dxos/react-client/echo';
@@ -65,36 +67,43 @@ import { ComplexMap, nonNullable, reduceGroupBy } from '@dxos/util';
 
 import {
   AwaitingObject,
+  CREATE_OBJECT_DIALOG,
+  CREATE_SPACE_DIALOG,
   CollectionMain,
   CollectionSection,
   CreateObjectDialog,
   type CreateObjectDialogProps,
   CreateSpaceDialog,
   DefaultObjectSettings,
-  JoinDialog,
   InlineSyncStatus,
+  JOIN_DIALOG,
+  JoinDialog,
+  type JoinDialogProps,
   MenuFooter,
+  POPOVER_RENAME_OBJECT,
+  POPOVER_RENAME_SPACE,
   PopoverRenameObject,
   PopoverRenameSpace,
+  SPACE_SETTINGS_DIALOG,
   ShareSpaceButton,
-  SmallPresence,
   SmallPresenceLive,
   SpacePluginSettings,
   SpacePresence,
   SpaceSettingsDialog,
+  type SpaceSettingsDialogProps,
   SpaceSettingsPanel,
   SyncStatus,
-  type SpaceSettingsDialogProps,
 } from './components';
-import meta, { CollectionAction, SPACE_PLUGIN, SpaceAction } from './meta';
+import meta, { SPACE_PLUGIN } from './meta';
 import translations from './translations';
 import {
+  CollectionAction,
   CollectionType,
-  parseSchemaPlugin,
-  SpaceForm,
   type PluginState,
+  SpaceAction,
   type SpacePluginProvides,
   type SpaceSettingsProps,
+  parseSchemaPlugin,
 } from './types';
 import {
   COMPOSER_SPACE_LOCK,
@@ -145,7 +154,7 @@ export type SpacePluginOptions = {
    * @param params.client DXOS Client
    * @param params.dispatch Function to dispatch intents
    */
-  onFirstRun?: (params: { client: Client; dispatch: IntentDispatcher }) => Promise<void>;
+  onFirstRun?: (params: { client: Client; dispatch: PromiseIntentDispatcher }) => Promise<void>;
 };
 
 export const SpacePlugin = ({
@@ -168,7 +177,7 @@ export const SpacePlugin = ({
   const subscriptions = new EventSubscriptions();
   const spaceSubscriptions = new EventSubscriptions();
   const graphSubscriptions = new Map<string, UnsubscribeCallback>();
-  const schemas: AbstractTypedObject[] = [];
+  const schemas: TypedObject[] = [];
 
   let clientPlugin: Plugin<ClientPluginProvides> | undefined;
   let graphPlugin: Plugin<GraphProvides> | undefined;
@@ -176,7 +185,6 @@ export const SpacePlugin = ({
   let layoutPlugin: Plugin<LayoutProvides> | undefined;
   let navigationPlugin: Plugin<LocationProvides> | undefined;
   let attentionPlugin: Plugin<AttentionPluginProvides> | undefined;
-  let metadataPlugin: Plugin<MetadataResolverProvides> | undefined;
 
   const createSpaceInvitationUrl = (invitationCode: string) => {
     const baseUrl = new URL(invitationUrl);
@@ -228,11 +236,7 @@ export const SpacePlugin = ({
             const timeout = setTimeout(async () => {
               const node = graph.findNode(soloPart.id);
               if (!node) {
-                await dispatch({
-                  plugin: SPACE_PLUGIN,
-                  action: SpaceAction.WAIT_FOR_OBJECT,
-                  data: { id: soloPart.id },
-                });
+                await dispatch(createIntent(SpaceAction.WaitForObject, { id: soloPart.id }));
               }
             }, WAIT_FOR_OBJECT_TIMEOUT);
 
@@ -392,7 +396,7 @@ export const SpacePlugin = ({
 
   return {
     meta,
-    ready: async (plugins) => {
+    ready: async ({ plugins }) => {
       settings.prop({ key: 'showHidden', type: LocalStorageStore.bool({ allowUndefined: true }) });
       state
         .prop({ key: 'spaceNames', type: LocalStorageStore.json<Record<string, string>>() })
@@ -406,7 +410,6 @@ export const SpacePlugin = ({
 
       graphPlugin = resolvePlugin(plugins, parseGraphPlugin);
       layoutPlugin = resolvePlugin(plugins, parseLayoutPlugin);
-      metadataPlugin = resolvePlugin(plugins, parseMetadataResolverPlugin);
       navigationPlugin = resolvePlugin(plugins, parseNavigationPlugin);
       attentionPlugin = resolvePlugin(plugins, parseAttentionPlugin);
       clientPlugin = resolvePlugin(plugins, parseClientPlugin);
@@ -416,7 +419,7 @@ export const SpacePlugin = ({
       }
 
       const client = clientPlugin.provides.client;
-      const dispatch = intentPlugin.provides.intent.dispatch;
+      const dispatch = intentPlugin.provides.intent.dispatchPromise;
 
       schemas.push(
         ...filterPlugins(plugins, parseSchemaPlugin)
@@ -437,7 +440,7 @@ export const SpacePlugin = ({
         const defaultSpace = client.spaces.default;
 
         // Create root collection structure.
-        defaultSpace.properties[CollectionType.typename] = create(CollectionType, { objects: [], views: {} });
+        defaultSpace.properties[CollectionType.typename] = makeRef(create(CollectionType, { objects: [], views: {} }));
         if (Migrations.versionProperty) {
           defaultSpace.properties[Migrations.versionProperty] = Migrations.targetVersion;
         }
@@ -480,15 +483,12 @@ export const SpacePlugin = ({
       metadata: {
         records: {
           [CollectionType.typename]: {
-            createObject: CollectionAction.CREATE,
+            createObject: (props: { name?: string }) => createIntent(CollectionAction.Create, props),
             placeholder: ['unnamed collection label', { ns: SPACE_PLUGIN }],
             icon: 'ph--cards-three--regular',
             // TODO(wittjosiah): Move out of metadata.
-            loadReferences: (collection: CollectionType) =>
-              loadObjectReferences(collection, (collection) => [
-                ...collection.objects,
-                ...Object.values(collection.views),
-              ]),
+            loadReferences: async (collection: CollectionType) =>
+              await RefArray.loadAll([...collection.objects, ...Object.values(collection.views)]),
           },
         },
       },
@@ -496,114 +496,159 @@ export const SpacePlugin = ({
         schema: [CollectionType],
       },
       surface: {
-        component: ({ data, role, ...rest }) => {
-          switch (role) {
-            case 'article':
-              // TODO(wittjosiah): Need to avoid shotgun parsing space state everywhere.
-              return isSpace(data.object) && data.object.state.get() === SpaceState.SPACE_READY ? (
+        definitions: ({ plugins }) => {
+          const resolve = resolvePlugin(plugins, parseMetadataResolverPlugin)?.provides.metadata.resolver;
+          const attention = resolvePlugin(plugins, parseAttentionPlugin)?.provides.attention;
+
+          invariant(resolve, 'Metadata plugin not found.');
+          invariant(attention, 'Attention plugin not found.');
+
+          return [
+            createSurface({
+              id: `${SPACE_PLUGIN}/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
-                  data={{ object: data.object.properties[CollectionType.typename], id: data.object.id }}
+                  data={{ id: data.subject.id, subject: data.subject.properties[CollectionType.typename]?.target }}
                   role={role}
                   {...rest}
                 />
-              ) : data.object instanceof CollectionType ? (
-                {
-                  node: <CollectionMain collection={data.object} />,
-                  disposition: 'fallback',
-                }
-              ) : null;
-            // TODO(burdon): Add role name syntax to minimal plugin docs.
-            case 'complementary--settings':
-              return isSpace(data.subject) ? (
-                <SpaceSettingsPanel space={data.subject} />
-              ) : isEchoObject(data.subject) ? (
-                { node: <DefaultObjectSettings object={data.subject} />, disposition: 'fallback' }
-              ) : null;
-            case 'dialog':
-              if (data.component === 'dxos.org/plugin/space/SpaceSettingsDialog') {
-                return (
-                  <SpaceSettingsDialog
-                    {...(data.subject as SpaceSettingsDialogProps)}
-                    createInvitationUrl={createSpaceInvitationUrl}
-                  />
-                );
-              } else if (data.component === 'dxos.org/plugin/space/JoinDialog') {
-                return <JoinDialog {...(data.subject as JoinPanelProps)} />;
-              } else if (data.component === 'dxos.org/plugin/space/CreateSpaceDialog') {
-                return <CreateSpaceDialog />;
-              } else if (data.component === 'dxos.org/plugin/space/CreateObjectDialog') {
-                return (
-                  <CreateObjectDialog
-                    {...(data.subject as CreateObjectDialogProps)}
-                    schemas={schemas}
-                    navigableCollections={state.values.navigableCollections}
-                    resolve={metadataPlugin?.provides.metadata.resolver}
-                  />
-                );
-              }
-              return null;
-            case 'popover': {
-              if (data.component === 'dxos.org/plugin/space/RenameSpacePopover' && isSpace(data.subject)) {
-                return <PopoverRenameSpace space={data.subject} />;
-              }
-              if (data.component === 'dxos.org/plugin/space/RenameObjectPopover' && isReactiveObject(data.subject)) {
-                return <PopoverRenameObject object={data.subject} />;
-              }
-              return null;
-            }
-            case 'navtree-item-end': {
-              return isReactiveObject(data.object) ? (
-                <SmallPresenceLive
-                  id={data.id as string}
-                  viewers={state.values.viewersByObject[fullyQualifiedId(data.object)]}
-                />
-              ) : isSpace(data.object) ? (
-                <InlineSyncStatus space={data.object} />
-              ) : (
-                // TODO(wittjosiah): Attention glyph for non-echo items should be handled elsewhere.
-                <SmallPresence id={data.id as string} count={0} />
-              );
-            }
-            case 'navbar-end': {
-              if (!isEchoObject(data.object) && !isSpace(data.object)) {
-                return null;
-              }
-
-              const space = isSpace(data.object) ? data.object : getSpace(data.object);
-              const object = isSpace(data.object)
-                ? data.object.state.get() === SpaceState.SPACE_READY
-                  ? (space?.properties[CollectionType.typename] as CollectionType)
-                  : undefined
-                : data.object;
-
-              return space && object
-                ? {
-                    node: (
-                      <>
-                        <SpacePresence object={object} />
-                        {space.properties[COMPOSER_SPACE_LOCK] ? null : <ShareSpaceButton space={space} />}
-                      </>
-                    ),
-                    disposition: 'hoist',
-                  }
-                : null;
-            }
-            case 'section':
-              return data.object instanceof CollectionType ? <CollectionSection collection={data.object} /> : null;
-            case 'settings':
-              return data.plugin === meta.id ? <SpacePluginSettings settings={settings.values} /> : null;
-            case 'menu-footer':
-              if (isEchoObject(data.object)) {
-                return <MenuFooter object={data.object} />;
-              } else {
-                return null;
-              }
-            case 'status': {
-              return <SyncStatus />;
-            }
-            default:
-              return null;
-          }
+              ),
+            }),
+            createSurface({
+              id: `${SPACE_PLUGIN}/collection-fallback`,
+              role: 'article',
+              disposition: 'fallback',
+              filter: (data): data is { subject: CollectionType } => data.subject instanceof CollectionType,
+              component: ({ data }) => <CollectionMain collection={data.subject} />,
+            }),
+            createSurface({
+              id: `${SPACE_PLUGIN}/settings-panel`,
+              // TODO(burdon): Add role name syntax to minimal plugin docs.
+              role: 'complementary--settings',
+              filter: (data): data is { subject: Space } => isSpace(data.subject),
+              component: ({ data }) => <SpaceSettingsPanel space={data.subject} />,
+            }),
+            createSurface({
+              id: `${SPACE_PLUGIN}/object-settings-panel-fallback`,
+              role: 'complementary--settings',
+              disposition: 'fallback',
+              filter: (data): data is { subject: ReactiveEchoObject<any> } => isEchoObject(data.subject),
+              component: ({ data }) => <DefaultObjectSettings object={data.subject} />,
+            }),
+            createSurface({
+              id: SPACE_SETTINGS_DIALOG,
+              role: 'dialog',
+              filter: (data): data is { subject: SpaceSettingsDialogProps } => data.component === SPACE_SETTINGS_DIALOG,
+              component: ({ data }) => (
+                <SpaceSettingsDialog {...data.subject} createInvitationUrl={createSpaceInvitationUrl} />
+              ),
+            }),
+            createSurface({
+              id: JOIN_DIALOG,
+              role: 'dialog',
+              filter: (data): data is { subject: JoinPanelProps } => data.component === JOIN_DIALOG,
+              component: ({ data }) => <JoinDialog {...data.subject} />,
+            }),
+            createSurface({
+              id: CREATE_SPACE_DIALOG,
+              role: 'dialog',
+              filter: (data): data is any => data.component === CREATE_SPACE_DIALOG,
+              component: () => <CreateSpaceDialog />,
+            }),
+            createSurface({
+              id: CREATE_OBJECT_DIALOG,
+              role: 'dialog',
+              filter: (data): data is { subject: Partial<CreateObjectDialogProps> } =>
+                data.component === CREATE_OBJECT_DIALOG,
+              component: ({ data }) => <CreateObjectDialog schemas={schemas} resolve={resolve} {...data.subject} />,
+            }),
+            createSurface({
+              id: POPOVER_RENAME_SPACE,
+              role: 'popover',
+              filter: (data): data is { subject: Space } =>
+                data.component === POPOVER_RENAME_SPACE && isSpace(data.subject),
+              component: ({ data }) => <PopoverRenameSpace space={data.subject} />,
+            }),
+            createSurface({
+              id: POPOVER_RENAME_OBJECT,
+              role: 'popover',
+              filter: (data): data is { subject: ReactiveEchoObject<any> } =>
+                data.component === POPOVER_RENAME_OBJECT && isReactiveObject(data.subject),
+              component: ({ data }) => <PopoverRenameObject object={data.subject} />,
+            }),
+            createSurface({
+              id: `${SPACE_PLUGIN}/navtree-presence`,
+              role: 'navtree-item-end',
+              filter: (data): data is { id: string; subject: ReactiveEchoObject<any>; open?: boolean } =>
+                typeof data.id === 'string' && isEchoObject(data.subject),
+              component: ({ data }) => (
+                <SmallPresenceLive id={data.id} open={data.open} viewers={state.values.viewersByObject[data.id]} />
+              ),
+            }),
+            createSurface({
+              // TODO(wittjosiah): Attention glyph for non-echo items should be handled elsewhere.
+              id: `${SPACE_PLUGIN}/navtree-presence-fallback`,
+              role: 'navtree-item-end',
+              disposition: 'fallback',
+              filter: (data): data is { id: string; open?: boolean } => typeof data.id === 'string',
+              component: ({ data }) => <SmallPresenceLive id={data.id} open={data.open} />,
+            }),
+            createSurface({
+              id: `${SPACE_PLUGIN}/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`,
+              role: 'navbar-end',
+              disposition: 'hoist',
+              filter: (data): data is { subject: Space | ReactiveEchoObject<any> } =>
+                isSpace(data.subject) || isEchoObject(data.subject),
+              component: ({ data }) => {
+                const space = isSpace(data.subject) ? data.subject : getSpace(data.subject);
+                const object = isSpace(data.subject)
+                  ? data.subject.state.get() === SpaceState.SPACE_READY
+                    ? (space?.properties[CollectionType.typename]?.target as CollectionType)
+                    : undefined
+                  : data.subject;
+
+                return space && object ? (
+                  <>
+                    <SpacePresence object={object} />
+                    {space.properties[COMPOSER_SPACE_LOCK] ? null : <ShareSpaceButton space={space} />}
+                  </>
+                ) : null;
+              },
+            }),
+            createSurface({
+              id: `${SPACE_PLUGIN}/collection-section`,
+              role: 'section',
+              filter: (data): data is { subject: CollectionType } => data.subject instanceof CollectionType,
+              component: ({ data }) => <CollectionSection collection={data.subject} />,
+            }),
+            createSurface({
+              id: `${SPACE_PLUGIN}/settings`,
+              role: 'settings',
+              filter: (data): data is any => data.subject === SPACE_PLUGIN,
+              component: () => <SpacePluginSettings settings={settings.values} />,
+            }),
+            createSurface({
+              id: `${SPACE_PLUGIN}/menu-footer`,
+              role: 'menu-footer',
+              filter: (data): data is { subject: ReactiveEchoObject<any> } => isEchoObject(data.subject),
+              component: ({ data }) => <MenuFooter object={data.subject} />,
+            }),
+            createSurface({
+              id: `${SPACE_PLUGIN}/status`,
+              role: 'status',
+              component: () => <SyncStatus />,
+            }),
+          ];
         },
       },
       graph: {
@@ -613,7 +658,7 @@ export const SpacePlugin = ({
           const graphPlugin = resolvePlugin(plugins, parseGraphPlugin);
 
           const client = clientPlugin?.provides.client;
-          const dispatch = intentPlugin?.provides.intent.dispatch;
+          const dispatch = intentPlugin?.provides.intent.dispatchPromise;
           const resolve = metadataPlugin?.provides.metadata.resolver;
           const graph = graphPlugin?.provides.graph;
           if (!client || !dispatch || !resolve || !graph) {
@@ -653,51 +698,51 @@ export const SpacePlugin = ({
           };
 
           return [
-            // Create spaces group node.
+            // Primary actions.
             createExtension({
-              id: `${SPACE_PLUGIN}/root`,
+              id: `${SPACE_PLUGIN}/primary-actions`,
               filter: (node): node is Node<null> => node.id === 'root',
-              connector: () => [spacesNode],
-              resolver: ({ id }) => (id === SPACES ? spacesNode : undefined),
-            }),
-
-            // Create space nodes.
-            createExtension({
-              id: SPACES,
-              filter: (node): node is Node<null> => node.id === SPACES,
               actions: () => [
                 {
-                  id: SpaceAction.OPEN_CREATE_SPACE,
+                  id: SpaceAction.OpenCreateSpace._tag,
                   data: async () => {
-                    await dispatch({
-                      plugin: SPACE_PLUGIN,
-                      action: SpaceAction.OPEN_CREATE_SPACE,
-                    });
+                    await dispatch(createIntent(SpaceAction.OpenCreateSpace));
                   },
                   properties: {
                     label: ['create space label', { ns: SPACE_PLUGIN }],
                     icon: 'ph--plus--regular',
                     testId: 'spacePlugin.createSpace',
                     disposition: 'item',
-                    className: 'border-t border-separator',
                   },
                 },
                 {
-                  id: SpaceAction.JOIN,
+                  id: SpaceAction.Join._tag,
                   data: async () => {
-                    await dispatch({
-                      plugin: SPACE_PLUGIN,
-                      action: SpaceAction.JOIN,
-                    });
+                    await dispatch(createIntent(SpaceAction.Join));
                   },
                   properties: {
                     label: ['join space label', { ns: SPACE_PLUGIN }],
                     icon: 'ph--sign-in--regular',
                     testId: 'spacePlugin.joinSpace',
                     disposition: 'item',
+                    className: 'border-b border-separator',
                   },
                 },
               ],
+            }),
+
+            // Create spaces group node.
+            createExtension({
+              id: `${SPACE_PLUGIN}/root`,
+              filter: (node): node is Node<null> => node.id === 'root',
+              connector: () => [spacesNode],
+              resolver: ({ id }) => (id === SPACES ? spacesNode : undefined),
+            }),
+
+            // Create space nodes.
+            createExtension({
+              id: SPACES,
+              filter: (node): node is Node<null> => node.id === SPACES,
               connector: () => {
                 const spaces = toSignal(
                   (onChange) => client.spaces.subscribe(() => onChange()).unsubscribe,
@@ -806,12 +851,13 @@ export const SpacePlugin = ({
                   return;
                 }
 
-                const collection = space.properties[CollectionType.typename] as CollectionType | undefined;
+                const collection = space.properties[CollectionType.typename]?.target as CollectionType | undefined;
                 if (!collection) {
                   return;
                 }
 
                 return collection.objects
+                  .map((object) => object.target)
                   .filter(nonNullable)
                   .map((object) =>
                     createObjectNode({ object, space, resolve, navigable: state.values.navigableCollections }),
@@ -832,6 +878,7 @@ export const SpacePlugin = ({
                 }
 
                 return collection.objects
+                  .map((object) => object.target)
                   .filter(nonNullable)
                   .map((object) =>
                     createObjectNode({ object, space, resolve, navigable: state.values.navigableCollections }),
@@ -866,7 +913,7 @@ export const SpacePlugin = ({
                 memoize(() => {
                   if (!store.value) {
                     void space.db
-                      .query({ id: objectId })
+                      .query({ id: objectId }, { deleted: QueryOptions.ShowDeletedOption.SHOW_DELETED })
                       .first()
                       .then((o) => (store.value = o))
                       .catch((err) => log.catch(err, { objectId }));
@@ -959,7 +1006,7 @@ export const SpacePlugin = ({
           ];
         },
         serializer: (plugins) => {
-          const dispatch = resolvePlugin(plugins, parseIntentPlugin)?.provides.intent.dispatch;
+          const dispatch = resolvePlugin(plugins, parseIntentPlugin)?.provides.intent.dispatchPromise;
           if (!dispatch) {
             return [];
           }
@@ -986,12 +1033,10 @@ export const SpacePlugin = ({
                 type: DIRECTORY_TYPE,
               }),
               deserialize: async (data) => {
-                const result = await dispatch({
-                  plugin: SPACE_PLUGIN,
-                  action: SpaceAction.CREATE,
-                  data: { name: data.name },
-                });
-                return result?.data.space;
+                const result = await dispatch(
+                  createIntent(SpaceAction.Create, { name: data.name, edgeReplication: true }),
+                );
+                return result.data?.space;
               },
             },
             {
@@ -1006,67 +1051,52 @@ export const SpacePlugin = ({
                 const space = ancestors.find(isSpace);
                 const collection =
                   ancestors.findLast((ancestor) => ancestor instanceof CollectionType) ??
-                  space?.properties[CollectionType.typename];
+                  space?.properties[CollectionType.typename]?.target;
                 if (!space || !collection) {
                   return;
                 }
 
-                const result = await dispatch({
-                  plugin: SPACE_PLUGIN,
-                  action: SpaceAction.ADD_OBJECT,
-                  data: {
+                const result = await dispatch(
+                  createIntent(SpaceAction.AddObject, {
                     target: collection,
                     object: create(CollectionType, { name: data.name, objects: [], views: {} }),
-                  },
-                });
+                  }),
+                );
 
-                return result?.data.object;
+                return result.data?.object;
               },
             },
           ];
         },
       },
       intent: {
-        resolver: async (intent, plugins) => {
-          const clientPlugin = resolvePlugin(plugins, parseClientPlugin);
-          const client = clientPlugin?.provides.client;
-          switch (intent.action) {
-            case SpaceAction.WAIT_FOR_OBJECT: {
-              state.values.awaiting = intent.data?.id;
-              return { data: true };
-            }
+        resolvers: ({ plugins, dispatchPromise: dispatch }) => {
+          const activeParts = resolvePlugin(plugins, parseNavigationPlugin)?.provides.location.active;
+          const client = resolvePlugin(plugins, parseClientPlugin)?.provides.client;
+          const resolve = resolvePlugin(plugins, parseMetadataResolverPlugin)?.provides.metadata.resolver;
 
-            case SpaceAction.OPEN_CREATE_SPACE: {
-              return {
-                data: true,
-                intents: [
-                  [
-                    {
-                      action: LayoutAction.SET_LAYOUT,
-                      data: {
-                        element: 'dialog',
-                        component: 'dxos.org/plugin/space/CreateSpaceDialog',
-                        dialogBlockAlign: 'start',
-                        subject: intent.data,
-                      },
-                    },
-                  ],
-                ],
-              };
-            }
+          invariant(activeParts, 'Active parts not available.');
+          invariant(client, 'Client not available.');
+          invariant(resolve, 'Metadata resolver not available.');
 
-            case SpaceAction.CREATE: {
-              if (!client || !S.is(SpaceForm)(intent.data)) {
-                return;
-              }
-
-              const space = await client.spaces.create({ name: intent.data.name });
-              if (intent.data.edgeReplication) {
+          return [
+            createResolver(SpaceAction.OpenCreateSpace, () => ({
+              intents: [
+                createIntent(LayoutAction.SetLayout, {
+                  element: 'dialog',
+                  component: CREATE_SPACE_DIALOG,
+                  dialogBlockAlign: 'start',
+                }),
+              ],
+            })),
+            createResolver(SpaceAction.Create, async ({ name, edgeReplication }) => {
+              const space = await client.spaces.create({ name });
+              if (edgeReplication) {
                 await space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED);
               }
               await space.waitUntilReady();
               const collection = create(CollectionType, { objects: [], views: {} });
-              space.properties[CollectionType.typename] = collection;
+              space.properties[CollectionType.typename] = makeRef(collection);
 
               if (Migrations.versionProperty) {
                 space.properties[Migrations.versionProperty] = Migrations.targetVersion;
@@ -1079,376 +1109,245 @@ export const SpacePlugin = ({
                   activeParts: { main: [space.id] },
                 },
                 intents: [
-                  [
-                    {
-                      action: ObservabilityAction.SEND_EVENT,
-                      data: {
-                        name: 'space.create',
-                        properties: {
-                          spaceId: space.id,
-                        },
-                      },
-                    },
-                  ],
-                ],
-              };
-            }
-
-            case SpaceAction.JOIN: {
-              return {
-                data: true,
-                intents: [
-                  [
-                    {
-                      action: LayoutAction.SET_LAYOUT,
-                      data: {
-                        element: 'dialog',
-                        component: 'dxos.org/plugin/space/JoinDialog',
-                        dialogBlockAlign: 'start',
-                        subject: {
-                          initialInvitationCode: intent.data?.invitationCode,
-                          onDone: intent.data?.onDone,
-                        } satisfies Partial<JoinPanelProps>,
-                      },
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.create',
+                    properties: {
+                      spaceId: space.id,
                     },
-                  ],
+                  }),
                 ],
               };
-            }
-
-            case SpaceAction.SHARE: {
-              const space = intent.data?.space;
-              if (isSpace(space) && !space.properties[COMPOSER_SPACE_LOCK]) {
+            }),
+            createResolver(SpaceAction.Join, ({ invitationCode }) => ({
+              intents: [
+                createIntent(LayoutAction.SetLayout, {
+                  element: 'dialog',
+                  component: JOIN_DIALOG,
+                  dialogBlockAlign: 'start',
+                  subject: {
+                    initialInvitationCode: invitationCode,
+                  } satisfies Partial<JoinDialogProps>,
+                }),
+              ],
+            })),
+            createResolver(
+              SpaceAction.Share,
+              ({ space }) => {
                 const active = navigationPlugin?.provides.location.active;
                 const mode = layoutPlugin?.provides.layout.layoutMode;
                 const current = active ? firstIdInPart(active, mode === 'solo' ? 'solo' : 'main') : undefined;
                 const target = current?.startsWith(space.id) ? current : undefined;
 
                 return {
-                  data: true,
-                  intents: [
-                    [
-                      {
-                        action: LayoutAction.SET_LAYOUT,
-                        data: {
-                          element: 'dialog',
-                          component: 'dxos.org/plugin/space/SpaceSettingsDialog',
-                          dialogBlockAlign: 'start',
-                          subject: {
-                            space,
-                            target,
-                            initialTab: 'members',
-                            createInvitationUrl: createSpaceInvitationUrl,
-                          } satisfies Partial<SpaceSettingsDialogProps>,
-                        },
-                      },
-                    ],
-                    [
-                      {
-                        action: ObservabilityAction.SEND_EVENT,
-                        data: {
-                          name: 'space.share',
-                          properties: {
-                            space: space.id,
-                          },
-                        },
-                      },
-                    ],
-                  ],
-                };
-              }
-              break;
-            }
-
-            case SpaceAction.LOCK: {
-              const space = intent.data?.space;
-              if (isSpace(space)) {
-                space.properties[COMPOSER_SPACE_LOCK] = true;
-                return {
-                  data: true,
-                  intents: [
-                    [
-                      {
-                        action: ObservabilityAction.SEND_EVENT,
-                        data: {
-                          name: 'space.lock',
-                          properties: {
-                            spaceId: space.id,
-                          },
-                        },
-                      },
-                    ],
-                  ],
-                };
-              }
-              break;
-            }
-
-            case SpaceAction.UNLOCK: {
-              const space = intent.data?.space;
-              if (isSpace(space)) {
-                space.properties[COMPOSER_SPACE_LOCK] = false;
-                return {
-                  data: true,
-                  intents: [
-                    [
-                      {
-                        action: ObservabilityAction.SEND_EVENT,
-                        data: {
-                          name: 'space.unlock',
-                          properties: {
-                            spaceId: space.id,
-                          },
-                        },
-                      },
-                    ],
-                  ],
-                };
-              }
-              break;
-            }
-
-            case SpaceAction.RENAME: {
-              const { caller, space } = intent.data ?? {};
-              if (typeof caller === 'string' && isSpace(space)) {
-                return {
-                  intents: [
-                    [
-                      {
-                        action: LayoutAction.SET_LAYOUT,
-                        data: {
-                          element: 'popover',
-                          anchorId: `dxos.org/ui/${caller}/${space.id}`,
-                          component: 'dxos.org/plugin/space/RenameSpacePopover',
-                          subject: space,
-                        },
-                      },
-                    ],
-                  ],
-                };
-              }
-              break;
-            }
-
-            case SpaceAction.OPEN_SETTINGS: {
-              const space = intent.data?.space;
-              if (isSpace(space)) {
-                return {
-                  data: true,
-                  intents: [
-                    [
-                      {
-                        action: LayoutAction.SET_LAYOUT,
-                        data: {
-                          element: 'dialog',
-                          component: 'dxos.org/plugin/space/SpaceSettingsDialog',
-                          dialogBlockAlign: 'start',
-                          subject: {
-                            space,
-                            initialTab: 'settings',
-                            createInvitationUrl: createSpaceInvitationUrl,
-                          } satisfies Partial<SpaceSettingsDialogProps>,
-                        },
-                      },
-                    ],
-                  ],
-                };
-              }
-              break;
-            }
-
-            case SpaceAction.OPEN: {
-              const space = intent.data?.space;
-              if (isSpace(space)) {
-                await space.open();
-                return { data: true };
-              }
-              break;
-            }
-
-            case SpaceAction.CLOSE: {
-              const space = intent.data?.space;
-              if (isSpace(space)) {
-                await space.close();
-                return { data: true };
-              }
-              break;
-            }
-
-            case SpaceAction.MIGRATE: {
-              const space = intent.data?.space;
-              if (isSpace(space)) {
-                if (space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
-                  state.values.sdkMigrationRunning[space.id] = true;
-                  await space.internal.migrate();
-                  state.values.sdkMigrationRunning[space.id] = false;
-                }
-                const result = await Migrations.migrate(space, intent.data?.version);
-                return {
-                  data: result,
                   intents: [
-                    [
-                      {
-                        action: ObservabilityAction.SEND_EVENT,
-                        data: {
-                          name: 'space.migrate',
-                          properties: {
-                            spaceId: space.id,
-                            version: intent.data?.version,
-                          },
-                        },
+                    createIntent(LayoutAction.SetLayout, {
+                      element: 'dialog',
+                      component: SPACE_SETTINGS_DIALOG,
+                      dialogBlockAlign: 'start',
+                      subject: {
+                        space,
+                        target,
+                        initialTab: 'members',
+                        createInvitationUrl: createSpaceInvitationUrl,
+                      } satisfies Partial<SpaceSettingsDialogProps>,
+                    }),
+                    createIntent(ObservabilityAction.SendEvent, {
+                      name: 'space.share',
+                      properties: {
+                        space: space.id,
                       },
-                    ],
+                    }),
                   ],
                 };
-              }
-              break;
-            }
-
-            case SpaceAction.OPEN_CREATE_OBJECT: {
+              },
+              { filter: (data): data is { space: Space } => !data.space.properties[COMPOSER_SPACE_LOCK] },
+            ),
+            createResolver(SpaceAction.Lock, ({ space }) => {
+              space.properties[COMPOSER_SPACE_LOCK] = true;
               return {
-                data: true,
                 intents: [
-                  [
-                    {
-                      action: LayoutAction.SET_LAYOUT,
-                      data: {
-                        element: 'dialog',
-                        component: 'dxos.org/plugin/space/CreateObjectDialog',
-                        dialogBlockAlign: 'start',
-                        subject: intent.data,
-                      },
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.lock',
+                    properties: {
+                      spaceId: space.id,
                     },
-                  ],
+                  }),
                 ],
               };
-            }
-
-            case SpaceAction.ADD_OBJECT: {
-              const object = intent.data?.object ?? intent.data?.result;
-              if (!isReactiveObject(object)) {
-                return;
-              }
-
-              const space = isSpace(intent.data?.target) ? intent.data?.target : getSpace(intent.data?.target);
-              if (!space) {
-                return;
+            }),
+            createResolver(SpaceAction.Unlock, ({ space }) => {
+              space.properties[COMPOSER_SPACE_LOCK] = false;
+              return {
+                intents: [
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.unlock',
+                    properties: {
+                      spaceId: space.id,
+                    },
+                  }),
+                ],
+              };
+            }),
+            createResolver(SpaceAction.Rename, ({ caller, space }) => {
+              return {
+                intents: [
+                  createIntent(LayoutAction.SetLayout, {
+                    element: 'popover',
+                    anchorId: `dxos.org/ui/${caller}/${space.id}`,
+                    component: POPOVER_RENAME_SPACE,
+                    subject: space,
+                  }),
+                ],
+              };
+            }),
+            createResolver(SpaceAction.OpenSettings, ({ space }) => {
+              return {
+                intents: [
+                  createIntent(LayoutAction.SetLayout, {
+                    element: 'dialog',
+                    component: SPACE_SETTINGS_DIALOG,
+                    dialogBlockAlign: 'start',
+                    subject: {
+                      space,
+                      initialTab: 'settings',
+                      createInvitationUrl: createSpaceInvitationUrl,
+                    } satisfies Partial<SpaceSettingsDialogProps>,
+                  }),
+                ],
+              };
+            }),
+            createResolver(SpaceAction.Open, async ({ space }) => {
+              await space.open();
+            }),
+            createResolver(SpaceAction.Close, async ({ space }) => {
+              await space.close();
+            }),
+            createResolver(SpaceAction.Migrate, async ({ space, version }) => {
+              if (space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
+                state.values.sdkMigrationRunning[space.id] = true;
+                await space.internal.migrate();
+                state.values.sdkMigrationRunning[space.id] = false;
               }
+              const result = await Migrations.migrate(space, version);
+              return {
+                data: result,
+                intents: [
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.migrate',
+                    properties: {
+                      spaceId: space.id,
+                      version,
+                    },
+                  }),
+                ],
+              };
+            }),
+            createResolver(SpaceAction.OpenCreateObject, ({ target, navigable = true }) => {
+              return {
+                intents: [
+                  createIntent(LayoutAction.SetLayout, {
+                    element: 'dialog',
+                    component: CREATE_OBJECT_DIALOG,
+                    dialogBlockAlign: 'start',
+                    subject: {
+                      target,
+                      shouldNavigate: navigable
+                        ? (object: ReactiveObject<any>) =>
+                            !(object instanceof CollectionType) || state.values.navigableCollections
+                        : () => false,
+                    } satisfies Partial<CreateObjectDialogProps>,
+                  }),
+                ],
+              };
+            }),
+            createResolver(SpaceAction.AddObject, async ({ target, object }) => {
+              const space = isSpace(target) ? target : getSpace(target);
+              invariant(space, 'Space not found.');
 
               if (space.db.coreDatabase.getAllObjectIds().length >= SPACE_MAX_OBJECTS) {
-                return {
-                  data: false,
-                  intents: [
-                    [
-                      {
-                        action: LayoutAction.SET_LAYOUT,
-                        data: {
-                          element: 'toast',
-                          subject: {
-                            id: `${SPACE_PLUGIN}/space-limit`,
-                            title: translations[0]['en-US'][SPACE_PLUGIN]['space limit label'],
-                            description: translations[0]['en-US'][SPACE_PLUGIN]['space limit description'],
-                            duration: 5_000,
-                            icon: 'ph--warning--regular',
-                            actionLabel: translations[0]['en-US'][SPACE_PLUGIN]['remove deleted objects label'],
-                            actionAlt: translations[0]['en-US'][SPACE_PLUGIN]['remove deleted objects alt'],
-                            // TODO(wittjosiah): Use OS namespace.
-                            closeLabel: translations[0]['en-US'][SPACE_PLUGIN]['space limit close label'],
-                            onAction: () => space.db.coreDatabase.unlinkDeletedObjects(),
-                          },
-                        },
-                      },
-                    ],
-                    [
-                      {
-                        action: ObservabilityAction.SEND_EVENT,
-                        data: {
-                          name: 'space.limit',
-                          properties: {
-                            spaceId: space.id,
-                          },
-                        },
-                      },
-                    ],
-                  ],
-                };
+                void dispatch(
+                  createIntent(LayoutAction.SetLayout, {
+                    element: 'toast',
+                    subject: {
+                      id: `${SPACE_PLUGIN}/space-limit`,
+                      title: ['space limit label', { ns: SPACE_PLUGIN }],
+                      description: ['space limit description', { ns: SPACE_PLUGIN }],
+                      duration: 5_000,
+                      icon: 'ph--warning--regular',
+                      actionLabel: ['remove deleted objects label', { ns: SPACE_PLUGIN }],
+                      actionAlt: ['remove deleted objects alt', { ns: SPACE_PLUGIN }],
+                      closeLabel: ['close label', { ns: 'os' }],
+                      onAction: () => space.db.coreDatabase.unlinkDeletedObjects(),
+                    },
+                  }),
+                );
+                void dispatch(
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.limit',
+                    properties: {
+                      spaceId: space.id,
+                    },
+                  }),
+                );
+
+                throw new Error('Space limit reached.');
               }
 
-              if (intent.data?.target instanceof CollectionType) {
-                intent.data?.target.objects.push(object as HasId);
-              } else if (isSpace(intent.data?.target)) {
-                const collection = space.properties[CollectionType.typename];
+              if (target instanceof CollectionType) {
+                target.objects.push(makeRef(object as HasId));
+              } else if (isSpace(target)) {
+                const collection = space.properties[CollectionType.typename]?.target;
                 if (collection instanceof CollectionType) {
-                  collection.objects.push(object as HasId);
+                  collection.objects.push(makeRef(object as HasId));
                 } else {
                   // TODO(wittjosiah): Can't add non-echo objects by including in a collection because of types.
-                  const collection = create(CollectionType, { objects: [object as HasId], views: {} });
-                  space.properties[CollectionType.typename] = collection;
+                  const collection = create(CollectionType, { objects: [makeRef(object as HasId)], views: {} });
+                  space.properties[CollectionType.typename] = makeRef(collection);
                 }
               }
 
               return {
-                data: { id: fullyQualifiedId(object), object, activeParts: { main: [fullyQualifiedId(object)] } },
+                data: {
+                  id: fullyQualifiedId(object),
+                  object: object as HasId,
+                  activeParts: { main: [fullyQualifiedId(object)] },
+                },
                 intents: [
-                  [
-                    {
-                      action: ObservabilityAction.SEND_EVENT,
-                      data: {
-                        name: 'space.object.add',
-                        properties: {
-                          spaceId: space.id,
-                          objectId: object.id,
-                          typename: getTypename(object),
-                        },
-                      },
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.object.add',
+                    properties: {
+                      spaceId: space.id,
+                      objectId: object.id,
+                      typename: getTypename(object),
                     },
-                  ],
+                  }),
                 ],
               };
-            }
-
-            case SpaceAction.REMOVE_OBJECTS: {
-              const objects = intent.data?.objects ?? intent.data?.result;
-              invariant(Array.isArray(objects));
-
+            }),
+            createResolver(SpaceAction.RemoveObjects, async ({ objects, target, deletionData }, undo) => {
               // All objects must be a member of the same space.
               const space = getSpace(objects[0]);
-              if (!space || !objects.every((obj) => isEchoObject(obj) && getSpace(obj) === space)) {
-                return;
-              }
-
-              const resolve = resolvePlugin(plugins, parseMetadataResolverPlugin)?.provides.metadata.resolver;
-              const activeParts = navigationPlugin?.provides.location.active;
+              invariant(space && objects.every((obj) => isEchoObject(obj) && getSpace(obj) === space));
               const openObjectIds = new Set<string>(openIds(activeParts ?? {}));
 
-              if (!intent.undo && resolve) {
-                const parentCollection = intent.data?.collection ?? space.properties[CollectionType.typename];
+              if (!undo) {
+                const parentCollection: CollectionType = target ?? space.properties[CollectionType.typename]?.target;
                 const nestedObjectsList = await Promise.all(objects.map((obj) => getNestedObjects(obj, resolve)));
 
                 const deletionData = {
                   objects,
                   parentCollection,
                   indices: objects.map((obj) =>
-                    parentCollection instanceof CollectionType ? parentCollection.objects.indexOf(obj as Expando) : -1,
+                    parentCollection instanceof CollectionType
+                      ? parentCollection.objects.findIndex((object) => object.target === obj)
+                      : -1,
                   ),
                   nestedObjectsList,
                   wasActive: objects
                     .flatMap((obj, i) => [obj, ...nestedObjectsList[i]])
                     .map((obj) => fullyQualifiedId(obj))
                     .filter((id) => openObjectIds.has(id)),
-                };
-
-                if (deletionData.wasActive.length > 0) {
-                  await intentPlugin?.provides.intent.dispatch({
-                    action: NavigationAction.CLOSE,
-                    data: {
-                      activeParts: {
-                        main: deletionData.wasActive,
-                        sidebar: deletionData.wasActive,
-                      },
-                    },
-                  });
-                }
+                } satisfies SpaceAction.DeletionData;
 
                 if (deletionData.parentCollection instanceof CollectionType) {
                   [...deletionData.indices]
@@ -1472,102 +1371,78 @@ export const SpacePlugin = ({
                     : 'object deleted label';
 
                 return {
-                  data: true,
                   undoable: {
                     // TODO(ZaymonFC): Pluralize if more than one object.
-                    message: translations[0]['en-US'][SPACE_PLUGIN][undoMessageKey],
-                    data: deletionData,
+                    message: [undoMessageKey, { ns: SPACE_PLUGIN }],
+                    data: { deletionData },
                   },
+                  intents:
+                    deletionData.wasActive.length > 0
+                      ? [createIntent(NavigationAction.Close, { activeParts: { main: deletionData.wasActive } })]
+                      : undefined,
                 };
               } else {
-                const undoData = intent.data;
                 if (
-                  undoData?.objects?.length &&
-                  undoData.objects.every(isEchoObject) &&
-                  undoData.parentCollection instanceof CollectionType
+                  deletionData?.objects?.length &&
+                  deletionData.objects.every(isEchoObject) &&
+                  deletionData.parentCollection instanceof CollectionType
                 ) {
                   // Restore the object to the space.
-                  const restoredObjects = undoData.objects.map((obj: Expando) => space.db.add(obj));
+                  const restoredObjects = deletionData.objects.map((obj: Expando) => space.db.add(obj));
 
                   // Restore nested objects to the space.
-                  undoData.nestedObjectsList.flat().forEach((obj: Expando) => {
+                  deletionData.nestedObjectsList.flat().forEach((obj: Expando) => {
                     space.db.add(obj);
                   });
 
-                  undoData.indices.forEach((index: number, i: number) => {
+                  deletionData.indices.forEach((index: number, i: number) => {
                     if (index !== -1) {
-                      undoData.parentCollection.objects.splice(index, 0, restoredObjects[i] as Expando);
+                      deletionData.parentCollection.objects.splice(index, 0, makeRef(restoredObjects[i] as Expando));
                     }
                   });
 
-                  if (undoData.wasActive.length > 0) {
-                    await intentPlugin?.provides.intent.dispatch({
-                      action: NavigationAction.OPEN,
-                      data: { activeParts: { main: undoData.wasActive } },
-                    });
-                  }
-
-                  return { data: true };
+                  return {
+                    intents:
+                      deletionData.wasActive.length > 0
+                        ? [
+                            createIntent(NavigationAction.Open, {
+                              activeParts: { main: deletionData.wasActive as string[] },
+                            }),
+                          ]
+                        : undefined,
+                  };
                 }
-
-                return { data: false };
-              }
-            }
-
-            case SpaceAction.RENAME_OBJECT: {
-              const object = intent.data?.object ?? intent.data?.result;
-              const caller = intent.data?.caller;
-              if (isReactiveObject(object) && caller) {
-                return {
-                  intents: [
-                    [
-                      {
-                        action: LayoutAction.SET_LAYOUT,
-                        data: {
-                          element: 'popover',
-                          anchorId: `dxos.org/ui/${caller}/${fullyQualifiedId(object)}`,
-                          component: 'dxos.org/plugin/space/RenameObjectPopover',
-                          subject: object,
-                        },
-                      },
-                    ],
-                  ],
-                };
-              }
-              break;
-            }
-
-            case SpaceAction.DUPLICATE_OBJECT: {
-              const originalObject = intent.data?.object ?? intent.data?.result;
-              const resolve = resolvePlugin(plugins, parseMetadataResolverPlugin)?.provides.metadata.resolver;
-              const space = isSpace(intent.data?.target) ? intent.data?.target : getSpace(intent.data?.target);
-              if (!isEchoObject(originalObject) || !resolve || !space) {
-                return;
               }
+            }),
+            createResolver(SpaceAction.RenameObject, async ({ object, caller }) => ({
+              intents: [
+                createIntent(LayoutAction.SetLayout, {
+                  element: 'popover',
+                  anchorId: `dxos.org/ui/${caller}/${fullyQualifiedId(object)}`,
+                  component: POPOVER_RENAME_OBJECT,
+                  subject: object,
+                }),
+              ],
+            })),
+            createResolver(SpaceAction.DuplicateObject, async ({ object, target }) => {
+              const space = isSpace(target) ? target : getSpace(target);
+              invariant(space, 'Space not found.');
 
-              const newObject = await cloneObject(originalObject, resolve, space);
+              const newObject = await cloneObject(object, resolve, space);
               return {
-                intents: [
-                  [{ action: SpaceAction.ADD_OBJECT, data: { object: newObject, target: intent.data?.target } }],
-                ],
+                intents: [createIntent(SpaceAction.AddObject, { object: newObject, target })],
               };
-            }
-
-            case SpaceAction.TOGGLE_HIDDEN: {
-              settings.values.showHidden = intent.data?.state ?? !settings.values.showHidden;
-              return { data: true };
-            }
-
-            case CollectionAction.CREATE: {
-              const collection = create(CollectionType, {
-                name: intent.data?.name,
-                objects: [],
-                views: {},
-              });
-
-              return { data: collection };
-            }
-          }
+            }),
+            createResolver(SpaceAction.WaitForObject, async ({ id }) => {
+              state.values.awaiting = id;
+            }),
+            createResolver(SpaceAction.ToggleHidden, async ({ state }) => {
+              settings.values.showHidden = state;
+            }),
+            createResolver(CollectionAction.Create, async ({ name }) => ({
+              data: { object: create(CollectionType, { name, objects: [], views: {} }) },
+            })),
+          ];
         },
       },
     },