@dxos/plugin-deck 0.8.4-main.f5c0578 → 0.8.4-main.fcc0d83b33

package/dist/lib/node-esm/open-4B3P5XGS.mjs

@@ -0,0 +1,148 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  openSubjectsOnActiveDeck
+} from "./chunk-WGBUTT5K.mjs";
+import {
+  computeActiveUpdates
+} from "./chunk-KY7ZCANM.mjs";
+import {
+  updateActiveDeck
+} from "./chunk-SHSR2CYO.mjs";
+import {
+  DeckCapabilities
+} from "./chunk-FO7YDJZ3.mjs";
+import "./chunk-HSLMI22Q.mjs";
+
+// src/operations/open.ts
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { AppCapabilities, LayoutOperation, createEdgeExistenceChecker, expandPath, validateNavigationTarget } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { Context } from "@dxos/context";
+import { Obj } from "@dxos/echo";
+import { AttentionCapabilities } from "@dxos/plugin-attention/types";
+import { ClientCapabilities } from "@dxos/plugin-client/types";
+import { Graph } from "@dxos/plugin-graph";
+import { ObservabilityOperation } from "@dxos/plugin-observability/operations";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-deck/src/operations/open.ts";
+var handler = LayoutOperation.Open.pipe(Operation.withHandler(Effect.fnUntraced(function* (input) {
+  const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+  const attention = yield* Capability.get(AttentionCapabilities.Attention);
+  const capabilities = yield* Capability.Service;
+  const pathResolvers = capabilities.getAll(AppCapabilities.NavigationPathResolver);
+  const checkRemoteExistence = yield* Capability.get(ClientCapabilities.Client).pipe(Effect.map((client) => createEdgeExistenceChecker((spaceId, body) => client.edge.http.execQuery(new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 25 }), spaceId, body))), Effect.catchAll(() => Effect.succeed(void 0)));
+  if (input.navigation === "immediate") {
+    for (const subjectId of input.subject) {
+      expandPath(graph, subjectId);
+    }
+  }
+  const validatedSubjects = yield* Effect.all(input.subject.map((subjectId) => input.navigation === "immediate" ? Effect.succeed(subjectId) : validateNavigationTarget({
+    graph,
+    subjectId,
+    pathResolvers,
+    checkRemoteExistence
+  })));
+  input = {
+    ...input,
+    subject: validatedSubjects
+  };
+  {
+    const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+    if (input.workspace && state.activeDeck !== input.workspace) {
+      yield* Operation.invoke(LayoutOperation.SwitchWorkspace, {
+        subject: input.workspace
+      });
+    }
+  }
+  {
+    const deck = yield* DeckCapabilities.getDeck();
+    const active = !deck.solo && deck.initialized ? deck.active : [];
+    if (active.length > 0 && input.subject.length > 0) {
+      const resolveDxn = (qualifiedPath) => Effect.reduce(pathResolvers, Option.none(), (acc, resolver) => Option.isSome(acc) ? Effect.succeed(acc) : resolver(qualifiedPath).pipe(Effect.map((opt) => Option.map(opt, (dxn) => dxn.toString())), Effect.catchAll(() => Effect.succeed(Option.none()))));
+      const deckDxnMap = /* @__PURE__ */ new Map();
+      yield* Effect.all(active.map((deckId) => resolveDxn(deckId).pipe(Effect.map((opt) => {
+        if (Option.isSome(opt)) {
+          deckDxnMap.set(opt.value, deckId);
+        }
+      }))), {
+        concurrency: "unbounded"
+      });
+      if (deckDxnMap.size > 0) {
+        const remapped = yield* Effect.all(input.subject.map((subjectId) => resolveDxn(subjectId).pipe(Effect.map((opt) => {
+          if (Option.isSome(opt)) {
+            const existing = deckDxnMap.get(opt.value);
+            if (existing && existing !== subjectId) {
+              return existing;
+            }
+          }
+          return subjectId;
+        }))), {
+          concurrency: "unbounded"
+        });
+        input = {
+          ...input,
+          subject: remapped
+        };
+      }
+    }
+  }
+  let previouslyOpenIds;
+  {
+    const deck = yield* DeckCapabilities.getDeck();
+    previouslyOpenIds = new Set(deck.solo ? [
+      deck.solo
+    ] : deck.active);
+    const next = deck.solo || !deck.initialized ? [
+      ...input.subject
+    ] : openSubjectsOnActiveDeck(deck.active, input.subject, {
+      pivotId: input.pivotId,
+      key: input.key
+    });
+    const { deckUpdates, toAttend: _toAttend } = computeActiveUpdates({
+      next,
+      deck,
+      attention
+    });
+    yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
+  }
+  {
+    const deck = yield* DeckCapabilities.getDeck();
+    const ids = deck.solo ? [
+      deck.solo
+    ] : deck.active;
+    const newlyOpen = ids.filter((i) => !previouslyOpenIds.has(i));
+    if (input.scrollIntoView !== false && (newlyOpen[0] ?? input.subject[0])) {
+      yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
+        subject: newlyOpen[0] ?? input.subject[0]
+      });
+    }
+    if (newlyOpen[0] ?? input.subject[0]) {
+      yield* Operation.schedule(LayoutOperation.Expose, {
+        subject: newlyOpen[0] ?? input.subject[0]
+      });
+    }
+    for (const subjectId of newlyOpen) {
+      const typename = Option.match(Graph.getNode(graph, subjectId), {
+        onNone: () => void 0,
+        onSome: (node) => {
+          const active = node.data;
+          return Obj.isObject(active) ? Obj.getTypename(active) : void 0;
+        }
+      });
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+        name: "navigation.activate",
+        properties: {
+          subjectId,
+          typename
+        }
+      });
+    }
+  }
+  return validatedSubjects;
+})));
+var open_default = handler;
+export {
+  open_default as default
+};
+//# sourceMappingURL=open-4B3P5XGS.mjs.map

package/dist/lib/node-esm/open-4B3P5XGS.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/open.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport {\n  AppCapabilities,\n  LayoutOperation,\n  createEdgeExistenceChecker,\n  expandPath,\n  validateNavigationTarget,\n} from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\nimport { Context } from '@dxos/context';\nimport { Obj } from '@dxos/echo';\nimport { AttentionCapabilities } from '@dxos/plugin-attention/types';\nimport { ClientCapabilities } from '@dxos/plugin-client/types';\nimport { Graph } from '@dxos/plugin-graph';\nimport { ObservabilityOperation } from '@dxos/plugin-observability/operations';\n\nimport { openSubjectsOnActiveDeck } from '../layout';\nimport { DeckCapabilities } from '../types';\nimport { computeActiveUpdates } from '../util';\nimport { updateActiveDeck } from './helpers';\n\nconst handler: Operation.WithHandler<typeof LayoutOperation.Open> = LayoutOperation.Open.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* (input) {\n      const { graph } = yield* Capability.get(AppCapabilities.AppGraph);\n      const attention = yield* Capability.get(AttentionCapabilities.Attention);\n\n      // Validate navigation targets, redirecting to 404 if not found.\n      const capabilities = yield* Capability.Service;\n      const pathResolvers = capabilities.getAll(AppCapabilities.NavigationPathResolver);\n      const checkRemoteExistence = yield* Capability.get(ClientCapabilities.Client).pipe(\n        Effect.map((client) =>\n          createEdgeExistenceChecker((spaceId, body) => client.edge.http.execQuery(new Context(), spaceId, body)),\n        ),\n        Effect.catchAll(() => Effect.succeed(undefined)),\n      );\n\n      // Immediate: skip 404 / resolver checks but still expand the path (same as validate’s first step).\n      if (input.navigation === 'immediate') {\n        for (const subjectId of input.subject) {\n          expandPath(graph, subjectId);\n        }\n      }\n\n      const validatedSubjects = yield* Effect.all(\n        input.subject.map((subjectId) =>\n          input.navigation === 'immediate'\n            ? Effect.succeed(subjectId)\n            : validateNavigationTarget({ graph, subjectId, pathResolvers, checkRemoteExistence }),\n        ),\n      );\n      input = { ...input, subject: validatedSubjects };\n\n      {\n        const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);\n        if (input.workspace && state.activeDeck !== input.workspace) {\n          yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: input.workspace });\n        }\n      }\n\n      // Dedup subjects against the active deck using DXN identity.\n      // The same object can appear under different graph paths (e.g., via collections vs types).\n      // Resolve each subject's DXN and, if it matches an already-open deck item, remap the\n      // subject to the existing deck entry so that openEntry's exact-match check succeeds.\n      // Only needed in multi (deck) mode; solo mode replaces the single visible item anyway.\n      {\n        const deck = yield* DeckCapabilities.getDeck();\n        const active = !deck.solo && deck.initialized ? deck.active : [];\n        if (active.length > 0 && input.subject.length > 0) {\n          const resolveDxn = (qualifiedPath: string) =>\n            Effect.reduce(pathResolvers, Option.none<string>(), (acc, resolver) =>\n              Option.isSome(acc)\n                ? Effect.succeed(acc)\n                : resolver(qualifiedPath).pipe(\n                    Effect.map((opt) => Option.map(opt, (dxn) => dxn.toString())),\n                    Effect.catchAll(() => Effect.succeed(Option.none<string>())),\n                  ),\n            );\n\n          // Build DXN → deck item ID map for active items.\n          const deckDxnMap = new Map<string, string>();\n          yield* Effect.all(\n            active.map((deckId) =>\n              resolveDxn(deckId).pipe(\n                Effect.map((opt) => {\n                  if (Option.isSome(opt)) {\n                    deckDxnMap.set(opt.value, deckId);\n                  }\n                }),\n              ),\n            ),\n            { concurrency: 'unbounded' },\n          );\n\n          // Remap subjects whose DXN matches an existing deck item.\n          if (deckDxnMap.size > 0) {\n            const remapped = yield* Effect.all(\n              input.subject.map((subjectId) =>\n                resolveDxn(subjectId).pipe(\n                  Effect.map((opt) => {\n                    if (Option.isSome(opt)) {\n                      const existing = deckDxnMap.get(opt.value);\n                      if (existing && existing !== subjectId) {\n                        return existing;\n                      }\n                    }\n                    return subjectId;\n                  }),\n                ),\n              ),\n              { concurrency: 'unbounded' },\n            );\n            input = { ...input, subject: remapped };\n          }\n        }\n      }\n\n      // Compute the next active deck state and apply it.\n      // In solo or uninitialized mode the subject list replaces the deck entirely.\n      // In multi (deck) mode, subjects are merged via openSubjectsOnActiveDeck which\n      // uses stack semantics (truncate after pivot, then push new entries).\n      let previouslyOpenIds: Set<string>;\n      {\n        const deck = yield* DeckCapabilities.getDeck();\n        previouslyOpenIds = new Set<string>(deck.solo ? [deck.solo] : deck.active);\n        const next =\n          deck.solo || !deck.initialized\n            ? [...input.subject]\n            : openSubjectsOnActiveDeck(deck.active, input.subject, {\n                pivotId: input.pivotId,\n                key: input.key,\n              });\n\n        const { deckUpdates, toAttend: _toAttend } = computeActiveUpdates({ next, deck, attention });\n        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));\n      }\n\n      // Schedule side-effects for the newly opened items: scroll into view, expose in\n      // the navigation sidebar, and emit observability events.\n      // When nothing is newly opened (subject was already visible), the fallback\n      // `input.subject[0]` still triggers scroll and expose so the user is taken there.\n      {\n        const deck = yield* DeckCapabilities.getDeck();\n        const ids = deck.solo ? [deck.solo] : deck.active;\n        const newlyOpen = ids.filter((i: string) => !previouslyOpenIds.has(i));\n\n        if (input.scrollIntoView !== false && (newlyOpen[0] ?? input.subject[0])) {\n          yield* Operation.schedule(LayoutOperation.ScrollIntoView, {\n            subject: newlyOpen[0] ?? input.subject[0],\n          });\n        }\n\n        if (newlyOpen[0] ?? input.subject[0]) {\n          yield* Operation.schedule(LayoutOperation.Expose, { subject: newlyOpen[0] ?? input.subject[0] });\n        }\n\n        for (const subjectId of newlyOpen) {\n          const typename = Option.match(Graph.getNode(graph, subjectId), {\n            onNone: () => undefined,\n            onSome: (node) => {\n              const active = node.data;\n              return Obj.isObject(active) ? Obj.getTypename(active) : undefined;\n            },\n          });\n          yield* Operation.schedule(ObservabilityOperation.SendEvent, {\n            name: 'navigation.activate',\n            properties: { subjectId, typename },\n          });\n        }\n      }\n\n      return validatedSubjects;\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": "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",
+  "names": ["Effect", "Option", "Capabilities", "Capability", "AppCapabilities", "LayoutOperation", "createEdgeExistenceChecker", "expandPath", "validateNavigationTarget", "Operation", "Context", "Obj", "AttentionCapabilities", "ClientCapabilities", "Graph", "ObservabilityOperation", "LayoutOperation", "attention", "Capability", "get", "AttentionCapabilities", "Attention", "capabilities", "Service", "checkRemoteExistence", "input", "expandPath", "graph", "subjectId", "pathResolvers", "subject", "Operation", "invoke", "SwitchWorkspace", "workspace", "active", "length", "resolveDxn", "qualifiedPath", "reduce", "deckDxnMap", "Map", "isSome", "opt", "set", "deckId", "concurrency", "Option", "value", "existing", "deck", "next", "openSubjectsOnActiveDeck", "pivotId", "key", "deckUpdates", "newlyOpen", "schedule", "ScrollIntoView", "onNone", "undefined", "onSome", "node", "isObject", "properties", "typename"]
+}

package/dist/lib/node-esm/operations/index.mjs

@@ -0,0 +1,14 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  definitions_exports
+} from "../chunk-L7OVX7CV.mjs";
+import "../chunk-HSLMI22Q.mjs";
+
+// src/operations/index.ts
+import { OperationHandlerSet } from "@dxos/compute";
+var DeckOperationHandlerSet = OperationHandlerSet.lazy(() => import("../add-toast-JUTN4GTI.mjs"), () => import("../adjust-P5QK33P4.mjs"), () => import("../close-U5VC7ERP.mjs"), () => import("../open-4B3P5XGS.mjs"), () => import("../revert-workspace-QD63M2U7.mjs"), () => import("../scroll-into-view-G5M2EWK7.mjs"), () => import("../set-ERJCXZBY.mjs"), () => import("../set-layout-mode-BOZD7744.mjs"), () => import("../show-undo-H5BRBYDC.mjs"), () => import("../switch-workspace-F54PXE5N.mjs"), () => import("../update-companion-47LMKL5R.mjs"), () => import("../update-complementary-7VYYG7L2.mjs"), () => import("../update-dialog-CABL7OWW.mjs"), () => import("../update-plank-size-WYTSMZF2.mjs"), () => import("../update-popover-YZDYGL7G.mjs"), () => import("../update-sidebar-HV736LUN.mjs"));
+export {
+  definitions_exports as DeckOperation,
+  DeckOperationHandlerSet
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/node-esm/operations/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/operations/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { OperationHandlerSet } from '@dxos/compute';\n\nexport * as DeckOperation from './definitions';\n\nexport const DeckOperationHandlerSet = OperationHandlerSet.lazy(\n  () => import('./add-toast'),\n  () => import('./adjust'),\n  () => import('./close'),\n  () => import('./open'),\n  () => import('./revert-workspace'),\n  () => import('./scroll-into-view'),\n  () => import('./set'),\n  () => import('./set-layout-mode'),\n  () => import('./show-undo'),\n  () => import('./switch-workspace'),\n  () => import('./update-companion'),\n  () => import('./update-complementary'),\n  () => import('./update-dialog'),\n  () => import('./update-plank-size'),\n  () => import('./update-popover'),\n  () => import('./update-sidebar'),\n);\n"],
+  "mappings": ";;;;;;;AAIA,SAASA,2BAA2B;AAI7B,IAAMC,0BAA0BD,oBAAoBE,KACzD,MAAM,OAAO,2BAAA,GACb,MAAM,OAAO,wBAAA,GACb,MAAM,OAAO,uBAAA,GACb,MAAM,OAAO,sBAAA,GACb,MAAM,OAAO,kCAAA,GACb,MAAM,OAAO,kCAAA,GACb,MAAM,OAAO,qBAAA,GACb,MAAM,OAAO,iCAAA,GACb,MAAM,OAAO,2BAAA,GACb,MAAM,OAAO,kCAAA,GACb,MAAM,OAAO,kCAAA,GACb,MAAM,OAAO,sCAAA,GACb,MAAM,OAAO,+BAAA,GACb,MAAM,OAAO,mCAAA,GACb,MAAM,OAAO,gCAAA,GACb,MAAM,OAAO,gCAAA,CAAA;",
+  "names": ["OperationHandlerSet", "DeckOperationHandlerSet", "lazy"]
+}

package/dist/lib/node-esm/revert-workspace-QD63M2U7.mjs

@@ -0,0 +1,22 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  DeckCapabilities
+} from "./chunk-FO7YDJZ3.mjs";
+import "./chunk-HSLMI22Q.mjs";
+
+// src/operations/revert-workspace.ts
+import * as Effect from "effect/Effect";
+import { Capabilities } from "@dxos/app-framework";
+import { LayoutOperation } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+var handler = LayoutOperation.RevertWorkspace.pipe(Operation.withHandler(Effect.fnUntraced(function* () {
+  const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+  yield* Operation.invoke(LayoutOperation.SwitchWorkspace, {
+    subject: state.previousDeck
+  });
+})));
+var revert_workspace_default = handler;
+export {
+  revert_workspace_default as default
+};
+//# sourceMappingURL=revert-workspace-QD63M2U7.mjs.map

package/dist/lib/node-esm/revert-workspace-QD63M2U7.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/revert-workspace.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities } from '@dxos/app-framework';\nimport { LayoutOperation } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\n\nimport { DeckCapabilities } from '../types';\n\nconst handler: Operation.WithHandler<typeof LayoutOperation.RevertWorkspace> = LayoutOperation.RevertWorkspace.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* () {\n      const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);\n      yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: state.previousDeck });\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,oBAAoB;AAC7B,SAASC,uBAAuB;AAChC,SAASC,iBAAiB;AAI1B,IAAMC,UAAyEC,gBAAgBC,gBAAgBC,KAC7GC,UAAUC,YACDC,kBAAW,aAAA;AAChB,QAAMC,QAAQ,OAAOC,aAAaC,aAAaC,iBAAiBC,KAAK;AACrE,SAAOP,UAAUQ,OAAOX,gBAAgBY,iBAAiB;IAAEC,SAASP,MAAMQ;EAAa,CAAA;AACzF,CAAA,CAAA,CAAA;AAIJ,IAAA,2BAAef;",
+  "names": ["Effect", "Capabilities", "LayoutOperation", "Operation", "handler", "LayoutOperation", "RevertWorkspace", "pipe", "Operation", "withHandler", "fnUntraced", "state", "Capabilities", "getAtomValue", "DeckCapabilities", "State", "invoke", "SwitchWorkspace", "subject", "previousDeck"]
+}

package/dist/lib/node-esm/scroll-into-view-G5M2EWK7.mjs

@@ -0,0 +1,22 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  DeckCapabilities
+} from "./chunk-FO7YDJZ3.mjs";
+import "./chunk-HSLMI22Q.mjs";
+
+// src/operations/scroll-into-view.ts
+import * as Effect from "effect/Effect";
+import { Capabilities } from "@dxos/app-framework";
+import { LayoutOperation } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+var handler = LayoutOperation.ScrollIntoView.pipe(Operation.withHandler(Effect.fnUntraced(function* (input) {
+  yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+    ...state,
+    scrollIntoView: input.subject
+  }));
+})));
+var scroll_into_view_default = handler;
+export {
+  scroll_into_view_default as default
+};
+//# sourceMappingURL=scroll-into-view-G5M2EWK7.mjs.map

package/dist/lib/node-esm/scroll-into-view-G5M2EWK7.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/scroll-into-view.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities } from '@dxos/app-framework';\nimport { LayoutOperation } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\n\nimport { DeckCapabilities } from '../types';\n\nconst handler: Operation.WithHandler<typeof LayoutOperation.ScrollIntoView> = LayoutOperation.ScrollIntoView.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* (input) {\n      yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({\n        ...state,\n        scrollIntoView: input.subject,\n      }));\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,oBAAoB;AAC7B,SAASC,uBAAuB;AAChC,SAASC,iBAAiB;AAI1B,IAAMC,UAAwEC,gBAAgBC,eAAeC,KAC3GC,UAAUC,YACDC,kBAAW,WAAWC,OAAK;AAChC,SAAOC,aAAaC,gBAAgBC,iBAAiBC,gBAAgB,CAACC,WAAW;IAC/E,GAAGA;IACHC,gBAAgBN,MAAMO;EACxB,EAAA;AACF,CAAA,CAAA,CAAA;AAIJ,IAAA,2BAAed;",
+  "names": ["Effect", "Capabilities", "LayoutOperation", "Operation", "handler", "LayoutOperation", "ScrollIntoView", "pipe", "Operation", "withHandler", "fnUntraced", "input", "Capabilities", "updateAtomValue", "DeckCapabilities", "EphemeralState", "state", "scrollIntoView", "subject"]
+}

package/dist/lib/node-esm/set-ERJCXZBY.mjs

@@ -0,0 +1,38 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  computeActiveUpdates
+} from "./chunk-KY7ZCANM.mjs";
+import {
+  updateActiveDeck
+} from "./chunk-SHSR2CYO.mjs";
+import {
+  DeckCapabilities
+} from "./chunk-FO7YDJZ3.mjs";
+import "./chunk-HSLMI22Q.mjs";
+
+// src/operations/set.ts
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { LayoutOperation } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { AttentionCapabilities } from "@dxos/plugin-attention/types";
+var handler = LayoutOperation.Set.pipe(Operation.withHandler(Effect.fnUntraced(function* (input) {
+  const deck = yield* DeckCapabilities.getDeck();
+  const attention = yield* Capability.get(AttentionCapabilities.Attention);
+  const { deckUpdates, toAttend } = computeActiveUpdates({
+    next: input.subject,
+    deck,
+    attention
+  });
+  yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
+  if (toAttend) {
+    yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
+      subject: toAttend
+    });
+  }
+})));
+var set_default = handler;
+export {
+  set_default as default
+};
+//# sourceMappingURL=set-ERJCXZBY.mjs.map

package/dist/lib/node-esm/set-ERJCXZBY.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/set.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { LayoutOperation } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\nimport { AttentionCapabilities } from '@dxos/plugin-attention/types';\n\nimport { DeckCapabilities } from '../types';\nimport { computeActiveUpdates } from '../util';\nimport { updateActiveDeck } from './helpers';\n\nconst handler: Operation.WithHandler<typeof LayoutOperation.Set> = LayoutOperation.Set.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* (input) {\n      const deck = yield* DeckCapabilities.getDeck();\n      const attention = yield* Capability.get(AttentionCapabilities.Attention);\n\n      const { deckUpdates, toAttend } = computeActiveUpdates({\n        next: input.subject as string[],\n        deck,\n        attention,\n      });\n      yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));\n\n      if (toAttend) {\n        yield* Operation.schedule(LayoutOperation.ScrollIntoView, { subject: toAttend });\n      }\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,cAAcC,kBAAkB;AACzC,SAASC,uBAAuB;AAChC,SAASC,iBAAiB;AAC1B,SAASC,6BAA6B;AAMtC,IAAMC,UAA6DC,gBAAgBC,IAAIC,KACrFC,UAAUC,YACDC,kBAAW,WAAWC,OAAK;AAChC,QAAMC,OAAO,OAAOC,iBAAiBC,QAAO;AAC5C,QAAMC,YAAY,OAAOC,WAAWC,IAAIC,sBAAsBC,SAAS;AAEvE,QAAM,EAAEC,aAAaC,SAAQ,IAAKC,qBAAqB;IACrDC,MAAMZ,MAAMa;IACZZ;IACAG;EACF,CAAA;AACA,SAAOU,aAAaC,gBAAgBb,iBAAiBc,OAAO,CAACC,UAAUC,iBAAiBD,OAAOR,WAAAA,CAAAA;AAE/F,MAAIC,UAAU;AACZ,WAAOb,UAAUsB,SAASzB,gBAAgB0B,gBAAgB;MAAEP,SAASH;IAAS,CAAA;EAChF;AACF,CAAA,CAAA,CAAA;AAIJ,IAAA,cAAejB;",
+  "names": ["Effect", "Capabilities", "Capability", "LayoutOperation", "Operation", "AttentionCapabilities", "handler", "LayoutOperation", "Set", "pipe", "Operation", "withHandler", "fnUntraced", "input", "deck", "DeckCapabilities", "getDeck", "attention", "Capability", "get", "AttentionCapabilities", "Attention", "deckUpdates", "toAttend", "computeActiveUpdates", "next", "subject", "Capabilities", "updateAtomValue", "State", "state", "updateActiveDeck", "schedule", "ScrollIntoView"]
+}

package/dist/lib/node-esm/set-layout-mode-BOZD7744.mjs

@@ -0,0 +1,86 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  updateActiveDeck
+} from "./chunk-SHSR2CYO.mjs";
+import {
+  DeckCapabilities,
+  getMode,
+  isLayoutMode
+} from "./chunk-FO7YDJZ3.mjs";
+import "./chunk-HSLMI22Q.mjs";
+
+// src/operations/set-layout-mode.ts
+import * as Effect from "effect/Effect";
+import { Capabilities } from "@dxos/app-framework";
+import { LayoutOperation } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { log } from "@dxos/log";
+import { isNonNullable } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-deck/src/operations/set-layout-mode.ts";
+var handler = LayoutOperation.SetLayoutMode.pipe(Operation.withHandler(Effect.fnUntraced(function* (input) {
+  if ("mode" in input && !isLayoutMode(input.mode)) {
+    return;
+  }
+  const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+  const deck = yield* DeckCapabilities.getDeck();
+  const computeModeUpdate = (mode, subject) => {
+    const current = deck.solo ? [
+      deck.solo
+    ] : deck.active;
+    const next = (mode !== "multi" ? [
+      subject ?? deck.solo ?? deck.active[0]
+    ] : [
+      ...deck.active,
+      deck.solo
+    ]).filter(isNonNullable);
+    const removed = current.filter((id) => !next.includes(id));
+    const closed = Array.from(/* @__PURE__ */ new Set([
+      ...deck.inactive.filter((id) => !next.includes(id)),
+      ...removed
+    ]));
+    const soloUpdate = mode !== "multi" && next[0] ? {
+      solo: next[0]
+    } : mode === "multi" && deck.solo ? {
+      solo: void 0,
+      initialized: true
+    } : {};
+    const fullscreenUpdate = mode === "solo--fullscreen" ? {
+      fullscreen: !deck.fullscreen
+    } : {};
+    return {
+      inactive: closed,
+      ...soloUpdate,
+      ...fullscreenUpdate
+    };
+  };
+  if ("mode" in input) {
+    const currentMode = getMode(deck);
+    const subject = "subject" in input ? input.subject : void 0;
+    const deckUpdates = computeModeUpdate(input.mode, subject);
+    yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => {
+      const newPreviousMode = currentMode !== input.mode ? {
+        ...state2.previousMode,
+        [state2.activeDeck]: currentMode
+      } : state2.previousMode;
+      return {
+        ...updateActiveDeck(state2, deckUpdates),
+        previousMode: newPreviousMode
+      };
+    });
+    if (subject) {
+      yield* Operation.schedule(LayoutOperation.Expose, {
+        subject
+      });
+    }
+  } else if ("revert" in input) {
+    const deckUpdates = computeModeUpdate(state.previousMode[state.activeDeck]);
+    yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => updateActiveDeck(state2, deckUpdates));
+  } else {
+    log.warn("Invalid layout mode", input, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 74, S: this });
+  }
+})));
+var set_layout_mode_default = handler;
+export {
+  set_layout_mode_default as default
+};
+//# sourceMappingURL=set-layout-mode-BOZD7744.mjs.map

package/dist/lib/node-esm/set-layout-mode-BOZD7744.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/set-layout-mode.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities } from '@dxos/app-framework';\nimport { LayoutOperation } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\nimport { log } from '@dxos/log';\nimport { isNonNullable } from '@dxos/util';\n\nimport { DeckCapabilities, type DeckState, type LayoutMode, getMode, isLayoutMode } from '../types';\nimport { updateActiveDeck } from './helpers';\n\n/**\n * Transitions between layout modes (multi, solo, solo--fullscreen) or reverts to the previous mode.\n * Computes which planks become active/inactive and persists the previous mode for revert support.\n */\nconst handler: Operation.WithHandler<typeof LayoutOperation.SetLayoutMode> = LayoutOperation.SetLayoutMode.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* (input) {\n      if ('mode' in input && !isLayoutMode(input.mode)) {\n        return;\n      }\n\n      const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);\n      const deck = yield* DeckCapabilities.getDeck();\n\n      const computeModeUpdate = (mode: LayoutMode, subject?: string): Partial<DeckState> => {\n        const current = deck.solo ? [deck.solo] : deck.active;\n        const next = (mode !== 'multi' ? [subject ?? deck.solo ?? deck.active[0]] : [...deck.active, deck.solo]).filter(\n          isNonNullable,\n        );\n\n        const removed = current.filter((id: string) => !next.includes(id));\n        const closed = Array.from(new Set([...deck.inactive.filter((id: string) => !next.includes(id)), ...removed]));\n\n        const soloUpdate =\n          mode !== 'multi' && next[0]\n            ? { solo: next[0] }\n            : mode === 'multi' && deck.solo\n              ? { solo: undefined, initialized: true }\n              : {};\n\n        const fullscreenUpdate = mode === 'solo--fullscreen' ? { fullscreen: !deck.fullscreen } : {};\n\n        return {\n          inactive: closed,\n          ...soloUpdate,\n          ...fullscreenUpdate,\n        };\n      };\n\n      if ('mode' in input) {\n        const currentMode = getMode(deck);\n        const subject = 'subject' in input ? input.subject : undefined;\n        const deckUpdates = computeModeUpdate(input.mode as LayoutMode, subject);\n\n        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => {\n          const newPreviousMode =\n            currentMode !== input.mode\n              ? { ...state.previousMode, [state.activeDeck]: currentMode }\n              : state.previousMode;\n          return {\n            ...updateActiveDeck(state, deckUpdates),\n            previousMode: newPreviousMode,\n          };\n        });\n\n        if (subject) {\n          yield* Operation.schedule(LayoutOperation.Expose, { subject });\n        }\n      } else if ('revert' in input) {\n        const deckUpdates = computeModeUpdate(state.previousMode[state.activeDeck]);\n        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));\n      } else {\n        log.warn('Invalid layout mode', input);\n      }\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,oBAAoB;AAC7B,SAASC,uBAAuB;AAChC,SAASC,iBAAiB;AAC1B,SAASC,WAAW;AACpB,SAASC,qBAAqB;AAK9B,IAAA,eAAA;IAQQ,UAAA,gBAAA,cAAA,KAAA,UAAA,YAAA,kBAAA,WAAA,OAAA;AACF,MAAA,UAAA,SAAA,CAAA,aAAA,MAAA,IAAA,GAAA;AAEA;EACA;AAEA,QAAMC,QAAAA,OAAAA,aAAuCC,aAAAA,iBAAAA,KAAAA;QAC3C,OAAMC,OAAUC,iBAAY,QAAA;4BAAU,CAAA,MAAA,YAAA;UAAIA,UAAW,KAAA,OAAA;MACrD,KAAMC;QAA4BH,KAAAA;UAA0C,QAAA,SAAA,UAAA;iBAASI,KAAM,QAAA,KAAA,OAAA,CAAA;QAAEF;MAAYG,GAAAA,KACvGC;MAGF,KAAMC;IACN,GAAA,OAAMC,aAAeC;oBAAsBC,QAASL,OAAQM,CAAAA,OAAgBR,CAAAA,KAAKS,SAASD,EAAAA,CAAAA;mBAASJ,MAAAA,KAAAA,oBAAAA,IAAAA;MAAQ,GAAA,KAAA,SAAA,OAAA,CAAA,OAAA,CAAA,KAAA,SAAA,EAAA,CAAA;MAE3G,GAAMM;;AAEgB,UAChBC,aAAS,SAAWZ,WAClB,KAAA,CAAA,IAAA;MAAEa,MAAMC,KAAAA,CAAAA;QAAWC,SAAAA,WAAa,KAAA,OAAA;MAChC,MAAC;MAET,aAAMC;QAAmDC,CAAAA;AAA6B,UAAK,mBAAA,SAAA,qBAAA;MAE3F,YAAO,CAAA,KAAA;QACLT,CAAAA;WACGG;MACH,UAAGK;MACL,GAAA;MACF,GAAA;IAEI;;MAEF,UAAMlB,OAAU;AAChB,UAAMoB,cAAcrB,QAAAA,IAAAA;AAEpB,UAAA,UAAOsB,aAAaC,QAAgBC,MAAAA,UAAiBC;UACnD,cAAMC,kBACJC,MAAgBC,MAAMb,OAClB;wBAAWc,gBAAY,iBAAA,OAAA,CAAAC,WAAA;YAAGA,kBAAmBH,gBAAAA,MAAAA,OAAAA;QAC7CG,GAAAA,OAAMD;QACZ,CAAAC,OAAO,UAAA,GAAA;UACLA,OAAGC;aACHF;QACF,GAAA,iBAAAC,QAAA,WAAA;QACF,cAAA;MAEI7B;;iBACkDA;AAAQ,aAAA,UAAA,SAAA,gBAAA,QAAA;QAC9D;MACK,CAAA;IACL;aACOqB,YAAAA,OAAaC;AACtB,UAAO,cAAA,kBAAA,MAAA,aAAA,MAAA,UAAA,CAAA;AACLS,WAAIC,aAAK,gBAAuBL,iBAAAA,OAAAA,CAAAA,WAAAA,iBAAAA,QAAAA,WAAAA,CAAAA;EAClC,OAAA;AACF,QAAA,KAAA,uBAAA,OAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,KAAA,CAAA;EAIJ;;;",
+  "names": ["Effect", "Capabilities", "LayoutOperation", "Operation", "log", "isNonNullable", "computeModeUpdate", "subject", "current", "deck", "next", "active", "filter", "isNonNullable", "removed", "closed", "from", "inactive", "id", "includes", "soloUpdate", "mode", "solo", "undefined", "initialized", "fullscreenUpdate", "fullscreen", "deckUpdates", "Capabilities", "updateAtomValue", "DeckCapabilities", "State", "newPreviousMode", "currentMode", "input", "previousMode", "state", "updateActiveDeck", "log", "warn"]
+}

package/dist/lib/node-esm/show-undo-H5BRBYDC.mjs

@@ -0,0 +1,60 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  DeckCapabilities
+} from "./chunk-FO7YDJZ3.mjs";
+import "./chunk-HSLMI22Q.mjs";
+
+// src/operations/show-undo.ts
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability, UndoOperation } from "@dxos/app-framework";
+import { Operation } from "@dxos/compute";
+import { meta } from "#meta";
+var handler = UndoOperation.ShowUndo.pipe(Operation.withHandler(Effect.fnUntraced(function* (input) {
+  const historyTracker = yield* Capability.get(Capabilities.HistoryTracker);
+  const newUndoId = `show-undo-${Date.now()}`;
+  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 ?? [
+        "undo-available.label",
+        {
+          ns: meta.id
+        }
+      ],
+      duration: 1e4,
+      actionLabel: [
+        "undo-action.label",
+        {
+          ns: meta.id
+        }
+      ],
+      actionAlt: [
+        "undo-action.alt",
+        {
+          ns: meta.id
+        }
+      ],
+      closeLabel: [
+        "undo-close.label",
+        {
+          ns: meta.id
+        }
+      ],
+      onAction: () => historyTracker.undoPromise()
+    };
+    return {
+      ...state,
+      currentUndoId: newUndoId,
+      toasts: [
+        ...filteredToasts,
+        toast
+      ]
+    };
+  });
+})));
+var show_undo_default = handler;
+export {
+  show_undo_default as default
+};
+//# sourceMappingURL=show-undo-H5BRBYDC.mjs.map

package/dist/lib/node-esm/show-undo-H5BRBYDC.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/show-undo.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability, UndoOperation } from '@dxos/app-framework';\nimport { LayoutOperation } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\n\nimport { meta } from '#meta';\n\nimport { DeckCapabilities } from '../types';\n\nconst handler: Operation.WithHandler<typeof UndoOperation.ShowUndo> = UndoOperation.ShowUndo.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* (input) {\n      const historyTracker = yield* Capability.get(Capabilities.HistoryTracker);\n\n      const newUndoId = `show-undo-${Date.now()}`;\n      // TODO(wittjosiah): Support undoing further back than the last action.\n      yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => {\n        const filteredToasts = state.currentUndoId\n          ? state.toasts.filter((toast) => toast.id !== state.currentUndoId)\n          : state.toasts;\n\n        const toast: LayoutOperation.Toast = {\n          id: newUndoId,\n          title: input.message ?? ['undo-available.label', { ns: meta.id }],\n          duration: 10_000,\n          actionLabel: ['undo-action.label', { ns: meta.id }],\n          actionAlt: ['undo-action.alt', { ns: meta.id }],\n          closeLabel: ['undo-close.label', { ns: meta.id }],\n          onAction: () => historyTracker.undoPromise(),\n        };\n\n        return {\n          ...state,\n          currentUndoId: newUndoId,\n          toasts: [...filteredToasts, toast],\n        };\n      });\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,cAAcC,YAAYC,qBAAqB;AAExD,SAASC,iBAAiB;AAE1B,SAASC,YAAY;AAIrB,IAAMC,UAAgEC,cAAcC,SAASC,KAC3FC,UAAUC,YACDC,kBAAW,WAAWC,OAAK;AAChC,QAAMC,iBAAiB,OAAOC,WAAWC,IAAIC,aAAaC,cAAc;AAExE,QAAMC,YAAY,aAAaC,KAAKC,IAAG,CAAA;AAEvC,SAAOJ,aAAaK,gBAAgBC,iBAAiBC,gBAAgB,CAACC,UAAAA;AACpE,UAAMC,iBAAiBD,MAAME,gBACzBF,MAAMG,OAAOC,OAAO,CAACC,WAAUA,OAAMC,OAAON,MAAME,aAAa,IAC/DF,MAAMG;AAEV,UAAME,QAA+B;MACnCC,IAAIZ;MACJa,OAAOnB,MAAMoB,WAAW;QAAC;QAAwB;UAAEC,IAAIC,KAAKJ;QAAG;;MAC/DK,UAAU;MACVC,aAAa;QAAC;QAAqB;UAAEH,IAAIC,KAAKJ;QAAG;;MACjDO,WAAW;QAAC;QAAmB;UAAEJ,IAAIC,KAAKJ;QAAG;;MAC7CQ,YAAY;QAAC;QAAoB;UAAEL,IAAIC,KAAKJ;QAAG;;MAC/CS,UAAU,MAAM1B,eAAe2B,YAAW;IAC5C;AAEA,WAAO;MACL,GAAGhB;MACHE,eAAeR;MACfS,QAAQ;WAAIF;QAAgBI;;IAC9B;EACF,CAAA;AACF,CAAA,CAAA,CAAA;AAIJ,IAAA,oBAAexB;",
+  "names": ["Effect", "Capabilities", "Capability", "UndoOperation", "Operation", "meta", "handler", "UndoOperation", "ShowUndo", "pipe", "Operation", "withHandler", "fnUntraced", "input", "historyTracker", "Capability", "get", "Capabilities", "HistoryTracker", "newUndoId", "Date", "now", "updateAtomValue", "DeckCapabilities", "EphemeralState", "state", "filteredToasts", "currentUndoId", "toasts", "filter", "toast", "id", "title", "message", "ns", "meta", "duration", "actionLabel", "actionAlt", "closeLabel", "onAction", "undoPromise"]
+}

package/dist/lib/node-esm/switch-workspace-F54PXE5N.mjs

@@ -0,0 +1,61 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  DeckCapabilities,
+  defaultDeck
+} from "./chunk-FO7YDJZ3.mjs";
+import "./chunk-HSLMI22Q.mjs";
+
+// src/operations/switch-workspace.ts
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { AppCapabilities, isPinnedWorkspace, LayoutOperation } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { invariant } from "@dxos/invariant";
+import { Graph, Node } from "@dxos/plugin-graph";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-deck/src/operations/switch-workspace.ts";
+var handler = LayoutOperation.SwitchWorkspace.pipe(Operation.withHandler(Effect.fnUntraced(function* (input) {
+  const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+  {
+    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 {
+        ...state2,
+        previousDeck: shouldUpdatePrevious ? state2.activeDeck : state2.previousDeck,
+        activeDeck: input.subject,
+        decks: newDecks
+      };
+    });
+  }
+  {
+    const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+    const deck = state.decks[input.subject];
+    invariant(deck, `Deck not found: ${input.subject}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 36, S: this, A: ["deck", "`Deck not found: ${input.subject}`"] });
+    const first = deck.solo ? deck.solo : deck.active[0];
+    if (first) {
+      yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
+        subject: first
+      });
+    } else {
+      const [item] = Graph.getConnections(graph, input.subject, "child").filter((node) => !Node.isActionLike(node) && !node.properties.disposition);
+      if (item) {
+        yield* Operation.schedule(LayoutOperation.Open, {
+          subject: [
+            item.id
+          ]
+        });
+      }
+    }
+  }
+})));
+var switch_workspace_default = handler;
+export {
+  switch_workspace_default as default
+};
+//# sourceMappingURL=switch-workspace-F54PXE5N.mjs.map

package/dist/lib/node-esm/switch-workspace-F54PXE5N.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/switch-workspace.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { AppCapabilities, isPinnedWorkspace, LayoutOperation } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\nimport { invariant } from '@dxos/invariant';\nimport { Graph, Node } from '@dxos/plugin-graph';\n\nimport { DeckCapabilities, defaultDeck } from '../types';\n\nconst handler: Operation.WithHandler<typeof LayoutOperation.SwitchWorkspace> = LayoutOperation.SwitchWorkspace.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* (input) {\n      const { graph } = yield* Capability.get(AppCapabilities.AppGraph);\n\n      {\n        const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);\n        // TODO(wittjosiah): This is a hack to prevent the previous deck from being set for pinned items.\n        //   Ideally this should be worked into the data model in a generic way.\n        const shouldUpdatePrevious = !isPinnedWorkspace(state.activeDeck);\n\n        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => {\n          const newDecks = state.decks[input.subject]\n            ? state.decks\n            : { ...state.decks, [input.subject]: { ...defaultDeck } };\n          return {\n            ...state,\n            previousDeck: shouldUpdatePrevious ? state.activeDeck : state.previousDeck,\n            activeDeck: input.subject,\n            decks: newDecks,\n          };\n        });\n      }\n\n      {\n        const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);\n        const deck = state.decks[input.subject];\n        invariant(deck, `Deck not found: ${input.subject}`);\n\n        const first = deck.solo ? deck.solo : deck.active[0];\n        if (first) {\n          yield* Operation.schedule(LayoutOperation.ScrollIntoView, { subject: first });\n        } else {\n          const [item] = Graph.getConnections(graph, input.subject, 'child').filter(\n            (node) => !Node.isActionLike(node) && !node.properties.disposition,\n          );\n          if (item) {\n            yield* Operation.schedule(LayoutOperation.Open, { subject: [item.id] });\n          }\n        }\n      }\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,cAAcC,kBAAkB;AACzC,SAASC,iBAAiBC,mBAAmBC,uBAAuB;AACpE,SAASC,iBAAiB;AAC1B,SAASC,iBAAiB;AAC1B,SAASC,OAAOC,YAAY;AAI5B,IAAA,eAA+EC;IAKzE,UAAA,gBAAA,gBAAA,KAAA,UAAA,YAAA,kBAAA,WAAA,OAAA;QACE,EAAA,MAAMC,IAAQ,OAAOC,WAAAA,IAAaC,gBAAaC,QAAAA;;AAE/C,UAAA,QAAA,OAAA,aAAA,aAAA,iBAAA,KAAA;UAIE,uBAAuBC,CAAAA,kBAAoB,MACvCJ,UACA;wBAAWI,gBAAK,iBAAA,OAAA,CAAAJ,WAAA;YAAGK,WAAMC,OAAU,MAAA,MAAA,OAAA,IAAAN,OAAA,QAAA;kBAAKO;QAAY,CAAA,MAAA,OAAA,GAAA;UAAE,GAAA;QAC1D;;aAEEC;QACAC,GAAAA;QACAL,cAAOM,uBAAAA,OAAAA,aAAAA,OAAAA;QACT,YAAA,MAAA;QACF,OAAA;MACF;IAEA,CAAA;;;AAGEC,UAAAA,QAAUC,OAAO,aAAgB,aAAQN,iBAAS,KAAA;AAElD,UAAMO,OAAAA,MAAaC,MAAI,MAAQA,OAAOF;AACtC,cAAIC,MAAO,mBAAA,MAAA,OAAA,IAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,MAAA,GAAA,CAAA,QAAA,oCAAA,EAAA,CAAA;UACT,QAAOE,KAAAA,OAAUC,KAASjB,OAAAA,KAAAA,OAAgBkB,CAAAA;eAAkBX;AAAe,aAAA,UAAA,SAAA,gBAAA,gBAAA;QACtE,SAAA;MACL,CAAA;WAGA;YACE,CAAA,IAAOS,IAAAA,MAAUC,eAASjB,OAAAA,MAAgBmB,SAAM,OAAA,EAAA,OAAA,CAAA,SAAA,CAAA,KAAA,aAAA,IAAA,KAAA,CAAA,KAAA,WAAA,WAAA;gBAAEZ;yBAAiB,SAAA,gBAAA,MAAA;mBAAC;YAAC,KAAA;UACvE;QACF,CAAA;MACF;IACF;EAIJ;;;",
+  "names": ["Effect", "Capabilities", "Capability", "AppCapabilities", "isPinnedWorkspace", "LayoutOperation", "Operation", "invariant", "Graph", "Node", "LayoutOperation", "state", "Capabilities", "getAtomValue", "DeckCapabilities", "decks", "input", "subject", "defaultDeck", "previousDeck", "activeDeck", "newDecks", "invariant", "deck", "first", "solo", "Operation", "schedule", "ScrollIntoView", "Open"]
+}