@gustavolmo/react-window-manager 0.4.1 → 0.4.3

package/dist/index.js

@@ -7,7 +7,7 @@ var useWorkspaceState = create((set, get) => ({
   wsElement: null,
   setWsElement: (el) => set({ wsElement: el }),
   isGridEnabled: true,
-  isDockPannelEnabled: true,
+  isDockPanelEnabled: true,
   responsiveBreak: "sm",
   isBelowBreakPoint: false,
   activeWindowId: "react-dynamic-window-instance0",
@@ -169,23 +169,21 @@ var dockCommandResolver = {
     ];
   }
 };
-var getDockDependencies = () => {
-  const { wsRect } = useWorkspaceState.getState();
-  return { wsRect };
-};
 
 // src/window-manager/internal/features/cursor/cursor-state.ts
-import { create as create2 } from "zustand";
-var useCursorState = create2((set) => ({
+var cursorPosition = {
   x: 10,
-  y: 10,
-  setXY: (x, y) => set({ x, y })
-}));
+  y: 10
+};
+var setCursorPosition = ({ x, y }) => {
+  cursorPosition.x = x;
+  cursorPosition.y = y;
+};
 
 // src/window-manager/internal/runtime/drag-resolver/drag-loop.ts
 var rafDragLoopResolver = {
   LOOP_DRAG: (targetWinId, commit) => {
-    const { x, y } = useCursorState.getState();
+    const { x, y } = cursorPosition;
     const { winCoord, isDragging, windowId } = windowRegistry[targetWinId].getState();
     if (!isDragging)
       throw new Error(`LOOP_DRAG called with isDragging false for winId: ${windowId}`);
@@ -199,7 +197,7 @@ var rafDragLoopResolver = {
 var dragLoop = (targetWinId, pointerOffset, commit) => {
   const { winCoord, isDragging } = windowRegistry[targetWinId].getState();
   const { wsRect } = useWorkspaceState.getState();
-  const { x, y } = useCursorState.getState();
+  const { x, y } = cursorPosition;
   if (!isDragging)
     return;
   let adjustedX = Math.round(x - pointerOffset.left);
@@ -249,9 +247,6 @@ var dragCommandResolver = {
     ];
   }
 };
-var isDragAllowed = () => {
-  return !useWorkspaceState.getState().isBelowBreakPoint;
-};
 
 // src/window-manager/internal/runtime/focus-resolver/focus-commands.ts
 var focusCommandResolver = {
@@ -328,30 +323,12 @@ var focusCommandResolver = {
   }
 };
 
-// src/window-manager/internal/runtime/stack-resolver/stack-commands.ts
-var stackCommandResolver = {
-  RESET_STACK: () => {
-    const batchUpdate = [];
-    for (const key of Object.keys(windowRegistry)) {
-      const { resetFlag } = windowRegistry[key].getState();
-      batchUpdate.push({
-        winId: key,
-        patch: {
-          resetFlag: !resetFlag,
-          // FIND ME: reset flag is anti-pattern
-          isWindowClosed: true,
-          isActive: false
-        }
-      });
-    }
-    return batchUpdate;
-  }
-};
-
 // src/window-manager/internal/runtime/workspace-resolver/workspace-commands.ts
 var workspaceCommandResolver = {
-  UPDATE_WORKSPACE_RECT: () => {
+  UPDATE_WORKSPACE_SIZE: () => {
+    const prevRect = useWorkspaceState.getState().wsRect;
     const rect = useWorkspaceState.getState().wsElement?.getBoundingClientRect();
+    const breakPoint = useWorkspaceState.getState().responsiveBreak;
     const top = rect?.top ?? 0;
     const left = rect?.left ?? 0;
     const innerHeight = rect?.height ?? 0;
@@ -360,10 +337,8 @@ var workspaceCommandResolver = {
     const right = left + innerWidth;
     const centerX = left + innerWidth / 2;
     const centerY = top + innerHeight / 2;
-    const breakPoint = useWorkspaceState.getState().responsiveBreak;
-    const isBelowBreakPoint = innerWidth < responsiveBreakInPx(breakPoint);
-    return {
-      isBelowBreakPoint,
+    const workspaceUpdate = {
+      isBelowBreakPoint: innerWidth < responsiveBreakInPx(breakPoint),
       wsRect: {
         top,
         left,
@@ -375,20 +350,50 @@ var workspaceCommandResolver = {
         centerY
       }
     };
+    const windowBatchUpdate = [];
+    const { innerHeight: prevWsHeight, innerWidth: prevWsWidth } = prevRect;
+    const currWsHeight = innerHeight;
+    const currWsWidth = innerWidth;
+    const widthChangeRatio = currWsWidth / prevWsWidth;
+    const heightChangeRatio = currWsHeight / prevWsHeight;
+    for (const key of Object.keys(windowRegistry)) {
+      const win = windowRegistry[key].getState();
+      windowBatchUpdate.push({
+        winId: key,
+        patch: {
+          winWidth: win.winWidth * widthChangeRatio,
+          winHeight: win.winHeight * heightChangeRatio,
+          winCoord: {
+            pointX: win.winCoord.pointX * widthChangeRatio,
+            pointY: win.winCoord.pointY * heightChangeRatio
+          }
+        }
+      });
+    }
+    return {
+      win: windowBatchUpdate,
+      ws: workspaceUpdate
+    };
   },
   SET_WORKSPACE_FEATURES: (_, ctx) => {
-    if (ctx?.isGridEnabled === void 0 || ctx?.isDockPannelEnabled === void 0)
+    if (ctx?.isGridEnabled === void 0 || ctx?.isDockPanelEnabled === void 0)
       throw new Error(`SET_WORKSPACE_FEATURES called without a ctx value`);
     return {
-      isGridEnabled: ctx.isGridEnabled,
-      isDockPannelEnabled: ctx.isDockPannelEnabled
+      win: [],
+      ws: {
+        isGridEnabled: ctx.isGridEnabled,
+        isDockPanelEnabled: ctx.isDockPanelEnabled
+      }
     };
   },
   SET_RESPONSIVE_BREAK: (_, ctx) => {
     if (ctx?.responsiveBreak === void 0 || ctx?.responsiveBreak === null)
       throw new Error(`SET_RESPONSIVE_BREAK called without a ctx value`);
     return {
-      responsiveBreak: ctx.responsiveBreak
+      win: [],
+      ws: {
+        responsiveBreak: ctx.responsiveBreak
+      }
     };
   }
 };
@@ -416,7 +421,7 @@ var resizeCommandResolver = {
   ENABLE_RESIZE: (targetWinId, direction) => {
     const currentResizeAction = windowRegistry[targetWinId].getState().resizeAction;
     if (currentResizeAction)
-      throw new Error(`ENABLE_RESIZE called on a window that is already risizing`);
+      throw new Error(`ENABLE_RESIZE called on a window that is already resizing`);
     return [
       {
         winId: targetWinId,
@@ -440,6 +445,108 @@ var resizeCommandResolver = {
   }
 };
 
+// src/window-manager/internal/runtime/resize-resolver/resize-loop-rules.ts
+var resolveNeighbourResizeLimit = (activeWinId, direction) => {
+  switch (direction) {
+    case "e":
+      return neighbourResizeLimit.e(activeWinId);
+    case "w":
+      return neighbourResizeLimit.w(activeWinId);
+    case "n":
+      return neighbourResizeLimit.n(activeWinId);
+    case "s":
+      return neighbourResizeLimit.s(activeWinId);
+    default:
+      return void 0;
+  }
+};
+var neighbourResizeLimit = {
+  e: (activeWinId) => {
+    let leftMostXAtMinWidth = void 0;
+    for (const key of Object.keys(windowRegistry)) {
+      const neighbourWin = windowRegistry[key].getState();
+      if (key === activeWinId)
+        continue;
+      if (neighbourWin.resizeAction !== "w")
+        continue;
+      if (neighbourWin.isWindowClosed)
+        continue;
+      const winBox = neighbourWin.winElement?.getBoundingClientRect();
+      if (!winBox)
+        continue;
+      const xAtMinWidth = winBox.right - neighbourWin.WIN_MIN_WIDTH;
+      if (leftMostXAtMinWidth === void 0)
+        leftMostXAtMinWidth = xAtMinWidth;
+      if (leftMostXAtMinWidth > xAtMinWidth)
+        leftMostXAtMinWidth = xAtMinWidth;
+    }
+    return leftMostXAtMinWidth;
+  },
+  w: (activeWinId) => {
+    let rightMostXAtMinWidth = void 0;
+    for (const key of Object.keys(windowRegistry)) {
+      const neighbourWin = windowRegistry[key].getState();
+      if (key === activeWinId)
+        continue;
+      if (neighbourWin.resizeAction !== "e")
+        continue;
+      if (neighbourWin.isWindowClosed)
+        continue;
+      const winBox = neighbourWin.winElement?.getBoundingClientRect();
+      if (!winBox)
+        continue;
+      const xAtMinWidth = winBox.left + neighbourWin.WIN_MIN_WIDTH;
+      if (rightMostXAtMinWidth === void 0)
+        rightMostXAtMinWidth = xAtMinWidth;
+      if (rightMostXAtMinWidth < xAtMinWidth)
+        rightMostXAtMinWidth = xAtMinWidth;
+    }
+    return rightMostXAtMinWidth;
+  },
+  n: (currentWinId) => {
+    let bottomMostYAtMinWidth = void 0;
+    for (const key of Object.keys(windowRegistry)) {
+      const remoteWin = windowRegistry[key].getState();
+      if (key === currentWinId)
+        continue;
+      if (remoteWin.resizeAction !== "s")
+        continue;
+      if (remoteWin.isWindowClosed)
+        continue;
+      const winBox = remoteWin.winElement?.getBoundingClientRect();
+      if (!winBox)
+        continue;
+      const yAtMinWidth = winBox.top + remoteWin.WIN_MIN_HEIGHT;
+      if (bottomMostYAtMinWidth === void 0)
+        bottomMostYAtMinWidth = yAtMinWidth;
+      if (bottomMostYAtMinWidth < yAtMinWidth)
+        bottomMostYAtMinWidth = yAtMinWidth;
+    }
+    return bottomMostYAtMinWidth;
+  },
+  s: (currentWinId) => {
+    let topMostYAtMinWidth = void 0;
+    for (const key of Object.keys(windowRegistry)) {
+      const remoteWin = windowRegistry[key].getState();
+      if (key === currentWinId)
+        continue;
+      if (remoteWin.resizeAction !== "n")
+        continue;
+      if (remoteWin.isWindowClosed)
+        continue;
+      const winBox = remoteWin.winElement?.getBoundingClientRect();
+      if (!winBox)
+        continue;
+      const yAtMinWidth = winBox.bottom - remoteWin.WIN_MIN_HEIGHT;
+      if (topMostYAtMinWidth === void 0)
+        topMostYAtMinWidth = yAtMinWidth;
+      if (topMostYAtMinWidth > yAtMinWidth)
+        topMostYAtMinWidth = yAtMinWidth;
+    }
+    return topMostYAtMinWidth;
+  }
+};
+
 // src/window-manager/internal/runtime/resize-resolver/resize-loop.ts
 var rafResizeLoopResolver = {
   LOOP_RESIZE: (targetWinId, commitCb) => {
@@ -450,95 +557,198 @@ var rafResizeLoopResolver = {
     const winElementBox = dep.winBox;
     if (!winElementBox)
       throw new Error(`LOOP_RESIZE called with null window element for winId: ${targetWinId}`);
-    requestAnimationFrame(
-      () => resizer[resizeDirection](getRafResizeDependencies(targetWinId), commitCb)
-    );
+    requestAnimationFrame(() => {
+      const neighbourLimit = resolveNeighbourResizeLimit(dep.win.windowId, resizeDirection);
+      resizer[resizeDirection](getRafResizeDependencies(targetWinId), commitCb, neighbourLimit);
+    });
   }
 };
 var resizer = {
-  e: (resizeDep, commit) => {
+  e: (resizeDep, commit, neighbourLimit) => {
     const { wsRect, win, winBox, x } = resizeDep;
     if (!win.resizeAction)
       return;
     if (!winBox)
       return;
     const cursorOutOfBounds = x > wsRect.right || x < wsRect.left;
-    const minWinWidth = x - winBox.left < win.WIN_MIN_WIDTH;
     const sizeDiff = x - winBox.right;
-    if (!minWinWidth && !cursorOutOfBounds && sizeDiff !== 0) {
+    const isResizeActive = !cursorOutOfBounds && sizeDiff !== 0;
+    const minWinWidth = x - winBox.left < win.WIN_MIN_WIDTH;
+    const leftMostXAtMinWidth = neighbourLimit;
+    const isNeighbourLimit = leftMostXAtMinWidth && x > leftMostXAtMinWidth;
+    if (isNeighbourLimit && isResizeActive) {
+      commit([
+        {
+          winId: win.windowId,
+          patch: { winWidth: leftMostXAtMinWidth - win.winCoord.pointX }
+        }
+      ]);
+    } else if (!minWinWidth && isResizeActive) {
+      commit([
+        {
+          winId: win.windowId,
+          patch: { winWidth: win.winWidth + sizeDiff }
+        }
+      ]);
+    } else if (minWinWidth && isResizeActive) {
       commit([
         {
           winId: win.windowId,
-          patch: { winWidth: Math.round(win.winWidth + sizeDiff) }
+          patch: { winWidth: win.WIN_MIN_WIDTH }
         }
       ]);
     }
-    requestAnimationFrame(() => resizer.e(getRafResizeDependencies(win.windowId), commit));
+    requestAnimationFrame(
+      () => resizer.e(getRafResizeDependencies(win.windowId), commit, neighbourLimit)
+    );
   },
-  w: (resizeDep, commit) => {
+  w: (resizeDep, commit, neighbourLimit) => {
     const { wsRect, win, winBox, x } = resizeDep;
     if (!win.resizeAction)
       return;
     if (!winBox)
       return;
-    const minWinWidth = winBox.right - x <= win.WIN_MIN_WIDTH;
     const cursorOutOfBounds = x > wsRect.right || x < wsRect.left;
     const sizeDiff = winBox.left - x;
-    if (!minWinWidth && !cursorOutOfBounds && sizeDiff !== 0) {
+    const isResizeActive = !cursorOutOfBounds && sizeDiff !== 0;
+    const minWinWidth = winBox.right - x <= win.WIN_MIN_WIDTH;
+    const rightMostXAtMinWidth = neighbourLimit;
+    const isNeighbourLimit = rightMostXAtMinWidth && x < rightMostXAtMinWidth;
+    if (isNeighbourLimit) {
       commit([
         {
           winId: win.windowId,
           patch: {
-            winWidth: Math.round(win.winWidth + sizeDiff),
+            winWidth: win.winCoord.pointX - rightMostXAtMinWidth + win.winWidth,
+            winCoord: {
+              pointX: rightMostXAtMinWidth,
+              pointY: win.winCoord.pointY
+            }
+          }
+        }
+      ]);
+    } else if (!minWinWidth && isResizeActive) {
+      commit([
+        {
+          winId: win.windowId,
+          patch: {
+            winWidth: win.winWidth + sizeDiff,
             winCoord: { pointX: x, pointY: win.winCoord.pointY }
           }
         }
       ]);
+    } else if (minWinWidth && isResizeActive) {
+      commit([
+        {
+          winId: win.windowId,
+          patch: {
+            winCoord: {
+              pointX: win.winCoord.pointX + win.winWidth - win.WIN_MIN_WIDTH,
+              pointY: win.winCoord.pointY
+            },
+            winWidth: win.WIN_MIN_WIDTH
+          }
+        }
+      ]);
     }
-    requestAnimationFrame(() => resizer.w(getRafResizeDependencies(win.windowId), commit));
+    requestAnimationFrame(
+      () => resizer.w(getRafResizeDependencies(win.windowId), commit, neighbourLimit)
+    );
   },
-  n: (resizeDep, commit) => {
+  n: (resizeDep, commit, neighbourLimit) => {
     const { wsRect, win, winBox, y } = resizeDep;
     if (!win.resizeAction)
       return;
     if (!winBox)
       return;
-    const minWinHeight = winBox.bottom - y <= win.WIN_MIN_HEIGHT;
     const cursorOutOfBounds = y > wsRect.bottom || y < wsRect.top;
     const sizeDiff = winBox.top - y;
-    if (!minWinHeight && !cursorOutOfBounds && sizeDiff !== 0) {
+    const isResizeActive = !cursorOutOfBounds && sizeDiff !== 0;
+    const minWinHeight = winBox.bottom - y <= win.WIN_MIN_HEIGHT;
+    const bottomMostYAtMinWidth = neighbourLimit;
+    const isNeighbourLimit = bottomMostYAtMinWidth && y < bottomMostYAtMinWidth;
+    if (isNeighbourLimit && isResizeActive) {
       commit([
         {
           winId: win.windowId,
           patch: {
-            winHeight: Math.round(win.winHeight + sizeDiff),
+            winHeight: win.winCoord.pointY - bottomMostYAtMinWidth + win.winHeight,
+            winCoord: {
+              pointX: win.winCoord.pointX,
+              pointY: bottomMostYAtMinWidth
+            }
+          }
+        }
+      ]);
+    } else if (!minWinHeight && isResizeActive) {
+      commit([
+        {
+          winId: win.windowId,
+          patch: {
+            winHeight: win.winHeight + sizeDiff,
             winCoord: { pointX: win.winCoord.pointX, pointY: y }
           }
         }
       ]);
+    } else if (minWinHeight && isResizeActive) {
+      commit([
+        {
+          winId: win.windowId,
+          patch: {
+            winHeight: win.WIN_MIN_HEIGHT,
+            winCoord: {
+              pointX: win.winCoord.pointX,
+              pointY: win.winCoord.pointY + win.winHeight - win.WIN_MIN_HEIGHT
+            }
+          }
+        }
+      ]);
     }
-    requestAnimationFrame(() => resizer.n(getRafResizeDependencies(win.windowId), commit));
+    requestAnimationFrame(
+      () => resizer.n(getRafResizeDependencies(win.windowId), commit, neighbourLimit)
+    );
   },
-  s: (resizeDep, commit) => {
+  s: (resizeDep, commit, neighbourLimit) => {
     const { wsRect, win, winBox, y } = resizeDep;
     if (!win.resizeAction)
       return;
     if (!winBox)
       return;
-    const minWinHeight = y - winBox.top < win.WIN_MIN_HEIGHT;
     const cursorOutOfBounds = y > wsRect.bottom || y < wsRect.top;
     const sizeDiff = y - winBox.bottom;
-    if (!minWinHeight && !cursorOutOfBounds && sizeDiff !== 0) {
+    const isResizeActive = !cursorOutOfBounds && sizeDiff !== 0;
+    const minWinHeight = y - winBox.top < win.WIN_MIN_HEIGHT;
+    const topMostYAtMinWidth = neighbourLimit;
+    const isNeighbourLimit = topMostYAtMinWidth && y > topMostYAtMinWidth;
+    if (isNeighbourLimit && isResizeActive) {
       commit([
         {
           winId: win.windowId,
           patch: {
-            winHeight: Math.round(win.winHeight + sizeDiff)
+            winHeight: topMostYAtMinWidth - win.winCoord.pointY
           }
         }
       ]);
+    } else if (!minWinHeight && isResizeActive) {
+      commit([
+        {
+          winId: win.windowId,
+          patch: {
+            winHeight: win.winHeight + sizeDiff
+          }
+        }
+      ]);
+    } else if (minWinHeight && isResizeActive) {
+      commit([
+        {
+          winId: win.windowId,
+          patch: { winHeight: win.WIN_MIN_HEIGHT }
+        }
+      ]);
     }
-    requestAnimationFrame(() => resizer.s(getRafResizeDependencies(win.windowId), commit));
+    requestAnimationFrame(
+      () => resizer.s(getRafResizeDependencies(win.windowId), commit, neighbourLimit)
+    );
   },
   nw: (resizeDep, commit) => {
     const { wsRect, win, winBox, x, y } = resizeDep;
@@ -550,37 +760,27 @@ var resizer = {
     const cursorOutOfBoundsX = x > wsRect.right || x < wsRect.left;
     const isCursorOutOfBounds = cursorOutOfBoundsY || cursorOutOfBoundsX;
     if (isCursorOutOfBounds) {
-      requestAnimationFrame(() => resizer.nw(getRafResizeDependencies(win.windowId), commit));
+      return;
     }
     const minWinHeight = winBox.bottom - y <= win.WIN_MIN_HEIGHT;
     const minWinWidth = winBox.right - x <= win.WIN_MIN_WIDTH;
     const sizeDiffY = winBox.top - y;
     const sizeDiffX = winBox.left - x;
-    const stagedChagnes = [];
     if (sizeDiffY !== 0 || sizeDiffX !== 0) {
-      stagedChagnes.push({
-        winId: win.windowId,
-        patch: {
-          winCoord: {
-            pointX: minWinWidth ? win.winCoord.pointX : x,
-            pointY: minWinHeight ? win.winCoord.pointY : y
+      commit([
+        {
+          winId: win.windowId,
+          patch: {
+            winWidth: minWinWidth ? win.WIN_MIN_WIDTH : win.winWidth + sizeDiffX,
+            winHeight: minWinHeight ? win.WIN_MIN_HEIGHT : win.winHeight + sizeDiffY,
+            winCoord: {
+              pointX: minWinWidth ? win.winCoord.pointX + win.winWidth - win.WIN_MIN_WIDTH : x,
+              pointY: minWinHeight ? win.winCoord.pointY + win.winHeight - win.WIN_MIN_HEIGHT : y
+            }
           }
         }
-      });
-    }
-    if (!minWinHeight && sizeDiffY !== 0) {
-      stagedChagnes.push({
-        winId: win.windowId,
-        patch: { winHeight: Math.round(win.winHeight + sizeDiffY) }
-      });
-    }
-    if (!minWinWidth && sizeDiffX !== 0) {
-      stagedChagnes.push({
-        winId: win.windowId,
-        patch: { winWidth: Math.round(win.winWidth + sizeDiffX) }
-      });
+      ]);
     }
-    commit(stagedChagnes);
     requestAnimationFrame(() => resizer.nw(getRafResizeDependencies(win.windowId), commit));
   },
   se: (resizeDep, commit) => {
@@ -600,28 +800,139 @@ var getRafResizeDependencies = (winId) => {
   const win = windowRegistry[winId].getState();
   const winBox = win.winElement?.getBoundingClientRect();
   const wsRect = useWorkspaceState.getState().wsRect;
-  const { x, y } = useCursorState.getState();
+  const { x, y } = cursorPosition;
   return { wsRect, win, winBox, x, y };
 };
 
+// src/window-manager/internal/runtime/history-resolver/app-history.ts
+var MAX_HISTORY = 100;
+var excludedCommands = [
+  "UPDATE_WORKSPACE_SIZE",
+  "SET_RESPONSIVE_BREAK",
+  "SET_WORKSPACE_FEATURES",
+  "APPLY_PREVIOUS",
+  "APPLY_NEXT",
+  "ENABLE_DRAG",
+  "ENABLE_RESIZE"
+];
+var appHistory = {
+  snapshots: [],
+  ptr: -1
+};
+function saveSnapshot(cmd) {
+  if (excludedCommands.includes(cmd))
+    return;
+  const snapshot = getSnapshot();
+  if (!snapshot)
+    return;
+  if (appHistory.ptr < appHistory.snapshots.length - 1) {
+    appHistory.snapshots = appHistory.snapshots.slice(0, appHistory.ptr + 1);
+  }
+  appHistory.snapshots.push(snapshot);
+  if (appHistory.snapshots.length > MAX_HISTORY) {
+    appHistory.snapshots.shift();
+  }
+  appHistory.ptr = appHistory.snapshots.length - 1;
+}
+var getSnapshot = () => {
+  const { wsElement, setWsElement, ...wsSnapshot } = useWorkspaceState.getState();
+  const wsUpdate = structuredClone(wsSnapshot);
+  const winStateSnapshots = [];
+  for (const key of Object.keys(windowRegistry)) {
+    const { winElement, setWinElement, isDragging, resizeAction, ...windowSnapshot } = windowRegistry[key].getState();
+    winStateSnapshots.push(structuredClone(windowSnapshot));
+  }
+  if (!isValidSnapshot(winStateSnapshots)) {
+    return;
+  }
+  return {
+    ws: wsUpdate,
+    winState: winStateSnapshots
+  };
+};
+var isValidSnapshot = (winStateSnapshots) => {
+  if (appHistory.ptr < 0)
+    return true;
+  const prevSnapshot = appHistory.snapshots[appHistory.ptr].winState;
+  for (const newWinState of winStateSnapshots) {
+    for (const prevWinState of prevSnapshot) {
+      if (newWinState.windowId !== prevWinState.windowId)
+        continue;
+      if (newWinState.zIndex !== prevWinState.zIndex || newWinState.winVisualState !== prevWinState.winVisualState || newWinState.isWindowClosed !== prevWinState.isWindowClosed || newWinState.winCoord?.pointX !== prevWinState.winCoord?.pointX || newWinState.winCoord?.pointY !== prevWinState.winCoord?.pointY || newWinState.winWidth !== prevWinState.winWidth || newWinState.winHeight !== prevWinState.winHeight)
+        return true;
+    }
+  }
+  return false;
+};
+
+// src/window-manager/internal/runtime/history-resolver/history-commands.ts
+var historyCommandResolver = {
+  APPLY_PREVIOUS: () => {
+    if (appHistory.ptr <= 0)
+      return { ws: {}, win: [] };
+    appHistory.ptr -= 1;
+    const snapshot = appHistory.snapshots[appHistory.ptr];
+    const wsUpdate = snapshot.ws;
+    const winBatchUpdate = [];
+    snapshot.winState.forEach((win) => {
+      const { windowId, setWinElement, ...state } = win;
+      winBatchUpdate.push({
+        winId: windowId,
+        patch: { ...state }
+      });
+    });
+    return {
+      ws: wsUpdate,
+      win: winBatchUpdate
+    };
+  },
+  APPLY_NEXT: () => {
+    if (appHistory.ptr >= appHistory.snapshots.length - 1)
+      return { ws: {}, win: [] };
+    appHistory.ptr += 1;
+    const snapshot = appHistory.snapshots[appHistory.ptr];
+    const wsUpdate = snapshot.ws;
+    const winBatchUpdate = [];
+    snapshot.winState.forEach((win) => {
+      const { windowId, setWinElement, ...state } = win;
+      winBatchUpdate.push({
+        winId: windowId,
+        patch: { ...state }
+      });
+    });
+    return {
+      ws: wsUpdate,
+      win: winBatchUpdate
+    };
+  },
+  CLEAR_HISTORY: () => {
+    appHistory.ptr = -1;
+    appHistory.snapshots = [];
+    return {
+      ws: {},
+      win: []
+    };
+  }
+};
+
 // src/window-manager/internal/runtime/rwm-runtime.ts
 var rwmRuntime = {
   dispatch: ({ subsystem, cmd, targetWinId, ctx }) => {
     switch (subsystem) {
       case "WORKSPACE": {
         const stagedChanges = workspaceCommandResolver[cmd](targetWinId, ctx);
-        commitToWorkspace(stagedChanges);
+        commitBatch(stagedChanges);
         break;
       }
       case "DRAG": {
-        if (!isDragAllowed())
+        if (useWorkspaceState.getState().isBelowBreakPoint)
           return;
         const stagedChanges = dragCommandResolver[cmd](targetWinId);
         commitToWindow(stagedChanges);
         break;
       }
       case "DOCK": {
-        const { wsRect } = getDockDependencies();
+        const { wsRect } = useWorkspaceState.getState();
         const stagedChanges = dockCommandResolver[cmd](targetWinId, wsRect);
         commitToWindow(stagedChanges);
         break;
@@ -631,24 +942,29 @@ var rwmRuntime = {
         commitToWindow(stagedChanges);
         break;
       }
-      case "STACK": {
-        const stagedChanges = stackCommandResolver[cmd](targetWinId);
-        commitToWindow(stagedChanges);
-        break;
-      }
       case "FOCUS": {
         const stagedChanges = focusCommandResolver[cmd](targetWinId);
         commitBatch(stagedChanges);
         break;
       }
+      case "HISTORY": {
+        const stagedChanges = historyCommandResolver[cmd]();
+        commitBatch(stagedChanges);
+        break;
+      }
+      default:
+        throw new Error(
+          `Unregistered rwmRuntime subsystem called: ${{ subsystem, cmd, targetWinId, ctx }}`
+        );
     }
+    saveSnapshot(cmd);
   }
 };
 var rafRuntime = {
   dispatch: ({ subsystem, cmd, targetWinId }) => {
     switch (subsystem) {
       case "RAF_DRAG": {
-        if (!isDragAllowed())
+        if (useWorkspaceState.getState().isBelowBreakPoint)
           return;
         rafDragLoopResolver[cmd](targetWinId, commitToWindow);
         break;
@@ -657,6 +973,10 @@ var rafRuntime = {
         rafResizeLoopResolver[cmd](targetWinId, commitToWindow);
         break;
       }
+      default:
+        throw new Error(
+          `Unregistered rafRuntime subsystem called: ${{ subsystem, cmd, targetWinId }}`
+        );
     }
   }
 };
@@ -747,13 +1067,6 @@ var focusApi = {
   }
 };
 
-// src/window-manager/internal/features/stack/stack-api.ts
-var stackApi = {
-  resetStack: () => {
-    rwmRuntime.dispatch({ subsystem: "STACK", cmd: "RESET_STACK" });
-  }
-};
-
 // src/window-manager/internal/features/workspace/workspace-api.ts
 var wsApi = {
   /**
@@ -773,36 +1086,35 @@ var wsApi = {
       ctx: { responsiveBreak: breakPoint }
     });
   },
-  setWsFeatures: ({ isDockPannelEnabled = true, isGridEnabled = true }) => {
+  setWsFeatures: ({ isDockPanelEnabled = true, isGridEnabled = true }) => {
     rwmRuntime.dispatch({
       subsystem: "WORKSPACE",
       cmd: "SET_WORKSPACE_FEATURES",
-      ctx: { isDockPannelEnabled, isGridEnabled }
+      ctx: { isDockPanelEnabled, isGridEnabled }
     });
   },
-  updateWsRect: () => {
-    rwmRuntime.dispatch({ subsystem: "WORKSPACE", cmd: "UPDATE_WORKSPACE_RECT" });
+  updateWsSize: () => {
+    rwmRuntime.dispatch({ subsystem: "WORKSPACE", cmd: "UPDATE_WORKSPACE_SIZE" });
   }
 };
 
 // src/window-manager/rwm.ts
-var { updateWsRect, ...publicWsApi } = wsApi;
+var { updateWsSize, ...publicWsApi } = wsApi;
 var rwm = {
   dockApi,
   focusApi,
-  stackApi,
   workspaceApi: publicWsApi,
   /**
    * @about
    * Zustand hook, can be used to access the current state of the workspace by either
-   * calling `const { <someState> } = worskpaceState()` inside a component or by calling
-   * `worskpaceState.getState()` anywhere.
+   * calling `const { <someState> } = workspaceState()` inside a component or by calling
+   * `workspaceState.getState()` anywhere.
    *
    * @note
    * The hook also exposes the `setState()` method, however, this is highly discouraged. Prefer calling
    * the exposed apis in rwm for state mutation.
    */
-  worskpaceState: useWorkspaceState,
+  workspaceState: useWorkspaceState,
   /**
    * @about
    * use the syntax `const { <someState> } = windowRegistry[<winId>]()` inside a component to access
@@ -817,14 +1129,14 @@ var rwm = {
 var rwm_default = rwm;
 
 // src/window-manager/workspace-layout.tsx
-import { useEffect as useEffect3, useRef } from "react";
+import { useEffect as useEffect4, useRef } from "react";
 
 // src/window-manager/internal/features/docking/docking-controls.tsx
 import { useState } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 function DockingControls() {
   const [isHovering, setIsHovering] = useState(false);
-  const { activeWindowId, isDockPannelEnabled, isBelowBreakPoint } = useWorkspaceState();
+  const { activeWindowId, isDockPanelEnabled, isBelowBreakPoint } = useWorkspaceState();
   const { isDragging } = windowRegistry[activeWindowId]();
   const cornerDockControl = /* @__PURE__ */ jsxs("div", { className: `flex xl:p-0 shrink-0 gap-0.5`, children: [
     /* @__PURE__ */ jsxs("div", { className: "flex flex-col justify-center gap-0.5", children: [
@@ -892,7 +1204,7 @@ function DockingControls() {
       }
     )
   ] });
-  const windowDockPannel = /* @__PURE__ */ jsx(
+  const windowDockPanel = /* @__PURE__ */ jsx(
     "span",
     {
       className: "pointer-events-auto px-4 pb-3",
@@ -916,7 +1228,7 @@ function DockingControls() {
   );
   if (isBelowBreakPoint)
     return;
-  if (!isDockPannelEnabled)
+  if (!isDockPanelEnabled)
     return;
   return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(
     "div",
@@ -926,7 +1238,7 @@ function DockingControls() {
         transition-all duration-500
         absolute z-50 flex items-center justify-center 
         w-full mx-auto pointer-events-none`,
-      children: windowDockPannel
+      children: windowDockPanel
     }
   ) });
 }
@@ -943,6 +1255,9 @@ var resizeApi = {
     rafRuntime.dispatch({ targetWinId: winId, subsystem: "RAF_RESIZE", cmd: "LOOP_RESIZE" });
   },
   stopResize: (winId) => {
+    const isNotResizing = !windowRegistry[winId].getState().resizeAction;
+    if (isNotResizing)
+      return;
     rwmRuntime.dispatch({
       targetWinId: winId,
       subsystem: "RESIZE",
@@ -956,20 +1271,34 @@ var resizeApi = {
 import { useEffect } from "react";
 import { Fragment as Fragment2, jsx as jsx2 } from "react/jsx-runtime";
 function CursorMoveListener() {
-  const { setXY } = useCursorState();
   useEffect(() => {
     const handlePointerMove = (e) => {
       e.preventDefault();
-      setXY(e.clientX, e.clientY);
+      setCursorPosition({ x: e.clientX, y: e.clientY });
     };
     window.addEventListener("pointermove", handlePointerMove);
     return () => window.removeEventListener("pointermove", handlePointerMove);
-  }, [setXY]);
+  }, []);
   return /* @__PURE__ */ jsx2(Fragment2, {});
 }
 
 // src/window-manager/internal/features/workspace/workspace-resize-listener.tsx
 import { useEffect as useEffect2 } from "react";
+
+// src/window-manager/internal/features/history/history-api.ts
+var appHistoryApi = {
+  moveToPreviousSnapshot: () => {
+    rwmRuntime.dispatch({ subsystem: "HISTORY", cmd: "APPLY_PREVIOUS" });
+  },
+  moveToNextSnapshot: () => {
+    rwmRuntime.dispatch({ subsystem: "HISTORY", cmd: "APPLY_NEXT" });
+  },
+  clearHistory: () => {
+    rwmRuntime.dispatch({ subsystem: "HISTORY", cmd: "CLEAR_HISTORY" });
+  }
+};
+
+// src/window-manager/internal/features/workspace/workspace-resize-listener.tsx
 import { Fragment as Fragment3, jsx as jsx3 } from "react/jsx-runtime";
 function WorkspaceResizeListener() {
   const { wsElement } = useWorkspaceState();
@@ -977,8 +1306,8 @@ function WorkspaceResizeListener() {
     if (!wsElement)
       return;
     const onResize = () => {
-      wsApi.updateWsRect();
-      stackApi.resetStack();
+      wsApi.updateWsSize();
+      appHistoryApi.clearHistory();
     };
     onResize();
     const observer = new ResizeObserver(onResize);
@@ -999,6 +1328,9 @@ var dragApi = {
     rafRuntime.dispatch({ targetWinId, subsystem: "RAF_DRAG", cmd: "LOOP_DRAG" });
   },
   stopDrag: (targetWinId) => {
+    const isNotDragging = !windowRegistry[targetWinId].getState().isDragging;
+    if (isNotDragging)
+      return;
     rwmRuntime.dispatch({
       targetWinId,
       subsystem: "DRAG",
@@ -1007,12 +1339,36 @@ var dragApi = {
   }
 };
 
+// src/window-manager/internal/features/history/history-keys-listener.tsx
+import { useEffect as useEffect3 } from "react";
+import { Fragment as Fragment4, jsx as jsx4 } from "react/jsx-runtime";
+function HistoryKeysListener() {
+  useEffect3(() => {
+    const handleKeyDown = (e) => {
+      const ctrlOrCmd = e.metaKey || e.ctrlKey;
+      if (!ctrlOrCmd)
+        return;
+      if (e.key.toLowerCase() === "z" && !e.shiftKey) {
+        e.preventDefault();
+        appHistoryApi.moveToPreviousSnapshot();
+      }
+      if (e.key.toLowerCase() === "z" && e.shiftKey) {
+        e.preventDefault();
+        appHistoryApi.moveToNextSnapshot();
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, []);
+  return /* @__PURE__ */ jsx4(Fragment4, {});
+}
+
 // src/window-manager/workspace-layout.tsx
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
 function WorkspaceLayout({ children, className }) {
   const { setWsElement, wsElement, isBelowBreakPoint, activeWindowId } = useWorkspaceState();
   const workspaceRef = useRef(null);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!workspaceRef.current)
       return;
     setWsElement(workspaceRef.current);
@@ -1030,10 +1386,11 @@ function WorkspaceLayout({ children, className }) {
       onPointerUp: disabledDragAndResize,
       className: className ? className : "fixed overflow-hidden h-full w-full touch-none -z-50",
       children: [
-        /* @__PURE__ */ jsx4(WorkspaceResizeListener, {}),
-        /* @__PURE__ */ jsx4(CursorMoveListener, {}),
+        /* @__PURE__ */ jsx5(WorkspaceResizeListener, {}),
+        /* @__PURE__ */ jsx5(HistoryKeysListener, {}),
+        /* @__PURE__ */ jsx5(CursorMoveListener, {}),
         /* @__PURE__ */ jsxs2("div", { className: " w-full h-full relative overflow-hidden", children: [
-          !isBelowBreakPoint && /* @__PURE__ */ jsx4(DockingControls, {}),
+          !isBelowBreakPoint && /* @__PURE__ */ jsx5(DockingControls, {}),
           children
         ] })
       ]
@@ -1042,15 +1399,15 @@ function WorkspaceLayout({ children, className }) {
 }
 
 // src/window-manager/registration/window-store-factory.tsx
-import { create as create3 } from "zustand";
+import { create as create2 } from "zustand";
 
 // src/window-manager/internal/features/window-layout.tsx
-import { useEffect as useEffect4, useRef as useRef2 } from "react";
+import { useEffect as useEffect5, useRef as useRef2 } from "react";
 
 // src/window-manager/internal/assets/svg-win-icons.tsx
-import { jsx as jsx5 } from "react/jsx-runtime";
+import { jsx as jsx6 } from "react/jsx-runtime";
 function IconWinMaximize({ color }) {
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx6(
     "svg",
     {
       xmlns: "http://www.w3.org/2000/svg",
@@ -1062,7 +1419,7 @@ function IconWinMaximize({ color }) {
       stroke: color ? color : "#cccccc",
       color: color ? color : "#cccccc",
       className: "size-6",
-      children: /* @__PURE__ */ jsx5(
+      children: /* @__PURE__ */ jsx6(
         "path",
         {
           strokeLinecap: "round",
@@ -1074,7 +1431,7 @@ function IconWinMaximize({ color }) {
   );
 }
 function IconWinDemaximize({ color }) {
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx6(
     "svg",
     {
       xmlns: "http://www.w3.org/2000/svg",
@@ -1086,7 +1443,7 @@ function IconWinDemaximize({ color }) {
       stroke: color ? color : "#cccccc",
       color: color ? color : "#cccccc",
       className: "size-6",
-      children: /* @__PURE__ */ jsx5(
+      children: /* @__PURE__ */ jsx6(
         "path",
         {
           strokeLinecap: "round",
@@ -1098,7 +1455,7 @@ function IconWinDemaximize({ color }) {
   );
 }
 function IconWinMinimize({ color }) {
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx6(
     "svg",
     {
       xmlns: "http://www.w3.org/2000/svg",
@@ -1110,31 +1467,30 @@ function IconWinMinimize({ color }) {
       stroke: color ? color : "#cccccc",
       color: color ? color : "#cccccc",
       className: "size-6",
-      children: /* @__PURE__ */ jsx5("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M6 18 18 6M6 6l12 12" })
+      children: /* @__PURE__ */ jsx6("path", { strokeLinecap: "round", strokeLinejoin: "round", d: "M6 18 18 6M6 6l12 12" })
     }
   );
 }
 
 // src/window-manager/internal/features/grid/grid-orchestrator.ts
 var tolerance = 4;
-var gridOrchestrator = {
-  attachAdjacentGridBehavior: (winId) => {
+var resizeOrchestrator = {
+  initializeResize: (winId, direction) => {
     if (!useWorkspaceState.getState().isGridEnabled)
       return;
     if (getOpenWinCount() < 1)
       throw new Error(`gridOrchestrator initalized but all windows are closed`);
-    if (getDraggingWinCount() < 1)
-      throw new Error(`gridOrchestrator initalized but no window is currently resizing`);
-    attachAdjacentGridBehavior(winId);
+    initNeighbourResizeBehavior(winId, /* @__PURE__ */ new Set(), direction);
+    resizeApi.startResize(winId, direction);
   }
 };
-var attachAdjacentGridBehavior = (winId, visited = /* @__PURE__ */ new Set()) => {
+var initNeighbourResizeBehavior = (winId, visited, direction) => {
   if (visited.has(winId))
     return;
   else
     visited.add(winId);
   const thisWin = windowRegistry[winId].getState();
-  const currentResize = thisWin.resizeAction;
+  const currentResize = direction ? direction : thisWin.resizeAction;
   for (const key of Object.keys(windowRegistry)) {
     const remoteWin = windowRegistry[key].getState();
     if (remoteWin.windowId === thisWin.windowId)
@@ -1149,22 +1505,22 @@ var attachAdjacentGridBehavior = (winId, visited = /* @__PURE__ */ new Set()) =>
     if (currentResize === "e") {
       const isRemoteConneted = resizeCase.whenDraggingEast(dependencies);
       if (isRemoteConneted)
-        attachAdjacentGridBehavior(remoteWin.windowId, visited);
+        initNeighbourResizeBehavior(remoteWin.windowId, visited);
     }
     if (currentResize === "w") {
       const isRemoteConneted = resizeCase.whenDragginWest(dependencies);
       if (isRemoteConneted)
-        attachAdjacentGridBehavior(remoteWin.windowId, visited);
+        initNeighbourResizeBehavior(remoteWin.windowId, visited);
     }
     if (currentResize === "n") {
       const isRemoteConneted = resizeCase.whenDragginNorth(dependencies);
       if (isRemoteConneted)
-        attachAdjacentGridBehavior(remoteWin.windowId, visited);
+        initNeighbourResizeBehavior(remoteWin.windowId, visited);
     }
     if (currentResize === "s") {
       const isRemoteConneted = resizeCase.whenDraggingSouth(dependencies);
       if (isRemoteConneted)
-        attachAdjacentGridBehavior(remoteWin.windowId, visited);
+        initNeighbourResizeBehavior(remoteWin.windowId, visited);
     }
   }
 };
@@ -1261,13 +1617,6 @@ var buildDependencies = (thisWin, remoteWin) => {
     isRemoteOutside
   };
 };
-var getDraggingWinCount = () => {
-  let isWindowResizingCount = 0;
-  for (const key of Object.keys(windowRegistry))
-    if (windowRegistry[key].getState().resizeAction)
-      isWindowResizingCount++;
-  return isWindowResizingCount;
-};
 var getOpenWinCount = () => {
   let openWnidowCount = 0;
   for (const key of Object.keys(windowRegistry))
@@ -1277,18 +1626,17 @@ var getOpenWinCount = () => {
 };
 
 // src/window-manager/internal/features/resizing/resizing-controls.tsx
-import { Fragment as Fragment4, jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Fragment as Fragment5, jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
 function ResizingControls({ winId }) {
   const { winCoord, winWidth, winHeight, resizeAction } = windowRegistry[winId]();
   const startResize = (direction) => {
-    resizeApi.startResize(winId, direction);
-    gridOrchestrator.attachAdjacentGridBehavior(winId);
+    resizeOrchestrator.initializeResize(winId, direction);
   };
   const stopResize = () => {
     resizeApi.stopResize(winId);
   };
-  return /* @__PURE__ */ jsxs3(Fragment4, { children: [
-    /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsxs3(Fragment5, { children: [
+    /* @__PURE__ */ jsx7(
       "span",
       {
         onPointerUp: stopResize,
@@ -1300,10 +1648,10 @@ function ResizingControls({ winId }) {
           left: `${winCoord.pointX + winWidth - 4}px`,
           height: `${winHeight}px`
         },
-        children: /* @__PURE__ */ jsx6("div", { className: `w-1 h-full bg-zinc-50` })
+        children: /* @__PURE__ */ jsx7("div", { className: `w-1 h-full bg-zinc-50` })
       }
     ),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       "span",
       {
         onPointerUp: stopResize,
@@ -1315,10 +1663,10 @@ function ResizingControls({ winId }) {
           left: `${winCoord.pointX - 4}px`,
           height: `${winHeight}px`
         },
-        children: /* @__PURE__ */ jsx6("div", { className: `w-1 h-full bg-zinc-50` })
+        children: /* @__PURE__ */ jsx7("div", { className: `w-1 h-full bg-zinc-50` })
       }
     ),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       "span",
       {
         onPointerUp: stopResize,
@@ -1330,10 +1678,10 @@ function ResizingControls({ winId }) {
           left: `${winCoord.pointX}px`,
           width: `${winWidth}px`
         },
-        children: /* @__PURE__ */ jsx6("div", { className: `w-full h-1 bg-zinc-50` })
+        children: /* @__PURE__ */ jsx7("div", { className: `w-full h-1 bg-zinc-50` })
       }
     ),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       "span",
       {
         onPointerUp: stopResize,
@@ -1345,10 +1693,10 @@ function ResizingControls({ winId }) {
           left: `${winCoord.pointX}px`,
           width: `${winWidth}px`
         },
-        children: /* @__PURE__ */ jsx6("div", { className: `w-full h-1 bg-zinc-50` })
+        children: /* @__PURE__ */ jsx7("div", { className: `w-full h-1 bg-zinc-50` })
       }
     ),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       "span",
       {
         onPointerUp: stopResize,
@@ -1361,7 +1709,7 @@ function ResizingControls({ winId }) {
         }
       }
     ),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       "span",
       {
         onPointerUp: stopResize,
@@ -1374,7 +1722,7 @@ function ResizingControls({ winId }) {
         }
       }
     ),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       "span",
       {
         onPointerUp: stopResize,
@@ -1382,12 +1730,12 @@ function ResizingControls({ winId }) {
         id: "win-resize-top-right-all",
         className: "fixed h-3 w-3 opacity-60 cursor-ne-resize z-20",
         style: {
-          top: `${winCoord.pointY - 6}px`,
-          left: `${winCoord.pointX + winWidth - 6}px`
+          top: `${winCoord.pointY - 8}px`,
+          left: `${winCoord.pointX + winWidth - 8}px`
         }
       }
     ),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       "span",
       {
         onPointerUp: stopResize,
@@ -1395,8 +1743,8 @@ function ResizingControls({ winId }) {
         id: "win-resize-top-left-all",
         className: "fixed h-3 w-3 opacity-60 cursor-nw-resize z-20",
         style: {
-          top: `${winCoord.pointY - 6}px`,
-          left: `${winCoord.pointX - 6}px`
+          top: `${winCoord.pointY - 8}px`,
+          left: `${winCoord.pointX - 8}px`
         }
       }
     )
@@ -1404,9 +1752,9 @@ function ResizingControls({ winId }) {
 }
 
 // src/window-manager/internal/features/drag/drag-handle.tsx
-import { jsx as jsx7 } from "react/jsx-runtime";
+import { jsx as jsx8 } from "react/jsx-runtime";
 function DragHandle({ winId }) {
-  return /* @__PURE__ */ jsx7(
+  return /* @__PURE__ */ jsx8(
     "div",
     {
       onPointerDown: () => dragApi.startDrag(winId),
@@ -1420,7 +1768,7 @@ function DragHandle({ winId }) {
 }
 
 // src/window-manager/internal/features/window-layout.tsx
-import { Fragment as Fragment5, jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Fragment as Fragment6, jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
 function WindowLayout({
   children,
   windowName,
@@ -1434,28 +1782,24 @@ function WindowLayout({
   const { wsElement, wsRect, isBelowBreakPoint } = useWorkspaceState();
   const windowRef = useRef2(null);
   const {
+    setWinElement,
     windowId,
     zIndex,
     isActive,
-    setWinElement,
-    resetFlag,
     winVisualState,
     isWindowClosed,
     winCoord,
     winWidth,
     winHeight
   } = windowRegistry[winId]();
-  useEffect4(() => {
+  useEffect5(() => {
     setWinElement(windowRef.current);
-  }, [setWinElement, windowRef.current]);
-  useEffect4(() => {
-    if (isBelowBreakPoint) {
-      dockApi.maximizeWindow(winId);
-    } else {
-      dockingRoutes[defaultDock](winId);
-    }
-  }, [wsElement, resetFlag]);
-  const dockingRoutes = {
+  }, [setWinElement]);
+  useEffect5(() => {
+    dockingResolver[defaultDock](winId);
+    appHistoryApi.clearHistory();
+  }, [wsElement]);
+  const dockingResolver = {
     right: dockApi.dockWindowRight,
     left: dockApi.dockWindowLeft,
     full: dockApi.maximizeWindow,
@@ -1467,30 +1811,30 @@ function WindowLayout({
     "bottom-left": dockApi.dockWindowBottomLeft,
     default: dockApi.demaximizeWindow
   };
-  const maximizeControl = winVisualState === "maximized" ? /* @__PURE__ */ jsx8(
+  const maximizeControl = winVisualState === "maximized" ? /* @__PURE__ */ jsx9(
     "button",
     {
       className: `block hover:bg-gray-500 hover:bg-opacity-10 px-5 h-full`,
       onClick: () => dockApi.demaximizeWindow(winId),
-      children: /* @__PURE__ */ jsx8(IconWinDemaximize, { color: style?.navControlsColor })
+      children: /* @__PURE__ */ jsx9(IconWinDemaximize, { color: style?.navControlsColor })
     }
-  ) : /* @__PURE__ */ jsx8(
+  ) : /* @__PURE__ */ jsx9(
     "button",
     {
       className: `block hover:bg-gray-500 hover:bg-opacity-10 px-5 h-full`,
       onClick: () => dockApi.maximizeWindow(winId),
-      children: /* @__PURE__ */ jsx8(IconWinMaximize, { color: style?.navControlsColor })
+      children: /* @__PURE__ */ jsx9(IconWinMaximize, { color: style?.navControlsColor })
     }
   );
-  const closeControl = /* @__PURE__ */ jsx8(
+  const closeControl = /* @__PURE__ */ jsx9(
     "button",
     {
       className: "hover:bg-red-500 hover:bg-opacity-20 px-5 h-full",
       onClick: () => focusApi.closeWindowAndRefocus(winId),
-      children: /* @__PURE__ */ jsx8(IconWinMinimize, { color: style?.navControlsColor })
+      children: /* @__PURE__ */ jsx9(IconWinMinimize, { color: style?.navControlsColor })
     }
   );
-  return /* @__PURE__ */ jsxs4(Fragment5, { children: [
+  return /* @__PURE__ */ jsxs4(Fragment6, { children: [
     /* @__PURE__ */ jsxs4(
       "div",
       {
@@ -1500,10 +1844,10 @@ function WindowLayout({
         onPointerDown: () => focusApi.bringWindowToFocus(windowId),
         style: {
           backgroundColor: style?.windowBackgroundColor,
-          top: `${winCoord.pointY}px`,
-          left: `${winCoord.pointX}px`,
-          width: `${winWidth}px`,
-          height: `${winHeight}px`,
+          top: isBelowBreakPoint ? wsRect.top : `${winCoord.pointY}px`,
+          left: isBelowBreakPoint ? wsRect.left : `${winCoord.pointX}px`,
+          width: isBelowBreakPoint ? wsRect.innerWidth : `${winWidth}px`,
+          height: isBelowBreakPoint ? wsRect.innerHeight : `${winHeight}px`,
           zIndex: `${zIndex}`,
           /* MINIMIZE LOGIC */
           transition: "transform 0.2s ease-in-out, opacity 0.3s ease-in-out",
@@ -1522,16 +1866,16 @@ function WindowLayout({
             ${navbarClassName ? navbarClassName : `bg-neutral-800 ${isActive ? "brightness-100" : "brightness-150"}`} 
           `,
               children: [
-                /* @__PURE__ */ jsx8("div", { className: "shrink h-8 px-2 text-white flex items-center text-sm truncate min-w-0", children: windowName }),
-                /* @__PURE__ */ jsx8("div", { className: "h-8 px-2 text-white flex items-center text-sm truncate min-w-0", children: navbarChildren }),
-                /* @__PURE__ */ jsx8(DragHandle, { winId }),
+                /* @__PURE__ */ jsx9("div", { className: "shrink h-8 px-2 text-white flex items-center text-sm truncate min-w-0", children: windowName }),
+                /* @__PURE__ */ jsx9("div", { className: "h-8 px-2 text-white flex items-center text-sm truncate min-w-0", children: navbarChildren }),
+                /* @__PURE__ */ jsx9(DragHandle, { winId }),
                 !isBelowBreakPoint && maximizeControl,
                 closeControl
               ]
             }
           ),
-          /* @__PURE__ */ jsx8(ResizingControls, { winId }),
-          /* @__PURE__ */ jsx8("div", { className: `relative w-full h-[calc(100%-32px)] overflow-auto select-text`, children })
+          !isBelowBreakPoint && /* @__PURE__ */ jsx9(ResizingControls, { winId }),
+          /* @__PURE__ */ jsx9("div", { className: `relative w-full h-[calc(100%-32px)] overflow-auto select-text`, children })
         ]
       }
     ),
@@ -1540,7 +1884,7 @@ function WindowLayout({
 }
 
 // src/window-manager/internal/features/window-button.tsx
-import { jsx as jsx9 } from "react/jsx-runtime";
+import { jsx as jsx10 } from "react/jsx-runtime";
 function WindowButton({
   children,
   winId,
@@ -1557,7 +1901,7 @@ function WindowButton({
       focusApi.bringWindowToFocus(windowId);
     }
   };
-  return /* @__PURE__ */ jsx9(
+  return /* @__PURE__ */ jsx10(
     "button",
     {
       id: `${windowId}_button`,
@@ -1572,26 +1916,25 @@ function WindowButton({
 }
 
 // src/window-manager/registration/window-store-factory.tsx
-import { jsx as jsx10 } from "react/jsx-runtime";
-var defaultMinWidth = 232;
-var defaultMinHeight = 128;
+import { jsx as jsx11 } from "react/jsx-runtime";
+var defaultMinWidth = 256;
+var defaultMinHeight = 64;
 var createWindowStore = () => {
   const zIndexAtLaunch = Object.keys(windowRegistry).length + 1;
   const windowInstanceId = `react-dynamic-window-instance${Object.keys(windowRegistry).length}`;
-  const storeInstance = create3((set, get) => ({
+  const storeInstance = create2((set) => ({
     setWinElement: (ref) => set({ winElement: ref }),
     winElement: void 0,
     windowId: windowInstanceId,
-    resetFlag: false,
     zIndex: zIndexAtLaunch,
     winCoord: { pointX: 40, pointY: 40 },
+    winWidth: defaultMinWidth,
+    winHeight: defaultMinHeight,
     winVisualState: "demaximized",
     isActive: false,
-    isDragging: false,
     isWindowClosed: true,
+    isDragging: false,
     resizeAction: false,
-    winWidth: defaultMinWidth,
-    winHeight: defaultMinHeight,
     WIN_MIN_WIDTH: defaultMinWidth,
     WIN_MIN_HEIGHT: defaultMinHeight
   }));
@@ -1599,8 +1942,8 @@ var createWindowStore = () => {
   return {
     id: storeInstance.getState().windowId,
     store: storeInstance,
-    Window: (props) => /* @__PURE__ */ jsx10(WindowLayout, { ...props, winId: windowInstanceId }),
-    Button: (props) => /* @__PURE__ */ jsx10(WindowButton, { ...props, winId: windowInstanceId })
+    Window: (props) => /* @__PURE__ */ jsx11(WindowLayout, { ...props, winId: windowInstanceId }),
+    Button: (props) => /* @__PURE__ */ jsx11(WindowButton, { ...props, winId: windowInstanceId })
   };
 };
 export {