@ai-matrx/summon 0.1.16 → 0.1.18

package/dist/index.js

@@ -1,228 +1,61 @@
-// 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
-import { globalSlot } from "@ai-matrx/kit/global-slot";
-var state = () => 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();
-}
+import {
+  DEFAULT_INSTANCE_ID,
+  DEFAULT_PORTS,
+  allOverlayMeta,
+  anonymousIdentity,
+  closeAllInstancesOfOverlay,
+  closeOverlay,
+  closeOverlaysBoundToPage,
+  consoleErrorSink,
+  consoleNotify,
+  debugOff,
+  defaultWindowIdFor,
+  dropPendingChannelsOf,
+  getOverlayMeta,
+  getOverlayMetaByLinkKey,
+  installSummonCore,
+  instanceKey,
+  isRegisteredOverlay,
+  listOpenInstanceKeys,
+  locationRouter,
+  openOverlay,
+  overlayIdsBoundToPage,
+  parseInstanceKey,
+  registerOverlayMeta,
+  resetOverlayRegistry,
+  resolvePorts,
+  selectIsOverlayOpen,
+  selectOpenInstances,
+  selectOverlay,
+  selectOverlayData,
+  subscribeToOverlayRegistry,
+  toggleOverlay
+} from "./chunk-server-C4KQZFIN.js";
+import {
+  callbackManager
+} from "./chunk-server-WP7NOTZQ.js";
+import "./chunk-server-H7NUWPEM.js";
 
 // src/core/overlaysSlice.ts
 import { createSlice } from "@reduxjs/toolkit";
-
-// src/open/actions.ts
-function creator(type, build) {
-  const create = (...args) => ({ type, payload: build(...args) });
-  return Object.assign(create, {
-    type,
-    toString: () => type,
-    match: (action) => typeof action === "object" && action !== null && action.type === type
-  });
-}
-function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stripFunctions(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 rawOpen(payload) {
-  const raw = { overlayId: payload.overlayId };
-  if (payload.instanceId !== void 0) raw.instanceId = payload.instanceId;
-  if (payload.data !== void 0) raw.data = stripFunctions(payload.overlayId, payload.data);
-  const defaults = getOverlayMeta(payload.overlayId)?.defaults;
-  if (isPlainRecord(defaults)) raw.defaults = stripFunctions(payload.overlayId, defaults);
-  return raw;
-}
-var O = "overlays/";
-var openOverlay = creator(O + "openOverlay", (payload) => rawOpen(payload));
-var closeOverlay = creator(
-  O + "closeOverlay",
-  (payload) => payload.instanceId === void 0 ? { overlayId: payload.overlayId } : { overlayId: payload.overlayId, instanceId: payload.instanceId }
-);
-var toggleOverlay = creator(O + "toggleOverlay", (payload) => rawOpen(payload));
-var closeAllInstancesOfOverlay = creator(O + "closeAllInstancesOfOverlay", (payload) => ({
-  overlayId: payload.overlayId
-}));
-function overlayIdsBoundToPage() {
-  return allOverlayMeta().filter((meta) => meta.closesOnNavigation === true).map((meta) => meta.id);
-}
-var closeOverlaysBoundToPage = creator(
-  O + "closeOverlaysBoundToPage",
-  (payload) => ({
-    overlayIds: [...payload?.overlayIds ?? overlayIdsBoundToPage()]
-  })
-);
-var closeAllOverlays = creator(O + "closeAllOverlays", () => void 0);
-var pruneStaleInstances = creator(O + "pruneStaleInstances", (payload) => payload);
-var W = "windowManager/";
-var pass = () => (payload) => payload;
-var focusWindow = creator(W + "focusWindow", pass());
-var restoreWindow = creator(W + "restoreWindow", pass());
-var toggleWindowsHidden = creator(W + "toggleWindowsHidden", () => void 0);
-var restoreAll = creator(W + "restoreAll", () => void 0);
-var minimizeAll = creator(W + "minimizeAll", pass());
-var arrangeActiveWindows = creator(W + "arrangeActiveWindows", pass());
-var revealWindow = creator(W + "revealWindow", pass());
-var updateWindowRect = creator(
-  W + "updateWindowRect",
-  pass()
-);
-var setOverlayStateValue = creator("overlayState/setOverlayStateValue", pass());
-var registerSyncEntry = creator("urlSync/registerSyncEntry", pass());
-var unregisterSyncEntry = creator("urlSync/unregisterSyncEntry", pass());
-
-// src/open/selectors.ts
-import { globalSlot as globalSlot2 } from "@ai-matrx/kit/global-slot";
-var overlaysOf = (state2) => state2.overlays;
-var CLOSED = Object.freeze({ isOpen: false, data: null });
-var EMPTY = Object.freeze([]);
-var selectOverlay = (state2, overlayId, instanceId = DEFAULT_INSTANCE_ID) => overlaysOf(state2)?.overlays[overlayId]?.[instanceId] ?? CLOSED;
-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 openCache = () => globalSlot2("ai-matrx.summon.openInstances", () => /* @__PURE__ */ new Map());
-var selectOpenInstances = (state2, overlayId) => {
-  const bucket = overlaysOf(state2)?.overlays[overlayId];
-  const cache = openCache();
-  const hit = cache.get(overlayId);
-  if (hit && hit.bucket === bucket) return hit.result;
-  let result = EMPTY;
-  if (bucket) {
-    const open = [];
-    for (const [instanceId, inst] of Object.entries(bucket)) if (inst.isOpen) open.push({ instanceId, data: inst.data });
-    if (open.length > 0) result = open;
-  }
-  cache.set(overlayId, { bucket, result });
-  return result;
-};
-function listOpenInstanceKeys(state2) {
-  const keys = [];
-  for (const [overlayId, bucket] of Object.entries(overlaysOf(state2)?.overlays ?? {})) {
-    for (const [instanceId, inst] of Object.entries(bucket)) if (inst.isOpen) keys.push(`${overlayId}:${instanceId}`);
-  }
-  return keys;
-}
-var EMPTY_WINDOWS = Object.freeze([]);
-
-// src/core/overlaysSlice.ts
 var initialState = { overlays: {} };
-function isPlainRecord2(value) {
+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 (isPlainRecord2(data)) return { ...defaults, ...data };
+  if (isPlainRecord(data)) return { ...defaults, ...data };
   return data;
 }
-function closeInstance(state2, overlayId, instanceId) {
-  const bucket = state2.overlays[overlayId];
+function closeInstance(state, overlayId, instanceId) {
+  const bucket = state.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];
+    if (Object.keys(bucket).length === 0) delete state.overlays[overlayId];
     return;
   }
   instance.isOpen = false;
@@ -232,17 +65,17 @@ var overlaysSlice = createSlice({
   name: "overlays",
   initialState,
   reducers: {
-    openOverlay: (state2, action) => {
+    openOverlay: (state, action) => {
       const { overlayId, instanceId = DEFAULT_INSTANCE_ID, data, defaults } = action.payload;
-      const bucket = state2.overlays[overlayId] ??= {};
+      const bucket = state.overlays[overlayId] ??= {};
       bucket[instanceId] = { isOpen: true, data: withDefaults(data, defaults), lastUsedAt: Date.now() };
     },
-    closeOverlay: (state2, action) => {
+    closeOverlay: (state, action) => {
       const { overlayId, instanceId = DEFAULT_INSTANCE_ID } = action.payload;
-      closeInstance(state2, overlayId, instanceId);
+      closeInstance(state, overlayId, instanceId);
     },
-    closeAllOverlays: (state2) => {
-      for (const [overlayId, bucket] of Object.entries(state2.overlays)) {
+    closeAllOverlays: (state) => {
+      for (const [overlayId, bucket] of Object.entries(state.overlays)) {
         for (const [instanceId, instance] of Object.entries(bucket)) {
           if (instanceId === DEFAULT_INSTANCE_ID) {
             instance.isOpen = false;
@@ -251,17 +84,17 @@ var overlaysSlice = createSlice({
             delete bucket[instanceId];
           }
         }
-        if (Object.keys(bucket).length === 0) delete state2.overlays[overlayId];
+        if (Object.keys(bucket).length === 0) delete state.overlays[overlayId];
       }
     },
-    toggleOverlay: (state2, action) => {
+    toggleOverlay: (state, action) => {
       const { overlayId, instanceId = DEFAULT_INSTANCE_ID, data, defaults } = action.payload;
-      const bucket = state2.overlays[overlayId] ??= {};
+      const bucket = state.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);
+        closeInstance(state, overlayId, instanceId);
       } else {
         existing.isOpen = true;
         existing.data = data === void 0 || data === null ? existing.data : withDefaults(data, defaults);
@@ -269,17 +102,17 @@ var overlaysSlice = createSlice({
       }
     },
     /** Removes every instance of an overlay id (e.g. an editor that spawned many tabs). */
-    closeAllInstancesOfOverlay: (state2, action) => {
-      delete state2.overlays[action.payload.overlayId];
+    closeAllInstancesOfOverlay: (state, action) => {
+      delete state.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) => {
+    closeOverlaysBoundToPage: (state, action) => {
       for (const overlayId of action.payload.overlayIds) {
-        const bucket = state2.overlays[overlayId];
+        const bucket = state.overlays[overlayId];
         if (!bucket) continue;
         for (const [instanceId, instance] of Object.entries(bucket)) {
           if (!instance.isOpen) continue;
@@ -290,29 +123,29 @@ var overlaysSlice = createSlice({
             delete bucket[instanceId];
           }
         }
-        if (Object.keys(bucket).length === 0) delete state2.overlays[overlayId];
+        if (Object.keys(bucket).length === 0) delete state.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) => {
+    pruneStaleInstances: (state, action) => {
       const cutoff = Date.now() - action.payload.olderThanMs;
-      for (const [overlayId, bucket] of Object.entries(state2.overlays)) {
+      for (const [overlayId, bucket] of Object.entries(state.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];
+        if (Object.keys(bucket).length === 0) delete state.overlays[overlayId];
       }
     }
   }
 });
 var overlaysReducer = overlaysSlice.reducer;
 var overlaysRawActions = overlaysSlice.actions;
-var { closeAllOverlays: closeAllOverlays2, pruneStaleInstances: pruneStaleInstances2 } = overlaysSlice.actions;
+var { closeAllOverlays, pruneStaleInstances } = overlaysSlice.actions;
 
 // src/core/windowManagerSlice.ts
 import {
@@ -618,11 +451,11 @@ function trayChipsPerRow(viewportWidth) {
     Math.floor((usable + TRAY_GAP_X) / (chipWidth + TRAY_GAP_X))
   );
 }
-function traySlotRect(slot2, viewportWidth, viewportHeight, totalSlots = slot2 + 1) {
+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(slot2));
+  const safeSlot = Math.max(0, Math.floor(slot));
   const usableHeight = Math.max(1, viewportHeight - TRAY_MARGIN_B - 8);
   const fullRows = Math.max(
     1,
@@ -684,71 +517,71 @@ var initialState2 = {
   popoutCandidateId: null,
   transientZ: {}
 };
-function recomputeAllTrayRects(state2) {
-  const viewport = state2.trayViewport;
+function recomputeAllTrayRects(state) {
+  const viewport = state.trayViewport;
   if (!viewport) return;
-  Object.values(state2.windows).forEach((entry) => {
+  Object.values(state.windows).forEach((entry) => {
     if (entry.traySlot === null) return;
     entry.windowed = traySlotRect(
       entry.traySlot,
       viewport.width,
       viewport.height,
-      state2.trayCount
+      state.trayCount
     );
   });
-  Object.values(state2.pendingRestores).forEach((session) => {
+  Object.values(state.pendingRestores).forEach((session) => {
     if (session.traySlot === null) return;
     session.renderRect = traySlotRect(
       session.traySlot,
       viewport.width,
       viewport.height,
-      state2.trayCount
+      state.trayCount
     );
   });
 }
-function hasMatchingLiveTrayReservation(state2, overlayId, instanceId, traySlot) {
+function hasMatchingLiveTrayReservation(state, overlayId, instanceId, traySlot) {
   if (traySlot === null) return false;
-  return Object.values(state2.windows).some(
+  return Object.values(state.windows).some(
     (entry) => entry.persistence?.overlayId === overlayId && entry.persistence.instanceId === instanceId && entry.traySlot === traySlot
   );
 }
-function compactReservedTraySlot(state2, freedSlot, freedRect) {
+function compactReservedTraySlot(state, freedSlot, freedRect) {
   const rectBySlot = /* @__PURE__ */ new Map();
   rectBySlot.set(freedSlot, freedRect);
-  Object.values(state2.windows).forEach((entry) => {
+  Object.values(state.windows).forEach((entry) => {
     if (entry.traySlot !== null) {
       rectBySlot.set(entry.traySlot, { ...entry.windowed });
     }
   });
-  Object.values(state2.pendingRestores).forEach((session) => {
+  Object.values(state.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) => {
+  state.trayCount = Math.max(0, state.trayCount - 1);
+  if (state.trayCount === 0) state.trayViewport = null;
+  Object.values(state.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) => {
+  Object.values(state.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);
+  recomputeAllTrayRects(state);
 }
-function releaseTraySlot(state2, win) {
+function releaseTraySlot(state, win) {
   const freedSlot = win.traySlot;
   if (freedSlot === null) return;
   const freedRect = { ...win.windowed };
   win.traySlot = null;
-  compactReservedTraySlot(state2, freedSlot, freedRect);
+  compactReservedTraySlot(state, freedSlot, freedRect);
 }
 var windowManagerSlice = createSlice2({
   name: "windowManager",
@@ -759,73 +592,73 @@ var windowManagerSlice = createSlice2({
      * that is already there. Same counter as `focusWindow`, so heavy and lite
      * windows interleave correctly.
      */
-    raiseTransientWindow(state2, action) {
-      state2.transientZ[action.payload] = state2.nextZIndex++;
+    raiseTransientWindow(state, action) {
+      state.transientZ[action.payload] = state.nextZIndex++;
     },
     /** Drop a transient window's z registration when it unmounts. */
-    releaseTransientWindow(state2, action) {
-      delete state2.transientZ[action.payload];
+    releaseTransientWindow(state, action) {
+      delete state.transientZ[action.payload];
     },
     /** Register a new window. Idempotent — ignored if id already exists. */
-    registerWindow(state2, action) {
+    registerWindow(state, action) {
       const { id, title, initial, initialState: initialState5, persistence, viewport } = action.payload;
-      if (state2.windows[id]) return;
+      if (state.windows[id]) return;
       const safeInitial = viewport ? clampRectToViewport(initial, viewport) : initial;
-      const pending2 = persistence ? state2.pendingRestores[windowSessionKey(persistence.overlayId, persistence.instanceId)] : void 0;
-      const pendingRenderRect = pending2 ? pending2.state === "minimized" && pending2.traySlot !== null && viewport ? traySlotRect(
-        pending2.traySlot,
+      const pending = persistence ? state.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(pending2.windowedRect, viewport) : pending2.renderRect : void 0;
-      const startsMinimized = !pending2 && initialState5 === "minimized" && viewport !== void 0;
-      const initialTraySlot = startsMinimized ? state2.trayCount : null;
-      state2.windows[id] = {
+        state.trayCount
+      ) : viewport ? clampRectToViewport(pending.windowedRect, viewport) : pending.renderRect : void 0;
+      const startsMinimized = !pending && initialState5 === "minimized" && viewport !== void 0;
+      const initialTraySlot = startsMinimized ? state.trayCount : null;
+      state.windows[id] = {
         id,
-        title: title ?? pending2?.title ?? id,
-        state: pending2?.state ?? (startsMinimized ? "minimized" : "windowed"),
+        title: title ?? pending?.title ?? id,
+        state: pending?.state ?? (startsMinimized ? "minimized" : "windowed"),
         windowed: pendingRenderRect ?? safeInitial,
-        preMinimizedRect: pending2?.state === "minimized" ? pending2.windowedRect : startsMinimized ? safeInitial : null,
-        zIndex: pending2?.zIndex ?? state2.nextZIndex++,
-        traySlot: pending2?.state === "minimized" ? pending2.traySlot : initialTraySlot,
+        preMinimizedRect: pending?.state === "minimized" ? pending.windowedRect : startsMinimized ? safeInitial : null,
+        zIndex: pending?.zIndex ?? state.nextZIndex++,
+        traySlot: pending?.state === "minimized" ? pending.traySlot : initialTraySlot,
         popoutMode: null,
         prePopoutRect: null,
         ...persistence ? {
           persistence: {
             ...persistence,
-            data: { ...pending2?.data ?? {}, ...persistence.data },
-            sidebarOpen: pending2?.sidebarOpen ?? persistence.sidebarOpen,
-            sidebarSize: pending2?.sidebarSize ?? persistence.sidebarSize,
+            data: { ...pending?.data ?? {}, ...persistence.data },
+            sidebarOpen: pending?.sidebarOpen ?? persistence.sidebarOpen,
+            sidebarSize: pending?.sidebarSize ?? persistence.sidebarSize,
             closing: false
           }
         } : {}
       };
-      if (pending2?.state === "minimized" && pending2.traySlot !== null) {
-        state2.trayCount = Math.max(state2.trayCount, pending2.traySlot + 1);
+      if (pending?.state === "minimized" && pending.traySlot !== null) {
+        state.trayCount = Math.max(state.trayCount, pending.traySlot + 1);
       } else if (startsMinimized && viewport) {
-        state2.trayCount += 1;
-        state2.trayViewport = viewport;
-        recomputeAllTrayRects(state2);
+        state.trayCount += 1;
+        state.trayViewport = viewport;
+        recomputeAllTrayRects(state);
       }
-      if (pending2 && pending2.zIndex >= state2.nextZIndex) {
-        state2.nextZIndex = pending2.zIndex + 1;
+      if (pending && pending.zIndex >= state.nextZIndex) {
+        state.nextZIndex = pending.zIndex + 1;
       }
-      if (state2.windowsHidden) state2.windowsHidden = false;
+      if (state.windowsHidden) state.windowsHidden = false;
     },
     /** Stage validated local sessions without creating phantom live windows. */
-    hydrateWindowSessions(state2, action) {
-      const liveEntries = Object.values(state2.windows).sort(
+    hydrateWindowSessions(state, action) {
+      const liveEntries = Object.values(state.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(
+        const alreadyLive = Object.values(state.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 trayBase = state.trayCount;
       const acceptedTraySlots = new Map(
         accepted.filter(
           (session) => session.state === "minimized" && session.traySlot !== null
@@ -840,7 +673,7 @@ var windowManagerSlice = createSlice2({
       ).forEach((session, index) => {
         const key = windowSessionKey(session.overlayId, session.instanceId);
         const traySlot = session.state === "minimized" ? acceptedTraySlots.get(session.sessionKey) ?? null : null;
-        state2.pendingRestores[key] = {
+        state.pendingRestores[key] = {
           ...session,
           sessionKey: key,
           traySlot,
@@ -855,35 +688,35 @@ var windowManagerSlice = createSlice2({
           })
         };
       });
-      state2.trayCount = trayBase + acceptedTraySlots.size;
-      state2.trayViewport = {
+      state.trayCount = trayBase + acceptedTraySlots.size;
+      state.trayViewport = {
         width: action.payload.viewportWidth,
         height: action.payload.viewportHeight
       };
-      recomputeAllTrayRects(state2);
+      recomputeAllTrayRects(state);
       liveEntries.forEach((entry, index) => {
         entry.zIndex = BASE_Z + accepted.length + index;
       });
-      state2.nextZIndex = BASE_Z + accepted.length + liveEntries.length;
+      state.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];
+    confirmWindowRestored(state, action) {
+      delete state.pendingRestores[action.payload];
     },
-    discardPendingWindowSession(state2, action) {
-      const pending2 = state2.pendingRestores[action.payload];
-      if (pending2?.traySlot !== null && pending2?.traySlot !== void 0 && !hasMatchingLiveTrayReservation(
-        state2,
-        pending2.overlayId,
-        pending2.instanceId,
-        pending2.traySlot
+    discardPendingWindowSession(state, action) {
+      const pending = state.pendingRestores[action.payload];
+      if (pending?.traySlot !== null && pending?.traySlot !== void 0 && !hasMatchingLiveTrayReservation(
+        state,
+        pending.overlayId,
+        pending.instanceId,
+        pending.traySlot
       )) {
-        compactReservedTraySlot(state2, pending2.traySlot, pending2.renderRect);
+        compactReservedTraySlot(state, pending.traySlot, pending.renderRect);
       }
-      delete state2.pendingRestores[action.payload];
+      delete state.pendingRestores[action.payload];
     },
-    updateWindowPersistence(state2, action) {
-      const entry = state2.windows[action.payload.id];
+    updateWindowPersistence(state, action) {
+      const entry = state.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;
@@ -896,32 +729,32 @@ var windowManagerSlice = createSlice2({
       }
     },
     /** Synchronous tombstone: close can never be undone by an unmount snapshot. */
-    markWindowClosing(state2, action) {
+    markWindowClosing(state, action) {
       const key = windowSessionKey(
         action.payload.overlayId,
         action.payload.instanceId
       );
-      const pending2 = state2.pendingRestores[key];
-      const hasMatchingLiveReservation = pending2 ? hasMatchingLiveTrayReservation(
-        state2,
+      const pending = state.pendingRestores[key];
+      const hasMatchingLiveReservation = pending ? hasMatchingLiveTrayReservation(
+        state,
         action.payload.overlayId,
         action.payload.instanceId,
-        pending2.traySlot
+        pending.traySlot
       ) : false;
-      if (!hasMatchingLiveReservation && pending2?.traySlot !== null && pending2?.traySlot !== void 0) {
-        compactReservedTraySlot(state2, pending2.traySlot, pending2.renderRect);
+      if (!hasMatchingLiveReservation && pending?.traySlot !== null && pending?.traySlot !== void 0) {
+        compactReservedTraySlot(state, pending.traySlot, pending.renderRect);
       }
-      delete state2.pendingRestores[key];
-      Object.values(state2.windows).forEach((entry) => {
+      delete state.pendingRestores[key];
+      Object.values(state.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(
+    clearWindowPersistenceState(state) {
+      Object.values(state.pendingRestores).filter(
         (session) => session.traySlot !== null && session.traySlot !== void 0 && !hasMatchingLiveTrayReservation(
-          state2,
+          state,
           session.overlayId,
           session.instanceId,
           session.traySlot
@@ -929,63 +762,63 @@ var windowManagerSlice = createSlice2({
       ).sort((a, b) => (b.traySlot ?? -1) - (a.traySlot ?? -1)).forEach((session) => {
         const traySlot = session.traySlot;
         if (traySlot === null) return;
-        compactReservedTraySlot(state2, traySlot, session.renderRect);
+        compactReservedTraySlot(state, traySlot, session.renderRect);
       });
-      state2.pendingRestores = {};
-      Object.values(state2.windows).forEach((entry) => {
+      state.pendingRestores = {};
+      Object.values(state.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];
+    updateWindowTitle(state, action) {
+      const win = state.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];
+    unregisterWindow(state, action) {
+      const win = state.windows[action.payload];
       if (!win) return;
-      const pending2 = win.persistence ? state2.pendingRestores[windowSessionKey(
+      const pending = win.persistence ? state.pendingRestores[windowSessionKey(
         win.persistence.overlayId,
         win.persistence.instanceId
       )] : void 0;
       const pendingOwnsLiveReservation = Boolean(
-        win.persistence && pending2 && hasMatchingLiveTrayReservation(
-          state2,
+        win.persistence && pending && hasMatchingLiveTrayReservation(
+          state,
           win.persistence.overlayId,
           win.persistence.instanceId,
-          pending2.traySlot
+          pending.traySlot
         )
       );
-      if (!pendingOwnsLiveReservation) releaseTraySlot(state2, win);
-      if (state2.activePipWindowId === action.payload) {
-        state2.activePipWindowId = null;
+      if (!pendingOwnsLiveReservation) releaseTraySlot(state, win);
+      if (state.activePipWindowId === action.payload) {
+        state.activePipWindowId = null;
       }
-      if (state2.popoutCandidateId === action.payload) {
-        state2.popoutCandidateId = null;
+      if (state.popoutCandidateId === action.payload) {
+        state.popoutCandidateId = null;
       }
-      delete state2.windows[action.payload];
-      if (Object.keys(state2.windows).length === 0) {
-        state2.windowsHidden = false;
+      delete state.windows[action.payload];
+      if (Object.keys(state.windows).length === 0) {
+        state.windowsHidden = false;
       }
     },
     /** Bring a window to the top of the z stack. */
-    focusWindow(state2, action) {
-      const win = state2.windows[action.payload];
+    focusWindow(state, action) {
+      const win = state.windows[action.payload];
       if (!win) return;
-      win.zIndex = state2.nextZIndex++;
+      win.zIndex = state.nextZIndex++;
     },
     /** Switch to windowed (restore) state. */
-    restoreWindow(state2, action) {
-      const win = state2.windows[action.payload];
+    restoreWindow(state, action) {
+      const win = state.windows[action.payload];
       if (!win) return;
-      releaseTraySlot(state2, win);
+      releaseTraySlot(state, win);
       if (win.preMinimizedRect) {
         win.windowed = win.preMinimizedRect;
         win.preMinimizedRect = null;
       }
       win.state = "windowed";
-      win.zIndex = state2.nextZIndex++;
+      win.zIndex = state.nextZIndex++;
     },
     /**
      * Bring an already-registered window unconditionally into view — the
@@ -1006,13 +839,13 @@ var windowManagerSlice = createSlice2({
      *
      * Caller supplies viewport dimensions (reducers can't read `window`).
      */
-    revealWindow(state2, action) {
+    revealWindow(state, action) {
       const { id, viewportWidth, viewportHeight } = action.payload;
-      const win = state2.windows[id];
+      const win = state.windows[id];
       if (!win) return;
-      if (state2.windowsHidden) state2.windowsHidden = false;
+      if (state.windowsHidden) state.windowsHidden = false;
       if (win.popoutMode !== null) return;
-      releaseTraySlot(state2, win);
+      releaseTraySlot(state, win);
       if (win.state === "minimized") {
         if (win.preMinimizedRect) {
           win.windowed = win.preMinimizedRect;
@@ -1027,55 +860,55 @@ var windowManagerSlice = createSlice2({
         });
         if (!rectsEqual(win.windowed, clamped)) win.windowed = clamped;
       }
-      win.zIndex = state2.nextZIndex++;
+      win.zIndex = state.nextZIndex++;
     },
     /** Switch to maximized state. */
-    maximizeWindow(state2, action) {
-      const win = state2.windows[action.payload];
+    maximizeWindow(state, action) {
+      const win = state.windows[action.payload];
       if (!win) return;
-      releaseTraySlot(state2, win);
+      releaseTraySlot(state, win);
       win.state = "maximized";
-      win.zIndex = state2.nextZIndex++;
+      win.zIndex = state.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) {
+    minimizeWindow(state, action) {
       const { id, viewportWidth, viewportHeight } = action.payload;
-      const win = state2.windows[id];
+      const win = state.windows[id];
       if (!win || win.state === "minimized") return;
       if (win.popoutMode !== null) return;
       win.preMinimizedRect = { ...win.windowed };
-      const slot2 = state2.trayCount;
-      win.traySlot = slot2;
-      state2.trayCount += 1;
-      state2.trayViewport = { width: viewportWidth, height: viewportHeight };
+      const slot = state.trayCount;
+      win.traySlot = slot;
+      state.trayCount += 1;
+      state.trayViewport = { width: viewportWidth, height: viewportHeight };
       win.state = "minimized";
-      recomputeAllTrayRects(state2);
+      recomputeAllTrayRects(state);
     },
     /**
      * Minimize ALL non-minimized, non-maximized windows in one shot.
      * Use for a "collapse all" button. Caller supplies viewport dimensions.
      */
-    minimizeAll(state2, action) {
+    minimizeAll(state, action) {
       const { viewportWidth, viewportHeight } = action.payload;
-      state2.trayViewport = { width: viewportWidth, height: viewportHeight };
-      Object.values(state2.windows).forEach((win) => {
+      state.trayViewport = { width: viewportWidth, height: viewportHeight };
+      Object.values(state.windows).forEach((win) => {
         if (win.state !== "windowed") return;
         if (win.popoutMode !== null) return;
         win.preMinimizedRect = { ...win.windowed };
-        const slot2 = state2.trayCount;
-        win.traySlot = slot2;
-        state2.trayCount += 1;
+        const slot = state.trayCount;
+        win.traySlot = slot;
+        state.trayCount += 1;
         win.state = "minimized";
       });
-      recomputeAllTrayRects(state2);
+      recomputeAllTrayRects(state);
     },
     /** Update the windowed rect (called during drag or resize). */
-    updateWindowRect(state2, action) {
-      const win = state2.windows[action.payload.id];
+    updateWindowRect(state, action) {
+      const win = state.windows[action.payload.id];
       if (!win) return;
       win.windowed = { ...win.windowed, ...action.payload.rect };
     },
@@ -1098,9 +931,9 @@ var windowManagerSlice = createSlice2({
      * `window.innerWidth` (consistent with `minimizeWindow` /
      * `arrangeActiveWindows` patterns).
      */
-    clampWindowRect(state2, action) {
+    clampWindowRect(state, action) {
       const { id, viewportWidth, viewportHeight } = action.payload;
-      const win = state2.windows[id];
+      const win = state.windows[id];
       if (!win) return;
       if (win.state !== "windowed") return;
       if (win.popoutMode !== null) return;
@@ -1117,9 +950,9 @@ var windowManagerSlice = createSlice2({
      *
      * Mirrors `recomputeTrayPositions`'s coverage for minimized chips.
      */
-    clampAllWindowRects(state2, action) {
+    clampAllWindowRects(state, action) {
       const { viewportWidth, viewportHeight } = action.payload;
-      Object.values(state2.windows).forEach((win) => {
+      Object.values(state.windows).forEach((win) => {
         if (win.state !== "windowed") return;
         if (win.popoutMode !== null) return;
         const clamped = clampRectToViewport(win.windowed, {
@@ -1130,9 +963,9 @@ var windowManagerSlice = createSlice2({
       });
     },
     /** Arranges all non-minimized windows globally */
-    arrangeActiveWindows(state2, action) {
+    arrangeActiveWindows(state, 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);
+      const eligibleWindows = Object.values(state.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,
@@ -1144,9 +977,9 @@ var windowManagerSlice = createSlice2({
         primary
       );
       updates.forEach(({ id, rect }) => {
-        if (state2.windows[id]) {
-          state2.windows[id].windowed = {
-            ...state2.windows[id].windowed,
+        if (state.windows[id]) {
+          state.windows[id].windowed = {
+            ...state.windows[id].windowed,
             ...rect
           };
         }
@@ -1157,27 +990,27 @@ var windowManagerSlice = createSlice2({
      * resize. Each window keeps its existing traySlot number — only x/y/w/h
      * are recalculated. No-op if nothing is minimized.
      */
-    recomputeTrayPositions(state2, action) {
+    recomputeTrayPositions(state, action) {
       const { viewportWidth, viewportHeight } = action.payload;
       if (!Number.isFinite(viewportWidth) || !Number.isFinite(viewportHeight) || viewportWidth <= 0 || viewportHeight <= 0) {
         return;
       }
-      const minimized = Object.values(state2.windows).filter(
+      const minimized = Object.values(state.windows).filter(
         (w) => w.state === "minimized" && w.traySlot !== null
       );
       if (minimized.length === 0) return;
-      const tv = state2.trayViewport;
+      const tv = state.trayViewport;
       if (!tv || tv.width !== viewportWidth || tv.height !== viewportHeight) {
-        state2.trayViewport = { width: viewportWidth, height: viewportHeight };
+        state.trayViewport = { width: viewportWidth, height: viewportHeight };
       }
-      recomputeAllTrayRects(state2);
+      recomputeAllTrayRects(state);
     },
     /**
      * 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) => {
+    restoreAll(state) {
+      Object.values(state.windows).forEach((win) => {
         if (win.state !== "minimized") return;
         if (win.preMinimizedRect) {
           win.windowed = win.preMinimizedRect;
@@ -1185,44 +1018,44 @@ var windowManagerSlice = createSlice2({
         }
         win.traySlot = null;
         win.state = "windowed";
-        win.zIndex = state2.nextZIndex++;
+        win.zIndex = state.nextZIndex++;
       });
-      Object.values(state2.pendingRestores).forEach((session) => {
+      Object.values(state.pendingRestores).forEach((session) => {
         if (session.state !== "minimized") return;
         session.state = "windowed";
         session.traySlot = null;
         session.renderRect = session.windowedRect;
       });
-      state2.trayCount = 0;
-      state2.trayViewport = null;
+      state.trayCount = 0;
+      state.trayViewport = null;
     },
     /** Show or hide all windows (they stay mounted). */
-    toggleWindowsHidden(state2) {
-      state2.windowsHidden = !state2.windowsHidden;
+    toggleWindowsHidden(state) {
+      state.windowsHidden = !state.windowsHidden;
     },
     /** Move a minimized chip to a new tray slot (drag-within-tray). */
-    moveTraySlot(state2, action) {
+    moveTraySlot(state, action) {
       const { id, toSlot } = action.payload;
-      const win = state2.windows[id];
+      const win = state.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)
+        Math.max(0, state.trayCount - 1)
       );
       if (fromSlot === boundedSlot) return;
       const rectBySlot = /* @__PURE__ */ new Map();
-      Object.values(state2.windows).forEach((entry) => {
+      Object.values(state.windows).forEach((entry) => {
         if (entry.traySlot !== null) {
           rectBySlot.set(entry.traySlot, { ...entry.windowed });
         }
       });
-      Object.values(state2.pendingRestores).forEach((session) => {
+      Object.values(state.pendingRestores).forEach((session) => {
         if (session.traySlot !== null) {
           rectBySlot.set(session.traySlot, { ...session.renderRect });
         }
       });
-      Object.values(state2.windows).forEach((w) => {
+      Object.values(state.windows).forEach((w) => {
         if (w.id === id || w.traySlot === null) return;
         if (fromSlot < boundedSlot && w.traySlot > fromSlot && w.traySlot <= boundedSlot) {
           w.traySlot -= 1;
@@ -1230,7 +1063,7 @@ var windowManagerSlice = createSlice2({
           w.traySlot += 1;
         }
       });
-      Object.values(state2.pendingRestores).forEach((session) => {
+      Object.values(state.pendingRestores).forEach((session) => {
         if (session.traySlot === null) return;
         if (fromSlot < boundedSlot && session.traySlot > fromSlot && session.traySlot <= boundedSlot) {
           session.traySlot -= 1;
@@ -1239,17 +1072,17 @@ var windowManagerSlice = createSlice2({
         }
       });
       win.traySlot = boundedSlot;
-      Object.values(state2.windows).forEach((entry) => {
+      Object.values(state.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) => {
+      Object.values(state.pendingRestores).forEach((session) => {
         if (session.traySlot === null) return;
         const nextRect = rectBySlot.get(session.traySlot);
         if (nextRect) session.renderRect = nextRect;
       });
-      recomputeAllTrayRects(state2);
+      recomputeAllTrayRects(state);
     },
     /**
      * Transition a window into popped-out mode.
@@ -1268,15 +1101,15 @@ var windowManagerSlice = createSlice2({
      * 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) {
+    popOutWindow(state, action) {
       const { id, mode } = action.payload;
-      const win = state2.windows[id];
+      const win = state.windows[id];
       if (!win) return;
-      if (mode === "pip" && state2.activePipWindowId !== null && state2.activePipWindowId !== id) {
+      if (mode === "pip" && state.activePipWindowId !== null && state.activePipWindowId !== id) {
         return;
       }
       if (win.traySlot !== null) {
-        releaseTraySlot(state2, win);
+        releaseTraySlot(state, win);
         if (win.preMinimizedRect) {
           win.windowed = win.preMinimizedRect;
           win.preMinimizedRect = null;
@@ -1288,10 +1121,10 @@ var windowManagerSlice = createSlice2({
       }
       win.popoutMode = mode;
       if (mode === "pip") {
-        state2.activePipWindowId = id;
+        state.activePipWindowId = id;
       }
-      if (state2.popoutCandidateId === id) {
-        state2.popoutCandidateId = null;
+      if (state.popoutCandidateId === id) {
+        state.popoutCandidateId = null;
       }
     },
     /**
@@ -1302,12 +1135,12 @@ var windowManagerSlice = createSlice2({
      * `popoutMode`, releases the PiP slot if held, and bumps z-index.
      * Caller is responsible for closing the actual browser popout window.
      */
-    dockWindow(state2, action) {
+    dockWindow(state, action) {
       const { id, viewportWidth, viewportHeight } = action.payload;
-      const win = state2.windows[id];
+      const win = state.windows[id];
       if (!win || win.popoutMode === null) return;
-      if (state2.activePipWindowId === win.id) {
-        state2.activePipWindowId = null;
+      if (state.activePipWindowId === win.id) {
+        state.activePipWindowId = null;
       }
       const savedRect = win.prePopoutRect ?? win.windowed;
       const centered = centerRectInViewport(savedRect, {
@@ -1317,7 +1150,7 @@ var windowManagerSlice = createSlice2({
       win.windowed = centered;
       win.prePopoutRect = null;
       win.popoutMode = null;
-      win.zIndex = state2.nextZIndex++;
+      win.zIndex = state.nextZIndex++;
     },
     /**
      * Set or clear the drag-out candidate window. Used purely for visual
@@ -1325,29 +1158,29 @@ var windowManagerSlice = createSlice2({
      * "Release to pop out" outline. Cleared on every pointerup regardless
      * of whether popout actually fires.
      */
-    setPopoutCandidate(state2, action) {
-      state2.popoutCandidateId = action.payload.id;
+    setPopoutCandidate(state, action) {
+      state.popoutCandidateId = action.payload.id;
     },
     /** Restore window geometry and state from localStorage */
-    restoreWindowState(state2, action) {
+    restoreWindowState(state, action) {
       const restored = action.payload;
-      let maxZ = state2.nextZIndex;
+      let maxZ = state.nextZIndex;
       Object.entries(restored).forEach(([id, win]) => {
-        if (!state2.windows[id]) {
+        if (!state.windows[id]) {
           return;
         }
-        state2.windows[id] = {
-          ...state2.windows[id],
+        state.windows[id] = {
+          ...state.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(
+      state.nextZIndex = Math.max(state.nextZIndex, maxZ);
+      state.activePipWindowId = null;
+      state.popoutCandidateId = null;
+      state.trayCount = Object.values(state.windows).filter(
         (w) => w.traySlot !== null
       ).length;
     }
@@ -1355,7 +1188,7 @@ var windowManagerSlice = createSlice2({
   extraReducers: (builder) => {
     builder.addMatcher(
       (action) => action.type === "overlays/closeOverlay",
-      (state2, action) => {
+      (state, action) => {
         const payload = action.payload;
         if (!payload || typeof payload !== "object") return;
         const overlayId = payload.overlayId;
@@ -1363,20 +1196,20 @@ var windowManagerSlice = createSlice2({
         if (typeof overlayId !== "string" || typeof instanceId !== "string") {
           return;
         }
-        const pending2 = Object.values(state2.pendingRestores).find(
+        const pending = Object.values(state.pendingRestores).find(
           (session) => session.overlayId === overlayId && session.instanceId === instanceId
         );
-        const hasMatchingLive = pending2 ? hasMatchingLiveTrayReservation(
-          state2,
+        const hasMatchingLive = pending ? hasMatchingLiveTrayReservation(
+          state,
           overlayId,
           instanceId,
-          pending2.traySlot
+          pending.traySlot
         ) : false;
-        if (!hasMatchingLive && pending2?.traySlot != null) {
-          compactReservedTraySlot(state2, pending2.traySlot, pending2.renderRect);
+        if (!hasMatchingLive && pending?.traySlot != null) {
+          compactReservedTraySlot(state, pending.traySlot, pending.renderRect);
         }
-        if (pending2) delete state2.pendingRestores[pending2.sessionKey];
-        Object.values(state2.windows).forEach((entry) => {
+        if (pending) delete state.pendingRestores[pending.sessionKey];
+        Object.values(state.windows).forEach((entry) => {
           if (entry.persistence?.overlayId === overlayId && entry.persistence.instanceId === instanceId) {
             entry.persistence.closing = true;
           }
@@ -1385,10 +1218,10 @@ var windowManagerSlice = createSlice2({
     );
     builder.addMatcher(
       (action) => action.type === "overlays/closeAllOverlays",
-      (state2) => {
-        Object.values(state2.pendingRestores).filter(
+      (state) => {
+        Object.values(state.pendingRestores).filter(
           (session) => session.traySlot !== null && !hasMatchingLiveTrayReservation(
-            state2,
+            state,
             session.overlayId,
             session.instanceId,
             session.traySlot
@@ -1396,27 +1229,27 @@ var windowManagerSlice = createSlice2({
         ).sort((a, b) => (b.traySlot ?? -1) - (a.traySlot ?? -1)).forEach((session) => {
           if (session.traySlot !== null) {
             compactReservedTraySlot(
-              state2,
+              state,
               session.traySlot,
               session.renderRect
             );
           }
         });
-        state2.pendingRestores = {};
-        Object.values(state2.windows).forEach((entry) => {
+        state.pendingRestores = {};
+        Object.values(state.windows).forEach((entry) => {
           if (entry.persistence) entry.persistence.closing = true;
         });
       }
     );
     builder.addMatcher(
       (action) => action.type === "overlays/closeAllInstancesOfOverlay",
-      (state2, action) => {
+      (state, 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(
+        Object.values(state.pendingRestores).filter(
           (session) => session.overlayId === overlayId && session.traySlot !== null && !hasMatchingLiveTrayReservation(
-            state2,
+            state,
             session.overlayId,
             session.instanceId,
             session.traySlot
@@ -1424,17 +1257,17 @@ var windowManagerSlice = createSlice2({
         ).sort((a, b) => (b.traySlot ?? -1) - (a.traySlot ?? -1)).forEach((session) => {
           if (session.traySlot !== null) {
             compactReservedTraySlot(
-              state2,
+              state,
               session.traySlot,
               session.renderRect
             );
           }
         });
-        Object.entries(state2.pendingRestores).forEach(([key, session]) => {
+        Object.entries(state.pendingRestores).forEach(([key, session]) => {
           if (session.overlayId === overlayId)
-            delete state2.pendingRestores[key];
+            delete state.pendingRestores[key];
         });
-        Object.values(state2.windows).forEach((entry) => {
+        Object.values(state.windows).forEach((entry) => {
           if (entry.persistence?.overlayId === overlayId) {
             entry.persistence.closing = true;
           }
@@ -1448,19 +1281,19 @@ var {
   releaseTransientWindow,
   registerWindow,
   unregisterWindow,
-  focusWindow: focusWindow2,
-  restoreWindow: restoreWindow2,
-  revealWindow: revealWindow2,
+  focusWindow,
+  restoreWindow,
+  revealWindow,
   maximizeWindow,
   minimizeWindow,
-  minimizeAll: minimizeAll2,
-  restoreAll: restoreAll2,
+  minimizeAll,
+  restoreAll,
   recomputeTrayPositions,
-  updateWindowRect: updateWindowRect2,
+  updateWindowRect,
   updateWindowTitle,
-  toggleWindowsHidden: toggleWindowsHidden2,
+  toggleWindowsHidden,
   moveTraySlot,
-  arrangeActiveWindows: arrangeActiveWindows2,
+  arrangeActiveWindows,
   popOutWindow,
   dockWindow,
   setPopoutCandidate,
@@ -1474,17 +1307,17 @@ var {
   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 selectWindowsMap = (state) => state.windowManager.windows;
+var selectPendingWindowRestores = (state) => state.windowManager.pendingRestores;
+var selectWindowPersistence = (id) => (state) => state.windowManager.windows[id]?.persistence;
+var selectWindow = (id) => (state) => state.windowManager.windows[id];
+var selectWindowState = (id) => (state) => state.windowManager.windows[id]?.state;
+var selectWindowRect = (id) => (state) => state.windowManager.windows[id]?.windowed;
+var selectWindowZIndex = (id) => (state) => state.windowManager.windows[id]?.zIndex ?? BASE_Z;
+var selectTransientZIndex = (id) => (state) => state.windowManager.transientZ[id] ?? BASE_Z;
+var selectWindowTitle = (id) => (state) => state.windowManager.windows[id]?.title ?? id;
 var selectTraySlotWidth = () => TRAY_SLOT_WIDTH;
-var selectWindowsHidden = (state2) => state2.windowManager.windowsHidden;
+var selectWindowsHidden = (state) => state.windowManager.windowsHidden;
 var selectTrayWindows = createSelector(
   [selectWindowsMap],
   (windows) => Object.values(windows).filter((w) => w.state === "minimized").sort((a, b) => (a.traySlot ?? 0) - (b.traySlot ?? 0))
@@ -1500,11 +1333,11 @@ var selectAllMinimized = createSelector(
     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 selectPopoutMode = (id) => (state) => state.windowManager.windows[id]?.popoutMode ?? null;
+var selectIsPoppedOut = (id) => (state) => (state.windowManager.windows[id]?.popoutMode ?? null) !== null;
+var selectActivePipWindowId = (state) => state.windowManager.activePipWindowId;
+var selectPopoutCandidateId = (state) => state.windowManager.popoutCandidateId;
+var selectPrePopoutRect = (id) => (state) => state.windowManager.windows[id]?.prePopoutRect ?? null;
 var selectDockedWindows = createSelector(
   [selectWindowsMap],
   (windows) => Object.values(windows).filter((w) => w.popoutMode === null).sort((a, b) => b.zIndex - a.zIndex)
@@ -1521,23 +1354,23 @@ var urlSyncSlice = createSlice3({
   name: "urlSync",
   initialState: initialState3,
   reducers: {
-    setHydrated: (state2) => {
-      state2.isHydrated = true;
+    setHydrated: (state) => {
+      state.isHydrated = true;
     },
-    registerSyncEntry: (state2, action) => {
+    registerSyncEntry: (state, action) => {
       const key = `${action.payload.typeKey}:${action.payload.instanceId}`;
-      state2.entries[key] = action.payload;
+      state.entries[key] = action.payload;
     },
-    unregisterSyncEntry: (state2, action) => {
+    unregisterSyncEntry: (state, action) => {
       const key = `${action.payload.typeKey}:${action.payload.instanceId}`;
-      delete state2.entries[key];
+      delete state.entries[key];
     }
   }
 });
 var linksReducer = urlSyncSlice.reducer;
-var { setHydrated, registerSyncEntry: registerSyncEntry2, unregisterSyncEntry: unregisterSyncEntry2 } = urlSyncSlice.actions;
-var selectUrlSyncEntries = (state2) => state2.urlSync.entries;
-var selectIsUrlHydrated = (state2) => state2.urlSync.isHydrated;
+var { setHydrated, registerSyncEntry, unregisterSyncEntry } = urlSyncSlice.actions;
+var selectUrlSyncEntries = (state) => state.urlSync.entries;
+var selectIsUrlHydrated = (state) => state.urlSync.isHydrated;
 
 // src/core/overlayStateSlice.ts
 import { createSlice as createSlice4 } from "@reduxjs/toolkit";
@@ -1546,306 +1379,39 @@ var overlayStateSlice = createSlice4({
   name: "overlayState",
   initialState: initialState4,
   reducers: {
-    setOverlayStateValue(state2, action) {
+    setOverlayStateValue(state, action) {
       const { key, name, value } = action.payload;
-      const entry = state2.entries[key] ??= { values: {}, updatedAt: 0 };
+      const entry = state.entries[key] ??= { values: {}, updatedAt: 0 };
       entry.values[name] = value;
       entry.updatedAt = Date.now();
     },
-    replaceOverlayState(state2, action) {
+    replaceOverlayState(state, action) {
       const { key, values } = action.payload;
-      state2.entries[key] = { values: { ...values }, updatedAt: Date.now() };
+      state.entries[key] = { values: { ...values }, updatedAt: Date.now() };
     },
-    clearOverlayState(state2, action) {
-      delete state2.entries[action.payload.key];
+    clearOverlayState(state, action) {
+      delete state.entries[action.payload.key];
     },
-    hydrateOverlayState(state2, action) {
+    hydrateOverlayState(state, 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 };
+        state.entries[key] = { values: { ...entry.values }, updatedAt: entry.updatedAt ?? now };
       }
     }
   }
 });
 var overlayStateReducer = overlayStateSlice.reducer;
-var { setOverlayStateValue: setOverlayStateValue2, replaceOverlayState, clearOverlayState, hydrateOverlayState } = overlayStateSlice.actions;
+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;
+var selectOverlayStateValue = (state, key, name) => state.overlayState.entries[key]?.values[name];
+var selectOverlayStateFor = (state, key) => state.overlayState.entries[key]?.values ?? EMPTY_VALUES;
 
 // src/core/store.ts
 import { combineReducers, configureStore } from "@reduxjs/toolkit";
 
 // src/core/middleware/closeLifecycle.ts
-import { globalSlot as globalSlot5 } from "@ai-matrx/kit/global-slot";
-
-// src/handles/callbackManager.ts
-import { globalSlot as globalSlot3 } from "@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/slot.ts
-var HANDLES_SLOT = "ai-matrx.summon.handles";
-
-// src/handles/callbackManager.ts
-var handlesState = () => globalSlot3(HANDLES_SLOT, () => ({
-  callbacks: /* @__PURE__ */ new Map(),
-  groups: /* @__PURE__ */ new Map(),
-  owners: /* @__PURE__ */ new Map(),
-  registryListeners: /* @__PURE__ */ new Set()
-}));
-function invoke(slot2, data, context) {
-  if (typeof slot2 !== "function") return void 0;
-  return slot2(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(slot2, options) {
-    const s = this.s;
-    const callbackId = options.id ?? newHandleId();
-    if (s.callbacks.has(callbackId)) this.deleteEntry(callbackId, false);
-    const entry = { callback: slot2 };
-    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/open/channels.ts
-import { globalSlot as globalSlot4 } from "@ai-matrx/kit/global-slot";
-var pending = () => globalSlot4("ai-matrx.summon.pendingChannels", () => /* @__PURE__ */ new Map());
-function dropPendingChannelsOf(owner) {
-  const map = pending();
-  for (const [id, entry] of [...map]) if (entry.owner === owner) map.delete(id);
-}
-
-// src/core/middleware/closeLifecycle.ts
-var closeState = () => globalSlot5("ai-matrx.summon.closeLifecycle", () => ({ flushers: /* @__PURE__ */ new Set() }));
+import { globalSlot } from "@ai-matrx/kit/global-slot";
+var closeState = () => globalSlot("ai-matrx.summon.closeLifecycle", () => ({ flushers: /* @__PURE__ */ new Set() }));
 function registerCloseFlusher(flush) {
   const { flushers } = closeState();
   flushers.add(flush);
@@ -1856,8 +1422,8 @@ function registerCloseFlusher(flush) {
 function dedupe(identities) {
   return [...new Map(identities.map((identity) => [`${identity.overlayId}:${identity.instanceId}`, identity])).values()];
 }
-function preservedIdentities(state2, overlayId) {
-  const wm = state2.windowManager;
+function preservedIdentities(state, overlayId) {
+  const wm = state.windowManager;
   if (!wm) return [];
   const identities = [];
   for (const entry of Object.values(wm.windows)) {
@@ -1871,7 +1437,7 @@ function preservedIdentities(state2, overlayId) {
   }
   return identities;
 }
-function isPlainRecord3(value) {
+function isPlainRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var CLOSE_TYPES = /* @__PURE__ */ new Set([
@@ -1896,11 +1462,11 @@ function closeInstanceResources(api, key) {
   if (keepAlive !== "restore" && hasState) api.dispatch(clearOverlayState({ key }));
 }
 var closeLifecycleMiddleware = (api) => (next) => (action) => {
-  if (!isPlainRecord3(action) || typeof action.type !== "string" || !CLOSE_TYPES.has(action.type)) {
+  if (!isPlainRecord2(action) || typeof action.type !== "string" || !CLOSE_TYPES.has(action.type)) {
     return next(action);
   }
   const type = action.type;
-  const payload = isPlainRecord3(action.payload) ? action.payload : null;
+  const payload = isPlainRecord2(action.payload) ? action.payload : null;
   const before = api.getState();
   const openBefore = new Set(listOpenInstanceKeys(before));
   let closing = [];
@@ -1946,12 +1512,12 @@ var closeLifecycleMiddleware = (api) => (next) => (action) => {
 };
 
 // src/core/middleware/renderWatchdog.ts
-import { globalSlot as globalSlot6 } from "@ai-matrx/kit/global-slot";
+import { globalSlot as globalSlot2 } from "@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 isPlainRecord4(value) {
+function isPlainRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var CHECK_DELAY_MS = 2500;
@@ -1961,7 +1527,7 @@ 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 = () => globalSlot6(RENDER_WATCHDOG_SLOT, () => ({
+var watchdogState = () => globalSlot2(RENDER_WATCHDOG_SLOT, () => ({
   renderAcks: /* @__PURE__ */ new Map(),
   ackWaiters: /* @__PURE__ */ new Map(),
   watches: /* @__PURE__ */ new Map()
@@ -2037,13 +1603,13 @@ function endWatch(watch) {
   watchdogState().watches.delete(watch.overlayId);
 }
 function evaluate(store, watch) {
-  const state2 = store.getState();
-  if (!selectIsOverlayOpen(state2, watch.overlayId, DEFAULT_INSTANCE_ID2)) {
+  const state = store.getState();
+  if (!selectIsOverlayOpen(state, 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 entry = state.windowManager.windows[windowId];
   const { vw, vh, degenerate } = safeViewportDims();
   return {
     viewportWidth: vw,
@@ -2052,14 +1618,14 @@ function evaluate(store, watch) {
     renderAcknowledgement: ack?.kind ?? "none",
     diag: diagnoseOverlayRender({
       entry,
-      windowsHidden: state2.windowManager.windowsHidden,
+      windowsHidden: state.windowManager.windowsHidden,
       viewportWidth: vw,
       viewportHeight: vh,
       surfaceAcknowledged: ack?.kind === "surface"
     }),
     windowId,
     entry,
-    windowsHidden: state2.windowManager.windowsHidden
+    windowsHidden: state.windowManager.windowsHidden
   };
 }
 function startWatch(store, ports, overlayId, slug, label) {
@@ -2140,7 +1706,7 @@ function scream(store, watch, res) {
       onClick: () => {
         const dims = safeViewportDims();
         store.dispatch(
-          revealWindow2({
+          revealWindow({
             id: acknowledgedWindowId(overlayId, watch.slug),
             viewportWidth: dims.vw,
             viewportHeight: dims.vh
@@ -2178,21 +1744,21 @@ function createOverlayRenderWatchdogMiddleware(ports) {
     const typed = action;
     if (typed.type !== OPEN_TYPE && typed.type !== TOGGLE_TYPE) return result;
     const payload = typed.payload;
-    const overlayId = isPlainRecord4(payload) && typeof payload.overlayId === "string" ? payload.overlayId : void 0;
+    const overlayId = isPlainRecord3(payload) && typeof payload.overlayId === "string" ? payload.overlayId : void 0;
     if (!overlayId) return result;
-    const instanceIdRaw = isPlainRecord4(payload) && typeof payload.instanceId === "string" ? payload.instanceId : void 0;
+    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)) {
+    const state = store.getState();
+    if (!selectIsOverlayOpen(state, overlayId, DEFAULT_INSTANCE_ID2)) {
       return result;
     }
     const slug = defaultWindowIdFor(meta);
     const revealDims = safeViewportDims();
     store.dispatch(
-      revealWindow2({
+      revealWindow({
         id: acknowledgedWindowId(overlayId, slug),
         viewportWidth: revealDims.vw,
         viewportHeight: revealDims.vh
@@ -2239,19 +1805,6 @@ function buildDockWindowPayload(windowId) {
   };
 }
 
-// src/open/gate.ts
-import { globalSlot as globalSlot7 } from "@ai-matrx/kit/global-slot";
-var slot = () => globalSlot7("ai-matrx.summon.gate", () => ({ core: null, loading: null, gates: /* @__PURE__ */ new Set(), listeners: /* @__PURE__ */ new Set() }));
-function installSummonCore(core) {
-  const s = slot();
-  if (s.core) return;
-  s.core = core;
-  const gates = [...s.gates];
-  s.gates.clear();
-  for (const gate of gates) gate.install(core);
-  for (const listener of [...s.listeners]) listener();
-}
-
 // src/index.ts
 var summonCore = { reducers: summonReducers, createMiddleware: createSummonMiddleware };
 installSummonCore(summonCore);
@@ -2279,7 +1832,7 @@ export {
   ackOverlaySurfaceRender,
   allOverlayMeta,
   anonymousIdentity,
-  arrangeActiveWindows2 as arrangeActiveWindows,
+  arrangeActiveWindows,
   buildDockWindowPayload,
   centerRectInViewport,
   clampAllWindowRects,
@@ -2291,7 +1844,7 @@ export {
   clearOverlaySurfaceRender,
   clearWindowPersistenceState,
   closeAllInstancesOfOverlay,
-  closeAllOverlays2 as closeAllOverlays,
+  closeAllOverlays,
   closeLifecycleMiddleware,
   closeOverlay,
   closeOverlaysBoundToPage,
@@ -2309,7 +1862,7 @@ export {
   diagnoseOverlayRender,
   discardPendingWindowSession,
   dockWindow,
-  focusWindow2 as focusWindow,
+  focusWindow,
   getGrid12Rect,
   getGrid4Rect,
   getGrid6Rect,
@@ -2334,7 +1887,7 @@ export {
   locationRouter,
   markWindowClosing,
   maximizeWindow,
-  minimizeAll2 as minimizeAll,
+  minimizeAll,
   minimizeWindow,
   moveTraySlot,
   openOverlay,
@@ -2344,14 +1897,14 @@ export {
   overlaysReducer,
   parseInstanceKey,
   popOutWindow,
-  pruneStaleInstances2 as pruneStaleInstances,
+  pruneStaleInstances,
   raiseTransientWindow,
   recomputeTrayPositions,
   rectOnScreen,
   rectsEqual,
   registerCloseFlusher,
   registerOverlayMeta,
-  registerSyncEntry2 as registerSyncEntry,
+  registerSyncEntry,
   registerWindow,
   releaseOverlayInstance,
   releaseTransientWindow,
@@ -2359,10 +1912,10 @@ export {
   resetOverlayRegistry,
   resetOverlayRenderWatchdog,
   resolvePorts,
-  restoreAll2 as restoreAll,
-  restoreWindow2 as restoreWindow,
+  restoreAll,
+  restoreWindow,
   restoreWindowState,
-  revealWindow2 as revealWindow,
+  revealWindow,
   safeViewportDims,
   selectActivePipWindowId,
   selectAllMinimized,
@@ -2392,19 +1945,19 @@ export {
   selectWindowZIndex,
   selectWindowsHidden,
   setHydrated,
-  setOverlayStateValue2 as setOverlayStateValue,
+  setOverlayStateValue,
   setPopoutCandidate,
   subscribeToOverlayRegistry,
   summonCore,
   summonReducers,
   toggleOverlay,
-  toggleWindowsHidden2 as toggleWindowsHidden,
+  toggleWindowsHidden,
   trayChipsPerRow,
   traySlotRect,
-  unregisterSyncEntry2 as unregisterSyncEntry,
+  unregisterSyncEntry,
   unregisterWindow,
   updateWindowPersistence,
-  updateWindowRect2 as updateWindowRect,
+  updateWindowRect,
   updateWindowTitle,
   watchdogTracksOpen,
   windowManagerReducer,