@dxos/plugin-deck 0.8.4-main.bc674ce → 0.8.4-main.c351d160a8

package/dist/lib/node-esm/{operation-resolver-WUOE33ID.mjs → operation-resolver-GCMCCI7A.mjs}

@@ -1,26 +1,25 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  closeEntry,
-  computeActiveUpdates,
-  createEntryId,
-  incrementPlank,
-  openEntry
-} from "./chunk-ADPMWKLL.mjs";
+  computeActiveUpdates
+} from "./chunk-DGTRKKWZ.mjs";
 import {
   DeckCapabilities,
   DeckOperation,
   PLANK_COMPANION_TYPE,
   defaultDeck,
   getMode,
-  isLayoutMode,
+  isLayoutMode
+} from "./chunk-GZJAQ5IP.mjs";
+import {
   meta
-} from "./chunk-XAKTY3EB.mjs";
+} from "./chunk-XCNF4COU.mjs";
 
 // src/capabilities/operation-resolver/operation-resolver.ts
 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, getCompanionVariant, isPinnedWorkspace } from "@dxos/app-toolkit";
 import { Obj } from "@dxos/echo";
 import { invariant } from "@dxos/invariant";
 import { log } from "@dxos/log";
@@ -30,12 +29,77 @@ import { AttentionCapabilities } from "@dxos/plugin-attention";
 import { Graph, Node } from "@dxos/plugin-graph";
 import { ObservabilityOperation } from "@dxos/plugin-observability/types";
 import { byPosition, isNonNullable } from "@dxos/util";
+
+// src/layout.ts
+import { produce } from "immer";
+var openEntry = (deck, entryId, options) => {
+  return produce(deck, (draft) => {
+    if (draft.find((id) => id === entryId)) {
+      return;
+    }
+    const key = options?.key;
+    const plankPositioning = options?.positioning ?? "start";
+    const pivotId = options?.pivotId;
+    if (key) {
+      const index = draft.findIndex((id) => id.split("+")[0] === key);
+      if (index !== -1) {
+        draft.splice(index, 1, entryId);
+        return;
+      }
+    }
+    if (pivotId) {
+      const pivotIndex = draft.findIndex((id) => id === pivotId);
+      if (pivotIndex !== -1) {
+        if (plankPositioning === "start") {
+          draft.splice(pivotIndex, 0, entryId);
+        } else {
+          draft.splice(pivotIndex + 1, 0, entryId);
+        }
+        return;
+      }
+    }
+    if (plankPositioning === "start") {
+      draft.unshift(entryId);
+    } else {
+      draft.push(entryId);
+    }
+  });
+};
+var closeEntry = (deck, entryId) => {
+  return produce(deck, (draft) => {
+    const index = draft.findIndex((id) => id === entryId);
+    if (index !== -1) {
+      draft.splice(index, 1);
+    }
+  });
+};
+var incrementPlank = (deck, adjustment) => {
+  return produce(deck, (draft) => {
+    const index = draft.findIndex((id) => id === adjustment.id);
+    if (index === -1 || adjustment.type === "increment-start" && index === 0 || adjustment.type === "increment-end" && index === draft.length - 1) {
+      return;
+    }
+    if (adjustment.type === "increment-start") {
+      [draft[index - 1], draft[index]] = [
+        draft[index],
+        draft[index - 1]
+      ];
+    } else if (adjustment.type === "increment-end") {
+      [draft[index], draft[index + 1]] = [
+        draft[index + 1],
+        draft[index]
+      ];
+    }
+  });
+};
+
+// src/capabilities/operation-resolver/operation-resolver.ts
 var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-deck/src/capabilities/operation-resolver/operation-resolver.ts";
 var updateActiveDeck = (current, deckUpdates) => {
   const currentDeck = current.decks[current.activeDeck];
   invariant(currentDeck, `Deck not found: ${current.activeDeck}`, {
     F: __dxlog_file,
-    L: 40,
+    L: 41,
     S: void 0,
     A: [
       "currentDeck",
@@ -54,18 +118,18 @@ var updateActiveDeck = (current, deckUpdates) => {
   };
 };
 var operation_resolver_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,
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => ({
+            ...state2,
             sidebarState: next
           }));
         }
@@ -75,17 +139,17 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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, (state2) => ({
+            ...state2,
+            complementarySidebarPanel: panelChanged ? input.subject : state2.complementarySidebarPanel,
+            complementarySidebarState: stateChanged ? next : state2.complementarySidebarState
           }));
         }
       })
@@ -94,10 +158,10 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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",
@@ -114,13 +178,14 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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 : void 0,
+          popoverContentRef: input.subjectRef,
           popoverContent: typeof input.subject === "string" ? {
             component: input.subject,
             props: input.props
@@ -128,8 +193,8 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
             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
         }));
       })
     }),
@@ -137,12 +202,12 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // AddToast
     //
     OperationResolver.make({
-      operation: Common.LayoutOperation.AddToast,
+      operation: LayoutOperation.AddToast,
       handler: Effect.fnUntraced(function* (input) {
-        yield* Common.Capability.updateAtomValue(DeckCapabilities.EphemeralState, (s) => ({
-          ...s,
+        yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+          ...state,
           toasts: [
-            ...s.toasts,
+            ...state.toasts,
             input
           ]
         }));
@@ -152,12 +217,12 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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()}`;
-        yield* Common.Capability.updateAtomValue(DeckCapabilities.EphemeralState, (s) => {
-          const filteredToasts = s.currentUndoId ? s.toasts.filter((toast2) => toast2.id !== s.currentUndoId) : s.toasts;
+        yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => {
+          const filteredToasts = state.currentUndoId ? state.toasts.filter((toast2) => toast2.id !== state.currentUndoId) : state.toasts;
           const toast = {
             id: newUndoId,
             title: input.message ?? [
@@ -188,7 +253,7 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
             onAction: () => historyTracker.undoPromise()
           };
           return {
-            ...s,
+            ...state,
             currentUndoId: newUndoId,
             toasts: [
               ...filteredToasts,
@@ -202,7 +267,7 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // SetLayoutMode
     //
     OperationResolver.make({
-      operation: Common.LayoutOperation.SetLayoutMode,
+      operation: LayoutOperation.SetLayoutMode,
       filter: (input) => {
         if ("mode" in input) {
           return isLayoutMode(input.mode);
@@ -210,7 +275,7 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
         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, subject) => {
           const current = deck.solo ? [
@@ -245,24 +310,24 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
         if ("mode" in input) {
           const currentMode = getMode(deck);
           const deckUpdates = computeModeUpdate(input.mode, "subject" in input ? input.subject : void 0);
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => {
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => {
             const newPreviousMode = currentMode !== input.mode ? {
-              ...s.previousMode,
-              [s.activeDeck]: currentMode
-            } : s.previousMode;
+              ...state2.previousMode,
+              [state2.activeDeck]: currentMode
+            } : state2.previousMode;
             return {
-              ...updateActiveDeck(s, deckUpdates),
+              ...updateActiveDeck(state2, 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, (state2) => updateActiveDeck(state2, deckUpdates));
         } else {
           log.warn("Invalid layout mode", input, {
             F: __dxlog_file,
-            L: 244,
+            L: 258,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -273,33 +338,33 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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 shouldUpdatePrevious = !state.activeDeck.startsWith("!");
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => {
-            const newDecks = s.decks[input.subject] ? s.decks : {
-              ...s.decks,
+          const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+          const shouldUpdatePrevious = !isPinnedWorkspace(state.activeDeck);
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => {
+            const newDecks = state2.decks[input.subject] ? state2.decks : {
+              ...state2.decks,
               [input.subject]: {
                 ...defaultDeck
               }
             };
             return {
-              ...s,
-              previousDeck: shouldUpdatePrevious ? s.activeDeck : s.previousDeck,
+              ...state2,
+              previousDeck: shouldUpdatePrevious ? state2.activeDeck : state2.previousDeck,
               activeDeck: input.subject,
               decks: newDecks
             };
           });
         }
         {
-          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}`, {
             F: __dxlog_file,
-            L: 277,
+            L: 293,
             S: this,
             A: [
               "deck",
@@ -308,13 +373,13 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
           });
           const first = deck.solo ? deck.solo : deck.active[0];
           if (first) {
-            yield* Operation.schedule(Common.LayoutOperation.ScrollIntoView, {
+            yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
               subject: first
             });
           } else {
-            const [item] = Graph.getConnections(graph, input.subject).filter((node) => !Node.isActionLike(node) && !node.properties.disposition);
+            const [item] = Graph.getConnections(graph, input.subject, "child").filter((node) => !Node.isActionLike(node) && !node.properties.disposition);
             if (item) {
-              yield* Operation.schedule(Common.LayoutOperation.Open, {
+              yield* Operation.schedule(LayoutOperation.Open, {
                 subject: [
                   item.id
                 ]
@@ -328,10 +393,10 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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, {
+        const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+        yield* Operation.invoke(LayoutOperation.SwitchWorkspace, {
           subject: state.previousDeck
         });
       })
@@ -340,15 +405,15 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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, {
+            yield* Operation.invoke(LayoutOperation.SwitchWorkspace, {
               subject: input.workspace
             });
           }
@@ -359,18 +424,19 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
           previouslyOpenIds = new Set(deck.solo ? [
             deck.solo
           ] : deck.active);
-          const next = deck.solo ? input.subject.map((id) => createEntryId(id, input.variant)) : input.subject.reduce((acc, entryId) => openEntry(acc, entryId, {
+          const next = deck.solo ? [
+            ...input.subject
+          ] : input.subject.reduce((acc, entryId) => openEntry(acc, entryId, {
             key: input.key,
             positioning: input.positioning ?? settings?.newPlankPositioning,
-            pivotId: input.pivotId,
-            variant: input.variant
+            pivotId: input.pivotId
           }), deck.active);
           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));
         }
         {
           const deck = yield* DeckCapabilities.getDeck();
@@ -379,12 +445,12 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
           ] : deck.active;
           const newlyOpen = ids.filter((i) => !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, {
+            yield* Operation.schedule(LayoutOperation.Expose, {
               subject: newlyOpen[0] ?? input.subject[0]
             });
           }
@@ -413,9 +479,9 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     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
           }
         }));
@@ -427,10 +493,10 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     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);
         let soloOperation;
         if (input.type === "increment-end" || input.type === "increment-start") {
           const next = incrementPlank(deck.active, input);
@@ -439,7 +505,7 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
             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")) {
           const entryId = input.id;
@@ -465,25 +531,24 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
           }
         }
         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, {
+          yield* Operation.invoke(LayoutOperation.SetLayoutMode, {
             mode: "deck"
           });
-          yield* Operation.invoke(Common.LayoutOperation.Open, {
+          yield* Operation.invoke(LayoutOperation.Open, {
             subject: [
               soloOperation.entryId
             ]
           });
         }
         if (input.type === "companion") {
-          const companion = Function.pipe(Graph.getNode(graph, input.id), Option.map((node) => Graph.getConnections(graph, 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()));
+          const companion = Function.pipe(Graph.getNode(graph, input.id), Option.map((node) => Graph.getConnections(graph, node.id, "child").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()));
           if (Option.isSome(companion)) {
             yield* Operation.invoke(DeckOperation.ChangeCompanion, {
-              primary: input.id,
               companion: companion.value.id
             });
           }
@@ -496,28 +561,15 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     OperationResolver.make({
       operation: DeckOperation.ChangeCompanion,
       handler: Effect.fnUntraced(function* (input) {
-        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, {
+            companionOpen: false
           }));
         } else {
-          const companion = input.companion;
-          invariant(companion !== input.primary, void 0, {
-            F: __dxlog_file,
-            L: 479,
-            S: this,
-            A: [
-              "companion !== input.primary",
-              ""
-            ]
-          });
-          yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => updateActiveDeck(s, {
-            activeCompanions: {
-              ...deck.activeCompanions,
-              [input.primary]: companion
-            }
+          const variant = getCompanionVariant(input.companion);
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, {
+            companionOpen: true,
+            companionVariant: variant
           }));
         }
       })
@@ -526,7 +578,7 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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);
@@ -539,17 +591,9 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
           deck,
           attention
         });
-        yield* Common.Capability.updateAtomValue(DeckCapabilities.State, (s) => updateActiveDeck(s, deckUpdates));
-        for (const id of input.subject) {
-          if (deck.activeCompanions && id in deck.activeCompanions) {
-            yield* Operation.invoke(DeckOperation.ChangeCompanion, {
-              primary: id,
-              companion: null
-            });
-          }
-        }
+        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
         if (toAttend) {
-          yield* Operation.schedule(Common.LayoutOperation.ScrollIntoView, {
+          yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
             subject: toAttend
           });
         }
@@ -559,7 +603,7 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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);
@@ -568,9 +612,9 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
           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, {
+          yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
             subject: toAttend
           });
         }
@@ -580,10 +624,10 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
     // 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
         }));
       })
@@ -593,4 +637,4 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
 export {
   operation_resolver_default as default
 };
-//# sourceMappingURL=operation-resolver-WUOE33ID.mjs.map
+//# sourceMappingURL=operation-resolver-GCMCCI7A.mjs.map