@surdeddd/wmkit 0.2.0 → 0.4.0

package/dist/{chunk-2TVOEDRG.js → chunk-FPZDAKNP.js}

@@ -38,19 +38,48 @@ function clampSize(size, min, max) {
 }
 function clampToViewport(bounds, viewport, minVisible) {
   if (viewport.width <= 0 || viewport.height <= 0) return bounds;
-  const x = clamp(bounds.x, minVisible - bounds.width, viewport.width - minVisible);
-  const y = clamp(bounds.y, 0, Math.max(0, viewport.height - minVisible));
+  const visibleX = Math.min(minVisible, bounds.width);
+  const visibleY = Math.min(minVisible, bounds.height);
+  const x = clamp(bounds.x, visibleX - bounds.width, Math.max(0, viewport.width - visibleX));
+  const y = clamp(bounds.y, 0, Math.max(0, viewport.height - visibleY));
   return x === bounds.x && y === bounds.y ? bounds : { ...bounds, x, y };
 }
 function boundsEqual(a, b) {
   return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
 }
+function applyAspect(size, ratio, min, max, drive) {
+  if (!Number.isFinite(ratio) || ratio <= 0) return clampSize(size, min, max);
+  const maxWidth = max ? max.width : Number.POSITIVE_INFINITY;
+  const maxHeight = max ? max.height : Number.POSITIVE_INFINITY;
+  if (drive === "height") {
+    const height = clamp(
+      size.height,
+      Math.max(min.height, min.width / ratio),
+      Math.min(maxHeight, maxWidth / ratio)
+    );
+    return { width: height * ratio, height };
+  }
+  const width = clamp(
+    size.width,
+    Math.max(min.width, min.height * ratio),
+    Math.min(maxWidth, maxHeight * ratio)
+  );
+  return { width, height: width / ratio };
+}
 function zoneBounds(zone, viewport) {
   const w = viewport.width;
   const h = viewport.height;
   const halfW = Math.round(w / 2);
   const halfH = Math.round(h / 2);
+  const oneThird = Math.round(w / 3);
+  const twoThirds = Math.round(w * 2 / 3);
   switch (zone) {
+    case "left-third":
+      return { x: 0, y: 0, width: oneThird, height: h };
+    case "center-third":
+      return { x: oneThird, y: 0, width: twoThirds - oneThird, height: h };
+    case "right-third":
+      return { x: twoThirds, y: 0, width: w - twoThirds, height: h };
     case "left":
       return { x: 0, y: 0, width: halfW, height: h };
     case "right":
@@ -97,6 +126,42 @@ function detectSnapZone(x, y, viewport, options = {}) {
   }
   return null;
 }
+function nearestEdge(low, high, targetLow, targetHigh) {
+  return [targetLow - low, targetHigh - low, targetLow - high, targetHigh - high];
+}
+function magnetize(bounds, targets, threshold) {
+  const result = { x: bounds.x, y: bounds.y, snappedX: false, snappedY: false };
+  if (threshold <= 0 || targets.length === 0) return result;
+  let bestX = threshold + 1;
+  let bestY = threshold + 1;
+  for (const target of targets) {
+    for (const delta of nearestEdge(
+      bounds.x,
+      bounds.x + bounds.width,
+      target.x,
+      target.x + target.width
+    )) {
+      if (Math.abs(delta) <= threshold && Math.abs(delta) < Math.abs(bestX)) bestX = delta;
+    }
+    for (const delta of nearestEdge(
+      bounds.y,
+      bounds.y + bounds.height,
+      target.y,
+      target.y + target.height
+    )) {
+      if (Math.abs(delta) <= threshold && Math.abs(delta) < Math.abs(bestY)) bestY = delta;
+    }
+  }
+  if (Math.abs(bestX) <= threshold) {
+    result.x = bounds.x + bestX;
+    result.snappedX = true;
+  }
+  if (Math.abs(bestY) <= threshold) {
+    result.y = bounds.y + bestY;
+    result.snappedY = true;
+  }
+  return result;
+}
 
 // src/core/manager.ts
 var LAYER_RANK = { normal: 0, floating: 1, modal: 2 };
@@ -110,8 +175,14 @@ var ZONES = [
   "top-left",
   "top-right",
   "bottom-left",
-  "bottom-right"
+  "bottom-right",
+  "left-third",
+  "center-third",
+  "right-third"
 ];
+function normalizeWorkspace(value, fallback) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : fallback;
+}
 function createWindowManager(options = {}) {
   const emitter = createEmitter();
   const keepInViewport = options.keepInViewport ?? true;
@@ -120,26 +191,41 @@ function createWindowManager(options = {}) {
   const cascadeOffset = options.cascadeOffset ?? 32;
   const cascadeOrigin = options.cascadeOrigin ?? { x: 32, y: 32 };
   const idPrefix = options.idPrefix ?? "wm";
+  const historyLimit = options.historyLimit ?? 50;
   let windows = {};
   let order = [];
   let focusedId = null;
   let viewport = options.viewport ?? { width: 0, height: 0 };
+  let workspace = normalizeWorkspace(options.workspace, 0);
   let seq = 0;
   let idCounter = 0;
   let cascadeIndex = 0;
   let snapshot = null;
   let batchDepth = 0;
   let batchDirty = false;
+  let historyDirty = false;
   const pendingEvents = [];
+  const past = [];
+  let future = [];
+  let interactionDepth = 0;
+  let interactionRecorded = false;
+  let skipNextHistory = false;
+  let pendingHistory = null;
+  const layouts = /* @__PURE__ */ new Map();
   function getState() {
     if (!snapshot) {
-      snapshot = { windows, order, focusedId, viewport };
+      snapshot = { windows, order, focusedId, viewport, workspace };
     }
     return snapshot;
   }
   function commit() {
     snapshot = null;
     batchDirty = true;
+    historyDirty = true;
+  }
+  function commitQuiet() {
+    snapshot = null;
+    batchDirty = true;
   }
   function flushEvents() {
     while (pendingEvents.length > 0) {
@@ -177,10 +263,14 @@ function createWindowManager(options = {}) {
     order = next;
     return changed;
   }
+  function onActiveWorkspace(win) {
+    return win.workspace === workspace;
+  }
   function topModalId() {
     for (let i = order.length - 1; i >= 0; i -= 1) {
       const win = windows[order[i]];
-      if (win.layer === "modal" && win.stage !== "minimized") return win.id;
+      if (win.layer === "modal" && win.stage !== "minimized" && onActiveWorkspace(win))
+        return win.id;
     }
     return null;
   }
@@ -188,7 +278,7 @@ function createWindowManager(options = {}) {
     const modal = topModalId();
     return order.filter((id) => {
       const win = windows[id];
-      if (win.stage === "minimized") return false;
+      if (win.stage === "minimized" || !onActiveWorkspace(win)) return false;
       if (modal && win.layer !== "modal") return false;
       return true;
     });
@@ -200,8 +290,9 @@ function createWindowManager(options = {}) {
   function emitFocus(win, previous) {
     queueEvent(() => emitter.emit("focus", { window: win, previous }));
   }
-  function normalizeSize(size, win) {
-    return clampSize(size, win.minSize, win.maxSize);
+  function normalizeSize(size, win, drive = "width") {
+    if (win.aspectRatio === null) return clampSize(size, win.minSize, win.maxSize);
+    return applyAspect(size, win.aspectRatio, win.minSize, win.maxSize, drive);
   }
   function positionForOpen(init) {
     if (init.x !== void 0 && init.y !== void 0) return { x: init.x, y: init.y };
@@ -223,11 +314,12 @@ function createWindowManager(options = {}) {
       width: init.maxWidth ?? Number.POSITIVE_INFINITY,
       height: init.maxHeight ?? Number.POSITIVE_INFINITY
     } : null;
-    const size = clampSize(
-      { width: init.width ?? defaultSize.width, height: init.height ?? defaultSize.height },
-      minSize,
-      maxSize
-    );
+    const aspectRatio = init.aspectRatio !== void 0 && Number.isFinite(init.aspectRatio) && init.aspectRatio > 0 ? init.aspectRatio : null;
+    const requested = {
+      width: init.width ?? defaultSize.width,
+      height: init.height ?? defaultSize.height
+    };
+    const size = aspectRatio === null ? clampSize(requested, minSize, maxSize) : applyAspect(requested, aspectRatio, minSize, maxSize, "width");
     const position = positionForOpen(init);
     let bounds = { ...position, ...size };
     if (keepInViewport) bounds = clampToViewport(bounds, viewport, minVisible);
@@ -242,8 +334,10 @@ function createWindowManager(options = {}) {
       stage: "normal",
       snapZone: null,
       layer: init.layer ?? "normal",
+      workspace: normalizeWorkspace(init.workspace, workspace),
       minSize,
       maxSize,
+      aspectRatio,
       openedSeq: ++seq,
       draggable: init.draggable ?? true,
       resizable: init.resizable ?? true,
@@ -261,7 +355,7 @@ function createWindowManager(options = {}) {
     setWindow(win);
     raise(id);
     let focusPayload = null;
-    if (stage !== "minimized") {
+    if (stage !== "minimized" && onActiveWorkspace(win)) {
       const previous = focusedId;
       const modal = topModalId();
       if (!modal || win.layer === "modal") {
@@ -299,11 +393,12 @@ function createWindowManager(options = {}) {
   function focus(id) {
     const win = windows[id];
     if (!win) return false;
+    if (!onActiveWorkspace(win)) setWorkspace(win.workspace);
     const modal = topModalId();
     if (modal && modal !== id && win.layer !== "modal") {
       const modalWin = windows[modal];
       if (modalWin) queueEvent(() => emitter.emit("modalblocked", { window: modalWin }));
-      commit();
+      commitQuiet();
       return false;
     }
     if (win.stage === "minimized") {
@@ -338,6 +433,14 @@ function createWindowManager(options = {}) {
   function fullBounds() {
     return { x: 0, y: 0, width: viewport.width, height: viewport.height };
   }
+  function snapBounds(win, zone) {
+    const rect = zoneBounds(zone, viewport);
+    return { x: rect.x, y: rect.y, ...normalizeSize(rect, win) };
+  }
+  function focusUnlessBlocked(id) {
+    const modal = topModalId();
+    if (modal === null || modal === id) focus(id);
+  }
   function applyStage(id, build) {
     const win = windows[id];
     if (!win) return false;
@@ -364,7 +467,7 @@ function createWindowManager(options = {}) {
   function maximize(id) {
     const result = applyStage(id, (win) => {
       if (win.stage === "maximized") return null;
-      const restoreBounds = win.stage === "normal" ? win.bounds : win.restoreBounds;
+      const restoreBounds = win.stage === "normal" ? win.bounds : win.restoreBounds ?? win.bounds;
       return {
         ...win,
         stage: "maximized",
@@ -385,22 +488,23 @@ function createWindowManager(options = {}) {
   function restore(id) {
     const result = applyStage(id, (win) => {
       if (win.stage === "minimized") {
-        const target = win.restoreStage ?? "normal";
-        if (target === "maximized") {
+        const target2 = win.restoreStage ?? "normal";
+        if (target2 === "maximized") {
           return { ...win, stage: "maximized", restoreStage: null, bounds: fullBounds() };
         }
-        if (target === "snapped" && win.snapZone) {
+        if (target2 === "snapped" && win.snapZone) {
           return {
             ...win,
             stage: "snapped",
             restoreStage: null,
-            bounds: zoneBounds(win.snapZone, viewport)
+            bounds: snapBounds(win, win.snapZone)
           };
         }
         return { ...win, stage: "normal", restoreStage: null };
       }
       if (win.stage === "normal") return null;
-      const bounds = win.restoreBounds ?? win.bounds;
+      const target = win.restoreBounds ?? win.bounds;
+      const bounds = { x: target.x, y: target.y, ...normalizeSize(target, win) };
       return {
         ...win,
         stage: "normal",
@@ -410,7 +514,7 @@ function createWindowManager(options = {}) {
         bounds: keepInViewport ? clampToViewport(bounds, viewport, minVisible) : bounds
       };
     });
-    if (result) focus(id);
+    if (result) focusUnlessBlocked(id);
     return result;
   }
   function restoreTo(id, bounds) {
@@ -426,19 +530,19 @@ function createWindowManager(options = {}) {
         bounds: keepInViewport ? clampToViewport(next, viewport, minVisible) : next
       };
     });
-    if (result) focus(id);
+    if (result) focusUnlessBlocked(id);
     return result;
   }
   function snap(id, zone) {
     const result = applyStage(id, (win) => {
-      const restoreBounds = win.stage === "normal" ? win.bounds : win.restoreBounds;
+      const restoreBounds = win.stage === "normal" ? win.bounds : win.restoreBounds ?? win.bounds;
       return {
         ...win,
         stage: "snapped",
         snapZone: zone,
         restoreBounds,
         restoreStage: null,
-        bounds: zoneBounds(zone, viewport)
+        bounds: snapBounds(win, zone)
       };
     });
     if (result) focus(id);
@@ -465,7 +569,8 @@ function createWindowManager(options = {}) {
     const win = windows[id];
     if (!win || win.stage === "maximized" || win.stage === "minimized") return false;
     const merged = { ...win.bounds, ...patch };
-    const size = normalizeSize(merged, win);
+    const drive = Math.abs(merged.height - win.bounds.height) > Math.abs(merged.width - win.bounds.width) ? "height" : "width";
+    const size = normalizeSize(merged, win, drive);
     let bounds = { x: merged.x, y: merged.y, ...size };
     if (keepInViewport) bounds = clampToViewport(bounds, viewport, minVisible);
     const becameNormal = win.stage === "snapped";
@@ -486,6 +591,7 @@ function createWindowManager(options = {}) {
       layer: patch.layer ?? win.layer,
       minSize: patch.minSize ?? win.minSize,
       maxSize: patch.maxSize === void 0 ? win.maxSize : patch.maxSize,
+      aspectRatio: patch.aspectRatio === void 0 ? win.aspectRatio : patch.aspectRatio !== null && Number.isFinite(patch.aspectRatio) && patch.aspectRatio > 0 ? patch.aspectRatio : null,
       draggable: patch.draggable ?? win.draggable,
       resizable: patch.resizable ?? win.resizable,
       closable: patch.closable ?? win.closable,
@@ -515,47 +621,242 @@ function createWindowManager(options = {}) {
   function setViewport(next) {
     if (next.width === viewport.width && next.height === viewport.height) return;
     viewport = { ...next };
-    transact(() => {
-      for (const id of order) {
-        const win = windows[id];
-        if (win.stage === "maximized") {
-          const updated = { ...win, bounds: fullBounds() };
-          setWindow(updated);
-          queueEvent(() => emitter.emit("resize", { window: updated }));
-        } else if (win.stage === "snapped" && win.snapZone) {
-          const updated = { ...win, bounds: zoneBounds(win.snapZone, viewport) };
-          setWindow(updated);
-          queueEvent(() => emitter.emit("resize", { window: updated }));
-        } else if (win.stage === "normal" && keepInViewport) {
-          const bounds = clampToViewport(win.bounds, viewport, minVisible);
-          if (!boundsEqual(bounds, win.bounds)) {
-            const updated = { ...win, bounds };
-            setWindow(updated);
-            queueEvent(() => emitter.emit("move", { window: updated }));
-          }
-        }
-      }
-      snapshot = null;
-      batchDirty = true;
-    });
+    reflowViewport();
+    commitQuiet();
+  }
+  function setWorkspace(next) {
+    const target = normalizeWorkspace(next, workspace);
+    if (target === workspace) return false;
+    const previous = workspace;
+    workspace = target;
+    const previousFocus = focusedId;
+    focusTop();
+    queueEvent(() => emitter.emit("workspace", { workspace: target, previous }));
+    if (focusedId && focusedId !== previousFocus) {
+      emitFocus(windows[focusedId], previousFocus);
+    }
+    commit();
+    return true;
+  }
+  function moveToWorkspace(id, next) {
+    const win = windows[id];
+    if (!win) return false;
+    const target = normalizeWorkspace(next, win.workspace);
+    if (target === win.workspace) return false;
+    const updated = { ...win, workspace: target };
+    setWindow(updated);
+    if (!onActiveWorkspace(updated) && focusedId === id) {
+      focusTop();
+      if (focusedId) emitFocus(windows[focusedId], id);
+    }
+    queueEvent(() => emitter.emit("update", { window: updated }));
+    commit();
+    return true;
+  }
+  function sendToBack(id) {
+    const win = windows[id];
+    if (!win) return false;
+    const without = order.filter((entry) => entry !== id);
+    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)];
+    if (next.every((entry, i) => entry === order[i])) return false;
+    order = next;
+    queueEvent(() => emitter.emit("order", { order }));
+    if (focusedId === id) {
+      focusTop();
+      if (focusedId) emitFocus(windows[focusedId], id);
+    }
+    commit();
+    return true;
+  }
+  function center(id) {
+    const win = windows[id];
+    if (win?.stage !== "normal") return false;
+    return move(
+      id,
+      Math.round((viewport.width - win.bounds.width) / 2),
+      Math.round((viewport.height - win.bounds.height) / 2)
+    );
   }
   function minimized() {
-    return Object.values(windows).filter((win) => win.stage === "minimized").sort((a, b) => a.openedSeq - b.openedSeq);
+    return Object.values(windows).filter((win) => win.stage === "minimized" && onActiveWorkspace(win)).sort((a, b) => a.openedSeq - b.openedSeq);
+  }
+  function captureEntry() {
+    return { windows, order, focusedId, workspace };
+  }
+  function recordHistory() {
+    if (!historyDirty) return;
+    if (skipNextHistory) {
+      skipNextHistory = false;
+      return;
+    }
+    if (historyLimit <= 0) return;
+    if (interactionDepth > 0) {
+      if (interactionRecorded) return;
+      interactionRecorded = true;
+    }
+    past.push(pendingHistory);
+    if (past.length > historyLimit) past.shift();
+    future = [];
   }
   function transact(run) {
+    if (batchDepth === 0) pendingHistory = captureEntry();
     batchDepth += 1;
     try {
       return run();
     } finally {
       batchDepth -= 1;
-      if (batchDepth === 0 && batchDirty) {
-        batchDirty = false;
-        snapshot = null;
-        flushEvents();
-        emitter.emit("change", { state: getState() });
+      if (batchDepth === 0) {
+        if (batchDirty) {
+          batchDirty = false;
+          recordHistory();
+          historyDirty = false;
+          snapshot = null;
+          flushEvents();
+          emitter.emit("change", { state: getState() });
+        }
+        pendingHistory = null;
       }
     }
   }
+  function reflowViewport() {
+    for (const id of order) {
+      const win = windows[id];
+      if (win.stage === "maximized") {
+        const updated = { ...win, bounds: fullBounds() };
+        setWindow(updated);
+        queueEvent(() => emitter.emit("resize", { window: updated }));
+      } else if (win.stage === "snapped" && win.snapZone) {
+        const updated = { ...win, bounds: snapBounds(win, win.snapZone) };
+        setWindow(updated);
+        queueEvent(() => emitter.emit("resize", { window: updated }));
+      } else if (win.stage === "normal" && keepInViewport) {
+        const bounds = clampToViewport(win.bounds, viewport, minVisible);
+        if (!boundsEqual(bounds, win.bounds)) {
+          const updated = { ...win, bounds };
+          setWindow(updated);
+          queueEvent(() => emitter.emit("move", { window: updated }));
+        }
+      }
+    }
+  }
+  function applyEntry(entry) {
+    windows = entry.windows;
+    order = [...entry.order];
+    focusedId = entry.focusedId;
+    const previousWorkspace = workspace;
+    workspace = entry.workspace;
+    if (workspace !== previousWorkspace) {
+      queueEvent(() => emitter.emit("workspace", { workspace, previous: previousWorkspace }));
+    }
+    reflowViewport();
+    commit();
+  }
+  function undo() {
+    const entry = past.pop();
+    if (!entry) return false;
+    future.push(captureEntry());
+    skipNextHistory = true;
+    applyEntry(entry);
+    return true;
+  }
+  function redo() {
+    const entry = future.pop();
+    if (!entry) return false;
+    past.push(captureEntry());
+    skipNextHistory = true;
+    applyEntry(entry);
+    return true;
+  }
+  function beginInteraction() {
+    interactionDepth += 1;
+    if (interactionDepth === 1) interactionRecorded = false;
+  }
+  function endInteraction() {
+    if (interactionDepth > 0) interactionDepth -= 1;
+  }
+  function abortInteraction() {
+    if (interactionDepth > 0 && interactionRecorded) {
+      past.pop();
+      interactionRecorded = false;
+    }
+    endInteraction();
+  }
+  function clearHistory() {
+    past.length = 0;
+    future = [];
+  }
+  function saveLayout(name) {
+    const data = serialize();
+    layouts.set(name, structuredClone(data));
+    return data;
+  }
+  function loadLayout(name) {
+    const data = layouts.get(name);
+    if (!data) return false;
+    return hydrate(structuredClone(data));
+  }
+  function getLayout(name) {
+    const data = layouts.get(name);
+    return data ? structuredClone(data) : void 0;
+  }
+  function setLayout(name, data) {
+    if (!isValidSerialized(data)) return false;
+    layouts.set(name, structuredClone(data));
+    return true;
+  }
+  function deleteLayout(name) {
+    return layouts.delete(name);
+  }
+  function layoutNames() {
+    return [...layouts.keys()];
+  }
+  function arrange(mode) {
+    const ids = order.filter((id) => {
+      const win = windows[id];
+      return win.stage !== "minimized" && onActiveWorkspace(win);
+    });
+    if (ids.length === 0) return;
+    if (mode === "cascade") {
+      ids.forEach((id, index) => {
+        const win = windows[id];
+        const size = win.restoreBounds ?? win.bounds;
+        restoreTo(id, {
+          x: cascadeOrigin.x + index % 10 * cascadeOffset,
+          y: cascadeOrigin.y + index % 10 * cascadeOffset,
+          width: size.width,
+          height: size.height
+        });
+      });
+      return;
+    }
+    if (viewport.width <= 0 || viewport.height <= 0) return;
+    const cols = Math.ceil(Math.sqrt(ids.length));
+    const rows = Math.ceil(ids.length / cols);
+    const cellWidth = Math.floor(viewport.width / cols);
+    const cellHeight = Math.floor(viewport.height / rows);
+    ids.forEach((id, index) => {
+      restoreTo(id, {
+        x: index % cols * cellWidth,
+        y: Math.floor(index / cols) * cellHeight,
+        width: cellWidth,
+        height: cellHeight
+      });
+    });
+  }
+  function minimizeAll() {
+    for (const id of [...order]) {
+      if (onActiveWorkspace(windows[id])) minimize(id);
+    }
+  }
+  function restoreAll() {
+    for (const win of minimized()) restore(win.id);
+  }
   function serialize() {
     return {
       version: 1,
@@ -571,7 +872,8 @@ function createWindowManager(options = {}) {
         meta: { ...win.meta }
       })),
       order: [...order],
-      focusedId
+      focusedId,
+      workspace
     };
   }
   function isBounds(value) {
@@ -602,10 +904,16 @@ function createWindowManager(options = {}) {
     const win = value;
     return typeof win.id === "string" && win.id.length > 0 && isBounds(win.bounds) && STAGES.includes(win.stage) && LAYERS.includes(win.layer);
   }
-  function hydrate(data) {
+  function isValidSerialized(data) {
     if (typeof data !== "object" || data === null) return false;
     if (data.version !== 1 || !Array.isArray(data.windows)) return false;
     if (!data.windows.every(isSerializedWindow)) return false;
+    const ids = new Set(data.windows.map((win) => win.id));
+    return ids.size === data.windows.length;
+  }
+  function hydrate(data) {
+    if (!isValidSerialized(data)) return false;
+    const previousWindows = windows;
     const nextWindows = {};
     let maxSeq = 0;
     for (const raw of data.windows) {
@@ -619,8 +927,10 @@ function createWindowManager(options = {}) {
         stage: raw.stage,
         snapZone: ZONES.includes(raw.snapZone) ? raw.snapZone : null,
         layer: raw.layer,
+        workspace: normalizeWorkspace(raw.workspace, 0),
         minSize: isSize(raw.minSize) ? { ...raw.minSize } : { width: 160, height: 100 },
         maxSize: readMaxSize(raw.maxSize),
+        aspectRatio: typeof raw.aspectRatio === "number" && Number.isFinite(raw.aspectRatio) && raw.aspectRatio > 0 ? raw.aspectRatio : null,
         openedSeq: typeof raw.openedSeq === "number" ? raw.openedSeq : ++maxSeq,
         draggable: raw.draggable !== false,
         resizable: raw.resizable !== false,
@@ -649,14 +959,38 @@ function createWindowManager(options = {}) {
     order = nextOrder;
     order = sortByLayer(order);
     seq = maxSeq;
+    const previousWorkspace = workspace;
+    workspace = normalizeWorkspace(data.workspace, 0);
+    if (workspace !== previousWorkspace) {
+      queueEvent(() => emitter.emit("workspace", { workspace, previous: previousWorkspace }));
+    }
     focusedId = data.focusedId && windows[data.focusedId] ? data.focusedId : null;
-    if (focusedId && windows[focusedId]?.stage === "minimized") focusedId = null;
+    const focusedCandidate = focusedId ? windows[focusedId] : void 0;
+    if (focusedCandidate && (focusedCandidate.stage === "minimized" || !onActiveWorkspace(focusedCandidate))) {
+      focusedId = null;
+    }
     if (!focusedId) focusTop();
     const modal = topModalId();
     if (modal) {
       const focusedWin = focusedId ? windows[focusedId] : null;
       if (focusedWin?.layer !== "modal") focusedId = modal;
     }
+    for (const id of Object.keys(previousWindows)) {
+      if (!windows[id]) {
+        const closed = previousWindows[id];
+        queueEvent(() => emitter.emit("close", { window: closed }));
+      }
+    }
+    for (const id of order) {
+      if (!previousWindows[id]) {
+        const opened = windows[id];
+        queueEvent(() => emitter.emit("open", { window: opened }));
+      }
+    }
+    if (viewport.width > 0 && viewport.height > 0) reflowViewport();
+    queueEvent(() => emitter.emit("order", { order }));
+    clearHistory();
+    skipNextHistory = true;
     commit();
     return true;
   }
@@ -678,15 +1012,37 @@ function createWindowManager(options = {}) {
     snap: (id, zone) => transact(() => snap(id, zone)),
     move: (id, x, y) => transact(() => move(id, x, y)),
     moveBy: (id, dx, dy) => transact(() => moveBy(id, dx, dy)),
+    center: (id) => transact(() => center(id)),
+    sendToBack: (id) => transact(() => sendToBack(id)),
     resize: (id, patch) => transact(() => resize(id, patch)),
     update: (id, patch) => transact(() => update(id, patch)),
     get: (id) => windows[id],
     getState,
     minimized,
     setViewport: (next) => transact(() => setViewport(next)),
+    workspace: () => workspace,
+    setWorkspace: (next) => transact(() => setWorkspace(next)),
+    moveToWorkspace: (id, next) => transact(() => moveToWorkspace(id, next)),
     batch: (run) => transact(run),
     serialize,
     hydrate: (data) => transact(() => hydrate(data)),
+    undo: () => transact(undo),
+    redo: () => transact(redo),
+    canUndo: () => past.length > 0,
+    canRedo: () => future.length > 0,
+    beginInteraction,
+    endInteraction,
+    abortInteraction,
+    clearHistory,
+    saveLayout,
+    loadLayout: (name) => transact(() => loadLayout(name)),
+    getLayout,
+    setLayout,
+    deleteLayout,
+    layoutNames,
+    arrange: (mode) => transact(() => arrange(mode)),
+    minimizeAll: () => transact(minimizeAll),
+    restoreAll: () => transact(restoreAll),
     subscribe: (listener) => emitter.on("change", ({ state }) => listener(state)),
     on: (event, listener) => emitter.on(event, listener),
     destroy
@@ -697,6 +1053,34 @@ function createWindowManager(options = {}) {
 function prefersReducedMotion(win) {
   return win.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
+function flipFromTarget(source, target, options = {}) {
+  const view = source.ownerDocument.defaultView;
+  if (!view || prefersReducedMotion(view)) return;
+  if (typeof source.animate !== "function") return;
+  const from = target.getBoundingClientRect();
+  const to = source.getBoundingClientRect();
+  if (from.width === 0 || to.width === 0) return;
+  const ghost = source.ownerDocument.createElement("div");
+  const style = view.getComputedStyle(source);
+  ghost.style.cssText = `position:fixed;left:${to.left}px;top:${to.top}px;width:${to.width}px;height:${to.height}px;margin:0;pointer-events:none;z-index:2147483647;border-radius:${style.borderRadius};background:${style.backgroundColor};box-shadow:${style.boxShadow};transform-origin:top left;will-change:transform,opacity`;
+  source.ownerDocument.body.append(ghost);
+  const dx = from.left + from.width / 2 - (to.left + to.width / 2);
+  const dy = from.top + from.height / 2 - (to.top + to.height / 2);
+  const scaleX = Math.max(from.width / to.width, 0.05);
+  const scaleY = Math.max(from.height / to.height, 0.05);
+  const animation = ghost.animate(
+    [
+      { transform: `translate(${dx}px, ${dy}px) scale(${scaleX}, ${scaleY})`, opacity: 0.2 },
+      { transform: "translate(0, 0) scale(1, 1)", opacity: 0.9 }
+    ],
+    {
+      duration: options.duration ?? 260,
+      easing: options.easing ?? "cubic-bezier(0.32, 0.72, 0, 1)"
+    }
+  );
+  animation.onfinish = () => ghost.remove();
+  animation.oncancel = () => ghost.remove();
+}
 function flipToTarget(source, target, options = {}) {
   const view = source.ownerDocument.defaultView;
   if (!view || prefersReducedMotion(view)) return;
@@ -734,7 +1118,8 @@ var defaultMessages = {
   restored: (title) => `${title} restored`,
   maximized: (title) => `${title} maximized`,
   snapped: (title, zone) => `${title} snapped to ${zone.replace("-", " ")}`,
-  focused: (title) => `${title} focused`
+  focused: (title) => `${title} focused`,
+  workspace: (index) => `workspace ${index + 1}`
 };
 function createAnnouncer(wm, container, messages = {}) {
   const dict = { ...defaultMessages, ...messages };
@@ -745,7 +1130,10 @@ function createAnnouncer(wm, container, messages = {}) {
   element.style.cssText = "position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0";
   container.append(element);
   let clearTimer;
+  let lastMessage = "";
+  let detailed = false;
   function announce(message) {
+    lastMessage = message;
     element.textContent = message;
     if (clearTimer !== void 0) clearTimeout(clearTimer);
     clearTimer = setTimeout(() => {
@@ -761,6 +1149,19 @@ function createAnnouncer(wm, container, messages = {}) {
       else if (win.stage === "snapped" && win.snapZone)
         announce(dict.snapped(win.title, win.snapZone));
       else if (win.stage === "normal" && previous !== "normal") announce(dict.restored(win.title));
+      else return;
+      detailed = true;
+    }),
+    wm.on("focus", ({ window: win, previous }) => {
+      if (detailed || previous === null || lastMessage === dict.opened(win.title)) return;
+      announce(dict.focused(win.title));
+    }),
+    wm.on("workspace", ({ workspace }) => {
+      announce(dict.workspace(workspace));
+      detailed = true;
+    }),
+    wm.subscribe(() => {
+      detailed = false;
     })
   ];
   return {
@@ -839,7 +1240,29 @@ function createDragStarter(ctx) {
         }
         return;
       }
-      wm.move(id, session.pendingX - session.grabDX, session.pendingY - session.grabDY);
+      let nextX = session.pendingX - session.grabDX;
+      let nextY = session.pendingY - session.grabDY;
+      if (ctx.magnetThreshold > 0) {
+        const state = wm.getState();
+        const targets = [
+          { x: 0, y: 0, width: state.viewport.width, height: state.viewport.height }
+        ];
+        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);
+          }
+        }
+        const magnet = magnetize(
+          { x: nextX, y: nextY, width: current.bounds.width, height: current.bounds.height },
+          targets,
+          ctx.magnetThreshold
+        );
+        nextX = magnet.x;
+        nextY = magnet.y;
+      }
+      wm.move(id, nextX, nextY);
       if (ctx.snapEnabled && current.snappable) {
         const viewport = wm.getState().viewport;
         const rawZone = detectSnapZone(session.pendingX, session.pendingY, viewport, ctx.snapDetect);
@@ -863,7 +1286,7 @@ function createDragStarter(ctx) {
       const movePoint = ctx.toLocal(moveEvent);
       if (!session.moved) {
         const travelled = Math.abs(movePoint.x - (session.startBounds.x + session.grabDX)) + Math.abs(movePoint.y - (session.startBounds.y + session.grabDY));
-        if (travelled < 3 && session.restored) return;
+        if (travelled < 3) return;
         session.moved = true;
         if (el) {
           el.dataset.wmDragging = "";
@@ -891,42 +1314,46 @@ function createDragStarter(ctx) {
     }
     function finish(cancelled) {
       if (ctx.currentDrag() !== session) return;
-      if (session.raf !== 0) view.cancelAnimationFrame(session.raf);
-      if (session.hasPending && !cancelled) flush();
-      ctx.releaseDrag(session);
-      releaseRect();
-      handle.removeEventListener("pointermove", onMove);
-      handle.removeEventListener("pointerup", onUp);
-      handle.removeEventListener("pointercancel", onCancel);
-      doc.removeEventListener("keydown", onKeydown, true);
-      if (handle.hasPointerCapture(session.pointerId)) {
-        handle.releasePointerCapture(session.pointerId);
-      }
-      if (el) {
-        delete el.dataset.wmDragging;
-        el.style.willChange = "";
-      }
-      ctx.hidePreview();
-      if (cancelled) {
-        if (session.moved && session.restored) {
-          if (session.startStage === "maximized") {
-            wm.restoreTo(id, session.startRestoreBounds ?? session.startBounds);
-            wm.maximize(id);
-          } else if (session.startStage === "snapped" && session.startZone) {
-            wm.restoreTo(id, session.startRestoreBounds ?? session.startBounds);
-            wm.snap(id, session.startZone);
-          } else {
-            wm.move(id, session.startBounds.x, session.startBounds.y);
+      try {
+        if (session.raf !== 0) view.cancelAnimationFrame(session.raf);
+        if (session.hasPending && !cancelled) flush();
+        if (cancelled) {
+          if (session.moved && session.restored) {
+            if (session.startStage === "maximized") {
+              wm.restoreTo(id, session.startRestoreBounds ?? session.startBounds);
+              wm.maximize(id);
+            } else if (session.startStage === "snapped" && session.startZone) {
+              wm.restoreTo(id, session.startRestoreBounds ?? session.startBounds);
+              wm.snap(id, session.startZone);
+            } else {
+              wm.move(id, session.startBounds.x, session.startBounds.y);
+            }
           }
+        } else if (session.moved && session.zone) {
+          if (session.zone === "maximize") wm.maximize(id);
+          else wm.snap(id, session.zone);
         }
-        return;
-      }
-      if (session.moved && session.zone) {
-        if (session.zone === "maximize") wm.maximize(id);
-        else wm.snap(id, session.zone);
+      } finally {
+        ctx.releaseDrag(session);
+        releaseRect();
+        handle.removeEventListener("pointermove", onMove);
+        handle.removeEventListener("pointerup", onUp);
+        handle.removeEventListener("pointercancel", onCancel);
+        doc.removeEventListener("keydown", onKeydown, true);
+        if (handle.hasPointerCapture(session.pointerId)) {
+          handle.releasePointerCapture(session.pointerId);
+        }
+        if (el) {
+          delete el.dataset.wmDragging;
+          el.style.willChange = "";
+        }
+        ctx.hidePreview();
+        if (cancelled) wm.abortInteraction();
+        else wm.endInteraction();
       }
     }
     session.finish = finish;
+    wm.beginInteraction();
     ctx.claimDrag(session);
     handle.setPointerCapture(event.pointerId);
     handle.addEventListener("pointermove", onMove);
@@ -956,40 +1383,42 @@ function createResizeStarter(ctx) {
     event.preventDefault();
     event.stopPropagation();
     const handleEl = event.currentTarget;
+    const session = { id, finish: (cancelled) => finish(cancelled) };
+    ctx.claimDrag(session);
+    wm.beginInteraction();
     const releaseRect = ctx.trackRect();
     const startPoint = ctx.toLocal(event);
     const start = win.bounds;
+    const startStage = win.stage;
+    const startZone = win.snapZone;
+    const startRestore = win.restoreBounds;
     const minSize = win.minSize;
     const maxSize = win.maxSize;
+    const aspect = win.aspectRatio;
+    const drive = direction === "n" || direction === "s" ? "height" : "width";
     let raf = 0;
     let pendingX = 0;
     let pendingY = 0;
     let hasPending = false;
     const el = ctx.windowElement(id);
     if (el) el.dataset.wmResizing = direction;
-    function clampWidth(width) {
-      return clamp(width, minSize.width, maxSize ? maxSize.width : Number.POSITIVE_INFINITY);
-    }
-    function clampHeight(height) {
-      return clamp(height, minSize.height, maxSize ? maxSize.height : Number.POSITIVE_INFINITY);
-    }
     function flush() {
       if (!hasPending) return;
       hasPending = false;
       raf = 0;
       const dx = pendingX - startPoint.x;
       const dy = pendingY - startPoint.y;
-      const next = { ...start };
-      if (direction.includes("e")) next.width = clampWidth(start.width + dx);
-      if (direction.includes("s")) next.height = clampHeight(start.height + dy);
-      if (direction.includes("w")) {
-        next.width = clampWidth(start.width - dx);
-        next.x = start.x + (start.width - next.width);
-      }
-      if (direction.includes("n")) {
-        next.height = clampHeight(start.height - dy);
-        next.y = start.y + (start.height - next.height);
-      }
+      const top = direction.includes("n") ? Math.max(0, start.y + dy) : start.y;
+      const raw = {
+        width: direction.includes("e") ? start.width + dx : direction.includes("w") ? start.width - dx : start.width,
+        height: direction.includes("s") ? start.height + dy : direction.includes("n") ? start.y + start.height - top : start.height
+      };
+      const size = aspect === null ? clampSize(raw, minSize, maxSize) : applyAspect(raw, aspect, minSize, maxSize, drive);
+      const next = {
+        x: direction.includes("w") ? start.x + start.width - size.width : start.x,
+        y: direction.includes("n") ? start.y + start.height - size.height : start.y,
+        ...size
+      };
       wm.resize(id, next);
     }
     function onMove(moveEvent) {
@@ -1001,18 +1430,32 @@ function createResizeStarter(ctx) {
       if (raf === 0) raf = view.requestAnimationFrame(flush);
     }
     function finish(cancelled) {
-      if (raf !== 0) view.cancelAnimationFrame(raf);
-      if (hasPending && !cancelled) flush();
-      releaseRect();
-      handleEl.removeEventListener("pointermove", onMove);
-      handleEl.removeEventListener("pointerup", onUp);
-      handleEl.removeEventListener("pointercancel", onCancelPointer);
-      doc.removeEventListener("keydown", onKeydown, true);
-      if (handleEl.hasPointerCapture(event.pointerId)) {
-        handleEl.releasePointerCapture(event.pointerId);
+      if (ctx.currentDrag() !== session) return;
+      try {
+        if (raf !== 0) view.cancelAnimationFrame(raf);
+        if (hasPending && !cancelled) flush();
+        if (cancelled) {
+          if (startStage === "snapped" && startZone) {
+            wm.restoreTo(id, startRestore ?? start);
+            wm.snap(id, startZone);
+          } else {
+            wm.resize(id, start);
+          }
+        }
+      } finally {
+        ctx.releaseDrag(session);
+        releaseRect();
+        handleEl.removeEventListener("pointermove", onMove);
+        handleEl.removeEventListener("pointerup", onUp);
+        handleEl.removeEventListener("pointercancel", onCancelPointer);
+        doc.removeEventListener("keydown", onKeydown, true);
+        if (handleEl.hasPointerCapture(event.pointerId)) {
+          handleEl.releasePointerCapture(event.pointerId);
+        }
+        if (el) delete el.dataset.wmResizing;
+        if (cancelled) wm.abortInteraction();
+        else wm.endInteraction();
       }
-      if (el) delete el.dataset.wmResizing;
-      if (cancelled) wm.resize(id, start);
     }
     function onUp(upEvent) {
       if (upEvent.pointerId !== event.pointerId) return;
@@ -1057,6 +1500,11 @@ function createResizeHandles(doc, edge, corner) {
 }
 
 // src/dom/controller.ts
+var SNAP_SHORTCUTS = {
+  ArrowLeft: "left",
+  ArrowRight: "right"
+};
+var FOCUSABLE_SELECTOR = 'button:not([disabled]), [href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
 function attachDesktop(wm, element, options = {}) {
   const doc = element.ownerDocument;
   const view = windowOf(element);
@@ -1069,9 +1517,13 @@ function attachDesktop(wm, element, options = {}) {
   const keyboardOptions = typeof options.keyboard === "object" ? options.keyboard : {};
   const moveStep = keyboardOptions.moveStep ?? 16;
   const cycleEnabled = keyboardOptions.cycle !== false;
+  const snapShortcuts = keyboardOptions.snapShortcuts !== false;
+  const historyShortcuts = keyboardOptions.historyShortcuts !== false;
   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);
   element.dataset.wmDesktop = "";
+  element.tabIndex = -1;
   if (view.getComputedStyle(element).position === "static") {
     element.style.position = "relative";
   }
@@ -1108,6 +1560,10 @@ function attachDesktop(wm, element, options = {}) {
   function hidePreview() {
     if (preview) preview.style.display = "none";
   }
+  function refreshRect() {
+    const rect = element.getBoundingClientRect();
+    cachedRect = { left: rect.left, top: rect.top };
+  }
   const ctx = {
     wm,
     doc,
@@ -1118,8 +1574,9 @@ function attachDesktop(wm, element, options = {}) {
     },
     trackRect() {
       if (rectUsers === 0) {
-        const rect = element.getBoundingClientRect();
-        cachedRect = { left: rect.left, top: rect.top };
+        refreshRect();
+        view.addEventListener("scroll", refreshRect, true);
+        view.addEventListener("resize", refreshRect);
       }
       rectUsers += 1;
       let released = false;
@@ -1127,7 +1584,11 @@ function attachDesktop(wm, element, options = {}) {
         if (released) return;
         released = true;
         rectUsers -= 1;
-        if (rectUsers === 0) cachedRect = null;
+        if (rectUsers === 0) {
+          view.removeEventListener("scroll", refreshRect, true);
+          view.removeEventListener("resize", refreshRect);
+          cachedRect = null;
+        }
       };
     },
     windowElement: (id) => registry.get(id)?.element,
@@ -1141,6 +1602,7 @@ function attachDesktop(wm, element, options = {}) {
     topEdge,
     hitEdge,
     hitCorner,
+    magnetThreshold,
     currentDrag: () => drag,
     claimDrag(session) {
       drag = session;
@@ -1154,28 +1616,34 @@ function attachDesktop(wm, element, options = {}) {
   if (options.autoViewport !== false) {
     const applyViewport = () => wm.setViewport({ width: element.clientWidth, height: element.clientHeight });
     applyViewport();
-    const observer = new ResizeObserver(applyViewport);
+    const observer = new view.ResizeObserver(applyViewport);
     observer.observe(element);
     cleanup.push(() => observer.disconnect());
   }
-  function syncWindow(attached, win, zIndex) {
+  function syncWindow(attached, win, zIndex, activeWorkspace) {
     const el = attached.element;
     const firstSync = attached.lastState === null;
     if (firstSync) el.style.transition = "none";
-    if (attached.lastState !== win) {
+    if (attached.lastState !== win || attached.lastWorkspace !== activeWorkspace) {
       el.style.transform = `translate3d(${win.bounds.x}px, ${win.bounds.y}px, 0)`;
       el.style.width = `${win.bounds.width}px`;
       el.style.height = `${win.bounds.height}px`;
       el.dataset.wmStage = win.stage;
       el.dataset.wmLayer = win.layer;
-      el.hidden = win.stage === "minimized";
+      el.dataset.wmWorkspace = String(win.workspace);
+      const hide = win.stage === "minimized" || win.workspace !== activeWorkspace;
+      if (hide && !el.hidden && el.contains(doc.activeElement)) {
+        element.focus({ preventScroll: true });
+      }
+      el.hidden = hide;
       el.setAttribute("aria-label", win.title);
       if (win.layer === "modal") el.setAttribute("aria-modal", "true");
       else el.removeAttribute("aria-modal");
       for (const handle of attached.handles) {
-        handle.style.display = win.resizable && win.stage === "normal" ? "" : "none";
+        handle.style.display = win.resizable && (win.stage === "normal" || win.stage === "snapped") ? "" : "none";
       }
       attached.lastState = win;
+      attached.lastWorkspace = activeWorkspace;
     }
     if (attached.lastZ !== zIndex) {
       el.style.zIndex = String(zIndex + 1);
@@ -1193,7 +1661,9 @@ function attachDesktop(wm, element, options = {}) {
       const attached = registry.get(id);
       const win = state.windows[id];
       if (!attached || !win) return;
-      if (orderChanged || attached.lastState !== win) syncWindow(attached, win, index);
+      if (orderChanged || attached.lastState !== win || attached.lastWorkspace !== state.workspace) {
+        syncWindow(attached, win, index, state.workspace);
+      }
     });
     if (state.focusedId !== lastFocused) {
       if (lastFocused) {
@@ -1229,17 +1699,51 @@ function attachDesktop(wm, element, options = {}) {
   );
   cleanup.push(
     wm.on("stage", ({ window: win, previous }) => {
-      if (win.stage !== "minimized" || previous === "minimized") return;
       const attached = registry.get(win.id);
-      const target = options.minimizeTarget?.(win);
-      if (attached && target) flipToTarget(attached.element, target);
+      if (!attached) return;
+      if (win.stage === "minimized" && previous !== "minimized") {
+        const target = options.minimizeTarget?.(win);
+        if (target) flipToTarget(attached.element, target);
+      } else if (previous === "minimized" && win.stage !== "minimized") {
+        const target = options.minimizeTarget?.(win);
+        if (target) view.requestAnimationFrame(() => flipFromTarget(attached.element, target));
+      }
     })
   );
-  if (keyboardEnabled && cycleEnabled) {
+  if (keyboardEnabled) {
     const onDesktopKeydown = (event) => {
-      if (event.key === "F6") {
+      if (cycleEnabled && event.key === "F6") {
         event.preventDefault();
         wm.cycleFocus(event.shiftKey ? -1 : 1);
+        return;
+      }
+      if (!event.ctrlKey && !event.metaKey) return;
+      const target = event.target;
+      if (target?.closest(INTERACTIVE_SELECTOR)) return;
+      if (historyShortcuts && (event.key === "z" || event.key === "Z")) {
+        event.preventDefault();
+        if (event.shiftKey) wm.redo();
+        else wm.undo();
+        return;
+      }
+      if (!snapShortcuts || !event.altKey) return;
+      const focused = wm.getState().focusedId;
+      const win = focused ? wm.get(focused) : void 0;
+      if (!win) return;
+      const zone = SNAP_SHORTCUTS[event.key];
+      if (zone) {
+        event.preventDefault();
+        if (win.snappable) wm.snap(win.id, zone);
+      } else if (event.key === "ArrowUp") {
+        event.preventDefault();
+        if (win.maximizable) wm.maximize(win.id);
+      } else if (event.key === "ArrowDown") {
+        event.preventDefault();
+        if (win.stage === "normal") {
+          if (win.minimizable) wm.minimize(win.id);
+        } else {
+          wm.restore(win.id);
+        }
       }
     };
     element.addEventListener("keydown", onDesktopKeydown);
@@ -1258,6 +1762,7 @@ function attachDesktop(wm, element, options = {}) {
       handles: [],
       lastState: null,
       lastZ: -1,
+      lastWorkspace: -1,
       cleanup: []
     };
     windowElement.dataset.wmWindow = id;
@@ -1308,6 +1813,16 @@ function attachDesktop(wm, element, options = {}) {
       };
       handle.addEventListener("dblclick", onDoubleClick);
       attached.cleanup.push(() => handle.removeEventListener("dblclick", onDoubleClick));
+      if (options.onTitlebarContextMenu) {
+        const onContextMenu = (event) => {
+          const current = wm.get(id);
+          if (!current) return;
+          event.preventDefault();
+          options.onTitlebarContextMenu?.(current, event);
+        };
+        handle.addEventListener("contextmenu", onContextMenu);
+        attached.cleanup.push(() => handle.removeEventListener("contextmenu", onContextMenu));
+      }
     }
     if (windowOptions.resizeHandles !== false) {
       for (const { element: resizeHandle, direction } of createResizeHandles(
@@ -1333,19 +1848,20 @@ function attachDesktop(wm, element, options = {}) {
         ArrowUp: [0, -1],
         ArrowDown: [0, 1]
       };
+      if (event.ctrlKey || event.metaKey) return;
       const vector = arrows[event.key];
       if (!vector || !keyboardEnabled) return;
-      event.preventDefault();
       const step = event.altKey ? 1 : moveStep;
       const [dx, dy] = vector;
       if (event.shiftKey) {
-        if (current.resizable) {
-          wm.resize(id, {
-            width: current.bounds.width + dx * step,
-            height: current.bounds.height + dy * step
-          });
-        }
+        if (!current.resizable) return;
+        event.preventDefault();
+        wm.resize(id, {
+          width: current.bounds.width + dx * step,
+          height: current.bounds.height + dy * step
+        });
       } else if (current.draggable && current.stage === "normal") {
+        event.preventDefault();
         wm.moveBy(id, dx * step, dy * step);
       }
     };
@@ -1355,13 +1871,18 @@ function attachDesktop(wm, element, options = {}) {
       if (event.key !== "Tab") return;
       const current = wm.get(id);
       if (current?.layer !== "modal") return;
-      const focusables = windowElement.querySelectorAll(
-        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
-      );
+      const focusables = [
+        ...windowElement.querySelectorAll(FOCUSABLE_SELECTOR)
+      ].filter((node) => node.offsetParent !== null || node === doc.activeElement);
       if (focusables.length === 0) return;
       const first = focusables[0];
       const last = focusables[focusables.length - 1];
       if (!first || !last) return;
+      if (!windowElement.contains(doc.activeElement)) {
+        event.preventDefault();
+        (event.shiftKey ? last : first).focus();
+        return;
+      }
       if (event.shiftKey && doc.activeElement === first) {
         event.preventDefault();
         last.focus();
@@ -1390,6 +1911,9 @@ function attachDesktop(wm, element, options = {}) {
     lastOrder = null;
     lastFocused = null;
     syncAll();
+    if (wm.getState().focusedId === id && !windowElement.contains(doc.activeElement)) {
+      windowElement.focus({ preventScroll: true });
+    }
     return detach;
   }
   return {
@@ -1413,29 +1937,33 @@ function attachDesktop(wm, element, options = {}) {
 // src/dom/binder.ts
 function createDesktopBinder(wm, options = {}) {
   let controller = null;
+  let stopOpen = null;
   const entries = /* @__PURE__ */ new Set();
   function attachEntry(entry) {
     if (controller && !entry.detach && wm.get(entry.id)) {
       entry.detach = controller.attachWindow(entry.id, entry.element, entry.options);
     }
   }
-  wm.on("open", ({ window: win }) => {
-    for (const entry of entries) {
-      if (entry.id === win.id) attachEntry(entry);
-    }
-  });
+  function unbindDesktop() {
+    stopOpen?.();
+    stopOpen = null;
+    for (const entry of entries) entry.detach = null;
+    controller?.destroy();
+    controller = null;
+  }
   return {
     wm,
     controller: () => controller,
     bindDesktop(element) {
       if (controller) throw new Error("wmkit: desktop is already bound");
       controller = attachDesktop(wm, element, options);
+      stopOpen = wm.on("open", ({ window: win }) => {
+        for (const entry of entries) {
+          if (entry.id === win.id) attachEntry(entry);
+        }
+      });
       for (const entry of entries) attachEntry(entry);
-      return () => {
-        for (const entry of entries) entry.detach = null;
-        controller?.destroy();
-        controller = null;
-      };
+      return unbindDesktop;
     },
     bindWindow(id, element, windowOptions) {
       const entry = { id, element, options: windowOptions, detach: null };
@@ -1446,10 +1974,14 @@ function createDesktopBinder(wm, options = {}) {
         entry.detach = null;
         entries.delete(entry);
       };
+    },
+    destroy() {
+      unbindDesktop();
+      entries.clear();
     }
   };
 }
 
-export { attachDesktop, boundsEqual, clamp, clampSize, clampToViewport, createAnnouncer, createDesktopBinder, createEmitter, createWindowManager, defaultMessages, detectSnapZone, flipToTarget, prefersReducedMotion, zoneBounds };
-//# sourceMappingURL=chunk-2TVOEDRG.js.map
-//# sourceMappingURL=chunk-2TVOEDRG.js.map
+export { applyAspect, attachDesktop, boundsEqual, clamp, clampSize, clampToViewport, createAnnouncer, createDesktopBinder, createEmitter, createWindowManager, defaultMessages, detectSnapZone, flipFromTarget, flipToTarget, magnetize, prefersReducedMotion, zoneBounds };
+//# sourceMappingURL=chunk-FPZDAKNP.js.map
+//# sourceMappingURL=chunk-FPZDAKNP.js.map