@dxos/plugin-deck 0.6.8-main.046e6cf

package/dist/lib/browser/index.mjs

@@ -0,0 +1,1657 @@
+import {
+  DECK_PLUGIN,
+  meta_default
+} from "./chunk-YVHGFQQR.mjs";
+
+// packages/plugins/plugin-deck/src/DeckPlugin.tsx
+import { ArrowsOut } from "@phosphor-icons/react";
+import { batch, effect } from "@preact/signals-core";
+import { setAutoFreeze } from "immer";
+import React14 from "react";
+import { IntentAction, LayoutAction as LayoutAction3, NavigationAction as NavigationAction3, parseGraphPlugin, parseIntentPlugin, resolvePlugin, Toast as ToastSchema, SLUG_PATH_SEPARATOR as SLUG_PATH_SEPARATOR5, isLayoutParts, isLayoutAdjustment, isLayoutMode, openIds as openIds2 } from "@dxos/app-framework";
+import { create, getTypename, isReactiveObject } from "@dxos/echo-schema";
+import { LocalStorageStore } from "@dxos/local-storage";
+import { log } from "@dxos/log";
+import { parseAttentionPlugin } from "@dxos/plugin-attention";
+import { parseClientPlugin } from "@dxos/plugin-client";
+import { createExtension } from "@dxos/plugin-graph";
+import { ObservabilityAction } from "@dxos/plugin-observability/meta";
+import { fullyQualifiedId } from "@dxos/react-client/echo";
+import { translations as deckTranslations } from "@dxos/react-ui-deck";
+import { Mosaic } from "@dxos/react-ui-mosaic";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/constants.ts
+var NAV_ID = "NavTree";
+var SURFACE_PREFIX = "surface:";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/DeckLayout.tsx
+import { Sidebar as MenuIcon } from "@phosphor-icons/react";
+import React12, { useMemo as useMemo2 } from "react";
+import { SLUG_PATH_SEPARATOR as SLUG_PATH_SEPARATOR3, Surface as Surface8, firstIdInPart, usePlugin } from "@dxos/app-framework";
+import { Button as Button3, Dialog, Main as Main3, Popover as Popover2, useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { Deck } from "@dxos/react-ui-deck";
+import { getSize, mx as mx4 } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ActiveNode.tsx
+import React from "react";
+import { Surface } from "@dxos/app-framework";
+import { useGraph } from "@dxos/plugin-graph";
+
+// packages/plugins/plugin-deck/src/hooks/useNode.ts
+import { useEffect, useState } from "react";
+var useNode = (graph, id, timeout) => {
+  const [nodeState, setNodeState] = useState(id ? graph.findNode(id) : void 0);
+  useEffect(() => {
+    if (nodeState?.id === id || !id) {
+      return;
+    }
+    const frame = requestAnimationFrame(async () => {
+      try {
+        const node = await graph.waitForNode(id, timeout);
+        if (node) {
+          setNodeState(node);
+        }
+      } catch {
+      }
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [
+    graph,
+    id,
+    timeout,
+    nodeState?.id
+  ]);
+  return nodeState;
+};
+
+// packages/plugins/plugin-deck/src/hooks/useNodeActionExpander.ts
+import { useEffect as useEffect2 } from "react";
+import { ACTION_GROUP_TYPE, ACTION_TYPE, getGraph } from "@dxos/plugin-graph";
+var expandNodeActions = async (node) => {
+  const graph = getGraph(node);
+  await graph.expand(node, "outbound", ACTION_GROUP_TYPE);
+  await graph.expand(node, "outbound", ACTION_TYPE);
+};
+var useNodeActionExpander = (node) => {
+  useEffect2(() => {
+    if (node) {
+      const frame = requestAnimationFrame(() => {
+        void expandNodeActions(node);
+      });
+      return () => cancelAnimationFrame(frame);
+    }
+  }, [
+    node
+  ]);
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ActiveNode.tsx
+var ActiveNode = ({ id }) => {
+  const { graph } = useGraph();
+  const activeNode = useNode(graph, id);
+  useNodeActionExpander(activeNode);
+  return /* @__PURE__ */ React.createElement("div", {
+    role: "none",
+    className: "sr-only"
+  }, /* @__PURE__ */ React.createElement(Surface, {
+    role: "document-title",
+    data: {
+      activeNode
+    },
+    limit: 1
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ComplementarySidebar.tsx
+import React5 from "react";
+import { SLUG_PATH_SEPARATOR as SLUG_PATH_SEPARATOR2, Surface as Surface3 } from "@dxos/app-framework";
+import { useGraph as useGraph3 } from "@dxos/plugin-graph";
+import { Main } from "@dxos/react-ui";
+import { createAttendableAttributes } from "@dxos/react-ui-attention";
+import { deckGrid } from "@dxos/react-ui-deck";
+import { mx as mx2 } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/NodePlankHeading.tsx
+import { Placeholder } from "@phosphor-icons/react";
+import React2, { Fragment, useEffect as useEffect3 } from "react";
+import { LayoutAction, NavigationAction, SLUG_COLLECTION_INDICATOR, SLUG_PATH_SEPARATOR, Surface as Surface2, useIntentDispatcher, indexInPart, partLength } from "@dxos/app-framework";
+import { useGraph as useGraph2 } from "@dxos/plugin-graph";
+import { Popover, toLocalizedString, useMediaQuery, useTranslation } from "@dxos/react-ui";
+import { PlankHeading, plankHeadingIconProps } from "@dxos/react-ui-deck";
+import { TextTooltip } from "@dxos/react-ui-text-tooltip";
+var NodePlankHeading = ({
+  node,
+  id,
+  layoutParts,
+  layoutPart,
+  // TODO(wittjosiah): Unused?
+  layoutEntry,
+  popoverAnchorId,
+  pending,
+  flatDeck
+}) => {
+  const { t } = useTranslation(DECK_PLUGIN);
+  const { graph } = useGraph2();
+  const Icon = node?.properties?.icon ?? Placeholder;
+  const label = pending ? t("pending heading") : toLocalizedString(node?.properties?.label ?? [
+    "plank heading fallback label",
+    {
+      ns: DECK_PLUGIN
+    }
+  ], t);
+  const dispatch = useIntentDispatcher();
+  const ActionRoot = node && popoverAnchorId === `dxos.org/ui/${DECK_PLUGIN}/${node.id}` ? Popover.Anchor : Fragment;
+  const [isNotMobile] = useMediaQuery("md");
+  useEffect3(() => {
+    const frame = requestAnimationFrame(() => {
+      node && graph.actions(node);
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [
+    node
+  ]);
+  const attendableId = id?.split(SLUG_PATH_SEPARATOR).at(0);
+  const layoutCoordinate = layoutPart !== void 0 && id !== void 0 ? {
+    part: layoutPart,
+    entryId: id
+  } : void 0;
+  const index = indexInPart(layoutParts, layoutCoordinate);
+  const length = partLength(layoutParts, layoutPart);
+  const canIncrementStart = layoutPart === "main" && index !== void 0 && index > 0 && length !== void 0 && length > 1;
+  const canIncrementEnd = layoutPart === "main" && index !== void 0 && index < length - 1 && length !== void 0;
+  return /* @__PURE__ */ React2.createElement(PlankHeading.Root, (layoutPart !== "main" || !flatDeck) && {
+    classNames: "pie-1 border-b separator-separator"
+  }, /* @__PURE__ */ React2.createElement(ActionRoot, null, node ? /* @__PURE__ */ React2.createElement(PlankHeading.ActionsMenu, {
+    Icon,
+    attendableId,
+    triggerLabel: t("actions menu label"),
+    actions: graph.actions(node),
+    onAction: (action) => typeof action.data === "function" && action.data?.({
+      node: action,
+      caller: DECK_PLUGIN
+    })
+  }, /* @__PURE__ */ React2.createElement(Surface2, {
+    role: "menu-footer",
+    data: {
+      object: node.data
+    }
+  })) : /* @__PURE__ */ React2.createElement(PlankHeading.Button, null, /* @__PURE__ */ React2.createElement("span", {
+    className: "sr-only"
+  }, label), /* @__PURE__ */ React2.createElement(Icon, plankHeadingIconProps))), /* @__PURE__ */ React2.createElement(TextTooltip, {
+    text: label,
+    onlyWhenTruncating: true
+  }, /* @__PURE__ */ React2.createElement(PlankHeading.Label, {
+    attendableId: node?.id,
+    ...pending && {
+      classNames: "fg-description"
+    }
+  }, label)), node && layoutPart !== "complementary" && // TODO(Zan): What are we doing with layout coordinate here?
+  /* @__PURE__ */ React2.createElement(Surface2, {
+    role: "navbar-end",
+    direction: "inline-reverse",
+    data: {
+      object: node.data
+    }
+  }), /* @__PURE__ */ React2.createElement(PlankHeading.Controls, {
+    capabilities: {
+      solo: (layoutPart === "solo" || layoutPart === "main") && isNotMobile,
+      incrementStart: canIncrementStart,
+      incrementEnd: canIncrementEnd
+    },
+    isSolo: layoutPart === "solo",
+    onClick: (eventType) => {
+      if (!layoutPart) {
+        return;
+      }
+      if (eventType === "solo") {
+        return dispatch([
+          {
+            action: NavigationAction.ADJUST,
+            data: {
+              type: eventType,
+              layoutCoordinate: {
+                part: "main",
+                entryId: id
+              }
+            }
+          }
+        ]);
+      }
+      return dispatch(eventType === "close" ? layoutPart === "complementary" ? {
+        action: LayoutAction.SET_LAYOUT,
+        data: {
+          element: "complementary",
+          state: false
+        }
+      } : {
+        action: NavigationAction.CLOSE,
+        data: {
+          activeParts: {
+            complementary: [
+              `${id}${SLUG_PATH_SEPARATOR}comments${SLUG_COLLECTION_INDICATOR}`
+            ],
+            [layoutPart]: [
+              id
+            ]
+          }
+        }
+      } : {
+        action: NavigationAction.ADJUST,
+        data: {
+          type: eventType,
+          layoutCoordinate
+        }
+      });
+    },
+    close: layoutCoordinate?.part === "complementary" ? "minify-end" : true
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/PlankError.tsx
+import React4, { useEffect as useEffect4, useState as useState2 } from "react";
+import { useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { descriptionText, mx } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/PlankLoading.tsx
+import React3 from "react";
+import { Status } from "@dxos/react-ui";
+var PlankLoading = () => {
+  return /* @__PURE__ */ React3.createElement("div", {
+    role: "none",
+    className: "grid bs-[100dvh] place-items-center row-span-2"
+  }, /* @__PURE__ */ React3.createElement(Status, {
+    indeterminate: true,
+    "aria-label": "Initializing"
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/PlankError.tsx
+var PlankContentError = ({ error }) => {
+  const { t } = useTranslation2(DECK_PLUGIN);
+  return /* @__PURE__ */ React4.createElement("div", {
+    role: "none",
+    className: "grid place-items-center row-span-2"
+  }, /* @__PURE__ */ React4.createElement("p", {
+    role: "alert",
+    className: mx(
+      descriptionText,
+      // TODO(burdon): Factor out common styles for all dialogs.
+      "overflow-hidden break-words",
+      "place-self-center border border-dashed border-neutral-400/50 rounded-lg text-center p-8 font-normal text-lg"
+    )
+  }, error ? error.toString() : t("error fallback message")));
+};
+var PlankError = ({ layoutCoordinate, id, node, error, flatDeck }) => {
+  const [timedOut, setTimedOut] = useState2(false);
+  useEffect4(() => {
+    setTimeout(() => setTimedOut(true), 5e3);
+  }, []);
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(NodePlankHeading, {
+    node,
+    id,
+    layoutPart: layoutCoordinate.part,
+    pending: !timedOut,
+    flatDeck
+  }), timedOut ? /* @__PURE__ */ React4.createElement(PlankContentError, {
+    error
+  }) : /* @__PURE__ */ React4.createElement(PlankLoading, null));
+};
+
+// packages/plugins/plugin-deck/src/components/LayoutContext.ts
+import { createContext, useContext } from "react";
+import { raise } from "@dxos/debug";
+var LayoutContext = createContext(null);
+var useLayout = () => useContext(LayoutContext) ?? raise(new Error("Missing LayoutContext"));
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ComplementarySidebar.tsx
+var ComplementarySidebar = ({ id, layoutParts, flatDeck }) => {
+  const { popoverAnchorId } = useLayout();
+  const { graph } = useGraph3();
+  const node = useNode(graph, id);
+  const complementaryAttrs = createAttendableAttributes(id?.split(SLUG_PATH_SEPARATOR2)[0] ?? "never");
+  useNodeActionExpander(node);
+  return /* @__PURE__ */ React5.createElement(Main.ComplementarySidebar, complementaryAttrs, node ? /* @__PURE__ */ React5.createElement("div", {
+    role: "none",
+    className: mx2(deckGrid, "grid-cols-1 bs-full")
+  }, /* @__PURE__ */ React5.createElement(NodePlankHeading, {
+    node,
+    id,
+    layoutParts,
+    layoutPart: "complementary",
+    popoverAnchorId,
+    flatDeck
+  }), /* @__PURE__ */ React5.createElement(Surface3, {
+    role: "article",
+    data: {
+      subject: node.data,
+      part: "complementary",
+      popoverAnchorId
+    },
+    limit: 1,
+    fallback: PlankContentError,
+    placeholder: /* @__PURE__ */ React5.createElement(PlankLoading, null)
+  })) : null);
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/ContentEmpty.tsx
+import React6 from "react";
+import { Surface as Surface4 } from "@dxos/app-framework";
+var ContentEmpty = () => {
+  return /* @__PURE__ */ React6.createElement("div", {
+    role: "none",
+    className: "min-bs-screen is-dvw sm:is-full flex items-center justify-center p-8",
+    "data-testid": "layoutPlugin.firstRunMessage"
+  }, /* @__PURE__ */ React6.createElement("div", {
+    role: "none",
+    className: "grid place-items-center grid-rows-[min-content_min-content]"
+  }, /* @__PURE__ */ React6.createElement(Surface4, {
+    role: "keyshortcuts"
+  })));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Fullscreen.tsx
+import React8 from "react";
+import { Surface as Surface5 } from "@dxos/app-framework";
+import { useGraph as useGraph4 } from "@dxos/plugin-graph";
+import { fixedInsetFlexLayout } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Fallback.tsx
+import React7 from "react";
+import { useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { errorText, mx as mx3 } from "@dxos/react-ui-theme";
+var Fallback = () => {
+  const { t } = useTranslation3(DECK_PLUGIN);
+  return /* @__PURE__ */ React7.createElement("div", {
+    role: "none",
+    className: "min-bs-screen is-full flex items-center justify-center p-8"
+  }, /* @__PURE__ */ React7.createElement("p", {
+    role: "alert",
+    className: mx3(errorText, "border border-error-400/50 rounded-lg flex items-center justify-center p-8 font-normal text-lg")
+  }, t("plugin error message")));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Fullscreen.tsx
+var Fullscreen = ({ id }) => {
+  const { graph } = useGraph4();
+  const fullScreenNode = useNode(graph, id);
+  return /* @__PURE__ */ React8.createElement("div", {
+    role: "none",
+    className: fixedInsetFlexLayout
+  }, /* @__PURE__ */ React8.createElement(Surface5, {
+    role: "main",
+    limit: 1,
+    fallback: Fallback,
+    data: {
+      active: fullScreenNode?.data,
+      component: id?.startsWith(SURFACE_PREFIX) ? id.slice(SURFACE_PREFIX.length) : void 0
+    }
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Plank.tsx
+import { Plus } from "@phosphor-icons/react";
+import React9, { useCallback } from "react";
+import { LayoutAction as LayoutAction2, NavigationAction as NavigationAction2, Surface as Surface6, useIntentDispatcher as useIntentDispatcher2 } from "@dxos/app-framework";
+import { debounce } from "@dxos/async";
+import { useGraph as useGraph5 } from "@dxos/plugin-graph";
+import { Button, Tooltip, useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { createAttendableAttributes as createAttendableAttributes2 } from "@dxos/react-ui-attention";
+import { Plank as NaturalPlank } from "@dxos/react-ui-deck";
+
+// packages/plugins/plugin-deck/src/components/DeckContext.ts
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { raise as raise2 } from "@dxos/debug";
+var DeckContext = createContext2(null);
+var useDeckContext = () => useContext2(DeckContext) ?? raise2(new Error("Missing DeckContext"));
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Plank.tsx
+var Plank = ({ entry, layoutParts, part, resizeable, flatDeck, searchEnabled, classNames }) => {
+  const { t } = useTranslation4(DECK_PLUGIN);
+  const dispatch = useIntentDispatcher2();
+  const { popoverAnchorId, scrollIntoView } = useLayout();
+  const { plankSizing } = useDeckContext();
+  const { graph } = useGraph5();
+  const node = useNode(graph, entry.id);
+  const attendableAttrs = createAttendableAttributes2(entry.id);
+  const size = plankSizing?.[entry.id];
+  const setSize = useCallback(debounce((newSize) => {
+    void dispatch({
+      action: DeckAction.UPDATE_PLANK_SIZE,
+      data: {
+        id: entry.id,
+        size: newSize
+      }
+    });
+  }, 200), [
+    dispatch,
+    entry.id
+  ]);
+  const coordinate = {
+    part,
+    entryId: entry.id
+  };
+  return /* @__PURE__ */ React9.createElement(NaturalPlank.Root, {
+    size,
+    setSize
+  }, /* @__PURE__ */ React9.createElement(NaturalPlank.Content, {
+    ...attendableAttrs,
+    classNames: [
+      !flatDeck && "surface-base",
+      classNames
+    ],
+    scrollIntoViewOnMount: entry.id === scrollIntoView,
+    suppressAutofocus: entry.id === NAV_ID || !!node?.properties?.managesAutofocus
+  }, node ? /* @__PURE__ */ React9.createElement(React9.Fragment, null, /* @__PURE__ */ React9.createElement(NodePlankHeading, {
+    layoutPart: coordinate.part,
+    layoutParts,
+    node,
+    id: entry.id,
+    popoverAnchorId,
+    flatDeck
+  }), /* @__PURE__ */ React9.createElement(Surface6, {
+    role: "article",
+    data: {
+      ...entry.path ? {
+        subject: node.data,
+        path: entry.path
+      } : {
+        object: node.data
+      },
+      coordinate,
+      popoverAnchorId
+    },
+    limit: 1,
+    fallback: PlankContentError,
+    placeholder: /* @__PURE__ */ React9.createElement(PlankLoading, null)
+  })) : /* @__PURE__ */ React9.createElement(PlankError, {
+    layoutCoordinate: coordinate,
+    id: entry.id,
+    flatDeck
+  })), searchEnabled && resizeable ? /* @__PURE__ */ React9.createElement("div", {
+    role: "none",
+    className: "grid grid-rows-subgrid row-span-3"
+  }, /* @__PURE__ */ React9.createElement(Tooltip.Root, null, /* @__PURE__ */ React9.createElement(Tooltip.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React9.createElement(Button, {
+    "data-testid": "plankHeading.open",
+    variant: "ghost",
+    classNames: "p-1 w-fit",
+    onClick: () => dispatch([
+      {
+        action: LayoutAction2.SET_LAYOUT,
+        data: {
+          element: "dialog",
+          component: "dxos.org/plugin/search/Dialog",
+          dialogBlockAlign: "start",
+          subject: {
+            action: NavigationAction2.SET,
+            position: "add-after",
+            coordinate
+          }
+        }
+      }
+    ])
+  }, /* @__PURE__ */ React9.createElement("span", {
+    className: "sr-only"
+  }, t("insert plank label")), /* @__PURE__ */ React9.createElement(Plus, null))), /* @__PURE__ */ React9.createElement(Tooltip.Portal, null, /* @__PURE__ */ React9.createElement(Tooltip.Content, {
+    side: "bottom",
+    classNames: "z-[70]"
+  }, t("insert plank label")))), /* @__PURE__ */ React9.createElement(NaturalPlank.ResizeHandle, {
+    classNames: "row-start-[toolbar-start] row-end-[content-end]"
+  })) : resizeable ? /* @__PURE__ */ React9.createElement(NaturalPlank.ResizeHandle, {
+    classNames: "row-span-3"
+  }) : null);
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Sidebar.tsx
+import React10, { useMemo } from "react";
+import { openIds, Surface as Surface7 } from "@dxos/app-framework";
+import { Main as Main2 } from "@dxos/react-ui";
+var Sidebar = ({ attention, layoutParts }) => {
+  const { layoutMode, popoverAnchorId } = useLayout();
+  const activeIds = useMemo(() => {
+    if (layoutMode === "solo") {
+      return new Set(layoutParts?.solo?.map((e) => e.id) ?? []);
+    } else if (layoutMode === "deck") {
+      return new Set(layoutParts?.main?.map((e) => e.id) ?? []);
+    }
+    return new Set(openIds(layoutParts));
+  }, [
+    layoutParts,
+    layoutMode
+  ]);
+  const navigationData = useMemo(() => ({
+    popoverAnchorId,
+    activeIds,
+    attended: attention.attended
+  }), [
+    popoverAnchorId,
+    activeIds,
+    attention.attended
+  ]);
+  return /* @__PURE__ */ React10.createElement(Main2.NavigationSidebar, null, /* @__PURE__ */ React10.createElement(Surface7, {
+    role: "navigation",
+    data: {
+      ...navigationData
+    },
+    limit: 1
+  }));
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/Toast.tsx
+import React11 from "react";
+import { Button as Button2, Toast as NaturalToast } from "@dxos/react-ui";
+var Toast = ({ id, title, description, icon, duration, actionLabel, actionAlt, closeLabel, onAction, onOpenChange }) => {
+  return /* @__PURE__ */ React11.createElement(NaturalToast.Root, {
+    "data-testid": id,
+    defaultOpen: true,
+    duration,
+    onOpenChange
+  }, /* @__PURE__ */ React11.createElement(NaturalToast.Body, null, /* @__PURE__ */ React11.createElement(NaturalToast.Title, null, icon?.({
+    className: "inline mr-1"
+  }), /* @__PURE__ */ React11.createElement("span", null, title)), description && /* @__PURE__ */ React11.createElement(NaturalToast.Description, null, description)), /* @__PURE__ */ React11.createElement(NaturalToast.Actions, null, onAction && actionAlt && actionLabel && /* @__PURE__ */ React11.createElement(NaturalToast.Action, {
+    altText: actionAlt,
+    asChild: true
+  }, /* @__PURE__ */ React11.createElement(Button2, {
+    "data-testid": "toast.action",
+    variant: "primary",
+    onClick: () => onAction?.()
+  }, actionLabel)), closeLabel && /* @__PURE__ */ React11.createElement(NaturalToast.Close, {
+    asChild: true
+  }, /* @__PURE__ */ React11.createElement(Button2, {
+    "data-testid": "toast.close"
+  }, closeLabel))));
+};
+
+// packages/plugins/plugin-deck/src/util/check-app-scheme.ts
+var checkAppScheme = (url) => {
+  const iframe = document.createElement("iframe");
+  iframe.style.display = "none";
+  document.body.appendChild(iframe);
+  iframe.src = url + window.location.pathname.replace(/^\/+/, "") + window.location.search;
+  const timer = setTimeout(() => {
+    document.body.removeChild(iframe);
+  }, 3e3);
+  window.addEventListener("pagehide", (event) => {
+    clearTimeout(timer);
+    document.body.removeChild(iframe);
+  });
+};
+
+// packages/plugins/plugin-deck/src/util/layout-parts.ts
+var getEffectivePart = (partName, layoutMode) => layoutMode === "solo" && partName === "main" ? "solo" : partName;
+
+// packages/plugins/plugin-deck/src/util/overscroll.ts
+import { PLANK_DEFAULTS } from "@dxos/react-ui-deck";
+var calculateOverscroll = (layoutMode, sidebarOpen, complementarySidebarOpen, layoutParts, plankSizing, overscroll) => {
+  if (!(layoutMode === "deck" && overscroll === "centering")) {
+    return;
+  }
+  if (!layoutParts.main || layoutParts.main.length === 0) {
+    return;
+  }
+  const sidebarWidth = sidebarOpen ? "270px" : "0px";
+  const complementarySidebarWidth = complementarySidebarOpen ? "360px" : "0px";
+  const getPlankSize = (id) => (plankSizing[id] ?? PLANK_DEFAULTS.size).toFixed(2) + "rem";
+  if (layoutParts.main.length === 1) {
+    const plank = layoutParts.main[0];
+    const plankSize = getPlankSize(plank.id);
+    const overscrollPadding = `max(0px, calc(((100dvw - ${sidebarWidth} - ${complementarySidebarWidth} - (${plankSize} + 20px)) / 2)))`;
+    return {
+      paddingLeft: overscrollPadding,
+      paddingRight: overscrollPadding
+    };
+  } else {
+    const firstPlank = layoutParts.main[0];
+    const firstPlankInlineSize = getPlankSize(firstPlank.id);
+    const paddingLeft = `max(0px, calc(((100dvw - (${firstPlankInlineSize} + 20px)) / 2) - ${sidebarWidth}))`;
+    const lastPlank = layoutParts.main[layoutParts.main.length - 1];
+    const lastPlankInlineSize = getPlankSize(lastPlank.id);
+    const paddingRight = `max(0px, calc(((100dvw - (${lastPlankInlineSize} + 20px)) / 2) - ${complementarySidebarWidth}))`;
+    return {
+      paddingLeft,
+      paddingRight
+    };
+  }
+};
+
+// packages/plugins/plugin-deck/src/components/DeckLayout/DeckLayout.tsx
+var DeckLayout = ({ showHintsFooter, toasts, onDismissToast, flatDeck, attention, layoutParts, slots, overscroll }) => {
+  const context = useLayout();
+  const { layoutMode, sidebarOpen, complementarySidebarOpen, dialogOpen, dialogContent, dialogBlockAlign, popoverOpen, popoverContent, popoverAnchorId } = context;
+  const { t } = useTranslation5(DECK_PLUGIN);
+  const { plankSizing } = useDeckContext();
+  const fullScreenSlug = useMemo2(() => firstIdInPart(layoutParts, "fullScreen"), [
+    layoutParts
+  ]);
+  const complementarySlug = useMemo2(() => {
+    const entry = layoutParts.complementary?.at(0);
+    if (entry) {
+      return entry.path ? `${entry.id}${SLUG_PATH_SEPARATOR3}${entry.path}` : entry.id;
+    }
+  }, [
+    layoutParts
+  ]);
+  const searchEnabled = !!usePlugin("dxos.org/plugin/search");
+  const activeId = useMemo2(() => Array.from(attention.attended ?? [])[0], [
+    attention.attended
+  ]);
+  const overscrollAmount = calculateOverscroll(layoutMode, sidebarOpen, complementarySidebarOpen, layoutParts, plankSizing, overscroll);
+  if (layoutMode === "fullscreen") {
+    return /* @__PURE__ */ React12.createElement(Fullscreen, {
+      id: fullScreenSlug
+    });
+  }
+  return /* @__PURE__ */ React12.createElement(Popover2.Root, {
+    modal: true,
+    open: !!(popoverAnchorId && popoverOpen),
+    onOpenChange: (nextOpen) => {
+      if (nextOpen && popoverAnchorId) {
+        context.popoverOpen = true;
+      } else {
+        context.popoverOpen = false;
+        context.popoverAnchorId = void 0;
+      }
+    }
+  }, /* @__PURE__ */ React12.createElement(ActiveNode, {
+    id: activeId
+  }), /* @__PURE__ */ React12.createElement(Main3.Root, {
+    navigationSidebarOpen: context.sidebarOpen,
+    onNavigationSidebarOpenChange: (next) => context.sidebarOpen = next,
+    ...complementarySidebarOpen !== null && {
+      complementarySidebarOpen: (
+        /* complementaryAvailable && */
+        context.complementarySidebarOpen
+      ),
+      onComplementarySidebarOpenChange: (next) => context.complementarySidebarOpen = next
+    }
+  }, /* @__PURE__ */ React12.createElement(Main3.Notch, {
+    classNames: "z-[21]"
+  }, /* @__PURE__ */ React12.createElement(Surface8, {
+    role: "notch-start"
+  }), /* @__PURE__ */ React12.createElement(Button3, {
+    // disabled={!sidebarAvailable}
+    onClick: () => context.sidebarOpen = !context.sidebarOpen,
+    variant: "ghost",
+    classNames: "p-1"
+  }, /* @__PURE__ */ React12.createElement("span", {
+    className: "sr-only"
+  }, t("open navigation sidebar label")), /* @__PURE__ */ React12.createElement(MenuIcon, {
+    weight: "light",
+    className: getSize(5)
+  })), /* @__PURE__ */ React12.createElement(Button3, {
+    // disabled={!complementaryAvailable}
+    onClick: () => context.complementarySidebarOpen = !context.complementarySidebarOpen,
+    variant: "ghost",
+    classNames: "p-1"
+  }, /* @__PURE__ */ React12.createElement("span", {
+    className: "sr-only"
+  }, t("open complementary sidebar label")), /* @__PURE__ */ React12.createElement(MenuIcon, {
+    mirrored: true,
+    weight: "light",
+    className: getSize(5)
+  })), /* @__PURE__ */ React12.createElement(Surface8, {
+    role: "notch-end"
+  })), /* @__PURE__ */ React12.createElement(Sidebar, {
+    attention,
+    layoutParts
+  }), /* @__PURE__ */ React12.createElement(ComplementarySidebar, {
+    id: complementarySlug,
+    layoutParts,
+    flatDeck
+  }), /* @__PURE__ */ React12.createElement(Main3.Overlay, null), layoutMode === "deck" && layoutParts.main && layoutParts.main.length > 0 && /* @__PURE__ */ React12.createElement(Main3.Content, {
+    bounce: true,
+    classNames: [
+      "grid",
+      "block-end-[--statusbar-size]"
+    ]
+  }, /* @__PURE__ */ React12.createElement("div", {
+    role: "none",
+    className: "relative"
+  }, /* @__PURE__ */ React12.createElement(Deck.Root, {
+    classNames: mx4("absolute inset-0", !flatDeck && "surface-deck", slots?.wallpaper?.classNames, slots?.deck?.classNames, "transition-[padding] duration-200 ease-in-out"),
+    style: {
+      ...overscrollAmount
+    }
+  }, layoutParts.main.map((layoutEntry) => {
+    return /* @__PURE__ */ React12.createElement(Plank, {
+      key: layoutEntry.id,
+      entry: layoutEntry,
+      layoutParts,
+      part: "main",
+      resizeable: true,
+      flatDeck,
+      searchEnabled
+    });
+  })))), layoutMode === "solo" && layoutParts.solo && layoutParts.solo.length > 0 && /* @__PURE__ */ React12.createElement(Main3.Content, {
+    bounce: true,
+    classNames: [
+      "grid",
+      "block-end-[--statusbar-size]"
+    ]
+  }, /* @__PURE__ */ React12.createElement(Deck.Root, {
+    classNames: [
+      !flatDeck && "surface-deck",
+      slots?.wallpaper?.classNames,
+      slots?.deck?.classNames
+    ],
+    solo: true
+  }, layoutParts.solo.map((layoutEntry) => {
+    return /* @__PURE__ */ React12.createElement(Plank, {
+      key: layoutEntry.id,
+      entry: layoutEntry,
+      layoutParts,
+      part: "solo",
+      flatDeck,
+      classNames: slots?.plank?.classNames
+    });
+  }))), (layoutMode === "solo" && (!layoutParts.solo || layoutParts.solo.length === 0) || layoutMode === "deck" && (!layoutParts.main || layoutParts.main.length === 0)) && /* @__PURE__ */ React12.createElement(Main3.Content, null, /* @__PURE__ */ React12.createElement(ContentEmpty, null)), /* @__PURE__ */ React12.createElement(Main3.Content, {
+    role: "none",
+    classNames: [
+      "fixed inset-inline-0 block-end-0 z-[2]"
+    ]
+  }, /* @__PURE__ */ React12.createElement(Surface8, {
+    role: "status-bar",
+    limit: 1
+  })), showHintsFooter && /* @__PURE__ */ React12.createElement("div", {
+    className: "fixed bottom-0 left-0 right-0 h-[32px] z-[1] flex justify-center"
+  }, /* @__PURE__ */ React12.createElement(Surface8, {
+    role: "hints",
+    limit: 1
+  })), /* @__PURE__ */ React12.createElement(Popover2.Portal, null, /* @__PURE__ */ React12.createElement(Popover2.Content, {
+    classNames: "z-[60]",
+    onEscapeKeyDown: () => {
+      context.popoverOpen = false;
+      context.popoverAnchorId = void 0;
+    }
+  }, /* @__PURE__ */ React12.createElement(Popover2.Viewport, null, /* @__PURE__ */ React12.createElement(Surface8, {
+    role: "popover",
+    data: popoverContent
+  })), /* @__PURE__ */ React12.createElement(Popover2.Arrow, null))), /* @__PURE__ */ React12.createElement(Dialog.Root, {
+    open: dialogOpen,
+    onOpenChange: (nextOpen) => context.dialogOpen = nextOpen
+  }, /* @__PURE__ */ React12.createElement(Dialog.Overlay, {
+    blockAlign: dialogBlockAlign
+  }, /* @__PURE__ */ React12.createElement(Surface8, {
+    role: "dialog",
+    data: dialogContent
+  }))), toasts?.map((toast) => /* @__PURE__ */ React12.createElement(Toast, {
+    ...toast,
+    key: toast.id,
+    onOpenChange: (open) => {
+      if (!open) {
+        onDismissToast(toast.id);
+      }
+      return open;
+    }
+  }))));
+};
+
+// packages/plugins/plugin-deck/src/components/LayoutSettings.tsx
+import React13 from "react";
+import { SettingsValue } from "@dxos/plugin-settings";
+import { Input, Select, useTranslation as useTranslation6 } from "@dxos/react-ui";
+
+// packages/plugins/plugin-deck/src/types.ts
+var NewPlankPositions = [
+  "start",
+  "end"
+];
+var OverscrollOptions = [
+  "none",
+  "centering"
+];
+
+// packages/plugins/plugin-deck/src/components/LayoutSettings.tsx
+var isSocket = !!globalThis.__args;
+var LayoutSettings = ({ settings }) => {
+  const { t } = useTranslation6(DECK_PLUGIN);
+  return /* @__PURE__ */ React13.createElement(React13.Fragment, null, /* @__PURE__ */ React13.createElement(SettingsValue, {
+    label: t("select new plank positioning label")
+  }, /* @__PURE__ */ React13.createElement(Select.Root, {
+    value: settings.newPlankPositioning ?? "start",
+    onValueChange: (value) => settings.newPlankPositioning = value
+  }, /* @__PURE__ */ React13.createElement(Select.TriggerButton, {
+    placeholder: t("select new plank positioning placeholder")
+  }), /* @__PURE__ */ React13.createElement(Select.Portal, null, /* @__PURE__ */ React13.createElement(Select.Content, null, /* @__PURE__ */ React13.createElement(Select.Viewport, null, NewPlankPositions.map((position) => /* @__PURE__ */ React13.createElement(Select.Option, {
+    key: position,
+    value: position
+  }, t(`settings new plank position ${position} label`)))))))), /* @__PURE__ */ React13.createElement(SettingsValue, {
+    label: t("settings overscroll label")
+  }, /* @__PURE__ */ React13.createElement(Select.Root, {
+    value: settings.overscroll ?? "none",
+    onValueChange: (value) => settings.overscroll = value
+  }, /* @__PURE__ */ React13.createElement(Select.TriggerButton, {
+    placeholder: t("select overscroll placeholder")
+  }), /* @__PURE__ */ React13.createElement(Select.Portal, null, /* @__PURE__ */ React13.createElement(Select.Content, null, /* @__PURE__ */ React13.createElement(Select.Viewport, null, OverscrollOptions.map((option) => /* @__PURE__ */ React13.createElement(Select.Option, {
+    key: option,
+    value: option
+  }, t(`settings overscroll ${option} label`)))))))), /* @__PURE__ */ React13.createElement(SettingsValue, {
+    label: t("settings show footer label")
+  }, /* @__PURE__ */ React13.createElement(Input.Switch, {
+    checked: settings.showFooter,
+    onCheckedChange: (checked) => settings.showFooter = !!checked
+  })), !isSocket && /* @__PURE__ */ React13.createElement(SettingsValue, {
+    label: t("settings native redirect label")
+  }, /* @__PURE__ */ React13.createElement(Input.Switch, {
+    checked: settings.enableNativeRedirect,
+    onCheckedChange: (checked) => settings.enableNativeRedirect = !!checked
+  })), /* @__PURE__ */ React13.createElement(SettingsValue, {
+    label: t("settings custom slots")
+  }, /* @__PURE__ */ React13.createElement(Input.Switch, {
+    checked: settings.customSlots,
+    onCheckedChange: (checked) => settings.customSlots = !!checked
+  })), /* @__PURE__ */ React13.createElement(SettingsValue, {
+    label: t("settings flat deck")
+  }, /* @__PURE__ */ React13.createElement(Input.Switch, {
+    checked: settings.flatDeck,
+    onCheckedChange: (checked) => settings.flatDeck = !!checked
+  })));
+};
+
+// packages/plugins/plugin-deck/src/layout.ts
+import { produce } from "immer";
+import { SLUG_ENTRY_SEPARATOR, SLUG_KEY_VALUE_SEPARATOR, SLUG_LIST_SEPARATOR, SLUG_PATH_SEPARATOR as SLUG_PATH_SEPARATOR4 } from "@dxos/app-framework";
+var partsThatSupportIncrement = [
+  "main"
+];
+var openEntry = (layout, part, entry, options) => {
+  return produce(layout, (draft) => {
+    const layoutPart = draft[part];
+    if (!layoutPart) {
+      draft[part] = [
+        entry
+      ];
+      return;
+    }
+    if (part === "main") {
+      if (layoutPart.find((e) => e.id === entry.id)) {
+        return;
+      }
+      const plankPositioning = options?.positioning ?? "start";
+      const pivotId = options?.pivotId;
+      if (pivotId) {
+        const pivotIndex = layoutPart.findIndex((e) => e.id === pivotId);
+        if (pivotIndex !== -1) {
+          if (plankPositioning === "start") {
+            layoutPart.splice(pivotIndex, 0, entry);
+          } else {
+            layoutPart.splice(pivotIndex + 1, 0, entry);
+          }
+          return;
+        }
+      }
+      if (plankPositioning === "start") {
+        layoutPart.unshift(entry);
+      } else {
+        layoutPart.push(entry);
+      }
+    } else {
+      draft[part] = [
+        entry
+      ];
+    }
+  });
+};
+var closeEntry = (layout, layoutCoordinate) => {
+  return produce(layout, (draft) => {
+    const { part, entryId: slugId } = layoutCoordinate;
+    const layoutPart = draft[part];
+    if (!layoutPart) {
+      return;
+    }
+    const index = layoutPart.findIndex((entry) => entry.id === slugId);
+    if (index === -1) {
+      return;
+    }
+    if (layoutPart.length === 1) {
+      delete draft[part];
+    } else {
+      layoutPart.splice(index, 1);
+    }
+  });
+};
+var incrementPlank = (layout, adjustment) => {
+  return produce(layout, (draft) => {
+    const { layoutCoordinate, type } = adjustment;
+    const { part, entryId } = layoutCoordinate;
+    if (partsThatSupportIncrement.includes(part) === false) {
+      return;
+    }
+    const layoutPart = draft[part];
+    if (!layoutPart) {
+      return;
+    }
+    const index = layoutPart.findIndex((entry) => entry.id === entryId);
+    if (index === -1 || type === "increment-start" && index === 0 || type === "increment-end" && index === layoutPart.length - 1) {
+      return;
+    }
+    if (type === "increment-start") {
+      [layoutPart[index - 1], layoutPart[index]] = [
+        layoutPart[index],
+        layoutPart[index - 1]
+      ];
+    } else if (type === "increment-end") {
+      [layoutPart[index], layoutPart[index + 1]] = [
+        layoutPart[index + 1],
+        layoutPart[index]
+      ];
+    }
+  });
+};
+var removePart = (layout, part) => {
+  return produce(layout, (draft) => {
+    delete draft[part];
+  });
+};
+var mergeLayoutParts = (...layoutParts) => {
+  return layoutParts.reduce((merged, current) => produce(merged, (draft) => {
+    Object.entries(current).forEach(([part, entries]) => {
+      const typedPart = part;
+      if (!draft[typedPart]) {
+        draft[typedPart] = [];
+      }
+      const partEntries = draft[typedPart];
+      entries.forEach((entry) => {
+        const existingIndex = partEntries.findIndex((e) => e.id === entry.id);
+        if (existingIndex !== -1) {
+          partEntries[existingIndex] = entry;
+        } else {
+          partEntries.push(entry);
+        }
+      });
+    });
+  }), {});
+};
+var parseLayoutEntry = (itemString) => {
+  const [id, path] = itemString.split(SLUG_PATH_SEPARATOR4);
+  const entry = {
+    id
+  };
+  if (path) {
+    entry.path = path;
+  }
+  return entry;
+};
+var uriToSoloPart = (uri) => {
+  const parts = uri.split("/");
+  const slug = parts[parts.length - 1];
+  if (slug.length > 0) {
+    return {
+      solo: [
+        parseLayoutEntry(slug)
+      ]
+    };
+  }
+  return void 0;
+};
+var soloPartToUri = (layout) => {
+  const soloPart = layout?.solo;
+  if (!soloPart || soloPart.length === 0) {
+    return "";
+  }
+  const entry = soloPart[0];
+  return `${entry.id}${entry.path ? SLUG_PATH_SEPARATOR4 + entry.path : ""}`;
+};
+
+// packages/plugins/plugin-deck/src/translations.ts
+var translations_default = [
+  {
+    "en-US": {
+      [DECK_PLUGIN]: {
+        "main header label": "Main header",
+        "open navigation sidebar label": "Open navigation sidebar.",
+        "open complementary sidebar label": "Open complementary sidebar.",
+        "open settings label": "Show settings",
+        "plugin error message": "Content failed to render.",
+        "content fallback message": "Unsupported",
+        "content fallback description": "No plugin had a response for the address you navigated\xA0to. Double-check the URL, and ensure you\u2019ve enabled a plugin that supports the\xA0object.",
+        "toggle fullscreen label": "Toggle fullscreen",
+        "settings show footer label": "Show footer (experimental)",
+        "settings native redirect label": "Enable native url redirect (experimental)",
+        "settings custom slots": "Theme option (experimental)",
+        "settings new plank position start label": "Start",
+        "settings new plank position end label": "End",
+        "select new plank positioning placeholder": "Select new plank positioning",
+        "select new plank positioning label": "New plank positioning",
+        "undo available label": "Click to undo previous action.",
+        "undo action label": "Undo",
+        "undo action alt": "Undo previous action",
+        "undo close label": "Dismiss",
+        "open comments label": "Open comments",
+        "error fallback message": "Unable to open this item",
+        "plank heading fallback label": "Untitled",
+        "actions menu label": "Options",
+        "settings deck label": "Disable Deck",
+        "reload required message": "Reload required.",
+        "pending heading": "Loading\u2026",
+        "insert plank label": "Open",
+        "solo plank label": "Solo",
+        "settings overscroll label": "Plank Overscrolling",
+        "select overscroll placeholder": "Select plank overscrolling behavior",
+        "settings overscroll centering label": "Centering",
+        "settings overscroll none label": "None",
+        "settings flat deck": "Flatten deck appearance"
+      }
+    }
+  }
+];
+
+// packages/plugins/plugin-deck/src/DeckPlugin.tsx
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-deck/src/DeckPlugin.tsx";
+var isSocket2 = !!globalThis.__args;
+var appScheme = "composer://";
+var customSlots = {
+  wallpaper: {
+    classNames: "bg-cover bg-no-repeat dark:bg-[url(https://cdn.midjourney.com/3865ba61-f98a-4d94-b91a-1763ead01f4f/0_0.jpeg)]"
+  },
+  deck: {
+    classNames: "px-96 bg-neutral-50 __dark:bg-neutral-950 dark:bg-transparent dark:opacity-95"
+  },
+  plank: {
+    classNames: "mx-1 bg-neutral-25 dark:bg-neutral-900"
+  }
+};
+setAutoFreeze(false);
+var DECK_ACTION = "dxos.org/plugin/deck";
+var DeckAction;
+(function(DeckAction2) {
+  DeckAction2[DeckAction2["UPDATE_PLANK_SIZE"] = `${DECK_ACTION}/update-plank-size`] = "UPDATE_PLANK_SIZE";
+})(DeckAction || (DeckAction = {}));
+var DeckPlugin = ({ observability } = {}) => {
+  let graphPlugin;
+  let intentPlugin;
+  let attentionPlugin;
+  let clientPlugin;
+  const unsubscriptionCallbacks = [];
+  let currentUndoId;
+  let handleNavigation;
+  const settings = new LocalStorageStore("dxos.org/settings/layout", {
+    showFooter: false,
+    customSlots: false,
+    flatDeck: false,
+    enableNativeRedirect: false,
+    disableDeck: false,
+    newPlankPositioning: "start",
+    overscroll: "centering"
+  });
+  const layout = new LocalStorageStore("dxos.org/settings/layout", {
+    layoutMode: "solo",
+    sidebarOpen: true,
+    complementarySidebarOpen: false,
+    dialogContent: null,
+    dialogOpen: false,
+    dialogBlockAlign: void 0,
+    popoverContent: null,
+    popoverAnchorId: void 0,
+    popoverOpen: false,
+    toasts: []
+  });
+  const deck = new LocalStorageStore("dxos.org/settings/deck", {
+    plankSizing: {}
+  });
+  const location = new LocalStorageStore("dxos.org/state/layout", {
+    active: {
+      sidebar: [
+        {
+          id: NAV_ID
+        }
+      ]
+    },
+    closed: []
+  });
+  const layoutModeHistory = create({
+    values: []
+  });
+  const handleSetLayout = ({ element, state, component, subject, anchorId, dialogBlockAlign }) => {
+    switch (element) {
+      case "sidebar": {
+        layout.values.sidebarOpen = state ?? !layout.values.sidebarOpen;
+        return {
+          data: true
+        };
+      }
+      case "complementary": {
+        layout.values.complementarySidebarOpen = !!state;
+        return {
+          data: true
+        };
+      }
+      case "dialog": {
+        layout.values.dialogOpen = state ?? Boolean(component);
+        layout.values.dialogContent = component ? {
+          component,
+          subject
+        } : null;
+        layout.values.dialogBlockAlign = dialogBlockAlign ?? "center";
+        return {
+          data: true
+        };
+      }
+      case "popover": {
+        layout.values.popoverOpen = state ?? Boolean(component);
+        layout.values.popoverContent = component ? {
+          component,
+          subject
+        } : null;
+        layout.values.popoverAnchorId = anchorId;
+        return {
+          data: true
+        };
+      }
+      case "toast": {
+        if (ToastSchema.safeParse(subject).success) {
+          layout.values.toasts = [
+            ...layout.values.toasts,
+            subject
+          ];
+          return {
+            data: true
+          };
+        }
+      }
+    }
+  };
+  return {
+    meta: meta_default,
+    ready: async (plugins) => {
+      intentPlugin = resolvePlugin(plugins, parseIntentPlugin);
+      graphPlugin = resolvePlugin(plugins, parseGraphPlugin);
+      attentionPlugin = resolvePlugin(plugins, parseAttentionPlugin);
+      clientPlugin = resolvePlugin(plugins, parseClientPlugin);
+      layout.prop({
+        key: "layoutMode",
+        storageKey: "layout-mode",
+        type: LocalStorageStore.enum()
+      }).prop({
+        key: "sidebarOpen",
+        storageKey: "sidebar-open",
+        type: LocalStorageStore.bool()
+      }).prop({
+        key: "complementarySidebarOpen",
+        storageKey: "complementary-sidebar-open",
+        type: LocalStorageStore.bool()
+      });
+      deck.prop({
+        key: "plankSizing",
+        storageKey: "plank-sizing",
+        type: LocalStorageStore.json()
+      });
+      location.prop({
+        key: "active",
+        storageKey: "active",
+        type: LocalStorageStore.json()
+      }).prop({
+        key: "closed",
+        storageKey: "closed",
+        type: LocalStorageStore.json()
+      });
+      unsubscriptionCallbacks.push(clientPlugin?.provides.client.shell.onReset(() => {
+        layout.expunge();
+        location.expunge();
+        deck.expunge();
+      }));
+      settings.prop({
+        key: "showFooter",
+        storageKey: "show-footer",
+        type: LocalStorageStore.bool()
+      }).prop({
+        key: "customSlots",
+        storageKey: "customSlots",
+        type: LocalStorageStore.bool()
+      }).prop({
+        key: "flatDeck",
+        storageKey: "flatDeck",
+        type: LocalStorageStore.bool()
+      }).prop({
+        key: "enableNativeRedirect",
+        storageKey: "enable-native-redirect",
+        type: LocalStorageStore.bool()
+      }).prop({
+        key: "disableDeck",
+        storageKey: "disable-deck",
+        type: LocalStorageStore.bool()
+      }).prop({
+        key: "newPlankPositioning",
+        storageKey: "newPlankPositioning",
+        type: LocalStorageStore.enum()
+      }).prop({
+        key: "overscroll",
+        storageKey: "overscroll",
+        type: LocalStorageStore.enum()
+      });
+      if (!isSocket2 && settings.values.enableNativeRedirect) {
+        checkAppScheme(appScheme);
+      }
+      handleNavigation = async () => {
+        const layoutFromUri = uriToSoloPart(window.location.pathname);
+        if (!layoutFromUri) {
+          return;
+        }
+        const startingLayout = removePart(location.values.active, "solo");
+        location.values.active = mergeLayoutParts(layoutFromUri, startingLayout);
+        layout.values.layoutMode = "solo";
+      };
+      await handleNavigation();
+      window.addEventListener("popstate", handleNavigation);
+      unsubscriptionCallbacks.push(effect(() => {
+        const selectedPath = soloPartToUri(location.values.active);
+        history.pushState(null, "", `/${selectedPath}${window.location.search}`);
+      }));
+      unsubscriptionCallbacks.push(effect(() => {
+        const soloId = location.values.active.solo?.[0].id;
+        if (layout.values.layoutMode === "solo" && soloId && layout.values.scrollIntoView !== soloId) {
+          void intentPlugin?.provides.intent.dispatch({
+            action: LayoutAction3.SCROLL_INTO_VIEW,
+            data: {
+              id: soloId
+            }
+          });
+        }
+      }));
+      layoutModeHistory.values.push(`${layout.values.layoutMode}`);
+    },
+    unload: async () => {
+      layout.close();
+      location.close();
+      unsubscriptionCallbacks.forEach((unsubscribe) => unsubscribe?.());
+      window.removeEventListener("popstate", handleNavigation);
+    },
+    provides: {
+      settings: settings.values,
+      layout: layout.values,
+      location: location.values,
+      translations: [
+        ...translations_default,
+        ...deckTranslations
+      ],
+      graph: {
+        builder: () => {
+          return createExtension({
+            id: DECK_PLUGIN,
+            filter: (node) => node.id === "root",
+            actions: () => [
+              {
+                id: `${LayoutAction3.SET_LAYOUT_MODE}/fullscreen`,
+                data: async () => {
+                  await intentPlugin?.provides.intent.dispatch({
+                    plugin: DECK_PLUGIN,
+                    action: LayoutAction3.SET_LAYOUT_MODE,
+                    data: {
+                      layoutMode: "fullscreen"
+                    }
+                  });
+                },
+                properties: {
+                  label: [
+                    "toggle fullscreen label",
+                    {
+                      ns: DECK_PLUGIN
+                    }
+                  ],
+                  icon: (props) => /* @__PURE__ */ React14.createElement(ArrowsOut, props),
+                  iconSymbol: "ph--arrows-out--regular",
+                  keyBinding: {
+                    macos: "ctrl+meta+f",
+                    windows: "shift+ctrl+f"
+                  }
+                }
+              }
+            ]
+          });
+        }
+      },
+      context: (props) => /* @__PURE__ */ React14.createElement(LayoutContext.Provider, {
+        value: layout.values
+      }, /* @__PURE__ */ React14.createElement(DeckContext.Provider, {
+        value: deck.values
+      }, props.children)),
+      root: () => {
+        return /* @__PURE__ */ React14.createElement(Mosaic.Root, null, /* @__PURE__ */ React14.createElement(DeckLayout, {
+          attention: attentionPlugin?.provides.attention ?? {
+            attended: /* @__PURE__ */ new Set()
+          },
+          layoutParts: location.values.active,
+          overscroll: settings.values.overscroll,
+          flatDeck: settings.values.flatDeck,
+          showHintsFooter: settings.values.showFooter,
+          slots: settings.values.customSlots ? customSlots : void 0,
+          toasts: layout.values.toasts,
+          onDismissToast: (id) => {
+            const index = layout.values.toasts.findIndex((toast) => toast.id === id);
+            if (index !== -1) {
+              setTimeout(() => {
+                if (layout.values.toasts[index].id === currentUndoId) {
+                  currentUndoId = void 0;
+                }
+                layout.values.toasts.splice(index, 1);
+              }, 1e3);
+            }
+          }
+        }), /* @__PURE__ */ React14.createElement(Mosaic.DragOverlay, null));
+      },
+      surface: {
+        component: ({ data, role }) => {
+          switch (role) {
+            case "settings":
+              return data.plugin === meta_default.id ? /* @__PURE__ */ React14.createElement(LayoutSettings, {
+                settings: settings.values
+              }) : null;
+          }
+          return null;
+        }
+      },
+      intent: {
+        resolver: (intent) => {
+          switch (intent.action) {
+            case LayoutAction3.SET_LAYOUT: {
+              return intent.data && handleSetLayout(intent.data);
+            }
+            case LayoutAction3.SET_LAYOUT_MODE: {
+              return batch(() => {
+                if (!intent.data) {
+                  return;
+                }
+                if (intent.data?.revert) {
+                  layout.values.layoutMode = layoutModeHistory.values.pop() ?? "solo";
+                  return {
+                    data: true
+                  };
+                }
+                if (isLayoutMode(intent?.data?.layoutMode)) {
+                  layoutModeHistory.values.push(layout.values.layoutMode);
+                  layout.values.layoutMode = intent.data.layoutMode;
+                } else {
+                  log.warn("Invalid layout mode", intent?.data?.layoutMode, {
+                    F: __dxlog_file,
+                    L: 384,
+                    S: void 0,
+                    C: (f, a) => f(...a)
+                  });
+                }
+                return {
+                  data: true
+                };
+              });
+            }
+            case LayoutAction3.SCROLL_INTO_VIEW: {
+              layout.values.scrollIntoView = intent.data?.id ?? void 0;
+              return void 0;
+            }
+            case DeckAction.UPDATE_PLANK_SIZE: {
+              const { id, size } = intent.data;
+              deck.values.plankSizing[id] = size;
+              return {
+                data: true
+              };
+            }
+            case IntentAction.SHOW_UNDO: {
+              if (currentUndoId) {
+                layout.values.toasts = layout.values.toasts.filter((toast) => toast.id !== currentUndoId);
+              }
+              currentUndoId = `${IntentAction.SHOW_UNDO}-${Date.now()}`;
+              const title = (
+                // TODO(wittjosiah): How to handle chains better?
+                intent.data?.results?.[0]?.result?.undoable?.message ?? translations_default[0]["en-US"]["dxos.org/plugin/deck"]["undo available label"]
+              );
+              layout.values.toasts = [
+                ...layout.values.toasts,
+                {
+                  id: currentUndoId,
+                  title,
+                  duration: 1e4,
+                  actionLabel: translations_default[0]["en-US"]["dxos.org/plugin/deck"]["undo action label"],
+                  actionAlt: translations_default[0]["en-US"]["dxos.org/plugin/deck"]["undo action alt"],
+                  closeLabel: translations_default[0]["en-US"]["dxos.org/plugin/deck"]["undo close label"],
+                  onAction: () => intentPlugin?.provides.intent.undo?.()
+                }
+              ];
+              return {
+                data: true
+              };
+            }
+            case NavigationAction3.OPEN: {
+              const previouslyOpenIds = new Set(openIds2(location.values.active));
+              const layoutMode = layout.values.layoutMode;
+              batch(() => {
+                if (!intent.data || !intent.data?.activeParts) {
+                  return;
+                }
+                const newPlankPositioning = settings.values.newPlankPositioning;
+                const processLayoutEntry = (partName, entryString, currentLayout) => {
+                  const [id, path] = entryString.split(SLUG_PATH_SEPARATOR5);
+                  const layoutEntry = {
+                    id,
+                    ...path ? {
+                      path
+                    } : {}
+                  };
+                  const effectivePart = getEffectivePart(partName, layoutMode);
+                  if (layoutMode === "deck" && effectivePart === "main" && currentLayout[effectivePart]?.some((entry) => entry.id === id) && !intent.data?.noToggle) {
+                    return closeEntry(currentLayout, {
+                      part: effectivePart,
+                      entryId: id
+                    });
+                  } else {
+                    return openEntry(currentLayout, effectivePart, layoutEntry, {
+                      positioning: newPlankPositioning
+                    });
+                  }
+                };
+                let newLayout = location.values.active;
+                Object.entries(intent.data.activeParts).forEach(([partName, layoutEntries]) => {
+                  if (Array.isArray(layoutEntries)) {
+                    layoutEntries.forEach((activePartEntry) => {
+                      newLayout = processLayoutEntry(partName, activePartEntry, newLayout);
+                    });
+                  } else if (typeof layoutEntries === "string") {
+                    newLayout = processLayoutEntry(partName, layoutEntries, newLayout);
+                  }
+                });
+                location.values.active = newLayout;
+              });
+              const ids = openIds2(location.values.active);
+              const newlyOpen = ids.filter((i) => !previouslyOpenIds.has(i));
+              return {
+                data: {
+                  ids
+                },
+                intents: [
+                  newlyOpen.length > 0 ? [
+                    {
+                      action: LayoutAction3.SCROLL_INTO_VIEW,
+                      data: {
+                        id: newlyOpen[0]
+                      }
+                    }
+                  ] : [],
+                  intent.data?.object ? [
+                    {
+                      action: NavigationAction3.EXPOSE,
+                      data: {
+                        id: fullyQualifiedId(intent.data.object)
+                      }
+                    }
+                  ] : [],
+                  observability ? newlyOpen.map((id) => {
+                    const active = graphPlugin?.provides.graph.findNode(id)?.data;
+                    const typename = isReactiveObject(active) ? getTypename(active) : void 0;
+                    return {
+                      action: ObservabilityAction.SEND_EVENT,
+                      data: {
+                        name: "navigation.activate",
+                        properties: {
+                          id,
+                          typename
+                        }
+                      }
+                    };
+                  }) : []
+                ]
+              };
+            }
+            case NavigationAction3.ADD_TO_ACTIVE: {
+              const data = intent.data;
+              const layoutEntry = {
+                id: data.id
+              };
+              const effectivePart = getEffectivePart(data.part, layout.values.layoutMode);
+              location.values.active = openEntry(location.values.active, effectivePart, layoutEntry, {
+                positioning: data.positioning ?? settings.values.newPlankPositioning,
+                pivotId: data.pivotId
+              });
+              const intents = [];
+              if (data.scrollIntoView && layout.values.layoutMode === "deck") {
+                intents.push([
+                  {
+                    action: LayoutAction3.SCROLL_INTO_VIEW,
+                    data: {
+                      id: data.id
+                    }
+                  }
+                ]);
+              }
+              return {
+                data: true,
+                intents
+              };
+            }
+            case NavigationAction3.CLOSE: {
+              return batch(() => {
+                if (!intent.data) {
+                  return;
+                }
+                let newLayout = location.values.active;
+                const layoutMode = layout.values.layoutMode;
+                const intentParts = intent.data.activeParts;
+                Object.keys(intentParts).forEach((partName) => {
+                  const effectivePart = getEffectivePart(partName, layoutMode);
+                  const ids = intentParts[partName];
+                  if (Array.isArray(ids)) {
+                    ids.forEach((id) => {
+                      newLayout = closeEntry(newLayout, {
+                        part: effectivePart,
+                        entryId: id
+                      });
+                    });
+                  } else {
+                    newLayout = closeEntry(newLayout, {
+                      part: effectivePart,
+                      entryId: ids
+                    });
+                  }
+                });
+                location.values.active = newLayout;
+                return {
+                  data: true
+                };
+              });
+            }
+            case NavigationAction3.SET: {
+              return batch(() => {
+                if (isLayoutParts(intent.data?.activeParts)) {
+                  location.values.active = intent.data.activeParts;
+                }
+                return {
+                  data: true
+                };
+              });
+            }
+            case NavigationAction3.ADJUST: {
+              return batch(() => {
+                if (isLayoutAdjustment(intent.data)) {
+                  const adjustment = intent.data;
+                  if (adjustment.type === "increment-end" || adjustment.type === "increment-start") {
+                    const nextActive = incrementPlank(location.values.active, {
+                      type: adjustment.type,
+                      layoutCoordinate: adjustment.layoutCoordinate
+                    });
+                    location.values.active = nextActive;
+                  }
+                  if (adjustment.type === "solo") {
+                    const entryId = adjustment.layoutCoordinate.entryId;
+                    if (layout.values.layoutMode !== "solo") {
+                      return {
+                        data: true,
+                        intents: [
+                          [
+                            {
+                              action: LayoutAction3.SET_LAYOUT_MODE,
+                              data: {
+                                layoutMode: "solo"
+                              }
+                            },
+                            {
+                              action: NavigationAction3.OPEN,
+                              data: {
+                                activeParts: {
+                                  solo: [
+                                    entryId
+                                  ]
+                                }
+                              }
+                            }
+                          ]
+                        ]
+                      };
+                    } else {
+                      return {
+                        data: true,
+                        intents: [
+                          [
+                            {
+                              action: LayoutAction3.SET_LAYOUT_MODE,
+                              data: {
+                                layoutMode: "deck"
+                              }
+                            },
+                            {
+                              action: NavigationAction3.CLOSE,
+                              data: {
+                                activeParts: {
+                                  solo: [
+                                    entryId
+                                  ]
+                                }
+                              }
+                            },
+                            {
+                              action: NavigationAction3.OPEN,
+                              data: {
+                                noToggle: true,
+                                activeParts: {
+                                  main: [
+                                    entryId
+                                  ]
+                                }
+                              }
+                            },
+                            {
+                              action: LayoutAction3.SCROLL_INTO_VIEW,
+                              data: {
+                                id: entryId
+                              }
+                            }
+                          ]
+                        ]
+                      };
+                    }
+                  }
+                }
+              });
+            }
+          }
+        }
+      }
+    }
+  };
+};
+
+// packages/plugins/plugin-deck/src/index.ts
+var src_default = DeckPlugin;
+export {
+  DeckAction,
+  DeckPlugin,
+  src_default as default
+};
+//# sourceMappingURL=index.mjs.map