@ai-matrx/summon 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2383 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_INSTANCE_ID: () => DEFAULT_INSTANCE_ID,
+  DEFAULT_PORTS: () => DEFAULT_PORTS,
+  LAZY_WINDOW_MOUNT_DEADLINE_MS: () => LAZY_WINDOW_MOUNT_DEADLINE_MS,
+  RENDER_WATCHDOG_SLOT: () => RENDER_WATCHDOG_SLOT,
+  TRAY_CHIP_H: () => TRAY_CHIP_H,
+  TRAY_CHIP_H_DESKTOP: () => TRAY_CHIP_H_DESKTOP,
+  TRAY_CHIP_H_MOBILE: () => TRAY_CHIP_H_MOBILE,
+  TRAY_CHIP_W: () => TRAY_CHIP_W,
+  TRAY_CHIP_W_DESKTOP: () => TRAY_CHIP_W_DESKTOP,
+  TRAY_CHIP_W_MOBILE_MAX: () => TRAY_CHIP_W_MOBILE_MAX,
+  TRAY_COMPACT_GAP: () => TRAY_COMPACT_GAP,
+  TRAY_COMPACT_H: () => TRAY_COMPACT_H,
+  TRAY_GAP_X: () => TRAY_GAP_X,
+  TRAY_GAP_Y: () => TRAY_GAP_Y,
+  TRAY_MARGIN_B: () => TRAY_MARGIN_B,
+  TRAY_MARGIN_L: () => TRAY_MARGIN_L,
+  TRAY_MARGIN_R: () => TRAY_MARGIN_R,
+  TRAY_MOBILE_BREAKPOINT: () => TRAY_MOBILE_BREAKPOINT,
+  WINDOW_SESSION_SCHEMA_VERSION: () => WINDOW_SESSION_SCHEMA_VERSION,
+  ackOverlayRender: () => ackOverlayRender,
+  ackOverlaySurfaceRender: () => ackOverlaySurfaceRender,
+  allOverlayMeta: () => allOverlayMeta,
+  anonymousIdentity: () => anonymousIdentity,
+  arrangeActiveWindows: () => arrangeActiveWindows,
+  buildDockWindowPayload: () => buildDockWindowPayload,
+  centerRectInViewport: () => centerRectInViewport,
+  clampAllWindowRects: () => clampAllWindowRects,
+  clampRectToCurrentViewport: () => clampRectToCurrentViewport,
+  clampRectToViewport: () => clampRectToViewport,
+  clampWindowRect: () => clampWindowRect,
+  clearOverlayRender: () => clearOverlayRender,
+  clearOverlayState: () => clearOverlayState,
+  clearOverlaySurfaceRender: () => clearOverlaySurfaceRender,
+  clearWindowPersistenceState: () => clearWindowPersistenceState,
+  closeAllInstancesOfOverlay: () => closeAllInstancesOfOverlay,
+  closeAllOverlays: () => closeAllOverlays,
+  closeLifecycleMiddleware: () => closeLifecycleMiddleware,
+  closeOverlay: () => closeOverlay,
+  closeOverlaysBoundToPage: () => closeOverlaysBoundToPage,
+  computeGlobalArrangement: () => computeGlobalArrangement,
+  computeTrayChipHeight: () => computeTrayChipHeight,
+  computeTrayChipWidth: () => computeTrayChipWidth,
+  confirmWindowRestored: () => confirmWindowRestored,
+  consoleErrorSink: () => consoleErrorSink,
+  consoleNotify: () => consoleNotify,
+  createOverlayRenderWatchdogMiddleware: () => createOverlayRenderWatchdogMiddleware,
+  createSummonMiddleware: () => createSummonMiddleware,
+  createSummonStore: () => createSummonStore,
+  debugOff: () => debugOff,
+  defaultWindowIdFor: () => defaultWindowIdFor,
+  diagnoseOverlayRender: () => diagnoseOverlayRender,
+  discardPendingWindowSession: () => discardPendingWindowSession,
+  dockWindow: () => dockWindow,
+  focusWindow: () => focusWindow,
+  getGrid12Rect: () => getGrid12Rect,
+  getGrid4Rect: () => getGrid4Rect,
+  getGrid6Rect: () => getGrid6Rect,
+  getGrid8Rect: () => getGrid8Rect,
+  getGrid9Rect: () => getGrid9Rect,
+  getOverlayMeta: () => getOverlayMeta,
+  getOverlayMetaByLinkKey: () => getOverlayMetaByLinkKey,
+  getStackedLeft2Rect: () => getStackedLeft2Rect,
+  getStackedLeft3Rect: () => getStackedLeft3Rect,
+  getStackedLeft4Rect: () => getStackedLeft4Rect,
+  getStackedLeft5Rect: () => getStackedLeft5Rect,
+  getStackedRight2Rect: () => getStackedRight2Rect,
+  getStackedRight3Rect: () => getStackedRight3Rect,
+  getStackedRight4Rect: () => getStackedRight4Rect,
+  getStackedRight5Rect: () => getStackedRight5Rect,
+  hydrateOverlayState: () => hydrateOverlayState,
+  hydrateWindowSessions: () => hydrateWindowSessions,
+  instanceKey: () => instanceKey,
+  isRegisteredOverlay: () => isRegisteredOverlay,
+  linksReducer: () => linksReducer,
+  listOpenInstanceKeys: () => listOpenInstanceKeys,
+  locationRouter: () => locationRouter,
+  markWindowClosing: () => markWindowClosing,
+  maximizeWindow: () => maximizeWindow,
+  minimizeAll: () => minimizeAll,
+  minimizeWindow: () => minimizeWindow,
+  moveTraySlot: () => moveTraySlot,
+  openOverlay: () => openOverlay,
+  overlayIdsBoundToPage: () => overlayIdsBoundToPage,
+  overlayStateReducer: () => overlayStateReducer,
+  overlaysRawActions: () => overlaysRawActions,
+  overlaysReducer: () => overlaysReducer,
+  parseInstanceKey: () => parseInstanceKey,
+  popOutWindow: () => popOutWindow,
+  pruneStaleInstances: () => pruneStaleInstances,
+  raiseTransientWindow: () => raiseTransientWindow,
+  recomputeTrayPositions: () => recomputeTrayPositions,
+  rectOnScreen: () => rectOnScreen,
+  rectsEqual: () => rectsEqual,
+  registerCloseFlusher: () => registerCloseFlusher,
+  registerOverlayMeta: () => registerOverlayMeta,
+  registerSyncEntry: () => registerSyncEntry,
+  registerWindow: () => registerWindow,
+  releaseOverlayInstance: () => releaseOverlayInstance,
+  releaseTransientWindow: () => releaseTransientWindow,
+  replaceOverlayState: () => replaceOverlayState,
+  resetOverlayRegistry: () => resetOverlayRegistry,
+  resetOverlayRenderWatchdog: () => resetOverlayRenderWatchdog,
+  resolvePorts: () => resolvePorts,
+  restoreAll: () => restoreAll,
+  restoreWindow: () => restoreWindow,
+  restoreWindowState: () => restoreWindowState,
+  revealWindow: () => revealWindow,
+  safeViewportDims: () => safeViewportDims,
+  selectActivePipWindowId: () => selectActivePipWindowId,
+  selectAllMinimized: () => selectAllMinimized,
+  selectAllWindows: () => selectAllWindows,
+  selectDockedWindows: () => selectDockedWindows,
+  selectIsOverlayOpen: () => selectIsOverlayOpen,
+  selectIsPoppedOut: () => selectIsPoppedOut,
+  selectIsUrlHydrated: () => selectIsUrlHydrated,
+  selectOpenInstances: () => selectOpenInstances,
+  selectOverlay: () => selectOverlay,
+  selectOverlayData: () => selectOverlayData,
+  selectOverlayStateFor: () => selectOverlayStateFor,
+  selectOverlayStateValue: () => selectOverlayStateValue,
+  selectPendingWindowRestores: () => selectPendingWindowRestores,
+  selectPopoutCandidateId: () => selectPopoutCandidateId,
+  selectPopoutMode: () => selectPopoutMode,
+  selectPrePopoutRect: () => selectPrePopoutRect,
+  selectTransientZIndex: () => selectTransientZIndex,
+  selectTraySlotWidth: () => selectTraySlotWidth,
+  selectTrayWindows: () => selectTrayWindows,
+  selectUrlSyncEntries: () => selectUrlSyncEntries,
+  selectWindow: () => selectWindow,
+  selectWindowPersistence: () => selectWindowPersistence,
+  selectWindowRect: () => selectWindowRect,
+  selectWindowState: () => selectWindowState,
+  selectWindowTitle: () => selectWindowTitle,
+  selectWindowZIndex: () => selectWindowZIndex,
+  selectWindowsHidden: () => selectWindowsHidden,
+  setHydrated: () => setHydrated,
+  setOverlayStateValue: () => setOverlayStateValue,
+  setPopoutCandidate: () => setPopoutCandidate,
+  subscribeToOverlayRegistry: () => subscribeToOverlayRegistry,
+  summonReducers: () => summonReducers,
+  toggleOverlay: () => toggleOverlay,
+  toggleWindowsHidden: () => toggleWindowsHidden,
+  trayChipsPerRow: () => trayChipsPerRow,
+  traySlotRect: () => traySlotRect,
+  unregisterSyncEntry: () => unregisterSyncEntry,
+  unregisterWindow: () => unregisterWindow,
+  updateWindowPersistence: () => updateWindowPersistence,
+  updateWindowRect: () => updateWindowRect,
+  updateWindowTitle: () => updateWindowTitle,
+  watchdogTracksOpen: () => watchdogTracksOpen,
+  windowManagerReducer: () => windowManagerReducer,
+  windowSessionKey: () => windowSessionKey
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/types.ts
+var DEFAULT_INSTANCE_ID = "default";
+function instanceKey(overlayId, instanceId = DEFAULT_INSTANCE_ID) {
+  return `${overlayId}:${instanceId}`;
+}
+function parseInstanceKey(key) {
+  const at = key.indexOf(":");
+  if (at <= 0 || at === key.length - 1) return null;
+  return { overlayId: key.slice(0, at), instanceId: key.slice(at + 1) };
+}
+function defaultWindowIdFor(meta) {
+  return meta.window?.windowId ?? meta.id;
+}
+
+// src/core/ports.ts
+var noop = () => {
+};
+var anonymousIdentity = {
+  current: () => ({ key: "anonymous", ready: true }),
+  subscribe: () => noop
+};
+var locationRouter = {
+  pathname: () => typeof window === "undefined" ? "/" : window.location.pathname,
+  search: () => typeof window === "undefined" ? "" : window.location.search,
+  replaceSearch: (nextSearch) => {
+    if (typeof window === "undefined") return;
+    const query = nextSearch && !nextSearch.startsWith("?") ? `?${nextSearch}` : nextSearch;
+    const url = `${window.location.pathname}${query}${window.location.hash}`;
+    window.history.replaceState(window.history.state, "", url);
+  },
+  subscribe: (listener) => {
+    if (typeof window === "undefined") return noop;
+    window.addEventListener("popstate", listener);
+    return () => window.removeEventListener("popstate", listener);
+  }
+};
+var consoleNotify = {
+  info: (message) => console.info(`[summon] ${message}`),
+  warn: (message) => console.warn(`[summon] ${message}`),
+  error: (message) => console.error(`[summon] ${message}`)
+};
+var consoleErrorSink = {
+  capture: (error, context) => console.error("[summon]", error, context)
+};
+var debugOff = { enabled: () => false };
+var DEFAULT_PORTS = {
+  identity: anonymousIdentity,
+  router: locationRouter,
+  notify: consoleNotify,
+  errors: consoleErrorSink,
+  debug: debugOff,
+  persistence: null
+};
+function resolvePorts(overrides) {
+  return { ...DEFAULT_PORTS, ...overrides };
+}
+
+// src/core/registry.ts
+var import_global_slot = require("@ai-matrx/kit/global-slot");
+var state = () => (0, import_global_slot.globalSlot)("ai-matrx.summon.registry", () => ({
+  byId: /* @__PURE__ */ new Map(),
+  byLinkKey: /* @__PURE__ */ new Map(),
+  listeners: /* @__PURE__ */ new Set()
+}));
+function registerOverlayMeta(definitions) {
+  const s = state();
+  for (const def of definitions) {
+    s.byId.set(def.id, def);
+    const keys = def.link ? [def.link.key, ...def.link.aliases ?? []] : [];
+    for (const key of keys) {
+      const holder = s.byLinkKey.get(key);
+      if (holder && holder.id !== def.id) {
+        throw new Error(`[summon] link key "${key}" is claimed by both "${holder.id}" and "${def.id}"`);
+      }
+      s.byLinkKey.set(key, def);
+    }
+  }
+  for (const listener of s.listeners) listener();
+}
+function getOverlayMeta(overlayId) {
+  return state().byId.get(overlayId);
+}
+function getOverlayMetaByLinkKey(linkKey) {
+  return state().byLinkKey.get(linkKey);
+}
+function allOverlayMeta() {
+  return [...state().byId.values()];
+}
+function isRegisteredOverlay(overlayId) {
+  return state().byId.has(overlayId);
+}
+function subscribeToOverlayRegistry(listener) {
+  const s = state();
+  s.listeners.add(listener);
+  return () => s.listeners.delete(listener);
+}
+function resetOverlayRegistry() {
+  const s = state();
+  s.byId.clear();
+  s.byLinkKey.clear();
+}
+
+// src/core/overlaysSlice.ts
+var import_toolkit = require("@reduxjs/toolkit");
+var import_global_slot2 = require("@ai-matrx/kit/global-slot");
+var initialState = { overlays: {} };
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function withDefaults(data, defaults) {
+  if (!defaults) return data ?? null;
+  if (data === void 0 || data === null) return { ...defaults };
+  if (isPlainRecord(data)) return { ...defaults, ...data };
+  return data;
+}
+function closeInstance(state2, overlayId, instanceId) {
+  const bucket = state2.overlays[overlayId];
+  if (!bucket) return;
+  const instance = bucket[instanceId];
+  if (!instance) return;
+  if (instanceId !== DEFAULT_INSTANCE_ID) {
+    delete bucket[instanceId];
+    if (Object.keys(bucket).length === 0) delete state2.overlays[overlayId];
+    return;
+  }
+  instance.isOpen = false;
+  instance.data = null;
+}
+var overlaysSlice = (0, import_toolkit.createSlice)({
+  name: "overlays",
+  initialState,
+  reducers: {
+    openOverlay: (state2, action) => {
+      const { overlayId, instanceId = DEFAULT_INSTANCE_ID, data, defaults } = action.payload;
+      const bucket = state2.overlays[overlayId] ??= {};
+      bucket[instanceId] = { isOpen: true, data: withDefaults(data, defaults), lastUsedAt: Date.now() };
+    },
+    closeOverlay: (state2, action) => {
+      const { overlayId, instanceId = DEFAULT_INSTANCE_ID } = action.payload;
+      closeInstance(state2, overlayId, instanceId);
+    },
+    closeAllOverlays: (state2) => {
+      for (const [overlayId, bucket] of Object.entries(state2.overlays)) {
+        for (const [instanceId, instance] of Object.entries(bucket)) {
+          if (instanceId === DEFAULT_INSTANCE_ID) {
+            instance.isOpen = false;
+            instance.data = null;
+          } else {
+            delete bucket[instanceId];
+          }
+        }
+        if (Object.keys(bucket).length === 0) delete state2.overlays[overlayId];
+      }
+    },
+    toggleOverlay: (state2, action) => {
+      const { overlayId, instanceId = DEFAULT_INSTANCE_ID, data, defaults } = action.payload;
+      const bucket = state2.overlays[overlayId] ??= {};
+      const existing = bucket[instanceId];
+      if (!existing) {
+        bucket[instanceId] = { isOpen: true, data: withDefaults(data, defaults), lastUsedAt: Date.now() };
+      } else if (existing.isOpen) {
+        closeInstance(state2, overlayId, instanceId);
+      } else {
+        existing.isOpen = true;
+        existing.data = data === void 0 || data === null ? existing.data : withDefaults(data, defaults);
+        existing.lastUsedAt = Date.now();
+      }
+    },
+    /** Removes every instance of an overlay id (e.g. an editor that spawned many tabs). */
+    closeAllInstancesOfOverlay: (state2, action) => {
+      delete state2.overlays[action.payload.overlayId];
+    },
+    /**
+     * Route change: close every open instance of the listed overlays — each shows a piece of the
+     * page that opened it, so after navigating away it would float over a page it does not
+     * belong to. Every other overlay is a workbench tool and stays open.
+     */
+    closeOverlaysBoundToPage: (state2, action) => {
+      for (const overlayId of action.payload.overlayIds) {
+        const bucket = state2.overlays[overlayId];
+        if (!bucket) continue;
+        for (const [instanceId, instance] of Object.entries(bucket)) {
+          if (!instance.isOpen) continue;
+          if (instanceId === DEFAULT_INSTANCE_ID) {
+            instance.isOpen = false;
+            instance.data = null;
+          } else {
+            delete bucket[instanceId];
+          }
+        }
+        if (Object.keys(bucket).length === 0) delete state2.overlays[overlayId];
+      }
+    },
+    /**
+     * GC pass — removes closed instances last used more than `olderThanMs` ago. Singleton slots
+     * are kept regardless so selectors returning stable references don't thrash.
+     */
+    pruneStaleInstances: (state2, action) => {
+      const cutoff = Date.now() - action.payload.olderThanMs;
+      for (const [overlayId, bucket] of Object.entries(state2.overlays)) {
+        for (const [instanceId, instance] of Object.entries(bucket)) {
+          if (instanceId === DEFAULT_INSTANCE_ID) continue;
+          if (instance.isOpen) continue;
+          if (!instance.lastUsedAt || instance.lastUsedAt < cutoff) delete bucket[instanceId];
+        }
+        if (Object.keys(bucket).length === 0) delete state2.overlays[overlayId];
+      }
+    }
+  }
+});
+var overlaysReducer = overlaysSlice.reducer;
+var overlaysRawActions = overlaysSlice.actions;
+function stripFunctionsFromOverlayData(overlayId, data) {
+  if (!isPlainRecord(data)) return data;
+  const offenders = Object.keys(data).filter((key) => typeof data[key] === "function");
+  if (offenders.length === 0) return data;
+  console.error(
+    `[summon] BUG: function value(s) in openOverlay data for "${overlayId}" (keys: ${offenders.join(", ")}). Functions cannot travel through Redux \u2014 the handler would NEVER fire. Register a handle (@ai-matrx/summon/handles) and pass its id string instead. The offending key(s) were stripped from state.`
+  );
+  const cleaned = { ...data };
+  for (const key of offenders) delete cleaned[key];
+  return cleaned;
+}
+function rawOpenPayload(payload) {
+  const raw = { overlayId: payload.overlayId };
+  if (payload.instanceId !== void 0) raw.instanceId = payload.instanceId;
+  if (payload.data !== void 0) raw.data = stripFunctionsFromOverlayData(payload.overlayId, payload.data);
+  const defaults = getOverlayMeta(payload.overlayId)?.defaults;
+  if (isPlainRecord(defaults)) {
+    raw.defaults = stripFunctionsFromOverlayData(payload.overlayId, defaults);
+  }
+  return raw;
+}
+function withMatcher(create, raw) {
+  return Object.assign(create, { type: raw.type, match: raw.match });
+}
+var openOverlay = withMatcher(
+  (payload) => overlaysSlice.actions.openOverlay(rawOpenPayload(payload)),
+  overlaysSlice.actions.openOverlay
+);
+var closeOverlay = withMatcher(
+  (payload) => overlaysSlice.actions.closeOverlay(
+    payload.instanceId === void 0 ? { overlayId: payload.overlayId } : { overlayId: payload.overlayId, instanceId: payload.instanceId }
+  ),
+  overlaysSlice.actions.closeOverlay
+);
+var toggleOverlay = withMatcher(
+  (payload) => overlaysSlice.actions.toggleOverlay(rawOpenPayload(payload)),
+  overlaysSlice.actions.toggleOverlay
+);
+var closeAllInstancesOfOverlay = withMatcher(
+  (payload) => overlaysSlice.actions.closeAllInstancesOfOverlay({ overlayId: payload.overlayId }),
+  overlaysSlice.actions.closeAllInstancesOfOverlay
+);
+function overlayIdsBoundToPage() {
+  return allOverlayMeta().filter((meta) => meta.closesOnNavigation === true).map((meta) => meta.id);
+}
+var closeOverlaysBoundToPage = withMatcher(
+  (payload) => overlaysSlice.actions.closeOverlaysBoundToPage({
+    overlayIds: [...payload?.overlayIds ?? overlayIdsBoundToPage()]
+  }),
+  overlaysSlice.actions.closeOverlaysBoundToPage
+);
+var { closeAllOverlays, pruneStaleInstances } = overlaysSlice.actions;
+var CLOSED_OVERLAY_INSTANCE = Object.freeze({ isOpen: false, data: null });
+var EMPTY_INSTANCES = Object.freeze([]);
+var selectOverlay = (state2, overlayId, instanceId = DEFAULT_INSTANCE_ID) => state2.overlays.overlays[overlayId]?.[instanceId] ?? CLOSED_OVERLAY_INSTANCE;
+var selectIsOverlayOpen = (state2, overlayId, instanceId = DEFAULT_INSTANCE_ID) => selectOverlay(state2, overlayId, instanceId).isOpen;
+var selectOverlayData = (state2, overlayId, instanceId = DEFAULT_INSTANCE_ID) => selectOverlay(state2, overlayId, instanceId).data;
+var openInstancesCache = () => (0, import_global_slot2.globalSlot)("ai-matrx.summon.openInstancesSelectors", () => /* @__PURE__ */ new Map());
+var selectOpenInstances = (state2, overlayId) => {
+  const cache = openInstancesCache();
+  let selector = cache.get(overlayId);
+  if (!selector) {
+    selector = (0, import_toolkit.createSelector)(
+      (s) => s.overlays.overlays[overlayId],
+      (instances) => {
+        if (!instances) return EMPTY_INSTANCES;
+        const result = [];
+        for (const [instanceId, inst] of Object.entries(instances)) {
+          if (inst.isOpen) result.push({ instanceId, data: inst.data });
+        }
+        return result.length === 0 ? EMPTY_INSTANCES : result;
+      }
+    );
+    cache.set(overlayId, selector);
+  }
+  return selector(state2);
+};
+function listOpenInstanceKeys(state2) {
+  const keys = [];
+  for (const [overlayId, bucket] of Object.entries(state2.overlays.overlays)) {
+    for (const [instanceId, inst] of Object.entries(bucket)) {
+      if (inst.isOpen) keys.push(`${overlayId}:${instanceId}`);
+    }
+  }
+  return keys;
+}
+
+// src/core/windowManagerSlice.ts
+var import_toolkit2 = require("@reduxjs/toolkit");
+
+// src/core/geometry/windowArrangements.ts
+function getGrid4Rect(index, vw, vh) {
+  const w = Math.round(vw / 2);
+  const h = Math.round(vh / 2);
+  return {
+    x: index % 2 * w,
+    y: Math.floor(index / 2) * h,
+    width: w,
+    height: h
+  };
+}
+function getGrid6Rect(index, vw, vh) {
+  const w = Math.round(vw / 3);
+  const h = Math.round(vh / 2);
+  return {
+    x: index % 3 * w,
+    y: Math.floor(index / 3) * h,
+    width: w,
+    height: h
+  };
+}
+function getGrid8Rect(index, vw, vh) {
+  const w = Math.round(vw / 4);
+  const h = Math.round(vh / 2);
+  return {
+    x: index % 4 * w,
+    y: Math.floor(index % 8 / 4) * h,
+    width: w,
+    height: h
+  };
+}
+function getGrid9Rect(index, vw, vh) {
+  const w = Math.round(vw / 3);
+  const h = Math.round(vh / 3);
+  return {
+    x: index % 3 * w,
+    y: Math.floor(index % 9 / 3) * h,
+    width: w,
+    height: h
+  };
+}
+function getGrid12Rect(index, vw, vh) {
+  const w = Math.round(vw / 4);
+  const h = Math.round(vh / 3);
+  return {
+    x: index % 4 * w,
+    y: Math.floor(index % 12 / 4) * h,
+    width: w,
+    height: h
+  };
+}
+function getStackedRight2Rect(index, vw, vh) {
+  const w = Math.round(vw / 2);
+  const h = Math.round(vh / 2);
+  return {
+    x: w,
+    y: index % 2 * h,
+    width: w,
+    height: h
+  };
+}
+function getStackedRight3Rect(index, vw, vh) {
+  const w = Math.round(vw / 3);
+  const h = Math.round(vh / 3);
+  return {
+    x: vw - w,
+    y: index % 3 * h,
+    width: w,
+    height: h
+  };
+}
+function getStackedRight4Rect(index, vw, vh) {
+  const w = Math.round(vw / 4);
+  const h = Math.round(vh / 4);
+  return {
+    x: vw - w,
+    y: index % 4 * h,
+    width: w,
+    height: h
+  };
+}
+function getStackedRight5Rect(index, vw, vh) {
+  const w = Math.round(vw / 5);
+  const h = Math.round(vh / 5);
+  return {
+    x: vw - w,
+    y: index % 5 * h,
+    width: w,
+    height: h
+  };
+}
+function getStackedLeft2Rect(index, vw, vh) {
+  const w = Math.round(vw / 2);
+  const h = Math.round(vh / 2);
+  return {
+    x: 0,
+    y: index % 2 * h,
+    width: w,
+    height: h
+  };
+}
+function getStackedLeft3Rect(index, vw, vh) {
+  const w = Math.round(vw / 3);
+  const h = Math.round(vh / 3);
+  return {
+    x: 0,
+    y: index % 3 * h,
+    width: w,
+    height: h
+  };
+}
+function getStackedLeft4Rect(index, vw, vh) {
+  const w = Math.round(vw / 4);
+  const h = Math.round(vh / 4);
+  return {
+    x: 0,
+    y: index % 4 * h,
+    width: w,
+    height: h
+  };
+}
+function getStackedLeft5Rect(index, vw, vh) {
+  const w = Math.round(vw / 5);
+  const h = Math.round(vh / 5);
+  return {
+    x: 0,
+    y: index % 5 * h,
+    width: w,
+    height: h
+  };
+}
+function computeGlobalArrangement(layout, windowIds, vw, vh, dirX = "rtl", dirY = "ttb", primary = "vertical") {
+  const specs = {
+    grid4: { cols: 2, rows: 2, fn: getGrid4Rect },
+    grid6: { cols: 3, rows: 2, fn: getGrid6Rect },
+    grid8: { cols: 4, rows: 2, fn: getGrid8Rect },
+    grid9: { cols: 3, rows: 3, fn: getGrid9Rect },
+    grid12: { cols: 4, rows: 3, fn: getGrid12Rect },
+    stackRight2: { cols: 1, rows: 2, fn: getStackedRight2Rect },
+    stackRight3: { cols: 1, rows: 3, fn: getStackedRight3Rect },
+    stackRight4: { cols: 1, rows: 4, fn: getStackedRight4Rect },
+    stackRight5: { cols: 1, rows: 5, fn: getStackedRight5Rect },
+    stackLeft2: { cols: 1, rows: 2, fn: getStackedLeft2Rect },
+    stackLeft3: { cols: 1, rows: 3, fn: getStackedLeft3Rect },
+    stackLeft4: { cols: 1, rows: 4, fn: getStackedLeft4Rect },
+    stackLeft5: { cols: 1, rows: 5, fn: getStackedLeft5Rect }
+  };
+  const spec = specs[layout];
+  const slotCount = spec.cols * spec.rows;
+  const placed = windowIds.slice(0, slotCount);
+  return placed.map((id, i) => {
+    let col;
+    let row;
+    if (primary === "horizontal") {
+      col = i % spec.cols;
+      row = Math.floor(i / spec.cols);
+    } else {
+      row = i % spec.rows;
+      col = Math.floor(i / spec.rows);
+    }
+    if (dirX === "rtl") {
+      col = spec.cols - 1 - col;
+    }
+    if (dirY === "btt") {
+      row = spec.rows - 1 - row;
+    }
+    const targetIndex = row * spec.cols + col;
+    return {
+      id,
+      rect: spec.fn(targetIndex, vw, vh)
+    };
+  });
+}
+
+// src/core/geometry/rectClamp.ts
+var VIEWPORT_PADDING = 8;
+var FALLBACK_W = 480;
+var FALLBACK_H = 360;
+var CLAMP_WARNED = /* @__PURE__ */ Symbol.for("ai-matrx.summon.clampDegenerateViewportWarned");
+var FALLBACK_VIEWPORT_W = 1280;
+var FALLBACK_VIEWPORT_H = 800;
+var DEGENERATE_WARNED = /* @__PURE__ */ Symbol.for(
+  "ai-matrx.summon.degenerateViewportWarned"
+);
+function screamOnceAboutDegenerateMeasurement(rawW, rawH) {
+  const host = globalThis;
+  if (host[DEGENERATE_WARNED]) return;
+  host[DEGENERATE_WARNED] = true;
+  console.warn(
+    "[window-panels] degenerate viewport measurement",
+    { innerWidth: rawW, innerHeight: rawH },
+    "\u2014 using fallback dimensions so window geometry cannot collapse to zero. Logged once per page; state writers bail out instead of persisting invented dims."
+  );
+}
+function safeViewportDims() {
+  if (typeof window === "undefined") {
+    return {
+      vw: FALLBACK_VIEWPORT_W,
+      vh: FALLBACK_VIEWPORT_H,
+      degenerate: true
+    };
+  }
+  const rawW = window.innerWidth;
+  const rawH = window.innerHeight;
+  const degenerate = !Number.isFinite(rawW) || !Number.isFinite(rawH) || rawW <= 0 || rawH <= 0;
+  if (degenerate) screamOnceAboutDegenerateMeasurement(rawW, rawH);
+  return {
+    vw: Number.isFinite(rawW) && rawW > 0 ? rawW : FALLBACK_VIEWPORT_W,
+    vh: Number.isFinite(rawH) && rawH > 0 ? rawH : FALLBACK_VIEWPORT_H,
+    degenerate
+  };
+}
+function clampRectToViewport(rect, viewport) {
+  if (!Number.isFinite(viewport.width) || !Number.isFinite(viewport.height) || viewport.width <= 0 || viewport.height <= 0) {
+    const host = globalThis;
+    if (!host[CLAMP_WARNED]) {
+      host[CLAMP_WARNED] = true;
+      console.warn(
+        "[window-panels] clampRectToViewport received a degenerate viewport",
+        viewport,
+        "\u2014 skipping clamp so real window geometry is not destroyed."
+      );
+    }
+    return {
+      x: Number.isFinite(rect.x) ? rect.x : 0,
+      y: Number.isFinite(rect.y) ? rect.y : 0,
+      width: Number.isFinite(rect.width) && rect.width > 0 ? rect.width : FALLBACK_W,
+      height: Number.isFinite(rect.height) && rect.height > 0 ? rect.height : FALLBACK_H
+    };
+  }
+  const maxW = Math.max(120, viewport.width - VIEWPORT_PADDING * 2);
+  const maxH = Math.max(80, viewport.height - VIEWPORT_PADDING * 2);
+  let width = rect.width;
+  if (!Number.isFinite(width) || width <= 0 || width > viewport.width * 4) {
+    width = FALLBACK_W;
+  }
+  width = Math.min(width, maxW);
+  let height = rect.height;
+  if (!Number.isFinite(height) || height <= 0 || height > viewport.height * 4) {
+    height = FALLBACK_H;
+  }
+  height = Math.min(height, maxH);
+  let x = Number.isFinite(rect.x) ? rect.x : 0;
+  let y = Number.isFinite(rect.y) ? rect.y : 0;
+  const maxX = Math.max(0, viewport.width - width - VIEWPORT_PADDING);
+  const maxY = Math.max(0, viewport.height - height - VIEWPORT_PADDING);
+  x = Math.max(0, Math.min(maxX, x));
+  y = Math.max(0, Math.min(maxY, y));
+  return { x, y, width, height };
+}
+function centerRectInViewport(rect, viewport) {
+  const sized = clampRectToViewport({ ...rect, x: 0, y: 0 }, viewport);
+  const x = Math.max(0, Math.round((viewport.width - sized.width) / 2));
+  const y = Math.max(0, Math.round((viewport.height - sized.height) / 2));
+  return { x, y, width: sized.width, height: sized.height };
+}
+function clampRectToCurrentViewport(rect) {
+  if (typeof window === "undefined") return rect;
+  const { vw, vh } = safeViewportDims();
+  return clampRectToViewport(rect, { width: vw, height: vh });
+}
+function rectsEqual(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+
+// src/core/geometry/tray.ts
+var TRAY_CHIP_W_DESKTOP = 240;
+var TRAY_CHIP_H_DESKTOP = 160;
+var TRAY_GAP_X = 8;
+var TRAY_GAP_Y = 8;
+var TRAY_MARGIN_R = 20;
+var TRAY_MARGIN_B = 20;
+var TRAY_MARGIN_L = 8;
+var TRAY_COMPACT_H = 32;
+var TRAY_COMPACT_GAP = 4;
+var TRAY_CHIP_W_MOBILE_MAX = 180;
+var TRAY_CHIP_H_MOBILE = 72;
+var TRAY_MOBILE_BREAKPOINT = 768;
+function computeTrayChipWidth(viewportWidth) {
+  if (viewportWidth < TRAY_MOBILE_BREAKPOINT) {
+    return Math.min(
+      TRAY_CHIP_W_MOBILE_MAX,
+      Math.max(120, Math.floor(viewportWidth / 2) - 24)
+    );
+  }
+  return TRAY_CHIP_W_DESKTOP;
+}
+function computeTrayChipHeight(viewportWidth) {
+  return viewportWidth < TRAY_MOBILE_BREAKPOINT ? TRAY_CHIP_H_MOBILE : TRAY_CHIP_H_DESKTOP;
+}
+function trayChipsPerRow(viewportWidth) {
+  const chipWidth = computeTrayChipWidth(viewportWidth);
+  const usable = viewportWidth - TRAY_MARGIN_R - TRAY_MARGIN_L;
+  return Math.max(
+    1,
+    Math.floor((usable + TRAY_GAP_X) / (chipWidth + TRAY_GAP_X))
+  );
+}
+function traySlotRect(slot, viewportWidth, viewportHeight, totalSlots = slot + 1) {
+  const chipWidth = computeTrayChipWidth(viewportWidth);
+  const chipHeight = computeTrayChipHeight(viewportWidth);
+  const perRow = trayChipsPerRow(viewportWidth);
+  const safeSlot = Math.max(0, Math.floor(slot));
+  const usableHeight = Math.max(1, viewportHeight - TRAY_MARGIN_B - 8);
+  const fullRows = Math.max(
+    1,
+    Math.floor((usableHeight + TRAY_GAP_Y) / (chipHeight + TRAY_GAP_Y))
+  );
+  const fullCardCapacity = perRow * fullRows;
+  if (totalSlots > fullCardCapacity) {
+    const compactRows = Math.max(
+      1,
+      Math.floor(
+        (viewportHeight - 16 + TRAY_COMPACT_GAP) / (TRAY_COMPACT_H + TRAY_COMPACT_GAP)
+      )
+    );
+    const compactColumns = Math.max(1, Math.ceil(totalSlots / compactRows));
+    const availableWidth = Math.max(
+      compactColumns,
+      viewportWidth - 16 - TRAY_COMPACT_GAP * (compactColumns - 1)
+    );
+    const compactWidth = Math.min(
+      TRAY_CHIP_W_DESKTOP,
+      Math.max(1, Math.floor(availableWidth / compactColumns))
+    );
+    const compactCol = safeSlot % compactColumns;
+    const compactRow = Math.floor(safeSlot / compactColumns);
+    return {
+      x: viewportWidth - 8 - compactWidth - compactCol * (compactWidth + TRAY_COMPACT_GAP),
+      y: viewportHeight - 8 - TRAY_COMPACT_H - compactRow * (TRAY_COMPACT_H + TRAY_COMPACT_GAP),
+      width: compactWidth,
+      height: TRAY_COMPACT_H
+    };
+  }
+  const col = safeSlot % perRow;
+  const row = Math.floor(safeSlot / perRow);
+  return {
+    x: viewportWidth - TRAY_MARGIN_R - chipWidth - col * (chipWidth + TRAY_GAP_X),
+    y: viewportHeight - TRAY_MARGIN_B - chipHeight - row * (chipHeight + TRAY_GAP_Y),
+    width: chipWidth,
+    height: chipHeight
+  };
+}
+
+// src/core/windowManagerSlice.ts
+var WINDOW_SESSION_SCHEMA_VERSION = 1;
+function windowSessionKey(overlayId, instanceId) {
+  return `${overlayId}:${instanceId}`;
+}
+var TRAY_CHIP_W = TRAY_CHIP_W_DESKTOP;
+var TRAY_CHIP_H = TRAY_CHIP_H_DESKTOP;
+var BASE_Z = 1e3;
+var TRAY_SLOT_WIDTH = TRAY_CHIP_W;
+var initialState2 = {
+  windows: {},
+  pendingRestores: {},
+  nextZIndex: BASE_Z,
+  trayCount: 0,
+  trayViewport: null,
+  windowsHidden: false,
+  activePipWindowId: null,
+  popoutCandidateId: null,
+  transientZ: {}
+};
+function recomputeAllTrayRects(state2) {
+  const viewport = state2.trayViewport;
+  if (!viewport) return;
+  Object.values(state2.windows).forEach((entry) => {
+    if (entry.traySlot === null) return;
+    entry.windowed = traySlotRect(
+      entry.traySlot,
+      viewport.width,
+      viewport.height,
+      state2.trayCount
+    );
+  });
+  Object.values(state2.pendingRestores).forEach((session) => {
+    if (session.traySlot === null) return;
+    session.renderRect = traySlotRect(
+      session.traySlot,
+      viewport.width,
+      viewport.height,
+      state2.trayCount
+    );
+  });
+}
+function hasMatchingLiveTrayReservation(state2, overlayId, instanceId, traySlot) {
+  if (traySlot === null) return false;
+  return Object.values(state2.windows).some(
+    (entry) => entry.persistence?.overlayId === overlayId && entry.persistence.instanceId === instanceId && entry.traySlot === traySlot
+  );
+}
+function compactReservedTraySlot(state2, freedSlot, freedRect) {
+  const rectBySlot = /* @__PURE__ */ new Map();
+  rectBySlot.set(freedSlot, freedRect);
+  Object.values(state2.windows).forEach((entry) => {
+    if (entry.traySlot !== null) {
+      rectBySlot.set(entry.traySlot, { ...entry.windowed });
+    }
+  });
+  Object.values(state2.pendingRestores).forEach((session) => {
+    if (session.traySlot !== null) {
+      rectBySlot.set(session.traySlot, { ...session.renderRect });
+    }
+  });
+  state2.trayCount = Math.max(0, state2.trayCount - 1);
+  if (state2.trayCount === 0) state2.trayViewport = null;
+  Object.values(state2.windows).forEach((entry) => {
+    if (entry.traySlot === null || entry.traySlot <= freedSlot) return;
+    const nextSlot = entry.traySlot - 1;
+    entry.traySlot = nextSlot;
+    const nextRect = rectBySlot.get(nextSlot);
+    if (nextRect) entry.windowed = nextRect;
+  });
+  Object.values(state2.pendingRestores).forEach((session) => {
+    if (session.traySlot === null || session.traySlot <= freedSlot) return;
+    const nextSlot = session.traySlot - 1;
+    session.traySlot = nextSlot;
+    const nextRect = rectBySlot.get(nextSlot);
+    if (nextRect) session.renderRect = nextRect;
+  });
+  recomputeAllTrayRects(state2);
+}
+function releaseTraySlot(state2, win) {
+  const freedSlot = win.traySlot;
+  if (freedSlot === null) return;
+  const freedRect = { ...win.windowed };
+  win.traySlot = null;
+  compactReservedTraySlot(state2, freedSlot, freedRect);
+}
+var windowManagerSlice = (0, import_toolkit2.createSlice)({
+  name: "windowManager",
+  initialState: initialState2,
+  reducers: {
+    /**
+     * Put a transient (lite) window on top of the shared stack, or raise one
+     * that is already there. Same counter as `focusWindow`, so heavy and lite
+     * windows interleave correctly.
+     */
+    raiseTransientWindow(state2, action) {
+      state2.transientZ[action.payload] = state2.nextZIndex++;
+    },
+    /** Drop a transient window's z registration when it unmounts. */
+    releaseTransientWindow(state2, action) {
+      delete state2.transientZ[action.payload];
+    },
+    /** Register a new window. Idempotent — ignored if id already exists. */
+    registerWindow(state2, action) {
+      const { id, title, initial, initialState: initialState5, persistence, viewport } = action.payload;
+      if (state2.windows[id]) return;
+      const safeInitial = viewport ? clampRectToViewport(initial, viewport) : initial;
+      const pending = persistence ? state2.pendingRestores[windowSessionKey(persistence.overlayId, persistence.instanceId)] : void 0;
+      const pendingRenderRect = pending ? pending.state === "minimized" && pending.traySlot !== null && viewport ? traySlotRect(
+        pending.traySlot,
+        viewport.width,
+        viewport.height,
+        state2.trayCount
+      ) : viewport ? clampRectToViewport(pending.windowedRect, viewport) : pending.renderRect : void 0;
+      const startsMinimized = !pending && initialState5 === "minimized" && viewport !== void 0;
+      const initialTraySlot = startsMinimized ? state2.trayCount : null;
+      state2.windows[id] = {
+        id,
+        title: title ?? pending?.title ?? id,
+        state: pending?.state ?? (startsMinimized ? "minimized" : "windowed"),
+        windowed: pendingRenderRect ?? safeInitial,
+        preMinimizedRect: pending?.state === "minimized" ? pending.windowedRect : startsMinimized ? safeInitial : null,
+        zIndex: pending?.zIndex ?? state2.nextZIndex++,
+        traySlot: pending?.state === "minimized" ? pending.traySlot : initialTraySlot,
+        popoutMode: null,
+        prePopoutRect: null,
+        ...persistence ? {
+          persistence: {
+            ...persistence,
+            data: { ...pending?.data ?? {}, ...persistence.data },
+            sidebarOpen: pending?.sidebarOpen ?? persistence.sidebarOpen,
+            sidebarSize: pending?.sidebarSize ?? persistence.sidebarSize,
+            closing: false
+          }
+        } : {}
+      };
+      if (pending?.state === "minimized" && pending.traySlot !== null) {
+        state2.trayCount = Math.max(state2.trayCount, pending.traySlot + 1);
+      } else if (startsMinimized && viewport) {
+        state2.trayCount += 1;
+        state2.trayViewport = viewport;
+        recomputeAllTrayRects(state2);
+      }
+      if (pending && pending.zIndex >= state2.nextZIndex) {
+        state2.nextZIndex = pending.zIndex + 1;
+      }
+      if (state2.windowsHidden) state2.windowsHidden = false;
+    },
+    /** Stage validated local sessions without creating phantom live windows. */
+    hydrateWindowSessions(state2, action) {
+      const liveEntries = Object.values(state2.windows).sort(
+        (a, b) => a.zIndex - b.zIndex || a.id.localeCompare(b.id)
+      );
+      const accepted = [];
+      action.payload.sessions.forEach((session) => {
+        const alreadyLive = Object.values(state2.windows).some(
+          (entry) => entry.persistence?.overlayId === session.overlayId && entry.persistence.instanceId === session.instanceId && !entry.persistence.closing
+        );
+        if (alreadyLive) return;
+        accepted.push(session);
+      });
+      const trayBase = state2.trayCount;
+      const acceptedTraySlots = new Map(
+        accepted.filter(
+          (session) => session.state === "minimized" && session.traySlot !== null
+        ).sort(
+          (a, b) => (a.traySlot ?? Number.MAX_SAFE_INTEGER) - (b.traySlot ?? Number.MAX_SAFE_INTEGER) || a.sessionKey.localeCompare(b.sessionKey)
+        ).map(
+          (session, index) => [session.sessionKey, trayBase + index]
+        )
+      );
+      accepted.sort(
+        (a, b) => a.zIndex - b.zIndex || a.sessionKey.localeCompare(b.sessionKey)
+      ).forEach((session, index) => {
+        const key = windowSessionKey(session.overlayId, session.instanceId);
+        const traySlot = session.state === "minimized" ? acceptedTraySlots.get(session.sessionKey) ?? null : null;
+        state2.pendingRestores[key] = {
+          ...session,
+          sessionKey: key,
+          traySlot,
+          zIndex: BASE_Z + index,
+          renderRect: traySlot !== null ? traySlotRect(
+            traySlot,
+            action.payload.viewportWidth,
+            action.payload.viewportHeight
+          ) : clampRectToViewport(session.windowedRect, {
+            width: action.payload.viewportWidth,
+            height: action.payload.viewportHeight
+          })
+        };
+      });
+      state2.trayCount = trayBase + acceptedTraySlots.size;
+      state2.trayViewport = {
+        width: action.payload.viewportWidth,
+        height: action.payload.viewportHeight
+      };
+      recomputeAllTrayRects(state2);
+      liveEntries.forEach((entry, index) => {
+        entry.zIndex = BASE_Z + accepted.length + index;
+      });
+      state2.nextZIndex = BASE_Z + accepted.length + liveEntries.length;
+    },
+    /** StrictMode-safe: the first mount cleanup may run before the real mount settles. */
+    confirmWindowRestored(state2, action) {
+      delete state2.pendingRestores[action.payload];
+    },
+    discardPendingWindowSession(state2, action) {
+      const pending = state2.pendingRestores[action.payload];
+      if (pending?.traySlot !== null && pending?.traySlot !== void 0 && !hasMatchingLiveTrayReservation(
+        state2,
+        pending.overlayId,
+        pending.instanceId,
+        pending.traySlot
+      )) {
+        compactReservedTraySlot(state2, pending.traySlot, pending.renderRect);
+      }
+      delete state2.pendingRestores[action.payload];
+    },
+    updateWindowPersistence(state2, action) {
+      const entry = state2.windows[action.payload.id];
+      if (!entry?.persistence || entry.persistence.closing) return;
+      if (action.payload.data !== void 0 && JSON.stringify(entry.persistence.data) !== JSON.stringify(action.payload.data)) {
+        entry.persistence.data = action.payload.data;
+      }
+      if (action.payload.sidebarOpen !== void 0 && entry.persistence.sidebarOpen !== action.payload.sidebarOpen) {
+        entry.persistence.sidebarOpen = action.payload.sidebarOpen;
+      }
+      if (action.payload.sidebarSize !== void 0 && entry.persistence.sidebarSize !== action.payload.sidebarSize) {
+        entry.persistence.sidebarSize = action.payload.sidebarSize;
+      }
+    },
+    /** Synchronous tombstone: close can never be undone by an unmount snapshot. */
+    markWindowClosing(state2, action) {
+      const key = windowSessionKey(
+        action.payload.overlayId,
+        action.payload.instanceId
+      );
+      const pending = state2.pendingRestores[key];
+      const hasMatchingLiveReservation = pending ? hasMatchingLiveTrayReservation(
+        state2,
+        action.payload.overlayId,
+        action.payload.instanceId,
+        pending.traySlot
+      ) : false;
+      if (!hasMatchingLiveReservation && pending?.traySlot !== null && pending?.traySlot !== void 0) {
+        compactReservedTraySlot(state2, pending.traySlot, pending.renderRect);
+      }
+      delete state2.pendingRestores[key];
+      Object.values(state2.windows).forEach((entry) => {
+        if (entry.persistence?.overlayId === action.payload.overlayId && entry.persistence.instanceId === action.payload.instanceId) {
+          entry.persistence.closing = true;
+        }
+      });
+    },
+    clearWindowPersistenceState(state2) {
+      Object.values(state2.pendingRestores).filter(
+        (session) => session.traySlot !== null && session.traySlot !== void 0 && !hasMatchingLiveTrayReservation(
+          state2,
+          session.overlayId,
+          session.instanceId,
+          session.traySlot
+        )
+      ).sort((a, b) => (b.traySlot ?? -1) - (a.traySlot ?? -1)).forEach((session) => {
+        const traySlot = session.traySlot;
+        if (traySlot === null) return;
+        compactReservedTraySlot(state2, traySlot, session.renderRect);
+      });
+      state2.pendingRestores = {};
+      Object.values(state2.windows).forEach((entry) => {
+        if (entry.persistence) entry.persistence.closing = true;
+      });
+    },
+    /** Update just the title (e.g. when prop changes). */
+    updateWindowTitle(state2, action) {
+      const win = state2.windows[action.payload.id];
+      if (win) win.title = action.payload.title;
+    },
+    /** Remove a window from tracking entirely. */
+    unregisterWindow(state2, action) {
+      const win = state2.windows[action.payload];
+      if (!win) return;
+      const pending = win.persistence ? state2.pendingRestores[windowSessionKey(
+        win.persistence.overlayId,
+        win.persistence.instanceId
+      )] : void 0;
+      const pendingOwnsLiveReservation = Boolean(
+        win.persistence && pending && hasMatchingLiveTrayReservation(
+          state2,
+          win.persistence.overlayId,
+          win.persistence.instanceId,
+          pending.traySlot
+        )
+      );
+      if (!pendingOwnsLiveReservation) releaseTraySlot(state2, win);
+      if (state2.activePipWindowId === action.payload) {
+        state2.activePipWindowId = null;
+      }
+      if (state2.popoutCandidateId === action.payload) {
+        state2.popoutCandidateId = null;
+      }
+      delete state2.windows[action.payload];
+      if (Object.keys(state2.windows).length === 0) {
+        state2.windowsHidden = false;
+      }
+    },
+    /** Bring a window to the top of the z stack. */
+    focusWindow(state2, action) {
+      const win = state2.windows[action.payload];
+      if (!win) return;
+      win.zIndex = state2.nextZIndex++;
+    },
+    /** Switch to windowed (restore) state. */
+    restoreWindow(state2, action) {
+      const win = state2.windows[action.payload];
+      if (!win) return;
+      releaseTraySlot(state2, win);
+      if (win.preMinimizedRect) {
+        win.windowed = win.preMinimizedRect;
+        win.preMinimizedRect = null;
+      }
+      win.state = "windowed";
+      win.zIndex = state2.nextZIndex++;
+    },
+    /**
+     * Bring an already-registered window unconditionally into view — the
+     * single "show me this panel" primitive used by the open path.
+     *
+     * Re-triggering a menu/opener for a window that is already open must never
+     * be a silent no-op. Before this existed, an open dispatch only updated
+     * overlay-slice data; if the window was minimized, dragged off-screen, or
+     * suppressed by `windowsHidden`, the user saw nothing. `revealWindow`:
+     *   - restores a minimized window to its pre-minimized rect,
+     *   - clamps the rect back into the current viewport (off-screen rescue),
+     *   - raises it to the top of the z-stack,
+     *   - clears the global hide-all flag.
+     *
+     * No-op when the window isn't registered yet (first open — `registerWindow`
+     * handles that). Popped-out windows keep their OS-managed frame; we only
+     * clear the global hide so the rest of the desktop is visible.
+     *
+     * Caller supplies viewport dimensions (reducers can't read `window`).
+     */
+    revealWindow(state2, action) {
+      const { id, viewportWidth, viewportHeight } = action.payload;
+      const win = state2.windows[id];
+      if (!win) return;
+      if (state2.windowsHidden) state2.windowsHidden = false;
+      if (win.popoutMode !== null) return;
+      releaseTraySlot(state2, win);
+      if (win.state === "minimized") {
+        if (win.preMinimizedRect) {
+          win.windowed = win.preMinimizedRect;
+          win.preMinimizedRect = null;
+        }
+        win.state = "windowed";
+      }
+      if (win.state === "windowed") {
+        const clamped = clampRectToViewport(win.windowed, {
+          width: viewportWidth,
+          height: viewportHeight
+        });
+        if (!rectsEqual(win.windowed, clamped)) win.windowed = clamped;
+      }
+      win.zIndex = state2.nextZIndex++;
+    },
+    /** Switch to maximized state. */
+    maximizeWindow(state2, action) {
+      const win = state2.windows[action.payload];
+      if (!win) return;
+      releaseTraySlot(state2, win);
+      win.state = "maximized";
+      win.zIndex = state2.nextZIndex++;
+    },
+    /**
+     * Minimize a window — parks it in the tray grid at the bottom of the
+     * viewport. Caller must supply current viewport dimensions so the reducer
+     * can compute the exact position without touching window/document.
+     */
+    minimizeWindow(state2, action) {
+      const { id, viewportWidth, viewportHeight } = action.payload;
+      const win = state2.windows[id];
+      if (!win || win.state === "minimized") return;
+      if (win.popoutMode !== null) return;
+      win.preMinimizedRect = { ...win.windowed };
+      const slot = state2.trayCount;
+      win.traySlot = slot;
+      state2.trayCount += 1;
+      state2.trayViewport = { width: viewportWidth, height: viewportHeight };
+      win.state = "minimized";
+      recomputeAllTrayRects(state2);
+    },
+    /**
+     * Minimize ALL non-minimized, non-maximized windows in one shot.
+     * Use for a "collapse all" button. Caller supplies viewport dimensions.
+     */
+    minimizeAll(state2, action) {
+      const { viewportWidth, viewportHeight } = action.payload;
+      state2.trayViewport = { width: viewportWidth, height: viewportHeight };
+      Object.values(state2.windows).forEach((win) => {
+        if (win.state !== "windowed") return;
+        if (win.popoutMode !== null) return;
+        win.preMinimizedRect = { ...win.windowed };
+        const slot = state2.trayCount;
+        win.traySlot = slot;
+        state2.trayCount += 1;
+        win.state = "minimized";
+      });
+      recomputeAllTrayRects(state2);
+    },
+    /** Update the windowed rect (called during drag or resize). */
+    updateWindowRect(state2, action) {
+      const win = state2.windows[action.payload.id];
+      if (!win) return;
+      win.windowed = { ...win.windowed, ...action.payload.rect };
+    },
+    /**
+     * Clamp a window's `windowed` rect into the current viewport so its body
+     * and footer remain reachable.
+     *
+     * **Why this exists:** drag-and-release outside the viewport (without a
+     * popout firing), restore-from-minimize where `preMinimizedRect` was
+     * captured at a larger viewport, and dock-from-popout where the docked
+     * rect was off-screen all leave the window in a position the user can't
+     * reach. We clamp at the boundary where the user expects to "see" the
+     * window again.
+     *
+     * **Skips popped-out windows** — their rect is OS-managed, not our
+     * concern. Skips minimized + maximized windows — those have their own
+     * rect logic that owners shouldn't fight.
+     *
+     * Caller passes viewport dimensions because reducers can't read
+     * `window.innerWidth` (consistent with `minimizeWindow` /
+     * `arrangeActiveWindows` patterns).
+     */
+    clampWindowRect(state2, action) {
+      const { id, viewportWidth, viewportHeight } = action.payload;
+      const win = state2.windows[id];
+      if (!win) return;
+      if (win.state !== "windowed") return;
+      if (win.popoutMode !== null) return;
+      const clamped = clampRectToViewport(win.windowed, {
+        width: viewportWidth,
+        height: viewportHeight
+      });
+      if (!rectsEqual(win.windowed, clamped)) win.windowed = clamped;
+    },
+    /**
+     * Clamp every docked windowed window into the viewport. Dispatched by
+     * a global resize listener so windows that were positioned for a larger
+     * viewport get nudged back into reach.
+     *
+     * Mirrors `recomputeTrayPositions`'s coverage for minimized chips.
+     */
+    clampAllWindowRects(state2, action) {
+      const { viewportWidth, viewportHeight } = action.payload;
+      Object.values(state2.windows).forEach((win) => {
+        if (win.state !== "windowed") return;
+        if (win.popoutMode !== null) return;
+        const clamped = clampRectToViewport(win.windowed, {
+          width: viewportWidth,
+          height: viewportHeight
+        });
+        if (!rectsEqual(win.windowed, clamped)) win.windowed = clamped;
+      });
+    },
+    /** Arranges all non-minimized windows globally */
+    arrangeActiveWindows(state2, action) {
+      const { layout, viewportWidth, viewportHeight, dirX, dirY, primary } = action.payload;
+      const eligibleWindows = Object.values(state2.windows).filter((w) => w.state === "windowed" && w.popoutMode === null).sort((a, b) => b.zIndex - a.zIndex).map((w) => w.id);
+      if (eligibleWindows.length === 0) return;
+      const updates = computeGlobalArrangement(
+        layout,
+        eligibleWindows,
+        viewportWidth,
+        viewportHeight,
+        dirX,
+        dirY,
+        primary
+      );
+      updates.forEach(({ id, rect }) => {
+        if (state2.windows[id]) {
+          state2.windows[id].windowed = {
+            ...state2.windows[id].windowed,
+            ...rect
+          };
+        }
+      });
+    },
+    /**
+     * Recompute tray positions for all minimized windows after a viewport
+     * resize. Each window keeps its existing traySlot number — only x/y/w/h
+     * are recalculated. No-op if nothing is minimized.
+     */
+    recomputeTrayPositions(state2, action) {
+      const { viewportWidth, viewportHeight } = action.payload;
+      if (!Number.isFinite(viewportWidth) || !Number.isFinite(viewportHeight) || viewportWidth <= 0 || viewportHeight <= 0) {
+        return;
+      }
+      state2.trayViewport = { width: viewportWidth, height: viewportHeight };
+      const minimized = Object.values(state2.windows).filter(
+        (w) => w.state === "minimized" && w.traySlot !== null
+      );
+      if (minimized.length === 0) return;
+      recomputeAllTrayRects(state2);
+    },
+    /**
+     * Restore ALL minimized windows to their pre-minimized rects in one shot.
+     * Maximized windows are left alone — only minimized ones are affected.
+     */
+    restoreAll(state2) {
+      Object.values(state2.windows).forEach((win) => {
+        if (win.state !== "minimized") return;
+        if (win.preMinimizedRect) {
+          win.windowed = win.preMinimizedRect;
+          win.preMinimizedRect = null;
+        }
+        win.traySlot = null;
+        win.state = "windowed";
+        win.zIndex = state2.nextZIndex++;
+      });
+      Object.values(state2.pendingRestores).forEach((session) => {
+        if (session.state !== "minimized") return;
+        session.state = "windowed";
+        session.traySlot = null;
+        session.renderRect = session.windowedRect;
+      });
+      state2.trayCount = 0;
+      state2.trayViewport = null;
+    },
+    /** Show or hide all windows (they stay mounted). */
+    toggleWindowsHidden(state2) {
+      state2.windowsHidden = !state2.windowsHidden;
+    },
+    /** Move a minimized chip to a new tray slot (drag-within-tray). */
+    moveTraySlot(state2, action) {
+      const { id, toSlot } = action.payload;
+      const win = state2.windows[id];
+      if (!win || win.traySlot === null) return;
+      const fromSlot = win.traySlot;
+      const boundedSlot = Math.min(
+        Math.max(0, Math.floor(toSlot)),
+        Math.max(0, state2.trayCount - 1)
+      );
+      if (fromSlot === boundedSlot) return;
+      const rectBySlot = /* @__PURE__ */ new Map();
+      Object.values(state2.windows).forEach((entry) => {
+        if (entry.traySlot !== null) {
+          rectBySlot.set(entry.traySlot, { ...entry.windowed });
+        }
+      });
+      Object.values(state2.pendingRestores).forEach((session) => {
+        if (session.traySlot !== null) {
+          rectBySlot.set(session.traySlot, { ...session.renderRect });
+        }
+      });
+      Object.values(state2.windows).forEach((w) => {
+        if (w.id === id || w.traySlot === null) return;
+        if (fromSlot < boundedSlot && w.traySlot > fromSlot && w.traySlot <= boundedSlot) {
+          w.traySlot -= 1;
+        } else if (fromSlot > boundedSlot && w.traySlot >= boundedSlot && w.traySlot < fromSlot) {
+          w.traySlot += 1;
+        }
+      });
+      Object.values(state2.pendingRestores).forEach((session) => {
+        if (session.traySlot === null) return;
+        if (fromSlot < boundedSlot && session.traySlot > fromSlot && session.traySlot <= boundedSlot) {
+          session.traySlot -= 1;
+        } else if (fromSlot > boundedSlot && session.traySlot >= boundedSlot && session.traySlot < fromSlot) {
+          session.traySlot += 1;
+        }
+      });
+      win.traySlot = boundedSlot;
+      Object.values(state2.windows).forEach((entry) => {
+        if (entry.traySlot === null) return;
+        const nextRect = rectBySlot.get(entry.traySlot);
+        if (nextRect) entry.windowed = nextRect;
+      });
+      Object.values(state2.pendingRestores).forEach((session) => {
+        if (session.traySlot === null) return;
+        const nextRect = rectBySlot.get(session.traySlot);
+        if (nextRect) session.renderRect = nextRect;
+      });
+      recomputeAllTrayRects(state2);
+    },
+    /**
+     * Transition a window into popped-out mode.
+     *
+     * Caller is responsible for actually opening the Document PiP / popup
+     * window FIRST (it requires a synchronous user gesture). This reducer is
+     * dispatched only after the window resolves successfully so Redux state
+     * always matches reality.
+     *
+     * If the window is currently minimized, the tray slot is freed first
+     * (same compaction logic as `restoreWindow`). The current `windowed`
+     * rect is saved to `prePopoutRect` so dock-back returns to the original
+     * dimensions.
+     *
+     * Single-PiP enforcement: callers MUST check `selectActivePipWindowId`
+     * before requesting `mode: "pip"`. This reducer is defense-in-depth and
+     * silently no-ops if a different window already holds the PiP slot.
+     */
+    popOutWindow(state2, action) {
+      const { id, mode } = action.payload;
+      const win = state2.windows[id];
+      if (!win) return;
+      if (mode === "pip" && state2.activePipWindowId !== null && state2.activePipWindowId !== id) {
+        return;
+      }
+      if (win.traySlot !== null) {
+        releaseTraySlot(state2, win);
+        if (win.preMinimizedRect) {
+          win.windowed = win.preMinimizedRect;
+          win.preMinimizedRect = null;
+        }
+        win.state = "windowed";
+      }
+      if (win.prePopoutRect === null) {
+        win.prePopoutRect = { ...win.windowed };
+      }
+      win.popoutMode = mode;
+      if (mode === "pip") {
+        state2.activePipWindowId = id;
+      }
+      if (state2.popoutCandidateId === id) {
+        state2.popoutCandidateId = null;
+      }
+    },
+    /**
+     * Transition a popped-out window back into the parent viewport.
+     *
+     * Centers the window in the parent viewport using `prePopoutRect`
+     * width/height (falls back to current `windowed` size), clears
+     * `popoutMode`, releases the PiP slot if held, and bumps z-index.
+     * Caller is responsible for closing the actual browser popout window.
+     */
+    dockWindow(state2, action) {
+      const { id, viewportWidth, viewportHeight } = action.payload;
+      const win = state2.windows[id];
+      if (!win || win.popoutMode === null) return;
+      if (state2.activePipWindowId === win.id) {
+        state2.activePipWindowId = null;
+      }
+      const savedRect = win.prePopoutRect ?? win.windowed;
+      const centered = centerRectInViewport(savedRect, {
+        width: viewportWidth,
+        height: viewportHeight
+      });
+      win.windowed = centered;
+      win.prePopoutRect = null;
+      win.popoutMode = null;
+      win.zIndex = state2.nextZIndex++;
+    },
+    /**
+     * Set or clear the drag-out candidate window. Used purely for visual
+     * feedback during a drag: when set, the WindowPanel renders a
+     * "Release to pop out" outline. Cleared on every pointerup regardless
+     * of whether popout actually fires.
+     */
+    setPopoutCandidate(state2, action) {
+      state2.popoutCandidateId = action.payload.id;
+    },
+    /** Restore window geometry and state from localStorage */
+    restoreWindowState(state2, action) {
+      const restored = action.payload;
+      let maxZ = state2.nextZIndex;
+      Object.entries(restored).forEach(([id, win]) => {
+        if (!state2.windows[id]) {
+          return;
+        }
+        state2.windows[id] = {
+          ...state2.windows[id],
+          ...win,
+          popoutMode: null,
+          prePopoutRect: null
+        };
+        if (win.zIndex >= maxZ) maxZ = win.zIndex + 1;
+      });
+      state2.nextZIndex = Math.max(state2.nextZIndex, maxZ);
+      state2.activePipWindowId = null;
+      state2.popoutCandidateId = null;
+      state2.trayCount = Object.values(state2.windows).filter(
+        (w) => w.traySlot !== null
+      ).length;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addMatcher(
+      (action) => action.type === "overlays/closeOverlay",
+      (state2, action) => {
+        const payload = action.payload;
+        if (!payload || typeof payload !== "object") return;
+        const overlayId = payload.overlayId;
+        const instanceId = payload.instanceId ?? "default";
+        if (typeof overlayId !== "string" || typeof instanceId !== "string") {
+          return;
+        }
+        const pending = Object.values(state2.pendingRestores).find(
+          (session) => session.overlayId === overlayId && session.instanceId === instanceId
+        );
+        const hasMatchingLive = pending ? hasMatchingLiveTrayReservation(
+          state2,
+          overlayId,
+          instanceId,
+          pending.traySlot
+        ) : false;
+        if (!hasMatchingLive && pending?.traySlot != null) {
+          compactReservedTraySlot(state2, pending.traySlot, pending.renderRect);
+        }
+        if (pending) delete state2.pendingRestores[pending.sessionKey];
+        Object.values(state2.windows).forEach((entry) => {
+          if (entry.persistence?.overlayId === overlayId && entry.persistence.instanceId === instanceId) {
+            entry.persistence.closing = true;
+          }
+        });
+      }
+    );
+    builder.addMatcher(
+      (action) => action.type === "overlays/closeAllOverlays",
+      (state2) => {
+        Object.values(state2.pendingRestores).filter(
+          (session) => session.traySlot !== null && !hasMatchingLiveTrayReservation(
+            state2,
+            session.overlayId,
+            session.instanceId,
+            session.traySlot
+          )
+        ).sort((a, b) => (b.traySlot ?? -1) - (a.traySlot ?? -1)).forEach((session) => {
+          if (session.traySlot !== null) {
+            compactReservedTraySlot(
+              state2,
+              session.traySlot,
+              session.renderRect
+            );
+          }
+        });
+        state2.pendingRestores = {};
+        Object.values(state2.windows).forEach((entry) => {
+          if (entry.persistence) entry.persistence.closing = true;
+        });
+      }
+    );
+    builder.addMatcher(
+      (action) => action.type === "overlays/closeAllInstancesOfOverlay",
+      (state2, action) => {
+        const payload = action.payload;
+        const overlayId = payload && typeof payload === "object" && "overlayId" in payload ? payload.overlayId : null;
+        if (typeof overlayId !== "string") return;
+        Object.values(state2.pendingRestores).filter(
+          (session) => session.overlayId === overlayId && session.traySlot !== null && !hasMatchingLiveTrayReservation(
+            state2,
+            session.overlayId,
+            session.instanceId,
+            session.traySlot
+          )
+        ).sort((a, b) => (b.traySlot ?? -1) - (a.traySlot ?? -1)).forEach((session) => {
+          if (session.traySlot !== null) {
+            compactReservedTraySlot(
+              state2,
+              session.traySlot,
+              session.renderRect
+            );
+          }
+        });
+        Object.entries(state2.pendingRestores).forEach(([key, session]) => {
+          if (session.overlayId === overlayId)
+            delete state2.pendingRestores[key];
+        });
+        Object.values(state2.windows).forEach((entry) => {
+          if (entry.persistence?.overlayId === overlayId) {
+            entry.persistence.closing = true;
+          }
+        });
+      }
+    );
+  }
+});
+var {
+  raiseTransientWindow,
+  releaseTransientWindow,
+  registerWindow,
+  unregisterWindow,
+  focusWindow,
+  restoreWindow,
+  revealWindow,
+  maximizeWindow,
+  minimizeWindow,
+  minimizeAll,
+  restoreAll,
+  recomputeTrayPositions,
+  updateWindowRect,
+  updateWindowTitle,
+  toggleWindowsHidden,
+  moveTraySlot,
+  arrangeActiveWindows,
+  popOutWindow,
+  dockWindow,
+  setPopoutCandidate,
+  clampWindowRect,
+  clampAllWindowRects,
+  restoreWindowState,
+  hydrateWindowSessions,
+  confirmWindowRestored,
+  discardPendingWindowSession,
+  updateWindowPersistence,
+  markWindowClosing,
+  clearWindowPersistenceState
+} = windowManagerSlice.actions;
+var selectWindowsMap = (state2) => state2.windowManager.windows;
+var selectPendingWindowRestores = (state2) => state2.windowManager.pendingRestores;
+var selectWindowPersistence = (id) => (state2) => state2.windowManager.windows[id]?.persistence;
+var selectWindow = (id) => (state2) => state2.windowManager.windows[id];
+var selectWindowState = (id) => (state2) => state2.windowManager.windows[id]?.state;
+var selectWindowRect = (id) => (state2) => state2.windowManager.windows[id]?.windowed;
+var selectWindowZIndex = (id) => (state2) => state2.windowManager.windows[id]?.zIndex ?? BASE_Z;
+var selectTransientZIndex = (id) => (state2) => state2.windowManager.transientZ[id] ?? BASE_Z;
+var selectWindowTitle = (id) => (state2) => state2.windowManager.windows[id]?.title ?? id;
+var selectTraySlotWidth = () => TRAY_SLOT_WIDTH;
+var selectWindowsHidden = (state2) => state2.windowManager.windowsHidden;
+var selectTrayWindows = (0, import_toolkit2.createSelector)(
+  [selectWindowsMap],
+  (windows) => Object.values(windows).filter((w) => w.state === "minimized").sort((a, b) => (a.traySlot ?? 0) - (b.traySlot ?? 0))
+);
+var selectAllWindows = (0, import_toolkit2.createSelector)(
+  [selectWindowsMap],
+  (windows) => Object.values(windows).sort((a, b) => b.zIndex - a.zIndex)
+);
+var selectAllMinimized = (0, import_toolkit2.createSelector)(
+  [selectWindowsMap],
+  (windows) => {
+    const wins = Object.values(windows);
+    return wins.length > 0 && wins.every((w) => w.state === "minimized");
+  }
+);
+var selectPopoutMode = (id) => (state2) => state2.windowManager.windows[id]?.popoutMode ?? null;
+var selectIsPoppedOut = (id) => (state2) => (state2.windowManager.windows[id]?.popoutMode ?? null) !== null;
+var selectActivePipWindowId = (state2) => state2.windowManager.activePipWindowId;
+var selectPopoutCandidateId = (state2) => state2.windowManager.popoutCandidateId;
+var selectPrePopoutRect = (id) => (state2) => state2.windowManager.windows[id]?.prePopoutRect ?? null;
+var selectDockedWindows = (0, import_toolkit2.createSelector)(
+  [selectWindowsMap],
+  (windows) => Object.values(windows).filter((w) => w.popoutMode === null).sort((a, b) => b.zIndex - a.zIndex)
+);
+var windowManagerReducer = windowManagerSlice.reducer;
+
+// src/core/linksSlice.ts
+var import_toolkit3 = require("@reduxjs/toolkit");
+var initialState3 = {
+  entries: {},
+  isHydrated: false
+};
+var urlSyncSlice = (0, import_toolkit3.createSlice)({
+  name: "urlSync",
+  initialState: initialState3,
+  reducers: {
+    setHydrated: (state2) => {
+      state2.isHydrated = true;
+    },
+    registerSyncEntry: (state2, action) => {
+      const key = `${action.payload.typeKey}:${action.payload.instanceId}`;
+      state2.entries[key] = action.payload;
+    },
+    unregisterSyncEntry: (state2, action) => {
+      const key = `${action.payload.typeKey}:${action.payload.instanceId}`;
+      delete state2.entries[key];
+    }
+  }
+});
+var linksReducer = urlSyncSlice.reducer;
+var { setHydrated, registerSyncEntry, unregisterSyncEntry } = urlSyncSlice.actions;
+var selectUrlSyncEntries = (state2) => state2.urlSync.entries;
+var selectIsUrlHydrated = (state2) => state2.urlSync.isHydrated;
+
+// src/core/overlayStateSlice.ts
+var import_toolkit4 = require("@reduxjs/toolkit");
+var initialState4 = { entries: {} };
+var overlayStateSlice = (0, import_toolkit4.createSlice)({
+  name: "overlayState",
+  initialState: initialState4,
+  reducers: {
+    setOverlayStateValue(state2, action) {
+      const { key, name, value } = action.payload;
+      const entry = state2.entries[key] ??= { values: {}, updatedAt: 0 };
+      entry.values[name] = value;
+      entry.updatedAt = Date.now();
+    },
+    replaceOverlayState(state2, action) {
+      const { key, values } = action.payload;
+      state2.entries[key] = { values: { ...values }, updatedAt: Date.now() };
+    },
+    clearOverlayState(state2, action) {
+      delete state2.entries[action.payload.key];
+    },
+    hydrateOverlayState(state2, action) {
+      const now = Date.now();
+      for (const [key, entry] of Object.entries(action.payload.entries)) {
+        state2.entries[key] = { values: { ...entry.values }, updatedAt: entry.updatedAt ?? now };
+      }
+    }
+  }
+});
+var overlayStateReducer = overlayStateSlice.reducer;
+var { setOverlayStateValue, replaceOverlayState, clearOverlayState, hydrateOverlayState } = overlayStateSlice.actions;
+var EMPTY_VALUES = Object.freeze({});
+var selectOverlayStateValue = (state2, key, name) => state2.overlayState.entries[key]?.values[name];
+var selectOverlayStateFor = (state2, key) => state2.overlayState.entries[key]?.values ?? EMPTY_VALUES;
+
+// src/core/store.ts
+var import_toolkit5 = require("@reduxjs/toolkit");
+
+// src/core/middleware/closeLifecycle.ts
+var import_global_slot4 = require("@ai-matrx/kit/global-slot");
+
+// src/handles/callbackManager.ts
+var import_global_slot3 = require("@ai-matrx/kit/global-slot");
+
+// src/handles/ids.ts
+function newHandleId() {
+  const c = typeof globalThis.crypto === "undefined" ? void 0 : globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return c.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (c && typeof c.getRandomValues === "function") {
+    c.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/handles/callbackManager.ts
+var HANDLES_SLOT = "ai-matrx.summon.handles";
+var handlesState = () => (0, import_global_slot3.globalSlot)(HANDLES_SLOT, () => ({
+  callbacks: /* @__PURE__ */ new Map(),
+  groups: /* @__PURE__ */ new Map(),
+  owners: /* @__PURE__ */ new Map(),
+  registryListeners: /* @__PURE__ */ new Set()
+}));
+function invoke(slot, data, context) {
+  if (typeof slot !== "function") return void 0;
+  return slot(data, context);
+}
+function invokeListener(listener, data, context) {
+  return listener(data, context);
+}
+var CallbackManager = class {
+  get s() {
+    return handlesState();
+  }
+  /**
+   * Observe the registry itself: `listener` runs after any entry is added or removed. This lets a
+   * view that resolves ids with `get` re-render when an id goes away (`useSyncExternalStore`).
+   */
+  subscribeToRegistry(listener) {
+    const listeners = this.s.registryListeners;
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  notifyRegistry() {
+    for (const listener of [...this.s.registryListeners]) listener();
+  }
+  /** Register a callback; returns its id. */
+  register(callback) {
+    return this.registerEntry(callback, {});
+  }
+  /** Register with optional context, group and owner. */
+  registerWithContext(callback, options = {}) {
+    return this.registerEntry(callback, options);
+  }
+  /** @internal The one insertion path (typed helpers pass a fixed id and a removal hook). */
+  registerEntry(slot, options) {
+    const s = this.s;
+    const callbackId = options.id ?? newHandleId();
+    if (s.callbacks.has(callbackId)) this.deleteEntry(callbackId, false);
+    const entry = { callback: slot };
+    if (options.context !== void 0) entry.context = options.context;
+    if (options.groupId !== void 0) entry.groupId = options.groupId;
+    if (options.owner !== void 0) entry.owner = options.owner;
+    if (options.onRemove !== void 0) entry.onRemove = options.onRemove;
+    s.callbacks.set(callbackId, entry);
+    if (options.groupId !== void 0) {
+      const group = s.groups.get(options.groupId) ?? /* @__PURE__ */ new Set();
+      group.add(callbackId);
+      s.groups.set(options.groupId, group);
+    }
+    if (options.owner !== void 0) {
+      const owned = s.owners.get(options.owner) ?? /* @__PURE__ */ new Set();
+      owned.add(callbackId);
+      s.owners.set(options.owner, owned);
+    }
+    this.notifyRegistry();
+    return callbackId;
+  }
+  /** Subscribe to results for a callback id. */
+  subscribe(callbackId, listener) {
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry) return false;
+    (entry.listeners ??= []).push(listener);
+    return true;
+  }
+  /** Unsubscribe a listener from a callback id. */
+  unsubscribe(callbackId, listener) {
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry || !entry.listeners) return false;
+    const index = entry.listeners.indexOf(listener);
+    if (index === -1) return false;
+    entry.listeners.splice(index, 1);
+    return true;
+  }
+  /** Run a callback once, notify its listeners, then remove it. */
+  trigger(callbackId, data) {
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry) return;
+    void invoke(entry.callback, data);
+    if (entry.listeners && entry.listeners.length > 0) {
+      for (const listener of [...entry.listeners]) void invokeListener(listener, data);
+    }
+    this.deleteEntry(callbackId, true);
+  }
+  /** Trigger with merged context and progress; removes unless `removeAfterTrigger: false`. */
+  triggerWithContext(callbackId, data, options) {
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry) return;
+    const mergedContext = {
+      ...entry.context,
+      ...options?.context,
+      ...options?.progress && { progress: options.progress }
+    };
+    void invoke(entry.callback, data, mergedContext);
+    if (entry.listeners && entry.listeners.length > 0) {
+      for (const listener of [...entry.listeners]) void invokeListener(listener, data, mergedContext);
+    }
+    if (options?.removeAfterTrigger !== false) this.deleteEntry(callbackId, true);
+  }
+  /** Trigger every callback in a group. */
+  triggerGroup(groupId, data, options) {
+    const group = this.s.groups.get(groupId);
+    if (!group) return;
+    for (const callbackId of [...group]) this.triggerWithContext(callbackId, data, options);
+    if (options?.removeAfterTrigger !== false) this.s.groups.delete(groupId);
+  }
+  /**
+   * Run the one durable command registered for a group. A command is retained on rejection so its
+   * caller can retry, and is removed only after its promise settles successfully.
+   */
+  async triggerGroupCommand(groupId, data, options) {
+    const group = this.s.groups.get(groupId);
+    const callbackIds = group ? [...group] : [];
+    const callbackId = callbackIds[0];
+    if (callbackIds.length !== 1 || callbackId === void 0) {
+      throw new Error(`Expected exactly one command callback for group "${groupId}", found ${callbackIds.length}`);
+    }
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry) throw new Error(`Command callback "${callbackId}" is no longer available`);
+    const mergedContext = { ...entry.context, ...options?.context };
+    await invoke(entry.callback, data, mergedContext);
+    for (const listener of entry.listeners ?? []) {
+      try {
+        await invokeListener(listener, data, mergedContext);
+      } catch (error) {
+        console.error("[overlays/handles] command observer failed", error);
+      }
+    }
+    if (options?.removeAfterSuccess !== false) {
+      this.deleteEntry(callbackId, true);
+      this.s.groups.delete(groupId);
+    }
+  }
+  /** Report progress to a callback (or every callback of a group) without removing it. */
+  updateProgress(id, progress, options) {
+    const progressInfo = { progress, status: options?.status || "running" };
+    if (options?.error !== void 0) progressInfo.error = options.error;
+    if (options?.groupId) {
+      this.triggerGroup(id, null, { progress: progressInfo, removeAfterTrigger: false });
+    } else {
+      this.triggerWithContext(id, null, { progress: progressInfo, removeAfterTrigger: false });
+    }
+  }
+  /** Create a new, empty group and return its id. */
+  createGroup() {
+    const groupId = newHandleId();
+    this.s.groups.set(groupId, /* @__PURE__ */ new Set());
+    return groupId;
+  }
+  /** Remove one entry (and its group/owner membership). */
+  remove(callbackId) {
+    this.deleteEntry(callbackId, true);
+  }
+  /** Alias of `remove` — the preferred name when unregistering a handle on unmount. */
+  unregister(callbackId) {
+    this.remove(callbackId);
+  }
+  /** The stored callback or object handle for an id, without invoking it. */
+  get(callbackId) {
+    return this.s.callbacks.get(callbackId)?.callback;
+  }
+  /** True when the id is registered. */
+  has(callbackId) {
+    return this.s.callbacks.has(callbackId);
+  }
+  /**
+   * Register an object handle (a widget handle, an editor API, …). The object occupies the slot;
+   * it is never invoked by `trigger`, only retrieved with `get`.
+   */
+  registerWidgetHandle(handle, options = {}) {
+    return this.registerEntry(handle, options.owner === void 0 ? {} : { owner: options.owner });
+  }
+  /** Remove a group and all its callbacks. */
+  removeGroup(groupId) {
+    const s = this.s;
+    const group = s.groups.get(groupId);
+    if (!group) return;
+    s.groups.delete(groupId);
+    for (const callbackId of [...group]) this.deleteEntry(callbackId, false);
+    this.notifyRegistry();
+  }
+  /** Remove everything registered with `owner` (an InstanceKey). Returns how many were removed. */
+  disposeOwner(owner) {
+    const s = this.s;
+    const owned = s.owners.get(owner);
+    if (!owned) return 0;
+    s.owners.delete(owner);
+    const ids = [...owned];
+    for (const callbackId of ids) this.deleteEntry(callbackId, false);
+    if (ids.length > 0) this.notifyRegistry();
+    return ids.length;
+  }
+  /** Ids currently owned by `owner`. */
+  ownedBy(owner) {
+    return [...this.s.owners.get(owner) ?? []];
+  }
+  /** The member ids of a group (empty when unknown). */
+  groupMembers(groupId) {
+    return [...this.s.groups.get(groupId) ?? []];
+  }
+  /** Total registered entries (diagnostics, leak tests). */
+  size() {
+    return this.s.callbacks.size;
+  }
+  /**
+   * The one removal path. Reads the entry BEFORE deleting it so group and owner membership shrink
+   * (the old `removeFromGroups`-after-delete bug), then runs the entry's removal hook.
+   */
+  deleteEntry(callbackId, notify) {
+    const s = this.s;
+    const entry = s.callbacks.get(callbackId);
+    if (!entry) return;
+    s.callbacks.delete(callbackId);
+    if (entry.groupId !== void 0) {
+      const group = s.groups.get(entry.groupId);
+      group?.delete(callbackId);
+      if (group?.size === 0) s.groups.delete(entry.groupId);
+    }
+    if (entry.owner !== void 0) {
+      const owned = s.owners.get(entry.owner);
+      owned?.delete(callbackId);
+      if (owned?.size === 0) s.owners.delete(entry.owner);
+    }
+    if (notify) this.notifyRegistry();
+    entry.onRemove?.();
+  }
+};
+var callbackManager = new CallbackManager();
+
+// src/core/middleware/closeLifecycle.ts
+var closeState = () => (0, import_global_slot4.globalSlot)("ai-matrx.summon.closeLifecycle", () => ({ flushers: /* @__PURE__ */ new Set() }));
+function registerCloseFlusher(flush) {
+  const { flushers } = closeState();
+  flushers.add(flush);
+  return () => {
+    flushers.delete(flush);
+  };
+}
+function dedupe(identities) {
+  return [...new Map(identities.map((identity) => [`${identity.overlayId}:${identity.instanceId}`, identity])).values()];
+}
+function preservedIdentities(state2, overlayId) {
+  const wm = state2.windowManager;
+  if (!wm) return [];
+  const identities = [];
+  for (const entry of Object.values(wm.windows)) {
+    if (!entry.persistence || entry.persistence.closing) continue;
+    if (overlayId && entry.persistence.overlayId !== overlayId) continue;
+    identities.push({ overlayId: entry.persistence.overlayId, instanceId: entry.persistence.instanceId });
+  }
+  for (const session of Object.values(wm.pendingRestores)) {
+    if (overlayId && session.overlayId !== overlayId) continue;
+    identities.push({ overlayId: session.overlayId, instanceId: session.instanceId });
+  }
+  return identities;
+}
+function isPlainRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var CLOSE_TYPES = /* @__PURE__ */ new Set([
+  overlaysRawActions.closeOverlay.type,
+  overlaysRawActions.toggleOverlay.type,
+  overlaysRawActions.closeAllOverlays.type,
+  overlaysRawActions.closeAllInstancesOfOverlay.type,
+  overlaysRawActions.closeOverlaysBoundToPage.type
+]);
+function releaseOverlayInstance(dispatch, key, options = {}) {
+  callbackManager.disposeOwner(key);
+  if (!options.keepState) dispatch(clearOverlayState({ key }));
+}
+function closeInstanceResources(api, key) {
+  const parsed = parseInstanceKey(key);
+  const keepAlive = parsed ? getOverlayMeta(parsed.overlayId)?.keepAlive : void 0;
+  if (keepAlive === "hidden") return;
+  const hasState = api.getState().overlayState?.entries[key] !== void 0;
+  callbackManager.disposeOwner(key);
+  if (keepAlive !== "restore" && hasState) api.dispatch(clearOverlayState({ key }));
+}
+var closeLifecycleMiddleware = (api) => (next) => (action) => {
+  if (!isPlainRecord2(action) || typeof action.type !== "string" || !CLOSE_TYPES.has(action.type)) {
+    return next(action);
+  }
+  const type = action.type;
+  const payload = isPlainRecord2(action.payload) ? action.payload : null;
+  const before = api.getState();
+  const openBefore = new Set(listOpenInstanceKeys(before));
+  let closing = [];
+  const intents = [];
+  const overlayId = typeof payload?.overlayId === "string" ? payload.overlayId : null;
+  if (type === overlaysRawActions.closeAllOverlays.type) {
+    closing = preservedIdentities(before);
+    intents.push({ scope: "all" });
+  } else if (type === overlaysRawActions.closeAllInstancesOfOverlay.type && overlayId) {
+    closing = preservedIdentities(before, overlayId);
+    intents.push({ scope: "overlay", overlayId });
+  } else if ((type === overlaysRawActions.closeOverlay.type || type === overlaysRawActions.toggleOverlay.type) && overlayId) {
+    const instanceId = typeof payload?.instanceId === "string" ? payload.instanceId : DEFAULT_INSTANCE_ID;
+    const wasOpen = before.overlays.overlays[overlayId]?.[instanceId]?.isOpen === true;
+    if (type === overlaysRawActions.closeOverlay.type || wasOpen) {
+      closing = [{ overlayId, instanceId }];
+      intents.push({ scope: "exact", overlayId, instanceId });
+    }
+  }
+  const result = next(action);
+  const openAfter = new Set(listOpenInstanceKeys(api.getState()));
+  const closedKeys = [...openBefore].filter((key) => !openAfter.has(key));
+  if (type === overlaysRawActions.closeOverlaysBoundToPage.type) {
+    for (const key of closedKeys) {
+      const parsed = parseInstanceKey(key);
+      if (parsed) closing.push(parsed);
+    }
+  }
+  const exact = dedupe(closing);
+  if (api.getState().windowManager) {
+    for (const identity of exact) api.dispatch(markWindowClosing(identity));
+  }
+  const released = new Set(closedKeys);
+  for (const intent of intents) {
+    if (intent.scope === "exact") released.add(`${intent.overlayId}:${intent.instanceId}`);
+  }
+  for (const key of released) closeInstanceResources(api, key);
+  if (exact.length > 0 || closedKeys.length > 0 || type === overlaysRawActions.closeAllOverlays.type || type === overlaysRawActions.closeAllInstancesOfOverlay.type) {
+    const event = { intents, closedKeys, actionType: type };
+    for (const flush of [...closeState().flushers]) flush(event);
+  }
+  return result;
+};
+
+// src/core/middleware/renderWatchdog.ts
+var import_global_slot5 = require("@ai-matrx/kit/global-slot");
+var LAZY_WINDOW_MOUNT_DEADLINE_MS = process.env.NODE_ENV === "production" ? 12e3 : 45e3;
+var OPEN_TYPE = "overlays/openOverlay";
+var TOGGLE_TYPE = "overlays/toggleOverlay";
+var DEFAULT_INSTANCE_ID2 = "default";
+function isPlainRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var CHECK_DELAY_MS = 2500;
+var ACK_SETTLE_MS = 300;
+var ACK_SETTLE_RETRY_MS = 700;
+var NO_MOUNT_DEADLINE_MS = LAZY_WINDOW_MOUNT_DEADLINE_MS;
+var TOAST_DURATION_MS = 8e3;
+var RECOVERY_POLL_MS = 500;
+var RENDER_WATCHDOG_SLOT = "ai-matrx.summon.renderWatchdog";
+var watchdogState = () => (0, import_global_slot5.globalSlot)(RENDER_WATCHDOG_SLOT, () => ({
+  renderAcks: /* @__PURE__ */ new Map(),
+  ackWaiters: /* @__PURE__ */ new Map(),
+  watches: /* @__PURE__ */ new Map()
+}));
+function notifyRenderAck(overlayId) {
+  const notify = watchdogState().ackWaiters.get(overlayId);
+  if (notify) {
+    watchdogState().ackWaiters.delete(overlayId);
+    notify();
+  }
+}
+function ackOverlayRender(overlayId, windowId) {
+  watchdogState().renderAcks.set(overlayId, { kind: "window", windowId });
+  notifyRenderAck(overlayId);
+}
+function clearOverlayRender(overlayId, windowId) {
+  const ack = watchdogState().renderAcks.get(overlayId);
+  if (ack?.kind === "window" && ack.windowId === windowId) {
+    watchdogState().renderAcks.delete(overlayId);
+  }
+}
+function ackOverlaySurfaceRender(overlayId) {
+  watchdogState().renderAcks.set(overlayId, { kind: "surface" });
+  notifyRenderAck(overlayId);
+}
+function clearOverlaySurfaceRender(overlayId) {
+  if (watchdogState().renderAcks.get(overlayId)?.kind === "surface") {
+    watchdogState().renderAcks.delete(overlayId);
+  }
+}
+function acknowledgedWindowId(overlayId, fallback) {
+  const ack = watchdogState().renderAcks.get(overlayId);
+  return ack?.kind === "window" ? ack.windowId : fallback;
+}
+function rectOnScreen(rect, viewportWidth, viewportHeight) {
+  const MARGIN = 24;
+  const intersectsX = rect.x < viewportWidth - MARGIN && rect.x + rect.width > MARGIN;
+  const intersectsY = rect.y < viewportHeight - MARGIN && rect.y + rect.height > MARGIN;
+  return intersectsX && intersectsY;
+}
+function diagnoseOverlayRender(args) {
+  const {
+    entry,
+    windowsHidden,
+    viewportWidth,
+    viewportHeight,
+    surfaceAcknowledged = false
+  } = args;
+  if (surfaceAcknowledged) return { ok: true, reason: null };
+  if (!entry) return { ok: false, reason: "no-window-registered" };
+  if (entry.popoutMode !== null) return { ok: true, reason: null };
+  if (windowsHidden) return { ok: false, reason: "all-windows-hidden" };
+  if (entry.state === "minimized") return { ok: true, reason: null };
+  if (entry.state === "maximized") return { ok: true, reason: null };
+  if (entry.windowed.width <= 1 || entry.windowed.height <= 1) {
+    return { ok: false, reason: "zero-size" };
+  }
+  if (!rectOnScreen(entry.windowed, viewportWidth, viewportHeight)) {
+    return { ok: false, reason: "off-screen" };
+  }
+  return { ok: true, reason: null };
+}
+var REASON_HINT = {
+  "no-window-registered": "no <WindowPanel> mounted for this overlay \u2014 check its definition's render module, the lazy import, and that the component returns a <WindowPanel> when open",
+  "all-windows-hidden": "the global 'Hide all windows' flag is on \u2014 opening should have cleared it (revealWindow)",
+  "zero-size": "the window rect collapsed to zero size",
+  "off-screen": "the window rect is outside the viewport \u2014 opening should have clamped it"
+};
+function endWatch(watch) {
+  if (watch.timer !== null) globalThis.clearTimeout(watch.timer);
+  if (watch.deadlineTimer !== null) globalThis.clearTimeout(watch.deadlineTimer);
+  watchdogState().ackWaiters.delete(watch.overlayId);
+  watchdogState().watches.delete(watch.overlayId);
+}
+function evaluate(store, watch) {
+  const state2 = store.getState();
+  if (!selectIsOverlayOpen(state2, watch.overlayId, DEFAULT_INSTANCE_ID2)) {
+    return null;
+  }
+  const ack = watchdogState().renderAcks.get(watch.overlayId);
+  const windowId = ack?.kind === "window" ? ack.windowId : watch.slug;
+  const entry = state2.windowManager.windows[windowId];
+  const { vw, vh, degenerate } = safeViewportDims();
+  return {
+    viewportWidth: vw,
+    viewportHeight: vh,
+    viewportDegenerate: degenerate,
+    renderAcknowledgement: ack?.kind ?? "none",
+    diag: diagnoseOverlayRender({
+      entry,
+      windowsHidden: state2.windowManager.windowsHidden,
+      viewportWidth: vw,
+      viewportHeight: vh,
+      surfaceAcknowledged: ack?.kind === "surface"
+    }),
+    windowId,
+    entry,
+    windowsHidden: state2.windowManager.windowsHidden
+  };
+}
+function startWatch(store, ports, overlayId, slug, label) {
+  if (watchdogState().watches.has(overlayId)) return;
+  const watch = { overlayId, slug, label, ports, timer: null, deadlineTimer: null };
+  watchdogState().watches.set(overlayId, watch);
+  watch.timer = globalThis.setTimeout(() => {
+    watch.timer = null;
+    const res = evaluate(store, watch);
+    if (!res) return endWatch(watch);
+    if (res.diag.ok) return endWatch(watch);
+    if (res.diag.reason === "no-window-registered" && !watchdogState().renderAcks.has(overlayId)) {
+      waitForMount(store, watch);
+      return;
+    }
+    scream(store, watch, res);
+    endWatch(watch);
+  }, CHECK_DELAY_MS);
+}
+function waitForMount(store, watch) {
+  const checkAfterAck = (delay, isRetry) => {
+    watch.timer = globalThis.setTimeout(() => {
+      watch.timer = null;
+      const res = evaluate(store, watch);
+      if (!res) return endWatch(watch);
+      if (res.diag.ok) return endWatch(watch);
+      if (res.diag.reason === "no-window-registered" && !isRetry) {
+        checkAfterAck(ACK_SETTLE_RETRY_MS, true);
+        return;
+      }
+      scream(store, watch, res);
+      endWatch(watch);
+    }, delay);
+  };
+  watchdogState().ackWaiters.set(watch.overlayId, () => {
+    if (watch.deadlineTimer !== null) {
+      globalThis.clearTimeout(watch.deadlineTimer);
+      watch.deadlineTimer = null;
+    }
+    checkAfterAck(ACK_SETTLE_MS, false);
+  });
+  watch.deadlineTimer = globalThis.setTimeout(() => {
+    watch.deadlineTimer = null;
+    watchdogState().ackWaiters.delete(watch.overlayId);
+    const res = evaluate(store, watch);
+    if (!res) return endWatch(watch);
+    if (res.diag.ok) return endWatch(watch);
+    scream(store, watch, res);
+    endWatch(watch);
+  }, NO_MOUNT_DEADLINE_MS);
+}
+function scream(store, watch, res) {
+  const { overlayId, label } = watch;
+  const reason = res.diag.ok ? null : res.diag.reason;
+  if (reason === null) return;
+  watch.ports.errors.capture(
+    new Error(
+      `[summon] SILENT RENDER FAILURE \u2014 overlay "${overlayId}" was opened but no visible panel is on screen (reason: ${reason}). ${REASON_HINT[reason]}.`
+    ),
+    {
+      overlayId,
+      windowId: res.windowId,
+      viewportWidth: res.viewportWidth,
+      viewportHeight: res.viewportHeight,
+      viewportDegenerate: res.viewportDegenerate,
+      renderAcknowledgement: res.renderAcknowledgement,
+      entry: res.entry,
+      windowsHidden: res.windowsHidden
+    }
+  );
+  const toastId = `window-watchdog-${overlayId}`;
+  watch.ports.notify.error(`"${label}" didn't appear`, {
+    id: toastId,
+    description: "The panel was opened but isn't visible. Click to show it.",
+    duration: TOAST_DURATION_MS,
+    action: {
+      label: "Show it",
+      onClick: () => {
+        const dims = safeViewportDims();
+        store.dispatch(
+          revealWindow({
+            id: acknowledgedWindowId(overlayId, watch.slug),
+            viewportWidth: dims.vw,
+            viewportHeight: dims.vh
+          })
+        );
+      }
+    }
+  });
+  let elapsed = 0;
+  const interval = globalThis.setInterval(() => {
+    elapsed += RECOVERY_POLL_MS;
+    const check = evaluate(store, watch);
+    if (check === null || check.diag.ok) {
+      globalThis.clearInterval(interval);
+      watch.ports.notify.dismiss?.(toastId);
+      if (check?.diag.ok) {
+        console.info(
+          `[summon] overlay "${overlayId}" became visible after the recovery scream \u2014 toast withdrawn. If this recurs, the pre-scream wait is ending too early for this panel.`
+        );
+      }
+      return;
+    }
+    if (elapsed >= TOAST_DURATION_MS) globalThis.clearInterval(interval);
+  }, RECOVERY_POLL_MS);
+}
+function watchdogTracksOpen(meta, instanceId) {
+  if (!meta || !meta.window) return false;
+  if (meta.instance === "multi") return false;
+  return instanceId === DEFAULT_INSTANCE_ID2;
+}
+function createOverlayRenderWatchdogMiddleware(ports) {
+  return (store) => (next) => (action) => {
+    const result = next(action);
+    if (typeof window === "undefined") return result;
+    const typed = action;
+    if (typed.type !== OPEN_TYPE && typed.type !== TOGGLE_TYPE) return result;
+    const payload = typed.payload;
+    const overlayId = isPlainRecord3(payload) && typeof payload.overlayId === "string" ? payload.overlayId : void 0;
+    if (!overlayId) return result;
+    const instanceIdRaw = isPlainRecord3(payload) && typeof payload.instanceId === "string" ? payload.instanceId : void 0;
+    const meta = getOverlayMeta(overlayId);
+    if (!meta || !watchdogTracksOpen(meta, instanceIdRaw ?? DEFAULT_INSTANCE_ID2)) {
+      return result;
+    }
+    const state2 = store.getState();
+    if (!selectIsOverlayOpen(state2, overlayId, DEFAULT_INSTANCE_ID2)) {
+      return result;
+    }
+    const slug = defaultWindowIdFor(meta);
+    const revealDims = safeViewportDims();
+    store.dispatch(
+      revealWindow({
+        id: acknowledgedWindowId(overlayId, slug),
+        viewportWidth: revealDims.vw,
+        viewportHeight: revealDims.vh
+      })
+    );
+    startWatch(store, ports, overlayId, slug, meta.label || overlayId);
+    return result;
+  };
+}
+function resetOverlayRenderWatchdog() {
+  const s = watchdogState();
+  for (const watch of [...s.watches.values()]) endWatch(watch);
+  s.renderAcks.clear();
+  s.ackWaiters.clear();
+}
+
+// src/core/store.ts
+var summonReducers = {
+  overlays: overlaysReducer,
+  windowManager: windowManagerReducer,
+  urlSync: linksReducer,
+  overlayState: overlayStateReducer
+};
+function createSummonMiddleware(ports) {
+  const resolved = resolvePorts(ports);
+  return [closeLifecycleMiddleware, createOverlayRenderWatchdogMiddleware(resolved)];
+}
+function createSummonStore(options = {}) {
+  const reducer = (0, import_toolkit5.combineReducers)({ ...options.extraReducers, ...summonReducers });
+  const middleware = createSummonMiddleware(options.ports);
+  return (0, import_toolkit5.configureStore)({
+    reducer,
+    ...options.preloadedState === void 0 ? {} : { preloadedState: options.preloadedState },
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(middleware)
+  });
+}
+
+// src/core/geometry/dockWindowPayload.ts
+function buildDockWindowPayload(windowId) {
+  return {
+    id: windowId,
+    viewportWidth: window.innerWidth,
+    viewportHeight: window.innerHeight
+  };
+}
+//# sourceMappingURL=index.cjs.map