@almadar/ui 5.62.0 → 5.63.1

package/dist/components/index.js

@@ -3202,12 +3202,60 @@ var init_Avatar = __esm({
     Avatar.displayName = "Avatar";
   }
 });
+function useTapReveal(options = {}) {
+  const { onReveal, onDismiss, refs, enabled = true } = options;
+  const [revealed, setRevealed] = useState(false);
+  const onRevealRef = useRef(onReveal);
+  const onDismissRef = useRef(onDismiss);
+  onRevealRef.current = onReveal;
+  onDismissRef.current = onDismiss;
+  const reveal = useCallback(() => {
+    setRevealed((wasRevealed) => {
+      if (!wasRevealed) onRevealRef.current?.();
+      return true;
+    });
+  }, []);
+  const dismiss = useCallback(() => {
+    setRevealed((wasRevealed) => {
+      if (wasRevealed) onDismissRef.current?.();
+      return false;
+    });
+  }, []);
+  const onPointerDown = useCallback(
+    (e) => {
+      if (!enabled || e.pointerType === "mouse") return;
+      if (revealed) dismiss();
+      else reveal();
+    },
+    [enabled, revealed, reveal, dismiss]
+  );
+  useEffect(() => {
+    if (!revealed || typeof document === "undefined") return;
+    const onDocDown = (ev) => {
+      const target = ev.target;
+      if (!(target instanceof Node)) return;
+      const inside = (refs ?? []).some((r) => r.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 paddingStyles2, paddingXStyles, paddingYStyles, marginStyles, marginXStyles, marginYStyles, bgStyles, roundedStyles, shadowStyles2, displayStyles, overflowStyles, positionStyles, Box;
 var init_Box = __esm({
   "components/core/atoms/Box.tsx"() {
     "use client";
     init_cn();
     init_useEventBus();
+    init_useTapReveal();
     paddingStyles2 = {
       none: "p-0",
       xs: "p-1",
@@ -3333,10 +3381,12 @@ var init_Box = __esm({
         action,
         actionPayload,
         hoverEvent,
+        tapReveal = true,
         maxWidth,
         onClick,
         onMouseEnter,
         onMouseLeave,
+        onPointerDown,
         ...rest
       }, ref) => {
         const eventBus = useEventBus();
@@ -3359,6 +3409,19 @@ var init_Box = __esm({
           }
           onMouseLeave?.(e);
         }, [hoverEvent, eventBus, onMouseLeave]);
+        const { triggerProps } = useTapReveal({
+          enabled: tapReveal && !!hoverEvent,
+          onReveal: useCallback(() => {
+            if (hoverEvent) eventBus.emit(`UI:${hoverEvent}`, { hovered: true });
+          }, [hoverEvent, eventBus]),
+          onDismiss: useCallback(() => {
+            if (hoverEvent) eventBus.emit(`UI:${hoverEvent}`, { hovered: false });
+          }, [hoverEvent, eventBus])
+        });
+        const handlePointerDown = useCallback((e) => {
+          if (hoverEvent && tapReveal) triggerProps.onPointerDown(e);
+          onPointerDown?.(e);
+        }, [hoverEvent, tapReveal, triggerProps, onPointerDown]);
         const isClickable = action || onClick;
         return React79__default.createElement(
           Component2,
@@ -3386,6 +3449,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
           },
@@ -4142,6 +4206,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) => {
@@ -4640,6 +4709,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",
@@ -4661,6 +4731,7 @@ var init_LawReferenceTooltip = __esm({
       const { t } = useTranslate();
       const [isVisible, setIsVisible] = React79__default.useState(false);
       const timeoutRef = React79__default.useRef(null);
+      const triggerRef = React79__default.useRef(null);
       const handleMouseEnter = () => {
         if (timeoutRef.current) clearTimeout(timeoutRef.current);
         timeoutRef.current = setTimeout(() => setIsVisible(true), 200);
@@ -4669,6 +4740,8 @@ var init_LawReferenceTooltip = __esm({
         if (timeoutRef.current) clearTimeout(timeoutRef.current);
         setIsVisible(false);
       };
+      const { revealed, triggerProps } = useTapReveal({ refs: [triggerRef] });
+      const open = isVisible || revealed;
       React79__default.useEffect(() => {
         return () => {
           if (timeoutRef.current) clearTimeout(timeoutRef.current);
@@ -4677,6 +4750,7 @@ var init_LawReferenceTooltip = __esm({
       return /* @__PURE__ */ jsxs(
         Box,
         {
+          ref: triggerRef,
           as: "span",
           position: "relative",
           display: "inline-block",
@@ -4685,9 +4759,10 @@ var init_LawReferenceTooltip = __esm({
           onMouseLeave: handleMouseLeave,
           onFocus: handleMouseEnter,
           onBlur: handleMouseLeave,
+          onPointerDown: triggerProps.onPointerDown,
           children: [
             children,
-            isVisible && /* @__PURE__ */ jsxs(
+            open && /* @__PURE__ */ jsxs(
               Box,
               {
                 padding: "sm",
@@ -9332,6 +9407,36 @@ function useCamera() {
     cameraRef.current.zoom = Math.max(0.5, Math.min(3, cameraRef.current.zoom * zoomDelta));
     drawFn?.();
   }, []);
+  const handlePointerDown = useCallback((e) => {
+    handleMouseDown(e);
+  }, [handleMouseDown]);
+  const handlePointerUp = useCallback(() => {
+    handleMouseUp();
+  }, [handleMouseUp]);
+  const handlePointerMove = useCallback((e, drawFn) => {
+    return handleMouseMove(e, drawFn);
+  }, [handleMouseMove]);
+  const panBy = useCallback((dx, dy, drawFn) => {
+    cameraRef.current.x -= dx;
+    cameraRef.current.y -= dy;
+    targetCameraRef.current = null;
+    drawFn?.();
+  }, []);
+  const zoomAtPoint = 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 = useCallback((clientX, clientY, canvas, viewportSize) => {
     const rect = canvas.getBoundingClientRect();
     const screenX = clientX - rect.left;
@@ -9363,6 +9468,11 @@ function useCamera() {
     handleMouseMove,
     handleMouseLeave,
     handleWheel,
+    handlePointerDown,
+    handlePointerUp,
+    handlePointerMove,
+    panBy,
+    zoomAtPoint,
     screenToWorld,
     lerpToTarget
   };
@@ -9372,6 +9482,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 = useRef(/* @__PURE__ */ new Map());
+  const pinch = useRef(null);
+  const computePinch = 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 = 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 = 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 = 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 = useCallback(
+    (e) => {
+      if (!enabled) return;
+      endPointer(e, true);
+    },
+    [enabled, endPointer]
+  );
+  const handlePointerCancel = useCallback(
+    (e) => {
+      if (!enabled) return;
+      endPointer(e, false);
+    },
+    [enabled, endPointer]
+  );
+  const handleWheel = 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"() {
+  }
+});
 
 // components/game/organisms/utils/spriteSheetConstants.ts
 var SHEET_COLUMNS, SPRITE_SHEET_LAYOUT;
@@ -9877,13 +10094,13 @@ function IsometricCanvas({
   const {
     cameraRef,
     targetCameraRef,
-    isDragging,
     dragDistance,
-    handleMouseDown,
-    handleMouseUp,
-    handleMouseMove,
     handleMouseLeave,
-    handleWheel,
+    handlePointerDown,
+    handlePointerUp,
+    handlePointerMove,
+    panBy,
+    zoomAtPoint,
     screenToWorld,
     lerpToTarget
   } = useCamera();
@@ -10318,11 +10535,16 @@ function IsometricCanvas({
       cancelAnimationFrame(rafIdRef.current);
     };
   }, [draw, units.length, validMoves.length, attackTargets.length, selectedUnitId, hasActiveEffects2, pendingCount, atlasPending, lerpToTarget, targetCameraRef]);
-  const handleMouseMoveWithCamera = useCallback((e) => {
-    if (enableCamera) {
-      const wasPanning = handleMouseMove(e, () => draw(animTimeRef.current));
-      if (wasPanning) return;
-    }
+  const singlePointerActiveRef = useRef(false);
+  const handleCanvasPointerDown = useCallback((e) => {
+    singlePointerActiveRef.current = true;
+    if (enableCamera) handlePointerDown(e);
+  }, [enableCamera, handlePointerDown]);
+  const handleCanvasPointerMove = useCallback((e) => {
+    if (enableCamera) handlePointerMove(e, () => draw(animTimeRef.current));
+  }, [enableCamera, handlePointerMove, draw]);
+  const handleCanvasHover = 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;
@@ -10333,26 +10555,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 = useCallback(() => {
-    handleMouseLeave();
-    if (tileLeaveEvent) eventBus.emit(`UI:${tileLeaveEvent}`, {});
-    onTileLeave?.();
-  }, [handleMouseLeave, onTileLeave, tileLeaveEvent, eventBus]);
-  const handleWheelWithCamera = useCallback((e) => {
-    if (enableCamera) {
-      handleWheel(e, () => draw(animTimeRef.current));
-    }
-  }, [enableCamera, handleWheel, draw]);
-  useEffect(() => {
-    const canvas = canvasRef.current;
-    if (!canvas) return;
-    canvas.addEventListener("wheel", handleWheelWithCamera, { passive: false });
-    return () => {
-      canvas.removeEventListener("wheel", handleWheelWithCamera);
-    };
-  }, [handleWheelWithCamera]);
-  const handleClick = useCallback((e) => {
+  }, [onTileHover, screenToWorld, viewportSize, scaledTileWidth, scaledDiamondTopY, scaledFloorHeight, scale, baseOffsetX, tilesProp, tileHoverEvent, eventBus]);
+  const handleCanvasPointerUp = 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);
@@ -10370,7 +10576,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 = useCallback(() => {
+    handleMouseLeave();
+    if (tileLeaveEvent) eventBus.emit(`UI:${tileLeaveEvent}`, {});
+    onTileLeave?.();
+  }, [handleMouseLeave, onTileLeave, tileLeaveEvent, eventBus]);
+  const applyZoom = useCallback((factor, centerX, centerY) => {
+    if (enableCamera) zoomAtPoint(factor, centerX, centerY, viewportSize, () => draw(animTimeRef.current));
+  }, [enableCamera, zoomAtPoint, viewportSize, draw]);
+  const applyPanDelta = useCallback((dx, dy) => {
+    if (enableCamera) panBy(dx, dy, () => draw(animTimeRef.current));
+  }, [enableCamera, panBy, draw]);
+  const cancelSinglePointer = 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__ */ jsx(ErrorState, { title: t("canvas.errorTitle"), message: error.message, className });
   }
@@ -10402,13 +10633,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
@@ -10462,6 +10697,7 @@ var init_IsometricCanvas = __esm({
     init_ErrorState();
     init_useImageCache();
     init_useCamera();
+    init_useCanvasGestures();
     init_useUnitSpriteAtlas();
     init_verificationRegistry();
     init_isometric();
@@ -13577,6 +13813,10 @@ var init_StateMachineView = __esm({
         const handleMouseLeave2 = () => {
           onHover(null, 0, 0);
         };
+        const handlePointerDown2 = (e) => {
+          if (e.pointerType === "mouse") return;
+          handleMouseEnter2();
+        };
         return /* @__PURE__ */ jsxs(
           "g",
           {
@@ -13586,6 +13826,7 @@ var init_StateMachineView = __esm({
             onClick: () => onClick?.(bundle),
             onMouseEnter: handleMouseEnter2,
             onMouseLeave: handleMouseLeave2,
+            onPointerDown: handlePointerDown2,
             style: { pointerEvents: "auto" },
             children: [
               /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx(
@@ -13703,6 +13944,10 @@ var init_StateMachineView = __esm({
       const handleMouseLeave = useCallback(() => {
         onHover(null, 0, 0);
       }, [onHover]);
+      const handlePointerDown = useCallback((e) => {
+        if (e.pointerType === "mouse") return;
+        handleMouseEnter();
+      }, [handleMouseEnter]);
       const uniqueMarkerId = `arrow-${bundle.id}`;
       const hasDetails = bundle.labels.some((l) => l.hasDetails);
       return /* @__PURE__ */ jsxs(
@@ -13714,6 +13959,7 @@ var init_StateMachineView = __esm({
           onClick: () => onClick?.(bundle),
           onMouseEnter: handleMouseEnter,
           onMouseLeave: handleMouseLeave,
+          onPointerDown: handlePointerDown,
           style: { pointerEvents: "auto" },
           children: [
             /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx(
@@ -22486,10 +22732,84 @@ function SubMenu({
   );
   return typeof document !== "undefined" ? createPortal(panel, document.body) : panel;
 }
+function MenuItemRow({
+  item,
+  itemId,
+  hasSubMenu,
+  isDanger,
+  direction,
+  isSubMenuOpen,
+  activeSubMenuRef,
+  eventBus,
+  onItemClick,
+  openSubMenu
+}) {
+  const rowRef = useRef(null);
+  const { triggerProps } = useTapReveal({
+    enabled: hasSubMenu,
+    onReveal: () => openSubMenu(itemId, rowRef.current),
+    refs: [rowRef]
+  });
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ 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__ */ jsxs(Box, { className: "flex items-center gap-3 flex-1 min-w-0", children: [
+          item.icon && (typeof item.icon === "string" ? /* @__PURE__ */ jsx(Icon, { name: item.icon, size: "sm", className: "flex-shrink-0" }) : /* @__PURE__ */ jsx(Icon, { icon: item.icon, size: "sm", className: "flex-shrink-0" })),
+          /* @__PURE__ */ jsx(
+            Typography,
+            {
+              variant: "small",
+              className: cn("flex-1", isDanger && "text-red-600"),
+              children: item.label
+            }
+          ),
+          item.badge !== void 0 && /* @__PURE__ */ jsx(Badge, { variant: "default", size: "sm", children: item.badge }),
+          hasSubMenu && /* @__PURE__ */ jsx(
+            Icon,
+            {
+              name: direction === "rtl" ? "chevron-left" : "chevron-right",
+              size: "sm",
+              className: "flex-shrink-0"
+            }
+          )
+        ] })
+      }
+    ),
+    hasSubMenu && isSubMenuOpen && item.subMenu && /* @__PURE__ */ 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();
@@ -22544,6 +22864,10 @@ var init_Menu = __esm({
           setIsOpen(false);
         }
       };
+      const openSubMenu = (itemId, el) => {
+        setActiveSubMenu(itemId);
+        setActiveSubMenuRef(el);
+      };
       useEffect(() => {
         if (isOpen) {
           updatePosition();
@@ -22587,61 +22911,22 @@ var init_Menu = __esm({
         if (isDivider) {
           return /* @__PURE__ */ jsx(Divider, { className: "my-1" }, `divider-${index}`);
         }
-        return /* @__PURE__ */ jsxs(Box, { children: [
-          /* @__PURE__ */ 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__ */ jsxs(Box, { className: "flex items-center gap-3 flex-1 min-w-0", children: [
-                item.icon && (typeof item.icon === "string" ? /* @__PURE__ */ jsx(Icon, { name: item.icon, size: "sm", className: "flex-shrink-0" }) : /* @__PURE__ */ jsx(Icon, { icon: item.icon, size: "sm", className: "flex-shrink-0" })),
-                /* @__PURE__ */ jsx(
-                  Typography,
-                  {
-                    variant: "small",
-                    className: cn("flex-1", isDanger && "text-red-600"),
-                    children: item.label
-                  }
-                ),
-                item.badge !== void 0 && /* @__PURE__ */ jsx(Badge, { variant: "default", size: "sm", children: item.badge }),
-                hasSubMenu && /* @__PURE__ */ jsx(
-                  Icon,
-                  {
-                    name: direction === "rtl" ? "chevron-left" : "chevron-right",
-                    size: "sm",
-                    className: "flex-shrink-0"
-                  }
-                )
-              ] })
-            }
-          ),
-          hasSubMenu && activeSubMenu === itemId && item.subMenu && /* @__PURE__ */ jsx(
-            SubMenu,
-            {
-              items: item.subMenu,
-              itemRef: activeSubMenuRef,
-              direction,
-              eventBus
-            }
-          )
-        ] }, itemId);
+        return /* @__PURE__ */ jsx(
+          MenuItemRow,
+          {
+            item,
+            itemId,
+            hasSubMenu,
+            isDanger,
+            direction,
+            isSubMenuOpen: activeSubMenu === itemId,
+            activeSubMenuRef,
+            eventBus,
+            onItemClick: handleItemClick,
+            openSubMenu
+          },
+          itemId
+        );
       });
       const panel = isOpen && triggerRect ? /* @__PURE__ */ jsxs(
         "div",
@@ -25886,6 +26171,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",
@@ -25956,18 +26242,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 = React79__default.isValidElement(children) ? children : /* @__PURE__ */ jsx("span", { children });
+      const childPointerDown = childElement.props.onPointerDown;
       const triggerElement = React79__default.cloneElement(
         childElement,
         {
           ref: triggerRef,
-          ...triggerProps
+          ...handlerProps,
+          ...trigger === "hover" ? {
+            onPointerDown: (e) => {
+              tapTriggerProps.onPointerDown(e);
+              childPointerDown?.(e);
+            }
+          } : void 0
         }
       );
       const panel = isOpen && triggerRect ? /* @__PURE__ */ jsxs(
@@ -26748,6 +27048,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",
@@ -26792,6 +27093,11 @@ var init_Tooltip = __esm({
           setIsVisible(false);
         }, hideDelay);
       };
+      const { triggerProps } = useTapReveal({
+        onReveal: handleMouseEnter,
+        onDismiss: handleMouseLeave,
+        refs: [triggerRef, tooltipRef]
+      });
       useLayoutEffect(() => {
         if (isVisible) {
           updatePosition();
@@ -26804,12 +27110,17 @@ var init_Tooltip = __esm({
         };
       }, []);
       const triggerElement = React79__default.isValidElement(children) ? children : /* @__PURE__ */ jsx("span", { children });
+      const childPointerDown = triggerElement.props.onPointerDown;
       const trigger = React79__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__ */ jsxs(
         "div",
@@ -30482,6 +30793,14 @@ var init_GraphView = __esm({
         },
         [onNodeClick]
       );
+      const handleNodePointerDown = useCallback(
+        (e, node) => {
+          if (e.pointerType === "mouse") return;
+          handleNodeMouseEnter(node);
+          handleNodeClickInternal(node);
+        },
+        [handleNodeMouseEnter, handleNodeClickInternal]
+      );
       if (nodes.length === 0) {
         return /* @__PURE__ */ jsx(Box, { className: cn("flex items-center justify-center", className), style: { width: w, height: h }, children: /* @__PURE__ */ jsx(Box, { className: "text-muted-foreground text-sm", children: t("display.noGraphData") }) });
       }
@@ -30541,6 +30860,7 @@ var init_GraphView = __esm({
                       onMouseEnter: () => handleNodeMouseEnter(node),
                       onMouseLeave: handleNodeMouseLeave,
                       onClick: () => handleNodeClickInternal(node),
+                      onPointerDown: (e) => handleNodePointerDown(e, node),
                       children: [
                         /* @__PURE__ */ jsx(
                           "circle",
@@ -30621,13 +30941,13 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect82, useRef: useRef81, useCallback: useCallback125, useState: useState111 } = React79__default;
+      const { useEffect: useEffect83, useRef: useRef83, useCallback: useCallback127, useState: useState112 } = React79__default;
       const { Typography: Typography2 } = await Promise.resolve().then(() => (init_Typography(), Typography_exports));
       const { useEventBus: useEventBus3 } = await Promise.resolve().then(() => (init_useEventBus(), useEventBus_exports));
       function MapUpdater({ centerLat, centerLng, zoom }) {
         const map = useMap();
-        const prevRef = useRef81({ centerLat, centerLng, zoom });
-        useEffect82(() => {
+        const prevRef = useRef83({ centerLat, centerLng, zoom });
+        useEffect83(() => {
           const prev = prevRef.current;
           if (prev.centerLat !== centerLat || prev.centerLng !== centerLng || prev.zoom !== zoom) {
             map.setView([centerLat, centerLng], zoom);
@@ -30638,7 +30958,7 @@ var init_MapView = __esm({
       }
       function MapClickHandler({ onMapClick }) {
         const map = useMap();
-        useEffect82(() => {
+        useEffect83(() => {
           if (!onMapClick) return;
           const handler = (e) => {
             onMapClick(e.latlng.lat, e.latlng.lng);
@@ -30666,8 +30986,8 @@ var init_MapView = __esm({
         showAttribution = true
       }) {
         const eventBus = useEventBus3();
-        const [clickedPosition, setClickedPosition] = useState111(null);
-        const handleMapClick = useCallback125((lat, lng) => {
+        const [clickedPosition, setClickedPosition] = useState112(null);
+        const handleMapClick = useCallback127((lat, lng) => {
           if (showClickedPin) {
             setClickedPosition({ lat, lng });
           }
@@ -30676,7 +30996,7 @@ var init_MapView = __esm({
             eventBus.emit(`UI:${mapClickEvent}`, { latitude: lat, longitude: lng });
           }
         }, [onMapClick, mapClickEvent, eventBus, showClickedPin]);
-        const handleMarkerClick = useCallback125((marker) => {
+        const handleMarkerClick = useCallback127((marker) => {
           onMarkerClick?.(marker);
           if (markerClickEvent) {
             eventBus.emit(`UI:${markerClickEvent}`, { ...marker });
@@ -31017,7 +31337,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;
@@ -31027,7 +31347,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;
@@ -34917,7 +35237,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) => {
@@ -39086,6 +39406,7 @@ var init_GraphCanvas = __esm({
     init_ErrorState();
     init_EmptyState();
     init_useEventBus();
+    init_useCanvasGestures();
     GROUP_COLORS2 = [
       "var(--color-primary)",
       "var(--color-success)",
@@ -39123,6 +39444,10 @@ var init_GraphCanvas = __esm({
       const animRef = useRef(0);
       const [zoom, setZoom] = useState(1);
       const [offset, setOffset] = useState({ x: 0, y: 0 });
+      const zoomRef = useRef(zoom);
+      zoomRef.current = zoom;
+      const offsetRef = useRef(offset);
+      offsetRef.current = offset;
       const [hoveredNode, setHoveredNode] = useState(null);
       const nodesRef = useRef([]);
       const [, forceUpdate] = useState(0);
@@ -39382,25 +39707,27 @@ var init_GraphCanvas = __esm({
         setZoom(1);
         setOffset({ x: 0, y: 0 });
       }, []);
-      const handleWheel = 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 = useCallback(
+      const applyZoom = 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 = useCallback((dx, dy) => {
+        if (!interactive) return;
+        setOffset((o) => ({ x: o.x + dx, y: o.y + dy }));
+      }, [interactive]);
+      const cancelSinglePointer = useCallback(() => {
+        interactionRef.current.mode = "none";
+        interactionRef.current.dragNodeId = null;
+      }, []);
+      const handlePointerDown = useCallback(
         (e) => {
           const coords = toCoords(e);
           if (!coords) return;
@@ -39422,7 +39749,7 @@ var init_GraphCanvas = __esm({
         },
         [toCoords, nodeAt, draggable, interactive, offset]
       );
-      const handleMouseMove = useCallback(
+      const handlePointerMove = useCallback(
         (e) => {
           const state = interactionRef.current;
           if (state.mode === "panning") {
@@ -39451,7 +39778,7 @@ var init_GraphCanvas = __esm({
         },
         [toCoords, nodeAt]
       );
-      const handleMouseUp = useCallback(
+      const handlePointerUp = useCallback(
         (e) => {
           const state = interactionRef.current;
           const moved = Math.abs(e.clientX - state.downPos.x) + Math.abs(e.clientY - state.downPos.y);
@@ -39468,11 +39795,19 @@ var init_GraphCanvas = __esm({
         },
         [toCoords, nodeAt, handleNodeClick]
       );
-      const handleMouseLeave = useCallback(() => {
-        interactionRef.current.mode = "none";
-        interactionRef.current.dragNodeId = null;
+      const handlePointerLeave = useCallback(() => {
         setHoveredNode(null);
       }, []);
+      const gestureHandlers = useCanvasGestures({
+        canvasRef,
+        enabled: interactive || draggable,
+        onPointerDown: handlePointerDown,
+        onPointerMove: handlePointerMove,
+        onPointerUp: handlePointerUp,
+        onZoom: applyZoom,
+        onPanDelta: applyPanDelta,
+        onMultiTouchStart: cancelSinglePointer
+      });
       const handleDoubleClick = useCallback(
         (e) => {
           const coords = toCoords(e);
@@ -39541,13 +39876,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
           }
         ) }),
@@ -44346,6 +44682,9 @@ var init_GameCanvas3D2 = __esm({
                             target: cameraTarget,
                             enableDamping: true,
                             dampingFactor: 0.05,
+                            enableZoom: true,
+                            enablePan: true,
+                            touches: { ONE: THREE3.TOUCH.ROTATE, TWO: THREE3.TOUCH.DOLLY_PAN },
                             minDistance: 2,
                             maxDistance: 100,
                             maxPolarAngle: Math.PI / 2 - 0.1
@@ -49831,20 +50170,21 @@ var init_SplitPane = __esm({
       const [ratio, setRatio] = useState(initialRatio);
       const containerRef = useRef(null);
       const isDragging = useRef(false);
-      const handleMouseDown = useCallback(
+      const handlePointerDown = 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;
@@ -49852,13 +50192,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]
       );
@@ -49887,9 +50229,9 @@ var init_SplitPane = __esm({
             resizable && /* @__PURE__ */ 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"
                 )
               }