@almadar/ui 5.62.0 → 5.63.2

package/dist/avl/index.cjs

@@ -3409,12 +3409,60 @@ var init_useEventBus = __esm({
     useEventBus_default = useEventBus;
   }
 });
+function useTapReveal(options = {}) {
+  const { onReveal, onDismiss, refs, enabled = true } = options;
+  const [revealed, setRevealed] = React93.useState(false);
+  const onRevealRef = React93.useRef(onReveal);
+  const onDismissRef = React93.useRef(onDismiss);
+  onRevealRef.current = onReveal;
+  onDismissRef.current = onDismiss;
+  const reveal = React93.useCallback(() => {
+    setRevealed((wasRevealed) => {
+      if (!wasRevealed) onRevealRef.current?.();
+      return true;
+    });
+  }, []);
+  const dismiss = React93.useCallback(() => {
+    setRevealed((wasRevealed) => {
+      if (wasRevealed) onDismissRef.current?.();
+      return false;
+    });
+  }, []);
+  const onPointerDown = React93.useCallback(
+    (e) => {
+      if (!enabled || e.pointerType === "mouse") return;
+      if (revealed) dismiss();
+      else reveal();
+    },
+    [enabled, revealed, reveal, dismiss]
+  );
+  React93.useEffect(() => {
+    if (!revealed || typeof document === "undefined") return;
+    const onDocDown = (ev) => {
+      const target = ev.target;
+      if (!(target instanceof Node)) return;
+      const inside = (refs ?? []).some((r2) => r2.current?.contains(target));
+      if (!inside) dismiss();
+    };
+    const id = setTimeout(() => document.addEventListener("pointerdown", onDocDown), 0);
+    return () => {
+      clearTimeout(id);
+      document.removeEventListener("pointerdown", onDocDown);
+    };
+  }, [revealed, refs, dismiss]);
+  return { revealed, triggerProps: { onPointerDown }, reveal, dismiss };
+}
+var init_useTapReveal = __esm({
+  "hooks/useTapReveal.ts"() {
+  }
+});
 var paddingStyles, paddingXStyles, paddingYStyles, marginStyles, marginXStyles, marginYStyles, bgStyles, roundedStyles, shadowStyles, displayStyles, overflowStyles2, positionStyles, Box;
 var init_Box = __esm({
   "components/core/atoms/Box.tsx"() {
     "use client";
     init_cn();
     init_useEventBus();
+    init_useTapReveal();
     paddingStyles = {
       none: "p-0",
       xs: "p-1",
@@ -3540,10 +3588,12 @@ var init_Box = __esm({
         action,
         actionPayload,
         hoverEvent,
+        tapReveal = true,
         maxWidth,
         onClick,
         onMouseEnter,
         onMouseLeave,
+        onPointerDown,
         ...rest
       }, ref) => {
         const eventBus = useEventBus();
@@ -3566,6 +3616,19 @@ var init_Box = __esm({
           }
           onMouseLeave?.(e);
         }, [hoverEvent, eventBus, onMouseLeave]);
+        const { triggerProps } = useTapReveal({
+          enabled: tapReveal && !!hoverEvent,
+          onReveal: React93.useCallback(() => {
+            if (hoverEvent) eventBus.emit(`UI:${hoverEvent}`, { hovered: true });
+          }, [hoverEvent, eventBus]),
+          onDismiss: React93.useCallback(() => {
+            if (hoverEvent) eventBus.emit(`UI:${hoverEvent}`, { hovered: false });
+          }, [hoverEvent, eventBus])
+        });
+        const handlePointerDown = React93.useCallback((e) => {
+          if (hoverEvent && tapReveal) triggerProps.onPointerDown(e);
+          onPointerDown?.(e);
+        }, [hoverEvent, tapReveal, triggerProps, onPointerDown]);
         const isClickable = action || onClick;
         return React93__namespace.default.createElement(
           Component2,
@@ -3593,6 +3656,7 @@ var init_Box = __esm({
             onClick: isClickable ? handleClick : void 0,
             onMouseEnter: hoverEvent || onMouseEnter ? handleMouseEnter : void 0,
             onMouseLeave: hoverEvent || onMouseLeave ? handleMouseLeave : void 0,
+            onPointerDown: hoverEvent && tapReveal || onPointerDown ? handlePointerDown : void 0,
             style: maxWidth ? { maxWidth, ...rest.style } : rest.style,
             ...rest
           },
@@ -8668,6 +8732,11 @@ var init_TextHighlight = __esm({
             if (hoverEvent) eventBus.emit(`UI:${hoverEvent}`, { hovered: false, annotationId });
             onMouseLeave?.();
           },
+          onPointerDown: (e) => {
+            if (e.pointerType === "mouse") return;
+            if (hoverEvent) eventBus.emit(`UI:${hoverEvent}`, { hovered: true, annotationId });
+            onMouseEnter?.();
+          },
           role: "button",
           tabIndex: 0,
           onKeyDown: (e) => {
@@ -8843,6 +8912,7 @@ var init_LawReferenceTooltip = __esm({
     init_Typography();
     init_Divider();
     init_cn();
+    init_useTapReveal();
     positionStyles2 = {
       top: "bottom-full left-1/2 -translate-x-1/2 mb-2",
       bottom: "top-full left-1/2 -translate-x-1/2 mt-2",
@@ -8864,6 +8934,7 @@ var init_LawReferenceTooltip = __esm({
       const { t } = hooks.useTranslate();
       const [isVisible, setIsVisible] = React93__namespace.default.useState(false);
       const timeoutRef = React93__namespace.default.useRef(null);
+      const triggerRef = React93__namespace.default.useRef(null);
       const handleMouseEnter = () => {
         if (timeoutRef.current) clearTimeout(timeoutRef.current);
         timeoutRef.current = setTimeout(() => setIsVisible(true), 200);
@@ -8872,6 +8943,8 @@ var init_LawReferenceTooltip = __esm({
         if (timeoutRef.current) clearTimeout(timeoutRef.current);
         setIsVisible(false);
       };
+      const { revealed, triggerProps } = useTapReveal({ refs: [triggerRef] });
+      const open = isVisible || revealed;
       React93__namespace.default.useEffect(() => {
         return () => {
           if (timeoutRef.current) clearTimeout(timeoutRef.current);
@@ -8880,6 +8953,7 @@ var init_LawReferenceTooltip = __esm({
       return /* @__PURE__ */ jsxRuntime.jsxs(
         Box,
         {
+          ref: triggerRef,
           as: "span",
           position: "relative",
           display: "inline-block",
@@ -8888,9 +8962,10 @@ var init_LawReferenceTooltip = __esm({
           onMouseLeave: handleMouseLeave,
           onFocus: handleMouseEnter,
           onBlur: handleMouseLeave,
+          onPointerDown: triggerProps.onPointerDown,
           children: [
             children,
-            isVisible && /* @__PURE__ */ jsxRuntime.jsxs(
+            open && /* @__PURE__ */ jsxRuntime.jsxs(
               Box,
               {
                 padding: "sm",
@@ -14306,6 +14381,36 @@ function useCamera() {
     cameraRef.current.zoom = Math.max(0.5, Math.min(3, cameraRef.current.zoom * zoomDelta));
     drawFn?.();
   }, []);
+  const handlePointerDown = React93.useCallback((e) => {
+    handleMouseDown(e);
+  }, [handleMouseDown]);
+  const handlePointerUp = React93.useCallback(() => {
+    handleMouseUp();
+  }, [handleMouseUp]);
+  const handlePointerMove = React93.useCallback((e, drawFn) => {
+    return handleMouseMove(e, drawFn);
+  }, [handleMouseMove]);
+  const panBy = React93.useCallback((dx, dy, drawFn) => {
+    cameraRef.current.x -= dx;
+    cameraRef.current.y -= dy;
+    targetCameraRef.current = null;
+    drawFn?.();
+  }, []);
+  const zoomAtPoint = React93.useCallback((factor, centerX, centerY, viewportSize, drawFn) => {
+    const cam = cameraRef.current;
+    const oldZoom = cam.zoom;
+    const newZoom = Math.max(0.5, Math.min(3, oldZoom * factor));
+    if (newZoom === oldZoom) {
+      drawFn?.();
+      return;
+    }
+    const inv = 1 / oldZoom - 1 / newZoom;
+    cam.x += (centerX - viewportSize.width / 2) * inv;
+    cam.y += (centerY - viewportSize.height / 2) * inv;
+    cam.zoom = newZoom;
+    targetCameraRef.current = null;
+    drawFn?.();
+  }, []);
   const screenToWorld = React93.useCallback((clientX, clientY, canvas, viewportSize) => {
     const rect = canvas.getBoundingClientRect();
     const screenX = clientX - rect.left;
@@ -14337,6 +14442,11 @@ function useCamera() {
     handleMouseMove,
     handleMouseLeave,
     handleWheel,
+    handlePointerDown,
+    handlePointerUp,
+    handlePointerMove,
+    panBy,
+    zoomAtPoint,
     screenToWorld,
     lerpToTarget
   };
@@ -14346,6 +14456,113 @@ var init_useCamera = __esm({
     "use client";
   }
 });
+function localPoint(canvas, clientX, clientY) {
+  if (!canvas) return { x: clientX, y: clientY };
+  const rect = canvas.getBoundingClientRect();
+  return { x: clientX - rect.left, y: clientY - rect.top };
+}
+function useCanvasGestures(options) {
+  const {
+    canvasRef,
+    enabled = true,
+    wheelStep = 1.1,
+    onPointerDown,
+    onPointerMove,
+    onPointerUp,
+    onZoom,
+    onPanDelta,
+    onMultiTouchStart
+  } = options;
+  const pointers = React93.useRef(/* @__PURE__ */ new Map());
+  const pinch = React93.useRef(null);
+  const computePinch = React93.useCallback(() => {
+    const pts = [...pointers.current.values()];
+    const dx = pts[1].x - pts[0].x;
+    const dy = pts[1].y - pts[0].y;
+    return {
+      distance: Math.hypot(dx, dy) || 1,
+      centroid: { x: (pts[0].x + pts[1].x) / 2, y: (pts[0].y + pts[1].y) / 2 }
+    };
+  }, []);
+  const handlePointerDown = React93.useCallback(
+    (e) => {
+      if (!enabled) return;
+      e.currentTarget.setPointerCapture(e.pointerId);
+      pointers.current.set(e.pointerId, localPoint(canvasRef.current, e.clientX, e.clientY));
+      if (pointers.current.size === 2) {
+        onMultiTouchStart?.();
+        pinch.current = computePinch();
+      } else if (pointers.current.size === 1) {
+        onPointerDown?.(e);
+      }
+    },
+    [enabled, canvasRef, onMultiTouchStart, computePinch, onPointerDown]
+  );
+  const handlePointerMove = React93.useCallback(
+    (e) => {
+      if (!enabled) return;
+      if (pointers.current.has(e.pointerId)) {
+        pointers.current.set(e.pointerId, localPoint(canvasRef.current, e.clientX, e.clientY));
+      }
+      if (pointers.current.size >= 2 && pinch.current) {
+        const next = computePinch();
+        const prev = pinch.current;
+        if (next.distance !== prev.distance) {
+          onZoom?.(next.distance / prev.distance, next.centroid.x, next.centroid.y);
+        }
+        onPanDelta?.(next.centroid.x - prev.centroid.x, next.centroid.y - prev.centroid.y);
+        pinch.current = next;
+        return;
+      }
+      onPointerMove?.(e);
+    },
+    [enabled, canvasRef, computePinch, onZoom, onPanDelta, onPointerMove]
+  );
+  const endPointer = React93.useCallback(
+    (e, fireUp) => {
+      const wasMulti = pointers.current.size >= 2;
+      pointers.current.delete(e.pointerId);
+      if (pointers.current.size < 2) pinch.current = null;
+      if (wasMulti && pointers.current.size === 1) return;
+      if (pointers.current.size === 0 && fireUp) onPointerUp?.(e);
+    },
+    [onPointerUp]
+  );
+  const handlePointerUp = React93.useCallback(
+    (e) => {
+      if (!enabled) return;
+      endPointer(e, true);
+    },
+    [enabled, endPointer]
+  );
+  const handlePointerCancel = React93.useCallback(
+    (e) => {
+      if (!enabled) return;
+      endPointer(e, false);
+    },
+    [enabled, endPointer]
+  );
+  const handleWheel = React93.useCallback(
+    (e) => {
+      if (!enabled) return;
+      e.preventDefault();
+      const { x, y } = localPoint(canvasRef.current, e.clientX, e.clientY);
+      onZoom?.(e.deltaY < 0 ? wheelStep : 1 / wheelStep, x, y);
+    },
+    [enabled, canvasRef, wheelStep, onZoom]
+  );
+  return {
+    onPointerDown: handlePointerDown,
+    onPointerMove: handlePointerMove,
+    onPointerUp: handlePointerUp,
+    onPointerCancel: handlePointerCancel,
+    onWheel: handleWheel
+  };
+}
+var init_useCanvasGestures = __esm({
+  "hooks/useCanvasGestures.ts"() {
+  }
+});
 function unitAtlasUrl(unit) {
   if (unit.spriteSheet) return unit.spriteSheet;
   const sprite = unit.sprite;
@@ -14724,11 +14941,12 @@ function IsometricCanvas({
     cameraRef,
     targetCameraRef,
     dragDistance,
-    handleMouseDown,
-    handleMouseUp,
-    handleMouseMove,
     handleMouseLeave,
-    handleWheel,
+    handlePointerDown,
+    handlePointerUp,
+    handlePointerMove,
+    panBy,
+    zoomAtPoint,
     screenToWorld,
     lerpToTarget
   } = useCamera();
@@ -15163,11 +15381,16 @@ function IsometricCanvas({
       cancelAnimationFrame(rafIdRef.current);
     };
   }, [draw, units.length, validMoves.length, attackTargets.length, selectedUnitId, hasActiveEffects2, pendingCount, atlasPending, lerpToTarget, targetCameraRef]);
-  const handleMouseMoveWithCamera = React93.useCallback((e) => {
-    if (enableCamera) {
-      const wasPanning = handleMouseMove(e, () => draw(animTimeRef.current));
-      if (wasPanning) return;
-    }
+  const singlePointerActiveRef = React93.useRef(false);
+  const handleCanvasPointerDown = React93.useCallback((e) => {
+    singlePointerActiveRef.current = true;
+    if (enableCamera) handlePointerDown(e);
+  }, [enableCamera, handlePointerDown]);
+  const handleCanvasPointerMove = React93.useCallback((e) => {
+    if (enableCamera) handlePointerMove(e, () => draw(animTimeRef.current));
+  }, [enableCamera, handlePointerMove, draw]);
+  const handleCanvasHover = React93.useCallback((e) => {
+    if (singlePointerActiveRef.current) return;
     if (!onTileHover && !tileHoverEvent || !canvasRef.current) return;
     const world = screenToWorld(e.clientX, e.clientY, canvasRef.current, viewportSize);
     const adjustedX = world.x - scaledTileWidth / 2;
@@ -15178,26 +15401,10 @@ function IsometricCanvas({
       if (tileHoverEvent) eventBus.emit(`UI:${tileHoverEvent}`, { x: isoPos.x, y: isoPos.y });
       onTileHover?.(isoPos.x, isoPos.y);
     }
-  }, [enableCamera, handleMouseMove, draw, onTileHover, screenToWorld, viewportSize, scaledTileWidth, scaledDiamondTopY, scaledFloorHeight, scale, baseOffsetX, tilesProp, tileHoverEvent, eventBus]);
-  const handleMouseLeaveWithCamera = React93.useCallback(() => {
-    handleMouseLeave();
-    if (tileLeaveEvent) eventBus.emit(`UI:${tileLeaveEvent}`, {});
-    onTileLeave?.();
-  }, [handleMouseLeave, onTileLeave, tileLeaveEvent, eventBus]);
-  const handleWheelWithCamera = React93.useCallback((e) => {
-    if (enableCamera) {
-      handleWheel(e, () => draw(animTimeRef.current));
-    }
-  }, [enableCamera, handleWheel, draw]);
-  React93.useEffect(() => {
-    const canvas = canvasRef.current;
-    if (!canvas) return;
-    canvas.addEventListener("wheel", handleWheelWithCamera, { passive: false });
-    return () => {
-      canvas.removeEventListener("wheel", handleWheelWithCamera);
-    };
-  }, [handleWheelWithCamera]);
-  const handleClick = React93.useCallback((e) => {
+  }, [onTileHover, screenToWorld, viewportSize, scaledTileWidth, scaledDiamondTopY, scaledFloorHeight, scale, baseOffsetX, tilesProp, tileHoverEvent, eventBus]);
+  const handleCanvasPointerUp = React93.useCallback((e) => {
+    singlePointerActiveRef.current = false;
+    if (enableCamera) handlePointerUp();
     if (dragDistance() > 5) return;
     if (!canvasRef.current) return;
     const world = screenToWorld(e.clientX, e.clientY, canvasRef.current, viewportSize);
@@ -15215,7 +15422,32 @@ function IsometricCanvas({
         onTileClick?.(isoPos.x, isoPos.y);
       }
     }
-  }, [dragDistance, screenToWorld, viewportSize, scaledTileWidth, scaledDiamondTopY, scaledFloorHeight, scale, baseOffsetX, units, tilesProp, onUnitClick, onTileClick, unitClickEvent, tileClickEvent, eventBus]);
+  }, [enableCamera, handlePointerUp, dragDistance, screenToWorld, viewportSize, scaledTileWidth, scaledDiamondTopY, scaledFloorHeight, scale, baseOffsetX, units, tilesProp, onUnitClick, onTileClick, unitClickEvent, tileClickEvent, eventBus]);
+  const handleCanvasPointerLeave = React93.useCallback(() => {
+    handleMouseLeave();
+    if (tileLeaveEvent) eventBus.emit(`UI:${tileLeaveEvent}`, {});
+    onTileLeave?.();
+  }, [handleMouseLeave, onTileLeave, tileLeaveEvent, eventBus]);
+  const applyZoom = React93.useCallback((factor, centerX, centerY) => {
+    if (enableCamera) zoomAtPoint(factor, centerX, centerY, viewportSize, () => draw(animTimeRef.current));
+  }, [enableCamera, zoomAtPoint, viewportSize, draw]);
+  const applyPanDelta = React93.useCallback((dx, dy) => {
+    if (enableCamera) panBy(dx, dy, () => draw(animTimeRef.current));
+  }, [enableCamera, panBy, draw]);
+  const cancelSinglePointer = React93.useCallback(() => {
+    singlePointerActiveRef.current = false;
+    if (enableCamera) handlePointerUp();
+  }, [enableCamera, handlePointerUp]);
+  const gestureHandlers = useCanvasGestures({
+    canvasRef,
+    enabled: enableCamera || !!onTileHover || !!tileHoverEvent || !!onTileClick || !!tileClickEvent || !!onUnitClick || !!unitClickEvent,
+    onPointerDown: handleCanvasPointerDown,
+    onPointerMove: handleCanvasPointerMove,
+    onPointerUp: handleCanvasPointerUp,
+    onZoom: applyZoom,
+    onPanDelta: applyPanDelta,
+    onMultiTouchStart: cancelSinglePointer
+  });
   if (error) {
     return /* @__PURE__ */ jsxRuntime.jsx(ErrorState, { title: t("canvas.errorTitle"), message: error.message, className });
   }
@@ -15247,13 +15479,17 @@ function IsometricCanvas({
           {
             ref: canvasRef,
             "data-testid": "game-canvas",
-            onClick: handleClick,
-            onMouseDown: enableCamera ? handleMouseDown : void 0,
-            onMouseMove: handleMouseMoveWithCamera,
-            onMouseUp: enableCamera ? handleMouseUp : void 0,
-            onMouseLeave: handleMouseLeaveWithCamera,
+            onPointerDown: gestureHandlers.onPointerDown,
+            onPointerMove: (e) => {
+              gestureHandlers.onPointerMove(e);
+              handleCanvasHover(e);
+            },
+            onPointerUp: gestureHandlers.onPointerUp,
+            onPointerCancel: gestureHandlers.onPointerCancel,
+            onPointerLeave: handleCanvasPointerLeave,
+            onWheel: gestureHandlers.onWheel,
             onContextMenu: (e) => e.preventDefault(),
-            className: "cursor-pointer",
+            className: "cursor-pointer touch-none",
             style: {
               width: viewportSize.width,
               height: viewportSize.height
@@ -15307,6 +15543,7 @@ var init_IsometricCanvas = __esm({
     init_ErrorState();
     init_useImageCache();
     init_useCamera();
+    init_useCanvasGestures();
     init_useUnitSpriteAtlas();
     init_verificationRegistry();
     init_isometric();
@@ -17593,6 +17830,10 @@ var init_StateMachineView = __esm({
         const handleMouseLeave2 = () => {
           onHover(null, 0, 0);
         };
+        const handlePointerDown2 = (e) => {
+          if (e.pointerType === "mouse") return;
+          handleMouseEnter2();
+        };
         return /* @__PURE__ */ jsxRuntime.jsxs(
           "g",
           {
@@ -17602,6 +17843,7 @@ var init_StateMachineView = __esm({
             onClick: () => onClick?.(bundle),
             onMouseEnter: handleMouseEnter2,
             onMouseLeave: handleMouseLeave2,
+            onPointerDown: handlePointerDown2,
             style: { pointerEvents: "auto" },
             children: [
               /* @__PURE__ */ jsxRuntime.jsx("defs", { children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -17719,6 +17961,10 @@ var init_StateMachineView = __esm({
       const handleMouseLeave = React93.useCallback(() => {
         onHover(null, 0, 0);
       }, [onHover]);
+      const handlePointerDown = React93.useCallback((e) => {
+        if (e.pointerType === "mouse") return;
+        handleMouseEnter();
+      }, [handleMouseEnter]);
       const uniqueMarkerId = `arrow-${bundle.id}`;
       const hasDetails = bundle.labels.some((l) => l.hasDetails);
       return /* @__PURE__ */ jsxRuntime.jsxs(
@@ -17730,6 +17976,7 @@ var init_StateMachineView = __esm({
           onClick: () => onClick?.(bundle),
           onMouseEnter: handleMouseEnter,
           onMouseLeave: handleMouseLeave,
+          onPointerDown: handlePointerDown,
           style: { pointerEvents: "auto" },
           children: [
             /* @__PURE__ */ jsxRuntime.jsx("defs", { children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -26228,10 +26475,84 @@ function SubMenu({
   );
   return typeof document !== "undefined" ? reactDom.createPortal(panel, document.body) : panel;
 }
+function MenuItemRow({
+  item,
+  itemId,
+  hasSubMenu,
+  isDanger,
+  direction,
+  isSubMenuOpen,
+  activeSubMenuRef,
+  eventBus,
+  onItemClick,
+  openSubMenu
+}) {
+  const rowRef = React93.useRef(null);
+  const { triggerProps } = useTapReveal({
+    enabled: hasSubMenu,
+    onReveal: () => openSubMenu(itemId, rowRef.current),
+    refs: [rowRef]
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxs(Box, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Box,
+      {
+        ref: rowRef,
+        as: "button",
+        onClick: () => onItemClick({ ...item, id: itemId }, itemId),
+        "aria-disabled": item.disabled || void 0,
+        onMouseEnter: (e) => {
+          if (hasSubMenu) openSubMenu(itemId, e.currentTarget);
+        },
+        onPointerDown: hasSubMenu ? triggerProps.onPointerDown : void 0,
+        "data-testid": item.event ? `action-${item.event}` : void 0,
+        className: cn(
+          "w-full flex items-center justify-between gap-3 px-4 py-2 text-start",
+          "text-sm transition-colors",
+          "hover:bg-muted",
+          "focus:outline-none focus:bg-muted",
+          "disabled:opacity-50 disabled:cursor-not-allowed",
+          item.disabled && "cursor-not-allowed",
+          isDanger && "text-error hover:bg-error/10"
+        ),
+        children: /* @__PURE__ */ jsxRuntime.jsxs(Box, { className: "flex items-center gap-3 flex-1 min-w-0", children: [
+          item.icon && (typeof item.icon === "string" ? /* @__PURE__ */ jsxRuntime.jsx(Icon, { name: item.icon, size: "sm", className: "flex-shrink-0" }) : /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: item.icon, size: "sm", className: "flex-shrink-0" })),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            Typography,
+            {
+              variant: "small",
+              className: cn("flex-1", isDanger && "text-red-600"),
+              children: item.label
+            }
+          ),
+          item.badge !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "default", size: "sm", children: item.badge }),
+          hasSubMenu && /* @__PURE__ */ jsxRuntime.jsx(
+            Icon,
+            {
+              name: direction === "rtl" ? "chevron-left" : "chevron-right",
+              size: "sm",
+              className: "flex-shrink-0"
+            }
+          )
+        ] })
+      }
+    ),
+    hasSubMenu && isSubMenuOpen && item.subMenu && /* @__PURE__ */ jsxRuntime.jsx(
+      SubMenu,
+      {
+        items: item.subMenu,
+        itemRef: activeSubMenuRef,
+        direction,
+        eventBus
+      }
+    )
+  ] });
+}
 var MENU_GAP, menuContainerStyles, Menu;
 var init_Menu = __esm({
   "components/core/molecules/Menu.tsx"() {
     "use client";
+    init_useTapReveal();
     init_Box();
     init_Icon();
     init_Divider();
@@ -26286,6 +26607,10 @@ var init_Menu = __esm({
           setIsOpen(false);
         }
       };
+      const openSubMenu = (itemId, el) => {
+        setActiveSubMenu(itemId);
+        setActiveSubMenuRef(el);
+      };
       React93.useEffect(() => {
         if (isOpen) {
           updatePosition();
@@ -26329,61 +26654,22 @@ var init_Menu = __esm({
         if (isDivider) {
           return /* @__PURE__ */ jsxRuntime.jsx(Divider, { className: "my-1" }, `divider-${index}`);
         }
-        return /* @__PURE__ */ jsxRuntime.jsxs(Box, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(
-            Box,
-            {
-              as: "button",
-              onClick: () => handleItemClick({ ...item, id: itemId }, itemId),
-              "aria-disabled": item.disabled || void 0,
-              onMouseEnter: (e) => {
-                if (hasSubMenu) {
-                  setActiveSubMenu(itemId);
-                  setActiveSubMenuRef(e.currentTarget);
-                }
-              },
-              "data-testid": item.event ? `action-${item.event}` : void 0,
-              className: cn(
-                "w-full flex items-center justify-between gap-3 px-4 py-2 text-start",
-                "text-sm transition-colors",
-                "hover:bg-muted",
-                "focus:outline-none focus:bg-muted",
-                "disabled:opacity-50 disabled:cursor-not-allowed",
-                item.disabled && "cursor-not-allowed",
-                isDanger && "text-error hover:bg-error/10"
-              ),
-              children: /* @__PURE__ */ jsxRuntime.jsxs(Box, { className: "flex items-center gap-3 flex-1 min-w-0", children: [
-                item.icon && (typeof item.icon === "string" ? /* @__PURE__ */ jsxRuntime.jsx(Icon, { name: item.icon, size: "sm", className: "flex-shrink-0" }) : /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: item.icon, size: "sm", className: "flex-shrink-0" })),
-                /* @__PURE__ */ jsxRuntime.jsx(
-                  Typography,
-                  {
-                    variant: "small",
-                    className: cn("flex-1", isDanger && "text-red-600"),
-                    children: item.label
-                  }
-                ),
-                item.badge !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "default", size: "sm", children: item.badge }),
-                hasSubMenu && /* @__PURE__ */ jsxRuntime.jsx(
-                  Icon,
-                  {
-                    name: direction === "rtl" ? "chevron-left" : "chevron-right",
-                    size: "sm",
-                    className: "flex-shrink-0"
-                  }
-                )
-              ] })
-            }
-          ),
-          hasSubMenu && activeSubMenu === itemId && item.subMenu && /* @__PURE__ */ jsxRuntime.jsx(
-            SubMenu,
-            {
-              items: item.subMenu,
-              itemRef: activeSubMenuRef,
-              direction,
-              eventBus
-            }
-          )
-        ] }, itemId);
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          MenuItemRow,
+          {
+            item,
+            itemId,
+            hasSubMenu,
+            isDanger,
+            direction,
+            isSubMenuOpen: activeSubMenu === itemId,
+            activeSubMenuRef,
+            eventBus,
+            onItemClick: handleItemClick,
+            openSubMenu
+          },
+          itemId
+        );
       });
       const panel = isOpen && triggerRect ? /* @__PURE__ */ jsxRuntime.jsxs(
         "div",
@@ -28686,6 +28972,7 @@ var init_Popover = __esm({
     "use client";
     init_Typography();
     init_cn();
+    init_useTapReveal();
     arrowClasses = {
       top: "top-full left-1/2 -translate-x-1/2 border-t-white border-l-transparent border-r-transparent border-b-transparent",
       bottom: "bottom-full left-1/2 -translate-x-1/2 border-b-white border-l-transparent border-r-transparent border-t-transparent",
@@ -28756,18 +29043,32 @@ var init_Popover = __esm({
         document.addEventListener("mousedown", handleClickOutside);
         return () => document.removeEventListener("mousedown", handleClickOutside);
       }, [isOpen, trigger]);
-      const triggerProps = trigger === "click" ? {
+      const { triggerProps: tapTriggerProps } = useTapReveal({
+        enabled: trigger === "hover",
+        onReveal: handleOpen,
+        onDismiss: handleClose,
+        refs: [triggerRef, popoverRef]
+      });
+      const handlerProps = trigger === "click" ? {
         onClick: handleToggle
       } : {
         onMouseEnter: handleOpen,
-        onMouseLeave: handleClose
+        onMouseLeave: handleClose,
+        onPointerDown: tapTriggerProps.onPointerDown
       };
       const childElement = React93__namespace.default.isValidElement(children) ? children : /* @__PURE__ */ jsxRuntime.jsx("span", { children });
+      const childPointerDown = childElement.props.onPointerDown;
       const triggerElement = React93__namespace.default.cloneElement(
         childElement,
         {
           ref: triggerRef,
-          ...triggerProps
+          ...handlerProps,
+          ...trigger === "hover" ? {
+            onPointerDown: (e) => {
+              tapTriggerProps.onPointerDown(e);
+              childPointerDown?.(e);
+            }
+          } : void 0
         }
       );
       const panel = isOpen && triggerRect ? /* @__PURE__ */ jsxRuntime.jsxs(
@@ -29298,6 +29599,7 @@ var init_Tooltip = __esm({
     "use client";
     init_Typography();
     init_cn();
+    init_useTapReveal();
     TRIGGER_GAP2 = 8;
     arrowClasses2 = {
       top: "top-full left-1/2 -translate-x-1/2 border-t-primary border-l-transparent border-r-transparent border-b-transparent",
@@ -29342,6 +29644,11 @@ var init_Tooltip = __esm({
           setIsVisible(false);
         }, hideDelay);
       };
+      const { triggerProps } = useTapReveal({
+        onReveal: handleMouseEnter,
+        onDismiss: handleMouseLeave,
+        refs: [triggerRef, tooltipRef]
+      });
       React93.useLayoutEffect(() => {
         if (isVisible) {
           updatePosition();
@@ -29354,12 +29661,17 @@ var init_Tooltip = __esm({
         };
       }, []);
       const triggerElement = React93__namespace.default.isValidElement(children) ? children : /* @__PURE__ */ jsxRuntime.jsx("span", { children });
+      const childPointerDown = triggerElement.props.onPointerDown;
       const trigger = React93__namespace.default.cloneElement(triggerElement, {
         ref: triggerRef,
         onMouseEnter: handleMouseEnter,
         onMouseLeave: handleMouseLeave,
         onFocus: handleMouseEnter,
-        onBlur: handleMouseLeave
+        onBlur: handleMouseLeave,
+        onPointerDown: (e) => {
+          triggerProps.onPointerDown(e);
+          childPointerDown?.(e);
+        }
       });
       const tooltipContent = isVisible && triggerRect ? /* @__PURE__ */ jsxRuntime.jsxs(
         "div",
@@ -32709,6 +33021,14 @@ var init_GraphView = __esm({
         },
         [onNodeClick]
       );
+      const handleNodePointerDown = React93.useCallback(
+        (e, node) => {
+          if (e.pointerType === "mouse") return;
+          handleNodeMouseEnter(node);
+          handleNodeClickInternal(node);
+        },
+        [handleNodeMouseEnter, handleNodeClickInternal]
+      );
       if (nodes.length === 0) {
         return /* @__PURE__ */ jsxRuntime.jsx(Box, { className: cn("flex items-center justify-center", className), style: { width: w, height: h }, children: /* @__PURE__ */ jsxRuntime.jsx(Box, { className: "text-muted-foreground text-sm", children: t("display.noGraphData") }) });
       }
@@ -32768,6 +33088,7 @@ var init_GraphView = __esm({
                       onMouseEnter: () => handleNodeMouseEnter(node),
                       onMouseLeave: handleNodeMouseLeave,
                       onClick: () => handleNodeClickInternal(node),
+                      onPointerDown: (e) => handleNodePointerDown(e, node),
                       children: [
                         /* @__PURE__ */ jsxRuntime.jsx(
                           "circle",
@@ -32848,13 +33169,13 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect87, useRef: useRef80, useCallback: useCallback130, useState: useState122 } = React93__namespace.default;
+      const { useEffect: useEffect88, useRef: useRef82, useCallback: useCallback132, useState: useState123 } = React93__namespace.default;
       const { Typography: Typography2 } = await Promise.resolve().then(() => (init_Typography(), Typography_exports));
       const { useEventBus: useEventBus4 } = await Promise.resolve().then(() => (init_useEventBus(), useEventBus_exports));
       function MapUpdater({ centerLat, centerLng, zoom }) {
         const map = useMap();
-        const prevRef = useRef80({ centerLat, centerLng, zoom });
-        useEffect87(() => {
+        const prevRef = useRef82({ centerLat, centerLng, zoom });
+        useEffect88(() => {
           const prev = prevRef.current;
           if (prev.centerLat !== centerLat || prev.centerLng !== centerLng || prev.zoom !== zoom) {
             map.setView([centerLat, centerLng], zoom);
@@ -32865,7 +33186,7 @@ var init_MapView = __esm({
       }
       function MapClickHandler({ onMapClick }) {
         const map = useMap();
-        useEffect87(() => {
+        useEffect88(() => {
           if (!onMapClick) return;
           const handler = (e) => {
             onMapClick(e.latlng.lat, e.latlng.lng);
@@ -32893,8 +33214,8 @@ var init_MapView = __esm({
         showAttribution = true
       }) {
         const eventBus = useEventBus4();
-        const [clickedPosition, setClickedPosition] = useState122(null);
-        const handleMapClick = useCallback130((lat, lng) => {
+        const [clickedPosition, setClickedPosition] = useState123(null);
+        const handleMapClick = useCallback132((lat, lng) => {
           if (showClickedPin) {
             setClickedPosition({ lat, lng });
           }
@@ -32903,7 +33224,7 @@ var init_MapView = __esm({
             eventBus.emit(`UI:${mapClickEvent}`, { latitude: lat, longitude: lng });
           }
         }, [onMapClick, mapClickEvent, eventBus, showClickedPin]);
-        const handleMarkerClick = useCallback130((marker) => {
+        const handleMarkerClick = useCallback132((marker) => {
           onMarkerClick?.(marker);
           if (markerClickEvent) {
             eventBus.emit(`UI:${markerClickEvent}`, { ...marker });
@@ -33244,7 +33565,7 @@ var init_StarRating = __esm({
           "aria-valuenow": value,
           tabIndex: readOnly ? void 0 : 0,
           onKeyDown: handleKeyDown,
-          onMouseLeave: () => setHoverValue(null),
+          onPointerLeave: () => setHoverValue(null),
           children: Array.from({ length: max }, (_, i) => {
             const fillLevel = Math.max(0, Math.min(1, displayValue - i));
             const isFull = fillLevel >= 1;
@@ -33254,7 +33575,7 @@ var init_StarRating = __esm({
               {
                 className: "relative inline-block",
                 onClick: () => handleStarClick(i, false),
-                onMouseMove: (e) => {
+                onPointerMove: (e) => {
                   if (readOnly) return;
                   const rect = e.currentTarget.getBoundingClientRect();
                   const isLeftHalf = e.clientX - rect.left < rect.width / 2;
@@ -37144,7 +37465,7 @@ var init_PositionedCanvas = __esm({
           {
             ref: containerRef,
             "data-testid": "positioned-canvas",
-            className: "relative bg-background border border-border rounded-container overflow-hidden",
+            className: "relative bg-background border border-border rounded-container overflow-hidden touch-none",
             style: { width, height },
             onClick: handleContainerClick,
             children: items.map((item) => {
@@ -40882,6 +41203,13 @@ var init_DocumentViewer = __esm({
     DocumentViewer.displayName = "DocumentViewer";
   }
 });
+function measureLabelWidth(text) {
+  if (typeof document === "undefined") return text.length * 6;
+  if (!labelMeasureCtx) labelMeasureCtx = document.createElement("canvas").getContext("2d");
+  if (!labelMeasureCtx) return text.length * 6;
+  labelMeasureCtx.font = "10px system-ui";
+  return labelMeasureCtx.measureText(text).width;
+}
 function getGroupColor(group, groups) {
   if (!group) return GROUP_COLORS2[0];
   const idx = groups.indexOf(group);
@@ -40893,7 +41221,7 @@ function resolveColor2(color, el) {
   const resolved = getComputedStyle(el).getPropertyValue(m[1]).trim();
   return resolved || (m[2]?.trim() ?? "#888888");
 }
-var GROUP_COLORS2, GraphCanvas;
+var GROUP_COLORS2, labelMeasureCtx, GraphCanvas;
 var init_GraphCanvas = __esm({
   "components/core/molecules/GraphCanvas.tsx"() {
     "use client";
@@ -40904,6 +41232,7 @@ var init_GraphCanvas = __esm({
     init_ErrorState();
     init_EmptyState();
     init_useEventBus();
+    init_useCanvasGestures();
     GROUP_COLORS2 = [
       "var(--color-primary)",
       "var(--color-success)",
@@ -40912,6 +41241,7 @@ var init_GraphCanvas = __esm({
       "var(--color-info)",
       "var(--color-accent)"
     ];
+    labelMeasureCtx = null;
     GraphCanvas = ({
       title,
       nodes: propNodes = [],
@@ -40941,6 +41271,10 @@ var init_GraphCanvas = __esm({
       const animRef = React93.useRef(0);
       const [zoom, setZoom] = React93.useState(1);
       const [offset, setOffset] = React93.useState({ x: 0, y: 0 });
+      const zoomRef = React93.useRef(zoom);
+      zoomRef.current = zoom;
+      const offsetRef = React93.useRef(offset);
+      offsetRef.current = offset;
       const [hoveredNode, setHoveredNode] = React93.useState(null);
       const nodesRef = React93.useRef([]);
       const [, forceUpdate] = React93.useState(0);
@@ -41088,22 +41422,36 @@ var init_GraphCanvas = __esm({
               node.x = Math.max(30, Math.min(w - 30, node.x));
               node.y = Math.max(30, Math.min(h - 30, node.y));
             }
+            const LABEL_GAP = 12;
+            const LABEL_H = 12;
+            const pad = nodeSpacing / 2;
             for (let i = 0; i < nodes.length; i++) {
               for (let j = i + 1; j < nodes.length; j++) {
                 const a = nodes[i];
                 const b = nodes[j];
-                const dx = b.x - a.x;
-                const dy = b.y - a.y;
-                const dist = Math.sqrt(dx * dx + dy * dy) || 1;
-                const minDist = (a.size || 8) + (b.size || 8) + nodeSpacing;
-                if (dist < minDist) {
-                  const push2 = (minDist - dist) / 2;
-                  const ux = dx / dist;
-                  const uy = dy / dist;
-                  a.x = Math.max(30, Math.min(w - 30, a.x - ux * push2));
-                  a.y = Math.max(30, Math.min(h - 30, a.y - uy * push2));
-                  b.x = Math.max(30, Math.min(w - 30, b.x + ux * push2));
-                  b.y = Math.max(30, Math.min(h - 30, b.y + uy * push2));
+                const ar = a.size || 8;
+                const br = b.size || 8;
+                if (showLabels) {
+                  if (a.labelW === void 0) a.labelW = a.label ? measureLabelWidth(a.label) : 0;
+                  if (b.labelW === void 0) b.labelW = b.label ? measureLabelWidth(b.label) : 0;
+                }
+                const labelBelow = showLabels ? LABEL_GAP + LABEL_H : 0;
+                const aHalfW = Math.max(ar, (a.labelW ?? 0) / 2) + pad;
+                const bHalfW = Math.max(br, (b.labelW ?? 0) / 2) + pad;
+                const aTop = a.y - ar - pad, aBot = a.y + ar + labelBelow + pad;
+                const bTop = b.y - br - pad, bBot = b.y + br + labelBelow + pad;
+                const overlapX = Math.min(a.x + aHalfW, b.x + bHalfW) - Math.max(a.x - aHalfW, b.x - bHalfW);
+                const overlapY = Math.min(aBot, bBot) - Math.max(aTop, bTop);
+                if (overlapX > 0 && overlapY > 0) {
+                  if (overlapX <= overlapY) {
+                    const push2 = overlapX / 2 * (b.x >= a.x ? 1 : -1);
+                    a.x = Math.max(30, Math.min(w - 30, a.x - push2));
+                    b.x = Math.max(30, Math.min(w - 30, b.x + push2));
+                  } else {
+                    const push2 = overlapY / 2 * (bTop + bBot >= aTop + aBot ? 1 : -1);
+                    a.y = Math.max(30, Math.min(h - 30, a.y - push2));
+                    b.y = Math.max(30, Math.min(h - 30, b.y + push2));
+                  }
                 }
               }
             }
@@ -41120,7 +41468,7 @@ var init_GraphCanvas = __esm({
         return () => {
           cancelAnimationFrame(animRef.current);
         };
-      }, [propNodes, propEdges, layout, repulsion, linkDistance, nodeSpacing, logicalW, height]);
+      }, [propNodes, propEdges, layout, repulsion, linkDistance, nodeSpacing, showLabels, logicalW, height]);
       React93.useEffect(() => {
         const canvas = canvasRef.current;
         if (!canvas) return;
@@ -41200,25 +41548,27 @@ var init_GraphCanvas = __esm({
         setZoom(1);
         setOffset({ x: 0, y: 0 });
       }, []);
-      const handleWheel = React93.useCallback(
-        (e) => {
-          if (!interactive) return;
-          e.preventDefault();
-          const coords = toCoords(e);
-          if (!coords) return;
-          const oldZoom = zoom;
-          const factor = e.deltaY < 0 ? 1.1 : 1 / 1.1;
-          const newZoom = Math.max(0.3, Math.min(3, oldZoom * factor));
-          if (newZoom === oldZoom) return;
-          setOffset((o) => ({
-            x: coords.screenX - (coords.screenX - o.x) * (newZoom / oldZoom),
-            y: coords.screenY - (coords.screenY - o.y) * (newZoom / oldZoom)
-          }));
-          setZoom(newZoom);
-        },
-        [interactive, toCoords, zoom]
-      );
-      const handleMouseDown = React93.useCallback(
+      const applyZoom = React93.useCallback((factor, cx, cy) => {
+        if (!interactive) return;
+        const oldZoom = zoomRef.current;
+        const newZoom = Math.max(0.3, Math.min(3, oldZoom * factor));
+        if (newZoom === oldZoom) return;
+        const o = offsetRef.current;
+        setOffset({
+          x: cx - (cx - o.x) * (newZoom / oldZoom),
+          y: cy - (cy - o.y) * (newZoom / oldZoom)
+        });
+        setZoom(newZoom);
+      }, [interactive]);
+      const applyPanDelta = React93.useCallback((dx, dy) => {
+        if (!interactive) return;
+        setOffset((o) => ({ x: o.x + dx, y: o.y + dy }));
+      }, [interactive]);
+      const cancelSinglePointer = React93.useCallback(() => {
+        interactionRef.current.mode = "none";
+        interactionRef.current.dragNodeId = null;
+      }, []);
+      const handlePointerDown = React93.useCallback(
         (e) => {
           const coords = toCoords(e);
           if (!coords) return;
@@ -41240,7 +41590,7 @@ var init_GraphCanvas = __esm({
         },
         [toCoords, nodeAt, draggable, interactive, offset]
       );
-      const handleMouseMove = React93.useCallback(
+      const handlePointerMove = React93.useCallback(
         (e) => {
           const state = interactionRef.current;
           if (state.mode === "panning") {
@@ -41269,7 +41619,7 @@ var init_GraphCanvas = __esm({
         },
         [toCoords, nodeAt]
       );
-      const handleMouseUp = React93.useCallback(
+      const handlePointerUp = React93.useCallback(
         (e) => {
           const state = interactionRef.current;
           const moved = Math.abs(e.clientX - state.downPos.x) + Math.abs(e.clientY - state.downPos.y);
@@ -41286,11 +41636,19 @@ var init_GraphCanvas = __esm({
         },
         [toCoords, nodeAt, handleNodeClick]
       );
-      const handleMouseLeave = React93.useCallback(() => {
-        interactionRef.current.mode = "none";
-        interactionRef.current.dragNodeId = null;
+      const handlePointerLeave = React93.useCallback(() => {
         setHoveredNode(null);
       }, []);
+      const gestureHandlers = useCanvasGestures({
+        canvasRef,
+        enabled: interactive || draggable,
+        onPointerDown: handlePointerDown,
+        onPointerMove: handlePointerMove,
+        onPointerUp: handlePointerUp,
+        onZoom: applyZoom,
+        onPanDelta: applyPanDelta,
+        onMultiTouchStart: cancelSinglePointer
+      });
       const handleDoubleClick = React93.useCallback(
         (e) => {
           const coords = toCoords(e);
@@ -41359,13 +41717,14 @@ var init_GraphCanvas = __esm({
             ref: canvasRef,
             width: Math.round(logicalW * (typeof window !== "undefined" && window.devicePixelRatio || 1)),
             height: Math.round(height * (typeof window !== "undefined" && window.devicePixelRatio || 1)),
-            className: "w-full cursor-grab active:cursor-grabbing",
+            className: "w-full cursor-grab active:cursor-grabbing touch-none",
             style: { height },
-            onWheel: handleWheel,
-            onMouseDown: handleMouseDown,
-            onMouseMove: handleMouseMove,
-            onMouseUp: handleMouseUp,
-            onMouseLeave: handleMouseLeave,
+            onPointerDown: gestureHandlers.onPointerDown,
+            onPointerMove: gestureHandlers.onPointerMove,
+            onPointerUp: gestureHandlers.onPointerUp,
+            onPointerCancel: gestureHandlers.onPointerCancel,
+            onPointerLeave: handlePointerLeave,
+            onWheel: gestureHandlers.onWheel,
             onDoubleClick: handleDoubleClick
           }
         ) }),
@@ -45837,6 +46196,9 @@ var init_GameCanvas3D2 = __esm({
                             target: cameraTarget,
                             enableDamping: true,
                             dampingFactor: 0.05,
+                            enableZoom: true,
+                            enablePan: true,
+                            touches: { ONE: THREE3__namespace.TOUCH.ROTATE, TWO: THREE3__namespace.TOUCH.DOLLY_PAN },
                             minDistance: 2,
                             maxDistance: 100,
                             maxPolarAngle: Math.PI / 2 - 0.1
@@ -51167,20 +51529,21 @@ var init_SplitPane = __esm({
       const [ratio, setRatio] = React93.useState(initialRatio);
       const containerRef = React93.useRef(null);
       const isDragging = React93.useRef(false);
-      const handleMouseDown = React93.useCallback(
+      const handlePointerDown = React93.useCallback(
         (e) => {
           if (!resizable) return;
           e.preventDefault();
           isDragging.current = true;
-          const handleMouseMove = (e2) => {
+          e.currentTarget.setPointerCapture(e.pointerId);
+          const handlePointerMove = (ev) => {
             if (!isDragging.current || !containerRef.current) return;
             const rect = containerRef.current.getBoundingClientRect();
             let newRatio;
             if (direction === "horizontal") {
-              const x = e2.clientX - rect.left;
+              const x = ev.clientX - rect.left;
               newRatio = x / rect.width * 100;
             } else {
-              const y = e2.clientY - rect.top;
+              const y = ev.clientY - rect.top;
               newRatio = y / rect.height * 100;
             }
             const minRatio = minSize / (direction === "horizontal" ? rect.width : rect.height) * 100;
@@ -51188,13 +51551,15 @@ var init_SplitPane = __esm({
             newRatio = Math.max(minRatio, Math.min(maxRatio, newRatio));
             setRatio(newRatio);
           };
-          const handleMouseUp = () => {
+          const handlePointerUp = () => {
             isDragging.current = false;
-            document.removeEventListener("mousemove", handleMouseMove);
-            document.removeEventListener("mouseup", handleMouseUp);
+            document.removeEventListener("pointermove", handlePointerMove);
+            document.removeEventListener("pointerup", handlePointerUp);
+            document.removeEventListener("pointercancel", handlePointerUp);
           };
-          document.addEventListener("mousemove", handleMouseMove);
-          document.addEventListener("mouseup", handleMouseUp);
+          document.addEventListener("pointermove", handlePointerMove);
+          document.addEventListener("pointerup", handlePointerUp);
+          document.addEventListener("pointercancel", handlePointerUp);
         },
         [direction, minSize, resizable]
       );
@@ -51223,9 +51588,9 @@ var init_SplitPane = __esm({
             resizable && /* @__PURE__ */ jsxRuntime.jsx(
               "div",
               {
-                onMouseDown: handleMouseDown,
+                onPointerDown: handlePointerDown,
                 className: cn(
-                  "flex-shrink-0 bg-border transition-colors",
+                  "flex-shrink-0 bg-border transition-colors touch-none",
                   isHorizontal ? "w-1 cursor-col-resize hover:w-1.5 hover:bg-muted-foreground" : "h-1 cursor-row-resize hover:h-1.5 hover:bg-muted-foreground"
                 )
               }