@tutti-os/workbench-surface 0.0.17 → 0.0.19

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   workbenchHostI18nResources,
   workbenchWindowChromeI18nNamespace,
   workbenchWindowChromeI18nResources
-} from "./chunk-64XVF4I6.js";
+} from "./chunk-B5MSA47V.js";
 
 // src/store/commands.ts
 function createWorkbenchCommands(store) {
@@ -1417,6 +1417,7 @@ var inactiveMissionControlSnapshotSource = {
 function useWorkbenchMissionControlState({
   adapter,
   mode,
+  nodeIds,
   onRequestClose
 }) {
   const isActive = mode !== null && adapter !== null;
@@ -1432,7 +1433,17 @@ function useWorkbenchMissionControlState({
   );
   const layoutConstraints = snapshot?.layoutConstraints ?? defaultWorkbenchLayoutConstraints;
   const surfaceSize = snapshot?.surfaceSize ?? defaultWorkbenchSurfaceSize;
-  const visibleNodes = snapshot?.visibleNodes ?? [];
+  const scopedNodeIdSet = useMemo(
+    () => nodeIds === void 0 ? null : new Set(nodeIds),
+    [nodeIds]
+  );
+  const visibleNodes = useMemo(() => {
+    const nextVisibleNodes = snapshot?.visibleNodes ?? [];
+    if (scopedNodeIdSet === null) {
+      return nextVisibleNodes;
+    }
+    return nextVisibleNodes.filter((node) => scopedNodeIdSet.has(node.id));
+  }, [scopedNodeIdSet, snapshot?.visibleNodes]);
   const [selectedNodeIds, setSelectedNodeIds] = useState3([]);
   useEffect(() => {
     if (mode === null) {
@@ -1511,13 +1522,13 @@ function useWorkbenchMissionControlState({
     [adapter, onRequestClose]
   );
   const applyLayoutAndClose = useCallback2(
-    (nodeIds, nextPreset) => {
-      if (!adapter || nodeIds.length < 2) {
+    (nodeIds2, nextPreset) => {
+      if (!adapter || nodeIds2.length < 2) {
         return;
       }
       onRequestClose();
       window.requestAnimationFrame(() => {
-        adapter.applyLayoutPreset(nodeIds, nextPreset);
+        adapter.applyLayoutPreset(nodeIds2, nextPreset);
       });
     },
     [adapter, onRequestClose]
@@ -1561,9 +1572,17 @@ function useWorkbenchMissionControlState({
         onNodePress: onPreviewPress,
         selectedNodeIds: selectedNodeIdSet
       },
-      mode: "mission-control"
+      mode: "mission-control",
+      visibleNodeIds: new Set(orderedNodes.map((node) => node.id))
     },
-    [mode, onPreviewPress, onRequestClose, previewItems, selectedNodeIdSet]
+    [
+      mode,
+      onPreviewPress,
+      onRequestClose,
+      orderedNodes,
+      previewItems,
+      selectedNodeIdSet
+    ]
   );
   useEffect(() => {
     if (mode === null) {
@@ -1708,9 +1727,16 @@ function WorkbenchDockFrame({
   const nodes = useWorkbenchSelector(
     selectDockNodes
   );
+  const minimizedNodesWithPending = useMemo2(
+    () => mergePendingMinimizedDockNode(
+      nodes.filter((node) => node.isMinimized),
+      genie.pendingMinimizedNode
+    ),
+    [genie.pendingMinimizedNode, nodes]
+  );
   const minimizedNodes = useMemo2(
-    () => nodes.filter((node) => node.isMinimized),
-    [nodes]
+    () => minimizedNodesWithPending.filter((node) => node.isMinimized),
+    [minimizedNodesWithPending]
   );
   const focusedNodeId = useWorkbenchSelector(
     (state) => selectFocusedWorkbenchNode(state)?.id ?? null
@@ -1752,6 +1778,9 @@ function WorkbenchDockFrame({
             },
             shouldAnimateMinimizedDockEnter: (nodeID) => {
               return genie.shouldAnimateMinimizedDockEnter(nodeID);
+            },
+            isPendingMinimizedDockNode: (nodeID) => {
+              return genie.isPendingMinimizedDockNode(nodeID);
             }
           },
           minimizedNodes,
@@ -1761,6 +1790,16 @@ function WorkbenchDockFrame({
     )
   ] });
 }
+function mergePendingMinimizedDockNode(nodes, pendingNode) {
+  if (!pendingNode) {
+    return nodes;
+  }
+  const existingNode = nodes.find((node) => node.id === pendingNode.id);
+  if (existingNode?.isMinimized) {
+    return nodes;
+  }
+  return [...nodes.filter((node) => node.id !== pendingNode.id), pendingNode];
+}
 
 // src/react/WorkbenchNodeLayer.tsx
 import { memo, useMemo as useMemo3 } from "react";
@@ -2086,7 +2125,8 @@ function WorkbenchWindowFrame({
   const resolvedFullscreenHeaderMode = fullscreenHeaderMode ?? "reveal";
   const presentationMode = presentation?.mode ?? null;
   const presentationFrame = presentation?.frameByNodeId.get(node.id) ?? null;
-  const presentationInteraction = interactive && presentationMode === "mission-control" ? presentation?.interaction ?? null : null;
+  const isPresentationHidden = presentationMode === "mission-control" && !presentation?.visibleNodeIds.has(node.id);
+  const presentationInteraction = interactive && presentationMode === "mission-control" && !isPresentationHidden ? presentation?.interaction ?? null : null;
   const isMissionControlSelected = presentationInteraction?.selectedNodeIds.has(node.id) ?? false;
   const presentationScale = presentationMode === "mission-control" && presentationFrame ? Math.min(
     presentationFrame.width / Math.max(1, node.frame.width),
@@ -2100,11 +2140,11 @@ function WorkbenchWindowFrame({
     0,
     (presentationFrame.height - node.frame.height * presentationScale) / 2
   ) - node.frame.y : 0;
-  const shellTransform = presentationMode === "mission-control" ? `matrix(${presentationScale}, 0, 0, ${presentationScale}, ${presentationOffsetX}, ${presentationOffsetY})` : void 0;
+  const shellTransform = presentationMode === "mission-control" && presentationFrame ? `matrix(${presentationScale}, 0, 0, ${presentationScale}, ${presentationOffsetX}, ${presentationOffsetY})` : void 0;
   return /* @__PURE__ */ jsxs2(
     "section",
     {
-      "aria-hidden": hiddenMounted ? true : void 0,
+      "aria-hidden": hiddenMounted || isPresentationHidden ? true : void 0,
       className: "workbench-window-shell",
       "data-focused": isFocused ? "true" : "false",
       "data-display-mode": node.displayMode,
@@ -2112,6 +2152,7 @@ function WorkbenchWindowFrame({
       "data-launch-source": resolveWorkbenchNodeLaunchSource(node.data),
       "data-minimized-mount": hiddenMounted ? "hidden" : "visible",
       "data-presentation-mode": presentationMode ?? "default",
+      "data-presentation-visibility": isPresentationHidden ? "hidden" : "visible",
       "data-slot": "viewport-menu-boundary",
       "data-workbench-node-type-id": resolveWorkbenchNodeTypeId(node.data),
       "data-workbench-window-id": node.id,
@@ -2126,7 +2167,7 @@ function WorkbenchWindowFrame({
         width: node.frame.width,
         zIndex
       },
-      onPointerDown: hiddenMounted || !interactive || presentationMode === "mission-control" ? void 0 : () => controller.commands.focusNode(node.id),
+      onPointerDown: hiddenMounted || isPresentationHidden || !interactive || presentationMode === "mission-control" ? void 0 : () => controller.commands.focusNode(node.id),
       children: [
         /* @__PURE__ */ jsx5("div", { className: "workbench-window-shell__content", children: /* @__PURE__ */ jsxs2(
           "div",
@@ -2505,41 +2546,143 @@ function resolveGenieDirtyRect({
     width: Math.max(0, right - left)
   };
 }
+function resolveGenieRowProgress({
+  direction,
+  progress,
+  rowProgress,
+  stagger
+}) {
+  const start = direction === "minimize" ? (1 - rowProgress) * stagger : rowProgress * stagger;
+  return clampGenieProgress((progress - start) / (1 - start));
+}
+function resolveGenieRowTargetY({
+  direction,
+  dockPoint,
+  progress,
+  sourceY,
+  textureHeight,
+  textureRect
+}) {
+  const rowProgress = clampGenieProgress(sourceY / textureHeight);
+  const verticalProgress = resolveGenieRowProgress({
+    direction,
+    progress,
+    rowProgress,
+    stagger: genieVerticalRowStagger
+  });
+  const verticalEase = easeInQuadratic(verticalProgress);
+  return direction === "minimize" ? lerpGenieValue(textureRect.top + sourceY, dockPoint.y, verticalEase) : lerpGenieValue(dockPoint.y, textureRect.top + sourceY, verticalEase);
+}
 function canInlineComputedStyle(element) {
   return element instanceof HTMLElement || typeof SVGElement !== "undefined" && element instanceof SVGElement;
 }
-function copyGenieComputedStyleTree(source, clone) {
-  if (canInlineComputedStyle(source) && canInlineComputedStyle(clone)) {
-    const computed = window.getComputedStyle(source);
-    if (computed.cssText) {
-      clone.style.cssText = computed.cssText;
-    } else {
-      for (let index = 0; index < computed.length; index += 1) {
-        const propertyName = computed.item(index);
-        if (!propertyName) {
-          continue;
-        }
-        clone.style.setProperty(
-          propertyName,
-          computed.getPropertyValue(propertyName),
-          computed.getPropertyPriority(propertyName)
-        );
-      }
+function isHiddenForGenieTexture(computed) {
+  return computed.display === "none" || computed.visibility === "hidden" || computed.visibility === "collapse" || Number.parseFloat(computed.opacity || "1") <= 0;
+}
+function rectsIntersect(a, b) {
+  return a.left < b.left + b.width && a.left + a.width > b.left && a.top < b.top + b.height && a.top + a.height > b.top;
+}
+function resolveElementSkipReasonForGenieTexture(element, rootRect, computed) {
+  if (isHiddenForGenieTexture(computed)) {
+    return "hidden";
+  }
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "script" || tagName === "style" || tagName === "template") {
+    return "unsupported";
+  }
+  const rect = element.getBoundingClientRect();
+  if (rect.width <= 0 || rect.height <= 0) {
+    return "zero-size";
+  }
+  return rectsIntersect(
+    {
+      height: rect.height,
+      left: rect.left,
+      top: rect.top,
+      width: rect.width
+    },
+    rootRect
+  ) ? null : "offscreen";
+}
+function hasMeaningfulTextNode(node) {
+  return node.textContent?.trim() ? true : false;
+}
+function cloneMeaningfulGenieNode(source, rootRect, images, forceInclude = false) {
+  if (source.nodeType === Node.TEXT_NODE) {
+    if (!hasMeaningfulTextNode(source)) {
+      return null;
+    }
+    return source.cloneNode(false);
+  }
+  if (source.nodeType !== Node.ELEMENT_NODE) {
+    return null;
+  }
+  const sourceElement = source;
+  if (!canInlineComputedStyle(sourceElement)) {
+    return null;
+  }
+  const computed = window.getComputedStyle(sourceElement);
+  const skipReason = resolveElementSkipReasonForGenieTexture(
+    sourceElement,
+    rootRect,
+    computed
+  );
+  const includeSelf = forceInclude || skipReason === null;
+  if (!includeSelf && skipReason === "hidden") {
+    return null;
+  }
+  const clone = sourceElement.cloneNode(false);
+  copyGenieComputedStyle(sourceElement, clone, computed);
+  for (const child of Array.from(source.childNodes)) {
+    const childClone = cloneMeaningfulGenieNode(child, rootRect, images);
+    if (childClone) {
+      clone.appendChild(childClone);
     }
-    clone.style.animation = "none";
-    clone.style.opacity = "1";
-    clone.style.transition = "none";
-    clone.style.visibility = "visible";
   }
-  const sourceChildren = Array.from(source.children);
-  const cloneChildren = Array.from(clone.children);
-  for (let index = 0; index < sourceChildren.length; index += 1) {
-    const sourceChild = sourceChildren[index];
-    const cloneChild = cloneChildren[index];
-    if (sourceChild && cloneChild) {
-      copyGenieComputedStyleTree(sourceChild, cloneChild);
+  if (!includeSelf && clone.childNodes.length === 0) {
+    return null;
+  }
+  if (sourceElement instanceof HTMLImageElement) {
+    const rect = sourceElement.getBoundingClientRect();
+    images.push({
+      displayHeight: rect.height,
+      displayWidth: rect.width,
+      url: sourceElement.currentSrc || sourceElement.src || sourceElement.getAttribute("src") || null
+    });
+  }
+  return clone;
+}
+function copyGenieComputedStyle(source, clone, computed = window.getComputedStyle(source)) {
+  if (!canInlineComputedStyle(source) || !canInlineComputedStyle(clone)) {
+    return;
+  }
+  if (computed.cssText) {
+    clone.style.cssText = computed.cssText;
+  } else {
+    for (let index = 0; index < computed.length; index += 1) {
+      const propertyName = computed.item(index);
+      if (!propertyName) {
+        continue;
+      }
+      clone.style.setProperty(
+        propertyName,
+        computed.getPropertyValue(propertyName),
+        computed.getPropertyPriority(propertyName)
+      );
     }
   }
+  clone.style.animation = "none";
+  clone.style.opacity = "1";
+  clone.style.transition = "none";
+  clone.style.visibility = "visible";
+}
+function cloneMeaningfulGenieElement(source, rootRect) {
+  const images = [];
+  const clone = cloneMeaningfulGenieNode(source, rootRect, images, true);
+  if (!(clone instanceof HTMLElement)) {
+    return null;
+  }
+  return { clone, images };
 }
 function renderGenieScanlines(context, viewportWidth, viewportHeight, frame) {
   const { direction, dockPoint, texture, textureRect } = frame;
@@ -2563,16 +2706,13 @@ function renderGenieScanlines(context, viewportWidth, viewportHeight, frame) {
     const sourceHeight = Math.min(scanlineStride, textureHeight - y);
     const sourceMidY = y + sourceHeight / 2;
     const rowProgress = sourceMidY / textureHeight;
-    const horizontalStart = direction === "minimize" ? (1 - rowProgress) * genieHorizontalRowStagger : rowProgress * genieHorizontalRowStagger;
-    const horizontalProgress = clampGenieProgress(
-      (progress - horizontalStart) / (1 - horizontalStart)
-    );
+    const horizontalProgress = resolveGenieRowProgress({
+      direction,
+      progress,
+      rowProgress,
+      stagger: genieHorizontalRowStagger
+    });
     const horizontalEase = easeInOutCubic(horizontalProgress);
-    const verticalStart = direction === "minimize" ? (1 - rowProgress) * genieVerticalRowStagger : rowProgress * genieVerticalRowStagger;
-    const verticalProgress = clampGenieProgress(
-      (progress - verticalStart) / (1 - verticalStart)
-    );
-    const verticalEase = easeInQuadratic(verticalProgress);
     const left = direction === "minimize" ? lerpGenieValue(textureRect.left, dockPoint.x, horizontalEase) : lerpGenieValue(dockPoint.x, textureRect.left, horizontalEase);
     const right = direction === "minimize" ? lerpGenieValue(
       textureRect.left + textureWidth,
@@ -2583,15 +2723,24 @@ function renderGenieScanlines(context, viewportWidth, viewportHeight, frame) {
       textureRect.left + textureWidth,
       horizontalEase
     );
-    const targetY = (direction === "minimize" ? lerpGenieValue(
-      textureRect.top + sourceMidY,
-      dockPoint.y,
-      verticalEase
-    ) : lerpGenieValue(
-      dockPoint.y,
-      textureRect.top + sourceMidY,
-      verticalEase
-    )) - sourceHeight / 2;
+    const targetTop = resolveGenieRowTargetY({
+      direction,
+      dockPoint,
+      progress,
+      sourceY: y,
+      textureHeight,
+      textureRect
+    });
+    const targetBottom = resolveGenieRowTargetY({
+      direction,
+      dockPoint,
+      progress,
+      sourceY: y + sourceHeight,
+      textureHeight,
+      textureRect
+    });
+    const targetY = Math.min(targetTop, targetBottom) - 0.5;
+    const targetHeight = Math.max(1, Math.abs(targetBottom - targetTop) + 1);
     const rowWidth = right - left;
     if (rowWidth < 0.8) {
       continue;
@@ -2605,7 +2754,7 @@ function renderGenieScanlines(context, viewportWidth, viewportHeight, frame) {
       left,
       targetY,
       rowWidth,
-      Math.max(1, sourceHeight)
+      targetHeight
     );
   }
   const glowProgress = direction === "minimize" ? progress : 1 - progress;
@@ -2635,6 +2784,7 @@ function renderGenieScanlines(context, viewportWidth, viewportHeight, frame) {
 // src/react/useWorkbenchGenieAnimation.tsx
 import { jsx as jsx7 } from "react/jsx-runtime";
 var genieDurationMs = 400;
+var scaleMinimizeDurationMs = 220;
 var genieMaxDevicePixelRatio = 2;
 var genieSnapshotScale = 1;
 var minimizedDockSlotEnterAnimationMs = 720;
@@ -2643,6 +2793,7 @@ var dockPreviewMaxHeight = 170;
 var dockPreviewImageCacheMaxEntries = 96;
 var inlineImageResourceCacheMaxEntries = 160;
 var dockAnchorFallbackSizePx = 43.2;
+var genieInlineImageMaxDevicePixelRatio = 2;
 var dockPreviewImageByNodeID = /* @__PURE__ */ new Map();
 var inlineImageResourceByUrl = /* @__PURE__ */ new Map();
 function resolveWorkbenchCaptureElement(windowElement) {
@@ -2683,9 +2834,6 @@ function blobToDataUrl(blob) {
     reader.readAsDataURL(blob);
   });
 }
-function resolveImageResourceUrl(image) {
-  return image.currentSrc || image.src || image.getAttribute("src") || null;
-}
 async function fetchInlineImageResource(imageUrl) {
   try {
     const response = await fetch(imageUrl);
@@ -2721,21 +2869,31 @@ function readInlineImageResource(imageUrl) {
 }
 async function inlineCloneImageResources({
   cloneRoot,
-  imageUrls
+  images
 }) {
   const cloneImages = Array.from(cloneRoot.querySelectorAll("img"));
   await Promise.all(
-    imageUrls.map(async (imageUrl, index) => {
+    images.map(async (imageInfo, index) => {
       const cloneImage = cloneImages[index];
       if (!cloneImage) {
         return;
       }
       cloneImage.removeAttribute("srcset");
       cloneImage.removeAttribute("sizes");
+      const imageUrl = imageInfo.url;
       if (!imageUrl) {
         return;
       }
-      cloneImage.src = await readInlineImageResource(imageUrl) ?? imageUrl;
+      const inlineImageUrl = await readInlineImageResource(imageUrl) ?? imageUrl;
+      const resizedImageUrl = await resizeInlineImageResourceForGenieTexture(
+        inlineImageUrl,
+        imageInfo
+      );
+      if (resizedImageUrl && resizedImageUrl !== inlineImageUrl) {
+        cloneImage.src = resizedImageUrl;
+        return;
+      }
+      cloneImage.src = inlineImageUrl;
     })
   );
 }
@@ -2745,16 +2903,61 @@ async function loadImageFromSvg(svg) {
   await image.decode();
   return image;
 }
+function resolveGenieInlineImageTargetSize({
+  displayHeight,
+  displayWidth
+}) {
+  if (displayWidth <= 0 || displayHeight <= 0) {
+    return null;
+  }
+  const scale = Math.min(
+    window.devicePixelRatio || 1,
+    genieInlineImageMaxDevicePixelRatio
+  );
+  return {
+    height: Math.max(1, Math.ceil(displayHeight * scale)),
+    width: Math.max(1, Math.ceil(displayWidth * scale))
+  };
+}
+async function resizeInlineImageResourceForGenieTexture(imageUrl, imageInfo) {
+  const targetSize = resolveGenieInlineImageTargetSize(imageInfo);
+  if (!targetSize) {
+    return null;
+  }
+  const image = new Image();
+  image.src = imageUrl;
+  try {
+    await image.decode();
+  } catch {
+    return null;
+  }
+  if (image.naturalWidth <= targetSize.width && image.naturalHeight <= targetSize.height) {
+    return null;
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = targetSize.width;
+  canvas.height = targetSize.height;
+  const context = canvas.getContext("2d");
+  if (!context) {
+    return null;
+  }
+  try {
+    context.drawImage(image, 0, 0, targetSize.width, targetSize.height);
+    return canvas.toDataURL("image/png");
+  } catch {
+    return null;
+  }
+}
 function prepareElementTextureCapture(element) {
   const windowRect = viewportRectFromElement(element);
   if (!isUsableGenieRect(windowRect)) {
     return null;
   }
-  const imageUrls = Array.from(element.querySelectorAll("img")).map(
-    resolveImageResourceUrl
-  );
-  const clone = element.cloneNode(true);
-  copyGenieComputedStyleTree(element, clone);
+  const clonedElement = cloneMeaningfulGenieElement(element, windowRect);
+  if (!clonedElement) {
+    return null;
+  }
+  const { clone, images } = clonedElement;
   clone.setAttribute("xmlns", "http://www.w3.org/1999/xhtml");
   clone.style.position = "relative";
   clone.style.left = "0";
@@ -2765,15 +2968,23 @@ function prepareElementTextureCapture(element) {
   clone.style.opacity = "1";
   clone.style.visibility = "visible";
   clone.style.pointerEvents = "none";
-  return { clone, imageUrls, rect: windowRect };
+  return {
+    clone,
+    images,
+    rect: windowRect
+  };
 }
 async function renderPreparedElementTexture({
   clone,
-  imageUrls,
+  images,
   rect
 }) {
-  await inlineCloneImageResources({ cloneRoot: clone, imageUrls });
-  const image = await loadImageFromSvg(createGenieSvgTexture(clone, rect));
+  await inlineCloneImageResources({
+    cloneRoot: clone,
+    images
+  });
+  const svgTexture = createGenieSvgTexture(clone, rect);
+  const image = await loadImageFromSvg(svgTexture);
   const canvas = document.createElement("canvas");
   canvas.width = Math.max(1, Math.round(rect.width * genieSnapshotScale));
   canvas.height = Math.max(1, Math.round(rect.height * genieSnapshotScale));
@@ -2864,20 +3075,16 @@ async function captureWorkbenchNodePreviewImage(nodeID, options = {}) {
   writeCachedWorkbenchNodePreviewImage(nodeID, previewImageUrl);
   return previewImageUrl;
 }
-async function captureWorkbenchNodePreviewImageForNode(node, input = {}) {
+async function captureProvidedWorkbenchNodePreviewImageForNode(node, input = {}) {
   const previewImageUrl = await Promise.resolve(
     input.captureNodePreviewImage?.(node) ?? null
   ).catch(() => null);
-  if (previewImageUrl) {
-    writeCachedWorkbenchNodePreviewImage(node.id, previewImageUrl);
-    persistWorkbenchNodePreviewImage(node, previewImageUrl, input);
-    return previewImageUrl;
+  if (!previewImageUrl) {
+    return null;
   }
-  const capturedPreviewImageUrl = await captureWorkbenchNodePreviewImage(
-    node.id
-  );
-  persistWorkbenchNodePreviewImage(node, capturedPreviewImageUrl, input);
-  return capturedPreviewImageUrl;
+  writeCachedWorkbenchNodePreviewImage(node.id, previewImageUrl);
+  persistWorkbenchNodePreviewImage(node, previewImageUrl, input);
+  return previewImageUrl;
 }
 function persistWorkbenchNodePreviewImage(node, previewImageUrl, input) {
   if (!previewImageUrl || !input.dockPreviewCache) {
@@ -2917,8 +3124,10 @@ function useWorkbenchGenieAnimation({
   captureNodePreviewImage,
   controller,
   dockPreviewCache,
+  minimizeAnimation = "genie",
   resolveDockAnchorKey,
-  resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2
+  resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2,
+  shouldCaptureNodePreviewImage
 }) {
   const dockAnchorElementsRef = useRef4(/* @__PURE__ */ new Map());
   const canvasRef = useRef4(null);
@@ -2933,6 +3142,7 @@ function useWorkbenchGenieAnimation({
   const [genieHiddenNodeIDs, setGenieHiddenNodeIDs] = useState4(
     () => /* @__PURE__ */ new Set()
   );
+  const [pendingMinimizedNode, setPendingMinimizedNode] = useState4(null);
   const registerDockAnchor = useCallback6(
     (anchorKey, element) => {
       if (element) {
@@ -3008,6 +3218,11 @@ function useWorkbenchGenieAnimation({
       return next;
     });
   }, []);
+  const clearPendingMinimizedNode = useCallback6((nodeID) => {
+    setPendingMinimizedNode(
+      (current) => current?.id === nodeID ? null : current
+    );
+  }, []);
   const setupCanvas = useCallback6(() => {
     const canvas = canvasRef.current;
     if (!canvas) {
@@ -3120,10 +3335,102 @@ function useWorkbenchGenieAnimation({
     },
     [setupCanvas, stopAnimation]
   );
+  const runScaleWindowAnimation = useCallback6(
+    ({
+      direction,
+      dockRect,
+      nodeElement,
+      onCancel,
+      onComplete,
+      skipStop
+    }) => {
+      if (!skipStop) {
+        stopAnimation();
+      }
+      const windowRect = viewportRectFromElement(nodeElement);
+      if (!isUsableGenieRect(windowRect) || !isUsableGenieRect(dockRect)) {
+        onComplete();
+        return;
+      }
+      const generation = animationGenerationRef.current;
+      const fromCenter = centerPointFromRect(windowRect);
+      const toCenter = centerPointFromRect(dockRect);
+      const targetScale = Math.max(
+        0.04,
+        Math.min(
+          0.32,
+          dockRect.width / Math.max(1, windowRect.width),
+          dockRect.height / Math.max(1, windowRect.height)
+        )
+      );
+      const previousPointerEvents = nodeElement.style.pointerEvents;
+      const previousTransformOrigin = nodeElement.style.transformOrigin;
+      const previousVisibility = nodeElement.style.visibility;
+      const previousZIndex = nodeElement.style.zIndex;
+      nodeElement.style.pointerEvents = "none";
+      nodeElement.style.transformOrigin = "center center";
+      nodeElement.style.visibility = "visible";
+      nodeElement.style.zIndex = "var(--z-workbench-genie)";
+      const dockTransform = `translate3d(${toCenter.x - fromCenter.x}px, ${toCenter.y - fromCenter.y}px, 0) scale(${targetScale})`;
+      const windowTransform = "translate3d(0, 0, 0) scale(1)";
+      const keyframes = direction === "open" ? [
+        {
+          opacity: 0,
+          transform: dockTransform
+        },
+        {
+          opacity: 1,
+          transform: windowTransform
+        }
+      ] : [
+        {
+          opacity: 1,
+          transform: windowTransform
+        },
+        {
+          opacity: 0,
+          transform: dockTransform
+        }
+      ];
+      const animation = nodeElement.animate(keyframes, {
+        duration: scaleMinimizeDurationMs,
+        easing: "cubic-bezier(0.4, 0, 0.2, 1)",
+        fill: "forwards"
+      });
+      const restoreElement = () => {
+        animation.cancel();
+        nodeElement.style.pointerEvents = previousPointerEvents;
+        nodeElement.style.transformOrigin = previousTransformOrigin;
+        nodeElement.style.visibility = previousVisibility;
+        nodeElement.style.zIndex = previousZIndex;
+      };
+      animationCleanupRef.current = () => {
+        restoreElement();
+        onCancel();
+      };
+      animation.finished.then(() => {
+        if (generation !== animationGenerationRef.current) {
+          return;
+        }
+        animationCleanupRef.current = null;
+        restoreElement();
+        onComplete();
+      }).catch(() => {
+        if (generation !== animationGenerationRef.current) {
+          return;
+        }
+        animationCleanupRef.current = null;
+        restoreElement();
+        onComplete();
+      });
+    },
+    [stopAnimation]
+  );
   useEffect3(() => () => stopAnimation(false), [stopAnimation]);
   const startOpenOrRestoreAnimation = useCallback6(
     async (nodeID, anchorKey, generation, dockRectFallback) => {
-      if (shouldReduceMotion()) {
+      const effectiveMinimizeAnimation = shouldReduceMotion() ? "off" : minimizeAnimation;
+      if (effectiveMinimizeAnimation === "off") {
         animationCleanupRef.current = null;
         showNodeForGenie(nodeID);
         return;
@@ -3135,6 +3442,32 @@ function useWorkbenchGenieAnimation({
       const resolvedDockRect = resolveDockAnchorRect(anchorKey);
       const dockRect = resolvedDockRect && isUsableGenieRect(resolvedDockRect) ? resolvedDockRect : dockRectFallback;
       const nodeElement = resolveNodeElement(nodeID);
+      if (effectiveMinimizeAnimation === "scale") {
+        if (!dockRect || !nodeElement || !isUsableGenieRect(dockRect)) {
+          animationCleanupRef.current = null;
+          showNodeForGenie(nodeID);
+          return;
+        }
+        flushSync(() => {
+          showNodeForGenie(nodeID);
+        });
+        runScaleWindowAnimation({
+          direction: "open",
+          dockRect,
+          nodeElement,
+          onCancel: () => {
+            flushSync(() => {
+              showNodeForGenie(nodeID);
+            });
+          },
+          onComplete: () => {
+            flushSync(() => {
+              showNodeForGenie(nodeID);
+            });
+          }
+        });
+        return;
+      }
       const captureTarget = nodeElement ? resolveWorkbenchCaptureElement(nodeElement) : null;
       if (!dockRect || !nodeElement || !captureTarget || !isUsableGenieRect(dockRect)) {
         animationCleanupRef.current = null;
@@ -3173,9 +3506,11 @@ function useWorkbenchGenieAnimation({
     },
     [
       clearCanvas,
+      minimizeAnimation,
       resolveDockAnchorRect,
       resolveNodeElement,
       runGenieAnimation,
+      runScaleWindowAnimation,
       showNodeForGenie
     ]
   );
@@ -3192,6 +3527,16 @@ function useWorkbenchGenieAnimation({
         });
         return;
       }
+      const effectiveMinimizeAnimation = shouldReduceMotion() ? "off" : minimizeAnimation;
+      if (effectiveMinimizeAnimation === "off") {
+        stopAnimation();
+        flushSync(() => {
+          showNodeForGenie(nodeID);
+        });
+        void Promise.resolve(launch()).catch(() => {
+        });
+        return;
+      }
       stopAnimation();
       const dockRectFallback = resolveDockAnchorRect(anchorKey);
       hideNodeForGenie(nodeID);
@@ -3216,6 +3561,7 @@ function useWorkbenchGenieAnimation({
       clearCanvas,
       controller,
       hideNodeForGenie,
+      minimizeAnimation,
       resolveDockAnchorRect,
       showNodeForGenie,
       startOpenOrRestoreAnimation,
@@ -3230,23 +3576,137 @@ function useWorkbenchGenieAnimation({
           return;
         }
         const runMinimize = minimize ?? (() => controller.commands.minimizeNode(nodeID));
-        if (shouldReduceMotion()) {
-          const wasFocusedForCapture2 = isFocusedWorkbenchNode(
-            controller,
-            nodeID
-          );
-          if (!wasFocusedForCapture2) {
+        const effectiveMinimizeAnimation = shouldReduceMotion() ? "off" : minimizeAnimation;
+        const shouldCapturePreview = shouldCaptureNodePreviewImage?.(target) ?? true;
+        if (effectiveMinimizeAnimation === "off") {
+          stopAnimation();
+          let frameID = null;
+          let timerID = null;
+          let minimizeCommitted2 = false;
+          const commitMinimize2 = () => {
+            if (minimizeCommitted2) {
+              return;
+            }
+            minimizeCommitted2 = true;
+            if (frameID !== null) {
+              window.cancelAnimationFrame(frameID);
+              frameID = null;
+            }
+            if (timerID !== null) {
+              clearTimeout(timerID);
+              timerID = null;
+            }
+            animationCleanupRef.current = null;
+            flushSync(() => {
+              clearPendingMinimizedNode(nodeID);
+              showNodeForGenie(nodeID);
+              runMinimize();
+            });
+            scheduleReleaseMinimizedDockEnterAnimation(nodeID);
+          };
+          animationCleanupRef.current = () => {
+            releaseMinimizedDockEnterAnimation(nodeID);
+            commitMinimize2();
+          };
+          registerMinimizedDockEnterAnimation(nodeID);
+          flushSync(() => {
+            hideNodeForGenie(nodeID);
+            setPendingMinimizedNode({
+              ...target,
+              isMinimized: true,
+              minimizedAtUnixMs: Date.now()
+            });
+          });
+          if (shouldCapturePreview) {
+            void captureProvidedWorkbenchNodePreviewImageForNode(target, {
+              captureNodePreviewImage,
+              dockPreviewCache,
+              resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2
+            });
+          }
+          frameID = window.requestAnimationFrame(() => {
+            frameID = null;
+            timerID = setTimeout(commitMinimize2, 0);
+          });
+          return;
+        }
+        if (effectiveMinimizeAnimation === "scale") {
+          stopAnimation();
+          const generation2 = animationGenerationRef.current;
+          const nodeElement2 = resolveNodeElement(nodeID);
+          if (!nodeElement2) {
+            runMinimize();
+            return;
+          }
+          const wasFocusedForCapture2 = shouldCapturePreview && isFocusedWorkbenchNode(controller, nodeID);
+          if (shouldCapturePreview && !wasFocusedForCapture2) {
             flushSync(() => {
               controller.commands.focusNode(nodeID);
             });
             await waitForNextAnimationFrame();
+            if (generation2 !== animationGenerationRef.current) {
+              return;
+            }
           }
-          await captureWorkbenchNodePreviewImageForNode(target, {
-            captureNodePreviewImage,
-            dockPreviewCache,
-            resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2
+          if (shouldCapturePreview) {
+            void captureProvidedWorkbenchNodePreviewImageForNode(target, {
+              captureNodePreviewImage,
+              dockPreviewCache,
+              resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2
+            });
+          }
+          let minimizeCommitted2 = false;
+          const commitMinimize2 = () => {
+            if (minimizeCommitted2) {
+              return;
+            }
+            minimizeCommitted2 = true;
+            runMinimize();
+          };
+          const cleanupPendingMinimize = () => {
+            releaseMinimizedDockEnterAnimation(nodeID);
+            flushSync(() => {
+              clearPendingMinimizedNode(nodeID);
+              commitMinimize2();
+            });
+          };
+          const pendingMinimizedNode3 = {
+            ...target,
+            isMinimized: true,
+            minimizedAtUnixMs: Date.now()
+          };
+          registerMinimizedDockEnterAnimation(nodeID);
+          flushSync(() => {
+            setPendingMinimizedNode(pendingMinimizedNode3);
+          });
+          animationCleanupRef.current = cleanupPendingMinimize;
+          await waitForNextAnimationFrame();
+          if (generation2 !== animationGenerationRef.current) {
+            return;
+          }
+          const anchorKey2 = resolveAnchorKeyForNode(pendingMinimizedNode3);
+          const dockRect2 = resolveDockAnchorRect(anchorKey2);
+          if (!nodeElement2.isConnected || !dockRect2 || !isUsableGenieRect(dockRect2)) {
+            cleanupPendingMinimize();
+            return;
+          }
+          runScaleWindowAnimation({
+            direction: "minimize",
+            dockRect: dockRect2,
+            nodeElement: nodeElement2,
+            onCancel: () => {
+              cleanupPendingMinimize();
+            },
+            onComplete: () => {
+              animationCleanupRef.current = null;
+              flushSync(() => {
+                clearPendingMinimizedNode(nodeID);
+                commitMinimize2();
+              });
+              scheduleReleaseMinimizedDockEnterAnimation(nodeID);
+            },
+            skipStop: true
           });
-          runMinimize();
           return;
         }
         stopAnimation();
@@ -3309,46 +3769,57 @@ function useWorkbenchGenieAnimation({
             resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2
           });
         }
-        const cleanupHiddenNode = () => {
+        let minimizeCommitted = false;
+        const commitMinimize = () => {
+          if (minimizeCommitted) {
+            return;
+          }
+          minimizeCommitted = true;
+          runMinimize();
+        };
+        const pendingMinimizedNode2 = {
+          ...target,
+          isMinimized: true,
+          minimizedAtUnixMs: Date.now()
+        };
+        const cleanupPendingGenieMinimize = () => {
+          releaseMinimizedDockEnterAnimation(nodeID);
           flushSync(() => {
+            clearPendingMinimizedNode(nodeID);
             showNodeForGenie(nodeID);
+            commitMinimize();
           });
           clearCanvas();
         };
-        animationCleanupRef.current = cleanupHiddenNode;
+        animationCleanupRef.current = cleanupPendingGenieMinimize;
         registerMinimizedDockEnterAnimation(nodeID);
         flushSync(() => {
+          setPendingMinimizedNode(pendingMinimizedNode2);
           hideNodeForGenie(nodeID);
-          runMinimize();
         });
         await waitForNextAnimationFrame();
         if (generation !== animationGenerationRef.current) {
-          releaseMinimizedDockEnterAnimation(nodeID);
           return;
         }
-        const minimizedTarget = controller.getSnapshot().nodes.find((node) => node.id === nodeID) ?? target;
-        const anchorKey = resolveAnchorKeyForNode(minimizedTarget);
+        const anchorKey = resolveAnchorKeyForNode(pendingMinimizedNode2);
         const dockRect = resolveDockAnchorRect(anchorKey);
         if (!dockRect || !isUsableGenieRect(dockRect)) {
-          releaseMinimizedDockEnterAnimation(nodeID);
           animationCleanupRef.current = null;
-          cleanupHiddenNode();
+          cleanupPendingGenieMinimize();
           return;
         }
         runGenieAnimation({
           direction: "minimize",
           dockRect,
           onCancel: () => {
-            releaseMinimizedDockEnterAnimation(nodeID);
-            flushSync(() => {
-              showNodeForGenie(nodeID);
-            });
-            clearCanvas();
+            cleanupPendingGenieMinimize();
           },
           onComplete: () => {
             scheduleReleaseMinimizedDockEnterAnimation(nodeID);
             flushSync(() => {
+              clearPendingMinimizedNode(nodeID);
               showNodeForGenie(nodeID);
+              commitMinimize();
             });
             clearCanvas();
           },
@@ -3361,8 +3832,10 @@ function useWorkbenchGenieAnimation({
       clearCanvas,
       controller,
       captureNodePreviewImage,
+      clearPendingMinimizedNode,
       dockPreviewCache,
       hideNodeForGenie,
+      minimizeAnimation,
       registerMinimizedDockEnterAnimation,
       releaseMinimizedDockEnterAnimation,
       resolveAnchorKeyForNode,
@@ -3370,7 +3843,9 @@ function useWorkbenchGenieAnimation({
       resolveDockAnchorRect,
       resolveNodeElement,
       runGenieAnimation,
+      runScaleWindowAnimation,
       scheduleReleaseMinimizedDockEnterAnimation,
+      shouldCaptureNodePreviewImage,
       setupCanvas,
       showNodeForGenie,
       stopAnimation
@@ -3403,8 +3878,13 @@ function useWorkbenchGenieAnimation({
       (nodeID) => genieHiddenNodeIDs.has(nodeID),
       [genieHiddenNodeIDs]
     ),
+    isPendingMinimizedDockNode: useCallback6(
+      (nodeID) => pendingMinimizedNode?.id === nodeID,
+      [pendingMinimizedNode]
+    ),
     launchNodeFromAnchor,
     minimizeNodeToAnchor,
+    pendingMinimizedNode,
     registerDockAnchor,
     shouldAnimateMinimizedDockEnter
   };
@@ -3421,6 +3901,7 @@ function WorkbenchSurface({
   interactive,
   layoutConstraints,
   missionControlPhase,
+  minimizeAnimation,
   presentation,
   renderBackdrop,
   renderBottomChrome,
@@ -3435,6 +3916,7 @@ function WorkbenchSurface({
   resolveDockAnchorKey,
   resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2,
   shortcutsEnabled,
+  shouldCaptureNodePreviewImage,
   wallpaper,
   windowChromeMode,
   windowChromeI18n
@@ -3449,6 +3931,7 @@ function WorkbenchSurface({
       interactive,
       layoutConstraints,
       missionControlPhase,
+      minimizeAnimation,
       presentation,
       renderBackdrop,
       renderBottomChrome,
@@ -3463,6 +3946,7 @@ function WorkbenchSurface({
       resolveDockAnchorKey,
       resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2,
       shortcutsEnabled,
+      shouldCaptureNodePreviewImage,
       wallpaper,
       windowChromeMode,
       windowChromeI18n
@@ -3477,6 +3961,7 @@ function WorkbenchSurfaceInner({
   interactive = true,
   layoutConstraints,
   missionControlPhase,
+  minimizeAnimation,
   presentation,
   renderBackdrop,
   renderBottomChrome,
@@ -3491,6 +3976,7 @@ function WorkbenchSurfaceInner({
   resolveDockAnchorKey,
   resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2,
   shortcutsEnabled,
+  shouldCaptureNodePreviewImage,
   wallpaper,
   windowChromeMode,
   windowChromeI18n
@@ -3507,8 +3993,10 @@ function WorkbenchSurfaceInner({
     captureNodePreviewImage,
     controller,
     dockPreviewCache,
+    minimizeAnimation,
     resolveDockAnchorKey,
-    resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2
+    resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2,
+    shouldCaptureNodePreviewImage
   });
   useWorkbenchShortcuts((shortcutsEnabled ?? true) && interactive);
   useEffect4(() => {
@@ -4769,6 +5257,11 @@ var WorkbenchHostSessionController = class {
       this.restoreAndFocusNode(nodeId);
     });
   }
+  minimizeNode(nodeId) {
+    this.runWhenReady(this.loadGeneration, () => {
+      this.controller.commands.minimizeNode(nodeId);
+    });
+  }
   exitFullscreenNode(nodeId) {
     this.runWhenReady(this.loadGeneration, () => {
       this.controller.commands.exitFullscreen(nodeId);
@@ -6244,7 +6737,7 @@ function resolveWorkbenchMinimizedDockAnchorKeyForNode(input) {
 }
 function isWorkbenchMinimizedDockEligibleNode(input) {
   const definition = input.nodeDefinitions.get(input.node.data.typeId);
-  return definition?.window?.minimizedDock?.kind === "snapshot";
+  return definition?.window?.minimizedDock !== void 0;
 }
 function orderWorkbenchMinimizedDockNodes(input) {
   return input.nodes.map((node, index) => ({ index, node })).filter(
@@ -6360,7 +6853,18 @@ import {
   useState as useState7
 } from "react";
 import { createPortal as createPortal2 } from "react-dom";
-import { Button as Button3, CloseIcon, FileCreateIcon, cn } from "@tutti-os/ui-system";
+import {
+  Button as Button3,
+  CheckIcon,
+  CloseIcon,
+  FileCreateIcon,
+  MaximizeIcon as MaximizeIcon2,
+  MinimizeIcon,
+  OverviewLayoutIcon,
+  PinFilledIcon,
+  PinIcon,
+  cn
+} from "@tutti-os/ui-system";
 
 // src/host/minimizedStackScroll.ts
 var minimizedStackViewportMarginPx = 56;
@@ -6492,7 +6996,7 @@ function resolveMinimizedStackTrackTranslateXPx(input) {
 }
 
 // src/host/WorkbenchHostDockPopup.tsx
-import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
 var dockPopupCardWidthPx = 165;
 var dockPopupGridGapPx = 8;
 var dockPopupPanelPaddingInlinePx = 12;
@@ -6557,9 +7061,14 @@ function writeDockPopupPreviewImage(memoryKey, preview, revision) {
 }
 function WorkbenchHostDockPopup({
   anchorRect,
+  canEnterFullscreen,
+  canShowAllWindows,
   capturePreview,
   debugDiagnostics,
+  dockRetention,
   dockPreviewCache,
+  fullscreenLabel,
+  hideLabel,
   items,
   label,
   labelMode,
@@ -6568,15 +7077,25 @@ function WorkbenchHostDockPopup({
   onClose,
   onCloseNode,
   onCreateNew,
+  onEnterFullscreen,
+  onHide,
+  onRunDockRetentionAction,
   onSelectNode,
+  onShowAllWindows,
+  openLabel,
+  onQuit,
   placement = "bottom",
+  quitLabel,
   resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2,
+  showAllWindowsLabel,
   showCreateNew,
+  showOpen,
   variant
 }) {
   const resolvedLabelMode = labelMode ?? "hover-overlay";
   const resolvedVariant = variant ?? "default";
   const isMinimizedStack = resolvedVariant === "minimized-stack";
+  const isContextMenu = resolvedVariant === "context-menu";
   const createCardCount = showCreateNew === false ? 0 : 1;
   const cardElementsRef = useRef7(/* @__PURE__ */ new Map());
   const cardRefCallbacksRef = useRef7(
@@ -6587,8 +7106,8 @@ function WorkbenchHostDockPopup({
   const [pointer, setPointer] = useState7(null);
   const [minimizedStackScrollOffset, setMinimizedStackScrollOffset] = useState7(0);
   const [capturedPreviewByMemoryKey, setCapturedPreviewByMemoryKey] = 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 columnCount = isContextMenu ? 1 : Math.min(Math.max(items.length + createCardCount, 1), 3);
+  const popupWidthPx = isContextMenu ? 268 : columnCount * dockPopupCardWidthPx + Math.max(0, columnCount - 1) * dockPopupGridGapPx + dockPopupPanelPaddingInlinePx * 2 + dockPopupPanelBorderInlinePx;
   const popupCenterY = anchorRect.top + anchorRect.height / 2;
   const isLeftMinimizedStack = placement === "left" && isMinimizedStack;
   const minimizedStackTrackHeightPx = resolveMinimizedStackTrackHeightPx(
@@ -6766,7 +7285,7 @@ function WorkbenchHostDockPopup({
     return () => viewport.removeEventListener("wheel", handleWheel);
   }, [isMinimizedStack, minimizedStackMaxScrollOffset]);
   useEffect8(() => {
-    if (!capturePreview) {
+    if (!capturePreview || isContextMenu) {
       return;
     }
     let cancelled = false;
@@ -6977,6 +7496,7 @@ function WorkbenchHostDockPopup({
   }, [
     capturePreview,
     dockPreviewCache,
+    isContextMenu,
     items,
     previewCaptureKey,
     resolveDockPreviewCacheKey2
@@ -6990,12 +7510,13 @@ function WorkbenchHostDockPopup({
       "data-desktop-dock-popup-root": "true",
       "data-popup-variant": resolvedVariant,
       style: popupStyle,
-      children: /* @__PURE__ */ jsxs5(
+      children: /* @__PURE__ */ jsx9(
         "div",
         {
           "aria-label": label,
           className: cn(
-            "desktop-dock-popup relative origin-bottom rounded-lg border border-[var(--border-1)] bg-background-fronted p-3 text-[var(--text-primary)] shadow-panel motion-safe:animate-in motion-safe:fade-in-0 motion-safe:zoom-in-95 motion-safe:slide-in-from-bottom-2 motion-safe:duration-[175ms] motion-safe:ease-[cubic-bezier(0.22,1,0.36,1)] motion-reduce:animate-none",
+            "desktop-dock-popup relative origin-bottom rounded-lg border border-[var(--border-1)] bg-background-fronted text-[var(--text-primary)] shadow-panel motion-safe:animate-in motion-safe:fade-in-0 motion-safe:zoom-in-95 motion-safe:slide-in-from-bottom-2 motion-safe:duration-[175ms] motion-safe:ease-[cubic-bezier(0.22,1,0.36,1)] motion-reduce:animate-none",
+            isContextMenu ? "p-1" : "p-3",
             isLeftMinimizedStack ? "w-full min-w-0 max-w-none" : "w-[min(var(--desktop-dock-popup-width,366px),calc(100vw-32px))]"
           ),
           "data-desktop-dock-popup-panel": "true",
@@ -7005,8 +7526,31 @@ function WorkbenchHostDockPopup({
           onPointerLeave: isMinimizedStack ? () => setPointer(null) : void 0,
           role: "dialog",
           style: panelStyle,
-          children: [
-            /* @__PURE__ */ jsx9("div", { className: "mb-2.5 flex items-center justify-between", children: /* @__PURE__ */ jsx9("span", { className: "min-w-0 truncate text-sm font-semibold", children: label }) }),
+          children: isContextMenu ? /* @__PURE__ */ jsx9(
+            WorkbenchHostDockContextMenu,
+            {
+              canCreateNew: showCreateNew !== false,
+              canEnterFullscreen: canEnterFullscreen === true,
+              canShowAllWindows: canShowAllWindows === true,
+              dockRetention,
+              fullscreenLabel,
+              hideLabel,
+              items,
+              newWindowLabel,
+              onCreateNew,
+              onEnterFullscreen,
+              onHide,
+              onQuit,
+              onRunDockRetentionAction,
+              onSelectNode,
+              onShowAllWindows,
+              openLabel,
+              quitLabel,
+              showAllWindowsLabel,
+              showOpen: showOpen === true
+            }
+          ) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
+            /* @__PURE__ */ jsx9("div", { className: "mb-2.5 flex items-center justify-between", children: /* @__PURE__ */ jsx9("span", { className: "min-w-0 truncate text-sm font-semibold", children: label }) }),
             isMinimizedStack ? /* @__PURE__ */ jsx9(
               "div",
               {
@@ -7111,7 +7655,7 @@ function WorkbenchHostDockPopup({
                 }
               ) : null
             ] })
-          ]
+          ] })
         }
       )
     }
@@ -7121,6 +7665,172 @@ function WorkbenchHostDockPopup({
   }
   return createPortal2(content, document.body);
 }
+function WorkbenchHostDockContextMenu({
+  canCreateNew,
+  canEnterFullscreen,
+  canShowAllWindows,
+  dockRetention,
+  fullscreenLabel,
+  hideLabel,
+  items,
+  newWindowLabel,
+  onCreateNew,
+  onEnterFullscreen,
+  onHide,
+  onQuit,
+  onRunDockRetentionAction,
+  onSelectNode,
+  onShowAllWindows,
+  openLabel,
+  quitLabel,
+  showAllWindowsLabel,
+  showOpen
+}) {
+  const hasOpenWindows = items.length > 0;
+  const hasNewWindowCommand = hasOpenWindows && canCreateNew;
+  const hasOpenCommand = !hasOpenWindows;
+  const hasDockActionGroup = Boolean(dockRetention) || hasNewWindowCommand || hasOpenCommand;
+  const hasWindowActionGroup = hasOpenWindows;
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: "flex min-w-0 flex-col gap-1",
+      "data-desktop-dock-context-menu": "true",
+      role: "menu",
+      children: [
+        hasOpenWindows ? /* @__PURE__ */ jsx9(Fragment3, { children: /* @__PURE__ */ jsx9("div", { className: "max-h-48 min-w-0 overflow-auto overscroll-contain", children: items.map((item) => /* @__PURE__ */ jsx9(
+          WorkbenchHostDockContextMenuItem,
+          {
+            checked: !item.isMinimized,
+            label: item.title?.trim() || item.node.title,
+            onSelect: () => onSelectNode(item.node.id)
+          },
+          item.node.id
+        )) }) }) : null,
+        hasOpenWindows && (hasDockActionGroup || hasWindowActionGroup) ? /* @__PURE__ */ jsx9(WorkbenchHostDockContextMenuSeparator, {}) : null,
+        dockRetention ? /* @__PURE__ */ jsx9(
+          WorkbenchHostDockContextMenuItem,
+          {
+            checked: dockRetention.checked,
+            checkedIcon: /* @__PURE__ */ jsx9(
+              PinFilledIcon,
+              {
+                "aria-hidden": "true",
+                className: "size-4 text-[var(--tutti-purple)]"
+              }
+            ),
+            disabled: dockRetention.disabled,
+            icon: /* @__PURE__ */ jsx9(PinIcon, { "aria-hidden": "true", className: "size-4" }),
+            label: dockRetention.pendingLabel ?? dockRetention.label,
+            onSelect: onRunDockRetentionAction
+          }
+        ) : null,
+        hasNewWindowCommand ? /* @__PURE__ */ jsx9(
+          WorkbenchHostDockContextMenuItem,
+          {
+            icon: /* @__PURE__ */ jsx9(FileCreateIcon, { "aria-hidden": "true", className: "size-4" }),
+            label: newWindowLabel,
+            onSelect: onCreateNew
+          }
+        ) : null,
+        hasOpenCommand ? /* @__PURE__ */ jsx9(
+          WorkbenchHostDockContextMenuItem,
+          {
+            disabled: !showOpen,
+            icon: /* @__PURE__ */ jsx9(FileCreateIcon, { "aria-hidden": "true", className: "size-4" }),
+            label: openLabel,
+            onSelect: onCreateNew
+          }
+        ) : null,
+        hasOpenWindows ? /* @__PURE__ */ jsxs5(Fragment3, { children: [
+          hasDockActionGroup ? /* @__PURE__ */ jsx9(WorkbenchHostDockContextMenuSeparator, {}) : null,
+          canShowAllWindows && onShowAllWindows ? /* @__PURE__ */ jsx9(
+            WorkbenchHostDockContextMenuItem,
+            {
+              icon: /* @__PURE__ */ jsx9(OverviewLayoutIcon, { "aria-hidden": "true", className: "size-4" }),
+              label: showAllWindowsLabel,
+              onSelect: onShowAllWindows
+            }
+          ) : null,
+          /* @__PURE__ */ jsx9(
+            WorkbenchHostDockContextMenuItem,
+            {
+              disabled: !canEnterFullscreen || !onEnterFullscreen,
+              icon: /* @__PURE__ */ jsx9(MaximizeIcon2, { "aria-hidden": "true", className: "size-4" }),
+              label: fullscreenLabel,
+              onSelect: onEnterFullscreen
+            }
+          ),
+          /* @__PURE__ */ jsx9(
+            WorkbenchHostDockContextMenuItem,
+            {
+              disabled: !onHide,
+              icon: /* @__PURE__ */ jsx9(MinimizeIcon, { "aria-hidden": "true", className: "size-4" }),
+              label: hideLabel,
+              onSelect: onHide
+            }
+          ),
+          /* @__PURE__ */ jsx9(
+            WorkbenchHostDockContextMenuItem,
+            {
+              disabled: !onQuit,
+              icon: /* @__PURE__ */ jsx9(CloseIcon, { "aria-hidden": "true", className: "size-4" }),
+              label: quitLabel,
+              onSelect: onQuit
+            }
+          )
+        ] }) : null
+      ]
+    }
+  );
+}
+function WorkbenchHostDockContextMenuItem({
+  checked,
+  checkedIcon,
+  disabled,
+  icon,
+  label,
+  onSelect
+}) {
+  return /* @__PURE__ */ jsxs5(
+    "button",
+    {
+      className: cn(
+        "flex h-8 w-full min-w-0 items-center gap-2 rounded-md px-2 text-left text-sm text-[var(--text-primary)] transition-colors",
+        disabled ? "cursor-default opacity-45" : "hover:bg-transparency-hover focus-visible:bg-transparency-hover focus-visible:outline-none"
+      ),
+      disabled,
+      role: "menuitem",
+      type: "button",
+      onClick: () => {
+        if (disabled || !onSelect) {
+          return;
+        }
+        onSelect();
+      },
+      children: [
+        /* @__PURE__ */ jsx9("span", { className: "flex size-4 shrink-0 items-center justify-center text-[var(--text-secondary)]", children: checked && checkedIcon ? checkedIcon : checked ? /* @__PURE__ */ jsx9(
+          CheckIcon,
+          {
+            "aria-hidden": "true",
+            className: "size-4 text-[var(--tutti-purple)]"
+          }
+        ) : icon ?? null }),
+        /* @__PURE__ */ jsx9("span", { className: "min-w-0 truncate", children: label })
+      ]
+    }
+  );
+}
+function WorkbenchHostDockContextMenuSeparator() {
+  return /* @__PURE__ */ jsx9(
+    "div",
+    {
+      "aria-hidden": "true",
+      className: "mx-2 my-1 h-px bg-[var(--border-1)]",
+      role: "separator"
+    }
+  );
+}
 function readPersistedDockPreview(dockPreviewCache, cacheKey) {
   if (!cacheKey) {
     return Promise.resolve(null);
@@ -7316,7 +8026,7 @@ var WorkbenchHostDockPopupCard = forwardRef(function WorkbenchHostDockPopupCard2
           "span",
           {
             "aria-hidden": "true",
-            className: "pointer-events-none absolute inset-0 z-[3] rounded-[8px] shadow-[inset_0_0_0_2px_var(--border-focus)]",
+            className: "pointer-events-none absolute inset-0 z-[3] rounded-md shadow-[inset_0_0_0_2px_var(--border-focus)]",
             "data-desktop-dock-popup-card-active-overlay": "true"
           }
         ) : null,
@@ -7420,6 +8130,7 @@ function WorkbenchHostDock({
   nodeDefinitions,
   onDockEntryAction,
   onDockEntryClick,
+  onMissionControlRequestOpen,
   workspaceId
 }) {
   const minimizedNodeIDs = useMemo5(
@@ -7452,6 +8163,7 @@ function WorkbenchHostDock({
     /* @__PURE__ */ new Map()
   );
   const previousAttentionTokenByEntryId = useRef8(/* @__PURE__ */ new Map());
+  const dockEntryClickThrottleUntilRef = useRef8(/* @__PURE__ */ new Map());
   const attentionTimeouts = useRef8(
     /* @__PURE__ */ new Map()
   );
@@ -7626,9 +8338,9 @@ function WorkbenchHostDock({
   const minimizedDockSlots = useMemo5(
     () => resolveWorkbenchMinimizedDockSlots({
       nodeDefinitions,
-      nodes: context.nodes
+      nodes: context.minimizedNodes
     }),
-    [context.nodes, nodeDefinitions]
+    [context.minimizedNodes, nodeDefinitions]
   );
   const { promotedNodeId, stackDispatching } = useMinimizedDockStackPromotion(minimizedDockSlots);
   const dockItems = useMemo5(
@@ -7999,6 +8711,19 @@ function WorkbenchHostDock({
       triggerDockBounce
     ]
   );
+  const isDockEntryClickThrottled = useCallback10(
+    (anchorKey) => {
+      const throttledUntil = dockEntryClickThrottleUntilRef.current.get(anchorKey);
+      return throttledUntil !== void 0 && Date.now() < throttledUntil;
+    },
+    []
+  );
+  const claimDockEntryClick = useCallback10((anchorKey) => {
+    dockEntryClickThrottleUntilRef.current.set(
+      anchorKey,
+      Date.now() + DOCK_ENTRY_CLICK_THROTTLE_MS
+    );
+  }, []);
   const beginDockMinimizedInteraction = useCallback10(
     (anchorKey) => {
       hoverPanelRestTargetRef.current = null;
@@ -8156,9 +8881,13 @@ function WorkbenchHostDock({
   }, [dockPlacement, presentDockItems.length, updateDockScrollState]);
   const hasMinimizedPreviewCapture = minimizedDockSlots.some(
     (slot) => minimizedDockSlotNodes(slot).some(
-      (node) => Boolean(
-        nodeDefinitions.get(node.data.typeId)?.window?.minimizedDock?.capturePreview
-      )
+      (node) => (() => {
+        if (context.genie.isPendingMinimizedDockNode(node.id)) {
+          return false;
+        }
+        const minimizedDock = nodeDefinitions.get(node.data.typeId)?.window?.minimizedDock;
+        return minimizedDock?.kind === "snapshot" && Boolean(minimizedDock.capturePreview);
+      })()
     )
   );
   useEffect9(() => {
@@ -8222,7 +8951,8 @@ function WorkbenchHostDock({
   );
   const captureMinimizedNodePreview = useCallback10(
     async (node) => {
-      const capturePreview = nodeDefinitions.get(node.data.typeId)?.window?.minimizedDock?.capturePreview;
+      const minimizedDock = nodeDefinitions.get(node.data.typeId)?.window?.minimizedDock;
+      const capturePreview = minimizedDock?.kind === "snapshot" ? minimizedDock.capturePreview : void 0;
       const externalState = readWorkbenchHostExternalState({
         externalStateSource,
         node,
@@ -8250,6 +8980,41 @@ function WorkbenchHostDock({
       workspaceId
     ]
   );
+  const provideMinimizedNodePreview = useCallback10(
+    (node) => {
+      const minimizedDock = nodeDefinitions.get(node.data.typeId)?.window?.minimizedDock;
+      if (minimizedDock?.kind !== "component") {
+        return null;
+      }
+      const externalState = readWorkbenchHostExternalState({
+        externalStateSource,
+        node,
+        workspaceId
+      });
+      return minimizedDock.providePreview({
+        externalNodeState: externalState.externalNodeState,
+        externalWorkspaceState: externalState.externalWorkspaceState,
+        host,
+        isFocused: context.focusedNodeId === node.id,
+        isMinimized: node.isMinimized,
+        node
+      });
+    },
+    [
+      context.focusedNodeId,
+      externalStateSource,
+      host,
+      nodeDefinitions,
+      workspaceId
+    ]
+  );
+  const provideMinimizedNodePreviewForNode = useCallback10(
+    (node) => {
+      const minimizedDock = nodeDefinitions.get(node.data.typeId)?.window?.minimizedDock;
+      return minimizedDock?.kind === "component" ? provideMinimizedNodePreview : void 0;
+    },
+    [nodeDefinitions, provideMinimizedNodePreview]
+  );
   if (dockItems.length === 0 && presentDockItems.length === 0) {
     return null;
   }
@@ -8303,12 +9068,59 @@ function WorkbenchHostDock({
     dockSlotRefCallbacksRef.current.set(anchorKey, callback);
     return callback;
   }, []);
+  const runDockEntryAction = useCallback10(
+    (entryId, actionId) => {
+      const actionKey = dockActionKey(entryId, actionId);
+      if (pendingActionKeys.has(actionKey)) {
+        return;
+      }
+      setPendingActionKeys((current) => {
+        const next = new Set(current);
+        next.add(actionKey);
+        return next;
+      });
+      void (async () => {
+        try {
+          await onDockEntryAction?.({
+            actionId,
+            entryId,
+            host
+          });
+        } catch {
+        } finally {
+          setPendingActionKeys((current) => {
+            if (!current.has(actionKey)) {
+              return current;
+            }
+            const next = new Set(current);
+            next.delete(actionKey);
+            return next;
+          });
+        }
+      })();
+    },
+    [host, onDockEntryAction, pendingActionKeys]
+  );
   const popupEntry = activePopup === null ? null : resolvedEntries.find(
     (entry) => entry.entry.id === activePopup.entryId
   ) ?? null;
   const activeMinimizedStackSlot = activeMinimizedStackPopup === null ? null : minimizedDockSlots.find(
     (slot) => slot.kind === "stack"
   ) ?? null;
+  const openDockContextMenuNodeIds = popupEntry?.matchedNodes.map((node) => node.id) ?? [];
+  const dockContextMenuInstanceMode = popupEntry === null ? void 0 : resolveDockEntryInstanceMode(popupEntry.entry, nodeDefinitions);
+  const canShowAllWindowsFromDockContextMenu = onMissionControlRequestOpen !== void 0 && dockContextMenuInstanceMode === "multi" && openDockContextMenuNodeIds.length > 1;
+  const fullscreenNodeFromDockContextMenu = popupEntry === null ? null : resolveDockContextMenuFullscreenNode({
+    focusedNodeId: context.focusedNodeId,
+    minimizedNodeIDs,
+    nodeDefinitions,
+    nodes: popupEntry.matchedNodes
+  });
+  const canOpenFromDockContextMenu = popupEntry !== null && popupEntry.matchedNodes.length === 0 && resolveWorkbenchDockEntryClick({
+    entry: popupEntry.entry,
+    instanceMode: dockContextMenuInstanceMode,
+    matchedNodes: popupEntry.matchedNodes
+  }).kind === "launch";
   return /* @__PURE__ */ jsxs6(
     "div",
     {
@@ -8409,13 +9221,26 @@ function WorkbenchHostDock({
                           className: "desktop-dock__btn",
                           "data-interactive": clickResolution.kind === "blocked" ? "false" : "true",
                           type: "button",
-                          onPointerDown: () => {
+                          onPointerDown: (event) => {
+                            if (event.button !== 0) {
+                              return;
+                            }
                             if (clickResolution.kind === "blocked") {
                               return;
                             }
+                            if (isDockEntryClickThrottled(anchorKey)) {
+                              return;
+                            }
                             beginDockIconInteraction(anchorKey);
                           },
                           onClick: (event) => {
+                            if (clickResolution.kind === "blocked") {
+                              return;
+                            }
+                            if (isDockEntryClickThrottled(anchorKey)) {
+                              return;
+                            }
+                            claimDockEntryClick(anchorKey);
                             logWorkbenchDockDebug("dock.click", debugDiagnostics, {
                               anchorKey,
                               clickResolution,
@@ -8442,14 +9267,16 @@ function WorkbenchHostDock({
                             switch (clickResolution.kind) {
                               case "focus-node":
                                 closePopup();
-                                void Promise.resolve(
-                                  onDockEntryClick?.({
-                                    entryId: entry.id,
-                                    host,
-                                    nodeId: clickResolution.nodeId
-                                  })
-                                ).catch(() => {
-                                });
+                                void (async () => {
+                                  try {
+                                    await onDockEntryClick?.({
+                                      entryId: entry.id,
+                                      host,
+                                      nodeId: clickResolution.nodeId
+                                    });
+                                  } catch {
+                                  }
+                                })();
                                 context.genie.launchNodeFromAnchor(
                                   anchorKey,
                                   clickResolution.nodeId,
@@ -8480,6 +9307,7 @@ function WorkbenchHostDock({
                                       top: rect.top,
                                       width: rect.width
                                     },
+                                    kind: "preview",
                                     entryId: entry.id
                                   }
                                 );
@@ -8487,14 +9315,16 @@ function WorkbenchHostDock({
                               }
                               case "action":
                                 closePopup();
-                                void Promise.resolve(
-                                  onDockEntryAction?.({
-                                    actionId: clickResolution.actionId,
-                                    entryId: entry.id,
-                                    host
-                                  })
-                                ).catch(() => {
-                                });
+                                void (async () => {
+                                  try {
+                                    await onDockEntryAction?.({
+                                      actionId: clickResolution.actionId,
+                                      entryId: entry.id,
+                                      host
+                                    });
+                                  } catch {
+                                  }
+                                })();
                                 return;
                               case "launch":
                                 closePopup();
@@ -8509,10 +9339,36 @@ function WorkbenchHostDock({
                                   })
                                 );
                                 return;
-                              case "blocked":
-                                return;
                             }
                           },
+                          onContextMenu: (event) => {
+                            if (clickResolution.kind === "blocked" || !dockEntryHasContextMenu(entry, resolvedEntry)) {
+                              return;
+                            }
+                            event.preventDefault();
+                            const rect = event.currentTarget.getBoundingClientRect();
+                            logWorkbenchDockDebug(
+                              "dock.popup.context_menu",
+                              debugDiagnostics,
+                              {
+                                anchorKey,
+                                entryId: entry.id,
+                                matchedNodeCount: resolvedEntry.matchedNodes.length,
+                                typeId: entry.typeId,
+                                workspaceId
+                              }
+                            );
+                            setActivePopup({
+                              anchorRect: {
+                                height: rect.height,
+                                left: rect.left,
+                                top: rect.top,
+                                width: rect.width
+                              },
+                              kind: "context-menu",
+                              entryId: entry.id
+                            });
+                          },
                           children: /* @__PURE__ */ jsxs6(
                             "span",
                             {
@@ -8641,7 +9497,10 @@ function WorkbenchHostDock({
                           className: "desktop-dock__btn desktop-dock__minimized-btn",
                           "data-interactive": "true",
                           type: "button",
-                          onPointerDown: () => {
+                          onPointerDown: (event) => {
+                            if (event.button !== 0) {
+                              return;
+                            }
                             beginDockMinimizedInteraction();
                           },
                           onClick: (event) => {
@@ -8683,9 +9542,12 @@ function WorkbenchHostDock({
                                           className: `desktop-dock__minimized-stack-layer desktop-dock__minimized-stack-layer--${index}`,
                                           dockPreviewCache,
                                           node: node2,
+                                          providePreview: provideMinimizedNodePreviewForNode(
+                                            node2
+                                          ),
                                           workspaceId
                                         },
-                                        node2.id
+                                        minimizedDockPreviewFreezeKey(node2)
                                       );
                                     }
                                     return /* @__PURE__ */ jsx10(
@@ -8753,6 +9615,7 @@ function WorkbenchHostDock({
                       );
                     }
                     const node = slot.node;
+                    const isPendingMinimizedNode = context.genie.isPendingMinimizedDockNode(node.id);
                     const labelTooltipTarget = dockLabelTooltipTarget(
                       `minimized-node:${node.id}`,
                       node.title
@@ -8763,8 +9626,12 @@ function WorkbenchHostDock({
                         "aria-label": i18n.t("launch", { title: node.title }),
                         className: "desktop-dock__btn desktop-dock__minimized-btn",
                         "data-interactive": "true",
+                        disabled: isPendingMinimizedNode,
                         type: "button",
-                        onPointerDown: () => {
+                        onPointerDown: (event) => {
+                          if (event.button !== 0 || isPendingMinimizedNode) {
+                            return;
+                          }
                           const restoreIntent = resolveWorkbenchMinimizedDockRestoreIntent({
                             nodeId: node.id,
                             slots: minimizedDockSlots,
@@ -8780,6 +9647,9 @@ function WorkbenchHostDock({
                           beginDockMinimizedInteraction();
                         },
                         onClick: () => {
+                          if (isPendingMinimizedNode) {
+                            return;
+                          }
                           const restoreIntent = resolveWorkbenchMinimizedDockRestoreIntent({
                             nodeId: node.id,
                             slots: minimizedDockSlots,
@@ -8809,11 +9679,14 @@ function WorkbenchHostDock({
                         children: /* @__PURE__ */ jsx10(
                           WorkbenchHostDockMinimizedNodePreview,
                           {
-                            capturePreview: captureMinimizedNodePreview,
-                            dockPreviewCache,
+                            capturePreview: isPendingMinimizedNode ? void 0 : captureMinimizedNodePreview,
+                            deferPreview: isPendingMinimizedNode,
+                            dockPreviewCache: isPendingMinimizedNode ? void 0 : dockPreviewCache,
                             node,
+                            providePreview: isPendingMinimizedNode ? void 0 : provideMinimizedNodePreviewForNode(node),
                             workspaceId
-                          }
+                          },
+                          minimizedDockPreviewFreezeKey(node)
                         )
                       }
                     );
@@ -8828,6 +9701,7 @@ function WorkbenchHostDock({
                         "data-dock-label-tooltip-key": labelTooltipTarget.key,
                         "data-dock-label-tooltip-label": labelTooltipTarget.label,
                         "data-node-state": "minimized",
+                        "data-pending-minimize": isPendingMinimizedNode ? "true" : void 0,
                         "data-presence": dockItem.presence,
                         "data-promoted-from-stack": promotedNodeId === node.id ? "true" : void 0,
                         "data-section-id": "minimized",
@@ -8929,7 +9803,27 @@ function WorkbenchHostDock({
           {
             anchorRect: activePopup.anchorRect,
             placement: dockPlacement,
+            canEnterFullscreen: fullscreenNodeFromDockContextMenu !== null,
+            canShowAllWindows: canShowAllWindowsFromDockContextMenu,
             debugDiagnostics,
+            dockRetention: popupEntry.entry.dockRetention ? {
+              checked: popupEntry.entry.dockRetention.retained,
+              disabled: popupEntry.entry.dockRetention.disabled === true || pendingActionKeys.has(
+                dockActionKey(
+                  popupEntry.entry.id,
+                  popupEntry.entry.dockRetention.actionId
+                )
+              ),
+              label: i18n.t(
+                popupEntry.entry.dockRetention.retained ? "dockContextMenu.removeFromDock" : "dockContextMenu.keepInDock"
+              ),
+              pendingLabel: pendingActionKeys.has(
+                dockActionKey(
+                  popupEntry.entry.id,
+                  popupEntry.entry.dockRetention.actionId
+                )
+              ) ? popupEntry.entry.dockRetention.pendingLabel : void 0
+            } : null,
             capturePreview: popupEntry.entry.capturePopupItemPreview ? async (item) => {
               const previewImageUrl = await Promise.resolve(
                 popupEntry.entry.capturePopupItemPreview?.(item) ?? null
@@ -8978,7 +9872,10 @@ function WorkbenchHostDock({
             label: popupEntry.entry.label,
             labelMode: popupEntry.entry.popupCardLabelMode,
             newWindowLabel: i18n.t("newWindow"),
+            openLabel: i18n.t("dockContextMenu.open"),
             closeWindowLabel: (title) => i18n.t("closeWindow", { title }),
+            fullscreenLabel: i18n.t("dockContextMenu.fullscreen"),
+            hideLabel: i18n.t("dockContextMenu.hide"),
             onClose: () => {
               logWorkbenchDockDebug(
                 "dock.popup.close_requested",
@@ -9013,16 +9910,46 @@ function WorkbenchHostDock({
                 })
               );
             },
+            onEnterFullscreen: () => {
+              if (!fullscreenNodeFromDockContextMenu) {
+                return;
+              }
+              context.controller.commands.enterFullscreen(
+                fullscreenNodeFromDockContextMenu.id
+              );
+              closePopup();
+            },
+            onHide: () => {
+              for (const node of popupEntry.matchedNodes) {
+                if (!minimizedNodeIDs.has(node.id)) {
+                  host.minimizeNode(node.id);
+                }
+              }
+              closePopup();
+            },
+            onRunDockRetentionAction: popupEntry.entry.dockRetention ? () => {
+              const dockRetention = popupEntry.entry.dockRetention;
+              if (!dockRetention || dockRetention.disabled === true) {
+                return;
+              }
+              runDockEntryAction(
+                popupEntry.entry.id,
+                dockRetention.actionId
+              );
+              closePopup();
+            } : void 0,
             onSelectNode: (nodeId) => {
               closePopup();
-              void Promise.resolve(
-                onDockEntryClick?.({
-                  entryId: popupEntry.entry.id,
-                  host,
-                  nodeId
-                })
-              ).catch(() => {
-              });
+              void (async () => {
+                try {
+                  await onDockEntryClick?.({
+                    entryId: popupEntry.entry.id,
+                    host,
+                    nodeId
+                  });
+                } catch {
+                }
+              })();
               context.genie.launchNodeFromAnchor(
                 anchorKeyFromPopupEntry(popupEntry),
                 nodeId,
@@ -9031,11 +9958,35 @@ function WorkbenchHostDock({
                 }
               );
             },
+            onShowAllWindows: () => {
+              closePopup();
+              for (const node of popupEntry.matchedNodes) {
+                if (minimizedNodeIDs.has(node.id)) {
+                  context.controller.commands.restoreNode(node.id);
+                }
+              }
+              window.requestAnimationFrame(() => {
+                onMissionControlRequestOpen?.("activate", {
+                  nodeIds: openDockContextMenuNodeIds,
+                  trigger: "dock-context-menu"
+                });
+              });
+            },
+            onQuit: () => {
+              for (const node of popupEntry.matchedNodes) {
+                host.requestNodeClose(node.id);
+              }
+              closePopup();
+            },
+            quitLabel: i18n.t("dockContextMenu.quit"),
             showCreateNew: canCreateNewWindow(
               popupEntry.entry,
-              resolveDockEntryInstanceMode(popupEntry.entry, nodeDefinitions)
+              dockContextMenuInstanceMode
             ),
-            resolveDockPreviewCacheKey: (node) => resolveDockPreviewCacheKey(workspaceId, node)
+            showOpen: canOpenFromDockContextMenu,
+            showAllWindowsLabel: i18n.t("dockContextMenu.showAllWindows"),
+            resolveDockPreviewCacheKey: (node) => resolveDockPreviewCacheKey(workspaceId, node),
+            variant: activePopup.kind === "context-menu" ? "context-menu" : "default"
           }
         ) : null,
         activeMinimizedStackSlot && activeMinimizedStackPopup ? /* @__PURE__ */ jsx10(
@@ -9055,6 +10006,7 @@ function WorkbenchHostDock({
                 node,
                 workspaceId
               });
+              const minimizedDock = nodeDefinitions.get(node.data.typeId)?.window?.minimizedDock;
               return {
                 externalNodeState: externalState.externalNodeState,
                 externalWorkspaceState: externalState.externalWorkspaceState,
@@ -9062,10 +10014,8 @@ function WorkbenchHostDock({
                 isFocused: context.focusedNodeId === node.id,
                 isMinimized: true,
                 node,
-                preview: nodeDefinitions.get(node.data.typeId)?.window?.minimizedDock?.capturePreview ? null : (() => {
-                  const previewImageUrl = readCachedWorkbenchNodePreviewImage(
-                    node.id
-                  );
+                preview: minimizedDock?.kind === "component" ? provideMinimizedNodePreview(node) ?? null : minimizedDock?.kind === "snapshot" && minimizedDock.capturePreview ? null : (() => {
+                  const previewImageUrl = readCachedWorkbenchNodePreviewImage(node.id);
                   return previewImageUrl ? { kind: "image", src: previewImageUrl } : null;
                 })(),
                 previewRevision: null,
@@ -9133,14 +10083,69 @@ function WorkbenchHostDock({
 function WorkbenchHostDockMinimizedNodePreview({
   capturePreview,
   className,
+  deferPreview = false,
   dockPreviewCache,
   node,
+  providePreview,
   workspaceId
 }) {
+  const [componentPreview, setComponentPreview] = useState8(void 0);
   const [previewImageUrl, setPreviewImageUrl] = useState8(
-    () => readCachedWorkbenchNodePreviewImage(node.id)
+    () => deferPreview || providePreview ? null : readCachedWorkbenchNodePreviewImage(node.id)
   );
   useEffect9(() => {
+    if (deferPreview || !providePreview || componentPreview !== void 0) {
+      return void 0;
+    }
+    let cancelled = false;
+    let frameId = null;
+    let idleId = null;
+    let timeoutId = null;
+    const setDeferredComponentPreview = () => {
+      if (cancelled) {
+        return;
+      }
+      setComponentPreview(providePreview(node) ?? null);
+    };
+    const scheduler = globalThis;
+    if (typeof scheduler.requestIdleCallback === "function") {
+      idleId = scheduler.requestIdleCallback(setDeferredComponentPreview, {
+        timeout: 250
+      });
+    } else if (typeof scheduler.requestAnimationFrame === "function") {
+      frameId = scheduler.requestAnimationFrame(() => {
+        frameId = null;
+        timeoutId = globalThis.setTimeout(setDeferredComponentPreview, 0);
+      });
+    } else {
+      timeoutId = globalThis.setTimeout(setDeferredComponentPreview, 0);
+    }
+    return () => {
+      cancelled = true;
+      if (idleId !== null && typeof scheduler.cancelIdleCallback === "function") {
+        scheduler.cancelIdleCallback(idleId);
+      }
+      if (frameId !== null && typeof scheduler.cancelAnimationFrame === "function") {
+        scheduler.cancelAnimationFrame(frameId);
+      }
+      if (timeoutId !== null) {
+        globalThis.clearTimeout(timeoutId);
+      }
+    };
+  }, [
+    componentPreview,
+    deferPreview,
+    node.data.instanceId,
+    node.data.instanceKey,
+    node.data.typeId,
+    node.id,
+    node.minimizedAtUnixMs,
+    providePreview
+  ]);
+  useEffect9(() => {
+    if (deferPreview || providePreview) {
+      return void 0;
+    }
     let cancelled = false;
     const cachedPreviewImageUrl = readCachedWorkbenchNodePreviewImage(node.id);
     setPreviewImageUrl(cachedPreviewImageUrl);
@@ -9182,14 +10187,22 @@ function WorkbenchHostDockMinimizedNodePreview({
     };
   }, [
     capturePreview,
+    deferPreview,
     dockPreviewCache,
     node.data.instanceId,
     node.data.instanceKey,
     node.data.typeId,
     node.id,
     node.minimizedAtUnixMs,
+    providePreview,
     workspaceId
   ]);
+  if (deferPreview) {
+    return renderMinimizedDockPreviewPlaceholder(className);
+  }
+  if (componentPreview) {
+    return renderMinimizedDockPreviewContent(componentPreview, className);
+  }
   if (previewImageUrl) {
     return /* @__PURE__ */ jsx10(
       "span",
@@ -9212,6 +10225,9 @@ function WorkbenchHostDockMinimizedNodePreview({
       }
     );
   }
+  return renderMinimizedDockPreviewPlaceholder(className);
+}
+function renderMinimizedDockPreviewPlaceholder(className) {
   return /* @__PURE__ */ jsxs6(
     "span",
     {
@@ -9225,9 +10241,101 @@ function WorkbenchHostDockMinimizedNodePreview({
     }
   );
 }
+function renderMinimizedDockPreviewContent(preview, className) {
+  if (preview.kind === "image") {
+    return /* @__PURE__ */ jsx10(
+      "span",
+      {
+        className: [
+          "desktop-dock__minimized-preview",
+          "desktop-dock__minimized-preview--snapshot",
+          className
+        ].filter(Boolean).join(" "),
+        "aria-hidden": "true",
+        children: /* @__PURE__ */ jsx10(
+          "img",
+          {
+            alt: "",
+            className: "desktop-dock__minimized-preview-image",
+            draggable: false,
+            src: preview.src
+          }
+        )
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx10(
+    WorkbenchHostDockFrozenComponentPreview,
+    {
+      className,
+      preview
+    }
+  );
+}
+function WorkbenchHostDockFrozenComponentPreview({
+  className,
+  preview
+}) {
+  const sourceRef = useRef8(null);
+  const [frozenMarkup, setFrozenMarkup] = useState8(null);
+  useLayoutEffect5(() => {
+    if (frozenMarkup !== null) {
+      return;
+    }
+    setFrozenMarkup(sourceRef.current?.innerHTML ?? "");
+  }, [frozenMarkup]);
+  return /* @__PURE__ */ jsx10(
+    "span",
+    {
+      className: [
+        "desktop-dock__minimized-preview",
+        "desktop-dock__minimized-preview--component",
+        className
+      ].filter(Boolean).join(" "),
+      "aria-hidden": "true",
+      children: frozenMarkup === null ? /* @__PURE__ */ jsx10(
+        "span",
+        {
+          ref: sourceRef,
+          className: "desktop-dock__minimized-preview-freeze-source",
+          children: preview.element
+        }
+      ) : /* @__PURE__ */ jsx10(
+        "span",
+        {
+          className: "desktop-dock__minimized-preview-frozen-content",
+          dangerouslySetInnerHTML: { __html: frozenMarkup }
+        }
+      )
+    }
+  );
+}
+function minimizedDockPreviewFreezeKey(node) {
+  return `${node.id}:${node.minimizedAtUnixMs ?? "pending"}`;
+}
 function dockEntryHasHoverPanel(entry) {
   return Boolean(entry.state?.reason?.trim()) || (entry.hoverActions?.length ?? 0) > 0;
 }
+function dockEntryHasContextMenu(entry, resolvedEntry) {
+  if (resolvedEntry.matchedNodes.length > 0 || entry.dockRetention) {
+    return true;
+  }
+  return entry.clickActionId === void 0;
+}
+function resolveDockContextMenuFullscreenNode({
+  focusedNodeId,
+  minimizedNodeIDs,
+  nodeDefinitions,
+  nodes
+}) {
+  const candidates = nodes.filter((node) => {
+    if (node.displayMode === "fullscreen" || minimizedNodeIDs.has(node.id)) {
+      return false;
+    }
+    return nodeDefinitions.get(node.data.typeId)?.window?.fullscreenable !== false;
+  });
+  return candidates.find((node) => node.id === focusedNodeId) ?? candidates[0] ?? null;
+}
 function dockLabelTooltipTarget(key, label) {
   return { key, label: label.trim() };
 }
@@ -9347,23 +10455,25 @@ function WorkbenchHostDockHoverPanel({
                   next.add(actionKey);
                   return next;
                 });
-                void Promise.resolve(
-                  onDockEntryAction?.({
-                    actionId: action.id,
-                    entryId: entry.id,
-                    host
-                  })
-                ).catch(() => {
-                }).finally(() => {
-                  setPendingActionKeys((current) => {
-                    if (!current.has(actionKey)) {
-                      return current;
-                    }
-                    const next = new Set(current);
-                    next.delete(actionKey);
-                    return next;
-                  });
-                });
+                void (async () => {
+                  try {
+                    await onDockEntryAction?.({
+                      actionId: action.id,
+                      entryId: entry.id,
+                      host
+                    });
+                  } catch {
+                  } finally {
+                    setPendingActionKeys((current) => {
+                      if (!current.has(actionKey)) {
+                        return current;
+                      }
+                      const next = new Set(current);
+                      next.delete(actionKey);
+                      return next;
+                    });
+                  }
+                })();
               },
               children: isPending ? action.pendingLabel ?? action.label : action.label
             },
@@ -9838,6 +10948,7 @@ function dockWallpaperToneMapsEqual(left, right) {
   return true;
 }
 var DOCK_BOUNCE_MS = 600;
+var DOCK_ENTRY_CLICK_THROTTLE_MS = DOCK_BOUNCE_MS;
 function useDockBounce(slotRefs) {
   const timeoutsRef = useRef8(/* @__PURE__ */ new Map());
   const clearDockBounce = useCallback10(
@@ -10027,8 +11138,8 @@ function createWorkbenchHostNodeHeaderContext({
 }
 
 // src/host/WorkbenchHostWindowActions.tsx
-import { Button as Button5, CloseIcon as CloseIcon2, MinimizeIcon } from "@tutti-os/ui-system";
-import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Button as Button5, CloseIcon as CloseIcon2, MinimizeIcon as MinimizeIcon2 } from "@tutti-os/ui-system";
+import { Fragment as Fragment4, jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
 function WorkbenchHostWindowActions({
   context,
   host,
@@ -10041,7 +11152,7 @@ function WorkbenchHostWindowActions({
   }
   const minimizable = definition.window?.minimizable !== false;
   const closable = definition.window?.closable !== false;
-  return /* @__PURE__ */ jsxs7(Fragment3, { children: [
+  return /* @__PURE__ */ jsxs7(Fragment4, { children: [
     minimizable ? /* @__PURE__ */ jsx11(
       Button5,
       {
@@ -10057,7 +11168,7 @@ function WorkbenchHostWindowActions({
             () => context.controller.commands.minimizeNode(context.node.id)
           );
         },
-        children: /* @__PURE__ */ jsx11(MinimizeIcon, { className: "size-3.5" })
+        children: /* @__PURE__ */ jsx11(MinimizeIcon2, { className: "size-3.5" })
       }
     ) : null,
     closable ? /* @__PURE__ */ jsx11(
@@ -10140,7 +11251,8 @@ function useWorkbenchHostSurfaceRenderers(input) {
   const captureNodePreviewImage = useCallback11(
     async (node) => {
       const definition = input.nodeDefinitionByType.get(node.data.typeId);
-      const capturePreview = definition?.window?.minimizedDock?.capturePreview;
+      const minimizedDock = definition?.window?.minimizedDock;
+      const capturePreview = minimizedDock?.kind === "snapshot" ? minimizedDock.capturePreview : void 0;
       const snapshot = input.hostSession.getSnapshot();
       const externalState = readWorkbenchHostExternalState({
         externalStateSource: input.externalStateSource,
@@ -10198,6 +11310,7 @@ function useWorkbenchHostSurfaceRenderers(input) {
             nodeDefinitions: input.nodeDefinitionByType,
             onDockEntryAction: input.onDockEntryAction,
             onDockEntryClick: input.onDockEntryClick,
+            onMissionControlRequestOpen: input.onMissionControlRequestOpen,
             workspaceId: input.workspaceId
           }
         )
@@ -10216,6 +11329,7 @@ function useWorkbenchHostSurfaceRenderers(input) {
       input.nodeDefinitionByType,
       input.onDockEntryAction,
       input.onDockEntryClick,
+      input.onMissionControlRequestOpen,
       input.workspaceId
     ]
   );
@@ -10305,17 +11419,30 @@ function useWorkbenchHostSurfaceRenderers(input) {
     },
     [input.nodeDefinitionByType]
   );
+  const shouldCaptureNodePreviewImage = useCallback11(
+    (node) => {
+      const minimizedDock = input.nodeDefinitionByType.get(node.data.typeId)?.window?.minimizedDock;
+      return minimizedDock?.kind !== "component";
+    },
+    [input.nodeDefinitionByType]
+  );
   const resolveDockAnchorKey = useCallback11(
     (node) => {
       if (node.isMinimized && isWorkbenchMinimizedDockEligibleNode({
         node,
         nodeDefinitions: input.nodeDefinitionByType
       })) {
+        const snapshotNodes = input.hostSession.getSnapshot().nodes;
+        const slotNodes = snapshotNodes.some(
+          (snapshotNode) => snapshotNode.id === node.id
+        ) ? snapshotNodes.map(
+          (snapshotNode) => snapshotNode.id === node.id ? node : snapshotNode
+        ) : [...snapshotNodes, node];
         const minimizedAnchorKey = resolveWorkbenchMinimizedDockAnchorKeyForNode({
           nodeId: node.id,
           slots: resolveWorkbenchMinimizedDockSlots({
             nodeDefinitions: input.nodeDefinitionByType,
-            nodes: input.hostSession.getSnapshot().nodes
+            nodes: slotNodes
           })
         });
         if (minimizedAnchorKey) {
@@ -10358,6 +11485,7 @@ function useWorkbenchHostSurfaceRenderers(input) {
     renderTopChrome,
     renderWindowActions,
     renderWindowHeader,
+    shouldCaptureNodePreviewImage,
     shouldKeepMinimizedNodeMounted,
     resolveDockAnchorKey,
     resolveDockPreviewCacheKey: resolveDockPreviewCacheKey2,
@@ -10537,12 +11665,14 @@ function WorkbenchHost({
   i18n,
   layoutConstraints,
   missionControl,
+  minimizeAnimation,
   nodes,
   onDockEntryAction,
   onDockEntryClick,
   onHandleReady,
   onLaunchRequest,
   onMissionControlAdapterReady,
+  onMissionControlRequestOpen,
   onNodeCloseRequest,
   projectedNodes,
   renderBottomChrome,
@@ -10576,6 +11706,7 @@ function WorkbenchHost({
     [contributions, dockEntries]
   );
   const missionControlMode = missionControl?.mode ?? null;
+  const missionControlNodeIds = missionControl?.nodeIds;
   const missionControlClose = missionControl?.onRequestClose ?? noop3;
   const missionControlEnabled = missionControlMode !== null || onMissionControlAdapterReady !== void 0;
   const {
@@ -10617,6 +11748,7 @@ function WorkbenchHost({
     nodeDefinitionByType,
     onDockEntryAction,
     onDockEntryClick,
+    onMissionControlRequestOpen,
     renderBottomChrome,
     renderTopChrome,
     workspaceId
@@ -10624,6 +11756,7 @@ function WorkbenchHost({
   const missionControlState = useWorkbenchMissionControlState({
     adapter: missionControlAdapter,
     mode: missionControlMode,
+    nodeIds: missionControlNodeIds,
     onRequestClose: missionControlClose
   });
   const missionControlPresence = useWorkbenchMissionControlPresence(missionControlState);
@@ -10639,6 +11772,7 @@ function WorkbenchHost({
       interactive: !isHydrating,
       layoutConstraints,
       missionControlPhase: missionControlPresence.phase,
+      minimizeAnimation,
       presentation: missionControlState?.presentation ?? null,
       renderBackdrop: missionControlRenderedState ? () => /* @__PURE__ */ jsx13(
         WorkbenchMissionControlBackdrop,
@@ -10666,6 +11800,7 @@ function WorkbenchHost({
       resolveFullscreenHeaderMode: surfaceRenderers.resolveFullscreenHeaderMode,
       resolveDockAnchorKey: surfaceRenderers.resolveDockAnchorKey,
       shortcutsEnabled,
+      shouldCaptureNodePreviewImage: surfaceRenderers.shouldCaptureNodePreviewImage,
       wallpaper,
       windowChromeI18n,
       windowChromeMode: surfaceRenderers.windowChromeMode