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

package/dist/lib/browser/{operation-resolver-CDYBLZJ4.mjs → operation-resolver-2TEGT4PG.mjs}

@@ -1,25 +1,24 @@
 import {
-  closeEntry,
-  computeActiveUpdates,
-  createEntryId,
-  incrementPlank,
-  openEntry
-} from "./chunk-NHABISX2.mjs";
+  computeActiveUpdates
+} from "./chunk-BJDEG7YZ.mjs";
 import {
   DeckCapabilities,
   DeckOperation,
   PLANK_COMPANION_TYPE,
   defaultDeck,
   getMode,
-  isLayoutMode,
+  isLayoutMode
+} from "./chunk-3P2FJVXC.mjs";
+import {
   meta
-} from "./chunk-ATFPDN6J.mjs";
+} from "./chunk-L3RYMAV7.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";
@@ -29,12 +28,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",
@@ -53,18 +117,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
           }));
         }
@@ -74,17 +138,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
           }));
         }
       })
@@ -93,10 +157,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",
@@ -113,13 +177,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
@@ -127,8 +192,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
         }));
       })
     }),
@@ -136,12 +201,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
           ]
         }));
@@ -151,12 +216,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 ?? [
@@ -187,7 +252,7 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
             onAction: () => historyTracker.undoPromise()
           };
           return {
-            ...s,
+            ...state,
             currentUndoId: newUndoId,
             toasts: [
               ...filteredToasts,
@@ -201,7 +266,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);
@@ -209,7 +274,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 ? [
@@ -244,24 +309,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)
           });
@@ -272,33 +337,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",
@@ -307,13 +372,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
                 ]
@@ -327,10 +392,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
         });
       })
@@ -339,15 +404,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
             });
           }
@@ -358,18 +423,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();
@@ -378,12 +444,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]
             });
           }
@@ -412,9 +478,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
           }
         }));
@@ -426,10 +492,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);
@@ -438,7 +504,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;
@@ -464,25 +530,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
             });
           }
@@ -495,28 +560,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
           }));
         }
       })
@@ -525,7 +577,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);
@@ -538,17 +590,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
           });
         }
@@ -558,7 +602,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);
@@ -567,9 +611,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
           });
         }
@@ -579,10 +623,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
         }));
       })
@@ -592,4 +636,4 @@ var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(functio
 export {
   operation_resolver_default as default
 };
-//# sourceMappingURL=operation-resolver-CDYBLZJ4.mjs.map
+//# sourceMappingURL=operation-resolver-2TEGT4PG.mjs.map