cubeforge 0.4.13 → 0.4.14

package/dist/index.js

@@ -506,6 +506,7 @@ var GameLoop = class {
   constructor(onTick, options) {
     this.onTick = onTick;
     this.fixedDt = options?.fixedDt;
+    this.onRender = options?.onRender;
   }
   rafId = 0;
   lastTime = 0;
@@ -513,6 +514,8 @@ var GameLoop = class {
   paused = false;
   hitPauseTimer = 0;
   fixedDt;
+  onRender;
+  /** Freeze gameplay for `duration` seconds. Physics/scripts stop but rendering continues. */
   hitPause(duration) {
     this.hitPauseTimer = duration;
   }
@@ -552,7 +555,8 @@ var GameLoop = class {
     this.lastTime = time;
     const dt = this.fixedDt ?? rawDt;
     if (this.hitPauseTimer > 0) {
-      this.hitPauseTimer -= dt;
+      this.hitPauseTimer -= rawDt;
+      this.onRender?.(0);
     } else {
       this.onTick(dt);
     }
@@ -1222,74 +1226,159 @@ function tween(from, to, duration, ease = Ease.linear, onUpdate, onComplete, opt
 }
 
 // ../../packages/core/src/tweenTimeline.ts
-function createTimeline() {
-  const entries = [];
+function createTimeline(opts) {
+  const segments = [];
+  const labels = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  let elapsed = 0;
   let running = false;
-  let currentTween = null;
-  let delayTimer = null;
-  let rafId = null;
-  let lastTime = 0;
-  function clearCurrent() {
-    if (currentTween) {
-      currentTween.stop();
-      currentTween = null;
-    }
-    if (delayTimer !== null) {
-      clearTimeout(delayTimer);
-      delayTimer = null;
-    }
-    if (rafId !== null) {
-      cancelAnimationFrame(rafId);
-      rafId = null;
+  let complete = false;
+  const maxRepeats = opts?.repeat ?? (opts?.loop ? Infinity : 0);
+  let repeatsDone = 0;
+  function resolveStartTime(addOpts) {
+    if (addOpts?.at) {
+      const labelTime = labels.get(addOpts.at);
+      return labelTime ?? cursor;
     }
+    return cursor;
   }
-  function tick(now) {
-    if (!running || !currentTween) return;
-    const dt = (now - lastTime) / 1e3;
-    lastTime = now;
-    currentTween.update(dt);
-    if (!currentTween.isComplete) {
-      rafId = requestAnimationFrame(tick);
+  function resetSegments() {
+    for (const seg of segments) {
+      seg.handle?.stop();
+      seg.handle = void 0;
+      seg.started = false;
+      seg.complete = false;
     }
   }
-  function playEntry(index) {
-    if (index >= entries.length) {
-      running = false;
-      return;
-    }
-    const entry = entries[index];
-    const delay = entry.delay ?? 0;
-    const startTween = () => {
-      if (!running) return;
-      currentTween = tween(entry.from, entry.to, entry.duration, entry.ease ?? Ease.linear, entry.onUpdate, () => {
-        entry.onComplete?.();
-        playEntry(index + 1);
-      });
-      lastTime = performance.now();
-      rafId = requestAnimationFrame(tick);
-    };
-    if (delay > 0) {
-      delayTimer = setTimeout(startTween, delay * 1e3);
-    } else {
-      startTween();
+  function computeTotalDuration() {
+    let max = 0;
+    for (const seg of segments) {
+      const end = seg.startTime + seg.delay + seg.entry.duration;
+      if (end > max) max = end;
     }
+    return max;
   }
   const timeline = {
-    add(entry) {
-      entries.push(entry);
+    add(entry, addOpts) {
+      const start = resolveStartTime(addOpts);
+      const delay = addOpts?.delay ?? 0;
+      segments.push({ startTime: start, delay, entry, started: false, complete: false });
+      cursor = start + delay + entry.duration;
+      return timeline;
+    },
+    addLabel(name) {
+      labels.set(name, cursor);
       return timeline;
     },
+    addParallel(entries, addOpts) {
+      const start = resolveStartTime(addOpts);
+      const delay = addOpts?.delay ?? 0;
+      let maxEnd = cursor;
+      for (const entry of entries) {
+        segments.push({ startTime: start, delay, entry, started: false, complete: false });
+        const end = start + delay + entry.duration;
+        if (end > maxEnd) maxEnd = end;
+      }
+      cursor = maxEnd;
+      return timeline;
+    },
+    update(dt) {
+      if (!running || complete) return;
+      elapsed += dt;
+      let allDone = true;
+      for (const seg of segments) {
+        if (seg.complete) continue;
+        const effectiveStart = seg.startTime + seg.delay;
+        if (elapsed < effectiveStart) {
+          allDone = false;
+          continue;
+        }
+        if (!seg.started) {
+          seg.started = true;
+          seg.handle = tween(
+            seg.entry.from,
+            seg.entry.to,
+            seg.entry.duration,
+            seg.entry.ease ?? Ease.linear,
+            seg.entry.onUpdate,
+            () => {
+              seg.complete = true;
+              seg.entry.onComplete?.();
+            }
+          );
+          const overflow = elapsed - effectiveStart;
+          if (overflow > 0) seg.handle.update(overflow);
+        } else if (seg.handle) {
+          seg.handle.update(dt);
+        }
+        if (!seg.complete) allDone = false;
+      }
+      if (allDone && segments.length > 0) {
+        if (repeatsDone < maxRepeats) {
+          repeatsDone++;
+          elapsed = 0;
+          resetSegments();
+        } else {
+          complete = true;
+          running = false;
+          opts?.onComplete?.();
+        }
+      }
+    },
     start() {
-      clearCurrent();
+      elapsed = 0;
       running = true;
-      playEntry(0);
+      complete = false;
+      repeatsDone = 0;
+      resetSegments();
     },
     stop() {
       running = false;
-      clearCurrent();
+      complete = false;
+      elapsed = 0;
+      repeatsDone = 0;
+      resetSegments();
+    },
+    seek(time) {
+      elapsed = 0;
+      resetSegments();
+      elapsed = 0;
+      const step = 1 / 60;
+      while (elapsed < time) {
+        const d = Math.min(step, time - elapsed);
+        elapsed += d;
+        for (const seg of segments) {
+          if (seg.complete) continue;
+          const effectiveStart = seg.startTime + seg.delay;
+          if (elapsed < effectiveStart) continue;
+          if (!seg.started) {
+            seg.started = true;
+            seg.handle = tween(
+              seg.entry.from,
+              seg.entry.to,
+              seg.entry.duration,
+              seg.entry.ease ?? Ease.linear,
+              seg.entry.onUpdate,
+              () => {
+                seg.complete = true;
+              }
+            );
+            const overflow = elapsed - effectiveStart;
+            if (overflow > 0) seg.handle.update(overflow);
+          } else if (seg.handle) {
+            seg.handle.update(d);
+          }
+        }
+      }
     },
-    isRunning() {
+    get isRunning() {
       return running;
+    },
+    get isComplete() {
+      return complete;
+    },
+    get totalDuration() {
+      return computeTotalDuration();
     }
   };
   return timeline;
@@ -3389,18 +3478,34 @@ var RenderSystem = class {
         animator._entered = true;
         stateDef.onEnter?.();
       }
-      if (stateDef.transitions && stateDef.transitions.length > 0) {
-        const sorted = [...stateDef.transitions].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
-        for (const trans of sorted) {
-          if (trans.exitTime != null && anim.frames.length > 0) {
-            const progress = anim.currentIndex / anim.frames.length;
-            if (progress < trans.exitTime) continue;
-          }
-          if (evaluateConditions(trans.when, animator.params)) {
-            stateDef.onExit?.();
-            animator.currentState = trans.to;
-            animator._entered = false;
-            break;
+      if (animator._blendTimer != null && animator._blendTimer > 0) {
+        animator._blendTimer -= dt;
+        if (animator._blendTimer <= 0 && animator._blendToState) {
+          stateDef.onExit?.();
+          animator.currentState = animator._blendToState;
+          animator._entered = false;
+          animator._blendTimer = void 0;
+          animator._blendToState = void 0;
+        }
+      } else {
+        if (stateDef.transitions && stateDef.transitions.length > 0) {
+          const sorted = [...stateDef.transitions].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+          for (const trans of sorted) {
+            if (trans.exitTime != null && anim.frames.length > 0) {
+              const progress = anim.currentIndex / anim.frames.length;
+              if (progress < trans.exitTime) continue;
+            }
+            if (evaluateConditions(trans.when, animator.params)) {
+              if (trans.blendDuration && trans.blendDuration > 0) {
+                animator._blendTimer = trans.blendDuration;
+                animator._blendToState = trans.to;
+              } else {
+                stateDef.onExit?.();
+                animator.currentState = trans.to;
+                animator._entered = false;
+              }
+              break;
+            }
           }
         }
       }
@@ -14557,7 +14662,11 @@ function Game({
           handle.onFrame?.();
         }
       },
-      deterministic ? { fixedDt: 1 / 60 } : void 0
+      {
+        ...deterministic ? { fixedDt: 1 / 60 } : {},
+        // During hit-pause, re-render the last frame so the screen isn't blank
+        onRender: () => renderSystem.update(ecs, 0)
+      }
     );
     const postProcessStack = createPostProcessStack();
     const state = {
@@ -16057,7 +16166,10 @@ function Tilemap({
   triggerLayer: triggerLayerName = "triggers",
   onTileProperty,
   navGrid,
-  mergeColliders = true
+  mergeColliders = true,
+  solidTiles,
+  autoColliders = false,
+  tileColliderProps: _tileColliderProps
 }) {
   const engine = useContext20(EngineContext);
   const [spawnedNodes, setSpawnedNodes] = useState6([]);
@@ -16118,7 +16230,7 @@ function Tilemap({
         if (layerFilter && !layerFilter(layer)) continue;
         if (!layer.visible) continue;
         if (layer.type === "tilelayer" && layer.data) {
-          const collision = isCollisionLayer(layer, collisionLayer);
+          const collision = isCollisionLayer(layer, collisionLayer) || autoColliders && solidTiles && solidTiles.length > 0;
           const trigger = !collision && isTriggerLayer(layer, triggerLayerName);
           if (collision && navGrid) {
             for (let row = 0; row < mapData.height; row++) {
@@ -16130,11 +16242,13 @@ function Tilemap({
           }
           if (collision || trigger) {
             if (mergeColliders) {
+              const solidSet = solidTiles ? new Set(solidTiles) : null;
               const solidGrid = [];
               for (let row = 0; row < mapData.height; row++) {
                 solidGrid[row] = [];
                 for (let col = 0; col < mapData.width; col++) {
-                  solidGrid[row][col] = layer.data[row * mapData.width + col] !== 0;
+                  const gid = layer.data[row * mapData.width + col];
+                  solidGrid[row][col] = gid !== 0 && (!solidSet || solidSet.has(gid));
                 }
               }
               const merged = mergeTileColliders(solidGrid, tilewidth, tileheight, 0, 0);
@@ -17764,6 +17878,200 @@ function useSceneManager(initialScene) {
   };
 }
 
+// src/hooks/useSceneTransition.ts
+import { useState as useState13, useCallback as useCallback7, useRef as useRef24, useEffect as useEffect60 } from "react";
+function useSceneTransition(initialScene, defaultTransition) {
+  const [stack, setStack] = useState13([initialScene]);
+  const [transState, setTransState] = useState13({
+    phase: "idle",
+    progress: 0,
+    effect: null,
+    pendingAction: null
+  });
+  const stackRef = useRef24(stack);
+  stackRef.current = stack;
+  const transRef = useRef24(transState);
+  transRef.current = transState;
+  useEffect60(() => {
+    if (transState.phase === "idle") return;
+    const effect = transState.effect;
+    if (!effect || effect.type === "instant") return;
+    const duration = (effect.duration ?? 0.4) / 2;
+    let rafId;
+    let start = performance.now();
+    const animate = (now) => {
+      const elapsed = (now - start) / 1e3;
+      const t = Math.min(elapsed / duration, 1);
+      if (transRef.current.phase === "out") {
+        setTransState((prev) => ({ ...prev, progress: t }));
+        if (t >= 1) {
+          transRef.current.pendingAction?.();
+          start = performance.now();
+          setTransState((prev) => ({ ...prev, phase: "in", progress: 1, pendingAction: null }));
+        }
+      } else if (transRef.current.phase === "in") {
+        setTransState((prev) => ({ ...prev, progress: 1 - t }));
+        if (t >= 1) {
+          setTransState({ phase: "idle", progress: 0, effect: null, pendingAction: null });
+          return;
+        }
+      }
+      rafId = requestAnimationFrame(animate);
+    };
+    rafId = requestAnimationFrame(animate);
+    return () => cancelAnimationFrame(rafId);
+  }, [transState.phase, transState.effect]);
+  const startTransition = useCallback7(
+    (effect, action) => {
+      const eff = effect ?? defaultTransition ?? { type: "instant" };
+      if (eff.type === "instant") {
+        action();
+        return;
+      }
+      setTransState({
+        phase: "out",
+        progress: 0,
+        effect: eff,
+        pendingAction: action
+      });
+    },
+    [defaultTransition]
+  );
+  const push = useCallback7(
+    (scene, transition) => {
+      startTransition(transition, () => setStack((prev) => [...prev, scene]));
+    },
+    [startTransition]
+  );
+  const pop = useCallback7(
+    (transition) => {
+      const prev = stackRef.current;
+      if (prev.length <= 1) return void 0;
+      const popped = prev[prev.length - 1];
+      startTransition(transition, () => setStack((p) => p.slice(0, -1)));
+      return popped;
+    },
+    [startTransition]
+  );
+  const replace = useCallback7(
+    (scene, transition) => {
+      startTransition(transition, () => setStack((prev) => [...prev.slice(0, -1), scene]));
+    },
+    [startTransition]
+  );
+  const reset = useCallback7(
+    (scene, transition) => {
+      startTransition(transition, () => setStack([scene]));
+    },
+    [startTransition]
+  );
+  return {
+    current: stack[stack.length - 1],
+    stack,
+    push,
+    pop,
+    replace,
+    reset,
+    progress: transState.progress,
+    phase: transState.phase,
+    activeTransition: transState.effect
+  };
+}
+
+// src/components/SceneTransitionOverlay.tsx
+import React9 from "react";
+function getOverlayStyle(effect, progress) {
+  const color = effect.color ?? "#000";
+  switch (effect.type) {
+    case "fade":
+      return {
+        position: "absolute",
+        inset: 0,
+        backgroundColor: color,
+        opacity: progress,
+        pointerEvents: "none",
+        zIndex: 9999
+      };
+    case "wipe": {
+      const dir = effect.direction ?? "left";
+      let clipPath;
+      switch (dir) {
+        case "left":
+          clipPath = `inset(0 ${(1 - progress) * 100}% 0 0)`;
+          break;
+        case "right":
+          clipPath = `inset(0 0 0 ${(1 - progress) * 100}%)`;
+          break;
+        case "up":
+          clipPath = `inset(0 0 ${(1 - progress) * 100}% 0)`;
+          break;
+        case "down":
+          clipPath = `inset(${(1 - progress) * 100}% 0 0 0)`;
+          break;
+        default:
+          clipPath = `inset(0 ${(1 - progress) * 100}% 0 0)`;
+      }
+      return {
+        position: "absolute",
+        inset: 0,
+        backgroundColor: color,
+        clipPath,
+        pointerEvents: "none",
+        zIndex: 9999
+      };
+    }
+    case "circle-close": {
+      const radius = (1 - progress) * 72;
+      return {
+        position: "absolute",
+        inset: 0,
+        backgroundColor: color,
+        clipPath: `circle(${radius}% at 50% 50%)`,
+        pointerEvents: "none",
+        zIndex: 9999
+      };
+    }
+    default:
+      return { display: "none" };
+  }
+}
+function SceneTransitionOverlay({ controls }) {
+  if (controls.phase === "idle" || !controls.activeTransition || controls.activeTransition.type === "instant") {
+    return null;
+  }
+  if (controls.activeTransition.type === "circle-close") {
+    const color = controls.activeTransition.color ?? "#000";
+    const radius = (1 - controls.progress) * 72;
+    return React9.createElement("div", {
+      style: {
+        position: "absolute",
+        inset: 0,
+        backgroundColor: color,
+        WebkitMaskImage: `radial-gradient(circle ${radius}vmax at 50% 50%, transparent 100%, black 100%)`,
+        maskImage: `radial-gradient(circle ${radius}vmax at 50% 50%, transparent 100%, black 100%)`,
+        pointerEvents: "none",
+        zIndex: 9999
+      }
+    });
+  }
+  return React9.createElement("div", {
+    style: getOverlayStyle(controls.activeTransition, controls.progress)
+  });
+}
+
+// src/hooks/useHitstop.ts
+import { useContext as useContext51, useCallback as useCallback8 } from "react";
+function useHitstop() {
+  const engine = useContext51(EngineContext);
+  const freeze = useCallback8(
+    (seconds) => {
+      engine.loop.hitPause(seconds);
+    },
+    [engine]
+  );
+  return { freeze };
+}
+
 // src/hooks/useInputBuffer.ts
 import { useMemo as useMemo9 } from "react";
 function useInputBuffer(opts) {
@@ -17771,9 +18079,9 @@ function useInputBuffer(opts) {
 }
 
 // src/hooks/useComboDetector.ts
-import { useMemo as useMemo10, useRef as useRef24 } from "react";
+import { useMemo as useMemo10, useRef as useRef25 } from "react";
 function useComboDetector(combos) {
-  const lastComboRef = useRef24(null);
+  const lastComboRef = useRef25(null);
   const result = useMemo10(() => {
     const detector = new ComboDetector({ combos });
     const api = {
@@ -17796,11 +18104,11 @@ function useComboDetector(combos) {
 }
 
 // src/hooks/useParent.ts
-import { useEffect as useEffect60, useContext as useContext51 } from "react";
+import { useEffect as useEffect61, useContext as useContext52 } from "react";
 function useParent(childEntityId, parentEntityId) {
-  const engine = useContext51(EngineContext);
+  const engine = useContext52(EngineContext);
   if (!engine) throw new Error("useParent must be used inside <Game>");
-  useEffect60(() => {
+  useEffect61(() => {
     setParent(engine.ecs, childEntityId, parentEntityId);
     return () => {
       removeParent(engine.ecs, childEntityId);
@@ -17809,7 +18117,7 @@ function useParent(childEntityId, parentEntityId) {
 }
 
 // src/hooks/useAccessibility.ts
-import { useCallback as useCallback7, useSyncExternalStore } from "react";
+import { useCallback as useCallback9, useSyncExternalStore } from "react";
 var _version = 0;
 var _listeners = /* @__PURE__ */ new Set();
 function subscribe(cb) {
@@ -17821,12 +18129,12 @@ function getSnapshot() {
 }
 function useAccessibility() {
   useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  const setOptions = useCallback7((opts) => {
+  const setOptions = useCallback9((opts) => {
     setAccessibilityOptions(opts);
     _version++;
     for (const cb of _listeners) cb();
   }, []);
-  const announce = useCallback7((text, priority) => {
+  const announce = useCallback9((text, priority) => {
     announceToScreenReader(text, priority);
   }, []);
   return {
@@ -17837,18 +18145,18 @@ function useAccessibility() {
 }
 
 // src/hooks/useHMR.ts
-import { useEffect as useEffect61, useRef as useRef25, useMemo as useMemo11 } from "react";
+import { useEffect as useEffect62, useRef as useRef26, useMemo as useMemo11 } from "react";
 var idCounter = 0;
 function useHMR(hmrKey) {
-  const idRef = useRef25(null);
+  const idRef = useRef26(null);
   if (idRef.current === null) {
     idRef.current = hmrKey ?? `__hmr_${idCounter++}`;
   }
   const key = idRef.current;
   const isHotReload = hmrLoadState(key) !== void 0;
-  const disposeRef = useRef25(null);
-  const acceptRef = useRef25(null);
-  useEffect61(() => {
+  const disposeRef = useRef26(null);
+  const acceptRef = useRef26(null);
+  useEffect62(() => {
     const hot = import.meta.hot;
     if (!hot) return;
     hot.dispose(() => {
@@ -17881,11 +18189,11 @@ function useHMR(hmrKey) {
 }
 
 // src/hooks/useSquashStretch.ts
-import { useCallback as useCallback8, useContext as useContext52 } from "react";
+import { useCallback as useCallback10, useContext as useContext53 } from "react";
 function useSquashStretch() {
-  const engine = useContext52(EngineContext);
-  const entityId = useContext52(EntityContext);
-  const trigger = useCallback8(
+  const engine = useContext53(EngineContext);
+  const entityId = useContext53(EntityContext);
+  const trigger = useCallback10(
     (scaleX, scaleY) => {
       const ss = engine.ecs.getComponent(entityId, "SquashStretch");
       if (!ss) return;
@@ -17898,10 +18206,10 @@ function useSquashStretch() {
 }
 
 // ../gameplay/src/hooks/useAnimationController.ts
-import { useState as useState13, useCallback as useCallback9 } from "react";
+import { useState as useState14, useCallback as useCallback11 } from "react";
 function useAnimationController(states, initial) {
-  const [stateName, setStateName] = useState13(initial);
-  const setState = useCallback9((next) => {
+  const [stateName, setStateName] = useState14(initial);
+  const setState = useCallback11((next) => {
     setStateName((prev) => prev === next ? prev : next);
   }, []);
   const clip = states[stateName] ?? states[initial];
@@ -17923,39 +18231,39 @@ function useAnimationController(states, initial) {
 }
 
 // ../gameplay/src/hooks/useAISteering.ts
-import { useCallback as useCallback10 } from "react";
+import { useCallback as useCallback12 } from "react";
 function useAISteering() {
-  const seek$ = useCallback10((pos, target, speed) => seek(pos, target, speed), []);
-  const flee$ = useCallback10((pos, threat, speed) => flee(pos, threat, speed), []);
-  const arrive$ = useCallback10(
+  const seek$ = useCallback12((pos, target, speed) => seek(pos, target, speed), []);
+  const flee$ = useCallback12((pos, threat, speed) => flee(pos, threat, speed), []);
+  const arrive$ = useCallback12(
     (pos, target, speed, slowRadius) => arrive(pos, target, speed, slowRadius),
     []
   );
-  const patrol$ = useCallback10(
+  const patrol$ = useCallback12(
     (pos, waypoints, speed, currentIdx, arriveThreshold) => patrol(pos, waypoints, speed, currentIdx, arriveThreshold),
     []
   );
-  const wander$ = useCallback10(
+  const wander$ = useCallback12(
     (pos, angle, speed, jitter) => wander(pos, angle, speed, jitter),
     []
   );
-  const pursuit$ = useCallback10(
+  const pursuit$ = useCallback12(
     (pos, targetPos, targetVel, speed, lookAhead) => pursuit(pos, targetPos, targetVel, speed, lookAhead),
     []
   );
-  const evade$ = useCallback10(
+  const evade$ = useCallback12(
     (pos, threatPos, threatVel, speed, lookAhead) => evade(pos, threatPos, threatVel, speed, lookAhead),
     []
   );
-  const separation$ = useCallback10(
+  const separation$ = useCallback12(
     (pos, neighbors, speed, radius) => separation(pos, neighbors, speed, radius),
     []
   );
-  const cohesion$ = useCallback10(
+  const cohesion$ = useCallback12(
     (pos, neighbors, speed) => cohesion(pos, neighbors, speed),
     []
   );
-  const alignment$ = useCallback10(
+  const alignment$ = useCallback12(
     (neighborVelocities, speed) => alignment(neighborVelocities, speed),
     []
   );
@@ -17974,9 +18282,9 @@ function useAISteering() {
 }
 
 // ../gameplay/src/hooks/useDamageZone.ts
-import { useContext as useContext53 } from "react";
+import { useContext as useContext54 } from "react";
 function useDamageZone(damage, opts = {}) {
-  const engine = useContext53(EngineContext);
+  const engine = useContext54(EngineContext);
   useTriggerEnter(
     (other) => {
       engine.events.emit(`damage:${other}`, { amount: damage });
@@ -17986,11 +18294,11 @@ function useDamageZone(damage, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useDropThrough.ts
-import { useContext as useContext54, useCallback as useCallback11 } from "react";
+import { useContext as useContext55, useCallback as useCallback13 } from "react";
 function useDropThrough(frames = 8) {
-  const engine = useContext54(EngineContext);
-  const entityId = useContext54(EntityContext);
-  const dropThrough = useCallback11(() => {
+  const engine = useContext55(EngineContext);
+  const entityId = useContext55(EntityContext);
+  const dropThrough = useCallback13(() => {
     const rb = engine.ecs.getComponent(entityId, "RigidBody");
     if (rb) rb.dropThrough = frames;
   }, [engine.ecs, entityId, frames]);
@@ -17998,17 +18306,17 @@ function useDropThrough(frames = 8) {
 }
 
 // ../gameplay/src/hooks/useGameStateMachine.ts
-import { useState as useState14, useRef as useRef26, useCallback as useCallback12, useEffect as useEffect62, useContext as useContext55 } from "react";
+import { useState as useState15, useRef as useRef27, useCallback as useCallback14, useEffect as useEffect63, useContext as useContext56 } from "react";
 function useGameStateMachine(states, initial) {
-  const engine = useContext55(EngineContext);
-  const [state, setState] = useState14(initial);
-  const stateRef = useRef26(initial);
-  const statesRef = useRef26(states);
+  const engine = useContext56(EngineContext);
+  const [state, setState] = useState15(initial);
+  const stateRef = useRef27(initial);
+  const statesRef = useRef27(states);
   statesRef.current = states;
-  useEffect62(() => {
+  useEffect63(() => {
     statesRef.current[initial]?.onEnter?.();
   }, []);
-  const transition = useCallback12((to) => {
+  const transition = useCallback14((to) => {
     const current = stateRef.current;
     if (current === to) return;
     statesRef.current[current]?.onExit?.();
@@ -18016,7 +18324,7 @@ function useGameStateMachine(states, initial) {
     setState(to);
     statesRef.current[to]?.onEnter?.();
   }, []);
-  useEffect62(() => {
+  useEffect63(() => {
     const eid = engine.ecs.createEntity();
     engine.ecs.addComponent(
       eid,
@@ -18032,27 +18340,27 @@ function useGameStateMachine(states, initial) {
 }
 
 // ../gameplay/src/hooks/useHealth.ts
-import { useRef as useRef27, useEffect as useEffect63, useContext as useContext56, useCallback as useCallback13 } from "react";
+import { useRef as useRef28, useEffect as useEffect64, useContext as useContext57, useCallback as useCallback15 } from "react";
 function useHealth(maxHp, opts = {}) {
-  const engine = useContext56(EngineContext);
-  const entityId = useContext56(EntityContext);
-  const hpRef = useRef27(maxHp);
-  const invincibleRef = useRef27(false);
+  const engine = useContext57(EngineContext);
+  const entityId = useContext57(EntityContext);
+  const hpRef = useRef28(maxHp);
+  const invincibleRef = useRef28(false);
   const iFrameDuration = opts.iFrames ?? 1;
-  const onDeathRef = useRef27(opts.onDeath);
-  const onDamageRef = useRef27(opts.onDamage);
-  useEffect63(() => {
+  const onDeathRef = useRef28(opts.onDeath);
+  const onDamageRef = useRef28(opts.onDamage);
+  useEffect64(() => {
     onDeathRef.current = opts.onDeath;
   });
-  useEffect63(() => {
+  useEffect64(() => {
     onDamageRef.current = opts.onDamage;
   });
-  const timerRef = useRef27(
+  const timerRef = useRef28(
     createTimer(iFrameDuration, () => {
       invincibleRef.current = false;
     })
   );
-  const takeDamage = useCallback13(
+  const takeDamage = useCallback15(
     (amount = 1) => {
       if (invincibleRef.current || hpRef.current <= 0) return;
       hpRef.current = Math.max(0, hpRef.current - amount);
@@ -18065,28 +18373,28 @@ function useHealth(maxHp, opts = {}) {
     },
     [iFrameDuration]
   );
-  const takeDamageRef = useRef27(takeDamage);
-  useEffect63(() => {
+  const takeDamageRef = useRef28(takeDamage);
+  useEffect64(() => {
     takeDamageRef.current = takeDamage;
   }, [takeDamage]);
-  useEffect63(() => {
+  useEffect64(() => {
     return engine.events.on(`damage:${entityId}`, ({ amount }) => {
       takeDamageRef.current(amount);
     });
   }, [engine.events, entityId]);
-  const heal = useCallback13(
+  const heal = useCallback15(
     (amount) => {
       hpRef.current = Math.min(maxHp, hpRef.current + amount);
     },
     [maxHp]
   );
-  const setHp = useCallback13(
+  const setHp = useCallback15(
     (hp) => {
       hpRef.current = Math.min(maxHp, Math.max(0, hp));
     },
     [maxHp]
   );
-  const update = useCallback13((dt) => {
+  const update = useCallback15((dt) => {
     timerRef.current.update(dt);
   }, []);
   return {
@@ -18110,11 +18418,11 @@ function useHealth(maxHp, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useKinematicBody.ts
-import { useContext as useContext57, useCallback as useCallback14 } from "react";
+import { useContext as useContext58, useCallback as useCallback16 } from "react";
 function useKinematicBody() {
-  const engine = useContext57(EngineContext);
-  const entityId = useContext57(EntityContext);
-  const moveAndCollide = useCallback14(
+  const engine = useContext58(EngineContext);
+  const entityId = useContext58(EntityContext);
+  const moveAndCollide = useCallback16(
     (dx, dy) => {
       const transform = engine.ecs.getComponent(entityId, "Transform");
       if (!transform) return { dx: 0, dy: 0 };
@@ -18150,7 +18458,7 @@ function useKinematicBody() {
     },
     [engine.ecs, entityId]
   );
-  const setVelocity = useCallback14(
+  const setVelocity = useCallback16(
     (vx, vy) => {
       const rb = engine.ecs.getComponent(entityId, "RigidBody");
       if (rb) {
@@ -18160,7 +18468,7 @@ function useKinematicBody() {
     },
     [engine.ecs, entityId]
   );
-  const setAngularVelocity = useCallback14(
+  const setAngularVelocity = useCallback16(
     (w) => {
       const rb = engine.ecs.getComponent(entityId, "RigidBody");
       if (rb) rb.angularVelocity = w;
@@ -18171,12 +18479,12 @@ function useKinematicBody() {
 }
 
 // ../gameplay/src/hooks/useLevelTransition.ts
-import { useState as useState15, useRef as useRef28, useCallback as useCallback15 } from "react";
+import { useState as useState16, useRef as useRef29, useCallback as useCallback17 } from "react";
 function useLevelTransition(initial) {
-  const [currentLevel, setCurrentLevel] = useState15(initial);
-  const [isTransitioning, setIsTransitioning] = useState15(false);
-  const overlayRef = useRef28(null);
-  const transitionTo = useCallback15((level, opts = {}) => {
+  const [currentLevel, setCurrentLevel] = useState16(initial);
+  const [isTransitioning, setIsTransitioning] = useState16(false);
+  const overlayRef = useRef29(null);
+  const transitionTo = useCallback17((level, opts = {}) => {
     const { duration = 0.4, type = "fade" } = opts;
     if (type === "instant") {
       setCurrentLevel(level);
@@ -18213,13 +18521,13 @@ function useLevelTransition(initial) {
 }
 
 // ../gameplay/src/hooks/usePlatformerController.ts
-import { useContext as useContext58, useEffect as useEffect64 } from "react";
+import { useContext as useContext59, useEffect as useEffect65 } from "react";
 function normalizeKeys(val, defaults) {
   if (!val) return defaults;
   return Array.isArray(val) ? val : [val];
 }
 function usePlatformerController(entityId, opts = {}) {
-  const engine = useContext58(EngineContext);
+  const engine = useContext59(EngineContext);
   const {
     speed = 200,
     jumpForce = -500,
@@ -18237,7 +18545,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"]);
-  useEffect64(() => {
+  useEffect65(() => {
     const state = {
       coyoteTimer: 0,
       jumpBuffer: 0,
@@ -18301,26 +18609,26 @@ function usePlatformerController(entityId, opts = {}) {
 }
 
 // ../gameplay/src/hooks/usePathfinding.ts
-import { useCallback as useCallback16 } from "react";
+import { useCallback as useCallback18 } from "react";
 function usePathfinding() {
-  const createGrid$ = useCallback16(
+  const createGrid$ = useCallback18(
     (cols, rows, cellSize) => createNavGrid(cols, rows, cellSize),
     []
   );
-  const setWalkable$ = useCallback16(
+  const setWalkable$ = useCallback18(
     (grid, col, row, walkable) => setWalkable(grid, col, row, walkable),
     []
   );
-  const findPath$ = useCallback16((grid, start, goal) => findPath(grid, start, goal), []);
+  const findPath$ = useCallback18((grid, start, goal) => findPath(grid, start, goal), []);
   return { createGrid: createGrid$, setWalkable: setWalkable$, findPath: findPath$ };
 }
 
 // ../gameplay/src/hooks/usePersistedBindings.ts
-import { useState as useState16, useCallback as useCallback17, useMemo as useMemo12, useContext as useContext59 } from "react";
+import { useState as useState17, useCallback as useCallback19, useMemo as useMemo12, useContext as useContext60 } from "react";
 function usePersistedBindings(storageKey, defaults) {
-  const engine = useContext59(EngineContext);
+  const engine = useContext60(EngineContext);
   const input = engine.input;
-  const [bindings, setBindings] = useState16(() => {
+  const [bindings, setBindings] = useState17(() => {
     try {
       const stored = localStorage.getItem(storageKey);
       if (stored) return { ...defaults, ...JSON.parse(stored) };
@@ -18336,7 +18644,7 @@ function usePersistedBindings(storageKey, defaults) {
     }
     return out;
   }, [bindings]);
-  const rebind = useCallback17(
+  const rebind = useCallback19(
     (action, keys) => {
       setBindings((prev) => {
         const next = { ...prev, [action]: Array.isArray(keys) ? keys : [keys] };
@@ -18349,7 +18657,7 @@ function usePersistedBindings(storageKey, defaults) {
     },
     [storageKey]
   );
-  const reset = useCallback17(() => {
+  const reset = useCallback19(() => {
     try {
       localStorage.removeItem(storageKey);
     } catch {
@@ -18370,21 +18678,21 @@ function usePersistedBindings(storageKey, defaults) {
 }
 
 // ../gameplay/src/hooks/useRestart.ts
-import { useState as useState17, useCallback as useCallback18 } from "react";
+import { useState as useState18, useCallback as useCallback20 } from "react";
 function useRestart() {
-  const [restartKey, setRestartKey] = useState17(0);
-  const restart = useCallback18(() => {
+  const [restartKey, setRestartKey] = useState18(0);
+  const restart = useCallback20(() => {
     setRestartKey((k) => k + 1);
   }, []);
   return { restartKey, restart };
 }
 
 // ../gameplay/src/hooks/useSave.ts
-import { useCallback as useCallback19, useRef as useRef29 } from "react";
+import { useCallback as useCallback21, useRef as useRef30 } from "react";
 function useSave(key, defaultValue, opts = {}) {
   const version = opts.version ?? 1;
-  const dataRef = useRef29(defaultValue);
-  const save = useCallback19(
+  const dataRef = useRef30(defaultValue);
+  const save = useCallback21(
     (value) => {
       dataRef.current = value;
       const slot = { version, data: value };
@@ -18396,7 +18704,7 @@ function useSave(key, defaultValue, opts = {}) {
     },
     [key, version]
   );
-  const load = useCallback19(() => {
+  const load = useCallback21(() => {
     try {
       const raw = localStorage.getItem(key);
       if (!raw) return defaultValue;
@@ -18416,11 +18724,11 @@ function useSave(key, defaultValue, opts = {}) {
       return defaultValue;
     }
   }, [key, version]);
-  const clear = useCallback19(() => {
+  const clear = useCallback21(() => {
     localStorage.removeItem(key);
     dataRef.current = defaultValue;
   }, [key]);
-  const exists = useCallback19(() => {
+  const exists = useCallback21(() => {
     return localStorage.getItem(key) !== null;
   }, [key]);
   return {
@@ -18435,7 +18743,7 @@ function useSave(key, defaultValue, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useIDBSave.ts
-import { useCallback as useCallback20, useRef as useRef30 } from "react";
+import { useCallback as useCallback22, useRef as useRef31 } from "react";
 var DB_NAME = "cubeforge-saves";
 var STORE_NAME = "saves";
 function openDB() {
@@ -18453,12 +18761,12 @@ function openDB() {
 }
 function useIDBSave(key, defaultValue, opts = {}) {
   const version = opts.version ?? 1;
-  const dbRef = useRef30(null);
-  const getDB = useCallback20(() => {
+  const dbRef = useRef31(null);
+  const getDB = useCallback22(() => {
     if (!dbRef.current) dbRef.current = openDB();
     return dbRef.current;
   }, []);
-  const save = useCallback20(
+  const save = useCallback22(
     async (value) => {
       const db = await getDB();
       const slot = { version, data: value };
@@ -18471,7 +18779,7 @@ function useIDBSave(key, defaultValue, opts = {}) {
     },
     [getDB, key, version]
   );
-  const load = useCallback20(async () => {
+  const load = useCallback22(async () => {
     const db = await getDB();
     return new Promise((resolve, reject) => {
       const tx = db.transaction(STORE_NAME, "readonly");
@@ -18497,7 +18805,7 @@ function useIDBSave(key, defaultValue, opts = {}) {
       req.onerror = () => reject(req.error);
     });
   }, [getDB, key, version]);
-  const clear = useCallback20(async () => {
+  const clear = useCallback22(async () => {
     const db = await getDB();
     return new Promise((resolve, reject) => {
       const tx = db.transaction(STORE_NAME, "readwrite");
@@ -18506,7 +18814,7 @@ function useIDBSave(key, defaultValue, opts = {}) {
       req.onerror = () => reject(req.error);
     });
   }, [getDB, key]);
-  const exists = useCallback20(async () => {
+  const exists = useCallback22(async () => {
     const db = await getDB();
     return new Promise((resolve, reject) => {
       const tx = db.transaction(STORE_NAME, "readonly");
@@ -18519,16 +18827,16 @@ function useIDBSave(key, defaultValue, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useTopDownMovement.ts
-import { useContext as useContext60, useEffect as useEffect65 } from "react";
+import { useContext as useContext61, useEffect as useEffect66 } from "react";
 function moveToward(current, target, maxDelta) {
   const diff = target - current;
   if (Math.abs(diff) <= maxDelta) return target;
   return current + Math.sign(diff) * maxDelta;
 }
 function useTopDownMovement(entityId, opts = {}) {
-  const engine = useContext60(EngineContext);
+  const engine = useContext61(EngineContext);
   const { speed = 200, normalizeDiagonal = true, acceleration = Infinity, deceleration = acceleration } = opts;
-  useEffect65(() => {
+  useEffect66(() => {
     const updateFn = (id, world, input, dt) => {
       if (!world.hasEntity(id)) return;
       const rb = world.getComponent(id, "RigidBody");
@@ -18568,18 +18876,18 @@ function useTopDownMovement(entityId, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useDialogue.ts
-import { useState as useState18, useCallback as useCallback21, useRef as useRef31 } from "react";
+import { useState as useState19, useCallback as useCallback23, useRef as useRef32 } from "react";
 function useDialogue() {
-  const [active, setActive] = useState18(false);
-  const [currentId, setCurrentId] = useState18(null);
-  const scriptRef = useRef31(null);
-  const start = useCallback21((script, startId) => {
+  const [active, setActive] = useState19(false);
+  const [currentId, setCurrentId] = useState19(null);
+  const scriptRef = useRef32(null);
+  const start = useCallback23((script, startId) => {
     scriptRef.current = script;
     const id = startId ?? Object.keys(script)[0];
     setCurrentId(id);
     setActive(true);
   }, []);
-  const advance = useCallback21(
+  const advance = useCallback23(
     (choiceIndex) => {
       if (!scriptRef.current || !currentId) return;
       const line = scriptRef.current[currentId];
@@ -18609,7 +18917,7 @@ function useDialogue() {
     },
     [currentId]
   );
-  const close = useCallback21(() => {
+  const close = useCallback23(() => {
     setActive(false);
     setCurrentId(null);
     scriptRef.current = null;
@@ -18727,17 +19035,17 @@ function DialogueBox({ dialogue, onAdvance, onClose, style = {} }) {
 }
 
 // ../gameplay/src/hooks/useCutscene.ts
-import { useState as useState19, useCallback as useCallback22, useRef as useRef32, useEffect as useEffect66, useContext as useContext61 } from "react";
+import { useState as useState20, useCallback as useCallback24, useRef as useRef33, useEffect as useEffect67, useContext as useContext62 } from "react";
 function useCutscene() {
-  const engine = useContext61(EngineContext);
-  const [playing, setPlaying] = useState19(false);
-  const [stepIndex, setStepIndex] = useState19(0);
-  const stepsRef = useRef32([]);
-  const timerRef = useRef32(0);
-  const idxRef = useRef32(0);
-  const playingRef = useRef32(false);
-  const entityRef = useRef32(null);
-  const finish = useCallback22(() => {
+  const engine = useContext62(EngineContext);
+  const [playing, setPlaying] = useState20(false);
+  const [stepIndex, setStepIndex] = useState20(0);
+  const stepsRef = useRef33([]);
+  const timerRef = useRef33(0);
+  const idxRef = useRef33(0);
+  const playingRef = useRef33(false);
+  const entityRef = useRef33(null);
+  const finish = useCallback24(() => {
     playingRef.current = false;
     setPlaying(false);
     setStepIndex(0);
@@ -18747,14 +19055,14 @@ function useCutscene() {
       entityRef.current = null;
     }
   }, [engine.ecs]);
-  const fireStep = useCallback22((step) => {
+  const fireStep = useCallback24((step) => {
     if (step.type === "call") step.fn();
     if (step.type === "parallel")
       step.steps.forEach((s2) => {
         if (s2.type === "call") s2.fn();
       });
   }, []);
-  const play = useCallback22(
+  const play = useCallback24(
     (steps) => {
       stepsRef.current = steps;
       idxRef.current = 0;
@@ -18811,7 +19119,7 @@ function useCutscene() {
     },
     [engine.ecs, finish, fireStep]
   );
-  const skip = useCallback22(() => {
+  const skip = useCallback24(() => {
     for (let i = idxRef.current; i < stepsRef.current.length; i++) {
       const step = stepsRef.current[i];
       if (step.type === "call") step.fn();
@@ -18822,7 +19130,7 @@ function useCutscene() {
     }
     finish();
   }, [finish]);
-  useEffect66(() => {
+  useEffect67(() => {
     return () => {
       if (entityRef.current !== null && engine.ecs.hasEntity(entityRef.current)) {
         engine.ecs.destroyEntity(entityRef.current);
@@ -18833,7 +19141,7 @@ function useCutscene() {
 }
 
 // ../gameplay/src/hooks/useGameStore.ts
-import { useSyncExternalStore as useSyncExternalStore2, useCallback as useCallback23 } from "react";
+import { useSyncExternalStore as useSyncExternalStore2, useCallback as useCallback25 } from "react";
 function createStore(initialState) {
   let state = { ...initialState };
   const listeners = /* @__PURE__ */ new Set();
@@ -18859,7 +19167,7 @@ function useGameStore(key, initialState) {
   }
   const store = stores.get(key);
   const state = useSyncExternalStore2(store.subscribe, store.getState);
-  const setState = useCallback23(
+  const setState = useCallback25(
     (partial) => {
       store.setState(partial);
     },
@@ -18869,21 +19177,21 @@ function useGameStore(key, initialState) {
 }
 
 // ../gameplay/src/hooks/useTween.ts
-import { useRef as useRef33, useCallback as useCallback24, useEffect as useEffect67 } from "react";
+import { useRef as useRef34, useCallback as useCallback26, useEffect as useEffect68 } from "react";
 function useTween(opts) {
-  const rafRef = useRef33(null);
-  const startTimeRef = useRef33(0);
-  const runningRef = useRef33(false);
-  const optsRef = useRef33(opts);
+  const rafRef = useRef34(null);
+  const startTimeRef = useRef34(0);
+  const runningRef = useRef34(false);
+  const optsRef = useRef34(opts);
   optsRef.current = opts;
-  const stop = useCallback24(() => {
+  const stop = useCallback26(() => {
     if (rafRef.current !== null) {
       cancelAnimationFrame(rafRef.current);
       rafRef.current = null;
     }
     runningRef.current = false;
   }, []);
-  const start = useCallback24(() => {
+  const start = useCallback26(() => {
     stop();
     runningRef.current = true;
     startTimeRef.current = performance.now();
@@ -18905,12 +19213,12 @@ function useTween(opts) {
     };
     rafRef.current = requestAnimationFrame(tick);
   }, [stop]);
-  useEffect67(() => {
+  useEffect68(() => {
     if (opts.autoStart) {
       start();
     }
   }, []);
-  useEffect67(() => {
+  useEffect68(() => {
     return () => {
       if (rafRef.current !== null) {
         cancelAnimationFrame(rafRef.current);
@@ -18929,15 +19237,15 @@ function useTween(opts) {
 }
 
 // ../gameplay/src/hooks/useObjectPool.ts
-import { useRef as useRef34, useMemo as useMemo13, useEffect as useEffect68 } from "react";
+import { useRef as useRef35, useMemo as useMemo13, useEffect as useEffect69 } from "react";
 function useObjectPool(factory, reset, initialSize) {
-  const poolRef = useRef34([]);
-  const activeRef = useRef34(0);
-  const factoryRef = useRef34(factory);
+  const poolRef = useRef35([]);
+  const activeRef = useRef35(0);
+  const factoryRef = useRef35(factory);
   factoryRef.current = factory;
-  const resetRef = useRef34(reset);
+  const resetRef = useRef35(reset);
   resetRef.current = reset;
-  useEffect68(() => {
+  useEffect69(() => {
     if (initialSize != null && initialSize > 0) {
       const pool = poolRef.current;
       for (let i = 0; i < initialSize; i++) {
@@ -18976,10 +19284,10 @@ function useObjectPool(factory, reset, initialSize) {
 }
 
 // ../gameplay/src/hooks/useForces.ts
-import { useContext as useContext62, useMemo as useMemo14 } from "react";
+import { useContext as useContext63, useMemo as useMemo14 } from "react";
 function useForces() {
-  const engine = useContext62(EngineContext);
-  const entityId = useContext62(EntityContext);
+  const engine = useContext63(EngineContext);
+  const entityId = useContext63(EntityContext);
   return useMemo14(() => {
     const getRb = () => engine.ecs.getComponent(entityId, "RigidBody");
     const getTransform = () => engine.ecs.getComponent(entityId, "Transform");
@@ -19048,10 +19356,10 @@ function useForces() {
 }
 
 // ../gameplay/src/hooks/useCharacterController.ts
-import { useContext as useContext63, useMemo as useMemo15 } from "react";
+import { useContext as useContext64, useMemo as useMemo15 } from "react";
 function useCharacterController(config = {}) {
-  const engine = useContext63(EngineContext);
-  const entityId = useContext63(EntityContext);
+  const engine = useContext64(EngineContext);
+  const entityId = useContext64(EntityContext);
   return useMemo15(() => {
     const controller = new CharacterController(config);
     return {
@@ -19101,7 +19409,7 @@ function definePrefab(name, defaults, render) {
 }
 
 // src/hooks/useNetworkSync.ts
-import { useEffect as useEffect70, useRef as useRef36 } from "react";
+import { useEffect as useEffect71, useRef as useRef37 } from "react";
 
 // ../../packages/net/src/transport.ts
 function isBinaryTransport(t) {
@@ -19446,17 +19754,17 @@ function syncEntity(config) {
 }
 
 // ../../packages/net/src/useNetworkInput.ts
-import { useState as useState20, useEffect as useEffect69, useRef as useRef35 } from "react";
+import { useState as useState21, useEffect as useEffect70, useRef as useRef36 } from "react";
 var INPUT_MSG_TYPE = "input:state";
 function useNetworkInput(config) {
   const { room, keys, input, tickRate = 20 } = config;
   const intervalMs = 1e3 / tickRate;
-  const [localInput, setLocalInput] = useState20(
+  const [localInput, setLocalInput] = useState21(
     () => Object.fromEntries(keys.map((k) => [k, false]))
   );
-  const [remoteInputs] = useState20(() => /* @__PURE__ */ new Map());
-  const localInputRef = useRef35(localInput);
-  useEffect69(() => {
+  const [remoteInputs] = useState21(() => /* @__PURE__ */ new Map());
+  const localInputRef = useRef36(localInput);
+  useEffect70(() => {
     let cleanupDom = null;
     if (!input) {
       let handleKeyDown2 = function(e) {
@@ -19670,9 +19978,9 @@ function lerpState(a, b, t) {
 
 // src/hooks/useNetworkSync.ts
 function useNetworkSync(entityId, components, room, world, owner, opts = {}) {
-  const optsRef = useRef36(opts);
+  const optsRef = useRef37(opts);
   optsRef.current = opts;
-  useEffect70(() => {
+  useEffect71(() => {
     const sync = syncEntity({
       entityId,
       components,
@@ -19687,18 +19995,18 @@ function useNetworkSync(entityId, components, room, world, owner, opts = {}) {
 }
 
 // src/hooks/useRemotePlayer.ts
-import { useEffect as useEffect71, useRef as useRef37, useState as useState21 } from "react";
+import { useEffect as useEffect72, useRef as useRef38, useState as useState22 } from "react";
 var PEER_JOIN_MSG = "peer:join";
 var PEER_LEAVE_MSG = "peer:leave";
 function useRemotePlayer(config) {
   const { room, world, createEntity, destroyEntity } = config;
-  const [players, setPlayers] = useState21(() => /* @__PURE__ */ new Map());
-  const playersRef = useRef37(players);
-  const createRef = useRef37(createEntity);
+  const [players, setPlayers] = useState22(() => /* @__PURE__ */ new Map());
+  const playersRef = useRef38(players);
+  const createRef = useRef38(createEntity);
   createRef.current = createEntity;
-  const destroyRef = useRef37(destroyEntity);
+  const destroyRef = useRef38(destroyEntity);
   destroyRef.current = destroyEntity;
-  useEffect71(() => {
+  useEffect72(() => {
     function spawnPeer(peerId) {
       if (playersRef.current.has(peerId)) return;
       const entityId = createRef.current(peerId);
@@ -19788,6 +20096,7 @@ export {
   RenderSystem,
   RigidBody,
   Room,
+  SceneTransitionOverlay,
   ScreenFlash,
   Script,
   SegmentCollider,
@@ -19985,6 +20294,7 @@ export {
   useGestures,
   useHMR,
   useHealth,
+  useHitstop,
   useIDBSave,
   useInput,
   useInputBuffer,
@@ -20012,6 +20322,7 @@ export {
   useRestart,
   useSave,
   useSceneManager,
+  useSceneTransition,
   useSnapshot,
   useSound,
   useSpatialSound,