@almadar/ui 5.61.0 → 5.63.1

package/dist/hooks/index.cjs

@@ -2059,7 +2059,111 @@ var en_default = {
   "stateMachine.legend.final": "Final",
   "stateMachine.legend.state": "State",
   "stateMachine.legend.multiEvent": "Multi-event",
-  "relationSelect.selectPlaceholder": "Select..."
+  "relationSelect.selectPlaceholder": "Select...",
+  "battle.cancel": "Cancel",
+  "battle.defeat": "Defeat",
+  "battle.endTurn": "End Turn",
+  "battle.playAgain": "Play Again",
+  "battle.turnsPlayed": "Turns Played",
+  "battle.victory": "Victory",
+  "builder.allPlaced": "All placed",
+  "builder.blueprint": "Blueprint",
+  "builder.build": "Build",
+  "builder.components": "Components",
+  "builder.empty": "Empty",
+  "builder.reset": "Reset",
+  "builder.success": "Success",
+  "classifier.allCorrect": "All correct!",
+  "classifier.check": "Check",
+  "classifier.correct": "correct",
+  "classifier.itemsToSort": "Items to sort",
+  "classifier.reset": "Reset",
+  "common.error": "Error",
+  "debugger.allFound": "All bugs found!",
+  "debugger.bugsFound": "bugs found",
+  "debugger.findBugs": "Find {{count}} bugs",
+  "debugger.reset": "Reset",
+  "debugger.submit": "Submit",
+  "error.genericLoad": "Failed to load",
+  "error.loadingData": "Loading data",
+  "eventHandler.addRule": "Add Rule",
+  "eventHandler.chainComplete": "Chain complete!",
+  "eventHandler.clickObject": "Click objects",
+  "eventHandler.eventLog": "Event Log",
+  "eventHandler.heardEvent": "{{object}} heard {{event}} \u2192 {{action}}",
+  "eventHandler.noEvents": "No events yet",
+  "eventHandler.noListeners": "No listeners for {{event}}",
+  "eventHandler.rules": "{{count}}/{{max}} rules",
+  "eventHandler.simulationStarted": "Simulating: {{events}}",
+  "eventHandler.state": "State",
+  "eventHandler.then": "then",
+  "eventHandler.when": "When",
+  "game.goal": "Goal",
+  "game.hint": "Hint",
+  "game.play": "Play",
+  "game.reset": "Reset",
+  "game.runTests": "Run Tests",
+  "negotiator.chooseAction": "Choose an action",
+  "negotiator.failed": "Negotiation failed",
+  "negotiator.finalScore": "Final score",
+  "negotiator.history": "History",
+  "negotiator.opponent": "Opponent",
+  "negotiator.playAgain": "Play Again",
+  "negotiator.round": "Round {{current}} of {{total}}",
+  "negotiator.success": "Negotiation successful",
+  "negotiator.target": "Target",
+  "negotiator.you": "You",
+  "platformer.level": "Level",
+  "platformer.lost": "Game Over",
+  "platformer.nextLevel": "Next Level",
+  "platformer.noLives": "No lives left",
+  "platformer.playAgain": "Play Again",
+  "platformer.score": "Score",
+  "platformer.won": "You won!",
+  "puzzle.tryAgainButton": "Try Again",
+  "roguelike.atk": "ATK",
+  "roguelike.cleared": "Dungeon cleared! Depth reached: {{depth}}",
+  "roguelike.defeat": "Defeated!",
+  "roguelike.depth": "Depth",
+  "roguelike.enemy": "Enemy",
+  "roguelike.hp": "HP",
+  "roguelike.phase": "Phase",
+  "roguelike.playAgain": "Play Again",
+  "roguelike.player": "Hero",
+  "roguelike.victory": "Victory!",
+  "sequencer.actions": "Actions",
+  "sequencer.dragActions": "Drag actions here",
+  "sequencer.levelComplete": "Level complete!",
+  "sequencer.yourSequence": "Your sequence",
+  "simulator.correct": "Correct",
+  "simulator.incorrect": "Incorrect",
+  "simulator.parameters": "Parameters",
+  "simulator.reset": "Reset",
+  "simulator.simulate": "Simulate",
+  "simulator.target": "Target",
+  "stateArchitect.addTransition": "Add transition from {{state}}",
+  "stateArchitect.addTransitionPrompt": "Click target state",
+  "stateArchitect.allPassed": "All tests passed!",
+  "stateArchitect.clickTarget": "Click a target state (current: {{state}})",
+  "stateArchitect.gotState": "Got state: {{state}}",
+  "stateArchitect.graph": "Graph",
+  "stateArchitect.hideJson": "Hide JSON",
+  "stateArchitect.showJson": "Show JSON",
+  "stateArchitect.testResults": "Test Results",
+  "stateArchitect.transitions": "{{count}} transitions",
+  "stateArchitect.variables": "Variables: {{name}}",
+  "stateArchitect.viewCode": "View Code",
+  "td.defeat": "Defeat",
+  "td.gold": "Gold",
+  "td.lives": "Lives",
+  "td.livesReachedZero": "Your base was overrun",
+  "td.placeTower": "Place tower",
+  "td.playAgain": "Play Again",
+  "td.startWave": "Start Wave",
+  "td.survivedAllWaves": "Survived all waves!",
+  "td.victory": "Victory!",
+  "td.wave": "Wave",
+  "td.waveInProgress": "Wave in progress\u2026"
 };
 
 // hooks/useTranslate.ts
@@ -2412,6 +2516,152 @@ function usePinchZoom(options = {}) {
     resetZoom
   };
 }
+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 = react.useRef(/* @__PURE__ */ new Map());
+  const pinch = react.useRef(null);
+  const computePinch = react.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 = react.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 = react.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 = react.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 = react.useCallback(
+    (e) => {
+      if (!enabled) return;
+      endPointer(e, true);
+    },
+    [enabled, endPointer]
+  );
+  const handlePointerCancel = react.useCallback(
+    (e) => {
+      if (!enabled) return;
+      endPointer(e, false);
+    },
+    [enabled, endPointer]
+  );
+  const handleWheel = react.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
+  };
+}
+function useTapReveal(options = {}) {
+  const { onReveal, onDismiss, refs, enabled = true } = options;
+  const [revealed, setRevealed] = react.useState(false);
+  const onRevealRef = react.useRef(onReveal);
+  const onDismissRef = react.useRef(onDismiss);
+  onRevealRef.current = onReveal;
+  onDismissRef.current = onDismiss;
+  const reveal = react.useCallback(() => {
+    setRevealed((wasRevealed) => {
+      if (!wasRevealed) onRevealRef.current?.();
+      return true;
+    });
+  }, []);
+  const dismiss = react.useCallback(() => {
+    setRevealed((wasRevealed) => {
+      if (wasRevealed) onDismissRef.current?.();
+      return false;
+    });
+  }, []);
+  const onPointerDown = react.useCallback(
+    (e) => {
+      if (!enabled || e.pointerType === "mouse") return;
+      if (revealed) dismiss();
+      else reveal();
+    },
+    [enabled, revealed, reveal, dismiss]
+  );
+  react.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 ALMADAR_DND_MIME = "application/x-almadar-dnd";
 function useDraggable({ payload, disabled = false }) {
   const [isDragging, setIsDragging] = react.useState(false);
@@ -2663,6 +2913,7 @@ exports.updateEntity = updateEntity;
 exports.updateSingleton = updateSingleton;
 exports.useAgentChat = useAgentChat;
 exports.useAuthContext = useAuthContext;
+exports.useCanvasGestures = useCanvasGestures;
 exports.useCompile = useCompile;
 exports.useConnectGitHub = useConnectGitHub;
 exports.useDeepAgentGeneration = useDeepAgentGeneration;
@@ -2696,6 +2947,7 @@ exports.useQuerySingleton = useQuerySingleton;
 exports.useRenderInterpolation = useRenderInterpolation;
 exports.useSingletonEntity = useSingletonEntity;
 exports.useSwipeGesture = useSwipeGesture;
+exports.useTapReveal = useTapReveal;
 exports.useTraitListens = useTraitListens;
 exports.useTranslate = useTranslate;
 exports.useUIEvents = useUIEvents;

package/dist/hooks/index.d.ts

@@ -24,6 +24,8 @@ export { useDragReorder, type DragReorderResult, } from './useDragReorder';
 export { useInfiniteScroll, type InfiniteScrollOptions, type InfiniteScrollResult, } from './useInfiniteScroll';
 export { usePullToRefresh, type PullToRefreshOptions, type PullToRefreshResult, } from './usePullToRefresh';
 export { usePinchZoom, type PinchZoomOptions, type PinchZoomResult, } from './usePinchZoom';
+export { useCanvasGestures, type UseCanvasGesturesOptions, type CanvasGestureCallbacks, type CanvasGestureHandlers, } from './useCanvasGestures';
+export { useTapReveal, type TapRevealOptions, type TapRevealResult, } from './useTapReveal';
 export { useDraggable, ALMADAR_DND_MIME, type DraggablePayload, type UseDraggableOptions, type UseDraggableResult, } from './useDraggable';
 export { useDropZone, type UseDropZoneOptions, type UseDropZoneResult, } from './useDropZone';
 export { useRenderInterpolation, type Positioned, type RenderInterpolationOptions, type RenderInterpolationHandle, } from './useRenderInterpolation';

package/dist/hooks/index.js

@@ -2057,7 +2057,111 @@ var en_default = {
   "stateMachine.legend.final": "Final",
   "stateMachine.legend.state": "State",
   "stateMachine.legend.multiEvent": "Multi-event",
-  "relationSelect.selectPlaceholder": "Select..."
+  "relationSelect.selectPlaceholder": "Select...",
+  "battle.cancel": "Cancel",
+  "battle.defeat": "Defeat",
+  "battle.endTurn": "End Turn",
+  "battle.playAgain": "Play Again",
+  "battle.turnsPlayed": "Turns Played",
+  "battle.victory": "Victory",
+  "builder.allPlaced": "All placed",
+  "builder.blueprint": "Blueprint",
+  "builder.build": "Build",
+  "builder.components": "Components",
+  "builder.empty": "Empty",
+  "builder.reset": "Reset",
+  "builder.success": "Success",
+  "classifier.allCorrect": "All correct!",
+  "classifier.check": "Check",
+  "classifier.correct": "correct",
+  "classifier.itemsToSort": "Items to sort",
+  "classifier.reset": "Reset",
+  "common.error": "Error",
+  "debugger.allFound": "All bugs found!",
+  "debugger.bugsFound": "bugs found",
+  "debugger.findBugs": "Find {{count}} bugs",
+  "debugger.reset": "Reset",
+  "debugger.submit": "Submit",
+  "error.genericLoad": "Failed to load",
+  "error.loadingData": "Loading data",
+  "eventHandler.addRule": "Add Rule",
+  "eventHandler.chainComplete": "Chain complete!",
+  "eventHandler.clickObject": "Click objects",
+  "eventHandler.eventLog": "Event Log",
+  "eventHandler.heardEvent": "{{object}} heard {{event}} \u2192 {{action}}",
+  "eventHandler.noEvents": "No events yet",
+  "eventHandler.noListeners": "No listeners for {{event}}",
+  "eventHandler.rules": "{{count}}/{{max}} rules",
+  "eventHandler.simulationStarted": "Simulating: {{events}}",
+  "eventHandler.state": "State",
+  "eventHandler.then": "then",
+  "eventHandler.when": "When",
+  "game.goal": "Goal",
+  "game.hint": "Hint",
+  "game.play": "Play",
+  "game.reset": "Reset",
+  "game.runTests": "Run Tests",
+  "negotiator.chooseAction": "Choose an action",
+  "negotiator.failed": "Negotiation failed",
+  "negotiator.finalScore": "Final score",
+  "negotiator.history": "History",
+  "negotiator.opponent": "Opponent",
+  "negotiator.playAgain": "Play Again",
+  "negotiator.round": "Round {{current}} of {{total}}",
+  "negotiator.success": "Negotiation successful",
+  "negotiator.target": "Target",
+  "negotiator.you": "You",
+  "platformer.level": "Level",
+  "platformer.lost": "Game Over",
+  "platformer.nextLevel": "Next Level",
+  "platformer.noLives": "No lives left",
+  "platformer.playAgain": "Play Again",
+  "platformer.score": "Score",
+  "platformer.won": "You won!",
+  "puzzle.tryAgainButton": "Try Again",
+  "roguelike.atk": "ATK",
+  "roguelike.cleared": "Dungeon cleared! Depth reached: {{depth}}",
+  "roguelike.defeat": "Defeated!",
+  "roguelike.depth": "Depth",
+  "roguelike.enemy": "Enemy",
+  "roguelike.hp": "HP",
+  "roguelike.phase": "Phase",
+  "roguelike.playAgain": "Play Again",
+  "roguelike.player": "Hero",
+  "roguelike.victory": "Victory!",
+  "sequencer.actions": "Actions",
+  "sequencer.dragActions": "Drag actions here",
+  "sequencer.levelComplete": "Level complete!",
+  "sequencer.yourSequence": "Your sequence",
+  "simulator.correct": "Correct",
+  "simulator.incorrect": "Incorrect",
+  "simulator.parameters": "Parameters",
+  "simulator.reset": "Reset",
+  "simulator.simulate": "Simulate",
+  "simulator.target": "Target",
+  "stateArchitect.addTransition": "Add transition from {{state}}",
+  "stateArchitect.addTransitionPrompt": "Click target state",
+  "stateArchitect.allPassed": "All tests passed!",
+  "stateArchitect.clickTarget": "Click a target state (current: {{state}})",
+  "stateArchitect.gotState": "Got state: {{state}}",
+  "stateArchitect.graph": "Graph",
+  "stateArchitect.hideJson": "Hide JSON",
+  "stateArchitect.showJson": "Show JSON",
+  "stateArchitect.testResults": "Test Results",
+  "stateArchitect.transitions": "{{count}} transitions",
+  "stateArchitect.variables": "Variables: {{name}}",
+  "stateArchitect.viewCode": "View Code",
+  "td.defeat": "Defeat",
+  "td.gold": "Gold",
+  "td.lives": "Lives",
+  "td.livesReachedZero": "Your base was overrun",
+  "td.placeTower": "Place tower",
+  "td.playAgain": "Play Again",
+  "td.startWave": "Start Wave",
+  "td.survivedAllWaves": "Survived all waves!",
+  "td.victory": "Victory!",
+  "td.wave": "Wave",
+  "td.waveInProgress": "Wave in progress\u2026"
 };
 
 // hooks/useTranslate.ts
@@ -2410,6 +2514,152 @@ function usePinchZoom(options = {}) {
     resetZoom
   };
 }
+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
+  };
+}
+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 ALMADAR_DND_MIME = "application/x-almadar-dnd";
 function useDraggable({ payload, disabled = false }) {
   const [isDragging, setIsDragging] = useState(false);
@@ -2645,4 +2895,4 @@ function useGitHubBranches(owner, repo, enabled = true) {
   });
 }
 
-export { ALMADAR_DND_MIME, DEFAULT_SLOTS, I18nProvider, clearEntities, createTranslate, getAllEntities, getByType, getEntity, getSingleton, parseQueryBinding, removeEntity, spawnEntity, updateEntity, updateSingleton, useAgentChat, useAuthContext, useCompile, useConnectGitHub, useDeepAgentGeneration, useDisconnectGitHub, useDragReorder, useDraggable, useDropZone, useEmitEvent, useEntities, useEntitiesByType, useEntity as useEntityById, useEventBus, useEventListener, useExtensions, useFileEditor, useFileSystem, useGitHubBranches, useGitHubRepo, useGitHubRepos, useGitHubStatus, useInfiniteScroll, useInput, useLongPress, useOrbitalHistory, usePhysics, usePinchZoom, usePlayer, usePreview, usePullToRefresh, useQuerySingleton, useRenderInterpolation, useSingletonEntity, useSwipeGesture, useTraitListens, useTranslate, useUIEvents, useUISlotManager, useValidation };
+export { ALMADAR_DND_MIME, DEFAULT_SLOTS, I18nProvider, clearEntities, createTranslate, getAllEntities, getByType, getEntity, getSingleton, parseQueryBinding, removeEntity, spawnEntity, updateEntity, updateSingleton, useAgentChat, useAuthContext, useCanvasGestures, useCompile, useConnectGitHub, useDeepAgentGeneration, useDisconnectGitHub, useDragReorder, useDraggable, useDropZone, useEmitEvent, useEntities, useEntitiesByType, useEntity as useEntityById, useEventBus, useEventListener, useExtensions, useFileEditor, useFileSystem, useGitHubBranches, useGitHubRepo, useGitHubRepos, useGitHubStatus, useInfiniteScroll, useInput, useLongPress, useOrbitalHistory, usePhysics, usePinchZoom, usePlayer, usePreview, usePullToRefresh, useQuerySingleton, useRenderInterpolation, useSingletonEntity, useSwipeGesture, useTapReveal, useTraitListens, useTranslate, useUIEvents, useUISlotManager, useValidation };

package/dist/hooks/useCanvasGestures.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Unified pointer/touch gesture detection for canvas surfaces (graph, isometric, etc.).
+ *
+ * It owns the hard part — pointer tracking + two-finger pinch (scale factor + centroid) —
+ * and DELEGATES application to the consumer via callbacks, so each canvas applies pan/zoom
+ * in its own coordinate convention (screen-offset vs world-camera). A single pointer is
+ * passed straight through to the consumer's domain handlers (pan / node-drag / tile-select);
+ * a second pointer takes over as a pinch and cancels any in-flight single-pointer action.
+ *
+ * Pointer Events cover mouse, touch and pen, so this REPLACES mouse handlers — no dual paths.
+ */
+export interface CanvasGestureCallbacks {
+    /** Single-pointer down — start the consumer's pan / drag / select (domain-specific). */
+    onPointerDown?: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+    /** Single-pointer move. */
+    onPointerMove?: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+    /** Single-pointer up. */
+    onPointerUp?: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+    /**
+     * Multiplicative zoom around a canvas-local point. Fired by wheel and by pinch.
+     * Consumer applies `newZoom = clamp(oldZoom * factor)` keeping (centerX,centerY) fixed.
+     */
+    onZoom?: (factor: number, centerX: number, centerY: number) => void;
+    /** Two-finger pan delta in canvas-local px (fired alongside pinch). */
+    onPanDelta?: (dx: number, dy: number) => void;
+    /** A second pointer arrived — cancel any single-pointer pan/drag the consumer started. */
+    onMultiTouchStart?: () => void;
+}
+export interface UseCanvasGesturesOptions extends CanvasGestureCallbacks {
+    /** The canvas being gestured on (for coordinate translation). */
+    canvasRef: React.RefObject<HTMLCanvasElement | null>;
+    /** When false, all gestures are inert. Default true. */
+    enabled?: boolean;
+    /** Wheel zoom step per notch (>1). Default 1.1. */
+    wheelStep?: number;
+}
+export interface CanvasGestureHandlers {
+    onPointerDown: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+    onPointerMove: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+    onPointerUp: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+    onPointerCancel: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+    onWheel: (e: React.WheelEvent<HTMLCanvasElement>) => void;
+}
+export declare function useCanvasGestures(options: UseCanvasGesturesOptions): CanvasGestureHandlers;

package/dist/hooks/useTapReveal.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Hover-only reveals (tooltips, hover-popovers, submenus, `Box.hoverEvent`) have no hover on
+ * touch, so they're invisible/unreachable. This adds the tap-to-reveal fallback: on a touch/pen
+ * tap the surface reveals and fires the SAME event the hover path fires; a tap outside dismisses.
+ * Mouse is left to the component's existing hover handlers (`pointerType === 'mouse'` is ignored),
+ * so this is purely additive — no behavior change on desktop.
+ */
+export interface TapRevealOptions {
+    /** Fired when a tap reveals — reuse to emit the component's existing hover event. */
+    onReveal?: () => void;
+    /** Fired when an outside tap (or a second trigger tap) dismisses. */
+    onDismiss?: () => void;
+    /**
+     * Elements considered "inside" for outside-tap detection. Pass the trigger and the surface
+     * (the surface may be portaled, so it isn't a DOM descendant of the trigger). A tap whose
+     * target is inside none of these dismisses.
+     */
+    refs?: ReadonlyArray<React.RefObject<HTMLElement | null>>;
+    /** When false, taps are ignored (hover-only). Default true. */
+    enabled?: boolean;
+}
+export interface TapRevealResult {
+    /** Whether the surface is currently revealed via a tap. OR this with the hover state. */
+    revealed: boolean;
+    /** Spread on the trigger; toggles reveal on a touch/pen tap (ignores mouse). */
+    triggerProps: {
+        onPointerDown: (e: React.PointerEvent) => void;
+    };
+    reveal: () => void;
+    dismiss: () => void;
+}
+export declare function useTapReveal(options?: TapRevealOptions): TapRevealResult;