@tutti-os/workbench-surface 0.0.1 → 0.0.3

package/dist/index.js

@@ -1712,6 +1712,9 @@ function WorkbenchDockFrame({
             },
             registerDockAnchor: (anchorKey, element) => {
               genie.registerDockAnchor(anchorKey, element);
+            },
+            shouldAnimateMinimizedDockEnter: (nodeID) => {
+              return genie.shouldAnimateMinimizedDockEnter(nodeID);
             }
           },
           minimizedNodes,
@@ -2589,6 +2592,7 @@ import { jsx as jsx7 } from "react/jsx-runtime";
 var genieDurationMs = 400;
 var genieMaxDevicePixelRatio = 2;
 var genieSnapshotScale = 1;
+var minimizedDockSlotEnterAnimationMs = 720;
 var dockPreviewMaxWidth = 260;
 var dockPreviewMaxHeight = 170;
 var dockPreviewImageCacheMaxEntries = 96;
@@ -2868,6 +2872,10 @@ function useWorkbenchGenieAnimation({
   const rafRef = useRef4(null);
   const animationGenerationRef = useRef4(0);
   const animationCleanupRef = useRef4(null);
+  const minimizedDockEnterAnimationNodeIdsRef = useRef4(/* @__PURE__ */ new Set());
+  const minimizedDockEnterAnimationTimersRef = useRef4(
+    /* @__PURE__ */ new Map()
+  );
   const [isCanvasActive, setIsCanvasActive] = useState4(false);
   const [genieHiddenNodeIDs, setGenieHiddenNodeIDs] = useState4(
     () => /* @__PURE__ */ new Set()
@@ -2895,6 +2903,40 @@ function useWorkbenchGenieAnimation({
     (node) => resolveDockAnchorKey?.(node) ?? node.id,
     [resolveDockAnchorKey]
   );
+  const releaseMinimizedDockEnterAnimation = useCallback6((nodeID) => {
+    const timer = minimizedDockEnterAnimationTimersRef.current.get(nodeID);
+    if (timer) {
+      clearTimeout(timer);
+      minimizedDockEnterAnimationTimersRef.current.delete(nodeID);
+    }
+    minimizedDockEnterAnimationNodeIdsRef.current.delete(nodeID);
+  }, []);
+  const registerMinimizedDockEnterAnimation = useCallback6(
+    (nodeID) => {
+      releaseMinimizedDockEnterAnimation(nodeID);
+      minimizedDockEnterAnimationNodeIdsRef.current.add(nodeID);
+    },
+    [releaseMinimizedDockEnterAnimation]
+  );
+  const scheduleReleaseMinimizedDockEnterAnimation = useCallback6(
+    (nodeID, delayMs = minimizedDockSlotEnterAnimationMs) => {
+      const existing = minimizedDockEnterAnimationTimersRef.current.get(nodeID);
+      if (existing) {
+        clearTimeout(existing);
+      }
+      minimizedDockEnterAnimationTimersRef.current.set(
+        nodeID,
+        setTimeout(() => {
+          minimizedDockEnterAnimationTimersRef.current.delete(nodeID);
+          minimizedDockEnterAnimationNodeIdsRef.current.delete(nodeID);
+        }, delayMs)
+      );
+    },
+    []
+  );
+  const shouldAnimateMinimizedDockEnter = useCallback6((nodeID) => {
+    return minimizedDockEnterAnimationNodeIdsRef.current.has(nodeID);
+  }, []);
   const hideNodeForGenie = useCallback6((nodeID) => {
     setGenieHiddenNodeIDs((current) => {
       if (current.has(nodeID)) {
@@ -3198,6 +3240,7 @@ function useWorkbenchGenieAnimation({
           clearCanvas();
         };
         animationCleanupRef.current = cleanupHiddenNode;
+        registerMinimizedDockEnterAnimation(nodeID);
         flushSync(() => {
           hideNodeForGenie(nodeID);
           runMinimize();
@@ -3206,12 +3249,14 @@ function useWorkbenchGenieAnimation({
           window.requestAnimationFrame(() => resolve());
         });
         if (generation !== animationGenerationRef.current) {
+          releaseMinimizedDockEnterAnimation(nodeID);
           return;
         }
         const minimizedTarget = controller.getSnapshot().nodes.find((node) => node.id === nodeID) ?? target;
         const anchorKey = resolveAnchorKeyForNode(minimizedTarget);
         const dockRect = resolveDockAnchorRect(anchorKey);
         if (!dockRect || !isUsableGenieRect(dockRect)) {
+          releaseMinimizedDockEnterAnimation(nodeID);
           animationCleanupRef.current = null;
           cleanupHiddenNode();
           return;
@@ -3220,12 +3265,14 @@ function useWorkbenchGenieAnimation({
           direction: "minimize",
           dockRect,
           onCancel: () => {
+            releaseMinimizedDockEnterAnimation(nodeID);
             flushSync(() => {
               showNodeForGenie(nodeID);
             });
             clearCanvas();
           },
           onComplete: () => {
+            scheduleReleaseMinimizedDockEnterAnimation(nodeID);
             flushSync(() => {
               showNodeForGenie(nodeID);
             });
@@ -3242,16 +3289,29 @@ function useWorkbenchGenieAnimation({
       captureNodePreviewImage,
       dockPreviewCache,
       hideNodeForGenie,
+      registerMinimizedDockEnterAnimation,
+      releaseMinimizedDockEnterAnimation,
       resolveAnchorKeyForNode,
       resolveDockPreviewCacheKey2,
       resolveDockAnchorRect,
       resolveNodeElement,
       runGenieAnimation,
+      scheduleReleaseMinimizedDockEnterAnimation,
       setupCanvas,
       showNodeForGenie,
       stopAnimation
     ]
   );
+  useEffect3(
+    () => () => {
+      for (const timer of minimizedDockEnterAnimationTimersRef.current.values()) {
+        clearTimeout(timer);
+      }
+      minimizedDockEnterAnimationTimersRef.current.clear();
+      minimizedDockEnterAnimationNodeIdsRef.current.clear();
+    },
+    []
+  );
   return {
     genieLayer: typeof document === "undefined" ? null : createPortal(
       /* @__PURE__ */ jsx7(
@@ -3271,7 +3331,8 @@ function useWorkbenchGenieAnimation({
     ),
     launchNodeFromAnchor,
     minimizeNodeToAnchor,
-    registerDockAnchor
+    registerDockAnchor,
+    shouldAnimateMinimizedDockEnter
   };
 }
 
@@ -4566,8 +4627,11 @@ var WorkbenchHostSessionController = class {
       return null;
     }
     const launchSource = resolveWorkbenchHostLaunchSource(input);
+    const currentState = this.controller.getSnapshot();
     const request = {
       ...input,
+      layoutConstraints: currentState.layoutConstraints,
+      surfaceSize: currentState.surfaceSize,
       workspaceId: this.input.workspaceId
     };
     if (launchSource !== null) {
@@ -5318,11 +5382,11 @@ import { useCallback as useCallback11, useMemo as useMemo6 } from "react";
 // src/host/WorkbenchHostDock.tsx
 import {
   useCallback as useCallback10,
-  useEffect as useEffect8,
+  useEffect as useEffect9,
   useLayoutEffect as useLayoutEffect4,
   useMemo as useMemo5,
-  useRef as useRef7,
-  useState as useState7
+  useRef as useRef8,
+  useState as useState8
 } from "react";
 import {
   ArrowLeftIcon,
@@ -5330,10 +5394,7 @@ import {
   Button as Button4,
   ChevronDownIcon,
   ChevronUpIcon,
-  Tooltip,
-  TooltipContent,
-  TooltipProvider,
-  TooltipTrigger
+  TooltipProvider
 } from "@tutti-os/ui-system";
 
 // src/host/dockEntries.ts
@@ -5437,6 +5498,8 @@ var MAGNIFICATION_SETTLE_EPSILON = 0.2;
 var MAGNIFICATION_SIZE_EPSILON = 0.2;
 var MAX_MAGNIFICATION_STEP_SECONDS = 1 / 30;
 var MAGNIFICATION_INFLUENCE_PADDING = 8;
+var DOCK_MAGNIFICATION_ENTRY_RAMP_MS = 90;
+var DOCK_MAGNIFICATION_CROSS_AXIS_PADDING = 8;
 var dockMagnificationShellBySlot = /* @__PURE__ */ new WeakMap();
 function mapDistanceToTargetSize(distance, baseSize = DOCK_ICON_BASE_SIZE, peakSize = DOCK_ICON_PEAK_SIZE, halfRange = DOCK_MAGNIFICATION_HALF_RANGE) {
   const absoluteDistance = Math.abs(distance);
@@ -5446,6 +5509,55 @@ function mapDistanceToTargetSize(distance, baseSize = DOCK_ICON_BASE_SIZE, peakS
   const influence = 1 - absoluteDistance / halfRange;
   return baseSize + (peakSize - baseSize) * influence;
 }
+function applyDockMagnificationEntryRamp(targetSize, baseSize, progress) {
+  const clampedProgress = Math.min(1, Math.max(0, progress));
+  return baseSize + (targetSize - baseSize) * clampedProgress;
+}
+function resolveDockMagnificationHitBounds(slotRects, dockPlacement, crossAxisPadding = DOCK_MAGNIFICATION_CROSS_AXIS_PADDING) {
+  if (slotRects.length === 0) {
+    return null;
+  }
+  let mainStart = Number.POSITIVE_INFINITY;
+  let mainEnd = Number.NEGATIVE_INFINITY;
+  let crossStart = Number.POSITIVE_INFINITY;
+  let crossEnd = Number.NEGATIVE_INFINITY;
+  for (const rect of slotRects) {
+    if (dockPlacement === "left") {
+      mainStart = Math.min(mainStart, rect.top);
+      mainEnd = Math.max(mainEnd, rect.bottom);
+      crossStart = Math.min(crossStart, rect.left);
+      crossEnd = Math.max(crossEnd, rect.right);
+    } else {
+      mainStart = Math.min(mainStart, rect.left);
+      mainEnd = Math.max(mainEnd, rect.right);
+      crossStart = Math.min(crossStart, rect.top);
+      crossEnd = Math.max(crossEnd, rect.bottom);
+    }
+  }
+  const effectiveCrossAxisEndPadding = dockPlacement === "left" ? crossAxisPadding + (DOCK_ICON_PEAK_SIZE - DOCK_ICON_BASE_SIZE) : crossAxisPadding;
+  return {
+    crossEnd: crossEnd + effectiveCrossAxisEndPadding,
+    crossStart: crossStart - crossAxisPadding,
+    mainEnd,
+    mainStart
+  };
+}
+function isDockMagnificationPointInsideHitBounds({
+  clientX,
+  clientY,
+  dockPlacement,
+  hitBounds
+}) {
+  if (!hitBounds) {
+    return false;
+  }
+  const mainAxis = dockPlacement === "left" ? clientY : clientX;
+  const crossAxis = dockPlacement === "left" ? clientX : clientY;
+  return mainAxis >= hitBounds.mainStart && mainAxis <= hitBounds.mainEnd && crossAxis >= hitBounds.crossStart && crossAxis <= hitBounds.crossEnd;
+}
+function resolveDockMagnificationSlotCenter(rect, dockPlacement, baseSize = DOCK_ICON_BASE_SIZE) {
+  return dockPlacement === "left" ? rect.top + baseSize / 2 : rect.left + baseSize / 2;
+}
 var DOCK_MAGNIFICATION_SPRING_SUBSTEPS = 8;
 function advanceDockMagnificationSpring(current, target, deltaSeconds) {
   const subDeltaSeconds = deltaSeconds / DOCK_MAGNIFICATION_SPRING_SUBSTEPS;
@@ -5470,6 +5582,14 @@ function hasAppliedSizeChanged(previous, next) {
   }
   return Math.abs(previous.size - next.size) > MAGNIFICATION_SIZE_EPSILON;
 }
+function resolveDockMagnificationSlotLayoutSize({
+  size
+}) {
+  return { height: size, width: size };
+}
+function isDockMagnificationSlotLayoutLocked(slotElement) {
+  return slotElement.dataset.collapsing === "true" || slotElement.dataset.presence === "entering" || slotElement.dataset.presence === "exiting";
+}
 function resolveDockMagnificationShell(slotElement) {
   const cachedShell = dockMagnificationShellBySlot.get(slotElement);
   if (cachedShell !== void 0 && (cachedShell === null || slotElement.contains(cachedShell))) {
@@ -5506,8 +5626,11 @@ function applyDockSlotMagnification(slotElement, size, baseSize, appliedStylesRe
     return;
   }
   const scale = nextStyle.size / baseSize;
-  slotElement.style.width = `${nextStyle.size}px`;
-  slotElement.style.height = `${nextStyle.size}px`;
+  const layoutSize = resolveDockMagnificationSlotLayoutSize({
+    size: nextStyle.size
+  });
+  slotElement.style.width = `${layoutSize.width}px`;
+  slotElement.style.height = `${layoutSize.height}px`;
   shell.style.transform = `scale(${scale})`;
 }
 function clearDockSlotMagnification(slotElement, appliedStylesRef) {
@@ -5533,7 +5656,9 @@ function useDockMagnification({
   );
   const animationFrameRef = useRef5(null);
   const lastFrameTimeRef = useRef5(null);
+  const entryRampStartedAtRef = useRef5(null);
   const restCentersRef = useRef5(null);
+  const hitBoundsRef = useRef5(null);
   const slotOrderRef = useRef5([]);
   const magnifyActiveRef = useRef5(false);
   const setMagnifyActive = useCallback8(
@@ -5560,14 +5685,25 @@ function useDockMagnification({
   const captureRestCenters = useCallback8(() => {
     const slots = slotRefs.current;
     const centers = /* @__PURE__ */ new Map();
+    const slotRects = [];
     const order = [];
     for (const [anchorKey, slotElement] of slots) {
       order.push(anchorKey);
       const rect = slotElement.getBoundingClientRect();
-      const center = dockPlacement === "left" ? rect.top + rect.height / 2 : rect.left + rect.width / 2;
+      slotRects.push({
+        bottom: rect.bottom,
+        left: rect.left,
+        right: rect.right,
+        top: rect.top
+      });
+      const center = resolveDockMagnificationSlotCenter(rect, dockPlacement);
       centers.set(anchorKey, center);
     }
     slotOrderRef.current = order;
+    hitBoundsRef.current = resolveDockMagnificationHitBounds(
+      slotRects,
+      dockPlacement
+    );
     restCentersRef.current = centers;
   }, [dockPlacement, slotRefs]);
   const runAnimationFrame = useCallback8(
@@ -5578,6 +5714,7 @@ function useDockMagnification({
       const pointerAxis = pointerAxisRef.current;
       if (pointerAxis !== null) {
         captureRestCenters();
+        entryRampStartedAtRef.current ??= frameTime;
       }
       const slots = slotRefs.current;
       const order = slotOrderRef.current;
@@ -5590,6 +5727,7 @@ function useDockMagnification({
       let shouldContinue = false;
       let allSettled = true;
       const influenceRadius = DOCK_MAGNIFICATION_HALF_RANGE + MAGNIFICATION_INFLUENCE_PADDING;
+      const entryRampProgress = pointerAxis === null || entryRampStartedAtRef.current === null ? 1 : (frameTime - entryRampStartedAtRef.current) / DOCK_MAGNIFICATION_ENTRY_RAMP_MS;
       for (let index = 0; index < order.length; index += 1) {
         const anchorKey = order[index];
         if (!anchorKey) {
@@ -5602,7 +5740,11 @@ function useDockMagnification({
         const distance = pointerAxis === null ? DOCK_MAGNIFICATION_HALF_RANGE : pointerAxis - center;
         const absoluteDistance = Math.abs(distance);
         const inRange = absoluteDistance < influenceRadius;
-        const targetSize = inRange ? mapDistanceToTargetSize(distance) : DOCK_ICON_BASE_SIZE;
+        const targetSize = inRange ? applyDockMagnificationEntryRamp(
+          mapDistanceToTargetSize(distance),
+          DOCK_ICON_BASE_SIZE,
+          entryRampProgress
+        ) : DOCK_ICON_BASE_SIZE;
         const currentSpring = springsRef.current.get(anchorKey) ?? {
           value: DOCK_ICON_BASE_SIZE,
           velocity: 0
@@ -5635,6 +5777,11 @@ function useDockMagnification({
         if (!slotElement) {
           continue;
         }
+        if (isDockMagnificationSlotLayoutLocked(slotElement)) {
+          springsRef.current.delete(anchorKey);
+          clearDockSlotMagnification(slotElement, appliedStylesRef.current);
+          continue;
+        }
         if (pointerAxis === null && isDockMagnificationSpringSettled(nextSpring, DOCK_ICON_BASE_SIZE)) {
           springsRef.current.delete(anchorKey);
           clearDockSlotMagnification(slotElement, appliedStylesRef.current);
@@ -5653,7 +5800,9 @@ function useDockMagnification({
         shouldContinue = true;
       }
       if (pointerAxis === null && allSettled) {
+        entryRampStartedAtRef.current = null;
         restCentersRef.current = null;
+        hitBoundsRef.current = null;
         slotOrderRef.current = [];
         setMagnifyActive(false);
       }
@@ -5674,9 +5823,23 @@ function useDockMagnification({
   }, [runAnimationFrame]);
   const handlePointerMove = useCallback8(
     (clientX, clientY) => {
-      pendingPointerAxisRef.current = dockPlacement === "left" ? clientY : clientX;
       if (restCentersRef.current === null) {
         captureRestCenters();
+      }
+      if (!isDockMagnificationPointInsideHitBounds({
+        clientX,
+        clientY,
+        dockPlacement,
+        hitBounds: hitBoundsRef.current
+      })) {
+        pendingPointerAxisRef.current = null;
+        pointerAxisRef.current = null;
+        entryRampStartedAtRef.current = null;
+        scheduleAnimation();
+        return;
+      }
+      pendingPointerAxisRef.current = dockPlacement === "left" ? clientY : clientX;
+      if (!magnifyActiveRef.current) {
         setMagnifyActive(true);
       }
       scheduleAnimation();
@@ -5693,6 +5856,7 @@ function useDockMagnification({
       springsRef.current.delete(anchorKey);
       restCentersRef.current?.delete(anchorKey);
       appliedStylesRef.current.delete(anchorKey);
+      hitBoundsRef.current = null;
       slotOrderRef.current = slotOrderRef.current.filter(
         (key) => key !== anchorKey
       );
@@ -5707,6 +5871,7 @@ function useDockMagnification({
     stopAnimation();
     pendingPointerAxisRef.current = null;
     pointerAxisRef.current = null;
+    entryRampStartedAtRef.current = null;
     lastFrameTimeRef.current = null;
   }, [stopAnimation]);
   const resetMagnification = useCallback8(() => {
@@ -5717,9 +5882,11 @@ function useDockMagnification({
     springsRef.current.clear();
     appliedStylesRef.current.clear();
     restCentersRef.current = null;
+    hitBoundsRef.current = null;
     slotOrderRef.current = [];
     pointerAxisRef.current = null;
     pendingPointerAxisRef.current = null;
+    entryRampStartedAtRef.current = null;
     setMagnifyActive(false);
   }, [setMagnifyActive, slotRefs, stopAnimation]);
   useEffect6(
@@ -5827,13 +5994,67 @@ function orderWorkbenchMinimizedDockNodes(input) {
   }).map(({ node }) => node);
 }
 
+// src/host/minimizedDockStackPromotion.ts
+import { useEffect as useEffect7, useRef as useRef6, useState as useState6 } from "react";
+var minimizedDockStackPromotionDurationMs = 520;
+function detectMinimizedDockStackPromotion(previous, next) {
+  const previousVisibleNodeIds = new Set(
+    previous.filter(
+      (slot) => slot.kind === "node"
+    ).map((slot) => slot.node.id)
+  );
+  const previousStackNodeIds = previous.find((slot) => slot.kind === "stack")?.nodes.map((node) => node.id) ?? [];
+  for (const slot of next) {
+    if (slot.kind !== "node") {
+      continue;
+    }
+    if (!previousVisibleNodeIds.has(slot.node.id) && previousStackNodeIds.includes(slot.node.id)) {
+      return slot.node.id;
+    }
+  }
+  return null;
+}
+function useMinimizedDockStackPromotion(slots) {
+  const previousSlotsRef = useRef6(slots);
+  const promotionTimerRef = useRef6(null);
+  const [promotedNodeId, setPromotedNodeId] = useState6(null);
+  const [stackDispatching, setStackDispatching] = useState6(false);
+  useEffect7(() => {
+    const promotedNodeId2 = detectMinimizedDockStackPromotion(
+      previousSlotsRef.current,
+      slots
+    );
+    previousSlotsRef.current = slots;
+    if (!promotedNodeId2) {
+      return void 0;
+    }
+    setPromotedNodeId(promotedNodeId2);
+    setStackDispatching(true);
+    if (promotionTimerRef.current !== null) {
+      clearTimeout(promotionTimerRef.current);
+    }
+    promotionTimerRef.current = setTimeout(() => {
+      promotionTimerRef.current = null;
+      setPromotedNodeId(null);
+      setStackDispatching(false);
+    }, minimizedDockStackPromotionDurationMs);
+    return () => {
+      if (promotionTimerRef.current !== null) {
+        clearTimeout(promotionTimerRef.current);
+        promotionTimerRef.current = null;
+      }
+    };
+  }, [slots]);
+  return { promotedNodeId, stackDispatching };
+}
+
 // src/host/WorkbenchHostDockPopup.tsx
 import {
   forwardRef,
   useCallback as useCallback9,
-  useEffect as useEffect7,
-  useRef as useRef6,
-  useState as useState6
+  useEffect as useEffect8,
+  useRef as useRef7,
+  useState as useState7
 } from "react";
 import { createPortal as createPortal2 } from "react-dom";
 import { Button as Button3, CloseIcon, FileCreateIcon, cn } from "@tutti-os/ui-system";
@@ -5845,7 +6066,7 @@ var minimizedStackCardWidthPx = 118;
 var minimizedStackLeftPlacementGapPx = 4;
 var minimizedStackLeftDockClearancePx = 2;
 var workbenchLeftDockLeftInsetPx = 4;
-var workbenchLeftDockViewportWidthPx = 104;
+var workbenchLeftDockViewportWidthPx = 124;
 var minimizedStackLeftGutterMinPx = 4;
 var minimizedStackLeftPopupNudgeLeftPx = 60;
 var minimizedStackLeftPopupNudgeDownPx = 32;
@@ -5974,7 +6195,7 @@ var dockPopupGridGapPx = 8;
 var dockPopupPanelPaddingInlinePx = 12;
 var dockPopupPanelBorderInlinePx = 2;
 var dockPopupPlacementGapPx = 14;
-var dockPopupMinimizedStackLaunchDisappearMs = 120;
+var dockPopupMinimizedStackLaunchDisappearMs = 0;
 var dockPopupMinimizedStackPopupZIndex = 100300;
 var popupCardMagnificationRange = 160;
 var popupCardMaxScale = 1.16;
@@ -6036,11 +6257,11 @@ function WorkbenchHostDockPopup({
   const resolvedVariant = variant ?? "default";
   const isMinimizedStack = resolvedVariant === "minimized-stack";
   const createCardCount = showCreateNew === false ? 0 : 1;
-  const cardElementsRef = useRef6(/* @__PURE__ */ new Map());
-  const minimizedStackViewportRef = useRef6(null);
-  const [pointer, setPointer] = useState6(null);
-  const [minimizedStackScrollOffset, setMinimizedStackScrollOffset] = useState6(0);
-  const [capturedPreviewByNodeId, setCapturedPreviewByNodeId] = useState6({});
+  const cardElementsRef = useRef7(/* @__PURE__ */ new Map());
+  const minimizedStackViewportRef = useRef7(null);
+  const [pointer, setPointer] = useState7(null);
+  const [minimizedStackScrollOffset, setMinimizedStackScrollOffset] = useState7(0);
+  const [capturedPreviewByNodeId, setCapturedPreviewByNodeId] = useState7({});
   const columnCount = Math.min(Math.max(items.length + createCardCount, 1), 3);
   const popupWidthPx = columnCount * dockPopupCardWidthPx + Math.max(0, columnCount - 1) * dockPopupGridGapPx + dockPopupPanelPaddingInlinePx * 2 + dockPopupPanelBorderInlinePx;
   const popupCenterY = anchorRect.top + anchorRect.height / 2;
@@ -6118,7 +6339,7 @@ function WorkbenchHostDockPopup({
     },
     []
   );
-  useEffect7(() => {
+  useEffect8(() => {
     if (!isLeftMinimizedStack) {
       return;
     }
@@ -6130,7 +6351,7 @@ function WorkbenchHostDockPopup({
       document.body.removeAttribute("data-desktop-dock-minimized-stack-open");
     };
   }, [isLeftMinimizedStack]);
-  useEffect7(() => {
+  useEffect8(() => {
     const handlePointerDown = (event) => {
       if (!(event.target instanceof Element)) {
         onClose();
@@ -6156,13 +6377,13 @@ function WorkbenchHostDockPopup({
     };
   }, [onClose]);
   const previewCaptureKey = items.map((item) => `${item.node.id}:${item.previewImageUrl ?? ""}`).join("|");
-  useEffect7(() => {
+  useEffect8(() => {
     if (!isMinimizedStack) {
       return;
     }
     setMinimizedStackScrollOffset(initialMinimizedStackScrollOffset);
   }, [initialMinimizedStackScrollOffset, isMinimizedStack, items.length]);
-  useEffect7(() => {
+  useEffect8(() => {
     if (!isMinimizedStack) {
       return;
     }
@@ -6183,7 +6404,7 @@ function WorkbenchHostDockPopup({
     viewport.addEventListener("wheel", handleWheel, { passive: false });
     return () => viewport.removeEventListener("wheel", handleWheel);
   }, [isMinimizedStack, minimizedStackMaxScrollOffset]);
-  useEffect7(() => {
+  useEffect8(() => {
     let cancelled = false;
     const missingItems = items.filter(
       (item) => !item.previewImageUrl && !capturedPreviewByNodeId[item.node.id]
@@ -6404,9 +6625,9 @@ var WorkbenchHostDockPopupCard = forwardRef(function WorkbenchHostDockPopupCard2
 }, ref) {
   const title = item.title?.trim() || item.node.title;
   const isMinimizedStack = variant === "minimized-stack";
-  const [isLaunching, setIsLaunching] = useState6(false);
-  const launchTimerRef = useRef6(null);
-  useEffect7(
+  const [isLaunching, setIsLaunching] = useState7(false);
+  const launchTimerRef = useRef7(null);
+  useEffect8(
     () => () => {
       if (launchTimerRef.current !== null) {
         clearTimeout(launchTimerRef.current);
@@ -6530,7 +6751,12 @@ function stripDockDescriptionTerminalPunctuation(value) {
   return trimmed.replace(/[。．.]+$/u, "");
 }
 function isDockVisualMutationActive(element) {
-  return element?.hasAttribute("data-dock-pointer-active") === true || element?.hasAttribute("data-dock-hover-panel-open") === true;
+  if (!element) {
+    return false;
+  }
+  return element.hasAttribute("data-dock-pointer-active") || element.hasAttribute("data-dock-hover-panel-open") || element.querySelector(
+    '[data-collapsing="true"], [data-presence="entering"], [data-presence="exiting"], [data-stack-dispatching="true"], [data-promoted-from-stack="true"]'
+  ) !== null;
 }
 function WorkbenchHostDock({
   context,
@@ -6550,45 +6776,49 @@ function WorkbenchHostDock({
     () => new Set(context.minimizedNodes.map((node) => node.id)),
     [context.minimizedNodes]
   );
-  const dockMeasureRef = useRef7(null);
-  const dockItemsRef = useRef7(null);
-  const hoverPanelRef = useRef7(null);
-  const hoverPanelCloseTimerRef = useRef7(
+  const dockMeasureRef = useRef8(null);
+  const dockItemsRef = useRef8(null);
+  const hoverPanelRef = useRef8(null);
+  const hoverPanelCloseTimerRef = useRef8(
     null
   );
-  const hoverPanelOpenTimerRef = useRef7(
+  const hoverPanelOpenTimerRef = useRef8(
     null
   );
-  const hoverPanelScheduledPointRef = useRef7(null);
-  const minimizedLaunchTimersRef = useRef7(
-    /* @__PURE__ */ new Map()
-  );
-  const hoverPanelRestTargetRef = useRef7(null);
-  const activeHoverPanelRef = useRef7(
+  const hoverPanelScheduledPointRef = useRef8(null);
+  const hoverPanelRestTargetRef = useRef8(null);
+  const activeHoverPanelRef = useRef8(
     null
   );
-  const pendingDockStateRefreshRef = useRef7(false);
-  const slotRefs = useRef7(/* @__PURE__ */ new Map());
-  const previousAttentionTokenByEntryId = useRef7(/* @__PURE__ */ new Map());
-  const attentionTimeouts = useRef7(
+  const pendingDockStateRefreshRef = useRef8(false);
+  const slotRefs = useRef8(/* @__PURE__ */ new Map());
+  const previousAttentionTokenByEntryId = useRef8(/* @__PURE__ */ new Map());
+  const attentionTimeouts = useRef8(
     /* @__PURE__ */ new Map()
   );
-  const [activeAttentionEntryIds, setActiveAttentionEntryIds] = useState7(/* @__PURE__ */ new Set());
-  const [activePopup, setActivePopup] = useState7(null);
-  const [activeHoverPanel, setActiveHoverPanel] = useState7(null);
-  const [activeMinimizedStackPopup, setActiveMinimizedStackPopup] = useState7(null);
-  const [pendingActionKeys, setPendingActionKeys] = useState7(
+  const [activeAttentionEntryIds, setActiveAttentionEntryIds] = useState8(/* @__PURE__ */ new Set());
+  const [activePopup, setActivePopup] = useState8(null);
+  const [activeHoverPanel, setActiveHoverPanel] = useState8(null);
+  const [activeMinimizedStackPopup, setActiveMinimizedStackPopup] = useState8(null);
+  const [pendingActionKeys, setPendingActionKeys] = useState8(
     () => /* @__PURE__ */ new Set()
   );
-  const [dockFrameSize, setDockFrameSize] = useState7(null);
+  const [dockFrameSize, setDockFrameSize] = useState8(null);
   const { triggerDockBounce } = useDockBounce(slotRefs);
-  const [dockScrollState, setDockScrollState] = useState7(() => ({
+  const [dockScrollState, setDockScrollState] = useState8(() => ({
     canScrollBackward: false,
     canScrollForward: false,
     hasOverflow: false
   }));
-  const [dockStateRevision, setDockStateRevision] = useState7(0);
-  const [externalStateRevision, setExternalStateRevision] = useState7(0);
+  const [dockStateRevision, setDockStateRevision] = useState8(0);
+  const [externalStateRevision, setExternalStateRevision] = useState8(0);
+  const [
+    collapsingMinimizedLaunchAnchorKeys,
+    setCollapsingMinimizedLaunchAnchorKeys
+  ] = useState8(() => /* @__PURE__ */ new Set());
+  const collapsingMinimizedLaunchTimerRef = useRef8(
+    /* @__PURE__ */ new Map()
+  );
   const clearHoverPanelCloseTimer = useCallback10(() => {
     if (hoverPanelCloseTimerRef.current === null) {
       return;
@@ -6604,17 +6834,47 @@ function WorkbenchHostDock({
     hoverPanelOpenTimerRef.current = null;
     hoverPanelScheduledPointRef.current = null;
   }, []);
-  useEffect8(
+  useEffect9(
     () => () => {
       clearHoverPanelCloseTimer();
       clearHoverPanelOpenTimer();
-      for (const timer of minimizedLaunchTimersRef.current.values()) {
+      for (const timer of collapsingMinimizedLaunchTimerRef.current.values()) {
         clearTimeout(timer);
       }
-      minimizedLaunchTimersRef.current.clear();
+      collapsingMinimizedLaunchTimerRef.current.clear();
     },
     [clearHoverPanelCloseTimer, clearHoverPanelOpenTimer]
   );
+  const clearCollapsingMinimizedLaunch = useCallback10((anchorKey) => {
+    const timer = collapsingMinimizedLaunchTimerRef.current.get(anchorKey);
+    if (timer) {
+      clearTimeout(timer);
+      collapsingMinimizedLaunchTimerRef.current.delete(anchorKey);
+    }
+    setCollapsingMinimizedLaunchAnchorKeys((current) => {
+      if (!current.has(anchorKey)) {
+        return current;
+      }
+      const next = new Set(current);
+      next.delete(anchorKey);
+      return next;
+    });
+  }, []);
+  const scheduleCollapsingMinimizedLaunchClear = useCallback10(
+    (anchorKey) => {
+      const existing = collapsingMinimizedLaunchTimerRef.current.get(anchorKey);
+      if (existing) {
+        clearTimeout(existing);
+      }
+      collapsingMinimizedLaunchTimerRef.current.set(
+        anchorKey,
+        setTimeout(() => {
+          clearCollapsingMinimizedLaunch(anchorKey);
+        }, minimizedDockSlotLayoutAnimationMs)
+      );
+    },
+    [clearCollapsingMinimizedLaunch]
+  );
   useLayoutEffect4(() => {
     const element = dockMeasureRef.current;
     if (!element || typeof window === "undefined") {
@@ -6659,7 +6919,7 @@ function WorkbenchHostDock({
     pendingDockStateRefreshRef.current = false;
     setDockStateRevision((revision) => revision + 1);
   }, []);
-  useEffect8(() => {
+  useEffect9(() => {
     if (!dockStateSource) {
       return void 0;
     }
@@ -6693,6 +6953,7 @@ function WorkbenchHostDock({
     }),
     [context.nodes, nodeDefinitions]
   );
+  const { promotedNodeId, stackDispatching } = useMinimizedDockStackPromotion(minimizedDockSlots);
   const dockItems = useMemo5(
     () => createWorkbenchHostDockItems({
       minimizedDockSlots,
@@ -6700,7 +6961,10 @@ function WorkbenchHostDock({
     }),
     [minimizedDockSlots, resolvedEntries]
   );
-  const presentDockItems = useDockPresenceItems(dockItems);
+  const presentDockItems = useDockPresenceItems(
+    dockItems,
+    (nodeId) => context.genie.shouldAnimateMinimizedDockEnter(nodeId)
+  );
   const dockWidth = useMemo5(
     () => resolveWorkbenchHostDockItemsWidth(dockItems),
     [dockItems]
@@ -6726,7 +6990,7 @@ function WorkbenchHostDock({
     }
     dockMeasureRef.current?.removeAttribute("data-dock-hover-panel-open");
   }, []);
-  useEffect8(() => {
+  useEffect9(() => {
     activeHoverPanelRef.current = activeHoverPanel;
   }, [activeHoverPanel]);
   const closeHoverPanelImmediate = useCallback10(
@@ -6857,6 +7121,7 @@ function WorkbenchHostDock({
       hoverPanelRestTargetRef.current = null;
       clearHoverPanelOpenTimer();
       closeHoverPanelImmediate();
+      pauseDockMagnification();
       if (!anchorKey) {
         return false;
       }
@@ -6864,6 +7129,7 @@ function WorkbenchHostDock({
       if (!slotElement) {
         return false;
       }
+      clearSlotMagnification(anchorKey);
       if (slotElement.dataset.collapsing === "true") {
         return true;
       }
@@ -6879,25 +7145,25 @@ function WorkbenchHostDock({
       slotElement.dataset.collapsing = "true";
       return true;
     },
-    [clearHoverPanelOpenTimer, closeHoverPanelImmediate]
+    [
+      clearHoverPanelOpenTimer,
+      clearSlotMagnification,
+      closeHoverPanelImmediate,
+      pauseDockMagnification
+    ]
   );
   const runDockMinimizedLaunchAfterCollapse = useCallback10(
     (anchorKey, launch) => {
-      const shouldDelayLaunch = beginDockMinimizedInteraction(anchorKey);
-      if (!shouldDelayLaunch) {
-        launch();
-        return;
-      }
-      if (minimizedLaunchTimersRef.current.has(anchorKey)) {
-        return;
-      }
-      const timer = setTimeout(() => {
-        minimizedLaunchTimersRef.current.delete(anchorKey);
-        launch();
-      }, dockMinimizedSlotCollapseLaunchDelayMs);
-      minimizedLaunchTimersRef.current.set(anchorKey, timer);
+      beginDockMinimizedInteraction(anchorKey);
+      setCollapsingMinimizedLaunchAnchorKeys((current) => {
+        const next = new Set(current);
+        next.add(anchorKey);
+        return next;
+      });
+      scheduleCollapsingMinimizedLaunchClear(anchorKey);
+      launch();
     },
-    [beginDockMinimizedInteraction]
+    [beginDockMinimizedInteraction, scheduleCollapsingMinimizedLaunchClear]
   );
   const handleDockPointerTravel = useCallback10(
     (clientX, clientY) => {
@@ -6982,7 +7248,7 @@ function WorkbenchHostDock({
       )
     )
   );
-  useEffect8(() => {
+  useEffect9(() => {
     const shouldSubscribe = activePopup !== null || hasMinimizedPreviewCapture;
     if (!shouldSubscribe || !externalStateSource?.subscribe) {
       return void 0;
@@ -6991,7 +7257,7 @@ function WorkbenchHostDock({
       setExternalStateRevision((revision) => revision + 1);
     });
   }, [activePopup, externalStateSource, hasMinimizedPreviewCapture]);
-  useEffect8(() => {
+  useEffect9(() => {
     const nextAttentionIds = /* @__PURE__ */ new Set();
     for (const entry of renderedDockEntries) {
       const nextToken = entry.attentionToken ?? null;
@@ -7032,7 +7298,7 @@ function WorkbenchHostDock({
       );
     }
   }, [renderedDockEntries]);
-  useEffect8(
+  useEffect9(
     () => () => {
       for (const timeout of attentionTimeouts.current.values()) {
         globalThis.clearTimeout(timeout);
@@ -7206,6 +7472,7 @@ function WorkbenchHostDock({
                           "aria-disabled": clickResolution.kind === "blocked" && !resolvedEntry.hasMatchingNodes,
                           className: "desktop-dock__btn",
                           "data-interactive": clickResolution.kind === "blocked" && !resolvedEntry.hasMatchingNodes ? "false" : "true",
+                          title: entry.label,
                           type: "button",
                           onPointerDown: () => {
                             if (clickResolution.kind === "blocked" && !resolvedEntry.hasMatchingNodes) {
@@ -7352,17 +7619,7 @@ function WorkbenchHostDock({
                             closeHoverPanelImmediate(entry.id);
                             handleDockPointerLeave();
                           },
-                          children: hasHoverPanel ? dockButton2 : /* @__PURE__ */ jsxs6(Tooltip, { children: [
-                            /* @__PURE__ */ jsx10(TooltipTrigger, { asChild: true, children: dockButton2 }),
-                            /* @__PURE__ */ jsx10(
-                              TooltipContent,
-                              {
-                                side: dockPlacement === "left" ? "right" : "top",
-                                sideOffset: 26,
-                                children: entry.label
-                              }
-                            )
-                          ] })
+                          children: dockButton2
                         },
                         dockItem.key
                       );
@@ -7378,6 +7635,7 @@ function WorkbenchHostDock({
                           "aria-label": i18n.t("minimizedWindows"),
                           className: "desktop-dock__btn desktop-dock__minimized-btn",
                           "data-interactive": "true",
+                          title: i18n.t("minimizedWindows"),
                           type: "button",
                           onPointerDown: () => {
                             beginDockMinimizedInteraction();
@@ -7453,17 +7711,8 @@ function WorkbenchHostDock({
                           "data-popup-active": stackPopupActive,
                           "data-presence": dockItem.presence,
                           "data-section-id": "minimized",
-                          children: /* @__PURE__ */ jsxs6(Tooltip, { children: [
-                            /* @__PURE__ */ jsx10(TooltipTrigger, { asChild: true, children: stackButton }),
-                            /* @__PURE__ */ jsx10(
-                              TooltipContent,
-                              {
-                                side: dockPlacement === "left" ? "right" : "top",
-                                sideOffset: 26,
-                                children: i18n.t("minimizedWindows")
-                              }
-                            )
-                          ] })
+                          "data-stack-dispatching": stackDispatching ? "true" : void 0,
+                          children: stackButton
                         },
                         dockItem.key
                       );
@@ -7475,6 +7724,7 @@ function WorkbenchHostDock({
                         "aria-label": i18n.t("launch", { title: node.title }),
                         className: "desktop-dock__btn desktop-dock__minimized-btn",
                         "data-interactive": "true",
+                        title: node.title,
                         type: "button",
                         onPointerDown: () => {
                           beginDockMinimizedInteraction(slot.anchorKey);
@@ -7510,22 +7760,14 @@ function WorkbenchHostDock({
                       {
                         ref: registerDockSlot(slot.anchorKey),
                         className: "desktop-dock__slot desktop-dock__slot--minimized",
+                        "data-collapsing": collapsingMinimizedLaunchAnchorKeys.has(slot.anchorKey) ? "true" : void 0,
                         "data-desktop-dock-anchor-key": slot.anchorKey,
                         "data-desktop-dock-slot": "true",
                         "data-node-state": "minimized",
                         "data-presence": dockItem.presence,
+                        "data-promoted-from-stack": promotedNodeId === node.id ? "true" : void 0,
                         "data-section-id": "minimized",
-                        children: /* @__PURE__ */ jsxs6(Tooltip, { children: [
-                          /* @__PURE__ */ jsx10(TooltipTrigger, { asChild: true, children: dockButton }),
-                          /* @__PURE__ */ jsx10(
-                            TooltipContent,
-                            {
-                              side: dockPlacement === "left" ? "right" : "top",
-                              sideOffset: 26,
-                              children: node.title
-                            }
-                          )
-                        ] })
+                        children: dockButton
                       },
                       dockItem.key
                     );
@@ -7698,13 +7940,15 @@ function WorkbenchHostDock({
             onCreateNew: () => void 0,
             onSelectNode: (nodeId) => {
               closePopup();
-              context.genie.launchNodeFromAnchor(
-                activeMinimizedStackSlot.anchorKey,
+              const anchorKey = resolveWorkbenchMinimizedDockAnchorKeyForNode({
                 nodeId,
-                () => {
+                slots: minimizedDockSlots
+              }) ?? activeMinimizedStackSlot.anchorKey;
+              runDockMinimizedLaunchAfterCollapse(anchorKey, () => {
+                context.genie.launchNodeFromAnchor(anchorKey, nodeId, () => {
                   host.focusNode(nodeId);
-                }
-              );
+                });
+              });
             },
             showCreateNew: false,
             resolveDockPreviewCacheKey: (node) => resolveDockPreviewCacheKey(workspaceId, node),
@@ -7722,10 +7966,10 @@ function WorkbenchHostDockMinimizedNodePreview({
   node,
   workspaceId
 }) {
-  const [previewImageUrl, setPreviewImageUrl] = useState7(
+  const [previewImageUrl, setPreviewImageUrl] = useState8(
     () => readCachedWorkbenchNodePreviewImage(node.id)
   );
-  useEffect8(() => {
+  useEffect9(() => {
     let cancelled = false;
     const cachedPreviewImageUrl = readCachedWorkbenchNodePreviewImage(node.id);
     setPreviewImageUrl(cachedPreviewImageUrl);
@@ -7980,19 +8224,48 @@ function createWorkbenchHostDockItems({
   }
   return items;
 }
-function useDockPresenceItems(items) {
-  const latestItemsByKey = useRef7(/* @__PURE__ */ new Map());
+function resolveMinimizedDockItemNodeId(item) {
+  if (item.kind !== "minimized" || item.slot.kind !== "node") {
+    return null;
+  }
+  return item.slot.node.id;
+}
+function resolveNextDockItemPresence(item, initialized, previousPresence, shouldAnimateMinimizedDockEnter) {
+  if (!initialized) {
+    return "present";
+  }
+  if (item.key === "separator:minimized") {
+    return "present";
+  }
+  if (item.kind === "minimized") {
+    const nodeId = resolveMinimizedDockItemNodeId(item);
+    if (nodeId && shouldAnimateMinimizedDockEnter(nodeId)) {
+      if (previousPresence === "exiting") {
+        return "entering";
+      }
+      return previousPresence ?? "entering";
+    }
+    return "present";
+  }
+  if (previousPresence === "exiting") {
+    return "entering";
+  }
+  return previousPresence ?? "entering";
+}
+function useDockPresenceItems(items, shouldAnimateMinimizedDockEnter) {
+  const latestItemsByKey = useRef8(/* @__PURE__ */ new Map());
   latestItemsByKey.current = new Map(items.map((item) => [item.key, item]));
   const itemKeys = items.map((item) => item.key).join("\0");
-  const [presentItems, setPresentItems] = useState7(
+  const [presentItems, setPresentItems] = useState8(
     () => items.map((item) => ({
       item,
       key: item.key,
       presence: "present"
     }))
   );
-  const initialized = useRef7(false);
-  useEffect8(() => {
+  const initialized = useRef8(false);
+  useEffect9(() => {
+    let nextSettleMs = dockPresenceAnimationMs;
     setPresentItems((current) => {
       const nextSourceItems = [...latestItemsByKey.current.values()];
       const currentByKey = new Map(current.map((item) => [item.key, item]));
@@ -8033,7 +8306,12 @@ function useDockPresenceItems(items) {
         nextItems.push({
           item,
           key: item.key,
-          presence: initialized.current ? currentByKey.get(item.key)?.presence === "exiting" ? "entering" : currentByKey.get(item.key)?.presence ?? "entering" : "present"
+          presence: resolveNextDockItemPresence(
+            item,
+            initialized.current,
+            currentByKey.get(item.key)?.presence,
+            shouldAnimateMinimizedDockEnter
+          )
         });
       }
       for (const currentItem of current) {
@@ -8048,9 +8326,15 @@ function useDockPresenceItems(items) {
           });
         }
       }
-      return nextItems.filter(
+      const filteredItems = nextItems.filter(
         (item) => nextByKey.has(item.key) || item.presence === "exiting"
       );
+      if (filteredItems.some(
+        (item) => item.item.kind === "minimized" && (item.presence === "entering" || item.presence === "exiting")
+      )) {
+        nextSettleMs = minimizedDockSlotLayoutAnimationMs;
+      }
+      return filteredItems;
     });
     initialized.current = true;
     const timeout = globalThis.setTimeout(() => {
@@ -8059,18 +8343,17 @@ function useDockPresenceItems(items) {
           (item) => item.presence === "entering" ? { ...item, presence: "present" } : item
         )
       );
-    }, dockPresenceAnimationMs);
+    }, nextSettleMs);
     return () => globalThis.clearTimeout(timeout);
-  }, [itemKeys]);
+  }, [itemKeys, shouldAnimateMinimizedDockEnter]);
   return presentItems.map((presentItem) => {
     const latestItem = latestItemsByKey.current.get(presentItem.key);
     return latestItem ? { ...presentItem, item: latestItem } : presentItem;
   });
 }
 var DOCK_BOUNCE_MS = 600;
-var dockMinimizedSlotCollapseLaunchDelayMs = 260;
 function useDockBounce(slotRefs) {
-  const timeoutsRef = useRef7(/* @__PURE__ */ new Map());
+  const timeoutsRef = useRef8(/* @__PURE__ */ new Map());
   const clearDockBounce = useCallback10(
     (anchorKey) => {
       const timeout = timeoutsRef.current.get(anchorKey);
@@ -8085,7 +8368,7 @@ function useDockBounce(slotRefs) {
     },
     [slotRefs]
   );
-  useEffect8(
+  useEffect9(
     () => () => {
       for (const anchorKey of timeoutsRef.current.keys()) {
         clearDockBounce(anchorKey);
@@ -8131,6 +8414,7 @@ var dockHoverPanelOpenDelayMs = 450;
 var dockHoverPanelHitSlopPx = 12;
 var dockHoverPanelPointerRestTolerancePx = 4;
 var dockPresenceAnimationMs = 300;
+var minimizedDockSlotLayoutAnimationMs = 720;
 var dockItemsGapPx = 10.8;
 var dockItemsHorizontalPaddingPx = 12.6;
 var dockSeparatorOuterWidthPx = 8.1;
@@ -8644,6 +8928,7 @@ export {
   createWorkbenchSnapshotFromState,
   createWorkbenchStateFromSnapshot,
   createWorkbenchWindowChromeI18nRuntime,
+  getWorkbenchLayoutFrame,
   resolveWorkbenchHostPrepareClose,
   useWorkbenchSelector,
   workbenchFocusInputActivationType,