cubeforge 0.4.7 → 0.4.8

package/dist/index.js

@@ -713,6 +713,47 @@ function findPath(grid, start, goal) {
   }
   return [];
 }
+function smoothPath(grid, path) {
+  if (path.length <= 2) return path.slice();
+  const result = [path[0]];
+  let anchor = 0;
+  while (anchor < path.length - 1) {
+    let farthest = anchor + 1;
+    for (let probe = anchor + 2; probe < path.length; probe++) {
+      if (hasLineOfSight(grid, path[anchor], path[probe])) {
+        farthest = probe;
+      }
+    }
+    result.push(path[farthest]);
+    anchor = farthest;
+  }
+  return result;
+}
+function hasLineOfSight(grid, a, b) {
+  let c0 = Math.floor(a.x / grid.cellSize);
+  let r0 = Math.floor(a.y / grid.cellSize);
+  const c1 = Math.floor(b.x / grid.cellSize);
+  const r1 = Math.floor(b.y / grid.cellSize);
+  const dc = Math.abs(c1 - c0);
+  const dr = Math.abs(r1 - r0);
+  const sc = c0 < c1 ? 1 : -1;
+  const sr = r0 < r1 ? 1 : -1;
+  let err = dc - dr;
+  while (true) {
+    if (!isWalkable(grid, c0, r0)) return false;
+    if (c0 === c1 && r0 === r1) break;
+    const e2 = 2 * err;
+    if (e2 > -dr) {
+      err -= dr;
+      c0 += sc;
+    }
+    if (e2 < dc) {
+      err += dc;
+      r0 += sr;
+    }
+  }
+  return true;
+}
 var MinHeap = class {
   constructor(compare) {
     this.compare = compare;
@@ -800,6 +841,60 @@ function wander(_pos, angle, speed, jitter) {
     newAngle
   };
 }
+function pursuit(pos, targetPos, targetVel, speed, lookAhead = 0.5) {
+  const predicted = {
+    x: targetPos.x + targetVel.x * lookAhead,
+    y: targetPos.y + targetVel.y * lookAhead
+  };
+  return seek(pos, predicted, speed);
+}
+function evade(pos, threatPos, threatVel, speed, lookAhead = 0.5) {
+  const predicted = {
+    x: threatPos.x + threatVel.x * lookAhead,
+    y: threatPos.y + threatVel.y * lookAhead
+  };
+  return flee(pos, predicted, speed);
+}
+function separation(pos, neighbors, speed, radius) {
+  let sx = 0;
+  let sy = 0;
+  let count = 0;
+  for (const n of neighbors) {
+    const dx = pos.x - n.x;
+    const dy = pos.y - n.y;
+    const dist = Math.hypot(dx, dy);
+    if (dist > 0 && dist < radius) {
+      const weight = 1 - dist / radius;
+      sx += dx / dist * weight;
+      sy += dy / dist * weight;
+      count++;
+    }
+  }
+  if (count === 0) return { x: 0, y: 0 };
+  return normalize({ x: sx, y: sy }, speed);
+}
+function cohesion(pos, neighbors, speed) {
+  if (neighbors.length === 0) return { x: 0, y: 0 };
+  let cx = 0;
+  let cy = 0;
+  for (const n of neighbors) {
+    cx += n.x;
+    cy += n.y;
+  }
+  cx /= neighbors.length;
+  cy /= neighbors.length;
+  return seek(pos, { x: cx, y: cy }, speed);
+}
+function alignment(neighborVelocities, speed) {
+  if (neighborVelocities.length === 0) return { x: 0, y: 0 };
+  let ax = 0;
+  let ay = 0;
+  for (const v of neighborVelocities) {
+    ax += v.x;
+    ay += v.y;
+  }
+  return normalize({ x: ax, y: ay }, speed);
+}
 
 // ../../packages/core/src/components/transform.ts
 function createTransform(x = 0, y = 0, rotation = 0, scaleX = 1, scaleY = 1) {
@@ -930,10 +1025,15 @@ var Ease = {
   easeInBounce: (t) => 1 - Ease.easeOutBounce(1 - t),
   easeInOutBounce: (t) => t < 0.5 ? (1 - Ease.easeOutBounce(1 - 2 * t)) / 2 : (1 + Ease.easeOutBounce(2 * t - 1)) / 2
 };
-function tween(from, to, duration, ease = Ease.linear, onUpdate, onComplete) {
+function tween(from, to, duration, ease = Ease.linear, onUpdate, onComplete, opts) {
   let elapsed = 0;
   let stopped = false;
   let complete = false;
+  let delayRemaining = opts?.delay ?? 0;
+  const maxRepeats = opts?.repeat ?? 0;
+  const yoyo = opts?.yoyo ?? false;
+  let repeatsDone = 0;
+  let forward = true;
   return {
     get isComplete() {
       return complete;
@@ -943,13 +1043,32 @@ function tween(from, to, duration, ease = Ease.linear, onUpdate, onComplete) {
     },
     update(dt) {
       if (stopped || complete) return;
-      elapsed = Math.min(elapsed + dt, duration);
-      const t = duration > 0 ? elapsed / duration : 1;
-      onUpdate(from + (to - from) * ease(t));
+      if (delayRemaining > 0) {
+        delayRemaining -= dt;
+        if (delayRemaining > 0) return;
+        dt = -delayRemaining;
+        delayRemaining = 0;
+      }
+      elapsed += dt;
       if (elapsed >= duration) {
-        complete = true;
-        onComplete?.();
+        const overshoot = elapsed - duration;
+        const end2 = forward ? to : from;
+        onUpdate(end2);
+        if (repeatsDone < maxRepeats) {
+          repeatsDone++;
+          if (yoyo) forward = !forward;
+          elapsed = Math.min(overshoot, duration);
+        } else {
+          complete = true;
+          onComplete?.();
+          return;
+        }
       }
+      const t = duration > 0 ? elapsed / duration : 1;
+      const easedT = ease(t);
+      const start = forward ? from : to;
+      const end = forward ? to : from;
+      onUpdate(start + (end - start) * easedT);
     }
   };
 }
@@ -2225,7 +2344,14 @@ function createWhiteTexture(gl) {
   gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
   return tex;
 }
-var SHAPE_TEX_SIZE = 128;
+function shapeTexSize(spriteW, spriteH) {
+  const maxDim = Math.max(spriteW, spriteH);
+  if (maxDim <= 32) return 32;
+  if (maxDim <= 64) return 64;
+  if (maxDim <= 128) return 128;
+  if (maxDim <= 256) return 256;
+  return 512;
+}
 function drawShapeOnCanvas(ctx, shape, w, h, borderRadius, starPoints, starInnerRadius) {
   const cx = w / 2;
   const cy = h / 2;
@@ -2305,7 +2431,8 @@ function getShapeKey(sprite) {
   const sp = shape === "star" ? sprite.starPoints ?? 5 : 0;
   const sir = shape === "star" ? sprite.starInnerRadius ?? 0.4 : 0;
   const stroke = sprite.strokeColor && (sprite.strokeWidth ?? 0) > 0 ? `|s:${sprite.strokeColor}:${sprite.strokeWidth}` : "";
-  return `__shape__:${shape}:${br}:${sp}:${sir}${stroke}`;
+  const res = shapeTexSize(sprite.width, sprite.height);
+  return `__shape__:${shape}:${br}:${sp}:${sir}${stroke}:r${res}`;
 }
 function getSamplingKey(sampling) {
   if (!sampling) return "";
@@ -2633,7 +2760,7 @@ var RenderSystem = class {
     const key = getShapeKey(sprite);
     const cached = this.shapeTextures.get(key);
     if (cached) return cached;
-    const size = SHAPE_TEX_SIZE;
+    const size = shapeTexSize(sprite.width, sprite.height);
     const offscreen = document.createElement("canvas");
     offscreen.width = size;
     offscreen.height = size;
@@ -2876,12 +3003,21 @@ var RenderSystem = class {
       }
       sprite.frameIndex = anim.frames[anim.currentIndex];
     }
-    for (const id of world.query("SquashStretch", "RigidBody")) {
+    for (const id of world.query("SquashStretch")) {
       const ss = world.getComponent(id, "SquashStretch");
-      const rb = world.getComponent(id, "RigidBody");
-      const spd = Math.sqrt(rb.vx * rb.vx + rb.vy * rb.vy);
-      const tScX = rb.vy < -100 ? 1 + ss.intensity * 0.4 : spd > 50 ? 1 - ss.intensity * 0.3 : 1;
-      const tScY = rb.vy < -100 ? 1 - ss.intensity * 0.4 : spd > 50 ? 1 + ss.intensity * 0.3 : 1;
+      let tScX;
+      let tScY;
+      if (ss._manualTargetX !== void 0 && ss._manualTargetY !== void 0) {
+        tScX = ss._manualTargetX;
+        tScY = ss._manualTargetY;
+        ss._manualTargetX = void 0;
+        ss._manualTargetY = void 0;
+      } else {
+        const rb = world.getComponent(id, "RigidBody");
+        const spd = rb ? Math.sqrt(rb.vx * rb.vx + rb.vy * rb.vy) : 0;
+        tScX = rb && rb.vy < -100 ? 1 + ss.intensity * 0.4 : spd > 50 ? 1 - ss.intensity * 0.3 : 1;
+        tScY = rb && rb.vy < -100 ? 1 - ss.intensity * 0.4 : spd > 50 ? 1 + ss.intensity * 0.3 : 1;
+      }
       ss.currentScaleX += (tScX - ss.currentScaleX) * ss.recovery * dt;
       ss.currentScaleY += (tScY - ss.currentScaleY) * ss.recovery * dt;
     }
@@ -3013,7 +3149,16 @@ var RenderSystem = class {
       const scaleXMod = ss ? ss.currentScaleX : 1;
       const scaleYMod = ss ? ss.currentScaleY : 1;
       const hasTexture = sprite.image && sprite.image.complete && sprite.image.naturalWidth > 0;
-      const [r, g, b, a] = hasTexture ? [1, 1, 1, 1] : parseCSSColor(sprite.color);
+      const opacity = sprite.opacity ?? 1;
+      let [r, g, b, a] = hasTexture ? [1, 1, 1, 1] : parseCSSColor(sprite.color);
+      a *= opacity;
+      if (sprite.tint && (sprite.tintOpacity ?? 0) > 0) {
+        const [tr, tg, tb] = parseCSSColor(sprite.tint);
+        const t = sprite.tintOpacity ?? 0.3;
+        r = r * (1 - t) + tr * t;
+        g = g * (1 - t) + tg * t;
+        b = b * (1 - t) + tb * t;
+      }
       const uv = getUVRect(sprite);
       this.writeInstance(
         batchCount * FLOATS_PER_INSTANCE,
@@ -3093,6 +3238,7 @@ var RenderSystem = class {
         p.x += p.vx * dt;
         p.y += p.vy * dt;
         p.vy += p.gravity * dt;
+        if (p.rotationSpeed !== void 0) p.rotation = (p.rotation ?? 0) + p.rotationSpeed * dt;
         return p.life > 0;
       });
       if (pool.active && pool.particles.length < pool.maxParticles) {
@@ -3120,6 +3266,13 @@ var RenderSystem = class {
             ox = (world.rng() - 0.5) * (pool.emitWidth ?? 0);
             oy = (world.rng() - 0.5) * (pool.emitHeight ?? 0);
           }
+          const startSize = pool.sizeOverLife?.start ?? pool.particleSize;
+          const endSize = pool.sizeOverLife?.end ?? pool.particleSize;
+          let rotSpeed;
+          if (pool.enableRotation && pool.rotationSpeedRange) {
+            const [mn, mx] = pool.rotationSpeedRange;
+            rotSpeed = mn + world.rng() * (mx - mn);
+          }
           pool.particles.push({
             x: t.x + ox,
             y: t.y + oy,
@@ -3127,9 +3280,13 @@ var RenderSystem = class {
             vy: Math.sin(angle) * speed,
             life: pool.particleLife,
             maxLife: pool.particleLife,
-            size: pool.particleSize,
+            size: startSize,
+            startSize,
+            endSize,
             color: pool.color,
-            gravity: pool.gravity
+            gravity: pool.gravity,
+            rotation: pool.enableRotation ? world.rng() * Math.PI * 2 : 0,
+            rotationSpeed: rotSpeed
           });
         }
       }
@@ -3140,15 +3297,33 @@ var RenderSystem = class {
           this.flush(pCount, pKey);
           pCount = 0;
         }
-        const alpha = p.life / p.maxLife;
-        const [r, g, b] = parseCSSColor(p.color);
+        const lifeFrac = p.life / p.maxLife;
+        const alpha = lifeFrac;
+        const sz = p.startSize !== void 0 && p.endSize !== void 0 ? p.endSize + (p.startSize - p.endSize) * lifeFrac : p.size;
+        let r, g, b;
+        if (pool.colorOverLife && pool.colorOverLife.length >= 2) {
+          const palette = pool.colorOverLife;
+          const frac = 1 - lifeFrac;
+          const scaled = frac * (palette.length - 1);
+          const lo = Math.floor(scaled);
+          const hi = Math.min(lo + 1, palette.length - 1);
+          const lf = scaled - lo;
+          const [r0, g0, b0] = parseCSSColor(palette[lo]);
+          const [r1, g1, b1] = parseCSSColor(palette[hi]);
+          r = r0 + (r1 - r0) * lf;
+          g = g0 + (g1 - g0) * lf;
+          b = b0 + (b1 - b0) * lf;
+        } else {
+          ;
+          [r, g, b] = parseCSSColor(p.color);
+        }
         this.writeInstance(
           pCount * FLOATS_PER_INSTANCE,
           p.x,
           p.y,
-          p.size,
-          p.size,
-          0,
+          sz,
+          sz,
+          p.rotation ?? 0,
           0.5,
           0.5,
           0,
@@ -3174,21 +3349,38 @@ var RenderSystem = class {
       trail.points.unshift({ x: t.x, y: t.y });
       if (trail.points.length > trail.length) trail.points.length = trail.length;
       if (trail.points.length < 1) continue;
-      const [tr, tg, tb] = parseCSSColor(trail.color);
-      const trailW = trail.width > 0 ? trail.width : 1;
+      const baseColor = parseCSSColor(trail.color);
       let tCount = 0;
       for (let i = 0; i < trail.points.length; i++) {
         if (tCount >= MAX_INSTANCES) {
           this.flush(tCount, "__color__");
           tCount = 0;
         }
-        const alpha = 1 - i / trail.points.length;
+        const frac = trail.points.length > 1 ? i / (trail.points.length - 1) : 0;
+        let tr, tg, tb;
+        if (trail.colorOverLife && trail.colorOverLife.length >= 2) {
+          const palette = trail.colorOverLife;
+          const scaled = frac * (palette.length - 1);
+          const lo = Math.floor(scaled);
+          const hi = Math.min(lo + 1, palette.length - 1);
+          const lf = scaled - lo;
+          const [r0, g0, b0] = parseCSSColor(palette[lo]);
+          const [r1, g1, b1] = parseCSSColor(palette[hi]);
+          tr = r0 + (r1 - r0) * lf;
+          tg = g0 + (g1 - g0) * lf;
+          tb = b0 + (b1 - b0) * lf;
+        } else {
+          ;
+          [tr, tg, tb] = baseColor;
+        }
+        const segW = trail.widthOverLife ? trail.widthOverLife.start + (trail.widthOverLife.end - trail.widthOverLife.start) * frac : trail.width > 0 ? trail.width : 1;
+        const alpha = 1 - frac;
         this.writeInstance(
           tCount * FLOATS_PER_INSTANCE,
           trail.points[i].x,
           trail.points[i].y,
-          trailW,
-          trailW,
+          segW,
+          segW,
           0,
           0.5,
           0.5,
@@ -4395,9 +4587,9 @@ function generatePolygonPolygonManifoldFromPolys(polyA, polyB) {
   bCy /= polyB.vertices.length;
   const contacts = [];
   for (const cp of clipPoints) {
-    const separation = dot(refNx, refNy, cp.x, cp.y) - refFaceOffset;
-    if (separation > 0) continue;
-    const penetration = -separation;
+    const separation2 = dot(refNx, refNy, cp.x, cp.y) - refFaceOffset;
+    if (separation2 > 0) continue;
+    const penetration = -separation2;
     let worldAx, worldAy, worldBx, worldBy;
     if (!flip) {
       worldBx = cp.x;
@@ -5371,8 +5563,8 @@ function solvePositions(constraints, iterations, beta, slop) {
         const rAy = pd.point.worldAy - bodyA.y;
         const rBx = pd.point.worldBx - bodyB.x;
         const rBy = pd.point.worldBy - bodyB.y;
-        const separation = (bodyB.x + rBx - (bodyA.x + rAx)) * manifold.normalX + (bodyB.y + rBy - (bodyA.y + rAy)) * manifold.normalY - pd.point.penetration;
-        const posError = Math.max(0, -separation - slop);
+        const separation2 = (bodyB.x + rBx - (bodyA.x + rAx)) * manifold.normalX + (bodyB.y + rBy - (bodyA.y + rAy)) * manifold.normalY - pd.point.penetration;
+        const posError = Math.max(0, -separation2 - slop);
         if (posError <= 0) continue;
         const rAxN = cross(rAx, rAy, manifold.normalX, manifold.normalY);
         const rBxN = cross(rBx, rBy, manifold.normalX, manifold.normalY);
@@ -14940,6 +15132,18 @@ function useCamera() {
         if (camId === void 0) return;
         const cam = engine.ecs.getComponent(camId, "Camera2D");
         if (cam) cam.zoom = zoom;
+      },
+      getPosition() {
+        const camId = engine.ecs.queryOne("Camera2D");
+        if (camId === void 0) return { x: 0, y: 0 };
+        const cam = engine.ecs.getComponent(camId, "Camera2D");
+        return cam ? { x: cam.x, y: cam.y } : { x: 0, y: 0 };
+      },
+      getZoom() {
+        const camId = engine.ecs.queryOne("Camera2D");
+        if (camId === void 0) return 1;
+        const cam = engine.ecs.getComponent(camId, "Camera2D");
+        return cam?.zoom ?? 1;
       }
     }),
     [engine]
@@ -15057,10 +15261,39 @@ function useCoordinates() {
   return { worldToScreen, screenToWorld };
 }
 
+// src/hooks/useWorldQuery.ts
+import { useEffect as useEffect42, useRef as useRef10, useState as useState7 } from "react";
+function useWorldQuery(...components) {
+  const engine = useGame();
+  const [result, setResult] = useState7(() => engine.ecs.query(...components));
+  const prevRef = useRef10([]);
+  const rafRef = useRef10(0);
+  const mountedRef = useRef10(true);
+  useEffect42(() => {
+    mountedRef.current = true;
+    const tick = () => {
+      if (!mountedRef.current) return;
+      const next = engine.ecs.query(...components);
+      const prev = prevRef.current;
+      if (next.length !== prev.length || next.some((id, i) => id !== prev[i])) {
+        prevRef.current = next;
+        setResult([...next]);
+      }
+      rafRef.current = requestAnimationFrame(tick);
+    };
+    rafRef.current = requestAnimationFrame(tick);
+    return () => {
+      mountedRef.current = false;
+      cancelAnimationFrame(rafRef.current);
+    };
+  }, [engine, ...components]);
+  return result;
+}
+
 // src/hooks/useInputContext.ts
-import { useEffect as useEffect42, useMemo as useMemo4 } from "react";
+import { useEffect as useEffect43, useMemo as useMemo4 } from "react";
 function useInputContext(ctx) {
-  useEffect42(() => {
+  useEffect43(() => {
     if (!ctx) return;
     globalInputContext.push(ctx);
     return () => globalInputContext.pop(ctx);
@@ -15102,12 +15335,12 @@ function useInputRecorder() {
 }
 
 // src/hooks/useGamepad.ts
-import { useEffect as useEffect43, useRef as useRef10, useState as useState7 } from "react";
+import { useEffect as useEffect44, useRef as useRef11, useState as useState8 } from "react";
 var EMPTY_STATE = { connected: false, axes: [], buttons: [] };
 function useGamepad(playerIndex = 0) {
-  const [state, setState] = useState7(EMPTY_STATE);
-  const rafRef = useRef10(0);
-  useEffect43(() => {
+  const [state, setState] = useState8(EMPTY_STATE);
+  const rafRef = useRef11(0);
+  useEffect44(() => {
     const poll = () => {
       const gp = navigator.getGamepads()[playerIndex];
       if (gp) {
@@ -15128,10 +15361,10 @@ function useGamepad(playerIndex = 0) {
 }
 
 // src/hooks/usePause.ts
-import { useContext as useContext44, useState as useState8, useCallback as useCallback4 } from "react";
+import { useContext as useContext44, useState as useState9, useCallback as useCallback4 } from "react";
 function usePause() {
   const engine = useContext44(EngineContext);
-  const [paused, setPaused] = useState8(false);
+  const [paused, setPaused] = useState9(false);
   const pause = useCallback4(() => {
     engine.loop.pause();
     setPaused(true);
@@ -15148,7 +15381,7 @@ function usePause() {
 }
 
 // src/hooks/useProfiler.ts
-import { useContext as useContext45, useEffect as useEffect44, useRef as useRef11, useState as useState9 } from "react";
+import { useContext as useContext45, useEffect as useEffect45, useRef as useRef12, useState as useState10 } from "react";
 var EMPTY = {
   fps: 0,
   frameTime: 0,
@@ -15157,11 +15390,11 @@ var EMPTY = {
 };
 function useProfiler() {
   const engine = useContext45(EngineContext);
-  const [data, setData] = useState9(EMPTY);
-  const frameTimesRef = useRef11([]);
-  const lastUpdateRef = useRef11(0);
-  const prevTimeRef = useRef11(0);
-  useEffect44(() => {
+  const [data, setData] = useState10(EMPTY);
+  const frameTimesRef = useRef12([]);
+  const lastUpdateRef = useRef12(0);
+  const prevTimeRef = useRef12(0);
+  useEffect45(() => {
     if (!engine) return;
     let rafId;
     const frameTimes = frameTimesRef.current;
@@ -15201,10 +15434,10 @@ function useProfiler() {
 }
 
 // src/hooks/usePostProcess.ts
-import { useEffect as useEffect45 } from "react";
+import { useEffect as useEffect46 } from "react";
 function usePostProcess(effect) {
   const engine = useGame();
-  useEffect45(() => {
+  useEffect46(() => {
     engine.postProcessStack.add(effect);
     return () => {
       engine.postProcessStack.remove(effect);
@@ -15238,14 +15471,14 @@ function useTouch() {
 }
 
 // src/hooks/useTimer.ts
-import { useRef as useRef12, useCallback as useCallback5, useEffect as useEffect46, useContext as useContext47 } from "react";
+import { useRef as useRef13, useCallback as useCallback5, useEffect as useEffect47, useContext as useContext47 } from "react";
 function useTimer(duration, onComplete, opts) {
   const engine = useContext47(EngineContext);
-  const onCompleteRef = useRef12(onComplete);
+  const onCompleteRef = useRef13(onComplete);
   onCompleteRef.current = onComplete;
-  const loopRef = useRef12(opts?.loop ?? false);
+  const loopRef = useRef13(opts?.loop ?? false);
   loopRef.current = opts?.loop ?? false;
-  const timerRef = useRef12(null);
+  const timerRef = useRef13(null);
   if (!timerRef.current) {
     timerRef.current = createTimer(
       duration,
@@ -15258,7 +15491,7 @@ function useTimer(duration, onComplete, opts) {
       opts?.autoStart ?? false
     );
   }
-  useEffect46(() => {
+  useEffect47(() => {
     const eid = engine.ecs.createEntity();
     engine.ecs.addComponent(
       eid,
@@ -15299,15 +15532,15 @@ function useTimer(duration, onComplete, opts) {
 }
 
 // src/hooks/useCoroutine.ts
-import { useRef as useRef13, useEffect as useEffect47, useContext as useContext48 } from "react";
+import { useRef as useRef14, useEffect as useEffect48, useContext as useContext48 } from "react";
 var wait = (seconds) => ({ type: "wait", seconds });
 var waitFrames = (frames) => ({ type: "waitFrames", frames });
 var waitUntil = (condition) => ({ type: "waitUntil", condition });
 var nextCoroutineId = 1;
 function useCoroutine() {
   const engine = useContext48(EngineContext);
-  const coroutinesRef = useRef13(/* @__PURE__ */ new Map());
-  useEffect47(() => {
+  const coroutinesRef = useRef14(/* @__PURE__ */ new Map());
+  useEffect48(() => {
     const eid = engine.ecs.createEntity();
     engine.ecs.addComponent(
       eid,
@@ -15372,15 +15605,15 @@ function useCoroutine() {
       return coroutinesRef.current.size;
     }
   };
-  const controlsRef = useRef13(controls);
+  const controlsRef = useRef14(controls);
   return controlsRef.current;
 }
 
 // src/hooks/useSceneManager.ts
-import { useState as useState10, useCallback as useCallback6, useRef as useRef14 } from "react";
+import { useState as useState11, useCallback as useCallback6, useRef as useRef15 } from "react";
 function useSceneManager(initialScene) {
-  const [stack, setStack] = useState10([initialScene]);
-  const stackRef = useRef14(stack);
+  const [stack, setStack] = useState11([initialScene]);
+  const stackRef = useRef15(stack);
   stackRef.current = stack;
   const push = useCallback6((scene) => {
     setStack((prev) => [...prev, scene]);
@@ -15422,9 +15655,9 @@ function useInputBuffer(opts) {
 }
 
 // src/hooks/useComboDetector.ts
-import { useMemo as useMemo9, useRef as useRef15 } from "react";
+import { useMemo as useMemo9, useRef as useRef16 } from "react";
 function useComboDetector(combos) {
-  const lastComboRef = useRef15(null);
+  const lastComboRef = useRef16(null);
   const result = useMemo9(() => {
     const detector = new ComboDetector({ combos });
     const api = {
@@ -15447,11 +15680,11 @@ function useComboDetector(combos) {
 }
 
 // src/hooks/useParent.ts
-import { useEffect as useEffect48, useContext as useContext49 } from "react";
+import { useEffect as useEffect49, useContext as useContext49 } from "react";
 function useParent(childEntityId, parentEntityId) {
   const engine = useContext49(EngineContext);
   if (!engine) throw new Error("useParent must be used inside <Game>");
-  useEffect48(() => {
+  useEffect49(() => {
     setParent(engine.ecs, childEntityId, parentEntityId);
     return () => {
       removeParent(engine.ecs, childEntityId);
@@ -15488,18 +15721,18 @@ function useAccessibility() {
 }
 
 // src/hooks/useHMR.ts
-import { useEffect as useEffect49, useRef as useRef16, useMemo as useMemo10 } from "react";
+import { useEffect as useEffect50, useRef as useRef17, useMemo as useMemo10 } from "react";
 var idCounter = 0;
 function useHMR(hmrKey) {
-  const idRef = useRef16(null);
+  const idRef = useRef17(null);
   if (idRef.current === null) {
     idRef.current = hmrKey ?? `__hmr_${idCounter++}`;
   }
   const key = idRef.current;
   const isHotReload = hmrLoadState(key) !== void 0;
-  const disposeRef = useRef16(null);
-  const acceptRef = useRef16(null);
-  useEffect49(() => {
+  const disposeRef = useRef17(null);
+  const acceptRef = useRef17(null);
+  useEffect50(() => {
     const hot = import.meta.hot;
     if (!hot) return;
     hot.dispose(() => {
@@ -15531,11 +15764,28 @@ function useHMR(hmrKey) {
   );
 }
 
+// src/hooks/useSquashStretch.ts
+import { useCallback as useCallback8, useContext as useContext50 } from "react";
+function useSquashStretch() {
+  const engine = useContext50(EngineContext);
+  const entityId = useContext50(EntityContext);
+  const trigger = useCallback8(
+    (scaleX, scaleY) => {
+      const ss = engine.ecs.getComponent(entityId, "SquashStretch");
+      if (!ss) return;
+      ss._manualTargetX = scaleX;
+      ss._manualTargetY = scaleY;
+    },
+    [engine, entityId]
+  );
+  return { trigger };
+}
+
 // ../gameplay/src/hooks/useAnimationController.ts
-import { useState as useState11, useCallback as useCallback8 } from "react";
+import { useState as useState12, useCallback as useCallback9 } from "react";
 function useAnimationController(states, initial) {
-  const [stateName, setStateName] = useState11(initial);
-  const setState = useCallback8((next) => {
+  const [stateName, setStateName] = useState12(initial);
+  const setState = useCallback9((next) => {
     setStateName((prev) => prev === next ? prev : next);
   }, []);
   const clip = states[stateName] ?? states[initial];
@@ -15557,29 +15807,60 @@ function useAnimationController(states, initial) {
 }
 
 // ../gameplay/src/hooks/useAISteering.ts
-import { useCallback as useCallback9 } from "react";
+import { useCallback as useCallback10 } from "react";
 function useAISteering() {
-  const seek$ = useCallback9((pos, target, speed) => seek(pos, target, speed), []);
-  const flee$ = useCallback9((pos, threat, speed) => flee(pos, threat, speed), []);
-  const arrive$ = useCallback9(
+  const seek$ = useCallback10((pos, target, speed) => seek(pos, target, speed), []);
+  const flee$ = useCallback10((pos, threat, speed) => flee(pos, threat, speed), []);
+  const arrive$ = useCallback10(
     (pos, target, speed, slowRadius) => arrive(pos, target, speed, slowRadius),
     []
   );
-  const patrol$ = useCallback9(
+  const patrol$ = useCallback10(
     (pos, waypoints, speed, currentIdx, arriveThreshold) => patrol(pos, waypoints, speed, currentIdx, arriveThreshold),
     []
   );
-  const wander$ = useCallback9(
+  const wander$ = useCallback10(
     (pos, angle, speed, jitter) => wander(pos, angle, speed, jitter),
     []
   );
-  return { seek: seek$, flee: flee$, arrive: arrive$, patrol: patrol$, wander: wander$ };
+  const pursuit$ = useCallback10(
+    (pos, targetPos, targetVel, speed, lookAhead) => pursuit(pos, targetPos, targetVel, speed, lookAhead),
+    []
+  );
+  const evade$ = useCallback10(
+    (pos, threatPos, threatVel, speed, lookAhead) => evade(pos, threatPos, threatVel, speed, lookAhead),
+    []
+  );
+  const separation$ = useCallback10(
+    (pos, neighbors, speed, radius) => separation(pos, neighbors, speed, radius),
+    []
+  );
+  const cohesion$ = useCallback10(
+    (pos, neighbors, speed) => cohesion(pos, neighbors, speed),
+    []
+  );
+  const alignment$ = useCallback10(
+    (neighborVelocities, speed) => alignment(neighborVelocities, speed),
+    []
+  );
+  return {
+    seek: seek$,
+    flee: flee$,
+    arrive: arrive$,
+    patrol: patrol$,
+    wander: wander$,
+    pursuit: pursuit$,
+    evade: evade$,
+    separation: separation$,
+    cohesion: cohesion$,
+    alignment: alignment$
+  };
 }
 
 // ../gameplay/src/hooks/useDamageZone.ts
-import { useContext as useContext50 } from "react";
+import { useContext as useContext51 } from "react";
 function useDamageZone(damage, opts = {}) {
-  const engine = useContext50(EngineContext);
+  const engine = useContext51(EngineContext);
   useTriggerEnter(
     (other) => {
       engine.events.emit(`damage:${other}`, { amount: damage });
@@ -15589,11 +15870,11 @@ function useDamageZone(damage, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useDropThrough.ts
-import { useContext as useContext51, useCallback as useCallback10 } from "react";
+import { useContext as useContext52, useCallback as useCallback11 } from "react";
 function useDropThrough(frames = 8) {
-  const engine = useContext51(EngineContext);
-  const entityId = useContext51(EntityContext);
-  const dropThrough = useCallback10(() => {
+  const engine = useContext52(EngineContext);
+  const entityId = useContext52(EntityContext);
+  const dropThrough = useCallback11(() => {
     const rb = engine.ecs.getComponent(entityId, "RigidBody");
     if (rb) rb.dropThrough = frames;
   }, [engine.ecs, entityId, frames]);
@@ -15601,17 +15882,17 @@ function useDropThrough(frames = 8) {
 }
 
 // ../gameplay/src/hooks/useGameStateMachine.ts
-import { useState as useState12, useRef as useRef17, useCallback as useCallback11, useEffect as useEffect50, useContext as useContext52 } from "react";
+import { useState as useState13, useRef as useRef18, useCallback as useCallback12, useEffect as useEffect51, useContext as useContext53 } from "react";
 function useGameStateMachine(states, initial) {
-  const engine = useContext52(EngineContext);
-  const [state, setState] = useState12(initial);
-  const stateRef = useRef17(initial);
-  const statesRef = useRef17(states);
+  const engine = useContext53(EngineContext);
+  const [state, setState] = useState13(initial);
+  const stateRef = useRef18(initial);
+  const statesRef = useRef18(states);
   statesRef.current = states;
-  useEffect50(() => {
+  useEffect51(() => {
     statesRef.current[initial]?.onEnter?.();
   }, []);
-  const transition = useCallback11((to) => {
+  const transition = useCallback12((to) => {
     const current = stateRef.current;
     if (current === to) return;
     statesRef.current[current]?.onExit?.();
@@ -15619,7 +15900,7 @@ function useGameStateMachine(states, initial) {
     setState(to);
     statesRef.current[to]?.onEnter?.();
   }, []);
-  useEffect50(() => {
+  useEffect51(() => {
     const eid = engine.ecs.createEntity();
     engine.ecs.addComponent(
       eid,
@@ -15635,27 +15916,27 @@ function useGameStateMachine(states, initial) {
 }
 
 // ../gameplay/src/hooks/useHealth.ts
-import { useRef as useRef18, useEffect as useEffect51, useContext as useContext53, useCallback as useCallback12 } from "react";
+import { useRef as useRef19, useEffect as useEffect52, useContext as useContext54, useCallback as useCallback13 } from "react";
 function useHealth(maxHp, opts = {}) {
-  const engine = useContext53(EngineContext);
-  const entityId = useContext53(EntityContext);
-  const hpRef = useRef18(maxHp);
-  const invincibleRef = useRef18(false);
+  const engine = useContext54(EngineContext);
+  const entityId = useContext54(EntityContext);
+  const hpRef = useRef19(maxHp);
+  const invincibleRef = useRef19(false);
   const iFrameDuration = opts.iFrames ?? 1;
-  const onDeathRef = useRef18(opts.onDeath);
-  const onDamageRef = useRef18(opts.onDamage);
-  useEffect51(() => {
+  const onDeathRef = useRef19(opts.onDeath);
+  const onDamageRef = useRef19(opts.onDamage);
+  useEffect52(() => {
     onDeathRef.current = opts.onDeath;
   });
-  useEffect51(() => {
+  useEffect52(() => {
     onDamageRef.current = opts.onDamage;
   });
-  const timerRef = useRef18(
+  const timerRef = useRef19(
     createTimer(iFrameDuration, () => {
       invincibleRef.current = false;
     })
   );
-  const takeDamage = useCallback12(
+  const takeDamage = useCallback13(
     (amount = 1) => {
       if (invincibleRef.current || hpRef.current <= 0) return;
       hpRef.current = Math.max(0, hpRef.current - amount);
@@ -15668,28 +15949,28 @@ function useHealth(maxHp, opts = {}) {
     },
     [iFrameDuration]
   );
-  const takeDamageRef = useRef18(takeDamage);
-  useEffect51(() => {
+  const takeDamageRef = useRef19(takeDamage);
+  useEffect52(() => {
     takeDamageRef.current = takeDamage;
   }, [takeDamage]);
-  useEffect51(() => {
+  useEffect52(() => {
     return engine.events.on(`damage:${entityId}`, ({ amount }) => {
       takeDamageRef.current(amount);
     });
   }, [engine.events, entityId]);
-  const heal = useCallback12(
+  const heal = useCallback13(
     (amount) => {
       hpRef.current = Math.min(maxHp, hpRef.current + amount);
     },
     [maxHp]
   );
-  const setHp = useCallback12(
+  const setHp = useCallback13(
     (hp) => {
       hpRef.current = Math.min(maxHp, Math.max(0, hp));
     },
     [maxHp]
   );
-  const update = useCallback12((dt) => {
+  const update = useCallback13((dt) => {
     timerRef.current.update(dt);
   }, []);
   return {
@@ -15713,11 +15994,11 @@ function useHealth(maxHp, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useKinematicBody.ts
-import { useContext as useContext54, useCallback as useCallback13 } from "react";
+import { useContext as useContext55, useCallback as useCallback14 } from "react";
 function useKinematicBody() {
-  const engine = useContext54(EngineContext);
-  const entityId = useContext54(EntityContext);
-  const moveAndCollide = useCallback13(
+  const engine = useContext55(EngineContext);
+  const entityId = useContext55(EntityContext);
+  const moveAndCollide = useCallback14(
     (dx, dy) => {
       const transform = engine.ecs.getComponent(entityId, "Transform");
       if (!transform) return { dx: 0, dy: 0 };
@@ -15753,7 +16034,7 @@ function useKinematicBody() {
     },
     [engine.ecs, entityId]
   );
-  const setVelocity = useCallback13(
+  const setVelocity = useCallback14(
     (vx, vy) => {
       const rb = engine.ecs.getComponent(entityId, "RigidBody");
       if (rb) {
@@ -15763,7 +16044,7 @@ function useKinematicBody() {
     },
     [engine.ecs, entityId]
   );
-  const setAngularVelocity = useCallback13(
+  const setAngularVelocity = useCallback14(
     (w) => {
       const rb = engine.ecs.getComponent(entityId, "RigidBody");
       if (rb) rb.angularVelocity = w;
@@ -15774,12 +16055,12 @@ function useKinematicBody() {
 }
 
 // ../gameplay/src/hooks/useLevelTransition.ts
-import { useState as useState13, useRef as useRef19, useCallback as useCallback14 } from "react";
+import { useState as useState14, useRef as useRef20, useCallback as useCallback15 } from "react";
 function useLevelTransition(initial) {
-  const [currentLevel, setCurrentLevel] = useState13(initial);
-  const [isTransitioning, setIsTransitioning] = useState13(false);
-  const overlayRef = useRef19(null);
-  const transitionTo = useCallback14((level, opts = {}) => {
+  const [currentLevel, setCurrentLevel] = useState14(initial);
+  const [isTransitioning, setIsTransitioning] = useState14(false);
+  const overlayRef = useRef20(null);
+  const transitionTo = useCallback15((level, opts = {}) => {
     const { duration = 0.4, type = "fade" } = opts;
     if (type === "instant") {
       setCurrentLevel(level);
@@ -15816,13 +16097,13 @@ function useLevelTransition(initial) {
 }
 
 // ../gameplay/src/hooks/usePlatformerController.ts
-import { useContext as useContext55, useEffect as useEffect52 } from "react";
+import { useContext as useContext56, useEffect as useEffect53 } from "react";
 function normalizeKeys(val, defaults) {
   if (!val) return defaults;
   return Array.isArray(val) ? val : [val];
 }
 function usePlatformerController(entityId, opts = {}) {
-  const engine = useContext55(EngineContext);
+  const engine = useContext56(EngineContext);
   const {
     speed = 200,
     jumpForce = -500,
@@ -15835,7 +16116,7 @@ function usePlatformerController(entityId, opts = {}) {
   const leftKeys = normalizeKeys(bindings?.left, ["ArrowLeft", "KeyA", "a"]);
   const rightKeys = normalizeKeys(bindings?.right, ["ArrowRight", "KeyD", "d"]);
   const jumpKeys = normalizeKeys(bindings?.jump, ["Space", "ArrowUp", "KeyW", "w"]);
-  useEffect52(() => {
+  useEffect53(() => {
     const state = {
       coyoteTimer: 0,
       jumpBuffer: 0,
@@ -15882,26 +16163,26 @@ function usePlatformerController(entityId, opts = {}) {
 }
 
 // ../gameplay/src/hooks/usePathfinding.ts
-import { useCallback as useCallback15 } from "react";
+import { useCallback as useCallback16 } from "react";
 function usePathfinding() {
-  const createGrid$ = useCallback15(
+  const createGrid$ = useCallback16(
     (cols, rows, cellSize) => createNavGrid(cols, rows, cellSize),
     []
   );
-  const setWalkable$ = useCallback15(
+  const setWalkable$ = useCallback16(
     (grid, col, row, walkable) => setWalkable(grid, col, row, walkable),
     []
   );
-  const findPath$ = useCallback15((grid, start, goal) => findPath(grid, start, goal), []);
+  const findPath$ = useCallback16((grid, start, goal) => findPath(grid, start, goal), []);
   return { createGrid: createGrid$, setWalkable: setWalkable$, findPath: findPath$ };
 }
 
 // ../gameplay/src/hooks/usePersistedBindings.ts
-import { useState as useState14, useCallback as useCallback16, useMemo as useMemo11, useContext as useContext56 } from "react";
+import { useState as useState15, useCallback as useCallback17, useMemo as useMemo11, useContext as useContext57 } from "react";
 function usePersistedBindings(storageKey, defaults) {
-  const engine = useContext56(EngineContext);
+  const engine = useContext57(EngineContext);
   const input = engine.input;
-  const [bindings, setBindings] = useState14(() => {
+  const [bindings, setBindings] = useState15(() => {
     try {
       const stored = localStorage.getItem(storageKey);
       if (stored) return { ...defaults, ...JSON.parse(stored) };
@@ -15917,7 +16198,7 @@ function usePersistedBindings(storageKey, defaults) {
     }
     return out;
   }, [bindings]);
-  const rebind = useCallback16(
+  const rebind = useCallback17(
     (action, keys) => {
       setBindings((prev) => {
         const next = { ...prev, [action]: Array.isArray(keys) ? keys : [keys] };
@@ -15930,7 +16211,7 @@ function usePersistedBindings(storageKey, defaults) {
     },
     [storageKey]
   );
-  const reset = useCallback16(() => {
+  const reset = useCallback17(() => {
     try {
       localStorage.removeItem(storageKey);
     } catch {
@@ -15951,21 +16232,21 @@ function usePersistedBindings(storageKey, defaults) {
 }
 
 // ../gameplay/src/hooks/useRestart.ts
-import { useState as useState15, useCallback as useCallback17 } from "react";
+import { useState as useState16, useCallback as useCallback18 } from "react";
 function useRestart() {
-  const [restartKey, setRestartKey] = useState15(0);
-  const restart = useCallback17(() => {
+  const [restartKey, setRestartKey] = useState16(0);
+  const restart = useCallback18(() => {
     setRestartKey((k) => k + 1);
   }, []);
   return { restartKey, restart };
 }
 
 // ../gameplay/src/hooks/useSave.ts
-import { useCallback as useCallback18, useRef as useRef20 } from "react";
+import { useCallback as useCallback19, useRef as useRef21 } from "react";
 function useSave(key, defaultValue, opts = {}) {
   const version = opts.version ?? 1;
-  const dataRef = useRef20(defaultValue);
-  const save = useCallback18(
+  const dataRef = useRef21(defaultValue);
+  const save = useCallback19(
     (value) => {
       dataRef.current = value;
       const slot = { version, data: value };
@@ -15977,7 +16258,7 @@ function useSave(key, defaultValue, opts = {}) {
     },
     [key, version]
   );
-  const load = useCallback18(() => {
+  const load = useCallback19(() => {
     try {
       const raw = localStorage.getItem(key);
       if (!raw) return defaultValue;
@@ -15997,11 +16278,11 @@ function useSave(key, defaultValue, opts = {}) {
       return defaultValue;
     }
   }, [key, version]);
-  const clear = useCallback18(() => {
+  const clear = useCallback19(() => {
     localStorage.removeItem(key);
     dataRef.current = defaultValue;
   }, [key]);
-  const exists = useCallback18(() => {
+  const exists = useCallback19(() => {
     return localStorage.getItem(key) !== null;
   }, [key]);
   return {
@@ -16016,11 +16297,11 @@ function useSave(key, defaultValue, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useTopDownMovement.ts
-import { useContext as useContext57, useEffect as useEffect53 } from "react";
+import { useContext as useContext58, useEffect as useEffect54 } from "react";
 function useTopDownMovement(entityId, opts = {}) {
-  const engine = useContext57(EngineContext);
+  const engine = useContext58(EngineContext);
   const { speed = 200, normalizeDiagonal = true } = opts;
-  useEffect53(() => {
+  useEffect54(() => {
     const updateFn = (id, world, input) => {
       if (!world.hasEntity(id)) return;
       const rb = world.getComponent(id, "RigidBody");
@@ -16045,18 +16326,18 @@ function useTopDownMovement(entityId, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useDialogue.ts
-import { useState as useState16, useCallback as useCallback19, useRef as useRef21 } from "react";
+import { useState as useState17, useCallback as useCallback20, useRef as useRef22 } from "react";
 function useDialogue() {
-  const [active, setActive] = useState16(false);
-  const [currentId, setCurrentId] = useState16(null);
-  const scriptRef = useRef21(null);
-  const start = useCallback19((script, startId) => {
+  const [active, setActive] = useState17(false);
+  const [currentId, setCurrentId] = useState17(null);
+  const scriptRef = useRef22(null);
+  const start = useCallback20((script, startId) => {
     scriptRef.current = script;
     const id = startId ?? Object.keys(script)[0];
     setCurrentId(id);
     setActive(true);
   }, []);
-  const advance = useCallback19(
+  const advance = useCallback20(
     (choiceIndex) => {
       if (!scriptRef.current || !currentId) return;
       const line = scriptRef.current[currentId];
@@ -16086,7 +16367,7 @@ function useDialogue() {
     },
     [currentId]
   );
-  const close = useCallback19(() => {
+  const close = useCallback20(() => {
     setActive(false);
     setCurrentId(null);
     scriptRef.current = null;
@@ -16096,17 +16377,17 @@ function useDialogue() {
 }
 
 // ../gameplay/src/hooks/useCutscene.ts
-import { useState as useState17, useCallback as useCallback20, useRef as useRef22, useEffect as useEffect54, useContext as useContext58 } from "react";
+import { useState as useState18, useCallback as useCallback21, useRef as useRef23, useEffect as useEffect55, useContext as useContext59 } from "react";
 function useCutscene() {
-  const engine = useContext58(EngineContext);
-  const [playing, setPlaying] = useState17(false);
-  const [stepIndex, setStepIndex] = useState17(0);
-  const stepsRef = useRef22([]);
-  const timerRef = useRef22(0);
-  const idxRef = useRef22(0);
-  const playingRef = useRef22(false);
-  const entityRef = useRef22(null);
-  const finish = useCallback20(() => {
+  const engine = useContext59(EngineContext);
+  const [playing, setPlaying] = useState18(false);
+  const [stepIndex, setStepIndex] = useState18(0);
+  const stepsRef = useRef23([]);
+  const timerRef = useRef23(0);
+  const idxRef = useRef23(0);
+  const playingRef = useRef23(false);
+  const entityRef = useRef23(null);
+  const finish = useCallback21(() => {
     playingRef.current = false;
     setPlaying(false);
     setStepIndex(0);
@@ -16116,14 +16397,14 @@ function useCutscene() {
       entityRef.current = null;
     }
   }, [engine.ecs]);
-  const fireStep = useCallback20((step) => {
+  const fireStep = useCallback21((step) => {
     if (step.type === "call") step.fn();
     if (step.type === "parallel")
       step.steps.forEach((s2) => {
         if (s2.type === "call") s2.fn();
       });
   }, []);
-  const play = useCallback20(
+  const play = useCallback21(
     (steps) => {
       stepsRef.current = steps;
       idxRef.current = 0;
@@ -16180,7 +16461,7 @@ function useCutscene() {
     },
     [engine.ecs, finish, fireStep]
   );
-  const skip = useCallback20(() => {
+  const skip = useCallback21(() => {
     for (let i = idxRef.current; i < stepsRef.current.length; i++) {
       const step = stepsRef.current[i];
       if (step.type === "call") step.fn();
@@ -16191,7 +16472,7 @@ function useCutscene() {
     }
     finish();
   }, [finish]);
-  useEffect54(() => {
+  useEffect55(() => {
     return () => {
       if (entityRef.current !== null && engine.ecs.hasEntity(entityRef.current)) {
         engine.ecs.destroyEntity(entityRef.current);
@@ -16202,7 +16483,7 @@ function useCutscene() {
 }
 
 // ../gameplay/src/hooks/useGameStore.ts
-import { useSyncExternalStore as useSyncExternalStore2, useCallback as useCallback21 } from "react";
+import { useSyncExternalStore as useSyncExternalStore2, useCallback as useCallback22 } from "react";
 function createStore(initialState) {
   let state = { ...initialState };
   const listeners = /* @__PURE__ */ new Set();
@@ -16228,7 +16509,7 @@ function useGameStore(key, initialState) {
   }
   const store = stores.get(key);
   const state = useSyncExternalStore2(store.subscribe, store.getState);
-  const setState = useCallback21(
+  const setState = useCallback22(
     (partial) => {
       store.setState(partial);
     },
@@ -16238,21 +16519,21 @@ function useGameStore(key, initialState) {
 }
 
 // ../gameplay/src/hooks/useTween.ts
-import { useRef as useRef23, useCallback as useCallback22, useEffect as useEffect55 } from "react";
+import { useRef as useRef24, useCallback as useCallback23, useEffect as useEffect56 } from "react";
 function useTween(opts) {
-  const rafRef = useRef23(null);
-  const startTimeRef = useRef23(0);
-  const runningRef = useRef23(false);
-  const optsRef = useRef23(opts);
+  const rafRef = useRef24(null);
+  const startTimeRef = useRef24(0);
+  const runningRef = useRef24(false);
+  const optsRef = useRef24(opts);
   optsRef.current = opts;
-  const stop = useCallback22(() => {
+  const stop = useCallback23(() => {
     if (rafRef.current !== null) {
       cancelAnimationFrame(rafRef.current);
       rafRef.current = null;
     }
     runningRef.current = false;
   }, []);
-  const start = useCallback22(() => {
+  const start = useCallback23(() => {
     stop();
     runningRef.current = true;
     startTimeRef.current = performance.now();
@@ -16274,12 +16555,12 @@ function useTween(opts) {
     };
     rafRef.current = requestAnimationFrame(tick);
   }, [stop]);
-  useEffect55(() => {
+  useEffect56(() => {
     if (opts.autoStart) {
       start();
     }
   }, []);
-  useEffect55(() => {
+  useEffect56(() => {
     return () => {
       if (rafRef.current !== null) {
         cancelAnimationFrame(rafRef.current);
@@ -16298,15 +16579,15 @@ function useTween(opts) {
 }
 
 // ../gameplay/src/hooks/useObjectPool.ts
-import { useRef as useRef24, useMemo as useMemo12, useEffect as useEffect56 } from "react";
+import { useRef as useRef25, useMemo as useMemo12, useEffect as useEffect57 } from "react";
 function useObjectPool(factory, reset, initialSize) {
-  const poolRef = useRef24([]);
-  const activeRef = useRef24(0);
-  const factoryRef = useRef24(factory);
+  const poolRef = useRef25([]);
+  const activeRef = useRef25(0);
+  const factoryRef = useRef25(factory);
   factoryRef.current = factory;
-  const resetRef = useRef24(reset);
+  const resetRef = useRef25(reset);
   resetRef.current = reset;
-  useEffect56(() => {
+  useEffect57(() => {
     if (initialSize != null && initialSize > 0) {
       const pool = poolRef.current;
       for (let i = 0; i < initialSize; i++) {
@@ -16345,10 +16626,10 @@ function useObjectPool(factory, reset, initialSize) {
 }
 
 // ../gameplay/src/hooks/useForces.ts
-import { useContext as useContext59, useMemo as useMemo13 } from "react";
+import { useContext as useContext60, useMemo as useMemo13 } from "react";
 function useForces() {
-  const engine = useContext59(EngineContext);
-  const entityId = useContext59(EntityContext);
+  const engine = useContext60(EngineContext);
+  const entityId = useContext60(EntityContext);
   return useMemo13(() => {
     const getRb = () => engine.ecs.getComponent(entityId, "RigidBody");
     const getTransform = () => engine.ecs.getComponent(entityId, "Transform");
@@ -16417,10 +16698,10 @@ function useForces() {
 }
 
 // ../gameplay/src/hooks/useCharacterController.ts
-import { useContext as useContext60, useMemo as useMemo14 } from "react";
+import { useContext as useContext61, useMemo as useMemo14 } from "react";
 function useCharacterController(config = {}) {
-  const engine = useContext60(EngineContext);
-  const entityId = useContext60(EntityContext);
+  const engine = useContext61(EngineContext);
+  const entityId = useContext61(EntityContext);
   return useMemo14(() => {
     const controller = new CharacterController(config);
     return {
@@ -16433,7 +16714,7 @@ function useCharacterController(config = {}) {
 }
 
 // ../../packages/audio/src/useSound.ts
-import { useEffect as useEffect57, useRef as useRef25 } from "react";
+import { useEffect as useEffect58, useRef as useRef26 } from "react";
 
 // ../../packages/audio/src/audioContext.ts
 var _audioCtx = null;
@@ -16531,13 +16812,13 @@ function createPoolEntry(ctx, buffer, loop, volume, destination) {
   return { source, gain };
 }
 function useSound(src, opts = {}) {
-  const bufferRef = useRef25(null);
-  const activeInstances = useRef25([]);
-  const volRef = useRef25(opts.volume ?? 1);
-  const loopRef = useRef25(opts.loop ?? false);
-  const groupRef = useRef25(opts.group);
+  const bufferRef = useRef26(null);
+  const activeInstances = useRef26([]);
+  const volRef = useRef26(opts.volume ?? 1);
+  const loopRef = useRef26(opts.loop ?? false);
+  const groupRef = useRef26(opts.group);
   const maxInstances = opts.maxInstances ?? 4;
-  useEffect57(() => {
+  useEffect58(() => {
     let cancelled = false;
     loadBuffer(src).then((buf) => {
       if (!cancelled) bufferRef.current = buf;
@@ -16665,7 +16946,7 @@ function useSound(src, opts = {}) {
 }
 
 // ../../packages/audio/src/useSpatialSound.ts
-import { useEffect as useEffect58, useRef as useRef26 } from "react";
+import { useEffect as useEffect59, useRef as useRef27 } from "react";
 async function loadBuffer2(src) {
   const bufferCache2 = _getBufferCache();
   const bufferRefCount2 = _getBufferRefCount();
@@ -16690,18 +16971,18 @@ function releaseBuffer2(src) {
   }
 }
 function useSpatialSound(src, opts = {}) {
-  const bufferRef = useRef26(null);
-  const sourceRef = useRef26(null);
-  const gainRef = useRef26(null);
-  const pannerRef = useRef26(null);
-  const volRef = useRef26(opts.volume ?? 1);
-  const loopRef = useRef26(opts.loop ?? false);
-  const groupRef = useRef26(opts.group);
+  const bufferRef = useRef27(null);
+  const sourceRef = useRef27(null);
+  const gainRef = useRef27(null);
+  const pannerRef = useRef27(null);
+  const volRef = useRef27(opts.volume ?? 1);
+  const loopRef = useRef27(opts.loop ?? false);
+  const groupRef = useRef27(opts.group);
   const maxDistance = opts.maxDistance ?? 1e3;
   const distModel = opts.distanceModel ?? "linear";
   const refDistance = opts.refDistance ?? 1;
   const rolloffFactor = opts.rolloffFactor ?? 1;
-  useEffect58(() => {
+  useEffect59(() => {
     let cancelled = false;
     loadBuffer2(src).then((buf) => {
       if (!cancelled) bufferRef.current = buf;
@@ -16919,6 +17200,7 @@ export {
   addForce,
   addForceAtPoint,
   addTorque,
+  alignment,
   announceToScreenReader,
   applyImpulse,
   applyImpulseAtPoint,
@@ -16932,6 +17214,7 @@ export {
   chromaticAberrationEffect,
   circleArea,
   circleShape,
+  cohesion,
   computeTOI,
   containsPoint,
   createAtlas,
@@ -16973,6 +17256,7 @@ export {
   deterministicSqrt,
   duck,
   epa,
+  evade,
   findByTag,
   flee,
   generateDeterministicPairs,
@@ -17005,6 +17289,7 @@ export {
   predictPosition,
   preloadManifest,
   projectPoint,
+  pursuit,
   queryBVH,
   queryBVHCircle,
   raycast,
@@ -17018,6 +17303,7 @@ export {
   restoreSnapshot,
   scanlineEffect,
   seek,
+  separation,
   setAccessibilityOptions,
   setAdditionalMass,
   setAnimationState,
@@ -17032,6 +17318,7 @@ export {
   setNextKinematicRotation,
   setParent,
   shapeCast,
+  smoothPath,
   snapshotFromBytes,
   snapshotFromJSON,
   snapshotHash,
@@ -17098,6 +17385,7 @@ export {
   useSnapshot,
   useSound,
   useSpatialSound,
+  useSquashStretch,
   useTimer,
   useTopDownMovement,
   useTouch,
@@ -17106,6 +17394,7 @@ export {
   useTriggerStay,
   useTween,
   useVirtualInput,
+  useWorldQuery,
   velocityAtPoint,
   vignetteEffect,
   wait,