efficient-shell 0.0.0-stage → 4.126.2

package/dist/chunk-W6XTG23K.js

@@ -0,0 +1,3708 @@
+import { useShellAuth, navIcons } from './chunk-GA35NEND.js';
+import { isStaleChunkError, CMD_Z, CMD_SHIFT_Z, LoadingSpinner, Result, Button_default, useIsMobile, useShellPrefs } from './chunk-YNHLQ24V.js';
+import { useShellStrings, PopupMenu, PopupMenuItem, PopupMenuDivider, PopupMenuLabel } from './chunk-7KIOEKHS.js';
+import { Z_LAYERS, confirm, runEscapeInterceptors } from './chunk-HYZ5QMVO.js';
+import { createContext, Component, useContext, useLayoutEffect, useRef, useEffect, useState, useCallback, useSyncExternalStore, useMemo, isValidElement, cloneElement, useReducer, useId, Suspense } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { createPortal } from 'react-dom';
+import { XMarkIcon } from '@heroicons/react/24/outline';
+import { useLocation } from 'react-router-dom';
+import { useQueryClient, useQuery } from '@tanstack/react-query';
+
+// src/windowRegistry/types.ts
+function isPageEntry(entry) {
+  return "component" in entry;
+}
+function isEntityEntry(entry) {
+  return "endpoint" in entry;
+}
+var _registry = {};
+function setShellWindowRegistry(registry) {
+  _registry = registry;
+}
+var WINDOW_REGISTRY = new Proxy({}, {
+  get(_t, prop) {
+    return _registry[prop];
+  },
+  has(_t, prop) {
+    return prop in _registry;
+  },
+  ownKeys() {
+    return Object.keys(_registry);
+  },
+  getOwnPropertyDescriptor(_t, prop) {
+    if (prop in _registry) {
+      return { configurable: true, enumerable: true, value: _registry[prop] };
+    }
+    return void 0;
+  }
+});
+
+// src/api/client.ts
+var _apiClient = null;
+function setShellApiClient(instance) {
+  _apiClient = instance;
+}
+function isShellApiClientConfigured() {
+  return _apiClient !== null;
+}
+var NOOP_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options",
+  "request"
+]);
+var apiClient = new Proxy({}, {
+  get(_t, prop) {
+    if (_apiClient) return _apiClient[prop];
+    if (typeof prop === "string" && NOOP_METHODS.has(prop)) {
+      return () => Promise.resolve({ data: null, status: 0, statusText: "", headers: {}, config: {} });
+    }
+    return void 0;
+  }
+});
+var client_default = apiClient;
+function WindowCrashedFallback({ error, onReload }) {
+  const stale = isStaleChunkError(error);
+  return /* @__PURE__ */ jsxs("div", { className: "flex-1 flex flex-col items-center justify-center gap-3 px-6 py-12 text-center", children: [
+    /* @__PURE__ */ jsx("svg", { className: "h-8 w-8 text-amber-500", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M12 9v3.75m-9.303 3.376c-.866 1.5.217 3.374 1.948 3.374h14.71c1.73 0 2.813-1.874 1.948-3.374L13.949 3.378c-.866-1.5-3.032-1.5-3.898 0L2.697 16.126zM12 15.75h.007v.008H12v-.008z" }) }),
+    /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+      /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-gray-700", children: stale ? "This window needs the latest version of the app" : "This window crashed" }),
+      /* @__PURE__ */ jsx("p", { className: "mt-1 text-xs text-gray-400 max-w-sm break-words", children: stale ? "A new version was deployed while this tab was open. Reload the page to pick it up." : error.message || String(error) })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: stale ? () => window.location.reload() : onReload,
+        className: "bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 text-sm font-medium rounded-lg",
+        children: stale ? "Reload page" : "Reload window"
+      }
+    )
+  ] });
+}
+var WindowErrorBoundary = class extends Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error: error instanceof Error ? error : new Error(String(error)) };
+  }
+  componentDidCatch(error, info) {
+    console.error("[react-os-shell] window content crashed:", error, info.componentStack);
+  }
+  reset = () => this.setState({ error: null });
+  render() {
+    const { error } = this.state;
+    if (error) {
+      return this.props.fallback ? this.props.fallback(error, this.reset) : /* @__PURE__ */ jsx(WindowCrashedFallback, { error, onReload: this.reset });
+    }
+    return this.props.children;
+  }
+};
+var UndoContext = createContext(null);
+var BTN = "text-xs text-gray-500 hover:text-gray-700 disabled:opacity-40 disabled:hover:text-gray-500 disabled:cursor-default";
+function UndoControls({ className = "", auto = false }) {
+  const ctx = useContext(UndoContext);
+  const claimOwnMount = ctx?.claimOwnMount;
+  useLayoutEffect(() => {
+    if (auto || !claimOwnMount) return;
+    claimOwnMount(true);
+    return () => claimOwnMount(false);
+  }, [auto, claimOwnMount]);
+  if (!ctx || !ctx.enabled) return null;
+  const { undo, redo, canUndo, canRedo, undoLabel, redoLabel } = ctx;
+  return /* @__PURE__ */ jsxs("div", { className: `flex items-center gap-2 ${className}`, "data-undo-controls": auto ? "shell" : "form", children: [
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: undo,
+        disabled: !canUndo,
+        title: canUndo ? `Undo ${undoLabel} (${CMD_Z})` : "Nothing to undo",
+        className: BTN,
+        children: "Undo"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: redo,
+        disabled: !canRedo,
+        title: canRedo ? `Redo ${redoLabel} (${CMD_SHIFT_Z})` : "Nothing to redo",
+        className: BTN,
+        children: "Redo"
+      }
+    )
+  ] });
+}
+
+// src/shell/entityFetchPolicy.ts
+var RETRYABLE_CLIENT_STATUSES = /* @__PURE__ */ new Set([
+  408,
+  // Request Timeout
+  429
+  // Too Many Requests
+]);
+var ENTITY_FETCH_MAX_RETRIES = 3;
+var ENTITY_REFETCH_INTERVAL_MS = 6e4;
+function entityFetchStatus(error) {
+  const status = error?.response?.status;
+  return typeof status === "number" ? status : void 0;
+}
+function isPermanentClientError(error) {
+  const status = entityFetchStatus(error);
+  if (status == null) return false;
+  return status >= 400 && status < 500 && !RETRYABLE_CLIENT_STATUSES.has(status);
+}
+function shouldRetryEntityFetch(failureCount, error) {
+  return !isPermanentClientError(error) && failureCount < ENTITY_FETCH_MAX_RETRIES;
+}
+function entityRefetchInterval(error) {
+  return isPermanentClientError(error) ? false : ENTITY_REFETCH_INTERVAL_MS;
+}
+function entityDetailUrl(endpoint, entityId) {
+  return `${endpoint}${encodeURIComponent(entityId)}/`;
+}
+function LoadingSpinner2() {
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center justify-center p-8 text-sm text-gray-400", children: "Loading..." });
+}
+var FILL_CLASS = "flex-1 min-h-0";
+function EntityWindowLoading() {
+  return /* @__PURE__ */ jsx(LoadingSpinner, { label: "Loading record\u2026", padding: "", className: FILL_CLASS });
+}
+function normaliseEntitySnapshot(snapshot) {
+  return snapshot ?? void 0;
+}
+function EntityWindowFallback({
+  isPending,
+  isFetching,
+  enabled = true,
+  error,
+  onRetry
+}) {
+  if (isFetching || isPending && enabled) return /* @__PURE__ */ jsx(EntityWindowLoading, {});
+  if (error) {
+    const status = entityFetchStatus(error);
+    if (status === 401) {
+      return /* @__PURE__ */ jsx(
+        Result,
+        {
+          status: "warning",
+          title: "Sign in required",
+          subTitle: "Your session may have expired. Sign in again to open this record.",
+          className: FILL_CLASS
+        }
+      );
+    }
+    if (status === 403) {
+      return /* @__PURE__ */ jsx(Result, { status: "403", className: FILL_CLASS });
+    }
+    if (status === 404 || status === 410) {
+      return /* @__PURE__ */ jsx(Result, { status: "404", title: "Record not found", className: FILL_CLASS });
+    }
+    const canRetry = status == null || status === 408 || status === 429 || status >= 500;
+    return /* @__PURE__ */ jsx(
+      Result,
+      {
+        status: "500",
+        title: "Couldn't load record",
+        subTitle: canRetry ? "Check your connection and try again." : "The server rejected this request.",
+        extra: canRetry ? /* @__PURE__ */ jsx(Button_default, { variant: "secondary", size: "sm", onClick: onRetry, children: "Try again" }) : void 0,
+        className: FILL_CLASS
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(Result, { status: "404", title: "Record not found", className: FILL_CLASS });
+}
+function EntityWindowState({
+  entity,
+  children,
+  ...fallback
+}) {
+  if (entity != null) return /* @__PURE__ */ jsx(Fragment, { children: children(entity) });
+  return /* @__PURE__ */ jsx(EntityWindowFallback, { ...fallback });
+}
+
+// src/shell/draftWindow.ts
+var TIMESTAMPED_PLACEHOLDER = /^[a-z]+(?:-[a-z]+)*-\d{13}$/;
+function isDraftEntityId(entityId) {
+  return typeof entityId === "string" && (entityId.startsWith("new-") || TIMESTAMPED_PLACEHOLDER.test(entityId));
+}
+function isDraftEntityWindow(item) {
+  if (isDraftEntityId(item.entityId)) return true;
+  const snapshot = item.entitySnapshot;
+  return !!snapshot && typeof snapshot === "object" && (!!snapshot._new || !!snapshot._duplicate);
+}
+var MinimizedContext = createContext({
+  openWindows: [],
+  openEntity: () => {
+  },
+  openPage: () => {
+  },
+  closeEntity: () => {
+  },
+  minimize: () => {
+  },
+  items: [],
+  restore: () => {
+  },
+  remove: () => {
+  },
+  restoreIfMinimized: () => false,
+  openItems: []
+});
+var WindowDirtyContext = createContext(null);
+function useWindowDirty(dirty) {
+  const register = useContext(WindowDirtyContext);
+  const idRef = useRef(null);
+  if (idRef.current === null) idRef.current = /* @__PURE__ */ Symbol("window-dirty");
+  useLayoutEffect(() => {
+    if (!register) return;
+    return register(idRef.current, dirty);
+  }, [register, dirty]);
+  useEffect(() => {
+    if (!register || !dirty) return;
+    const holdUnload = (e) => {
+      e.preventDefault();
+      e.returnValue = "";
+    };
+    window.addEventListener("beforeunload", holdUnload);
+    return () => window.removeEventListener("beforeunload", holdUnload);
+  }, [register, dirty]);
+}
+function useWindowDirtyRegistry() {
+  const registrations = useRef(/* @__PURE__ */ new Map());
+  const [dirty, setDirty] = useState(false);
+  const registerDirty = useCallback((id, value) => {
+    const updateAggregate = () => {
+      const next = Array.from(registrations.current.values()).some(Boolean);
+      setDirty((current) => current === next ? current : next);
+    };
+    registrations.current.set(id, value);
+    updateAggregate();
+    return () => {
+      registrations.current.delete(id);
+      updateAggregate();
+    };
+  }, []);
+  return { dirty, registerDirty };
+}
+function useWindowManager() {
+  return useContext(MinimizedContext);
+}
+function shortcutSpecFor(item) {
+  if (item.type !== "page" && isDraftEntityWindow(item)) return null;
+  const entityType = item.type === "page" ? "page" : item.entityType || "";
+  const entityId = item.type === "page" ? item.route || "" : item.entityId || "";
+  if (!entityType || !entityId) return null;
+  return { entityType, entityId, label: item.label };
+}
+function PageWindow({ item, onClose, accentRgb }) {
+  const { dirty, registerDirty } = useWindowDirtyRegistry();
+  const raw = WINDOW_REGISTRY[item.route];
+  if (!raw || !isPageEntry(raw)) return null;
+  const entry = raw;
+  const Component2 = entry.component;
+  return /* @__PURE__ */ jsx(Modal, { open: true, onClose, icon: navIcons[item.route], title: entry.label, size: entry.size || "2xl", dirty, allowPinOnTop: entry.allowPinOnTop, initialPosition: entry.initialPosition, widget: entry.widget, compact: entry.compact, appStyle: entry.appStyle, flushBody: entry.flushBody, autoHeight: entry.autoHeight, autoMinHeight: entry.autoMinHeight, autoWidth: entry.autoWidth, dimensions: entry.dimensions, windowKey: item.id, openedFromKey: item.openedFrom, accentRgb, children: /* @__PURE__ */ jsx(WindowDirtyContext.Provider, { value: registerDirty, children: /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx("div", { className: "flex items-center justify-center py-12", children: /* @__PURE__ */ jsx(LoadingSpinner2, {}) }), children: /* @__PURE__ */ jsx(Component2, {}) }) }) });
+}
+function DocFavStar({ entityType, entityId, label }) {
+  const shellStrings = useShellStrings();
+  const queryClient = useQueryClient();
+  const { data: profile } = useQuery({ queryKey: ["my-profile-sidebar"], enabled: isShellApiClientConfigured(), queryFn: () => client_default.get("/auth/me/").then((r) => r.data) });
+  const favDocs = (profile?.preferences || {}).favorite_documents || [];
+  const isFav = favDocs.some((d) => d.entityType === entityType && d.entityId === entityId);
+  const toggle = () => {
+    const next = isFav ? favDocs.filter((d) => !(d.entityType === entityType && d.entityId === entityId)) : [...favDocs, { entityType, entityId, label }];
+    client_default.patch("/auth/me/", { preferences: { favorite_documents: next } }).then(() => {
+      queryClient.invalidateQueries({ queryKey: ["my-profile-sidebar"] });
+    });
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      onClick: toggle,
+      title: isFav ? shellStrings.taskbar.removeFromDesktop : shellStrings.taskbar.addToDesktop,
+      className: `shrink-0 transition-colors ${isFav ? "text-yellow-500 hover:text-yellow-600" : "text-gray-300 hover:text-yellow-400"}`,
+      children: /* @__PURE__ */ jsx("svg", { className: "h-4 w-4", fill: isFav ? "currentColor" : "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M11.48 3.499a.562.562 0 011.04 0l2.125 5.111a.563.563 0 00.475.345l5.518.442c.499.04.701.663.321.988l-4.204 3.602a.563.563 0 00-.182.557l1.285 5.385a.562.562 0 01-.84.61l-4.725-2.885a.563.563 0 00-.586 0L6.982 20.54a.562.562 0 01-.84-.61l1.285-5.386a.562.562 0 00-.182-.557l-4.204-3.602a.563.563 0 01.321-.988l5.518-.442a.563.563 0 00.475-.345L11.48 3.5z" }) })
+    }
+  );
+}
+function RestoredRegistryModal({ item, onClose, onMinimize, accentRgb }) {
+  const raw = WINDOW_REGISTRY[item.entityType];
+  if (!raw || !isEntityEntry(raw)) return null;
+  const entry = raw;
+  const [editing, setEditing] = useState(false);
+  const { dirty, registerDirty } = useWindowDirtyRegistry();
+  const qkPrefix = entry.queryKey || entry.endpoint.replace(/^\/|\/$/g, "").split("/").pop() || item.entityType;
+  const isDuplicate = item.entitySnapshot?._duplicate;
+  const isDraft = isDraftEntityId(item.entityId);
+  const fetchesDetail = !entry.selfFetching && !isDuplicate && !isDraft && isShellApiClientConfigured();
+  const entityQuery = useQuery({
+    queryKey: [qkPrefix, item.entityId],
+    queryFn: () => client_default.get(entityDetailUrl(entry.endpoint, String(item.entityId))).then((r) => r.data),
+    initialData: normaliseEntitySnapshot(item.entitySnapshot),
+    initialDataUpdatedAt: 0,
+    // Treat snapshot as stale so query refetches immediately
+    enabled: fetchesDetail,
+    staleTime: 0,
+    refetchOnWindowFocus: true,
+    refetchOnMount: "always",
+    // Fallback polling; WebSocket provides instant updates. A window whose
+    // entity the server says is not there stops polling instead of asking
+    // every 60s forever — see entityFetchPolicy.
+    refetchInterval: (query) => entityRefetchInterval(query.state.error),
+    refetchIntervalInBackground: false,
+    retry: shouldRetryEntityFetch
+  });
+  const entity = entityQuery.data;
+  const refetch = entityQuery.refetch;
+  useEffect(() => {
+    if (entry.selfFetching || isDuplicate || isDraft) return;
+    const handler = () => {
+      refetch();
+    };
+    window.addEventListener("modal-reorder", handler);
+    return () => window.removeEventListener("modal-reorder", handler);
+  }, [refetch, entry.selfFetching, isDuplicate, isDraft]);
+  const handleClose = useCallback(() => {
+    if (editing && !dirty) {
+      setEditing(false);
+    } else {
+      onClose();
+    }
+  }, [editing, dirty, onClose]);
+  const titleBase = entry.selfFetching ? item.label : entity ? entry.title(entity, editing, setEditing) : item.label;
+  const entityIconKey = entry.icon;
+  const entityIcon = entityIconKey ? navIcons[entityIconKey] : null;
+  const titleContent = titleBase;
+  const footerContent = !entry.selfFetching && entity && entry.footer && !isDuplicate ? entry.footer(entity) : void 0;
+  if (entry.rendersOwnModal) {
+    if (entry.selfFetching) {
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingSpinner2, {}), children: entry.render(entity ?? item.entitySnapshot, onClose, item.entityId, editing, setEditing) });
+    }
+    if (entity != null) {
+      return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Modal, { open: true, onClose, title: item.label, size: entry.size || "2xl", children: /* @__PURE__ */ jsx(EntityWindowLoading, {}) }), children: entry.render(entity, onClose, item.entityId, editing, setEditing) });
+    }
+    return /* @__PURE__ */ jsx(Modal, { open: true, onClose, title: item.label, size: entry.size || "2xl", children: /* @__PURE__ */ jsx(
+      EntityWindowFallback,
+      {
+        isPending: entityQuery.isPending,
+        isFetching: entityQuery.isFetching,
+        enabled: fetchesDetail,
+        error: entityQuery.error,
+        onRetry: refetch
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx(
+    Modal,
+    {
+      open: true,
+      onClose: handleClose,
+      onMinimize,
+      initialBox: item.savedBox,
+      icon: entityIcon,
+      title: titleContent,
+      footer: footerContent,
+      copyText: item.label,
+      windowKey: item.id,
+      openedFromKey: item.openedFrom,
+      size: entry.size || "2xl",
+      dirty,
+      editing: editing || isDraft || isDuplicate,
+      dimensions: entry.dimensions,
+      autoHeight: entry.autoHeight,
+      autoMinHeight: entry.autoMinHeight,
+      autoWidth: entry.autoWidth,
+      appStyle: entry.appStyle,
+      flushBody: entry.flushBody,
+      accentRgb,
+      children: /* @__PURE__ */ jsx(WindowDirtyContext.Provider, { value: registerDirty, children: /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(EntityWindowLoading, {}), children: entry.selfFetching ? entry.render(null, onClose, item.entityId, editing, setEditing) : /* @__PURE__ */ jsx(
+        EntityWindowState,
+        {
+          entity,
+          isPending: entityQuery.isPending,
+          isFetching: entityQuery.isFetching,
+          enabled: fetchesDetail,
+          error: entityQuery.error,
+          onRetry: refetch,
+          children: (current) => entry.render(current, onClose, item.entityId, editing, setEditing)
+        }
+      ) }) })
+    }
+  );
+}
+function findPanelByWindowKey(key) {
+  return document.querySelector(`[data-modal-panel][data-window-key="${key}"]`);
+}
+function currentlyActiveWindowKey() {
+  const activeId = getActiveModalId();
+  if (!activeId) return void 0;
+  const panel = document.querySelector(`[data-modal-panel][data-modal-id="${activeId}"]`);
+  return panel?.getAttribute("data-window-key") ?? void 0;
+}
+var routeByWindowKey = /* @__PURE__ */ new Map();
+function getActiveWindowRoute() {
+  const key = currentlyActiveWindowKey();
+  if (!key) return void 0;
+  return routeByWindowKey.get(key);
+}
+function findPanelByLabel(label) {
+  const panels = document.querySelectorAll("[data-modal-panel]");
+  for (const p of Array.from(panels)) {
+    const t = p.querySelector("[data-window-title]");
+    if (t?.textContent?.includes(label)) return p;
+  }
+  return null;
+}
+var PEEK_STYLE_ID = "rosh-peek-style";
+var PEEK_Z = 249;
+var PREVIEW_Z = 300;
+function ensurePeekStyle() {
+  if (typeof document === "undefined" || document.getElementById(PEEK_STYLE_ID)) return;
+  const style = document.createElement("style");
+  style.id = PEEK_STYLE_ID;
+  style.textContent = `body.rosh-peeking [data-modal-panel]{transition:opacity .18s ease}body.rosh-peeking [data-modal-panel]:not([data-peek-focus]){opacity:.4}body.rosh-peeking [data-modal-panel][data-peek-focus]{opacity:1}body.rosh-peeking [data-modal-panel][data-peek-focus]:not([data-pinned-top]){z-index:${PEEK_Z}!important}html.rosh-reduce-transparency body.rosh-peeking [data-modal-panel]:not([data-peek-focus]){opacity:.92}@media (prefers-reduced-motion:reduce){body.rosh-peeking [data-modal-panel]{transition:none}}`;
+  document.head.appendChild(style);
+}
+function setPeekFocus(panel) {
+  if (typeof document === "undefined") return;
+  ensurePeekStyle();
+  document.querySelectorAll("[data-modal-panel][data-peek-focus]").forEach((el) => el.removeAttribute("data-peek-focus"));
+  if (panel) panel.setAttribute("data-peek-focus", "");
+  document.body.classList.toggle("rosh-peeking", !!panel);
+}
+function clearPeekFocus() {
+  if (typeof document === "undefined") return;
+  document.body.classList.remove("rosh-peeking");
+  document.querySelectorAll("[data-modal-panel][data-peek-focus]").forEach((el) => el.removeAttribute("data-peek-focus"));
+}
+function ThumbCard({ id, label, maxW, maxH, titleAbove = false, onClick, onClose }) {
+  const shellStrings = useShellStrings();
+  const previewRef = useRef(null);
+  const [size, setSize] = useState({ w: maxW, h: Math.round(maxH * 0.75) });
+  const [hasSnapshot, setHasSnapshot] = useState(false);
+  useLayoutEffect(() => {
+    const inner = previewRef.current;
+    if (!inner) return;
+    const target = findPanelByWindowKey(id) ?? findPanelByLabel(label);
+    if (!target) {
+      setHasSnapshot(false);
+      return;
+    }
+    const rect = target.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) {
+      setHasSnapshot(false);
+      return;
+    }
+    const ratio = Math.min(maxW / rect.width, maxH / rect.height);
+    const cardW = Math.max(80, Math.round(rect.width * ratio));
+    const cardH = Math.max(60, Math.round(rect.height * ratio));
+    setSize({ w: cardW, h: cardH });
+    setHasSnapshot(true);
+    const clone = target.cloneNode(true);
+    clone.style.position = "absolute";
+    clone.style.top = "0";
+    clone.style.left = "0";
+    clone.style.right = "auto";
+    clone.style.bottom = "auto";
+    clone.style.width = rect.width + "px";
+    clone.style.height = rect.height + "px";
+    clone.style.transform = `scale(${ratio})`;
+    clone.style.transformOrigin = "top left";
+    clone.style.pointerEvents = "none";
+    clone.style.animation = "none";
+    clone.style.zIndex = "auto";
+    clone.removeAttribute("data-modal-panel");
+    clone.removeAttribute("data-modal-id");
+    clone.removeAttribute("data-window-key");
+    clone.querySelectorAll('[role="dialog"], [data-portal]').forEach((el) => {
+      el.style.display = "none";
+    });
+    inner.innerHTML = "";
+    inner.appendChild(clone);
+    return () => {
+      inner.innerHTML = "";
+    };
+  }, [id, label, maxW, maxH]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: { width: size.w, height: size.h },
+      className: "relative rounded-md overflow-hidden bg-white/95 border border-gray-300 shadow-md cursor-pointer ring-2 ring-transparent group-hover:ring-blue-400 transition shrink-0",
+      onClick,
+      children: [
+        /* @__PURE__ */ jsx("div", { ref: previewRef, className: "absolute inset-0 z-0 overflow-hidden" }),
+        !hasSnapshot && /* @__PURE__ */ jsxs("div", { className: "absolute inset-0 flex flex-col items-center justify-center text-gray-400 bg-gray-50", children: [
+          /* @__PURE__ */ jsx("svg", { className: "h-6 w-6", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M3.75 6.75A2.25 2.25 0 016 4.5h12a2.25 2.25 0 012.25 2.25v10.5A2.25 2.25 0 0118 19.5H6a2.25 2.25 0 01-2.25-2.25V6.75z M3.75 9h16.5" }) }),
+          /* @__PURE__ */ jsx("span", { className: "mt-1 text-[10px] uppercase tracking-wide", children: "Hidden" })
+        ] }),
+        !titleAbove && /* @__PURE__ */ jsx("div", { className: "absolute bottom-0 left-0 right-0 z-10 px-2 py-1 text-[10px] font-medium text-white bg-gradient-to-t from-black/80 to-transparent truncate pointer-events-none", children: label }),
+        onClose && /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: (e) => {
+              e.stopPropagation();
+              onClose();
+            },
+            className: "absolute top-1 right-1 z-20 h-5 w-5 rounded-full bg-gray-900/90 ring-1 ring-white/80 shadow-sm hover:bg-red-500 text-white flex items-center justify-center",
+            title: shellStrings.taskbar.closeWindow,
+            children: /* @__PURE__ */ jsx("svg", { className: "h-3 w-3", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 3, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M6 18L18 6M6 6l12 12" }) })
+          }
+        )
+      ]
+    }
+  );
+}
+function TaskbarTabPreview({ items, anchorEl, onActivate, onClose, onMouseEnter, onMouseLeave }) {
+  const shellStrings = useShellStrings();
+  const MAX_W = 240;
+  const MAX_H = 160;
+  const isGroup = items.length > 1;
+  const popoverRef = useRef(null);
+  const [pos, setPos] = useState({ left: -9999, top: -9999, ready: false });
+  const [taskbarPos, setTaskbarPos] = useState(
+    () => typeof document !== "undefined" ? getComputedStyle(document.documentElement).getPropertyValue("--taskbar-position")?.trim() || "bottom" : "bottom"
+  );
+  useLayoutEffect(() => {
+    const el = popoverRef.current;
+    if (!el) return;
+    const measure = () => {
+      const tabRect = anchorEl.getBoundingClientRect();
+      const popRect = el.getBoundingClientRect();
+      const tbPos = getComputedStyle(document.documentElement).getPropertyValue("--taskbar-position")?.trim() || "bottom";
+      setTaskbarPos(tbPos);
+      let left = tabRect.left + tabRect.width / 2 - popRect.width / 2;
+      let top;
+      if (tbPos === "top") {
+        top = tabRect.bottom + 8;
+      } else if (tbPos === "left") {
+        left = tabRect.right + 8;
+        top = tabRect.top + tabRect.height / 2 - popRect.height / 2;
+      } else if (tbPos === "right") {
+        left = tabRect.left - popRect.width - 8;
+        top = tabRect.top + tabRect.height / 2 - popRect.height / 2;
+      } else {
+        top = tabRect.top - popRect.height - 8;
+      }
+      left = Math.max(8, Math.min(left, window.innerWidth - popRect.width - 8));
+      top = Math.max(8, Math.min(top, window.innerHeight - popRect.height - 8));
+      setPos({ left, top, ready: true });
+    };
+    measure();
+    const ro = new ResizeObserver(measure);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [anchorEl, items.length]);
+  useEffect(() => clearPeekFocus, []);
+  const titleBelow = taskbarPos === "top";
+  const titleClass = `${titleBelow ? "mt-1" : "mb-1"} max-w-[240px] truncate text-[11px] font-medium text-gray-900 bg-white/80 px-2 py-0.5 rounded shadow-sm ring-2 ring-transparent transition group-hover:ring-blue-400`;
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: popoverRef,
+        "data-taskbar-preview": "",
+        style: {
+          position: "fixed",
+          left: pos.left,
+          top: pos.top,
+          zIndex: PREVIEW_Z,
+          maxWidth: "calc(100vw - 16px)",
+          opacity: pos.ready ? 1 : 0
+        },
+        className: isGroup ? "flex gap-2 flex-wrap" : "",
+        onMouseEnter,
+        onMouseLeave: () => {
+          clearPeekFocus();
+          onMouseLeave();
+        },
+        children: items.map((it) => {
+          const panel = findPanelByWindowKey(it.id) ?? findPanelByLabel(it.label);
+          const bearing = panel ? panelOffscreenBearing(panel) : null;
+          return /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "group flex flex-col items-center",
+              onMouseEnter: () => setPeekFocus(panel),
+              children: [
+                !titleBelow && /* @__PURE__ */ jsx("span", { className: titleClass, children: it.label }),
+                /* @__PURE__ */ jsx(
+                  ThumbCard,
+                  {
+                    id: it.id,
+                    label: it.label,
+                    maxW: MAX_W,
+                    maxH: MAX_H,
+                    titleAbove: true,
+                    onClick: () => onActivate(it.id),
+                    onClose: () => onClose(it.id)
+                  }
+                ),
+                titleBelow && /* @__PURE__ */ jsx("span", { className: titleClass, children: it.label }),
+                bearing !== null && /* @__PURE__ */ jsxs(
+                  "span",
+                  {
+                    title: shellStrings.taskbar.offscreenHint,
+                    className: "mt-1 inline-flex items-center gap-1 rounded bg-amber-500 px-1.5 py-0.5 text-[10px] font-semibold text-white shadow-sm",
+                    children: [
+                      /* @__PURE__ */ jsx("svg", { className: "h-3 w-3", style: { transform: `rotate(${bearing}deg)` }, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 3, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M5 12h14m0 0l-5-5m5 5l-5 5" }) }),
+                      "Off screen"
+                    ]
+                  }
+                )
+              ]
+            },
+            it.id
+          );
+        })
+      }
+    ),
+    document.body
+  );
+}
+function taskbarMenuStyle(x, y) {
+  const pos = getComputedStyle(document.documentElement).getPropertyValue("--taskbar-position")?.trim() || "bottom";
+  return pos === "top" ? { left: Math.min(x, window.innerWidth - 220), top: y + 4 } : pos === "left" ? { left: x + 4, top: Math.min(y, window.innerHeight - 160) } : pos === "right" ? { right: window.innerWidth - x + 4, top: Math.min(y, window.innerHeight - 160) } : { left: Math.min(x, window.innerWidth - 220), bottom: window.innerHeight - y + 4 };
+}
+function TaskbarWindows({ openWindows, onRemove, onSplitView, onActivate, onActivateById }) {
+  const shellStrings = useShellStrings();
+  const [target, setTarget] = useState(null);
+  useEffect(() => {
+    const el = document.getElementById("taskbar-windows");
+    if (el) setTarget(el);
+    else {
+      const t = setInterval(() => {
+        const e = document.getElementById("taskbar-windows");
+        if (e) {
+          setTarget(e);
+          clearInterval(t);
+        }
+      }, 100);
+      return () => clearInterval(t);
+    }
+  }, []);
+  const activeModalId = useSyncExternalStore(subscribeActive, getActiveModalId);
+  const [, setGeomTick] = useState(0);
+  useEffect(() => {
+    const bump = () => setGeomTick((t) => t + 1);
+    window.addEventListener("modal-geometry", bump);
+    window.addEventListener("resize", bump);
+    return () => {
+      window.removeEventListener("modal-geometry", bump);
+      window.removeEventListener("resize", bump);
+    };
+  }, []);
+  const [, forceTick] = useState(0);
+  useEffect(() => {
+    const onTitle = () => forceTick((t) => t + 1);
+    window.addEventListener("window-title-update", onTitle);
+    return () => window.removeEventListener("window-title-update", onTitle);
+  }, []);
+  const liveTitle = (label) => {
+    const panel = findPanelByLabel(label);
+    const titleEl = panel?.querySelector("[data-window-title]");
+    return titleEl?.textContent?.trim() || label;
+  };
+  const [hoveredItems, setHoveredItems] = useState(null);
+  const [hoveredAnchor, setHoveredAnchor] = useState(null);
+  const [groupMenu, setGroupMenu] = useState(null);
+  const hoverTimerRef = useRef(null);
+  const handleEnter = (items, el) => {
+    if (groupMenu) return;
+    if (hoverTimerRef.current) {
+      clearTimeout(hoverTimerRef.current);
+      hoverTimerRef.current = null;
+    }
+    hoverTimerRef.current = setTimeout(() => {
+      setHoveredItems(items);
+      setHoveredAnchor(el);
+    }, 350);
+  };
+  const dismissPreview = () => {
+    if (hoverTimerRef.current) {
+      clearTimeout(hoverTimerRef.current);
+      hoverTimerRef.current = null;
+    }
+    setHoveredItems(null);
+    setHoveredAnchor(null);
+  };
+  const handleLeave = () => {
+    if (hoverTimerRef.current) {
+      clearTimeout(hoverTimerRef.current);
+      hoverTimerRef.current = null;
+    }
+    hoverTimerRef.current = setTimeout(() => {
+      setHoveredItems(null);
+      setHoveredAnchor(null);
+    }, 150);
+  };
+  const cancelLeave = () => {
+    if (hoverTimerRef.current) {
+      clearTimeout(hoverTimerRef.current);
+      hoverTimerRef.current = null;
+    }
+  };
+  const tabWindows = openWindows.filter((item) => !item.route || !WINDOW_REGISTRY[item.route]?.utility);
+  if (!target || tabWindows.length === 0) return null;
+  const groups = [];
+  const idx = /* @__PURE__ */ new Map();
+  for (const item of tabWindows) {
+    const entry = item.route ? WINDOW_REGISTRY[item.route] : void 0;
+    const grp = entry?.taskbarGroup;
+    const key = grp?.key ?? item.route ?? `entity:${item.id}`;
+    const i = idx.get(key);
+    if (i !== void 0) {
+      groups[i].items.push(item);
+    } else {
+      idx.set(key, groups.length);
+      const label = grp?.label ?? entry?.label ?? item.label;
+      groups.push({ key, route: grp?.icon ?? item.route, label, items: [item] });
+    }
+  }
+  return createPortal(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      groups.map((group) => {
+        const icon = group.route ? navIcons[group.route] : null;
+        const primary = group.items[group.items.length - 1];
+        let isActive = false;
+        if (activeModalId) {
+          const panel = document.querySelector(`[data-modal-id="${activeModalId}"]`);
+          if (panel) {
+            const titleEl = panel.querySelector("[data-window-title]");
+            const titleText = titleEl?.textContent ?? "";
+            isActive = group.items.some((it) => titleText.includes(it.label));
+          }
+        }
+        const isGrouped = group.items.length > 1;
+        const offscreen = group.items.some((it) => {
+          const p = findPanelByWindowKey(it.id) ?? findPanelByLabel(it.label);
+          return !!p && !isPanelFullyVisible(p);
+        });
+        return /* @__PURE__ */ jsxs(
+          "button",
+          {
+            onClick: () => onActivateById(primary.id),
+            onMouseEnter: (e) => handleEnter(group.items, e.currentTarget),
+            onMouseLeave: handleLeave,
+            onDoubleClick: (e) => {
+              e.stopPropagation();
+              window.dispatchEvent(new CustomEvent("modal-center", { detail: { windowKey: primary.id, label: primary.label } }));
+            },
+            onContextMenu: (e) => {
+              e.preventDefault();
+              e.stopPropagation();
+              dismissPreview();
+              if (isGrouped) {
+                setGroupMenu({ x: e.clientX, y: e.clientY, items: group.items, label: group.label });
+                return;
+              }
+              window.dispatchEvent(new CustomEvent("modal-context-menu", { detail: { windowKey: primary.id, label: primary.label, x: e.clientX, y: e.clientY } }));
+            },
+            style: { width: "var(--window-tab-width, 200px)", fontSize: "var(--window-tab-font-size, 12px)" },
+            "data-tab-group": group.key,
+            className: `group relative flex items-center gap-1.5 rounded-lg px-3 py-2 font-medium transition-all min-w-0 shrink ${isActive ? "bg-blue-100/60 border border-blue-400/60 text-blue-700" : "bg-gray-50/40 border border-gray-200/40 text-gray-700 hover:bg-gray-200/40"}`,
+            children: [
+              icon && isValidElement(icon) ? cloneElement(icon, { className: `h-3.5 w-3.5 shrink-0 ${isActive ? "text-blue-600" : "text-gray-400"}` }) : /* @__PURE__ */ jsx("svg", { className: `h-3.5 w-3.5 shrink-0 ${isActive ? "text-blue-600" : "text-gray-400"}`, fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 2, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M4 8V4m0 0h4M4 4l5 5m11-1V4m0 0h-4m4 0l-5 5M4 16v4m0 0h4m-4 0l5-5m11 5l-5-5m5 5v-4m0 4h-4" }) }),
+              /* @__PURE__ */ jsx("span", { className: "truncate flex-1", children: isGrouped ? group.label : liveTitle(primary.label) }),
+              offscreen && /* @__PURE__ */ jsx("span", { title: shellStrings.taskbar.offscreenDot, className: "shrink-0 h-1.5 w-1.5 rounded-full bg-amber-500" }),
+              isGrouped && /* @__PURE__ */ jsx("span", { className: "shrink-0 px-1.5 py-0.5 rounded-full bg-blue-500/80 text-white text-[10px] font-bold leading-none", children: group.items.length }),
+              !isGrouped && /* @__PURE__ */ jsx("span", { role: "button", onClick: (e) => {
+                e.stopPropagation();
+                onRemove(primary.id);
+              }, className: "ml-auto text-gray-400 hover:text-red-500 shrink-0 opacity-0 group-hover:opacity-100 transition-opacity", children: /* @__PURE__ */ jsx("svg", { className: "h-3 w-3", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 2, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M6 18L18 6M6 6l12 12" }) }) })
+            ]
+          },
+          group.key
+        );
+      }),
+      /* @__PURE__ */ jsx("div", { className: "flex-1" }),
+      tabWindows.length >= 2 && /* @__PURE__ */ jsxs(
+        "button",
+        {
+          onClick: onSplitView,
+          title: shellStrings.taskbar.expose,
+          className: "flex items-center gap-1 rounded px-2 py-1 text-[11px] font-medium text-blue-600 border border-blue-300 hover:bg-blue-50 transition-colors shrink-0",
+          children: [
+            /* @__PURE__ */ jsxs("svg", { className: "h-3 w-3", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 2, children: [
+              /* @__PURE__ */ jsx("rect", { x: "3.5", y: "3.5", width: "7", height: "7", rx: "1" }),
+              /* @__PURE__ */ jsx("rect", { x: "13.5", y: "3.5", width: "7", height: "7", rx: "1" }),
+              /* @__PURE__ */ jsx("rect", { x: "3.5", y: "13.5", width: "7", height: "7", rx: "1" }),
+              /* @__PURE__ */ jsx("rect", { x: "13.5", y: "13.5", width: "7", height: "7", rx: "1" })
+            ] }),
+            "Expos\xE9"
+          ]
+        }
+      ),
+      groupMenu && /* @__PURE__ */ jsxs(PopupMenu, { portal: true, minWidth: 200, style: taskbarMenuStyle(groupMenu.x, groupMenu.y), onClose: () => setGroupMenu(null), children: [
+        /* @__PURE__ */ jsx(PopupMenuLabel, { children: groupMenu.label }),
+        /* @__PURE__ */ jsxs(PopupMenuItem, { onClick: () => {
+          setGroupMenu(null);
+          groupMenu.items.forEach((it) => minimizeWindowByKey(it.id));
+        }, children: [
+          /* @__PURE__ */ jsx("svg", { className: "h-4 w-4 text-gray-400", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M19.5 12h-15" }) }),
+          shellStrings.taskbar.minimizeAllWindows
+        ] }),
+        /* @__PURE__ */ jsxs(PopupMenuItem, { onClick: () => {
+          setGroupMenu(null);
+          groupMenu.items.forEach((it) => onActivateById(it.id));
+        }, children: [
+          /* @__PURE__ */ jsx("svg", { className: "h-4 w-4 text-gray-400", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M3.75 3.75h6.5v6.5h-6.5zM13.75 8.75h6.5v6.5h-6.5z" }) }),
+          shellStrings.taskbar.restoreAllWindows
+        ] }),
+        /* @__PURE__ */ jsx(PopupMenuDivider, {}),
+        /* @__PURE__ */ jsxs(PopupMenuItem, { danger: true, onClick: () => {
+          setGroupMenu(null);
+          groupMenu.items.forEach((it) => onRemove(it.id));
+        }, children: [
+          /* @__PURE__ */ jsx("svg", { className: "h-4 w-4", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 2, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M6 18L18 6M6 6l12 12" }) }),
+          `${shellStrings.taskbar.closeAllWindows} (${groupMenu.items.length})`
+        ] })
+      ] }),
+      hoveredItems && hoveredAnchor && /* @__PURE__ */ jsx(
+        TaskbarTabPreview,
+        {
+          items: hoveredItems,
+          anchorEl: hoveredAnchor,
+          onActivate: (id) => {
+            onActivateById(id);
+            setHoveredItems(null);
+            setHoveredAnchor(null);
+          },
+          onClose: (id) => {
+            onRemove(id);
+            setHoveredItems(null);
+            setHoveredAnchor(null);
+          },
+          onMouseEnter: cancelLeave,
+          onMouseLeave: handleLeave
+        }
+      )
+    ] }),
+    target
+  );
+}
+var AUTH_PAGES = ["/login", "/forgot-password", "/reset-password", "/force-change-password"];
+function WindowManagerProvider({ children, windowAccentForRoute }) {
+  const location = useLocation();
+  const isAuthPage = AUTH_PAGES.some((p) => location.pathname.startsWith(p));
+  const [openWindows, setOpenWindows] = useState([]);
+  const openWindowsRef = useRef(openWindows);
+  useLayoutEffect(() => {
+    openWindowsRef.current = openWindows;
+  }, [openWindows]);
+  useEffect(() => {
+    routeByWindowKey.clear();
+    for (const w of openWindows) {
+      if (w.route) routeByWindowKey.set(w.id, w.route);
+    }
+  }, [openWindows]);
+  const forceRemoveWindow = useCallback((id) => {
+    setOpenWindows((prev) => prev.filter((m) => m.id !== id));
+  }, []);
+  const requestClose = useCallback((id) => {
+    if (!findPanelByWindowKey(id)) {
+      forceRemoveWindow(id);
+      return;
+    }
+    requestModalClose(id);
+  }, [forceRemoveWindow]);
+  const activateAfterMount = (windowKey) => {
+    setTimeout(() => {
+      const panel = document.querySelector(`[data-modal-panel][data-window-key="${windowKey}"]`);
+      const mid = panel?.getAttribute("data-modal-id");
+      if (mid) activateModal(mid);
+    }, 50);
+  };
+  const openEntity = useCallback((entityType, entityId, snapshot, label, route) => {
+    if (!WINDOW_REGISTRY[entityType] || !isEntityEntry(WINDOW_REGISTRY[entityType])) return;
+    const id = `${entityType}:${entityId}`;
+    const openedFrom = currentlyActiveWindowKey();
+    setOpenWindows((prev) => {
+      const existing = prev.find((m) => m.entityType === entityType && String(m.entityId) === String(entityId));
+      if (existing) {
+        activateAfterMount(existing.id);
+        return prev;
+      }
+      activateAfterMount(id);
+      return [...prev, {
+        id,
+        type: "modal",
+        label: label || entityId,
+        route: route || window.location.pathname,
+        entityType,
+        entityId,
+        entitySnapshot: normaliseEntitySnapshot(snapshot),
+        openedFrom
+      }];
+    });
+  }, []);
+  const openPage = useCallback((path) => {
+    if (!WINDOW_REGISTRY[path] || !isPageEntry(WINDOW_REGISTRY[path])) return;
+    const entry = WINDOW_REGISTRY[path];
+    if (entry.widget) {
+      const existing = openWindowsRef.current.find((m) => m.type === "page" && m.route === path);
+      if (existing) {
+        requestClose(existing.id);
+        return;
+      }
+    }
+    const openedFrom = currentlyActiveWindowKey();
+    setOpenWindows((prev) => {
+      if (entry.multiInstance) {
+        const id2 = `page:${path}:${Math.random().toString(36).slice(2, 8)}`;
+        activateAfterMount(id2);
+        return [...prev, {
+          id: id2,
+          type: "page",
+          label: entry.label,
+          route: path,
+          openedFrom
+        }];
+      }
+      const existing = prev.find((m) => m.type === "page" && m.route === path);
+      if (existing) {
+        if (entry.widget) return prev;
+        activateAfterMount(existing.id);
+        return prev;
+      }
+      const id = `page:${path}`;
+      activateAfterMount(id);
+      return [...prev, {
+        id,
+        type: "page",
+        label: entry.label,
+        route: path,
+        openedFrom
+      }];
+    });
+  }, [requestClose]);
+  const minimize = useCallback(() => {
+  }, []);
+  const restore = useCallback(() => {
+  }, []);
+  const closeEntity = requestClose;
+  const remove = requestClose;
+  const restoreIfMinimized = () => false;
+  return /* @__PURE__ */ jsxs(MinimizedContext.Provider, { value: { openWindows, openEntity, openPage, closeEntity, minimize, items: [], openItems: openWindows, restore, remove, restoreIfMinimized }, children: [
+    children,
+    /* @__PURE__ */ jsx(
+      TaskbarWindows,
+      {
+        openWindows,
+        onRemove: requestClose,
+        onSplitView: triggerSplitView,
+        onActivate: (label) => {
+          const panels = document.querySelectorAll("[data-modal-panel]");
+          panels.forEach((p) => {
+            const titleEl = p.querySelector("[data-window-title]");
+            if (titleEl?.textContent?.includes(label)) {
+              const mid = p.getAttribute("data-modal-id");
+              if (mid) activateModal(mid);
+            }
+          });
+        },
+        onActivateById: (id) => {
+          const panel = document.querySelector(`[data-modal-panel][data-window-key="${id}"]`);
+          if (!panel) return;
+          if (!isPanelFullyVisible(panel)) {
+            revealWindow(id);
+            return;
+          }
+          const mid = panel.getAttribute("data-modal-id");
+          if (mid) activateModal(mid);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(ExposeBackdrop, {}),
+    !isAuthPage && openWindows.map((item) => {
+      const accentRgb = item.route ? windowAccentForRoute?.(item.route) : void 0;
+      return /* @__PURE__ */ jsx(
+        WindowErrorBoundary,
+        {
+          fallback: (error, reset) => /* @__PURE__ */ jsx(Modal, { open: true, onClose: () => forceRemoveWindow(item.id), title: item.label, size: "md", autoHeight: true, windowKey: item.id, children: /* @__PURE__ */ jsx(WindowCrashedFallback, { error, onReload: reset }) }),
+          children: /* @__PURE__ */ jsx(WindowShortcutProvider, { spec: shortcutSpecFor(item), children: /* @__PURE__ */ jsx(UndoProvider, { windowId: item.id, children: item.type === "page" ? /* @__PURE__ */ jsx(PageWindow, { item, onClose: () => forceRemoveWindow(item.id), accentRgb }) : /* @__PURE__ */ jsx(
+            RestoredRegistryModal,
+            {
+              item,
+              onClose: () => forceRemoveWindow(item.id),
+              onMinimize: () => {
+              },
+              accentRgb
+            }
+          ) }) })
+        },
+        item.id
+      );
+    })
+  ] });
+}
+
+// src/shell/mobileSwipeStore.ts
+var _parentKey = null;
+var subs = /* @__PURE__ */ new Set();
+function getSwipingParentKey() {
+  return _parentKey;
+}
+function setSwipingParentKey(key) {
+  if (_parentKey === key) return;
+  _parentKey = key;
+  for (const cb of subs) cb();
+}
+function subscribeSwipingParentKey(cb) {
+  subs.add(cb);
+  return () => {
+    subs.delete(cb);
+  };
+}
+
+// src/shell/perfEvents.ts
+var empty = () => ({ menus: 0, submenus: 0, menuKey: null, moveMs: 0, resizeMs: 0 });
+var collecting = false;
+var counts = empty();
+var NOOP = () => {
+};
+function setPerfCollecting(on) {
+  collecting = on;
+  counts = empty();
+}
+function markMenuOpen(layer, key) {
+  if (!collecting) return;
+  if (layer === "submenu") counts.submenus++;
+  else counts.menus++;
+  counts.menuKey = key;
+}
+function beginWindowGesture(kind) {
+  if (!collecting) return NOOP;
+  const startedAt = performance.now();
+  let ended = false;
+  return () => {
+    if (ended) return;
+    ended = true;
+    if (!collecting) return;
+    const elapsed = performance.now() - startedAt;
+    if (kind === "move") counts.moveMs += elapsed;
+    else counts.resizeMs += elapsed;
+  };
+}
+function drainPerfEvents() {
+  const drained = counts;
+  counts = empty();
+  return drained;
+}
+
+// src/shell/workArea.ts
+var SIDEBAR_STRIP_W = 280;
+function computeMaximizedBox() {
+  const cs = getComputedStyle(document.documentElement);
+  const taskbarH = parseInt(cs.getPropertyValue("--taskbar-height")) || 0;
+  const taskbarW = parseInt(cs.getPropertyValue("--taskbar-width")) || 0;
+  const tbPos = cs.getPropertyValue("--taskbar-position")?.trim() || "bottom";
+  const sidebarW = parseInt(cs.getPropertyValue("--sidebar-width")) || 0;
+  return {
+    x: (tbPos === "left" ? taskbarW : 0) + sidebarW,
+    y: tbPos === "top" ? taskbarH : 0,
+    w: window.innerWidth - (tbPos === "left" || tbPos === "right" ? taskbarW : 0) - sidebarW,
+    h: window.innerHeight - (tbPos === "top" || tbPos === "bottom" ? taskbarH : 0)
+  };
+}
+function boxFillsWorkArea(box, workArea2, sidebarReserved) {
+  const TOL = 4;
+  const otherW = sidebarReserved ? workArea2.w + SIDEBAR_STRIP_W : workArea2.w - SIDEBAR_STRIP_W;
+  const fillsWidth = Math.abs(box.w - workArea2.w) <= TOL || Math.abs(box.w - otherW) <= TOL;
+  return Math.abs(box.h - workArea2.h) <= TOL && fillsWidth;
+}
+function scrollerIsFluid({ over, residual }, probeGain) {
+  return residual <= 1 || over - residual >= probeGain - 2;
+}
+function widthToFit(curW, probeGain, scrollers) {
+  let need = curW;
+  for (const s of scrollers) {
+    if (scrollerIsFluid(s, probeGain)) need = Math.max(need, curW + s.over);
+  }
+  return Math.ceil(need);
+}
+function growBoxToWidth(box, w, area, margin) {
+  const nextW = Math.min(w, area.w - margin * 2);
+  if (nextW <= box.w + 1) return box;
+  const minX = area.x + margin;
+  const maxX = area.x + area.w - margin - nextW;
+  const x = Math.min(Math.max(box.x - (nextW - box.w) / 2, minX), maxX);
+  return { ...box, x: Math.round(x), w: Math.round(nextW) };
+}
+function isSidebarStripReserved() {
+  return (parseInt(getComputedStyle(document.documentElement).getPropertyValue("--sidebar-width")) || 0) > 0;
+}
+function readAlwaysMaximizedFlag() {
+  if (typeof document === "undefined") return false;
+  return getComputedStyle(document.documentElement).getPropertyValue("--layout-mode")?.trim() === "sidebar";
+}
+var ModalIdContext = createContext("");
+var WindowShortcutContext = createContext(null);
+function WindowShortcutProvider({ spec, children }) {
+  return /* @__PURE__ */ jsx(WindowShortcutContext.Provider, { value: spec, children });
+}
+var TITLE_STRIP_TYPES = /* @__PURE__ */ new Set(["button", "input", "textarea", "select", "kbd", "svg"]);
+var MODAL_SUBMIT_SELECTOR = 'button[type="submit"], button[data-submit], button.btn-submit, button.bg-green-600, button.bg-blue-600';
+function extractTitleText(node) {
+  if (node == null || typeof node === "boolean") return "";
+  if (typeof node === "string") return node;
+  if (typeof node === "number") return String(node);
+  if (Array.isArray(node)) return node.map(extractTitleText).join("");
+  if (isValidElement(node)) {
+    const el = node;
+    const tag = typeof el.type === "string" ? el.type : "";
+    if (TITLE_STRIP_TYPES.has(tag)) return "";
+    return extractTitleText(el.props?.children);
+  }
+  return "";
+}
+function useWidgetSettings(handler) {
+  const id = useContext(ModalIdContext);
+  useEffect(() => {
+    if (!id) return;
+    const listener = (e) => {
+      if (e.detail === id) handler();
+    };
+    window.addEventListener("widget-open-settings", listener);
+    return () => window.removeEventListener("widget-open-settings", listener);
+  }, [handler, id]);
+}
+var _extraMenuItems = {};
+function useWindowMenuItem(label, onClick, icon) {
+  const id = useContext(ModalIdContext);
+  useEffect(() => {
+    if (!id) return;
+    if (!_extraMenuItems[id]) _extraMenuItems[id] = [];
+    const item = { label, icon, onClick };
+    _extraMenuItems[id].push(item);
+    return () => {
+      _extraMenuItems[id] = (_extraMenuItems[id] || []).filter((i) => i !== item);
+    };
+  }, [id, label, onClick, icon]);
+}
+function WindowTitle({ title }) {
+  const ref = useRef(null);
+  useEffect(() => {
+    const handle = setTimeout(() => {
+      const panel = ref.current?.closest("[data-modal-id]");
+      const id = panel?.getAttribute("data-modal-id");
+      if (id) window.dispatchEvent(new CustomEvent("window-title-update", { detail: { id, title } }));
+    }, 0);
+    return () => clearTimeout(handle);
+  }, [title]);
+  return /* @__PURE__ */ jsx("span", { ref, style: { display: "none" }, "aria-hidden": "true" });
+}
+function useWindowTitle(_title) {
+}
+function CopyButton({ text }) {
+  const [copied, setCopied] = useState(false);
+  const handleCopy = (e) => {
+    e.stopPropagation();
+    navigator.clipboard.writeText(text).then(() => {
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1500);
+    });
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      onClick: handleCopy,
+      title: copied ? "Copied!" : `Copy ${text}`,
+      className: "shrink-0 text-gray-400 hover:text-gray-600 transition-colors",
+      children: copied ? /* @__PURE__ */ jsx("svg", { className: "w-4 h-4 text-green-600", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M5 13l4 4L19 7" }) }) : /* @__PURE__ */ jsx("svg", { className: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z" }) })
+    }
+  );
+}
+var ModalActionsContext = createContext(null);
+function useModalFooterOpen() {
+  return useContext(ModalActionsContext)?.footerOpen ?? false;
+}
+function useEnclosingModalId() {
+  return useContext(ModalIdContext);
+}
+function useModalActive() {
+  const activeId = useSyncExternalStore(subscribeActive, getActiveModalId);
+  const ctx = useContext(ModalActionsContext);
+  return ctx?.active ?? (activationOrder.length <= 1 || activeId != null);
+}
+function ModalActions({ children, position = "right", quiet = false }) {
+  const ctx = useContext(ModalActionsContext);
+  const [target, setTarget] = useState(null);
+  useEffect(() => {
+    if (!ctx) return;
+    const ref = position === "left" ? ctx.leftRef : ctx.rightRef;
+    const check = () => {
+      if (ref.current) {
+        setTarget(ref.current);
+        if (!quiet) ctx.notify();
+        return true;
+      }
+      return false;
+    };
+    if (check()) return;
+    const t = setInterval(() => {
+      if (check()) clearInterval(t);
+    }, 50);
+    const cleanup = setTimeout(() => clearInterval(t), 2e3);
+    return () => {
+      clearInterval(t);
+      clearTimeout(cleanup);
+    };
+  }, [ctx, position, quiet]);
+  if (!target) return null;
+  return createPortal(children, target);
+}
+function CancelButton({ onClick, children, className }) {
+  const ctx = useContext(ModalActionsContext);
+  const handleClick = async () => {
+    if (ctx?.isDirty) {
+      const { confirm: confirm2 } = await import('./ConfirmDialog-LJXMB45A.js');
+      const ok = await confirm2({
+        title: "Discard changes?",
+        message: "You have unsaved changes. Are you sure you want to cancel? All changes will be lost.",
+        confirmLabel: "Discard",
+        cancelLabel: "Keep Editing",
+        variant: "warning"
+      });
+      if (!ok) return;
+    }
+    onClick();
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: handleClick,
+      className: className || "bg-white text-gray-700 border border-gray-300 px-4 py-2 text-sm font-medium rounded-lg hover:bg-gray-50",
+      children: children || "Cancel"
+    }
+  );
+}
+var WP_KEY = "erp_window_positions";
+var _windowPositions = {};
+try {
+  const stored = localStorage.getItem(WP_KEY);
+  if (stored) _windowPositions = JSON.parse(stored);
+} catch {
+}
+var _saveTimer = null;
+function _savePositionsDebounced() {
+  if (_saveTimer) clearTimeout(_saveTimer);
+  _saveTimer = setTimeout(() => {
+    try {
+      localStorage.setItem(WP_KEY, JSON.stringify(_windowPositions));
+    } catch {
+    }
+  }, 500);
+}
+var AO_KEY = "erp_activation_order";
+var _activationOrderKeys = [];
+try {
+  const stored = localStorage.getItem(AO_KEY);
+  const parsed = stored ? JSON.parse(stored) : null;
+  if (Array.isArray(parsed) && parsed.every((k) => typeof k === "string")) _activationOrderKeys = parsed;
+} catch {
+}
+var _saveOrderTimer = null;
+function _saveOrderDebounced() {
+  if (_saveOrderTimer) clearTimeout(_saveOrderTimer);
+  _saveOrderTimer = setTimeout(() => {
+    try {
+      localStorage.setItem(AO_KEY, JSON.stringify(_activationOrderKeys));
+    } catch {
+    }
+  }, 500);
+}
+function setWindowDefaultPosition(key, pos) {
+  if (_windowPositions[key]) return;
+  _windowPositions[key] = pos;
+  _savePositionsDebounced();
+}
+function getWindowPosition(key) {
+  return _windowPositions[key] ? { ..._windowPositions[key] } : null;
+}
+function setWindowPosition(key, pos) {
+  _windowPositions[key] = pos;
+  _savePositionsDebounced();
+}
+function forgetMaximizedWindowBoxes() {
+  const workArea2 = computeMaximizedBox();
+  const sidebarReserved = isSidebarStripReserved();
+  let changed = false;
+  for (const key of Object.keys(_windowPositions)) {
+    if (boxFillsWorkArea(_windowPositions[key], workArea2, sidebarReserved)) {
+      delete _windowPositions[key];
+      changed = true;
+    }
+  }
+  if (changed) _savePositionsDebounced();
+}
+var sizeDefaults = {
+  sm: 384,
+  md: 512,
+  lg: 672,
+  xl: 896,
+  "2xl": 1152,
+  "3xl": 1408
+};
+var AUTO_WIDTH_WATCH_MS = 4e3;
+var readDefaultWindowSize = () => {
+  if (typeof document === "undefined") return "large";
+  const v = getComputedStyle(document.documentElement).getPropertyValue("--default-window-size")?.trim();
+  return v === "small" || v === "medium" || v === "maximized" ? v : "large";
+};
+var windowHeightScale = {
+  small: 0.8,
+  medium: 1,
+  large: 1.25,
+  maximized: 1.25
+};
+var activationOrder = [];
+var activeListeners = /* @__PURE__ */ new Set();
+var _minimizedIds = /* @__PURE__ */ new Set();
+var _activeVersion = 0;
+function getActiveVersion() {
+  return _activeVersion;
+}
+function notifyActive() {
+  _activeVersion++;
+  activeListeners.forEach((fn) => fn());
+}
+var _modalIdByKey = /* @__PURE__ */ new Map();
+var _keyByModalId = /* @__PURE__ */ new Map();
+function _insertModalIdForKey(modalId, key) {
+  const savedIdx = _activationOrderKeys.indexOf(key);
+  if (savedIdx === -1) {
+    activationOrder.push(modalId);
+    return;
+  }
+  let insertAt = activationOrder.length;
+  for (let i = 0; i < activationOrder.length; i++) {
+    const otherKey = _keyByModalId.get(activationOrder[i]);
+    if (!otherKey) continue;
+    const otherIdx = _activationOrderKeys.indexOf(otherKey);
+    if (otherIdx > savedIdx) {
+      insertAt = i;
+      break;
+    }
+  }
+  activationOrder.splice(insertAt, 0, modalId);
+}
+var _frontRequest = null;
+function _honourFrontRequest(modalId) {
+  _frontRequest = null;
+  activateModal(modalId);
+}
+function requestWindowFront(windowKey) {
+  _frontRequest = windowKey;
+  const modalId = _modalIdByKey.get(windowKey);
+  if (modalId) _honourFrontRequest(modalId);
+}
+function cancelWindowFront(windowKey) {
+  if (_frontRequest === windowKey) _frontRequest = null;
+}
+function mountModal(modalId, key) {
+  if (!key) {
+    activationOrder.push(modalId);
+  } else {
+    _modalIdByKey.set(key, modalId);
+    _keyByModalId.set(modalId, key);
+    _insertModalIdForKey(modalId, key);
+    if (_activationOrderKeys.indexOf(key) === -1) {
+      _activationOrderKeys.push(key);
+      _saveOrderDebounced();
+    }
+  }
+  notifyActive();
+  window.dispatchEvent(new CustomEvent("modal-reorder"));
+  if (key && _frontRequest === key) _honourFrontRequest(modalId);
+}
+function unmountModal(modalId) {
+  const idx = activationOrder.indexOf(modalId);
+  if (idx !== -1) {
+    activationOrder.splice(idx, 1);
+    notifyActive();
+  }
+  _minimizedIds.delete(modalId);
+  const key = _keyByModalId.get(modalId);
+  if (key) {
+    _keyByModalId.delete(modalId);
+    _modalIdByKey.delete(key);
+  }
+}
+function activateModal(id) {
+  const idx = activationOrder.indexOf(id);
+  if (idx !== -1) activationOrder.splice(idx, 1);
+  activationOrder.push(id);
+  _minimizedIds.delete(id);
+  const key = _keyByModalId.get(id);
+  if (key) {
+    const kidx = _activationOrderKeys.indexOf(key);
+    if (kidx !== -1) _activationOrderKeys.splice(kidx, 1);
+    _activationOrderKeys.push(key);
+    _saveOrderDebounced();
+    if (_frontRequest && _frontRequest !== key) _frontRequest = null;
+  }
+  notifyActive();
+  window.dispatchEvent(new CustomEvent("modal-reorder"));
+}
+function _minimizeModal(modalId) {
+  const idx = activationOrder.indexOf(modalId);
+  if (idx !== -1) activationOrder.splice(idx, 1);
+  _minimizedIds.add(modalId);
+  const key = _keyByModalId.get(modalId);
+  if (key) {
+    const kidx = _activationOrderKeys.indexOf(key);
+    if (kidx !== -1) {
+      _activationOrderKeys.splice(kidx, 1);
+      _saveOrderDebounced();
+    }
+  }
+  notifyActive();
+  window.dispatchEvent(new CustomEvent("modal-reorder"));
+}
+var widgetIds = /* @__PURE__ */ new Set();
+function deactivateAllModals() {
+  for (let i = activationOrder.length - 1; i >= 0; i--) {
+    if (!widgetIds.has(activationOrder[i])) activationOrder.splice(i, 1);
+  }
+  _activationOrderKeys = _activationOrderKeys.filter((k) => {
+    const mid = _modalIdByKey.get(k);
+    return mid != null && widgetIds.has(mid);
+  });
+  _saveOrderDebounced();
+  notifyActive();
+  window.dispatchEvent(new CustomEvent("modal-reorder"));
+}
+var EDGE_THRESHOLD = 8;
+var CORNER_THRESHOLD = 32;
+function workArea() {
+  const taskbarH = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-height")) || 0;
+  const taskbarW = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-width")) || 0;
+  const tbPos = getComputedStyle(document.documentElement).getPropertyValue("--taskbar-position")?.trim() || "bottom";
+  const x = tbPos === "left" ? taskbarW : 0;
+  const y = tbPos === "top" ? taskbarH : 0;
+  const w = window.innerWidth - (tbPos === "left" || tbPos === "right" ? taskbarW : 0);
+  const h = window.innerHeight - (tbPos === "top" || tbPos === "bottom" ? taskbarH : 0);
+  return { x, y, w, h };
+}
+var CAPTION_H = 40;
+var MIN_VISIBLE_X = 80;
+var MIN_W = 384;
+var MIN_H = 400;
+function clampReachable(box, a = workArea()) {
+  const x = Math.min(Math.max(box.x, a.x + MIN_VISIBLE_X - box.w), a.x + a.w - MIN_VISIBLE_X);
+  const y = Math.min(Math.max(box.y, a.y), a.y + a.h - CAPTION_H);
+  return x === box.x && y === box.y ? box : { ...box, x, y };
+}
+function clampFullyVisible(box, a = workArea()) {
+  const w = Math.min(box.w, a.w);
+  const h = Math.min(box.h, a.h);
+  return {
+    w,
+    h,
+    x: Math.min(Math.max(box.x, a.x), a.x + a.w - w),
+    y: Math.min(Math.max(box.y, a.y), a.y + a.h - h)
+  };
+}
+function isPanelFullyVisible(panel) {
+  const r = panel.getBoundingClientRect();
+  if (r.width === 0 || r.height === 0) return true;
+  const a = workArea();
+  const EPS = 1;
+  return r.left >= a.x - EPS && r.top >= a.y - EPS && r.right <= a.x + a.w + EPS && r.bottom <= a.y + a.h + EPS;
+}
+function panelOffscreenBearing(panel) {
+  if (isPanelFullyVisible(panel)) return null;
+  const r = panel.getBoundingClientRect();
+  const a = workArea();
+  const dx = r.left + r.width / 2 - (a.x + a.w / 2);
+  const dy = r.top + r.height / 2 - (a.y + a.h / 2);
+  return Math.atan2(dy, dx) * 180 / Math.PI;
+}
+function revealWindow(windowKey) {
+  window.dispatchEvent(new CustomEvent("modal-reveal", { detail: { windowKey } }));
+}
+function calcSnapBox(zone) {
+  const a = workArea();
+  const halfW = Math.floor(a.w / 2);
+  const halfH = Math.floor(a.h / 2);
+  switch (zone) {
+    case "top":
+      return { x: a.x, y: a.y, w: a.w, h: a.h };
+    case "left":
+      return { x: a.x, y: a.y, w: halfW, h: a.h };
+    case "right":
+      return { x: a.x + halfW, y: a.y, w: a.w - halfW, h: a.h };
+    case "tl":
+      return { x: a.x, y: a.y, w: halfW, h: halfH };
+    case "tr":
+      return { x: a.x + halfW, y: a.y, w: a.w - halfW, h: halfH };
+    case "bl":
+      return { x: a.x, y: a.y + halfH, w: halfW, h: a.h - halfH };
+    case "br":
+      return { x: a.x + halfW, y: a.y + halfH, w: a.w - halfW, h: a.h - halfH };
+  }
+}
+function detectSnapZone(clientX, clientY) {
+  const a = workArea();
+  const nearLeft = clientX <= a.x + EDGE_THRESHOLD;
+  const nearRight = clientX >= a.x + a.w - EDGE_THRESHOLD;
+  const nearTop = clientY <= a.y + EDGE_THRESHOLD;
+  const nearBottom = clientY >= a.y + a.h - EDGE_THRESHOLD;
+  const cornerLeft = clientX <= a.x + CORNER_THRESHOLD;
+  const cornerRight = clientX >= a.x + a.w - CORNER_THRESHOLD;
+  const cornerTop = clientY <= a.y + CORNER_THRESHOLD;
+  const cornerBottom = clientY >= a.y + a.h - CORNER_THRESHOLD;
+  if (nearTop && cornerLeft) return "tl";
+  if (nearTop && cornerRight) return "tr";
+  if (nearBottom && cornerLeft) return "bl";
+  if (nearBottom && cornerRight) return "br";
+  if (cornerTop && nearLeft) return "tl";
+  if (cornerTop && nearRight) return "tr";
+  if (cornerBottom && nearLeft) return "bl";
+  if (cornerBottom && nearRight) return "br";
+  if (nearTop) return "top";
+  if (nearLeft) return "left";
+  if (nearRight) return "right";
+  return null;
+}
+var snapPreviewEl = null;
+function getSnapPreviewEl() {
+  if (!snapPreviewEl) {
+    snapPreviewEl = document.createElement("div");
+    snapPreviewEl.style.cssText = [
+      "position: fixed",
+      "pointer-events: none",
+      "z-index: 40",
+      "border-radius: 8px",
+      "background: rgba(59, 130, 246, 0.18)",
+      "border: 2px solid rgb(59, 130, 246)",
+      "transition: left 120ms ease, top 120ms ease, width 120ms ease, height 120ms ease, opacity 120ms ease",
+      "opacity: 0",
+      "display: none"
+    ].join(";");
+    document.body.appendChild(snapPreviewEl);
+  }
+  return snapPreviewEl;
+}
+function showSnapPreview(box) {
+  const el = getSnapPreviewEl();
+  el.style.display = "block";
+  el.style.left = `${box.x}px`;
+  el.style.top = `${box.y}px`;
+  el.style.width = `${box.w}px`;
+  el.style.height = `${box.h}px`;
+  el.style.opacity = "1";
+}
+function hideSnapPreview() {
+  if (!snapPreviewEl) return;
+  snapPreviewEl.style.opacity = "0";
+  snapPreviewEl.style.display = "none";
+}
+var SNAP_PICKER_ZONES = [
+  { zone: "left", labelKey: "snapLeft", region: "inset-y-0 left-0 w-1/2" },
+  { zone: "right", labelKey: "snapRight", region: "inset-y-0 right-0 w-1/2" },
+  { zone: "tl", labelKey: "snapTopLeft", region: "top-0 left-0 h-1/2 w-1/2" },
+  { zone: "tr", labelKey: "snapTopRight", region: "top-0 right-0 h-1/2 w-1/2" },
+  { zone: "bl", labelKey: "snapBottomLeft", region: "bottom-0 left-0 h-1/2 w-1/2" },
+  { zone: "br", labelKey: "snapBottomRight", region: "bottom-0 right-0 h-1/2 w-1/2" }
+];
+var SNAP_PICKER_OPEN_MS = 350;
+var SNAP_PICKER_CLOSE_MS = 200;
+function SnapLayoutsButton({ maximized, onToggleMax, onSnap, buttonClassName, strings }) {
+  const [open, setOpen] = useState(false);
+  const openTimer = useRef(void 0);
+  const closeTimer = useRef(void 0);
+  useEffect(() => () => {
+    clearTimeout(openTimer.current);
+    clearTimeout(closeTimer.current);
+  }, []);
+  const armOpen = () => {
+    clearTimeout(closeTimer.current);
+    openTimer.current = setTimeout(() => setOpen(true), SNAP_PICKER_OPEN_MS);
+  };
+  const armClose = () => {
+    clearTimeout(openTimer.current);
+    closeTimer.current = setTimeout(() => setOpen(false), SNAP_PICKER_CLOSE_MS);
+  };
+  return /* @__PURE__ */ jsxs("span", { className: "relative inline-flex", onMouseEnter: armOpen, onMouseLeave: armClose, children: [
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        onClick: onToggleMax,
+        onFocus: armOpen,
+        onBlur: armClose,
+        title: maximized ? strings.windowed : strings.maximize,
+        className: buttonClassName,
+        children: maximized ? "\u2750" : "\u2922"
+      }
+    ),
+    open && /* @__PURE__ */ jsx(
+      "div",
+      {
+        role: "group",
+        "aria-label": strings.snapLayouts,
+        onMouseEnter: () => clearTimeout(closeTimer.current),
+        onMouseLeave: armClose,
+        className: "absolute right-0 top-full z-30 mt-1 grid w-max grid-cols-2 gap-1 rounded-lg border border-gray-200 bg-white p-1.5 shadow-lg",
+        children: SNAP_PICKER_ZONES.map(({ zone, labelKey, region }) => /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": strings[labelKey],
+            title: strings[labelKey],
+            onClick: () => {
+              setOpen(false);
+              onSnap(zone);
+            },
+            onFocus: () => clearTimeout(closeTimer.current),
+            onBlur: armClose,
+            className: "relative h-7 w-11 rounded border border-gray-300 bg-gray-50 hover:border-blue-400 focus:outline-none focus-visible:ring-2 focus-visible:ring-blue-400",
+            children: /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: `absolute rounded-sm bg-blue-500/70 ${region}`, style: { margin: 2 } })
+          },
+          zone
+        ))
+      }
+    )
+  ] });
+}
+var GESTURE_STYLE_ID = "rosh-gesture-style";
+function ensureGestureStyle() {
+  if (typeof document === "undefined" || document.getElementById(GESTURE_STYLE_ID)) return;
+  const style = document.createElement("style");
+  style.id = GESTURE_STYLE_ID;
+  style.textContent = // Promote every window to its own compositor layer for the gesture so
+  // dragging the foreground window doesn't repaint the ones behind it. We do
+  // NOT drop backdrop-blur — every window keeps its frosted glass while a
+  // drag/resize is in progress (only the grabbed window re-samples, cheaply).
+  "body.rosh-gesturing [data-modal-panel]{will-change:transform}";
+  document.head.appendChild(style);
+}
+var RESIZE_CURSOR = {
+  se: "nwse-resize",
+  nw: "nwse-resize",
+  sw: "nesw-resize",
+  ne: "nesw-resize",
+  n: "ns-resize",
+  s: "ns-resize",
+  e: "ew-resize",
+  w: "ew-resize"
+};
+var DRAG_THRESHOLD = 4;
+function beginPointerGesture(handle, pointerId, cursor, kind) {
+  ensureGestureStyle();
+  try {
+    handle.setPointerCapture(pointerId);
+  } catch {
+  }
+  document.body.classList.add("rosh-gesturing");
+  const shield = document.createElement("div");
+  shield.setAttribute("data-drag-shield", "");
+  shield.style.cssText = `position:fixed;inset:0;z-index:2147483647;cursor:${cursor};background:transparent;touch-action:none`;
+  document.body.appendChild(shield);
+  const endMark = beginWindowGesture(kind);
+  let done = false;
+  return () => {
+    if (done) return;
+    done = true;
+    endMark();
+    try {
+      handle.releasePointerCapture(pointerId);
+    } catch {
+    }
+    shield.remove();
+    document.body.classList.remove("rosh-gesturing");
+  };
+}
+if (typeof window !== "undefined") window.addEventListener("deactivate-all-modals", deactivateAllModals);
+function getZForModal(id) {
+  const idx = activationOrder.indexOf(id);
+  if (idx === -1) return -1;
+  return Z_LAYERS.window + idx * Z_LAYERS.windowStep;
+}
+function getActiveModalId() {
+  return activationOrder[activationOrder.length - 1] || null;
+}
+function subscribeActive(cb) {
+  activeListeners.add(cb);
+  return () => {
+    activeListeners.delete(cb);
+  };
+}
+var MODAL_CLOSE_REQUEST_EVENT = "modal-close-request";
+function requestModalClose(windowKey) {
+  window.dispatchEvent(new CustomEvent(MODAL_CLOSE_REQUEST_EVENT, {
+    detail: { windowKey }
+  }));
+}
+function minimizeWindowByKey(windowKey) {
+  const modalId = _modalIdByKey.get(windowKey);
+  if (modalId) _minimizeModal(modalId);
+}
+function useIsActiveModal(modalId) {
+  const activeId = useSyncExternalStore(subscribeActive, getActiveModalId);
+  return activationOrder.length <= 1 || activeId === modalId;
+}
+function useIsMinimizedModal(modalId) {
+  return useSyncExternalStore(subscribeActive, () => _minimizedIds.has(modalId));
+}
+function useIsActiveWindow(windowKey) {
+  useSyncExternalStore(subscribeActive, getActiveVersion);
+  const ctx = useContext(ModalActionsContext);
+  if (activationOrder.length <= 1) return true;
+  if (windowKey) {
+    const modalId = _modalIdByKey.get(windowKey);
+    if (modalId != null) return getActiveModalId() === modalId;
+  }
+  return ctx?.active ?? getActiveModalId() != null;
+}
+var _exposeOn = false;
+var _exposeListeners = /* @__PURE__ */ new Set();
+function _notifyExpose() {
+  _exposeListeners.forEach((fn) => fn());
+}
+function subscribeExpose(fn) {
+  _exposeListeners.add(fn);
+  return () => _exposeListeners.delete(fn);
+}
+function getExposeState() {
+  return _exposeOn;
+}
+function setExposeState(v) {
+  if (_exposeOn === v) return;
+  _exposeOn = v;
+  _notifyExpose();
+}
+function toggleExposeMode() {
+  setExposeState(!_exposeOn);
+}
+function exitExposeMode() {
+  setExposeState(false);
+}
+var _exposeExitFocusId = null;
+var _exposeExitListeners = /* @__PURE__ */ new Set();
+function subscribeExposeExitFocus(fn) {
+  _exposeExitListeners.add(fn);
+  return () => _exposeExitListeners.delete(fn);
+}
+function getExposeExitFocus() {
+  return _exposeExitFocusId;
+}
+function setExposeExitFocus(id) {
+  if (_exposeExitFocusId === id) return;
+  _exposeExitFocusId = id;
+  _exposeExitListeners.forEach((fn) => fn());
+}
+var _exposeHighlightId = null;
+var _exposeHighlightListeners = /* @__PURE__ */ new Set();
+function subscribeExposeHighlight(fn) {
+  _exposeHighlightListeners.add(fn);
+  return () => _exposeHighlightListeners.delete(fn);
+}
+function getExposeHighlight() {
+  return _exposeHighlightId;
+}
+function setExposeHighlight(id) {
+  if (_exposeHighlightId === id) return;
+  _exposeHighlightId = id;
+  _exposeHighlightListeners.forEach((fn) => fn());
+}
+function commitExposeHighlight() {
+  if (!_exposeHighlightId) {
+    setExposeState(false);
+    return;
+  }
+  const id = _exposeHighlightId;
+  setExposeExitFocus(id);
+  setExposeHighlight(null);
+  setExposeState(false);
+}
+function triggerSplitView() {
+  setExposeState(!_exposeOn);
+  window.dispatchEvent(new CustomEvent("modal-split-view"));
+}
+if (typeof window !== "undefined") {
+  window.addEventListener("keydown", (e) => {
+    if (_exposeOn && e.key === "Escape") {
+      setExposeHighlight(null);
+      setExposeState(false);
+    }
+  });
+}
+function computeExposeTile(modalId) {
+  if (typeof document === "undefined") return null;
+  const allPanels = Array.from(document.querySelectorAll("[data-modal-panel]"));
+  const tileable = allPanels.filter((p) => {
+    const el = p;
+    if (el.hasAttribute("data-utility") || el.hasAttribute("data-widget")) return false;
+    if (el.style.display === "none") return false;
+    return true;
+  });
+  tileable.sort((a2, b) => (a2.getAttribute("data-modal-id") || "").localeCompare(b.getAttribute("data-modal-id") || ""));
+  const myIdx = tileable.findIndex((p) => p.getAttribute("data-modal-id") === modalId);
+  const count = tileable.length;
+  if (myIdx < 0 || count < 1) return null;
+  const cols = Math.ceil(Math.sqrt(count));
+  const rows = Math.ceil(count / cols);
+  const myRow = Math.floor(myIdx / cols);
+  const myCol = myIdx % cols;
+  const lastRowCount = count - cols * (rows - 1);
+  const isLastRow = myRow === rows - 1 && lastRowCount < cols;
+  const taskbarH = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-height")) || 0;
+  const taskbarW = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-width")) || 0;
+  const tbPos = (getComputedStyle(document.documentElement).getPropertyValue("--taskbar-position") || "bottom").trim();
+  const xOffset = tbPos === "left" ? taskbarW : 0;
+  const xRight = tbPos === "right" ? taskbarW : 0;
+  const yOffset = tbPos === "top" ? taskbarH : 0;
+  const yBottom = tbPos === "top" || tbPos === "left" || tbPos === "right" ? 0 : taskbarH;
+  const a = {
+    x: xOffset,
+    y: yOffset,
+    w: window.innerWidth - xOffset - xRight,
+    h: window.innerHeight - yOffset - yBottom
+  };
+  const gapX = 20;
+  const gapY = 14;
+  const labelH = 22;
+  const cellW = (a.w - gapX * (cols + 1)) / cols;
+  const cellH = (a.h - gapY * (rows + 1) - labelH * rows) / rows;
+  const lastRowOffsetX = isLastRow ? (cols - lastRowCount) * (cellW + gapX) / 2 : 0;
+  const tileX = a.x + gapX + myCol * (cellW + gapX) + lastRowOffsetX;
+  const tileY = a.y + gapY + myRow * (cellH + gapY + labelH);
+  return { x: tileX, y: tileY, w: cellW, h: cellH };
+}
+function ExposeBackdrop() {
+  const on = useSyncExternalStore(subscribeExpose, getExposeState);
+  const [mounted, setMounted] = useState(on);
+  const [visible, setVisible] = useState(on);
+  useEffect(() => {
+    if (on) {
+      setMounted(true);
+      const id = requestAnimationFrame(() => setVisible(true));
+      return () => cancelAnimationFrame(id);
+    }
+    setVisible(false);
+    const t = setTimeout(() => setMounted(false), 280);
+    return () => clearTimeout(t);
+  }, [on]);
+  if (!mounted || typeof document === "undefined") return null;
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        onMouseDown: (e) => {
+          e.stopPropagation();
+          setExposeState(false);
+        },
+        style: {
+          position: "fixed",
+          inset: 0,
+          background: "rgba(0,0,0,0.55)",
+          backdropFilter: "blur(2px)",
+          WebkitBackdropFilter: "blur(2px)",
+          zIndex: 2e3,
+          cursor: "pointer",
+          opacity: visible ? 1 : 0,
+          transition: "opacity 260ms cubic-bezier(0.2, 0.8, 0.2, 1)",
+          pointerEvents: visible ? "auto" : "none"
+        }
+      }
+    ),
+    document.body
+  );
+}
+function Modal({ open, onClose, title, icon, copyText, size = "lg", dirty = false, onNext, onPrev, footer, bodyScroll, onMinimize, initialBox, actions, actionsLeft, editing = false, allowPinOnTop, initialPosition, widget, compact, appStyle, flushBody, autoHeight, autoMinHeight, autoWidth, widgetMenu, dimensions, windowKey, openedFromKey, accentRgb, children }) {
+  const isMobile = useIsMobile();
+  const [swipeX, setSwipeX] = useState(0);
+  const [swipeDragging, setSwipeDragging] = useState(false);
+  const swipeStartRef = useRef(null);
+  const swipeXRef = useRef(0);
+  useEffect(() => {
+    swipeXRef.current = swipeX;
+  }, [swipeX]);
+  const handleEdgePointerDown = useCallback((e) => {
+    if (!isMobile) return;
+    swipeStartRef.current = { startX: e.clientX, startY: e.clientY, pointerId: e.pointerId };
+    setSwipeDragging(true);
+    setSwipingParentKey(openedFromKey ?? null);
+  }, [isMobile, openedFromKey]);
+  const swipingParentKey = useSyncExternalStore(subscribeSwipingParentKey, getSwipingParentKey);
+  useEffect(() => {
+    if (!swipeDragging) return;
+    const onMove = (ev) => {
+      if (!swipeStartRef.current) return;
+      const dx = ev.clientX - swipeStartRef.current.startX;
+      const dy = Math.abs(ev.clientY - swipeStartRef.current.startY);
+      if (dy > Math.abs(dx) + 12) {
+        swipeStartRef.current = null;
+        setSwipeDragging(false);
+        setSwipeX(0);
+        setSwipingParentKey(null);
+        return;
+      }
+      setSwipeX(Math.max(0, dx));
+    };
+    const onUp = () => {
+      if (!swipeStartRef.current) return;
+      const threshold = window.innerWidth * 0.3;
+      const past = swipeXRef.current > threshold;
+      swipeStartRef.current = null;
+      setSwipeDragging(false);
+      if (past) {
+        setSwipeX(window.innerWidth);
+        setTimeout(() => {
+          onClose();
+          setSwipeX(0);
+          setSwipingParentKey(null);
+        }, 180);
+      } else {
+        setSwipeX(0);
+        setSwipingParentKey(null);
+      }
+    };
+    window.addEventListener("pointermove", onMove);
+    window.addEventListener("pointerup", onUp);
+    window.addEventListener("pointercancel", onUp);
+    return () => {
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
+      window.removeEventListener("pointercancel", onUp);
+    };
+  }, [swipeDragging]);
+  const [displayTitle, setDisplayTitle] = useState(title);
+  const shellStrings = useShellStrings();
+  const winStr = shellStrings.window;
+  useEffect(() => {
+    setDisplayTitle(title);
+  }, [title]);
+  const titleTooltip = useMemo(() => extractTitleText(displayTitle).trim() || void 0, [displayTitle]);
+  const [touched, setTouched] = useState(false);
+  const touchedRef = useRef(false);
+  const [pinnedOnTop, setPinnedOnTop] = useState(false);
+  const [windowMenu, setWindowMenu] = useState(null);
+  const shortcutSpec = useContext(WindowShortcutContext);
+  const { prefs: shellPrefs, save: saveShellPrefs } = useShellPrefs();
+  const accentStripeOn = !!shellPrefs.window_accent_stripe;
+  const favDocs = shellPrefs.favorite_documents || [];
+  const isOnDesktop = !!shortcutSpec && favDocs.some((d) => d.entityType === shortcutSpec.entityType && d.entityId === shortcutSpec.entityId);
+  const toggleDesktopShortcut = useCallback(() => {
+    if (!shortcutSpec) return;
+    const next = isOnDesktop ? favDocs.filter((d) => !(d.entityType === shortcutSpec.entityType && d.entityId === shortcutSpec.entityId)) : [...favDocs, { entityType: shortcutSpec.entityType, entityId: shortcutSpec.entityId, label: shortcutSpec.label }];
+    saveShellPrefs({ favorite_documents: next });
+  }, [shortcutSpec, isOnDesktop, favDocs, saveShellPrefs]);
+  const [ctxMenu, setCtxMenu] = useState(null);
+  const [widgetAnchor, setWidgetAnchor] = useState(initialPosition === "top-right" ? "right" : "left");
+  const closingRef = useRef(false);
+  const panelRef = useRef(null);
+  useLayoutEffect(() => {
+    const el = panelRef.current;
+    if (!el) return;
+    if (accentRgb) el.style.setProperty("--window-accent-rgb", accentRgb);
+    else el.style.removeProperty("--window-accent-rgb");
+  }, [accentRgb]);
+  const swallowInactiveClickRef = useRef(false);
+  const bodyRef = useRef(null);
+  const actionsRef = useRef(null);
+  const actionsLeftRef = useRef(null);
+  const [hasActions, setHasActions] = useState(false);
+  const footerRef = useRef(null);
+  const hasFooterContent = !!(footer || actions || actionsLeft) || hasActions;
+  const undoCtx = useContext(UndoContext);
+  const nestedInWindow = useContext(ModalIdContext) !== "";
+  const showsUndo = !!undoCtx && !nestedInWindow && undoCtx.enabled && undoCtx.hasState && (editing || undoCtx.declaredEditable) && !undoCtx.handMounted && hasFooterContent && !widget && !compact && !appStyle && !isMobile;
+  const fallbackIcon = /* @__PURE__ */ jsx("svg", { className: "h-4 w-4 text-gray-400", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M3.75 6.75A2.25 2.25 0 016 4.5h12a2.25 2.25 0 012.25 2.25v10.5A2.25 2.25 0 0118 19.5H6a2.25 2.25 0 01-2.25-2.25V6.75z M3.75 9h16.5" }) });
+  const effectiveIcon = icon && isValidElement(icon) ? cloneElement(icon, {
+    className: `h-4 w-4 ${icon.props?.className ?? ""}`.trim()
+  }) : icon ?? fallbackIcon;
+  const renderIconButton = () => /* @__PURE__ */ jsx(
+    "button",
+    {
+      onPointerDown: (e) => e.stopPropagation(),
+      onClick: (e) => {
+        e.stopPropagation();
+        const rect = e.currentTarget.getBoundingClientRect();
+        setWindowMenu((prev) => prev ? null : { x: rect.left, y: rect.bottom + 4 });
+      },
+      className: "shrink-0 p-0.5 rounded hover:bg-gray-200/50 transition-colors",
+      title: "Window menu",
+      children: effectiveIcon
+    }
+  );
+  const padding = 40;
+  const { minimize: globalMinimize, items: minimizedItems, restoreIfMinimized, openWindows } = useWindowManager();
+  const modalId = useRef(`modal-${Math.random().toString(36).slice(2, 8)}`).current;
+  useEffect(() => {
+    if (widget) {
+      widgetIds.add(modalId);
+      return () => {
+        widgetIds.delete(modalId);
+      };
+    }
+  }, [widget, modalId]);
+  useEffect(() => {
+    const handler = (e) => {
+      const detail = e.detail;
+      if (detail?.id === modalId) setDisplayTitle(detail.title);
+    };
+    window.addEventListener("window-title-update", handler);
+    return () => window.removeEventListener("window-title-update", handler);
+  }, [modalId]);
+  const [zIndex, setZIndex] = useState(Z_LAYERS.window);
+  const isActive = useIsActiveModal(modalId);
+  const isMinimized = useIsMinimizedModal(modalId);
+  const exposeOn = useSyncExternalStore(subscribeExpose, getExposeState);
+  const exposeExitFocusId = useSyncExternalStore(subscribeExposeExitFocus, getExposeExitFocus);
+  const exposeHighlightId = useSyncExternalStore(subscribeExposeHighlight, getExposeHighlight);
+  const isExposeTileable = !allowPinOnTop && !widget;
+  const exposeActive = exposeOn && isExposeTileable;
+  const [exposeHovered, setExposeHovered] = useState(false);
+  const exposeKeyboardHighlight = exposeActive && exposeHighlightId === modalId;
+  const [exposeExiting, setExposeExiting] = useState(false);
+  const exposeExitRole = exposeExiting && isExposeTileable && exposeExitFocusId === modalId ? "picked" : null;
+  const prevExposeActiveRef = useRef(exposeActive);
+  useEffect(() => {
+    if (prevExposeActiveRef.current && !exposeActive) {
+      setExposeExiting(true);
+      const t = setTimeout(() => {
+        setExposeExiting(false);
+        if (_exposeExitFocusId === modalId) setExposeExitFocus(null);
+      }, 700);
+      prevExposeActiveRef.current = exposeActive;
+      return () => clearTimeout(t);
+    }
+    prevExposeActiveRef.current = exposeActive;
+  }, [exposeActive, modalId]);
+  useEffect(() => {
+    if (!exposeActive) setExposeHovered(false);
+  }, [exposeActive]);
+  useEffect(() => {
+    const r = actionsRef.current;
+    const l = actionsLeftRef.current;
+    if (!r && !l) return;
+    const counted = (el) => el ? Array.from(el.children).filter((c) => c.dataset.undoControls !== "shell").length : 0;
+    const check = () => setHasActions(counted(r) + counted(l) > 0);
+    check();
+    const obs = new MutationObserver(check);
+    if (r) obs.observe(r, { childList: true });
+    if (l) obs.observe(l, { childList: true });
+    return () => obs.disconnect();
+  }, [open]);
+  useEffect(() => {
+    const handler = (e) => {
+      const btn = e.target.closest('button[type="submit"]');
+      if (btn && panelRef.current) {
+        const form = panelRef.current.querySelector("form");
+        if (form) {
+          e.preventDefault();
+          form.requestSubmit();
+        }
+      }
+    };
+    const r = actionsRef.current;
+    const l = actionsLeftRef.current;
+    if (r) r.addEventListener("click", handler);
+    if (l) l.addEventListener("click", handler);
+    return () => {
+      if (r) r.removeEventListener("click", handler);
+      if (l) l.removeEventListener("click", handler);
+    };
+  }, [open]);
+  const isNested = useRef(false);
+  const calcMaximized = useCallback(computeMaximizedBox, []);
+  const calcWindowed = useCallback(() => {
+    const sw = 0;
+    const taskbarH = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-height")) || 0;
+    const taskbarW = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-width")) || 0;
+    const tbPos = getComputedStyle(document.documentElement).getPropertyValue("--taskbar-position")?.trim() || "bottom";
+    const leftOffset = tbPos === "left" ? taskbarW : 0;
+    const rightOffset = tbPos === "right" ? taskbarW : 0;
+    const targetW = dimensions ? dimensions[0] : sizeDefaults[size] || 672;
+    const availW = window.innerWidth - sw - leftOffset - rightOffset - padding * 2;
+    const availH = window.innerHeight - taskbarH - padding * 2;
+    const w = Math.min(targetW, availW);
+    const heightScale = windowHeightScale[readDefaultWindowSize()];
+    const h = dimensions ? Math.min(dimensions[1], availH) : (() => {
+      const minH = 320;
+      const maxH = (size === "sm" ? 500 : size === "md" ? 600 : size === "lg" ? 700 : size === "xl" ? 800 : 920) * heightScale;
+      return Math.max(minH, Math.min(maxH, window.innerHeight - taskbarH - 80));
+    })();
+    const posMode = getComputedStyle(document.documentElement).getPropertyValue("--window-position")?.trim() || "cascade";
+    const offset = posMode === "cascade" ? (activationOrder.length - 1) * 30 : 0;
+    const maxOffsetX = availW - w;
+    const maxOffsetY = availH - h;
+    if (initialPosition === "top-right") {
+      return { x: window.innerWidth - w - padding, y: padding, w, h };
+    }
+    if (initialPosition === "top-left") {
+      return { x: sw + padding, y: padding, w, h };
+    }
+    return {
+      x: sw + Math.max(padding, (availW - w) / 2 + padding) + Math.min(offset, Math.max(0, maxOffsetX)),
+      y: Math.max(padding, (availH - h) / 2) + Math.min(offset, Math.max(0, maxOffsetY)),
+      w,
+      h
+    };
+  }, [size]);
+  const interceptedRef = useRef(false);
+  if (!open) interceptedRef.current = false;
+  const boxKey = windowKey || copyText || null;
+  useEffect(() => {
+    if (!open) return;
+    mountModal(modalId, boxKey);
+    if (!windowKey) activateModal(modalId);
+    isNested.current = false;
+    setZIndex(getZForModal(modalId));
+    const onReorder = () => {
+      setZIndex(getZForModal(modalId));
+    };
+    const onSplitView = () => {
+    };
+    const addressesThisWindow = (detail) => {
+      if (!detail) return false;
+      if (detail.windowKey) return detail.windowKey === windowKey;
+      if (!detail.label) return false;
+      const titleEl = panelRef.current?.querySelector("[data-window-title]");
+      return !!titleEl?.textContent?.includes(detail.label);
+    };
+    const onCenter = (e) => {
+      if (!addressesThisWindow(e.detail)) return;
+      activateModal(modalId);
+      const taskbarH = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-height")) || 0;
+      const taskbarW = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-width")) || 0;
+      const tbPos = getComputedStyle(document.documentElement).getPropertyValue("--taskbar-position")?.trim() || "bottom";
+      const leftOff = tbPos === "left" ? taskbarW : 0;
+      const rightOff = tbPos === "right" ? taskbarW : 0;
+      const availW = window.innerWidth - leftOff - rightOff;
+      const availH = window.innerHeight - taskbarH;
+      const w = Math.min(boxRef.current.w, availW - 40);
+      const h = Math.min(boxRef.current.h, availH - 40);
+      const x = leftOff + (availW - w) / 2;
+      const y = (tbPos === "top" ? taskbarH : 0) + (availH - h) / 2;
+      setBox({ x, y, w, h });
+      setMaximized(false);
+    };
+    const onCtxMenu = (e) => {
+      const detail = e.detail;
+      if (!addressesThisWindow(detail)) return;
+      activateModal(modalId);
+      setWindowMenu({ x: detail.x, y: detail.y });
+    };
+    const onReveal = (e) => {
+      if (e.detail?.windowKey !== windowKey) return;
+      activateModal(modalId);
+      const cur = boxRef.current;
+      const next = clampFullyVisible(cur);
+      if (next.x === cur.x && next.y === cur.y && next.w === cur.w && next.h === cur.h) return;
+      const panel = panelRef.current;
+      const stillness = typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+      if (panel && !stillness) {
+        let settled = false;
+        const done = () => {
+          if (settled) return;
+          settled = true;
+          panel.style.transition = "";
+          window.dispatchEvent(new CustomEvent("modal-geometry"));
+        };
+        panel.style.transition = "left .28s ease, top .28s ease, width .28s ease, height .28s ease";
+        panel.addEventListener("transitionend", done, { once: true });
+        window.setTimeout(done, 400);
+      }
+      setBox(next);
+    };
+    window.addEventListener("modal-reorder", onReorder);
+    window.addEventListener("modal-split-view", onSplitView);
+    window.addEventListener("modal-center", onCenter);
+    window.addEventListener("modal-reveal", onReveal);
+    window.addEventListener("modal-context-menu", onCtxMenu);
+    return () => {
+      unmountModal(modalId);
+      window.removeEventListener("modal-reorder", onReorder);
+      window.removeEventListener("modal-split-view", onSplitView);
+      window.removeEventListener("modal-center", onCenter);
+      window.removeEventListener("modal-reveal", onReveal);
+      window.removeEventListener("modal-context-menu", onCtxMenu);
+      window.dispatchEvent(new CustomEvent("modal-reorder"));
+    };
+  }, [open, modalId, boxKey, calcMaximized]);
+  const openMaximized = !widget && readDefaultWindowSize() === "maximized";
+  const [box, setBox] = useState(() => {
+    if (boxKey && _windowPositions[boxKey]) {
+      const saved = { ..._windowPositions[boxKey] };
+      if (dimensions) {
+        saved.w = dimensions[0];
+        if (!autoHeight) saved.h = dimensions[1];
+      }
+      return clampReachable(saved);
+    }
+    if (initialBox) return { x: initialBox.x, y: initialBox.y, w: initialBox.w, h: initialBox.h };
+    return openMaximized ? calcMaximized() : calcWindowed();
+  });
+  const [autoHeightResolved, setAutoHeightResolved] = useState(() => !autoHeight);
+  const [alwaysMaximizedRaw, setAlwaysMaximizedRaw] = useState(() => readAlwaysMaximizedFlag());
+  useEffect(() => {
+    const refresh = () => setAlwaysMaximizedRaw(readAlwaysMaximizedFlag());
+    window.addEventListener("react-os-shell:layout-mode-changed", refresh);
+    return () => window.removeEventListener("react-os-shell:layout-mode-changed", refresh);
+  }, []);
+  const alwaysMaximized = alwaysMaximizedRaw && !widget;
+  const [maximized, setMaximized] = useState(() => {
+    if (boxKey && _windowPositions[boxKey] || initialBox) return alwaysMaximized;
+    return alwaysMaximized || openMaximized;
+  });
+  const boxRef = useRef(box);
+  boxRef.current = box;
+  useLayoutEffect(() => {
+    if (autoHeightResolved) return;
+    const panel = panelRef.current;
+    const body = bodyRef.current;
+    if (!panel || !body) return;
+    const floor = autoMinHeight ?? (widget ? 0 : 240);
+    const taskbarH = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-height")) || 0;
+    let lastH = 0;
+    let freezeTimer = null;
+    let observed = null;
+    const measure = () => {
+      const content2 = body.firstElementChild;
+      if (!content2 || panel.offsetHeight <= 0) return;
+      if (content2 !== observed) {
+        if (observed) ro.unobserve(observed);
+        ro.observe(content2);
+        observed = content2;
+      }
+      const chrome = panel.offsetHeight - body.offsetHeight;
+      const prevFlex = body.style.flex, prevOverflow = body.style.overflowY, prevHeight = body.style.height;
+      body.style.flex = "0 0 auto";
+      body.style.height = "auto";
+      body.style.overflowY = "visible";
+      const bodyNatural = body.offsetHeight;
+      const contentNatural = content2.offsetHeight;
+      body.style.flex = prevFlex;
+      body.style.height = prevHeight;
+      body.style.overflowY = prevOverflow;
+      const contentFilled = content2.offsetHeight;
+      const fillsContainer = contentFilled > contentNatural + 4;
+      const viewportCap = Math.max(floor, window.innerHeight - taskbarH - Math.max(0, boxRef.current.y) - 24);
+      const target = fillsContainer ? Math.min(boxRef.current.h, viewportCap) : Math.min(Math.max(floor, chrome + bodyNatural), viewportCap);
+      const changed = Math.abs(target - lastH) > 1;
+      if (changed) {
+        lastH = target;
+        setBox((prev) => Math.abs(prev.h - target) > 1 ? { ...prev, h: target } : prev);
+      }
+      if (!widget) {
+        if (target <= floor) {
+          if (freezeTimer) {
+            clearTimeout(freezeTimer);
+            freezeTimer = null;
+          }
+        } else if (changed || freezeTimer === null) {
+          if (freezeTimer) clearTimeout(freezeTimer);
+          freezeTimer = setTimeout(() => {
+            const before = lastH;
+            measure();
+            if (lastH === before) setAutoHeightResolved(true);
+          }, 160);
+        }
+      }
+    };
+    const ro = new ResizeObserver(measure);
+    measure();
+    if (footerRef.current) ro.observe(footerRef.current);
+    const mo = new MutationObserver(measure);
+    mo.observe(body, { childList: true, subtree: true, characterData: true });
+    return () => {
+      ro.disconnect();
+      mo.disconnect();
+      if (freezeTimer) clearTimeout(freezeTimer);
+    };
+  }, [autoHeightResolved, widget, autoMinHeight, hasFooterContent]);
+  useLayoutEffect(() => {
+    if (!autoHeight || !autoHeightResolved || widget || !open) return;
+    const footerEl = footerRef.current;
+    if (!footerEl) return;
+    let lastFooterH = footerEl.offsetHeight;
+    const ro = new ResizeObserver(() => {
+      if (!footerEl.isConnected) return;
+      const h = footerEl.offsetHeight;
+      const delta = h - lastFooterH;
+      const flipped = h > 0 !== lastFooterH > 0;
+      lastFooterH = h;
+      if (!flipped || delta === 0 || maximized) return;
+      if (document.body.classList.contains("rosh-gesturing")) return;
+      const floor = autoMinHeight ?? 240;
+      const taskbarH = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--taskbar-height")) || 0;
+      const viewportCap = Math.max(floor, window.innerHeight - taskbarH - Math.max(0, boxRef.current.y) - 24);
+      setBox((prev) => ({ ...prev, h: Math.min(Math.max(floor, prev.h + delta), viewportCap) }));
+    });
+    ro.observe(footerEl);
+    return () => ro.disconnect();
+  }, [autoHeight, autoHeightResolved, widget, open, maximized, autoMinHeight]);
+  const fitWidth = autoWidth !== false && !widget && !appStyle && !isMobile;
+  const [autoWidthResolved, setAutoWidthResolved] = useState(() => !fitWidth);
+  useLayoutEffect(() => {
+    if (autoWidthResolved || !open) return;
+    if (!fitWidth || maximized) {
+      setAutoWidthResolved(true);
+      return;
+    }
+    const panel = panelRef.current;
+    const body = bodyRef.current;
+    if (!panel || !body) return;
+    const rigid = /* @__PURE__ */ new WeakSet();
+    let expectedW = boxRef.current.w;
+    let frame = 0;
+    const stop = () => setAutoWidthResolved(true);
+    const measure = () => {
+      frame = 0;
+      const cur = boxRef.current;
+      if (Math.abs(cur.w - expectedW) > 1 || document.body.classList.contains("rosh-gesturing")) {
+        stop();
+        return;
+      }
+      const area = computeMaximizedBox();
+      const capW = area.w - padding * 2;
+      if (cur.w >= capW) {
+        stop();
+        return;
+      }
+      const scrollers = [];
+      const over = [];
+      for (const el of [body, ...Array.from(body.querySelectorAll("*"))]) {
+        const o = el.scrollWidth - el.clientWidth;
+        if (o <= 4 || rigid.has(el)) continue;
+        const ox = getComputedStyle(el).overflowX;
+        if (ox !== "auto" && ox !== "scroll") continue;
+        scrollers.push(el);
+        over.push(o);
+      }
+      if (!scrollers.length) return;
+      const probeW = Math.min(capW, cur.w + Math.max(...over));
+      const gain = probeW - cur.w;
+      const prevWidth = panel.style.width;
+      panel.style.width = `${probeW}px`;
+      const measured = scrollers.map((el, i) => ({ over: over[i], residual: el.scrollWidth - el.clientWidth }));
+      panel.style.width = prevWidth;
+      measured.forEach((m, i) => {
+        if (!scrollerIsFluid(m, gain)) rigid.add(scrollers[i]);
+      });
+      const next = growBoxToWidth(cur, widthToFit(cur.w, gain, measured), area, padding);
+      if (next === cur) return;
+      expectedW = next.w;
+      setBox(next);
+    };
+    const schedule = () => {
+      if (!frame) frame = requestAnimationFrame(measure);
+    };
+    measure();
+    const mo = new MutationObserver(schedule);
+    mo.observe(body, { childList: true, subtree: true, characterData: true, attributes: true, attributeFilter: ["style", "class", "hidden"] });
+    const deadline = setTimeout(stop, AUTO_WIDTH_WATCH_MS);
+    return () => {
+      mo.disconnect();
+      if (frame) cancelAnimationFrame(frame);
+      clearTimeout(deadline);
+    };
+  }, [autoWidthResolved, open, fitWidth, maximized]);
+  useEffect(() => {
+    if (alwaysMaximized) {
+      setMaximized(true);
+      setBox(calcMaximized());
+    }
+  }, [alwaysMaximized, calcMaximized]);
+  useEffect(() => {
+    if (widget) return;
+    const restore = () => {
+      setMaximized(false);
+      setBox(calcWindowed());
+    };
+    window.addEventListener("react-os-shell:restore-windowed", restore);
+    return () => window.removeEventListener("react-os-shell:restore-windowed", restore);
+  }, [widget, calcWindowed]);
+  useEffect(() => {
+    if (open && boxKey) {
+      _windowPositions[boxKey] = box;
+      _savePositionsDebounced();
+    }
+    if (open) window.dispatchEvent(new CustomEvent("modal-geometry"));
+  }, [box, open, boxKey]);
+  useEffect(() => {
+    if (!open) return;
+    const sync = () => {
+      if (maximized) {
+        setBox(calcMaximized());
+        return;
+      }
+      if (document.body.classList.contains("rosh-gesturing")) return;
+      setBox(clampReachable);
+    };
+    window.addEventListener("resize", sync);
+    let observer = null;
+    if (maximized) {
+      observer = new MutationObserver(sync);
+      observer.observe(document.body, { childList: true, subtree: false, attributes: true, attributeFilter: ["class"] });
+    }
+    return () => {
+      window.removeEventListener("resize", sync);
+      observer?.disconnect();
+    };
+  }, [open, maximized, calcMaximized]);
+  useEffect(() => {
+    if (!open) return;
+    setTouched(false);
+    touchedRef.current = false;
+    closingRef.current = false;
+    setAutoWidthResolved(!fitWidth);
+    if (boxKey && _windowPositions[boxKey]) {
+      const saved = _windowPositions[boxKey];
+      setBox((prev) => clampReachable({
+        ...saved,
+        ...autoHeight ? { h: prev.h } : {},
+        ...fitWidth ? { x: prev.x, w: prev.w } : {}
+      }));
+      return;
+    }
+    if (initialBox) {
+      setBox({ x: initialBox.x, y: initialBox.y, w: initialBox.w, h: initialBox.h });
+      setMaximized(initialBox.maximized);
+    }
+  }, [open]);
+  useEffect(() => {
+    if (!open || dirty !== "auto") return;
+    let timer;
+    const handler = (e) => {
+      if (!panelRef.current?.contains(e.target) || touchedRef.current) return;
+      touchedRef.current = true;
+      timer = setTimeout(() => setTouched(true), 0);
+    };
+    document.addEventListener("input", handler, true);
+    document.addEventListener("change", handler, true);
+    return () => {
+      clearTimeout(timer);
+      document.removeEventListener("input", handler, true);
+      document.removeEventListener("change", handler, true);
+    };
+  }, [open, dirty]);
+  const isDirty = dirty === "auto" ? touched : dirty === true;
+  useWindowDirty(!windowKey && open ? isDirty : false);
+  const guardedClose = useCallback(async () => {
+    if (closingRef.current) return;
+    if (isDirty || dirty === "auto" && touchedRef.current) {
+      closingRef.current = true;
+      const name = titleTooltip;
+      const ok = await confirm({
+        title: "Discard changes?",
+        message: name ? `\u201C${name}\u201D has unsaved changes. Are you sure you want to close? All changes will be lost.` : "You have unsaved changes. Are you sure you want to close? All changes will be lost.",
+        confirmLabel: "Discard",
+        cancelLabel: "Keep Editing",
+        variant: "warning"
+      });
+      closingRef.current = false;
+      if (!ok) return;
+    }
+    onClose();
+  }, [isDirty, dirty, onClose, titleTooltip]);
+  useLayoutEffect(() => {
+    if (!open || !windowKey) return;
+    const handler = (event) => {
+      if (event.detail?.windowKey === windowKey) guardedClose();
+    };
+    window.addEventListener(MODAL_CLOSE_REQUEST_EVENT, handler);
+    return () => window.removeEventListener(MODAL_CLOSE_REQUEST_EVENT, handler);
+  }, [open, windowKey, guardedClose]);
+  const preSnapBoxRef = useRef(null);
+  const startDrag = useCallback((e) => {
+    if (e.button !== 0) return;
+    if (e.target.closest("button, input, a, kbd, select, textarea")) return;
+    setWindowMenu(null);
+    activateModal(modalId);
+    if (alwaysMaximized) {
+      e.preventDefault();
+      return;
+    }
+    e.preventDefault();
+    const dragHandle = e.currentTarget;
+    const dragPointerId = e.pointerId;
+    let endGesture = null;
+    const sx = e.clientX, sy = e.clientY;
+    const panel = panelRef.current;
+    const rect = panel?.getBoundingClientRect();
+    let ox, oy, actualH, actualW;
+    if (preSnapBoxRef.current) {
+      const restore = preSnapBoxRef.current;
+      preSnapBoxRef.current = null;
+      actualW = restore.w;
+      actualH = restore.h;
+      const offsetX = rect ? Math.min(Math.max(20, e.clientX - rect.left), restore.w - 20) : restore.w / 2;
+      ox = e.clientX - offsetX;
+      oy = e.clientY - 12;
+      if (panel) {
+        panel.style.width = `${actualW}px`;
+        panel.style.height = `${actualH}px`;
+        panel.style.left = `${ox}px`;
+        panel.style.top = `${oy}px`;
+      }
+    } else {
+      ox = rect ? rect.left : boxRef.current.x;
+      oy = rect ? rect.top : boxRef.current.y;
+      actualH = rect ? rect.height : boxRef.current.h;
+      actualW = rect ? rect.width : boxRef.current.w;
+    }
+    setMaximized(false);
+    setBox((b) => ({ ...b, x: ox, y: oy, w: actualW, h: actualH }));
+    let currentZone = null;
+    const move = (ev) => {
+      if (!endGesture) {
+        if (Math.abs(ev.clientX - sx) < DRAG_THRESHOLD && Math.abs(ev.clientY - sy) < DRAG_THRESHOLD) return;
+        endGesture = beginPointerGesture(dragHandle, dragPointerId, "move", "move");
+        if (panel) panel.style.transition = "none";
+      }
+      const nx = ox + ev.clientX - sx;
+      const ny = Math.max(0, oy + ev.clientY - sy);
+      if (panel) panel.style.transform = `translate(${nx - ox}px, ${ny - oy}px)`;
+      boxRef.current = { ...boxRef.current, x: nx, y: ny };
+      if (!widget) {
+        const zone = detectSnapZone(ev.clientX, ev.clientY);
+        if (zone !== currentZone) {
+          currentZone = zone;
+          if (zone) showSnapPreview(calcSnapBox(zone));
+          else hideSnapPreview();
+        }
+      }
+    };
+    const up = () => {
+      window.removeEventListener("pointermove", move);
+      window.removeEventListener("pointerup", up);
+      endGesture?.();
+      hideSnapPreview();
+      const finalBox = clampReachable({ ...boxRef.current });
+      boxRef.current = finalBox;
+      if (!widget && currentZone) {
+        preSnapBoxRef.current = { x: ox, y: oy, w: actualW, h: actualH };
+        const snapped = calcSnapBox(currentZone);
+        if (panel) {
+          panel.style.left = `${snapped.x}px`;
+          panel.style.top = `${snapped.y}px`;
+          panel.style.width = `${snapped.w}px`;
+          panel.style.height = `${snapped.h}px`;
+          panel.style.transform = "";
+          panel.style.transition = "";
+        }
+        setBox(snapped);
+        return;
+      }
+      if (widget) {
+        const centerX = finalBox.x + finalBox.w / 2;
+        const mid = window.innerWidth / 2;
+        setWidgetAnchor(centerX > mid ? "right" : "left");
+      }
+      if (panel) {
+        panel.style.left = `${finalBox.x}px`;
+        panel.style.top = `${finalBox.y}px`;
+        panel.style.transform = "";
+        panel.style.transition = "";
+      }
+      setBox(finalBox);
+    };
+    window.addEventListener("pointermove", move);
+    window.addEventListener("pointerup", up);
+  }, []);
+  const startResizeCorner = useCallback((e, corner) => {
+    if (e.button !== 0) return;
+    e.preventDefault();
+    e.stopPropagation();
+    const resizeHandle = e.currentTarget;
+    const resizePointerId = e.pointerId;
+    let endGesture = null;
+    const sx = e.clientX, sy = e.clientY;
+    const panel = panelRef.current;
+    const rect = panel?.getBoundingClientRect();
+    const ox = rect ? rect.left : boxRef.current.x;
+    const oy = rect ? rect.top : boxRef.current.y;
+    const ow = rect ? rect.width : boxRef.current.w;
+    const oh = rect ? rect.height : boxRef.current.h;
+    const isWest = corner === "sw" || corner === "nw" || corner === "w";
+    const isNorth = corner === "ne" || corner === "nw" || corner === "n";
+    const isEast = corner === "se" || corner === "ne" || corner === "e";
+    const isSouth = corner === "se" || corner === "sw" || corner === "s";
+    setMaximized(false);
+    setBox({ x: ox, y: oy, w: ow, h: oh });
+    boxRef.current = { x: ox, y: oy, w: ow, h: oh };
+    const compute = (dx, dy) => {
+      let nx = ox, ny = oy, nw = ow, nh = oh;
+      if (isEast) nw = Math.max(MIN_W, ow + dx);
+      if (isSouth) nh = Math.max(MIN_H, oh + dy);
+      if (isWest) {
+        const targetW = Math.max(MIN_W, ow - dx);
+        nx = ox + ow - targetW;
+        nw = targetW;
+      }
+      if (isNorth) {
+        const targetH = Math.max(MIN_H, oh - dy);
+        ny = oy + oh - targetH;
+        nh = targetH;
+      }
+      return { x: nx, y: ny, w: nw, h: nh };
+    };
+    let raf = 0;
+    let pending = null;
+    const flush = () => {
+      raf = 0;
+      if (!pending) return;
+      const next = pending;
+      pending = null;
+      boxRef.current = next;
+      if (panel) {
+        panel.style.left = `${next.x}px`;
+        panel.style.top = `${next.y}px`;
+        panel.style.width = `${next.w}px`;
+        panel.style.height = `${next.h}px`;
+      }
+    };
+    const move = (ev) => {
+      if (!endGesture) {
+        if (Math.abs(ev.clientX - sx) < DRAG_THRESHOLD && Math.abs(ev.clientY - sy) < DRAG_THRESHOLD) return;
+        endGesture = beginPointerGesture(resizeHandle, resizePointerId, RESIZE_CURSOR[corner], "resize");
+      }
+      pending = compute(ev.clientX - sx, ev.clientY - sy);
+      if (!raf) raf = requestAnimationFrame(flush);
+    };
+    const up = () => {
+      window.removeEventListener("pointermove", move);
+      window.removeEventListener("pointerup", up);
+      if (raf) cancelAnimationFrame(raf);
+      flush();
+      endGesture?.();
+      setBox({ ...boxRef.current });
+    };
+    window.addEventListener("pointermove", move);
+    window.addEventListener("pointerup", up);
+  }, []);
+  const KEY_STEP = 24;
+  const onTitleBarKeyDown = useCallback((e) => {
+    if (e.target.closest("button, input, a, kbd, select, textarea")) return;
+    const arrows = {
+      ArrowLeft: [-1, 0],
+      ArrowRight: [1, 0],
+      ArrowUp: [0, -1],
+      ArrowDown: [0, 1]
+    };
+    const dir = arrows[e.key];
+    if (!dir && e.key !== "Enter") return;
+    e.preventDefault();
+    e.stopPropagation();
+    activateModal(modalId);
+    if (e.key === "Enter") {
+      if (maximized) {
+        setMaximized(false);
+        setBox(calcWindowed());
+      } else {
+        setMaximized(true);
+        setBox(calcMaximized());
+      }
+      return;
+    }
+    const [dx, dy] = dir;
+    if (e.ctrlKey || e.metaKey) {
+      const savePreSnap = () => {
+        if (!preSnapBoxRef.current) preSnapBoxRef.current = { ...boxRef.current };
+      };
+      if (dy < 0) {
+        savePreSnap();
+        setMaximized(true);
+        setBox(calcMaximized());
+        return;
+      }
+      if (dy > 0) {
+        if (maximized) {
+          setMaximized(false);
+          setBox(calcWindowed());
+          return;
+        }
+        if (preSnapBoxRef.current) {
+          const restore = clampReachable(preSnapBoxRef.current);
+          preSnapBoxRef.current = null;
+          boxRef.current = restore;
+          setBox(restore);
+          return;
+        }
+        _minimizeModal(modalId);
+        return;
+      }
+      savePreSnap();
+      setMaximized(false);
+      const snapped = calcSnapBox(dx < 0 ? "left" : "right");
+      boxRef.current = snapped;
+      setBox(snapped);
+      return;
+    }
+    if (maximized) return;
+    const b = boxRef.current;
+    const next = e.shiftKey ? { ...b, w: Math.max(MIN_W, b.w + dx * KEY_STEP), h: Math.max(MIN_H, b.h + dy * KEY_STEP) } : clampReachable({ ...b, x: b.x + dx * KEY_STEP, y: Math.max(0, b.y + dy * KEY_STEP) });
+    boxRef.current = next;
+    setBox(next);
+  }, [modalId, maximized, calcWindowed, calcMaximized]);
+  const applySnapZone = useCallback((zone) => {
+    if (!preSnapBoxRef.current) preSnapBoxRef.current = { ...boxRef.current };
+    setMaximized(false);
+    const snapped = calcSnapBox(zone);
+    boxRef.current = snapped;
+    setBox(snapped);
+    activateModal(modalId);
+  }, [modalId]);
+  const titleBarKeyProps = alwaysMaximized || exposeActive ? {} : {
+    tabIndex: 0,
+    role: "group",
+    "aria-label": titleTooltip ? `${titleTooltip} \u2014 ${winStr.windowSuffix}` : winStr.windowSuffix,
+    "aria-keyshortcuts": "ArrowUp ArrowDown ArrowLeft ArrowRight Shift+ArrowUp Shift+ArrowDown Shift+ArrowLeft Shift+ArrowRight Control+ArrowUp Control+ArrowDown Control+ArrowLeft Control+ArrowRight Enter",
+    onKeyDown: onTitleBarKeyDown
+  };
+  const reset = () => {
+    setMaximized(true);
+    setBox(calcMaximized());
+  };
+  const submitModal = useCallback(() => {
+    const panel = panelRef.current;
+    if (!panel) return;
+    const form = panel.querySelector("form");
+    if (form) {
+      form.requestSubmit();
+    } else {
+      const btn = panel.querySelector(MODAL_SUBMIT_SELECTOR);
+      if (btn && !btn.disabled) btn.click();
+    }
+  }, []);
+  useEffect(() => {
+    if (!open) return;
+    const handler = (e) => {
+      if (activationOrder[activationOrder.length - 1] !== modalId) return;
+      if (e.key === "Enter") {
+        const target = e.target;
+        if (target.tagName === "TEXTAREA" || target.isContentEditable) return;
+        if (e.metaKey || e.ctrlKey) {
+          e.preventDefault();
+          submitModal();
+        } else if (target.tagName === "INPUT" && target.closest("form")) {
+          return;
+        } else {
+          e.preventDefault();
+        }
+      }
+    };
+    window.addEventListener("keydown", handler, true);
+    return () => window.removeEventListener("keydown", handler, true);
+  }, [open, submitModal, modalId]);
+  useEffect(() => {
+    if (!open) return;
+    const handler = (e) => {
+      if (activationOrder[activationOrder.length - 1] !== modalId) return;
+      if ((e.metaKey || e.ctrlKey) && e.key === "s") {
+        e.preventDefault();
+        document.dispatchEvent(new CustomEvent("modal-save", { detail: { modalId } }));
+        touchedRef.current = false;
+        setTouched(false);
+      } else if (e.altKey && e.shiftKey && (e.code === "KeyD" || e.key === "D" || e.key === "d")) {
+        e.preventDefault();
+        document.dispatchEvent(new CustomEvent("modal-duplicate", { detail: { modalId } }));
+      }
+    };
+    window.addEventListener("keydown", handler, true);
+    return () => window.removeEventListener("keydown", handler, true);
+  }, [open]);
+  useEffect(() => {
+    if (!open) return;
+    if (widget) return;
+    const handler = (e) => {
+      if (e.key === "Escape" && activationOrder[activationOrder.length - 1] === modalId) {
+        if (runEscapeInterceptors(e)) {
+          e.preventDefault();
+          e.stopPropagation();
+          return;
+        }
+        e.preventDefault();
+        e.stopPropagation();
+        guardedClose();
+      }
+    };
+    window.addEventListener("keydown", handler, true);
+    return () => window.removeEventListener("keydown", handler, true);
+  }, [open, guardedClose, modalId, widget]);
+  const hasNav = open && (onNext !== void 0 || onPrev !== void 0);
+  const showBoundaryToast = useCallback((edge) => {
+    const existing = document.getElementById("nav-boundary-toast");
+    if (existing) existing.remove();
+    const lines = edge === "bottom" ? ["That's the last one, chief.", "You've hit rock bottom... of the list.", "End of the line, buddy.", "Nothing left. Go outside.", "Congratulations, you scrolled to the void.", "There's no more. I checked.", "You've reached the edge of the known universe.", "Plot twist: there is no next one.", "Even scrolling has limits. Unlike your ambition.", "Last one. Time to touch grass."] : ["Already at the top. Overachiever.", "There is no item above this. Trust me.", "You're #1. Literally.", "Can't go higher. You've peaked.", "This is it. The summit. The top.", "First item. No VIP lounge above this.", "Going up? Nope. Elevator's broken.", "You want negative indexes? Bold.", "Top of the list. Top of the world.", "The only way is down from here."];
+    const msg = lines[Math.floor(Math.random() * lines.length)];
+    const toast = document.createElement("div");
+    toast.id = "nav-boundary-toast";
+    toast.className = "fixed bottom-6 left-1/2 -translate-x-1/2 z-[9999] bg-gray-900 text-white px-5 py-2.5 rounded-lg shadow-lg text-sm font-medium transition-opacity duration-300";
+    toast.textContent = msg;
+    document.body.appendChild(toast);
+    setTimeout(() => {
+      toast.style.opacity = "0";
+      setTimeout(() => toast.remove(), 300);
+    }, 2e3);
+  }, []);
+  useEffect(() => {
+    if (!open) return;
+    const handler = (e) => {
+      if (activationOrder[activationOrder.length - 1] !== modalId) return;
+      const tag = e.target.tagName;
+      if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return;
+      if (e.target.isContentEditable) return;
+      if (e.key === "j" && hasNav) {
+        e.preventDefault();
+        if (onNext) onNext();
+        else showBoundaryToast("bottom");
+      }
+      if (e.key === "k" && hasNav) {
+        e.preventDefault();
+        if (onPrev) onPrev();
+        else showBoundaryToast("top");
+      }
+    };
+    window.addEventListener("keydown", handler);
+    return () => window.removeEventListener("keydown", handler);
+  }, [open, onNext, onPrev, hasNav, showBoundaryToast, modalId]);
+  if (!open || interceptedRef.current) return null;
+  const exposeTile = exposeActive ? computeExposeTile(modalId) : null;
+  const exposeScale = exposeActive && exposeTile ? Math.min(exposeTile.w / box.w, exposeTile.h / box.h) : 1;
+  const exposeStyle = (() => {
+    if (exposeActive && exposeTile) {
+      const scale = exposeScale;
+      const scaledW = box.w * scale;
+      const scaledH = box.h * scale;
+      const tx = exposeTile.x + (exposeTile.w - scaledW) / 2 - box.x;
+      const ty = exposeTile.y + (exposeTile.h - scaledH) / 2 - box.y;
+      const lit = exposeHovered || exposeKeyboardHighlight;
+      return {
+        transform: `translate(${tx}px, ${ty}px) scale(${scale})`,
+        transformOrigin: "top left",
+        transition: "transform 280ms cubic-bezier(0.2, 0.8, 0.2, 1), box-shadow 280ms",
+        cursor: "pointer",
+        // Lifted tile sits above its neighbours so the glow isn't clipped.
+        zIndex: lit ? 2020 : 2010,
+        boxShadow: lit ? "0 24px 72px rgba(0,0,0,0.6), 0 0 0 2px rgba(255,255,255,0.55), 0 0 36px 12px rgba(96,165,250,0.85), 0 0 96px 28px rgba(96,165,250,0.55)" : "0 16px 48px rgba(0,0,0,0.55)",
+        pointerEvents: "auto"
+      };
+    }
+    if (exposeExiting && isExposeTileable) {
+      const picked = exposeExitRole === "picked";
+      return {
+        transition: picked ? "transform 640ms cubic-bezier(0.34, 1.42, 0.64, 1), box-shadow 600ms" : "transform 600ms cubic-bezier(0.2, 0.8, 0.2, 1), box-shadow 600ms",
+        ...picked ? { zIndex: 2030 } : {}
+      };
+    }
+    return null;
+  })();
+  const content = /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: panelRef,
+        "data-modal-panel": true,
+        "data-modal-id": modalId,
+        "data-window-key": windowKey || void 0,
+        ...allowPinOnTop ? { "data-utility": "" } : {},
+        ...pinnedOnTop ? { "data-pinned-top": "" } : {},
+        ...widget ? { "data-widget": "" } : {},
+        className: `fixed rounded-2xl flex flex-col overflow-hidden ${widget ? isActive ? "shadow-2xl" : "shadow-lg" : `border ${isActive ? "shadow-2xl border-gray-200" : "shadow-lg border-gray-300"}`}`,
+        onMouseDownCapture: (e) => {
+          swallowInactiveClickRef.current = false;
+          if (exposeActive) {
+            if (e.target.closest("[data-expose-close]")) return;
+            e.preventDefault();
+            e.stopPropagation();
+            setExposeExitFocus(modalId);
+            setExposeState(false);
+            activateModal(modalId);
+            return;
+          }
+          if (!isActive && !widget && !pinnedOnTop && e.button === 0) {
+            const target = e.target;
+            if (target.closest("[data-modal-panel]") === panelRef.current && target.closest("button, input, a, select, textarea") && !target.closest("[data-window-chrome]")) {
+              e.preventDefault();
+              e.stopPropagation();
+              swallowInactiveClickRef.current = true;
+              setWindowMenu(null);
+              activateModal(modalId);
+              window.addEventListener("mouseup", () => {
+                setTimeout(() => {
+                  swallowInactiveClickRef.current = false;
+                }, 0);
+              }, { once: true });
+            }
+          }
+        },
+        onClickCapture: (e) => {
+          if (swallowInactiveClickRef.current) {
+            swallowInactiveClickRef.current = false;
+            e.preventDefault();
+            e.stopPropagation();
+          }
+        },
+        onMouseDown: (e) => {
+          if (exposeActive) return;
+          setWindowMenu(null);
+          const targetPanel = e.target.closest("[data-modal-panel]");
+          if (targetPanel !== panelRef.current) return;
+          if (!e.target.closest("button, input, a, select, textarea")) {
+            activateModal(modalId);
+          }
+        },
+        style: isMobile ? {
+          // Mobile fullscreen: ignore stored box, fill viewport down to bottom
+          // nav. Widgets stay hidden on mobile. Only the active window is
+          // visible — all others hidden so swipe-right reveals the home
+          // wallpaper backdrop. Exception: when a sibling Modal is being
+          // swiped to-back and we're its `openedFrom` parent, un-hide so the
+          // user sees their parent list during the slide instead of just the
+          // wallpaper.
+          zIndex: zIndex + 1,
+          top: 0,
+          left: 0,
+          right: 0,
+          bottom: "var(--mobile-bottom-nav, 56px)",
+          width: "auto",
+          height: "auto",
+          transform: `translateX(${swipeX}px)`,
+          transition: swipeDragging ? "none" : "transform 180ms ease-out",
+          ...widget ? { display: "none" } : {},
+          ...zIndex < 0 ? { display: "none" } : {},
+          ...!isActive && !pinnedOnTop && !(swipingParentKey && windowKey === swipingParentKey) ? { display: "none" } : {}
+        } : {
+          // The panel is always a definite height — even while an `autoHeight`
+          // window is still measuring (box.h is seeded from the size ladder).
+          // The measurement effect adjusts box.h to hug the content; rendering
+          // at a definite height the whole way through means fill-height
+          // content (flex-1 / h-full) never collapses to the floor.
+          zIndex: pinnedOnTop ? Z_LAYERS.pinnedWindow : zIndex + 1,
+          width: box.w,
+          height: box.h,
+          top: box.y,
+          ...widget && widgetAnchor === "right" ? { right: window.innerWidth - box.x - box.w } : { left: box.x },
+          ...zIndex < 0 && !pinnedOnTop ? { display: "none" } : {},
+          ...exposeStyle ?? {}
+        },
+        children: [
+          isMobile && !widget && /* @__PURE__ */ jsx(
+            "div",
+            {
+              onPointerDown: handleEdgePointerDown,
+              className: "absolute top-0 bottom-0 left-0 w-[22px] z-[5]",
+              style: { touchAction: "pan-y" },
+              "aria-hidden": "true"
+            }
+          ),
+          widget ? (
+            /* Widget: no title bar — drag via body, close via right-click context menu */
+            null
+          ) : isMobile ? null : compact ? (
+            /* Compact: smaller title bar with title + close only */
+            /* @__PURE__ */ jsxs(
+              "div",
+              {
+                onPointerDown: startDrag,
+                "data-window-chrome": "",
+                ...titleBarKeyProps,
+                className: `flex items-center justify-between px-3 py-1.5 border-b border-gray-200 shrink-0 cursor-move select-none rounded-t-2xl focus:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-blue-400 ${isActive ? "backdrop-blur-sm" : ""}`,
+                style: { touchAction: "none", backgroundColor: isActive ? `rgb(var(--window-header-rgb) / var(--active-header-opacity, 0.8))` : `rgb(var(--window-header-rgb) / var(--inactive-header-opacity, 0.7))` },
+                children: [
+                  /* @__PURE__ */ jsxs("div", { "data-window-title": true, title: titleTooltip, className: "text-sm font-medium min-w-0 flex-1 truncate flex items-center gap-1.5", style: { color: isActive ? "var(--window-title-active, rgb(17 24 39))" : "var(--window-title-inactive, rgb(156 163 175))" }, children: [
+                    !exposeActive && renderIconButton(),
+                    /* @__PURE__ */ jsx("span", { className: "truncate", children: exposeActive ? extractTitleText(displayTitle) : displayTitle })
+                  ] }),
+                  !exposeActive && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1 shrink-0 ml-2", children: [
+                    allowPinOnTop && /* @__PURE__ */ jsx(
+                      "button",
+                      {
+                        onClick: () => setPinnedOnTop((p) => !p),
+                        title: pinnedOnTop ? winStr.unpin : winStr.pinOnTop,
+                        className: `p-0.5 rounded hover:bg-gray-200 ${pinnedOnTop ? "text-blue-600" : "text-gray-400 hover:text-gray-600"}`,
+                        children: /* @__PURE__ */ jsx("svg", { className: "h-3 w-3", fill: pinnedOnTop ? "currentColor" : "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M16.5 3.75V16.5L12 14.25 7.5 16.5V3.75m9 0H18A2.25 2.25 0 0120.25 6v12A2.25 2.25 0 0118 20.25H6A2.25 2.25 0 013.75 18V6A2.25 2.25 0 016 3.75h1.5m9 0h-9" }) })
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("button", { type: "button", onClick: guardedClose, className: "rounded p-0.5 text-gray-400 hover:text-gray-600 hover:bg-gray-200", children: /* @__PURE__ */ jsx(XMarkIcon, { className: "h-4 w-4" }) })
+                  ] })
+                ]
+              }
+            )
+          ) : appStyle ? (
+            /* App style: small title bar like compact, but keeps minimize/maximize for full window control. */
+            /* @__PURE__ */ jsxs(
+              "div",
+              {
+                onPointerDown: startDrag,
+                "data-window-chrome": "",
+                ...titleBarKeyProps,
+                className: `flex items-center justify-between px-3 py-1.5 border-b border-gray-200 shrink-0 cursor-move select-none rounded-t-2xl focus:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-blue-400 ${isActive ? "backdrop-blur-sm" : ""}`,
+                style: { touchAction: "none", backgroundColor: isActive ? `rgb(var(--window-header-rgb) / var(--active-header-opacity, 0.8))` : `rgb(var(--window-header-rgb) / var(--inactive-header-opacity, 0.7))` },
+                children: [
+                  /* @__PURE__ */ jsxs("div", { "data-window-title": true, title: titleTooltip, className: "text-sm font-medium min-w-0 flex-1 truncate flex items-center gap-1.5", style: { color: isActive ? "var(--window-title-active, rgb(17 24 39))" : "var(--window-title-inactive, rgb(156 163 175))" }, children: [
+                    !exposeActive && renderIconButton(),
+                    /* @__PURE__ */ jsx("span", { className: "truncate", children: exposeActive ? extractTitleText(displayTitle) : displayTitle })
+                  ] }),
+                  !exposeActive && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-0.5 shrink-0 ml-2", children: [
+                    allowPinOnTop && /* @__PURE__ */ jsx(
+                      "button",
+                      {
+                        onClick: () => setPinnedOnTop((p) => !p),
+                        title: pinnedOnTop ? winStr.unpin : winStr.pinOnTop,
+                        className: `p-0.5 rounded hover:bg-gray-200 ${pinnedOnTop ? "text-blue-600" : "text-gray-400 hover:text-gray-600"}`,
+                        children: /* @__PURE__ */ jsx("svg", { className: "h-3 w-3", fill: pinnedOnTop ? "currentColor" : "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M16.5 3.75V16.5L12 14.25 7.5 16.5V3.75m9 0H18A2.25 2.25 0 0120.25 6v12A2.25 2.25 0 0118 20.25H6A2.25 2.25 0 013.75 18V6A2.25 2.25 0 016 3.75h1.5m9 0h-9" }) })
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("button", { onClick: () => _minimizeModal(modalId), title: winStr.minimize, className: "text-gray-400 hover:text-gray-600 px-1 py-0.5 rounded hover:bg-gray-200 text-xs leading-none", children: "\u2500" }),
+                    !alwaysMaximized && /* @__PURE__ */ jsx(
+                      SnapLayoutsButton,
+                      {
+                        maximized,
+                        onToggleMax: () => {
+                          if (maximized) {
+                            setMaximized(false);
+                            setBox(calcWindowed());
+                          } else {
+                            reset();
+                          }
+                        },
+                        onSnap: applySnapZone,
+                        buttonClassName: "text-gray-400 hover:text-gray-600 px-1 py-0.5 rounded hover:bg-gray-200 text-xs leading-none",
+                        strings: winStr
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("button", { type: "button", onClick: guardedClose, className: "rounded p-0.5 text-gray-400 hover:text-gray-600 hover:bg-gray-200", children: /* @__PURE__ */ jsx(XMarkIcon, { className: "h-4 w-4" }) })
+                  ] })
+                ]
+              }
+            )
+          ) : /* @__PURE__ */ jsxs(
+            "div",
+            {
+              onPointerDown: startDrag,
+              "data-window-chrome": "",
+              ...titleBarKeyProps,
+              className: `flex items-center justify-between px-4 py-2.5 border-b border-gray-200 shrink-0 cursor-move select-none rounded-t-2xl focus:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-blue-400 ${isActive ? "backdrop-blur-sm" : ""}`,
+              style: { touchAction: "none", backgroundColor: isActive ? `rgb(var(--window-header-rgb) / var(--active-header-opacity, 0.8))` : `rgb(var(--window-header-rgb) / var(--inactive-header-opacity, 0.7))` },
+              children: [
+                /* @__PURE__ */ jsxs("div", { "data-window-title": true, title: titleTooltip, className: "text-base font-medium min-w-0 flex-1 truncate flex items-center gap-2", style: { color: isActive ? "var(--window-title-active, rgb(17 24 39))" : "var(--window-title-inactive, rgb(156 163 175))" }, children: [
+                  !exposeActive && renderIconButton(),
+                  /* @__PURE__ */ jsx("span", { className: "truncate", children: exposeActive ? extractTitleText(displayTitle) : displayTitle })
+                ] }),
+                !exposeActive && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5 shrink-0 ml-4", children: [
+                  hasNav && /* @__PURE__ */ jsxs("span", { className: "flex items-center gap-1 mr-1 text-[10px] text-gray-400", children: [
+                    /* @__PURE__ */ jsx("kbd", { className: "rounded border border-gray-300 bg-gray-200 px-1.5 py-0.5 font-medium text-gray-500", children: "K" }),
+                    /* @__PURE__ */ jsx("span", { children: winStr.prev }),
+                    /* @__PURE__ */ jsx("kbd", { className: "rounded border border-gray-300 bg-gray-200 px-1.5 py-0.5 font-medium ml-1 text-gray-500", children: "J" }),
+                    /* @__PURE__ */ jsx("span", { children: winStr.next })
+                  ] }),
+                  allowPinOnTop && /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      onClick: () => setPinnedOnTop((p) => !p),
+                      title: pinnedOnTop ? winStr.unpin : winStr.pinOnTop,
+                      className: `text-xs px-2 py-1 rounded hover:bg-gray-200 ${pinnedOnTop ? "text-blue-600" : "text-gray-400 hover:text-gray-600"}`,
+                      children: /* @__PURE__ */ jsx("svg", { className: "h-3.5 w-3.5", fill: pinnedOnTop ? "currentColor" : "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M16.5 3.75V16.5L12 14.25 7.5 16.5V3.75m9 0H18A2.25 2.25 0 0120.25 6v12A2.25 2.25 0 0118 20.25H6A2.25 2.25 0 013.75 18V6A2.25 2.25 0 016 3.75h1.5m9 0h-9" }) })
+                    }
+                  ),
+                  /* @__PURE__ */ jsx("button", { onClick: () => _minimizeModal(modalId), title: winStr.minimize, className: "text-gray-400 hover:text-gray-600 text-xs px-2 py-1 rounded hover:bg-gray-200", children: "\u2500" }),
+                  !alwaysMaximized && /* @__PURE__ */ jsx(
+                    SnapLayoutsButton,
+                    {
+                      maximized,
+                      onToggleMax: () => {
+                        if (maximized) {
+                          setMaximized(false);
+                          setBox(calcWindowed());
+                        } else {
+                          reset();
+                        }
+                      },
+                      onSnap: applySnapZone,
+                      buttonClassName: "text-gray-400 hover:text-gray-600 text-xs px-2 py-1 rounded hover:bg-gray-200",
+                      strings: winStr
+                    }
+                  ),
+                  /* @__PURE__ */ jsx("kbd", { className: "rounded border border-gray-300 bg-gray-200 px-1.5 py-0.5 text-[10px] font-medium text-gray-400", children: "ESC" }),
+                  /* @__PURE__ */ jsx("button", { type: "button", onClick: guardedClose, className: "rounded-md text-gray-400 hover:text-gray-600", children: /* @__PURE__ */ jsx(XMarkIcon, { className: "h-5 w-5" }) })
+                ] })
+              ]
+            }
+          ),
+          accentRgb && accentStripeOn && !widget && !isMobile && /* @__PURE__ */ jsx(
+            "div",
+            {
+              "aria-hidden": "true",
+              className: "h-[3px] shrink-0 pointer-events-none",
+              style: { backgroundColor: `rgb(var(--window-accent-rgb) / ${isActive ? 0.9 : 0.55})` }
+            }
+          ),
+          /* @__PURE__ */ jsx(ModalIdContext.Provider, { value: modalId, children: /* @__PURE__ */ jsx(ModalActionsContext.Provider, { value: { rightRef: actionsRef, leftRef: actionsLeftRef, notify: () => setHasActions(true), active: isActive, isDirty, footerOpen: hasFooterContent && !widget && !compact && !appStyle && !isMobile }, children: /* @__PURE__ */ jsx(
+            "div",
+            {
+              ref: bodyRef,
+              ...widget ? { onPointerDown: startDrag, onContextMenu: (e) => {
+                e.preventDefault();
+                setCtxMenu({ x: e.clientX, y: e.clientY });
+              } } : {},
+              className: `flex-1 min-h-0 flex flex-col ${widget ? "p-0 cursor-move" : appStyle ? "p-0" : flushBody ? "p-0" : compact ? "p-2" : "p-4"} ${widget ? "" : "backdrop-blur-sm"} ${bodyScroll === false || appStyle || flushBody ? "overflow-hidden" : "overflow-y-auto overscroll-contain"} ${widget ? "rounded-2xl select-none" : ""}`,
+              style: { ...widget ? { touchAction: "none" } : {}, backgroundColor: widget ? "transparent" : isActive ? `rgb(var(--window-content-rgb) / var(--active-content-opacity, 0.9))` : `rgb(var(--window-content-rgb) / var(--inactive-content-opacity, 0.8))` },
+              children: /* @__PURE__ */ jsx(WindowErrorBoundary, { children })
+            }
+          ) }) }),
+          widget && ctxMenu && /* @__PURE__ */ jsxs(PopupMenu, { minWidth: 160, style: { left: ctxMenu.x, top: ctxMenu.y }, onClose: () => setCtxMenu(null), children: [
+            /* @__PURE__ */ jsx(PopupMenuItem, { onClick: () => {
+              setCtxMenu(null);
+              window.dispatchEvent(new CustomEvent("widget-open-settings", { detail: modalId }));
+            }, children: "Settings" }),
+            /* @__PURE__ */ jsx(PopupMenuDivider, {}),
+            widgetMenu && /* @__PURE__ */ jsxs(Fragment, { children: [
+              widgetMenu,
+              /* @__PURE__ */ jsx(PopupMenuDivider, {})
+            ] }),
+            /* @__PURE__ */ jsxs(PopupMenuItem, { onClick: () => {
+              setCtxMenu(null);
+              setPinnedOnTop((p) => !p);
+            }, children: [
+              /* @__PURE__ */ jsx("span", { className: "flex-1", children: "Always on Top" }),
+              pinnedOnTop && /* @__PURE__ */ jsx("svg", { className: "h-4 w-4 text-blue-600 shrink-0", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 2, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M5 13l4 4L19 7" }) })
+            ] }),
+            /* @__PURE__ */ jsx(PopupMenuDivider, {}),
+            /* @__PURE__ */ jsx(PopupMenuItem, { onClick: () => {
+              setCtxMenu(null);
+              guardedClose();
+            }, children: "Close" })
+          ] }),
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              onPointerDown: startDrag,
+              ref: footerRef,
+              className: `px-4 py-2 border-t border-gray-200 shrink-0 flex items-center justify-between text-xs select-none cursor-move${isActive ? " backdrop-blur-sm" : ""}${widget || compact || appStyle || isMobile || !hasFooterContent ? " hidden" : ""}`,
+              style: { touchAction: "none", backgroundColor: isActive ? `rgb(var(--window-footer-rgb) / var(--active-header-opacity, 0.8))` : `rgb(var(--window-footer-rgb) / var(--inactive-header-opacity, 0.7))` },
+              children: [
+                /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 min-w-0", children: [
+                  showsUndo && /* @__PURE__ */ jsx(UndoControls, { auto: true }),
+                  actionsLeft,
+                  /* @__PURE__ */ jsx("div", { ref: actionsLeftRef, "data-modal-actions-left": true, className: "flex items-center gap-2" }),
+                  footer
+                ] }),
+                /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 ml-auto", children: [
+                  /* @__PURE__ */ jsx("div", { ref: actionsRef, "data-modal-actions": true, className: "flex items-center gap-2" }),
+                  actions
+                ] })
+              ]
+            }
+          ),
+          !widget && !isMobile && !exposeActive && isActive && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx("div", { onPointerDown: (e) => startResizeCorner(e, "se"), className: "absolute bottom-0 right-0 w-3 h-3 cursor-nwse-resize z-10" }),
+            /* @__PURE__ */ jsx("div", { onPointerDown: (e) => startResizeCorner(e, "sw"), className: "absolute bottom-0 left-0 w-3 h-3 cursor-nesw-resize z-10" }),
+            /* @__PURE__ */ jsx("div", { onPointerDown: (e) => startResizeCorner(e, "ne"), className: "absolute top-0 right-0 w-3 h-3 cursor-nesw-resize z-10" }),
+            /* @__PURE__ */ jsx("div", { onPointerDown: (e) => startResizeCorner(e, "nw"), className: "absolute top-0 left-0 w-3 h-3 cursor-nwse-resize z-10" }),
+            /* @__PURE__ */ jsx("div", { onPointerDown: (e) => startResizeCorner(e, "n"), className: "absolute top-0 left-3 right-3 h-1 cursor-ns-resize" }),
+            /* @__PURE__ */ jsx("div", { onPointerDown: (e) => startResizeCorner(e, "s"), className: "absolute bottom-0 left-3 right-3 h-1 cursor-ns-resize" }),
+            /* @__PURE__ */ jsx("div", { onPointerDown: (e) => startResizeCorner(e, "e"), className: "absolute top-3 bottom-3 right-0 w-1 cursor-ew-resize" }),
+            /* @__PURE__ */ jsx("div", { onPointerDown: (e) => startResizeCorner(e, "w"), className: "absolute top-3 bottom-3 left-0 w-1 cursor-ew-resize" })
+          ] }),
+          exposeActive && /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "absolute inset-0",
+              style: { zIndex: 9999, cursor: "pointer", background: "transparent" },
+              onMouseEnter: () => setExposeHovered(true),
+              onMouseLeave: () => setExposeHovered(false),
+              onMouseDown: (e) => {
+                e.stopPropagation();
+                e.preventDefault();
+                activateModal(modalId);
+                setExposeState(false);
+              },
+              onClick: (e) => {
+                e.stopPropagation();
+                e.preventDefault();
+              },
+              children: exposeHovered && /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  "data-expose-close": true,
+                  "aria-label": shellStrings.taskbar.closeWindow,
+                  title: "Close",
+                  className: "absolute flex items-center justify-center rounded-full bg-black/55 text-white shadow-lg ring-1 ring-white/40 transition-colors hover:bg-red-500",
+                  style: {
+                    top: 8,
+                    right: 8,
+                    width: 30,
+                    height: 30,
+                    transform: `scale(${1 / exposeScale})`,
+                    transformOrigin: "top right",
+                    zIndex: 1e4
+                  },
+                  onMouseDown: (e) => {
+                    e.stopPropagation();
+                    e.preventDefault();
+                  },
+                  onClick: (e) => {
+                    e.stopPropagation();
+                    e.preventDefault();
+                    guardedClose();
+                  },
+                  children: /* @__PURE__ */ jsx("svg", { className: "h-4 w-4", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 2.2, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M6 18L18 6M6 6l12 12" }) })
+                }
+              )
+            }
+          )
+        ]
+      }
+    ),
+    exposeActive && exposeTile && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "fixed pointer-events-none select-none truncate text-center",
+        style: {
+          left: exposeTile.x,
+          top: exposeTile.y + exposeTile.h + 4,
+          width: exposeTile.w,
+          zIndex: exposeHovered ? 2021 : 2011,
+          color: "white",
+          fontSize: 12,
+          fontWeight: 500,
+          textShadow: "0 1px 2px rgba(0,0,0,0.6)"
+        },
+        children: extractTitleText(displayTitle)
+      }
+    )
+  ] });
+  const windowMenuEl = windowMenu && /* @__PURE__ */ jsxs(PopupMenu, { style: { left: windowMenu.x, top: windowMenu.y }, onClose: () => setWindowMenu(null), minWidth: 160, children: [
+    !widget && !compact && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(PopupMenuItem, { onClick: () => {
+        _minimizeModal(modalId);
+        setWindowMenu(null);
+      }, children: [
+        /* @__PURE__ */ jsx("svg", { className: "h-4 w-4 text-gray-400", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M19.5 12h-15" }) }),
+        winStr.minimize
+      ] }),
+      !alwaysMaximized && (maximized ? /* @__PURE__ */ jsxs(PopupMenuItem, { onClick: () => {
+        setMaximized(false);
+        setBox(calcWindowed());
+        setWindowMenu(null);
+      }, children: [
+        /* @__PURE__ */ jsx("svg", { className: "h-4 w-4 text-gray-400", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M9 4.5v15m6-15v15M4.5 9h15M4.5 15h15" }) }),
+        winStr.windowed
+      ] }) : /* @__PURE__ */ jsxs(PopupMenuItem, { onClick: () => {
+        reset();
+        setWindowMenu(null);
+      }, children: [
+        /* @__PURE__ */ jsx("svg", { className: "h-4 w-4 text-gray-400", fill: "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M3.75 3.75v4.5m0-4.5h4.5m-4.5 0L9 9M3.75 20.25v-4.5m0 4.5h4.5m-4.5 0L9 15M20.25 3.75h-4.5m4.5 0v4.5m0-4.5L15 9m5.25 11.25h-4.5m4.5 0v-4.5m0 4.5L15 15" }) }),
+        winStr.maximize
+      ] }))
+    ] }),
+    allowPinOnTop && /* @__PURE__ */ jsxs(PopupMenuItem, { onClick: () => {
+      setPinnedOnTop((p) => !p);
+      setWindowMenu(null);
+    }, children: [
+      /* @__PURE__ */ jsx("svg", { className: `h-4 w-4 ${pinnedOnTop ? "text-blue-600" : "text-gray-400"}`, fill: pinnedOnTop ? "currentColor" : "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M16.5 3.75V16.5L12 14.25 7.5 16.5V3.75m9 0H18A2.25 2.25 0 0120.25 6v12A2.25 2.25 0 0118 20.25H6A2.25 2.25 0 013.75 18V6A2.25 2.25 0 016 3.75h1.5m9 0h-9" }) }),
+      pinnedOnTop ? winStr.unpin : winStr.pinOnTop
+    ] }),
+    shortcutSpec && /* @__PURE__ */ jsxs(PopupMenuItem, { onClick: () => {
+      setWindowMenu(null);
+      toggleDesktopShortcut();
+    }, children: [
+      /* @__PURE__ */ jsx("svg", { className: `h-4 w-4 ${isOnDesktop ? "text-yellow-500" : "text-gray-400"}`, fill: isOnDesktop ? "currentColor" : "none", viewBox: "0 0 24 24", stroke: "currentColor", strokeWidth: 1.5, children: /* @__PURE__ */ jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M11.48 3.499a.562.562 0 011.04 0l2.125 5.111a.563.563 0 00.475.345l5.518.442c.499.04.701.663.321.988l-4.204 3.602a.563.563 0 00-.182.557l1.285 5.385a.562.562 0 01-.84.61l-4.725-2.885a.563.563 0 00-.586 0L6.982 20.54a.562.562 0 01-.84-.61l1.285-5.386a.562.562 0 00-.182-.557l-4.204-3.602a.563.563 0 01.321-.988l5.518-.442a.563.563 0 00.475-.345L11.48 3.5z" }) }),
+      isOnDesktop ? shellStrings.taskbar.removeFromDesktop : shellStrings.taskbar.addToDesktop
+    ] }),
+    (_extraMenuItems[modalId] || []).length > 0 && /* @__PURE__ */ jsx(Fragment, { children: (_extraMenuItems[modalId] || []).map((item, i) => /* @__PURE__ */ jsxs(PopupMenuItem, { onClick: () => {
+      setWindowMenu(null);
+      item.onClick();
+    }, children: [
+      item.icon,
+      item.label
+    ] }, i)) }),
+    /* @__PURE__ */ jsx(PopupMenuDivider, {}),
+    /* @__PURE__ */ jsxs(PopupMenuItem, { danger: true, onClick: () => {
+      setWindowMenu(null);
+      guardedClose();
+    }, children: [
+      /* @__PURE__ */ jsx(XMarkIcon, { className: "h-4 w-4" }),
+      winStr.close
+    ] })
+  ] });
+  const listedInTaskbar = !!windowKey && openWindows.some((w) => w.id === windowKey);
+  const restoreTab = isMinimized && !listedInTaskbar && !widget ? /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-modal-restore-tab": true,
+      "data-modal-id": modalId,
+      className: "fixed left-1/2 z-[1200] flex -translate-x-1/2 items-center gap-1 rounded-lg border border-gray-300 bg-white px-1.5 py-1 shadow-lg",
+      style: { bottom: "calc(var(--taskbar-height, 0px) + 12px)" },
+      children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => activateModal(modalId),
+            title: winStr.restore,
+            className: "max-w-[16rem] truncate rounded px-2 py-0.5 text-sm font-medium text-gray-700 hover:bg-gray-100 hover:text-gray-900",
+            children: titleTooltip || winStr.windowSuffix
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => activateModal(modalId),
+            title: winStr.restore,
+            "aria-label": winStr.restore,
+            className: "rounded px-1.5 py-0.5 text-xs leading-none text-gray-400 hover:bg-gray-100 hover:text-gray-600",
+            children: "\u25B4"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => {
+              void guardedClose();
+            },
+            title: winStr.close,
+            "aria-label": winStr.close,
+            className: "rounded px-1.5 py-0.5 text-xs leading-none text-gray-400 hover:bg-gray-100 hover:text-gray-600",
+            children: "\u2715"
+          }
+        )
+      ]
+    }
+  ) : null;
+  return createPortal(
+    /* @__PURE__ */ jsxs(WindowShortcutContext.Provider, { value: null, children: [
+      content,
+      windowMenuEl,
+      restoreTab
+    ] }),
+    document.body
+  );
+}
+
+// src/hooks/undoHistory.ts
+var UNDO_LIMIT = 100;
+var emptyUndoState = { past: [], future: [] };
+function undoReducer(state, action) {
+  switch (action.type) {
+    case "record": {
+      const newest = state.past[state.past.length - 1];
+      if (action.step.coalesceKey !== null && newest?.coalesceKey === action.step.coalesceKey) {
+        return state.future.length === 0 ? state : { ...state, future: [] };
+      }
+      const past = [...state.past, action.step];
+      return {
+        past: past.length > UNDO_LIMIT ? past.slice(past.length - UNDO_LIMIT) : past,
+        future: []
+      };
+    }
+    case "undo": {
+      if (state.past.length === 0) return state;
+      return {
+        past: state.past.slice(0, -1),
+        future: [action.redoStep, ...state.future]
+      };
+    }
+    case "redo": {
+      if (state.future.length === 0) return state;
+      return {
+        past: [...state.past, action.undoStep],
+        future: state.future.slice(1)
+      };
+    }
+    case "clear":
+      return state.past.length === 0 && state.future.length === 0 ? state : emptyUndoState;
+  }
+}
+var TEXT_ENTRY = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
+function matchUndoHotkey(e) {
+  if (!(e.metaKey || e.ctrlKey) || e.altKey) return null;
+  const key = e.key.toLowerCase();
+  const action = key === "z" ? e.shiftKey ? "redo" : "undo" : key === "y" && e.ctrlKey && !e.metaKey && !e.shiftKey ? "redo" : null;
+  if (!action) return null;
+  const target = e.target;
+  if (target?.isContentEditable) return null;
+  if (target?.tagName && TEXT_ENTRY.has(target.tagName.toUpperCase())) return null;
+  return action;
+}
+function sameValue(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
+var RUNAWAY_LIMIT = 500;
+var RUNAWAY_QUIET_MS = 250;
+function UndoProvider({ children, canEdit = true, perms, windowId }) {
+  const [state, dispatch] = useReducer(undoReducer, emptyUndoState);
+  const slices = useRef(/* @__PURE__ */ new Map());
+  const [sliceCount, setSliceCount] = useState(0);
+  const hasState = sliceCount > 0;
+  const [readOnlyClaims, setReadOnlyClaims] = useState(0);
+  const [editClaims, setEditClaims] = useState(0);
+  const declaredEditable = editClaims > 0;
+  const { hasAnyPerm } = useShellAuth();
+  const enabled = canEdit && readOnlyClaims === 0 && (perms && perms.length > 0 ? hasAnyPerm(perms) : true);
+  const pending = useRef(null);
+  const suspended = useRef(false);
+  const snapshot = useCallback(() => {
+    const values = {};
+    for (const [id, slice] of slices.current) values[id] = slice.getLast();
+    return values;
+  }, []);
+  const register = useCallback((id, slice) => {
+    if (!slices.current.has(id)) setSliceCount((c) => c + 1);
+    slices.current.set(id, slice);
+  }, []);
+  const unregister = useCallback((id) => {
+    if (slices.current.delete(id)) setSliceCount((c) => c - 1);
+  }, []);
+  const claimReadOnly = useCallback((on) => {
+    setReadOnlyClaims((c) => c + (on ? 1 : -1));
+  }, []);
+  const claimEditable = useCallback((on) => {
+    setEditClaims((c) => c + (on ? 1 : -1));
+  }, []);
+  const [ownMountClaims, setOwnMountClaims] = useState(0);
+  const handMounted = ownMountClaims > 0;
+  const claimOwnMount = useCallback((on) => {
+    setOwnMountClaims((c) => c + (on ? 1 : -1));
+  }, []);
+  const parent = useContext(UndoContext);
+  const parentClaimReadOnly = parent?.claimReadOnly;
+  useEffect(() => {
+    if (!parentClaimReadOnly || enabled) return;
+    parentClaimReadOnly(true);
+    return () => parentClaimReadOnly(false);
+  }, [parentClaimReadOnly, enabled]);
+  const parentClaimOwnMount = parent?.claimOwnMount;
+  useEffect(() => {
+    if (!parentClaimOwnMount || !handMounted) return;
+    parentClaimOwnMount(true);
+    return () => parentClaimOwnMount(false);
+  }, [parentClaimOwnMount, handMounted]);
+  const runaway = useRef({ last: 0, count: 0, tripped: false });
+  const seeded = useRef(false);
+  const record = useCallback((label, coalesceKey, change) => {
+    if (suspended.current) {
+      if (!change || !sameValue(change.prev, change.next)) seeded.current = true;
+      return;
+    }
+    if (!enabled || pending.current) return;
+    const r = runaway.current;
+    if (r.tripped) return;
+    const now = Date.now();
+    if (now - r.last > RUNAWAY_QUIET_MS) r.count = 0;
+    r.last = now;
+    if (++r.count > RUNAWAY_LIMIT) {
+      r.tripped = true;
+      console.error(
+        `[react-os-shell] UndoProvider: "${label}" recorded ${RUNAWAY_LIMIT} undo steps with no pause between them, which no user action can do. The value passed to useUndoable for this slice is almost certainly rebuilt on every render (a .map/.filter/object literal in the call) rather than held in state, so it reads as changed every time \u2014 and since recording a step re-renders the form, that is a loop. Undo recording is now off for this form to keep the tab responsive.`
+      );
+      return;
+    }
+    pending.current = { values: snapshot(), label, coalesceKey };
+    queueMicrotask(() => {
+      const step = pending.current;
+      pending.current = null;
+      if (step) dispatch({ type: "record", step });
+    });
+  }, [enabled, snapshot]);
+  const applyValues = useCallback((values) => {
+    for (const [id, value2] of Object.entries(values)) {
+      const slice = slices.current.get(id);
+      if (!slice) continue;
+      slice.setLast(value2);
+      slice.apply(value2);
+    }
+  }, []);
+  const undo = useCallback(() => {
+    const step = state.past[state.past.length - 1];
+    if (!step) return;
+    const redoStep = { values: snapshot(), label: step.label, coalesceKey: null };
+    applyValues(step.values);
+    dispatch({ type: "undo", redoStep });
+  }, [state.past, snapshot, applyValues]);
+  const redo = useCallback(() => {
+    const step = state.future[0];
+    if (!step) return;
+    const undoStep = { values: snapshot(), label: step.label, coalesceKey: null };
+    applyValues(step.values);
+    dispatch({ type: "redo", undoStep });
+  }, [state.future, snapshot, applyValues]);
+  const [baselineToken, setBaselineToken] = useState(0);
+  const tokenCounter = useRef(0);
+  const suspendUntil = useRef(0);
+  const forceClear = useRef(false);
+  const suspend = useCallback(() => {
+    suspended.current = true;
+    seeded.current = false;
+    pending.current = null;
+    tokenCounter.current += 1;
+    suspendUntil.current = tokenCounter.current;
+    setBaselineToken(tokenCounter.current);
+  }, []);
+  const baselineKey = useRef(void 0);
+  const baseline = useCallback((key) => {
+    if (key !== void 0) {
+      if (baselineKey.current !== void 0 && key !== baselineKey.current) forceClear.current = true;
+      baselineKey.current = key;
+    }
+    suspend();
+  }, [suspend]);
+  useEffect(() => {
+    if (!suspended.current || baselineToken !== suspendUntil.current) return;
+    suspended.current = false;
+    pending.current = null;
+    if (seeded.current || forceClear.current) dispatch({ type: "clear" });
+    seeded.current = false;
+    forceClear.current = false;
+  }, [baselineToken]);
+  const clear = useCallback(() => {
+    forceClear.current = true;
+    dispatch({ type: "clear" });
+    suspend();
+  }, [suspend]);
+  const canUndo = enabled && state.past.length > 0;
+  const canRedo = enabled && state.future.length > 0;
+  const isActive = useIsActiveWindow(windowId);
+  const keyed = useRef({ undo, redo, canUndo, canRedo });
+  keyed.current = { undo, redo, canUndo, canRedo };
+  useEffect(() => {
+    if (!isActive || !enabled) return;
+    const handler = (e) => {
+      const action = matchUndoHotkey(e);
+      if (!action) return;
+      const k = keyed.current;
+      if (action === "undo" ? !k.canUndo : !k.canRedo) return;
+      e.preventDefault();
+      if (action === "undo") k.undo();
+      else k.redo();
+    };
+    window.addEventListener("keydown", handler);
+    return () => window.removeEventListener("keydown", handler);
+  }, [isActive, enabled]);
+  const value = useMemo(() => ({
+    register,
+    unregister,
+    record,
+    undo,
+    redo,
+    clear,
+    baseline,
+    canUndo,
+    canRedo,
+    enabled,
+    hasState,
+    handMounted,
+    claimOwnMount,
+    claimReadOnly,
+    declaredEditable,
+    claimEditable,
+    undoLabel: canUndo ? state.past[state.past.length - 1].label : null,
+    redoLabel: canRedo ? state.future[0].label : null
+  }), [
+    register,
+    unregister,
+    record,
+    undo,
+    redo,
+    clear,
+    baseline,
+    canUndo,
+    canRedo,
+    enabled,
+    hasState,
+    handMounted,
+    claimOwnMount,
+    claimReadOnly,
+    declaredEditable,
+    claimEditable,
+    state.past,
+    state.future
+  ]);
+  const insideModal = useEnclosingModalId() !== "";
+  const footerOpen = useModalFooterOpen();
+  const showsOwnControls = insideModal && enabled && hasState && !handMounted && footerOpen;
+  return /* @__PURE__ */ jsxs(UndoContext.Provider, { value, children: [
+    showsOwnControls && /* @__PURE__ */ jsx(ModalActions, { position: "left", quiet: true, children: /* @__PURE__ */ jsx(UndoControls, { auto: true }) }),
+    children
+  ] });
+}
+function useUndo() {
+  const ctx = useContext(UndoContext);
+  const noop = useCallback(() => {
+  }, []);
+  return {
+    undo: ctx?.undo ?? noop,
+    redo: ctx?.redo ?? noop,
+    clear: ctx?.clear ?? noop,
+    baseline: ctx?.baseline ?? noop,
+    canUndo: ctx?.canUndo ?? false,
+    canRedo: ctx?.canRedo ?? false,
+    undoLabel: ctx?.undoLabel ?? null,
+    redoLabel: ctx?.redoLabel ?? null,
+    enabled: ctx?.enabled ?? false,
+    hasState: ctx?.hasState ?? false
+  };
+}
+function useUndoCanEdit(canEdit) {
+  const ctx = useContext(UndoContext);
+  const claimReadOnly = ctx?.claimReadOnly;
+  const claimEditable = ctx?.claimEditable;
+  useEffect(() => {
+    const claim = canEdit ? claimEditable : claimReadOnly;
+    if (!claim) return;
+    claim(true);
+    return () => claim(false);
+  }, [claimReadOnly, claimEditable, canEdit]);
+}
+function useUndoable(value, apply, opts) {
+  const ctx = useContext(UndoContext);
+  const id = useId();
+  const last = useRef(value);
+  const applyRef = useRef(apply);
+  applyRef.current = apply;
+  useEffect(() => {
+    if (!ctx) return;
+    ctx.register(id, {
+      getLast: () => last.current,
+      setLast: (v) => {
+        last.current = v;
+      },
+      apply: (v) => applyRef.current(v)
+    });
+    return () => ctx.unregister(id);
+  }, [ctx, id]);
+  const { label, coalesceKey = null } = opts;
+  const ctxRef = useRef(ctx);
+  ctxRef.current = ctx;
+  const optsRef = useRef({ label, coalesceKey });
+  optsRef.current = { label, coalesceKey };
+  useEffect(() => {
+    const c = ctxRef.current;
+    if (!c) return;
+    if (Object.is(value, last.current)) return;
+    c.record(optsRef.current.label, optsRef.current.coalesceKey, { prev: last.current, next: value });
+    last.current = value;
+  }, [value]);
+}
+function useUndoableState(initial, opts) {
+  const [value, setValue] = useState(initial);
+  useUndoable(value, (next) => setValue(() => next), opts);
+  return [value, setValue];
+}
+
+export { CancelButton, CopyButton, DocFavStar, EntityWindowFallback, EntityWindowLoading, EntityWindowState, LoadingSpinner2 as LoadingSpinner, MODAL_SUBMIT_SELECTOR, Modal, ModalActions, SIDEBAR_STRIP_W, UndoControls, UndoProvider, WINDOW_REGISTRY, WindowCrashedFallback, WindowErrorBoundary, WindowManagerProvider, WindowTitle, beginWindowGesture, cancelWindowFront, client_default, commitExposeHighlight, drainPerfEvents, exitExposeMode, forgetMaximizedWindowBoxes, getActiveModalId, getActiveWindowRoute, getExposeHighlight, getWindowPosition, isDraftEntityId, isDraftEntityWindow, isEntityEntry, isPageEntry, isShellApiClientConfigured, markMenuOpen, requestWindowFront, setExposeHighlight, setPerfCollecting, setShellApiClient, setShellWindowRegistry, setWindowDefaultPosition, setWindowPosition, subscribeExposeHighlight, toggleExposeMode, useEnclosingModalId, useIsActiveWindow, useModalActive, useUndo, useUndoCanEdit, useUndoable, useUndoableState, useWidgetSettings, useWindowDirty, useWindowManager, useWindowMenuItem, useWindowTitle };
+//# sourceMappingURL=chunk-W6XTG23K.js.map
+//# sourceMappingURL=chunk-W6XTG23K.js.map