@dxos/plugin-deck 0.8.2-main.f11618f → 0.8.2-main.fbd8ed0

package/src/capabilities/app-graph-builder.ts

@@ -2,112 +2,140 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, createIntent, LayoutAction, type PluginsContext } from '@dxos/app-framework';
+import { Rx } from '@effect-rx/rx-react';
+import { Option, pipe } from 'effect';
+
+import { Capabilities, contributes, createIntent, LayoutAction, type PluginContext } from '@dxos/app-framework';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { createExtension, type Node, ROOT_ID } from '@dxos/plugin-graph';
+import { createExtension, ROOT_ID, rxFromSignal } from '@dxos/plugin-graph';
 
 import { DeckCapabilities } from './capabilities';
 import { DECK_PLUGIN } from '../meta';
 
-export default (context: PluginsContext) =>
+export default (context: PluginContext) =>
   contributes(
     Capabilities.AppGraphBuilder,
     createExtension({
       id: DECK_PLUGIN,
-      filter: (node): node is Node<null> => node.id === ROOT_ID,
-      actions: () => {
-        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+      actions: (node) =>
+        Rx.make((get) =>
+          pipe(
+            get(node),
+            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
+            Option.map(() => {
+              const state = context.getCapability(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.UpdateLayout._tag}/fullscreen`,
-          data: async () => {
-            const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
-            await dispatch(createIntent(LayoutAction.SetLayoutMode, { part: 'mode', options: { mode: 'fullscreen' } }));
-          },
-          properties: {
-            label: ['toggle fullscreen label', { ns: DECK_PLUGIN }],
-            icon: 'ph--arrows-out--regular',
-            keyBinding: {
-              macos: 'ctrl+meta+f',
-              windows: 'shift+ctrl+f',
-            },
-          },
-        };
+              // 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.UpdateLayout._tag}/fullscreen`,
+                data: async () => {
+                  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+                  await dispatch(
+                    createIntent(LayoutAction.SetLayoutMode, { part: 'mode', options: { mode: 'fullscreen' } }),
+                  );
+                },
+                properties: {
+                  label: ['toggle fullscreen label', { ns: DECK_PLUGIN }],
+                  icon: 'ph--arrows-out--regular',
+                  keyBinding: {
+                    macos: 'ctrl+meta+f',
+                    windows: 'shift+ctrl+f',
+                  },
+                },
+              };
 
-        const closeCurrent = {
-          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(LayoutAction.Close, { part: 'main', subject: [attended], options: { state: false } }),
-              );
-            }
-          },
-          properties: {
-            label: ['close current label', { ns: DECK_PLUGIN }],
-            icon: 'ph--x--regular',
-          },
-        };
+              const closeCurrent = {
+                id: `${LayoutAction.Close._tag}/current`,
+                data: async () => {
+                  const attention = context.getCapability(AttentionCapabilities.Attention);
+                  const attended = attention.current.at(-1);
+                  if (attended) {
+                    const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+                    await dispatch(
+                      createIntent(LayoutAction.Close, {
+                        part: 'main',
+                        subject: [attended],
+                        options: { state: false },
+                      }),
+                    );
+                  }
+                },
+                properties: {
+                  label: ['close current label', { ns: DECK_PLUGIN }],
+                  icon: 'ph--x--regular',
+                },
+              };
 
-        const closeOthers = {
-          id: `${LayoutAction.Close._tag}/others`,
-          data: async () => {
-            const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
-            const attention = context.requestCapability(AttentionCapabilities.Attention);
-            const attended = attention.current.at(-1);
-            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 }],
-            icon: 'ph--x-square--regular',
-          },
-        };
+              const closeOthers = {
+                id: `${LayoutAction.Close._tag}/others`,
+                data: async () => {
+                  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+                  const attention = context.getCapability(AttentionCapabilities.Attention);
+                  const attended = attention.current.at(-1);
+                  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 }],
+                  icon: 'ph--x-square--regular',
+                },
+              };
 
-        const closeAll = {
-          id: `${LayoutAction.Close._tag}/all`,
-          data: async () => {
-            const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
-            await dispatch(
-              createIntent(LayoutAction.Close, {
-                part: 'main',
-                subject: state.deck.active,
-                options: { state: false },
-              }),
-            );
-          },
-          properties: {
-            label: ['close all label', { ns: DECK_PLUGIN }],
-            icon: 'ph--x-circle--regular',
-          },
-        };
+              const closeAll = {
+                id: `${LayoutAction.Close._tag}/all`,
+                data: async () => {
+                  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
+                  await dispatch(
+                    createIntent(LayoutAction.Close, {
+                      part: 'main',
+                      subject: state.deck.active,
+                      options: { state: false },
+                    }),
+                  );
+                },
+                properties: {
+                  label: ['close all label', { ns: DECK_PLUGIN }],
+                  icon: 'ph--x-circle--regular',
+                },
+              };
 
-        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',
-          },
-        };
+              const toggleSidebar = {
+                id: `${LayoutAction.UpdateSidebar._tag}/nav`,
+                data: async () => {
+                  state.sidebarState = state.sidebarState === 'expanded' ? 'collapsed' : 'expanded';
+                },
+                properties: {
+                  label: [
+                    get(
+                      rxFromSignal(() =>
+                        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];
-      },
+              return get(
+                rxFromSignal(() =>
+                  !state.deck.solo ? [closeCurrent, closeOthers, closeAll, toggleSidebar] : [toggleSidebar],
+                ),
+              );
+            }),
+            Option.getOrElse(() => []),
+          ),
+        ),
     }),
   );

package/src/capabilities/check-app-scheme.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';
+import { Capabilities, contributes, type PluginContext } from '@dxos/app-framework';
 
 import { DECK_PLUGIN } from '../meta';
 import { type DeckSettingsProps } from '../types';
@@ -30,10 +30,8 @@ const checkAppScheme = (url: string) => {
   });
 };
 
-export default async (context: PluginsContext) => {
-  const settings = context
-    .requestCapability(Capabilities.SettingsStore)
-    .getStore<DeckSettingsProps>(DECK_PLUGIN)?.value;
+export default async (context: PluginContext) => {
+  const settings = context.getCapability(Capabilities.SettingsStore).getStore<DeckSettingsProps>(DECK_PLUGIN)?.value;
   if (!isSocket && settings?.enableNativeRedirect) {
     checkAppScheme(appScheme);
   }

package/src/capabilities/index.ts

@@ -15,3 +15,4 @@ export const Tools = lazy(() => import('./tools'));
 export const UrlHandler = lazy(() => import('./url-handler'));
 
 export * from './capabilities';
+export * from './state';

package/src/capabilities/intent-resolver.ts

@@ -3,7 +3,7 @@
 //
 
 import { batch } from '@preact/signals-core';
-import { Effect, pipe } from 'effect';
+import { Schema, Effect, pipe, Option } from 'effect';
 
 import {
   Capabilities,
@@ -11,16 +11,16 @@ import {
   contributes,
   IntentAction,
   LayoutAction,
-  type PluginsContext,
+  type PluginContext,
   createIntent,
   chain,
 } from '@dxos/app-framework';
-import { getTypename, S } from '@dxos/echo-schema';
+import { getTypename } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { isLiveObject } from '@dxos/live-object';
 import { log } from '@dxos/log';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { type Node } from '@dxos/plugin-graph';
+import { isActionLike } from '@dxos/plugin-graph';
 import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { byPosition, isNonNullable } from '@dxos/util';
 
@@ -38,13 +38,13 @@ import {
 } from '../types';
 import { setActive } from '../util';
 
-export default (context: PluginsContext) =>
+export default (context: PluginContext) =>
   contributes(Capabilities.IntentResolver, [
     createResolver({
       intent: IntentAction.ShowUndo,
       resolve: (data) => {
-        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
-        const { undoPromise: undo } = context.requestCapability(Capabilities.IntentDispatcher);
+        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
+        const { undoPromise: undo } = context.getCapability(Capabilities.IntentDispatcher);
 
         // TODO(wittjosiah): Support undoing further back than the last action.
         if (layout.currentUndoId) {
@@ -67,12 +67,12 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdateSidebar.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.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),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.UpdateSidebar.fields.input> =>
+        Schema.is(LayoutAction.UpdateSidebar.fields.input)(data),
       resolve: ({ options }) => {
-        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
         const next = options?.state ?? layout.sidebarState;
         if (next !== layout.sidebarState) {
           layout.sidebarState = next;
@@ -81,12 +81,12 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdateComplementary.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.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),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.UpdateComplementary.fields.input> =>
+        Schema.is(LayoutAction.UpdateComplementary.fields.input)(data),
       resolve: ({ subject, options }) => {
-        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
 
         if (layout.complementarySidebarPanel !== subject) {
           layout.complementarySidebarPanel = subject;
@@ -100,12 +100,12 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdateDialog.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.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),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.UpdateDialog.fields.input> =>
+        Schema.is(LayoutAction.UpdateDialog.fields.input)(data),
       resolve: ({ subject, options }) => {
-        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
         layout.dialogOpen = options.state ?? Boolean(subject);
         layout.dialogContent = subject ? { component: subject, props: options.props } : null;
         layout.dialogBlockAlign = options.blockAlign ?? 'center';
@@ -114,12 +114,12 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.UpdatePopover.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.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),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.UpdatePopover.fields.input> =>
+        Schema.is(LayoutAction.UpdatePopover.fields.input)(data),
       resolve: ({ subject, options }) => {
-        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
         layout.popoverOpen = options.state ?? Boolean(subject);
         layout.popoverContent =
           typeof subject === 'string' ? { component: subject, props: options.props } : subject ? { subject } : null;
@@ -133,21 +133,21 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `S.is(LayoutAction.AddToast.fields.input)`
+      // TODO(wittjosiah): This should be able to just be `Schema.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),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.AddToast.fields.input> =>
+        Schema.is(LayoutAction.AddToast.fields.input)(data),
       resolve: ({ subject }) => {
-        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.getCapability(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)`
+      // TODO(wittjosiah): This should be able to just be `Schema.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)) {
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.SetLayoutMode.fields.input> => {
+        if (!Schema.is(LayoutAction.SetLayoutMode.fields.input)(data)) {
           return false;
         }
 
@@ -158,7 +158,7 @@ export default (context: PluginsContext) =>
         return true;
       },
       resolve: ({ subject, options }) => {
-        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const state = context.getCapability(DeckCapabilities.MutableDeckState);
 
         const setMode = (mode: LayoutMode) => {
           const deck = state.deck;
@@ -202,10 +202,11 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.SwitchWorkspace.fields.input> =>
-        S.is(LayoutAction.SwitchWorkspace.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.SwitchWorkspace.fields.input> =>
+        Schema.is(LayoutAction.SwitchWorkspace.fields.input)(data),
       resolve: ({ subject }) => {
-        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const { graph } = context.getCapability(Capabilities.AppGraph);
+        const state = context.getCapability(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.
@@ -223,15 +224,22 @@ export default (context: PluginsContext) =>
           return {
             intents: [createIntent(LayoutAction.ScrollIntoView, { part: 'current', subject: first })],
           };
+        } else {
+          const [item] = graph.getConnections(subject).filter((node) => !isActionLike(node));
+          if (item) {
+            return {
+              intents: [createIntent(LayoutAction.Open, { part: 'main', subject: [item.id] })],
+            };
+          }
         }
       },
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.RevertWorkspace.fields.input> =>
-        S.is(LayoutAction.RevertWorkspace.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.RevertWorkspace.fields.input> =>
+        Schema.is(LayoutAction.RevertWorkspace.fields.input)(data),
       resolve: () => {
-        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const state = context.getCapability(DeckCapabilities.MutableDeckState);
         return {
           intents: [createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: state.previousDeck })],
         };
@@ -239,19 +247,19 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.Open.fields.input> =>
-        S.is(LayoutAction.Open.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.Open.fields.input> =>
+        Schema.is(LayoutAction.Open.fields.input)(data),
       resolve: ({ subject, options }) =>
         Effect.gen(function* () {
-          const { graph } = context.requestCapability(Capabilities.AppGraph);
-          const state = context.requestCapability(DeckCapabilities.MutableDeckState);
-          const attention = context.requestCapability(AttentionCapabilities.Attention);
+          const { graph } = context.getCapability(Capabilities.AppGraph);
+          const state = context.getCapability(DeckCapabilities.MutableDeckState);
+          const attention = context.getCapability(AttentionCapabilities.Attention);
           const settings = context
-            .requestCapabilities(Capabilities.SettingsStore)[0]
+            .getCapabilities(Capabilities.SettingsStore)[0]
             ?.getStore<DeckSettingsProps>(DECK_PLUGIN)?.value;
 
           if (options?.workspace && state.activeDeck !== options?.workspace) {
-            const { dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+            const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
             yield* dispatch(
               createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: options.workspace }),
             );
@@ -285,8 +293,13 @@ export default (context: PluginsContext) =>
                 : []),
               createIntent(LayoutAction.Expose, { part: 'navigation', subject: newlyOpen[0] ?? subject[0] }),
               ...newlyOpen.map((subjectId) => {
-                const active = graph?.findNode(subjectId)?.data;
-                const typename = isLiveObject(active) ? getTypename(active) : undefined;
+                const typename = Option.match(graph.getNode(subjectId), {
+                  onNone: () => undefined,
+                  onSome: (node) => {
+                    const active = node.data;
+                    return isLiveObject(active) ? getTypename(active) : undefined;
+                  },
+                });
                 return createIntent(ObservabilityAction.SendEvent, {
                   name: 'navigation.activate',
                   properties: {
@@ -301,11 +314,11 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.Close.fields.input> =>
-        S.is(LayoutAction.Close.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.Close.fields.input> =>
+        Schema.is(LayoutAction.Close.fields.input)(data),
       resolve: ({ subject }) => {
-        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
-        const attention = context.requestCapability(AttentionCapabilities.Attention);
+        const state = context.getCapability(DeckCapabilities.MutableDeckState);
+        const attention = context.getCapability(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 });
@@ -324,11 +337,11 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.Set.fields.input> =>
-        S.is(LayoutAction.Set.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.Set.fields.input> =>
+        Schema.is(LayoutAction.Set.fields.input)(data),
       resolve: ({ subject }) => {
-        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
-        const attention = context.requestCapability(AttentionCapabilities.Attention);
+        const state = context.getCapability(DeckCapabilities.MutableDeckState);
+        const attention = context.getCapability(AttentionCapabilities.Attention);
         const toAttend = setActive({ next: subject as string[], state, attention });
         return {
           intents: toAttend ? [createIntent(LayoutAction.ScrollIntoView, { part: 'current', subject: toAttend })] : [],
@@ -337,24 +350,24 @@ export default (context: PluginsContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is S.Schema.Type<typeof LayoutAction.ScrollIntoView.fields.input> =>
-        S.is(LayoutAction.ScrollIntoView.fields.input)(data),
+      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.ScrollIntoView.fields.input> =>
+        Schema.is(LayoutAction.ScrollIntoView.fields.input)(data),
       resolve: ({ subject }) => {
-        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
         layout.scrollIntoView = subject;
       },
     }),
     createResolver({
       intent: DeckAction.UpdatePlankSize,
       resolve: (data) => {
-        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const state = context.getCapability(DeckCapabilities.MutableDeckState);
         state.deck.plankSizing[data.id] = data.size;
       },
     }),
     createResolver({
       intent: DeckAction.ChangeCompanion,
       resolve: (data) => {
-        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const state = context.getCapability(DeckCapabilities.MutableDeckState);
         // TODO(thure): Reactivity only works when creating a lexically new `activeCompanions`… Are these not proxy objects?
         if (data.companion === null) {
           const { [data.primary]: _, ...nextActiveCompanions } = state.deck.activeCompanions ?? {};
@@ -371,9 +384,9 @@ export default (context: PluginsContext) =>
     createResolver({
       intent: DeckAction.Adjust,
       resolve: (adjustment) => {
-        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
-        const attention = context.requestCapability(AttentionCapabilities.Attention);
-        const { graph } = context.requestCapability(Capabilities.AppGraph);
+        const state = context.getCapability(DeckCapabilities.MutableDeckState);
+        const attention = context.getCapability(AttentionCapabilities.Attention);
+        const { graph } = context.getCapability(Capabilities.AppGraph);
 
         return batch(() => {
           if (adjustment.type === 'increment-end' || adjustment.type === 'increment-start') {
@@ -385,20 +398,25 @@ export default (context: PluginsContext) =>
           }
 
           if (adjustment.type === 'companion') {
-            const node = graph.findNode(adjustment.id);
-            const [companion] = node
-              ? graph
-                  .nodes(node, { filter: (n): n is Node<any> => n.type === PLANK_COMPANION_TYPE })
-                  .toSorted((a, b) => byPosition(a.properties, b.properties))
-              : [];
-            if (companion) {
-              return {
-                intents: [
-                  // TODO(wittjosiah): This should remember the previously selected companion.
-                  createIntent(DeckAction.ChangeCompanion, { primary: adjustment.id, companion: companion.id }),
-                ],
-              };
-            }
+            return pipe(
+              graph.getNode(adjustment.id),
+              Option.map((node) =>
+                graph
+                  .getConnections(node.id)
+                  .filter((n) => n.type === PLANK_COMPANION_TYPE)
+                  .toSorted((a, b) => byPosition(a.properties, b.properties)),
+              ),
+              Option.flatMap((companions) => (companions.length > 0 ? Option.some(companions[0]) : Option.none())),
+              Option.match({
+                onNone: () => ({}),
+                onSome: (companion) => ({
+                  intents: [
+                    // TODO(wittjosiah): This should remember the previously selected companion.
+                    createIntent(DeckAction.ChangeCompanion, { primary: adjustment.id, companion: companion.id }),
+                  ],
+                }),
+              }),
+            );
           }
 
           if (adjustment.type.startsWith('solo')) {

package/src/capabilities/settings.ts

@@ -11,9 +11,9 @@ import { DeckSettingsSchema, type DeckSettingsProps } from '../types';
 export default () => {
   const settings = live<DeckSettingsProps>({
     showHints: false,
-    enableDeck: true,
-    enableNativeRedirect: false,
+    enableDeck: false,
     enableStatusbar: false,
+    enableNativeRedirect: false,
     newPlankPositioning: 'start',
     overscroll: 'none',
   });

package/src/capabilities/state.ts

@@ -10,7 +10,7 @@ import { type SidebarState } from '@dxos/react-ui';
 
 import { DeckCapabilities } from './capabilities';
 import { DECK_PLUGIN } from '../meta';
-import { getMode, type DeckState, type DeckPluginState, defaultDeck } from '../types';
+import { getMode, type DeckPluginState, defaultDeck, type DeckState } from '../types';
 
 const boolean = /true|false/;
 
@@ -29,7 +29,7 @@ const migrateSidebarState = () => {
   });
 };
 
-export default () => {
+const DeckStateFactory = () => {
   migrateSidebarState();
 
   const state = new LocalStorageStore<DeckPluginState>(DECK_PLUGIN, {
@@ -100,3 +100,5 @@ export default () => {
     contributes(Capabilities.Layout, layout),
   ];
 };
+
+export default DeckStateFactory;