@dxos/plugin-deck 0.7.4 → 0.7.5-labs.071a3e2

package/src/capabilities/capabilities.ts

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

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

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';
+
+import { DECK_PLUGIN } from '../meta';
+import { type DeckSettingsProps } from '../types';
+
+const isSocket = !!(globalThis as any).__args;
+
+// TODO(mjamesderocher): Can we get this directly from Socket?
+const appScheme = 'composer://';
+
+// TODO(mjamesderocher): Factor out as part of NavigationPlugin.
+const checkAppScheme = (url: string) => {
+  const iframe = document.createElement('iframe');
+  iframe.style.display = 'none';
+  document.body.appendChild(iframe);
+
+  iframe.src = url + window.location.pathname.replace(/^\/+/, '') + window.location.search;
+
+  const timer = setTimeout(() => {
+    document.body.removeChild(iframe);
+  }, 3000);
+
+  window.addEventListener('pagehide', (event) => {
+    clearTimeout(timer);
+    document.body.removeChild(iframe);
+  });
+};
+
+export default async (context: PluginsContext) => {
+  const settingsStore = context.requestCapability(Capabilities.SettingsStore);
+  const settings = settingsStore.getStore<DeckSettingsProps>(DECK_PLUGIN)?.value;
+  if (!isSocket && settings?.enableNativeRedirect) {
+    checkAppScheme(appScheme);
+  }
+
+  return contributes(Capabilities.Null, null);
+};

package/src/capabilities/index.ts

@@ -0,0 +1,17 @@
+//
+// 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';

package/src/capabilities/intent-resolver.ts

@@ -0,0 +1,350 @@
+//
+// 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 { nonNullable } from '@dxos/util';
+
+import { DeckCapabilities } from './capabilities';
+import { setActive } from './set-active';
+import { closeEntry, incrementPlank, openEntry } from '../layout';
+import { DECK_PLUGIN } from '../meta';
+import { DeckAction, type LayoutMode, type DeckSettingsProps, isLayoutMode, getMode } from '../types';
+
+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;
+      },
+    }),
+    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 === 'solo' ? [subject ?? deck.solo ?? deck.active[0]] : [...deck.active, deck.solo]
+          ).filter(nonNullable);
+
+          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 === 'solo' && next[0]) {
+            deck.solo = next[0];
+          } else if (mode !== 'solo' && 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(() => {
+          state.activeDeck = subject;
+          if (!state.decks[subject]) {
+            state.decks[subject] = { initialized: false, active: [], inactive: [], fullscreen: false, plankSizing: {} };
+          }
+        });
+
+        const first = state.decks[state.activeDeck].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.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 next = subject.reduce((acc, id) => closeEntry(acc, id), state.deck.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] }),
+                  ),
+                ],
+              };
+            }
+          }
+        });
+      },
+    }),
+  ]);

package/src/capabilities/react-root.tsx

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback } from 'react';
+
+import { Capabilities, contributes, useCapabilities, useCapability } from '@dxos/app-framework';
+
+import { DeckCapabilities } from './capabilities';
+import { DeckLayout } from '../components';
+import { DECK_PLUGIN } from '../meta';
+import { type DeckSettingsProps } from '../types';
+
+export default () =>
+  contributes(Capabilities.ReactRoot, {
+    id: DECK_PLUGIN,
+    root: () => {
+      const layout = useCapability(DeckCapabilities.MutableDeckState);
+      const settings = useCapability(Capabilities.SettingsStore).getStore<DeckSettingsProps>(DECK_PLUGIN)!.value;
+      const panels = useCapabilities(DeckCapabilities.ComplementaryPanel);
+
+      const handleDismissToast = useCallback(
+        (id: string) => {
+          const index = layout.toasts.findIndex((toast) => toast.id === id);
+          if (index !== -1) {
+            // Allow time for the toast to animate out.
+            // TODO(burdon): Factor out and unregister timeout.
+            setTimeout(() => {
+              if (layout.toasts[index].id === layout.currentUndoId) {
+                layout.currentUndoId = undefined;
+              }
+              layout.toasts.splice(index, 1);
+            }, 1_000);
+          }
+        },
+        [layout.toasts],
+      );
+
+      return (
+        <DeckLayout
+          showHints={settings.showHints}
+          overscroll={settings.overscroll}
+          panels={panels}
+          onDismissToast={handleDismissToast}
+        />
+      );
+    },
+  });

package/src/capabilities/react-surface.tsx

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
+import { SettingsStore } from '@dxos/local-storage';
+
+import { LayoutSettings } from '../components';
+import { Banner } from '../components/DeckLayout/Banner';
+import { DECK_PLUGIN } from '../meta';
+import { type DeckSettingsProps } from '../types';
+
+export default () =>
+  contributes(Capabilities.ReactSurface, [
+    createSurface({
+      id: `${DECK_PLUGIN}/settings`,
+      role: 'article',
+      filter: (data): data is { subject: SettingsStore<DeckSettingsProps> } =>
+        data.subject instanceof SettingsStore && data.subject.prefix === DECK_PLUGIN,
+      component: ({ data: { subject } }) => <LayoutSettings settings={subject.value} />,
+    }),
+    createSurface({
+      id: `${DECK_PLUGIN}/banner`,
+      role: 'banner',
+      component: ({ data }) => {
+        return <Banner variant={data.variant} />;
+      },
+    }),
+  ]);

package/src/capabilities/set-active.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { batch } from '@preact/signals-core';
+
+import { type AttentionManager } from '@dxos/plugin-attention';
+
+import { type DeckState } from '../types';
+
+export type SetActiveOptions = {
+  next: string[];
+  state: DeckState;
+  attention?: AttentionManager;
+};
+
+export const setActive = ({ next, state, attention }: SetActiveOptions) => {
+  return batch(() => {
+    const active = state.deck.solo ? [state.deck.solo] : state.deck.active;
+    const removed = active.filter((id) => !next.includes(id));
+    const closed = Array.from(new Set([...state.deck.inactive.filter((id) => !next.includes(id)), ...removed]));
+
+    state.deck.inactive = closed;
+
+    if (state.deck.solo || !state.deck.initialized) {
+      state.deck.solo = next[0];
+    } else {
+      state.deck.active = next;
+    }
+
+    if (attention) {
+      const attended = attention.current;
+      const [attendedId] = Array.from(attended);
+      const isAttendedAvailable = !!attendedId && next.includes(attendedId);
+      if (!isAttendedAvailable) {
+        const attendedIndex = active.indexOf(attendedId);
+        // If outside of bounds, focus on the first/last plank, otherwise focus on the new plank in the same position.
+        const index = attendedIndex === -1 ? 0 : attendedIndex >= next.length ? next.length - 1 : attendedIndex;
+        return next[index];
+      }
+    }
+  });
+};

package/src/capabilities/settings.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes } from '@dxos/app-framework';
+import { create } from '@dxos/live-object';
+
+import { DECK_PLUGIN } from '../meta';
+import { DeckSettingsSchema, type DeckSettingsProps } from '../types';
+
+export default () => {
+  const settings = create<DeckSettingsProps>({
+    showHints: false,
+    enableNativeRedirect: false,
+    enableIdeStyleStatusbar: true,
+    newPlankPositioning: 'start',
+    overscroll: 'none',
+  });
+
+  return contributes(Capabilities.Settings, { schema: DeckSettingsSchema, prefix: DECK_PLUGIN, value: settings });
+};

package/src/capabilities/state.ts

@@ -0,0 +1,102 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes } from '@dxos/app-framework';
+import { invariant } from '@dxos/invariant';
+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 Deck, type DeckState } from '../types';
+
+const boolean = /true|false/;
+
+// TODO(thure, 18 Feb 2025): Remove after the next release.
+
+const migrateSidebarStateDefaults = {
+  [`${DECK_PLUGIN}/complementary-sidebar-state`]: 'expanded',
+  [`${DECK_PLUGIN}/sidebar-state`]: 'collapsed',
+};
+
+const migrateSidebarState = () => {
+  Object.entries(migrateSidebarStateDefaults).forEach(([key, defaultValue]) => {
+    if (boolean.test(localStorage.getItem(key) ?? 'never')) {
+      localStorage.setItem(key, defaultValue);
+    }
+  });
+};
+
+export default () => {
+  migrateSidebarState();
+
+  const state = new LocalStorageStore<DeckState>(DECK_PLUGIN, {
+    sidebarState: 'expanded',
+    complementarySidebarState: 'collapsed',
+    complementarySidebarPanel: undefined,
+    dialogContent: null,
+    dialogOpen: false,
+    dialogBlockAlign: undefined,
+    dialogType: undefined,
+    popoverContent: null,
+    popoverAnchorId: undefined,
+    popoverOpen: false,
+    toasts: [],
+    currentUndoId: undefined,
+    activeDeck: 'default',
+    decks: {
+      default: {
+        initialized: false,
+        active: [],
+        inactive: [],
+        fullscreen: false,
+        solo: undefined,
+        plankSizing: {},
+      },
+    },
+    get deck() {
+      const deck = this.decks[this.activeDeck];
+      invariant(deck, `Deck not found: ${this.activeDeck}`);
+      return deck;
+    },
+    previousMode: {},
+    scrollIntoView: undefined,
+  });
+
+  state
+    .prop({ key: 'sidebarState', type: LocalStorageStore.enum<SidebarState>() })
+    .prop({ key: 'complementarySidebarState', type: LocalStorageStore.enum<SidebarState>() })
+    .prop({ key: 'decks', type: LocalStorageStore.json<Record<string, Deck>>() })
+    .prop({ key: 'activeDeck', type: LocalStorageStore.string() });
+
+  const layout = create<Capabilities.Layout>({
+    get mode() {
+      return getMode(state.values.deck);
+    },
+    get dialogOpen() {
+      return state.values.dialogOpen;
+    },
+    get sidebarOpen() {
+      return state.values.sidebarState === 'expanded';
+    },
+    get complementarySidebarOpen() {
+      return state.values.complementarySidebarState === 'expanded';
+    },
+    get active() {
+      return state.values.deck.solo ? [state.values.deck.solo] : state.values.deck.active;
+    },
+    get inactive() {
+      return state.values.deck.inactive;
+    },
+    get scrollIntoView() {
+      return state.values.scrollIntoView;
+    },
+  });
+
+  return [
+    contributes(DeckCapabilities.DeckState, state.values, () => state.close()),
+    contributes(Capabilities.Layout, layout),
+  ];
+};