@almadar/ui 5.85.0 → 5.87.0

package/dist/runtime/index.cjs

@@ -817,13 +817,13 @@ function useRenderInterpolation(options = {}) {
     const prevMap = /* @__PURE__ */ new Map();
     for (const e of prev.entities) prevMap.set(e.id, e);
     for (const c of curr.entities) {
-      const p2 = prevMap.get(c.id);
-      if (!p2) {
+      const p = prevMap.get(c.id);
+      if (!p) {
         out.set(c.id, { x: c.x, y: c.y });
       } else {
         out.set(c.id, {
-          x: p2.x + (c.x - p2.x) * alpha,
-          y: p2.y + (c.y - p2.y) * alpha
+          x: p.x + (c.x - p.x) * alpha,
+          y: p.y + (c.y - p.y) * alpha
         });
       }
     }
@@ -1135,12 +1135,12 @@ function kebabToPascal(name) {
   }).join("");
 }
 function loadLib(key, importer) {
-  let p2 = libPromises.get(key);
-  if (!p2) {
-    p2 = importer();
-    libPromises.set(key, p2);
+  let p = libPromises.get(key);
+  if (!p) {
+    p = importer();
+    libPromises.set(key, p);
   }
-  return p2;
+  return p;
 }
 function lazyFamilyIcon(libKey, importer, pick, fallbackName, family) {
   const Lazy = React95__namespace.default.lazy(async () => {
@@ -6394,28 +6394,28 @@ var init_ConfettiEffect = __esm({
           ),
           "aria-hidden": "true",
           children: [
-            particles.map((p2) => {
-              const rad = p2.angle * Math.PI / 180;
-              const tx = Math.cos(rad) * p2.distance;
-              const ty = Math.sin(rad) * p2.distance - 20;
+            particles.map((p) => {
+              const rad = p.angle * Math.PI / 180;
+              const tx = Math.cos(rad) * p.distance;
+              const ty = Math.sin(rad) * p.distance - 20;
               return /* @__PURE__ */ jsxRuntime.jsx(
                 Box,
                 {
                   className: "absolute rounded-sm",
                   style: {
-                    left: `${p2.left}%`,
+                    left: `${p.left}%`,
                     top: "50%",
-                    width: p2.size,
-                    height: p2.size,
-                    backgroundColor: p2.color,
-                    animation: `confetti-burst ${duration - p2.delay}ms ease-out ${p2.delay}ms forwards`,
+                    width: p.size,
+                    height: p.size,
+                    backgroundColor: p.color,
+                    animation: `confetti-burst ${duration - p.delay}ms ease-out ${p.delay}ms forwards`,
                     opacity: 0,
                     "--confetti-tx": `${tx}px`,
                     "--confetti-ty": `${ty}px`,
-                    "--confetti-rotate": `${p2.rotation}deg`
+                    "--confetti-rotate": `${p.rotation}deg`
                   }
                 },
-                p2.id
+                p.id
               );
             }),
             /* @__PURE__ */ jsxRuntime.jsx("style", { children: `
@@ -7326,8 +7326,8 @@ var init_AnimatedGraphic = __esm({
           const el = containerRef.current;
           if (!el || !strokeColor) return;
           const paths = el.querySelectorAll("path, line, polyline, polygon, circle, ellipse, rect");
-          paths.forEach((p2) => {
-            p2.style.stroke = strokeColor;
+          paths.forEach((p) => {
+            p.style.stroke = strokeColor;
           });
         }, [resolvedSvg, strokeColor]);
         React95.useEffect(() => {
@@ -7335,23 +7335,23 @@ var init_AnimatedGraphic = __esm({
           if (!el || !resolvedSvg) return;
           if (animation === "draw" || animation === "fill") {
             const paths = el.querySelectorAll("path, line, polyline, polygon, circle, ellipse, rect");
-            paths.forEach((p2) => {
-              if ("getTotalLength" in p2 && typeof p2.getTotalLength === "function") {
-                const len = p2.getTotalLength();
-                p2.style.strokeDasharray = `${len}`;
-                p2.style.strokeDashoffset = `${len}`;
+            paths.forEach((p) => {
+              if ("getTotalLength" in p && typeof p.getTotalLength === "function") {
+                const len = p.getTotalLength();
+                p.style.strokeDasharray = `${len}`;
+                p.style.strokeDashoffset = `${len}`;
               }
               if (animation === "fill") {
-                p2.style.fillOpacity = "0";
+                p.style.fillOpacity = "0";
               }
             });
           }
           if (animation === "morph") {
             const paths = el.querySelectorAll("path, circle, ellipse, rect, polygon");
-            paths.forEach((p2) => {
-              p2.style.transform = "scale(0)";
-              p2.style.transformOrigin = "center";
-              p2.style.opacity = "0";
+            paths.forEach((p) => {
+              p.style.transform = "scale(0)";
+              p.style.transformOrigin = "center";
+              p.style.opacity = "0";
             });
           }
         }, [resolvedSvg, animation]);
@@ -7456,14 +7456,8 @@ var init_TraitFrame = __esm({
 });
 
 // components/game/shared/effects.ts
-var EMPTY_EFFECT_STATE;
 var init_effects = __esm({
   "components/game/shared/effects.ts"() {
-    EMPTY_EFFECT_STATE = {
-      particles: [],
-      sequences: [],
-      overlays: []
-    };
   }
 });
 
@@ -7871,1021 +7865,12 @@ var init_spriteAnimation = __esm({
   }
 });
 
-// components/game/shared/combatPresets.ts
-function p(manifest, key) {
-  const particles = manifest.particles;
-  if (!particles) return [];
-  const val = particles[key];
-  if (Array.isArray(val)) return val.map((v) => `${manifest.baseUrl}/${v}`);
-  if (typeof val === "string") return [`${manifest.baseUrl}/${val}`];
-  return [];
-}
-function anim(manifest, key) {
-  const animations = manifest.animations;
-  if (!animations) return [];
-  const val = animations[key];
-  if (Array.isArray(val)) return val.map((v) => `${manifest.baseUrl}/${v}`);
-  return [];
-}
-function createCombatPresets(manifest) {
-  return {
-    // =====================================================================
-    // MELEE — slash (red) + dirt + scratch + flash sequence
-    // =====================================================================
-    melee: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "slash"),
-          count: 6,
-          originX,
-          originY,
-          spread: 8,
-          velocityMin: 40,
-          velocityMax: 120,
-          angleMin: -PI2 * 0.8,
-          angleMax: -PI2 * 0.2,
-          gravity: 0,
-          tint: { r: 255, g: 60, b: 40 },
-          scaleMin: 0.3,
-          scaleMax: 0.6,
-          lifetimeMin: 300,
-          lifetimeMax: 500,
-          fadeRate: -2.5
-        },
-        {
-          spriteUrls: p(manifest, "dirt"),
-          count: 4,
-          originX,
-          originY: originY + 10,
-          spread: 12,
-          velocityMin: 20,
-          velocityMax: 60,
-          angleMin: -PI2 * 0.9,
-          angleMax: -PI2 * 0.1,
-          gravity: 120,
-          tint: { r: 180, g: 140, b: 90 },
-          scaleMin: 0.15,
-          scaleMax: 0.3,
-          lifetimeMin: 400,
-          lifetimeMax: 700,
-          fadeRate: -1.8
-        },
-        {
-          spriteUrls: p(manifest, "scratch"),
-          count: 2,
-          originX,
-          originY,
-          spread: 5,
-          velocityMin: 10,
-          velocityMax: 30,
-          angleMin: -PI2 * 0.7,
-          angleMax: -PI2 * 0.3,
-          gravity: 0,
-          tint: { r: 255, g: 200, b: 150 },
-          scaleMin: 0.25,
-          scaleMax: 0.4,
-          lifetimeMin: 200,
-          lifetimeMax: 400,
-          fadeRate: -3
-        }
-      ];
-      const sequences = [];
-      const flashFrames = anim(manifest, "flash");
-      if (flashFrames.length > 0) {
-        sequences.push({
-          frameUrls: flashFrames,
-          originX,
-          originY,
-          frameDuration: 35,
-          scale: 0.4
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences,
-        overlays: [],
-        screenShake: 4,
-        screenFlash: null
-      };
-    },
-    // =====================================================================
-    // RANGED — muzzle + trace + smoke + explosion sequence
-    // =====================================================================
-    ranged: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "muzzle"),
-          count: 3,
-          originX,
-          originY,
-          spread: 4,
-          velocityMin: 60,
-          velocityMax: 150,
-          angleMin: -PI2 * 0.6,
-          angleMax: -PI2 * 0.4,
-          gravity: 0,
-          tint: { r: 255, g: 220, b: 100 },
-          scaleMin: 0.2,
-          scaleMax: 0.4,
-          lifetimeMin: 200,
-          lifetimeMax: 400,
-          fadeRate: -3
-        },
-        {
-          spriteUrls: p(manifest, "trace"),
-          count: 5,
-          originX,
-          originY,
-          spread: 3,
-          velocityMin: 100,
-          velocityMax: 200,
-          angleMin: -PI2 * 0.55,
-          angleMax: -PI2 * 0.45,
-          gravity: 0,
-          tint: { r: 255, g: 200, b: 80 },
-          scaleMin: 0.15,
-          scaleMax: 0.3,
-          lifetimeMin: 150,
-          lifetimeMax: 300,
-          fadeRate: -4
-        },
-        {
-          spriteUrls: p(manifest, "smoke").slice(0, 3),
-          count: 3,
-          originX,
-          originY: originY + 5,
-          spread: 6,
-          velocityMin: 10,
-          velocityMax: 30,
-          angleMin: -PI2 * 0.8,
-          angleMax: -PI2 * 0.2,
-          gravity: -20,
-          tint: { r: 200, g: 200, b: 200 },
-          scaleMin: 0.2,
-          scaleMax: 0.35,
-          lifetimeMin: 500,
-          lifetimeMax: 800,
-          fadeRate: -1.5
-        }
-      ];
-      const sequences = [];
-      const explosionFrames = anim(manifest, "smokeExplosion");
-      if (explosionFrames.length > 0) {
-        sequences.push({
-          frameUrls: explosionFrames,
-          originX,
-          originY,
-          frameDuration: 50,
-          scale: 0.35
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences,
-        overlays: [],
-        screenShake: 2,
-        screenFlash: null
-      };
-    },
-    // =====================================================================
-    // MAGIC — twirl (purple) + spark (purple) + star
-    // =====================================================================
-    magic: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "twirl"),
-          count: 5,
-          originX,
-          originY,
-          spread: 15,
-          velocityMin: 20,
-          velocityMax: 80,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: -30,
-          tint: { r: 180, g: 80, b: 255 },
-          scaleMin: 0.2,
-          scaleMax: 0.5,
-          lifetimeMin: 500,
-          lifetimeMax: 900,
-          fadeRate: -1.2,
-          blendMode: "lighter",
-          rotationSpeedMin: -4,
-          rotationSpeedMax: 4
-        },
-        {
-          spriteUrls: p(manifest, "spark"),
-          count: 8,
-          originX,
-          originY,
-          spread: 20,
-          velocityMin: 30,
-          velocityMax: 100,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: -15,
-          tint: { r: 200, g: 120, b: 255 },
-          scaleMin: 0.1,
-          scaleMax: 0.25,
-          lifetimeMin: 300,
-          lifetimeMax: 600,
-          fadeRate: -2,
-          blendMode: "lighter"
-        },
-        {
-          spriteUrls: p(manifest, "star"),
-          count: 4,
-          originX,
-          originY,
-          spread: 10,
-          velocityMin: 15,
-          velocityMax: 50,
-          angleMin: -PI2,
-          angleMax: 0,
-          gravity: -40,
-          tint: { r: 220, g: 180, b: 255 },
-          scaleMin: 0.15,
-          scaleMax: 0.3,
-          lifetimeMin: 600,
-          lifetimeMax: 1e3,
-          fadeRate: -1,
-          blendMode: "lighter"
-        }
-      ];
-      const overlays = [];
-      const circleUrls = p(manifest, "circle");
-      if (circleUrls.length > 0) {
-        overlays.push({
-          spriteUrl: circleUrls[0],
-          originX,
-          originY,
-          alpha: 0.5,
-          fadeRate: -0.6,
-          pulseAmplitude: 0.2,
-          pulseFrequency: 3,
-          scale: 0.5,
-          blendMode: "lighter",
-          lifetime: 1200
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences: [],
-        overlays,
-        screenShake: 0,
-        screenFlash: null
-      };
-    },
-    // =====================================================================
-    // HEAL — circle (green) + star (green) + light (green, pulse)
-    // =====================================================================
-    heal: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "circle"),
-          count: 6,
-          originX,
-          originY,
-          spread: 15,
-          velocityMin: 10,
-          velocityMax: 40,
-          angleMin: -PI2,
-          angleMax: -PI2 * 0.3,
-          gravity: -50,
-          tint: { r: 80, g: 255, b: 120 },
-          scaleMin: 0.15,
-          scaleMax: 0.35,
-          lifetimeMin: 600,
-          lifetimeMax: 1e3,
-          fadeRate: -0.8,
-          blendMode: "lighter"
-        },
-        {
-          spriteUrls: p(manifest, "star"),
-          count: 5,
-          originX,
-          originY,
-          spread: 12,
-          velocityMin: 15,
-          velocityMax: 50,
-          angleMin: -PI2 * 0.9,
-          angleMax: -PI2 * 0.1,
-          gravity: -60,
-          tint: { r: 100, g: 255, b: 140 },
-          scaleMin: 0.1,
-          scaleMax: 0.2,
-          lifetimeMin: 500,
-          lifetimeMax: 800,
-          fadeRate: -1.2,
-          blendMode: "lighter"
-        }
-      ];
-      const overlays = [];
-      const lightUrls = p(manifest, "light");
-      if (lightUrls.length > 0) {
-        overlays.push({
-          spriteUrl: lightUrls[0],
-          originX,
-          originY,
-          alpha: 0.6,
-          fadeRate: -0.4,
-          pulseAmplitude: 0.25,
-          pulseFrequency: 2.5,
-          scale: 0.6,
-          blendMode: "lighter",
-          lifetime: 1500
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences: [],
-        overlays,
-        screenShake: 0,
-        screenFlash: null
-      };
-    },
-    // =====================================================================
-    // DEFEND / SHIELD — star (blue) + circle (blue, pulse)
-    // =====================================================================
-    defend: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "star"),
-          count: 8,
-          originX,
-          originY,
-          spread: 18,
-          velocityMin: 10,
-          velocityMax: 35,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: 0,
-          tint: { r: 80, g: 160, b: 255 },
-          scaleMin: 0.12,
-          scaleMax: 0.25,
-          lifetimeMin: 600,
-          lifetimeMax: 1e3,
-          fadeRate: -0.8,
-          blendMode: "lighter",
-          rotationSpeedMin: -1,
-          rotationSpeedMax: 1
-        }
-      ];
-      const overlays = [];
-      const circleUrls = p(manifest, "circle");
-      if (circleUrls.length > 0) {
-        overlays.push({
-          spriteUrl: circleUrls[0],
-          originX,
-          originY,
-          alpha: 0.6,
-          fadeRate: -0.3,
-          pulseAmplitude: 0.2,
-          pulseFrequency: 2,
-          scale: 0.6,
-          blendMode: "lighter",
-          lifetime: 1500
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences: [],
-        overlays,
-        screenShake: 0,
-        screenFlash: null
-      };
-    },
-    // shield aliases to defend
-    shield: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "star"),
-          count: 10,
-          originX,
-          originY,
-          spread: 20,
-          velocityMin: 8,
-          velocityMax: 30,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: 0,
-          tint: { r: 60, g: 180, b: 255 },
-          scaleMin: 0.1,
-          scaleMax: 0.22,
-          lifetimeMin: 700,
-          lifetimeMax: 1200,
-          fadeRate: -0.7,
-          blendMode: "lighter",
-          rotationSpeedMin: -0.8,
-          rotationSpeedMax: 0.8
-        }
-      ];
-      const overlays = [];
-      const circleUrls = p(manifest, "circle");
-      if (circleUrls.length > 0) {
-        overlays.push({
-          spriteUrl: circleUrls[0],
-          originX,
-          originY,
-          alpha: 0.7,
-          fadeRate: -0.25,
-          pulseAmplitude: 0.25,
-          pulseFrequency: 1.8,
-          scale: 0.7,
-          blendMode: "lighter",
-          lifetime: 1800
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences: [],
-        overlays,
-        screenShake: 0,
-        screenFlash: null
-      };
-    },
-    // =====================================================================
-    // HIT — spark (orange) + flash (5 frames) + screen shake/flash
-    // =====================================================================
-    hit: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "spark"),
-          count: 10,
-          originX,
-          originY,
-          spread: 8,
-          velocityMin: 50,
-          velocityMax: 150,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: 80,
-          tint: { r: 255, g: 180, b: 50 },
-          scaleMin: 0.08,
-          scaleMax: 0.2,
-          lifetimeMin: 200,
-          lifetimeMax: 500,
-          fadeRate: -2.5
-        }
-      ];
-      const sequences = [];
-      const flashFrames = anim(manifest, "flash");
-      if (flashFrames.length > 0) {
-        sequences.push({
-          frameUrls: flashFrames.slice(0, 5),
-          originX,
-          originY,
-          frameDuration: 40,
-          scale: 0.3
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences,
-        overlays: [],
-        screenShake: 3,
-        screenFlash: { r: 255, g: 50, b: 50, duration: 150 }
-      };
-    },
-    // critical aliases to hit with bigger shake
-    critical: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "flame"),
-          count: 8,
-          originX,
-          originY,
-          spread: 12,
-          velocityMin: 60,
-          velocityMax: 180,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: 60,
-          tint: { r: 255, g: 120, b: 30 },
-          scaleMin: 0.15,
-          scaleMax: 0.4,
-          lifetimeMin: 300,
-          lifetimeMax: 600,
-          fadeRate: -2
-        },
-        {
-          spriteUrls: p(manifest, "spark"),
-          count: 12,
-          originX,
-          originY,
-          spread: 10,
-          velocityMin: 80,
-          velocityMax: 200,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: 100,
-          tint: { r: 255, g: 200, b: 60 },
-          scaleMin: 0.06,
-          scaleMax: 0.18,
-          lifetimeMin: 200,
-          lifetimeMax: 400,
-          fadeRate: -3
-        }
-      ];
-      const sequences = [];
-      const flashFrames = anim(manifest, "flash");
-      if (flashFrames.length > 0) {
-        sequences.push({
-          frameUrls: flashFrames,
-          originX,
-          originY,
-          frameDuration: 30,
-          scale: 0.5
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences,
-        overlays: [],
-        screenShake: 6,
-        screenFlash: { r: 255, g: 80, b: 0, duration: 200 }
-      };
-    },
-    // =====================================================================
-    // DEATH — dirt (gray) + explosion + black smoke + scorch (ground)
-    // =====================================================================
-    death: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "dirt"),
-          count: 8,
-          originX,
-          originY,
-          spread: 10,
-          velocityMin: 30,
-          velocityMax: 100,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: 100,
-          tint: { r: 140, g: 140, b: 140 },
-          scaleMin: 0.15,
-          scaleMax: 0.35,
-          lifetimeMin: 500,
-          lifetimeMax: 900,
-          fadeRate: -1.2
-        }
-      ];
-      const sequences = [];
-      const explosionFrames = anim(manifest, "explosion");
-      if (explosionFrames.length > 0) {
-        sequences.push({
-          frameUrls: explosionFrames,
-          originX,
-          originY,
-          frameDuration: 60,
-          scale: 0.5
-        });
-      }
-      const blackSmokeFrames = anim(manifest, "blackSmoke");
-      if (blackSmokeFrames.length > 0) {
-        sequences.push({
-          frameUrls: blackSmokeFrames,
-          originX,
-          originY: originY - 10,
-          frameDuration: 50,
-          scale: 0.4,
-          alpha: 0.7
-        });
-      }
-      const overlays = [];
-      const scorchUrls = p(manifest, "scorch");
-      if (scorchUrls.length > 0) {
-        overlays.push({
-          spriteUrl: scorchUrls[0],
-          originX,
-          originY: originY + 10,
-          alpha: 0.6,
-          fadeRate: -0.15,
-          scale: 0.4,
-          lifetime: 4e3
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences,
-        overlays,
-        screenShake: 0,
-        screenFlash: null
-      };
-    },
-    // =====================================================================
-    // BUFF — star (gold) + symbol + flare (gold, pulse)
-    // =====================================================================
-    buff: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "star"),
-          count: 6,
-          originX,
-          originY,
-          spread: 15,
-          velocityMin: 15,
-          velocityMax: 50,
-          angleMin: -PI2,
-          angleMax: 0,
-          gravity: -30,
-          tint: { r: 255, g: 215, b: 50 },
-          scaleMin: 0.12,
-          scaleMax: 0.25,
-          lifetimeMin: 600,
-          lifetimeMax: 1e3,
-          fadeRate: -0.8,
-          blendMode: "lighter"
-        },
-        {
-          spriteUrls: p(manifest, "symbol"),
-          count: 2,
-          originX,
-          originY: originY - 10,
-          spread: 8,
-          velocityMin: 5,
-          velocityMax: 20,
-          angleMin: -PI2 * 0.7,
-          angleMax: -PI2 * 0.3,
-          gravity: -20,
-          tint: { r: 255, g: 230, b: 100 },
-          scaleMin: 0.2,
-          scaleMax: 0.35,
-          lifetimeMin: 800,
-          lifetimeMax: 1200,
-          fadeRate: -0.6,
-          blendMode: "lighter"
-        }
-      ];
-      const overlays = [];
-      const flareUrls = p(manifest, "flare");
-      if (flareUrls.length > 0) {
-        overlays.push({
-          spriteUrl: flareUrls[0],
-          originX,
-          originY,
-          alpha: 0.5,
-          fadeRate: -0.3,
-          pulseAmplitude: 0.3,
-          pulseFrequency: 2,
-          scale: 0.5,
-          blendMode: "lighter",
-          lifetime: 1500
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences: [],
-        overlays,
-        screenShake: 0,
-        screenFlash: null
-      };
-    },
-    // =====================================================================
-    // DEBUFF — scorch (dark) + smoke (purple tint)
-    // =====================================================================
-    debuff: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "scorch"),
-          count: 4,
-          originX,
-          originY,
-          spread: 12,
-          velocityMin: 15,
-          velocityMax: 40,
-          angleMin: -PI2,
-          angleMax: 0,
-          gravity: -20,
-          tint: { r: 120, g: 40, b: 160 },
-          scaleMin: 0.15,
-          scaleMax: 0.3,
-          lifetimeMin: 500,
-          lifetimeMax: 800,
-          fadeRate: -1
-        },
-        {
-          spriteUrls: p(manifest, "smoke").slice(0, 3),
-          count: 3,
-          originX,
-          originY,
-          spread: 10,
-          velocityMin: 8,
-          velocityMax: 25,
-          angleMin: -PI2 * 0.8,
-          angleMax: -PI2 * 0.2,
-          gravity: -15,
-          tint: { r: 100, g: 50, b: 140 },
-          scaleMin: 0.2,
-          scaleMax: 0.35,
-          lifetimeMin: 600,
-          lifetimeMax: 1e3,
-          fadeRate: -0.8
-        }
-      ];
-      const overlays = [];
-      const circleUrls = p(manifest, "circle");
-      if (circleUrls.length > 0) {
-        overlays.push({
-          spriteUrl: circleUrls[0],
-          originX,
-          originY,
-          alpha: 0.4,
-          fadeRate: -0.4,
-          pulseAmplitude: 0.15,
-          pulseFrequency: 2,
-          scale: 0.45,
-          lifetime: 1200
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences: [],
-        overlays,
-        screenShake: 0,
-        screenFlash: null
-      };
-    },
-    // =====================================================================
-    // AOE — explosion (large) + flame + spark (radial) + screen shake
-    // =====================================================================
-    aoe: (originX, originY) => {
-      const particles = [
-        {
-          spriteUrls: p(manifest, "flame"),
-          count: 10,
-          originX,
-          originY,
-          spread: 20,
-          velocityMin: 40,
-          velocityMax: 140,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: 40,
-          tint: { r: 255, g: 140, b: 30 },
-          scaleMin: 0.2,
-          scaleMax: 0.5,
-          lifetimeMin: 400,
-          lifetimeMax: 800,
-          fadeRate: -1.5
-        },
-        {
-          spriteUrls: p(manifest, "spark"),
-          count: 15,
-          originX,
-          originY,
-          spread: 15,
-          velocityMin: 60,
-          velocityMax: 200,
-          angleMin: 0,
-          angleMax: PI2 * 2,
-          gravity: 60,
-          tint: { r: 255, g: 180, b: 60 },
-          scaleMin: 0.06,
-          scaleMax: 0.15,
-          lifetimeMin: 200,
-          lifetimeMax: 500,
-          fadeRate: -2.5
-        }
-      ];
-      const sequences = [];
-      const explosionFrames = anim(manifest, "explosion");
-      if (explosionFrames.length > 0) {
-        sequences.push({
-          frameUrls: explosionFrames,
-          originX,
-          originY,
-          frameDuration: 50,
-          scale: 0.6
-        });
-      }
-      return {
-        particles: particles.filter((pc) => pc.spriteUrls.length > 0),
-        sequences,
-        overlays: [],
-        screenShake: 5,
-        screenFlash: { r: 255, g: 160, b: 0, duration: 180 }
-      };
-    }
-  };
-}
-var PI2;
-var init_combatPresets = __esm({
-  "components/game/shared/combatPresets.ts"() {
-    PI2 = Math.PI;
-  }
-});
-
-// components/game/shared/canvasEffects.ts
-function getOffscreenCtx(w, h) {
-  if (!_offscreen) {
-    if (typeof OffscreenCanvas !== "undefined") {
-      _offscreen = new OffscreenCanvas(w, h);
-    } else {
-      _offscreen = document.createElement("canvas");
-    }
-  }
-  if (_offscreen.width < w) _offscreen.width = w;
-  if (_offscreen.height < h) _offscreen.height = h;
-  if (!_offCtx) {
-    _offCtx = _offscreen.getContext("2d");
-  }
-  return _offCtx;
-}
-function drawTintedImage(ctx, img, x, y, w, h, tint, alpha, blendMode = "source-over") {
-  if (w <= 0 || h <= 0) return;
-  const oc = getOffscreenCtx(w, h);
-  oc.clearRect(0, 0, w, h);
-  oc.globalCompositeOperation = "source-over";
-  oc.drawImage(img, 0, 0, w, h);
-  oc.globalCompositeOperation = "source-atop";
-  oc.fillStyle = `rgb(${tint.r}, ${tint.g}, ${tint.b})`;
-  oc.fillRect(0, 0, w, h);
-  const prevAlpha = ctx.globalAlpha;
-  const prevBlend = ctx.globalCompositeOperation;
-  ctx.globalAlpha = alpha;
-  ctx.globalCompositeOperation = blendMode;
-  ctx.drawImage(_offscreen, 0, 0, w, h, x, y, w, h);
-  ctx.globalAlpha = prevAlpha;
-  ctx.globalCompositeOperation = prevBlend;
-}
-function randRange(min, max) {
-  return min + Math.random() * (max - min);
-}
-function spawnParticles(config, animTime) {
-  const particles = [];
-  for (let i = 0; i < config.count; i++) {
-    const angle = randRange(config.angleMin, config.angleMax);
-    const speed = randRange(config.velocityMin, config.velocityMax);
-    const spriteUrl = config.spriteUrls[Math.floor(Math.random() * config.spriteUrls.length)];
-    particles.push({
-      spriteUrl,
-      x: config.originX + randRange(-config.spread, config.spread),
-      y: config.originY + randRange(-config.spread, config.spread),
-      vx: Math.cos(angle) * speed,
-      vy: Math.sin(angle) * speed,
-      gravity: config.gravity,
-      rotation: Math.random() * Math.PI * 2,
-      rotationSpeed: randRange(config.rotationSpeedMin ?? -2, config.rotationSpeedMax ?? 2),
-      scale: randRange(config.scaleMin, config.scaleMax),
-      scaleSpeed: config.scaleSpeed ?? 0,
-      alpha: config.alpha ?? 1,
-      fadeRate: config.fadeRate ?? -1.5,
-      tint: { ...config.tint },
-      blendMode: config.blendMode ?? "source-over",
-      spawnTime: animTime,
-      lifetime: randRange(config.lifetimeMin, config.lifetimeMax)
-    });
-  }
-  return particles;
-}
-function spawnSequence(config, animTime) {
-  return {
-    frameUrls: config.frameUrls,
-    x: config.originX,
-    y: config.originY,
-    frameDuration: config.frameDuration,
-    startTime: animTime,
-    loop: config.loop ?? false,
-    scale: config.scale ?? 1,
-    tint: config.tint ?? null,
-    alpha: config.alpha ?? 1,
-    blendMode: config.blendMode ?? "source-over"
-  };
-}
-function spawnOverlay(config, animTime) {
-  return {
-    spriteUrl: config.spriteUrl,
-    x: config.originX,
-    y: config.originY,
-    alpha: config.alpha ?? 0.8,
-    fadeRate: config.fadeRate ?? -0.5,
-    pulseAmplitude: config.pulseAmplitude ?? 0,
-    pulseFrequency: config.pulseFrequency ?? 2,
-    scale: config.scale ?? 1,
-    blendMode: config.blendMode ?? "source-over",
-    spawnTime: animTime,
-    lifetime: config.lifetime ?? 2e3
-  };
-}
-function updateEffectState(state, animTime, deltaMs) {
-  const dt = deltaMs / 1e3;
-  const particles = state.particles.map((p2) => ({
-    ...p2,
-    x: p2.x + p2.vx * dt,
-    y: p2.y + p2.vy * dt,
-    vy: p2.vy + p2.gravity * dt,
-    rotation: p2.rotation + p2.rotationSpeed * dt,
-    scale: Math.max(0, p2.scale + p2.scaleSpeed * dt),
-    alpha: Math.max(0, p2.alpha + p2.fadeRate * dt)
-  })).filter((p2) => p2.alpha > 0.01 && animTime - p2.spawnTime < p2.lifetime);
-  const sequences = state.sequences.filter((s) => {
-    const elapsed = animTime - s.startTime;
-    const totalDuration = s.frameUrls.length * s.frameDuration;
-    return s.loop || elapsed < totalDuration;
-  });
-  const overlays = state.overlays.map((o) => ({
-    ...o,
-    alpha: Math.max(0, o.alpha + o.fadeRate * dt)
-  })).filter((o) => o.alpha > 0.01 && animTime - o.spawnTime < o.lifetime);
-  return { particles, sequences, overlays };
-}
-function drawEffectState(ctx, state, animTime, getImage) {
-  for (const o of state.overlays) {
-    const img = getImage(o.spriteUrl);
-    if (!img) continue;
-    let alpha = o.alpha;
-    if (o.pulseAmplitude > 0) {
-      const elapsed = (animTime - o.spawnTime) / 1e3;
-      alpha += Math.sin(elapsed * o.pulseFrequency * Math.PI * 2) * o.pulseAmplitude;
-      alpha = Math.max(0, Math.min(1, alpha));
-    }
-    const w = img.naturalWidth * o.scale;
-    const h = img.naturalHeight * o.scale;
-    const prevAlpha = ctx.globalAlpha;
-    const prevBlend = ctx.globalCompositeOperation;
-    ctx.globalAlpha = alpha;
-    ctx.globalCompositeOperation = o.blendMode;
-    ctx.drawImage(img, o.x - w / 2, o.y - h / 2, w, h);
-    ctx.globalAlpha = prevAlpha;
-    ctx.globalCompositeOperation = prevBlend;
-  }
-  for (const s of state.sequences) {
-    const elapsed = animTime - s.startTime;
-    let frameIndex = Math.floor(elapsed / s.frameDuration);
-    if (s.loop) {
-      frameIndex = frameIndex % s.frameUrls.length;
-    } else if (frameIndex >= s.frameUrls.length) {
-      continue;
-    }
-    const img = getImage(s.frameUrls[frameIndex]);
-    if (!img) continue;
-    const w = img.naturalWidth * s.scale;
-    const h = img.naturalHeight * s.scale;
-    if (s.tint) {
-      drawTintedImage(ctx, img, s.x - w / 2, s.y - h / 2, w, h, s.tint, s.alpha, s.blendMode);
-    } else {
-      const prevAlpha = ctx.globalAlpha;
-      const prevBlend = ctx.globalCompositeOperation;
-      ctx.globalAlpha = s.alpha;
-      ctx.globalCompositeOperation = s.blendMode;
-      ctx.drawImage(img, s.x - w / 2, s.y - h / 2, w, h);
-      ctx.globalAlpha = prevAlpha;
-      ctx.globalCompositeOperation = prevBlend;
-    }
-  }
-  for (const p2 of state.particles) {
-    const img = getImage(p2.spriteUrl);
-    if (!img) continue;
-    const w = img.naturalWidth * p2.scale;
-    const h = img.naturalHeight * p2.scale;
-    ctx.save();
-    ctx.translate(p2.x, p2.y);
-    ctx.rotate(p2.rotation);
-    drawTintedImage(ctx, img, -w / 2, -h / 2, w, h, p2.tint, p2.alpha, p2.blendMode);
-    ctx.restore();
-  }
-}
-function hasActiveEffects(state) {
-  return state.particles.length > 0 || state.sequences.length > 0 || state.overlays.length > 0;
-}
-function getAllEffectSpriteUrls(manifest) {
-  const urls = [];
-  const base = manifest.baseUrl;
-  if (manifest.particles) {
-    for (const value of Object.values(manifest.particles)) {
-      if (Array.isArray(value)) {
-        value.forEach((v) => urls.push(`${base}/${v}`));
-      } else if (typeof value === "string") {
-        urls.push(`${base}/${value}`);
-      }
-    }
-  }
-  if (manifest.animations) {
-    for (const frames of Object.values(manifest.animations)) {
-      if (Array.isArray(frames)) {
-        frames.forEach((f3) => urls.push(`${base}/${f3}`));
-      }
-    }
-  }
-  return urls;
-}
-var _offscreen, _offCtx;
-var init_canvasEffects = __esm({
-  "components/game/shared/canvasEffects.ts"() {
-    _offscreen = null;
-    _offCtx = null;
-  }
-});
-
 // components/game/shared/index.ts
 var init_shared = __esm({
   "components/game/shared/index.ts"() {
     init_effects();
     init_boardEntity();
     init_makeAsset();
-    init_combatPresets();
-    init_canvasEffects();
   }
 });
 function GameIcon({ assetUrl, icon, size = "md", alt, className }) {
@@ -11612,8 +10597,8 @@ function Canvas2D({
     if (isFree) return 0;
     return (gridHeight - 1) * (scaledTileWidth / 2);
   }, [isFree, gridHeight, scaledTileWidth]);
-  const validMoveSet = React95.useMemo(() => new Set(validMoves.map((p2) => `${p2.x},${p2.y}`)), [validMoves]);
-  const attackTargetSet = React95.useMemo(() => new Set(attackTargets.map((p2) => `${p2.x},${p2.y}`)), [attackTargets]);
+  const validMoveSet = React95.useMemo(() => new Set(validMoves.map((p) => `${p.x},${p.y}`)), [validMoves]);
+  const attackTargetSet = React95.useMemo(() => new Set(attackTargets.map((p) => `${p.x},${p.y}`)), [attackTargets]);
   const spriteUrls = React95.useMemo(() => {
     const urls = [];
     for (const tile of sortedTiles) {
@@ -12330,264 +11315,6 @@ var init_Canvas2D = __esm({
     Canvas2D.displayName = "Canvas2D";
   }
 });
-function CanvasEffectEngine({
-  actionType,
-  x,
-  y,
-  duration = 2e3,
-  intensity = 1,
-  onComplete,
-  className,
-  assetManifest,
-  width = 400,
-  height = 300
-}) {
-  const canvasRef = React95.useRef(null);
-  const stateRef = React95.useRef({ ...EMPTY_EFFECT_STATE });
-  const lastTimeRef = React95.useRef(0);
-  const rafRef = React95.useRef(0);
-  const imageCacheRef = React95.useRef(/* @__PURE__ */ new Map());
-  const [shakeOffset, setShakeOffset] = React95.useState({ x: 0, y: 0 });
-  const [flash, setFlash] = React95.useState(null);
-  const shakeRef = React95.useRef({ x: 0, y: 0, intensity: 0 });
-  const presets = React95.useMemo(() => createCombatPresets(assetManifest), [assetManifest]);
-  const spriteUrls = React95.useMemo(() => getAllEffectSpriteUrls(assetManifest), [assetManifest]);
-  React95.useEffect(() => {
-    const cache = imageCacheRef.current;
-    for (const url of spriteUrls) {
-      if (!cache.has(url)) {
-        const img = new Image();
-        img.crossOrigin = "anonymous";
-        img.src = url;
-        cache.set(url, img);
-      }
-    }
-  }, [spriteUrls]);
-  const getImage = React95.useCallback((url) => {
-    const img = imageCacheRef.current.get(url);
-    return img?.complete ? img : void 0;
-  }, []);
-  React95.useEffect(() => {
-    const now2 = performance.now();
-    const effectX = x || width / 2;
-    const effectY = y || height / 2;
-    const preset = presets[actionType](effectX, effectY);
-    const state = stateRef.current;
-    for (const emitter of preset.particles) {
-      const scaledEmitter = { ...emitter, count: Math.round(emitter.count * intensity) };
-      state.particles.push(...spawnParticles(scaledEmitter, now2));
-    }
-    for (const seqConfig of preset.sequences) {
-      state.sequences.push(spawnSequence(seqConfig, now2));
-    }
-    for (const ovConfig of preset.overlays) {
-      state.overlays.push(spawnOverlay(ovConfig, now2));
-    }
-    if (preset.screenShake > 0) {
-      shakeRef.current.intensity = preset.screenShake * intensity;
-    }
-    if (preset.screenFlash) {
-      const { r, g, b, duration: flashDur } = preset.screenFlash;
-      setFlash({ color: `rgb(${r}, ${g}, ${b})`, alpha: 0.3 });
-      setTimeout(() => setFlash(null), flashDur);
-    }
-    const timer = setTimeout(() => {
-      onComplete?.();
-    }, duration);
-    return () => clearTimeout(timer);
-  }, []);
-  React95.useEffect(() => {
-    const canvas = canvasRef.current;
-    if (!canvas) return;
-    const ctx = canvas.getContext("2d");
-    if (!ctx) return;
-    function loop(animTime) {
-      const delta = lastTimeRef.current > 0 ? animTime - lastTimeRef.current : 16;
-      lastTimeRef.current = animTime;
-      stateRef.current = updateEffectState(stateRef.current, animTime, delta);
-      if (shakeRef.current.intensity > 0.2) {
-        const i = shakeRef.current.intensity;
-        shakeRef.current.x = (Math.random() - 0.5) * i * 2;
-        shakeRef.current.y = (Math.random() - 0.5) * i * 2;
-        shakeRef.current.intensity *= 0.85;
-        setShakeOffset({ x: shakeRef.current.x, y: shakeRef.current.y });
-      } else if (shakeRef.current.intensity > 0) {
-        shakeRef.current = { x: 0, y: 0, intensity: 0 };
-        setShakeOffset({ x: 0, y: 0 });
-      }
-      ctx.clearRect(0, 0, width, height);
-      drawEffectState(ctx, stateRef.current, animTime, getImage);
-      if (hasActiveEffects(stateRef.current)) {
-        rafRef.current = requestAnimationFrame(loop);
-      }
-    }
-    rafRef.current = requestAnimationFrame(loop);
-    return () => cancelAnimationFrame(rafRef.current);
-  }, [width, height, getImage]);
-  const shakeStyle = shakeOffset.x !== 0 || shakeOffset.y !== 0 ? { transform: `translate(${shakeOffset.x}px, ${shakeOffset.y}px)` } : {};
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    Box,
-    {
-      className: cn("absolute inset-0 pointer-events-none z-10", className),
-      style: shakeStyle,
-      children: [
-        flash && /* @__PURE__ */ jsxRuntime.jsx(
-          Box,
-          {
-            className: "absolute inset-0 z-20 pointer-events-none rounded-container",
-            style: { backgroundColor: flash.color, opacity: flash.alpha }
-          }
-        ),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          "canvas",
-          {
-            ref: canvasRef,
-            width,
-            height,
-            className: "absolute inset-0 w-full h-full",
-            style: { imageRendering: "pixelated" }
-          }
-        )
-      ]
-    }
-  );
-}
-function EmojiEffect({
-  actionType,
-  x,
-  y,
-  duration = 800,
-  intensity = 1,
-  onComplete,
-  className,
-  effectSpriteUrl,
-  assetBaseUrl
-}) {
-  const [visible, setVisible] = React95.useState(true);
-  const [phase, setPhase] = React95.useState("enter");
-  React95.useEffect(() => {
-    const enterTimer = setTimeout(() => setPhase("active"), 100);
-    const exitTimer = setTimeout(() => setPhase("exit"), duration * 0.7);
-    const doneTimer = setTimeout(() => {
-      setVisible(false);
-      onComplete?.();
-    }, duration);
-    return () => {
-      clearTimeout(enterTimer);
-      clearTimeout(exitTimer);
-      clearTimeout(doneTimer);
-    };
-  }, [duration, onComplete]);
-  if (!visible) return null;
-  const config = ACTION_EMOJI[actionType] ?? ACTION_EMOJI.melee;
-  const scaleVal = phase === "enter" ? 0.3 : phase === "active" ? intensity : 0.5;
-  const opacity = phase === "exit" ? 0 : 1;
-  const resolvedSpriteUrl = effectSpriteUrl ? effectSpriteUrl.startsWith("http") || effectSpriteUrl.startsWith("/") ? effectSpriteUrl : assetBaseUrl ? `${assetBaseUrl.replace(/\/$/, "")}/${effectSpriteUrl}` : effectSpriteUrl : void 0;
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    Box,
-    {
-      className: cn(
-        "fixed pointer-events-none z-50 flex items-center justify-center",
-        "transition-all ease-out",
-        className
-      ),
-      style: {
-        left: x,
-        top: y,
-        transform: `translate(-50%, -50%) scale(${scaleVal})`,
-        opacity,
-        transitionDuration: phase === "enter" ? "100ms" : "300ms"
-      },
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx(
-          Box,
-          {
-            className: "absolute rounded-pill animate-ping",
-            style: {
-              width: 48 * intensity,
-              height: 48 * intensity,
-              backgroundColor: config.color,
-              opacity: 0.25
-            }
-          }
-        ),
-        resolvedSpriteUrl ? /* @__PURE__ */ jsxRuntime.jsx(
-          "img",
-          {
-            src: resolvedSpriteUrl,
-            alt: config.label,
-            className: "relative drop-shadow-lg",
-            style: {
-              width: `${3 * intensity}rem`,
-              height: `${3 * intensity}rem`,
-              objectFit: "contain",
-              imageRendering: "pixelated"
-            }
-          }
-        ) : /* @__PURE__ */ jsxRuntime.jsx(
-          "span",
-          {
-            className: "relative text-3xl drop-shadow-lg",
-            style: { fontSize: `${2 * intensity}rem` },
-            role: "img",
-            "aria-label": config.label,
-            children: config.emoji
-          }
-        )
-      ]
-    }
-  );
-}
-function CanvasEffect({
-  effectSpriteUrl,
-  assetBaseUrl,
-  ...props
-}) {
-  const eventBus = useEventBus();
-  const mergedProps = { effectSpriteUrl, assetBaseUrl, ...props };
-  const { completeEvent, onComplete, ...rest } = mergedProps;
-  const handleComplete = React95.useCallback(() => {
-    if (completeEvent) eventBus.emit(`UI:${completeEvent}`, {});
-    onComplete?.();
-  }, [completeEvent, eventBus, onComplete]);
-  const enhancedProps = { ...rest, onComplete: handleComplete };
-  if (rest.assetManifest) {
-    return /* @__PURE__ */ jsxRuntime.jsx(CanvasEffectEngine, { ...enhancedProps, assetManifest: rest.assetManifest });
-  }
-  return /* @__PURE__ */ jsxRuntime.jsx(EmojiEffect, { ...enhancedProps });
-}
-var ACTION_EMOJI;
-var init_CanvasEffect = __esm({
-  "components/game/2d/organisms/CanvasEffect.tsx"() {
-    "use client";
-    init_cn();
-    init_useEventBus();
-    init_Box();
-    init_effects();
-    init_canvasEffects();
-    init_combatPresets();
-    ACTION_EMOJI = {
-      melee: { emoji: "\u2694\uFE0F", color: "var(--color-error)", label: "Slash" },
-      ranged: { emoji: "\u{1F3F9}", color: "var(--color-warning)", label: "Arrow" },
-      magic: { emoji: "\u2728", color: "var(--color-primary)", label: "Spell" },
-      heal: { emoji: "\u{1F49A}", color: "var(--color-success)", label: "Heal" },
-      buff: { emoji: "\u2B06\uFE0F", color: "var(--color-info)", label: "Buff" },
-      debuff: { emoji: "\u2B07\uFE0F", color: "var(--color-warning)", label: "Debuff" },
-      shield: { emoji: "\u{1F6E1}\uFE0F", color: "var(--color-info)", label: "Shield" },
-      aoe: { emoji: "\u{1F4A5}", color: "var(--color-error)", label: "Explosion" },
-      critical: { emoji: "\u{1F525}", color: "var(--color-error)", label: "Critical" },
-      defend: { emoji: "\u{1F6E1}\uFE0F", color: "var(--color-info)", label: "Defend" },
-      hit: { emoji: "\u{1F4A5}", color: "var(--color-error)", label: "Hit" },
-      death: { emoji: "\u{1F480}", color: "var(--color-error)", label: "Death" }
-    };
-    CanvasEffect.displayName = "CanvasEffect";
-  }
-});
-var init_useCanvasEffects = __esm({
-  "components/game/shared/hooks/useCanvasEffects.ts"() {
-    "use client";
-  }
-});
 var init_useGameAudio = __esm({
   "components/game/shared/hooks/useGameAudio.ts"() {
     "use client";
@@ -15207,7 +13934,7 @@ function NegotiatorBoard({
   React95.useEffect(() => {
     if (currentRound > prevRoundRef.current && lastPlayerAction) {
       const opponentPayoffEntry = payoffMatrix.find(
-        (p2) => p2.playerAction === lastPlayerAction && p2.opponentAction === lastOpponentAction
+        (p) => p.playerAction === lastPlayerAction && p.opponentAction === lastOpponentAction
       );
       setHistory((prev) => [
         ...prev,
@@ -15493,14 +14220,14 @@ function SimulationCanvas({
       const ctx = canvas.getContext("2d");
       if (!ctx) return;
       const bodies = bodiesRef.current;
-      const p2 = presetRef.current;
+      const p = presetRef.current;
       const w = widthRef.current;
       const h = heightRef.current;
       ctx.clearRect(0, 0, w, h);
-      ctx.fillStyle = p2.backgroundColor ?? "#1a1a2e";
+      ctx.fillStyle = p.backgroundColor ?? "#1a1a2e";
       ctx.fillRect(0, 0, w, h);
-      if (p2.constraints) {
-        for (const c of p2.constraints) {
+      if (p.constraints) {
+        for (const c of p.constraints) {
           const a = bodies[c.bodyA];
           const b = bodies[c.bodyB];
           if (a && b) {
@@ -15523,7 +14250,7 @@ function SimulationCanvas({
         ctx.arc(pos.x, pos.y, body.radius, 0, Math.PI * 2);
         ctx.fillStyle = body.color ?? "#e94560";
         ctx.fill();
-        if (p2.showVelocity) {
+        if (p.showVelocity) {
           ctx.beginPath();
           ctx.moveTo(pos.x, pos.y);
           ctx.lineTo(pos.x + body.vx * 0.1, pos.y + body.vy * 0.1);
@@ -15782,7 +14509,6 @@ var init_GameShell = __esm({
 var init_molecules = __esm({
   "components/game/2d/molecules/index.ts"() {
     init_shared();
-    init_useCanvasEffects();
     init_puzzleObject();
   }
 });
@@ -15823,8 +14549,8 @@ function shapeBounds(shape) {
     case "polygon":
       if (!shape.points || shape.points.length === 0) return null;
       {
-        const xs = shape.points.map((p2) => p2.x);
-        const ys = shape.points.map((p2) => p2.y);
+        const xs = shape.points.map((p) => p.x);
+        const ys = shape.points.map((p) => p.y);
         const minX = Math.min(...xs);
         const minY = Math.min(...ys);
         return {
@@ -15950,13 +14676,13 @@ function drawShape(ctx, shape, width, height) {
     }
     case "path": {
       if (!shape.path) break;
-      const p2 = new Path2D(shape.path);
+      const p = new Path2D(shape.path);
       if (fill) {
         ctx.fillStyle = fill;
-        ctx.fill(p2);
+        ctx.fill(p);
       }
       ctx.strokeStyle = stroke;
-      ctx.stroke(p2);
+      ctx.stroke(p);
       break;
     }
     case "text": {
@@ -21416,7 +20142,7 @@ function renderStateMachineToDomData(stateMachine, options = {}, config = DEFAUL
   }
   let domOutputs;
   if (outputs.length > 0) {
-    const maxX = Math.max(...Object.values(positions).map((p2) => p2.x));
+    const maxX = Math.max(...Object.values(positions).map((p) => p.x));
     const maxOutputLength = Math.max(...outputs.map((o) => o.length));
     const boxWidth = Math.max(200, maxOutputLength * 7 + 30);
     const lineHeight = 22;
@@ -22398,7 +21124,7 @@ var init_BookViewer = __esm({
   }
 });
 function BoxPattern({
-  p: p2,
+  p,
   m,
   bg = "transparent",
   border = false,
@@ -22411,7 +21137,7 @@ function BoxPattern({
   return /* @__PURE__ */ jsxRuntime.jsx(
     Box,
     {
-      padding: p2,
+      padding: p,
       margin: m,
       bg,
       border,
@@ -24113,10 +22839,10 @@ var init_Chart = __esm({
         const set = [];
         const seen = /* @__PURE__ */ new Set();
         for (const s of series) {
-          for (const p2 of s.data) {
-            if (!seen.has(p2.label)) {
-              seen.add(p2.label);
-              set.push(p2.label);
+          for (const p of s.data) {
+            if (!seen.has(p.label)) {
+              seen.add(p.label);
+              set.push(p.label);
             }
           }
         }
@@ -24124,8 +22850,8 @@ var init_Chart = __esm({
       }, [series]);
       const valueAt = React95.useCallback(
         (s, label) => {
-          const p2 = s.data.find((d) => d.label === label);
-          return p2 ? p2.value : 0;
+          const p = s.data.find((d) => d.label === label);
+          return p ? p.value : 0;
         },
         []
       );
@@ -24142,7 +22868,7 @@ var init_Chart = __esm({
         }
         let m = 1;
         for (const s of series) {
-          for (const p2 of s.data) if (p2.value > m) m = p2.value;
+          for (const p of s.data) if (p.value > m) m = p.value;
         }
         return m;
       }, [series, stack, columnTotals]);
@@ -24402,10 +23128,10 @@ var init_Chart = __esm({
         const seen = /* @__PURE__ */ new Set();
         const out = [];
         for (const s of series) {
-          for (const p2 of s.data) {
-            if (!seen.has(p2.label)) {
-              seen.add(p2.label);
-              out.push(p2.label);
+          for (const p of s.data) {
+            if (!seen.has(p.label)) {
+              seen.add(p.label);
+              out.push(p.label);
             }
           }
         }
@@ -24414,7 +23140,7 @@ var init_Chart = __esm({
       const maxValue = React95.useMemo(() => {
         let m = 1;
         for (const s of series) {
-          for (const p2 of s.data) if (p2.value > m) m = p2.value;
+          for (const p of s.data) if (p.value > m) m = p.value;
         }
         return m;
       }, [series]);
@@ -24461,7 +23187,7 @@ var init_Chart = __esm({
                   label
                 };
               });
-              const linePath = points.map((p2, i) => `${i === 0 ? "M" : "L"} ${p2.x} ${p2.y}`).join(" ");
+              const linePath = points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x} ${p.y}`).join(" ");
               const areaPath = `${linePath} L ${points[points.length - 1]?.x ?? 0} ${padding.top + chartHeight} L ${padding.left} ${padding.top + chartHeight} Z`;
               return /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
                 fill && /* @__PURE__ */ jsxRuntime.jsx(
@@ -24484,19 +23210,19 @@ var init_Chart = __esm({
                     strokeDasharray: s.dashed ? "6 4" : void 0
                   }
                 ),
-                points.map((p2, idx) => /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
+                points.map((p, idx) => /* @__PURE__ */ jsxRuntime.jsxs("g", { children: [
                   /* @__PURE__ */ jsxRuntime.jsx(
                     "circle",
                     {
-                      cx: p2.x,
-                      cy: p2.y,
+                      cx: p.x,
+                      cy: p.y,
                       r: "4",
                       fill: "var(--color-card)",
                       stroke: color,
                       strokeWidth: "2",
                       className: "cursor-pointer",
                       onClick: () => onPointClick?.(
-                        { label: p2.label, value: p2.value, color },
+                        { label: p.label, value: p.value, color },
                         s.name
                       )
                     }
@@ -24504,13 +23230,13 @@ var init_Chart = __esm({
                   showValues && series.length === 1 && /* @__PURE__ */ jsxRuntime.jsx(
                     "text",
                     {
-                      x: p2.x,
-                      y: p2.y - 10,
+                      x: p.x,
+                      y: p.y - 10,
                       textAnchor: "middle",
                       fill: "var(--color-foreground)",
                       fontSize: "10",
                       fontWeight: "500",
-                      children: p2.value
+                      children: p.value
                     }
                   )
                 ] }, idx))
@@ -24545,11 +23271,11 @@ var init_Chart = __esm({
         let mxX = data[0].x;
         let mnY = data[0].y;
         let mxY = data[0].y;
-        for (const p2 of data) {
-          if (p2.x < mnX) mnX = p2.x;
-          if (p2.x > mxX) mxX = p2.x;
-          if (p2.y < mnY) mnY = p2.y;
-          if (p2.y > mxY) mxY = p2.y;
+        for (const p of data) {
+          if (p.x < mnX) mnX = p.x;
+          if (p.x > mxX) mxX = p.x;
+          if (p.y < mnY) mnY = p.y;
+          if (p.y > mxY) mxY = p.y;
         }
         return { minX: mnX, maxX: mxX, minY: mnY, maxY: mxY };
       }, [data]);
@@ -24579,11 +23305,11 @@ var init_Chart = __esm({
                 frac
               );
             }),
-            data.map((p2, idx) => {
-              const cx = padding.left + (p2.x - minX) / rangeX * chartWidth;
-              const cy = padding.top + chartHeight - (p2.y - minY) / rangeY * chartHeight;
-              const r = p2.size ?? 5;
-              const color = p2.color ?? CHART_COLORS[idx % CHART_COLORS.length];
+            data.map((p, idx) => {
+              const cx = padding.left + (p.x - minX) / rangeX * chartWidth;
+              const cy = padding.top + chartHeight - (p.y - minY) / rangeY * chartHeight;
+              const r = p.size ?? 5;
+              const color = p.color ?? CHART_COLORS[idx % CHART_COLORS.length];
               return /* @__PURE__ */ jsxRuntime.jsx(
                 "circle",
                 {
@@ -24595,13 +23321,13 @@ var init_Chart = __esm({
                   className: "cursor-pointer hover:opacity-100",
                   onClick: () => onPointClick?.(
                     {
-                      label: p2.label ?? `(${p2.x}, ${p2.y})`,
-                      value: p2.y,
+                      label: p.label ?? `(${p.x}, ${p.y})`,
+                      value: p.y,
                       color
                     },
                     "default"
                   ),
-                  children: /* @__PURE__ */ jsxRuntime.jsx("title", { children: p2.label ?? `(${p2.x}, ${p2.y})` })
+                  children: /* @__PURE__ */ jsxRuntime.jsx("title", { children: p.label ?? `(${p.x}, ${p.y})` })
                 },
                 idx
               );
@@ -30681,7 +29407,7 @@ var init_LineChart = __esm({
       }, [sortedData, width, height]);
       const linePath = React95.useMemo(() => {
         if (points.length === 0) return "";
-        return points.map((p2, i) => `${i === 0 ? "M" : "L"} ${p2.x} ${p2.y}`).join(" ");
+        return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x} ${p.y}`).join(" ");
       }, [points]);
       const areaPath = React95.useMemo(() => {
         if (points.length === 0 || !showArea) return "";
@@ -30881,18 +29607,18 @@ var init_MathCanvas = __esm({
             });
           }
         }
-        for (const p2 of points) {
-          if (p2.x < xMin || p2.x > xMax || p2.y < yMin || p2.y > yMax) continue;
+        for (const p of points) {
+          if (p.x < xMin || p.x > xMax || p.y < yMin || p.y > yMax) continue;
           out.push({
             type: "circle",
-            x: mapX(p2.x),
-            y: mapY(p2.y),
-            radius: p2.radius ?? 4,
-            color: p2.color ?? "#dc2626",
-            fill: p2.color ?? "#dc2626"
+            x: mapX(p.x),
+            y: mapY(p.y),
+            radius: p.radius ?? 4,
+            color: p.color ?? "#dc2626",
+            fill: p.color ?? "#dc2626"
           });
-          if (p2.label) {
-            out.push({ type: "text", x: mapX(p2.x) + 8, y: mapY(p2.y) - 8, text: p2.label, color: "#111827", fontSize: 12 });
+          if (p.label) {
+            out.push({ type: "text", x: mapX(p.x) + 8, y: mapY(p.y) - 8, text: p.label, color: "#111827", fontSize: 12 });
           }
         }
         for (const v of vectors) {
@@ -31411,13 +30137,13 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect68, useRef: useRef67, useCallback: useCallback101, useState: useState99 } = React95__namespace.default;
+      const { useEffect: useEffect67, useRef: useRef65, useCallback: useCallback99, useState: useState97 } = React95__namespace.default;
       const { Typography: Typography2 } = await Promise.resolve().then(() => (init_Typography(), Typography_exports));
       const { useEventBus: useEventBus2 } = await Promise.resolve().then(() => (init_useEventBus(), useEventBus_exports));
       function MapUpdater({ centerLat, centerLng, zoom }) {
         const map = useMap();
-        const prevRef = useRef67({ centerLat, centerLng, zoom });
-        useEffect68(() => {
+        const prevRef = useRef65({ centerLat, centerLng, zoom });
+        useEffect67(() => {
           const prev = prevRef.current;
           if (prev.centerLat !== centerLat || prev.centerLng !== centerLng || prev.zoom !== zoom) {
             map.setView([centerLat, centerLng], zoom);
@@ -31428,7 +30154,7 @@ var init_MapView = __esm({
       }
       function MapClickHandler({ onMapClick }) {
         const map = useMap();
-        useEffect68(() => {
+        useEffect67(() => {
           if (!onMapClick) return;
           const handler = (e) => {
             onMapClick(e.latlng.lat, e.latlng.lng);
@@ -31456,8 +30182,8 @@ var init_MapView = __esm({
         showAttribution = true
       }) {
         const eventBus = useEventBus2();
-        const [clickedPosition, setClickedPosition] = useState99(null);
-        const handleMapClick = useCallback101((lat, lng) => {
+        const [clickedPosition, setClickedPosition] = useState97(null);
+        const handleMapClick = useCallback99((lat, lng) => {
           if (showClickedPin) {
             setClickedPosition({ lat, lng });
           }
@@ -31466,7 +30192,7 @@ var init_MapView = __esm({
             eventBus.emit(`UI:${mapClickEvent}`, { latitude: lat, longitude: lng });
           }
         }, [onMapClick, mapClickEvent, eventBus, showClickedPin]);
-        const handleMarkerClick = useCallback101((marker) => {
+        const handleMarkerClick = useCallback99((marker) => {
           onMarkerClick?.(marker);
           if (markerClickEvent) {
             eventBus.emit(`UI:${markerClickEvent}`, { ...marker });
@@ -32539,7 +31265,7 @@ function TableView({
       children: [
         header,
         dnd.wrapContainer(body),
-        hasMore && /* @__PURE__ */ jsxRuntime.jsx(Box, { className: "flex justify-center py-3", children: /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "ghost", size: "sm", onClick: () => setVisibleCount((p2) => p2 + (pageSize || 5)), children: [
+        hasMore && /* @__PURE__ */ jsxRuntime.jsx(Box, { className: "flex justify-center py-3", children: /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "ghost", size: "sm", onClick: () => setVisibleCount((p) => p + (pageSize || 5)), children: [
           /* @__PURE__ */ jsxRuntime.jsx(Icon, { name: "chevron-down", size: "xs", className: "mr-1" }),
           t("common.showMore"),
           " (",
@@ -35123,7 +33849,7 @@ var init_QrScanner = __esm({
         setCurrentFacing((f3) => f3 === "environment" ? "user" : "environment");
       }, []);
       const togglePause = React95.useCallback(() => {
-        setIsPaused((p2) => !p2);
+        setIsPaused((p) => !p);
       }, []);
       const handleMockScan = React95.useCallback(() => {
         const result = {
@@ -38045,10 +36771,10 @@ var init_ModuleCard = __esm({
                 ] })
               ] }, trait.name);
             }),
-            pages.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 py-1.5 flex items-center gap-2 flex-wrap", children: pages.map((p2) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-0.5", children: [
+            pages.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 py-1.5 flex items-center gap-2 flex-wrap", children: pages.map((p) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-0.5", children: [
               /* @__PURE__ */ jsxRuntime.jsx("svg", { width: 10, height: 10, viewBox: "0 0 12 12", children: /* @__PURE__ */ jsxRuntime.jsx(AvlPage, { x: 6, y: 6, size: 5 }) }),
-              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-mono text-[var(--color-muted-foreground)]", children: p2.route })
-            ] }, p2.name)) })
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-mono text-[var(--color-muted-foreground)]", children: p.route })
+            ] }, p.name)) })
           ]
         }
       );
@@ -39584,12 +38310,12 @@ var init_DocumentViewer = __esm({
       const handleZoomIn = React95.useCallback(() => setZoom((z) => Math.min(z + 25, 200)), []);
       const handleZoomOut = React95.useCallback(() => setZoom((z) => Math.max(z - 25, 50)), []);
       const handlePagePrev = React95.useCallback(() => {
-        setCurrentPage((p2) => Math.max(p2 - 1, 1));
+        setCurrentPage((p) => Math.max(p - 1, 1));
         eventBus.emit("UI:DOCUMENT_PAGE_CHANGE", { page: currentPage - 1 });
       }, [eventBus, currentPage]);
       const handlePageNext = React95.useCallback(() => {
         if (totalPages) {
-          setCurrentPage((p2) => Math.min(p2 + 1, totalPages));
+          setCurrentPage((p) => Math.min(p + 1, totalPages));
           eventBus.emit("UI:DOCUMENT_PAGE_CHANGE", { page: currentPage + 1 });
         }
       }, [totalPages, eventBus, currentPage]);
@@ -43691,7 +42417,7 @@ function WalkMinimap() {
   const graphH = 120;
   const nodeR = 10;
   const positions = activeTrait ? layoutGraph(activeTrait.states, activeTrait.transitions, activeTrait.initialState, graphW, graphH) : [];
-  const posMap = new Map(positions.map((p2) => [p2.state, p2]));
+  const posMap = new Map(positions.map((p) => [p.state, p]));
   const visitedStates = new Set(
     coveredEdges.filter((e) => e.trait === walkStep.traitName).flatMap((e) => [e.from, e.to])
   );
@@ -46961,7 +45687,6 @@ var init_component_registry_generated = __esm({
     init_CTABanner();
     init_CalendarGrid();
     init_Canvas2D();
-    init_CanvasEffect();
     init_Card();
     init_CardGrid();
     init_Carousel();
@@ -47260,7 +45985,6 @@ var init_component_registry_generated = __esm({
       "CTABanner": CTABanner,
       "CalendarGrid": CalendarGrid,
       "Canvas2D": Canvas2D,
-      "CanvasEffect": CanvasEffect,
       "Card": Card,
       "CardGrid": CardGrid,
       "Carousel": Carousel,
@@ -48504,12 +47228,12 @@ function isFnFormLambda(value) {
     return false;
   }
   const params = arr[1];
-  return typeof params === "string" || Array.isArray(params) && params.length > 0 && params.every((p2) => typeof p2 === "string");
+  return typeof params === "string" || Array.isArray(params) && params.length > 0 && params.every((p) => typeof p === "string");
 }
 function fnFormParams(value) {
-  const p2 = value[1];
-  if (typeof p2 === "string") return [p2];
-  if (Array.isArray(p2)) return p2.filter((x) => typeof x === "string");
+  const p = value[1];
+  if (typeof p === "string") return [p];
+  if (Array.isArray(p)) return p.filter((x) => typeof x === "string");
   return [];
 }
 function resolveLambdaBindings(body, params, item, index) {
@@ -50009,9 +48733,9 @@ function SchemaRunner({ schema, serverUrl, transport, mockData, pageName, onNavi
   const orbitalsByTrait = React95.useMemo(
     () => buildOrbitalsByTrait(
       schema,
-      ir ? Array.from(ir.pages.values()).map((p2) => ({
-        path: p2.path,
-        traitNames: p2.traits.map((b) => b.trait.name)
+      ir ? Array.from(ir.pages.values()).map((p) => ({
+        path: p.path,
+        traitNames: p.traits.map((b) => b.trait.name)
       })) : []
     ),
     [schema, ir]
@@ -50200,7 +48924,7 @@ function OrbPreview({
     navLog.debug("handleNavigate", () => ({
       path,
       matched: match?.page.name ?? null,
-      availablePaths: pages.map((p2) => p2.page.path)
+      availablePaths: pages.map((p) => p.page.path)
     }));
     if (match) {
       setCurrentPage(match.page.name);
@@ -50244,7 +48968,7 @@ function OrbPreview({
       handleNavigate(href);
     };
     el.addEventListener("click", handler, true);
-    navLog.info("interceptor:installed", { pageCount: pages.length, paths: pages.map((p2) => p2.page.path) });
+    navLog.info("interceptor:installed", { pageCount: pages.length, paths: pages.map((p) => p.page.path) });
     return () => el.removeEventListener("click", handler, true);
   }, [pages, handleNavigate]);
   return /* @__PURE__ */ jsxRuntime.jsxs(