cubeforge 0.3.14 → 0.3.16

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/components/Game.tsx
-import { useEffect as useEffect3, useRef as useRef3, useState as useState2 } from "react";
+import { useEffect as useEffect4, useRef as useRef4, useState as useState2 } from "react";
 
 // ../../packages/core/src/ecs/world.ts
 var ECSWorld = class {
@@ -734,14 +734,95 @@ var ScriptSystem = class {
 // ../../packages/core/src/tween.ts
 var Ease = {
   linear: (t) => t,
+  // Quad
   easeInQuad: (t) => t * t,
   easeOutQuad: (t) => t * (2 - t),
   easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+  // Cubic
+  easeInCubic: (t) => t * t * t,
+  easeOutCubic: (t) => {
+    const t1 = t - 1;
+    return t1 * t1 * t1 + 1;
+  },
+  easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+  // Quart
+  easeInQuart: (t) => t * t * t * t,
+  easeOutQuart: (t) => {
+    const t1 = t - 1;
+    return 1 - t1 * t1 * t1 * t1;
+  },
+  easeInOutQuart: (t) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * (t - 1) * (t - 1) * (t - 1) * (t - 1),
+  // Quint
+  easeInQuint: (t) => t * t * t * t * t,
+  easeOutQuint: (t) => {
+    const t1 = t - 1;
+    return 1 + t1 * t1 * t1 * t1 * t1;
+  },
+  easeInOutQuint: (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * (t - 1) * (t - 1) * (t - 1) * (t - 1) * (t - 1),
+  // Sine
+  easeInSine: (t) => 1 - Math.cos(t * Math.PI / 2),
+  easeOutSine: (t) => Math.sin(t * Math.PI / 2),
+  easeInOutSine: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+  // Expo
+  easeInExpo: (t) => t === 0 ? 0 : Math.pow(2, 10 * (t - 1)),
+  easeOutExpo: (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t),
+  easeInOutExpo: (t) => {
+    if (t === 0) return 0;
+    if (t === 1) return 1;
+    return t < 0.5 ? Math.pow(2, 20 * t - 10) / 2 : (2 - Math.pow(2, -20 * t + 10)) / 2;
+  },
+  // Circ
+  easeInCirc: (t) => 1 - Math.sqrt(1 - t * t),
+  easeOutCirc: (t) => Math.sqrt(1 - (t - 1) * (t - 1)),
+  easeInOutCirc: (t) => t < 0.5 ? (1 - Math.sqrt(1 - 4 * t * t)) / 2 : (Math.sqrt(1 - (-2 * t + 2) * (-2 * t + 2)) + 1) / 2,
+  // Back
+  easeInBack: (t) => {
+    const c1 = 1.70158;
+    const c3 = c1 + 1;
+    return c3 * t * t * t - c1 * t * t;
+  },
   easeOutBack: (t) => {
     const c1 = 1.70158;
     const c3 = c1 + 1;
     return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
-  }
+  },
+  easeInOutBack: (t) => {
+    const c1 = 1.70158;
+    const c2 = c1 * 1.525;
+    return t < 0.5 ? 2 * t * (2 * t) * ((c2 + 1) * 2 * t - c2) / 2 : ((2 * t - 2) * (2 * t - 2) * ((c2 + 1) * (2 * t - 2) + c2) + 2) / 2;
+  },
+  // Elastic
+  easeInElastic: (t) => {
+    if (t === 0 || t === 1) return t;
+    return -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * (2 * Math.PI / 3));
+  },
+  easeOutElastic: (t) => {
+    if (t === 0 || t === 1) return t;
+    return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * (2 * Math.PI / 3)) + 1;
+  },
+  easeInOutElastic: (t) => {
+    if (t === 0 || t === 1) return t;
+    const c5 = 2 * Math.PI / 4.5;
+    return t < 0.5 ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * c5)) / 2 : Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * c5) / 2 + 1;
+  },
+  // Bounce
+  easeOutBounce: (t) => {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (t < 1 / d1) return n1 * t * t;
+    if (t < 2 / d1) {
+      const t22 = t - 1.5 / d1;
+      return n1 * t22 * t22 + 0.75;
+    }
+    if (t < 2.5 / d1) {
+      const t22 = t - 2.25 / d1;
+      return n1 * t22 * t22 + 0.9375;
+    }
+    const t2 = t - 2.625 / d1;
+    return n1 * t2 * t2 + 0.984375;
+  },
+  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) {
   let elapsed = 0;
@@ -767,6 +848,87 @@ function tween(from, to, duration, ease = Ease.linear, onUpdate, onComplete) {
   };
 }
 
+// ../../packages/core/src/tweenTimeline.ts
+function createTimeline() {
+  const entries = [];
+  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;
+    }
+  }
+  function tick(now) {
+    if (!running || !currentTween) return;
+    const dt = (now - lastTime) / 1e3;
+    lastTime = now;
+    currentTween.update(dt);
+    if (!currentTween.isComplete) {
+      rafId = requestAnimationFrame(tick);
+    }
+  }
+  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();
+    }
+  }
+  const timeline = {
+    add(entry) {
+      entries.push(entry);
+      return timeline;
+    },
+    start() {
+      clearCurrent();
+      running = true;
+      playEntry(0);
+    },
+    stop() {
+      running = false;
+      clearCurrent();
+    },
+    isRunning() {
+      return running;
+    }
+  };
+  return timeline;
+}
+
 // ../../packages/core/src/timer.ts
 function createTimer(duration, onComplete, autoStart = false) {
   let _duration = duration;
@@ -831,6 +993,48 @@ function hotReloadPlugin(engine, oldPlugin, newPlugin, oldSystems) {
   newPlugin.onInit?.(engine);
 }
 
+// ../../packages/core/src/tilemapMerge.ts
+function mergeTileColliders(solidGrid, tileWidth, tileHeight, originX, originY) {
+  const rows = solidGrid.length;
+  if (rows === 0) return [];
+  const cols = solidGrid[0].length;
+  const visited = [];
+  for (let r = 0; r < rows; r++) {
+    visited[r] = new Array(cols).fill(false);
+  }
+  const rects = [];
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      if (!solidGrid[row][col] || visited[row][col]) continue;
+      let maxCol = col;
+      while (maxCol + 1 < cols && solidGrid[row][maxCol + 1] && !visited[row][maxCol + 1]) {
+        maxCol++;
+      }
+      let maxRow = row;
+      outer:
+        for (let r = row + 1; r < rows; r++) {
+          for (let c = col; c <= maxCol; c++) {
+            if (!solidGrid[r][c] || visited[r][c]) break outer;
+          }
+          maxRow = r;
+        }
+      for (let r = row; r <= maxRow; r++) {
+        for (let c = col; c <= maxCol; c++) {
+          visited[r][c] = true;
+        }
+      }
+      const spanCols = maxCol - col + 1;
+      const spanRows = maxRow - row + 1;
+      const width = spanCols * tileWidth;
+      const height = spanRows * tileHeight;
+      const x = originX + col * tileWidth + width / 2;
+      const y = originY + row * tileHeight + height / 2;
+      rects.push({ x, y, width, height });
+    }
+  }
+  return rects;
+}
+
 // ../../packages/input/src/keyboard.ts
 var Keyboard = class {
   held = /* @__PURE__ */ new Set();
@@ -1156,13 +1360,36 @@ function createSprite(opts) {
     zIndex: 0,
     visible: true,
     flipX: false,
+    flipY: false,
     anchorX: 0.5,
     anchorY: 0.5,
     frameIndex: 0,
+    blendMode: "normal",
+    layer: "default",
     ...opts
   };
 }
 
+// ../../packages/renderer/src/renderLayers.ts
+var defaultLayers = [
+  { name: "background", order: -100 },
+  { name: "default", order: 0 },
+  { name: "foreground", order: 100 },
+  { name: "ui", order: 200 }
+];
+function createRenderLayerManager(layers = defaultLayers) {
+  const map = /* @__PURE__ */ new Map();
+  for (const l of layers) map.set(l.name, l.order);
+  return {
+    addLayer(name, order) {
+      map.set(name, order);
+    },
+    getOrder(name) {
+      return map.get(name) ?? 0;
+    }
+  };
+}
+
 // ../../packages/renderer/src/textureFilter.ts
 var TextureFilter = {
   /** Nearest-neighbor — sharp pixels, ideal for pixel art */
@@ -1269,8 +1496,9 @@ layout(location = 4) in float i_rot;
 layout(location = 5) in vec2  i_anchor;
 layout(location = 6) in vec2  i_offset;
 layout(location = 7) in float i_flipX;
-layout(location = 8) in vec4  i_color;
-layout(location = 9) in vec4  i_uvRect;
+layout(location = 8) in float i_flipY;
+layout(location = 9) in vec4  i_color;
+layout(location = 10) in vec4  i_uvRect;
 
 uniform vec2  u_camPos;
 uniform float u_zoom;
@@ -1286,6 +1514,8 @@ void main() {
 
   // Horizontal flip
   if (i_flipX > 0.5) local.x = -local.x;
+  // Vertical flip
+  if (i_flipY > 0.5) local.y = -local.y;
 
   // Rotate around local origin
   float c = cos(i_rot);
@@ -1397,9 +1627,9 @@ function parseCSSColor(css) {
 }
 
 // ../../packages/renderer/src/webglRenderSystem.ts
-var FLOATS_PER_INSTANCE = 18;
-var MAX_INSTANCES = 8192;
-var MAX_SPRITE_TEXTURES = 512;
+var FLOATS_PER_INSTANCE = 19;
+var MAX_INSTANCES = 16384;
+var MAX_SPRITE_TEXTURES = 1024;
 var MAX_TEXT_CACHE = 200;
 function compileShader(gl, type, src) {
   const shader = gl.createShader(type);
@@ -1531,8 +1761,9 @@ var RenderSystem = class {
     addAttr(5, 2);
     addAttr(6, 2);
     addAttr(7, 1);
-    addAttr(8, 4);
+    addAttr(8, 1);
     addAttr(9, 4);
+    addAttr(10, 4);
     gl.bindVertexArray(null);
     gl.useProgram(this.program);
     this.uCamPos = gl.getUniformLocation(this.program, "u_camPos");
@@ -1604,6 +1835,8 @@ var RenderSystem = class {
   textureCache = /* @__PURE__ */ new Map();
   /** Insertion-order key list for LRU-style eviction. */
   textureCacheKeys = [];
+  // ── Render layer manager ────────────────────────────────────────────────
+  layers = createRenderLayerManager();
   // ── Texture sampling ────────────────────────────────────────────────────
   _defaultSampling = DEFAULT_SAMPLING;
   /** Set the global default texture sampling mode for all sprites that don't specify their own. */
@@ -1768,10 +2001,29 @@ var RenderSystem = class {
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, toGLMinFilter(gl, min));
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, toGLMagFilter(gl, mag));
   }
+  // ── Blend mode helper ────────────────────────────────────────────────────
+  applyBlendMode(mode) {
+    const { gl } = this;
+    switch (mode) {
+      case "additive":
+        gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
+        break;
+      case "multiply":
+        gl.blendFunc(gl.DST_COLOR, gl.ONE_MINUS_SRC_ALPHA);
+        break;
+      case "screen":
+        gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_COLOR);
+        break;
+      default:
+        gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+        break;
+    }
+  }
   // ── Instanced draw call ────────────────────────────────────────────────────
-  flush(count, textureKey, sampling) {
+  flush(count, textureKey, sampling, blendMode) {
     if (count === 0) return;
     const { gl } = this;
+    if (blendMode && blendMode !== "normal") this.applyBlendMode(blendMode);
     const isColor = textureKey.startsWith("__color__");
     const tex = isColor ? this.whiteTexture : this.loadTexture(textureKey);
     gl.bindTexture(gl.TEXTURE_2D, tex);
@@ -1781,6 +2033,7 @@ var RenderSystem = class {
     gl.bindBuffer(gl.ARRAY_BUFFER, this.instanceBuffer);
     gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.instanceData, 0, count * FLOATS_PER_INSTANCE);
     gl.drawArraysInstanced(gl.TRIANGLES, 0, 6, count);
+    if (blendMode && blendMode !== "normal") this.applyBlendMode("normal");
   }
   flushWithTex(count, tex, useTexture) {
     if (count === 0) return;
@@ -1793,7 +2046,7 @@ var RenderSystem = class {
     gl.drawArraysInstanced(gl.TRIANGLES, 0, 6, count);
   }
   // ── Write one sprite instance into instanceData ───────────────────────────
-  writeInstance(base, x, y, w, h, rot, anchorX, anchorY, offsetX, offsetY, flipX, r, g, b, a, u, v, uw, vh) {
+  writeInstance(base, x, y, w, h, rot, anchorX, anchorY, offsetX, offsetY, flipX, flipY, r, g, b, a, u, v, uw, vh) {
     const d = this.instanceData;
     d[base + 0] = x;
     d[base + 1] = y;
@@ -1805,14 +2058,15 @@ var RenderSystem = class {
     d[base + 7] = offsetX;
     d[base + 8] = offsetY;
     d[base + 9] = flipX ? 1 : 0;
-    d[base + 10] = r;
-    d[base + 11] = g;
-    d[base + 12] = b;
-    d[base + 13] = a;
-    d[base + 14] = u;
-    d[base + 15] = v;
-    d[base + 16] = uw;
-    d[base + 17] = vh;
+    d[base + 10] = flipY ? 1 : 0;
+    d[base + 11] = r;
+    d[base + 12] = g;
+    d[base + 13] = b;
+    d[base + 14] = a;
+    d[base + 15] = u;
+    d[base + 16] = v;
+    d[base + 17] = uw;
+    d[base + 18] = vh;
   }
   // ── Main update loop ───────────────────────────────────────────────────────
   update(world, dt) {
@@ -1872,9 +2126,47 @@ var RenderSystem = class {
       camY = cam.y;
       zoom = cam.zoom;
     }
+    for (const id of world.query("Animator", "AnimationState")) {
+      const animator = world.getComponent(id, "Animator");
+      const anim = world.getComponent(id, "AnimationState");
+      if (!animator.playing) continue;
+      if (!animator.states[animator.currentState]) {
+        animator.currentState = animator.initialState;
+        animator._entered = false;
+      }
+      const stateDef = animator.states[animator.currentState];
+      if (!stateDef) continue;
+      if (!animator._entered) {
+        anim.currentClip = stateDef.clip;
+        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;
+          }
+        }
+      }
+    }
     for (const id of world.query("AnimationState", "Sprite")) {
       const anim = world.getComponent(id, "AnimationState");
       const sprite = world.getComponent(id, "Sprite");
+      if (anim.clips && anim.currentClip && anim._resolvedClip !== anim.currentClip) {
+        const clip = anim.clips[anim.currentClip];
+        if (clip) {
+          resolveClip(anim, clip);
+          anim._resolvedClip = anim.currentClip;
+        }
+      }
       if (!anim.playing || anim.frames.length === 0) continue;
       anim.timer += dt;
       const frameDuration = 1 / anim.fps;
@@ -1882,8 +2174,24 @@ var RenderSystem = class {
         anim.timer -= frameDuration;
         anim.currentIndex++;
         if (anim.currentIndex >= anim.frames.length) {
-          anim.currentIndex = anim.loop ? 0 : anim.frames.length - 1;
+          if (anim.loop) {
+            anim.currentIndex = 0;
+          } else {
+            anim.currentIndex = anim.frames.length - 1;
+            anim.playing = false;
+            if (anim.onComplete && !anim._completed) {
+              anim._completed = true;
+              anim.onComplete();
+            }
+            if (anim.clips && anim.currentClip) {
+              const currentClipDef = anim.clips[anim.currentClip];
+              if (currentClipDef?.next && anim.clips[currentClipDef.next]) {
+                anim.currentClip = currentClipDef.next;
+              }
+            }
+          }
         }
+        anim.frameEvents?.[anim.currentIndex]?.();
       }
       sprite.frameIndex = anim.frames[anim.currentIndex];
     }
@@ -1947,6 +2255,8 @@ var RenderSystem = class {
     renderables.sort((a, b) => {
       const sa = world.getComponent(a, "Sprite");
       const sb = world.getComponent(b, "Sprite");
+      const ld = this.layers.getOrder(sa.layer) - this.layers.getOrder(sb.layer);
+      if (ld !== 0) return ld;
       const zd = sa.zIndex - sb.zIndex;
       if (zd !== 0) return zd;
       const ka = getTextureKey(sa), kb = getTextureKey(sb);
@@ -1955,9 +2265,10 @@ var RenderSystem = class {
     let batchCount = 0;
     let batchKey = "";
     let batchSampling;
+    let batchBlendMode = "normal";
     for (let i = 0; i <= renderables.length; i++) {
       if (i === renderables.length) {
-        this.flush(batchCount, batchKey, batchSampling);
+        this.flush(batchCount, batchKey, batchSampling, batchBlendMode);
         break;
       }
       const id = renderables[i];
@@ -2006,12 +2317,14 @@ var RenderSystem = class {
         sprite.image = img;
       }
       const key = getTextureKey(sprite);
-      if (key !== batchKey && batchCount > 0 || batchCount >= MAX_INSTANCES) {
-        this.flush(batchCount, batchKey, batchSampling);
+      const spriteBlend = sprite.blendMode ?? "normal";
+      if ((key !== batchKey || spriteBlend !== batchBlendMode) && batchCount > 0 || batchCount >= MAX_INSTANCES) {
+        this.flush(batchCount, batchKey, batchSampling, batchBlendMode);
         batchCount = 0;
       }
       batchKey = key;
       batchSampling = sprite.sampling;
+      batchBlendMode = spriteBlend;
       const ss = world.getComponent(id, "SquashStretch");
       const scaleXMod = ss ? ss.currentScaleX : 1;
       const scaleYMod = ss ? ss.currentScaleY : 1;
@@ -2030,6 +2343,7 @@ var RenderSystem = class {
         sprite.offsetX,
         sprite.offsetY,
         sprite.flipX,
+        sprite.flipY ?? false,
         r,
         g,
         b,
@@ -2053,10 +2367,11 @@ var RenderSystem = class {
       if (!text.visible) continue;
       const entry = this.getOrCreateTextTexture(text);
       if (!entry) continue;
-      this.flush(batchCount, batchKey, batchSampling);
+      this.flush(batchCount, batchKey, batchSampling, batchBlendMode);
       batchCount = 0;
       batchKey = "";
       batchSampling = void 0;
+      batchBlendMode = "normal";
       this.writeInstance(
         0,
         transform.x + text.offsetX,
@@ -2070,6 +2385,9 @@ var RenderSystem = class {
         0,
         0,
         false,
+        // flipX
+        false,
+        // flipY
         1,
         1,
         1,
@@ -2093,15 +2411,33 @@ var RenderSystem = class {
         return p.life > 0;
       });
       if (pool.active && pool.particles.length < pool.maxParticles) {
-        pool.timer += dt;
-        const spawnCount = Math.floor(pool.timer * pool.rate);
-        pool.timer -= spawnCount / pool.rate;
+        let spawnCount;
+        if (pool.burstCount != null && pool.burstCount > 0) {
+          spawnCount = pool.burstCount;
+          pool.active = false;
+        } else {
+          pool.timer += dt;
+          spawnCount = Math.floor(pool.timer * pool.rate);
+          pool.timer -= spawnCount / pool.rate;
+        }
         for (let i = 0; i < spawnCount && pool.particles.length < pool.maxParticles; i++) {
           const angle = pool.angle + (world.rng() - 0.5) * pool.spread;
           const speed = pool.speed * (0.5 + world.rng() * 0.5);
+          let ox = 0;
+          let oy = 0;
+          const shape = pool.emitShape ?? "point";
+          if (shape === "circle") {
+            const r = (pool.emitRadius ?? 0) * Math.sqrt(world.rng());
+            const a = world.rng() * Math.PI * 2;
+            ox = Math.cos(a) * r;
+            oy = Math.sin(a) * r;
+          } else if (shape === "box") {
+            ox = (world.rng() - 0.5) * (pool.emitWidth ?? 0);
+            oy = (world.rng() - 0.5) * (pool.emitHeight ?? 0);
+          }
           pool.particles.push({
-            x: t.x,
-            y: t.y,
+            x: t.x + ox,
+            y: t.y + oy,
             vx: Math.cos(angle) * speed,
             vy: Math.sin(angle) * speed,
             life: pool.particleLife,
@@ -2133,6 +2469,7 @@ var RenderSystem = class {
           0,
           0,
           false,
+          false,
           r,
           g,
           b,
@@ -2173,6 +2510,7 @@ var RenderSystem = class {
           0,
           0,
           false,
+          false,
           tr,
           tg,
           tb,
@@ -2210,6 +2548,7 @@ var RenderSystem = class {
             0,
             0,
             false,
+            false,
             walkable ? 0 : 1,
             walkable ? 1 : 0,
             0,
@@ -2243,6 +2582,7 @@ var RenderSystem = class {
           0,
           0,
           false,
+          false,
           1,
           0.3,
           0.3,
@@ -2266,6 +2606,110 @@ var RenderSystem = class {
     this.lastTimestamp = now;
   }
 };
+function resolveClip(anim, clip) {
+  anim.frames = clip.frames;
+  anim.fps = clip.fps ?? 12;
+  anim.loop = clip.loop ?? true;
+  anim.onComplete = clip.onComplete;
+  anim.frameEvents = clip.frameEvents;
+  anim.currentIndex = 0;
+  anim.timer = 0;
+  anim._completed = false;
+  anim.playing = true;
+}
+function evaluateConditions(conditions, params) {
+  for (const cond of conditions) {
+    const val = params[cond.param];
+    if (val === void 0) return false;
+    switch (cond.op) {
+      case "==":
+        if (val !== cond.value) return false;
+        break;
+      case "!=":
+        if (val === cond.value) return false;
+        break;
+      case ">":
+        if (val <= cond.value) return false;
+        break;
+      case ">=":
+        if (val < cond.value) return false;
+        break;
+      case "<":
+        if (val >= cond.value) return false;
+        break;
+      case "<=":
+        if (val > cond.value) return false;
+        break;
+    }
+  }
+  return true;
+}
+
+// ../../packages/renderer/src/postProcess.ts
+function createPostProcessStack() {
+  const effects = [];
+  return {
+    add(effect) {
+      if (!effects.includes(effect)) {
+        effects.push(effect);
+      }
+    },
+    remove(effect) {
+      const idx = effects.indexOf(effect);
+      if (idx !== -1) effects.splice(idx, 1);
+    },
+    apply(ctx, width, height, dt) {
+      for (const effect of effects) {
+        ctx.save();
+        effect(ctx, width, height, dt);
+        ctx.restore();
+      }
+    },
+    clear() {
+      effects.length = 0;
+    }
+  };
+}
+function vignetteEffect(intensity = 0.4) {
+  return (ctx, width, height) => {
+    const cx = width / 2;
+    const cy = height / 2;
+    const radius = Math.sqrt(cx * cx + cy * cy);
+    const gradient = ctx.createRadialGradient(cx, cy, radius * 0.3, cx, cy, radius);
+    gradient.addColorStop(0, "rgba(0,0,0,0)");
+    gradient.addColorStop(1, `rgba(0,0,0,${intensity})`);
+    ctx.fillStyle = gradient;
+    ctx.fillRect(0, 0, width, height);
+  };
+}
+function scanlineEffect(gap = 3, opacity = 0.15) {
+  return (ctx, width, height) => {
+    ctx.fillStyle = `rgba(0,0,0,${opacity})`;
+    for (let y = 0; y < height; y += gap) {
+      ctx.fillRect(0, y, width, 1);
+    }
+  };
+}
+function chromaticAberrationEffect(offset = 2) {
+  return (ctx, width, height) => {
+    if (width === 0 || height === 0) return;
+    const imageData = ctx.getImageData(0, 0, width, height);
+    const { data } = imageData;
+    const copy = new Uint8ClampedArray(data);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const i = (y * width + x) * 4;
+        const srcR = Math.min(x + offset, width - 1);
+        const iR = (y * width + srcR) * 4;
+        data[i] = copy[iR];
+        const srcB = Math.max(x - offset, 0);
+        const iB = (y * width + srcB) * 4;
+        data[i + 2] = copy[iB + 2];
+      }
+    }
+    ctx.putImageData(imageData, 0, 0);
+  };
+}
 
 // ../../packages/renderer/src/canvas2d.ts
 var Canvas2DRenderer = class {
@@ -2310,6 +2754,9 @@ function createRigidBody(opts) {
     isKinematic: false,
     dropThrough: 0,
     ccd: false,
+    angularVelocity: 0,
+    angularDamping: 0,
+    linearDamping: 0,
     ...opts
   };
 }
@@ -2644,6 +3091,15 @@ var PhysicsSystem = class {
       if (!rb.lockY) rb.vy += this.gravity * rb.gravityScale * dt;
       if (rb.lockX) rb.vx = 0;
       if (rb.lockY) rb.vy = 0;
+      if (rb.linearDamping > 0) {
+        rb.vx *= 1 - rb.linearDamping;
+        rb.vy *= 1 - rb.linearDamping;
+      }
+      if (rb.angularVelocity !== 0) {
+        const transform = world.getComponent(id, "Transform");
+        transform.rotation += rb.angularVelocity * dt;
+        if (rb.angularDamping > 0) rb.angularVelocity *= 1 - rb.angularDamping;
+      }
       if (rb.dropThrough > 0) rb.dropThrough--;
     }
     const ccdPrev = /* @__PURE__ */ new Map();
@@ -2662,6 +3118,15 @@ var PhysicsSystem = class {
       if (!rb.lockY) rb.vy += this.gravity * rb.gravityScale * dt;
       if (rb.lockX) rb.vx = 0;
       if (rb.lockY) rb.vy = 0;
+      if (rb.linearDamping > 0) {
+        rb.vx *= 1 - rb.linearDamping;
+        rb.vy *= 1 - rb.linearDamping;
+      }
+      if (rb.angularVelocity !== 0) {
+        const transform = world.getComponent(id, "Transform");
+        transform.rotation += rb.angularVelocity * dt;
+        if (rb.angularDamping > 0) rb.angularVelocity *= 1 - rb.angularDamping;
+      }
       if (rb.dropThrough > 0) rb.dropThrough--;
     }
     for (const id of dynamics) {
@@ -3543,10 +4008,48 @@ function useCircleStay(handler, opts) {
   useContactEvent("circleStay", handler, opts);
 }
 
+// ../context/src/useCollidingWith.ts
+import { useContext as useContext2, useEffect as useEffect2, useRef as useRef2 } from "react";
+function useCollidingWith() {
+  const engine = useContext2(EngineContext);
+  const entityId = useContext2(EntityContext);
+  if (!engine) throw new Error("useCollidingWith hook must be used inside <Game>");
+  if (entityId === null) throw new Error("useCollidingWith hook must be used inside <Entity>");
+  const setRef = useRef2(/* @__PURE__ */ new Set());
+  useEffect2(() => {
+    const set = setRef.current;
+    function handleEnter({ a, b }) {
+      const isA = a === entityId;
+      const isB = b === entityId;
+      if (!isA && !isB) return;
+      set.add(isA ? b : a);
+    }
+    function handleExit({ a, b }) {
+      const isA = a === entityId;
+      const isB = b === entityId;
+      if (!isA && !isB) return;
+      set.delete(isA ? b : a);
+    }
+    const unsubs = [
+      engine.events.on("collisionEnter", handleEnter),
+      engine.events.on("collisionExit", handleExit),
+      engine.events.on("triggerEnter", handleEnter),
+      engine.events.on("triggerExit", handleExit),
+      engine.events.on("circleEnter", handleEnter),
+      engine.events.on("circleExit", handleExit)
+    ];
+    return () => {
+      unsubs.forEach((unsub) => unsub());
+      set.clear();
+    };
+  }, [engine.events, entityId]);
+  return setRef.current;
+}
+
 // ../devtools/src/DevTools.tsx
 import React from "react";
 import { createPortal } from "react-dom";
-import { useState, useEffect as useEffect2, useCallback, useRef as useRef2 } from "react";
+import { useState, useEffect as useEffect3, useCallback, useRef as useRef3 } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 var MAX_DEVTOOLS_FRAMES = 600;
 var C = {
@@ -3710,8 +4213,8 @@ function DevToolsOverlay({ handle, loop, ecs, engine }) {
   const [contactLog, setContactLog] = useState([]);
   const [showNavGrid, setShowNavGrid] = useState(false);
   const [showContactFlash, setShowContactFlash] = useState(false);
-  const frameRef = useRef2(0);
-  useEffect2(() => {
+  const frameRef = useRef3(0);
+  useEffect3(() => {
     handle.onFrame = () => {
       frameRef.current++;
       if (!paused) {
@@ -3723,7 +4226,7 @@ function DevToolsOverlay({ handle, loop, ecs, engine }) {
       handle.onFrame = void 0;
     };
   }, [handle, paused]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!engine) return;
     const events = engine.events;
     const types = ["triggerEnter", "triggerExit", "collisionEnter", "collisionExit", "circleEnter", "circleExit"];
@@ -4234,13 +4737,13 @@ function Game({
   className,
   children
 }) {
-  const canvasRef = useRef3(null);
-  const debugCanvasRef = useRef3(null);
-  const wrapperRef = useRef3(null);
+  const canvasRef = useRef4(null);
+  const debugCanvasRef = useRef4(null);
+  const wrapperRef = useRef4(null);
   const [engine, setEngine] = useState2(null);
   const [assetsReady, setAssetsReady] = useState2(asyncAssets);
-  const devtoolsHandle = useRef3({ buffer: [] });
-  useEffect3(() => {
+  const devtoolsHandle = useRef4({ buffer: [] });
+  useEffect4(() => {
     const canvas = canvasRef.current;
     const ecs = new ECSWorld();
     if (deterministic) ecs.setDeterministicSeed(seed);
@@ -4283,6 +4786,7 @@ function Game({
         handle.onFrame?.();
       }
     }, deterministic ? { fixedDt: 1 / 60 } : void 0);
+    const postProcessStack = createPostProcessStack();
     const state = {
       ecs,
       input,
@@ -4293,7 +4797,8 @@ function Game({
       loop,
       canvas,
       entityIds,
-      systemTimings
+      systemTimings,
+      postProcessStack
     };
     setEngine(state);
     if (plugins) {
@@ -4355,7 +4860,7 @@ function Game({
       }
     };
   }, []);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!engine) return;
     let cancelled = false;
     if (asyncAssets) {
@@ -4373,13 +4878,13 @@ function Game({
       cancelled = true;
     };
   }, [engine]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!engine) return;
     const canvas = engine.canvas;
     if (canvas.width !== width) canvas.width = width;
     if (canvas.height !== height) canvas.height = height;
   }, [width, height, engine]);
-  useEffect3(() => {
+  useEffect4(() => {
     engine?.physics.setGravity(gravity);
   }, [gravity, engine]);
   const canvasStyle = {
@@ -4460,15 +4965,15 @@ function Game({
 }
 
 // src/components/World.tsx
-import { useEffect as useEffect4, useContext as useContext2 } from "react";
+import { useEffect as useEffect5, useContext as useContext3 } from "react";
 import { Fragment as Fragment2, jsx as jsx3 } from "react/jsx-runtime";
 function World({ gravity, background = "#1a1a2e", children }) {
-  const engine = useContext2(EngineContext);
-  useEffect4(() => {
+  const engine = useContext3(EngineContext);
+  useEffect5(() => {
     if (!engine) return;
     if (gravity !== void 0) engine.physics.setGravity(gravity);
   }, [gravity, engine]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (!engine) return;
     const camId = engine.ecs.queryOne("Camera2D");
     if (camId !== void 0) {
@@ -4482,12 +4987,17 @@ function World({ gravity, background = "#1a1a2e", children }) {
 }
 
 // src/components/Entity.tsx
-import { useEffect as useEffect5, useContext as useContext3, useState as useState3 } from "react";
+import { useEffect as useEffect6, useContext as useContext4, useState as useState3 } from "react";
 import { jsx as jsx4 } from "react/jsx-runtime";
 function Entity({ id, tags = [], children }) {
-  const engine = useContext3(EngineContext);
+  const engine = useContext4(EngineContext);
   const [entityId, setEntityId] = useState3(null);
-  useEffect5(() => {
+  if (process.env.NODE_ENV !== "production") {
+    if (!engine) {
+      console.warn("[Cubeforge] <Entity> must be inside a <World>. No EngineContext found.");
+    }
+  }
+  useEffect6(() => {
     const eid = engine.ecs.createEntity();
     if (id) {
       if (engine.entityIds.has(id)) {
@@ -4507,15 +5017,15 @@ function Entity({ id, tags = [], children }) {
 }
 
 // src/components/Transform.tsx
-import { useEffect as useEffect6, useContext as useContext4 } from "react";
+import { useEffect as useEffect7, useContext as useContext5 } from "react";
 function Transform({ x = 0, y = 0, rotation = 0, scaleX = 1, scaleY = 1 }) {
-  const engine = useContext4(EngineContext);
-  const entityId = useContext4(EntityContext);
-  useEffect6(() => {
+  const engine = useContext5(EngineContext);
+  const entityId = useContext5(EntityContext);
+  useEffect7(() => {
     engine.ecs.addComponent(entityId, createTransform(x, y, rotation, scaleX, scaleY));
     return () => engine.ecs.removeComponent(entityId, "Transform");
   }, []);
-  useEffect6(() => {
+  useEffect7(() => {
     const comp = engine.ecs.getComponent(entityId, "Transform");
     if (comp) {
       comp.x = x;
@@ -4529,7 +5039,7 @@ function Transform({ x = 0, y = 0, rotation = 0, scaleX = 1, scaleY = 1 }) {
 }
 
 // src/components/Sprite.tsx
-import { useEffect as useEffect7, useContext as useContext5 } from "react";
+import { useEffect as useEffect8, useContext as useContext6 } from "react";
 function Sprite({
   width,
   height,
@@ -4540,6 +5050,7 @@ function Sprite({
   zIndex = 0,
   visible = true,
   flipX = false,
+  flipY = false,
   anchorX = 0.5,
   anchorY = 0.5,
   frameIndex = 0,
@@ -4552,12 +5063,22 @@ function Sprite({
   tileY,
   tileSizeX,
   tileSizeY,
-  sampling
+  sampling,
+  blendMode = "normal",
+  layer = "default"
 }) {
   const resolvedFrameIndex = atlas && frame != null ? atlas[frame] ?? 0 : frameIndex;
-  const engine = useContext5(EngineContext);
-  const entityId = useContext5(EntityContext);
-  useEffect7(() => {
+  const engine = useContext6(EngineContext);
+  const entityId = useContext6(EntityContext);
+  if (process.env.NODE_ENV !== "production") {
+    if (entityId === null) {
+      console.warn("[Cubeforge] <Sprite> must be inside an <Entity>. No EntityContext found.");
+    }
+    if ((frameWidth != null || frameHeight != null || frameColumns != null) && !src) {
+      console.warn("[Cubeforge] <Sprite> has frameWidth/frameHeight/frameColumns but no `src`. Sprite-sheet props require an image source.");
+    }
+  }
+  useEffect8(() => {
     const comp = createSprite({
       width,
       height,
@@ -4568,6 +5089,7 @@ function Sprite({
       zIndex,
       visible,
       flipX,
+      flipY,
       anchorX,
       anchorY,
       frameIndex: resolvedFrameIndex,
@@ -4578,7 +5100,9 @@ function Sprite({
       tileY,
       tileSizeX,
       tileSizeY,
-      sampling
+      sampling,
+      blendMode,
+      layer
     });
     engine.ecs.addComponent(entityId, comp);
     if (src) {
@@ -4592,20 +5116,23 @@ function Sprite({
     }
     return () => engine.ecs.removeComponent(entityId, "Sprite");
   }, []);
-  useEffect7(() => {
+  useEffect8(() => {
     const comp = engine.ecs.getComponent(entityId, "Sprite");
     if (!comp) return;
     comp.color = color;
     comp.visible = visible;
     comp.flipX = flipX;
+    comp.flipY = flipY;
     comp.zIndex = zIndex;
     comp.frameIndex = resolvedFrameIndex;
-  }, [color, visible, flipX, zIndex, resolvedFrameIndex, engine, entityId]);
+    comp.blendMode = blendMode;
+    comp.layer = layer;
+  }, [color, visible, flipX, flipY, zIndex, resolvedFrameIndex, blendMode, layer, engine, entityId]);
   return null;
 }
 
 // src/components/Text.tsx
-import { useEffect as useEffect8, useContext as useContext6 } from "react";
+import { useEffect as useEffect9, useContext as useContext7 } from "react";
 function Text({
   text,
   fontSize = 16,
@@ -4619,9 +5146,9 @@ function Text({
   offsetX = 0,
   offsetY = 0
 }) {
-  const engine = useContext6(EngineContext);
-  const entityId = useContext6(EntityContext);
-  useEffect8(() => {
+  const engine = useContext7(EngineContext);
+  const entityId = useContext7(EntityContext);
+  useEffect9(() => {
     const comp = {
       type: "Text",
       text,
@@ -4639,7 +5166,7 @@ function Text({
     engine.ecs.addComponent(entityId, comp);
     return () => engine.ecs.removeComponent(entityId, "Text");
   }, []);
-  useEffect8(() => {
+  useEffect9(() => {
     const comp = engine.ecs.getComponent(entityId, "Text");
     if (!comp) return;
     comp.text = text;
@@ -4651,7 +5178,7 @@ function Text({
 }
 
 // src/components/RigidBody.tsx
-import { useEffect as useEffect9, useContext as useContext7 } from "react";
+import { useEffect as useEffect10, useContext as useContext8 } from "react";
 function RigidBody({
   mass = 1,
   gravityScale = 1,
@@ -4662,19 +5189,27 @@ function RigidBody({
   vy = 0,
   lockX = false,
   lockY = false,
-  ccd = false
+  ccd = false,
+  angularVelocity = 0,
+  angularDamping = 0,
+  linearDamping = 0
 }) {
-  const engine = useContext7(EngineContext);
-  const entityId = useContext7(EntityContext);
-  useEffect9(() => {
-    engine.ecs.addComponent(entityId, createRigidBody({ mass, gravityScale, isStatic, bounce, friction, vx, vy, lockX, lockY, ccd }));
+  const engine = useContext8(EngineContext);
+  const entityId = useContext8(EntityContext);
+  if (process.env.NODE_ENV !== "production") {
+    if (entityId === null) {
+      console.warn("[Cubeforge] <RigidBody> must be inside an <Entity>. No EntityContext found.");
+    }
+  }
+  useEffect10(() => {
+    engine.ecs.addComponent(entityId, createRigidBody({ mass, gravityScale, isStatic, bounce, friction, vx, vy, lockX, lockY, ccd, angularVelocity, angularDamping, linearDamping }));
     return () => engine.ecs.removeComponent(entityId, "RigidBody");
   }, []);
   return null;
 }
 
 // src/components/BoxCollider.tsx
-import { useEffect as useEffect10, useContext as useContext8 } from "react";
+import { useEffect as useEffect11, useContext as useContext9 } from "react";
 function BoxCollider({
   width,
   height,
@@ -4685,13 +5220,18 @@ function BoxCollider({
   mask = "*",
   oneWay = false
 }) {
-  const engine = useContext8(EngineContext);
-  const entityId = useContext8(EntityContext);
-  useEffect10(() => {
+  const engine = useContext9(EngineContext);
+  const entityId = useContext9(EntityContext);
+  useEffect11(() => {
     engine.ecs.addComponent(entityId, createBoxCollider(width, height, { offsetX, offsetY, isTrigger, layer, mask, oneWay }));
     const checkId = setTimeout(() => {
-      if (engine.ecs.hasEntity(entityId) && !engine.ecs.hasComponent(entityId, "Transform")) {
-        console.warn(`[Cubeforge] BoxCollider on entity ${entityId} has no Transform. Physics requires Transform.`);
+      if (process.env.NODE_ENV !== "production") {
+        if (engine.ecs.hasEntity(entityId) && !engine.ecs.hasComponent(entityId, "Transform")) {
+          console.warn(`[Cubeforge] BoxCollider on entity ${entityId} has no Transform. Physics requires Transform.`);
+        }
+        if (engine.ecs.hasEntity(entityId) && !engine.ecs.hasComponent(entityId, "RigidBody")) {
+          console.warn(`[Cubeforge] BoxCollider on entity ${entityId} has no RigidBody. Add a <RigidBody> sibling for physics to work.`);
+        }
       }
     }, 0);
     return () => {
@@ -4703,7 +5243,7 @@ function BoxCollider({
 }
 
 // src/components/CircleCollider.tsx
-import { useEffect as useEffect11, useContext as useContext9 } from "react";
+import { useEffect as useEffect12, useContext as useContext10 } from "react";
 function CircleCollider({
   radius,
   offsetX = 0,
@@ -4712,9 +5252,9 @@ function CircleCollider({
   layer = "default",
   mask = "*"
 }) {
-  const engine = useContext9(EngineContext);
-  const entityId = useContext9(EntityContext);
-  useEffect11(() => {
+  const engine = useContext10(EngineContext);
+  const entityId = useContext10(EntityContext);
+  useEffect12(() => {
     engine.ecs.addComponent(entityId, createCircleCollider(radius, { offsetX, offsetY, isTrigger, layer, mask }));
     return () => engine.ecs.removeComponent(entityId, "CircleCollider");
   }, []);
@@ -4722,7 +5262,7 @@ function CircleCollider({
 }
 
 // src/components/CapsuleCollider.tsx
-import { useEffect as useEffect12, useContext as useContext10 } from "react";
+import { useEffect as useEffect13, useContext as useContext11 } from "react";
 function CapsuleCollider({
   width,
   height,
@@ -4732,9 +5272,9 @@ function CapsuleCollider({
   layer = "default",
   mask = "*"
 }) {
-  const engine = useContext10(EngineContext);
-  const entityId = useContext10(EntityContext);
-  useEffect12(() => {
+  const engine = useContext11(EngineContext);
+  const entityId = useContext11(EntityContext);
+  useEffect13(() => {
     engine.ecs.addComponent(entityId, createCapsuleCollider(width, height, { offsetX, offsetY, isTrigger, layer, mask }));
     return () => engine.ecs.removeComponent(entityId, "CapsuleCollider");
   }, []);
@@ -4742,16 +5282,16 @@ function CapsuleCollider({
 }
 
 // src/components/CompoundCollider.tsx
-import { useEffect as useEffect13, useContext as useContext11 } from "react";
+import { useEffect as useEffect14, useContext as useContext12 } from "react";
 function CompoundCollider({
   shapes,
   isTrigger = false,
   layer = "default",
   mask = "*"
 }) {
-  const engine = useContext11(EngineContext);
-  const entityId = useContext11(EntityContext);
-  useEffect13(() => {
+  const engine = useContext12(EngineContext);
+  const entityId = useContext12(EntityContext);
+  useEffect14(() => {
     engine.ecs.addComponent(entityId, createCompoundCollider(shapes, { isTrigger, layer, mask }));
     const checkId = setTimeout(() => {
       if (engine.ecs.hasEntity(entityId) && !engine.ecs.hasComponent(entityId, "Transform")) {
@@ -4767,15 +5307,20 @@ function CompoundCollider({
 }
 
 // src/components/Script.tsx
-import { useEffect as useEffect14, useContext as useContext12, useRef as useRef4 } from "react";
+import { useEffect as useEffect15, useContext as useContext13, useRef as useRef5 } from "react";
 function Script({ init, update }) {
-  const engine = useContext12(EngineContext);
-  const entityId = useContext12(EntityContext);
-  const initRef = useRef4(init);
+  const engine = useContext13(EngineContext);
+  const entityId = useContext13(EntityContext);
+  if (process.env.NODE_ENV !== "production") {
+    if (entityId === null) {
+      console.warn("[Cubeforge] <Script> must be inside an <Entity>. No EntityContext found.");
+    }
+  }
+  const initRef = useRef5(init);
   initRef.current = init;
-  const updateRef = useRef4(update);
+  const updateRef = useRef5(update);
   updateRef.current = update;
-  useEffect14(() => {
+  useEffect15(() => {
     if (initRef.current) {
       try {
         initRef.current(entityId, engine.ecs);
@@ -4791,7 +5336,7 @@ function Script({ init, update }) {
 }
 
 // src/components/Camera2D.tsx
-import { useEffect as useEffect15, useContext as useContext13 } from "react";
+import { useEffect as useEffect16, useContext as useContext14 } from "react";
 function Camera2D({
   followEntity,
   x = 0,
@@ -4804,8 +5349,8 @@ function Camera2D({
   followOffsetX = 0,
   followOffsetY = 0
 }) {
-  const engine = useContext13(EngineContext);
-  useEffect15(() => {
+  const engine = useContext14(EngineContext);
+  useEffect16(() => {
     const entityId = engine.ecs.createEntity();
     engine.ecs.addComponent(entityId, createCamera2D({
       followEntityId: followEntity,
@@ -4821,7 +5366,7 @@ function Camera2D({
     }));
     return () => engine.ecs.destroyEntity(entityId);
   }, []);
-  useEffect15(() => {
+  useEffect16(() => {
     const camId = engine.ecs.queryOne("Camera2D");
     if (camId === void 0) return;
     const cam = engine.ecs.getComponent(camId, "Camera2D");
@@ -4840,11 +5385,11 @@ function Camera2D({
 }
 
 // src/components/Animation.tsx
-import { useEffect as useEffect16, useContext as useContext14 } from "react";
+import { useEffect as useEffect17, useContext as useContext15 } from "react";
 function Animation({ frames, fps = 12, loop = true, playing = true, onComplete, frameEvents }) {
-  const engine = useContext14(EngineContext);
-  const entityId = useContext14(EntityContext);
-  useEffect16(() => {
+  const engine = useContext15(EngineContext);
+  const entityId = useContext15(EntityContext);
+  useEffect17(() => {
     const state = {
       type: "AnimationState",
       frames,
@@ -4862,7 +5407,7 @@ function Animation({ frames, fps = 12, loop = true, playing = true, onComplete,
       engine.ecs.removeComponent(entityId, "AnimationState");
     };
   }, []);
-  useEffect16(() => {
+  useEffect17(() => {
     const anim = engine.ecs.getComponent(entityId, "AnimationState");
     if (!anim) return;
     const wasFramesChanged = anim.frames !== frames;
@@ -4881,12 +5426,162 @@ function Animation({ frames, fps = 12, loop = true, playing = true, onComplete,
   return null;
 }
 
+// src/components/AnimatedSprite.tsx
+import { useEffect as useEffect18, useContext as useContext16 } from "react";
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+function defineAnimations(clips) {
+  return clips;
+}
+function AnimatedSprite(props) {
+  const {
+    width,
+    height,
+    src,
+    color,
+    offsetX,
+    offsetY,
+    zIndex,
+    visible,
+    flipX,
+    flipY,
+    anchorX,
+    anchorY,
+    frameWidth,
+    frameHeight,
+    frameColumns,
+    atlas,
+    frame,
+    tileX,
+    tileY,
+    tileSizeX,
+    tileSizeY,
+    sampling,
+    blendMode
+  } = props;
+  const spriteEl = /* @__PURE__ */ jsx5(
+    Sprite,
+    {
+      width,
+      height,
+      src,
+      color,
+      offsetX,
+      offsetY,
+      zIndex,
+      visible,
+      flipX,
+      flipY,
+      anchorX,
+      anchorY,
+      frameWidth,
+      frameHeight,
+      frameColumns,
+      atlas,
+      frame,
+      tileX,
+      tileY,
+      tileSizeX,
+      tileSizeY,
+      sampling,
+      blendMode
+    }
+  );
+  if (props.animations) {
+    return /* @__PURE__ */ jsxs3(Fragment3, { children: [
+      spriteEl,
+      /* @__PURE__ */ jsx5(
+        MultiClipAnimation,
+        {
+          animations: props.animations,
+          current: props.current
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Fragment3, { children: [
+    spriteEl,
+    /* @__PURE__ */ jsx5(
+      Animation,
+      {
+        frames: props.frames,
+        fps: props.fps,
+        loop: props.loop,
+        playing: props.playing,
+        onComplete: props.onComplete,
+        frameEvents: props.frameEvents
+      }
+    )
+  ] });
+}
+function MultiClipAnimation({ animations, current }) {
+  const engine = useContext16(EngineContext);
+  const entityId = useContext16(EntityContext);
+  useEffect18(() => {
+    const clip = animations[current] ?? Object.values(animations)[0];
+    const state = {
+      type: "AnimationState",
+      clips: animations,
+      currentClip: current,
+      _resolvedClip: current,
+      frames: clip.frames,
+      fps: clip.fps ?? 12,
+      loop: clip.loop ?? true,
+      playing: true,
+      currentIndex: 0,
+      timer: 0,
+      _completed: false,
+      onComplete: clip.onComplete
+    };
+    engine.ecs.addComponent(entityId, state);
+    return () => engine.ecs.removeComponent(entityId, "AnimationState");
+  }, []);
+  useEffect18(() => {
+    const anim = engine.ecs.getComponent(entityId, "AnimationState");
+    if (!anim) return;
+    anim.clips = animations;
+    anim.currentClip = current;
+  }, [current, animations, engine, entityId]);
+  return null;
+}
+
+// src/components/Animator.tsx
+import { useEffect as useEffect19, useContext as useContext17 } from "react";
+function Animator({ initial, states, params = {}, playing = true }) {
+  const engine = useContext17(EngineContext);
+  const entityId = useContext17(EntityContext);
+  useEffect19(() => {
+    const comp = {
+      type: "Animator",
+      initialState: initial,
+      currentState: initial,
+      states,
+      params: { ...params },
+      playing,
+      _entered: false
+    };
+    engine.ecs.addComponent(entityId, comp);
+    return () => engine.ecs.removeComponent(entityId, "Animator");
+  }, []);
+  useEffect19(() => {
+    const comp = engine.ecs.getComponent(entityId, "Animator");
+    if (!comp) return;
+    Object.assign(comp.params, params);
+    comp.playing = playing;
+  }, [params, playing, engine, entityId]);
+  useEffect19(() => {
+    const comp = engine.ecs.getComponent(entityId, "Animator");
+    if (!comp) return;
+    comp.states = states;
+  }, [states, engine, entityId]);
+  return null;
+}
+
 // src/components/SquashStretch.tsx
-import { useEffect as useEffect17, useContext as useContext15 } from "react";
+import { useEffect as useEffect20, useContext as useContext18 } from "react";
 function SquashStretch({ intensity = 0.2, recovery = 8 }) {
-  const engine = useContext15(EngineContext);
-  const entityId = useContext15(EntityContext);
-  useEffect17(() => {
+  const engine = useContext18(EngineContext);
+  const entityId = useContext18(EntityContext);
+  useEffect20(() => {
     engine.ecs.addComponent(entityId, {
       type: "SquashStretch",
       intensity,
@@ -4900,7 +5595,7 @@ function SquashStretch({ intensity = 0.2, recovery = 8 }) {
 }
 
 // src/components/ParticleEmitter.tsx
-import { useEffect as useEffect18, useContext as useContext16 } from "react";
+import { useEffect as useEffect21, useContext as useContext19 } from "react";
 
 // src/components/particlePresets.ts
 var PARTICLE_PRESETS = {
@@ -4973,7 +5668,12 @@ function ParticleEmitter({
   particleSize,
   color,
   gravity,
-  maxParticles
+  maxParticles,
+  burstCount,
+  emitShape,
+  emitRadius,
+  emitWidth,
+  emitHeight
 }) {
   const presetConfig = preset ? PARTICLE_PRESETS[preset] : {};
   const resolvedRate = rate ?? presetConfig.rate ?? 20;
@@ -4985,9 +5685,9 @@ function ParticleEmitter({
   const resolvedColor = color ?? presetConfig.color ?? "#ffffff";
   const resolvedGravity = gravity ?? presetConfig.gravity ?? 200;
   const resolvedMaxParticles = maxParticles ?? presetConfig.maxParticles ?? 100;
-  const engine = useContext16(EngineContext);
-  const entityId = useContext16(EntityContext);
-  useEffect18(() => {
+  const engine = useContext19(EngineContext);
+  const entityId = useContext19(EntityContext);
+  useEffect21(() => {
     engine.ecs.addComponent(entityId, {
       type: "ParticlePool",
       particles: [],
@@ -5001,11 +5701,16 @@ function ParticleEmitter({
       particleLife: resolvedParticleLife,
       particleSize: resolvedParticleSize,
       color: resolvedColor,
-      gravity: resolvedGravity
+      gravity: resolvedGravity,
+      burstCount,
+      emitShape,
+      emitRadius,
+      emitWidth,
+      emitHeight
     });
     return () => engine.ecs.removeComponent(entityId, "ParticlePool");
   }, []);
-  useEffect18(() => {
+  useEffect21(() => {
     const pool = engine.ecs.getComponent(entityId, "ParticlePool");
     if (!pool) return;
     pool.active = active;
@@ -5014,7 +5719,7 @@ function ParticleEmitter({
 }
 
 // src/components/VirtualJoystick.tsx
-import { useRef as useRef5 } from "react";
+import { useRef as useRef6 } from "react";
 
 // src/hooks/useVirtualInput.ts
 var _axes = { x: 0, y: 0 };
@@ -5039,7 +5744,7 @@ function useVirtualInput() {
 }
 
 // src/components/VirtualJoystick.tsx
-import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Fragment as Fragment4, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
 function VirtualJoystick({
   size = 120,
   position = "left",
@@ -5048,10 +5753,10 @@ function VirtualJoystick({
   actionLabel = "A",
   actionName = "action"
 }) {
-  const baseRef = useRef5(null);
-  const stickRef = useRef5(null);
-  const activePtr = useRef5(null);
-  const baseCenterRef = useRef5({ x: 0, y: 0 });
+  const baseRef = useRef6(null);
+  const stickRef = useRef6(null);
+  const activePtr = useRef6(null);
+  const baseCenterRef = useRef6({ x: 0, y: 0 });
   const radius = size / 2 - 16;
   const applyStickPosition = (dx, dy) => {
     if (!stickRef.current) return;
@@ -5096,8 +5801,8 @@ function VirtualJoystick({
   };
   const cornerStyle = position === "left" ? { left: 24, bottom: 24 } : { right: 24, bottom: 24 };
   const actionCorner = position === "left" ? { right: 24, bottom: 24 } : { left: 24, bottom: 24 };
-  return /* @__PURE__ */ jsxs3(Fragment3, { children: [
-    /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsxs4(Fragment4, { children: [
+    /* @__PURE__ */ jsx6(
       "div",
       {
         onPointerDown: handlePointerDown,
@@ -5118,7 +5823,7 @@ function VirtualJoystick({
           ...style
         },
         ref: baseRef,
-        children: /* @__PURE__ */ jsx5(
+        children: /* @__PURE__ */ jsx6(
           "div",
           {
             ref: stickRef,
@@ -5138,7 +5843,7 @@ function VirtualJoystick({
         )
       }
     ),
-    actionButton && /* @__PURE__ */ jsx5(
+    actionButton && /* @__PURE__ */ jsx6(
       "div",
       {
         onPointerDown: (e) => {
@@ -5173,7 +5878,7 @@ function VirtualJoystick({
 }
 
 // src/components/MovingPlatform.tsx
-import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 var platformPhases = /* @__PURE__ */ new Map();
 function MovingPlatform({
   x1,
@@ -5185,12 +5890,12 @@ function MovingPlatform({
   duration = 3,
   color = "#37474f"
 }) {
-  return /* @__PURE__ */ jsxs4(Entity, { children: [
-    /* @__PURE__ */ jsx6(Transform, { x: x1, y: y1 }),
-    /* @__PURE__ */ jsx6(Sprite, { width, height, color, zIndex: 5 }),
-    /* @__PURE__ */ jsx6(RigidBody, { isStatic: true }),
-    /* @__PURE__ */ jsx6(BoxCollider, { width, height }),
-    /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsxs5(Entity, { children: [
+    /* @__PURE__ */ jsx7(Transform, { x: x1, y: y1 }),
+    /* @__PURE__ */ jsx7(Sprite, { width, height, color, zIndex: 5 }),
+    /* @__PURE__ */ jsx7(RigidBody, { isStatic: true }),
+    /* @__PURE__ */ jsx7(BoxCollider, { width, height }),
+    /* @__PURE__ */ jsx7(
       Script,
       {
         init: () => {
@@ -5212,7 +5917,7 @@ function MovingPlatform({
 
 // src/components/Checkpoint.tsx
 import { useState as useState4 } from "react";
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 function CheckpointActivator({ onActivate }) {
   const [used, setUsed] = useState4(false);
   useTriggerEnter(() => {
@@ -5230,17 +5935,17 @@ function Checkpoint({
   color = "#ffd54f",
   onActivate
 }) {
-  return /* @__PURE__ */ jsxs5(Entity, { tags: ["checkpoint"], children: [
-    /* @__PURE__ */ jsx7(Transform, { x, y }),
-    /* @__PURE__ */ jsx7(Sprite, { width, height, color, zIndex: 5 }),
-    /* @__PURE__ */ jsx7(BoxCollider, { width, height, isTrigger: true }),
-    /* @__PURE__ */ jsx7(CheckpointActivator, { onActivate })
+  return /* @__PURE__ */ jsxs6(Entity, { tags: ["checkpoint"], children: [
+    /* @__PURE__ */ jsx8(Transform, { x, y }),
+    /* @__PURE__ */ jsx8(Sprite, { width, height, color, zIndex: 5 }),
+    /* @__PURE__ */ jsx8(BoxCollider, { width, height, isTrigger: true }),
+    /* @__PURE__ */ jsx8(CheckpointActivator, { onActivate })
   ] });
 }
 
 // src/components/Tilemap.tsx
-import { useEffect as useEffect19, useState as useState5, useContext as useContext17 } from "react";
-import { Fragment as Fragment4, jsx as jsx8 } from "react/jsx-runtime";
+import { useEffect as useEffect22, useState as useState5, useContext as useContext20 } from "react";
+import { Fragment as Fragment5, jsx as jsx9 } from "react/jsx-runtime";
 var animatedTiles = /* @__PURE__ */ new Map();
 function getProperty(props, name) {
   return props?.find((p) => p.name === name)?.value;
@@ -5262,11 +5967,12 @@ function Tilemap({
   collisionLayer = "collision",
   triggerLayer: triggerLayerName = "triggers",
   onTileProperty,
-  navGrid
+  navGrid,
+  mergeColliders = true
 }) {
-  const engine = useContext17(EngineContext);
+  const engine = useContext20(EngineContext);
   const [spawnedNodes, setSpawnedNodes] = useState5([]);
-  useEffect19(() => {
+  useEffect22(() => {
     if (!engine) return;
     const createdEntities = [];
     async function load() {
@@ -5334,32 +6040,54 @@ function Tilemap({
             }
           }
           if (collision || trigger) {
-            for (let row = 0; row < mapData.height; row++) {
-              let col = 0;
-              while (col < mapData.width) {
-                const i = row * mapData.width + col;
-                const gid = layer.data[i];
-                if (gid === 0) {
-                  col++;
-                  continue;
+            if (mergeColliders) {
+              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;
                 }
-                let runLength = 1;
-                while (col + runLength < mapData.width && layer.data[row * mapData.width + col + runLength] !== 0) {
-                  runLength++;
-                }
-                const runWidth = runLength * tilewidth;
-                const x = col * tilewidth + runWidth / 2;
-                const y = row * tileheight + tileheight / 2;
+              }
+              const merged = mergeTileColliders(solidGrid, tilewidth, tileheight, 0, 0);
+              for (const rect of merged) {
                 const eid = engine.ecs.createEntity();
                 createdEntities.push(eid);
-                engine.ecs.addComponent(eid, createTransform(x, y));
+                engine.ecs.addComponent(eid, createTransform(rect.x, rect.y));
                 if (collision) {
                   engine.ecs.addComponent(eid, createRigidBody({ isStatic: true }));
-                  engine.ecs.addComponent(eid, createBoxCollider(runWidth, tileheight));
+                  engine.ecs.addComponent(eid, createBoxCollider(rect.width, rect.height));
                 } else {
-                  engine.ecs.addComponent(eid, createBoxCollider(runWidth, tileheight, { isTrigger: true }));
+                  engine.ecs.addComponent(eid, createBoxCollider(rect.width, rect.height, { isTrigger: true }));
+                }
+              }
+            } else {
+              for (let row = 0; row < mapData.height; row++) {
+                let col = 0;
+                while (col < mapData.width) {
+                  const i = row * mapData.width + col;
+                  const gid = layer.data[i];
+                  if (gid === 0) {
+                    col++;
+                    continue;
+                  }
+                  let runLength = 1;
+                  while (col + runLength < mapData.width && layer.data[row * mapData.width + col + runLength] !== 0) {
+                    runLength++;
+                  }
+                  const runWidth = runLength * tilewidth;
+                  const x = col * tilewidth + runWidth / 2;
+                  const y = row * tileheight + tileheight / 2;
+                  const eid = engine.ecs.createEntity();
+                  createdEntities.push(eid);
+                  engine.ecs.addComponent(eid, createTransform(x, y));
+                  if (collision) {
+                    engine.ecs.addComponent(eid, createRigidBody({ isStatic: true }));
+                    engine.ecs.addComponent(eid, createBoxCollider(runWidth, tileheight));
+                  } else {
+                    engine.ecs.addComponent(eid, createBoxCollider(runWidth, tileheight, { isTrigger: true }));
+                  }
+                  col += runLength;
                 }
-                col += runLength;
               }
             }
           } else {
@@ -5453,12 +6181,12 @@ function Tilemap({
     };
   }, [src]);
   if (spawnedNodes.length === 0) return null;
-  return /* @__PURE__ */ jsx8(Fragment4, { children: spawnedNodes });
+  return /* @__PURE__ */ jsx9(Fragment5, { children: spawnedNodes });
 }
 
 // src/components/ParallaxLayer.tsx
-import { useEffect as useEffect20, useContext as useContext18 } from "react";
-import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+import { useEffect as useEffect23, useContext as useContext21 } from "react";
+import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
 function ParallaxLayerInner({
   src,
   speedX,
@@ -5469,9 +6197,9 @@ function ParallaxLayerInner({
   offsetX,
   offsetY
 }) {
-  const engine = useContext18(EngineContext);
-  const entityId = useContext18(EntityContext);
-  useEffect20(() => {
+  const engine = useContext21(EngineContext);
+  const entityId = useContext21(EntityContext);
+  useEffect23(() => {
     engine.ecs.addComponent(entityId, {
       type: "ParallaxLayer",
       src,
@@ -5487,7 +6215,7 @@ function ParallaxLayerInner({
     });
     return () => engine.ecs.removeComponent(entityId, "ParallaxLayer");
   }, []);
-  useEffect20(() => {
+  useEffect23(() => {
     const layer = engine.ecs.getComponent(entityId, "ParallaxLayer");
     if (!layer) return;
     layer.src = src;
@@ -5511,9 +6239,9 @@ function ParallaxLayer({
   offsetX = 0,
   offsetY = 0
 }) {
-  return /* @__PURE__ */ jsxs6(Entity, { children: [
-    /* @__PURE__ */ jsx9(Transform, { x: 0, y: 0 }),
-    /* @__PURE__ */ jsx9(
+  return /* @__PURE__ */ jsxs7(Entity, { children: [
+    /* @__PURE__ */ jsx10(Transform, { x: 0, y: 0 }),
+    /* @__PURE__ */ jsx10(
       ParallaxLayerInner,
       {
         src,
@@ -5530,10 +6258,10 @@ function ParallaxLayer({
 }
 
 // src/components/ScreenFlash.tsx
-import { forwardRef, useImperativeHandle, useRef as useRef6 } from "react";
-import { jsx as jsx10 } from "react/jsx-runtime";
+import { forwardRef, useImperativeHandle, useRef as useRef7 } from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
 var ScreenFlash = forwardRef((_, ref) => {
-  const divRef = useRef6(null);
+  const divRef = useRef7(null);
   useImperativeHandle(ref, () => ({
     flash(color, duration) {
       const el = divRef.current;
@@ -5551,7 +6279,7 @@ var ScreenFlash = forwardRef((_, ref) => {
       });
     }
   }));
-  return /* @__PURE__ */ jsx10(
+  return /* @__PURE__ */ jsx11(
     "div",
     {
       ref: divRef,
@@ -5569,8 +6297,8 @@ var ScreenFlash = forwardRef((_, ref) => {
 ScreenFlash.displayName = "ScreenFlash";
 
 // src/components/CameraZone.tsx
-import { useEffect as useEffect21, useContext as useContext19, useRef as useRef7 } from "react";
-import { Fragment as Fragment5, jsx as jsx11 } from "react/jsx-runtime";
+import { useEffect as useEffect24, useContext as useContext22, useRef as useRef8 } from "react";
+import { Fragment as Fragment6, jsx as jsx12 } from "react/jsx-runtime";
 function CameraZone({
   x,
   y,
@@ -5581,10 +6309,10 @@ function CameraZone({
   targetY,
   children
 }) {
-  const engine = useContext19(EngineContext);
-  const prevFollowRef = useRef7(void 0);
-  const activeRef = useRef7(false);
-  useEffect21(() => {
+  const engine = useContext22(EngineContext);
+  const prevFollowRef = useRef8(void 0);
+  const activeRef = useRef8(false);
+  useEffect24(() => {
     const eid = engine.ecs.createEntity();
     engine.ecs.addComponent(eid, createScript(() => {
       const cam = engine.ecs.queryOne("Camera2D");
@@ -5627,15 +6355,15 @@ function CameraZone({
       if (engine.ecs.hasEntity(eid)) engine.ecs.destroyEntity(eid);
     };
   }, [engine.ecs, x, y, width, height, watchTag, targetX, targetY]);
-  return /* @__PURE__ */ jsx11(Fragment5, { children: children ?? null });
+  return /* @__PURE__ */ jsx12(Fragment6, { children: children ?? null });
 }
 
 // src/components/Trail.tsx
-import { useEffect as useEffect22, useContext as useContext20 } from "react";
+import { useEffect as useEffect25, useContext as useContext23 } from "react";
 function Trail({ length = 20, color = "#ffffff", width = 3 }) {
-  const engine = useContext20(EngineContext);
-  const entityId = useContext20(EntityContext);
-  useEffect22(() => {
+  const engine = useContext23(EngineContext);
+  const entityId = useContext23(EntityContext);
+  useEffect25(() => {
     engine.ecs.addComponent(entityId, createTrail({ length, color, width }));
     return () => engine.ecs.removeComponent(entityId, "Trail");
   }, []);
@@ -5643,7 +6371,7 @@ function Trail({ length = 20, color = "#ffffff", width = 3 }) {
 }
 
 // src/components/NineSlice.tsx
-import { useEffect as useEffect23, useContext as useContext21 } from "react";
+import { useEffect as useEffect26, useContext as useContext24 } from "react";
 function NineSlice({
   src,
   width,
@@ -5654,9 +6382,9 @@ function NineSlice({
   borderLeft = 8,
   zIndex = 0
 }) {
-  const engine = useContext21(EngineContext);
-  const entityId = useContext21(EntityContext);
-  useEffect23(() => {
+  const engine = useContext24(EngineContext);
+  const entityId = useContext24(EntityContext);
+  useEffect26(() => {
     engine.ecs.addComponent(
       entityId,
       createNineSlice(src, width, height, {
@@ -5673,14 +6401,14 @@ function NineSlice({
 }
 
 // src/components/AssetLoader.tsx
-import { useEffect as useEffect25 } from "react";
+import { useEffect as useEffect28 } from "react";
 
 // src/hooks/usePreload.ts
-import { useState as useState6, useEffect as useEffect24, useContext as useContext22 } from "react";
+import { useState as useState6, useEffect as useEffect27, useContext as useContext25 } from "react";
 function usePreload(assets) {
-  const engine = useContext22(EngineContext);
+  const engine = useContext25(EngineContext);
   const [state, setState] = useState6({ progress: assets.length === 0 ? 1 : 0, loaded: assets.length === 0, error: null });
-  useEffect24(() => {
+  useEffect27(() => {
     if (assets.length === 0) {
       setState({ progress: 1, loaded: true, error: null });
       return;
@@ -5708,22 +6436,22 @@ function usePreload(assets) {
 }
 
 // src/components/AssetLoader.tsx
-import { Fragment as Fragment6, jsx as jsx12 } from "react/jsx-runtime";
+import { Fragment as Fragment7, jsx as jsx13 } from "react/jsx-runtime";
 function AssetLoader({ assets, fallback = null, onError, children }) {
   const { loaded, error } = usePreload(assets);
-  useEffect25(() => {
+  useEffect28(() => {
     if (error && onError) onError(error);
   }, [error, onError]);
   if (!loaded) {
-    return /* @__PURE__ */ jsx12(Fragment6, { children: fallback });
+    return /* @__PURE__ */ jsx13(Fragment7, { children: fallback });
   }
-  return /* @__PURE__ */ jsx12(Fragment6, { children });
+  return /* @__PURE__ */ jsx13(Fragment7, { children });
 }
 
 // src/hooks/useGame.ts
-import { useContext as useContext23 } from "react";
+import { useContext as useContext26 } from "react";
 function useGame() {
-  const engine = useContext23(EngineContext);
+  const engine = useContext26(EngineContext);
   if (!engine) throw new Error("useGame must be used inside <Game>");
   return engine;
 }
@@ -5780,18 +6508,18 @@ function useSnapshot() {
 }
 
 // src/hooks/useEntity.ts
-import { useContext as useContext24 } from "react";
+import { useContext as useContext27 } from "react";
 function useEntity() {
-  const id = useContext24(EntityContext);
+  const id = useContext27(EntityContext);
   if (id === null) throw new Error("useEntity must be used inside <Entity>");
   return id;
 }
 
 // src/hooks/useDestroyEntity.ts
-import { useCallback as useCallback2, useContext as useContext25 } from "react";
+import { useCallback as useCallback2, useContext as useContext28 } from "react";
 function useDestroyEntity() {
-  const engine = useContext25(EngineContext);
-  const entityId = useContext25(EntityContext);
+  const engine = useContext28(EngineContext);
+  const entityId = useContext28(EntityContext);
   if (!engine) throw new Error("useDestroyEntity must be used inside <Game>");
   if (entityId === null) throw new Error("useDestroyEntity must be used inside <Entity>");
   return useCallback2(() => {
@@ -5802,9 +6530,9 @@ function useDestroyEntity() {
 }
 
 // src/hooks/useInput.ts
-import { useContext as useContext26 } from "react";
+import { useContext as useContext29 } from "react";
 function useInput() {
-  const engine = useContext26(EngineContext);
+  const engine = useContext29(EngineContext);
   if (!engine) throw new Error("useInput must be used inside <Game>");
   return engine.input;
 }
@@ -5824,25 +6552,25 @@ function useInputMap(bindings) {
 }
 
 // src/hooks/useEvents.ts
-import { useContext as useContext27, useEffect as useEffect26, useRef as useRef8 } from "react";
+import { useContext as useContext30, useEffect as useEffect29, useRef as useRef9 } from "react";
 function useEvents() {
-  const engine = useContext27(EngineContext);
+  const engine = useContext30(EngineContext);
   if (!engine) throw new Error("useEvents must be used inside <Game>");
   return engine.events;
 }
 function useEvent(event, handler) {
   const events = useEvents();
-  const handlerRef = useRef8(handler);
+  const handlerRef = useRef9(handler);
   handlerRef.current = handler;
-  useEffect26(() => {
+  useEffect29(() => {
     return events.on(event, (data) => handlerRef.current(data));
   }, [events, event]);
 }
 
 // src/hooks/useCoordinates.ts
-import { useCallback as useCallback3, useContext as useContext28 } from "react";
+import { useCallback as useCallback3, useContext as useContext31 } from "react";
 function useCoordinates() {
-  const engine = useContext28(EngineContext);
+  const engine = useContext31(EngineContext);
   const worldToScreen = useCallback3((wx, wy) => {
     const canvas = engine.canvas;
     const camId = engine.ecs.queryOne("Camera2D");
@@ -5869,9 +6597,9 @@ function useCoordinates() {
 }
 
 // src/hooks/useInputContext.ts
-import { useEffect as useEffect27, useMemo as useMemo4 } from "react";
+import { useEffect as useEffect30, useMemo as useMemo4 } from "react";
 function useInputContext(ctx) {
-  useEffect27(() => {
+  useEffect30(() => {
     if (!ctx) return;
     globalInputContext.push(ctx);
     return () => globalInputContext.pop(ctx);
@@ -5910,12 +6638,12 @@ function useInputRecorder() {
 }
 
 // src/hooks/useGamepad.ts
-import { useEffect as useEffect28, useRef as useRef9, useState as useState7 } from "react";
+import { useEffect as useEffect31, useRef as useRef10, useState as useState7 } from "react";
 var EMPTY_STATE = { connected: false, axes: [], buttons: [] };
 function useGamepad(playerIndex = 0) {
   const [state, setState] = useState7(EMPTY_STATE);
-  const rafRef = useRef9(0);
-  useEffect28(() => {
+  const rafRef = useRef10(0);
+  useEffect31(() => {
     const poll = () => {
       const gp = navigator.getGamepads()[playerIndex];
       if (gp) {
@@ -5936,9 +6664,9 @@ function useGamepad(playerIndex = 0) {
 }
 
 // src/hooks/usePause.ts
-import { useContext as useContext29, useState as useState8, useCallback as useCallback4 } from "react";
+import { useContext as useContext32, useState as useState8, useCallback as useCallback4 } from "react";
 function usePause() {
-  const engine = useContext29(EngineContext);
+  const engine = useContext32(EngineContext);
   const [paused, setPaused] = useState8(false);
   const pause = useCallback4(() => {
     engine.loop.pause();
@@ -5955,10 +6683,75 @@ function usePause() {
   return { paused, pause, resume, toggle };
 }
 
+// src/hooks/useProfiler.ts
+import { useContext as useContext33, useEffect as useEffect32, useRef as useRef11, useState as useState9 } from "react";
+var EMPTY = {
+  fps: 0,
+  frameTime: 0,
+  entityCount: 0,
+  systemTimings: /* @__PURE__ */ new Map()
+};
+function useProfiler() {
+  const engine = useContext33(EngineContext);
+  const [data, setData] = useState9(EMPTY);
+  const frameTimesRef = useRef11([]);
+  const lastUpdateRef = useRef11(0);
+  const prevTimeRef = useRef11(0);
+  useEffect32(() => {
+    if (!engine) return;
+    let rafId;
+    const frameTimes = frameTimesRef.current;
+    const sample = (now) => {
+      if (prevTimeRef.current > 0) {
+        frameTimes.push(now - prevTimeRef.current);
+      }
+      prevTimeRef.current = now;
+      if (now - lastUpdateRef.current >= 500) {
+        lastUpdateRef.current = now;
+        let fps = 0;
+        let avgFrameTime = 0;
+        if (frameTimes.length > 0) {
+          const sum = frameTimes.reduce((a, b) => a + b, 0);
+          avgFrameTime = sum / frameTimes.length;
+          fps = avgFrameTime > 0 ? 1e3 / avgFrameTime : 0;
+          frameTimes.length = 0;
+        }
+        setData({
+          fps: Math.round(fps * 10) / 10,
+          frameTime: Math.round(avgFrameTime * 100) / 100,
+          entityCount: engine.ecs.entityCount,
+          systemTimings: new Map(engine.systemTimings)
+        });
+      }
+      rafId = requestAnimationFrame(sample);
+    };
+    rafId = requestAnimationFrame(sample);
+    return () => {
+      cancelAnimationFrame(rafId);
+      frameTimes.length = 0;
+      prevTimeRef.current = 0;
+      lastUpdateRef.current = 0;
+    };
+  }, [engine]);
+  return data;
+}
+
+// src/hooks/usePostProcess.ts
+import { useEffect as useEffect33 } from "react";
+function usePostProcess(effect) {
+  const engine = useGame();
+  useEffect33(() => {
+    engine.postProcessStack.add(effect);
+    return () => {
+      engine.postProcessStack.remove(effect);
+    };
+  }, [engine, effect]);
+}
+
 // ../gameplay/src/hooks/useAnimationController.ts
-import { useState as useState9, useCallback as useCallback5 } from "react";
+import { useState as useState10, useCallback as useCallback5 } from "react";
 function useAnimationController(states, initial) {
-  const [stateName, setStateName] = useState9(initial);
+  const [stateName, setStateName] = useState10(initial);
   const setState = useCallback5((next) => {
     setStateName((prev) => prev === next ? prev : next);
   }, []);
@@ -6007,19 +6800,19 @@ function useAISteering() {
 }
 
 // ../gameplay/src/hooks/useDamageZone.ts
-import { useContext as useContext30 } from "react";
+import { useContext as useContext34 } from "react";
 function useDamageZone(damage, opts = {}) {
-  const engine = useContext30(EngineContext);
+  const engine = useContext34(EngineContext);
   useTriggerEnter((other) => {
     engine.events.emit(`damage:${other}`, { amount: damage });
   }, { tag: opts.tag, layer: opts.layer });
 }
 
 // ../gameplay/src/hooks/useDropThrough.ts
-import { useContext as useContext31, useCallback as useCallback7 } from "react";
+import { useContext as useContext35, useCallback as useCallback7 } from "react";
 function useDropThrough(frames = 8) {
-  const engine = useContext31(EngineContext);
-  const entityId = useContext31(EntityContext);
+  const engine = useContext35(EngineContext);
+  const entityId = useContext35(EntityContext);
   const dropThrough = useCallback7(() => {
     const rb = engine.ecs.getComponent(entityId, "RigidBody");
     if (rb) rb.dropThrough = frames;
@@ -6028,14 +6821,14 @@ function useDropThrough(frames = 8) {
 }
 
 // ../gameplay/src/hooks/useGameStateMachine.ts
-import { useState as useState10, useRef as useRef10, useCallback as useCallback8, useEffect as useEffect29, useContext as useContext32 } from "react";
+import { useState as useState11, useRef as useRef12, useCallback as useCallback8, useEffect as useEffect34, useContext as useContext36 } from "react";
 function useGameStateMachine(states, initial) {
-  const engine = useContext32(EngineContext);
-  const [state, setState] = useState10(initial);
-  const stateRef = useRef10(initial);
-  const statesRef = useRef10(states);
+  const engine = useContext36(EngineContext);
+  const [state, setState] = useState11(initial);
+  const stateRef = useRef12(initial);
+  const statesRef = useRef12(states);
   statesRef.current = states;
-  useEffect29(() => {
+  useEffect34(() => {
     statesRef.current[initial]?.onEnter?.();
   }, []);
   const transition = useCallback8((to) => {
@@ -6046,7 +6839,7 @@ function useGameStateMachine(states, initial) {
     setState(to);
     statesRef.current[to]?.onEnter?.();
   }, []);
-  useEffect29(() => {
+  useEffect34(() => {
     const eid = engine.ecs.createEntity();
     engine.ecs.addComponent(eid, createScript((_id, _world, _input, dt) => {
       statesRef.current[stateRef.current]?.onUpdate?.(dt);
@@ -6059,22 +6852,22 @@ function useGameStateMachine(states, initial) {
 }
 
 // ../gameplay/src/hooks/useHealth.ts
-import { useRef as useRef11, useEffect as useEffect30, useContext as useContext33, useCallback as useCallback9 } from "react";
+import { useRef as useRef13, useEffect as useEffect35, useContext as useContext37, useCallback as useCallback9 } from "react";
 function useHealth(maxHp, opts = {}) {
-  const engine = useContext33(EngineContext);
-  const entityId = useContext33(EntityContext);
-  const hpRef = useRef11(maxHp);
-  const invincibleRef = useRef11(false);
+  const engine = useContext37(EngineContext);
+  const entityId = useContext37(EntityContext);
+  const hpRef = useRef13(maxHp);
+  const invincibleRef = useRef13(false);
   const iFrameDuration = opts.iFrames ?? 1;
-  const onDeathRef = useRef11(opts.onDeath);
-  const onDamageRef = useRef11(opts.onDamage);
-  useEffect30(() => {
+  const onDeathRef = useRef13(opts.onDeath);
+  const onDamageRef = useRef13(opts.onDamage);
+  useEffect35(() => {
     onDeathRef.current = opts.onDeath;
   });
-  useEffect30(() => {
+  useEffect35(() => {
     onDamageRef.current = opts.onDamage;
   });
-  const timerRef = useRef11(
+  const timerRef = useRef13(
     createTimer(iFrameDuration, () => {
       invincibleRef.current = false;
     })
@@ -6089,11 +6882,11 @@ function useHealth(maxHp, opts = {}) {
     }
     if (hpRef.current <= 0) onDeathRef.current?.();
   }, [iFrameDuration]);
-  const takeDamageRef = useRef11(takeDamage);
-  useEffect30(() => {
+  const takeDamageRef = useRef13(takeDamage);
+  useEffect35(() => {
     takeDamageRef.current = takeDamage;
   }, [takeDamage]);
-  useEffect30(() => {
+  useEffect35(() => {
     return engine.events.on(`damage:${entityId}`, ({ amount }) => {
       takeDamageRef.current(amount);
     });
@@ -6128,10 +6921,10 @@ function useHealth(maxHp, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useKinematicBody.ts
-import { useContext as useContext34, useCallback as useCallback10 } from "react";
+import { useContext as useContext38, useCallback as useCallback10 } from "react";
 function useKinematicBody() {
-  const engine = useContext34(EngineContext);
-  const entityId = useContext34(EntityContext);
+  const engine = useContext38(EngineContext);
+  const entityId = useContext38(EntityContext);
   const moveAndCollide = useCallback10((dx, dy) => {
     const transform = engine.ecs.getComponent(entityId, "Transform");
     if (!transform) return { dx: 0, dy: 0 };
@@ -6176,11 +6969,11 @@ function useKinematicBody() {
 }
 
 // ../gameplay/src/hooks/useLevelTransition.ts
-import { useState as useState11, useRef as useRef12, useCallback as useCallback11 } from "react";
+import { useState as useState12, useRef as useRef14, useCallback as useCallback11 } from "react";
 function useLevelTransition(initial) {
-  const [currentLevel, setCurrentLevel] = useState11(initial);
-  const [isTransitioning, setIsTransitioning] = useState11(false);
-  const overlayRef = useRef12(null);
+  const [currentLevel, setCurrentLevel] = useState12(initial);
+  const [isTransitioning, setIsTransitioning] = useState12(false);
+  const overlayRef = useRef14(null);
   const transitionTo = useCallback11((level, opts = {}) => {
     const { duration = 0.4, type = "fade" } = opts;
     if (type === "instant") {
@@ -6218,13 +7011,13 @@ function useLevelTransition(initial) {
 }
 
 // ../gameplay/src/hooks/usePlatformerController.ts
-import { useContext as useContext35, useEffect as useEffect31 } from "react";
+import { useContext as useContext39, useEffect as useEffect36 } from "react";
 function normalizeKeys(val, defaults) {
   if (!val) return defaults;
   return Array.isArray(val) ? val : [val];
 }
 function usePlatformerController(entityId, opts = {}) {
-  const engine = useContext35(EngineContext);
+  const engine = useContext39(EngineContext);
   const {
     speed = 200,
     jumpForce = -500,
@@ -6237,7 +7030,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"]);
-  useEffect31(() => {
+  useEffect36(() => {
     const state = {
       coyoteTimer: 0,
       jumpBuffer: 0,
@@ -6301,11 +7094,11 @@ function usePathfinding() {
 }
 
 // ../gameplay/src/hooks/usePersistedBindings.ts
-import { useState as useState12, useCallback as useCallback13, useMemo as useMemo8, useContext as useContext36 } from "react";
+import { useState as useState13, useCallback as useCallback13, useMemo as useMemo8, useContext as useContext40 } from "react";
 function usePersistedBindings(storageKey, defaults) {
-  const engine = useContext36(EngineContext);
+  const engine = useContext40(EngineContext);
   const input = engine.input;
-  const [bindings, setBindings] = useState12(() => {
+  const [bindings, setBindings] = useState13(() => {
     try {
       const stored = localStorage.getItem(storageKey);
       if (stored) return { ...defaults, ...JSON.parse(stored) };
@@ -6349,9 +7142,9 @@ function usePersistedBindings(storageKey, defaults) {
 }
 
 // ../gameplay/src/hooks/useRestart.ts
-import { useState as useState13, useCallback as useCallback14 } from "react";
+import { useState as useState14, useCallback as useCallback14 } from "react";
 function useRestart() {
-  const [restartKey, setRestartKey] = useState13(0);
+  const [restartKey, setRestartKey] = useState14(0);
   const restart = useCallback14(() => {
     setRestartKey((k) => k + 1);
   }, []);
@@ -6359,10 +7152,10 @@ function useRestart() {
 }
 
 // ../gameplay/src/hooks/useSave.ts
-import { useCallback as useCallback15, useRef as useRef13 } from "react";
+import { useCallback as useCallback15, useRef as useRef15 } from "react";
 function useSave(key, defaultValue, opts = {}) {
   const version = opts.version ?? 1;
-  const dataRef = useRef13(defaultValue);
+  const dataRef = useRef15(defaultValue);
   const save = useCallback15((value) => {
     dataRef.current = value;
     const slot = { version, data: value };
@@ -6408,11 +7201,11 @@ function useSave(key, defaultValue, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useTopDownMovement.ts
-import { useContext as useContext37, useEffect as useEffect32 } from "react";
+import { useContext as useContext41, useEffect as useEffect37 } from "react";
 function useTopDownMovement(entityId, opts = {}) {
-  const engine = useContext37(EngineContext);
+  const engine = useContext41(EngineContext);
   const { speed = 200, normalizeDiagonal = true } = opts;
-  useEffect32(() => {
+  useEffect37(() => {
     const updateFn = (id, world, input) => {
       if (!world.hasEntity(id)) return;
       const rb = world.getComponent(id, "RigidBody");
@@ -6437,11 +7230,11 @@ function useTopDownMovement(entityId, opts = {}) {
 }
 
 // ../gameplay/src/hooks/useDialogue.ts
-import { useState as useState14, useCallback as useCallback16, useRef as useRef14 } from "react";
+import { useState as useState15, useCallback as useCallback16, useRef as useRef16 } from "react";
 function useDialogue() {
-  const [active, setActive] = useState14(false);
-  const [currentId, setCurrentId] = useState14(null);
-  const scriptRef = useRef14(null);
+  const [active, setActive] = useState15(false);
+  const [currentId, setCurrentId] = useState15(null);
+  const scriptRef = useRef16(null);
   const start = useCallback16((script, startId) => {
     scriptRef.current = script;
     const id = startId ?? Object.keys(script)[0];
@@ -6485,16 +7278,16 @@ function useDialogue() {
 }
 
 // ../gameplay/src/hooks/useCutscene.ts
-import { useState as useState15, useCallback as useCallback17, useRef as useRef15, useEffect as useEffect33, useContext as useContext38 } from "react";
+import { useState as useState16, useCallback as useCallback17, useRef as useRef17, useEffect as useEffect38, useContext as useContext42 } from "react";
 function useCutscene() {
-  const engine = useContext38(EngineContext);
-  const [playing, setPlaying] = useState15(false);
-  const [stepIndex, setStepIndex] = useState15(0);
-  const stepsRef = useRef15([]);
-  const timerRef = useRef15(0);
-  const idxRef = useRef15(0);
-  const playingRef = useRef15(false);
-  const entityRef = useRef15(null);
+  const engine = useContext42(EngineContext);
+  const [playing, setPlaying] = useState16(false);
+  const [stepIndex, setStepIndex] = useState16(0);
+  const stepsRef = useRef17([]);
+  const timerRef = useRef17(0);
+  const idxRef = useRef17(0);
+  const playingRef = useRef17(false);
+  const entityRef = useRef17(null);
   const finish = useCallback17(() => {
     playingRef.current = false;
     setPlaying(false);
@@ -6572,7 +7365,7 @@ function useCutscene() {
     }
     finish();
   }, [finish]);
-  useEffect33(() => {
+  useEffect38(() => {
     return () => {
       if (entityRef.current !== null && engine.ecs.hasEntity(entityRef.current)) {
         engine.ecs.destroyEntity(entityRef.current);
@@ -6618,8 +7411,112 @@ function useGameStore(key, initialState) {
   return [state, setState];
 }
 
+// ../gameplay/src/hooks/useTween.ts
+import { useRef as useRef18, useCallback as useCallback19, useEffect as useEffect39 } from "react";
+function useTween(opts) {
+  const rafRef = useRef18(null);
+  const startTimeRef = useRef18(0);
+  const runningRef = useRef18(false);
+  const optsRef = useRef18(opts);
+  optsRef.current = opts;
+  const stop = useCallback19(() => {
+    if (rafRef.current !== null) {
+      cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+    }
+    runningRef.current = false;
+  }, []);
+  const start = useCallback19(() => {
+    stop();
+    runningRef.current = true;
+    startTimeRef.current = performance.now();
+    const tick = (now) => {
+      if (!runningRef.current) return;
+      const { from, to, duration, ease, onUpdate, onComplete } = optsRef.current;
+      const easeFn = ease ?? Ease.linear;
+      const elapsed = (now - startTimeRef.current) / 1e3;
+      const t = duration > 0 ? Math.min(elapsed / duration, 1) : 1;
+      const value = from + (to - from) * easeFn(t);
+      onUpdate(value);
+      if (t >= 1) {
+        runningRef.current = false;
+        rafRef.current = null;
+        onComplete?.();
+      } else {
+        rafRef.current = requestAnimationFrame(tick);
+      }
+    };
+    rafRef.current = requestAnimationFrame(tick);
+  }, [stop]);
+  useEffect39(() => {
+    if (opts.autoStart) {
+      start();
+    }
+  }, []);
+  useEffect39(() => {
+    return () => {
+      if (rafRef.current !== null) {
+        cancelAnimationFrame(rafRef.current);
+        rafRef.current = null;
+      }
+      runningRef.current = false;
+    };
+  }, []);
+  return {
+    start,
+    stop,
+    get isRunning() {
+      return runningRef.current;
+    }
+  };
+}
+
+// ../gameplay/src/hooks/useObjectPool.ts
+import { useRef as useRef19, useMemo as useMemo9, useEffect as useEffect40 } from "react";
+function useObjectPool(factory, reset, initialSize) {
+  const poolRef = useRef19([]);
+  const activeRef = useRef19(0);
+  const factoryRef = useRef19(factory);
+  factoryRef.current = factory;
+  const resetRef = useRef19(reset);
+  resetRef.current = reset;
+  useEffect40(() => {
+    if (initialSize != null && initialSize > 0) {
+      const pool = poolRef.current;
+      for (let i = 0; i < initialSize; i++) {
+        pool.push(factoryRef.current());
+      }
+    }
+  }, []);
+  return useMemo9(() => ({
+    acquire() {
+      activeRef.current++;
+      if (poolRef.current.length > 0) {
+        return poolRef.current.pop();
+      }
+      return factoryRef.current();
+    },
+    release(obj) {
+      resetRef.current(obj);
+      activeRef.current = Math.max(0, activeRef.current - 1);
+      poolRef.current.push(obj);
+    },
+    prewarm(count) {
+      for (let i = 0; i < count; i++) {
+        poolRef.current.push(factoryRef.current());
+      }
+    },
+    get activeCount() {
+      return activeRef.current;
+    },
+    get poolSize() {
+      return poolRef.current.length;
+    }
+  }), []);
+}
+
 // ../../packages/audio/src/useSound.ts
-import { useEffect as useEffect34, useRef as useRef16 } from "react";
+import { useEffect as useEffect41, useRef as useRef20 } from "react";
 var _audioCtx = null;
 function getAudioCtx() {
   if (!_audioCtx) _audioCtx = new AudioContext();
@@ -6686,13 +7583,13 @@ async function loadBuffer(src) {
   return buf;
 }
 function useSound(src, opts = {}) {
-  const bufferRef = useRef16(null);
-  const sourceRef = useRef16(null);
-  const gainRef = useRef16(null);
-  const volRef = useRef16(opts.volume ?? 1);
-  const loopRef = useRef16(opts.loop ?? false);
-  const groupRef = useRef16(opts.group);
-  useEffect34(() => {
+  const bufferRef = useRef20(null);
+  const sourceRef = useRef20(null);
+  const gainRef = useRef20(null);
+  const volRef = useRef20(opts.volume ?? 1);
+  const loopRef = useRef20(opts.loop ?? false);
+  const groupRef = useRef20(opts.group);
+  useEffect41(() => {
     let cancelled = false;
     loadBuffer(src).then((buf) => {
       if (!cancelled) bufferRef.current = buf;
@@ -6714,7 +7611,7 @@ function useSound(src, opts = {}) {
     };
   }, [src]);
   const getDestination = () => groupRef.current ? getGroupGainNode(groupRef.current) : getGroupGainNode("master");
-  const play = () => {
+  const play = (playOpts) => {
     if (!bufferRef.current) return;
     const ctx = getAudioCtx();
     if (ctx.state === "suspended") void ctx.resume();
@@ -6733,7 +7630,12 @@ function useSound(src, opts = {}) {
     source.buffer = bufferRef.current;
     source.loop = loopRef.current;
     source.connect(gain);
-    source.start();
+    const delay = playOpts?.delay;
+    if (delay && delay > 0) {
+      source.start(ctx.currentTime + delay);
+    } else {
+      source.start();
+    }
     source.onended = () => {
       sourceRef.current = null;
     };
@@ -6827,8 +7729,38 @@ function createAtlas(names, _columns) {
   });
   return atlas;
 }
+
+// src/utils/animationHelpers.ts
+function playClip(world, entityId, clipName) {
+  const anim = world.getComponent(entityId, "AnimationState");
+  if (anim) anim.currentClip = clipName;
+}
+function setAnimationState(world, entityId, stateName) {
+  const animator = world.getComponent(entityId, "Animator");
+  if (animator) {
+    animator.currentState = stateName;
+    animator._entered = false;
+  }
+}
+function setAnimatorParam(world, entityId, name, value) {
+  const animator = world.getComponent(entityId, "Animator");
+  if (animator) animator.params[name] = value;
+}
+
+// src/utils/prefab.ts
+import { memo } from "react";
+function definePrefab(name, defaults, render) {
+  const component = memo((props) => {
+    const merged = { ...defaults, ...props };
+    return render(merged);
+  });
+  component.displayName = name;
+  return component;
+}
 export {
+  AnimatedSprite,
   Animation,
+  Animator,
   AssetLoader,
   BoxCollider,
   Camera2D,
@@ -6858,30 +7790,42 @@ export {
   VirtualJoystick,
   World,
   arrive,
+  chromaticAberrationEffect,
   createAtlas,
   createCompoundCollider,
   createInputMap,
   createInputRecorder,
   createNineSlice,
   createPlayerInput,
+  createPostProcessStack,
+  createRenderLayerManager,
   createSprite,
   createTag,
+  createTimeline,
   createTimer,
   createTransform,
+  defaultLayers,
+  defineAnimations,
   definePlugin,
+  definePrefab,
   duck,
   findByTag,
   flee,
   getGroupVolume,
   globalInputContext,
   hotReloadPlugin,
+  mergeTileColliders,
   overlapBox,
   overlapCircle,
   patrol,
+  playClip,
   preloadManifest,
   raycast,
   raycastAll,
+  scanlineEffect,
   seek,
+  setAnimationState,
+  setAnimatorParam,
   setGroupMute,
   setGroupVolume,
   setMasterVolume,
@@ -6894,6 +7838,7 @@ export {
   useCircleEnter,
   useCircleExit,
   useCircleStay,
+  useCollidingWith,
   useCollisionEnter,
   useCollisionExit,
   useCollisionStay,
@@ -6918,12 +7863,15 @@ export {
   useKinematicBody,
   useLevelTransition,
   useLocalMultiplayer,
+  useObjectPool,
   usePathfinding,
   usePause,
   usePersistedBindings,
   usePlatformerController,
   usePlayerInput,
+  usePostProcess,
   usePreload,
+  useProfiler,
   useRestart,
   useSave,
   useSnapshot,
@@ -6932,6 +7880,8 @@ export {
   useTriggerEnter,
   useTriggerExit,
   useTriggerStay,
+  useTween,
   useVirtualInput,
+  vignetteEffect,
   wander
 };