@surdeddd/wmkit 0.3.0 → 0.4.1

package/dist/{chunk-B35DANTX.cjs → chunk-TJ6QOOJ2.cjs}

@@ -40,19 +40,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":
@@ -148,8 +177,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;
@@ -163,12 +198,14 @@ function createWindowManager(options = {}) {
   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 = [];
@@ -179,13 +216,18 @@ function createWindowManager(options = {}) {
   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) {
@@ -223,10 +265,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;
   }
@@ -234,7 +280,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;
     });
@@ -246,8 +292,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 };
@@ -269,11 +316,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);
@@ -288,8 +336,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,
@@ -307,7 +357,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") {
@@ -345,11 +395,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") {
@@ -384,6 +435,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;
@@ -410,7 +469,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",
@@ -431,22 +490,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",
@@ -456,7 +516,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) {
@@ -472,19 +532,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);
@@ -511,7 +571,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";
@@ -532,6 +593,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,
@@ -562,16 +624,75 @@ function createWindowManager(options = {}) {
     if (next.width === viewport.width && next.height === viewport.height) return;
     viewport = { ...next };
     reflowViewport();
-    snapshot = null;
-    batchDirty = true;
+    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 };
+    return { windows, order, focusedId, workspace };
   }
   function recordHistory() {
+    if (!historyDirty) return;
     if (skipNextHistory) {
       skipNextHistory = false;
       return;
@@ -596,6 +717,7 @@ function createWindowManager(options = {}) {
         if (batchDirty) {
           batchDirty = false;
           recordHistory();
+          historyDirty = false;
           snapshot = null;
           flushEvents();
           emitter.emit("change", { state: getState() });
@@ -612,7 +734,7 @@ function createWindowManager(options = {}) {
         setWindow(updated);
         queueEvent(() => emitter.emit("resize", { window: updated }));
       } else if (win.stage === "snapped" && win.snapZone) {
-        const updated = { ...win, bounds: zoneBounds(win.snapZone, viewport) };
+        const updated = { ...win, bounds: snapBounds(win, win.snapZone) };
         setWindow(updated);
         queueEvent(() => emitter.emit("resize", { window: updated }));
       } else if (win.stage === "normal" && keepInViewport) {
@@ -629,6 +751,11 @@ function createWindowManager(options = {}) {
     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();
   }
@@ -655,6 +782,13 @@ function createWindowManager(options = {}) {
   function endInteraction() {
     if (interactionDepth > 0) interactionDepth -= 1;
   }
+  function abortInteraction() {
+    if (interactionDepth > 0 && interactionRecorded) {
+      past.pop();
+      interactionRecorded = false;
+    }
+    endInteraction();
+  }
   function clearHistory() {
     past.length = 0;
     future = [];
@@ -685,7 +819,10 @@ function createWindowManager(options = {}) {
     return [...layouts.keys()];
   }
   function arrange(mode) {
-    const ids = order.filter((id) => windows[id].stage !== "minimized");
+    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) => {
@@ -700,6 +837,7 @@ function createWindowManager(options = {}) {
       });
       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);
@@ -714,7 +852,9 @@ function createWindowManager(options = {}) {
     });
   }
   function minimizeAll() {
-    for (const id of [...order]) minimize(id);
+    for (const id of [...order]) {
+      if (onActiveWorkspace(windows[id])) minimize(id);
+    }
   }
   function restoreAll() {
     for (const win of minimized()) restore(win.id);
@@ -734,7 +874,8 @@ function createWindowManager(options = {}) {
         meta: { ...win.meta }
       })),
       order: [...order],
-      focusedId
+      focusedId,
+      workspace
     };
   }
   function isBounds(value) {
@@ -788,8 +929,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,
@@ -818,8 +961,16 @@ 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) {
@@ -838,6 +989,7 @@ function createWindowManager(options = {}) {
         queueEvent(() => emitter.emit("open", { window: opened }));
       }
     }
+    if (viewport.width > 0 && viewport.height > 0) reflowViewport();
     queueEvent(() => emitter.emit("order", { order }));
     clearHistory();
     skipNextHistory = true;
@@ -862,12 +1014,17 @@ 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)),
@@ -877,6 +1034,8 @@ function createWindowManager(options = {}) {
     canRedo: () => future.length > 0,
     beginInteraction,
     endInteraction,
+    abortInteraction,
+    clearHistory,
     saveLayout,
     loadLayout: (name) => transact(() => loadLayout(name)),
     getLayout,
@@ -961,7 +1120,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 };
@@ -972,7 +1132,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(() => {
@@ -988,6 +1151,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 {
@@ -1076,7 +1252,9 @@ function createDragStarter(ctx) {
         for (const otherId of state.order) {
           if (otherId === id) continue;
           const other = state.windows[otherId];
-          if (other && other.stage !== "minimized") targets.push(other.bounds);
+          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 },
@@ -1110,7 +1288,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 = "";
@@ -1138,42 +1316,43 @@ 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);
         }
-        wm.endInteraction();
-        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();
       }
-      wm.endInteraction();
     }
     session.finish = finish;
     wm.beginInteraction();
@@ -1206,41 +1385,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) {
@@ -1252,19 +1432,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);
-      wm.endInteraction();
     }
     function onUp(upEvent) {
       if (upEvent.pointerId !== event.pointerId) return;
@@ -1309,6 +1502,12 @@ function createResizeHandles(doc, edge, corner) {
 }
 
 // src/dom/controller.ts
+var SNAP_SHORTCUTS = {
+  ArrowLeft: "left",
+  ArrowRight: "right"
+};
+var LANDMARK_TAGS = /* @__PURE__ */ new Set(["header", "footer", "aside", "nav"]);
+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);
@@ -1321,10 +1520,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";
   }
@@ -1361,6 +1563,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,
@@ -1371,8 +1577,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;
@@ -1380,7 +1587,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,
@@ -1408,28 +1619,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);
@@ -1447,7 +1664,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) {
@@ -1490,15 +1709,44 @@ function attachDesktop(wm, element, options = {}) {
         if (target) flipToTarget(attached.element, target);
       } else if (previous === "minimized" && win.stage !== "minimized") {
         const target = options.minimizeTarget?.(win);
-        if (target) flipFromTarget(attached.element, target);
+        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);
@@ -1517,6 +1765,7 @@ function attachDesktop(wm, element, options = {}) {
       handles: [],
       lastState: null,
       lastZ: -1,
+      lastWorkspace: -1,
       cleanup: []
     };
     windowElement.dataset.wmWindow = id;
@@ -1532,6 +1781,9 @@ function attachDesktop(wm, element, options = {}) {
     }
     const handle = typeof windowOptions.handle === "string" ? windowElement.querySelector(windowOptions.handle) : windowOptions.handle ?? windowElement.querySelector("[data-wm-drag]");
     attached.handle = handle;
+    if (handle && !handle.hasAttribute("role") && LANDMARK_TAGS.has(handle.localName)) {
+      handle.setAttribute("role", "presentation");
+    }
     const onPointerDownFocus = () => {
       wm.focus(id);
     };
@@ -1602,19 +1854,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);
       }
     };
@@ -1624,13 +1877,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();
@@ -1659,6 +1917,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 {
@@ -1682,29 +1943,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 };
@@ -1715,10 +1980,15 @@ function createDesktopBinder(wm, options = {}) {
         entry.detach = null;
         entries.delete(entry);
       };
+    },
+    destroy() {
+      unbindDesktop();
+      entries.clear();
     }
   };
 }
 
+exports.applyAspect = applyAspect;
 exports.attachDesktop = attachDesktop;
 exports.boundsEqual = boundsEqual;
 exports.clamp = clamp;
@@ -1730,9 +2000,10 @@ exports.createEmitter = createEmitter;
 exports.createWindowManager = createWindowManager;
 exports.defaultMessages = defaultMessages;
 exports.detectSnapZone = detectSnapZone;
+exports.flipFromTarget = flipFromTarget;
 exports.flipToTarget = flipToTarget;
 exports.magnetize = magnetize;
 exports.prefersReducedMotion = prefersReducedMotion;
 exports.zoneBounds = zoneBounds;
-//# sourceMappingURL=chunk-B35DANTX.cjs.map
-//# sourceMappingURL=chunk-B35DANTX.cjs.map
+//# sourceMappingURL=chunk-TJ6QOOJ2.cjs.map
+//# sourceMappingURL=chunk-TJ6QOOJ2.cjs.map