@dxos/plugin-deck 0.7.5-main.9d2a38b → 0.7.5-main.e94eead

package/src/DeckPlugin.ts

@@ -5,21 +5,17 @@
 import { setAutoFreeze } from 'immer';
 
 import { allOf, Capabilities, contributes, defineModule, definePlugin, Events, oneOf } from '@dxos/app-framework';
-import { AttentionEvents } from '@dxos/plugin-attention';
 import { translations as stackTranslations } from '@dxos/react-ui-stack';
 
 import {
   AppGraphBuilder,
   CheckAppScheme,
+  DeckSettings,
   DeckState,
   LayoutIntentResolver,
-  LayoutState,
-  LocationState,
-  NavigationIntentResolver,
-  ReactContext,
   ReactRoot,
-  DeckSettings,
   ReactSurface,
+  Tools,
   UrlHandler,
 } from './capabilities';
 import { DeckEvents } from './events';
@@ -33,35 +29,23 @@ setAutoFreeze(false);
 
 export const DeckPlugin = () =>
   definePlugin(meta, [
-    //
-    // Settings
-    //
-
+    defineModule({
+      id: `${meta.id}/module/check-app-scheme`,
+      activatesOn: Events.SettingsReady,
+      activate: CheckAppScheme,
+    }),
     defineModule({
       id: `${meta.id}/module/settings`,
       activatesOn: Events.SetupSettings,
       activate: DeckSettings,
     }),
-    defineModule({
-      id: `${meta.id}/module/react-surface`,
-      activatesOn: Events.Startup,
-      activate: ReactSurface,
-    }),
-
-    //
-    // Layout
-    //
-
     defineModule({
       id: `${meta.id}/module/layout`,
-      activatesOn: oneOf(Events.Startup, Events.SetupAppGraph),
-      activatesAfter: [Events.LayoutReady],
-      activate: LayoutState,
-    }),
-    defineModule({
-      id: `${meta.id}/module/deck`,
-      activatesOn: oneOf(Events.Startup, Events.SetupAppGraph),
-      activatesAfter: [DeckEvents.StateReady],
+      // TODO(wittjosiah): Does not integrate with settings store.
+      //   Should this be a different event?
+      //   Should settings store be renamed to be more generic?
+      activatesOn: oneOf(Events.SetupSettings, Events.SetupAppGraph),
+      activatesAfter: [Events.LayoutReady, DeckEvents.StateReady],
       activate: DeckState,
     }),
     defineModule({
@@ -69,19 +53,20 @@ export const DeckPlugin = () =>
       activatesOn: Events.SetupTranslations,
       activate: () => contributes(Capabilities.Translations, [...translations, ...stackTranslations]),
     }),
-    defineModule({
-      id: `${meta.id}/module/react-context`,
-      activatesOn: Events.Startup,
-      activate: ReactContext,
-    }),
     defineModule({
       id: `${meta.id}/module/react-root`,
       activatesOn: Events.Startup,
+      activatesBefore: [DeckEvents.SetupComplementaryPanels],
       activate: ReactRoot,
     }),
+    defineModule({
+      id: `${meta.id}/module/react-surface`,
+      activatesOn: Events.SetupReactSurface,
+      activate: ReactSurface,
+    }),
     defineModule({
       id: `${meta.id}/module/layout-intent-resolver`,
-      activatesOn: Events.SetupIntents,
+      activatesOn: Events.SetupIntentResolver,
       activate: LayoutIntentResolver,
     }),
     defineModule({
@@ -89,35 +74,14 @@ export const DeckPlugin = () =>
       activatesOn: Events.SetupAppGraph,
       activate: AppGraphBuilder,
     }),
-
-    //
-    // Navigation
-    //
-
-    defineModule({
-      id: `${meta.id}/module/location`,
-      activatesOn: oneOf(Events.Startup, Events.SetupAppGraph),
-      activatesAfter: [Events.LocationReady],
-      activate: LocationState,
-    }),
     defineModule({
-      id: `${meta.id}/module/check-app-scheme`,
-      activatesOn: Events.SettingsReady,
-      activate: CheckAppScheme,
+      id: `${meta.id}/module/tools`,
+      activatesOn: Events.SetupArtifactDefinition,
+      activate: Tools,
     }),
     defineModule({
       id: `${meta.id}/module/url`,
-      activatesOn: allOf(
-        Events.DispatcherReady,
-        Events.LayoutReady,
-        Events.LocationReady,
-        AttentionEvents.AttentionReady,
-      ),
+      activatesOn: allOf(Events.DispatcherReady, DeckEvents.StateReady),
       activate: UrlHandler,
     }),
-    defineModule({
-      id: `${meta.id}/module/navigation-intent-resolver`,
-      activatesOn: Events.SetupIntents,
-      activate: NavigationIntentResolver,
-    }),
   ]);

package/src/capabilities/{layout/app-graph-builder.ts → app-graph-builder.ts}

@@ -2,19 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import {
-  Capabilities,
-  contributes,
-  createIntent,
-  LayoutAction,
-  NavigationAction,
-  openIds,
-  type PluginsContext,
-} from '@dxos/app-framework';
+import { Capabilities, contributes, createIntent, LayoutAction, type PluginsContext } from '@dxos/app-framework';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
 import { createExtension, type Node, ROOT_ID } from '@dxos/plugin-graph';
 
-import { DECK_PLUGIN } from '../../meta';
+import { DeckCapabilities } from './capabilities';
+import { DECK_PLUGIN } from '../meta';
 
 export default (context: PluginsContext) =>
   contributes(
@@ -23,13 +16,15 @@ export default (context: PluginsContext) =>
       id: DECK_PLUGIN,
       filter: (node): node is Node<null> => node.id === ROOT_ID,
       actions: () => {
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+
         // NOTE(Zan): This is currently disabled.
         // TODO(Zan): Fullscreen needs to know the active node and provide that to the layout part.
         const _fullscreen = {
-          id: `${LayoutAction.SetLayoutMode._tag}/fullscreen`,
+          id: `${LayoutAction.UpdateLayout._tag}/fullscreen`,
           data: async () => {
             const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
-            await dispatch(createIntent(LayoutAction.SetLayoutMode, { layoutMode: 'fullscreen' }));
+            await dispatch(createIntent(LayoutAction.SetLayoutMode, { part: 'mode', options: { mode: 'fullscreen' } }));
           },
           properties: {
             label: ['toggle fullscreen label', { ns: DECK_PLUGIN }],
@@ -42,13 +37,15 @@ export default (context: PluginsContext) =>
         };
 
         const closeCurrent = {
-          id: `${NavigationAction.Close._tag}/current`,
+          id: `${LayoutAction.Close._tag}/current`,
           data: async () => {
             const attention = context.requestCapability(AttentionCapabilities.Attention);
             const attended = attention.current.at(-1);
             if (attended) {
               const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
-              await dispatch(createIntent(NavigationAction.Close, { activeParts: { main: [attended] } }));
+              await dispatch(
+                createIntent(LayoutAction.Close, { part: 'main', subject: [attended], options: { state: false } }),
+              );
             }
           },
           properties: {
@@ -58,18 +55,13 @@ export default (context: PluginsContext) =>
         };
 
         const closeOthers = {
-          id: `${NavigationAction.Close._tag}/others`,
+          id: `${LayoutAction.Close._tag}/others`,
           data: async () => {
             const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
-            const location = context.requestCapability(Capabilities.Location);
             const attention = context.requestCapability(AttentionCapabilities.Attention);
             const attended = attention.current.at(-1);
-            const ids = openIds(location.active, ['main']).filter((id) => id !== attended);
-            await dispatch(
-              createIntent(NavigationAction.Close, {
-                activeParts: { main: ids },
-              }),
-            );
+            const ids = state.deck.active.filter((id) => id !== attended) ?? [];
+            await dispatch(createIntent(LayoutAction.Close, { part: 'main', subject: ids, options: { state: false } }));
           },
           properties: {
             label: ['close others label', { ns: DECK_PLUGIN }],
@@ -78,13 +70,14 @@ export default (context: PluginsContext) =>
         };
 
         const closeAll = {
-          id: `${NavigationAction.Close._tag}/all`,
+          id: `${LayoutAction.Close._tag}/all`,
           data: async () => {
             const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
-            const location = context.requestCapability(Capabilities.Location);
             await dispatch(
-              createIntent(NavigationAction.Close, {
-                activeParts: { main: openIds(location.active, ['main']) },
+              createIntent(LayoutAction.Close, {
+                part: 'main',
+                subject: state.deck.active,
+                options: { state: false },
               }),
             );
           },
@@ -94,8 +87,27 @@ export default (context: PluginsContext) =>
           },
         };
 
-        const layoutMode = context.requestCapabilities(Capabilities.Layout)[0]?.layoutMode;
-        return layoutMode === 'deck' ? [closeCurrent, closeOthers, closeAll] : [];
+        const toggleSidebar = {
+          id: `${LayoutAction.UpdateSidebar._tag}/nav`,
+          data: async () => {
+            state.sidebarState = state.sidebarState === 'expanded' ? 'collapsed' : 'expanded';
+          },
+          properties: {
+            label: [
+              state.sidebarState === 'expanded' ? 'collapse navigation sidebar label' : 'open navigation sidebar label',
+              { ns: DECK_PLUGIN },
+            ],
+            icon: 'ph--sidebar--regular',
+            keyBinding: {
+              macos: 'meta+b',
+            },
+            disposition: 'pin-end',
+            position: 'hoist',
+            l0Breakpoint: 'lg',
+          },
+        };
+
+        return !state.deck.solo ? [closeCurrent, closeOthers, closeAll, toggleSidebar] : [toggleSidebar];
       },
     }),
   );

package/src/capabilities/capabilities.ts

@@ -2,16 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { defineCapability, type Label } from '@dxos/app-framework';
+import { defineCapability } from '@dxos/app-framework';
 import { type DeepReadonly } from '@dxos/util';
 
-import { type DeckContextType } from '../components';
 import { DECK_PLUGIN } from '../meta';
+import { type DeckState, type Panel } from '../types';
 
 export namespace DeckCapabilities {
-  export const DeckState = defineCapability<DeepReadonly<DeckContextType>>(`${DECK_PLUGIN}/capability/state`);
-  export const MutableDeckState = defineCapability<DeckContextType>(`${DECK_PLUGIN}/capability/state`);
-  export const ComplementaryPanel = defineCapability<{ id: string; label: Label; icon: string }>(
-    `${DECK_PLUGIN}/capability/complementary-panel`,
-  );
+  export const DeckState = defineCapability<DeepReadonly<DeckState>>(`${DECK_PLUGIN}/capability/state`);
+  export const MutableDeckState = defineCapability<DeckState>(`${DECK_PLUGIN}/capability/state`);
+  export const ComplementaryPanel = defineCapability<Panel>(`${DECK_PLUGIN}/capability/complementary-panel`);
 }

package/src/capabilities/{navigation/check-app-scheme.ts → check-app-scheme.ts}

@@ -7,8 +7,8 @@
 
 import { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';
 
-import { DECK_PLUGIN } from '../../meta';
-import { type DeckSettingsProps } from '../../types';
+import { DECK_PLUGIN } from '../meta';
+import { type DeckSettingsProps } from '../types';
 
 const isSocket = !!(globalThis as any).__args;
 

package/src/capabilities/index.ts

@@ -2,7 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
+import { lazy } from '@dxos/app-framework';
+
+export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
+export const CheckAppScheme = lazy(() => import('./check-app-scheme'));
+export const LayoutIntentResolver = lazy(() => import('./intent-resolver'));
+export const ReactRoot = lazy(() => import('./react-root'));
+export const ReactSurface = lazy(() => import('./react-surface'));
+export const DeckSettings = lazy(() => import('./settings'));
+export const DeckState = lazy(() => import('./state'));
+export const Tools = lazy(() => import('./tools'));
+export const UrlHandler = lazy(() => import('./url-handler'));
+
 export * from './capabilities';
-export * from './layout';
-export * from './navigation';
-export * from './settings';

package/src/capabilities/intent-resolver.ts

@@ -0,0 +1,368 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { batch } from '@preact/signals-core';
+import { pipe } from 'effect';
+
+import {
+  Capabilities,
+  createResolver,
+  contributes,
+  IntentAction,
+  LayoutAction,
+  type PluginsContext,
+  createIntent,
+  chain,
+} from '@dxos/app-framework';
+import { getTypename, S } from '@dxos/echo-schema';
+import { isReactiveObject } from '@dxos/live-object';
+import { log } from '@dxos/log';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { ObservabilityAction } from '@dxos/plugin-observability/types';
+import { isNonNullable } from '@dxos/util';
+
+import { DeckCapabilities } from './capabilities';
+import { closeEntry, incrementPlank, openEntry } from '../layout';
+import { DECK_PLUGIN } from '../meta';
+import { DeckAction, type LayoutMode, type DeckSettingsProps, isLayoutMode, getMode } from '../types';
+import { setActive } from '../util';
+
+export default (context: PluginsContext) =>
+  contributes(Capabilities.IntentResolver, [
+    createResolver({
+      intent: IntentAction.ShowUndo,
+      resolve: (data) => {
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const { undoPromise: undo } = context.requestCapability(Capabilities.IntentDispatcher);
+
+        // TODO(wittjosiah): Support undoing further back than the last action.
+        if (layout.currentUndoId) {
+          layout.toasts = layout.toasts.filter((toast) => toast.id !== layout.currentUndoId);
+        }
+        layout.currentUndoId = `${IntentAction.ShowUndo._tag}-${Date.now()}`;
+        layout.toasts = [
+          ...layout.toasts,
+          {
+            id: layout.currentUndoId,
+            title: data.message ?? ['undo available label', { ns: DECK_PLUGIN }],
+            duration: 10_000,
+            actionLabel: ['undo action label', { ns: DECK_PLUGIN }],
+            actionAlt: ['undo action alt', { ns: DECK_PLUGIN }],
+            closeLabel: ['undo close label', { ns: DECK_PLUGIN }],
+            onAction: () => undo(),
+          },
+        ];
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdateSidebar.fields.input)`
+      //  but the filter is not being applied correctly.
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.UpdateSidebar.fields.input> =>
+        S.is(LayoutAction.UpdateSidebar.fields.input)(data),
+      resolve: ({ options }) => {
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const next = options?.state ?? layout.sidebarState;
+        if (next !== layout.sidebarState) {
+          layout.sidebarState = next;
+        }
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdateComplementary.fields.input)`
+      //  but the filter is not being applied correctly.
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.UpdateComplementary.fields.input> =>
+        S.is(LayoutAction.UpdateComplementary.fields.input)(data),
+      resolve: ({ subject, options }) => {
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+
+        if (layout.complementarySidebarPanel !== subject) {
+          layout.complementarySidebarPanel = subject;
+        }
+
+        const next = subject ? 'expanded' : options?.state ?? layout.complementarySidebarState;
+        if (next !== layout.complementarySidebarState) {
+          layout.complementarySidebarState = next;
+        }
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdateDialog.fields.input)`
+      //  but the filter is not being applied correctly.
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.UpdateDialog.fields.input> =>
+        S.is(LayoutAction.UpdateDialog.fields.input)(data),
+      resolve: ({ subject, options }) => {
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        layout.dialogOpen = options.state ?? Boolean(subject);
+        layout.dialogContent = subject ? { component: subject, props: options.props } : null;
+        layout.dialogBlockAlign = options.blockAlign ?? 'center';
+        layout.dialogType = options.type ?? 'default';
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdatePopover.fields.input)`
+      //  but the filter is not being applied correctly.
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.UpdatePopover.fields.input> =>
+        S.is(LayoutAction.UpdatePopover.fields.input)(data),
+      resolve: ({ subject, options }) => {
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        layout.popoverOpen = options.state ?? Boolean(subject);
+        layout.popoverContent = subject ? { component: subject, props: options.props } : null;
+        layout.popoverAnchorId = options.anchorId;
+        layout.popoverSide = options.side;
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.AddToast.fields.input)`
+      //  but the filter is not being applied correctly.
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.AddToast.fields.input> =>
+        S.is(LayoutAction.AddToast.fields.input)(data),
+      resolve: ({ subject }) => {
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        layout.toasts.push(subject);
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.SetLayoutMode.fields.input)`
+      //  but the filter is not being applied correctly.
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.SetLayoutMode.fields.input> => {
+        if (!S.is(LayoutAction.SetLayoutMode.fields.input)(data)) {
+          return false;
+        }
+
+        if ('mode' in data.options) {
+          return isLayoutMode(data.options.mode);
+        }
+
+        return true;
+      },
+      resolve: ({ subject, options }) => {
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+
+        const setMode = (mode: LayoutMode) => {
+          const deck = state.deck;
+          const current = deck.solo ? [deck.solo] : deck.active;
+          // When un-soloing, the solo entry is added to the deck.
+          const next = (
+            mode !== 'deck' ? [subject ?? deck.solo ?? deck.active[0]] : [...deck.active, deck.solo]
+          ).filter(isNonNullable);
+
+          const removed = current.filter((id) => !next.includes(id));
+          const closed = Array.from(new Set([...deck.inactive.filter((id) => !next.includes(id)), ...removed]));
+          deck.inactive = closed;
+
+          if (mode !== 'deck' && next[0]) {
+            deck.solo = next[0];
+          } else if (mode === 'deck' && deck.solo) {
+            deck.solo = undefined;
+            deck.initialized = true;
+          }
+
+          if (mode === 'fullscreen' && !deck.fullscreen) {
+            deck.fullscreen = true;
+          } else if (mode !== 'fullscreen' && deck.fullscreen) {
+            deck.fullscreen = false;
+          }
+        };
+
+        return batch(() => {
+          if ('mode' in options) {
+            const current = getMode(state.deck);
+            if (current !== options.mode) {
+              state.previousMode[state.activeDeck] = current;
+            }
+            setMode(options.mode as LayoutMode);
+          } else if ('revert' in options) {
+            const last = state.previousMode[state.activeDeck];
+            setMode(last ?? 'solo');
+          } else {
+            log.warn('Invalid layout mode', options);
+          }
+        });
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.SwitchWorkspace.fields.input> =>
+        S.is(LayoutAction.SwitchWorkspace.fields.input)(data),
+      resolve: ({ subject }) => {
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        batch(() => {
+          // TODO(wittjosiah): This is a hack to prevent the previous deck from being set for pinned items.
+          //  Ideally this should be worked into the data model in a generic way.
+          if (!state.activeDeck.startsWith('!')) {
+            state.previousDeck = state.activeDeck;
+          }
+          state.activeDeck = subject;
+          if (!state.decks[subject]) {
+            state.decks[subject] = { initialized: false, active: [], inactive: [], fullscreen: false, plankSizing: {} };
+          }
+        });
+
+        const first = state.deck.solo ? state.deck.solo : state.deck.active[0];
+        if (first) {
+          return {
+            intents: [createIntent(LayoutAction.ScrollIntoView, { part: 'current', subject: first })],
+          };
+        }
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.RevertWorkspace.fields.input> =>
+        S.is(LayoutAction.RevertWorkspace.fields.input)(data),
+      resolve: () => {
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        return {
+          intents: [createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: state.previousDeck })],
+        };
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.Open.fields.input> =>
+        S.is(LayoutAction.Open.fields.input)(data),
+      resolve: ({ subject, options }) => {
+        const { graph } = context.requestCapability(Capabilities.AppGraph);
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const attention = context.requestCapability(AttentionCapabilities.Attention);
+        const settings = context
+          .requestCapabilities(Capabilities.SettingsStore)[0]
+          ?.getStore<DeckSettingsProps>(DECK_PLUGIN)?.value;
+
+        const previouslyOpenIds = new Set<string>(state.deck.solo ? [state.deck.solo] : state.deck.active);
+        batch(() => {
+          const next = state.deck.solo
+            ? (subject as string[])
+            : subject.reduce(
+                (acc, entryId) =>
+                  openEntry(acc, entryId, {
+                    key: options?.key,
+                    positioning: options?.positioning ?? settings?.newPlankPositioning,
+                    pivotId: options?.pivotId,
+                  }),
+                state.deck.active,
+              );
+
+          return setActive({ next, state, attention });
+        });
+
+        const ids = state.deck.solo ? [state.deck.solo] : state.deck.active;
+        const newlyOpen = ids.filter((i) => !previouslyOpenIds.has(i));
+
+        return {
+          intents: [
+            ...(options?.scrollIntoView !== false
+              ? [createIntent(LayoutAction.ScrollIntoView, { part: 'current', subject: newlyOpen[0] ?? subject[0] })]
+              : []),
+            createIntent(LayoutAction.Expose, { part: 'navigation', subject: newlyOpen[0] ?? subject[0] }),
+            ...newlyOpen.map((id) => {
+              const active = graph?.findNode(id)?.data;
+              const typename = isReactiveObject(active) ? getTypename(active) : undefined;
+              return createIntent(ObservabilityAction.SendEvent, {
+                name: 'navigation.activate',
+                properties: {
+                  id,
+                  typename,
+                },
+              });
+            }),
+          ],
+        };
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.Close.fields.input> =>
+        S.is(LayoutAction.Close.fields.input)(data),
+      resolve: ({ subject }) => {
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const attention = context.requestCapability(AttentionCapabilities.Attention);
+        const active = state.deck.solo ? [state.deck.solo] : state.deck.active;
+        const next = subject.reduce((acc, id) => closeEntry(acc, id), active);
+        const toAttend = setActive({ next, state, attention });
+        return {
+          intents: toAttend ? [createIntent(LayoutAction.ScrollIntoView, { part: 'current', subject: toAttend })] : [],
+        };
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.Set.fields.input> =>
+        S.is(LayoutAction.Set.fields.input)(data),
+      resolve: ({ subject }) => {
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const attention = context.requestCapability(AttentionCapabilities.Attention);
+        const toAttend = setActive({ next: subject as string[], state, attention });
+        return {
+          intents: toAttend ? [createIntent(LayoutAction.ScrollIntoView, { part: 'current', subject: toAttend })] : [],
+        };
+      },
+    }),
+    createResolver({
+      intent: LayoutAction.UpdateLayout,
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.ScrollIntoView.fields.input> =>
+        S.is(LayoutAction.ScrollIntoView.fields.input)(data),
+      resolve: ({ subject }) => {
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        layout.scrollIntoView = subject;
+      },
+    }),
+    createResolver({
+      intent: DeckAction.UpdatePlankSize,
+      resolve: (data) => {
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        state.deck.plankSizing[data.id] = data.size;
+      },
+    }),
+    createResolver({
+      intent: DeckAction.Adjust,
+      resolve: (adjustment) => {
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const attention = context.requestCapability(AttentionCapabilities.Attention);
+
+        return batch(() => {
+          if (adjustment.type === 'increment-end' || adjustment.type === 'increment-start') {
+            setActive({
+              next: incrementPlank(state.deck.active, adjustment),
+              state,
+              attention,
+            });
+          }
+
+          if (adjustment.type === 'solo') {
+            const entryId = adjustment.id;
+            if (!state.deck.solo) {
+              // Solo the entry.
+              return {
+                intents: [
+                  createIntent(LayoutAction.SetLayoutMode, {
+                    part: 'mode',
+                    subject: entryId,
+                    options: { mode: 'solo' },
+                  }),
+                ],
+              };
+            } else {
+              // Un-solo the current entry.
+              return {
+                intents: [
+                  // NOTE: The order of these is important.
+                  pipe(
+                    createIntent(LayoutAction.SetLayoutMode, { part: 'mode', options: { mode: 'deck' } }),
+                    chain(LayoutAction.Open, { part: 'main', subject: [entryId] }),
+                  ),
+                ],
+              };
+            }
+          }
+        });
+      },
+    }),
+  ]);