@dxos/plugin-deck 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/dist/lib/neutral/add-toast-IKNUJBKF.mjs

@@ -0,0 +1,24 @@
+import {
+  DeckCapabilities_exports
+} from "./chunk-DNLSRLTQ.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/add-toast.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.AddToast.pipe(Operation.withHandler(Effect.fnUntraced(function* (input) {
+  yield* Capabilities.updateAtomValue(DeckCapabilities_exports.EphemeralState, (state) => ({
+    ...state,
+    toasts: [
+      ...state.toasts,
+      input
+    ]
+  }));
+})));
+var add_toast_default = handler;
+export {
+  add_toast_default as default
+};
+//# sourceMappingURL=add-toast-IKNUJBKF.mjs.map

package/dist/lib/neutral/add-toast-IKNUJBKF.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/add-toast.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.AddToast> = LayoutOperation.AddToast.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* (input) {\n      yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({\n        ...state,\n        toasts: [...state.toasts, input as LayoutOperation.Toast],\n      }));\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,oBAAoB;AAC7B,SAASC,uBAAuB;AAChC,SAASC,iBAAiB;AAI1B,IAAMC,UAAkEC,gBAAgBC,SAASC,KAC/FC,UAAUC,YACDC,kBAAW,WAAWC,OAAK;AAChC,SAAOC,aAAaC,gBAAgBC,yBAAiBC,gBAAgB,CAACC,WAAW;IAC/E,GAAGA;IACHC,QAAQ;SAAID,MAAMC;MAAQN;;EAC5B,EAAA;AACF,CAAA,CAAA,CAAA;AAIJ,IAAA,oBAAeP;",
+  "names": ["Effect", "Capabilities", "LayoutOperation", "Operation", "handler", "LayoutOperation", "AddToast", "pipe", "Operation", "withHandler", "fnUntraced", "input", "Capabilities", "updateAtomValue", "DeckCapabilities", "EphemeralState", "state", "toasts"]
+}

package/dist/lib/neutral/adjust-5H2LB7IO.mjs

@@ -0,0 +1,93 @@
+import {
+  incrementPlank
+} from "./chunk-ZYYOSX5I.mjs";
+import {
+  updateActiveDeck
+} from "./chunk-GLB73Q6U.mjs";
+import {
+  DeckCapabilities_exports,
+  DeckOperation_exports,
+  PLANK_COMPANION_TYPE
+} from "./chunk-DNLSRLTQ.mjs";
+import {
+  computeActiveUpdates
+} from "./chunk-GBIGQKYW.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/adjust.ts
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { AppCapabilities, LayoutOperation } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { AttentionCapabilities } from "@dxos/plugin-attention";
+import { Graph } from "@dxos/plugin-graph";
+import { byPosition } from "@dxos/util";
+var handler = DeckOperation_exports.Adjust.pipe(Operation.withHandler(Effect.fnUntraced(function* (input) {
+  const _state = yield* Capabilities.getAtomValue(DeckCapabilities_exports.State);
+  const deck = yield* DeckCapabilities_exports.getDeck();
+  const attention = yield* Capability.get(AttentionCapabilities.Attention);
+  const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+  let soloOperation;
+  if (input.type === "increment-end" || input.type === "increment-start") {
+    const next = incrementPlank(deck.active, input);
+    const { deckUpdates } = computeActiveUpdates({
+      next,
+      deck,
+      attention
+    });
+    yield* Capabilities.updateAtomValue(DeckCapabilities_exports.State, (state) => updateActiveDeck(state, deckUpdates));
+  }
+  if (input.type.startsWith("solo")) {
+    const entryId = input.id;
+    if (!deck.solo) {
+      soloOperation = {
+        type: "solo",
+        entryId,
+        mode: input.type
+      };
+    } else {
+      if (input.type === "solo--fullscreen") {
+        soloOperation = {
+          type: "solo",
+          entryId,
+          mode: "solo--fullscreen"
+        };
+      } else if (input.type === "solo") {
+        soloOperation = {
+          type: "unsolo",
+          entryId
+        };
+      }
+    }
+  }
+  if (soloOperation?.type === "solo") {
+    yield* Operation.invoke(LayoutOperation.SetLayoutMode, {
+      subject: soloOperation.entryId,
+      mode: soloOperation.mode
+    });
+  } else if (soloOperation?.type === "unsolo") {
+    yield* Operation.invoke(LayoutOperation.SetLayoutMode, {
+      mode: "multi"
+    });
+    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, "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(LayoutOperation.UpdateCompanion, {
+        subject: companion.value.id
+      });
+    }
+  }
+})));
+var adjust_default = handler;
+export {
+  adjust_default as default
+};
+//# sourceMappingURL=adjust-5H2LB7IO.mjs.map

package/dist/lib/neutral/adjust-5H2LB7IO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/adjust.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\nimport { AttentionCapabilities } from '@dxos/plugin-attention';\nimport { Graph } from '@dxos/plugin-graph';\nimport { byPosition } from '@dxos/util';\n\nimport { incrementPlank } from '../layout';\nimport { DeckCapabilities, DeckOperation, PLANK_COMPANION_TYPE } from '../types';\nimport { computeActiveUpdates } from '../util';\nimport { updateActiveDeck } from './helpers';\n\nconst handler: Operation.WithHandler<typeof DeckOperation.Adjust> = DeckOperation.Adjust.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* (input) {\n      const _state = yield* Capabilities.getAtomValue(DeckCapabilities.State);\n      const deck = yield* DeckCapabilities.getDeck();\n      const attention = yield* Capability.get(AttentionCapabilities.Attention);\n      const { graph } = yield* Capability.get(AppCapabilities.AppGraph);\n\n      let soloOperation:\n        | { type: 'solo'; entryId: string; mode: string }\n        | { type: 'unsolo'; entryId: string }\n        | undefined;\n\n      if (input.type === 'increment-end' || input.type === 'increment-start') {\n        const next = incrementPlank(deck.active, input);\n        const { deckUpdates } = computeActiveUpdates({ next, deck, attention });\n        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));\n      }\n\n      if (input.type.startsWith('solo')) {\n        const entryId = input.id;\n        if (!deck.solo) {\n          soloOperation = { type: 'solo', entryId, mode: input.type };\n        } else {\n          if (input.type === 'solo--fullscreen') {\n            soloOperation = { type: 'solo', entryId, mode: 'solo--fullscreen' };\n          } else if (input.type === 'solo') {\n            soloOperation = { type: 'unsolo', entryId };\n          }\n        }\n      }\n\n      if (soloOperation?.type === 'solo') {\n        yield* Operation.invoke(LayoutOperation.SetLayoutMode, {\n          subject: soloOperation.entryId,\n          mode: soloOperation.mode,\n        });\n      } else if (soloOperation?.type === 'unsolo') {\n        yield* Operation.invoke(LayoutOperation.SetLayoutMode, { mode: 'multi' });\n        yield* Operation.invoke(LayoutOperation.Open, { subject: [soloOperation.entryId] });\n      }\n\n      if (input.type === 'companion') {\n        const companion = Function.pipe(\n          Graph.getNode(graph, input.id),\n          Option.map((node) =>\n            Graph.getConnections(graph, node.id, 'child')\n              .filter((n) => n.type === PLANK_COMPANION_TYPE)\n              .toSorted((a, b) => byPosition(a.properties, b.properties)),\n          ),\n          Option.flatMap((companions) => (companions.length > 0 ? Option.some(companions[0]) : Option.none())),\n        );\n\n        if (Option.isSome(companion)) {\n          yield* Operation.invoke(LayoutOperation.UpdateCompanion, { subject: companion.value.id });\n        }\n      }\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAIA,YAAYA,YAAY;AACxB,YAAYC,cAAc;AAC1B,YAAYC,YAAY;AAExB,SAASC,cAAcC,kBAAkB;AACzC,SAASC,iBAAiBC,uBAAuB;AACjD,SAASC,iBAAiB;AAC1B,SAASC,6BAA6B;AACtC,SAASC,aAAa;AACtB,SAASC,kBAAkB;AAO3B,IAAMC,UAA8DC,sBAAcC,OAAOC,KACvFC,UAAUC,YACDC,kBAAW,WAAWC,OAAK;AAChC,QAAMC,SAAS,OAAOC,aAAaC,aAAaC,yBAAiBC,KAAK;AACtE,QAAMC,OAAO,OAAOF,yBAAiBG,QAAO;AAC5C,QAAMC,YAAY,OAAOC,WAAWC,IAAIC,sBAAsBC,SAAS;AACvE,QAAM,EAAEC,MAAK,IAAK,OAAOJ,WAAWC,IAAII,gBAAgBC,QAAQ;AAEhE,MAAIC;AAKJ,MAAIhB,MAAMiB,SAAS,mBAAmBjB,MAAMiB,SAAS,mBAAmB;AACtE,UAAMC,OAAOC,eAAeb,KAAKc,QAAQpB,KAAAA;AACzC,UAAM,EAAEqB,YAAW,IAAKC,qBAAqB;MAAEJ;MAAMZ;MAAME;IAAU,CAAA;AACrE,WAAON,aAAaqB,gBAAgBnB,yBAAiBC,OAAO,CAACmB,UAAUC,iBAAiBD,OAAOH,WAAAA,CAAAA;EACjG;AAEA,MAAIrB,MAAMiB,KAAKS,WAAW,MAAA,GAAS;AACjC,UAAMC,UAAU3B,MAAM4B;AACtB,QAAI,CAACtB,KAAKuB,MAAM;AACdb,sBAAgB;QAAEC,MAAM;QAAQU;QAASG,MAAM9B,MAAMiB;MAAK;IAC5D,OAAO;AACL,UAAIjB,MAAMiB,SAAS,oBAAoB;AACrCD,wBAAgB;UAAEC,MAAM;UAAQU;UAASG,MAAM;QAAmB;MACpE,WAAW9B,MAAMiB,SAAS,QAAQ;AAChCD,wBAAgB;UAAEC,MAAM;UAAUU;QAAQ;MAC5C;IACF;EACF;AAEA,MAAIX,eAAeC,SAAS,QAAQ;AAClC,WAAOpB,UAAUkC,OAAOC,gBAAgBC,eAAe;MACrDC,SAASlB,cAAcW;MACvBG,MAAMd,cAAcc;IACtB,CAAA;EACF,WAAWd,eAAeC,SAAS,UAAU;AAC3C,WAAOpB,UAAUkC,OAAOC,gBAAgBC,eAAe;MAAEH,MAAM;IAAQ,CAAA;AACvE,WAAOjC,UAAUkC,OAAOC,gBAAgBG,MAAM;MAAED,SAAS;QAAClB,cAAcW;;IAAS,CAAA;EACnF;AAEA,MAAI3B,MAAMiB,SAAS,aAAa;AAC9B,UAAMmB,YAAqBxC,cACzByC,MAAMC,QAAQzB,OAAOb,MAAM4B,EAAE,GACtBW,WAAI,CAACC,SACVH,MAAMI,eAAe5B,OAAO2B,KAAKZ,IAAI,OAAA,EAClCc,OAAO,CAACC,MAAMA,EAAE1B,SAAS2B,oBAAAA,EACzBC,SAAS,CAACC,GAAGC,MAAMC,WAAWF,EAAEG,YAAYF,EAAEE,UAAU,CAAA,CAAA,GAEtDC,eAAQ,CAACC,eAAgBA,WAAWC,SAAS,IAAWC,YAAKF,WAAW,CAAA,CAAE,IAAWG,YAAI,CAAA,CAAA;AAGlG,QAAWC,cAAOnB,SAAAA,GAAY;AAC5B,aAAOvC,UAAUkC,OAAOC,gBAAgBwB,iBAAiB;QAAEtB,SAASE,UAAUqB,MAAM7B;MAAG,CAAA;IACzF;EACF;AACF,CAAA,CAAA,CAAA;AAIJ,IAAA,iBAAenC;",
+  "names": ["Effect", "Function", "Option", "Capabilities", "Capability", "AppCapabilities", "LayoutOperation", "Operation", "AttentionCapabilities", "Graph", "byPosition", "handler", "DeckOperation", "Adjust", "pipe", "Operation", "withHandler", "fnUntraced", "input", "_state", "Capabilities", "getAtomValue", "DeckCapabilities", "State", "deck", "getDeck", "attention", "Capability", "get", "AttentionCapabilities", "Attention", "graph", "AppCapabilities", "AppGraph", "soloOperation", "type", "next", "incrementPlank", "active", "deckUpdates", "computeActiveUpdates", "updateAtomValue", "state", "updateActiveDeck", "startsWith", "entryId", "id", "solo", "mode", "invoke", "LayoutOperation", "SetLayoutMode", "subject", "Open", "companion", "Graph", "getNode", "map", "node", "getConnections", "filter", "n", "PLANK_COMPANION_TYPE", "toSorted", "a", "b", "byPosition", "properties", "flatMap", "companions", "length", "some", "none", "isSome", "UpdateCompanion", "value"]
+}

package/dist/lib/neutral/app-graph-builder-MRA3OMKO.mjs

@@ -0,0 +1,129 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/app-graph-builder.ts
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { AppCapabilities, AppNode, LayoutOperation } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { AttentionCapabilities } from "@dxos/plugin-attention";
+import { GraphBuilder, NodeMatcher } from "@dxos/plugin-graph";
+import { meta } from "#meta";
+import { DeckCapabilities } from "#types";
+var app_graph_builder_default = Capability.makeModule(Effect.fnUntraced(function* () {
+  const extensions = yield* Effect.all([
+    GraphBuilder.createExtension({
+      id: "not-found",
+      match: NodeMatcher.whenRoot,
+      connector: () => Effect.succeed([
+        AppNode.makeNotFound()
+      ])
+    }),
+    GraphBuilder.createExtension({
+      id: "root",
+      match: NodeMatcher.whenRoot,
+      actions: (_node, get) => Effect.gen(function* () {
+        const closeCurrent = {
+          id: `${LayoutOperation.Close.meta.key}.current`,
+          data: Effect.fnUntraced(function* () {
+            const attention = yield* Capability.get(AttentionCapabilities.Attention);
+            const attended = attention.getCurrent().at(-1);
+            if (attended) {
+              yield* Operation.invoke(LayoutOperation.Close, {
+                subject: [
+                  attended
+                ]
+              });
+            }
+          }),
+          properties: {
+            label: [
+              "close-current.label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--x--regular"
+          }
+        };
+        const closeOthers = {
+          id: `${LayoutOperation.Close.meta.key}.others`,
+          data: Effect.fnUntraced(function* () {
+            const attention = yield* Capability.get(AttentionCapabilities.Attention);
+            const deck2 = yield* DeckCapabilities.getDeck();
+            const attended = attention.getCurrent().at(-1);
+            const ids = deck2.active.filter((id) => id !== attended) ?? [];
+            yield* Operation.invoke(LayoutOperation.Close, {
+              subject: ids
+            });
+          }),
+          properties: {
+            label: [
+              "close-others.label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--x-square--regular"
+          }
+        };
+        const closeAll = {
+          id: `${LayoutOperation.Close.meta.key}.all`,
+          data: Effect.fnUntraced(function* () {
+            const deck2 = yield* DeckCapabilities.getDeck();
+            yield* Operation.invoke(LayoutOperation.Close, {
+              subject: deck2.active
+            });
+          }),
+          properties: {
+            label: [
+              "close-all.label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--x-circle--regular"
+          }
+        };
+        const state = get(yield* Capability.get(DeckCapabilities.State));
+        const deck = state.decks[state.activeDeck];
+        const toggleSidebar = {
+          id: `${LayoutOperation.UpdateSidebar.meta.key}.nav`,
+          data: Effect.fnUntraced(function* () {
+            yield* Capabilities.updateAtomValue(DeckCapabilities.State, (s) => ({
+              ...s,
+              sidebarState: s.sidebarState === "expanded" ? "collapsed" : "expanded"
+            }));
+          }),
+          properties: {
+            label: [
+              state.sidebarState === "expanded" ? "collapse-navigation-sidebar.label" : "open-navigation-sidebar.label",
+              {
+                ns: meta.id
+              }
+            ],
+            icon: "ph--sidebar--regular",
+            keyBinding: {
+              macos: "meta+'"
+            },
+            disposition: "pin-end",
+            position: "last",
+            l0Breakpoint: "lg"
+          }
+        };
+        return !deck?.solo ? [
+          closeCurrent,
+          closeOthers,
+          closeAll,
+          toggleSidebar
+        ] : [
+          toggleSidebar
+        ];
+      })
+    })
+  ]);
+  return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions.flat());
+}));
+export {
+  app_graph_builder_default as default
+};
+//# sourceMappingURL=app-graph-builder-MRA3OMKO.mjs.map

package/dist/lib/neutral/app-graph-builder-MRA3OMKO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/app-graph-builder.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, AppNode, LayoutOperation } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\nimport { AttentionCapabilities } from '@dxos/plugin-attention';\nimport { GraphBuilder, NodeMatcher } from '@dxos/plugin-graph';\n\nimport { meta } from '#meta';\nimport { DeckCapabilities } from '#types';\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    const extensions = yield* Effect.all([\n      GraphBuilder.createExtension({\n        id: 'not-found',\n        match: NodeMatcher.whenRoot,\n        connector: () => Effect.succeed([AppNode.makeNotFound()]),\n      }),\n\n      GraphBuilder.createExtension({\n        id: 'root',\n        match: NodeMatcher.whenRoot,\n        actions: (_node, get) =>\n          Effect.gen(function* () {\n            // NOTE(Zan): This is currently disabled.\n            // TODO(Zan): Fullscreen needs to know the active node and provide that to the layout part.\n            // const _fullscreen = {\n            //   id: `${LayoutAction.UpdateLayout._tag}/fullscreen`,\n            //   data: async () => {\n            //     const { dispatchPromise: dispatch } = context.get(Capabilities.IntentDispatcher);\n            //     await dispatch(\n            //       createIntent(LayoutAction.SetLayoutMode, { part: 'mode', options: { mode: 'fullscreen' } }),\n            //     );\n            //   },\n            //   properties: {\n            //     label: ['toggle-fullscreen.label', { ns: meta.id }],\n            //     icon: 'ph--arrows-out--regular',\n            //     keyBinding: {\n            //       macos: 'ctrl+meta+f',\n            //       windows: 'shift+ctrl+f',\n            //     },\n            //   },\n            // };\n\n            const closeCurrent = {\n              id: `${LayoutOperation.Close.meta.key}.current`,\n              data: Effect.fnUntraced(function* () {\n                const attention = yield* Capability.get(AttentionCapabilities.Attention);\n                const attended = attention.getCurrent().at(-1);\n                if (attended) {\n                  yield* Operation.invoke(LayoutOperation.Close, { subject: [attended] });\n                }\n              }),\n              properties: {\n                label: ['close-current.label', { ns: meta.id }],\n                icon: 'ph--x--regular',\n              },\n            };\n\n            const closeOthers = {\n              id: `${LayoutOperation.Close.meta.key}.others`,\n              data: Effect.fnUntraced(function* () {\n                const attention = yield* Capability.get(AttentionCapabilities.Attention);\n                const deck = yield* DeckCapabilities.getDeck();\n                const attended = attention.getCurrent().at(-1);\n                const ids = deck.active.filter((id: string) => id !== attended) ?? [];\n                yield* Operation.invoke(LayoutOperation.Close, { subject: ids });\n              }),\n              properties: {\n                label: ['close-others.label', { ns: meta.id }],\n                icon: 'ph--x-square--regular',\n              },\n            };\n\n            const closeAll = {\n              id: `${LayoutOperation.Close.meta.key}.all`,\n              data: Effect.fnUntraced(function* () {\n                const deck = yield* DeckCapabilities.getDeck();\n                yield* Operation.invoke(LayoutOperation.Close, { subject: deck.active });\n              }),\n              properties: {\n                label: ['close-all.label', { ns: meta.id }],\n                icon: 'ph--x-circle--regular',\n              },\n            };\n\n            const state = get(yield* Capability.get(DeckCapabilities.State));\n            const deck = state.decks[state.activeDeck];\n\n            const toggleSidebar = {\n              id: `${LayoutOperation.UpdateSidebar.meta.key}.nav`,\n              data: Effect.fnUntraced(function* () {\n                yield* Capabilities.updateAtomValue(DeckCapabilities.State, (s) => ({\n                  ...s,\n                  sidebarState: s.sidebarState === 'expanded' ? ('collapsed' as const) : ('expanded' as const),\n                }));\n              }),\n              properties: {\n                label: [\n                  state.sidebarState === 'expanded'\n                    ? 'collapse-navigation-sidebar.label'\n                    : 'open-navigation-sidebar.label',\n                  { ns: meta.id },\n                ],\n                icon: 'ph--sidebar--regular',\n                keyBinding: {\n                  macos: \"meta+'\",\n                },\n                disposition: 'pin-end',\n                position: 'last',\n                l0Breakpoint: 'lg',\n              },\n            };\n\n            return !deck?.solo ? [closeCurrent, closeOthers, closeAll, toggleSidebar] : [toggleSidebar];\n          }),\n      }),\n    ]);\n\n    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions.flat());\n  }),\n);\n"],
+  "mappings": "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",
+  "names": ["Effect", "Capabilities", "Capability", "AppCapabilities", "AppNode", "LayoutOperation", "Operation", "AttentionCapabilities", "GraphBuilder", "NodeMatcher", "meta", "DeckCapabilities", "makeModule", "fnUntraced", "extensions", "all", "createExtension", "id", "match", "whenRoot", "connector", "succeed", "makeNotFound", "actions", "_node", "get", "gen", "closeCurrent", "Close", "key", "data", "attention", "Attention", "attended", "getCurrent", "at", "invoke", "subject", "properties", "label", "ns", "icon", "closeOthers", "deck", "getDeck", "ids", "active", "filter", "closeAll", "state", "State", "decks", "activeDeck", "toggleSidebar", "UpdateSidebar", "updateAtomValue", "s", "sidebarState", "keyBinding", "macos", "disposition", "position", "l0Breakpoint", "solo", "contributes", "AppGraphBuilder", "flat"]
+}

package/dist/lib/neutral/capabilities/index.mjs

@@ -0,0 +1,23 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/capabilities/index.ts
+import { Capability } from "@dxos/app-framework";
+var AppGraphBuilder = Capability.lazy("AppGraphBuilder", () => import("../app-graph-builder-MRA3OMKO.mjs"));
+var CheckAppScheme = Capability.lazy("CheckAppScheme", () => import("../check-app-scheme-A7FZVNZO.mjs"));
+var OperationHandler = Capability.lazy("OperationHandler", () => import("../operation-handler-266CVMTW.mjs"));
+var ReactRoot = Capability.lazy("ReactRoot", () => import("../react-root-WZ6KH27J.mjs"));
+var ReactSurface = Capability.lazy("ReactSurface", () => import("../react-surface-KAAZDHV3.mjs"));
+var DeckSettings = Capability.lazy("DeckSettings", () => import("../settings-EGNYUM4T.mjs"));
+var DeckState = Capability.lazy("DeckState", () => import("../state-IIDXMQUO.mjs"));
+var UrlHandler = Capability.lazy("UrlHandler", () => import("../url-handler-3QTKEM2K.mjs"));
+export {
+  AppGraphBuilder,
+  CheckAppScheme,
+  DeckSettings,
+  DeckState,
+  OperationHandler,
+  ReactRoot,
+  ReactSurface,
+  UrlHandler
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/capabilities/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/capabilities/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capability } from '@dxos/app-framework';\nimport { OperationHandlerSet } from '@dxos/compute';\n\nexport const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));\nexport const CheckAppScheme = Capability.lazy('CheckAppScheme', () => import('./check-app-scheme'));\nexport const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(\n  'OperationHandler',\n  () => import('./operation-handler'),\n);\nexport const ReactRoot = Capability.lazy('ReactRoot', () => import('./react-root'));\nexport const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));\nexport const DeckSettings = Capability.lazy('DeckSettings', () => import('./settings'));\nexport const DeckState = Capability.lazy('DeckState', () => import('./state'));\nexport const UrlHandler = Capability.lazy('UrlHandler', () => import('./url-handler'));\n"],
+  "mappings": ";;;AAIA,SAASA,kBAAkB;AAGpB,IAAMC,kBAAkBD,WAAWE,KAAK,mBAAmB,MAAM,OAAO,mCAAA,CAAA;AACxE,IAAMC,iBAAiBH,WAAWE,KAAK,kBAAkB,MAAM,OAAO,kCAAA,CAAA;AACtE,IAAME,mBAAmBJ,WAAWE,KACzC,oBACA,MAAM,OAAO,mCAAA,CAAA;AAER,IAAMG,YAAYL,WAAWE,KAAK,aAAa,MAAM,OAAO,4BAAA,CAAA;AAC5D,IAAMI,eAAeN,WAAWE,KAAK,gBAAgB,MAAM,OAAO,+BAAA,CAAA;AAClE,IAAMK,eAAeP,WAAWE,KAAK,gBAAgB,MAAM,OAAO,0BAAA,CAAA;AAClE,IAAMM,YAAYR,WAAWE,KAAK,aAAa,MAAM,OAAO,uBAAA,CAAA;AAC5D,IAAMO,aAAaT,WAAWE,KAAK,cAAc,MAAM,OAAO,6BAAA,CAAA;",
+  "names": ["Capability", "AppGraphBuilder", "lazy", "CheckAppScheme", "OperationHandler", "ReactRoot", "ReactSurface", "DeckSettings", "DeckState", "UrlHandler"]
+}

package/dist/lib/neutral/check-app-scheme-A7FZVNZO.mjs

@@ -0,0 +1,10 @@
+import {
+  check_app_scheme_default,
+  shouldDeferNavigationHandlers
+} from "./chunk-VHETZ22W.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  check_app_scheme_default as default,
+  shouldDeferNavigationHandlers
+};
+//# sourceMappingURL=check-app-scheme-A7FZVNZO.mjs.map

package/dist/lib/neutral/chunk-DNLSRLTQ.mjs

@@ -0,0 +1,278 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/types/schema.ts
+import * as Schema from "effect/Schema";
+import { Label, LayoutOperation } from "@dxos/app-toolkit";
+import { meta } from "#meta";
+import { PLANK_COMPANION_TYPE, DECK_COMPANION_TYPE } from "@dxos/app-toolkit";
+var PlankSizing = Schema.Record({
+  key: Schema.String,
+  value: Schema.Number
+});
+var DeckState = Schema.Struct({
+  /** If false, the deck has not yet left solo mode and new planks should be soloed. */
+  initialized: Schema.Boolean,
+  /** Item IDs of planks currently displayed in multi-mode. */
+  active: Schema.mutable(Schema.Array(Schema.String)),
+  /** Item IDs of planks that have been closed; used for state persistence and reopening. */
+  inactive: Schema.mutable(Schema.Array(Schema.String)),
+  /** Item ID of the single plank displayed in solo or fullscreen mode. */
+  solo: Schema.optional(Schema.String),
+  /** Whether the solo plank is displayed in fullscreen mode (no heading or sidebars). */
+  fullscreen: Schema.Boolean,
+  /** Persisted plank widths in rem, keyed by item ID. */
+  plankSizing: Schema.mutable(PlankSizing),
+  /** Whether the companion pane is visible alongside the active plank(s). */
+  companionOpen: Schema.Boolean,
+  /** Which companion variant to display when the companion pane is open. */
+  companionVariant: Schema.optional(Schema.String),
+  /** Persisted companion frame widths in rem, keyed by frame ID. */
+  companionFrameSizing: Schema.mutable(PlankSizing)
+});
+var defaultDeck = {
+  initialized: false,
+  active: [],
+  inactive: [],
+  solo: void 0,
+  fullscreen: false,
+  plankSizing: {},
+  companionOpen: false,
+  companionVariant: void 0,
+  companionFrameSizing: {}
+};
+var LayoutMode = Schema.Literal("multi", "solo", "solo--fullscreen");
+var isLayoutMode = (value) => Schema.is(LayoutMode)(value);
+var getMode = (deck) => {
+  if (deck.solo) {
+    return deck.fullscreen ? "solo--fullscreen" : "solo";
+  }
+  return "multi";
+};
+var StoredDeckState = Schema.Struct({
+  sidebarState: Schema.Literal("closed", "collapsed", "expanded"),
+  complementarySidebarState: Schema.Literal("closed", "collapsed", "expanded"),
+  complementarySidebarPanel: Schema.optional(Schema.String),
+  activeDeck: Schema.String,
+  previousDeck: Schema.String,
+  decks: Schema.mutable(Schema.Record({
+    key: Schema.String,
+    value: Schema.mutable(DeckState)
+  })),
+  previousMode: Schema.mutable(Schema.Record({
+    key: Schema.String,
+    value: LayoutMode
+  }))
+}).pipe(Schema.mutable);
+var EphemeralDeckState = Schema.Struct({
+  dialogOpen: Schema.Boolean,
+  dialogType: Schema.optional(Schema.Literal("default", "alert")),
+  dialogBlockAlign: Schema.optional(Schema.Literal("start", "center", "end")),
+  dialogOverlayClasses: Schema.optional(Schema.String),
+  dialogOverlayStyle: Schema.optional(Schema.Record({
+    key: Schema.String,
+    value: Schema.Any
+  })),
+  /** Data to be passed to the dialog Surface. */
+  dialogContent: Schema.NullOr(Schema.Struct({
+    component: Schema.String,
+    props: Schema.optional(Schema.Any)
+  })),
+  popoverOpen: Schema.Boolean,
+  popoverSide: Schema.optional(Schema.Literal("top", "right", "bottom", "left")),
+  popoverAnchor: Schema.optional(Schema.Any),
+  popoverAnchorId: Schema.optional(Schema.String),
+  popoverKind: Schema.optional(Schema.Literal("base", "card")),
+  popoverTitle: Schema.optional(Label.annotations({
+    description: "The title of the popover."
+  })),
+  /** Ref of the subject to be passed to the popover Surface. */
+  popoverContentRef: Schema.optional(Schema.String),
+  /** Data to be passed to the popover Surface. */
+  popoverContent: Schema.NullOr(Schema.Union(Schema.Struct({
+    component: Schema.String,
+    props: Schema.optional(Schema.Any)
+  }), Schema.Struct({
+    subject: Schema.Any
+  }))),
+  toasts: Schema.mutable(Schema.Array(LayoutOperation.Toast)),
+  currentUndoId: Schema.optional(Schema.String),
+  /** The identifier of a component to scroll into view when it is mounted. */
+  scrollIntoView: Schema.optional(Schema.String)
+}).pipe(Schema.mutable);
+(function(DeckAction2) {
+  const PartAdjustmentSchema2 = Schema.Union(Schema.Literal("close").annotations({
+    description: "Close the plank."
+  }), Schema.Literal("companion").annotations({
+    description: "Open the companion plank."
+  }), Schema.Literal("solo").annotations({
+    description: "Solo the plank."
+  }), Schema.Literal("solo--fullscreen").annotations({
+    description: "Fullscreen the plank."
+  }), Schema.Literal("increment-start").annotations({
+    description: "Move the plank towards the start of the deck."
+  }), Schema.Literal("increment-end").annotations({
+    description: "Move the plank towards the end of the deck."
+  }));
+  DeckAction2.Adjustment = Schema.mutable(Schema.Struct({
+    id: Schema.String,
+    type: PartAdjustmentSchema2
+  }));
+  class Adjust2 extends Schema.TaggedClass()(`${meta.id}.action.adjust`, {
+    input: DeckAction2.Adjustment,
+    output: Schema.Void
+  }) {
+  }
+  DeckAction2.Adjust = Adjust2;
+  class UpdatePlankSize2 extends Schema.TaggedClass()(`${meta.id}.action.update-plank-size`, {
+    input: Schema.Struct({
+      id: Schema.String,
+      size: Schema.Number
+    }),
+    output: Schema.Void
+  }) {
+  }
+  DeckAction2.UpdatePlankSize = UpdatePlankSize2;
+})(DeckAction || (DeckAction = {}));
+var DeckAction;
+
+// src/types/DeckCapabilities.ts
+var DeckCapabilities_exports = {};
+__export(DeckCapabilities_exports, {
+  EphemeralState: () => EphemeralState,
+  Settings: () => Settings,
+  State: () => State,
+  getDeck: () => getDeck
+});
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { invariant } from "@dxos/invariant";
+import { meta as meta2 } from "#meta";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-deck/src/types/DeckCapabilities.ts";
+var Settings = Capability.make(`${meta2.id}.capability.settings`);
+var State = Capability.make(`${meta2.id}.capability.state`);
+var EphemeralState = Capability.make(`${meta2.id}.capability.ephemeral-state`);
+var getDeck = () => Effect.gen(function* () {
+  const state = yield* Capabilities.getAtomValue(State);
+  const deck = state.decks[state.activeDeck];
+  invariant(deck, `Deck not found: ${state.activeDeck}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 15, S: this, A: ["deck", "`Deck not found: ${state.activeDeck}`"] });
+  return deck;
+});
+
+// src/types/DeckEvents.ts
+var DeckEvents_exports = {};
+__export(DeckEvents_exports, {
+  SettingsReady: () => SettingsReady,
+  StateReady: () => StateReady
+});
+import { AppActivationEvents } from "@dxos/app-toolkit";
+import { meta as meta3 } from "#meta";
+var StateReady = AppActivationEvents.createStateEvent(`${meta3.id}.state-ready`);
+var SettingsReady = AppActivationEvents.createSettingsEvent(Settings.identifier);
+
+// src/types/DeckOperation.ts
+var DeckOperation_exports = {};
+__export(DeckOperation_exports, {
+  Adjust: () => Adjust,
+  UpdatePlankSize: () => UpdatePlankSize
+});
+import * as Schema2 from "effect/Schema";
+import { Capability as Capability2 } from "@dxos/app-framework";
+import { Operation } from "@dxos/compute";
+import { meta as meta4 } from "#meta";
+var PartAdjustmentSchema = Schema2.Union(Schema2.Literal("close").annotations({
+  description: "Close the plank."
+}), Schema2.Literal("companion").annotations({
+  description: "Open the companion plank."
+}), Schema2.Literal("solo").annotations({
+  description: "Solo the plank."
+}), Schema2.Literal("solo--fullscreen").annotations({
+  description: "Fullscreen the plank."
+}), Schema2.Literal("increment-start").annotations({
+  description: "Move the plank towards the start of the deck."
+}), Schema2.Literal("increment-end").annotations({
+  description: "Move the plank towards the end of the deck."
+}));
+var Adjust = Operation.make({
+  meta: {
+    key: `${meta4.id}.operation.adjust`,
+    name: "Adjust",
+    description: "Adjust the layout of a plank."
+  },
+  services: [
+    Capability2.Service
+  ],
+  input: Schema2.Struct({
+    id: Schema2.String.annotations({
+      description: "The id of the plank to adjust."
+    }),
+    type: PartAdjustmentSchema.annotations({
+      description: "The type of adjustment to make."
+    })
+  }),
+  output: Schema2.Void
+});
+var UpdatePlankSize = Operation.make({
+  meta: {
+    key: `${meta4.id}.operation.update-plank-size`,
+    name: "Update Plank Size",
+    description: "Update the size of a plank."
+  },
+  services: [
+    Capability2.Service
+  ],
+  input: Schema2.Struct({
+    id: Schema2.String.annotations({
+      description: "The id of the plank to resize."
+    }),
+    size: Schema2.Number.annotations({
+      description: "The new size of the plank."
+    })
+  }),
+  output: Schema2.Void
+});
+
+// src/types/Settings.ts
+var Settings_exports = {};
+__export(Settings_exports, {
+  Settings: () => Settings2
+});
+import * as Schema3 from "effect/Schema";
+var Settings2 = Schema3.Struct({
+  enableDeck: Schema3.optional(Schema3.Boolean.annotations({
+    title: "Enable Deck",
+    description: "Display multiple panels side by side instead of one at a time."
+  })),
+  // TODO(burdon): Rename layoutMode? (e.g., bento/encapsulated or floating/compact, etc.)
+  encapsulatedPlanks: Schema3.optional(Schema3.Boolean.annotations({
+    title: "Encapsulated planks",
+    description: "Render each plank inside its own isolated container."
+  })),
+  showHints: Schema3.optional(Schema3.Boolean.annotations({
+    title: "Show hints",
+    description: "Show helpful tips and keyboard shortcut hints in the interface."
+  })),
+  enableNativeRedirect: Schema3.optional(Schema3.Boolean.annotations({
+    title: "Enable native url redirect",
+    description: "Redirect supported URLs to the native desktop application."
+  }))
+}).pipe(Schema3.mutable);
+
+export {
+  PlankSizing,
+  DeckState,
+  defaultDeck,
+  isLayoutMode,
+  getMode,
+  StoredDeckState,
+  EphemeralDeckState,
+  DeckAction,
+  PLANK_COMPANION_TYPE,
+  DECK_COMPANION_TYPE,
+  DeckCapabilities_exports,
+  DeckEvents_exports,
+  DeckOperation_exports,
+  Settings_exports
+};
+//# sourceMappingURL=chunk-DNLSRLTQ.mjs.map