hayao 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,11 +1,179 @@
+// src/core/dmath.ts
+var INV_PIO2 = 0.6366197723675814;
+var PIO2_HI = 1.5707963267341256;
+var PIO2_LO = 6077100506506192e-26;
+var S1 = -0.16666666666666632;
+var S2 = 0.00833333333332249;
+var S3 = -1984126982985795e-19;
+var S4 = 27557313707070068e-22;
+var S5 = -25050760253406863e-24;
+var S6 = 158969099521155e-24;
+var C1 = 0.0416666666666666;
+var C2 = -0.001388888888887411;
+var C3 = 2480158728947673e-20;
+var C4 = -27557314351390663e-23;
+var C5 = 2087572321298175e-24;
+var C6 = -11359647557788195e-27;
+function kSin(r) {
+  const z = r * r;
+  return r + r * z * (S1 + z * (S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)))));
+}
+function kCos(r) {
+  const z = r * r;
+  return 1 - 0.5 * z + z * z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * C6)))));
+}
+function reduce(x) {
+  const n2 = Math.round(x * INV_PIO2);
+  const r = x - n2 * PIO2_HI - n2 * PIO2_LO;
+  return { n: (n2 % 4 + 4) % 4, r };
+}
+function dsin(x) {
+  if (!Number.isFinite(x)) return NaN;
+  const { n: n2, r } = reduce(x);
+  switch (n2) {
+    case 0:
+      return kSin(r);
+    case 1:
+      return kCos(r);
+    case 2:
+      return -kSin(r);
+    default:
+      return -kCos(r);
+  }
+}
+function dcos(x) {
+  if (!Number.isFinite(x)) return NaN;
+  const { n: n2, r } = reduce(x);
+  switch (n2) {
+    case 0:
+      return kCos(r);
+    case 1:
+      return -kSin(r);
+    case 2:
+      return -kCos(r);
+    default:
+      return kSin(r);
+  }
+}
+var ATAN_HI = [0.4636476090008061, 0.7853981633974483, 0.982793723247329, 1.5707963267948966];
+var ATAN_LO = [22698777452961687e-33, 3061616997868383e-32, 13903311031230998e-33, 6123233995736766e-32];
+var AT = [
+  0.3333333333333293,
+  -0.19999999999876483,
+  0.14285714272503466,
+  -0.11111110405462356,
+  0.09090887133436507,
+  -0.0769187620504483,
+  0.06661073137387531,
+  -0.058335701337905735,
+  0.049768779946159324,
+  -0.036531572744216916,
+  0.016285820115365782
+];
+function datan(x) {
+  if (Number.isNaN(x)) return NaN;
+  if (!Number.isFinite(x)) return x > 0 ? ATAN_HI[3] : -ATAN_HI[3];
+  const sign = x < 0 || Object.is(x, -0) ? -1 : 1;
+  let ax = Math.abs(x);
+  if (ax >= 1e19) return sign * (ATAN_HI[3] + ATAN_LO[3]);
+  let id = -1;
+  if (ax < 0.4375) {
+    if (ax < 1e-9) return x;
+  } else if (ax < 0.6875) {
+    id = 0;
+    ax = (2 * ax - 1) / (2 + ax);
+  } else if (ax < 1.1875) {
+    id = 1;
+    ax = (ax - 1) / (ax + 1);
+  } else if (ax < 2.4375) {
+    id = 2;
+    ax = (ax - 1.5) / (1 + 1.5 * ax);
+  } else {
+    id = 3;
+    ax = -1 / ax;
+  }
+  const z = ax * ax;
+  const w = z * z;
+  const s1 = z * (AT[0] + w * (AT[2] + w * (AT[4] + w * (AT[6] + w * (AT[8] + w * AT[10])))));
+  const s2 = w * (AT[1] + w * (AT[3] + w * (AT[5] + w * (AT[7] + w * AT[9]))));
+  if (id < 0) return sign * (ax - ax * (s1 + s2));
+  const r = ATAN_HI[id] - (ax * (s1 + s2) - ATAN_LO[id] - ax);
+  return sign * r;
+}
+var PI = 3.141592653589793;
+function datan2(y, x) {
+  if (Number.isNaN(x) || Number.isNaN(y)) return NaN;
+  if (y === 0 && x === 0) return Object.is(x, -0) ? Object.is(y, -0) ? -PI : PI : Object.is(y, -0) ? -0 : 0;
+  if (x === 0 || !Number.isFinite(y) && Number.isFinite(x)) return y > 0 ? PI / 2 : -PI / 2;
+  if (!Number.isFinite(x)) {
+    if (!Number.isFinite(y)) {
+      const q = x > 0 ? PI / 4 : 3 * PI / 4;
+      return y > 0 ? q : -q;
+    }
+    return x > 0 ? y < 0 || Object.is(y, -0) ? -0 : 0 : y < 0 || Object.is(y, -0) ? -PI : PI;
+  }
+  const a = datan(y / x);
+  if (x > 0) return a;
+  return y < 0 || Object.is(y, -0) ? a - PI : a + PI;
+}
+var LN2 = 0.6931471805599453;
+function dexp2(x) {
+  if (Number.isNaN(x)) return NaN;
+  if (x >= 1024) return Infinity;
+  if (x <= -1075) return 0;
+  const k = Math.round(x);
+  const y = (x - k) * LN2;
+  let term = 1;
+  let sum = 1;
+  for (let i = 1; i <= 13; i++) {
+    term = term * y / i;
+    sum += term;
+  }
+  return sum * 2 ** k;
+}
+function dexp(x) {
+  return dexp2(x * INV_LN2);
+}
+function dhypot(x, y) {
+  return Math.sqrt(x * x + y * y);
+}
+var logView = new DataView(new ArrayBuffer(8));
+var LN2_HI = 0.6931471803691238;
+var LN2_LO = 19082149292705877e-26;
+function dlog(x) {
+  if (Number.isNaN(x) || x < 0) return NaN;
+  if (x === 0) return -Infinity;
+  if (!Number.isFinite(x)) return Infinity;
+  logView.setFloat64(0, x);
+  let e = (logView.getUint32(0) >>> 20 & 2047) - 1023;
+  if (e === -1023) {
+    logView.setFloat64(0, x * 18014398509481984);
+    e = (logView.getUint32(0) >>> 20 & 2047) - 1023 - 54;
+  }
+  logView.setUint32(0, logView.getUint32(0) & 1048575 | 1023 << 20);
+  let m = logView.getFloat64(0);
+  if (m > 1.4142135623730951) {
+    m *= 0.5;
+    e += 1;
+  }
+  const s = (m - 1) / (m + 1);
+  const z = s * s;
+  const p = 1 + z * (0.3333333333333333 + z * (0.2 + z * (0.14285714285714285 + z * (0.1111111111111111 + z * (0.09090909090909091 + z * (0.07692307692307693 + z * (0.06666666666666667 + z * (0.058823529411764705 + z * 0.05263157894736842))))))));
+  return e * LN2_HI + (2 * s * p + e * LN2_LO);
+}
+var INV_LN10 = 0.4342944819032518;
+var INV_LN2 = 1.4426950408889634;
+var dlog10 = (x) => dlog(x) * INV_LN10;
+var dlog2 = (x) => dlog(x) * INV_LN2;
+
 // src/core/math.ts
 var vec2 = (x = 0, y = 0) => ({ x, y });
 var vadd = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
 var vsub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
 var vscale = (a, s) => ({ x: a.x * s, y: a.y * s });
 var vdot = (a, b) => a.x * b.x + a.y * b.y;
-var vlen = (a) => Math.hypot(a.x, a.y);
-var vdist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var vlen = (a) => dhypot(a.x, a.y);
+var vdist = (a, b) => dhypot(a.x - b.x, a.y - b.y);
 function vnorm(a) {
   const l = vlen(a);
   return l === 0 ? { x: 0, y: 0 } : { x: a.x / l, y: a.y / l };
@@ -14,6 +182,10 @@ var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
 var lerp = (a, b, t) => a + (b - a) * t;
 var invLerp = (a, b, v) => a === b ? 0 : (v - a) / (b - a);
 var remap = (v, a0, a1, b0, b1) => lerp(b0, b1, invLerp(a0, a1, v));
+var smoothstep = (edge0, edge1, v) => {
+  const t = clamp(edge0 === edge1 ? v < edge0 ? 0 : 1 : invLerp(edge0, edge1, v), 0, 1);
+  return t * t * (3 - 2 * t);
+};
 var TAU = Math.PI * 2;
 var deg2rad = (d) => d * Math.PI / 180;
 var rad2deg = (r) => r * 180 / Math.PI;
@@ -35,8 +207,8 @@ function composeTransform(m, n2) {
   };
 }
 function makeTransform(pos, rotation, scale) {
-  const cos = Math.cos(rotation);
-  const sin = Math.sin(rotation);
+  const cos = dcos(rotation);
+  const sin = dsin(rotation);
   return {
     a: cos * scale.x,
     b: sin * scale.x,
@@ -309,7 +481,7 @@ function hashValue(value) {
           return;
         }
         const obj = v;
-        const keys = Object.keys(obj).sort();
+        const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
         push("{");
         for (const k of keys) {
           push(k + ":");
@@ -648,27 +820,74 @@ var Timer = class extends Node {
   }
 };
 
+// src/scene/pool.ts
+var NodePool = class {
+  constructor(parent, make) {
+    this.parent = parent;
+    this.make = make;
+  }
+  parent;
+  make;
+  items = [];
+  used = 0;
+  /** Start a frame: every pooled node is up for reuse. */
+  begin() {
+    this.used = 0;
+  }
+  /** Claim the next node (created and parented on first use), made visible. */
+  get() {
+    if (this.used === this.items.length) this.items.push(this.parent.addChild(this.make()));
+    const n2 = this.items[this.used++];
+    n2.visible = true;
+    return n2;
+  }
+  /** End a frame: hide every node not claimed since begin(). */
+  end() {
+    for (let i = this.used; i < this.items.length; i++) this.items[i].visible = false;
+  }
+  /** Nodes claimed this frame (call after the get() loop). */
+  get liveCount() {
+    return this.used;
+  }
+};
+
 // src/scene/tween.ts
-var pow = Math.pow;
+var lerpDamp = (current, target, lambda, dt) => lerp(target, current, dexp(-lambda * dt));
+var spring = (value = 0) => ({ value, vel: 0 });
+function springStep(s, target, omega, dt) {
+  const decay = dexp(-omega * dt);
+  const d = s.value - target;
+  const c = s.vel + omega * d;
+  s.value = target + (d + c * dt) * decay;
+  s.vel = (s.vel - c * omega * dt) * decay;
+  return s;
+}
+function makeReach(start = 0, settle = 0.25) {
+  const omega = 4 / Math.max(1e-4, settle);
+  const s = spring(start);
+  return (target, dt) => springStep(s, target, omega, dt).value;
+}
+var sq = (x) => x * x;
+var cube = (x) => x * x * x;
 var EASINGS = {
   linear: (t) => t,
   quadIn: (t) => t * t,
   quadOut: (t) => 1 - (1 - t) * (1 - t),
-  quadInOut: (t) => t < 0.5 ? 2 * t * t : 1 - pow(-2 * t + 2, 2) / 2,
+  quadInOut: (t) => t < 0.5 ? 2 * t * t : 1 - sq(-2 * t + 2) / 2,
   cubicIn: (t) => t * t * t,
-  cubicOut: (t) => 1 - pow(1 - t, 3),
-  cubicInOut: (t) => t < 0.5 ? 4 * t * t * t : 1 - pow(-2 * t + 2, 3) / 2,
-  sineIn: (t) => 1 - Math.cos(t * Math.PI / 2),
-  sineOut: (t) => Math.sin(t * Math.PI / 2),
-  sineInOut: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+  cubicOut: (t) => 1 - cube(1 - t),
+  cubicInOut: (t) => t < 0.5 ? 4 * t * t * t : 1 - cube(-2 * t + 2) / 2,
+  sineIn: (t) => 1 - dcos(t * Math.PI / 2),
+  sineOut: (t) => dsin(t * Math.PI / 2),
+  sineInOut: (t) => -(dcos(Math.PI * t) - 1) / 2,
   backOut: (t) => {
     const c1 = 1.70158;
     const c3 = c1 + 1;
-    return 1 + c3 * pow(t - 1, 3) + c1 * pow(t - 1, 2);
+    return 1 + c3 * cube(t - 1) + c1 * sq(t - 1);
   },
   elasticOut: (t) => {
     const c4 = 2 * Math.PI / 3;
-    return t === 0 ? 0 : t === 1 ? 1 : pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c4) + 1;
+    return t === 0 ? 0 : t === 1 ? 1 : dexp2(-10 * t) * dsin((t * 10 - 0.75) * c4) + 1;
   },
   bounceOut: (t) => {
     const n1 = 7.5625;
@@ -740,16 +959,16 @@ var Particles = class extends Node {
     this.maxParticles = config.maxParticles ?? 512;
   }
   /** Emit a burst at a position (in this node's local space). */
-  burst(count, at, style) {
+  burst(count, at2, style) {
     const r = this.rng;
     for (let i = 0; i < count; i++) {
       const angle = style.angle !== void 0 ? style.angle + (r.float() - 0.5) * (style.spread ?? 0.6) : r.float() * TAU;
       const speed = style.speedMin + r.float() * (style.speedMax - style.speedMin);
       const p = {
-        x: at.x,
-        y: at.y,
-        vx: Math.cos(angle) * speed,
-        vy: Math.sin(angle) * speed,
+        x: at2.x,
+        y: at2.y,
+        vx: dcos(angle) * speed,
+        vy: dsin(angle) * speed,
         life: 0,
         maxLife: style.lifeMin + r.float() * (style.lifeMax - style.lifeMin),
         size: style.sizeMin + r.float() * (style.sizeMax - style.sizeMin),
@@ -805,6 +1024,114 @@ var PARTICLE_PRESETS = {
   hit: (colors = ["#ff5e5e", "#ffd0d0"]) => ({ colors, sizeMin: 2, sizeMax: 4, speedMin: 160, speedMax: 380, lifeMin: 0.15, lifeMax: 0.35, drag: 6, shrink: true }),
   sparkle: (colors = ["#9ef7ff", "#e8fdff", "#4ed8e8"]) => ({ colors, sizeMin: 1.5, sizeMax: 3.5, speedMin: 20, speedMax: 70, lifeMin: 0.4, lifeMax: 0.9, gravity: -40, drag: 2, shrink: true })
 };
+function weatherEnvelope(t, keys) {
+  if (keys.length === 0) return 1;
+  if (t <= keys[0].time) return keys[0].intensity;
+  for (let i = 1; i < keys.length; i++) {
+    if (t <= keys[i].time) {
+      const a = keys[i - 1];
+      const b = keys[i];
+      return a.intensity + (b.intensity - a.intensity) * smoothstep(a.time, b.time, t);
+    }
+  }
+  return keys[keys.length - 1].intensity;
+}
+var AmbientField = class extends Node {
+  type = "AmbientField";
+  rng;
+  field = [];
+  time = 0;
+  style;
+  /** Field region (px). Particles wrap within [0,width] × [0,height]. */
+  width;
+  height;
+  /** Optional weather intensity schedule; scales count/opacity. */
+  envelope;
+  constructor(config) {
+    super(config);
+    this.cosmetic = true;
+    this.rng = new Rng(config.seed ?? 11);
+    this.width = config.width;
+    this.height = config.height;
+    this.style = config.style;
+    this.envelope = config.envelope;
+    const count = config.count ?? 120;
+    const s = this.style;
+    for (let i = 0; i < count; i++) {
+      this.field.push({
+        x: this.rng.float() * this.width,
+        y: this.rng.float() * this.height,
+        size: s.sizeMin + this.rng.float() * (s.sizeMax - s.sizeMin),
+        color: s.colors[this.rng.int(s.colors.length)],
+        phase: this.rng.float() * TAU,
+        depth: 0.5 + this.rng.float() * 0.5
+      });
+    }
+  }
+  intensity() {
+    return this.envelope ? weatherEnvelope(this.time, this.envelope) : 1;
+  }
+  onProcess(dt) {
+    this.time += dt;
+    const s = this.style;
+    const wind = s.windX ?? 0;
+    const w = this.width;
+    const h = this.height;
+    for (const p of this.field) {
+      p.y += s.fallY * p.depth * dt;
+      p.x += wind * dt;
+      if (p.y > h) p.y -= h;
+      else if (p.y < 0) p.y += h;
+      if (p.x > w) p.x -= w;
+      else if (p.x < 0) p.x += w;
+    }
+  }
+  draw(out, world) {
+    const s = this.style;
+    const intensity = this.intensity();
+    if (intensity <= 0) return;
+    const shown = Math.round(this.field.length * intensity);
+    const swayAmp = s.swayAmp ?? 0;
+    const swayFreq = s.swayFreq ?? 0;
+    for (let i = 0; i < shown; i++) {
+      const p = this.field[i];
+      const sway = swayAmp !== 0 ? dsin(this.time * swayFreq * TAU + p.phase) * swayAmp : 0;
+      const x = p.x + sway;
+      if (s.streak) {
+        const len = s.streakLen ?? s.fallY * 0.03;
+        out.push({
+          kind: "poly",
+          points: [x, p.y, x, p.y + len],
+          closed: false,
+          stroke: p.color,
+          strokeWidth: p.size,
+          opacity: intensity,
+          transform: world,
+          z: this.z
+        });
+      } else {
+        out.push({
+          kind: "circle",
+          cx: x,
+          cy: p.y,
+          radius: p.size,
+          fill: p.color,
+          opacity: intensity,
+          transform: world,
+          z: this.z
+        });
+      }
+    }
+  }
+  get liveCount() {
+    return this.field.length;
+  }
+};
+var AMBIENT_PRESETS = {
+  snow: (colors = ["#ffffff", "#e8f0f8", "#cdd9e6"]) => ({ colors, sizeMin: 1.5, sizeMax: 3.5, windX: 8, fallY: 42, swayAmp: 14, swayFreq: 0.25 }),
+  rain: (colors = ["#9fb4c8", "#c3d2e0"]) => ({ colors, sizeMin: 1, sizeMax: 1.8, windX: -40, fallY: 620, streak: true, streakLen: 16 }),
+  ash: (colors = ["#6b6b6b", "#8a8580", "#3d3a36"]) => ({ colors, sizeMin: 1, sizeMax: 2.5, windX: 14, fallY: 26, swayAmp: 20, swayFreq: 0.18 })
+};
 var Shaker = class extends Node {
   type = "Shaker";
   rng;
@@ -832,6 +1159,86 @@ var Shaker = class extends Node {
   }
 };
 
+// src/scene/floatingText.ts
+var FloatingText = class extends Node {
+  type = "FloatingText";
+  pool = [];
+  rng;
+  /** Cap on live popups (oldest recycled first). */
+  maxPopups;
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+    this.rng = new Rng(config.seed ?? 31);
+    this.maxPopups = config.maxPopups ?? 128;
+  }
+  /** Spawn one popup at `at` (in this node's local space). */
+  pop(text, at2, style) {
+    const jitter = style.jitter ?? 0;
+    const p = {
+      x: at2.x + (this.rng.float() - 0.5) * jitter * 0.1,
+      y: at2.y,
+      vx: (this.rng.float() - 0.5) * jitter,
+      vy: -(style.rise ?? 60),
+      life: 0,
+      maxLife: Math.max(0.05, style.life ?? 0.9),
+      text,
+      color: style.color,
+      size: style.size ?? 20,
+      font: style.font,
+      weight: style.weight,
+      align: style.align ?? "center",
+      fade: clamp(style.fade ?? 0.4, 0, 1)
+    };
+    this.gravity = style.gravity ?? 0;
+    if (this.pool.length >= this.maxPopups) this.pool.shift();
+    this.pool.push(p);
+  }
+  gravity = 0;
+  onProcess(dt) {
+    let write = 0;
+    for (const p of this.pool) {
+      p.life += dt;
+      if (p.life >= p.maxLife) continue;
+      p.vy += this.gravity * dt;
+      p.x += p.vx * dt;
+      p.y += p.vy * dt;
+      this.pool[write++] = p;
+    }
+    this.pool.length = write;
+  }
+  draw(out, world) {
+    for (const p of this.pool) {
+      const t = p.life / p.maxLife;
+      const fadeStart = 1 - p.fade;
+      const opacity = t < fadeStart ? 1 : clamp(1 - (t - fadeStart) / Math.max(1e-4, p.fade), 0, 1);
+      out.push({
+        kind: "text",
+        text: p.text,
+        x: p.x,
+        y: p.y,
+        size: p.size,
+        font: p.font,
+        weight: p.weight,
+        align: p.align,
+        fill: p.color,
+        opacity,
+        transform: world,
+        z: this.z
+      });
+    }
+  }
+  get liveCount() {
+    return this.pool.length;
+  }
+};
+var FLOAT_PRESETS = {
+  damage: (color = "#e14b4b") => ({ color, size: 22, weight: 700, rise: 70, gravity: 120, life: 0.8, jitter: 40, fade: 0.4 }),
+  crit: (color = "#ffb020") => ({ color, size: 32, weight: 800, rise: 100, gravity: 160, life: 1, jitter: 60, fade: 0.35 }),
+  heal: (color = "#4bb06a") => ({ color, size: 20, weight: 700, rise: 55, gravity: 40, life: 1, jitter: 20, fade: 0.5 }),
+  label: (color = "#3d3323") => ({ color, size: 18, weight: 600, rise: 40, gravity: 0, life: 1.2, jitter: 0, fade: 0.5 })
+};
+
 // src/scene/registry.ts
 var registry = /* @__PURE__ */ new Map();
 function registerNode(type, factory) {
@@ -1205,7 +1612,7 @@ function stepPlatformer(s, input, dt, map, cfg = DEFAULT_PLATFORMER, platforms =
     let dx2 = input.moveX;
     let dy2 = input.moveY;
     if (dx2 === 0 && dy2 === 0) dx2 = s.facing;
-    const inv = 1 / Math.hypot(dx2, dy2);
+    const inv = 1 / dhypot(dx2, dy2);
     s.dashing = cfg.dashTime;
     s.dashCd = cfg.dashCooldown;
     s.dashesLeft--;
@@ -1422,7 +1829,7 @@ function raycastTiles(map, x0, y0, x1, y1) {
   const ts = map.tileSize;
   const dx = x1 - x0;
   const dy = y1 - y0;
-  const maxDist = Math.hypot(dx, dy);
+  const maxDist = dhypot(dx, dy);
   if (maxDist === 0) return { blocked: false, x: x1, y: y1, dist: 0 };
   const dirX = dx / maxDist;
   const dirY = dy / maxDist;
@@ -1458,13 +1865,855 @@ function lineOfSight(map, ax, ay, bx, by) {
 function inVisionCone(map, ex, ey, faceX, faceY, fov, range, tx, ty) {
   const dx = tx - ex;
   const dy = ty - ey;
-  const d = Math.hypot(dx, dy);
+  const d = dhypot(dx, dy);
   if (d > range || d === 0) return false;
   const dot = (dx * faceX + dy * faceY) / d;
-  if (dot < Math.cos(fov / 2)) return false;
+  if (dot < dcos(fov / 2)) return false;
   return lineOfSight(map, ex, ey, tx, ty);
 }
 
+// src/physics/rigidBody.ts
+function createRigidWorld(opts = {}) {
+  return {
+    gravityX: opts.gravityX ?? 0,
+    gravityY: opts.gravityY ?? 900,
+    iterations: opts.iterations ?? 16,
+    cellSize: opts.cellSize ?? 96,
+    nextId: 1,
+    bodies: [],
+    joints: [],
+    warm: {}
+  };
+}
+function massProps(shape) {
+  if (shape.kind === "circle") {
+    const area2 = Math.PI * shape.r * shape.r;
+    return { area: area2, unitI: shape.r * shape.r / 2 };
+  }
+  const p = shape.points;
+  const n2 = p.length / 2;
+  let area = 0;
+  let inertia = 0;
+  for (let k = 0; k < n2; k++) {
+    const x0 = p[k * 2], y0 = p[k * 2 + 1];
+    const j = (k + 1) % n2;
+    const x1 = p[j * 2], y1 = p[j * 2 + 1];
+    const cross = x0 * y1 - x1 * y0;
+    area += cross / 2;
+    inertia += cross * (x0 * x0 + x0 * x1 + x1 * x1 + y0 * y0 + y0 * y1 + y1 * y1) / 12;
+  }
+  return { area: Math.abs(area), unitI: area !== 0 ? Math.abs(inertia) / Math.abs(area) : 0 };
+}
+var DENSITY_SCALE = 1e-4;
+function addBody(rw, def) {
+  const kind = def.kind ?? "dynamic";
+  const density = def.density ?? 1;
+  const { area, unitI } = massProps(def.shape);
+  const m = kind === "dynamic" ? Math.max(area * density * DENSITY_SCALE, 1e-6) : 0;
+  const i = kind === "dynamic" && !def.fixedRotation ? m * unitI : 0;
+  const body = {
+    id: rw.nextId++,
+    kind,
+    shape: def.shape,
+    x: def.x ?? 0,
+    y: def.y ?? 0,
+    a: def.a ?? 0,
+    vx: def.vx ?? 0,
+    vy: def.vy ?? 0,
+    w: def.w ?? 0,
+    m,
+    invM: m > 0 ? 1 / m : 0,
+    i,
+    invI: i > 0 ? 1 / i : 0,
+    restitution: def.restitution ?? 0.1,
+    friction: def.friction ?? 0.4,
+    linDamp: def.linDamp ?? 0,
+    angDamp: def.angDamp ?? 0.6,
+    gravityScale: def.gravityScale ?? 1,
+    bullet: def.bullet ?? false,
+    sensor: def.sensor ?? false,
+    layer: def.layer ?? 1,
+    mask: def.mask ?? 65535,
+    canSleep: def.canSleep ?? true,
+    sleeping: false,
+    sleepTime: 0,
+    sleepR: def.shape.kind === "circle" ? def.shape.r : Math.sqrt(def.shape.points.reduce((m2, _, i2, p) => i2 % 2 ? m2 : Math.max(m2, p[i2] * p[i2] + p[i2 + 1] * p[i2 + 1]), 0)),
+    fx: 0,
+    fy: 0,
+    torque: 0
+  };
+  rw.bodies.push(body);
+  return body.id;
+}
+function getBody(rw, id) {
+  const bs = rw.bodies;
+  for (let k = 0; k < bs.length; k++) if (bs[k].id === id) return bs[k];
+  return void 0;
+}
+function removeBody(rw, id) {
+  const idx = rw.bodies.findIndex((b) => b.id === id);
+  if (idx >= 0) rw.bodies.splice(idx, 1);
+  rw.joints = rw.joints.filter((j) => j.a !== id && j.b !== id);
+}
+function wakeBody(b) {
+  b.sleeping = false;
+  b.sleepTime = 0;
+}
+function applyImpulse(rw, id, ix, iy, px, py) {
+  const b = getBody(rw, id);
+  if (!b || b.invM === 0) return;
+  wakeBody(b);
+  b.vx += ix * b.invM;
+  b.vy += iy * b.invM;
+  if (px !== void 0 && py !== void 0) {
+    b.w += ((px - b.x) * iy - (py - b.y) * ix) * b.invI;
+  }
+}
+function worldPoints(b) {
+  if (b.shape.kind !== "poly") return [];
+  const c = dcos(b.a), s = dsin(b.a);
+  const p = b.shape.points;
+  const out = new Array(p.length);
+  for (let k = 0; k < p.length; k += 2) {
+    out[k] = b.x + p[k] * c - p[k + 1] * s;
+    out[k + 1] = b.y + p[k] * s + p[k + 1] * c;
+  }
+  return out;
+}
+function bodyAABB(b) {
+  if (b.shape.kind === "circle") {
+    const r = b.shape.r;
+    return { x: b.x - r, y: b.y - r, w: r * 2, h: r * 2 };
+  }
+  const wp = worldPoints(b);
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (let k = 0; k < wp.length; k += 2) {
+    if (wp[k] < x0) x0 = wp[k];
+    if (wp[k] > x1) x1 = wp[k];
+    if (wp[k + 1] < y0) y0 = wp[k + 1];
+    if (wp[k + 1] > y1) y1 = wp[k + 1];
+  }
+  return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+function polygonBox(w, h) {
+  const hw = w / 2, hh = h / 2;
+  return { kind: "poly", points: [-hw, -hh, hw, -hh, hw, hh, -hw, hh] };
+}
+
+// src/physics/rigidCollide.ts
+function collideCircles(a, b) {
+  if (a.shape.kind !== "circle" || b.shape.kind !== "circle") return null;
+  const dx = b.x - a.x, dy = b.y - a.y;
+  const rsum = a.shape.r + b.shape.r;
+  const d2 = dx * dx + dy * dy;
+  if (d2 >= rsum * rsum) return null;
+  const d = Math.sqrt(d2);
+  const nx = d > 1e-9 ? dx / d : 1, ny = d > 1e-9 ? dy / d : 0;
+  return {
+    a,
+    b,
+    nx,
+    ny,
+    points: [{ px: a.x + nx * a.shape.r, py: a.y + ny * a.shape.r, pen: rsum - d, feature: 0 }]
+  };
+}
+function collidePolyCircle(a, b) {
+  if (a.shape.kind !== "poly" || b.shape.kind !== "circle") return null;
+  const wp = worldPoints(a);
+  const n2 = wp.length / 2;
+  const r = b.shape.r;
+  let bestSep = -Infinity, bestI = 0;
+  for (let k2 = 0; k2 < n2; k2++) {
+    const j2 = (k2 + 1) % n2;
+    const ex2 = wp[j2 * 2] - wp[k2 * 2], ey2 = wp[j2 * 2 + 1] - wp[k2 * 2 + 1];
+    const len = dhypot(ex2, ey2) || 1;
+    const nx2 = ey2 / len, ny2 = -ex2 / len;
+    const sep = (b.x - wp[k2 * 2]) * nx2 + (b.y - wp[k2 * 2 + 1]) * ny2;
+    if (sep > bestSep) {
+      bestSep = sep;
+      bestI = k2;
+    }
+  }
+  if (bestSep > r) return null;
+  const k = bestI, j = (bestI + 1) % n2;
+  const ax = wp[k * 2], ay = wp[k * 2 + 1], bx2 = wp[j * 2], by2 = wp[j * 2 + 1];
+  if (bestSep < 1e-9) {
+    const ex2 = bx2 - ax, ey2 = by2 - ay;
+    const len = dhypot(ex2, ey2) || 1;
+    const nx2 = ey2 / len, ny2 = -ex2 / len;
+    return { a, b, nx: nx2, ny: ny2, points: [{ px: b.x - nx2 * r, py: b.y - ny2 * r, pen: r - bestSep, feature: bestI }] };
+  }
+  const ex = bx2 - ax, ey = by2 - ay;
+  const e2 = ex * ex + ey * ey || 1;
+  let t = ((b.x - ax) * ex + (b.y - ay) * ey) / e2;
+  t = t < 0 ? 0 : t > 1 ? 1 : t;
+  const cx = ax + ex * t, cy = ay + ey * t;
+  const dx = b.x - cx, dy = b.y - cy;
+  const d2 = dx * dx + dy * dy;
+  if (d2 >= r * r) return null;
+  const d = Math.sqrt(d2) || 1e-9;
+  const nx = dx / d, ny = dy / d;
+  return { a, b, nx, ny, points: [{ px: cx, py: cy, pen: r - d, feature: bestI }] };
+}
+function maxSeparation(wpA, wpB) {
+  const nA = wpA.length / 2, nB = wpB.length / 2;
+  let best = -Infinity, bestI = 0;
+  for (let k = 0; k < nA; k++) {
+    const j = (k + 1) % nA;
+    const ex = wpA[j * 2] - wpA[k * 2], ey = wpA[j * 2 + 1] - wpA[k * 2 + 1];
+    const len = dhypot(ex, ey) || 1;
+    const nx = ey / len, ny = -ex / len;
+    let minDot = Infinity;
+    for (let v = 0; v < nB; v++) {
+      const d = (wpB[v * 2] - wpA[k * 2]) * nx + (wpB[v * 2 + 1] - wpA[k * 2 + 1]) * ny;
+      if (d < minDot) minDot = d;
+    }
+    if (minDot > best) {
+      best = minDot;
+      bestI = k;
+    }
+  }
+  return [best, bestI];
+}
+function collidePolys(a, b) {
+  const wpA = worldPoints(a), wpB = worldPoints(b);
+  const [sepA, faceA] = maxSeparation(wpA, wpB);
+  if (sepA > 0) return null;
+  const [sepB, faceB] = maxSeparation(wpB, wpA);
+  if (sepB > 0) return null;
+  let ref, inc, refFace, flip;
+  if (sepB > sepA + 1e-4) {
+    ref = wpB;
+    inc = wpA;
+    refFace = faceB;
+    flip = true;
+  } else {
+    ref = wpA;
+    inc = wpB;
+    refFace = faceA;
+    flip = false;
+  }
+  const nRef = ref.length / 2, nInc = inc.length / 2;
+  const rj = (refFace + 1) % nRef;
+  const rex = ref[rj * 2] - ref[refFace * 2], rey = ref[rj * 2 + 1] - ref[refFace * 2 + 1];
+  const rlen = dhypot(rex, rey) || 1;
+  const rnx = rey / rlen, rny = -rex / rlen;
+  const rtx = rex / rlen, rty = rey / rlen;
+  let incFace = 0, minDot = Infinity;
+  for (let k = 0; k < nInc; k++) {
+    const j = (k + 1) % nInc;
+    const ex = inc[j * 2] - inc[k * 2], ey = inc[j * 2 + 1] - inc[k * 2 + 1];
+    const len = dhypot(ex, ey) || 1;
+    const d = ey / len * rnx + -ex / len * rny;
+    if (d < minDot) {
+      minDot = d;
+      incFace = k;
+    }
+  }
+  const ij = (incFace + 1) % nInc;
+  let v1x = inc[incFace * 2], v1y = inc[incFace * 2 + 1];
+  let v2x = inc[ij * 2], v2y = inc[ij * 2 + 1];
+  const refX = ref[refFace * 2], refY = ref[refFace * 2 + 1];
+  const refX2 = ref[rj * 2], refY2 = ref[rj * 2 + 1];
+  for (let side = 0; side < 2; side++) {
+    const ox = side === 0 ? refX : refX2, oy = side === 0 ? refY : refY2;
+    const sx = side === 0 ? rtx : -rtx, sy = side === 0 ? rty : -rty;
+    const d1 = (v1x - ox) * sx + (v1y - oy) * sy;
+    const d2 = (v2x - ox) * sx + (v2y - oy) * sy;
+    if (d1 < 0 && d2 < 0) return null;
+    if (d1 < 0) {
+      const t = d1 / (d1 - d2);
+      v1x = v1x + (v2x - v1x) * t;
+      v1y = v1y + (v2y - v1y) * t;
+    } else if (d2 < 0) {
+      const t = d2 / (d2 - d1);
+      v2x = v2x + (v1x - v2x) * t;
+      v2y = v2y + (v1y - v2y) * t;
+    }
+  }
+  const nx = flip ? -rnx : rnx, ny = flip ? -rny : rny;
+  const points = [];
+  const pen1 = -((v1x - refX) * rnx + (v1y - refY) * rny);
+  const pen2 = -((v2x - refX) * rnx + (v2y - refY) * rny);
+  const fid = ((flip ? 1 : 0) * 64 + refFace) * 64 + incFace;
+  if (pen1 > 0) points.push({ px: v1x, py: v1y, pen: pen1, feature: fid * 2 });
+  if (pen2 > 0) points.push({ px: v2x, py: v2y, pen: pen2, feature: fid * 2 + 1 });
+  if (points.length === 0) return null;
+  return { a, b, nx, ny, points };
+}
+function collide(a, b) {
+  const ka = a.shape.kind, kb = b.shape.kind;
+  if (ka === "circle" && kb === "circle") return collideCircles(a, b);
+  if (ka === "poly" && kb === "poly") return collidePolys(a, b);
+  if (ka === "poly" && kb === "circle") return collidePolyCircle(a, b);
+  const m = collidePolyCircle(b, a);
+  if (!m) return null;
+  return { a, b, nx: -m.nx, ny: -m.ny, points: m.points };
+}
+
+// src/physics/rigidJoints.ts
+function toLocal(b, wx, wy) {
+  const c = dcos(b.a), s = dsin(b.a);
+  const dx = wx - b.x, dy = wy - b.y;
+  return [dx * c + dy * s, -dx * s + dy * c];
+}
+function anchorWorld(b, lx, ly) {
+  const c = dcos(b.a), s = dsin(b.a);
+  return [b.x + lx * c - ly * s, b.y + lx * s + ly * c];
+}
+function addDistanceJoint(rw, def) {
+  const A = getBody(rw, def.a), B = getBody(rw, def.b);
+  if (!A || !B) throw new Error(`distance joint: missing body ${def.a}/${def.b}`);
+  const ax = def.ax ?? 0, ay = def.ay ?? 0, bx = def.bx ?? 0, by = def.by ?? 0;
+  const [wax, way] = anchorWorld(A, ax, ay);
+  const [wbx, wby] = anchorWorld(B, bx, by);
+  const j = {
+    kind: "distance",
+    id: rw.nextId++,
+    a: def.a,
+    b: def.b,
+    ax,
+    ay,
+    bx,
+    by,
+    length: def.length ?? dhypot(wbx - wax, wby - way),
+    rope: def.rope ?? false
+  };
+  rw.joints.push(j);
+  wakeBody(A);
+  wakeBody(B);
+  return j.id;
+}
+function addRevoluteJoint(rw, def) {
+  const A = getBody(rw, def.a), B = getBody(rw, def.b);
+  if (!A || !B) throw new Error(`revolute joint: missing body ${def.a}/${def.b}`);
+  const [ax, ay] = toLocal(A, def.px, def.py);
+  const [bx, by] = toLocal(B, def.px, def.py);
+  const j = {
+    kind: "revolute",
+    id: rw.nextId++,
+    a: def.a,
+    b: def.b,
+    ax,
+    ay,
+    bx,
+    by,
+    motorSpeed: def.motorSpeed ?? 0,
+    maxMotorTorque: def.maxMotorTorque ?? 0,
+    limitLower: def.limitLower ?? 0,
+    limitUpper: def.limitUpper ?? 0,
+    limitEnabled: def.limitLower !== void 0 || def.limitUpper !== void 0,
+    refAngle: B.a - A.a
+  };
+  rw.joints.push(j);
+  wakeBody(A);
+  wakeBody(B);
+  return j.id;
+}
+function getJoint(rw, id) {
+  for (const j of rw.joints) if (j.id === id) return j;
+  return void 0;
+}
+function removeJoint(rw, id) {
+  rw.joints = rw.joints.filter((j) => j.id !== id);
+}
+function solveJoint(j, A, B, dt, scratch) {
+  const [wax, way] = anchorWorld(A, j.ax, j.ay);
+  const [wbx, wby] = anchorWorld(B, j.bx, j.by);
+  const rax = wax - A.x, ray = way - A.y;
+  const rbx = wbx - B.x, rby = wby - B.y;
+  if (j.kind === "distance") {
+    let dx = wbx - wax, dy = wby - way;
+    const dist = dhypot(dx, dy);
+    if (dist < 1e-9) return;
+    dx /= dist;
+    dy /= dist;
+    const stretch = dist - j.length;
+    if (j.rope && stretch <= 0) return;
+    const vax2 = A.vx - A.w * ray, vay2 = A.vy + A.w * rax;
+    const vbx2 = B.vx - B.w * rby, vby2 = B.vy + B.w * rbx;
+    const vrel = (vbx2 - vax2) * dx + (vby2 - vay2) * dy;
+    const crossA = rax * dy - ray * dx;
+    const crossB = rbx * dy - rby * dx;
+    const k = A.invM + B.invM + A.invI * crossA * crossA + B.invI * crossB * crossB;
+    if (k < 1e-12) return;
+    const bias = 0.2 / dt * stretch;
+    let lambda = -(vrel + bias) / k;
+    if (j.rope && lambda > 0) lambda = 0;
+    const ix2 = dx * lambda, iy2 = dy * lambda;
+    A.vx -= ix2 * A.invM;
+    A.vy -= iy2 * A.invM;
+    A.w -= (rax * iy2 - ray * ix2) * A.invI;
+    B.vx += ix2 * B.invM;
+    B.vy += iy2 * B.invM;
+    B.w += (rbx * iy2 - rby * ix2) * B.invI;
+    return;
+  }
+  if (j.maxMotorTorque > 0) {
+    const kw = A.invI + B.invI;
+    if (kw > 1e-12) {
+      const cdot = B.w - A.w - j.motorSpeed;
+      const imp = -cdot / kw;
+      const maxImp = j.maxMotorTorque * dt;
+      const acc0 = scratch.motorImpulse;
+      scratch.motorImpulse = Math.min(Math.max(acc0 + imp, -maxImp), maxImp);
+      const applied = scratch.motorImpulse - acc0;
+      A.w -= applied * A.invI;
+      B.w += applied * B.invI;
+    }
+  }
+  if (j.limitEnabled) {
+    const kw = A.invI + B.invI;
+    if (kw > 1e-12) {
+      const angle = B.a - A.a - j.refAngle;
+      let c = 0;
+      if (angle < j.limitLower) c = angle - j.limitLower;
+      else if (angle > j.limitUpper) c = angle - j.limitUpper;
+      if (c !== 0) {
+        const cdot = B.w - A.w;
+        const imp = -(cdot + 0.2 / dt * c) / kw;
+        if (c < 0 && imp > 0 || c > 0 && imp < 0) {
+          A.w -= imp * A.invI;
+          B.w += imp * B.invI;
+        }
+      }
+    }
+  }
+  const vax = A.vx - A.w * ray, vay = A.vy + A.w * rax;
+  const vbx = B.vx - B.w * rby, vby = B.vy + B.w * rbx;
+  const cx = wbx - wax, cy = wby - way;
+  const vrx = vbx - vax + 0.2 / dt * cx;
+  const vry = vby - vay + 0.2 / dt * cy;
+  const k11 = A.invM + B.invM + A.invI * ray * ray + B.invI * rby * rby;
+  const k12 = -A.invI * rax * ray - B.invI * rbx * rby;
+  const k22 = A.invM + B.invM + A.invI * rax * rax + B.invI * rbx * rbx;
+  const det = k11 * k22 - k12 * k12;
+  if (Math.abs(det) < 1e-12) return;
+  const ix = -(k22 * vrx - k12 * vry) / det;
+  const iy = -(k11 * vry - k12 * vrx) / det;
+  A.vx -= ix * A.invM;
+  A.vy -= iy * A.invM;
+  A.w -= (rax * iy - ray * ix) * A.invI;
+  B.vx += ix * B.invM;
+  B.vy += iy * B.invM;
+  B.w += (rbx * iy - rby * ix) * B.invI;
+}
+
+// src/physics/rigidStep.ts
+var SLOP = 0.5;
+var BIAS = 0.2;
+var REST_THRESHOLD = 40;
+var SLEEP_LIN2 = 64;
+var SLEEP_RIM = 8;
+var TIME_TO_SLEEP = 0.5;
+var WAKE_LIN2 = 100;
+function canCollide(a, b) {
+  if (a.invM === 0 && b.invM === 0 && a.kind !== "kinematic" && b.kind !== "kinematic" && !a.sensor && !b.sensor) return false;
+  return (a.mask & b.layer) !== 0 && (b.mask & a.layer) !== 0;
+}
+function rigidStep(rw, dt) {
+  const bodies = rw.bodies;
+  const events = [];
+  if (dt <= 0) return events;
+  for (let k = 0; k < bodies.length; k++) {
+    const b = bodies[k];
+    if (b.kind !== "dynamic" || b.sleeping) {
+      b.fx = 0;
+      b.fy = 0;
+      b.torque = 0;
+      continue;
+    }
+    b.vx += (rw.gravityX * b.gravityScale + b.fx * b.invM) * dt;
+    b.vy += (rw.gravityY * b.gravityScale + b.fy * b.invM) * dt;
+    b.w += b.torque * b.invI * dt;
+    const ld = 1 / (1 + b.linDamp * dt);
+    b.vx *= ld;
+    b.vy *= ld;
+    b.w *= 1 / (1 + b.angDamp * dt);
+    b.fx = 0;
+    b.fy = 0;
+    b.torque = 0;
+  }
+  const hash = new SpatialHash(rw.cellSize);
+  const indexOf = /* @__PURE__ */ new Map();
+  for (let k = 0; k < bodies.length; k++) {
+    hash.insert(bodies[k], bodyAABB(bodies[k]));
+    indexOf.set(bodies[k], k);
+  }
+  const manifolds = [];
+  const seen = /* @__PURE__ */ new Set();
+  const jointed = /* @__PURE__ */ new Set();
+  for (const j of rw.joints) {
+    const lo = Math.min(j.a, j.b), hi = Math.max(j.a, j.b);
+    jointed.add(lo * 1048576 + hi);
+  }
+  for (let k = 0; k < bodies.length; k++) {
+    const a = bodies[k];
+    const near = hash.query(bodyAABB(a));
+    for (const b of near) {
+      if (b.id <= a.id) continue;
+      const packed = a.id * 1048576 + b.id;
+      if (seen.has(packed)) continue;
+      seen.add(packed);
+      if (jointed.has(packed)) continue;
+      if (!canCollide(a, b)) continue;
+      const activeA = !a.sleeping && a.kind !== "static";
+      const activeB = !b.sleeping && b.kind !== "static";
+      if (!activeA && !activeB) continue;
+      const m = collide(a, b);
+      if (!m) continue;
+      const wakeIf = (s, o) => {
+        if (s.sleeping && (o.vx * o.vx + o.vy * o.vy > WAKE_LIN2 || o.kind === "kinematic")) wakeBody(s);
+      };
+      wakeIf(a, b);
+      wakeIf(b, a);
+      if (a.sensor || b.sensor) {
+        events.push({ a: a.id, b: b.id, px: m.points[0].px, py: m.points[0].py, nx: m.nx, ny: m.ny, impulse: 0, sensor: true });
+        continue;
+      }
+      const sp = [];
+      const tx = -m.ny, ty = m.nx;
+      for (const p of m.points) {
+        const rax = p.px - a.x, ray = p.py - a.y;
+        const rbx = p.px - b.x, rby = p.py - b.y;
+        const crossAN = rax * m.ny - ray * m.nx;
+        const crossBN = rbx * m.ny - rby * m.nx;
+        const kn = a.invM + b.invM + a.invI * crossAN * crossAN + b.invI * crossBN * crossBN;
+        const crossAT = rax * ty - ray * tx;
+        const crossBT = rbx * ty - rby * tx;
+        const kt = a.invM + b.invM + a.invI * crossAT * crossAT + b.invI * crossBT * crossBT;
+        const vrx = b.vx - b.w * rby - a.vx + a.w * ray;
+        const vry = b.vy + b.w * rbx - a.vy - a.w * rax;
+        const vn = vrx * m.nx + vry * m.ny;
+        const e = Math.max(a.restitution, b.restitution);
+        const key = `${a.id}:${b.id}:${p.feature}`;
+        const warm2 = rw.warm[key];
+        const sp1 = {
+          rax,
+          ray,
+          rbx,
+          rby,
+          pen: p.pen,
+          massN: kn > 1e-12 ? 1 / kn : 0,
+          massT: kt > 1e-12 ? 1 / kt : 0,
+          restBias: vn < -REST_THRESHOLD ? -e * vn : 0,
+          posBias: BIAS / dt * Math.max(0, p.pen - SLOP),
+          pn: warm2 ? warm2[0] : 0,
+          pt: warm2 ? warm2[1] : 0,
+          pb: 0,
+          key
+        };
+        sp.push(sp1);
+      }
+      manifolds.push({ m, ia: k, ib: indexOf.get(b), points: sp, friction: Math.sqrt(a.friction * b.friction) });
+    }
+  }
+  for (const sm of manifolds) {
+    const { a, b, nx, ny } = sm.m;
+    const tx = -ny, ty = nx;
+    for (const p of sm.points) {
+      if (p.pn === 0 && p.pt === 0) continue;
+      const ix = nx * p.pn + tx * p.pt;
+      const iy = ny * p.pn + ty * p.pt;
+      a.vx -= ix * a.invM;
+      a.vy -= iy * a.invM;
+      a.w -= (p.rax * iy - p.ray * ix) * a.invI;
+      b.vx += ix * b.invM;
+      b.vy += iy * b.invM;
+      b.w += (p.rbx * iy - p.rby * ix) * b.invI;
+    }
+  }
+  manifolds.sort((p, q) => {
+    const ps = p.m.a.invM === 0 || p.m.b.invM === 0 ? 0 : 1;
+    const qs = q.m.a.invM === 0 || q.m.b.invM === 0 ? 0 : 1;
+    if (ps !== qs) return ps - qs;
+    const py = Math.max(p.m.a.y, p.m.b.y), qy = Math.max(q.m.a.y, q.m.b.y);
+    if (py !== qy) return qy - py;
+    if (p.m.a.id !== q.m.a.id) return p.m.a.id - q.m.a.id;
+    return p.m.b.id - q.m.b.id;
+  });
+  const bvx = new Float64Array(bodies.length);
+  const bvy = new Float64Array(bodies.length);
+  const bw = new Float64Array(bodies.length);
+  const jointScratch = rw.joints.map(() => ({ motorImpulse: 0 }));
+  for (let iter = 0; iter < rw.iterations; iter++) {
+    for (let jk = 0; jk < rw.joints.length; jk++) {
+      const j = rw.joints[jk];
+      const A = getBody(rw, j.a), B = getBody(rw, j.b);
+      if (!A || !B) continue;
+      if (A.sleeping && B.sleeping) continue;
+      if (A.sleeping) wakeBody(A);
+      if (B.sleeping) wakeBody(B);
+      solveJoint(j, A, B, dt, jointScratch[jk]);
+    }
+    for (const sm of manifolds) {
+      const { a, b, nx, ny } = sm.m;
+      const { ia, ib } = sm;
+      const tx = -ny, ty = nx;
+      for (const p of sm.points) {
+        let vrx = b.vx - b.w * p.rby - a.vx + a.w * p.ray;
+        let vry = b.vy + b.w * p.rbx - a.vy - a.w * p.rax;
+        const vn = vrx * nx + vry * ny;
+        let dPn = p.massN * (p.restBias - vn);
+        const pn0 = p.pn;
+        p.pn = Math.max(pn0 + dPn, 0);
+        dPn = p.pn - pn0;
+        let ix = nx * dPn, iy = ny * dPn;
+        a.vx -= ix * a.invM;
+        a.vy -= iy * a.invM;
+        a.w -= (p.rax * iy - p.ray * ix) * a.invI;
+        b.vx += ix * b.invM;
+        b.vy += iy * b.invM;
+        b.w += (p.rbx * iy - p.rby * ix) * b.invI;
+        vrx = b.vx - b.w * p.rby - a.vx + a.w * p.ray;
+        vry = b.vy + b.w * p.rbx - a.vy - a.w * p.rax;
+        const vt = vrx * tx + vry * ty;
+        let dPt = p.massT * -vt;
+        const maxPt = sm.friction * p.pn;
+        const pt0 = p.pt;
+        p.pt = Math.min(Math.max(pt0 + dPt, -maxPt), maxPt);
+        dPt = p.pt - pt0;
+        ix = tx * dPt;
+        iy = ty * dPt;
+        a.vx -= ix * a.invM;
+        a.vy -= iy * a.invM;
+        a.w -= (p.rax * iy - p.ray * ix) * a.invI;
+        b.vx += ix * b.invM;
+        b.vy += iy * b.invM;
+        b.w += (p.rbx * iy - p.rby * ix) * b.invI;
+        if (p.posBias > 0) {
+          const vbn = (bvx[ib] - bw[ib] * p.rby - bvx[ia] + bw[ia] * p.ray) * nx + (bvy[ib] + bw[ib] * p.rbx - bvy[ia] - bw[ia] * p.rax) * ny;
+          let dPb = p.massN * (p.posBias - vbn);
+          const pb0 = p.pb;
+          p.pb = Math.max(pb0 + dPb, 0);
+          dPb = p.pb - pb0;
+          const bix = nx * dPb, biy = ny * dPb;
+          bvx[ia] -= bix * a.invM;
+          bvy[ia] -= biy * a.invM;
+          bvx[ib] += bix * b.invM;
+          bvy[ib] += biy * b.invM;
+        }
+      }
+    }
+  }
+  const preX = [], preY = [];
+  for (let k = 0; k < bodies.length; k++) {
+    const b = bodies[k];
+    preX.push(b.x);
+    preY.push(b.y);
+    if (b.invM === 0 && b.kind !== "kinematic") continue;
+    if (b.sleeping) continue;
+    b.x += (b.vx + bvx[k]) * dt;
+    b.y += (b.vy + bvy[k]) * dt;
+    b.a += (b.w + bw[k]) * dt;
+  }
+  for (let k = 0; k < bodies.length; k++) {
+    const b = bodies[k];
+    if (!b.bullet || b.shape.kind !== "circle" || b.sleeping) continue;
+    const dx = b.x - preX[k], dy = b.y - preY[k];
+    if (dx * dx + dy * dy < 1) continue;
+    let bestT = 1;
+    for (let q = 0; q < bodies.length; q++) {
+      const o = bodies[q];
+      if (o === b || o.bullet || o.sensor || !canCollide(b, o)) continue;
+      const t = sweepCircle(preX[k], preY[k], dx, dy, b.shape.r, o);
+      if (t >= 0 && t < bestT) bestT = t;
+    }
+    if (bestT < 1) {
+      const len = dhypot(dx, dy) || 1;
+      b.x = preX[k] + dx * bestT + dx / len * 0.4;
+      b.y = preY[k] + dy * bestT + dy / len * 0.4;
+    }
+  }
+  const touching = /* @__PURE__ */ new Set();
+  const parent = [];
+  for (let k = 0; k < bodies.length; k++) parent.push(k);
+  const find = (x) => {
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  const union = (x, y) => {
+    parent[find(x)] = find(y);
+  };
+  for (const sm of manifolds) {
+    touching.add(sm.m.a.id);
+    touching.add(sm.m.b.id);
+    if (sm.m.a.kind === "dynamic" && sm.m.b.kind === "dynamic") union(sm.ia, sm.ib);
+  }
+  for (const j of rw.joints) {
+    touching.add(j.a);
+    touching.add(j.b);
+    const A = getBody(rw, j.a), B = getBody(rw, j.b);
+    if (A?.kind === "dynamic" && B?.kind === "dynamic") union(indexOf.get(A), indexOf.get(B));
+  }
+  for (let k = 0; k < bodies.length; k++) {
+    const b = bodies[k];
+    if (b.kind !== "dynamic") continue;
+    const lin2 = b.vx * b.vx + b.vy * b.vy;
+    if (b.sleeping) {
+      if (lin2 > WAKE_LIN2) wakeBody(b);
+      continue;
+    }
+    if (!b.canSleep || !touching.has(b.id)) {
+      b.sleepTime = 0;
+      continue;
+    }
+    b.sleepTime = lin2 < SLEEP_LIN2 && Math.abs(b.w) * b.sleepR < SLEEP_RIM ? b.sleepTime + dt : 0;
+  }
+  const islandMin = /* @__PURE__ */ new Map();
+  for (let k = 0; k < bodies.length; k++) {
+    const b = bodies[k];
+    if (b.kind !== "dynamic" || b.sleeping) continue;
+    const root = find(k);
+    const t = !b.canSleep || !touching.has(b.id) ? -1 : b.sleepTime;
+    const cur = islandMin.get(root);
+    islandMin.set(root, cur === void 0 ? t : Math.min(cur, t));
+  }
+  for (let k = 0; k < bodies.length; k++) {
+    const b = bodies[k];
+    if (b.kind !== "dynamic" || b.sleeping) continue;
+    if ((islandMin.get(find(k)) ?? -1) >= TIME_TO_SLEEP) {
+      b.sleeping = true;
+      b.vx = 0;
+      b.vy = 0;
+      b.w = 0;
+    }
+  }
+  const warm = {};
+  for (const sm of manifolds) {
+    let total = 0;
+    for (const p of sm.points) {
+      total += p.pn;
+      if (p.pn !== 0 || p.pt !== 0) warm[p.key] = [p.pn, p.pt];
+    }
+    const p0 = sm.m.points[0];
+    events.push({
+      a: sm.m.a.id,
+      b: sm.m.b.id,
+      px: p0.px,
+      py: p0.py,
+      nx: sm.m.nx,
+      ny: sm.m.ny,
+      impulse: total,
+      sensor: false
+    });
+  }
+  rw.warm = warm;
+  return events;
+}
+function sweepCircle(x0, y0, dx, dy, r, o) {
+  if (o.shape.kind === "circle") {
+    return sweepVsCircle(x0, y0, dx, dy, o.x, o.y, r + o.shape.r);
+  }
+  const wp = worldPoints(o);
+  const n2 = wp.length / 2;
+  let best = -1;
+  for (let k = 0; k < n2; k++) {
+    const j = (k + 1) % n2;
+    const ax = wp[k * 2], ay = wp[k * 2 + 1];
+    const bx = wp[j * 2], by = wp[j * 2 + 1];
+    const ex = bx - ax, ey = by - ay;
+    const len = dhypot(ex, ey) || 1;
+    const nx = ey / len, ny = -ex / len;
+    const startSep = (x0 - ax) * nx + (y0 - ay) * ny - r;
+    if (dx * nx + dy * ny < 0 && startSep > 0.5) {
+      const t = sweepVsSegment(x0, y0, dx, dy, ax + nx * r, ay + ny * r, bx + nx * r, by + ny * r);
+      if (t >= 0 && (best < 0 || t < best)) best = t;
+    }
+    const tv = sweepVsCircle(x0, y0, dx, dy, ax, ay, r);
+    if (tv >= 0 && (best < 0 || tv < best)) best = tv;
+  }
+  return best;
+}
+function sweepVsCircle(x0, y0, dx, dy, cx, cy, R) {
+  const fx = x0 - cx, fy = y0 - cy;
+  const a = dx * dx + dy * dy;
+  if (a < 1e-12) return -1;
+  const b = 2 * (fx * dx + fy * dy);
+  if (fx * fx + fy * fy < (R + 0.5) * (R + 0.5)) return -1;
+  const c = fx * fx + fy * fy - R * R;
+  const disc = b * b - 4 * a * c;
+  if (disc < 0) return -1;
+  const t = (-b - Math.sqrt(disc)) / (2 * a);
+  return t >= 0 && t <= 1 ? t : -1;
+}
+function sweepVsSegment(x0, y0, dx, dy, ax, ay, bx, by) {
+  const ex = bx - ax, ey = by - ay;
+  const denom = dx * ey - dy * ex;
+  if (Math.abs(denom) < 1e-12) return -1;
+  const t = ((ax - x0) * ey - (ay - y0) * ex) / denom;
+  const s = ((ax - x0) * dy - (ay - y0) * dx) / denom;
+  return t >= 0 && t <= 1 && s >= 0 && s <= 1 ? t : -1;
+}
+
+// src/physics/rigidQueries.ts
+function bodyContains(b, x, y) {
+  if (b.shape.kind === "circle") {
+    const dx = x - b.x, dy = y - b.y;
+    return dx * dx + dy * dy <= b.shape.r * b.shape.r;
+  }
+  const wp = worldPoints(b);
+  const n2 = wp.length / 2;
+  for (let k = 0; k < n2; k++) {
+    const j = (k + 1) % n2;
+    const ex = wp[j * 2] - wp[k * 2], ey = wp[j * 2 + 1] - wp[k * 2 + 1];
+    if ((x - wp[k * 2]) * ey - (y - wp[k * 2 + 1]) * ex > 0) return false;
+  }
+  return true;
+}
+function pointQuery(rw, x, y, mask = 65535) {
+  let hit;
+  for (const b of rw.bodies) if ((b.layer & mask) !== 0 && bodyContains(b, x, y)) hit = b;
+  return hit;
+}
+function rayCircle(x0, y0, dx, dy, cx, cy, r) {
+  const fx = x0 - cx, fy = y0 - cy;
+  const a = dx * dx + dy * dy;
+  if (a < 1e-12) return -1;
+  const b = 2 * (fx * dx + fy * dy);
+  const c = fx * fx + fy * fy - r * r;
+  const disc = b * b - 4 * a * c;
+  if (disc < 0) return -1;
+  const t = (-b - Math.sqrt(disc)) / (2 * a);
+  return t >= 0 && t <= 1 ? t : -1;
+}
+function rayCastRigid(rw, x0, y0, x1, y1, mask = 65535) {
+  const dx = x1 - x0, dy = y1 - y0;
+  let best = null;
+  for (const b of rw.bodies) {
+    if ((b.layer & mask) === 0) continue;
+    if (b.shape.kind === "circle") {
+      const t = rayCircle(x0, y0, dx, dy, b.x, b.y, b.shape.r);
+      if (t >= 0 && (!best || t < best.t)) {
+        const hx = x0 + dx * t, hy = y0 + dy * t;
+        const len = dhypot(hx - b.x, hy - b.y) || 1;
+        best = { id: b.id, t, x: hx, y: hy, nx: (hx - b.x) / len, ny: (hy - b.y) / len };
+      }
+      continue;
+    }
+    const wp = worldPoints(b);
+    const n2 = wp.length / 2;
+    for (let k = 0; k < n2; k++) {
+      const j = (k + 1) % n2;
+      const ax = wp[k * 2], ay = wp[k * 2 + 1];
+      const ex = wp[j * 2] - ax, ey = wp[j * 2 + 1] - ay;
+      const denom = dx * ey - dy * ex;
+      if (Math.abs(denom) < 1e-12) continue;
+      const t = ((ax - x0) * ey - (ay - y0) * ex) / denom;
+      const s = ((ax - x0) * dy - (ay - y0) * dx) / denom;
+      if (t < 0 || t > 1 || s < 0 || s > 1) continue;
+      if (!best || t < best.t) {
+        const len = dhypot(ex, ey) || 1;
+        best = { id: b.id, t, x: x0 + dx * t, y: y0 + dy * t, nx: ey / len, ny: -ex / len };
+      }
+    }
+  }
+  return best;
+}
+
 // src/render/commands.ts
 function sortCommands(cmds) {
   return cmds.map((c, i) => [c, i]).sort((a, b) => a[0].z - b[0].z || a[1] - b[1]).map(([c]) => c);
@@ -1585,6 +2834,7 @@ var Canvas2DRenderer = class {
     this.canvas = document.createElement("canvas");
     this.canvas.style.width = "100%";
     this.canvas.style.height = "100%";
+    this.canvas.style.objectFit = "contain";
     this.canvas.style.display = "block";
     const ctx = this.canvas.getContext("2d");
     if (!ctx) throw new Error("hayao: 2D canvas context unavailable");
@@ -1727,6 +2977,57 @@ var HeadlessRenderer = class {
   }
 };
 
+// src/render/nineSlice.ts
+function nineSlice(rect, style, z = 0, transform = IDENTITY) {
+  const b = Math.max(0, Math.min(style.border, rect.w / 2, rect.h / 2));
+  const fill = style.fill ?? "#fbf6ea";
+  const edge = style.edge ?? fill;
+  const corner = style.corner ?? edge;
+  const out = [];
+  const x0 = rect.x;
+  const x1 = rect.x + b;
+  const x2 = rect.x + rect.w - b;
+  const y0 = rect.y;
+  const y1 = rect.y + b;
+  const y2 = rect.y + rect.h - b;
+  const iw = rect.w - 2 * b;
+  const ih = rect.h - 2 * b;
+  const push = (x, y, w, h, f, r2) => {
+    if (w <= 0 || h <= 0) return;
+    out.push({ kind: "rect", x, y, w, h, r: r2, fill: f, transform, z });
+  };
+  push(x1, y1, iw, ih, fill);
+  push(x1, y0, iw, b, style.highlight ?? edge);
+  push(x1, y2, iw, b, style.shadow ?? edge);
+  push(x0, y1, b, ih, style.highlight ?? edge);
+  push(x2, y1, b, ih, style.shadow ?? edge);
+  const r = style.radius;
+  push(x0, y0, b, b, corner, r);
+  push(x2, y0, b, b, corner, r);
+  push(x0, y2, b, b, corner, r);
+  push(x2, y2, b, b, corner, r);
+  if (style.stroke) {
+    out.push({
+      kind: "rect",
+      x: rect.x,
+      y: rect.y,
+      w: rect.w,
+      h: rect.h,
+      r: style.radius,
+      fill: "none",
+      stroke: style.stroke,
+      strokeWidth: style.strokeWidth ?? 2,
+      transform,
+      z: z + 1e-3
+    });
+  }
+  return out;
+}
+var PANEL_PRESETS = {
+  parchment: () => ({ border: 10, fill: "#fbf6ea", edge: "#efe4c8", corner: "#e2d3a8", highlight: "#fdfaf0", shadow: "#d9c79c", stroke: "#b8a06a", strokeWidth: 2, radius: 4 }),
+  slate: () => ({ border: 8, fill: "#2c3040", edge: "#363c4f", corner: "#454c63", highlight: "#4a5268", shadow: "#20242f", stroke: "#151821", strokeWidth: 2, radius: 3 })
+};
+
 // src/art/palette.ts
 var MEADOW = {
   name: "meadow",
@@ -1784,7 +3085,103 @@ function hexToRgb(hex) {
   return [n2 >> 16 & 255, n2 >> 8 & 255, n2 & 255];
 }
 function rgbToHex(r, g, b) {
-  return "#" + [r, g, b].map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join("");
+  return "#" + [r, g, b].map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0")).join("");
+}
+var mod360 = (h) => (h % 360 + 360) % 360;
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function hsl(h, s, l) {
+  h = mod360(h) / 360;
+  s = clamp01(s);
+  l = clamp01(l);
+  if (s === 0) {
+    const v = l * 255;
+    return rgbToHex(v, v, v);
+  }
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const hue = (t) => {
+    t = t < 0 ? t + 1 : t > 1 ? t - 1 : t;
+    if (t < 1 / 6) return p + (q - p) * 6 * t;
+    if (t < 1 / 2) return q;
+    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+  };
+  return rgbToHex(hue(h + 1 / 3) * 255, hue(h) * 255, hue(h - 1 / 3) * 255);
+}
+function hsv(h, s, v) {
+  h = mod360(h) / 60;
+  s = clamp01(s);
+  v = clamp01(v);
+  const c = v * s;
+  const x = c * (1 - Math.abs(h % 2 - 1));
+  const m = v - c;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  if (h < 1) [r, g, b] = [c, x, 0];
+  else if (h < 2) [r, g, b] = [x, c, 0];
+  else if (h < 3) [r, g, b] = [0, c, x];
+  else if (h < 4) [r, g, b] = [0, x, c];
+  else if (h < 5) [r, g, b] = [x, 0, c];
+  else [r, g, b] = [c, 0, x];
+  return rgbToHex((r + m) * 255, (g + m) * 255, (b + m) * 255);
+}
+function hexToHsl(hex) {
+  const [r255, g255, b255] = hexToRgb(hex);
+  const r = r255 / 255;
+  const g = g255 / 255;
+  const b = b255 / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  const d = max - min;
+  if (d === 0) return { h: 0, s: 0, l };
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h;
+  if (max === r) h = (g - b) / d + (g < b ? 6 : 0);
+  else if (max === g) h = (b - r) / d + 2;
+  else h = (r - g) / d + 4;
+  return { h: h * 60, s, l };
+}
+function mutateColor(rng, hex, amounts = {}) {
+  const c = hexToHsl(hex);
+  const dh = amounts.hue ?? 0;
+  const ds = amounts.sat ?? 0;
+  const dl = amounts.light ?? 0;
+  return hsl(
+    c.h + rng.range(-dh, dh),
+    c.s + rng.range(-ds, ds),
+    c.l + rng.range(-dl, dl)
+  );
+}
+function dpow(base, exp) {
+  if (base <= 0) return 0;
+  return dexp2(exp * dlog2(base));
+}
+var srgbToLinear = (c) => c <= 0.04045 ? c / 12.92 : dpow((c + 0.055) / 1.055, 2.4);
+var linearToSrgb = (c) => c <= 31308e-7 ? c * 12.92 : 1.055 * dpow(c, 1 / 2.4) - 0.055;
+function mixLinear(a, b, t) {
+  const pa = hexToRgb(a);
+  const pb = hexToRgb(b);
+  const chan = (i) => {
+    const la = srgbToLinear(pa[i] / 255);
+    const lb = srgbToLinear(pb[i] / 255);
+    return linearToSrgb(la + (lb - la) * t) * 255;
+  };
+  return rgbToHex(chan(0), chan(1), chan(2));
+}
+function sampleGradient(stops, t) {
+  if (stops.length === 0) return "#000000";
+  if (stops.length === 1) return stops[0];
+  const clamped = clamp01(t);
+  const scaled = clamped * (stops.length - 1);
+  const i = Math.min(stops.length - 2, Math.floor(scaled));
+  return mixLinear(stops[i], stops[i + 1], scaled - i);
+}
+function gradient(stops, n2) {
+  if (n2 <= 0) return [];
+  if (n2 === 1) return [sampleGradient(stops, 0)];
+  return Array.from({ length: n2 }, (_, i) => sampleGradient(stops, i / (n2 - 1)));
 }
 
 // src/art/shapes.ts
@@ -1792,7 +3189,7 @@ function regularPolygon(sides, radius, rotation = 0) {
   const pts = [];
   for (let i = 0; i < sides; i++) {
     const a = rotation + i / sides * TAU;
-    pts.push(Math.cos(a) * radius, Math.sin(a) * radius);
+    pts.push(dcos(a) * radius, dsin(a) * radius);
   }
   return pts;
 }
@@ -1801,7 +3198,7 @@ function star(points, outer, inner, rotation = -Math.PI / 2) {
   for (let i = 0; i < points * 2; i++) {
     const r = i % 2 === 0 ? outer : inner;
     const a = rotation + i / (points * 2) * TAU;
-    pts.push(Math.cos(a) * r, Math.sin(a) * r);
+    pts.push(dcos(a) * r, dsin(a) * r);
   }
   return pts;
 }
@@ -1810,7 +3207,7 @@ function blobPath(rng, radius, wobble = 0.25, lobes = 7) {
   for (let i = 0; i < lobes; i++) {
     const a = i / lobes * TAU;
     const r = radius * (1 - wobble + rng.float() * wobble * 2);
-    pts.push({ x: Math.cos(a) * r, y: Math.sin(a) * r });
+    pts.push({ x: dcos(a) * r, y: dsin(a) * r });
   }
   return smoothClosedPath(pts);
 }
@@ -1852,40 +3249,828 @@ function smoothOpenPath(points, tension = 1) {
   return d;
 }
 
-// src/audio/audio.ts
-var DEFAULT_VOLUMES = { master: 0.7, music: 0.6, sfx: 0.8, muted: false };
-var AudioBus = class {
-  ctx = null;
-  master = null;
-  musicGain = null;
-  sfxGain = null;
-  vol = { ...DEFAULT_VOLUMES };
-  padOn = false;
-  get available() {
-    return typeof globalThis.AudioContext !== "undefined" || "webkitAudioContext" in globalThis;
+// src/art/texture.ts
+var PixelBuffer = class _PixelBuffer {
+  width;
+  height;
+  data;
+  constructor(width, height, data) {
+    this.width = width;
+    this.height = height;
+    this.data = data ?? new Uint8Array(width * height);
+  }
+  get(x, y) {
+    if (x < 0 || y < 0 || x >= this.width || y >= this.height) return 0;
+    return this.data[y * this.width + x];
+  }
+  set(x, y, index) {
+    if (x < 0 || y < 0 || x >= this.width || y >= this.height) return;
+    this.data[y * this.width + x] = index;
+  }
+  /** Build from a rows-of-strings grid, mapping each character to an index. */
+  static fromRows(rows, charToIndex) {
+    const height = rows.length;
+    const width = rows.reduce((w, r) => Math.max(w, r.length), 0);
+    const buf = new _PixelBuffer(width, height);
+    for (let y = 0; y < height; y++) {
+      const row = rows[y];
+      for (let x = 0; x < row.length; x++) buf.data[y * width + x] = charToIndex[row[x]] ?? 0;
+    }
+    return buf;
   }
-  get started() {
-    return !!this.ctx;
+  /** A copy with every index passed through `lut` (2-bit → palette remap). */
+  remap(lut) {
+    const out = new Uint8Array(this.data.length);
+    for (let i = 0; i < this.data.length; i++) out[i] = lut[this.data[i]] ?? 0;
+    return new _PixelBuffer(this.width, this.height, out);
   }
-  /** Must be called from a user gesture (browser autoplay policy). */
-  start() {
-    if (this.ctx) {
-      void this.ctx.resume();
-      return;
+};
+function toBig(source) {
+  if (typeof source === "bigint") return source;
+  const s = source.trim();
+  if (s.startsWith("0x") || s.startsWith("0b") || s.startsWith("0o")) return BigInt(s);
+  return BigInt("0x" + s);
+}
+function decodeBits(source, width, height) {
+  const bits = toBig(source);
+  const total = width * height;
+  const buf = new PixelBuffer(width, height);
+  for (let i = 0; i < total; i++) {
+    buf.data[i] = Number(bits >> BigInt(total - 1 - i) & 1n);
+  }
+  return buf;
+}
+function decode2bit(source, width, height) {
+  const bits = toBig(source);
+  const total = width * height;
+  const buf = new PixelBuffer(width, height);
+  for (let i = 0; i < total; i++) {
+    const shift = BigInt((total - 1 - i) * 2);
+    buf.data[i] = Number(bits >> shift & 3n);
+  }
+  return buf;
+}
+function decodeRLE(runs, width, height) {
+  const buf = new PixelBuffer(width, height);
+  let p = 0;
+  for (let i = 0; i + 1 < runs.length; i += 2) {
+    const count = runs[i];
+    const index = runs[i + 1];
+    for (let k = 0; k < count && p < buf.data.length; k++) buf.data[p++] = index;
+  }
+  return buf;
+}
+function encodeRLE(buf) {
+  const runs = [];
+  const d = buf.data;
+  for (let i = 0; i < d.length; ) {
+    const v = d[i];
+    let count = 1;
+    while (i + count < d.length && d[i + count] === v) count++;
+    runs.push(count, v);
+    i += count;
+  }
+  return runs;
+}
+function pixelsToCommands(buf, palette, options = {}) {
+  const cell = options.cell ?? 1;
+  const ox = options.x ?? 0;
+  const oy = options.y ?? 0;
+  const z = options.z ?? 0;
+  const transform = options.transform ?? IDENTITY;
+  const out = [];
+  for (let y = 0; y < buf.height; y++) {
+    let x = 0;
+    while (x < buf.width) {
+      const idx = buf.get(x, y);
+      const fill = palette[idx];
+      if (fill == null) {
+        x++;
+        continue;
+      }
+      let run = 1;
+      while (x + run < buf.width && buf.get(x + run, y) === idx) run++;
+      out.push({
+        kind: "rect",
+        x: ox + x * cell,
+        y: oy + y * cell,
+        w: run * cell,
+        h: cell,
+        transform,
+        z,
+        fill
+      });
+      x += run;
     }
-    if (!this.available) return;
-    const Ctx = globalThis.AudioContext || globalThis.webkitAudioContext;
-    this.ctx = new Ctx();
-    this.master = this.ctx.createGain();
-    this.musicGain = this.ctx.createGain();
-    this.sfxGain = this.ctx.createGain();
-    this.musicGain.connect(this.master);
-    this.sfxGain.connect(this.master);
-    this.master.connect(this.ctx.destination);
-    this.applyVolumes();
   }
-  setVolumes(v) {
-    this.vol = { ...this.vol, ...v };
+  return out;
+}
+var TextureSprite = class extends Node {
+  type = "TextureSprite";
+  buffer;
+  palette;
+  cell;
+  center;
+  constructor(config) {
+    super(config);
+    this.buffer = config.buffer;
+    this.palette = config.palette;
+    this.cell = config.cell ?? 1;
+    this.center = config.center ?? true;
+    this.cosmetic = true;
+  }
+  draw(out, world) {
+    const cell = this.cell;
+    const x = this.center ? -(this.buffer.width * cell) / 2 : 0;
+    const y = this.center ? -(this.buffer.height * cell) / 2 : 0;
+    for (const cmd of pixelsToCommands(this.buffer, this.palette, { cell, x, y, z: this.z, transform: world })) {
+      out.push(cmd);
+    }
+  }
+};
+
+// src/art/font5.ts
+var G = {
+  A: [".#.", "#.#", "###", "#.#", "#.#"],
+  B: ["##.", "#.#", "##.", "#.#", "##."],
+  C: [".##", "#..", "#..", "#..", ".##"],
+  D: ["##.", "#.#", "#.#", "#.#", "##."],
+  E: ["###", "#..", "##.", "#..", "###"],
+  F: ["###", "#..", "##.", "#..", "#.."],
+  G: [".##", "#..", "#.#", "#.#", ".##"],
+  H: ["#.#", "#.#", "###", "#.#", "#.#"],
+  I: ["#", "#", "#", "#", "#"],
+  J: ["..#", "..#", "..#", "#.#", ".#."],
+  K: ["#.#", "##.", "#..", "##.", "#.#"],
+  L: ["#..", "#..", "#..", "#..", "###"],
+  M: ["#...#", "##.##", "#.#.#", "#...#", "#...#"],
+  N: ["#...#", "##..#", "#.#.#", "#..##", "#...#"],
+  O: [".#.", "#.#", "#.#", "#.#", ".#."],
+  P: ["##.", "#.#", "##.", "#..", "#.."],
+  Q: [".#.", "#.#", "#.#", "#.#", ".##"],
+  R: ["##.", "#.#", "##.", "#.#", "#.#"],
+  S: [".##", "#..", ".#.", "..#", "##."],
+  T: ["###", ".#.", ".#.", ".#.", ".#."],
+  U: ["#.#", "#.#", "#.#", "#.#", "###"],
+  V: ["#.#", "#.#", "#.#", "#.#", ".#."],
+  W: ["#...#", "#...#", "#.#.#", "##.##", "#...#"],
+  X: ["#.#", "#.#", ".#.", "#.#", "#.#"],
+  Y: ["#.#", "#.#", ".#.", ".#.", ".#."],
+  Z: ["###", "..#", ".#.", "#..", "###"],
+  "0": [".#.", "#.#", "#.#", "#.#", ".#."],
+  "1": [".#.", "##.", ".#.", ".#.", "###"],
+  "2": ["##.", "..#", ".#.", "#..", "###"],
+  "3": ["##.", "..#", ".#.", "..#", "##."],
+  "4": ["#.#", "#.#", "###", "..#", "..#"],
+  "5": ["###", "#..", "##.", "..#", "##."],
+  "6": [".##", "#..", "##.", "#.#", ".#."],
+  "7": ["###", "..#", ".#.", ".#.", ".#."],
+  "8": [".#.", "#.#", ".#.", "#.#", ".#."],
+  "9": [".#.", "#.#", ".##", "..#", "##."],
+  ".": [".", ".", ".", ".", "#"],
+  ",": ["..", "..", "..", ".#", "#."],
+  "!": ["#", "#", "#", ".", "#"],
+  "?": ["##.", "..#", ".#.", "...", ".#."],
+  ":": [".", "#", ".", "#", "."],
+  ";": ["..", ".#", "..", ".#", "#."],
+  "-": ["...", "...", "###", "...", "..."],
+  "+": ["...", ".#.", "###", ".#.", "..."],
+  "=": ["...", "###", "...", "###", "..."],
+  "/": ["..#", "..#", ".#.", "#..", "#.."],
+  "'": ["#", "#", ".", ".", "."],
+  '"': ["#.#", "#.#", "...", "...", "..."],
+  "(": [".#", "#.", "#.", "#.", ".#"],
+  ")": ["#.", ".#", ".#", ".#", "#."],
+  "<": ["..#", ".#.", "#..", ".#.", "..#"],
+  ">": ["#..", ".#.", "..#", ".#.", "#.."],
+  "%": ["#.#", "..#", ".#.", "#..", "#.#"],
+  "*": ["...", "#.#", ".#.", "#.#", "..."],
+  "#": ["#.#", "###", "#.#", "###", "#.#"]
+};
+var FONT_5 = {
+  height: 5,
+  tracking: 1,
+  spaceWidth: 3,
+  glyphs: G
+};
+
+// src/art/bitmapFont.ts
+function parseRich(markup, colorMap = {}) {
+  const out = [];
+  const stack = [];
+  let i = 0;
+  let srcIndex = 0;
+  while (i < markup.length) {
+    const c = markup[i];
+    if (c === "{" && markup[i + 1] === "{") {
+      out.push({ ch: "{", color: stack[stack.length - 1], i: srcIndex++ });
+      i += 2;
+      continue;
+    }
+    if (c === "{") {
+      const end = markup.indexOf("}", i);
+      if (end === -1) {
+        out.push({ ch: c, color: stack[stack.length - 1], i: srcIndex++ });
+        i++;
+        continue;
+      }
+      const tag = markup.slice(i + 1, end);
+      if (tag === "/") stack.pop();
+      else stack.push(tag[0] === "#" ? tag : colorMap[tag] ?? tag);
+      i = end + 1;
+      continue;
+    }
+    out.push({ ch: c, color: stack[stack.length - 1], i: srcIndex++ });
+    i++;
+  }
+  return out;
+}
+function resolveChar(font, ch) {
+  if (ch === " " || ch === "\n") return ch;
+  const up = ch.toUpperCase();
+  if (font.glyphs[up]) return up;
+  if (font.glyphs[ch]) return ch;
+  return font.glyphs["?"] ? "?" : " ";
+}
+function glyphWidth(font, ch) {
+  if (ch === " ") return font.spaceWidth;
+  const rows = font.glyphs[ch];
+  return rows ? rows[0].length : font.spaceWidth;
+}
+function measureLine(font, chars) {
+  let w = 0;
+  for (let k = 0; k < chars.length; k++) {
+    w += glyphWidth(font, chars[k].ch);
+    if (k < chars.length - 1) w += font.tracking;
+  }
+  return w;
+}
+function measureText(font, text) {
+  return measureLine(font, [...text].map((ch, i) => ({ ch: resolveChar(font, ch), i })));
+}
+function layoutText(font, input, options = {}) {
+  const lineSpacing = options.lineSpacing ?? 1;
+  const source = typeof input === "string" ? [...input].map((ch, i) => ({ ch, i })) : input.map((r) => ({ ...r }));
+  const hardLines = [[]];
+  for (const rc of source) {
+    if (rc.ch === "\n") hardLines.push([]);
+    else hardLines[hardLines.length - 1].push({ ...rc, ch: resolveChar(font, rc.ch) });
+  }
+  const rows = [];
+  for (const line of hardLines) {
+    if (options.maxWidth === void 0) {
+      rows.push(line);
+      continue;
+    }
+    let current = [];
+    let word = [];
+    const flushWord = () => {
+      if (word.length === 0) return;
+      const sep = current.length ? font.spaceWidth + font.tracking : 0;
+      if (current.length && measureLine(font, current) + sep + measureLine(font, word) > options.maxWidth) {
+        rows.push(current);
+        current = [];
+      }
+      if (current.length) current.push({ ch: " ", i: -1 });
+      current.push(...word);
+      word = [];
+    };
+    for (const rc of line) {
+      if (rc.ch === " ") flushWord();
+      else word.push(rc);
+    }
+    flushWord();
+    rows.push(current);
+  }
+  const glyphs = [];
+  let maxW = 0;
+  for (const row of rows) maxW = Math.max(maxW, measureLine(font, row));
+  const boundW = options.maxWidth ?? maxW;
+  let y = 0;
+  for (const row of rows) {
+    const rowW = measureLine(font, row);
+    let x = options.align === "center" ? Math.floor((boundW - rowW) / 2) : options.align === "right" ? boundW - rowW : 0;
+    for (const rc of row) {
+      const w = glyphWidth(font, rc.ch);
+      if (rc.ch !== " ") glyphs.push({ ch: rc.ch, color: rc.color, i: rc.i, x, y, w });
+      x += w + font.tracking;
+    }
+    y += font.height + lineSpacing;
+  }
+  return { glyphs, width: boundW, height: rows.length * (font.height + lineSpacing) - lineSpacing, lines: rows.length };
+}
+function typewriterCount(total, elapsedSec, charsPerSec) {
+  if (charsPerSec <= 0) return total;
+  const n2 = Math.floor(elapsedSec * charsPerSec);
+  return n2 < 0 ? 0 : n2 > total ? total : n2;
+}
+function textToCommands(font, layout, options = {}) {
+  const cell = options.cell ?? 2;
+  const ox = options.x ?? 0;
+  const oy = options.y ?? 0;
+  const z = options.z ?? 0;
+  const transform = options.transform ?? IDENTITY;
+  const defColor = options.color ?? "#000";
+  const reveal = options.reveal;
+  const out = [];
+  for (const g of layout.glyphs) {
+    if (reveal !== void 0 && g.i >= reveal) continue;
+    const rows = font.glyphs[g.ch];
+    if (!rows) continue;
+    const fill = g.color ?? defColor;
+    for (let ry = 0; ry < rows.length; ry++) {
+      const row = rows[ry];
+      let cx = 0;
+      while (cx < row.length) {
+        if (row[cx] !== "#") {
+          cx++;
+          continue;
+        }
+        let run = 1;
+        while (cx + run < row.length && row[cx + run] === "#") run++;
+        out.push({
+          kind: "rect",
+          x: ox + (g.x + cx) * cell,
+          y: oy + (g.y + ry) * cell,
+          w: run * cell,
+          h: cell,
+          transform,
+          z,
+          fill
+        });
+        cx += run;
+      }
+    }
+  }
+  return out;
+}
+var BitmapText = class extends Node {
+  type = "BitmapText";
+  text;
+  font;
+  cell;
+  color;
+  colorMap;
+  maxWidth;
+  lineSpacing;
+  align;
+  charsPerSec;
+  center;
+  startTime = 0;
+  constructor(config) {
+    super(config);
+    this.text = config.text;
+    this.font = config.font ?? FONT_5;
+    this.cell = config.cell ?? 2;
+    this.color = config.color ?? "#000";
+    this.colorMap = config.colorMap ?? {};
+    this.maxWidth = config.maxWidth;
+    this.lineSpacing = config.lineSpacing ?? 1;
+    this.align = config.align ?? "left";
+    this.charsPerSec = config.charsPerSec;
+    this.center = config.center ?? false;
+    this.cosmetic = true;
+  }
+  onReady() {
+    this.startTime = this.world?.time ?? 0;
+  }
+  /** Restart the typewriter from the current sim time. */
+  restartReveal() {
+    this.startTime = this.world?.time ?? 0;
+  }
+  buildLayout() {
+    const chars = parseRich(this.text, this.colorMap);
+    return layoutText(this.font, chars, { maxWidth: this.maxWidth, lineSpacing: this.lineSpacing, align: this.align });
+  }
+  draw(out, world) {
+    const layout = this.buildLayout();
+    let reveal;
+    if (this.charsPerSec !== void 0) {
+      const elapsed = (this.world?.time ?? 0) - this.startTime;
+      reveal = typewriterCount(this.text.length, elapsed, this.charsPerSec);
+    }
+    const x = this.center ? -(layout.width * this.cell) / 2 : 0;
+    const y = this.center ? -(layout.height * this.cell) / 2 : 0;
+    for (const cmd of textToCommands(this.font, layout, {
+      cell: this.cell,
+      x,
+      y,
+      z: this.z,
+      color: this.color,
+      transform: world,
+      reveal
+    })) {
+      out.push(cmd);
+    }
+  }
+};
+
+// src/art/autotile.ts
+function gridFromRows(rows, solid = "#") {
+  return rows.map((r) => [...r].map((c) => solid.includes(c)));
+}
+function at(grid, x, y) {
+  return y >= 0 && y < grid.length && x >= 0 && x < grid[y].length && grid[y][x];
+}
+var Edge = { N: 1, E: 2, S: 4, W: 8 };
+function mask4(grid, x, y) {
+  return (at(grid, x, y - 1) ? Edge.N : 0) | (at(grid, x + 1, y) ? Edge.E : 0) | (at(grid, x, y + 1) ? Edge.S : 0) | (at(grid, x - 1, y) ? Edge.W : 0);
+}
+function mask8(grid, x, y) {
+  let m = 0;
+  const dirs = [
+    [0, -1],
+    [1, -1],
+    [1, 0],
+    [1, 1],
+    [0, 1],
+    [-1, 1],
+    [-1, 0],
+    [-1, -1]
+  ];
+  for (let i = 0; i < 8; i++) if (at(grid, x + dirs[i][0], y + dirs[i][1])) m |= 1 << i;
+  return m;
+}
+var WangFrame = { Isolated: 0, Cap: 1, Straight: 2, Bend: 3, Tee: 4, Cross: 5 };
+function rotateCW(m) {
+  let r = 0;
+  if (m & Edge.N) r |= Edge.E;
+  if (m & Edge.E) r |= Edge.S;
+  if (m & Edge.S) r |= Edge.W;
+  if (m & Edge.W) r |= Edge.N;
+  return r;
+}
+var WANG4 = (() => {
+  const bases = [
+    [WangFrame.Isolated, 0],
+    [WangFrame.Cap, Edge.N],
+    [WangFrame.Straight, Edge.N | Edge.S],
+    [WangFrame.Bend, Edge.N | Edge.E],
+    [WangFrame.Tee, Edge.N | Edge.E | Edge.S],
+    [WangFrame.Cross, 15]
+  ];
+  const table = new Array(16);
+  for (const [frame, mask0] of bases) {
+    let m = mask0;
+    for (let rotation = 0; rotation < 4; rotation++) {
+      if (table[m] === void 0) table[m] = { mask: m, frame, rotation };
+      m = rotateCW(m);
+    }
+  }
+  return table;
+})();
+function wangTile(mask) {
+  return WANG4[mask & 15];
+}
+function autotile4(grid) {
+  return grid.map((row, y) => row.map((solid, x) => solid ? wangTile(mask4(grid, x, y)) : null));
+}
+function marchingSquaresCases(grid) {
+  const h = grid.length;
+  const w = h ? grid[0].length : 0;
+  const out = [];
+  for (let y = 0; y < h - 1; y++) {
+    const row = [];
+    for (let x = 0; x < w - 1; x++) {
+      row.push(
+        (at(grid, x, y) ? 1 : 0) | (at(grid, x + 1, y) ? 2 : 0) | (at(grid, x + 1, y + 1) ? 4 : 0) | (at(grid, x, y + 1) ? 8 : 0)
+      );
+    }
+    out.push(row);
+  }
+  return out;
+}
+var MS_SEGMENTS = [
+  [],
+  // 0
+  [["L", "T"]],
+  // 1 TL
+  [["T", "R"]],
+  // 2 TR
+  [["L", "R"]],
+  // 3 TL,TR
+  [["R", "B"]],
+  // 4 BR
+  [["L", "T"], ["R", "B"]],
+  // 5 saddle
+  [["T", "B"]],
+  // 6 TR,BR
+  [["L", "B"]],
+  // 7 TL,TR,BR
+  [["B", "L"]],
+  // 8 BL
+  [["T", "B"]],
+  // 9 TL,BL
+  [["T", "R"], ["B", "L"]],
+  // 10 saddle
+  [["R", "B"]],
+  // 11 TL,TR,BL
+  [["L", "R"]],
+  // 12 BR,BL
+  [["T", "R"]],
+  // 13 TL,BR,BL
+  [["L", "T"]],
+  // 14 TR,BR,BL
+  []
+  // 15
+];
+function marchingSquaresContours(grid, options = {}) {
+  const cell = options.cell ?? 1;
+  const ox = options.x ?? 0;
+  const oy = options.y ?? 0;
+  const cases = marchingSquaresCases(grid);
+  const segs = [];
+  const mid = (edge, cx, cy) => {
+    switch (edge) {
+      case "T":
+        return { x: cx + cell / 2, y: cy };
+      case "R":
+        return { x: cx + cell, y: cy + cell / 2 };
+      case "B":
+        return { x: cx + cell / 2, y: cy + cell };
+      case "L":
+        return { x: cx, y: cy + cell / 2 };
+    }
+  };
+  for (let y = 0; y < cases.length; y++) {
+    for (let x = 0; x < cases[y].length; x++) {
+      const cx = ox + x * cell;
+      const cy = oy + y * cell;
+      for (const [e1, e2] of MS_SEGMENTS[cases[y][x]]) segs.push({ a: mid(e1, cx, cy), b: mid(e2, cx, cy) });
+    }
+  }
+  return segs;
+}
+function autotileToCommands(grid, options = {}) {
+  const tile = options.tile ?? 8;
+  const ox = options.x ?? 0;
+  const oy = options.y ?? 0;
+  const z = options.z ?? 0;
+  const transform = options.transform ?? IDENTITY;
+  const fill = options.fill ?? "#888";
+  const edge = options.edge;
+  const edgeWidth = options.edgeWidth ?? Math.max(1, tile / 8);
+  const out = [];
+  for (let y = 0; y < grid.length; y++) {
+    for (let x = 0; x < grid[y].length; x++) {
+      if (!grid[y][x]) continue;
+      const px = ox + x * tile;
+      const py = oy + y * tile;
+      out.push({ kind: "rect", x: px, y: py, w: tile, h: tile, transform, z, fill });
+      if (!edge) continue;
+      const m = mask4(grid, x, y);
+      const line = (points) => out.push({ kind: "poly", points, closed: false, transform, z: z + 1, stroke: edge, strokeWidth: edgeWidth });
+      if (!(m & Edge.N)) line([px, py, px + tile, py]);
+      if (!(m & Edge.E)) line([px + tile, py, px + tile, py + tile]);
+      if (!(m & Edge.S)) line([px, py + tile, px + tile, py + tile]);
+      if (!(m & Edge.W)) line([px, py, px, py + tile]);
+    }
+  }
+  return out;
+}
+function contourToCommands(grid, options = {}) {
+  const tile = options.tile ?? 8;
+  const transform = options.transform ?? IDENTITY;
+  const z = options.z ?? 0;
+  const stroke = options.edge ?? options.fill ?? "#333";
+  const strokeWidth = options.edgeWidth ?? Math.max(1, tile / 8);
+  const segs = marchingSquaresContours(grid, { cell: tile, x: options.x ?? 0, y: options.y ?? 0 });
+  return segs.map((s) => ({
+    kind: "poly",
+    points: [s.a.x, s.a.y, s.b.x, s.b.y],
+    closed: false,
+    transform,
+    z,
+    stroke,
+    strokeWidth,
+    round: true
+  }));
+}
+
+// src/procgen/grid.ts
+function makeGrid(cols, rows, fill = 0) {
+  return { cols, rows, cells: new Array(cols * rows).fill(fill) };
+}
+function gridAt(g, x, y) {
+  if (x < 0 || y < 0 || x >= g.cols || y >= g.rows) return 1;
+  return g.cells[y * g.cols + x];
+}
+function gridSet(g, x, y, v) {
+  if (x < 0 || y < 0 || x >= g.cols || y >= g.rows) return;
+  g.cells[y * g.cols + x] = v;
+}
+function solidNeighbours(g, x, y) {
+  let n2 = 0;
+  for (let dy = -1; dy <= 1; dy++) {
+    for (let dx = -1; dx <= 1; dx++) {
+      if (dx === 0 && dy === 0) continue;
+      if (gridAt(g, x + dx, y + dy) === 1) n2++;
+    }
+  }
+  return n2;
+}
+function gridToTilemap(g, tileSize = 32) {
+  const tiles = g.cells.map((c) => c === 1 ? TILE.SOLID : TILE.EMPTY);
+  return { cols: g.cols, rows: g.rows, tileSize, tiles };
+}
+
+// src/procgen/scatter.ts
+function cellHash(x, y, seed = 0) {
+  let h = (seed ^ 2654435769) >>> 0;
+  h = Math.imul(h ^ (x | 0), 2246822507) >>> 0;
+  h = Math.imul(h ^ (y | 0), 3266489909) >>> 0;
+  h ^= h >>> 13;
+  h = Math.imul(h, 668265263) >>> 0;
+  h ^= h >>> 15;
+  return h >>> 0;
+}
+function cellFloat(x, y, seed = 0) {
+  return cellHash(x, y, seed) / 4294967296;
+}
+function cellInt(x, y, n2, seed = 0) {
+  return Math.floor(cellFloat(x, y, seed) * n2);
+}
+function scatter(x, y, probability, seed = 0) {
+  return cellFloat(x, y, seed) < probability;
+}
+function scatterCells(x0, y0, cols, rows, probability, seed = 0) {
+  const out = [];
+  for (let y = y0; y < y0 + rows; y++) {
+    for (let x = x0; x < x0 + cols; x++) {
+      if (scatter(x, y, probability, seed)) out.push({ x, y });
+    }
+  }
+  return out;
+}
+var smooth = (t) => t * t * (3 - 2 * t);
+function valueNoise(x, y, seed = 0) {
+  const x0 = Math.floor(x);
+  const y0 = Math.floor(y);
+  const fx = smooth(x - x0);
+  const fy = smooth(y - y0);
+  const c00 = cellFloat(x0, y0, seed);
+  const c10 = cellFloat(x0 + 1, y0, seed);
+  const c01 = cellFloat(x0, y0 + 1, seed);
+  const c11 = cellFloat(x0 + 1, y0 + 1, seed);
+  const top = c00 + (c10 - c00) * fx;
+  const bot = c01 + (c11 - c01) * fx;
+  return top + (bot - top) * fy;
+}
+function fractalNoise(x, y, seed = 0, opts = {}) {
+  const octaves = opts.octaves ?? 4;
+  const lacunarity = opts.lacunarity ?? 2;
+  const gain = opts.gain ?? 0.5;
+  let amp = 1;
+  let freq = 1;
+  let sum = 0;
+  let norm = 0;
+  for (let o = 0; o < octaves; o++) {
+    sum += amp * valueNoise(x * freq, y * freq, seed + o);
+    norm += amp;
+    amp *= gain;
+    freq *= lacunarity;
+  }
+  return norm === 0 ? 0 : sum / norm;
+}
+
+// src/procgen/cave.ts
+function generateCave(rng, opts) {
+  const { cols, rows } = opts;
+  const fill = opts.fill ?? 0.45;
+  const steps = opts.steps ?? 4;
+  const birth = opts.birth ?? 5;
+  const survive = opts.survive ?? 4;
+  const border = opts.border ?? true;
+  let g = makeGrid(cols, rows, 0);
+  for (let y = 0; y < rows; y++) {
+    for (let x = 0; x < cols; x++) {
+      const edge = border && (x === 0 || y === 0 || x === cols - 1 || y === rows - 1);
+      gridSet(g, x, y, edge || rng.chance(fill) ? 1 : 0);
+    }
+  }
+  for (let s = 0; s < steps; s++) {
+    const next = makeGrid(cols, rows, 0);
+    for (let y = 0; y < rows; y++) {
+      for (let x = 0; x < cols; x++) {
+        if (border && (x === 0 || y === 0 || x === cols - 1 || y === rows - 1)) {
+          gridSet(next, x, y, 1);
+          continue;
+        }
+        const n2 = solidNeighbours(g, x, y);
+        const wasSolid = g.cells[y * cols + x] === 1;
+        gridSet(next, x, y, (wasSolid ? n2 >= survive : n2 >= birth) ? 1 : 0);
+      }
+    }
+    g = next;
+  }
+  return g;
+}
+
+// src/procgen/terrain.ts
+function terrainHeight(col, opts) {
+  const scale = opts.scale ?? 0.08;
+  const seed = opts.seed ?? 0;
+  const n2 = fractalNoise(col * scale, 0, seed, opts.fractal) * 2 - 1;
+  let row = Math.round(opts.base + n2 * opts.amplitude);
+  if (opts.minRow !== void 0 || opts.maxRow !== void 0) {
+    row = clamp(row, opts.minRow ?? -Infinity, opts.maxRow ?? Infinity);
+  }
+  return row;
+}
+function terrainSlice(startCol, count, opts) {
+  const out = new Array(count);
+  for (let i = 0; i < count; i++) out[i] = terrainHeight(startCol + i, opts);
+  return out;
+}
+function isGround(col, row, opts) {
+  return row >= terrainHeight(col, opts);
+}
+
+// src/procgen/rooms.ts
+function roomCenter(r) {
+  return { x: Math.floor(r.x + r.w / 2), y: Math.floor(r.y + r.h / 2) };
+}
+function overlaps(a, b) {
+  return a.x <= b.x + b.w && a.x + a.w >= b.x && a.y <= b.y + b.h && a.y + a.h >= b.y;
+}
+function carveRoom(g, r) {
+  for (let y = r.y; y < r.y + r.h; y++) {
+    for (let x = r.x; x < r.x + r.w; x++) gridSet(g, x, y, 0);
+  }
+}
+function carveHCorridor(g, x0, x1, y) {
+  for (let x = Math.min(x0, x1); x <= Math.max(x0, x1); x++) gridSet(g, x, y, 0);
+}
+function carveVCorridor(g, y0, y1, x) {
+  for (let y = Math.min(y0, y1); y <= Math.max(y0, y1); y++) gridSet(g, x, y, 0);
+}
+function generateDungeon(rng, opts) {
+  const { cols, rows } = opts;
+  const attempts = opts.attempts ?? 12;
+  const minSize = opts.minSize ?? 4;
+  const maxSize = opts.maxSize ?? 8;
+  const margin = opts.border ?? true ? 1 : 0;
+  const g = makeGrid(cols, rows, 1);
+  const rooms = [];
+  for (let i = 0; i < attempts; i++) {
+    const w = rng.intRange(minSize, maxSize);
+    const h = rng.intRange(minSize, maxSize);
+    const x = rng.intRange(margin, cols - w - margin - 1);
+    const y = rng.intRange(margin, rows - h - margin - 1);
+    if (x < margin || y < margin) continue;
+    const room = { x, y, w, h };
+    if (rooms.some((r) => overlaps(room, r))) continue;
+    carveRoom(g, room);
+    if (rooms.length > 0) {
+      const prev = roomCenter(rooms[rooms.length - 1]);
+      const cur = roomCenter(room);
+      if (rng.chance(0.5)) {
+        carveHCorridor(g, prev.x, cur.x, prev.y);
+        carveVCorridor(g, prev.y, cur.y, cur.x);
+      } else {
+        carveVCorridor(g, prev.y, cur.y, prev.x);
+        carveHCorridor(g, prev.x, cur.x, cur.y);
+      }
+    }
+    rooms.push(room);
+  }
+  return { rooms, grid: g };
+}
+
+// src/audio/audio.ts
+var DEFAULT_VOLUMES = { master: 0.7, music: 0.6, sfx: 0.8, muted: false };
+var AudioBus = class {
+  ctx = null;
+  master = null;
+  musicGain = null;
+  sfxGain = null;
+  vol = { ...DEFAULT_VOLUMES };
+  padOn = false;
+  get available() {
+    return typeof globalThis.AudioContext !== "undefined" || "webkitAudioContext" in globalThis;
+  }
+  get started() {
+    return !!this.ctx;
+  }
+  /** Must be called from a user gesture (browser autoplay policy). */
+  start() {
+    if (this.ctx) {
+      void this.ctx.resume();
+      return;
+    }
+    if (!this.available) return;
+    const Ctx = globalThis.AudioContext || globalThis.webkitAudioContext;
+    this.ctx = new Ctx();
+    this.master = this.ctx.createGain();
+    this.musicGain = this.ctx.createGain();
+    this.sfxGain = this.ctx.createGain();
+    this.musicGain.connect(this.master);
+    this.sfxGain.connect(this.master);
+    this.master.connect(this.ctx.destination);
+    this.applyVolumes();
+  }
+  setVolumes(v) {
+    this.vol = { ...this.vol, ...v };
     this.applyVolumes();
   }
   getVolumes() {
@@ -1901,7 +4086,7 @@ var AudioBus = class {
   /** Play a single tone (no-op if audio unstarted). */
   tone(spec) {
     if (!this.ctx || !this.sfxGain) return;
-    const { freq, duration, type = "sine", gain = 0.2, delay = 0 } = spec;
+    const { freq, duration, type = "sine", gain = 0.2, delay = 0, pan } = spec;
     const t = this.ctx.currentTime + delay;
     const osc = this.ctx.createOscillator();
     osc.type = type;
@@ -1911,10 +4096,26 @@ var AudioBus = class {
     g.gain.linearRampToValueAtTime(gain, t + 8e-3);
     g.gain.exponentialRampToValueAtTime(1e-4, t + duration);
     osc.connect(g);
-    g.connect(this.sfxGain);
+    if (pan !== void 0 && typeof this.ctx.createStereoPanner === "function") {
+      const p = this.ctx.createStereoPanner();
+      p.pan.value = Math.max(-1, Math.min(1, pan));
+      g.connect(p);
+      p.connect(this.sfxGain);
+    } else {
+      g.connect(this.sfxGain);
+    }
     osc.start(t);
     osc.stop(t + duration + 0.05);
   }
+  /**
+   * A positional cue: gain falls with distance, pan follows the horizontal
+   * offset. dx/dist in design-space px; hearing range sets the falloff.
+   */
+  spatial(freq, dx, dist, hearing = 600, duration = 0.18, type = "sawtooth") {
+    if (dist > hearing) return;
+    const near = 1 - dist / hearing;
+    this.tone({ freq, duration, type, gain: 0.04 + near * near * 0.3, pan: Math.max(-1, Math.min(1, dx / (hearing * 0.6))) });
+  }
   /** Play a sequence of tones as an arpeggio/chord. */
   play(tones) {
     for (const t of tones) this.tone(t);
@@ -2181,6 +4382,187 @@ var Shell = class {
   }
 };
 
+// src/ui/transition.ts
+var BAYER4 = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
+var smoothstep2 = (t) => t * t * (3 - 2 * t);
+var ScreenTransition = class extends Node {
+  type = "ScreenTransition";
+  kind;
+  color;
+  screenW;
+  screenH;
+  cell;
+  /** 0 = fully clear, 1 = fully covering. */
+  coverage = 0;
+  queue = [];
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+    this.kind = config.kind ?? "fade";
+    this.color = config.color ?? "#1a1410";
+    this.screenW = config.width ?? 1280;
+    this.screenH = config.height ?? 720;
+    this.cell = config.cell ?? 28;
+  }
+  /** True while a wipe is animating. */
+  get busy() {
+    return this.queue.length > 0;
+  }
+  enqueue(to, dur, onEnd) {
+    this.queue.push({ from: void 0, to, dur: Math.max(1e-4, dur), elapsed: 0, onEnd });
+  }
+  /** Animate the overlay to fully covering over `dur` seconds. */
+  cover(dur = 0.4, onEnd) {
+    this.enqueue(1, dur, onEnd);
+    return this;
+  }
+  /** Animate the overlay back to fully clear over `dur` seconds. */
+  reveal(dur = 0.4, onEnd) {
+    this.enqueue(0, dur, onEnd);
+    return this;
+  }
+  /** Hold the current coverage for `dur` seconds (chains after cover/reveal). */
+  hold(dur, onEnd) {
+    const target = this.queue.length ? this.queue[this.queue.length - 1].to : this.coverage;
+    this.enqueue(target, dur, onEnd);
+    return this;
+  }
+  /** The classic cover → onMidpoint → reveal sequence. Returns this for chaining. */
+  wipe(opts = {}) {
+    const cover = opts.cover ?? 0.4;
+    this.cover(cover, () => {
+      this.emit("covered", void 0);
+      opts.onMidpoint?.();
+    });
+    if (opts.hold) this.hold(opts.hold);
+    this.reveal(opts.reveal ?? cover, () => {
+      this.emit("done", void 0);
+      opts.onDone?.();
+    });
+    return this;
+  }
+  /** Signal emitted at full cover (the midpoint). */
+  get covered() {
+    return this.signal("covered");
+  }
+  /** Signal emitted when a wipe fully finishes revealing. */
+  get done() {
+    return this.signal("done");
+  }
+  onProcess(dt) {
+    const step = this.queue[0];
+    if (!step) return;
+    if (step.from === void 0) step.from = this.coverage;
+    step.elapsed += dt;
+    const t = clamp(step.elapsed / step.dur, 0, 1);
+    this.coverage = lerp(step.from, step.to, smoothstep2(t));
+    if (t >= 1) {
+      this.coverage = step.to;
+      const end = step.onEnd;
+      this.queue.shift();
+      end?.();
+    }
+  }
+  draw(out, _world) {
+    const c = this.coverage;
+    if (c <= 0) return;
+    const z = this.z;
+    if (this.kind === "fade") {
+      out.push({ kind: "rect", x: 0, y: 0, w: this.screenW, h: this.screenH, fill: this.color, opacity: c, transform: IDENTITY, z });
+      return;
+    }
+    if (this.kind === "circle") {
+      const cx = this.screenW / 2;
+      const cy = this.screenH / 2;
+      const diag = Math.sqrt(cx * cx + cy * cy);
+      out.push({ kind: "circle", cx, cy, radius: c * diag, fill: this.color, transform: IDENTITY, z });
+      return;
+    }
+    const cols = Math.ceil(this.screenW / this.cell);
+    const rows = Math.ceil(this.screenH / this.cell);
+    for (let cy = 0; cy < rows; cy++) {
+      for (let cx = 0; cx < cols; cx++) {
+        const threshold = (BAYER4[(cx & 3) + ((cy & 3) << 2)] + 0.5) / 16;
+        if (threshold < c) {
+          out.push({ kind: "rect", x: cx * this.cell, y: cy * this.cell, w: this.cell, h: this.cell, fill: this.color, transform: IDENTITY, z });
+        }
+      }
+    }
+  }
+};
+var CinematicPlayer = class extends Node {
+  type = "CinematicPlayer";
+  steps = [];
+  index = -1;
+  elapsed = 0;
+  running = false;
+  onFinish;
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+  }
+  /** Load and start a sequence. `onDone` fires after the last step advances. */
+  play(steps, onDone) {
+    this.steps = steps;
+    this.onFinish = onDone;
+    this.index = -1;
+    this.elapsed = 0;
+    this.running = steps.length > 0;
+    this.advance();
+    return this;
+  }
+  /** True while a sequence is playing. */
+  get active() {
+    return this.running;
+  }
+  /** Index of the step currently on screen (−1 before play / after finish). */
+  get step() {
+    return this.index;
+  }
+  /** Signal emitted when the whole sequence finishes. */
+  get finished() {
+    return this.signal("finished");
+  }
+  advance() {
+    this.index++;
+    this.elapsed = 0;
+    if (this.index >= this.steps.length) {
+      this.running = false;
+      this.index = -1;
+      this.emit("finished", void 0);
+      this.onFinish?.();
+      return;
+    }
+    this.steps[this.index].enter?.();
+  }
+  /** Abort the sequence immediately (no further enters, no finish callback). */
+  stop() {
+    this.running = false;
+    this.index = -1;
+    this.steps = [];
+  }
+  onProcess(dt) {
+    if (!this.running) return;
+    this.elapsed += dt;
+    const s = this.steps[this.index];
+    const durationDone = this.elapsed >= (s.duration ?? 0);
+    const gateOpen = s.until ? s.until() : true;
+    if (durationDone && gateOpen) this.advance();
+  }
+};
+function addTransition(parent, config = {}) {
+  const t = new ScreenTransition({ z: 1e4, ...config });
+  return parent.addChild(t);
+}
+function wipeStep(transition, opts = {}) {
+  return {
+    name: opts.name ?? "wipe",
+    enter: () => transition.wipe(opts),
+    until: () => !transition.busy
+  };
+}
+var screenRect = (w, h) => ({ x: 0, y: 0, w, h });
+
 // src/verify/solver.ts
 function solve(puzzle, options = {}) {
   const maxDepth = options.maxDepth ?? 60;
@@ -2394,6 +4776,101 @@ function steer2D(px, py, tx, ty, out, dead = 8) {
   else if (py > ty + dead) out.push("up");
 }
 
+// src/verify/layout.ts
+function textBox(cmd) {
+  const w = cmd.text.length * cmd.size * 0.56;
+  const h = cmd.size * 1.25;
+  const cx = cmd.transform.e + cmd.x;
+  const by = cmd.transform.f + cmd.y;
+  const left = cmd.align === "center" ? cx - w / 2 : cmd.align === "right" ? cx - w : cx;
+  return { cmd, x: left, y: by - cmd.size, w, h };
+}
+function shapeBox(cmd) {
+  const ex = cmd.transform.e;
+  const ey = cmd.transform.f;
+  switch (cmd.kind) {
+    case "rect":
+      return { x: ex + cmd.x, y: ey + cmd.y, w: cmd.w, h: cmd.h };
+    case "circle":
+      return { x: ex + cmd.cx - cmd.radius, y: ey + cmd.cy - cmd.radius, w: cmd.radius * 2, h: cmd.radius * 2 };
+    case "poly": {
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (let i = 0; i < cmd.points.length; i += 2) {
+        minX = Math.min(minX, cmd.points[i]);
+        maxX = Math.max(maxX, cmd.points[i]);
+        minY = Math.min(minY, cmd.points[i + 1]);
+        maxY = Math.max(maxY, cmd.points[i + 1]);
+      }
+      return { x: ex + minX, y: ey + minY, w: maxX - minX, h: maxY - minY };
+    }
+    default:
+      return null;
+  }
+}
+var overlaps2 = (a, b) => a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+var contains = (outer, inner, pad = 2) => outer.x - pad <= inner.x && outer.y - pad <= inner.y && outer.x + outer.w + pad >= inner.x + inner.w && outer.y + outer.h + pad >= inner.y + inner.h;
+function layoutIssues(commands, opts = {}) {
+  const backgroundZ = opts.backgroundZ ?? 1;
+  const margin = opts.margin ?? 0;
+  const issues = [];
+  const texts = [];
+  for (const c of commands) if (c.kind === "text" && c.text.trim().length) texts.push(textBox(c));
+  for (const t of texts) {
+    const r = { x: t.x - margin, y: t.y - margin, w: t.w + margin * 2, h: t.h + margin * 2 };
+    let panelZ = -Infinity;
+    for (const c of commands) {
+      if (c.kind === "text") continue;
+      const b = shapeBox(c);
+      if (b && contains(b, t) && (c.opacity === void 0 || c.opacity >= 0.6)) panelZ = Math.max(panelZ, c.z ?? 0);
+    }
+    for (const c of commands) {
+      if (c.kind === "text") continue;
+      if ((c.z ?? 0) <= backgroundZ) continue;
+      if ((c.z ?? 0) <= panelZ) continue;
+      if (c.opacity !== void 0 && c.opacity < 0.25) continue;
+      const b = shapeBox(c);
+      if (!b) continue;
+      if (overlaps2(r, b) && !contains(b, t)) {
+        issues.push(`text "${clip(t.cmd.text)}" collides with a ${c.kind} (z${c.z}) at ~(${Math.round(b.x)},${Math.round(b.y)}) \u2014 back it with a panel, or stay clear`);
+      }
+    }
+  }
+  for (let i = 0; i < texts.length; i++)
+    for (let j = i + 1; j < texts.length; j++)
+      if (overlaps2(texts[i], texts[j])) issues.push(`texts "${clip(texts[i].cmd.text)}" and "${clip(texts[j].cmd.text)}" overlap`);
+  return dedupe(issues);
+}
+var clip = (s) => s.length > 28 ? s.slice(0, 25) + "\u2026" : s;
+var dedupe = (a) => [...new Set(a)];
+function keyMentions(code) {
+  if (code.startsWith("Digit")) return [code.slice(5)];
+  if (code.startsWith("Key")) return [code.slice(3).toLowerCase()];
+  if (code.startsWith("Arrow")) return ["arrow", "\u2190", "\u2192", "\u2191", "\u2193", code.slice(5).toLowerCase()];
+  if (code.startsWith("Shift")) return ["shift"];
+  if (code === "Space") return ["space"];
+  if (code === "Enter") return ["enter"];
+  if (code === "Period") return ["."];
+  return [code.toLowerCase()];
+}
+function missingControlHints(world, inputMap) {
+  const textBlob = world.render().filter((c) => c.kind === "text").map((c) => c.text.toLowerCase()).join(" \xB7 ");
+  const missing = [];
+  const mentions = (n2) => {
+    if (!n2.length) return false;
+    if (n2.length <= 2 && /^[a-z0-9.]+$/.test(n2)) return new RegExp(`(^|[^a-z0-9])${n2.replace(".", "\\.")}($|[^a-z0-9])`).test(textBlob);
+    return textBlob.includes(n2);
+  };
+  for (const [action, keys] of Object.entries(inputMap)) {
+    if (action === "restart") continue;
+    const names = [action.toLowerCase().replace(/-\d+$/, ""), ...keys.flatMap(keyMentions)];
+    if (!names.some(mentions)) missing.push(action);
+  }
+  return dedupe(missing);
+}
+
 // src/verify/feel.ts
 function recordTimeline(world, frames) {
   const out = [world.probe()];
@@ -2462,14 +4939,1781 @@ function renderFilmstrip(world, frames, opts) {
   return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${totalW} ${totalH}" width="${totalW}" height="${totalH}"><rect x="0" y="0" width="${totalW}" height="${totalH}" fill="#f4f4f2"/>` + cells + `</svg>`;
 }
 
-// src/world.ts
-var World = class {
-  rng;
-  clock;
-  input = new InputState();
-  events = new EventBus();
-  resources = /* @__PURE__ */ new Map();
-  /**
+// src/logic/fsm.ts
+var Fsm = class {
+  constructor(states, transitions, initial, ctx) {
+    this.states = states;
+    this.transitions = transitions;
+    this.ctx = ctx;
+    this.current = initial;
+    this.states[initial]?.onEnter?.(ctx);
+  }
+  states;
+  transitions;
+  ctx;
+  /** The active state key — this is the whole serializable state. */
+  current;
+  /**
+   * Advance one fixed step: fire the first satisfied transition (if any), then
+   * run the current state's `onUpdate`. A transition runs its target's
+   * `onUpdate` this same tick, so entering and acting aren't a frame apart.
+   */
+  update(dt) {
+    for (const t of this.transitions) {
+      if ((t.from === "*" || t.from === this.current) && t.when(this.ctx)) {
+        this.go(t.to);
+        break;
+      }
+    }
+    this.states[this.current]?.onUpdate?.(this.ctx, dt);
+  }
+  /** Force a transition (fires onLeave/onEnter). No-op if already there. */
+  go(to) {
+    if (to === this.current) return;
+    this.states[this.current]?.onLeave?.(this.ctx);
+    this.current = to;
+    this.states[to]?.onEnter?.(this.ctx);
+  }
+  /** True when in one of the given states. */
+  is(...states) {
+    return states.includes(this.current);
+  }
+  /** Serialize (games persist this in `world.state`; the handlers are code). */
+  getState() {
+    return this.current;
+  }
+  /** Restore without firing enter/leave (it's a resume, not a transition). */
+  setState(state) {
+    this.current = state;
+  }
+};
+var PhaseClock = class {
+  constructor(defs, initial) {
+    this.defs = defs;
+    if (!defs[initial]) throw new Error(`hayao: PhaseClock has no phase '${initial}'`);
+    this.phase = initial;
+  }
+  defs;
+  /** Current phase key — serializable with `elapsed`. */
+  phase;
+  /** Seconds spent in the current phase so far. */
+  elapsed = 0;
+  get duration() {
+    return this.defs[this.phase]?.duration ?? 0;
+  }
+  /** Eased fraction 0→1 through the current phase (clamped). For cosmetic interp. */
+  progress(ease = (t) => t) {
+    const d = this.duration;
+    const raw = d > 0 ? this.elapsed / d : 1;
+    return ease(raw < 0 ? 0 : raw > 1 ? 1 : raw);
+  }
+  /** True once the current phase's duration has fully elapsed. */
+  get done() {
+    return this.elapsed >= this.duration;
+  }
+  /**
+   * Advance by `dt`. When a phase completes and has a `next`, roll into it
+   * (carrying any overshoot so long phases don't drift). Returns true on the
+   * tick a new phase begins — the game's cue to commit the next logical step.
+   */
+  update(dt) {
+    this.elapsed += dt;
+    let advanced = false;
+    let guard = 0;
+    while (this.elapsed >= this.duration && this.defs[this.phase]?.next !== void 0 && guard++ < 1024) {
+      const overshoot = this.elapsed - this.duration;
+      this.phase = this.defs[this.phase].next;
+      this.elapsed = overshoot;
+      advanced = true;
+    }
+    return advanced;
+  }
+  /** Jump to a phase and reset its timer (fresh `onEnter`-style restart). */
+  to(phase) {
+    if (!this.defs[phase]) throw new Error(`hayao: PhaseClock has no phase '${phase}'`);
+    this.phase = phase;
+    this.elapsed = 0;
+  }
+  getState() {
+    return { phase: this.phase, elapsed: this.elapsed };
+  }
+  setState(state) {
+    this.phase = state.phase;
+    this.elapsed = state.elapsed;
+  }
+};
+
+// src/logic/random.ts
+function totalWeight(weights) {
+  let sum = 0;
+  for (const w of weights) sum += w > 0 ? w : 0;
+  return sum;
+}
+function weightedIndex(rng, weights) {
+  const total = totalWeight(weights);
+  if (total <= 0) throw new Error("hayao: weightedIndex needs at least one positive weight");
+  let r = rng.float() * total;
+  for (let i = 0; i < weights.length; i++) {
+    const w = weights[i] > 0 ? weights[i] : 0;
+    if (r < w) return i;
+    r -= w;
+  }
+  for (let i = weights.length - 1; i >= 0; i--) if (weights[i] > 0) return i;
+  return weights.length - 1;
+}
+function weightedPick(rng, items, weights) {
+  if (items.length !== weights.length) throw new Error("hayao: weightedPick items/weights length mismatch");
+  return items[weightedIndex(rng, weights)];
+}
+function pickEntry(rng, entries) {
+  return entries[weightedIndex(rng, entries.map((e) => e.weight))].value;
+}
+var LootTable = class {
+  values;
+  /** Cumulative (prefix-sum) weights; last element is the total. */
+  cumulative;
+  total;
+  constructor(entries) {
+    if (entries.length === 0) throw new Error("hayao: LootTable needs at least one entry");
+    const values = [];
+    const cumulative = [];
+    let sum = 0;
+    for (const e of entries) {
+      sum += e.weight > 0 ? e.weight : 0;
+      values.push(e.value);
+      cumulative.push(sum);
+    }
+    if (sum <= 0) throw new Error("hayao: LootTable needs at least one positive weight");
+    this.values = values;
+    this.cumulative = cumulative;
+    this.total = sum;
+  }
+  /** One draw with replacement. */
+  roll(rng) {
+    const r = rng.float() * this.total;
+    for (let i = 0; i < this.cumulative.length; i++) if (r < this.cumulative[i]) return this.values[i];
+    return this.values[this.values.length - 1];
+  }
+  /** `n` independent draws with replacement, in order. */
+  rollMany(rng, n2) {
+    const out = [];
+    for (let i = 0; i < n2; i++) out.push(this.roll(rng));
+    return out;
+  }
+};
+
+// src/logic/graph.ts
+function bfs(start, neighbours, key, opts = {}) {
+  const maxNodes = opts.maxNodes ?? 1e6;
+  const order = [];
+  const cameFrom = /* @__PURE__ */ new Map();
+  const dist = /* @__PURE__ */ new Map();
+  const startKey = key(start);
+  dist.set(startKey, 0);
+  let frontier = [start];
+  order.push(start);
+  if (opts.goal?.(start)) return { order, cameFrom, dist };
+  let expanded = 0;
+  while (frontier.length > 0 && expanded < maxNodes) {
+    const next = [];
+    for (const node of frontier) {
+      const d = dist.get(key(node)) ?? 0;
+      for (const nb of neighbours(node)) {
+        const k = key(nb);
+        if (dist.has(k)) continue;
+        dist.set(k, d + 1);
+        cameFrom.set(k, node);
+        order.push(nb);
+        expanded++;
+        if (opts.goal?.(nb)) return { order, cameFrom, dist };
+        next.push(nb);
+      }
+    }
+    frontier = next;
+  }
+  return { order, cameFrom, dist };
+}
+function reconstructPath(cameFrom, key, start, goal) {
+  const path = [goal];
+  let cur = goal;
+  const startKey = key(start);
+  while (key(cur) !== startKey) {
+    const prev = cameFrom.get(key(cur));
+    if (prev === void 0) return [];
+    cur = prev;
+    path.push(cur);
+  }
+  path.reverse();
+  return path;
+}
+function astar(start, isGoal, neighbours, key, opts = {}) {
+  const h = opts.heuristic ?? (() => 0);
+  const maxNodes = opts.maxNodes ?? 1e6;
+  const cameFrom = /* @__PURE__ */ new Map();
+  const gScore = /* @__PURE__ */ new Map();
+  const heap = new MinHeap();
+  const startKey = key(start);
+  gScore.set(startKey, 0);
+  heap.push(start, h(start));
+  let expanded = 0;
+  while (heap.size > 0 && expanded < maxNodes) {
+    const { item: cur, priority: f } = heap.pop();
+    const ck = key(cur);
+    const g = gScore.get(ck) ?? Infinity;
+    if (f > g + h(cur) + 1e-9) continue;
+    if (isGoal(cur)) return { path: rebuild(cameFrom, key, cur), cost: g };
+    expanded++;
+    for (const edge of neighbours(cur)) {
+      const nk = key(edge.node);
+      const tentative = g + edge.cost;
+      if (tentative < (gScore.get(nk) ?? Infinity)) {
+        gScore.set(nk, tentative);
+        cameFrom.set(nk, cur);
+        heap.push(edge.node, tentative + h(edge.node));
+      }
+    }
+  }
+  return null;
+}
+function rebuild(cameFrom, key, goal) {
+  const path = [goal];
+  let cur = goal;
+  let prev = cameFrom.get(key(cur));
+  while (prev !== void 0) {
+    cur = prev;
+    path.push(cur);
+    prev = cameFrom.get(key(cur));
+  }
+  path.reverse();
+  return path;
+}
+var MinHeap = class {
+  items = [];
+  prio = [];
+  seq = [];
+  counter = 0;
+  get size() {
+    return this.items.length;
+  }
+  push(item, priority) {
+    this.items.push(item);
+    this.prio.push(priority);
+    this.seq.push(this.counter++);
+    this.bubbleUp(this.items.length - 1);
+  }
+  pop() {
+    const item = this.items[0];
+    const priority = this.prio[0];
+    const last = this.items.length - 1;
+    this.swap(0, last);
+    this.items.pop();
+    this.prio.pop();
+    this.seq.pop();
+    if (this.items.length > 0) this.bubbleDown(0);
+    return { item, priority };
+  }
+  /** true if a is strictly higher priority (lower value, then earlier seq). */
+  less(a, b) {
+    return this.prio[a] < this.prio[b] || this.prio[a] === this.prio[b] && this.seq[a] < this.seq[b];
+  }
+  bubbleUp(i) {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (!this.less(i, parent)) break;
+      this.swap(i, parent);
+      i = parent;
+    }
+  }
+  bubbleDown(i) {
+    const n2 = this.items.length;
+    for (; ; ) {
+      const l = 2 * i + 1;
+      const r = 2 * i + 2;
+      let smallest = i;
+      if (l < n2 && this.less(l, smallest)) smallest = l;
+      if (r < n2 && this.less(r, smallest)) smallest = r;
+      if (smallest === i) break;
+      this.swap(i, smallest);
+      i = smallest;
+    }
+  }
+  swap(a, b) {
+    [this.items[a], this.items[b]] = [this.items[b], this.items[a]];
+    [this.prio[a], this.prio[b]] = [this.prio[b], this.prio[a]];
+    [this.seq[a], this.seq[b]] = [this.seq[b], this.seq[a]];
+  }
+};
+var NEIGHBORS_4 = [
+  { x: 0, y: -1 },
+  { x: 1, y: 0 },
+  { x: 0, y: 1 },
+  { x: -1, y: 0 }
+];
+var NEIGHBORS_8 = [
+  ...NEIGHBORS_4,
+  { x: 1, y: -1 },
+  { x: 1, y: 1 },
+  { x: -1, y: 1 },
+  { x: -1, y: -1 }
+];
+var cellKey = (c) => `${c.x},${c.y}`;
+function gridNeighbours(passable, cols, rows, diagonal) {
+  const offsets = diagonal ? NEIGHBORS_8 : NEIGHBORS_4;
+  return (c) => {
+    const out = [];
+    for (const o of offsets) {
+      const x = c.x + o.x;
+      const y = c.y + o.y;
+      if (x < 0 || y < 0 || x >= cols || y >= rows) continue;
+      if (!passable(x, y)) continue;
+      out.push({ x, y });
+    }
+    return out;
+  };
+}
+function floodFill(start, passable, opts) {
+  if (!passable(start.x, start.y)) return [];
+  const nb = gridNeighbours(passable, opts.cols, opts.rows, opts.diagonal ?? false);
+  return bfs(start, nb, cellKey).order;
+}
+function connectedComponents(cols, rows, passable, diagonal = false) {
+  const labels = new Array(cols * rows).fill(-1);
+  const cells = [];
+  const offsets = diagonal ? NEIGHBORS_8 : NEIGHBORS_4;
+  for (let y = 0; y < rows; y++) {
+    for (let x = 0; x < cols; x++) {
+      if (labels[y * cols + x] !== -1 || !passable(x, y)) continue;
+      const id = cells.length;
+      const region = [];
+      let frontier = [{ x, y }];
+      labels[y * cols + x] = id;
+      while (frontier.length > 0) {
+        const next = [];
+        for (const c of frontier) {
+          region.push(c);
+          for (const o of offsets) {
+            const nx = c.x + o.x;
+            const ny = c.y + o.y;
+            if (nx < 0 || ny < 0 || nx >= cols || ny >= rows) continue;
+            const idx = ny * cols + nx;
+            if (labels[idx] !== -1 || !passable(nx, ny)) continue;
+            labels[idx] = id;
+            next.push({ x: nx, y: ny });
+          }
+        }
+        frontier = next;
+      }
+      cells.push(region);
+    }
+  }
+  return { labels, cells };
+}
+function astarGrid(start, goal, passable, opts) {
+  const diagonal = opts.diagonal ?? false;
+  const offsets = diagonal ? NEIGHBORS_8 : NEIGHBORS_4;
+  const stepCost = opts.cost ?? (() => 1);
+  const SQRT2 = 1.4142135623730951;
+  const neighbours = (c) => {
+    const out = [];
+    for (const o of offsets) {
+      const x = c.x + o.x;
+      const y = c.y + o.y;
+      if (x < 0 || y < 0 || x >= opts.cols || y >= opts.rows) continue;
+      if (!passable(x, y)) continue;
+      const diag = o.x !== 0 && o.y !== 0;
+      out.push({ node: { x, y }, cost: stepCost(x, y) * (diag ? SQRT2 : 1) });
+    }
+    return out;
+  };
+  const heuristic = (c) => {
+    const dx = Math.abs(c.x - goal.x);
+    const dy = Math.abs(c.y - goal.y);
+    if (!diagonal) return dx + dy;
+    const lo = Math.min(dx, dy);
+    return dx + dy - (2 - SQRT2) * lo;
+  };
+  if (!passable(goal.x, goal.y)) return null;
+  const result = astar(start, (c) => c.x === goal.x && c.y === goal.y, neighbours, cellKey, {
+    heuristic,
+    maxNodes: opts.maxNodes
+  });
+  return result ? result.path : null;
+}
+function passableFromTilemap(map) {
+  return (x, y) => tileAt(map, x, y) !== TILE.SOLID;
+}
+
+// src/logic/history.ts
+function deepClone(s) {
+  return structuredClone(s);
+}
+var UndoStack = class {
+  history = [];
+  cursor = -1;
+  limit;
+  clone;
+  constructor(opts = {}) {
+    this.limit = Math.max(1, opts.limit ?? 64);
+    this.clone = opts.clone ?? deepClone;
+  }
+  /** Push a new state as the present, discarding any redo branch ahead of it. */
+  record(state) {
+    this.history.length = this.cursor + 1;
+    this.history.push(this.clone(state));
+    this.cursor = this.history.length - 1;
+    if (this.history.length > this.limit) {
+      const overflow = this.history.length - this.limit;
+      this.history.splice(0, overflow);
+      this.cursor -= overflow;
+    }
+  }
+  /** Step back one state and return a clone of it (undefined if nothing to undo). */
+  undo() {
+    if (this.cursor <= 0) return void 0;
+    this.cursor--;
+    return this.clone(this.history[this.cursor]);
+  }
+  /** Step forward one state and return a clone of it (undefined if nothing to redo). */
+  redo() {
+    if (this.cursor >= this.history.length - 1) return void 0;
+    this.cursor++;
+    return this.clone(this.history[this.cursor]);
+  }
+  /** A clone of the current state, or undefined if empty. */
+  current() {
+    return this.cursor >= 0 ? this.clone(this.history[this.cursor]) : void 0;
+  }
+  get canUndo() {
+    return this.cursor > 0;
+  }
+  get canRedo() {
+    return this.cursor < this.history.length - 1;
+  }
+  /** Number of recorded states retained. */
+  get size() {
+    return this.history.length;
+  }
+  clear() {
+    this.history.length = 0;
+    this.cursor = -1;
+  }
+};
+var RingBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    if (!Number.isInteger(capacity) || capacity < 1) throw new Error("hayao: RingBuffer capacity must be a positive integer");
+    this.buf = new Array(capacity);
+  }
+  capacity;
+  buf;
+  start = 0;
+  count = 0;
+  push(item) {
+    const end = (this.start + this.count) % this.capacity;
+    this.buf[end] = item;
+    if (this.count < this.capacity) {
+      this.count++;
+    } else {
+      this.start = (this.start + 1) % this.capacity;
+    }
+  }
+  /** Number of items currently held (≤ capacity). */
+  get length() {
+    return this.count;
+  }
+  get isFull() {
+    return this.count === this.capacity;
+  }
+  /** Item by age index: 0 = oldest, length-1 = newest. Undefined if out of range. */
+  at(i) {
+    if (i < 0 || i >= this.count) return void 0;
+    return this.buf[(this.start + i) % this.capacity];
+  }
+  /** The most recently pushed item, or undefined if empty. */
+  latest() {
+    return this.at(this.count - 1);
+  }
+  /** Contents oldest→newest. */
+  toArray() {
+    const out = [];
+    for (let i = 0; i < this.count; i++) out.push(this.buf[(this.start + i) % this.capacity]);
+    return out;
+  }
+  clear() {
+    this.start = 0;
+    this.count = 0;
+    this.buf.fill(void 0);
+  }
+};
+
+// src/persist/storage.ts
+var MemoryStorage = class {
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.map.has(key) ? this.map.get(key) : null;
+  }
+  set(key, value) {
+    this.map.set(key, value);
+  }
+  remove(key) {
+    this.map.delete(key);
+  }
+  keys() {
+    return [...this.map.keys()];
+  }
+};
+var NullStorage = class {
+  get(_key) {
+    return null;
+  }
+  set(_key, _value) {
+  }
+  remove(_key) {
+  }
+  keys() {
+    return [];
+  }
+};
+var LocalStorageAdapter = class {
+  constructor(prefix = "hayao.save.") {
+    this.prefix = prefix;
+  }
+  prefix;
+  ls() {
+    try {
+      return typeof localStorage !== "undefined" ? localStorage : null;
+    } catch {
+      return null;
+    }
+  }
+  get(key) {
+    try {
+      return this.ls()?.getItem(this.prefix + key) ?? null;
+    } catch {
+      return null;
+    }
+  }
+  set(key, value) {
+    try {
+      this.ls()?.setItem(this.prefix + key, value);
+    } catch {
+    }
+  }
+  remove(key) {
+    try {
+      this.ls()?.removeItem(this.prefix + key);
+    } catch {
+    }
+  }
+  keys() {
+    const ls = this.ls();
+    if (!ls) return [];
+    const out = [];
+    try {
+      for (let i = 0; i < ls.length; i++) {
+        const k = ls.key(i);
+        if (k && k.startsWith(this.prefix)) out.push(k.slice(this.prefix.length));
+      }
+    } catch {
+    }
+    return out;
+  }
+};
+function defaultStorage(prefix) {
+  try {
+    if (typeof localStorage !== "undefined") {
+      const probe = "__hayao_probe__";
+      localStorage.setItem(probe, "1");
+      localStorage.removeItem(probe);
+      return new LocalStorageAdapter(prefix);
+    }
+  } catch {
+  }
+  return new MemoryStorage();
+}
+
+// src/persist/codec.ts
+var ESC = "~";
+var RLE_MIN_RUN = 4;
+function rleEncode(input) {
+  let out = "";
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    let run = 1;
+    while (i + run < input.length && input[i + run] === ch) run++;
+    if (run >= RLE_MIN_RUN || ch === ESC) {
+      out += ESC + ch + run.toString(36) + ESC;
+    } else {
+      out += ch.repeat(run);
+    }
+    i += run;
+  }
+  return out;
+}
+function rleDecode(input) {
+  let out = "";
+  let i = 0;
+  while (i < input.length) {
+    if (input[i] === ESC) {
+      const ch = input[i + 1];
+      const end = input.indexOf(ESC, i + 2);
+      if (ch === void 0 || end < 0) throw new Error("hayao: malformed RLE stream");
+      const count = parseInt(input.slice(i + 2, end), 36);
+      if (!Number.isFinite(count) || count < 1) throw new Error("hayao: malformed RLE count");
+      out += ch.repeat(count);
+      i = end + 1;
+    } else {
+      out += input[i];
+      i++;
+    }
+  }
+  return out;
+}
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var INDEX = {};
+for (let i = 0; i < ALPHABET.length; i++) INDEX[ALPHABET[i]] = i;
+function packVarints(nums) {
+  let out = "";
+  for (const n2 of nums) {
+    if (!Number.isInteger(n2) || n2 < 0) throw new Error(`hayao: packVarints expects non-negative integers, got ${n2}`);
+    let v = n2;
+    do {
+      let digit = v & 31;
+      v = Math.floor(v / 32);
+      if (v > 0) digit |= 32;
+      out += ALPHABET[digit];
+    } while (v > 0);
+  }
+  return out;
+}
+function unpackVarints(input) {
+  const out = [];
+  let v = 0;
+  let shift = 1;
+  for (const ch of input) {
+    const digit = INDEX[ch];
+    if (digit === void 0) throw new Error(`hayao: unpackVarints saw invalid char "${ch}"`);
+    v += (digit & 31) * shift;
+    if (digit & 32) {
+      shift *= 32;
+    } else {
+      out.push(v);
+      v = 0;
+      shift = 1;
+    }
+  }
+  if (shift !== 1) throw new Error("hayao: unpackVarints hit a truncated stream");
+  return out;
+}
+
+// src/persist/save.ts
+var SAVE_FORMAT_VERSION = 1;
+function serializeSnapshot(snap) {
+  const envelope = { v: SAVE_FORMAT_VERSION, snap };
+  return JSON.stringify(envelope);
+}
+function parseSnapshot(text) {
+  if (!text) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const env = parsed;
+  if (env.v !== SAVE_FORMAT_VERSION || !env.snap || typeof env.snap !== "object") return null;
+  const snap = env.snap;
+  if (typeof snap.seed !== "number" || !snap.rng || !snap.clock || !snap.input || !snap.state || !snap.tree) {
+    return null;
+  }
+  return snap;
+}
+var SaveManager = class {
+  constructor(world, storage = defaultStorage()) {
+    this.world = world;
+    this.storage = storage;
+  }
+  world;
+  storage;
+  /** Snapshot the world and persist it under `slot`. */
+  save(slot = "auto") {
+    this.storage.set(slot, serializeSnapshot(this.world.snapshot()));
+  }
+  /** Restore `slot` into the world. Returns false if absent/corrupt (world untouched). */
+  load(slot = "auto") {
+    const snap = parseSnapshot(this.storage.get(slot));
+    if (!snap) return false;
+    this.world.restore(snap);
+    return true;
+  }
+  /** Is there a well-formed save in `slot`? */
+  has(slot = "auto") {
+    return parseSnapshot(this.storage.get(slot)) !== null;
+  }
+  /** Delete a save slot. */
+  delete(slot = "auto") {
+    this.storage.remove(slot);
+  }
+  /** All slot names currently persisted. */
+  slots() {
+    return this.storage.keys();
+  }
+};
+
+// src/content/dsl.ts
+function initDirector(waves) {
+  return { next: waves.map((w) => w.time) };
+}
+function pollDirector(waves, state, time, rng) {
+  const out = [];
+  for (let i = 0; i < waves.length; i++) {
+    const w = waves[i];
+    let next = state.next[i] ?? w.time;
+    while (next <= time) {
+      let spawn;
+      if (typeof w.spawn === "string") {
+        spawn = w.spawn;
+      } else {
+        if (!rng) throw new Error("hayao: pollDirector needs an Rng to roll a weighted wave");
+        spawn = pickEntry(rng, w.spawn);
+      }
+      out.push({ spawn, count: w.count ?? 1, wave: i });
+      if (w.every && w.every > 0) {
+        next += w.every;
+        if (w.end !== void 0 && next >= w.end) {
+          next = Infinity;
+          break;
+        }
+      } else {
+        next = Infinity;
+        break;
+      }
+    }
+    state.next[i] = next;
+  }
+  return out;
+}
+function availableUpgrades(defs, owned) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const id of owned) counts.set(id, (counts.get(id) ?? 0) + 1);
+  const has = (id) => (counts.get(id) ?? 0) > 0;
+  return defs.filter((d) => {
+    const stacks = counts.get(d.id) ?? 0;
+    if (stacks >= (d.maxStacks ?? 1)) return false;
+    return (d.requires ?? []).every(has);
+  });
+}
+
+// src/net/players.ts
+function playerIds(count) {
+  const out = [];
+  for (let i = 1; i <= count; i++) out.push(`p${i}`);
+  return out;
+}
+var playerAction = (player, action) => `${player}:${action}`;
+function mergePlayerFrames(players, inputs) {
+  const out = [];
+  for (const p of players) {
+    const actions = inputs.get(p) ?? [];
+    for (const a of actions) out.push(playerAction(p, a));
+  }
+  return out.sort();
+}
+var PlayerInput = class {
+  constructor(world, player) {
+    this.world = world;
+    this.player = player;
+  }
+  world;
+  player;
+  isDown(action) {
+    return this.world.input.isDown(playerAction(this.player, action));
+  }
+  justPressed(action) {
+    return this.world.input.justPressed(playerAction(this.player, action));
+  }
+  justReleased(action) {
+    return this.world.input.justReleased(playerAction(this.player, action));
+  }
+};
+var playerInput = (world, player) => new PlayerInput(world, player);
+
+// src/net/protocol.ts
+var NET_PROTOCOL_VERSION = 1;
+var DEFAULT_SESSION_CONFIG = {
+  mode: "lockstep",
+  inputDelay: 2,
+  hashInterval: 20,
+  maxRollback: 12,
+  redundancy: 3
+};
+function encodeMessage(msg) {
+  return JSON.stringify(msg);
+}
+function decodeMessage(data) {
+  try {
+    const msg = JSON.parse(data);
+    if (!msg || typeof msg !== "object" || msg.v !== NET_PROTOCOL_VERSION || typeof msg.t !== "string") return null;
+    return msg;
+  } catch {
+    return null;
+  }
+}
+function netMessage(msg) {
+  return { v: NET_PROTOCOL_VERSION, ...msg };
+}
+
+// src/net/transport.ts
+var LoopbackHub = class {
+  peers = [];
+  queue = [];
+  tickCount = 0;
+  seq = 0;
+  sent = 0;
+  delay;
+  dropEvery;
+  constructor(opts = {}) {
+    this.delay = opts.delay ?? 0;
+    this.dropEvery = opts.dropEvery ?? 0;
+  }
+  /** Create a new endpoint on this bus. */
+  connect() {
+    const t = new LoopbackTransport(this, this.peers.length);
+    this.peers.push(t);
+    return t;
+  }
+  /** @internal */
+  enqueue(data, from) {
+    this.sent++;
+    if (this.dropEvery > 0 && this.sent % this.dropEvery === 0) return;
+    this.queue.push({ data, from, dueTick: this.tickCount + this.delay, seq: this.seq++ });
+  }
+  /** Advance one network tick, delivering everything that is due. */
+  tick() {
+    const due = this.queue.filter((m) => m.dueTick <= this.tickCount).sort((a, b) => a.seq - b.seq);
+    this.queue = this.queue.filter((m) => m.dueTick > this.tickCount);
+    this.tickCount++;
+    for (const m of due) {
+      for (const peer of this.peers) {
+        if (peer.peerIndex !== m.from && peer.isOpen) peer.deliver(m.data);
+      }
+    }
+  }
+  /** Deliver everything in flight (repeated ticks until the queue drains). */
+  flush() {
+    while (this.queue.length > 0) this.tick();
+  }
+  get pending() {
+    return this.queue.length;
+  }
+};
+var LoopbackTransport = class {
+  constructor(hub, peerIndex) {
+    this.hub = hub;
+    this.peerIndex = peerIndex;
+  }
+  hub;
+  peerIndex;
+  listeners = [];
+  closeListeners = [];
+  open = true;
+  send(data) {
+    if (this.open) this.hub.enqueue(data, this.peerIndex);
+  }
+  onMessage(cb) {
+    this.listeners.push(cb);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== cb);
+    };
+  }
+  onClose(cb) {
+    this.closeListeners.push(cb);
+    return () => {
+      this.closeListeners = this.closeListeners.filter((l) => l !== cb);
+    };
+  }
+  close() {
+    if (!this.open) return;
+    this.open = false;
+    for (const cb of this.closeListeners) cb();
+  }
+  get isOpen() {
+    return this.open;
+  }
+  /** @internal */
+  deliver(data) {
+    for (const cb of this.listeners) cb(data);
+  }
+};
+var BroadcastChannelTransport = class {
+  channel;
+  listeners = [];
+  closeListeners = [];
+  open = true;
+  constructor(room) {
+    this.channel = new BroadcastChannel(`hayao-net:${room}`);
+    this.channel.onmessage = (e) => {
+      if (typeof e.data === "string") for (const cb of this.listeners) cb(e.data);
+    };
+  }
+  send(data) {
+    if (this.open) this.channel.postMessage(data);
+  }
+  onMessage(cb) {
+    this.listeners.push(cb);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== cb);
+    };
+  }
+  onClose(cb) {
+    this.closeListeners.push(cb);
+    return () => {
+      this.closeListeners = this.closeListeners.filter((l) => l !== cb);
+    };
+  }
+  close() {
+    if (!this.open) return;
+    this.open = false;
+    this.channel.close();
+    for (const cb of this.closeListeners) cb();
+  }
+  get isOpen() {
+    return this.open;
+  }
+};
+function connectWebSocket(url) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const listeners = [];
+    const closeListeners = [];
+    let open = false;
+    const transport = {
+      send(data) {
+        if (open) ws.send(data);
+      },
+      onMessage(cb) {
+        listeners.push(cb);
+        return () => {
+          const i = listeners.indexOf(cb);
+          if (i >= 0) listeners.splice(i, 1);
+        };
+      },
+      onClose(cb) {
+        closeListeners.push(cb);
+        return () => {
+          const i = closeListeners.indexOf(cb);
+          if (i >= 0) closeListeners.splice(i, 1);
+        };
+      },
+      close() {
+        open = false;
+        ws.close();
+      },
+      get isOpen() {
+        return open;
+      }
+    };
+    ws.onopen = () => {
+      open = true;
+      resolve(transport);
+    };
+    ws.onmessage = (e) => {
+      if (typeof e.data === "string") for (const cb of listeners) cb(e.data);
+    };
+    ws.onclose = () => {
+      const wasOpen = open;
+      open = false;
+      if (wasOpen) for (const cb of closeListeners) cb();
+    };
+    ws.onerror = () => {
+      if (!open) reject(new Error(`hayao-net: could not connect to ${url}`));
+    };
+  });
+}
+
+// src/net/inputBuffer.ts
+var InputBuffer = class {
+  /** player → frame → actions (sorted). */
+  frames = /* @__PURE__ */ new Map();
+  /** player → highest contiguous frame received (for prediction + confirm). */
+  contiguous = /* @__PURE__ */ new Map();
+  addPlayer(player) {
+    if (!this.frames.has(player)) {
+      this.frames.set(player, /* @__PURE__ */ new Map());
+      this.contiguous.set(player, -1);
+    }
+  }
+  removePlayer(player) {
+    this.frames.delete(player);
+    this.contiguous.delete(player);
+  }
+  players() {
+    return [...this.frames.keys()];
+  }
+  /**
+   * Record a player's actions for a frame. Returns true if this was new
+   * information (first write for that slot).
+   */
+  set(player, frame, actions) {
+    const perPlayer = this.frames.get(player);
+    if (!perPlayer || perPlayer.has(frame)) return false;
+    perPlayer.set(frame, [...actions].sort());
+    let c = this.contiguous.get(player) ?? -1;
+    while (perPlayer.has(c + 1)) c++;
+    this.contiguous.set(player, c);
+    return true;
+  }
+  has(player, frame) {
+    return this.frames.get(player)?.has(frame) ?? false;
+  }
+  get(player, frame) {
+    return this.frames.get(player)?.get(frame);
+  }
+  /** The last actions at or before `frame` — the rollback predictor's guess. */
+  latestAt(player, frame) {
+    const perPlayer = this.frames.get(player);
+    if (!perPlayer) return [];
+    for (let f = frame; f >= 0; f--) {
+      const a = perPlayer.get(f);
+      if (a) return a;
+    }
+    return [];
+  }
+  /** Highest frame such that this player's inputs 0..frame are all known. */
+  contiguousThrough(player) {
+    return this.contiguous.get(player) ?? -1;
+  }
+  /** Highest frame with ALL players' inputs known contiguously. */
+  confirmedFrame() {
+    let min = Infinity;
+    for (const c of this.contiguous.values()) min = Math.min(min, c);
+    return min === Infinity ? -1 : min;
+  }
+  /** Forget a player's frames at/after `frame` (leave cutoff). */
+  clearFrom(player, frame) {
+    const perPlayer = this.frames.get(player);
+    if (!perPlayer) return;
+    for (const f of perPlayer.keys()) if (f >= frame) perPlayer.delete(f);
+    let c = this.contiguous.get(player) ?? -1;
+    if (c >= frame) c = frame - 1;
+    this.contiguous.set(player, c);
+  }
+  /** Drop history strictly before `frame` (memory hygiene on long sessions). */
+  prune(frame) {
+    for (const perPlayer of this.frames.values()) {
+      for (const f of perPlayer.keys()) if (f < frame) perPlayer.delete(f);
+    }
+  }
+};
+
+// src/net/lockstep.ts
+var LockstepSession = class {
+  world;
+  localPlayer;
+  config;
+  startFrame;
+  transport;
+  buffer = new InputBuffer();
+  roster = [];
+  mergedLog = [];
+  localHashes = /* @__PURE__ */ new Map();
+  pendingRemoteHashes = [];
+  sentThrough;
+  stallCount = 0;
+  desynced = false;
+  afterStepListeners = [];
+  unsubscribe;
+  onDesync;
+  onStall;
+  constructor(opts) {
+    this.world = opts.world;
+    this.transport = opts.transport;
+    this.localPlayer = opts.localPlayer;
+    this.config = { ...DEFAULT_SESSION_CONFIG, ...opts.config, mode: "lockstep" };
+    this.startFrame = opts.startFrame ?? 0;
+    this.onDesync = opts.onDesync;
+    this.onStall = opts.onStall;
+    for (const p of opts.players) {
+      this.roster.push({ player: p, from: this.startFrame, until: Infinity });
+      this.buffer.addPlayer(p);
+      if (this.startFrame === 0 || p === this.localPlayer) {
+        for (let f = this.startFrame; f < this.startFrame + this.config.inputDelay; f++) this.buffer.set(p, f, []);
+      }
+    }
+    this.sentThrough = this.startFrame + this.config.inputDelay - 1;
+    this.unsubscribe = this.transport.onMessage((data) => this.receive(data));
+  }
+  // ── the roster (players can come and go at agreed frames) ────
+  activePlayers(frame) {
+    return this.roster.filter((r) => r.from <= frame && frame < r.until).map((r) => r.player);
+  }
+  /** All peers must call this with the SAME atFrame (the room layer's job). */
+  addPlayer(player, atFrame) {
+    if (this.roster.some((r) => r.player === player && r.until === Infinity)) return;
+    this.roster.push({ player, from: atFrame, until: Infinity });
+    this.buffer.addPlayer(player);
+    for (let f = atFrame; f < atFrame + this.config.inputDelay; f++) this.buffer.set(player, f, []);
+  }
+  /** All peers must call this with the SAME atFrame. */
+  removePlayer(player, atFrame) {
+    const entry = this.roster.find((r) => r.player === player && r.until === Infinity);
+    if (entry) entry.until = atFrame;
+    this.buffer.clearFrom(player, atFrame);
+  }
+  // ── driving the sim ──────────────────────────────────────────
+  get frame() {
+    return this.world.frame;
+  }
+  /** Highest frame every currently-active player's input is known for. */
+  get confirmedFrame() {
+    let min = Infinity;
+    for (const p of this.activePlayers(this.world.frame)) min = Math.min(min, this.buffer.contiguousThrough(p));
+    return min === Infinity ? -1 : min;
+  }
+  get stalls() {
+    return this.stallCount;
+  }
+  /**
+   * Try to advance exactly one frame with the local player's current actions.
+   * Returns 1 if the world stepped, 0 if blocked waiting for a remote input.
+   */
+  tick(localActions = []) {
+    if (this.desynced) return 0;
+    const f = this.world.frame;
+    this.scheduleLocal(localActions);
+    const active2 = this.activePlayers(f);
+    for (const p of active2) {
+      if (!this.buffer.has(p, f)) {
+        this.stallCount++;
+        this.onStall?.(p, f);
+        return 0;
+      }
+    }
+    const inputs = /* @__PURE__ */ new Map();
+    for (const p of active2) inputs.set(p, this.buffer.get(p, f));
+    const merged = mergePlayerFrames(active2, inputs);
+    this.world.step(merged);
+    this.mergedLog.push(merged);
+    this.afterStep(this.world.frame);
+    return 1;
+  }
+  /**
+   * Feed real elapsed ms (the browser loop's dt). Runs the fixed steps the
+   * clock grants — stalling drops time (the sim slows rather than desyncs) —
+   * then catches up if we're measurably behind the other peers.
+   */
+  advance(realMs, localActions = []) {
+    let stepped = 0;
+    const steps = this.world.clock.advance(realMs);
+    for (let i = 0; i < steps; i++) {
+      if (this.tick(localActions) === 0) break;
+      stepped++;
+    }
+    let guard = 0;
+    while (guard++ < 8 && this.world.frame < this.remoteFrameEstimate() && this.tick(localActions) === 1) stepped++;
+    return stepped;
+  }
+  /** The merged input log from startFrame — replayable when startFrame is 0. */
+  inputLog() {
+    return { frames: this.mergedLog.map((f) => f.slice()) };
+  }
+  dispose() {
+    this.unsubscribe();
+  }
+  /** Feed a raw transport message that arrived before this session existed. */
+  deliver(data) {
+    this.receive(data);
+  }
+  /** Subscribe to "the world just reached frame N" (room layer uses this). */
+  onAfterStep(cb) {
+    this.afterStepListeners.push(cb);
+    return () => {
+      this.afterStepListeners = this.afterStepListeners.filter((l) => l !== cb);
+    };
+  }
+  // ── internals ────────────────────────────────────────────────
+  scheduleLocal(localActions) {
+    const target = this.world.frame + this.config.inputDelay;
+    if (this.sentThrough >= target) return;
+    while (this.sentThrough < target) {
+      this.sentThrough++;
+      this.buffer.set(this.localPlayer, this.sentThrough, localActions);
+    }
+    const from = Math.max(this.startFrame, target - this.config.redundancy + 1);
+    const frames = [];
+    for (let f = from; f <= target; f++) frames.push(this.buffer.get(this.localPlayer, f) ?? []);
+    this.transport.send(encodeMessage(netMessage({ t: "input", player: this.localPlayer, from, frames })));
+  }
+  afterStep(frame) {
+    if (frame % this.config.hashInterval === 0) {
+      const hash = this.world.hash();
+      this.localHashes.set(frame, hash);
+      this.transport.send(encodeMessage(netMessage({ t: "hash", player: this.localPlayer, frame, hash })));
+      this.checkPendingHashes();
+    }
+    if (frame % 64 === 0) {
+      this.buffer.prune(frame - 128);
+      for (const f of this.localHashes.keys()) if (f < frame - 512) this.localHashes.delete(f);
+    }
+    for (const cb of this.afterStepListeners) cb(frame);
+  }
+  receive(data) {
+    const msg = decodeMessage(data);
+    if (!msg) return;
+    if (msg.t === "input" && msg.player !== this.localPlayer) {
+      for (let i = 0; i < msg.frames.length; i++) this.buffer.set(msg.player, msg.from + i, msg.frames[i]);
+    } else if (msg.t === "hash" && msg.player !== this.localPlayer) {
+      this.pendingRemoteHashes.push({ player: msg.player, frame: msg.frame, hash: msg.hash });
+      this.checkPendingHashes();
+    }
+  }
+  checkPendingHashes() {
+    const still = [];
+    for (const remote of this.pendingRemoteHashes) {
+      const local = this.localHashes.get(remote.frame);
+      if (local === void 0) {
+        if (remote.frame > this.world.frame - 512) still.push(remote);
+        continue;
+      }
+      if (local !== remote.hash && !this.desynced) {
+        this.desynced = true;
+        this.onDesync?.({
+          frame: remote.frame,
+          player: remote.player,
+          localHash: local,
+          remoteHash: remote.hash,
+          log: this.inputLog(),
+          startFrame: this.startFrame
+        });
+      }
+    }
+    this.pendingRemoteHashes = still;
+  }
+  remoteFrameEstimate() {
+    let max = -1;
+    for (const entry of this.roster) {
+      if (entry.player === this.localPlayer || entry.until !== Infinity) continue;
+      max = Math.max(max, this.buffer.contiguousThrough(entry.player) - this.config.inputDelay);
+    }
+    return max;
+  }
+};
+
+// src/net/rollback.ts
+var RollbackSession = class {
+  world;
+  localPlayer;
+  config;
+  transport;
+  players;
+  buffer = new InputBuffer();
+  attach;
+  onDesync;
+  onRollbackOverflow;
+  /** Snapshot AT frame f (state before stepping f), keyed f % ring length. */
+  ring;
+  /** What we actually fed `step()` per frame — prediction bookkeeping. */
+  usedInputs = /* @__PURE__ */ new Map();
+  earliestBad = Infinity;
+  rollbackCount = 0;
+  resimulatedFrames = 0;
+  localHashes = /* @__PURE__ */ new Map();
+  /** player → cutoff frame: their inputs are [] from there on (departed). */
+  dropped = /* @__PURE__ */ new Map();
+  pendingRemoteHashes = [];
+  hashedThrough = -1;
+  desynced = false;
+  overflowed = false;
+  unsubscribe;
+  constructor(opts) {
+    this.world = opts.world;
+    this.transport = opts.transport;
+    this.localPlayer = opts.localPlayer;
+    this.players = [...opts.players];
+    this.config = { ...DEFAULT_SESSION_CONFIG, mode: "rollback", inputDelay: 0, ...opts.config };
+    this.attach = opts.attach;
+    this.onDesync = opts.onDesync;
+    this.onRollbackOverflow = opts.onRollbackOverflow;
+    this.ring = new Array(this.config.maxRollback + 1).fill(null);
+    for (const p of this.players) this.buffer.addPlayer(p);
+    this.unsubscribe = this.transport.onMessage((data) => this.receive(data));
+  }
+  get frame() {
+    return this.world.frame;
+  }
+  /** Highest frame all players' real inputs are known for (inclusive). */
+  get confirmedFrame() {
+    let min = Infinity;
+    for (const p of this.players) {
+      const cut = this.dropped.get(p);
+      let c = this.buffer.contiguousThrough(p);
+      if (cut !== void 0 && c >= cut - 1) c = Infinity;
+      min = Math.min(min, c);
+    }
+    return min === Infinity ? -1 : min;
+  }
+  /** Highest contiguous frame received from `player` — the drop-cutoff basis. */
+  lastKnownFrame(player) {
+    return this.buffer.contiguousThrough(player);
+  }
+  /**
+   * A player left (or vanished): their inputs are [] from `atFrame` on, so the
+   * session stops waiting on them. All peers must apply the SAME atFrame (the
+   * room layer broadcasts it). Frames already simulated with a non-empty
+   * prediction for the departed player roll back and re-simulate as usual.
+   */
+  removePlayer(player, atFrame) {
+    if (player === this.localPlayer || this.dropped.has(player)) return;
+    this.dropped.set(player, atFrame);
+    this.buffer.clearFrom(player, atFrame);
+    for (let f = atFrame; f < this.world.frame; f++) {
+      const used = this.usedInputs.get(f)?.get(player);
+      if (used !== void 0 && used !== "[]") this.earliestBad = Math.min(this.earliestBad, f);
+    }
+    this.settleHashes();
+  }
+  get stats() {
+    return { rollbacks: this.rollbackCount, resimulatedFrames: this.resimulatedFrames };
+  }
+  /**
+   * Advance one frame: publish local input, apply any pending correction,
+   * then step with confirmed-or-predicted inputs. Returns 1 unless the sim
+   * has outrun its rollback window (backpressure) or is desynced.
+   */
+  tick(localActions = []) {
+    if (this.desynced || this.overflowed) return 0;
+    const f = this.world.frame;
+    if (f - (this.confirmedFrame + 1) >= this.config.maxRollback) return 0;
+    this.publishLocal(f, localActions);
+    if (!this.resolveCorrections()) return 0;
+    this.storeSnapshot(f);
+    this.stepFrame(f);
+    this.settleHashes();
+    if (f % 64 === 0) this.pruneOld(f);
+    return 1;
+  }
+  /** Feed real elapsed ms; runs the fixed steps the clock grants. */
+  advance(realMs, localActions = []) {
+    let stepped = 0;
+    const steps = this.world.clock.advance(realMs);
+    for (let i = 0; i < steps; i++) {
+      if (this.tick(localActions) === 0) break;
+      stepped++;
+    }
+    return stepped;
+  }
+  /** Merged CONFIRMED input log from frame 0 — replayable ground truth. */
+  inputLog() {
+    const frames = [];
+    const through = this.confirmedFrame;
+    for (let f = 0; f <= through; f++) {
+      const inputs = /* @__PURE__ */ new Map();
+      for (const p of this.players) inputs.set(p, this.buffer.get(p, f) ?? []);
+      frames.push(mergePlayerFrames(this.players, inputs));
+    }
+    return { frames };
+  }
+  dispose() {
+    this.unsubscribe();
+  }
+  /** Feed a raw transport message that arrived before this session existed. */
+  deliver(data) {
+    this.receive(data);
+  }
+  // ── internals ────────────────────────────────────────────────
+  publishLocal(frame, actions) {
+    if (!this.buffer.set(this.localPlayer, frame, actions)) return;
+    const from = Math.max(0, frame - this.config.redundancy + 1);
+    const frames = [];
+    for (let f = from; f <= frame; f++) frames.push(this.buffer.get(this.localPlayer, f) ?? []);
+    this.transport.send(encodeMessage(netMessage({ t: "input", player: this.localPlayer, from, frames })));
+  }
+  inputsFor(frame) {
+    const inputs = /* @__PURE__ */ new Map();
+    for (const p of this.players) {
+      const cut = this.dropped.get(p);
+      if (cut !== void 0 && frame >= cut) inputs.set(p, []);
+      else inputs.set(p, this.buffer.get(p, frame) ?? this.buffer.latestAt(p, frame));
+    }
+    return inputs;
+  }
+  stepFrame(frame) {
+    const inputs = this.inputsFor(frame);
+    const used = /* @__PURE__ */ new Map();
+    for (const p of this.players) used.set(p, JSON.stringify(inputs.get(p)));
+    this.usedInputs.set(frame, used);
+    this.world.step(mergePlayerFrames(this.players, inputs));
+  }
+  /** Apply pending corrections. False = overflow (fatal). */
+  resolveCorrections() {
+    if (this.earliestBad === Infinity) return true;
+    const target = this.world.frame;
+    const bad = this.earliestBad;
+    this.earliestBad = Infinity;
+    const entry = this.ring[bad % this.ring.length];
+    if (!entry || entry.frame !== bad) {
+      this.overflowed = true;
+      this.onRollbackOverflow?.(bad);
+      return false;
+    }
+    this.rollbackCount++;
+    this.world.restore(entry.snap);
+    this.attach?.(this.world);
+    for (let f = bad; f < target; f++) {
+      this.storeSnapshot(f);
+      this.stepFrame(f);
+      this.resimulatedFrames++;
+    }
+    return true;
+  }
+  storeSnapshot(frame) {
+    this.ring[frame % this.ring.length] = { frame, snap: this.world.snapshot() };
+  }
+  receive(data) {
+    const msg = decodeMessage(data);
+    if (!msg) return;
+    if (msg.t === "input" && msg.player !== this.localPlayer) {
+      const cut = this.dropped.get(msg.player);
+      for (let i = 0; i < msg.frames.length; i++) {
+        const frame = msg.from + i;
+        if (cut !== void 0 && frame >= cut) continue;
+        if (!this.buffer.set(msg.player, frame, msg.frames[i])) continue;
+        if (frame < this.world.frame) {
+          const used = this.usedInputs.get(frame)?.get(msg.player);
+          const actual = JSON.stringify([...msg.frames[i]].sort());
+          if (used !== void 0 && used !== actual) this.earliestBad = Math.min(this.earliestBad, frame);
+        }
+      }
+      this.settleHashes();
+    } else if (msg.t === "hash" && msg.player !== this.localPlayer) {
+      this.pendingRemoteHashes.push({ player: msg.player, frame: msg.frame, hash: msg.hash });
+      this.compareHashes();
+    }
+  }
+  /**
+   * Hash exchange runs on CONFIRMED frames only (predicted state is
+   * provisional by design). A snapshot has exactly the shape `world.hash()`
+   * hashes, so ring entries give us hashes of past frames for free.
+   */
+  settleHashes() {
+    const settled = Math.min(this.confirmedFrame + 1, this.world.frame, this.earliestBad === Infinity ? Infinity : this.earliestBad);
+    const interval = this.config.hashInterval;
+    let h = (Math.floor(this.hashedThrough / interval) + 1) * interval;
+    for (; h <= settled; h += interval) {
+      const entry = this.ring[h % this.ring.length];
+      if (!entry || entry.frame !== h) continue;
+      const hash = hashValue(entry.snap);
+      this.localHashes.set(h, hash);
+      this.hashedThrough = h;
+      this.transport.send(encodeMessage(netMessage({ t: "hash", player: this.localPlayer, frame: h, hash })));
+    }
+    this.compareHashes();
+  }
+  compareHashes() {
+    const still = [];
+    for (const remote of this.pendingRemoteHashes) {
+      const local = this.localHashes.get(remote.frame);
+      if (local === void 0) {
+        if (remote.frame > this.hashedThrough - 512) still.push(remote);
+        continue;
+      }
+      if (local !== remote.hash && !this.desynced) {
+        this.desynced = true;
+        this.onDesync?.({
+          frame: remote.frame,
+          player: remote.player,
+          localHash: local,
+          remoteHash: remote.hash,
+          log: this.inputLog(),
+          startFrame: 0
+        });
+      }
+    }
+    this.pendingRemoteHashes = still;
+  }
+  pruneOld(frame) {
+    this.buffer.prune(frame - 128);
+    for (const f of this.usedInputs.keys()) if (f < frame - 128) this.usedInputs.delete(f);
+    for (const f of this.localHashes.keys()) if (f < frame - 512) this.localHashes.delete(f);
+  }
+};
+
+// src/net/room.ts
+function makeUid() {
+  return globalThis.crypto.randomUUID();
+}
+function buildSession(mode, world, transport, localPlayer, players, startFrame, config, attach, callbacks) {
+  if (mode === "rollback") {
+    return new RollbackSession({ world, transport, localPlayer, players, config, attach, onDesync: callbacks.onDesync });
+  }
+  return new LockstepSession({ world, transport, localPlayer, players, startFrame, config, onDesync: callbacks.onDesync });
+}
+function makeGame(world, session, localPlayer, players, extraDispose) {
+  return {
+    world,
+    session,
+    localPlayer,
+    players,
+    advance: (realMs, localActions = []) => session.advance(realMs, localActions),
+    dispose: () => {
+      session.dispose();
+      extraDispose?.();
+    }
+  };
+}
+var RoomHost = class {
+  localPlayer = "p1";
+  seed;
+  config;
+  transport;
+  makeWorld;
+  maxPlayers;
+  joinMargin;
+  attach;
+  callbacks;
+  players = ["p1"];
+  uidToPlayer = /* @__PURE__ */ new Map();
+  nextPlayerIndex = 2;
+  started = false;
+  game = null;
+  pendingSnapshots = [];
+  unsubscribe;
+  constructor(opts) {
+    this.transport = opts.transport;
+    this.makeWorld = opts.makeWorld;
+    this.seed = opts.seed ?? 1;
+    this.config = { ...DEFAULT_SESSION_CONFIG, ...opts.config };
+    this.maxPlayers = opts.maxPlayers ?? 4;
+    this.joinMargin = opts.joinMargin ?? 30;
+    this.attach = opts.attach;
+    this.callbacks = opts;
+    this.unsubscribe = this.transport.onMessage((data) => this.receive(data));
+  }
+  /** Players currently in the room (host first). */
+  get roster() {
+    return [...this.players];
+  }
+  get isStarted() {
+    return this.started;
+  }
+  /** Freeze the roster's frame 0 and begin simulating. */
+  start() {
+    if (this.game) return this.game;
+    this.started = true;
+    const world = this.makeWorld(this.seed);
+    const session = buildSession(
+      this.config.mode,
+      world,
+      this.transport,
+      this.localPlayer,
+      this.players,
+      0,
+      this.config,
+      this.attach,
+      this.callbacks
+    );
+    if (session instanceof LockstepSession) {
+      session.onAfterStep((frame) => this.serviceSnapshots(frame, world));
+    }
+    this.transport.send(encodeMessage(netMessage({ t: "start", players: [...this.players] })));
+    this.game = makeGame(world, session, this.localPlayer, this.players, () => this.unsubscribe());
+    return this.game;
+  }
+  /** Announce a player's departure (disconnect handling is the app's call). */
+  dropPlayer(player) {
+    const session = this.game?.session;
+    if (!session) return;
+    const atFrame = session instanceof LockstepSession ? Math.max(session.frame, session.confirmedFrame + 1) : session.lastKnownFrame(player) + 1;
+    this.transport.send(encodeMessage(netMessage({ t: "leave", player, atFrame })));
+    session.removePlayer(player, atFrame);
+    this.players = this.players.filter((p) => p !== player);
+    this.callbacks.onPlayerLeave?.(player, atFrame);
+  }
+  dispose() {
+    this.unsubscribe();
+    this.game?.dispose();
+  }
+  // ── internals ────────────────────────────────────────────────
+  receive(data) {
+    const msg = decodeMessage(data);
+    if (!msg) return;
+    if (msg.t === "hello") this.handleHello(msg);
+    else if (msg.t === "bye") {
+      const player = this.uidToPlayer.get(msg.uid);
+      if (player && this.started) this.dropPlayer(player);
+      else if (player) {
+        this.players = this.players.filter((p) => p !== player);
+        this.uidToPlayer.delete(msg.uid);
+      }
+    }
+  }
+  handleHello(msg) {
+    if (this.uidToPlayer.has(msg.uid)) return;
+    if (this.players.length >= this.maxPlayers) {
+      this.transport.send(encodeMessage(netMessage({ t: "deny", to: msg.uid, reason: "room full" })));
+      return;
+    }
+    if (this.started && this.config.mode === "rollback") {
+      this.transport.send(encodeMessage(netMessage({ t: "deny", to: msg.uid, reason: "rollback rooms cannot be joined mid-game" })));
+      return;
+    }
+    const player = `p${this.nextPlayerIndex++}`;
+    this.uidToPlayer.set(msg.uid, player);
+    this.players.push(player);
+    if (!this.started) {
+      this.transport.send(
+        encodeMessage(
+          netMessage({
+            t: "welcome",
+            to: msg.uid,
+            player,
+            players: [...this.players],
+            seed: this.seed,
+            config: this.config,
+            startFrame: 0
+          })
+        )
+      );
+      this.callbacks.onPlayerJoin?.(player, 0);
+      return;
+    }
+    const session = this.game.session;
+    const atFrame = session.frame + this.joinMargin;
+    this.transport.send(encodeMessage(netMessage({ t: "join", player, atFrame })));
+    session.addPlayer(player, atFrame);
+    this.pendingSnapshots.push({ uid: msg.uid, player, atFrame });
+    this.callbacks.onPlayerJoin?.(player, atFrame);
+  }
+  serviceSnapshots(frame, world) {
+    if (this.pendingSnapshots.length === 0) return;
+    const due = this.pendingSnapshots.filter((p) => p.atFrame === frame);
+    if (due.length === 0) return;
+    this.pendingSnapshots = this.pendingSnapshots.filter((p) => p.atFrame !== frame);
+    const snapshot = world.snapshot();
+    for (const join of due) {
+      const stillPending = this.pendingSnapshots.filter((p) => p.player !== join.player);
+      const pendingIds = new Set(stillPending.map((p) => p.player));
+      this.transport.send(
+        encodeMessage(
+          netMessage({
+            t: "welcome",
+            to: join.uid,
+            player: join.player,
+            players: this.players.filter((p) => !pendingIds.has(p)),
+            seed: this.seed,
+            config: this.config,
+            startFrame: frame,
+            snapshot,
+            joins: stillPending.map((p) => ({ player: p.player, atFrame: p.atFrame }))
+          })
+        )
+      );
+    }
+  }
+};
+function joinRoom(opts) {
+  const uid = makeUid();
+  const transport = opts.transport;
+  return new Promise((resolve, reject) => {
+    let welcome = null;
+    let started = false;
+    let startRoster = null;
+    const buffered = [];
+    const pendingRoster = [];
+    const finish = () => {
+      if (!welcome || !started) return;
+      unsub();
+      const roster = startRoster ?? welcome.players;
+      const world = opts.makeWorld(welcome.seed);
+      if (welcome.snapshot) {
+        world.restore(welcome.snapshot);
+        opts.attach?.(world);
+      }
+      const session = buildSession(
+        welcome.config.mode,
+        world,
+        transport,
+        welcome.player,
+        roster,
+        welcome.startFrame,
+        welcome.config,
+        opts.attach,
+        opts
+      );
+      if (welcome.joins && session instanceof LockstepSession) {
+        for (const j of welcome.joins) session.addPlayer(j.player, j.atFrame);
+      }
+      for (const m of pendingRoster) {
+        if (m.t === "join" && session instanceof LockstepSession) session.addPlayer(m.player, m.atFrame);
+        if (m.t === "leave") session.removePlayer(m.player, m.atFrame);
+      }
+      const roomUnsub = transport.onMessage((data) => {
+        const msg = decodeMessage(data);
+        if (!msg) return;
+        if (msg.t === "join" && session instanceof LockstepSession) {
+          session.addPlayer(msg.player, msg.atFrame);
+          opts.onPlayerJoin?.(msg.player, msg.atFrame);
+        } else if (msg.t === "leave") {
+          session.removePlayer(msg.player, msg.atFrame);
+          opts.onPlayerLeave?.(msg.player, msg.atFrame);
+        }
+      });
+      const game = makeGame(world, session, welcome.player, roster, () => {
+        roomUnsub();
+        transport.send(encodeMessage(netMessage({ t: "bye", uid })));
+      });
+      for (const data of buffered) session.deliver(data);
+      resolve(game);
+    };
+    const unsub = transport.onMessage((data) => {
+      const msg = decodeMessage(data);
+      if (!msg) return;
+      switch (msg.t) {
+        case "welcome":
+          if (msg.to === uid) {
+            welcome = msg;
+            if (msg.snapshot || msg.startFrame > 0) started = true;
+            finish();
+          }
+          break;
+        case "deny":
+          if (msg.to === uid) {
+            unsub();
+            reject(new Error(`hayao-net: join denied \u2014 ${msg.reason}`));
+          }
+          break;
+        case "start":
+          started = true;
+          startRoster = msg.players;
+          finish();
+          break;
+        case "join":
+        case "leave":
+          pendingRoster.push(msg);
+          break;
+        case "input":
+        case "hash":
+          buffered.push(data);
+          break;
+      }
+    });
+    transport.send(encodeMessage(netMessage({ t: "hello", uid, name: opts.name })));
+  });
+}
+function hostRoom(opts) {
+  return new RoomHost(opts);
+}
+
+// src/world.ts
+var World = class {
+  rng;
+  clock;
+  input = new InputState();
+  events = new EventBus();
+  resources = /* @__PURE__ */ new Map();
+  /**
    * Canonical game state that lives OUTSIDE the scene tree (pure-sim structs,
    * controllers). Must be plain JSON-serializable data: it is included in
    * `hash()` and `snapshot()`, so hidden state here cannot escape determinism
@@ -2634,6 +6878,86 @@ function runHeadless(def, inputLog) {
   return { world, hash: world.hash(), steps: frames.length };
 }
 
+// src/net/browser.ts
+function runBrowserNet(def, mount, opts) {
+  const width = def.width ?? 1280;
+  const height = def.height ?? 720;
+  const background = def.background ?? "#f3ecdb";
+  const renderer = opts.renderer === "canvas" ? new Canvas2DRenderer({ width, height, background }) : new SvgRenderer({ width, height, background });
+  mount.style.position = mount.style.position || "relative";
+  renderer.mount?.(mount);
+  setOverlayHost(mount);
+  const input = new KeyboardSource(def.inputMap ?? {}, document);
+  const makeWorld = (seed) => createWorld(def, seed);
+  let game = null;
+  let host2 = null;
+  let raf = 0;
+  let stopped = false;
+  const loop = (last) => (now) => {
+    if (!stopped && game) {
+      const stepped = game.advance(now - last, input.currentActions());
+      if (stepped > 0) input.clearPressed();
+      renderer.draw(game.world.render());
+    }
+    raf = requestAnimationFrame(loop(now));
+  };
+  const begin = (g) => {
+    game = g;
+    opts.onStatus?.(`playing as ${g.localPlayer} (${g.players.length} players)`);
+    raf = requestAnimationFrame(loop(performance.now()));
+  };
+  if (opts.role === "host") {
+    host2 = hostRoom({
+      transport: opts.transport,
+      makeWorld,
+      seed: opts.seed ?? def.seed ?? 1,
+      config: opts.config,
+      maxPlayers: opts.maxPlayers,
+      attach: opts.attach,
+      onDesync: opts.onDesync,
+      onPlayerJoin: (p, f) => {
+        opts.onStatus?.(`${p} joined`);
+        opts.onPlayerJoin?.(p, f);
+      },
+      onPlayerLeave: opts.onPlayerLeave
+    });
+    opts.onStatus?.("hosting \u2014 waiting for players");
+  } else {
+    opts.onStatus?.("joining\u2026");
+    joinRoom({
+      transport: opts.transport,
+      makeWorld,
+      attach: opts.attach,
+      onDesync: opts.onDesync,
+      onPlayerJoin: opts.onPlayerJoin,
+      onPlayerLeave: opts.onPlayerLeave
+    }).then(begin).catch((err) => opts.onStatus?.(err.message));
+  }
+  return {
+    start() {
+      if (host2 && !game) begin(host2.start());
+    },
+    get game() {
+      return game;
+    },
+    get localPlayer() {
+      return game?.localPlayer ?? (opts.role === "host" ? "p1" : null);
+    },
+    get roster() {
+      return host2?.roster ?? game?.players ?? [];
+    },
+    input,
+    stop() {
+      stopped = true;
+      cancelAnimationFrame(raf);
+      game?.dispose();
+      host2?.dispose();
+      input.dispose();
+      renderer.dispose?.();
+    }
+  };
+}
+
 // src/app/browser.ts
 function runBrowser(def, mount, opts = {}) {
   const width = def.width ?? 1280;
@@ -2711,33 +7035,66 @@ function runBrowser(def, mount, opts = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 export {
+  AMBIENT_PRESETS,
+  AmbientField,
   AnimationPlayer,
   AudioBus,
+  BitmapText,
+  BroadcastChannelTransport,
   Camera2D,
   Canvas2DRenderer,
+  CinematicPlayer,
   Clock,
   DEFAULT_INPUT_MAP,
   DEFAULT_PLATFORMER,
+  DEFAULT_SESSION_CONFIG,
   DEFAULT_TILE_CHARS,
   DUSK,
   EASINGS,
+  Edge,
   EventBus,
+  FLOAT_PRESETS,
+  FONT_5,
+  FloatingText,
+  Fsm,
   HeadlessRenderer,
   IDENTITY,
+  InputBuffer,
   InputRecorder,
   InputState,
   KeyboardSource,
+  LocalStorageAdapter,
+  LockstepSession,
+  LoopbackHub,
+  LoopbackTransport,
+  LootTable,
   MEADOW,
+  MemoryStorage,
+  NEIGHBORS_4,
+  NEIGHBORS_8,
+  NET_PROTOCOL_VERSION,
   Node,
   Node as Node2D,
+  NodePool,
+  NullStorage,
   PAD_NEUTRAL,
   PALETTES,
+  PANEL_PRESETS,
   PAPER,
   PARTICLE_PRESETS,
   Particles,
+  PhaseClock,
+  PixelBuffer,
+  PlayerInput,
+  RingBuffer,
   Rng,
+  RollbackSession,
+  RoomHost,
+  SAVE_FORMAT_VERSION,
+  SaveManager,
+  ScreenTransition,
   Shaker,
   Shell,
   Signal,
@@ -2747,59 +7104,150 @@ export {
   TAU,
   TILE,
   Text,
+  TextureSprite,
   Timer,
+  UndoStack,
   VERSION,
+  WangFrame,
   World,
+  addBody,
+  addDistanceJoint,
+  addRevoluteJoint,
+  addTransition,
+  applyImpulse,
   applyTransform,
   asciiEntities,
   assertDeterministic,
   assertSnapshotStable,
   assertSolvable,
+  astar,
+  astarGrid,
   audio,
+  autotile4,
+  autotileToCommands,
+  availableUpgrades,
+  bfs,
   blobPath,
+  bodyAABB,
+  bodyContains,
+  cellFloat,
+  cellHash,
+  cellInt,
   changeFrames,
   checkDeterministic,
   clamp,
+  collide,
   commandsToSVGInner,
   composeTransform,
+  connectWebSocket,
+  connectedComponents,
+  contourToCommands,
   createPlanBot,
   createPlatformerState,
+  createRigidWorld,
   createWorld,
   dashJumpDistance,
+  datan,
+  datan2,
+  dcos,
+  decode2bit,
+  decodeBits,
+  decodeMessage,
+  decodeRLE,
+  defaultStorage,
   defineGame,
   deg2rad,
   deserializeNode,
+  dexp,
+  dexp2,
+  dhypot,
+  dlog,
+  dlog10,
+  dlog2,
   drive,
+  dsin,
+  encodeMessage,
+  encodeRLE,
   firstFrame,
+  floodFill,
+  fractalNoise,
   frameActions,
   gameInputMap,
+  generateCave,
+  generateDungeon,
+  getBody,
+  getJoint,
+  gradient,
+  gridAt,
+  gridFromRows,
+  gridSet,
+  gridToTilemap,
   groundAt,
   hashString,
   hashValue,
+  hexToHsl,
   hideScreen,
   hold,
+  hostRoom,
+  hsl,
+  hsv,
   inVisionCone,
+  initDirector,
   inputDensity,
   installCapture,
   invLerp,
   invertTransform,
   isCaptureMode,
+  isGround,
   isMonotonic,
+  joinRoom,
   jumpAirtime,
   jumpDistance,
   jumpHeight,
+  keyMentions,
   keysToActions,
+  layoutIssues,
+  layoutText,
   lerp,
+  lerpDamp,
   lineOfSight,
   longestLull,
+  makeGrid,
+  makeReach,
   makeTransform,
   mapHeight,
   mapWidth,
+  marchingSquaresCases,
+  marchingSquaresContours,
+  mask4,
+  mask8,
+  measureLine,
+  measureText,
+  mergePlayerFrames,
+  missingControlHints,
   mix,
+  mixLinear,
   moveRect,
+  mutateColor,
+  netMessage,
+  nineSlice,
+  packVarints,
+  parseRich,
+  parseSnapshot,
+  passableFromTilemap,
+  pickEntry,
+  pixelsToCommands,
+  playerAction,
+  playerIds,
+  playerInput,
+  pointQuery,
+  pollDirector,
+  polygonBox,
   pump,
   rad2deg,
+  rayCastRigid,
   raycastTiles,
+  reconstructPath,
   recordTimeline,
   rectBlocked,
   rectContains,
@@ -2807,30 +7255,55 @@ export {
   registerNode,
   regularPolygon,
   remap,
+  removeBody,
+  removeJoint,
   renderFilmstrip,
   renderToSVGString,
   replay,
   resetNodeIds,
+  rigidStep,
+  rleDecode,
+  rleEncode,
+  roomCenter,
   runBrowser,
+  runBrowserNet,
   runHeadless,
+  sampleGradient,
+  scatter,
+  scatterCells,
+  screenRect,
   scriptToFrames,
   scriptedPlaythrough,
+  serializeSnapshot,
   series,
   setOverlayHost,
   settings,
+  shapeBox,
   showScreen,
   smoothClosedPath,
   smoothOpenPath,
+  smoothstep,
+  solidNeighbours,
   solve,
+  solveJoint,
   sortCommands,
+  spring,
+  springStep,
   star,
   steer2D,
   stepPlatformer,
+  terrainHeight,
+  terrainSlice,
+  textBox,
+  textToCommands,
   tileAt,
   tileAtPoint,
   tilemapFromAscii,
   toggleFullscreen,
+  typewriterCount,
+  unpackVarints,
   vadd,
+  valueNoise,
   vdist,
   vdot,
   vec2,
@@ -2839,6 +7312,13 @@ export {
   vscale,
   vsub,
   wait,
-  withAlpha
+  wakeBody,
+  wangTile,
+  weatherEnvelope,
+  weightedIndex,
+  weightedPick,
+  wipeStep,
+  withAlpha,
+  worldPoints
 };
 //# sourceMappingURL=index.js.map