@dxos/plugin-deck 0.8.4-main.21d9917 → 0.8.4-main.2244d791bb

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -6,7 +6,8 @@ import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
 import * as Option from 'effect/Option';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability, UndoOperation } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
 import { Obj } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
@@ -52,17 +53,20 @@ const updateActiveDeck = (current: DeckStateProps, deckUpdates: Partial<DeckStat
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    return Capability.contributes(Common.Capability.OperationResolver, [
+    return Capability.contributes(Capabilities.OperationResolver, [
       //
       // UpdateSidebar
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.UpdateSidebar,
+        operation: LayoutOperation.UpdateSidebar,
         handler: Effect.fnUntraced(function* (input) {
-          const state = yield* Common.Capability.getAtomValue(DeckCapabilities.State);
+          const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
           const next = input.state ?? state.sidebarState;
           if (next !== state.sidebarState) {
-            yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => ({ ...s, sidebarState: next }));
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => ({
+              ...state,
+              sidebarState: next,
+            }));
           }
         }),
       }),
@@ -71,18 +75,18 @@ export default Capability.makeModule(
       // UpdateComplementary
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.UpdateComplementary,
+        operation: LayoutOperation.UpdateComplementary,
         handler: Effect.fnUntraced(function* (input) {
-          const state = yield* Common.Capability.getAtomValue(DeckCapabilities.State);
+          const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
           const panelChanged = state.complementarySidebarPanel !== input.subject;
           const next = input.subject ? 'expanded' : (input.state ?? state.complementarySidebarState);
           const stateChanged = next !== state.complementarySidebarState;
 
           if (panelChanged || stateChanged) {
-            yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => ({
-              ...s,
-              complementarySidebarPanel: panelChanged ? input.subject : s.complementarySidebarPanel,
-              complementarySidebarState: stateChanged ? next : s.complementarySidebarState,
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => ({
+              ...state,
+              complementarySidebarPanel: panelChanged ? input.subject : state.complementarySidebarPanel,
+              complementarySidebarState: stateChanged ? next : state.complementarySidebarState,
             }));
           }
         }),
@@ -92,10 +96,10 @@ export default Capability.makeModule(
       // UpdateDialog
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.UpdateDialog,
+        operation: LayoutOperation.UpdateDialog,
         handler: Effect.fnUntraced(function* (input) {
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.EphemeralState, (s) => ({
-            ...s,
+          yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+            ...state,
             dialogOpen: input.state ?? Boolean(input.subject),
             dialogType: input.type ?? 'default',
             dialogBlockAlign: input.blockAlign ?? 'center',
@@ -110,13 +114,14 @@ export default Capability.makeModule(
       // UpdatePopover
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.UpdatePopover,
+        operation: LayoutOperation.UpdatePopover,
         handler: Effect.fnUntraced(function* (input) {
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.EphemeralState, (s) => ({
-            ...s,
+          yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+            ...state,
             popoverOpen: input.state ?? Boolean(input.subject),
             popoverKind: input.kind ?? 'base',
             popoverTitle: input.kind === 'card' ? input.title : undefined,
+            popoverContentRef: input.subjectRef,
             popoverContent:
               typeof input.subject === 'string'
                 ? { component: input.subject, props: input.props }
@@ -124,8 +129,8 @@ export default Capability.makeModule(
                   ? { subject: input.subject }
                   : null,
             popoverSide: input.side,
-            popoverAnchor: input.variant === 'virtual' ? input.anchor : s.popoverAnchor,
-            popoverAnchorId: input.variant !== 'virtual' ? input.anchorId : s.popoverAnchorId,
+            popoverAnchor: input.variant === 'virtual' ? input.anchor : state.popoverAnchor,
+            popoverAnchorId: input.variant !== 'virtual' ? input.anchorId : state.popoverAnchorId,
           }));
         }),
       }),
@@ -134,11 +139,11 @@ export default Capability.makeModule(
       // AddToast
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.AddToast,
+        operation: LayoutOperation.AddToast,
         handler: Effect.fnUntraced(function* (input) {
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.EphemeralState, (s) => ({
-            ...s,
-            toasts: [...s.toasts, input as Common.LayoutOperation.Toast],
+          yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+            ...state,
+            toasts: [...state.toasts, input as LayoutOperation.Toast],
           }));
         }),
       }),
@@ -147,18 +152,18 @@ export default Capability.makeModule(
       // ShowUndo
       //
       OperationResolver.make({
-        operation: Common.UndoOperation.ShowUndo,
+        operation: UndoOperation.ShowUndo,
         handler: Effect.fnUntraced(function* (input) {
-          const historyTracker = yield* Capability.get(Common.Capability.HistoryTracker);
+          const historyTracker = yield* Capability.get(Capabilities.HistoryTracker);
 
           const newUndoId = `show-undo-${Date.now()}`;
           // TODO(wittjosiah): Support undoing further back than the last action.
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.EphemeralState, (s) => {
-            const filteredToasts = s.currentUndoId
-              ? s.toasts.filter((toast) => toast.id !== s.currentUndoId)
-              : s.toasts;
+          yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => {
+            const filteredToasts = state.currentUndoId
+              ? state.toasts.filter((toast) => toast.id !== state.currentUndoId)
+              : state.toasts;
 
-            const toast: Common.LayoutOperation.Toast = {
+            const toast: LayoutOperation.Toast = {
               id: newUndoId,
               title: input.message ?? ['undo available label', { ns: meta.id }],
               duration: 10_000,
@@ -169,7 +174,7 @@ export default Capability.makeModule(
             };
 
             return {
-              ...s,
+              ...state,
               currentUndoId: newUndoId,
               toasts: [...filteredToasts, toast],
             };
@@ -181,7 +186,7 @@ export default Capability.makeModule(
       // SetLayoutMode
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.SetLayoutMode,
+        operation: LayoutOperation.SetLayoutMode,
         filter: (input) => {
           if ('mode' in input) {
             return isLayoutMode(input.mode);
@@ -189,7 +194,7 @@ export default Capability.makeModule(
           return true;
         },
         handler: Effect.fnUntraced(function* (input) {
-          const state = yield* Common.Capability.getAtomValue(DeckCapabilities.State);
+          const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
           const deck = yield* DeckCapabilities.getDeck();
 
           const computeModeUpdate = (mode: LayoutMode, subject?: string): Partial<DeckState> => {
@@ -228,18 +233,22 @@ export default Capability.makeModule(
               'subject' in input ? input.subject : undefined,
             );
 
-            yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => {
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => {
               const newPreviousMode =
-                currentMode !== input.mode ? { ...s.previousMode, [s.activeDeck]: currentMode } : s.previousMode;
+                currentMode !== input.mode
+                  ? { ...state.previousMode, [state.activeDeck]: currentMode }
+                  : state.previousMode;
               return {
-                ...updateActiveDeck(s, deckUpdates),
+                ...updateActiveDeck(state, deckUpdates),
                 previousMode: newPreviousMode,
               };
             });
           } else if ('revert' in input) {
             const last = state.previousMode[state.activeDeck];
             const deckUpdates = computeModeUpdate(last ?? 'solo');
-            yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => updateActiveDeck(s, deckUpdates));
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) =>
+              updateActiveDeck(state, deckUpdates),
+            );
           } else {
             log.warn('Invalid layout mode', input);
           }
@@ -250,21 +259,23 @@ export default Capability.makeModule(
       // SwitchWorkspace
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.SwitchWorkspace,
+        operation: LayoutOperation.SwitchWorkspace,
         handler: Effect.fnUntraced(function* (input) {
-          const { graph } = yield* Capability.get(Common.Capability.AppGraph);
+          const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
 
           {
-            const state = yield* Common.Capability.getAtomValue(DeckCapabilities.State);
+            const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
             // 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.
             const shouldUpdatePrevious = !state.activeDeck.startsWith('!');
 
-            yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => {
-              const newDecks = s.decks[input.subject] ? s.decks : { ...s.decks, [input.subject]: { ...defaultDeck } };
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => {
+              const newDecks = state.decks[input.subject]
+                ? state.decks
+                : { ...state.decks, [input.subject]: { ...defaultDeck } };
               return {
-                ...s,
-                previousDeck: shouldUpdatePrevious ? s.activeDeck : s.previousDeck,
+                ...state,
+                previousDeck: shouldUpdatePrevious ? state.activeDeck : state.previousDeck,
                 activeDeck: input.subject,
                 decks: newDecks,
               };
@@ -272,19 +283,19 @@ export default Capability.makeModule(
           }
 
           {
-            const state = yield* Common.Capability.getAtomValue(DeckCapabilities.State);
+            const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
             const deck = state.decks[input.subject];
             invariant(deck, `Deck not found: ${input.subject}`);
 
             const first = deck.solo ? deck.solo : deck.active[0];
             if (first) {
-              yield* Operation.schedule(Common.LayoutOperation.ScrollIntoView, { subject: first });
+              yield* Operation.schedule(LayoutOperation.ScrollIntoView, { subject: first });
             } else {
               const [item] = Graph.getConnections(graph, input.subject).filter(
                 (node) => !Node.isActionLike(node) && !node.properties.disposition,
               );
               if (item) {
-                yield* Operation.schedule(Common.LayoutOperation.Open, { subject: [item.id] });
+                yield* Operation.schedule(LayoutOperation.Open, { subject: [item.id] });
               }
             }
           }
@@ -295,10 +306,10 @@ export default Capability.makeModule(
       // RevertWorkspace
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.RevertWorkspace,
+        operation: LayoutOperation.RevertWorkspace,
         handler: Effect.fnUntraced(function* () {
-          const state = yield* Common.Capability.getAtomValue(DeckCapabilities.State);
-          yield* Operation.invoke(Common.LayoutOperation.SwitchWorkspace, { subject: state.previousDeck });
+          const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+          yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: state.previousDeck });
         }),
       }),
 
@@ -306,16 +317,16 @@ export default Capability.makeModule(
       // Open
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.Open,
+        operation: LayoutOperation.Open,
         handler: Effect.fnUntraced(function* (input) {
-          const { graph } = yield* Capability.get(Common.Capability.AppGraph);
+          const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
           const attention = yield* Capability.get(AttentionCapabilities.Attention);
-          const settings = yield* Common.Capability.getAtomValue(DeckCapabilities.Settings);
+          const settings = yield* Capabilities.getAtomValue(DeckCapabilities.Settings);
 
           {
-            const state = yield* Common.Capability.getAtomValue(DeckCapabilities.State);
+            const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
             if (input.workspace && state.activeDeck !== input.workspace) {
-              yield* Operation.invoke(Common.LayoutOperation.SwitchWorkspace, { subject: input.workspace });
+              yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: input.workspace });
             }
           }
 
@@ -337,7 +348,9 @@ export default Capability.makeModule(
                 );
 
             const { deckUpdates, toAttend: _toAttend } = computeActiveUpdates({ next, deck, attention });
-            yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => updateActiveDeck(s, deckUpdates));
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) =>
+              updateActiveDeck(state, deckUpdates),
+            );
           }
 
           {
@@ -346,13 +359,13 @@ export default Capability.makeModule(
             const newlyOpen = ids.filter((i: string) => !previouslyOpenIds.has(i));
 
             if (input.scrollIntoView !== false && (newlyOpen[0] ?? input.subject[0])) {
-              yield* Operation.schedule(Common.LayoutOperation.ScrollIntoView, {
+              yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
                 subject: newlyOpen[0] ?? input.subject[0],
               });
             }
 
             if (newlyOpen[0] ?? input.subject[0]) {
-              yield* Operation.schedule(Common.LayoutOperation.Expose, { subject: newlyOpen[0] ?? input.subject[0] });
+              yield* Operation.schedule(LayoutOperation.Expose, { subject: newlyOpen[0] ?? input.subject[0] });
             }
 
             // Send analytics events for newly opened items.
@@ -379,10 +392,10 @@ export default Capability.makeModule(
       OperationResolver.make({
         operation: DeckOperation.UpdatePlankSize,
         handler: Effect.fnUntraced(function* (input) {
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) =>
-            updateActiveDeck(s, {
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) =>
+            updateActiveDeck(state, {
               plankSizing: {
-                ...s.decks[s.activeDeck]?.plankSizing,
+                ...state.decks[state.activeDeck]?.plankSizing,
                 [input.id]: input.size,
               },
             }),
@@ -396,10 +409,10 @@ export default Capability.makeModule(
       OperationResolver.make({
         operation: DeckOperation.Adjust,
         handler: Effect.fnUntraced(function* (input) {
-          const _state = yield* Common.Capability.getAtomValue(DeckCapabilities.State);
+          const _state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
           const deck = yield* DeckCapabilities.getDeck();
           const attention = yield* Capability.get(AttentionCapabilities.Attention);
-          const { graph } = yield* Capability.get(Common.Capability.AppGraph);
+          const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
 
           // Collect layout operations to run after state updates.
           let soloOperation:
@@ -410,7 +423,9 @@ export default Capability.makeModule(
           if (input.type === 'increment-end' || input.type === 'increment-start') {
             const next = incrementPlank(deck.active, input);
             const { deckUpdates } = computeActiveUpdates({ next, deck, attention });
-            yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => updateActiveDeck(s, deckUpdates));
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) =>
+              updateActiveDeck(state, deckUpdates),
+            );
           }
 
           if (input.type.startsWith('solo')) {
@@ -431,13 +446,13 @@ export default Capability.makeModule(
 
           // Run collected solo operations.
           if (soloOperation?.type === 'solo') {
-            yield* Operation.invoke(Common.LayoutOperation.SetLayoutMode, {
+            yield* Operation.invoke(LayoutOperation.SetLayoutMode, {
               subject: soloOperation.entryId,
               mode: soloOperation.mode,
             });
           } else if (soloOperation?.type === 'unsolo') {
-            yield* Operation.invoke(Common.LayoutOperation.SetLayoutMode, { mode: 'deck' });
-            yield* Operation.invoke(Common.LayoutOperation.Open, { subject: [soloOperation.entryId] });
+            yield* Operation.invoke(LayoutOperation.SetLayoutMode, { mode: 'deck' });
+            yield* Operation.invoke(LayoutOperation.Open, { subject: [soloOperation.entryId] });
           }
 
           if (input.type === 'companion') {
@@ -471,14 +486,14 @@ export default Capability.makeModule(
           const deck = yield* DeckCapabilities.getDeck();
           if (input.companion === null) {
             const { [input.primary]: _, ...nextActiveCompanions } = deck.activeCompanions ?? {};
-            yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) =>
-              updateActiveDeck(s, { activeCompanions: nextActiveCompanions }),
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) =>
+              updateActiveDeck(state, { activeCompanions: nextActiveCompanions }),
             );
           } else {
             const companion = input.companion;
             invariant(companion !== input.primary);
-            yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) =>
-              updateActiveDeck(s, {
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) =>
+              updateActiveDeck(state, {
                 activeCompanions: {
                   ...deck.activeCompanions,
                   [input.primary]: companion,
@@ -493,7 +508,7 @@ export default Capability.makeModule(
       // Close
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.Close,
+        operation: LayoutOperation.Close,
         handler: Effect.fnUntraced(function* (input) {
           const deck = yield* DeckCapabilities.getDeck();
           const attention = yield* Capability.get(AttentionCapabilities.Attention);
@@ -501,7 +516,7 @@ export default Capability.makeModule(
           const active = deck.solo ? [deck.solo] : deck.active;
           const next = input.subject.reduce((acc, id) => closeEntry(acc, id), active);
           const { deckUpdates, toAttend } = computeActiveUpdates({ next, deck, attention });
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => updateActiveDeck(s, deckUpdates));
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
 
           // Clear companions for closed entries.
           for (const id of input.subject) {
@@ -511,7 +526,7 @@ export default Capability.makeModule(
           }
 
           if (toAttend) {
-            yield* Operation.schedule(Common.LayoutOperation.ScrollIntoView, { subject: toAttend });
+            yield* Operation.schedule(LayoutOperation.ScrollIntoView, { subject: toAttend });
           }
         }),
       }),
@@ -520,7 +535,7 @@ export default Capability.makeModule(
       // Set
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.Set,
+        operation: LayoutOperation.Set,
         handler: Effect.fnUntraced(function* (input) {
           const deck = yield* DeckCapabilities.getDeck();
           const attention = yield* Capability.get(AttentionCapabilities.Attention);
@@ -530,10 +545,10 @@ export default Capability.makeModule(
             deck,
             attention,
           });
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => updateActiveDeck(s, deckUpdates));
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
 
           if (toAttend) {
-            yield* Operation.schedule(Common.LayoutOperation.ScrollIntoView, { subject: toAttend });
+            yield* Operation.schedule(LayoutOperation.ScrollIntoView, { subject: toAttend });
           }
         }),
       }),
@@ -542,10 +557,10 @@ export default Capability.makeModule(
       // ScrollIntoView
       //
       OperationResolver.make({
-        operation: Common.LayoutOperation.ScrollIntoView,
+        operation: LayoutOperation.ScrollIntoView,
         handler: Effect.fnUntraced(function* (input) {
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.EphemeralState, (s) => ({
-            ...s,
+          yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+            ...state,
             scrollIntoView: input.subject,
           }));
         }),

package/src/capabilities/react-root/react-root.tsx

@@ -5,7 +5,7 @@
 import * as Effect from 'effect/Effect';
 import React, { useCallback } from 'react';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
 
 import { DeckLayout } from '../../components';
 import { useDeckState } from '../../hooks';
@@ -13,7 +13,7 @@ import { meta } from '../../meta';
 
 export default Capability.makeModule(() =>
   Effect.succeed(
-    Capability.contributes(Common.Capability.ReactRoot, {
+    Capability.contributes(Capabilities.ReactRoot, {
       id: meta.id,
       root: () => {
         const { state, updateEphemeral } = useDeckState();

package/src/capabilities/react-surface/react-surface.tsx

@@ -5,8 +5,9 @@
 import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capability, Common } from '@dxos/app-framework';
-import { useSettingsState } from '@dxos/app-framework/react';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useSettingsState } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
 
 import { Banner, DeckSettings } from '../../components';
 import { meta } from '../../meta';
@@ -14,18 +15,18 @@ import { type DeckSettingsProps } from '../../types';
 
 export default Capability.makeModule(() =>
   Effect.succeed(
-    Capability.contributes(Common.Capability.ReactSurface, [
-      Common.createSurface({
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
         id: `${meta.id}/plugin-settings`,
         role: 'article',
-        filter: (data): data is { subject: Common.Capability.Settings } =>
-          Common.Capability.isSettings(data.subject) && data.subject.prefix === meta.id,
+        filter: (data): data is { subject: AppCapabilities.Settings } =>
+          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
         component: ({ data: { subject } }) => {
           const { settings, updateSettings } = useSettingsState<DeckSettingsProps>(subject.atom);
           return <DeckSettings settings={settings} onSettingsChange={updateSettings} />;
         },
       }),
-      Common.createSurface({
+      Surface.create({
         id: `${meta.id}/banner`,
         role: 'banner',
         component: ({ data }: { data: { variant?: 'topbar' | 'sidebar' } }) => {

package/src/capabilities/settings/settings.ts

@@ -4,7 +4,8 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { createKvsStore } from '@dxos/effect';
 
 import { meta } from '../../meta';
@@ -28,7 +29,7 @@ export default Capability.makeModule(() =>
 
     return [
       Capability.contributes(DeckCapabilities.Settings, settingsAtom),
-      Capability.contributes(Common.Capability.Settings, {
+      Capability.contributes(AppCapabilities.Settings, {
         prefix: meta.id,
         schema: DeckSettingsSchema,
         atom: settingsAtom,

package/src/capabilities/state/state.ts

@@ -5,7 +5,8 @@
 import { Atom } from '@effect-atom/atom-react';
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { createKvsStore } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 
@@ -49,7 +50,7 @@ const defaultDeckEphemeralState: DeckEphemeralStateProps = {
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    const registry = yield* Capability.get(Common.Capability.AtomRegistry);
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
 
     // Persisted state using KVS store.
     const stateAtom = createKvsStore({
@@ -92,13 +93,13 @@ export default Capability.makeModule(
         active: deck.solo ? [deck.solo] : deck.active,
         inactive: deck.inactive,
         scrollIntoView: ephemeral.scrollIntoView,
-      } satisfies Common.Capability.Layout;
+      } satisfies AppCapabilities.Layout;
     }).pipe(Atom.keepAlive);
 
     return [
       Capability.contributes(DeckCapabilities.State, stateAtom),
       Capability.contributes(DeckCapabilities.EphemeralState, ephemeralAtom),
-      Capability.contributes(Common.Capability.Layout, layoutAtom),
+      Capability.contributes(AppCapabilities.Layout, layoutAtom),
     ];
   }),
 );

package/src/capabilities/toolkit/toolkit.ts

@@ -7,7 +7,8 @@ import * as Toolkit from '@effect/ai/Toolkit';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { Capability, type CapabilityManager, Common } from '@dxos/app-framework';
+import { Capabilities, Capability, type CapabilityManager } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
 import { GenericToolkit } from '@dxos/assistant';
 import { ArtifactId } from '@dxos/assistant';
 import { type SpaceId } from '@dxos/keys';
@@ -35,7 +36,7 @@ export namespace DeckToolkit {
     Toolkit$.toLayer({
       'open-item': ({ id }) =>
         Effect.gen(function* () {
-          const registry = capabilityManager.get(Common.Capability.AtomRegistry);
+          const registry = capabilityManager.get(Capabilities.AtomRegistry);
           const stateAtom = capabilityManager.get(DeckCapabilities.State);
           const state = registry.get(stateAtom);
           const dxn = ArtifactId.toDXN(id, state.activeDeck as SpaceId).asEchoDXN();
@@ -45,8 +46,8 @@ export namespace DeckToolkit {
           }
 
           // TODO(wittjosiah): Get capabilities via layers.
-          const { invoke } = capabilityManager.get(Common.Capability.OperationInvoker);
-          yield* invoke(Common.LayoutOperation.Open, { subject: [`${dxn.spaceId!}:${dxn.echoId}`] });
+          const { invoke } = capabilityManager.get(Capabilities.OperationInvoker);
+          yield* invoke(LayoutOperation.Open, { subject: [`${dxn.spaceId!}:${dxn.echoId}`] });
         }).pipe(Effect.orDie),
     });
 }
@@ -56,7 +57,7 @@ export default Capability.makeModule(
     const capabilityManager = yield* Capability.Service;
 
     return Capability.contributes(
-      Common.Capability.Toolkit,
+      AppCapabilities.Toolkit,
       GenericToolkit.make(DeckToolkit.Toolkit, DeckToolkit.createLayer(capabilityManager)),
     );
   }),

package/src/capabilities/url-handler/url-handler.ts

@@ -4,7 +4,8 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability, Common } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
 import { invariant } from '@dxos/invariant';
 
 import { DeckCapabilities, type DeckStateProps, defaultDeck } from '../../types';
@@ -12,8 +13,8 @@ import { DeckCapabilities, type DeckStateProps, defaultDeck } from '../../types'
 // TODO(wittjosiah): Cleanup the url handling. May justify introducing routing capabilities.
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
-    const { invokeSync } = yield* Capability.get(Common.Capability.OperationInvoker);
-    const registry = yield* Capability.get(Common.Capability.AtomRegistry);
+    const { invokeSync } = yield* Capability.get(Capabilities.OperationInvoker);
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
     const stateAtom = yield* Capability.get(DeckCapabilities.State);
 
     // Helper to get state.
@@ -49,14 +50,14 @@ export default Capability.makeModule(
 
       const [_, nextDeck, nextSolo] = pathname.split('/');
       if (nextDeck && nextDeck !== state.activeDeck) {
-        invokeSync(Common.LayoutOperation.SwitchWorkspace, { subject: nextDeck });
+        invokeSync(LayoutOperation.SwitchWorkspace, { subject: nextDeck });
       }
 
       const deck = getDeck();
       if (nextSolo && nextSolo !== deck.solo) {
-        invokeSync(Common.LayoutOperation.SetLayoutMode, { subject: nextSolo, mode: 'solo' });
+        invokeSync(LayoutOperation.SetLayoutMode, { subject: nextSolo, mode: 'solo' });
       } else if (!nextSolo && deck.solo) {
-        invokeSync(Common.LayoutOperation.SetLayoutMode, { mode: 'deck' });
+        invokeSync(LayoutOperation.SetLayoutMode, { mode: 'deck' });
       }
     };
 
@@ -85,7 +86,7 @@ export default Capability.makeModule(
       }
     });
 
-    return Capability.contributes(Common.Capability.Null, null, () =>
+    return Capability.contributes(Capabilities.Null, null, () =>
       Effect.sync(() => {
         window.removeEventListener('popstate', handleNavigation);
         unsubscribe();