@dxos/plugin-deck 0.8.4-main.406dc2a → 0.8.4-main.52d7546f51

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

@@ -0,0 +1,1469 @@
+import {
+  getCompanionId,
+  useBreakpoints,
+  useCompanions,
+  useDeckCompanions,
+  useDeckState,
+  useHoistStatusbar,
+  useMainSize,
+  useNodeActionExpander
+} from "./chunk-YT3AJVUU.mjs";
+import {
+  calculateOverscroll,
+  layoutAppliesTopbar,
+  parseEntryId
+} from "./chunk-NHABISX2.mjs";
+import {
+  DeckCapabilities,
+  DeckOperation,
+  NewPlankPositions,
+  OverscrollOptions,
+  PLANK_COMPANION_TYPE,
+  getMode,
+  meta
+} from "./chunk-DONG2FYU.mjs";
+
+// src/components/DeckLayout/Banner.tsx
+import React9 from "react";
+import { Surface as Surface5 } from "@dxos/app-framework/ui";
+import { useTranslation as useTranslation6 } from "@dxos/react-ui";
+import { mx as mx5, osTranslations } from "@dxos/ui-theme";
+
+// src/components/Sidebar/ComplementarySidebar.tsx
+import React7, { Fragment as Fragment2, useCallback as useCallback5, useEffect as useEffect3, useMemo as useMemo3, useState as useState2 } from "react";
+import { Surface as Surface3, useOperationInvoker as useOperationInvoker5 } from "@dxos/app-framework/ui";
+import { LayoutOperation as LayoutOperation4 } from "@dxos/app-toolkit";
+import { IconButton as IconButton4, Main, ScrollArea, toLocalizedString as toLocalizedString2, useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { Tabs } from "@dxos/react-ui-tabs";
+import { mx as mx4 } from "@dxos/ui-theme";
+
+// src/components/Plank/Plank.tsx
+import { useFocusFinders } from "@fluentui/react-tabster";
+import React5, { memo as memo2, useCallback as useCallback3, useLayoutEffect, useMemo as useMemo2, useRef } from "react";
+import { Surface as Surface2, useOperationInvoker as useOperationInvoker3 } from "@dxos/app-framework/ui";
+import { LayoutOperation as LayoutOperation2 } from "@dxos/app-toolkit";
+import { useAppGraph as useAppGraph2 } from "@dxos/app-toolkit/ui";
+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/ui-theme";
+
+// src/components/Plank/PlankError.tsx
+import React4, { useEffect as useEffect2, useState } from "react";
+import { useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { descriptionMessage, mx as mx2 } from "@dxos/ui-theme";
+
+// src/components/Plank/PlankHeading.tsx
+import React2, { Fragment, memo, useCallback as useCallback2, useEffect, useMemo } from "react";
+import { Surface, useOperationInvoker as useOperationInvoker2 } from "@dxos/app-framework/ui";
+import { LayoutOperation } from "@dxos/app-toolkit";
+import { useAppGraph } from "@dxos/app-toolkit/ui";
+import { Graph, useActionRunner } from "@dxos/plugin-graph";
+import { Icon, IconButton as IconButton2, Popover, toLocalizedString, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { StackItem } from "@dxos/react-ui-stack";
+import { TextTooltip } from "@dxos/react-ui-text-tooltip";
+import { hoverableControls, hoverableFocusedWithinControls } from "@dxos/ui-theme";
+
+// src/components/fragments.ts
+import { mx } from "@dxos/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");
+
+// src/components/Plank/PlankControls.tsx
+import React, { forwardRef, useCallback } from "react";
+import { useOperationInvoker } from "@dxos/app-framework/ui";
+import { invariant } from "@dxos/invariant";
+import { ButtonGroup, IconButton, useTranslation } from "@dxos/react-ui";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-deck/src/components/Plank/PlankControls.tsx";
+var PlankControl = ({ icon, label: label3, ...props }) => {
+  return /* @__PURE__ */ React.createElement(IconButton, {
+    label: label3,
+    icon,
+    iconOnly: true,
+    variant: "ghost",
+    tooltipSide: "bottom",
+    ...props
+  });
+};
+var plankControlSpacing = "pli-2";
+var PlankCompanionControls = /* @__PURE__ */ forwardRef(({ primary }, forwardedRef) => {
+  const { t } = useTranslation(meta.id);
+  const { invokePromise } = useOperationInvoker();
+  const handleCloseCompanion = useCallback(() => {
+    invariant(primary, void 0, {
+      F: __dxlog_file,
+      L: 49,
+      S: void 0,
+      A: [
+        "primary",
+        ""
+      ]
+    });
+    return invokePromise(DeckOperation.ChangeCompanion, {
+      primary,
+      companion: null
+    });
+  }, [
+    invokePromise,
+    primary
+  ]);
+  return /* @__PURE__ */ React.createElement("div", {
+    ref: forwardedRef,
+    className: "contents app-no-drag"
+  }, /* @__PURE__ */ React.createElement(PlankControl, {
+    label: t("close companion label"),
+    variant: "ghost",
+    icon: "ph--x--regular",
+    onClick: handleCloseCompanion,
+    classNames: plankControlSpacing
+  }));
+});
+var PlankControls = /* @__PURE__ */ forwardRef(({ children, classNames, variant = "default", capabilities, layoutMode, pin, close = false, onClick, ...props }, forwardedRef) => {
+  const { t } = useTranslation(meta.id);
+  const buttonClassNames = variant === "hide-disabled" ? `disabled:hidden ${plankControlSpacing}` : plankControlSpacing;
+  const layoutIsAnySolo = !!layoutMode?.startsWith("solo");
+  return /* @__PURE__ */ React.createElement(ButtonGroup, {
+    ...props,
+    classNames: [
+      "app-no-drag !opacity-100",
+      classNames
+    ],
+    ref: forwardedRef
+  }, capabilities.deck ? /* @__PURE__ */ React.createElement(React.Fragment, null, capabilities.solo && /* @__PURE__ */ React.createElement(React.Fragment, null, layoutMode === "solo" && /* @__PURE__ */ React.createElement(PlankControl, {
+    label: t("show fullscreen plank label"),
+    classNames: buttonClassNames,
+    icon: "ph--corners-out--regular",
+    onClick: () => onClick?.("solo--fullscreen")
+  }), /* @__PURE__ */ React.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__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(PlankControl, {
+    label: t("increment start label"),
+    disabled: !capabilities.incrementStart,
+    classNames: buttonClassNames,
+    icon: "ph--caret-left--regular",
+    onClick: () => onClick?.("increment-start")
+  }), /* @__PURE__ */ React.createElement(PlankControl, {
+    label: t("increment end label"),
+    disabled: !capabilities.incrementEnd,
+    classNames: buttonClassNames,
+    icon: "ph--caret-right--regular",
+    onClick: () => onClick?.("increment-end")
+  }))) : capabilities.fullscreen && /* @__PURE__ */ React.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__ */ React.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__ */ React.createElement(PlankControl, {
+    label: t("open companion label"),
+    classNames: buttonClassNames,
+    "data-testid": "plankHeading.companion",
+    icon: "ph--square-split-horizontal--regular",
+    onClick: () => onClick?.("companion")
+  }), children);
+});
+
+// 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 = [] }) => {
+  const { t } = useTranslation2(meta.id);
+  const { invokePromise, invokeSync } = useOperationInvoker2();
+  const runAction = useActionRunner();
+  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: meta.id
+    }
+  ], t);
+  const isCompanionNode = node?.type === PLANK_COMPANION_TYPE;
+  useEffect(() => {
+    const frame = requestAnimationFrame(() => {
+      if (node) {
+        void Graph.expand(graph, 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(graph, node.id).filter((a) => [
+          "list-item",
+          "list-item-primary",
+          "heading-list-item"
+        ].includes(a.properties.disposition))
+      ].filter((a) => a.length > 0);
+    }
+  }, [
+    actions,
+    node,
+    variant,
+    graph
+  ]);
+  const handleAction = useCallback2((action) => {
+    if (typeof action.data === "function") {
+      void runAction(action, {
+        parent: node,
+        caller: meta.id
+      });
+    }
+  }, [
+    node,
+    runAction
+  ]);
+  const handlePlankAction = useCallback2((eventType) => {
+    if (eventType.startsWith("solo")) {
+      return invokePromise(DeckOperation.Adjust, {
+        type: eventType,
+        id
+      });
+    } else if (eventType === "close") {
+      if (part === "complementary") {
+        return invokeSync(LayoutOperation.UpdateComplementary, {
+          state: "collapsed"
+        });
+      } else {
+        return invokeSync(LayoutOperation.Close, {
+          subject: [
+            id
+          ]
+        });
+      }
+    } else {
+      return invokePromise(DeckOperation.Adjust, {
+        type: eventType,
+        id
+      });
+    }
+  }, [
+    invokePromise,
+    invokeSync,
+    id,
+    part
+  ]);
+  const ActionRoot = node && popoverAnchorId === `dxos.org/ui/${meta.id}/${node.id}` ? Popover.Anchor : Fragment;
+  const handleTabClick = useCallback2((event) => {
+    const target = event.target.closest("[data-id]");
+    const tabId = target?.dataset?.id;
+    if (primaryId && tabId) {
+      void invokePromise(DeckOperation.ChangeCompanion, {
+        primary: primaryId,
+        companion: tabId
+      });
+    }
+  }, [
+    primaryId,
+    invokePromise
+  ]);
+  return /* @__PURE__ */ React2.createElement(StackItem.Heading, {
+    classNames: [
+      "plb-1 items-stretch gap-1 sticky inline-start-12 app-drag min-is-0 contain-layout density-coarse",
+      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 ? (
+    /* TODO(thure): IMPORTANT: This is a tablist; it should be implemented as such. */
+    /* @__PURE__ */ React2.createElement("div", {
+      role: "none",
+      className: "flex-1 min-is-0 overflow-x-auto scrollbar-none flex gap-1"
+    }, companions.map(({ id: id2, properties: { icon: icon2, label: label4 } }) => /* @__PURE__ */ React2.createElement(IconButton2, {
+      key: id2,
+      "data-id": id2,
+      icon: icon2,
+      iconOnly: companions.length > MAX_COMPANIONS && node?.id !== id2,
+      label: toLocalizedString(label4, t),
+      variant: node?.id === id2 ? "primary" : "ghost",
+      onClick: handleTabClick
+    })))
+  ) : /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(ActionRoot, null, node && sigilActions ? /* @__PURE__ */ React2.createElement(StackItem.Sigil, {
+    icon,
+    related: part === "complementary",
+    attendableId,
+    triggerLabel: t("actions menu label"),
+    actions: sigilActions,
+    onAction: handleAction
+  }, /* @__PURE__ */ React2.createElement(Surface.Surface, {
+    role: "menu-footer",
+    data: {
+      subject: node.data
+    }
+  })) : /* @__PURE__ */ React2.createElement(StackItem.SigilButton, null, /* @__PURE__ */ React2.createElement("span", {
+    className: "sr-only"
+  }, label3), /* @__PURE__ */ React2.createElement(Icon, {
+    icon
+  }))), /* @__PURE__ */ React2.createElement(TextTooltip, {
+    text: label3,
+    onlyWhenTruncating: true
+  }, /* @__PURE__ */ React2.createElement(StackItem.HeadingLabel, {
+    attendableId,
+    related: part === "complementary",
+    ...pending && {
+      classNames: "text-description"
+    }
+  }, label3))), node && part !== "complementary" && /* @__PURE__ */ React2.createElement(Surface.Surface, {
+    role: "navbar-end",
+    data: {
+      subject: node.data
+    }
+  }), companioned === "companion" ? /* @__PURE__ */ React2.createElement(PlankCompanionControls, {
+    primary: primaryId
+  }) : /* @__PURE__ */ React2.createElement(PlankControls, {
+    capabilities,
+    layoutMode,
+    close: part === "complementary" ? "minify-end" : true,
+    onClick: handlePlankAction
+  }));
+});
+
+// src/components/Plank/PlankLoading.tsx
+import React3 from "react";
+var PlankLoading = () => {
+  return /* @__PURE__ */ React3.createElement("div", {
+    role: "none",
+    className: "grid place-items-center attention-surface"
+  });
+};
+
+// src/components/Plank/PlankError.tsx
+var PlankContentError = ({ error }) => {
+  const { t } = useTranslation3(meta.id);
+  const errorString = error?.toString() ?? "";
+  return /* @__PURE__ */ React4.createElement("div", {
+    role: "none",
+    className: "overflow-y-auto p-8 attention-surface grid place-items-center"
+  }, /* @__PURE__ */ React4.createElement("p", {
+    role: "alert",
+    className: mx2(descriptionMessage, "break-all rounded-md p-4")
+  }, error ? errorString : t("error fallback message")));
+};
+var PlankError = ({ id, part, node, error }) => {
+  const [timedOut, setTimedOut] = useState(false);
+  useEffect2(() => {
+    setTimeout(() => setTimedOut(true), 5e3);
+  }, []);
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(PlankHeading, {
+    id,
+    part,
+    node,
+    pending: !timedOut
+  }), timedOut ? /* @__PURE__ */ React4.createElement(PlankContentError, {
+    error
+  }) : /* @__PURE__ */ React4.createElement(PlankLoading, null));
+};
+
+// src/components/Plank/Plank.tsx
+var UNKNOWN_ID = "unknown_id";
+var Plank = /* @__PURE__ */ memo2(({ id = UNKNOWN_ID, companionId, ...props }) => {
+  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__ */ React5.createElement(PlankContainer, {
+    solo: props.part === "solo",
+    companion: hasCompanion,
+    encapsulate: !!props.settings?.encapsulatedPlanks
+  }, /* @__PURE__ */ React5.createElement(PlankComponent, {
+    id,
+    node,
+    companioned: hasCompanion ? "primary" : void 0,
+    companions: hasCompanion ? [] : companions,
+    ...props,
+    ...props.part === "solo" ? {
+      part: "solo-primary"
+    } : {}
+  }), hasCompanion && /* @__PURE__ */ React5.createElement(PlankComponent, {
+    id: companionId,
+    node: currentCompanion,
+    primary: node,
+    companions,
+    companioned: "companion",
+    ...props,
+    ...props.part === "solo" ? {
+      part: "solo-companion"
+    } : {
+      order: (props.order ?? 0) + 1
+    }
+  }));
+});
+var PlankContainer = ({ children, solo, companion, encapsulate }) => {
+  const sizeAttrs = useMainSize();
+  if (!solo) {
+    return children;
+  }
+  return /* @__PURE__ */ React5.createElement("div", {
+    role: "none",
+    "data-popover-collision-boundary": true,
+    className: mx3("absolute inset-[--main-spacing] grid", encapsulate && "border border-separator rounded overflow-hidden", companion && "grid-cols-[6fr_4fr]", railGridHorizontal, mainIntrinsicSize),
+    ...sizeAttrs
+  }, children);
+};
+var PlankComponent = /* @__PURE__ */ memo2(({ layoutMode, id, part, path, order, active, companioned, node, primary, companions, settings }) => {
+  const { invokePromise } = useOperationInvoker3();
+  const { state, deck } = useDeckState();
+  const { popoverAnchorId, scrollIntoView } = state;
+  const { findFirstFocusable } = useFocusFinders();
+  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 = useCallback3(debounce((nextSize) => {
+    return invokePromise(DeckOperation.UpdatePlankSize, {
+      id: sizeKey,
+      size: nextSize
+    });
+  }, 200), [
+    invokePromise,
+    sizeKey
+  ]);
+  const handleKeyDown = useCallback3((event) => {
+    if (event.target === event.currentTarget) {
+      switch (event.key) {
+        case "Escape":
+          rootElement.current?.closest("main")?.focus();
+          break;
+        case "Enter":
+          rootElement.current && findFirstFocusable(rootElement.current)?.focus();
+          break;
+      }
+    }
+  }, []);
+  useLayoutEffect(() => {
+    if (scrollIntoView === id) {
+      layoutMode === "deck" && rootElement.current?.scrollIntoView({
+        behavior: "smooth",
+        inline: "center"
+      });
+      void invokePromise(LayoutOperation2.ScrollIntoView, {
+        subject: void 0
+      });
+    }
+  }, [
+    id,
+    scrollIntoView,
+    layoutMode,
+    invokePromise
+  ]);
+  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 && {
+    attendableId: id,
+    subject: node.data,
+    companionTo: primary?.data,
+    properties: node.properties,
+    variant,
+    path,
+    popoverAnchorId
+  }, [
+    node,
+    node?.data,
+    node?.properties,
+    path,
+    popoverAnchorId,
+    primary?.data,
+    variant
+  ]);
+  const placeholder = useMemo2(() => /* @__PURE__ */ React5.createElement(PlankLoading, null), []);
+  const Root = part.startsWith("solo") ? "article" : StackItem2.Root;
+  const fullscreen = layoutMode === "solo--fullscreen";
+  const className = mx3("attention-surface relative dx-focus-ring-inset-over-all density-coarse", isSolo && "absolute inset-0", isSolo && mainIntrinsicSize, railGridHorizontal, part.startsWith("solo") && "grid", part.startsWith("solo-") && "grid-rows-subgrid row-span-2 min-is-0", fullscreen && "grid-rows-1", part === "deck" && (companioned === "companion" ? "!border-separator border-ie" : "!border-separator border-li"), part === "solo-companion" && "!border-separator border-is", settings?.encapsulatedPlanks && !part.startsWith("solo") && "mli-[--main-spacing] !border-separator border rounded overflow-hidden");
+  return /* @__PURE__ */ React5.createElement(Root, {
+    ref: rootElement,
+    "data-testid": "deck.plank",
+    "data-popover-collision-boundary": true,
+    tabIndex: 0,
+    ...part.startsWith("solo") ? {
+      ...sizeAttrs,
+      className
+    } : {
+      item: {
+        id
+      },
+      size,
+      onSizeChange: handleSizeChange,
+      classNames: className,
+      order,
+      role: "article"
+    },
+    ...isAttendable ? attentionAttrs : {},
+    onKeyDown: handleKeyDown
+  }, node ? /* @__PURE__ */ React5.createElement(React5.Fragment, null, !fullscreen && /* @__PURE__ */ React5.createElement(PlankHeading, {
+    id,
+    part: part.startsWith("solo-") ? "solo" : part,
+    node,
+    layoutMode,
+    deckEnabled: settings?.enableDeck,
+    canIncrementStart,
+    canIncrementEnd,
+    popoverAnchorId,
+    primaryId: primary?.id,
+    companioned,
+    companions
+  }), /* @__PURE__ */ React5.createElement(Surface2.Surface, {
+    key: node.id,
+    role: "article",
+    data,
+    limit: 1,
+    fallback: PlankContentError,
+    placeholder
+  })) : /* @__PURE__ */ React5.createElement(PlankError, {
+    id,
+    part
+  }), canResize && /* @__PURE__ */ React5.createElement(StackItem2.ResizeHandle, null));
+});
+
+// src/components/Sidebar/SidebarButton.tsx
+import React6, { useCallback as useCallback4 } from "react";
+import { useOperationInvoker as useOperationInvoker4 } from "@dxos/app-framework/ui";
+import { LayoutOperation as LayoutOperation3 } from "@dxos/app-toolkit";
+import { IconButton as IconButton3, useTranslation as useTranslation4 } from "@dxos/react-ui";
+var ToggleSidebarButton = ({ classNames, variant = "ghost" }) => {
+  const { updateState } = useDeckState();
+  const { t } = useTranslation4(meta.id);
+  const handleClick = useCallback4(() => {
+    updateState((state) => ({
+      ...state,
+      sidebarState: state.sidebarState === "expanded" ? "collapsed" : "expanded"
+    }));
+  }, [
+    updateState
+  ]);
+  return /* @__PURE__ */ React6.createElement(IconButton3, {
+    variant,
+    icon: "ph--sidebar--regular",
+    iconOnly: true,
+    size: 4,
+    label: t("open navigation sidebar label"),
+    onClick: handleClick,
+    classNames
+  });
+};
+var CloseSidebarButton = () => {
+  const { updateState } = useDeckState();
+  const { t } = useTranslation4(meta.id);
+  const handleClick = useCallback4(() => {
+    updateState((state) => ({
+      ...state,
+      sidebarState: "collapsed"
+    }));
+  }, [
+    updateState
+  ]);
+  return /* @__PURE__ */ React6.createElement(IconButton3, {
+    variant: "ghost",
+    icon: "ph--caret-line-left--regular",
+    iconOnly: true,
+    size: 4,
+    label: t("close navigation sidebar label"),
+    onClick: handleClick,
+    classNames: "rounded-none pli-1 dx-focus-ring-inset pie-[max(.5rem,env(safe-area-inset-left))]"
+  });
+};
+var ToggleComplementarySidebarButton = ({ inR0, classNames, current }) => {
+  const { invokeSync } = useOperationInvoker4();
+  const { state, updateState } = useDeckState();
+  const { t } = useTranslation4(meta.id);
+  const companions = useDeckCompanions();
+  const handleClick = useCallback4(() => {
+    const nextState = state.complementarySidebarState === "expanded" ? "collapsed" : "expanded";
+    updateState((state2) => ({
+      ...state2,
+      complementarySidebarState: nextState
+    }));
+    const subject = state.complementarySidebarPanel ?? (companions[0] && getCompanionId(companions[0].id));
+    if (nextState === "expanded" && !current && subject) {
+      invokeSync(LayoutOperation3.UpdateComplementary, {
+        subject
+      });
+    }
+  }, [
+    state,
+    updateState,
+    current,
+    companions,
+    invokeSync
+  ]);
+  return /* @__PURE__ */ React6.createElement(IconButton3, {
+    variant: "ghost",
+    classNames: [
+      "[&>svg]:-scale-x-100",
+      classNames
+    ],
+    icon: "ph--sidebar-simple--regular",
+    iconOnly: true,
+    label: t("open complementary sidebar label"),
+    size: inR0 ? 5 : 4,
+    tooltipSide: inR0 ? "left" : void 0,
+    onClick: handleClick
+  });
+};
+
+// src/components/Sidebar/ComplementarySidebar.tsx
+var label = [
+  "complementary sidebar title",
+  {
+    ns: meta.id
+  }
+];
+var ComplementarySidebar = ({ current }) => {
+  const { t } = useTranslation5(meta.id);
+  const { invokeSync } = useOperationInvoker5();
+  const { state, deck, updateState } = useDeckState();
+  const layoutMode = getMode(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) {
+      updateState((state2) => ({
+        ...state2,
+        complementarySidebarState: state2.complementarySidebarState === "expanded" ? "collapsed" : "expanded"
+      }));
+    } else {
+      setInternalValue(nextValue);
+      updateState((state2) => ({
+        ...state2,
+        complementarySidebarState: "expanded"
+      }));
+      invokeSync(LayoutOperation4.UpdateComplementary, {
+        subject: nextValue
+      });
+    }
+  }, [
+    state.complementarySidebarState,
+    activeId,
+    invokeSync,
+    updateState
+  ]);
+  const data = useMemo3(() => activeCompanion && {
+    id: activeCompanion.id,
+    subject: activeCompanion.data
+  }, [
+    activeCompanion?.id,
+    activeCompanion?.data
+  ]);
+  useEffect3(() => {
+    if (!activeId) {
+      invokeSync(LayoutOperation4.UpdateComplementary, {
+        state: "collapsed"
+      });
+    }
+  }, [
+    activeId,
+    invokeSync
+  ]);
+  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: mx4("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,
+    iconOnly: true,
+    tooltipSide: "left",
+    "data-value": getCompanionId(companion.id),
+    variant: activeId === getCompanionId(companion.id) ? state.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.Surface, {
+    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] overflow-hidden',
+      "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)]"
+    ],
+    ...state.complementarySidebarState !== "expanded" && {
+      inert: true
+    }
+  }, /* @__PURE__ */ React7.createElement(ComplementarySidebarPanel, {
+    companion,
+    activeId,
+    data,
+    hoistStatusbar
+  })))));
+};
+var ComplementarySidebarPanel = ({ companion, activeId, data, hoistStatusbar }) => {
+  const { t } = useTranslation5(meta.id);
+  if (getCompanionId(companion.id) !== activeId && !data) {
+    return null;
+  }
+  const Wrapper = companion.properties.fixed ? Fragment2 : ScrollAreaWrapper;
+  return /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement("div", {
+    role: "none",
+    className: "flex items-center p-1 gap-1 border-be border-subduedSeparator"
+  }, /* @__PURE__ */ React7.createElement(IconButton4, {
+    label: toLocalizedString2(companion.properties.label, t),
+    icon: companion.properties.icon,
+    iconOnly: true,
+    tooltipSide: "left",
+    "data-value": getCompanionId(companion.id),
+    classNames: "bs-10 is-10",
+    variant: "default"
+  }), /* @__PURE__ */ React7.createElement("div", {
+    role: "none",
+    className: "pli-1"
+  }, toLocalizedString2(companion.properties.label, t))), /* @__PURE__ */ React7.createElement(Wrapper, null, /* @__PURE__ */ React7.createElement(Surface3.Surface, {
+    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.Surface, {
+    role: "status-bar--r1-footer",
+    limit: 1
+  })));
+};
+var ScrollAreaWrapper = ({ children }) => {
+  return /* @__PURE__ */ React7.createElement(ScrollArea.Root, {
+    thin: true,
+    orientation: "vertical",
+    classNames: "grow"
+  }, /* @__PURE__ */ React7.createElement(ScrollArea.Viewport, null, children));
+};
+
+// src/components/Sidebar/Sidebar.tsx
+import React8, { useMemo as useMemo4 } from "react";
+import { Surface as Surface4 } from "@dxos/app-framework/ui";
+import { Main as Main2 } from "@dxos/react-ui";
+var label2 = [
+  "sidebar title",
+  {
+    ns: meta.id
+  }
+];
+var Sidebar = () => {
+  const { state, deck } = useDeckState();
+  const { popoverAnchorId, activeDeck: current } = state;
+  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.Surface, {
+    role: "navigation",
+    data: navigationData,
+    limit: 1
+  }));
+};
+
+// src/components/DeckLayout/Banner.tsx
+var Banner = ({ variant, classNames }) => {
+  const { t } = useTranslation6(meta.id);
+  return /* @__PURE__ */ React9.createElement("header", {
+    className: mx5("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: osTranslations
+  })), 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.Surface, {
+    role: "search-input",
+    limit: 1
+  }))), /* @__PURE__ */ React9.createElement("span", {
+    role: "none",
+    className: "grow"
+  }), /* @__PURE__ */ React9.createElement(Surface5.Surface, {
+    role: "header-end",
+    limit: 1
+  }), /* @__PURE__ */ React9.createElement(Surface5.Surface, {
+    role: "notch-start",
+    limit: 1
+  }));
+};
+
+// src/components/DeckLayout/DeckLayout.tsx
+import React18 from "react";
+import { Mosaic } from "@dxos/react-ui-mosaic";
+
+// src/components/DeckLayout/ActiveNode.tsx
+import React10 from "react";
+import { Surface as Surface6 } from "@dxos/app-framework/ui";
+import { useAppGraph as useAppGraph3 } from "@dxos/app-toolkit/ui";
+import { useNode as useNode2 } from "@dxos/plugin-graph";
+import { useAttended } from "@dxos/react-ui-attention";
+var ActiveNode = () => {
+  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.Surface, {
+    role: "document-title",
+    data: {
+      subject: activeNode
+    },
+    limit: 1
+  }));
+};
+
+// src/components/DeckLayout/DeckMain.tsx
+import React14, { Fragment as Fragment3, useCallback as useCallback6, useEffect as useEffect4, useMemo as useMemo5, useRef as useRef2 } from "react";
+import { useAtomCapability, useOperationInvoker as useOperationInvoker6, usePluginManager } from "@dxos/app-framework/ui";
+import { LayoutOperation as LayoutOperation5 } from "@dxos/app-toolkit";
+import { AttentionCapabilities } from "@dxos/plugin-attention";
+import { Main as Main3, useMediaQuery, useOnTransition } from "@dxos/react-ui";
+import { DEFAULT_HORIZONTAL_SIZE, Stack, StackContext } from "@dxos/react-ui-stack";
+import { mainPaddingTransitions, mx as mx6 } from "@dxos/ui-theme";
+
+// src/components/DeckLayout/ContentEmpty.tsx
+import React11 from "react";
+import { Surface as Surface7 } from "@dxos/app-framework/ui";
+var ContentEmpty = () => {
+  const breakpoint = useBreakpoints();
+  const { deck } = useDeckState();
+  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.Surface, {
+    role: "keyshortcuts"
+  }), !topbar && /* @__PURE__ */ React11.createElement(ToggleSidebarButton, {
+    variant: "default",
+    classNames: fixedSidebarToggleStyles
+  }));
+};
+
+// src/components/DeckLayout/StatusBar.tsx
+import React12 from "react";
+import { Surface as Surface8 } from "@dxos/app-framework/ui";
+import { useLandmarkMover } from "@dxos/react-ui";
+var StatusBar = ({ showHints }) => {
+  const mover = useLandmarkMover(void 0, "3");
+  return /* @__PURE__ */ React12.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__ */ React12.createElement(Surface8.Surface, {
+    role: "hints",
+    limit: 1
+  }), /* @__PURE__ */ React12.createElement(Surface8.Surface, {
+    role: "status-bar",
+    limit: 1
+  }));
+};
+
+// src/components/DeckLayout/Topbar.tsx
+import React13 from "react";
+var Topbar = () => {
+  return /* @__PURE__ */ React13.createElement(Banner, {
+    variant: "topbar"
+  });
+};
+
+// src/components/DeckLayout/DeckMain.tsx
+var DeckMain = () => {
+  const { invokeSync } = useOperationInvoker6();
+  const settings = useAtomCapability(DeckCapabilities.Settings);
+  const { state, deck, updateState } = useDeckState();
+  const { sidebarState, complementarySidebarState, complementarySidebarPanel } = state;
+  const { active, activeCompanions, fullscreen, solo, plankSizing } = deck;
+  const layoutMode = getMode(deck);
+  const breakpoint = useBreakpoints();
+  const topbar = layoutAppliesTopbar(breakpoint, layoutMode);
+  const hoistStatusbar = useHoistStatusbar(breakpoint, layoutMode);
+  const pluginManager = usePluginManager();
+  const scrollLeftRef = useRef2(null);
+  const deckRef = useRef2(null);
+  useEffect4(() => {
+    const attention = pluginManager.capabilities.get(AttentionCapabilities.Attention);
+    const attended = attention.getCurrent();
+    const firstId = solo ?? active[0];
+    if (attended.length === 0 && firstId) {
+      document.querySelector(`article[data-attendable-id="${firstId}"] button`)?.focus();
+    }
+  }, []);
+  const [isNotMobile] = useMediaQuery("md");
+  const shouldRevert = useRef2(false);
+  useEffect4(() => {
+    if (!isNotMobile && layoutMode === "deck") {
+      const attention = pluginManager.capabilities.get(AttentionCapabilities.Attention);
+      const attended = attention.getCurrent();
+      shouldRevert.current = true;
+      invokeSync(LayoutOperation5.SetLayoutMode, {
+        subject: attended[0],
+        mode: "solo"
+      });
+    } else if (isNotMobile && layoutMode === "solo" && shouldRevert.current) {
+      invokeSync(LayoutOperation5.SetLayoutMode, {
+        revert: true
+      });
+    }
+  }, [
+    isNotMobile,
+    layoutMode,
+    invokeSync
+  ]);
+  useEffect4(() => {
+    if (!settings?.enableDeck && layoutMode === "deck") {
+      invokeSync(LayoutOperation5.SetLayoutMode, {
+        subject: active[0],
+        mode: "solo"
+      });
+    }
+  }, [
+    settings?.enableDeck,
+    invokeSync,
+    active,
+    layoutMode
+  ]);
+  const handleResize = useCallback6(() => {
+    scrollLeftRef.current = null;
+  }, []);
+  useEffect4(() => {
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, [
+    handleResize
+  ]);
+  const restoreScroll = useCallback6(() => {
+    if (deckRef.current && scrollLeftRef.current != null) {
+      deckRef.current.scrollLeft = scrollLeftRef.current;
+    }
+  }, []);
+  useOnTransition(layoutMode, (mode) => mode !== "deck", "deck", restoreScroll);
+  const handleScroll = useCallback6((event) => {
+    if (!solo && event.currentTarget === event.target) {
+      scrollLeftRef.current = event.target.scrollLeft;
+    }
+  }, [
+    solo
+  ]);
+  const isEmpty = !solo && active.length === 0;
+  const padding = useMemo5(() => {
+    if (!solo && settings?.overscroll === "centering") {
+      return calculateOverscroll(active.length);
+    }
+    return {};
+  }, [
+    solo,
+    settings?.overscroll,
+    deck
+  ]);
+  const mainPosition = useMemo5(() => [
+    "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 } = useMemo5(() => {
+    return active.reduce((acc, entryId) => {
+      acc.order[entryId] = acc.itemsCount + 1;
+      acc.itemsCount += activeCompanions?.[entryId] ? 3 : 2;
+      return acc;
+    }, {
+      order: {},
+      itemsCount: 0
+    });
+  }, [
+    active,
+    activeCompanions
+  ]);
+  const handleNavigationSidebarStateChange = useCallback6((next) => {
+    updateState((s) => ({
+      ...s,
+      sidebarState: next
+    }));
+  }, [
+    updateState
+  ]);
+  const handleComplementarySidebarStateChange = useCallback6((next) => {
+    updateState((s) => ({
+      ...s,
+      complementarySidebarState: next
+    }));
+  }, [
+    updateState
+  ]);
+  return /* @__PURE__ */ React14.createElement(Main3.Root, {
+    navigationSidebarState: fullscreen ? "closed" : sidebarState,
+    complementarySidebarState: fullscreen ? "closed" : complementarySidebarState,
+    onNavigationSidebarStateChange: handleNavigationSidebarStateChange,
+    onComplementarySidebarStateChange: handleComplementarySidebarStateChange
+  }, /* @__PURE__ */ React14.createElement(Sidebar, null), /* @__PURE__ */ React14.createElement(ComplementarySidebar, {
+    current: complementarySidebarPanel
+  }), /* @__PURE__ */ React14.createElement(Main3.Overlay, null), isEmpty && /* @__PURE__ */ React14.createElement(Main3.Content, {
+    bounce: true,
+    handlesFocus: true,
+    classNames: mainPosition
+  }, /* @__PURE__ */ React14.createElement(ContentEmpty, null)), !isEmpty && /* @__PURE__ */ React14.createElement(Main3.Content, {
+    bounce: true,
+    handlesFocus: true,
+    classNames: mainPosition,
+    style: {
+      "--main-spacing": settings?.encapsulatedPlanks ? "0.75rem" : "0",
+      "--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__ */ React14.createElement("div", {
+    role: "none",
+    className: !solo ? "relative bg-deckSurface overflow-hidden" : "sr-only",
+    ...solo && {
+      inert: true
+    }
+  }, !topbar && !fullscreen && /* @__PURE__ */ React14.createElement(ToggleSidebarButton, {
+    classNames: fixedSidebarToggleStyles
+  }), !topbar && !fullscreen && /* @__PURE__ */ React14.createElement(ToggleComplementarySidebarButton, {
+    classNames: fixedComplementarySidebarToggleStyles
+  }), /* @__PURE__ */ React14.createElement(Stack, {
+    ref: deckRef,
+    orientation: "horizontal",
+    size: "contain",
+    itemsCount: itemsCount - 1,
+    classNames: [
+      "absolute inset-block-[--main-spacing] -inset-inline-px bs-[calc(100%-2*var(--main-spacing))]",
+      mainPaddingTransitions
+    ],
+    style: padding,
+    onScroll: handleScroll
+  }, active.map((entryId) => /* @__PURE__ */ React14.createElement(Fragment3, {
+    key: entryId
+  }, /* @__PURE__ */ React14.createElement(PlankSeparator, {
+    order: order[entryId] - 1,
+    encapsulate: !!settings?.enableDeck
+  }), /* @__PURE__ */ React14.createElement(Plank, {
+    id: entryId,
+    companionId: activeCompanions?.[entryId],
+    part: "deck",
+    order: order[entryId],
+    active,
+    layoutMode,
+    settings
+  }))))), /* @__PURE__ */ React14.createElement("div", {
+    role: "none",
+    className: solo ? "relative overflow-hidden bg-deckSurface" : "sr-only",
+    ...!solo && {
+      inert: true
+    }
+  }, !topbar && !fullscreen && /* @__PURE__ */ React14.createElement(ToggleSidebarButton, {
+    classNames: fixedSidebarToggleStyles
+  }), !topbar && !fullscreen && /* @__PURE__ */ React14.createElement(ToggleComplementarySidebarButton, {
+    classNames: fixedComplementarySidebarToggleStyles
+  }), /* @__PURE__ */ React14.createElement(StackContext.Provider, {
+    value: {
+      orientation: "horizontal",
+      size: "contain",
+      rail: true
+    }
+  }, /* @__PURE__ */ React14.createElement(Plank, {
+    id: solo,
+    companionId: solo ? activeCompanions?.[solo] : void 0,
+    part: "solo",
+    layoutMode,
+    settings
+  })))), topbar && /* @__PURE__ */ React14.createElement(Topbar, null), hoistStatusbar && /* @__PURE__ */ React14.createElement(StatusBar, {
+    showHints: settings?.showHints
+  }));
+};
+var PlankSeparator = ({ order, encapsulate }) => order > 0 ? /* @__PURE__ */ React14.createElement("span", {
+  role: "separator",
+  className: mx6("row-span-2 bg-deckSurface", encapsulate ? "is-0" : "is-4"),
+  style: {
+    gridColumn: order
+  }
+}) : null;
+
+// src/components/DeckLayout/Dialog.tsx
+import React15, { useCallback as useCallback7 } from "react";
+import { Surface as Surface9 } from "@dxos/app-framework/ui";
+import { AlertDialog, Dialog as NaturalDialog } from "@dxos/react-ui";
+var Dialog = () => {
+  const { state, updateEphemeral } = useDeckState();
+  const { dialogOpen, dialogType, dialogBlockAlign, dialogOverlayClasses, dialogOverlayStyle, dialogContent } = state;
+  const Root = dialogType === "alert" ? AlertDialog.Root : NaturalDialog.Root;
+  const Overlay = dialogType === "alert" ? AlertDialog.Overlay : NaturalDialog.Overlay;
+  const handleOpenChange = useCallback7((nextOpen) => {
+    updateEphemeral((s) => ({
+      ...s,
+      dialogOpen: nextOpen
+    }));
+  }, [
+    updateEphemeral
+  ]);
+  return /* @__PURE__ */ React15.createElement(Root, {
+    modal: dialogBlockAlign !== "end",
+    open: dialogOpen,
+    onOpenChange: handleOpenChange
+  }, dialogBlockAlign === "end" ? (
+    // TODO(burdon): Placeholder creates a suspense boundary; replace with defaults.
+    /* @__PURE__ */ React15.createElement(Surface9.Surface, {
+      role: "dialog",
+      data: dialogContent,
+      limit: 1,
+      fallback: PlankContentError,
+      placeholder: /* @__PURE__ */ React15.createElement("div", null)
+    })
+  ) : /* @__PURE__ */ React15.createElement(Overlay, {
+    blockAlign: dialogBlockAlign,
+    classNames: dialogOverlayClasses,
+    style: dialogOverlayStyle
+  }, /* @__PURE__ */ React15.createElement(Surface9.Surface, {
+    role: "dialog",
+    data: dialogContent,
+    limit: 1,
+    fallback: PlankContentError
+  })));
+};
+
+// src/components/DeckLayout/Popover.tsx
+import { createContext } from "@radix-ui/react-context";
+import React16, { useCallback as useCallback8, useEffect as useEffect5, useRef as useRef3, useState as useState3 } from "react";
+import { Surface as Surface10, useOperationInvoker as useOperationInvoker7 } from "@dxos/app-framework/ui";
+import { LayoutOperation as LayoutOperation6 } from "@dxos/app-toolkit";
+import { Popover as Popover2, toLocalizedString as toLocalizedString3, useTranslation as useTranslation7 } from "@dxos/react-ui";
+import { Card } from "@dxos/react-ui-mosaic";
+var DEBOUNCE_DELAY = 40;
+var [DeckPopoverProvider, useDeckPopoverContext] = createContext("DeckPopover");
+var PopoverRoot = ({ children }) => {
+  const { state } = useDeckState();
+  const virtualRef = useRef3(null);
+  const [virtualIter, setVirtualIter] = useState3(0);
+  const [open, setOpen] = useState3(false);
+  const debounceRef = useRef3(null);
+  useEffect5(() => {
+    setOpen(false);
+    if (state.popoverOpen) {
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+      }
+      if (state.popoverAnchor && virtualRef.current !== state.popoverAnchor) {
+        virtualRef.current = state.popoverAnchor ?? null;
+        setVirtualIter((iter) => iter + 1);
+      }
+      debounceRef.current = setTimeout(() => setOpen(true), DEBOUNCE_DELAY);
+    }
+  }, [
+    state.popoverOpen,
+    state.popoverAnchorId,
+    state.popoverAnchor,
+    state.popoverContent
+  ]);
+  return /* @__PURE__ */ React16.createElement(DeckPopoverProvider, {
+    setOpen
+  }, /* @__PURE__ */ React16.createElement(Popover2.Root, {
+    modal: false,
+    open
+  }, state.popoverAnchor && /* @__PURE__ */ React16.createElement(Popover2.VirtualTrigger, {
+    key: virtualIter,
+    virtualRef
+  }), children));
+};
+var PopoverContent = () => {
+  const { t } = useTranslation7(meta.id);
+  const { state, updateEphemeral } = useDeckState();
+  const { setOpen } = useDeckPopoverContext("PopoverContent");
+  const { invokeSync } = useOperationInvoker7();
+  const handleClose = useCallback8(() => {
+    setOpen(false);
+    updateEphemeral((state2) => ({
+      ...state2,
+      popoverOpen: false,
+      popoverAnchor: void 0,
+      popoverAnchorId: void 0,
+      popoverSide: void 0
+    }));
+  }, [
+    updateEphemeral
+  ]);
+  const handleInteractOutside = useCallback8((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 {
+      handleClose();
+    }
+  }, [
+    handleClose
+  ]);
+  return /* @__PURE__ */ React16.createElement(Popover2.Portal, null, /* @__PURE__ */ React16.createElement(Popover2.Content, {
+    side: state.popoverSide,
+    sticky: "always",
+    hideWhenDetached: true,
+    onInteractOutside: handleInteractOutside,
+    onEscapeKeyDown: handleInteractOutside
+  }, /* @__PURE__ */ React16.createElement(Popover2.Viewport, null, state.popoverKind === "base" && /* @__PURE__ */ React16.createElement(Surface10.Surface, {
+    role: "popover",
+    data: state.popoverContent,
+    limit: 1
+  }), state.popoverKind === "card" && /* @__PURE__ */ React16.createElement(Card.Root, {
+    border: false,
+    classNames: "popover-card-max-width"
+  }, /* @__PURE__ */ React16.createElement(Card.Toolbar, null, state.popoverContentRef ? /* @__PURE__ */ React16.createElement(Card.ToolbarIconButton, {
+    icon: "ph--arrow-square-out--regular",
+    iconOnly: true,
+    label: t("open item label"),
+    onClick: () => {
+      invokeSync(LayoutOperation6.Open, {
+        subject: [
+          state.popoverContentRef
+        ]
+      });
+    }
+  }) : /* @__PURE__ */ React16.createElement("div", null), state.popoverTitle ? /* @__PURE__ */ React16.createElement(Card.Title, null, toLocalizedString3(state.popoverTitle, t)) : /* @__PURE__ */ React16.createElement("span", null), /* @__PURE__ */ React16.createElement(Card.Close, {
+    onClick: handleClose
+  })), /* @__PURE__ */ React16.createElement(Surface10.Surface, {
+    role: "card--content",
+    data: state.popoverContent,
+    limit: 1
+  }))), /* @__PURE__ */ React16.createElement(Popover2.Arrow, null)));
+};
+
+// src/components/DeckLayout/Toast.tsx
+import React17 from "react";
+import { Button, Icon as Icon2, Toast as NaturalToast, toLocalizedString as toLocalizedString4, useTranslation as useTranslation8 } from "@dxos/react-ui";
+var Toast = ({ id, title, description, icon, duration, actionLabel, actionAlt, closeLabel, onAction, onOpenChange }) => {
+  const { t } = useTranslation8(meta.id);
+  return /* @__PURE__ */ React17.createElement(NaturalToast.Root, {
+    "data-testid": id,
+    defaultOpen: true,
+    duration,
+    onOpenChange
+  }, /* @__PURE__ */ React17.createElement(NaturalToast.Body, null, /* @__PURE__ */ React17.createElement(NaturalToast.Title, {
+    classNames: "items-center"
+  }, icon && /* @__PURE__ */ React17.createElement(Icon2, {
+    icon,
+    classNames: "inline mr-1"
+  }), title && /* @__PURE__ */ React17.createElement("span", null, toLocalizedString4(title, t))), description && /* @__PURE__ */ React17.createElement(NaturalToast.Description, null, description && toLocalizedString4(description, t))), /* @__PURE__ */ React17.createElement(NaturalToast.Actions, null, onAction && actionAlt && actionLabel && /* @__PURE__ */ React17.createElement(NaturalToast.Action, {
+    altText: toLocalizedString4(actionAlt, t),
+    asChild: true
+  }, /* @__PURE__ */ React17.createElement(Button, {
+    "data-testid": "toast.action",
+    variant: "primary",
+    onClick: () => onAction?.()
+  }, toLocalizedString4(actionLabel, t))), closeLabel && /* @__PURE__ */ React17.createElement(NaturalToast.Close, {
+    asChild: true
+  }, /* @__PURE__ */ React17.createElement(Button, {
+    "data-testid": "toast.close"
+  }, toLocalizedString4(closeLabel, t)))));
+};
+var Toaster = ({ toasts, onDismissToast }) => {
+  return /* @__PURE__ */ React17.createElement(React17.Fragment, null, toasts?.map((toast) => /* @__PURE__ */ React17.createElement(Toast, {
+    ...toast,
+    key: toast.id,
+    onOpenChange: (open) => {
+      if (!open) {
+        onDismissToast?.(toast.id);
+      }
+      return open;
+    }
+  })));
+};
+
+// src/components/DeckLayout/DeckLayout.tsx
+var DeckLayout = ({ onDismissToast }) => {
+  const { state } = useDeckState();
+  const { toasts } = state;
+  return /* @__PURE__ */ React18.createElement(Mosaic.Root, null, /* @__PURE__ */ React18.createElement(PopoverRoot, null, /* @__PURE__ */ React18.createElement(ActiveNode, null), /* @__PURE__ */ React18.createElement(DeckMain, null), /* @__PURE__ */ React18.createElement(PopoverContent, null), /* @__PURE__ */ React18.createElement(Dialog, null), /* @__PURE__ */ React18.createElement(Toaster, {
+    toasts,
+    onDismissToast
+  })));
+};
+
+// src/components/DeckSettings/DeckSettings.tsx
+import React19 from "react";
+import { Input, Select, useTranslation as useTranslation9 } from "@dxos/react-ui";
+import { Settings } from "@dxos/react-ui-form";
+var isSocket = !!globalThis.__args;
+var DeckSettings = ({ settings, onSettingsChange }) => {
+  const { t } = useTranslation9(meta.id);
+  return /* @__PURE__ */ React19.createElement(Settings.Root, null, /* @__PURE__ */ React19.createElement(Settings.Section, {
+    title: t("settings title", {
+      ns: meta.id
+    })
+  }, /* @__PURE__ */ React19.createElement(Settings.Group, null, /* @__PURE__ */ React19.createElement(Settings.ItemInput, {
+    title: t("settings enable deck label")
+  }, /* @__PURE__ */ React19.createElement(Input.Switch, {
+    checked: settings.enableDeck,
+    onCheckedChange: (checked) => onSettingsChange((s) => ({
+      ...s,
+      enableDeck: checked
+    }))
+  })), /* @__PURE__ */ React19.createElement(Settings.ItemInput, {
+    title: t("settings encapsulated planks label")
+  }, /* @__PURE__ */ React19.createElement(Input.Switch, {
+    checked: settings.encapsulatedPlanks ?? false,
+    onCheckedChange: (checked) => onSettingsChange((s) => ({
+      ...s,
+      encapsulatedPlanks: checked
+    }))
+  })), /* @__PURE__ */ React19.createElement(Settings.ItemInput, {
+    title: t("select new plank positioning label")
+  }, /* @__PURE__ */ React19.createElement(Select.Root, {
+    disabled: !settings.enableDeck,
+    value: settings.newPlankPositioning ?? "start",
+    onValueChange: (value) => onSettingsChange((s) => ({
+      ...s,
+      newPlankPositioning: value
+    }))
+  }, /* @__PURE__ */ React19.createElement(Select.TriggerButton, {
+    placeholder: t("select new plank positioning placeholder")
+  }), /* @__PURE__ */ React19.createElement(Select.Portal, null, /* @__PURE__ */ React19.createElement(Select.Content, null, /* @__PURE__ */ React19.createElement(Select.Viewport, null, NewPlankPositions.map((position) => /* @__PURE__ */ React19.createElement(Select.Option, {
+    key: position,
+    value: position
+  }, t(`settings new plank position ${position} label`)))), /* @__PURE__ */ React19.createElement(Select.Arrow, null))))), /* @__PURE__ */ React19.createElement(Settings.ItemInput, {
+    title: t("settings overscroll label")
+  }, /* @__PURE__ */ React19.createElement(Select.Root, {
+    disabled: !settings.enableDeck,
+    value: settings.overscroll ?? "none",
+    onValueChange: (value) => onSettingsChange((s) => ({
+      ...s,
+      overscroll: value
+    }))
+  }, /* @__PURE__ */ React19.createElement(Select.TriggerButton, {
+    placeholder: t("select overscroll placeholder")
+  }), /* @__PURE__ */ React19.createElement(Select.Portal, null, /* @__PURE__ */ React19.createElement(Select.Content, null, /* @__PURE__ */ React19.createElement(Select.Viewport, null, OverscrollOptions.map((option) => /* @__PURE__ */ React19.createElement(Select.Option, {
+    key: option,
+    value: option
+  }, t(`settings overscroll ${option} label`)))), /* @__PURE__ */ React19.createElement(Select.Arrow, null))))), /* @__PURE__ */ React19.createElement(Settings.ItemInput, {
+    title: t("settings enable statusbar label")
+  }, /* @__PURE__ */ React19.createElement(Input.Switch, {
+    checked: settings.enableStatusbar,
+    onCheckedChange: (checked) => onSettingsChange((s) => ({
+      ...s,
+      enableStatusbar: checked
+    }))
+  })), /* @__PURE__ */ React19.createElement(Settings.ItemInput, {
+    title: t("settings show hints label")
+  }, /* @__PURE__ */ React19.createElement(Input.Switch, {
+    checked: settings.showHints,
+    onCheckedChange: (checked) => onSettingsChange((s) => ({
+      ...s,
+      showHints: checked
+    }))
+  })), !isSocket && /* @__PURE__ */ React19.createElement(Settings.ItemInput, {
+    title: t("settings native redirect label")
+  }, /* @__PURE__ */ React19.createElement(Input.Switch, {
+    checked: settings.enableNativeRedirect,
+    onCheckedChange: (checked) => onSettingsChange((s) => ({
+      ...s,
+      enableNativeRedirect: checked
+    }))
+  })))));
+};
+
+export {
+  Banner,
+  DeckLayout,
+  DeckSettings
+};
+//# sourceMappingURL=chunk-JGC4ZLG3.mjs.map