@dxos/plugin-deck 0.8.2-staging.7ac8446 → 0.8.3-main.672df60

package/dist/lib/browser/chunk-LWXMANOA.mjs

@@ -0,0 +1,1487 @@
+import {
+  getCompanionId,
+  useBreakpoints,
+  useCompanions,
+  useDeckCompanions,
+  useHoistStatusbar,
+  useMainSize,
+  useNodeActionExpander
+} from "./chunk-KRDA6PUM.mjs";
+import {
+  calculateOverscroll,
+  layoutAppliesTopbar,
+  parseEntryId
+} from "./chunk-TRFYUEBA.mjs";
+import {
+  DeckCapabilities
+} from "./chunk-KLN73CM3.mjs";
+import {
+  DeckAction,
+  NewPlankPositions,
+  OverscrollOptions,
+  PLANK_COMPANION_TYPE,
+  getMode
+} from "./chunk-YN5OZEGS.mjs";
+import {
+  DECK_PLUGIN
+} from "./chunk-NSATFAEE.mjs";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Banner.tsx
+import { useSignals as _useSignals9 } from "@preact-signals/safe-react/tracking";
+import React9 from "react";
+import { Surface as Surface5 } from "@dxos/app-framework";
+import { useTranslation as useTranslation6 } from "@dxos/react-ui";
+import { mx as mx4 } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/Sidebar/ComplementarySidebar.tsx
+import { useSignals as _useSignals7 } from "@preact-signals/safe-react/tracking";
+import React7, { Fragment as Fragment2, useCallback as useCallback5, useEffect as useEffect3, useMemo as useMemo3, useState as useState2 } from "react";
+import { LayoutAction as LayoutAction4, Surface as Surface3, createIntent as createIntent5, useCapability as useCapability3, useIntentDispatcher as useIntentDispatcher5 } from "@dxos/app-framework";
+import { Main, useTranslation as useTranslation5, toLocalizedString as toLocalizedString2, IconButton as IconButton4 } from "@dxos/react-ui";
+import { Tabs } from "@dxos/react-ui-tabs";
+
+// packages/plugins/plugin-deck/src/components/Sidebar/SidebarButton.tsx
+import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
+import React, { useCallback } from "react";
+import { createIntent, LayoutAction, useCapability, useIntentDispatcher } from "@dxos/app-framework";
+import { IconButton, useTranslation } from "@dxos/react-ui";
+var ToggleSidebarButton = ({ classNames, variant = "ghost" }) => {
+  var _effect = _useSignals();
+  try {
+    const layoutContext = useCapability(DeckCapabilities.MutableDeckState);
+    const { t } = useTranslation(DECK_PLUGIN);
+    return /* @__PURE__ */ React.createElement(IconButton, {
+      variant,
+      iconOnly: true,
+      icon: "ph--sidebar--regular",
+      size: 4,
+      label: t("open navigation sidebar label"),
+      onClick: () => layoutContext.sidebarState = layoutContext.sidebarState === "expanded" ? "collapsed" : "expanded",
+      classNames
+    });
+  } finally {
+    _effect.f();
+  }
+};
+var CloseSidebarButton = () => {
+  var _effect = _useSignals();
+  try {
+    const layoutContext = useCapability(DeckCapabilities.MutableDeckState);
+    const { t } = useTranslation(DECK_PLUGIN);
+    return /* @__PURE__ */ React.createElement(IconButton, {
+      variant: "ghost",
+      iconOnly: true,
+      icon: "ph--caret-line-left--regular",
+      size: 4,
+      label: t("close navigation sidebar label"),
+      onClick: () => layoutContext.sidebarState = "collapsed",
+      classNames: "rounded-none pli-1 dx-focus-ring-inset pie-[max(.5rem,env(safe-area-inset-left))]"
+    });
+  } finally {
+    _effect.f();
+  }
+};
+var ToggleComplementarySidebarButton = ({ inR0, classNames, current }) => {
+  var _effect = _useSignals();
+  try {
+    const { dispatchPromise: dispatch } = useIntentDispatcher();
+    const layoutContext = useCapability(DeckCapabilities.MutableDeckState);
+    const { t } = useTranslation(DECK_PLUGIN);
+    const companions = useDeckCompanions();
+    const handleClick = useCallback(async () => {
+      layoutContext.complementarySidebarState = layoutContext.complementarySidebarState === "expanded" ? "collapsed" : "expanded";
+      const firstCompanion = companions[0];
+      if (layoutContext.complementarySidebarState === "expanded" && !current && firstCompanion) {
+        await dispatch(createIntent(LayoutAction.UpdateComplementary, {
+          part: "complementary",
+          subject: getCompanionId(firstCompanion.id)
+        }));
+      }
+    }, [
+      layoutContext,
+      current,
+      companions,
+      dispatch
+    ]);
+    return /* @__PURE__ */ React.createElement(IconButton, {
+      iconOnly: true,
+      onClick: handleClick,
+      variant: "ghost",
+      label: t("open complementary sidebar label"),
+      classNames: [
+        "[&>svg]:-scale-x-100",
+        classNames
+      ],
+      icon: "ph--sidebar-simple--regular",
+      size: inR0 ? 5 : 4,
+      tooltipSide: inR0 ? "left" : void 0
+    });
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/Plank/Plank.tsx
+import { useSignals as _useSignals6 } from "@preact-signals/safe-react/tracking";
+import React6, { memo as memo2, useCallback as useCallback4, useLayoutEffect, useMemo as useMemo2, useRef } from "react";
+import { LayoutAction as LayoutAction3, Surface as Surface2, createIntent as createIntent4, useCapability as useCapability2, useAppGraph as useAppGraph2, useIntentDispatcher as useIntentDispatcher4 } from "@dxos/app-framework";
+import { debounce } from "@dxos/async";
+import { useNode } from "@dxos/plugin-graph";
+import { ATTENDABLE_PATH_SEPARATOR, useAttentionAttributes } from "@dxos/react-ui-attention";
+import { StackItem as StackItem2, railGridHorizontal } from "@dxos/react-ui-stack";
+import { mainIntrinsicSize, mx as mx3 } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/Plank/PlankError.tsx
+import { useSignals as _useSignals5 } from "@preact-signals/safe-react/tracking";
+import React5, { useEffect as useEffect2, useState } from "react";
+import { useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { descriptionMessage, mx as mx2 } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/Plank/PlankHeading.tsx
+import { useSignals as _useSignals3 } from "@preact-signals/safe-react/tracking";
+import React3, { Fragment, memo, useCallback as useCallback3, useEffect, useMemo } from "react";
+import { createIntent as createIntent3, LayoutAction as LayoutAction2, Surface, useAppGraph, useIntentDispatcher as useIntentDispatcher3 } from "@dxos/app-framework";
+import { Icon, IconButton as IconButton3, Popover, toLocalizedString, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { StackItem } from "@dxos/react-ui-stack";
+import { TextTooltip } from "@dxos/react-ui-text-tooltip";
+import { hoverableControls, hoverableFocusedWithinControls } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/Plank/PlankControls.tsx
+import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
+import React2, { forwardRef, useCallback as useCallback2 } from "react";
+import { createIntent as createIntent2, useIntentDispatcher as useIntentDispatcher2 } from "@dxos/app-framework";
+import { invariant } from "@dxos/invariant";
+import { ButtonGroup, IconButton as IconButton2, useTranslation as useTranslation2 } from "@dxos/react-ui";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-deck/src/components/Plank/PlankControls.tsx";
+var PlankControl = ({ icon, label: label3, ...props }) => {
+  var _effect = _useSignals2();
+  try {
+    return /* @__PURE__ */ React2.createElement(IconButton2, {
+      iconOnly: true,
+      label: label3,
+      icon,
+      size: 5,
+      variant: "ghost",
+      tooltipSide: "bottom",
+      ...props
+    });
+  } finally {
+    _effect.f();
+  }
+};
+var plankControlSpacing = "pli-2";
+var PlankCompanionControls = /* @__PURE__ */ forwardRef(({ primary }, forwardedRef) => {
+  var _effect = _useSignals2();
+  try {
+    const { t } = useTranslation2(DECK_PLUGIN);
+    const { dispatchPromise: dispatch } = useIntentDispatcher2();
+    const handleCloseCompanion = useCallback2(() => {
+      invariant(primary, void 0, {
+        F: __dxlog_file,
+        L: 49,
+        S: void 0,
+        A: [
+          "primary",
+          ""
+        ]
+      });
+      return dispatch(createIntent2(DeckAction.ChangeCompanion, {
+        primary,
+        companion: null
+      }));
+    }, []);
+    return /* @__PURE__ */ React2.createElement("div", {
+      ref: forwardedRef,
+      className: "contents app-no-drag"
+    }, /* @__PURE__ */ React2.createElement(PlankControl, {
+      label: t("close companion label"),
+      variant: "ghost",
+      icon: "ph--x--regular",
+      onClick: handleCloseCompanion,
+      classNames: plankControlSpacing
+    }));
+  } finally {
+    _effect.f();
+  }
+});
+var PlankControls = /* @__PURE__ */ forwardRef(({ children, classNames, variant = "default", capabilities, layoutMode, pin, close = false, onClick, ...props }, forwardedRef) => {
+  var _effect = _useSignals2();
+  try {
+    const { t } = useTranslation2(DECK_PLUGIN);
+    const buttonClassNames = variant === "hide-disabled" ? `disabled:hidden ${plankControlSpacing}` : plankControlSpacing;
+    const layoutIsAnySolo = !!layoutMode?.startsWith("solo");
+    return /* @__PURE__ */ React2.createElement(ButtonGroup, {
+      ...props,
+      classNames: [
+        "app-no-drag !opacity-100",
+        classNames
+      ],
+      ref: forwardedRef
+    }, capabilities.deck ? /* @__PURE__ */ React2.createElement(React2.Fragment, null, capabilities.solo && /* @__PURE__ */ React2.createElement(React2.Fragment, null, layoutMode === "solo" && /* @__PURE__ */ React2.createElement(PlankControl, {
+      label: t("show fullscreen plank label"),
+      classNames: buttonClassNames,
+      icon: "ph--corners-out--regular",
+      onClick: () => onClick?.("solo--fullscreen")
+    }), /* @__PURE__ */ React2.createElement(PlankControl, {
+      label: t(layoutMode === "solo--fullscreen" ? "exit fullscreen label" : layoutIsAnySolo ? "show deck plank label" : "show solo plank label"),
+      classNames: buttonClassNames,
+      icon: layoutMode === "solo--fullscreen" ? "ph--corners-in--regular" : layoutIsAnySolo ? "ph--arrows-in-line-horizontal--regular" : "ph--arrows-out-line-horizontal--regular",
+      onClick: () => onClick?.(layoutMode === "solo--fullscreen" ? "solo--fullscreen" : "solo")
+    })), !layoutIsAnySolo && /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(PlankControl, {
+      label: t("increment start label"),
+      disabled: !capabilities.incrementStart,
+      classNames: buttonClassNames,
+      icon: "ph--caret-left--regular",
+      onClick: () => onClick?.("increment-start")
+    }), /* @__PURE__ */ React2.createElement(PlankControl, {
+      label: t("increment end label"),
+      disabled: !capabilities.incrementEnd,
+      classNames: buttonClassNames,
+      icon: "ph--caret-right--regular",
+      onClick: () => onClick?.("increment-end")
+    }))) : capabilities.fullscreen && /* @__PURE__ */ React2.createElement(PlankControl, {
+      label: t(layoutMode === "solo--fullscreen" ? "exit fullscreen label" : "show fullscreen plank label"),
+      classNames: buttonClassNames,
+      icon: layoutMode === "solo--fullscreen" ? "ph--corners-in--regular" : "ph--corners-out--regular",
+      onClick: () => onClick?.("solo--fullscreen")
+    }), close && !layoutIsAnySolo && /* @__PURE__ */ React2.createElement(PlankControl, {
+      label: t(`${typeof close === "string" ? "minify" : "close"} label`),
+      classNames: buttonClassNames,
+      "data-testid": "plankHeading.close",
+      icon: close === "minify-start" ? "ph--caret-line-left--regular" : close === "minify-end" ? "ph--caret-line-right--regular" : "ph--x--regular",
+      onClick: () => onClick?.("close")
+    }), capabilities.companion && /* @__PURE__ */ React2.createElement(PlankControl, {
+      label: t("open companion label"),
+      classNames: buttonClassNames,
+      "data-testid": "plankHeading.companion",
+      icon: "ph--square-split-horizontal--regular",
+      onClick: () => onClick?.("companion")
+    }), children);
+  } finally {
+    _effect.f();
+  }
+});
+
+// packages/plugins/plugin-deck/src/components/fragments.ts
+import { mx } from "@dxos/react-ui-theme";
+var soloInlinePadding = "pis-[calc(env(safe-area-inset-left)+.25rem)] pie-[calc(env(safe-area-inset-left)+.25rem)]";
+var sidebarToggleStyles = "bs-[--rail-item] is-[--rail-item] absolute block-end-2 z-[1] !bg-deckSurface lg:hidden";
+var fixedSidebarToggleStyles = mx(sidebarToggleStyles, "inline-start-2");
+var fixedComplementarySidebarToggleStyles = mx(sidebarToggleStyles, "inline-end-2");
+
+// packages/plugins/plugin-deck/src/components/Plank/PlankHeading.tsx
+var MAX_COMPANIONS = 5;
+var PlankHeading = /* @__PURE__ */ memo(({ id, part, node, deckEnabled, canIncrementStart, canIncrementEnd, popoverAnchorId, primaryId, pending, companioned, companions, layoutMode, actions = [] }) => {
+  var _effect = _useSignals3();
+  try {
+    const { t } = useTranslation3(DECK_PLUGIN);
+    const { dispatchPromise: dispatch } = useIntentDispatcher3();
+    const { graph } = useAppGraph();
+    const breakpoint = useBreakpoints();
+    const icon = node?.properties?.icon ?? "ph--placeholder--regular";
+    const label3 = pending ? t("pending heading") : toLocalizedString(node?.properties?.label ?? [
+      "plank heading fallback label",
+      {
+        ns: DECK_PLUGIN
+      }
+    ], t);
+    const isCompanionNode = node?.type === PLANK_COMPANION_TYPE;
+    useEffect(() => {
+      const frame = requestAnimationFrame(() => {
+        if (node) {
+          void graph.expand(node.id);
+        }
+      });
+      return () => cancelAnimationFrame(frame);
+    }, [
+      node
+    ]);
+    const attendableId = primaryId ?? id;
+    const capabilities = useMemo(() => ({
+      deck: deckEnabled ?? true,
+      solo: breakpoint !== "mobile" && (part === "solo" || part === "deck"),
+      incrementStart: canIncrementStart,
+      incrementEnd: canIncrementEnd,
+      fullscreen: !isCompanionNode,
+      companion: !isCompanionNode && companions && companions.length > 0
+    }), [
+      breakpoint,
+      part,
+      companions,
+      canIncrementStart,
+      canIncrementEnd,
+      isCompanionNode,
+      deckEnabled
+    ]);
+    const { variant } = parseEntryId(id);
+    const sigilActions = useMemo(() => {
+      if (!node) {
+        return void 0;
+      } else if (variant) {
+        return [];
+      } else {
+        return [
+          actions,
+          graph.getActions(node.id)
+        ].filter((a) => a.length > 0);
+      }
+    }, [
+      actions,
+      node,
+      variant,
+      graph
+    ]);
+    const handleAction = useCallback3((action) => {
+      typeof action.data === "function" && action.data?.({
+        parent: node,
+        caller: DECK_PLUGIN
+      });
+    }, [
+      node
+    ]);
+    const handlePlankAction = useCallback3((eventType) => {
+      if (eventType.startsWith("solo")) {
+        return dispatch(createIntent3(DeckAction.Adjust, {
+          type: eventType,
+          id
+        }));
+      } else if (eventType === "close") {
+        if (part === "complementary") {
+          return dispatch(createIntent3(LayoutAction2.UpdateComplementary, {
+            part: "complementary",
+            options: {
+              state: "collapsed"
+            }
+          }));
+        } else {
+          return dispatch(createIntent3(LayoutAction2.Close, {
+            part: "main",
+            subject: [
+              id
+            ],
+            options: {
+              state: false
+            }
+          }));
+        }
+      } else {
+        return dispatch(createIntent3(DeckAction.Adjust, {
+          type: eventType,
+          id
+        }));
+      }
+    }, [
+      dispatch,
+      id,
+      part
+    ]);
+    const ActionRoot = node && popoverAnchorId === `dxos.org/ui/${DECK_PLUGIN}/${node.id}` ? Popover.Anchor : Fragment;
+    const handleTabClick = useCallback3((event) => {
+      const target = event.target.closest("[data-id]");
+      const tabId = target?.dataset?.id;
+      if (primaryId && tabId) {
+        void dispatch(createIntent3(DeckAction.ChangeCompanion, {
+          primary: primaryId,
+          companion: tabId
+        }));
+      }
+    }, [
+      primaryId
+    ]);
+    return /* @__PURE__ */ React3.createElement(StackItem.Heading, {
+      classNames: [
+        "plb-1 border-be border-subduedSeparator items-stretch gap-1 sticky inline-start-12 app-drag min-is-0 contain-layout",
+        part === "solo" ? soloInlinePadding : "pli-1",
+        ...layoutMode === "solo--fullscreen" ? [
+          hoverableControls,
+          hoverableFocusedWithinControls,
+          "[&>*]:transition-opacity [&>*]:opacity-[--controls-opacity] bg-transparent border-transparent transition-[background-color,border-color] hover-hover:hover:bg-headerSurface focus-within:bg-headerSurface hover-hover:hover:border-subduedSeparator focus-within:border-subduedSeparator"
+        ] : []
+      ],
+      "data-plank-heading": true
+    }, companions && isCompanionNode ? /* @__PURE__ */ React3.createElement("div", {
+      role: "none",
+      className: "flex-1 min-is-0 overflow-x-auto scrollbar-thin flex gap-1"
+    }, companions.map(({ id: id2, properties: { icon: icon2, label: label4 } }) => /* @__PURE__ */ React3.createElement(IconButton3, {
+      key: id2,
+      "data-id": id2,
+      icon: icon2,
+      iconOnly: companions.length > MAX_COMPANIONS && node?.id !== id2,
+      label: toLocalizedString(label4, t),
+      size: 5,
+      variant: node?.id === id2 ? "primary" : "default",
+      onClick: handleTabClick
+    }))) : /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(ActionRoot, null, node && sigilActions ? /* @__PURE__ */ React3.createElement(StackItem.Sigil, {
+      icon,
+      related: part === "complementary",
+      attendableId,
+      triggerLabel: t("actions menu label"),
+      actions: sigilActions,
+      onAction: handleAction
+    }, /* @__PURE__ */ React3.createElement(Surface, {
+      role: "menu-footer",
+      data: {
+        subject: node.data
+      }
+    })) : /* @__PURE__ */ React3.createElement(StackItem.SigilButton, null, /* @__PURE__ */ React3.createElement("span", {
+      className: "sr-only"
+    }, label3), /* @__PURE__ */ React3.createElement(Icon, {
+      icon,
+      size: 5
+    }))), /* @__PURE__ */ React3.createElement(TextTooltip, {
+      text: label3,
+      onlyWhenTruncating: true
+    }, /* @__PURE__ */ React3.createElement(StackItem.HeadingLabel, {
+      attendableId,
+      related: part === "complementary",
+      ...pending && {
+        classNames: "text-description"
+      }
+    }, label3))), node && part !== "complementary" && /* @__PURE__ */ React3.createElement(Surface, {
+      role: "navbar-end",
+      data: {
+        subject: node.data
+      }
+    }), companioned === "companion" ? /* @__PURE__ */ React3.createElement(PlankCompanionControls, {
+      primary: primaryId
+    }) : /* @__PURE__ */ React3.createElement(PlankControls, {
+      capabilities,
+      layoutMode,
+      close: part === "complementary" ? "minify-end" : true,
+      onClick: handlePlankAction
+    }));
+  } finally {
+    _effect.f();
+  }
+});
+
+// packages/plugins/plugin-deck/src/components/Plank/PlankLoading.tsx
+import { useSignals as _useSignals4 } from "@preact-signals/safe-react/tracking";
+import React4 from "react";
+var PlankLoading = () => {
+  var _effect = _useSignals4();
+  try {
+    return /* @__PURE__ */ React4.createElement("div", {
+      role: "none",
+      className: "grid place-items-center attention-surface"
+    });
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/Plank/PlankError.tsx
+var PlankContentError = ({ error }) => {
+  var _effect = _useSignals5();
+  try {
+    const { t } = useTranslation4(DECK_PLUGIN);
+    const errorString = error?.toString() ?? "";
+    return /* @__PURE__ */ React5.createElement("div", {
+      role: "none",
+      className: "overflow-auto p-8 attention-surface grid place-items-center"
+    }, /* @__PURE__ */ React5.createElement("p", {
+      role: "alert",
+      className: mx2(descriptionMessage, "break-words rounded-lg p-8", errorString.length < 256 && "text-lg")
+    }, error ? errorString : t("error fallback message")));
+  } finally {
+    _effect.f();
+  }
+};
+var PlankError = ({ id, part, node, error }) => {
+  var _effect = _useSignals5();
+  try {
+    const [timedOut, setTimedOut] = useState(false);
+    useEffect2(() => {
+      setTimeout(() => setTimedOut(true), 5e3);
+    }, []);
+    return /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(PlankHeading, {
+      id,
+      part,
+      node,
+      pending: !timedOut
+    }), timedOut ? /* @__PURE__ */ React5.createElement(PlankContentError, {
+      error
+    }) : /* @__PURE__ */ React5.createElement(PlankLoading, null));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/Plank/Plank.tsx
+var UNKNOWN_ID = "unknown_id";
+var Plank = /* @__PURE__ */ memo2(({ id = UNKNOWN_ID, companionId, ...props }) => {
+  var _effect = _useSignals6();
+  try {
+    const { graph } = useAppGraph2();
+    const node = useNode(graph, id);
+    const companions = useCompanions(id);
+    const currentCompanion = companions.find(({ id: id2 }) => id2 === companionId);
+    const hasCompanion = !!(companionId && currentCompanion);
+    return /* @__PURE__ */ React6.createElement(PlankContainer, {
+      solo: props.part === "solo",
+      companion: hasCompanion
+    }, /* @__PURE__ */ React6.createElement(PlankComponent, {
+      id,
+      node,
+      companioned: hasCompanion ? "primary" : void 0,
+      companions: hasCompanion ? [] : companions,
+      ...props,
+      ...props.part === "solo" ? {
+        part: "solo-primary"
+      } : {}
+    }), hasCompanion && /* @__PURE__ */ React6.createElement(PlankComponent, {
+      id: companionId,
+      node: currentCompanion,
+      primary: node,
+      companions,
+      companioned: "companion",
+      ...props,
+      ...props.part === "solo" ? {
+        part: "solo-companion"
+      } : {
+        order: (props.order ?? 0) + 1
+      }
+    }));
+  } finally {
+    _effect.f();
+  }
+});
+var PlankContainer = ({ children, solo, companion }) => {
+  var _effect = _useSignals6();
+  try {
+    const sizeAttrs = useMainSize();
+    if (!solo) {
+      return children;
+    }
+    return /* @__PURE__ */ React6.createElement("div", {
+      role: "none",
+      className: mx3("absolute inset-0 grid", companion && "grid-cols-[1fr_1fr]", railGridHorizontal, mainIntrinsicSize),
+      ...sizeAttrs
+    }, children);
+  } finally {
+    _effect.f();
+  }
+};
+var PlankComponent = /* @__PURE__ */ memo2(({ layoutMode, id, part, path, order, active, companioned, node, primary, companions, settings }) => {
+  var _effect = _useSignals6();
+  try {
+    const { dispatchPromise: dispatch } = useIntentDispatcher4();
+    const { deck, popoverAnchorId, scrollIntoView } = useCapability2(DeckCapabilities.DeckState);
+    const canResize = layoutMode === "deck";
+    const attentionAttrs = useAttentionAttributes(primary?.id ?? id);
+    const index = active ? active.findIndex((entryId) => entryId === id) : 0;
+    const length = active?.length ?? 1;
+    const canIncrementStart = active && index !== void 0 && index > 0 && length !== void 0 && length > 1;
+    const canIncrementEnd = active && index !== void 0 && index < length - 1 && length !== void 0;
+    const rootElement = useRef(null);
+    const { variant } = parseEntryId(id);
+    const sizeKey = `${id.split("+")[0]}${variant ? `${ATTENDABLE_PATH_SEPARATOR}${variant}` : ""}`;
+    const size = deck.plankSizing[sizeKey];
+    const handleSizeChange = useCallback4(debounce((nextSize) => {
+      return dispatch(createIntent4(DeckAction.UpdatePlankSize, {
+        id: sizeKey,
+        size: nextSize
+      }));
+    }, 200), [
+      dispatch,
+      sizeKey
+    ]);
+    const handleKeyDown = useCallback4((event) => {
+      if (event.target === event.currentTarget && event.key === "Escape") {
+        rootElement.current?.closest("main")?.focus();
+      }
+    }, []);
+    useLayoutEffect(() => {
+      if (scrollIntoView === id) {
+        const focusable = rootElement.current?.querySelector("button") || rootElement.current;
+        focusable?.focus({
+          preventScroll: true
+        });
+        layoutMode === "deck" && focusable?.scrollIntoView({
+          behavior: "smooth",
+          inline: "center"
+        });
+        void dispatch(createIntent4(LayoutAction3.ScrollIntoView, {
+          part: "current",
+          subject: void 0
+        }));
+      }
+    }, [
+      id,
+      scrollIntoView,
+      layoutMode
+    ]);
+    const isSolo = layoutMode.startsWith("solo") && part === "solo";
+    const isAttendable = layoutMode.startsWith("solo") && part.startsWith("solo") || layoutMode === "deck" && part === "deck";
+    const sizeAttrs = useMainSize();
+    const data = useMemo2(() => node && {
+      subject: node.data,
+      companionTo: primary?.data,
+      variant,
+      path,
+      popoverAnchorId
+    }, [
+      node,
+      node?.data,
+      path,
+      popoverAnchorId,
+      primary?.data,
+      variant
+    ]);
+    const placeholder = useMemo2(() => /* @__PURE__ */ React6.createElement(PlankLoading, null), []);
+    const Root = part.startsWith("solo") ? "article" : StackItem2.Root;
+    const className = mx3("attention-surface relative dx-focus-ring-inset-over-all", isSolo && mainIntrinsicSize, isSolo && railGridHorizontal, isSolo && "absolute inset-0", part.startsWith("solo") && "grid", part === "deck" && (companioned === "companion" ? "!border-separator border-ie" : "!border-separator border-li"), part.startsWith("solo-") && "row-span-2 grid-rows-subgrid min-is-0", part === "solo-companion" && "!border-separator border-is");
+    return /* @__PURE__ */ React6.createElement(Root, {
+      ref: rootElement,
+      "data-testid": "deck.plank",
+      tabIndex: 0,
+      ...part.startsWith("solo") ? {
+        ...sizeAttrs,
+        className
+      } : {
+        item: {
+          id
+        },
+        size,
+        onSizeChange: handleSizeChange,
+        classNames: className,
+        order,
+        role: "article"
+      },
+      ...isAttendable ? attentionAttrs : {},
+      onKeyDown: handleKeyDown
+    }, node ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(PlankHeading, {
+      id,
+      part: part.startsWith("solo-") ? "solo" : part,
+      node,
+      layoutMode,
+      deckEnabled: settings?.enableDeck,
+      canIncrementStart,
+      canIncrementEnd,
+      popoverAnchorId,
+      primaryId: primary?.id,
+      companioned,
+      companions
+    }), /* @__PURE__ */ React6.createElement(Surface2, {
+      key: node.id,
+      role: "article",
+      data,
+      limit: 1,
+      fallback: PlankContentError,
+      placeholder
+    })) : /* @__PURE__ */ React6.createElement(PlankError, {
+      id,
+      part
+    }), canResize && /* @__PURE__ */ React6.createElement(StackItem2.ResizeHandle, null));
+  } finally {
+    _effect.f();
+  }
+});
+
+// packages/plugins/plugin-deck/src/components/Sidebar/ComplementarySidebar.tsx
+var label = [
+  "complementary sidebar title",
+  {
+    ns: DECK_PLUGIN
+  }
+];
+var ComplementarySidebar = ({ current }) => {
+  var _effect = _useSignals7();
+  try {
+    const { t } = useTranslation5(DECK_PLUGIN);
+    const { dispatchPromise: dispatch } = useIntentDispatcher5();
+    const layout = useCapability3(DeckCapabilities.MutableDeckState);
+    const layoutMode = getMode(layout.deck);
+    const breakpoint = useBreakpoints();
+    const topbar = layoutAppliesTopbar(breakpoint, layoutMode);
+    const hoistStatusbar = useHoistStatusbar(breakpoint, layoutMode);
+    const companions = useDeckCompanions();
+    const activeCompanion = companions.find((companion) => getCompanionId(companion.id) === current);
+    const activeId = activeCompanion && getCompanionId(activeCompanion.id);
+    const [internalValue, setInternalValue] = useState2(activeId);
+    useEffect3(() => {
+      setInternalValue(activeId);
+    }, [
+      activeId
+    ]);
+    const handleTabClick = useCallback5((event) => {
+      const nextValue = event.currentTarget.getAttribute("data-value");
+      if (nextValue === activeId) {
+        layout.complementarySidebarState = layout.complementarySidebarState === "expanded" ? "collapsed" : "expanded";
+      } else {
+        setInternalValue(nextValue);
+        layout.complementarySidebarState = "expanded";
+        void dispatch(createIntent5(LayoutAction4.UpdateComplementary, {
+          part: "complementary",
+          subject: nextValue
+        }));
+      }
+    }, [
+      layout,
+      activeId,
+      dispatch
+    ]);
+    const data = useMemo3(() => activeCompanion && {
+      id: activeCompanion.id,
+      subject: activeCompanion.data
+    }, [
+      activeCompanion?.id,
+      activeCompanion?.data
+    ]);
+    useEffect3(() => {
+      if (!activeId) {
+        void dispatch(createIntent5(LayoutAction4.UpdateComplementary, {
+          part: "complementary",
+          options: {
+            state: "collapsed"
+          }
+        }));
+      }
+    }, [
+      activeId,
+      dispatch
+    ]);
+    return /* @__PURE__ */ React7.createElement(Main.ComplementarySidebar, {
+      label,
+      classNames: [
+        topbar && "block-start-[calc(env(safe-area-inset-top)+var(--rail-size))]",
+        hoistStatusbar && "block-end-[--statusbar-size]"
+      ]
+    }, /* @__PURE__ */ React7.createElement(Tabs.Root, {
+      orientation: "vertical",
+      verticalVariant: "stateless",
+      value: internalValue,
+      classNames: "contents"
+    }, /* @__PURE__ */ React7.createElement("div", {
+      role: "none",
+      className: "absolute z-[1] inset-block-0 inline-end-0 !is-[--r0-size] pbs-[env(safe-area-inset-top)] pbe-[env(safe-area-inset-bottom)] border-is border-subduedSeparator grid grid-cols-1 grid-rows-[1fr_min-content] bg-baseSurface contain-layout app-drag"
+    }, /* @__PURE__ */ React7.createElement(Tabs.Tablist, {
+      classNames: "grid grid-cols-1 auto-rows-[--rail-action] p-1 gap-1 !overflow-y-auto"
+    }, companions.map((companion) => /* @__PURE__ */ React7.createElement(Tabs.Tab, {
+      key: getCompanionId(companion.id),
+      value: getCompanionId(companion.id),
+      asChild: true
+    }, /* @__PURE__ */ React7.createElement(IconButton4, {
+      label: toLocalizedString2(companion.properties.label, t),
+      icon: companion.properties.icon,
+      size: 5,
+      iconOnly: true,
+      tooltipSide: "left",
+      "data-value": getCompanionId(companion.id),
+      variant: activeId === getCompanionId(companion.id) ? layout.complementarySidebarState === "expanded" ? "primary" : "default" : "ghost",
+      onClick: handleTabClick
+    })))), !hoistStatusbar && /* @__PURE__ */ React7.createElement("div", {
+      role: "none",
+      className: "grid grid-cols-1 auto-rows-[--rail-item] p-1 overflow-y-auto"
+    }, /* @__PURE__ */ React7.createElement(Surface3, {
+      role: "status-bar--r0-footer",
+      limit: 1
+    })), /* @__PURE__ */ React7.createElement("div", {
+      role: "none",
+      className: "hidden lg:grid grid-cols-1 auto-rows-[--rail-action] p-1"
+    }, /* @__PURE__ */ React7.createElement(ToggleComplementarySidebarButton, null))), activeId && companions.map((companion) => /* @__PURE__ */ React7.createElement(Tabs.Tabpanel, {
+      key: getCompanionId(companion.id),
+      value: getCompanionId(companion.id),
+      classNames: 'absolute data-[state="inactive"]:-z-[1] inset-block-0 inline-start-0 is-[calc(100%-var(--r0-size))] lg:is-[--r1-size] grid grid-cols-1 grid-rows-[var(--rail-size)_1fr_min-content] pbs-[env(safe-area-inset-top)]',
+      ...layout.complementarySidebarState !== "expanded" && {
+        inert: "true"
+      }
+    }, /* @__PURE__ */ React7.createElement(ComplementarySidebarPanel, {
+      companion,
+      activeId,
+      data,
+      hoistStatusbar
+    })))));
+  } finally {
+    _effect.f();
+  }
+};
+var ScrollArea = ({ children }) => {
+  var _effect = _useSignals7();
+  try {
+    return /* @__PURE__ */ React7.createElement("div", {
+      className: "flex flex-col grow overflow-x-hidden overflow-y-auto scrollbar-thin"
+    }, children);
+  } finally {
+    _effect.f();
+  }
+};
+var ComplementarySidebarPanel = ({ companion, activeId, data, hoistStatusbar }) => {
+  var _effect = _useSignals7();
+  try {
+    const { t } = useTranslation5(DECK_PLUGIN);
+    if (getCompanionId(companion.id) !== activeId && !data) {
+      return null;
+    }
+    const Wrapper = companion.properties.fixed ? Fragment2 : ScrollArea;
+    return /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement("h2", {
+      className: "flex items-center pli-2 border-subduedSeparator border-be font-medium"
+    }, toLocalizedString2(companion.properties.label, t)), /* @__PURE__ */ React7.createElement(Wrapper, null, /* @__PURE__ */ React7.createElement(Surface3, {
+      role: `deck-companion--${getCompanionId(companion.id)}`,
+      data,
+      fallback: PlankContentError,
+      placeholder: /* @__PURE__ */ React7.createElement(PlankLoading, null)
+    })), !hoistStatusbar && /* @__PURE__ */ React7.createElement("div", {
+      role: "contentinfo",
+      className: "flex flex-wrap justify-center items-center border-bs border-subduedSeparator pbs-1 pbe-[max(env(safe-area-inset-bottom),0.25rem)]"
+    }, /* @__PURE__ */ React7.createElement(Surface3, {
+      role: "status-bar--r1-footer",
+      limit: 1
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/Sidebar/Sidebar.tsx
+import { useSignals as _useSignals8 } from "@preact-signals/safe-react/tracking";
+import React8, { useMemo as useMemo4 } from "react";
+import { Surface as Surface4, useCapability as useCapability4 } from "@dxos/app-framework";
+import { Main as Main2 } from "@dxos/react-ui";
+var label2 = [
+  "sidebar title",
+  {
+    ns: DECK_PLUGIN
+  }
+];
+var Sidebar = () => {
+  var _effect = _useSignals8();
+  try {
+    const { popoverAnchorId, activeDeck: current, deck } = useCapability4(DeckCapabilities.DeckState);
+    const breakpoint = useBreakpoints();
+    const layoutMode = getMode(deck);
+    const topbar = layoutAppliesTopbar(breakpoint, layoutMode);
+    const hoistStatusbar = useHoistStatusbar(breakpoint, layoutMode);
+    const navigationData = useMemo4(() => ({
+      popoverAnchorId,
+      topbar,
+      hoistStatusbar,
+      current
+    }), [
+      popoverAnchorId,
+      topbar,
+      hoistStatusbar,
+      current
+    ]);
+    return /* @__PURE__ */ React8.createElement(Main2.NavigationSidebar, {
+      label: label2,
+      classNames: [
+        "grid",
+        topbar && "block-start-[calc(env(safe-area-inset-top)+var(--rail-size))]",
+        hoistStatusbar && "block-end-[--statusbar-size]"
+      ]
+    }, /* @__PURE__ */ React8.createElement(Surface4, {
+      role: "navigation",
+      data: navigationData,
+      limit: 1
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Banner.tsx
+var Banner = ({ variant, classNames }) => {
+  var _effect = _useSignals9();
+  try {
+    const { t } = useTranslation6(DECK_PLUGIN);
+    return /* @__PURE__ */ React9.createElement("header", {
+      className: mx4("flex items-stretch relative plb-1 pis-1 pie-2", variant === "topbar" && "fixed inset-inline-0 block-start-[env(safe-area-inset-top)] bs-[--rail-size] border-be border-separator", classNames)
+    }, variant === "sidebar" ? /* @__PURE__ */ React9.createElement(CloseSidebarButton, null) : /* @__PURE__ */ React9.createElement(ToggleSidebarButton, null), /* @__PURE__ */ React9.createElement("span", {
+      className: "self-center grow mis-1"
+    }, t("current app name", {
+      ns: "appkit"
+    })), variant === "topbar" && /* @__PURE__ */ React9.createElement("div", {
+      role: "none",
+      className: "absolute inset-0 pointer-events-none"
+    }, /* @__PURE__ */ React9.createElement("div", {
+      role: "none",
+      className: "grid bs-full pointer-fine:p-1 max-is-md mli-auto pointer-events-auto"
+    }, /* @__PURE__ */ React9.createElement(Surface5, {
+      role: "search-input",
+      limit: 1
+    }))), /* @__PURE__ */ React9.createElement("span", {
+      role: "none",
+      className: "grow"
+    }), /* @__PURE__ */ React9.createElement(Surface5, {
+      role: "header-end",
+      limit: 1
+    }), /* @__PURE__ */ React9.createElement(Surface5, {
+      role: "notch-start",
+      limit: 1
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/DeckLayout.tsx
+import { useSignals as _useSignals17 } from "@preact-signals/safe-react/tracking";
+import { untracked } from "@preact/signals-core";
+import React17, { useCallback as useCallback7, useEffect as useEffect5, useMemo as useMemo6, useRef as useRef3, Fragment as Fragment3 } from "react";
+import { Capabilities, LayoutAction as LayoutAction5, createIntent as createIntent6, useCapability as useCapability8, useIntentDispatcher as useIntentDispatcher6, usePluginManager } from "@dxos/app-framework";
+import { AttentionCapabilities } from "@dxos/plugin-attention";
+import { Main as Main3, useMediaQuery, useOnTransition } from "@dxos/react-ui";
+import { Stack, StackContext, DEFAULT_HORIZONTAL_SIZE } from "@dxos/react-ui-stack";
+import { mainPaddingTransitions } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ActiveNode.tsx
+import { useSignals as _useSignals10 } from "@preact-signals/safe-react/tracking";
+import React10 from "react";
+import { Surface as Surface6, useAppGraph as useAppGraph3 } from "@dxos/app-framework";
+import { useNode as useNode2 } from "@dxos/plugin-graph";
+import { useAttended } from "@dxos/react-ui-attention";
+var ActiveNode = () => {
+  var _effect = _useSignals10();
+  try {
+    const [id] = useAttended();
+    const { graph } = useAppGraph3();
+    const activeNode = useNode2(graph, id);
+    useNodeActionExpander(activeNode);
+    return /* @__PURE__ */ React10.createElement("div", {
+      role: "none",
+      className: "sr-only"
+    }, /* @__PURE__ */ React10.createElement(Surface6, {
+      role: "document-title",
+      data: {
+        subject: activeNode
+      },
+      limit: 1
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ContentEmpty.tsx
+import { useSignals as _useSignals11 } from "@preact-signals/safe-react/tracking";
+import React11 from "react";
+import { Surface as Surface7, useCapability as useCapability5 } from "@dxos/app-framework";
+var ContentEmpty = () => {
+  var _effect = _useSignals11();
+  try {
+    const breakpoint = useBreakpoints();
+    const { deck } = useCapability5(DeckCapabilities.MutableDeckState);
+    const layoutMode = getMode(deck);
+    const topbar = layoutAppliesTopbar(breakpoint, layoutMode);
+    return /* @__PURE__ */ React11.createElement("div", {
+      role: "none",
+      className: "grid place-items-center p-8 relative bg-deckSurface",
+      "data-testid": "layoutPlugin.firstRunMessage"
+    }, /* @__PURE__ */ React11.createElement(Surface7, {
+      role: "keyshortcuts"
+    }), !topbar && /* @__PURE__ */ React11.createElement(ToggleSidebarButton, {
+      variant: "default",
+      classNames: fixedSidebarToggleStyles
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Dialog.tsx
+import { useSignals as _useSignals12 } from "@preact-signals/safe-react/tracking";
+import React12 from "react";
+import { Surface as Surface8, useCapability as useCapability6 } from "@dxos/app-framework";
+import { AlertDialog, Dialog as NaturalDialog } from "@dxos/react-ui";
+var Dialog = () => {
+  var _effect = _useSignals12();
+  try {
+    const context = useCapability6(DeckCapabilities.MutableDeckState);
+    const { dialogOpen, dialogType, dialogBlockAlign, dialogOverlayClasses, dialogOverlayStyle, dialogContent } = context;
+    const Root = dialogType === "alert" ? AlertDialog.Root : NaturalDialog.Root;
+    const Overlay = dialogType === "alert" ? AlertDialog.Overlay : NaturalDialog.Overlay;
+    return /* @__PURE__ */ React12.createElement(Root, {
+      modal: dialogBlockAlign !== "end",
+      open: dialogOpen,
+      onOpenChange: (nextOpen) => context.dialogOpen = nextOpen
+    }, dialogBlockAlign === "end" ? (
+      // TODO(burdon): Placeholder creates a suspense boundary; replace with defaults.
+      /* @__PURE__ */ React12.createElement(Surface8, {
+        role: "dialog",
+        data: dialogContent,
+        limit: 1,
+        fallback: PlankContentError,
+        placeholder: /* @__PURE__ */ React12.createElement("div", null)
+      })
+    ) : /* @__PURE__ */ React12.createElement(Overlay, {
+      blockAlign: dialogBlockAlign,
+      classNames: dialogOverlayClasses,
+      style: dialogOverlayStyle
+    }, /* @__PURE__ */ React12.createElement(Surface8, {
+      role: "dialog",
+      data: dialogContent,
+      limit: 1,
+      fallback: PlankContentError
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Popover.tsx
+import { useSignals as _useSignals13 } from "@preact-signals/safe-react/tracking";
+import { createContext } from "@radix-ui/react-context";
+import React13, { useCallback as useCallback6, useEffect as useEffect4, useMemo as useMemo5, useRef as useRef2, useState as useState3 } from "react";
+import { Surface as Surface9, useCapability as useCapability7 } from "@dxos/app-framework";
+import { Popover as Popover2 } from "@dxos/react-ui";
+var DEBOUNCE_DELAY = 40;
+var [DeckPopoverProvider, useDeckPopoverContext] = createContext("DeckPopover");
+var PopoverRoot = ({ children }) => {
+  var _effect = _useSignals13();
+  try {
+    const layout = useCapability7(DeckCapabilities.MutableDeckState);
+    const virtualRef = useRef2(null);
+    const [virtualIter, setVirtualIter] = useState3(0);
+    const [open, setOpen] = useState3(false);
+    const debounceRef = useRef2(null);
+    useEffect4(() => {
+      setOpen(false);
+      if (layout.popoverOpen) {
+        if (debounceRef.current) {
+          clearTimeout(debounceRef.current);
+        }
+        if (layout.popoverAnchor && virtualRef.current !== layout.popoverAnchor) {
+          virtualRef.current = layout.popoverAnchor ?? null;
+          setVirtualIter((iter) => iter + 1);
+        }
+        debounceRef.current = setTimeout(() => setOpen(true), DEBOUNCE_DELAY);
+      }
+    }, [
+      layout.popoverOpen,
+      layout.popoverAnchorId,
+      layout.popoverAnchor,
+      layout.popoverContent
+    ]);
+    return /* @__PURE__ */ React13.createElement(DeckPopoverProvider, {
+      setOpen
+    }, /* @__PURE__ */ React13.createElement(Popover2.Root, {
+      modal: false,
+      open
+    }, layout.popoverAnchor && /* @__PURE__ */ React13.createElement(Popover2.VirtualTrigger, {
+      key: virtualIter,
+      virtualRef
+    }), children));
+  } finally {
+    _effect.f();
+  }
+};
+var PopoverContent = () => {
+  var _effect = _useSignals13();
+  try {
+    const layout = useCapability7(DeckCapabilities.MutableDeckState);
+    const { setOpen } = useDeckPopoverContext("PopoverContent");
+    const handleClose = useCallback6((event) => {
+      if (
+        // TODO(thure): CodeMirror should not focus itself when it updates.
+        event.type === "dismissableLayer.focusOutside" && event.currentTarget?.classList.contains("cm-content")
+      ) {
+        event.preventDefault();
+      } else {
+        setOpen(false);
+        layout.popoverOpen = false;
+        layout.popoverAnchor = void 0;
+        layout.popoverAnchorId = void 0;
+        layout.popoverSide = void 0;
+      }
+    }, [
+      setOpen
+    ]);
+    const collisionBoundaries = useMemo5(() => {
+      const closest = layout.popoverAnchor?.closest("[data-popover-collision-boundary]");
+      return closest ? [
+        closest
+      ] : [];
+    }, [
+      layout.popoverAnchor
+    ]);
+    return /* @__PURE__ */ React13.createElement(Popover2.Portal, null, /* @__PURE__ */ React13.createElement(Popover2.Content, {
+      side: layout.popoverSide,
+      onInteractOutside: handleClose,
+      onEscapeKeyDown: handleClose,
+      collisionBoundary: collisionBoundaries,
+      sticky: "always",
+      hideWhenDetached: true
+    }, /* @__PURE__ */ React13.createElement(Popover2.Viewport, null, /* @__PURE__ */ React13.createElement(Surface9, {
+      role: "popover",
+      data: layout.popoverContent,
+      limit: 1
+    })), /* @__PURE__ */ React13.createElement(Popover2.Arrow, null)));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/StatusBar.tsx
+import { useSignals as _useSignals14 } from "@preact-signals/safe-react/tracking";
+import React14 from "react";
+import { Surface as Surface10 } from "@dxos/app-framework";
+import { useLandmarkMover } from "@dxos/react-ui";
+var StatusBar = ({ showHints }) => {
+  var _effect = _useSignals14();
+  try {
+    const mover = useLandmarkMover(void 0, "3");
+    return /* @__PURE__ */ React14.createElement("div", {
+      role: "contentinfo",
+      className: "fixed block-end-0 inset-inline-0 bs-[--statusbar-size] border-bs border-separator z-[2] flex text-description",
+      ...mover
+    }, showHints && /* @__PURE__ */ React14.createElement(Surface10, {
+      role: "hints",
+      limit: 1
+    }), /* @__PURE__ */ React14.createElement(Surface10, {
+      role: "status-bar",
+      limit: 1
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Toast.tsx
+import { useSignals as _useSignals15 } from "@preact-signals/safe-react/tracking";
+import React15 from "react";
+import { Button, Icon as Icon2, Toast as NaturalToast, toLocalizedString as toLocalizedString3, useTranslation as useTranslation7 } from "@dxos/react-ui";
+var Toast = ({ id, title, description, icon, duration, actionLabel, actionAlt, closeLabel, onAction, onOpenChange }) => {
+  var _effect = _useSignals15();
+  try {
+    const { t } = useTranslation7(DECK_PLUGIN);
+    return /* @__PURE__ */ React15.createElement(NaturalToast.Root, {
+      "data-testid": id,
+      defaultOpen: true,
+      duration,
+      onOpenChange
+    }, /* @__PURE__ */ React15.createElement(NaturalToast.Body, null, /* @__PURE__ */ React15.createElement(NaturalToast.Title, {
+      classNames: "items-center"
+    }, icon && /* @__PURE__ */ React15.createElement(Icon2, {
+      icon,
+      size: 5,
+      classNames: "inline mr-1"
+    }), title && /* @__PURE__ */ React15.createElement("span", null, toLocalizedString3(title, t))), description && /* @__PURE__ */ React15.createElement(NaturalToast.Description, null, description && toLocalizedString3(description, t))), /* @__PURE__ */ React15.createElement(NaturalToast.Actions, null, onAction && actionAlt && actionLabel && /* @__PURE__ */ React15.createElement(NaturalToast.Action, {
+      altText: toLocalizedString3(actionAlt, t),
+      asChild: true
+    }, /* @__PURE__ */ React15.createElement(Button, {
+      "data-testid": "toast.action",
+      variant: "primary",
+      onClick: () => onAction?.()
+    }, toLocalizedString3(actionLabel, t))), closeLabel && /* @__PURE__ */ React15.createElement(NaturalToast.Close, {
+      asChild: true
+    }, /* @__PURE__ */ React15.createElement(Button, {
+      "data-testid": "toast.close"
+    }, toLocalizedString3(closeLabel, t)))));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Topbar.tsx
+import { useSignals as _useSignals16 } from "@preact-signals/safe-react/tracking";
+import React16 from "react";
+var Topbar = () => {
+  var _effect = _useSignals16();
+  try {
+    return /* @__PURE__ */ React16.createElement(Banner, {
+      variant: "topbar"
+    });
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/DeckLayout.tsx
+var PlankSeparator = ({ order }) => {
+  var _effect = _useSignals17();
+  try {
+    return order > 0 ? /* @__PURE__ */ React17.createElement("span", {
+      role: "separator",
+      className: "row-span-2 bg-deckSurface is-4",
+      style: {
+        gridColumn: order
+      }
+    }) : null;
+  } finally {
+    _effect.f();
+  }
+};
+var DeckLayout = ({ onDismissToast }) => {
+  var _effect = _useSignals17();
+  try {
+    const { dispatchPromise: dispatch } = useIntentDispatcher6();
+    const settings = useCapability8(Capabilities.SettingsStore).getStore(DECK_PLUGIN).value;
+    const context = useCapability8(DeckCapabilities.MutableDeckState);
+    const { sidebarState, complementarySidebarState, complementarySidebarPanel, deck, toasts } = context;
+    const { active, activeCompanions, fullscreen, solo, plankSizing } = deck;
+    const breakpoint = useBreakpoints();
+    const layoutMode = getMode(deck);
+    const topbar = layoutAppliesTopbar(breakpoint, layoutMode);
+    const hoistStatusbar = useHoistStatusbar(breakpoint, layoutMode);
+    const pluginManager = usePluginManager();
+    const scrollLeftRef = useRef3();
+    const deckRef = useRef3(null);
+    useEffect5(() => {
+      const attended = untracked(() => {
+        const attention = pluginManager.context.getCapability(AttentionCapabilities.Attention);
+        return attention.current;
+      });
+      const firstId = solo ?? active[0];
+      if (attended.length === 0 && firstId) {
+        document.querySelector(`article[data-attendable-id="${firstId}"] button`)?.focus();
+      }
+    }, []);
+    const [isNotMobile] = useMediaQuery("md", {
+      ssr: false
+    });
+    const shouldRevert = useRef3(false);
+    useEffect5(() => {
+      if (!isNotMobile && getMode(deck) === "deck") {
+        const attended = untracked(() => {
+          const attention = pluginManager.context.getCapability(AttentionCapabilities.Attention);
+          return attention.current;
+        });
+        shouldRevert.current = true;
+        void dispatch(createIntent6(LayoutAction5.SetLayoutMode, {
+          part: "mode",
+          subject: attended[0],
+          options: {
+            mode: "solo"
+          }
+        }));
+      } else if (isNotMobile && getMode(deck) === "solo" && shouldRevert.current) {
+        void dispatch(createIntent6(LayoutAction5.SetLayoutMode, {
+          part: "mode",
+          options: {
+            revert: true
+          }
+        }));
+      }
+    }, [
+      isNotMobile,
+      deck,
+      dispatch
+    ]);
+    useEffect5(() => {
+      if (!settings.enableDeck && layoutMode === "deck") {
+        void dispatch(createIntent6(LayoutAction5.SetLayoutMode, {
+          part: "mode",
+          subject: active[0],
+          options: {
+            mode: "solo"
+          }
+        }));
+      }
+    }, [
+      settings.enableDeck,
+      dispatch,
+      active,
+      layoutMode
+    ]);
+    const handleResize = useCallback7(() => {
+      scrollLeftRef.current = null;
+    }, []);
+    useEffect5(() => {
+      window.addEventListener("resize", handleResize);
+      return () => window.removeEventListener("resize", handleResize);
+    }, [
+      handleResize
+    ]);
+    const restoreScroll = useCallback7(() => {
+      if (deckRef.current && scrollLeftRef.current != null) {
+        deckRef.current.scrollLeft = scrollLeftRef.current;
+      }
+    }, []);
+    useOnTransition(layoutMode, (mode) => mode !== "deck", "deck", restoreScroll);
+    const handleScroll = useCallback7((event) => {
+      if (!solo && event.currentTarget === event.target) {
+        scrollLeftRef.current = event.target.scrollLeft;
+      }
+    }, [
+      solo
+    ]);
+    const isEmpty = !solo && active.length === 0;
+    const padding = useMemo6(() => {
+      if (!solo && settings.overscroll === "centering") {
+        return calculateOverscroll(active.length);
+      }
+      return {};
+    }, [
+      solo,
+      settings.overscroll,
+      deck
+    ]);
+    const mainPosition = useMemo6(() => [
+      "grid !block-start-[env(safe-area-inset-top)]",
+      topbar && "!block-start-[calc(env(safe-area-inset-top)+var(--rail-size))]",
+      hoistStatusbar && "lg:block-end-[--statusbar-size]"
+    ], [
+      topbar,
+      hoistStatusbar
+    ]);
+    const { order, itemsCount } = useMemo6(() => {
+      return active.reduce((acc, entryId) => {
+        acc.order[entryId] = acc.itemsCount + 1;
+        acc.itemsCount += activeCompanions?.[entryId] ? 3 : 2;
+        return acc;
+      }, {
+        order: {},
+        itemsCount: 0
+      });
+    }, [
+      active,
+      activeCompanions
+    ]);
+    return /* @__PURE__ */ React17.createElement(PopoverRoot, null, /* @__PURE__ */ React17.createElement(ActiveNode, null), /* @__PURE__ */ React17.createElement(Main3.Root, {
+      navigationSidebarState: fullscreen ? "closed" : context.sidebarState,
+      onNavigationSidebarStateChange: (next) => context.sidebarState = next,
+      complementarySidebarState: fullscreen ? "closed" : context.complementarySidebarState,
+      onComplementarySidebarStateChange: (next) => context.complementarySidebarState = next
+    }, /* @__PURE__ */ React17.createElement(Sidebar, null), /* @__PURE__ */ React17.createElement(ComplementarySidebar, {
+      current: complementarySidebarPanel
+    }), /* @__PURE__ */ React17.createElement(Main3.Overlay, null), isEmpty && /* @__PURE__ */ React17.createElement(Main3.Content, {
+      bounce: true,
+      handlesFocus: true,
+      classNames: mainPosition
+    }, /* @__PURE__ */ React17.createElement(ContentEmpty, null)), !isEmpty && /* @__PURE__ */ React17.createElement(Main3.Content, {
+      bounce: true,
+      handlesFocus: true,
+      classNames: mainPosition,
+      style: {
+        "--dx-main-sidebarWidth": sidebarState === "expanded" ? "var(--nav-sidebar-size)" : sidebarState === "collapsed" ? "var(--l0-size)" : "0",
+        "--dx-main-complementaryWidth": complementarySidebarState === "expanded" ? "var(--complementary-sidebar-size)" : complementarySidebarState === "collapsed" ? "var(--rail-size)" : "0",
+        "--dx-main-contentFirstWidth": `${plankSizing[active[0] ?? "never"] ?? DEFAULT_HORIZONTAL_SIZE}rem`,
+        "--dx-main-contentLastWidth": `${plankSizing[active[(active.length ?? 1) - 1] ?? "never"] ?? DEFAULT_HORIZONTAL_SIZE}rem`
+      }
+    }, /* @__PURE__ */ React17.createElement("div", {
+      role: "none",
+      className: !solo ? "relative bg-deckSurface overflow-hidden" : "sr-only",
+      ...solo && {
+        inert: ""
+      }
+    }, !topbar && !fullscreen && /* @__PURE__ */ React17.createElement(ToggleSidebarButton, {
+      classNames: fixedSidebarToggleStyles
+    }), !topbar && !fullscreen && /* @__PURE__ */ React17.createElement(ToggleComplementarySidebarButton, {
+      classNames: fixedComplementarySidebarToggleStyles
+    }), /* @__PURE__ */ React17.createElement(Stack, {
+      ref: deckRef,
+      orientation: "horizontal",
+      size: "contain",
+      classNames: [
+        "absolute inset-block-0 -inset-inline-px",
+        mainPaddingTransitions
+      ],
+      itemsCount: itemsCount - 1,
+      style: padding,
+      onScroll: handleScroll
+    }, active.map((entryId) => /* @__PURE__ */ React17.createElement(Fragment3, {
+      key: entryId
+    }, /* @__PURE__ */ React17.createElement(PlankSeparator, {
+      order: order[entryId] - 1
+    }), /* @__PURE__ */ React17.createElement(Plank, {
+      id: entryId,
+      companionId: activeCompanions?.[entryId],
+      part: "deck",
+      order: order[entryId],
+      active,
+      layoutMode,
+      settings
+    }))))), /* @__PURE__ */ React17.createElement("div", {
+      role: "none",
+      className: solo ? "relative bg-deckSurface overflow-hidden" : "sr-only",
+      ...!solo && {
+        inert: ""
+      }
+    }, !topbar && !fullscreen && /* @__PURE__ */ React17.createElement(ToggleSidebarButton, {
+      classNames: fixedSidebarToggleStyles
+    }), !topbar && !fullscreen && /* @__PURE__ */ React17.createElement(ToggleComplementarySidebarButton, {
+      classNames: fixedComplementarySidebarToggleStyles
+    }), /* @__PURE__ */ React17.createElement(StackContext.Provider, {
+      value: {
+        size: "contain",
+        orientation: "horizontal",
+        rail: true
+      }
+    }, /* @__PURE__ */ React17.createElement(Plank, {
+      id: solo,
+      companionId: solo ? activeCompanions?.[solo] : void 0,
+      part: "solo",
+      layoutMode,
+      settings
+    })))), topbar && /* @__PURE__ */ React17.createElement(Topbar, null), hoistStatusbar && /* @__PURE__ */ React17.createElement(StatusBar, {
+      showHints: settings.showHints
+    })), /* @__PURE__ */ React17.createElement(PopoverContent, null), /* @__PURE__ */ React17.createElement(Dialog, null), toasts?.map((toast) => /* @__PURE__ */ React17.createElement(Toast, {
+      ...toast,
+      key: toast.id,
+      onOpenChange: (open) => {
+        if (!open) {
+          onDismissToast(toast.id);
+        }
+        return open;
+      }
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckSettings/DeckSettings.tsx
+import { useSignals as _useSignals18 } from "@preact-signals/safe-react/tracking";
+import React18 from "react";
+import { Input, Select, useTranslation as useTranslation8 } from "@dxos/react-ui";
+import { DeprecatedFormContainer, DeprecatedFormInput } from "@dxos/react-ui-form";
+var isSocket = !!globalThis.__args;
+var DeckSettings = ({ settings }) => {
+  var _effect = _useSignals18();
+  try {
+    const { t } = useTranslation8(DECK_PLUGIN);
+    return /* @__PURE__ */ React18.createElement(DeprecatedFormContainer, null, /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+      label: t("settings enable deck label")
+    }, /* @__PURE__ */ React18.createElement(Input.Switch, {
+      checked: settings.enableDeck,
+      onCheckedChange: (checked) => settings.enableDeck = checked
+    })), /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+      label: t("select new plank positioning label")
+    }, /* @__PURE__ */ React18.createElement(Select.Root, {
+      disabled: !settings.enableDeck,
+      value: settings.newPlankPositioning ?? "start",
+      onValueChange: (value) => settings.newPlankPositioning = value
+    }, /* @__PURE__ */ React18.createElement(Select.TriggerButton, {
+      placeholder: t("select new plank positioning placeholder")
+    }), /* @__PURE__ */ React18.createElement(Select.Portal, null, /* @__PURE__ */ React18.createElement(Select.Content, null, /* @__PURE__ */ React18.createElement(Select.Viewport, null, NewPlankPositions.map((position) => /* @__PURE__ */ React18.createElement(Select.Option, {
+      key: position,
+      value: position
+    }, t(`settings new plank position ${position} label`)))))))), /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+      label: t("settings overscroll label")
+    }, /* @__PURE__ */ React18.createElement(Select.Root, {
+      disabled: !settings.enableDeck,
+      value: settings.overscroll ?? "none",
+      onValueChange: (value) => settings.overscroll = value
+    }, /* @__PURE__ */ React18.createElement(Select.TriggerButton, {
+      placeholder: t("select overscroll placeholder")
+    }), /* @__PURE__ */ React18.createElement(Select.Portal, null, /* @__PURE__ */ React18.createElement(Select.Content, null, /* @__PURE__ */ React18.createElement(Select.Viewport, null, OverscrollOptions.map((option) => /* @__PURE__ */ React18.createElement(Select.Option, {
+      key: option,
+      value: option
+    }, t(`settings overscroll ${option} label`)))))))), /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+      label: t("settings enable statusbar label")
+    }, /* @__PURE__ */ React18.createElement(Input.Switch, {
+      checked: settings.enableStatusbar,
+      onCheckedChange: (checked) => settings.enableStatusbar = checked
+    })), /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+      label: t("settings show hints label")
+    }, /* @__PURE__ */ React18.createElement(Input.Switch, {
+      checked: settings.showHints,
+      onCheckedChange: (checked) => settings.showHints = checked
+    })), !isSocket && /* @__PURE__ */ React18.createElement(DeprecatedFormInput, {
+      label: t("settings native redirect label")
+    }, /* @__PURE__ */ React18.createElement(Input.Switch, {
+      checked: settings.enableNativeRedirect,
+      onCheckedChange: (checked) => settings.enableNativeRedirect = checked
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+
+export {
+  Banner,
+  DeckLayout,
+  DeckSettings
+};
+//# sourceMappingURL=chunk-LWXMANOA.mjs.map