@dxos/plugin-deck 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

package/src/capabilities/intent-resolver.ts

@@ -3,7 +3,7 @@
 //
 
 import { batch } from '@preact/signals-core';
-import { Schema, Effect, pipe, Option } from 'effect';
+import { pipe } from 'effect';
 
 import {
   Capabilities,
@@ -11,16 +11,16 @@ import {
   contributes,
   IntentAction,
   LayoutAction,
-  type PluginContext,
+  type PluginsContext,
   createIntent,
   chain,
 } from '@dxos/app-framework';
-import { getTypename } from '@dxos/echo-schema';
+import { getTypename, S } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { isLiveObject } from '@dxos/live-object';
+import { isReactiveObject } from '@dxos/live-object';
 import { log } from '@dxos/log';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { isActionLike } from '@dxos/plugin-graph';
+import { type Node } 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: PluginContext) =>
+export default (context: PluginsContext) =>
   contributes(Capabilities.IntentResolver, [
     createResolver({
       intent: IntentAction.ShowUndo,
       resolve: (data) => {
-        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
-        const { undoPromise: undo } = context.getCapability(Capabilities.IntentDispatcher);
+        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) {
@@ -67,12 +67,12 @@ export default (context: PluginContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.UpdateSidebar.fields.input)`
+      // 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 Schema.Schema.Type<typeof LayoutAction.UpdateSidebar.fields.input> =>
-        Schema.is(LayoutAction.UpdateSidebar.fields.input)(data),
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.UpdateSidebar.fields.input> =>
+        S.is(LayoutAction.UpdateSidebar.fields.input)(data),
       resolve: ({ options }) => {
-        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
         const next = options?.state ?? layout.sidebarState;
         if (next !== layout.sidebarState) {
           layout.sidebarState = next;
@@ -81,12 +81,12 @@ export default (context: PluginContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.UpdateComplementary.fields.input)`
+      // 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 Schema.Schema.Type<typeof LayoutAction.UpdateComplementary.fields.input> =>
-        Schema.is(LayoutAction.UpdateComplementary.fields.input)(data),
+      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.getCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
 
         if (layout.complementarySidebarPanel !== subject) {
           layout.complementarySidebarPanel = subject;
@@ -100,12 +100,12 @@ export default (context: PluginContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.UpdateDialog.fields.input)`
+      // 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 Schema.Schema.Type<typeof LayoutAction.UpdateDialog.fields.input> =>
-        Schema.is(LayoutAction.UpdateDialog.fields.input)(data),
+      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.getCapability(DeckCapabilities.MutableDeckState);
+        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';
@@ -114,40 +114,35 @@ export default (context: PluginContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.UpdatePopover.fields.input)`
+      // 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 Schema.Schema.Type<typeof LayoutAction.UpdatePopover.fields.input> =>
-        Schema.is(LayoutAction.UpdatePopover.fields.input)(data),
+      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.getCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
         layout.popoverOpen = options.state ?? Boolean(subject);
-        layout.popoverContent =
-          typeof subject === 'string' ? { component: subject, props: options.props } : subject ? { subject } : null;
+        layout.popoverContent = subject ? { component: subject, props: options.props } : null;
+        layout.popoverAnchorId = options.anchorId;
         layout.popoverSide = options.side;
-        if (options.variant === 'virtual') {
-          layout.popoverAnchor = options.anchor;
-        } else {
-          layout.popoverAnchorId = options.anchorId;
-        }
       },
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.AddToast.fields.input)`
+      // 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 Schema.Schema.Type<typeof LayoutAction.AddToast.fields.input> =>
-        Schema.is(LayoutAction.AddToast.fields.input)(data),
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.AddToast.fields.input> =>
+        S.is(LayoutAction.AddToast.fields.input)(data),
       resolve: ({ subject }) => {
-        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
         layout.toasts.push(subject);
       },
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      // TODO(wittjosiah): This should be able to just be `Schema.is(LayoutAction.SetLayoutMode.fields.input)`
+      // 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 Schema.Schema.Type<typeof LayoutAction.SetLayoutMode.fields.input> => {
-        if (!Schema.is(LayoutAction.SetLayoutMode.fields.input)(data)) {
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.SetLayoutMode.fields.input> => {
+        if (!S.is(LayoutAction.SetLayoutMode.fields.input)(data)) {
           return false;
         }
 
@@ -158,7 +153,7 @@ export default (context: PluginContext) =>
         return true;
       },
       resolve: ({ subject, options }) => {
-        const state = context.getCapability(DeckCapabilities.MutableDeckState);
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
 
         const setMode = (mode: LayoutMode) => {
           const deck = state.deck;
@@ -179,8 +174,10 @@ export default (context: PluginContext) =>
             deck.initialized = true;
           }
 
-          if (mode === 'solo--fullscreen') {
-            deck.fullscreen = !deck.fullscreen;
+          if (mode === 'fullscreen' && !deck.fullscreen) {
+            deck.fullscreen = true;
+          } else if (mode !== 'fullscreen' && deck.fullscreen) {
+            deck.fullscreen = false;
           }
         };
 
@@ -202,11 +199,10 @@ export default (context: PluginContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.SwitchWorkspace.fields.input> =>
-        Schema.is(LayoutAction.SwitchWorkspace.fields.input)(data),
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.SwitchWorkspace.fields.input> =>
+        S.is(LayoutAction.SwitchWorkspace.fields.input)(data),
       resolve: ({ subject }) => {
-        const { graph } = context.getCapability(Capabilities.AppGraph);
-        const state = context.getCapability(DeckCapabilities.MutableDeckState);
+        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.
@@ -224,22 +220,15 @@ export default (context: PluginContext) =>
           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 Schema.Schema.Type<typeof LayoutAction.RevertWorkspace.fields.input> =>
-        Schema.is(LayoutAction.RevertWorkspace.fields.input)(data),
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.RevertWorkspace.fields.input> =>
+        S.is(LayoutAction.RevertWorkspace.fields.input)(data),
       resolve: () => {
-        const state = context.getCapability(DeckCapabilities.MutableDeckState);
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
         return {
           intents: [createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: state.previousDeck })],
         };
@@ -247,78 +236,65 @@ export default (context: PluginContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      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.getCapability(Capabilities.AppGraph);
-          const state = context.getCapability(DeckCapabilities.MutableDeckState);
-          const attention = context.getCapability(AttentionCapabilities.Attention);
-          const settings = context
-            .getCapabilities(Capabilities.SettingsStore)[0]
-            ?.getStore<DeckSettingsProps>(DECK_PLUGIN)?.value;
-
-          if (options?.workspace && state.activeDeck !== options?.workspace) {
-            const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-            yield* dispatch(
-              createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: options.workspace }),
-            );
-          }
+      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[]).map((id) => createEntryId(id, options?.variant))
-              : subject.reduce(
-                  (acc, entryId) =>
-                    openEntry(acc, entryId, {
-                      key: options?.key,
-                      positioning: options?.positioning ?? settings?.newPlankPositioning,
-                      pivotId: options?.pivotId,
-                      variant: options?.variant,
-                    }),
-                  state.deck.active,
-                );
+        const previouslyOpenIds = new Set<string>(state.deck.solo ? [state.deck.solo] : state.deck.active);
+        batch(() => {
+          const next = state.deck.solo
+            ? (subject as string[]).map((id) => createEntryId(id, options?.variant))
+            : subject.reduce(
+                (acc, entryId) =>
+                  openEntry(acc, entryId, {
+                    key: options?.key,
+                    positioning: options?.positioning ?? settings?.newPlankPositioning,
+                    pivotId: options?.pivotId,
+                    variant: options?.variant,
+                  }),
+                state.deck.active,
+              );
 
-            return setActive({ next, state, attention });
-          });
+          return setActive({ next, state, attention });
+        });
 
-          const ids = state.deck.solo ? [state.deck.solo] : state.deck.active;
-          const newlyOpen = ids.filter((i) => !previouslyOpenIds.has(i));
+        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((subjectId) => {
-                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: {
-                    subjectId,
-                    typename,
-                  },
-                });
-              }),
-            ],
-          };
-        }),
+        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((subjectId) => {
+              const active = graph?.findNode(subjectId)?.data;
+              const typename = isReactiveObject(active) ? getTypename(active) : undefined;
+              return createIntent(ObservabilityAction.SendEvent, {
+                name: 'navigation.activate',
+                properties: {
+                  subjectId,
+                  typename,
+                },
+              });
+            }),
+          ],
+        };
+      },
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.Close.fields.input> =>
-        Schema.is(LayoutAction.Close.fields.input)(data),
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.Close.fields.input> =>
+        S.is(LayoutAction.Close.fields.input)(data),
       resolve: ({ subject }) => {
-        const state = context.getCapability(DeckCapabilities.MutableDeckState);
-        const attention = context.getCapability(AttentionCapabilities.Attention);
+        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 });
@@ -337,11 +313,11 @@ export default (context: PluginContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.Set.fields.input> =>
-        Schema.is(LayoutAction.Set.fields.input)(data),
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.Set.fields.input> =>
+        S.is(LayoutAction.Set.fields.input)(data),
       resolve: ({ subject }) => {
-        const state = context.getCapability(DeckCapabilities.MutableDeckState);
-        const attention = context.getCapability(AttentionCapabilities.Attention);
+        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 })] : [],
@@ -350,24 +326,24 @@ export default (context: PluginContext) =>
     }),
     createResolver({
       intent: LayoutAction.UpdateLayout,
-      filter: (data): data is Schema.Schema.Type<typeof LayoutAction.ScrollIntoView.fields.input> =>
-        Schema.is(LayoutAction.ScrollIntoView.fields.input)(data),
+      filter: (data): data is S.Schema.Type<typeof LayoutAction.ScrollIntoView.fields.input> =>
+        S.is(LayoutAction.ScrollIntoView.fields.input)(data),
       resolve: ({ subject }) => {
-        const layout = context.getCapability(DeckCapabilities.MutableDeckState);
+        const layout = context.requestCapability(DeckCapabilities.MutableDeckState);
         layout.scrollIntoView = subject;
       },
     }),
     createResolver({
       intent: DeckAction.UpdatePlankSize,
       resolve: (data) => {
-        const state = context.getCapability(DeckCapabilities.MutableDeckState);
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
         state.deck.plankSizing[data.id] = data.size;
       },
     }),
     createResolver({
       intent: DeckAction.ChangeCompanion,
       resolve: (data) => {
-        const state = context.getCapability(DeckCapabilities.MutableDeckState);
+        const state = context.requestCapability(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 ?? {};
@@ -384,9 +360,9 @@ export default (context: PluginContext) =>
     createResolver({
       intent: DeckAction.Adjust,
       resolve: (adjustment) => {
-        const state = context.getCapability(DeckCapabilities.MutableDeckState);
-        const attention = context.getCapability(AttentionCapabilities.Attention);
-        const { graph } = context.getCapability(Capabilities.AppGraph);
+        const state = context.requestCapability(DeckCapabilities.MutableDeckState);
+        const attention = context.requestCapability(AttentionCapabilities.Attention);
+        const { graph } = context.requestCapability(Capabilities.AppGraph);
 
         return batch(() => {
           if (adjustment.type === 'increment-end' || adjustment.type === 'increment-start') {
@@ -398,28 +374,23 @@ export default (context: PluginContext) =>
           }
 
           if (adjustment.type === 'companion') {
-            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 }),
-                  ],
-                }),
-              }),
-            );
+            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 }),
+                ],
+              };
+            }
           }
 
-          if (adjustment.type.startsWith('solo')) {
+          if (adjustment.type === 'solo') {
             const entryId = adjustment.id;
             if (!state.deck.solo) {
               // Solo the entry.
@@ -428,34 +399,21 @@ export default (context: PluginContext) =>
                   createIntent(LayoutAction.SetLayoutMode, {
                     part: 'mode',
                     subject: entryId,
-                    options: { mode: adjustment.type },
+                    options: { mode: 'solo' },
                   }),
                 ],
               };
             } else {
-              if (adjustment.type === 'solo--fullscreen') {
-                // Toggle fullscreen on the current entry.
-                return {
-                  intents: [
-                    createIntent(LayoutAction.SetLayoutMode, {
-                      part: 'mode',
-                      subject: entryId,
-                      options: { mode: 'solo--fullscreen' },
-                    }),
-                  ],
-                };
-              } else if (adjustment.type === 'solo') {
-                // 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] }),
-                    ),
-                  ],
-                };
-              }
+              // 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] }),
+                  ),
+                ],
+              };
             }
           }
         });

package/src/capabilities/settings.ts

@@ -3,17 +3,17 @@
 //
 
 import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
+import { create } from '@dxos/live-object';
 
 import { DECK_PLUGIN } from '../meta';
 import { DeckSettingsSchema, type DeckSettingsProps } from '../types';
 
 export default () => {
-  const settings = live<DeckSettingsProps>({
+  const settings = create<DeckSettingsProps>({
     showHints: false,
-    enableDeck: false,
-    enableStatusbar: false,
+    enableDeck: true,
     enableNativeRedirect: false,
+    enableStatusbar: false,
     newPlankPositioning: 'start',
     overscroll: 'none',
   });

package/src/capabilities/state.ts

@@ -4,13 +4,13 @@
 
 import { Capabilities, contributes } from '@dxos/app-framework';
 import { invariant } from '@dxos/invariant';
-import { live } from '@dxos/live-object';
+import { create } from '@dxos/live-object';
 import { LocalStorageStore } from '@dxos/local-storage';
 import { type SidebarState } from '@dxos/react-ui';
 
 import { DeckCapabilities } from './capabilities';
 import { DECK_PLUGIN } from '../meta';
-import { getMode, type DeckPluginState, defaultDeck, type DeckState } from '../types';
+import { getMode, type DeckState, type DeckPluginState, defaultDeck } from '../types';
 
 const boolean = /true|false/;
 
@@ -29,7 +29,7 @@ const migrateSidebarState = () => {
   });
 };
 
-const DeckStateFactory = () => {
+export default () => {
   migrateSidebarState();
 
   const state = new LocalStorageStore<DeckPluginState>(DECK_PLUGIN, {
@@ -41,7 +41,6 @@ const DeckStateFactory = () => {
     dialogBlockAlign: undefined,
     dialogType: undefined,
     popoverContent: null,
-    popoverAnchor: undefined,
     popoverAnchorId: undefined,
     popoverOpen: false,
     toasts: [],
@@ -68,7 +67,7 @@ const DeckStateFactory = () => {
     .prop({ key: 'activeDeck', type: LocalStorageStore.string() })
     .prop({ key: 'previousDeck', type: LocalStorageStore.string() });
 
-  const layout = live<Capabilities.Layout>({
+  const layout = create<Capabilities.Layout>({
     get mode() {
       return getMode(state.values.deck);
     },
@@ -100,5 +99,3 @@ const DeckStateFactory = () => {
     contributes(Capabilities.Layout, layout),
   ];
 };
-
-export default DeckStateFactory;

package/src/capabilities/tools.ts

@@ -2,8 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
-
 import {
   contributes,
   createIntent,
@@ -12,6 +10,7 @@ import {
   type PromiseIntentDispatcher,
 } from '@dxos/app-framework';
 import { defineTool, ToolResult } from '@dxos/artifact';
+import { S } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 
 import { meta } from '../meta';
@@ -36,8 +35,8 @@ export default () =>
       `,
       caption: 'Showing item...',
       // TODO(wittjosiah): Refactor Layout/Navigation/Deck actions so that they can be used directly.
-      schema: Schema.Struct({
-        id: Schema.String.annotations({
+      schema: S.Struct({
+        id: S.String.annotations({
           description: 'The ID of the item to show.',
         }),
       }),

package/src/capabilities/url-handler.ts

@@ -2,16 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, createIntent, LayoutAction, type PluginContext } from '@dxos/app-framework';
+import { Capabilities, contributes, createIntent, LayoutAction, type PluginsContext } from '@dxos/app-framework';
 import { scheduledEffect } from '@dxos/echo-signals/core';
 
 import { DeckCapabilities } from './capabilities';
 import { defaultDeck } from '../types';
 
 // TODO(wittjosiah): Cleanup the url handling. May justify introducing routing capabilities.
-export default async (context: PluginContext) => {
-  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-  const state = context.getCapability(DeckCapabilities.MutableDeckState);
+export default async (context: PluginsContext) => {
+  const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher) ?? {};
+  const state = context.requestCapability(DeckCapabilities.MutableDeckState);
 
   const handleNavigation = async () => {
     const pathname = window.location.pathname;

package/src/components/DeckLayout/ContentEmpty.tsx

@@ -4,24 +4,19 @@
 
 import React from 'react';
 
-import { Surface, useCapability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework';
 
-import { DeckCapabilities } from '../../capabilities';
-import { useBreakpoints } from '../../hooks';
-import { getMode } from '../../types';
-import { layoutAppliesTopbar } from '../../util';
+import { layoutAppliesTopbar, useBreakpoints } from '../../util';
 import { ToggleSidebarButton } from '../Sidebar';
 import { fixedSidebarToggleStyles } from '../fragments';
 
 export const ContentEmpty = () => {
   const breakpoint = useBreakpoints();
-  const { deck } = useCapability(DeckCapabilities.MutableDeckState);
-  const layoutMode = getMode(deck);
-  const topbar = layoutAppliesTopbar(breakpoint, layoutMode);
+  const topbar = layoutAppliesTopbar(breakpoint);
   return (
     <div
       role='none'
-      className='grid place-items-center p-8 relative bg-deckSurface'
+      className='grid place-items-center p-8 relative bg-deck'
       data-testid='layoutPlugin.firstRunMessage'
     >
       <Surface role='keyshortcuts' />