@surdeddd/wmkit 0.5.0 → 0.6.0

package/dist/{chunk-L43XBN44.js → chunk-3HLKVOSI.js}

@@ -193,6 +193,12 @@ function createWindowManager(options = {}) {
   const idPrefix = options.idPrefix ?? "wm";
   const historyLimit = options.historyLimit ?? 50;
   let windows = {};
+  let windowsShared = false;
+  let modalCount = 0;
+  let cachedGroups = null;
+  let cachedOrder = null;
+  let cachedTabs = null;
+  let groupsDirty = false;
   let order = [];
   let focusedId = null;
   let viewport = options.viewport ?? { width: 0, height: 0 };
@@ -217,6 +223,7 @@ function createWindowManager(options = {}) {
   const layouts = /* @__PURE__ */ new Map();
   function getState() {
     if (!snapshot) {
+      windowsShared = true;
       snapshot = { windows, order, focusedId, viewport, workspace, groups: buildGroups() };
     }
     return snapshot;
@@ -238,30 +245,58 @@ function createWindowManager(options = {}) {
   function queueEvent(emit) {
     pendingEvents.push(emit);
   }
+  function ownWindows() {
+    if (windowsShared) {
+      windows = { ...windows };
+      windowsShared = false;
+    }
+    return windows;
+  }
   function setWindow(next) {
-    windows = { ...windows, [next.id]: next };
+    const map = ownWindows();
+    const previous = map[next.id];
+    const wasModal = previous?.layer === "modal";
+    if (wasModal !== (next.layer === "modal")) modalCount += wasModal ? -1 : 1;
+    if (previous?.groupId !== next.groupId) groupsDirty = true;
+    map[next.id] = next;
   }
   function removeWindow(id) {
-    const { [id]: _removed, ...rest } = windows;
-    windows = rest;
+    const map = ownWindows();
+    const previous = map[id];
+    if (previous?.layer === "modal") modalCount -= 1;
+    if (previous?.groupId != null) groupsDirty = true;
+    delete map[id];
     order = order.filter((entry) => entry !== id);
   }
+  function countModals() {
+    let total = 0;
+    for (const id of order) {
+      if (windows[id].layer === "modal") total += 1;
+    }
+    return total;
+  }
   function layerRankOf(id) {
     return LAYER_RANK[windows[id].layer];
   }
   function sortByLayer(ids) {
     return ids.map((id, index) => ({ id, index, rank: layerRankOf(id) })).sort((a, b) => a.rank !== b.rank ? a.rank - b.rank : a.index - b.index).map((entry) => entry.id);
   }
+  function blockOf(id) {
+    const win = windows[id];
+    if (win.groupId === null) return [id];
+    return [...membersOf(win.groupId).filter((entry) => entry !== id), id];
+  }
   function raise(id) {
     const win = windows[id];
-    const without = order.filter((entry) => entry !== id);
+    const block = blockOf(id);
+    const without = order.filter((entry) => !block.includes(entry));
     const rank = LAYER_RANK[win.layer];
     let insertAt = without.length;
     for (let i = without.length - 1; i >= 0; i -= 1) {
       if (layerRankOf(without[i]) > rank) insertAt = i;
       else break;
     }
-    const next = [...without.slice(0, insertAt), id, ...without.slice(insertAt)];
+    const next = [...without.slice(0, insertAt), ...block, ...without.slice(insertAt)];
     const changed = next.length !== order.length || next.some((entry, i) => entry !== order[i]);
     order = next;
     return changed;
@@ -276,31 +311,57 @@ function createWindowManager(options = {}) {
     return win.groupId === null || activeTabs[win.groupId] === win.id;
   }
   function buildGroups() {
-    const result = {};
+    if (cachedGroups && !groupsDirty && cachedOrder === order && cachedTabs === activeTabs) {
+      return cachedGroups;
+    }
+    const result = /* @__PURE__ */ Object.create(null);
     for (const [groupId, activeId] of Object.entries(activeTabs)) {
       result[groupId] = { id: groupId, activeId, members: membersOf(groupId) };
     }
+    cachedGroups = result;
+    cachedOrder = order;
+    cachedTabs = activeTabs;
+    groupsDirty = false;
     return result;
   }
+  function sharedSize(ids, size) {
+    let shared = size;
+    for (const id of ids) {
+      const fit = normalizeSize(shared, windows[id]);
+      shared = {
+        width: Math.max(shared.width, fit.width),
+        height: Math.max(shared.height, fit.height)
+      };
+    }
+    return shared;
+  }
   function syncGroup(source) {
-    if (source.groupId === null) return;
-    for (const id of membersOf(source.groupId)) {
-      if (id === source.id) continue;
+    if (source.groupId === null) return source;
+    const members = membersOf(source.groupId);
+    const fitted = sharedSize(members, source.bounds);
+    let effective = source;
+    if (fitted.width !== source.bounds.width || fitted.height !== source.bounds.height) {
+      effective = { ...source, bounds: { ...source.bounds, ...fitted } };
+      setWindow(effective);
+    }
+    for (const id of members) {
+      if (id === effective.id) continue;
       const member = windows[id];
-      if (boundsEqual(member.bounds, source.bounds) && member.stage === source.stage && member.snapZone === source.snapZone && member.layer === source.layer && member.workspace === source.workspace) {
+      if (boundsEqual(member.bounds, effective.bounds) && member.stage === effective.stage && member.snapZone === effective.snapZone && member.layer === effective.layer && member.workspace === effective.workspace) {
         continue;
       }
       setWindow({
         ...member,
-        bounds: source.bounds,
-        stage: source.stage,
-        snapZone: source.snapZone,
-        restoreBounds: source.restoreBounds,
-        restoreStage: source.restoreStage,
-        layer: source.layer,
-        workspace: source.workspace
+        bounds: effective.bounds,
+        stage: effective.stage,
+        snapZone: effective.snapZone,
+        restoreBounds: effective.restoreBounds,
+        restoreStage: effective.restoreStage,
+        layer: effective.layer,
+        workspace: effective.workspace
       });
     }
+    return effective;
   }
   function dissolveIfOrphaned(groupId) {
     const members = membersOf(groupId);
@@ -312,6 +373,7 @@ function createWindowManager(options = {}) {
     activeTabs = rest;
   }
   function topModalId() {
+    if (modalCount === 0) return null;
     for (let i = order.length - 1; i >= 0; i -= 1) {
       const win = windows[order[i]];
       if (win.layer === "modal" && win.stage !== "minimized" && onActiveWorkspace(win) && isVisibleTab(win)) {
@@ -330,8 +392,21 @@ function createWindowManager(options = {}) {
     });
   }
   function focusTop() {
-    const targets = focusTargets();
-    focusedId = targets.length > 0 ? targets[targets.length - 1] : null;
+    for (let i = order.length - 1; i >= 0; i -= 1) {
+      const win = windows[order[i]];
+      if (win.stage === "minimized" || !onActiveWorkspace(win) || !isVisibleTab(win)) continue;
+      focusedId = win.id;
+      return;
+    }
+    focusedId = null;
+  }
+  function reconcileFocus() {
+    if (focusedId === null) return;
+    const win = windows[focusedId];
+    if (win && win.stage !== "minimized" && onActiveWorkspace(win) && isVisibleTab(win)) return;
+    const previous = focusedId;
+    focusTop();
+    if (focusedId) emitFocus(windows[focusedId], previous);
   }
   function emitFocus(win, previous) {
     queueEvent(() => emitter.emit("focus", { window: win, previous }));
@@ -454,7 +529,6 @@ function createWindowManager(options = {}) {
     const win = windows[id];
     if (!win) return false;
     if (!onActiveWorkspace(win)) setWorkspace(win.workspace);
-    if (!isVisibleTab(win)) activateTab(id);
     const modal = topModalId();
     if (modal && modal !== id && win.layer !== "modal") {
       const modalWin = windows[modal];
@@ -462,6 +536,7 @@ function createWindowManager(options = {}) {
       commitQuiet();
       return false;
     }
+    if (!isVisibleTab(win)) activateTab(id);
     if (win.stage === "minimized") {
       restore(id);
       return focusedId === id;
@@ -514,8 +589,9 @@ function createWindowManager(options = {}) {
     const next = build(win);
     if (!next) return false;
     setWindow(next);
-    syncGroup(next);
-    queueEvent(() => emitter.emit("stage", { window: next, previous: win.stage }));
+    const synced = syncGroup(next);
+    queueEvent(() => emitter.emit("stage", { window: synced, previous: win.stage }));
+    if (next.groupId !== null) reconcileFocus();
     commit();
     return true;
   }
@@ -646,9 +722,11 @@ function createWindowManager(options = {}) {
     if (boundsEqual(bounds, win.bounds) && !becameNormal) return true;
     const next = becameNormal ? { ...win, stage: "normal", snapZone: null, restoreBounds: null, bounds } : { ...win, bounds };
     setWindow(next);
-    syncGroup(next);
-    if (becameNormal) queueEvent(() => emitter.emit("stage", { window: next, previous: "snapped" }));
-    queueEvent(() => emitter.emit("resize", { window: next }));
+    const synced = syncGroup(next);
+    if (becameNormal) {
+      queueEvent(() => emitter.emit("stage", { window: synced, previous: "snapped" }));
+    }
+    queueEvent(() => emitter.emit("resize", { window: synced }));
     commit();
     return true;
   }
@@ -674,18 +752,18 @@ function createWindowManager(options = {}) {
     const resized = size.width !== next.bounds.width || size.height !== next.bounds.height;
     const finalWin = resized ? { ...next, bounds: { ...next.bounds, ...size } } : next;
     setWindow(finalWin);
-    syncGroup(finalWin);
+    const synced = syncGroup(finalWin);
     if (patch.layer && patch.layer !== win.layer) {
       order = sortByLayer(order);
       queueEvent(() => emitter.emit("order", { order }));
       if (patch.layer === "modal" && topModalId() === id && focusedId !== id) {
         const previous = focusedId;
         focusedId = id;
-        emitFocus(finalWin, previous);
+        emitFocus(synced, previous);
       }
     }
-    queueEvent(() => emitter.emit("update", { window: finalWin }));
-    if (resized) queueEvent(() => emitter.emit("resize", { window: finalWin }));
+    queueEvent(() => emitter.emit("update", { window: synced }));
+    if (resized) queueEvent(() => emitter.emit("resize", { window: synced }));
     commit();
     return true;
   }
@@ -720,6 +798,8 @@ function createWindowManager(options = {}) {
     if (!onActiveWorkspace(updated) && focusedId === id) {
       focusTop();
       if (focusedId) emitFocus(windows[focusedId], id);
+    } else if (updated.groupId !== null && !onActiveWorkspace(updated)) {
+      reconcileFocus();
     } else if (onActiveWorkspace(updated) && topModalId() === id && focusedId !== id) {
       const previous = focusedId;
       focusedId = id;
@@ -745,7 +825,16 @@ function createWindowManager(options = {}) {
       for (const entry of siblings) if (!expanded.includes(entry)) expanded.push(entry);
     }
     if (expanded.length < 2) return null;
-    const groupId = `${idPrefix}-group-${++groupCounter}`;
+    let groupId = `${idPrefix}-group-${++groupCounter}`;
+    while (activeTabs[groupId]) groupId = `${idPrefix}-group-${++groupCounter}`;
+    const shared = expanded.reduce(
+      (size, id) => {
+        const fit = normalizeSize(size, windows[id]);
+        return { width: Math.max(size.width, fit.width), height: Math.max(size.height, fit.height) };
+      },
+      { width: host.bounds.width, height: host.bounds.height }
+    );
+    const bounds = { x: host.bounds.x, y: host.bounds.y, ...shared };
     const retired = /* @__PURE__ */ new Set();
     for (const id of expanded) {
       const win = windows[id];
@@ -753,7 +842,7 @@ function createWindowManager(options = {}) {
       setWindow({
         ...win,
         groupId,
-        bounds: host.bounds,
+        bounds,
         stage: host.stage,
         snapZone: host.snapZone,
         restoreBounds: host.restoreBounds,
@@ -768,8 +857,11 @@ function createWindowManager(options = {}) {
     raise(host.id);
     emitGroup(groupId, null);
     queueEvent(() => emitter.emit("order", { order }));
+    const hostVisible = onActiveWorkspace(host) && host.stage !== "minimized";
+    commit();
+    if (hostVisible) focus(host.id);
+    reconcileFocus();
     commit();
-    if (onActiveWorkspace(host) && host.stage !== "minimized") focus(host.id);
     return groupId;
   }
   function ungroup(id) {
@@ -783,7 +875,7 @@ function createWindowManager(options = {}) {
     dissolveIfOrphaned(groupId);
     if (membersOf(groupId).length >= 2) emitGroup(groupId, wasActive ? id : null);
     commit();
-    focus(id);
+    if (onActiveWorkspace(win) && win.stage !== "minimized") focus(id);
     return true;
   }
   function activateTab(id) {
@@ -793,6 +885,10 @@ function createWindowManager(options = {}) {
     const previous = activeTabs[groupId];
     if (previous === id) return false;
     activeTabs = { ...activeTabs, [groupId]: id };
+    if (focusedId === previous) {
+      focusedId = id;
+      emitFocus(win, previous);
+    }
     emitGroup(groupId, previous);
     commit();
     return true;
@@ -803,14 +899,15 @@ function createWindowManager(options = {}) {
   function sendToBack(id) {
     const win = windows[id];
     if (!win) return false;
-    const without = order.filter((entry) => entry !== id);
+    const block = blockOf(id);
+    const without = order.filter((entry) => !block.includes(entry));
     const rank = LAYER_RANK[win.layer];
     let insertAt = 0;
     for (const entry of without) {
       if (layerRankOf(entry) < rank) insertAt += 1;
       else break;
     }
-    const next = [...without.slice(0, insertAt), id, ...without.slice(insertAt)];
+    const next = [...without.slice(0, insertAt), ...block, ...without.slice(insertAt)];
     if (next.every((entry, i) => entry === order[i])) return false;
     order = next;
     queueEvent(() => emitter.emit("order", { order }));
@@ -834,6 +931,7 @@ function createWindowManager(options = {}) {
     return Object.values(windows).filter((win) => win.stage === "minimized" && onActiveWorkspace(win) && isVisibleTab(win)).sort((a, b) => a.openedSeq - b.openedSeq);
   }
   function captureEntry() {
+    windowsShared = true;
     return { windows, order, focusedId, workspace, activeTabs };
   }
   function recordHistory() {
@@ -874,19 +972,23 @@ function createWindowManager(options = {}) {
   function reflowViewport() {
     for (const id of order) {
       const win = windows[id];
+      if (!isVisibleTab(win)) continue;
       if (win.stage === "maximized") {
         const updated = { ...win, bounds: fullBounds() };
         setWindow(updated);
-        queueEvent(() => emitter.emit("resize", { window: updated }));
+        const synced = syncGroup(updated);
+        queueEvent(() => emitter.emit("resize", { window: synced }));
       } else if (win.stage === "snapped" && win.snapZone) {
         const updated = { ...win, bounds: snapBounds(win, win.snapZone) };
         setWindow(updated);
-        queueEvent(() => emitter.emit("resize", { window: updated }));
+        const synced = syncGroup(updated);
+        queueEvent(() => emitter.emit("resize", { window: synced }));
       } else if (win.stage === "normal" && keepInViewport) {
         const bounds = clampToViewport(win.bounds, viewport, minVisible);
         if (!boundsEqual(bounds, win.bounds)) {
           const updated = { ...win, bounds };
           setWindow(updated);
+          syncGroup(updated);
           queueEvent(() => emitter.emit("move", { window: updated }));
         }
       }
@@ -895,6 +997,8 @@ function createWindowManager(options = {}) {
   function applyEntry(entry) {
     windows = entry.windows;
     order = [...entry.order];
+    modalCount = countModals();
+    groupsDirty = true;
     focusedId = entry.focusedId;
     activeTabs = entry.activeTabs;
     const previousWorkspace = workspace;
@@ -973,7 +1077,7 @@ function createWindowManager(options = {}) {
   function arrange(mode) {
     const ids = order.filter((id) => {
       const win = windows[id];
-      return win.stage !== "minimized" && onActiveWorkspace(win);
+      return win.stage !== "minimized" && onActiveWorkspace(win) && isVisibleTab(win);
     });
     if (ids.length === 0) return;
     if (mode === "cascade") {
@@ -1005,7 +1109,8 @@ function createWindowManager(options = {}) {
   }
   function minimizeAll() {
     for (const id of [...order]) {
-      if (onActiveWorkspace(windows[id])) minimize(id);
+      const win = windows[id];
+      if (onActiveWorkspace(win) && isVisibleTab(win)) minimize(id);
     }
   }
   function restoreAll() {
@@ -1112,8 +1217,11 @@ function createWindowManager(options = {}) {
       if (!seen.has(id)) nextOrder.push(id);
     }
     windows = nextWindows;
+    windowsShared = false;
     order = nextOrder;
     order = sortByLayer(order);
+    modalCount = countModals();
+    groupsDirty = true;
     seq = maxSeq;
     const previousWorkspace = workspace;
     workspace = normalizeWorkspace(data.workspace, 0);
@@ -1125,7 +1233,7 @@ function createWindowManager(options = {}) {
     if (focusedCandidate && (focusedCandidate.stage === "minimized" || !onActiveWorkspace(focusedCandidate))) {
       focusedId = null;
     }
-    const restoredTabs = {};
+    const restoredTabs = /* @__PURE__ */ Object.create(null);
     const rawTabs = data.activeTabs;
     for (const id of order) {
       const groupId = windows[id].groupId;
@@ -1222,6 +1330,7 @@ function createWindowManager(options = {}) {
 
 // src/dom/animate.ts
 function prefersReducedMotion(win) {
+  if (typeof win.matchMedia !== "function") return false;
   return win.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
 function flipFromTarget(source, target, options = {}) {
@@ -1350,14 +1459,6 @@ function createAnnouncer(wm, container, messages = {}) {
   };
 }
 
-// src/dom/shared.ts
-var INTERACTIVE_SELECTOR = "button, input, select, textarea, a[href], [contenteditable], [data-wm-close], [data-wm-minimize], [data-wm-maximize]";
-function windowOf(element) {
-  const view = element.ownerDocument.defaultView;
-  if (!view) throw new Error("wmkit: desktop element is not attached to a document");
-  return view;
-}
-
 // src/dom/drag.ts
 function createDragStarter(ctx) {
   const { wm, doc, view } = ctx;
@@ -1365,7 +1466,7 @@ function createDragStarter(ctx) {
     const win = wm.get(id);
     if (!win?.draggable || event.button !== 0 || ctx.currentDrag()) return;
     const target = event.target;
-    if (target?.closest(INTERACTIVE_SELECTOR)) return;
+    if (target?.closest(ctx.interactiveSelector)) return;
     event.preventDefault();
     const releaseRect = ctx.trackRect();
     const point = ctx.toLocal(event);
@@ -1398,6 +1499,8 @@ function createDragStarter(ctx) {
     const el = ctx.windowElement(id);
     function armGroup(target2) {
       session.groupTarget = target2;
+      session.zone = null;
+      ctx.hidePreview();
       ctx.markGroupTarget(target2);
     }
     function clearHover() {
@@ -1442,9 +1545,9 @@ function createDragStarter(ctx) {
         for (const otherId of state.order) {
           if (otherId === id) continue;
           const other = state.windows[otherId];
-          if (other && other.stage !== "minimized" && other.workspace === state.workspace) {
-            targets.push(other.bounds);
-          }
+          if (!other || other.stage === "minimized" || other.workspace !== state.workspace) continue;
+          if (other.groupId !== null && state.groups[other.groupId]?.activeId !== otherId) continue;
+          targets.push(other.bounds);
         }
         const magnet = magnetize(
           { x: nextX, y: nextY, width: current.bounds.width, height: current.bounds.height },
@@ -1718,6 +1821,99 @@ function createResizeHandles(doc, edge, corner) {
   });
 }
 
+// src/dom/shared.ts
+var INTERACTIVE_SELECTOR = "button, input, select, textarea, a[href], [contenteditable], [data-wm-close], [data-wm-minimize], [data-wm-maximize]";
+function windowOf(element) {
+  const view = element.ownerDocument.defaultView;
+  if (!view) throw new Error("wmkit: desktop element is not attached to a document");
+  return view;
+}
+
+// src/dom/stacking.ts
+var UNASSIGNED = Number.NEGATIVE_INFINITY;
+var tails = new Int32Array(0);
+var parents = new Int32Array(0);
+var kept = new Uint8Array(0);
+function reserve(length) {
+  if (tails.length >= length) return;
+  const size = Math.max(length, 64);
+  tails = new Int32Array(size);
+  parents = new Int32Array(size);
+  kept = new Uint8Array(size);
+}
+function markLongestIncreasing(target) {
+  const length = target.length;
+  reserve(length);
+  kept.fill(0, 0, length);
+  let size = 0;
+  for (let i = 0; i < length; i += 1) {
+    const value = target.zAt(i);
+    parents[i] = -1;
+    if (!Number.isFinite(value)) continue;
+    let low = 0;
+    let high = size;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (target.zAt(tails[mid]) < value) low = mid + 1;
+      else high = mid;
+    }
+    if (low > 0) parents[i] = tails[low - 1];
+    tails[low] = i;
+    if (low === size) size += 1;
+  }
+  let cursor = size > 0 ? tails[size - 1] : -1;
+  let count = 0;
+  while (cursor !== -1) {
+    kept[cursor] = 1;
+    count += 1;
+    cursor = parents[cursor];
+  }
+  return count;
+}
+function between(low, high, base, gap) {
+  if (!Number.isFinite(high)) return Number.isFinite(low) ? low + gap : base + gap;
+  if (!Number.isFinite(low)) {
+    const candidate2 = high - gap > base ? high - gap : Math.floor((base + high) / 2);
+    return candidate2 > base && candidate2 < high ? candidate2 : null;
+  }
+  const candidate = Math.floor((low + high) / 2);
+  return candidate > low && candidate < high ? candidate : null;
+}
+function renormalize(target, base, gap) {
+  let writes = 0;
+  for (let i = 0; i < target.length; i += 1) {
+    const z = base + (i + 1) * gap;
+    if (target.zAt(i) === z) continue;
+    target.assign(i, z);
+    writes += 1;
+  }
+  return writes;
+}
+function restack(target, options = {}) {
+  const base = options.base ?? 0;
+  const gap = options.gap ?? 32;
+  const length = target.length;
+  if (length === 0) return 0;
+  const keepCount = markLongestIncreasing(target);
+  if (length - keepCount > length / 3) return renormalize(target, base, gap);
+  let writes = 0;
+  for (let i = 0; i < length; i += 1) {
+    if (kept[i] === 1) continue;
+    const low = i > 0 ? target.zAt(i - 1) : UNASSIGNED;
+    let high = Number.POSITIVE_INFINITY;
+    for (let j = i + 1; j < length; j += 1) {
+      if (kept[j] !== 1) continue;
+      high = target.zAt(j);
+      break;
+    }
+    const z = between(low, high, base, gap);
+    if (z === null) return renormalize(target, base, gap);
+    target.assign(i, z);
+    writes += 1;
+  }
+  return writes;
+}
+
 // src/dom/controller.ts
 var SNAP_SHORTCUTS = {
   ArrowLeft: "left",
@@ -1744,17 +1940,24 @@ function attachDesktop(wm, element, options = {}) {
   const hitEdge = options.hitAreas?.edge ?? (coarsePointer ? 16 : 8);
   const hitCorner = options.hitAreas?.corner ?? (coarsePointer ? 24 : 12);
   const magnetThreshold = options.magnetism === false ? 0 : (typeof options.magnetism === "object" ? options.magnetism.threshold : void 0) ?? (coarsePointer ? 12 : 8);
+  const zIndexBase = options.stacking?.base ?? 0;
+  const zIndexGap = options.stacking?.gap ?? 32;
+  const interactiveSelector = options.interactiveSelector ?? INTERACTIVE_SELECTOR;
+  const animationEnabled = options.animation !== false;
+  const animationOptions = typeof options.animation === "object" ? options.animation : {};
   element.dataset.wmDesktop = "";
   element.tabIndex = -1;
   if (view.getComputedStyle(element).position === "static") {
     element.style.position = "relative";
   }
+  if (options.stacking?.isolate !== false) element.style.isolation = "isolate";
   const registry = /* @__PURE__ */ new Map();
   const cleanup = [];
   let lastOrder = null;
   let lastFocused = null;
   let drag = null;
   let groupTargetId = null;
+  let groupTargetEl = null;
   let cachedRect = null;
   let rectUsers = 0;
   let announcer = null;
@@ -1825,6 +2028,7 @@ function attachDesktop(wm, element, options = {}) {
     topEdge,
     hitEdge,
     hitCorner,
+    interactiveSelector,
     magnetThreshold,
     groupDwell,
     groupTarget(clientX, clientY, selfId) {
@@ -1833,21 +2037,16 @@ function attachDesktop(wm, element, options = {}) {
         const handle = node.closest?.("[data-wm-drag]");
         const host = handle?.closest("[data-wm-window]");
         const id = host?.dataset.wmWindow;
-        if (id && id !== selfId && registry.has(id)) return id;
+        if (id && id !== selfId && registry.get(id)?.element === host) return id;
       }
       return null;
     },
     markGroupTarget(id) {
       if (groupTargetId === id) return;
-      if (groupTargetId) {
-        const previous = registry.get(groupTargetId);
-        if (previous) delete previous.element.dataset.wmTabTarget;
-      }
+      if (groupTargetEl) delete groupTargetEl.dataset.wmTabTarget;
       groupTargetId = id;
-      if (id) {
-        const next = registry.get(id);
-        if (next) next.element.dataset.wmTabTarget = "";
-      }
+      groupTargetEl = id ? registry.get(id)?.element ?? null : null;
+      if (groupTargetEl) groupTargetEl.dataset.wmTabTarget = "";
     },
     currentDrag: () => drag,
     claimDrag(session) {
@@ -1866,7 +2065,7 @@ function attachDesktop(wm, element, options = {}) {
     observer.observe(element);
     cleanup.push(() => observer.disconnect());
   }
-  function syncWindow(attached, win, zIndex, activeWorkspace, activeTab) {
+  function syncWindow(attached, win, activeWorkspace, activeTab) {
     const el = attached.element;
     const firstSync = attached.lastState === null;
     if (firstSync) el.style.transition = "none";
@@ -1904,27 +2103,44 @@ function attachDesktop(wm, element, options = {}) {
       attached.lastWorkspace = activeWorkspace;
       attached.lastTab = activeTab;
     }
-    if (attached.lastZ !== zIndex) {
-      el.style.zIndex = String(zIndex + 1);
-      attached.lastZ = zIndex;
-    }
     if (firstSync) {
       void el.offsetWidth;
       el.style.transition = "";
     }
   }
+  const stackRows = [];
+  const stackTarget = {
+    length: 0,
+    zAt: (index) => stackRows[index].lastZ,
+    assign(index, z) {
+      const attached = stackRows[index];
+      attached.lastZ = z;
+      attached.element.style.zIndex = String(z);
+    }
+  };
+  function applyStacking(order) {
+    let length = 0;
+    for (const id of order) {
+      const attached = registry.get(id);
+      if (attached) stackRows[length++] = attached;
+    }
+    stackTarget.length = length;
+    restack(stackTarget, { base: zIndexBase, gap: zIndexGap });
+    stackRows.length = length;
+  }
   function syncAll() {
     const state = wm.getState();
     const orderChanged = state.order !== lastOrder;
-    state.order.forEach((id, index) => {
+    for (const id of state.order) {
       const attached = registry.get(id);
       const win = state.windows[id];
-      if (!attached || !win) return;
+      if (!attached || !win) continue;
       const activeTab = win.groupId === null || state.groups[win.groupId]?.activeId === win.id;
-      if (orderChanged || attached.lastState !== win || attached.lastWorkspace !== state.workspace || attached.lastTab !== activeTab) {
-        syncWindow(attached, win, index, state.workspace, activeTab);
+      if (attached.lastState !== win || attached.lastWorkspace !== state.workspace || attached.lastTab !== activeTab) {
+        syncWindow(attached, win, state.workspace, activeTab);
       }
-    });
+    }
+    if (orderChanged) applyStacking(state.order);
     if (state.focusedId !== lastFocused) {
       if (lastFocused) {
         const prev = registry.get(lastFocused);
@@ -1962,12 +2178,17 @@ function attachDesktop(wm, element, options = {}) {
     wm.on("stage", ({ window: win, previous }) => {
       const attached = registry.get(win.id);
       if (!attached) return;
+      if (!animationEnabled) return;
       if (win.stage === "minimized" && previous !== "minimized") {
         const target = options.minimizeTarget?.(win);
-        if (target) flipToTarget(attached.element, target);
+        if (target) flipToTarget(attached.element, target, animationOptions);
       } else if (previous === "minimized" && win.stage !== "minimized") {
         const target = options.minimizeTarget?.(win);
-        if (target) view.requestAnimationFrame(() => flipFromTarget(attached.element, target));
+        if (target) {
+          view.requestAnimationFrame(
+            () => flipFromTarget(attached.element, target, animationOptions)
+          );
+        }
       }
     })
   );
@@ -1981,7 +2202,7 @@ function attachDesktop(wm, element, options = {}) {
       if (!event.ctrlKey && !event.metaKey) return;
       if (drag) return;
       const target = event.target;
-      if (target?.closest(INTERACTIVE_SELECTOR)) return;
+      if (target?.closest(interactiveSelector)) return;
       if (historyShortcuts && (event.key === "z" || event.key === "Z")) {
         event.preventDefault();
         if (event.shiftKey) wm.redo();
@@ -2023,7 +2244,7 @@ function attachDesktop(wm, element, options = {}) {
       handle: null,
       handles: [],
       lastState: null,
-      lastZ: -1,
+      lastZ: UNASSIGNED,
       lastWorkspace: -1,
       lastTab: true,
       cleanup: []
@@ -2057,7 +2278,7 @@ function attachDesktop(wm, element, options = {}) {
       const current = wm.get(id);
       if (!current) return;
       if (target.closest("[data-wm-close]")) {
-        if (current.closable) wm.close(id);
+        if (current.closable && options.beforeClose?.(current) !== false) wm.close(id);
       } else if (target.closest("[data-wm-minimize]")) {
         if (current.minimizable) wm.minimize(id);
       } else if (target.closest("[data-wm-maximize]")) {
@@ -2073,7 +2294,7 @@ function attachDesktop(wm, element, options = {}) {
       attached.cleanup.push(() => handle.removeEventListener("pointerdown", onHandleDown));
       const onDoubleClick = (event) => {
         const target = event.target;
-        if (target?.closest(INTERACTIVE_SELECTOR)) return;
+        if (target?.closest(interactiveSelector)) return;
         const current = wm.get(id);
         if (current?.maximizable) wm.toggleMaximize(id);
       };
@@ -2105,7 +2326,7 @@ function attachDesktop(wm, element, options = {}) {
     }
     const onWindowKeydown = (event) => {
       const target = event.target;
-      if (target?.closest(INTERACTIVE_SELECTOR)) return;
+      if (target?.closest(interactiveSelector)) return;
       const current = wm.get(id);
       if (!current) return;
       const arrows = {
@@ -2249,5 +2470,5 @@ function createDesktopBinder(wm, options = {}) {
 }
 
 export { applyAspect, attachDesktop, boundsEqual, clamp, clampSize, clampToViewport, createAnnouncer, createDesktopBinder, createEmitter, createWindowManager, defaultMessages, detectSnapZone, flipFromTarget, flipToTarget, magnetize, prefersReducedMotion, zoneBounds };
-//# sourceMappingURL=chunk-L43XBN44.js.map
-//# sourceMappingURL=chunk-L43XBN44.js.map
+//# sourceMappingURL=chunk-3HLKVOSI.js.map
+//# sourceMappingURL=chunk-3HLKVOSI.js.map