hayao 0.1.0

package/dist/index.js

@@ -0,0 +1,2844 @@
+// 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);
+function vnorm(a) {
+  const l = vlen(a);
+  return l === 0 ? { x: 0, y: 0 } : { x: a.x / l, y: a.y / l };
+}
+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 TAU = Math.PI * 2;
+var deg2rad = (d) => d * Math.PI / 180;
+var rad2deg = (r) => r * 180 / Math.PI;
+function rectContains(r, p) {
+  return p.x >= r.x && p.x <= r.x + r.w && p.y >= r.y && p.y <= r.y + r.h;
+}
+function rectsOverlap(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;
+}
+var IDENTITY = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
+function composeTransform(m, n2) {
+  return {
+    a: m.a * n2.a + m.c * n2.b,
+    b: m.b * n2.a + m.d * n2.b,
+    c: m.a * n2.c + m.c * n2.d,
+    d: m.b * n2.c + m.d * n2.d,
+    e: m.a * n2.e + m.c * n2.f + m.e,
+    f: m.b * n2.e + m.d * n2.f + m.f
+  };
+}
+function makeTransform(pos, rotation, scale) {
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  return {
+    a: cos * scale.x,
+    b: sin * scale.x,
+    c: -sin * scale.y,
+    d: cos * scale.y,
+    e: pos.x,
+    f: pos.y
+  };
+}
+function applyTransform(m, p) {
+  return { x: m.a * p.x + m.c * p.y + m.e, y: m.b * p.x + m.d * p.y + m.f };
+}
+function invertTransform(m) {
+  const det = m.a * m.d - m.b * m.c;
+  if (det === 0) return { ...IDENTITY };
+  const id = 1 / det;
+  return {
+    a: m.d * id,
+    b: -m.b * id,
+    c: -m.c * id,
+    d: m.a * id,
+    e: (m.c * m.f - m.d * m.e) * id,
+    f: (m.b * m.e - m.a * m.f) * id
+  };
+}
+
+// src/core/rng.ts
+function splitmix32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 2654435769 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 16, 569420461);
+    t = Math.imul(t ^ t >>> 15, 1935289751);
+    return (t ^ t >>> 15) >>> 0;
+  };
+}
+var Rng = class _Rng {
+  s0;
+  s1;
+  s2;
+  s3;
+  constructor(seed = 0) {
+    if (typeof seed === "number") {
+      const sm = splitmix32(seed === 0 ? 305441741 : seed);
+      this.s0 = sm();
+      this.s1 = sm();
+      this.s2 = sm();
+      this.s3 = sm();
+    } else {
+      [this.s0, this.s1, this.s2, this.s3] = seed.s;
+    }
+  }
+  /** Raw 32-bit unsigned integer. */
+  next() {
+    const result = Math.imul(this.rotl(Math.imul(this.s1, 5), 7), 9) >>> 0;
+    const t = this.s1 << 9 >>> 0;
+    this.s2 ^= this.s0;
+    this.s3 ^= this.s1;
+    this.s1 ^= this.s2;
+    this.s0 ^= this.s3;
+    this.s2 = (this.s2 ^ t) >>> 0;
+    this.s3 = this.rotl(this.s3, 11);
+    return result >>> 0;
+  }
+  rotl(x, k) {
+    return (x << k | x >>> 32 - k) >>> 0;
+  }
+  /** Float in [0, 1). */
+  float() {
+    return this.next() / 4294967296;
+  }
+  /** Float in [lo, hi). */
+  range(lo, hi) {
+    return lo + this.float() * (hi - lo);
+  }
+  /** Integer in [0, n). */
+  int(n2) {
+    return Math.floor(this.float() * n2);
+  }
+  /** Integer in [lo, hi] inclusive. */
+  intRange(lo, hi) {
+    return lo + this.int(hi - lo + 1);
+  }
+  /** True with probability p. */
+  chance(p) {
+    return this.float() < p;
+  }
+  /** Uniform element of an array. */
+  pick(arr) {
+    return arr[this.int(arr.length)];
+  }
+  /** In-place Fisher–Yates shuffle (deterministic). */
+  shuffle(arr) {
+    for (let i = arr.length - 1; i > 0; i--) {
+      const j = this.int(i + 1);
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return arr;
+  }
+  /**
+   * Derive an independent child stream. Same parent state + same key always
+   * yields the same child — so subsystems (enemy AI, loot, terrain) get stable,
+   * decorrelated randomness without threading one generator through everything.
+   */
+  split(key = 0) {
+    const mix2 = (this.s0 ^ Math.imul(key + 1, 2654435769)) >>> 0;
+    const child = new _Rng(mix2 ^ this.s3);
+    this.next();
+    return child;
+  }
+  /** Serialize / restore for saves and replay. */
+  getState() {
+    return { s: [this.s0, this.s1, this.s2, this.s3] };
+  }
+  setState(state) {
+    [this.s0, this.s1, this.s2, this.s3] = state.s;
+  }
+};
+function hashString(str) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+
+// src/core/clock.ts
+var Clock = class {
+  stepMs;
+  dt;
+  // fixed delta in seconds, for game logic
+  maxFrameMs;
+  accumulator = 0;
+  _frame = 0;
+  _simTimeMs = 0;
+  constructor(config = {}) {
+    const hz = config.hz ?? 60;
+    this.stepMs = 1e3 / hz;
+    this.dt = 1 / hz;
+    this.maxFrameMs = config.maxFrameMs ?? 250;
+  }
+  /**
+   * Feed real elapsed ms; returns how many fixed steps to run now.
+   * Caller runs the sim exactly that many times.
+   */
+  advance(realMs) {
+    this.accumulator += Math.min(realMs, this.maxFrameMs);
+    let steps = 0;
+    while (this.accumulator >= this.stepMs) {
+      this.accumulator -= this.stepMs;
+      steps++;
+    }
+    return steps;
+  }
+  /** Called by the World once per executed step to keep counters honest. */
+  tick() {
+    this._frame++;
+    this._simTimeMs += this.stepMs;
+  }
+  /** Interpolation alpha in [0,1) for smooth rendering between fixed steps. */
+  get alpha() {
+    return this.accumulator / this.stepMs;
+  }
+  get frame() {
+    return this._frame;
+  }
+  get simTimeMs() {
+    return this._simTimeMs;
+  }
+  get simTimeSec() {
+    return this._simTimeMs / 1e3;
+  }
+  getState() {
+    return { accumulator: this.accumulator, frame: this._frame, simTimeMs: this._simTimeMs };
+  }
+  setState(s) {
+    this.accumulator = s.accumulator;
+    this._frame = s.frame;
+    this._simTimeMs = s.simTimeMs;
+  }
+};
+
+// src/core/events.ts
+var Signal = class {
+  listeners = [];
+  connect(fn) {
+    this.listeners.push(fn);
+    return () => this.disconnect(fn);
+  }
+  once(fn) {
+    const off = this.connect((p) => {
+      off();
+      fn(p);
+    });
+    return off;
+  }
+  disconnect(fn) {
+    const i = this.listeners.indexOf(fn);
+    if (i >= 0) this.listeners.splice(i, 1);
+  }
+  emit(payload) {
+    for (const fn of this.listeners.slice()) fn(payload);
+  }
+  get count() {
+    return this.listeners.length;
+  }
+  clear() {
+    this.listeners.length = 0;
+  }
+};
+var EventBus = class {
+  signals = /* @__PURE__ */ new Map();
+  signalFor(key) {
+    let s = this.signals.get(key);
+    if (!s) {
+      s = new Signal();
+      this.signals.set(key, s);
+    }
+    return s;
+  }
+  on(key, fn) {
+    return this.signalFor(key).connect(fn);
+  }
+  once(key, fn) {
+    return this.signalFor(key).once(fn);
+  }
+  emit(key, payload) {
+    this.signalFor(key).emit(payload);
+  }
+  clear() {
+    this.signals.clear();
+  }
+};
+
+// src/core/hash.ts
+function canonicalNumber(n2) {
+  if (Number.isNaN(n2)) return "NaN";
+  if (n2 === Infinity) return "Inf";
+  if (n2 === -Infinity) return "-Inf";
+  if (n2 === 0) return "0";
+  return n2.toString();
+}
+function hashValue(value) {
+  let h1 = 2166136261 >>> 0;
+  let h2 = 2166136261 >>> 0;
+  const push = (s) => {
+    for (let i = 0; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      h1 = Math.imul(h1 ^ c, 16777619) >>> 0;
+      h2 = Math.imul(h2 ^ (c << 3 | c >>> 5), 2246822519) >>> 0;
+    }
+  };
+  const walk = (v) => {
+    if (v === null) return push("n");
+    if (v === void 0) return push("u");
+    switch (typeof v) {
+      case "number":
+        return push("#" + canonicalNumber(v));
+      case "boolean":
+        return push(v ? "t" : "f");
+      case "string":
+        return push('"' + v);
+      case "object": {
+        if (Array.isArray(v)) {
+          push("[");
+          for (const el of v) walk(el);
+          push("]");
+          return;
+        }
+        const obj = v;
+        const keys = Object.keys(obj).sort();
+        push("{");
+        for (const k of keys) {
+          push(k + ":");
+          walk(obj[k]);
+        }
+        push("}");
+        return;
+      }
+      default:
+        push("?");
+    }
+  };
+  walk(value);
+  const hex = (n2) => n2.toString(16).padStart(8, "0");
+  return hex(h1) + hex(h2);
+}
+
+// src/scene/node.ts
+var __idCounter = 0;
+function resetNodeIds(start = 0) {
+  __idCounter = start;
+}
+var Node = class {
+  id;
+  name;
+  /** Type tag for serialization; subclasses override. */
+  type = "Node";
+  pos;
+  rotation;
+  scale;
+  z;
+  visible;
+  /**
+   * Cosmetic nodes are pure *view* (derived from game state, rebuildable) and are
+   * excluded from serialize()/snapshot()/hash(). Mark a container cosmetic when it
+   * only renders state that lives elsewhere — so transient display (move counters,
+   * particles, tweened positions) never pollutes the canonical, verifiable state.
+   */
+  cosmetic = false;
+  parent = null;
+  children = [];
+  world = null;
+  /** Optional inline update without subclassing: node.onUpdate = (n, dt) => {…}. */
+  onUpdate;
+  behaviors = [];
+  signals = /* @__PURE__ */ new Map();
+  _ready = false;
+  _freed = false;
+  constructor(config = {}) {
+    this.id = `n${__idCounter++}`;
+    this.name = config.name ?? this.constructor.name;
+    this.pos = config.pos ? { ...config.pos } : { x: 0, y: 0 };
+    this.rotation = config.rotation ?? 0;
+    this.scale = config.scale ? { ...config.scale } : { x: 1, y: 1 };
+    this.z = config.z ?? 0;
+    this.visible = config.visible ?? true;
+  }
+  // ── Tree structure ─────────────────────────────────────────────
+  addChild(child) {
+    child.parent = this;
+    this.children.push(child);
+    if (this.world && this._ready) child.enterTree(this.world);
+    return child;
+  }
+  removeChild(child) {
+    const i = this.children.indexOf(child);
+    if (i >= 0) {
+      this.children.splice(i, 1);
+      child.parent = null;
+    }
+  }
+  /** Deferred free: runs exit hooks and detaches at the end of the step. */
+  free() {
+    this.world?.requestFree(this);
+  }
+  /** Depth-first find by name. */
+  find(name) {
+    if (this.name === name) return this;
+    for (const c of this.children) {
+      const r = c.find(name);
+      if (r) return r;
+    }
+    return null;
+  }
+  /** All descendants (and self) of a given type tag. */
+  query(type, out = []) {
+    if (this.type === type) out.push(this);
+    for (const c of this.children) c.query(type, out);
+    return out;
+  }
+  // ── Behaviors ─────────────────────────────────────────────────
+  addBehavior(b) {
+    this.behaviors.push(b);
+    if (this._ready) b.ready?.(this);
+    return this;
+  }
+  // ── Signals ───────────────────────────────────────────────────
+  signal(name) {
+    let s = this.signals.get(name);
+    if (!s) {
+      s = new Signal();
+      this.signals.set(name, s);
+    }
+    return s;
+  }
+  emit(name, payload) {
+    this.signals.get(name)?.emit(payload);
+  }
+  // ── Lifecycle (engine-called) ─────────────────────────────────
+  enterTree(world) {
+    this.world = world;
+    if (!this._ready) {
+      this._ready = true;
+      this.onReady();
+      for (const b of this.behaviors) b.ready?.(this);
+    }
+    for (const c of this.children) c.enterTree(world);
+  }
+  updateTree(dt) {
+    if (this._freed) return;
+    for (const b of this.behaviors) b.update?.(this, dt);
+    this.onUpdate?.(this, dt);
+    this.onProcess(dt);
+    for (const c of this.children.slice()) c.updateTree(dt);
+  }
+  exitTree() {
+    for (const b of this.behaviors) b.exit?.(this);
+    this.onExit();
+    for (const c of this.children.slice()) c.exitTree();
+    this._freed = true;
+  }
+  get isFreed() {
+    return this._freed;
+  }
+  // ── Transforms ────────────────────────────────────────────────
+  localTransform() {
+    return makeTransform(this.pos, this.rotation, this.scale);
+  }
+  worldTransform() {
+    const local = this.localTransform();
+    return this.parent ? composeTransform(this.parent.worldTransform(), local) : local;
+  }
+  // ── Rendering (projection) ────────────────────────────────────
+  /** Walk the subtree, appending draw commands with computed world transforms. */
+  collectDraw(out, parentWorld = IDENTITY) {
+    if (!this.visible) return;
+    const world = composeTransform(parentWorld, this.localTransform());
+    this.draw(out, world);
+    for (const c of this.children) c.collectDraw(out, world);
+  }
+  /** Subclasses emit their own commands here. Base draws nothing. */
+  draw(_out, _world) {
+  }
+  // ── Overridable hooks ─────────────────────────────────────────
+  onReady() {
+  }
+  onProcess(_dt) {
+  }
+  onExit() {
+  }
+  // ── Serialization (data only; behaviors/closures are re-attached by scene code) ──
+  serialize() {
+    return {
+      type: this.type,
+      name: this.name,
+      pos: { ...this.pos },
+      rotation: this.rotation,
+      scale: { ...this.scale },
+      z: this.z,
+      visible: this.visible,
+      props: this.serializeProps(),
+      children: this.children.filter((c) => !c.cosmetic).map((c) => c.serialize())
+    };
+  }
+  /** Subclasses persist their own fields here. */
+  serializeProps() {
+    return {};
+  }
+  /** Subclasses restore their own fields here. */
+  applyProps(_props) {
+  }
+};
+
+// src/scene/nodes.ts
+var Sprite = class extends Node {
+  type = "Sprite";
+  shape;
+  paint;
+  constructor(config) {
+    super(config);
+    this.shape = config.shape;
+    this.paint = {
+      fill: config.fill,
+      stroke: config.stroke,
+      strokeWidth: config.strokeWidth,
+      opacity: config.opacity,
+      round: config.round
+    };
+  }
+  draw(out, world) {
+    const p = this.paint;
+    const base = { transform: world, z: this.z, ...p };
+    switch (this.shape.kind) {
+      case "rect":
+        out.push({ kind: "rect", x: -this.shape.w / 2, y: -this.shape.h / 2, w: this.shape.w, h: this.shape.h, r: this.shape.r, ...base });
+        break;
+      case "circle":
+        out.push({ kind: "circle", cx: 0, cy: 0, radius: this.shape.radius, ...base });
+        break;
+      case "poly":
+        out.push({ kind: "poly", points: this.shape.points, closed: this.shape.closed ?? true, ...base });
+        break;
+      case "path":
+        out.push({ kind: "path", d: this.shape.d, ...base });
+        break;
+      case "glyph":
+        out.push({ kind: "text", text: this.shape.char, x: 0, y: 0, size: this.shape.size, align: "center", ...base });
+        break;
+    }
+  }
+  serializeProps() {
+    return { shape: this.shape, paint: this.paint };
+  }
+  applyProps(props) {
+    if (props.shape) this.shape = props.shape;
+    if (props.paint) this.paint = props.paint;
+  }
+};
+var Text = class extends Node {
+  type = "Text";
+  text;
+  size;
+  font;
+  align;
+  weight;
+  paint;
+  constructor(config) {
+    super(config);
+    this.text = config.text;
+    this.size = config.size ?? 24;
+    this.font = config.font;
+    this.align = config.align ?? "left";
+    this.weight = config.weight;
+    this.paint = { fill: config.fill ?? "#000", stroke: config.stroke, strokeWidth: config.strokeWidth, opacity: config.opacity };
+  }
+  draw(out, world) {
+    out.push({
+      kind: "text",
+      text: this.text,
+      x: 0,
+      y: 0,
+      size: this.size,
+      font: this.font,
+      align: this.align,
+      weight: this.weight,
+      transform: world,
+      z: this.z,
+      ...this.paint
+    });
+  }
+  serializeProps() {
+    return { text: this.text, size: this.size, align: this.align, paint: this.paint };
+  }
+  applyProps(props) {
+    if (typeof props.text === "string") this.text = props.text;
+    if (typeof props.size === "number") this.size = props.size;
+    if (props.align) this.align = props.align;
+    if (props.paint) this.paint = props.paint;
+  }
+};
+var Camera2D = class extends Node {
+  type = "Camera2D";
+  zoom;
+  current;
+  constructor(config = {}) {
+    super(config);
+    this.zoom = config.zoom ?? 1;
+    this.current = config.current ?? true;
+  }
+  onReady() {
+    if (this.current) this.world.activeCamera = this;
+  }
+  serializeProps() {
+    return { zoom: this.zoom, current: this.current };
+  }
+  applyProps(props) {
+    if (typeof props.zoom === "number") this.zoom = props.zoom;
+    if (typeof props.current === "boolean") this.current = props.current;
+  }
+};
+var Timer = class extends Node {
+  type = "Timer";
+  duration;
+  oneShot;
+  remaining;
+  running;
+  constructor(config) {
+    super(config);
+    this.duration = config.duration;
+    this.oneShot = config.oneShot ?? true;
+    this.remaining = config.duration;
+    this.running = config.autostart ?? true;
+  }
+  start(duration) {
+    if (duration !== void 0) this.duration = duration;
+    this.remaining = this.duration;
+    this.running = true;
+  }
+  stop() {
+    this.running = false;
+  }
+  get timeLeft() {
+    return this.remaining;
+  }
+  onProcess(dt) {
+    if (!this.running) return;
+    this.remaining -= dt;
+    if (this.remaining <= 0) {
+      this.emit("timeout", void 0);
+      if (this.oneShot) this.running = false;
+      else this.remaining += this.duration;
+    }
+  }
+  /** Signal emitted when the countdown reaches zero. */
+  get timeout() {
+    return this.signal("timeout");
+  }
+  serializeProps() {
+    return { duration: this.duration, oneShot: this.oneShot, remaining: this.remaining, running: this.running };
+  }
+  applyProps(props) {
+    if (typeof props.duration === "number") this.duration = props.duration;
+    if (typeof props.oneShot === "boolean") this.oneShot = props.oneShot;
+    if (typeof props.remaining === "number") this.remaining = props.remaining;
+    if (typeof props.running === "boolean") this.running = props.running;
+  }
+};
+
+// src/scene/tween.ts
+var pow = Math.pow;
+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,
+  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,
+  backOut: (t) => {
+    const c1 = 1.70158;
+    const c3 = c1 + 1;
+    return 1 + c3 * pow(t - 1, 3) + c1 * pow(t - 1, 2);
+  },
+  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;
+  },
+  bounceOut: (t) => {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (t < 1 / d1) return n1 * t * t;
+    if (t < 2 / d1) return n1 * (t -= 1.5 / d1) * t + 0.75;
+    if (t < 2.5 / d1) return n1 * (t -= 2.25 / d1) * t + 0.9375;
+    return n1 * (t -= 2.625 / d1) * t + 0.984375;
+  }
+};
+var AnimationPlayer = class extends Node {
+  type = "AnimationPlayer";
+  tracks = [];
+  /**
+   * Animate a value from → to over `duration` seconds via `apply(value)`.
+   * Returns this for chaining.
+   */
+  to(apply, from, to, duration, ease = "cubicOut", opts = {}) {
+    this.tracks.push({
+      apply,
+      from,
+      to,
+      duration: Math.max(1e-6, duration),
+      elapsed: 0,
+      ease: typeof ease === "function" ? ease : EASINGS[ease] ?? EASINGS.linear,
+      delay: opts.delay ?? 0,
+      onDone: opts.onDone
+    });
+    return this;
+  }
+  get active() {
+    return this.tracks.length > 0;
+  }
+  /** Signal emitted when all tracks complete. */
+  get finished() {
+    return this.signal("finished");
+  }
+  onProcess(dt) {
+    if (this.tracks.length === 0) return;
+    for (let i = this.tracks.length - 1; i >= 0; i--) {
+      const tk = this.tracks[i];
+      if (tk.delay > 0) {
+        tk.delay -= dt;
+        continue;
+      }
+      tk.elapsed += dt;
+      const t = clamp(tk.elapsed / tk.duration, 0, 1);
+      tk.apply(tk.from + (tk.to - tk.from) * tk.ease(t));
+      if (t >= 1) {
+        tk.onDone?.();
+        this.tracks.splice(i, 1);
+      }
+    }
+    if (this.tracks.length === 0) this.emit("finished", void 0);
+  }
+};
+
+// src/scene/particles.ts
+var Particles = class extends Node {
+  type = "Particles";
+  pool = [];
+  rng;
+  /** Cap on live particles (oldest are recycled first). */
+  maxParticles;
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+    this.rng = new Rng(config.seed ?? 7);
+    this.maxParticles = config.maxParticles ?? 512;
+  }
+  /** Emit a burst at a position (in this node's local space). */
+  burst(count, at, 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,
+        life: 0,
+        maxLife: style.lifeMin + r.float() * (style.lifeMax - style.lifeMin),
+        size: style.sizeMin + r.float() * (style.sizeMax - style.sizeMin),
+        color: style.colors[r.int(style.colors.length)]
+      };
+      if (this.pool.length >= this.maxParticles) this.pool.shift();
+      this.pool.push(p);
+    }
+    this.gravity = style.gravity ?? 0;
+    this.drag = style.drag ?? 0;
+    this.shrink = style.shrink ?? true;
+  }
+  gravity = 0;
+  drag = 0;
+  shrink = true;
+  onProcess(dt) {
+    const drag = Math.max(0, 1 - this.drag * 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.vx *= drag;
+      p.vy *= drag;
+      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 = 1 - p.life / p.maxLife;
+      out.push({
+        kind: "circle",
+        cx: p.x,
+        cy: p.y,
+        radius: this.shrink ? p.size * t : p.size,
+        fill: p.color,
+        opacity: Math.min(1, t * 2),
+        transform: world,
+        z: this.z
+      });
+    }
+  }
+  get liveCount() {
+    return this.pool.length;
+  }
+};
+var PARTICLE_PRESETS = {
+  dust: (colors = ["#c8c2b6", "#a09a8c"]) => ({ colors, sizeMin: 2, sizeMax: 4, speedMin: 30, speedMax: 90, lifeMin: 0.2, lifeMax: 0.45, gravity: 300, drag: 3, shrink: true }),
+  burst: (colors = ["#ffd75e", "#ff9d47", "#fff2c9"]) => ({ colors, sizeMin: 2, sizeMax: 5, speedMin: 120, speedMax: 320, lifeMin: 0.25, lifeMax: 0.6, drag: 4, shrink: true }),
+  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 })
+};
+var Shaker = class extends Node {
+  type = "Shaker";
+  rng;
+  trauma = 0;
+  /** Max offset in px at full trauma. */
+  amplitude;
+  /** Trauma decay per second. */
+  decay;
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+    this.rng = new Rng(config.seed ?? 99);
+    this.amplitude = config.amplitude ?? 14;
+    this.decay = config.decay ?? 2.6;
+  }
+  /** Add shake (0..1). Stacks, clamped to 1. Quadratic falloff feels right. */
+  addTrauma(amount) {
+    this.trauma = Math.min(1, this.trauma + amount);
+  }
+  onProcess(dt) {
+    this.trauma = Math.max(0, this.trauma - this.decay * dt);
+    const s = this.trauma * this.trauma * this.amplitude;
+    this.pos.x = (this.rng.float() * 2 - 1) * s;
+    this.pos.y = (this.rng.float() * 2 - 1) * s;
+  }
+};
+
+// src/scene/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerNode(type, factory) {
+  registry.set(type, factory);
+}
+registerNode("Node", () => new Node());
+registerNode("Sprite", () => new Sprite({ shape: { kind: "rect", w: 1, h: 1 } }));
+registerNode("Text", () => new Text({ text: "" }));
+registerNode("Camera2D", () => new Camera2D());
+registerNode("Timer", () => new Timer({ duration: 1 }));
+registerNode("AnimationPlayer", () => new AnimationPlayer());
+function deserializeNode(data) {
+  const factory = registry.get(data.type);
+  if (!factory) throw new Error(`hayao: unknown node type "${data.type}" (register it first)`);
+  const node = factory();
+  node.name = data.name;
+  node.pos = { ...data.pos };
+  node.rotation = data.rotation;
+  node.scale = { ...data.scale };
+  node.z = data.z;
+  node.visible = data.visible;
+  node.applyProps(data.props);
+  for (const child of data.children) node.addChild(deserializeNode(child));
+  return node;
+}
+
+// src/input/actions.ts
+var InputState = class {
+  down = /* @__PURE__ */ new Set();
+  prev = /* @__PURE__ */ new Set();
+  /** Analog axes (e.g. from gamepad or pointer), sampled per step. */
+  axes = /* @__PURE__ */ new Map();
+  /** Engine: set which actions are down this step (from live input or replay). */
+  beginFrame(actionsDown) {
+    this.prev = new Set(this.down);
+    this.down = new Set(actionsDown);
+  }
+  isDown(action) {
+    return this.down.has(action);
+  }
+  justPressed(action) {
+    return this.down.has(action) && !this.prev.has(action);
+  }
+  justReleased(action) {
+    return !this.down.has(action) && this.prev.has(action);
+  }
+  axis(name) {
+    return this.axes.get(name) ?? 0;
+  }
+  /** The current down-set as a stable sorted array (for recording). */
+  snapshot() {
+    return [...this.down].sort();
+  }
+  getState() {
+    return { down: [...this.down].sort(), prev: [...this.prev].sort() };
+  }
+  setState(s) {
+    this.down = new Set(s.down);
+    this.prev = new Set(s.prev);
+  }
+};
+function keysToActions(map, keysDown) {
+  const actions = [];
+  for (const action in map) {
+    if (map[action].some((k) => keysDown.has(k))) actions.push(action);
+  }
+  return actions.sort();
+}
+var InputRecorder = class {
+  frames = [];
+  record(actionsDown) {
+    this.frames.push(actionsDown.slice().sort());
+  }
+  get length() {
+    return this.frames.length;
+  }
+  toLog() {
+    return { frames: this.frames.map((f) => f.slice()) };
+  }
+};
+function frameActions(log, i) {
+  return log.frames[i] ?? [];
+}
+var DEFAULT_INPUT_MAP = {
+  up: ["ArrowUp", "KeyW"],
+  down: ["ArrowDown", "KeyS"],
+  left: ["ArrowLeft", "KeyA"],
+  right: ["ArrowRight", "KeyD"],
+  confirm: ["Enter", "Space"],
+  cancel: ["Escape", "Backspace"],
+  action: ["KeyZ", "KeyJ"],
+  action2: ["KeyX", "KeyK"],
+  undo: ["KeyU"],
+  restart: ["KeyR"]
+};
+
+// src/input/source.ts
+var KeyboardSource = class {
+  keysDown = /* @__PURE__ */ new Set();
+  /** Virtual action taps (from DOM buttons etc.) pending consumption by a step. */
+  pressed = /* @__PURE__ */ new Set();
+  map;
+  target;
+  onDown;
+  onUp;
+  onBlur;
+  constructor(map, target = document) {
+    this.map = map;
+    this.target = target;
+    this.onDown = (e) => {
+      this.keysDown.add(e.code);
+      if (e.code.startsWith("Arrow") || e.code === "Space") e.preventDefault();
+    };
+    this.onUp = (e) => this.keysDown.delete(e.code);
+    this.onBlur = () => this.keysDown.clear();
+    target.addEventListener("keydown", this.onDown);
+    target.addEventListener("keyup", this.onUp);
+    globalThis.addEventListener?.("blur", this.onBlur);
+  }
+  /** The actions currently held down, as a stable sorted array. */
+  currentActions() {
+    const acts = keysToActions(this.map, this.keysDown);
+    if (this.pressed.size === 0) return acts;
+    const merged = new Set(acts);
+    for (const a of this.pressed) merged.add(a);
+    return [...merged].sort();
+  }
+  /**
+   * Virtually tap an action (DOM button, touch control). The tap is held until
+   * at least one fixed step has sampled it — the driver calls clearPressed()
+   * after a successful advance — so UI clicks enter the SAME deterministic
+   * input log as keys, and record/replay covers them.
+   */
+  press(action) {
+    this.pressed.add(action);
+  }
+  /** Consume pending virtual taps (driver-called after ≥1 step ran). */
+  clearPressed() {
+    this.pressed.clear();
+  }
+  setMap(map) {
+    this.map = map;
+  }
+  dispose() {
+    this.target.removeEventListener("keydown", this.onDown);
+    this.target.removeEventListener("keyup", this.onUp);
+    globalThis.removeEventListener?.("blur", this.onBlur);
+  }
+};
+
+// src/physics/tilemap.ts
+var TILE = {
+  EMPTY: 0,
+  SOLID: 1,
+  /** Passable from below/sides; solid only when landing on its top edge. */
+  ONEWAY: 2,
+  HAZARD: 3
+};
+var DEFAULT_TILE_CHARS = {
+  "#": TILE.SOLID,
+  "-": TILE.ONEWAY,
+  "^": TILE.HAZARD
+};
+function tilemapFromAscii(rowsAscii, tileSize = 32, chars = DEFAULT_TILE_CHARS) {
+  const rows = rowsAscii.length;
+  const cols = Math.max(...rowsAscii.map((r) => r.length));
+  const tiles = new Array(cols * rows).fill(TILE.EMPTY);
+  rowsAscii.forEach((row, ty) => {
+    for (let tx = 0; tx < row.length; tx++) tiles[ty * cols + tx] = chars[row[tx]] ?? TILE.EMPTY;
+  });
+  return { cols, rows, tileSize, tiles };
+}
+function asciiEntities(rowsAscii, tileSize = 32, chars = DEFAULT_TILE_CHARS) {
+  const out = [];
+  rowsAscii.forEach((row, ty) => {
+    for (let tx = 0; tx < row.length; tx++) {
+      const c = row[tx];
+      if (c === " " || c === "." || chars[c] !== void 0) continue;
+      out.push({ char: c, tx, ty, x: (tx + 0.5) * tileSize, y: (ty + 0.5) * tileSize });
+    }
+  });
+  return out;
+}
+function tileAt(map, tx, ty) {
+  if (tx < 0 || ty < 0 || tx >= map.cols || ty >= map.rows) return TILE.SOLID;
+  return map.tiles[ty * map.cols + tx];
+}
+function tileAtPoint(map, x, y) {
+  return tileAt(map, Math.floor(x / map.tileSize), Math.floor(y / map.tileSize));
+}
+var mapWidth = (map) => map.cols * map.tileSize;
+var mapHeight = (map) => map.rows * map.tileSize;
+
+// src/physics/aabb.ts
+var EPS = 1e-6;
+var spanTiles = (lo, hi, ts) => [Math.floor(lo / ts), Math.floor((hi - EPS) / ts)];
+function rectBlocked(map, x, y, w, h, solids = []) {
+  const ts = map.tileSize;
+  const [tx0, tx1] = spanTiles(x, x + w, ts);
+  const [ty0, ty1] = spanTiles(y, y + h, ts);
+  for (let ty = ty0; ty <= ty1; ty++)
+    for (let tx = tx0; tx <= tx1; tx++) if (tileAt(map, tx, ty) === TILE.SOLID) return true;
+  for (const s of solids) {
+    if (s.oneway) continue;
+    if (x < s.x + s.w - EPS && x + w > s.x + EPS && y < s.y + s.h - EPS && y + h > s.y + EPS) return true;
+  }
+  return false;
+}
+function moveRect(map, rect, dx, dy, opts = {}) {
+  const ts = map.tileSize;
+  const solids = opts.solids ?? [];
+  let { x, y } = rect;
+  const { w, h } = rect;
+  let hitX = false;
+  let hitY = false;
+  let onWallLeft = false;
+  let onWallRight = false;
+  if (dx !== 0) {
+    const [ty0, ty1] = spanTiles(y, y + h, ts);
+    if (dx > 0) {
+      let limit = x + dx;
+      const [c0, c1] = [Math.floor((x + w) / ts), Math.floor((x + w + dx - EPS) / ts)];
+      for (let tx = c0; tx <= c1; tx++)
+        for (let ty = ty0; ty <= ty1; ty++)
+          if (tileAt(map, tx, ty) === TILE.SOLID) limit = Math.min(limit, tx * ts - w);
+      for (const s of solids)
+        if (!s.oneway && s.y < y + h - EPS && s.y + s.h > y + EPS && s.x >= x + w - EPS) limit = Math.min(limit, s.x - w);
+      if (limit < x + dx - EPS) {
+        hitX = true;
+        onWallRight = true;
+      }
+      x = Math.min(x + dx, limit);
+    } else {
+      let limit = x + dx;
+      const [c0, c1] = [Math.floor((x - EPS) / ts), Math.floor((x + dx) / ts)];
+      for (let tx = c0; tx >= c1; tx--)
+        for (let ty = ty0; ty <= ty1; ty++)
+          if (tileAt(map, tx, ty) === TILE.SOLID) limit = Math.max(limit, (tx + 1) * ts);
+      for (const s of solids)
+        if (!s.oneway && s.y < y + h - EPS && s.y + s.h > y + EPS && s.x + s.w <= x + EPS) limit = Math.max(limit, s.x + s.w);
+      if (limit > x + dx + EPS) {
+        hitX = true;
+        onWallLeft = true;
+      }
+      x = Math.max(x + dx, limit);
+    }
+  }
+  const prevBottom = y + h;
+  let onFloor = false;
+  let onCeiling = false;
+  let floorSolid = -1;
+  if (dy !== 0) {
+    const [tx0, tx1] = spanTiles(x, x + w, ts);
+    if (dy > 0) {
+      let limit = y + dy;
+      const [r0, r1] = [Math.floor(prevBottom / ts), Math.floor((prevBottom + dy - EPS) / ts)];
+      for (let ty = r0; ty <= r1; ty++)
+        for (let tx = tx0; tx <= tx1; tx++) {
+          const t = tileAt(map, tx, ty);
+          const blocks = t === TILE.SOLID || t === TILE.ONEWAY && !opts.dropThrough && prevBottom <= ty * ts + EPS;
+          if (blocks) limit = Math.min(limit, ty * ts - h);
+        }
+      for (let i = 0; i < solids.length; i++) {
+        const s = solids[i];
+        const inX = s.x < x + w - EPS && s.x + s.w > x + EPS;
+        if (!inX || s.y < prevBottom - EPS) continue;
+        if (s.oneway && (opts.dropThrough || prevBottom > s.y + EPS)) continue;
+        if (s.y - h < limit) {
+          limit = s.y - h;
+          floorSolid = i;
+        }
+      }
+      if (limit < y + dy - EPS) {
+        hitY = true;
+        onFloor = true;
+      } else floorSolid = -1;
+      y = Math.min(y + dy, limit);
+    } else {
+      let limit = y + dy;
+      const [r0, r1] = [Math.floor((y - EPS) / ts), Math.floor((y + dy) / ts)];
+      for (let ty = r0; ty >= r1; ty--)
+        for (let tx = tx0; tx <= tx1; tx++)
+          if (tileAt(map, tx, ty) === TILE.SOLID) limit = Math.max(limit, (ty + 1) * ts);
+      for (const s of solids)
+        if (!s.oneway && s.x < x + w - EPS && s.x + s.w > x + EPS && s.y + s.h <= y + EPS) limit = Math.max(limit, s.y + s.h);
+      if (limit > y + dy + EPS) {
+        hitY = true;
+        onCeiling = true;
+      }
+      y = Math.max(y + dy, limit);
+    }
+  }
+  if (!onFloor) {
+    const probe = groundAt(map, x, y, w, h, solids, opts.dropThrough ?? false);
+    onFloor = probe.grounded;
+    floorSolid = probe.solid;
+  }
+  const inset = 3;
+  let hazard = false;
+  {
+    const [hx0, hx1] = spanTiles(x + inset, x + w - inset, ts);
+    const [hy0, hy1] = spanTiles(y + inset, y + h - inset, ts);
+    for (let ty = hy0; ty <= hy1 && !hazard; ty++)
+      for (let tx = hx0; tx <= hx1 && !hazard; tx++) if (tileAt(map, tx, ty) === TILE.HAZARD) hazard = true;
+  }
+  return { x, y, hitX, hitY, onFloor, onCeiling, onWallLeft, onWallRight, hazard, floorSolid };
+}
+function groundAt(map, x, y, w, h, solids = [], dropThrough = false) {
+  const ts = map.tileSize;
+  const bottom = y + h;
+  const [tx0, tx1] = spanTiles(x, x + w, ts);
+  const ty = Math.floor((bottom + 1) / ts);
+  for (let tx = tx0; tx <= tx1; tx++) {
+    const t = tileAt(map, tx, ty);
+    if (t === TILE.SOLID) return { grounded: true, solid: -1 };
+    if (t === TILE.ONEWAY && !dropThrough && Math.abs(bottom - ty * ts) <= 1 + EPS) return { grounded: true, solid: -1 };
+  }
+  for (let i = 0; i < solids.length; i++) {
+    const s = solids[i];
+    const inX = s.x < x + w - EPS && s.x + s.w > x + EPS;
+    if (inX && bottom <= s.y + 1 + EPS && bottom >= s.y - 1 - EPS) return { grounded: true, solid: i };
+  }
+  return { grounded: false, solid: -1 };
+}
+
+// src/physics/platformer.ts
+var DEFAULT_PLATFORMER = {
+  width: 22,
+  height: 28,
+  runSpeed: 340,
+  groundAccel: 3800,
+  groundFriction: 4200,
+  airAccel: 2600,
+  airFriction: 260,
+  gravity: 2300,
+  maxFall: 660,
+  apexThreshold: 60,
+  apexGravityMult: 0.5,
+  jumpVelocity: 650,
+  jumpCutMult: 0.4,
+  coyoteTime: 0.1,
+  jumpBuffer: 0.12,
+  jumpCornerNudge: 10,
+  dashCornerNudge: 12,
+  airJumps: 0,
+  airJumpMult: 0.92,
+  dashSpeed: 640,
+  dashTime: 0.14,
+  dashCooldown: 0.25,
+  dashCharges: 1,
+  wallSlideMaxFall: 150,
+  wallJumpVelX: 360,
+  wallJumpVelY: 600,
+  wallJumpLock: 0.13
+};
+var PAD_NEUTRAL = { moveX: 0, moveY: 0, jumpHeld: false, jumpPressed: false, dashPressed: false };
+function createPlatformerState(x, y) {
+  return { x, y, vx: 0, vy: 0, facing: 1, onGround: false, onWall: 0, coyote: 0, buffer: 0, jumping: false, wallLock: 0, airJumpsLeft: 0, dashing: 0, dashCd: 0, dashesLeft: 1, dashVx: 0, dashVy: 0, carryVx: 0, carryVy: 0, dead: false };
+}
+var approach = (v, target, delta) => v < target ? Math.min(v + delta, target) : Math.max(v - delta, target);
+function stepPlatformer(s, input, dt, map, cfg = DEFAULT_PLATFORMER, platforms = []) {
+  const ev = { jumped: false, wallJumped: false, airJumped: false, dashed: false, landed: false, died: false };
+  if (s.dead) return ev;
+  const wasGrounded = s.onGround;
+  s.coyote = Math.max(0, s.coyote - dt);
+  s.buffer = Math.max(0, s.buffer - dt);
+  s.wallLock = Math.max(0, s.wallLock - dt);
+  s.dashCd = Math.max(0, s.dashCd - dt);
+  if (input.jumpPressed) s.buffer = cfg.jumpBuffer;
+  if (input.dashPressed && s.dashing <= 0 && s.dashCd <= 0 && s.dashesLeft > 0) {
+    let dx2 = input.moveX;
+    let dy2 = input.moveY;
+    if (dx2 === 0 && dy2 === 0) dx2 = s.facing;
+    const inv = 1 / Math.hypot(dx2, dy2);
+    s.dashing = cfg.dashTime;
+    s.dashCd = cfg.dashCooldown;
+    s.dashesLeft--;
+    s.dashVx = dx2 * inv * cfg.dashSpeed;
+    s.dashVy = dy2 * inv * cfg.dashSpeed;
+    s.jumping = false;
+    ev.dashed = true;
+  }
+  if (s.dashing > 0) {
+    s.vx = s.dashVx;
+    s.vy = s.dashVy;
+    s.dashing -= dt;
+  } else if (s.wallLock <= 0) {
+    const target = input.moveX * cfg.runSpeed;
+    const accel = s.onGround ? input.moveX !== 0 ? cfg.groundAccel : cfg.groundFriction : input.moveX !== 0 ? cfg.airAccel : cfg.airFriction;
+    s.vx = approach(s.vx, target, accel * dt);
+    if (input.moveX !== 0) s.facing = input.moveX > 0 ? 1 : -1;
+  }
+  if (s.dashing <= 0 && !s.onGround) {
+    let g = cfg.gravity;
+    if (Math.abs(s.vy) < cfg.apexThreshold && input.jumpHeld && s.jumping) g *= cfg.apexGravityMult;
+    s.vy = Math.min(s.vy + g * dt, cfg.maxFall);
+    if (s.onWall !== 0 && s.vy > cfg.wallSlideMaxFall && input.moveX === s.onWall) s.vy = cfg.wallSlideMaxFall;
+  }
+  if (s.jumping && !input.jumpHeld && s.vy < 0) {
+    s.vy *= cfg.jumpCutMult;
+    s.jumping = false;
+  }
+  if (s.buffer > 0 && s.dashing <= 0) {
+    if (s.onGround || s.coyote > 0) {
+      s.vy = -cfg.jumpVelocity;
+      s.vx += s.carryVx;
+      if (s.carryVy < 0) s.vy += s.carryVy;
+      s.jumping = true;
+      s.buffer = 0;
+      s.coyote = 0;
+      s.onGround = false;
+      ev.jumped = true;
+    } else if (s.onWall !== 0 && cfg.wallJumpVelY > 0) {
+      s.vx = -s.onWall * cfg.wallJumpVelX;
+      s.vy = -cfg.wallJumpVelY;
+      s.facing = -s.onWall;
+      s.jumping = true;
+      s.buffer = 0;
+      s.wallLock = cfg.wallJumpLock;
+      ev.wallJumped = true;
+      ev.jumped = true;
+    } else if (s.airJumpsLeft > 0) {
+      s.vy = -cfg.jumpVelocity * cfg.airJumpMult;
+      s.airJumpsLeft--;
+      s.jumping = true;
+      s.buffer = 0;
+      ev.jumped = true;
+      ev.airJumped = true;
+    }
+  }
+  const dropThrough = input.moveY > 0 && s.buffer <= 0;
+  let dx = s.vx * dt + s.carryVx * dt * (s.onGround ? 1 : 0);
+  let dy = s.vy * dt + Math.max(0, s.carryVy) * dt * (s.onGround ? 1 : 0);
+  let res = moveRect(map, { x: s.x, y: s.y, w: cfg.width, h: cfg.height }, dx, dy, { solids: platforms, dropThrough });
+  if (res.onCeiling && s.vy < 0 && s.dashing <= 0) {
+    const slip = cornerSlipX(map, platforms, res.x, res.y, cfg.width, cfg.height, dy, cfg.jumpCornerNudge);
+    if (slip !== null) {
+      res = moveRect(map, { x: slip, y: res.y, w: cfg.width, h: cfg.height }, 0, dy, { solids: platforms, dropThrough });
+      res.x = slip;
+    }
+  }
+  if (res.hitX && s.dashing > 0 && Math.abs(s.dashVy) < 1) {
+    const slip = cornerSlipY(map, platforms, res.x, res.y, cfg.width, cfg.height, dx, cfg.dashCornerNudge);
+    if (slip !== null) {
+      res = moveRect(map, { x: res.x, y: slip, w: cfg.width, h: cfg.height }, dx, 0, { solids: platforms, dropThrough });
+      res.y = slip;
+    }
+  }
+  s.x = res.x;
+  s.y = res.y;
+  if (res.hitY && s.vy > 0) s.vy = 0;
+  if (res.onCeiling) {
+    s.vy = Math.max(s.vy, 0);
+    s.jumping = false;
+  }
+  if (res.hitX && s.dashing <= 0) s.vx = 0;
+  s.onWall = res.onWallLeft ? -1 : res.onWallRight ? 1 : wallTouch(map, platforms, s.x, s.y, cfg.width, cfg.height);
+  s.onGround = res.onFloor;
+  if (s.onGround) {
+    s.coyote = cfg.coyoteTime;
+    s.dashesLeft = cfg.dashCharges;
+    s.airJumpsLeft = cfg.airJumps;
+    if (!wasGrounded) ev.landed = true;
+    if (res.floorSolid >= 0) {
+      const p = platforms[res.floorSolid];
+      s.carryVx = p.vx;
+      s.carryVy = p.vy;
+      s.y = p.y - cfg.height;
+    } else {
+      s.carryVx = 0;
+      s.carryVy = 0;
+    }
+    if (s.vy > 0) s.vy = 0;
+    s.jumping = false;
+  } else if (wasGrounded && s.carryVy !== 0) {
+  }
+  if (res.hazard) {
+    s.dead = true;
+    ev.died = true;
+  }
+  return ev;
+}
+function jumpHeight(cfg = DEFAULT_PLATFORMER) {
+  return cfg.jumpVelocity * cfg.jumpVelocity / (2 * cfg.gravity);
+}
+function jumpAirtime(cfg = DEFAULT_PLATFORMER) {
+  return 2 * cfg.jumpVelocity / cfg.gravity;
+}
+function jumpDistance(cfg = DEFAULT_PLATFORMER) {
+  return cfg.runSpeed * jumpAirtime(cfg);
+}
+function dashJumpDistance(cfg = DEFAULT_PLATFORMER) {
+  return jumpDistance(cfg) + (cfg.dashSpeed - cfg.runSpeed) * cfg.dashTime;
+}
+function cornerSlipX(map, solids, x, y, w, h, dy, nudge) {
+  for (let n2 = 1; n2 <= nudge; n2++) {
+    for (const dir of [1, -1]) {
+      const nx = x + dir * n2;
+      if (!rectBlocked(map, nx, y + dy, w, h, solids) && !rectBlocked(map, nx, y, w, h, solids)) return nx;
+    }
+  }
+  return null;
+}
+function cornerSlipY(map, solids, x, y, w, h, dx, nudge) {
+  for (let n2 = 1; n2 <= nudge; n2++) {
+    for (const dir of [-1, 1]) {
+      const ny = y + dir * n2;
+      if (!rectBlocked(map, x + dx, ny, w, h, solids) && !rectBlocked(map, x, ny, w, h, solids)) return ny;
+    }
+  }
+  return null;
+}
+function wallTouch(map, solids, x, y, w, h) {
+  if (rectBlocked(map, x + 1, y, w, h, solids)) return 1;
+  if (rectBlocked(map, x - 1, y, w, h, solids)) return -1;
+  return 0;
+}
+
+// src/physics/spatialHash.ts
+var SpatialHash = class {
+  cells = /* @__PURE__ */ new Map();
+  bounds = /* @__PURE__ */ new Map();
+  cellSize;
+  constructor(cellSize = 64) {
+    this.cellSize = cellSize;
+  }
+  clear() {
+    this.cells.clear();
+    this.bounds.clear();
+  }
+  get size() {
+    return this.bounds.size;
+  }
+  key(cx, cy) {
+    return (cx + 32768) * 65536 + (cy + 32768);
+  }
+  insert(item, rect) {
+    this.bounds.set(item, rect);
+    const cs = this.cellSize;
+    const x0 = Math.floor(rect.x / cs);
+    const x1 = Math.floor((rect.x + rect.w) / cs);
+    const y0 = Math.floor(rect.y / cs);
+    const y1 = Math.floor((rect.y + rect.h) / cs);
+    for (let cy = y0; cy <= y1; cy++)
+      for (let cx = x0; cx <= x1; cx++) {
+        const k = this.key(cx, cy);
+        const cell = this.cells.get(k);
+        if (cell) cell.push(item);
+        else this.cells.set(k, [item]);
+      }
+  }
+  /** All items whose rects overlap the query rect (deduplicated, deterministic order). */
+  query(rect) {
+    const cs = this.cellSize;
+    const x0 = Math.floor(rect.x / cs);
+    const x1 = Math.floor((rect.x + rect.w) / cs);
+    const y0 = Math.floor(rect.y / cs);
+    const y1 = Math.floor((rect.y + rect.h) / cs);
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (let cy = y0; cy <= y1; cy++)
+      for (let cx = x0; cx <= x1; cx++) {
+        const cell = this.cells.get(this.key(cx, cy));
+        if (!cell) continue;
+        for (const item of cell) {
+          if (seen.has(item)) continue;
+          seen.add(item);
+          const b = this.bounds.get(item);
+          if (b.x < rect.x + rect.w && b.x + b.w > rect.x && b.y < rect.y + rect.h && b.y + b.h > rect.y) out.push(item);
+        }
+      }
+    return out;
+  }
+  /** All items within `radius` of a point (circle vs rect-center test on bounds). */
+  queryCircle(x, y, radius) {
+    const near = this.query({ x: x - radius, y: y - radius, w: radius * 2, h: radius * 2 });
+    return near.filter((item) => {
+      const b = this.bounds.get(item);
+      const cx = Math.max(b.x, Math.min(x, b.x + b.w));
+      const cy = Math.max(b.y, Math.min(y, b.y + b.h));
+      return (x - cx) * (x - cx) + (y - cy) * (y - cy) <= radius * radius;
+    });
+  }
+};
+
+// src/physics/raycast.ts
+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);
+  if (maxDist === 0) return { blocked: false, x: x1, y: y1, dist: 0 };
+  const dirX = dx / maxDist;
+  const dirY = dy / maxDist;
+  let tx = Math.floor(x0 / ts);
+  let ty = Math.floor(y0 / ts);
+  const stepX = dirX > 0 ? 1 : -1;
+  const stepY = dirY > 0 ? 1 : -1;
+  const tDeltaX = dirX !== 0 ? Math.abs(ts / dirX) : Infinity;
+  const tDeltaY = dirY !== 0 ? Math.abs(ts / dirY) : Infinity;
+  let tMaxX = dirX !== 0 ? (dirX > 0 ? (tx + 1) * ts - x0 : x0 - tx * ts) / Math.abs(dirX) : Infinity;
+  let tMaxY = dirY !== 0 ? (dirY > 0 ? (ty + 1) * ts - y0 : y0 - ty * ts) / Math.abs(dirY) : Infinity;
+  let t = 0;
+  for (let guard = 0; guard < 512; guard++) {
+    if (tMaxX < tMaxY) {
+      t = tMaxX;
+      tMaxX += tDeltaX;
+      tx += stepX;
+    } else {
+      t = tMaxY;
+      tMaxY += tDeltaY;
+      ty += stepY;
+    }
+    if (t >= maxDist) return { blocked: false, x: x1, y: y1, dist: maxDist };
+    if (tileAt(map, tx, ty) === TILE.SOLID) {
+      return { blocked: true, x: x0 + dirX * t, y: y0 + dirY * t, dist: t };
+    }
+  }
+  return { blocked: true, x: x0 + dirX * t, y: y0 + dirY * t, dist: t };
+}
+function lineOfSight(map, ax, ay, bx, by) {
+  return !raycastTiles(map, ax, ay, bx, by).blocked;
+}
+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);
+  if (d > range || d === 0) return false;
+  const dot = (dx * faceX + dy * faceY) / d;
+  if (dot < Math.cos(fov / 2)) return false;
+  return lineOfSight(map, ex, ey, tx, ty);
+}
+
+// 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);
+}
+
+// src/render/svgString.ts
+var n = (v) => Number.isInteger(v) ? String(v) : (Math.round(v * 1e3) / 1e3).toString();
+function matrix(t) {
+  return `matrix(${n(t.a)} ${n(t.b)} ${n(t.c)} ${n(t.d)} ${n(t.e)} ${n(t.f)})`;
+}
+function paintAttrs(p) {
+  const parts = [];
+  parts.push(`fill="${p.fill ?? "none"}"`);
+  if (p.stroke) {
+    parts.push(`stroke="${p.stroke}"`);
+    parts.push(`stroke-width="${n(p.strokeWidth ?? 1)}"`);
+    if (p.round) parts.push('stroke-linejoin="round" stroke-linecap="round"');
+  }
+  if (p.opacity !== void 0 && p.opacity !== 1) parts.push(`opacity="${n(p.opacity)}"`);
+  return parts.join(" ");
+}
+function escapeText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function commandToSVG(c) {
+  const tf = `transform="${matrix(c.transform)}"`;
+  const paint = paintAttrs(c);
+  switch (c.kind) {
+    case "rect":
+      return `<rect x="${n(c.x)}" y="${n(c.y)}" width="${n(c.w)}" height="${n(c.h)}"${c.r ? ` rx="${n(c.r)}"` : ""} ${tf} ${paint}/>`;
+    case "circle":
+      return `<circle cx="${n(c.cx)}" cy="${n(c.cy)}" r="${n(c.radius)}" ${tf} ${paint}/>`;
+    case "poly": {
+      const pts = [];
+      for (let i = 0; i < c.points.length; i += 2) pts.push(`${n(c.points[i])},${n(c.points[i + 1])}`);
+      const tag = c.closed ? "polygon" : "polyline";
+      return `<${tag} points="${pts.join(" ")}" ${tf} ${paint}/>`;
+    }
+    case "path":
+      return `<path d="${c.d}" ${tf} ${paint}/>`;
+    case "text": {
+      const anchor = c.align === "center" ? "middle" : c.align === "right" ? "end" : "start";
+      const font = c.font ? ` font-family="${c.font}"` : "";
+      const weight = c.weight ? ` font-weight="${c.weight}"` : "";
+      const fill = c.fill ?? "#000";
+      return `<text x="${n(c.x)}" y="${n(c.y)}" font-size="${n(c.size)}" text-anchor="${anchor}" dominant-baseline="middle"${font}${weight} fill="${fill}"${c.opacity !== void 0 && c.opacity !== 1 ? ` opacity="${n(c.opacity)}"` : ""} ${tf}>${escapeText(c.text)}</text>`;
+    }
+    case "image":
+      return `<image href="${c.href}" x="${n(c.x)}" y="${n(c.y)}" width="${n(c.w)}" height="${n(c.h)}" ${tf}${c.opacity !== void 0 && c.opacity !== 1 ? ` opacity="${n(c.opacity)}"` : ""}/>`;
+  }
+}
+function commandsToSVGInner(commands) {
+  return sortCommands(commands).map(commandToSVG).join("");
+}
+function renderToSVGString(commands, width, height, background = "#ffffff") {
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}"><rect x="0" y="0" width="${width}" height="${height}" fill="${background}"/>` + commandsToSVGInner(commands) + `</svg>`;
+}
+
+// src/render/svg.ts
+var SVGNS = "http://www.w3.org/2000/svg";
+var SvgRenderer = class {
+  width;
+  height;
+  background;
+  svg;
+  bg;
+  layer;
+  constructor(config) {
+    this.width = config.width;
+    this.height = config.height;
+    this.background = config.background ?? "#ffffff";
+    this.svg = document.createElementNS(SVGNS, "svg");
+    this.svg.setAttribute("viewBox", `0 0 ${this.width} ${this.height}`);
+    this.svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+    this.svg.style.width = "100%";
+    this.svg.style.height = "100%";
+    this.svg.style.display = "block";
+    this.bg = document.createElementNS(SVGNS, "rect");
+    this.bg.setAttribute("x", "0");
+    this.bg.setAttribute("y", "0");
+    this.bg.setAttribute("width", String(this.width));
+    this.bg.setAttribute("height", String(this.height));
+    this.bg.setAttribute("fill", this.background);
+    this.svg.appendChild(this.bg);
+    this.layer = document.createElementNS(SVGNS, "g");
+    this.svg.appendChild(this.layer);
+  }
+  mount(parent) {
+    parent.appendChild(this.svg);
+  }
+  draw(commands) {
+    this.layer.innerHTML = commandsToSVGInner(commands);
+  }
+  setBackground(color) {
+    this.background = color;
+    this.bg.setAttribute("fill", color);
+  }
+  get element() {
+    return this.svg;
+  }
+  dispose() {
+    this.svg.remove();
+  }
+};
+
+// src/render/canvas.ts
+var Canvas2DRenderer = class {
+  width;
+  height;
+  background;
+  canvas;
+  ctx;
+  dpr = 1;
+  constructor(config) {
+    this.width = config.width;
+    this.height = config.height;
+    this.background = config.background ?? "#ffffff";
+    this.canvas = document.createElement("canvas");
+    this.canvas.style.width = "100%";
+    this.canvas.style.height = "100%";
+    this.canvas.style.display = "block";
+    const ctx = this.canvas.getContext("2d");
+    if (!ctx) throw new Error("hayao: 2D canvas context unavailable");
+    this.ctx = ctx;
+    this.resize();
+  }
+  mount(parent) {
+    parent.appendChild(this.canvas);
+    this.resize();
+  }
+  resize() {
+    this.dpr = Math.min(3, globalThis.devicePixelRatio || 1);
+    this.canvas.width = Math.round(this.width * this.dpr);
+    this.canvas.height = Math.round(this.height * this.dpr);
+  }
+  draw(commands) {
+    const ctx = this.ctx;
+    ctx.setTransform(this.dpr, 0, 0, this.dpr, 0, 0);
+    ctx.fillStyle = this.background;
+    ctx.fillRect(0, 0, this.width, this.height);
+    for (const c of sortCommands(commands)) {
+      ctx.save();
+      const t = c.transform;
+      ctx.transform(t.a, t.b, t.c, t.d, t.e, t.f);
+      ctx.globalAlpha = c.opacity ?? 1;
+      this.paint(ctx, c);
+      ctx.restore();
+    }
+  }
+  stroke(ctx, c) {
+    if (c.fill && c.fill !== "none") {
+      ctx.fillStyle = c.fill;
+      ctx.fill();
+    }
+    if (c.stroke) {
+      ctx.strokeStyle = c.stroke;
+      ctx.lineWidth = c.strokeWidth ?? 1;
+      if (c.round) {
+        ctx.lineJoin = "round";
+        ctx.lineCap = "round";
+      }
+      ctx.stroke();
+    }
+  }
+  paint(ctx, c) {
+    switch (c.kind) {
+      case "rect":
+        ctx.beginPath();
+        if (c.r) this.roundRect(ctx, c.x, c.y, c.w, c.h, c.r);
+        else ctx.rect(c.x, c.y, c.w, c.h);
+        this.stroke(ctx, c);
+        break;
+      case "circle":
+        ctx.beginPath();
+        ctx.arc(c.cx, c.cy, c.radius, 0, Math.PI * 2);
+        this.stroke(ctx, c);
+        break;
+      case "poly":
+        ctx.beginPath();
+        for (let i = 0; i < c.points.length; i += 2) {
+          if (i === 0) ctx.moveTo(c.points[i], c.points[i + 1]);
+          else ctx.lineTo(c.points[i], c.points[i + 1]);
+        }
+        if (c.closed) ctx.closePath();
+        this.stroke(ctx, c);
+        break;
+      case "path":
+        {
+          const p = new Path2D(c.d);
+          if (c.fill && c.fill !== "none") {
+            ctx.fillStyle = c.fill;
+            ctx.fill(p);
+          }
+          if (c.stroke) {
+            ctx.strokeStyle = c.stroke;
+            ctx.lineWidth = c.strokeWidth ?? 1;
+            if (c.round) {
+              ctx.lineJoin = "round";
+              ctx.lineCap = "round";
+            }
+            ctx.stroke(p);
+          }
+        }
+        break;
+      case "text":
+        ctx.fillStyle = c.fill ?? "#000";
+        ctx.font = `${c.weight ?? 400} ${c.size}px ${c.font ?? "sans-serif"}`;
+        ctx.textAlign = c.align ?? "left";
+        ctx.textBaseline = "middle";
+        ctx.fillText(c.text, c.x, c.y);
+        break;
+      case "image":
+        break;
+    }
+  }
+  roundRect(ctx, x, y, w, h, r) {
+    const rr = Math.min(r, w / 2, h / 2);
+    ctx.moveTo(x + rr, y);
+    ctx.arcTo(x + w, y, x + w, y + h, rr);
+    ctx.arcTo(x + w, y + h, x, y + h, rr);
+    ctx.arcTo(x, y + h, x, y, rr);
+    ctx.arcTo(x, y, x + w, y, rr);
+    ctx.closePath();
+  }
+  get element() {
+    return this.canvas;
+  }
+  dispose() {
+    this.canvas.remove();
+  }
+};
+
+// src/render/headless.ts
+var HeadlessRenderer = class {
+  width;
+  height;
+  background;
+  last = [];
+  frameCount = 0;
+  constructor(config) {
+    this.width = config.width;
+    this.height = config.height;
+    this.background = config.background ?? "#ffffff";
+  }
+  draw(commands) {
+    this.last = commands;
+    this.frameCount++;
+  }
+  /** The most recently drawn display list. */
+  get commands() {
+    return this.last;
+  }
+  /** Count commands of a given kind (handy for assertions). */
+  count(kind) {
+    return this.last.filter((c) => c.kind === kind).length;
+  }
+  /** A vector screenshot of the last frame. */
+  toSVGString() {
+    return renderToSVGString(this.last, this.width, this.height, this.background);
+  }
+};
+
+// src/art/palette.ts
+var MEADOW = {
+  name: "meadow",
+  bg: "#f3ecdb",
+  ink: "#3d3323",
+  inkSoft: "#6f6047",
+  line: "#d9ccae",
+  accent: "#a11d3a",
+  accent2: "#5a7d4e",
+  good: "#4d6b3c",
+  warn: "#c8791f",
+  ramp: ["#a11d3a", "#c8791f", "#c9a22f", "#5a7d4e", "#3f7d8c", "#6a4c93"]
+};
+var DUSK = {
+  name: "dusk",
+  bg: "#1c1a24",
+  ink: "#efe9f2",
+  inkSoft: "#a89fb5",
+  line: "#3a3546",
+  accent: "#e26d8a",
+  accent2: "#6cc4a1",
+  good: "#6cc4a1",
+  warn: "#e8b64a",
+  ramp: ["#e26d8a", "#e8b64a", "#f2e07a", "#6cc4a1", "#5aa9d6", "#b493e6"]
+};
+var PAPER = {
+  name: "paper",
+  bg: "#faf7f0",
+  ink: "#2b2b2b",
+  inkSoft: "#666",
+  line: "#e2ddd2",
+  accent: "#d1495b",
+  accent2: "#2e86ab",
+  good: "#3c896d",
+  warn: "#e0902f",
+  ramp: ["#d1495b", "#e0902f", "#edc531", "#3c896d", "#2e86ab", "#8a5a9e"]
+};
+var PALETTES = { meadow: MEADOW, dusk: DUSK, paper: PAPER };
+function mix(a, b, t) {
+  const pa = hexToRgb(a);
+  const pb = hexToRgb(b);
+  const r = Math.round(pa[0] + (pb[0] - pa[0]) * t);
+  const g = Math.round(pa[1] + (pb[1] - pa[1]) * t);
+  const bl = Math.round(pa[2] + (pb[2] - pa[2]) * t);
+  return rgbToHex(r, g, bl);
+}
+function withAlpha(hex, alpha) {
+  const [r, g, b] = hexToRgb(hex);
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+function hexToRgb(hex) {
+  let h = hex.replace("#", "");
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  const n2 = parseInt(h, 16);
+  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("");
+}
+
+// src/art/shapes.ts
+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);
+  }
+  return pts;
+}
+function star(points, outer, inner, rotation = -Math.PI / 2) {
+  const pts = [];
+  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);
+  }
+  return pts;
+}
+function blobPath(rng, radius, wobble = 0.25, lobes = 7) {
+  const pts = [];
+  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 });
+  }
+  return smoothClosedPath(pts);
+}
+function smoothClosedPath(points, tension = 1) {
+  const nPts = points.length;
+  if (nPts < 3) return "";
+  const p = (i) => points[(i % nPts + nPts) % nPts];
+  const r = (v) => Math.round(v * 100) / 100;
+  let d = `M ${r(p(0).x)} ${r(p(0).y)}`;
+  for (let i = 0; i < nPts; i++) {
+    const p0 = p(i - 1);
+    const p1 = p(i);
+    const p2 = p(i + 1);
+    const p3 = p(i + 2);
+    const c1x = p1.x + (p2.x - p0.x) / 6 * tension;
+    const c1y = p1.y + (p2.y - p0.y) / 6 * tension;
+    const c2x = p2.x - (p3.x - p1.x) / 6 * tension;
+    const c2y = p2.y - (p3.y - p1.y) / 6 * tension;
+    d += ` C ${r(c1x)} ${r(c1y)}, ${r(c2x)} ${r(c2y)}, ${r(p2.x)} ${r(p2.y)}`;
+  }
+  return d + " Z";
+}
+function smoothOpenPath(points, tension = 1) {
+  const nPts = points.length;
+  if (nPts < 2) return "";
+  const r = (v) => Math.round(v * 100) / 100;
+  let d = `M ${r(points[0].x)} ${r(points[0].y)}`;
+  for (let i = 0; i < nPts - 1; i++) {
+    const p0 = points[Math.max(0, i - 1)];
+    const p1 = points[i];
+    const p2 = points[i + 1];
+    const p3 = points[Math.min(nPts - 1, i + 2)];
+    const c1x = p1.x + (p2.x - p0.x) / 6 * tension;
+    const c1y = p1.y + (p2.y - p0.y) / 6 * tension;
+    const c2x = p2.x - (p3.x - p1.x) / 6 * tension;
+    const c2y = p2.y - (p3.y - p1.y) / 6 * tension;
+    d += ` C ${r(c1x)} ${r(c1y)}, ${r(c2x)} ${r(c2y)}, ${r(p2.x)} ${r(p2.y)}`;
+  }
+  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;
+  }
+  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() {
+    return { ...this.vol };
+  }
+  applyVolumes() {
+    if (!this.ctx || !this.master || !this.musicGain || !this.sfxGain) return;
+    const t = this.ctx.currentTime;
+    this.master.gain.setTargetAtTime(this.vol.muted ? 0 : this.vol.master, t, 0.04);
+    this.musicGain.gain.setTargetAtTime(this.vol.music * 0.5, t, 0.04);
+    this.sfxGain.gain.setTargetAtTime(this.vol.sfx, t, 0.04);
+  }
+  /** 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 t = this.ctx.currentTime + delay;
+    const osc = this.ctx.createOscillator();
+    osc.type = type;
+    osc.frequency.value = freq;
+    const g = this.ctx.createGain();
+    g.gain.setValueAtTime(0, t);
+    g.gain.linearRampToValueAtTime(gain, t + 8e-3);
+    g.gain.exponentialRampToValueAtTime(1e-4, t + duration);
+    osc.connect(g);
+    g.connect(this.sfxGain);
+    osc.start(t);
+    osc.stop(t + duration + 0.05);
+  }
+  /** Play a sequence of tones as an arpeggio/chord. */
+  play(tones) {
+    for (const t of tones) this.tone(t);
+  }
+  /** Convenience SFX. */
+  blip(freq = 520) {
+    this.tone({ freq, duration: 0.06, type: "sine", gain: 0.18 });
+  }
+  chime() {
+    [523.25, 659.25, 783.99].forEach((f, i) => this.tone({ freq: f, duration: 0.9 - i * 0.15, type: "sine", gain: 0.15, delay: i * 0.04 }));
+  }
+  success() {
+    [392, 493.88, 587.33, 783.99].forEach((f, i) => this.tone({ freq: f, duration: 0.4, type: "triangle", gain: 0.15, delay: i * 0.08 }));
+  }
+  thud() {
+    this.tone({ freq: 130, duration: 0.14, type: "sine", gain: 0.22 });
+  }
+  /** Start a soft evolving ambient pad on the music bus. */
+  startAmbient(root = 110, voices = [1, 1.5, 2, 2.5]) {
+    if (!this.ctx || !this.musicGain || this.padOn) return;
+    this.padOn = true;
+    const filter = this.ctx.createBiquadFilter();
+    filter.type = "lowpass";
+    filter.frequency.value = 900;
+    filter.connect(this.musicGain);
+    const bus = this.ctx.createGain();
+    bus.gain.value = 0;
+    bus.connect(filter);
+    for (const mult of voices) {
+      const osc = this.ctx.createOscillator();
+      osc.type = "triangle";
+      osc.frequency.value = root * mult;
+      const g = this.ctx.createGain();
+      g.gain.value = 0.1 / voices.length;
+      osc.connect(g);
+      g.connect(bus);
+      osc.start();
+    }
+    bus.gain.setTargetAtTime(0.9, this.ctx.currentTime, 3);
+  }
+};
+var audio = new AudioBus();
+
+// src/ui/overlay.ts
+var active = null;
+var STYLE_ID = "hayao-overlay-style";
+var CSS = `
+.hy-scrim{position:absolute;inset:0;display:grid;place-items:center;z-index:50;font-family:var(--hy-serif,Georgia,serif)}
+.hy-scrim.dim{background:rgba(30,24,14,.5);backdrop-filter:blur(2px)}
+.hy-card{background:var(--hy-paper,#fbf6ea);color:var(--hy-ink,#3d3323);border:1px solid var(--hy-line,#d9ccae);border-radius:14px;box-shadow:0 14px 44px rgba(40,30,15,.3);padding:26px 30px;max-width:440px;text-align:center}
+.hy-card h1{margin:0 0 6px;font-size:30px}
+.hy-card .hy-body{color:var(--hy-ink-soft,#6f6047);font-size:15px;line-height:1.5;margin-bottom:18px}
+.hy-menu{display:flex;flex-direction:column;gap:8px;align-items:stretch}
+.hy-item{font:inherit;font-size:16px;padding:9px 16px;border-radius:9px;border:1px solid var(--hy-line,#d9ccae);background:transparent;color:inherit;cursor:pointer;transition:transform .1s,background .1s}
+.hy-item:hover,.hy-item.sel{background:var(--hy-accent,#a11d3a);color:#fdf3ee;border-color:transparent;transform:translateY(-1px)}
+.hy-item.primary{background:var(--hy-accent,#a11d3a);color:#fdf3ee;border-color:transparent}
+`;
+function ensureStyle() {
+  if (typeof document === "undefined" || document.getElementById(STYLE_ID)) return;
+  const s = document.createElement("style");
+  s.id = STYLE_ID;
+  s.textContent = CSS;
+  document.head.appendChild(s);
+}
+var host = null;
+function setOverlayHost(el) {
+  host = el;
+}
+function showScreen(spec) {
+  if (typeof document === "undefined") {
+    return { close() {
+    }, element: null };
+  }
+  ensureStyle();
+  hideScreen();
+  const scrim = document.createElement("div");
+  scrim.className = `hy-scrim${spec.dim === false ? "" : " dim"}${spec.className ? " " + spec.className : ""}`;
+  const card = document.createElement("div");
+  card.className = "hy-card";
+  if (spec.title) {
+    const h = document.createElement("h1");
+    h.textContent = spec.title;
+    card.appendChild(h);
+  }
+  if (spec.body) {
+    const b = document.createElement("div");
+    b.className = "hy-body";
+    b.innerHTML = spec.body;
+    card.appendChild(b);
+  }
+  const actions = spec.actions ?? [];
+  let sel = Math.max(0, actions.findIndex((a) => a.primary));
+  if (sel < 0) sel = 0;
+  const items = [];
+  if (actions.length) {
+    const menu = document.createElement("div");
+    menu.className = "hy-menu";
+    actions.forEach((a, i) => {
+      const btn = document.createElement("button");
+      btn.className = `hy-item${a.primary ? " primary" : ""}`;
+      btn.textContent = a.label;
+      btn.addEventListener("click", () => a.onSelect());
+      btn.addEventListener("mouseenter", () => setSel(i));
+      menu.appendChild(btn);
+      items.push(btn);
+    });
+    card.appendChild(menu);
+  }
+  function setSel(i) {
+    sel = (i + items.length) % items.length;
+    items.forEach((el, k) => el.classList.toggle("sel", k === sel));
+  }
+  if (items.length) setSel(sel);
+  const onKey = (e) => {
+    if (!items.length) return;
+    if (e.code === "ArrowDown") {
+      setSel(sel + 1);
+      e.preventDefault();
+    } else if (e.code === "ArrowUp") {
+      setSel(sel - 1);
+      e.preventDefault();
+    } else if (e.code === "Enter" || e.code === "Space") {
+      actions[sel]?.onSelect();
+      e.preventDefault();
+    }
+  };
+  document.addEventListener("keydown", onKey);
+  scrim.appendChild(card);
+  (host ?? document.body).appendChild(scrim);
+  const handle = {
+    element: scrim,
+    close() {
+      document.removeEventListener("keydown", onKey);
+      scrim.remove();
+      if (active === handle) active = null;
+    }
+  };
+  active = handle;
+  return handle;
+}
+function hideScreen() {
+  active?.close();
+}
+
+// src/ui/settings.ts
+var KEY = "hayao.settings.v1";
+var DEFAULTS = { master: 0.7, music: 0.6, sfx: 0.8, muted: false, colorblind: false, reducedMotion: false };
+var SettingsStore = class {
+  state;
+  subs = /* @__PURE__ */ new Set();
+  constructor() {
+    this.state = this.load();
+    this.pushToAudio();
+  }
+  get() {
+    return { ...this.state };
+  }
+  set(patch) {
+    this.state = { ...this.state, ...patch };
+    this.save();
+    this.pushToAudio();
+    for (const fn of this.subs) fn(this.get());
+  }
+  subscribe(fn) {
+    this.subs.add(fn);
+    return () => this.subs.delete(fn);
+  }
+  pushToAudio() {
+    audio.setVolumes({ master: this.state.master, music: this.state.music, sfx: this.state.sfx, muted: this.state.muted });
+  }
+  load() {
+    try {
+      const raw = typeof localStorage !== "undefined" && localStorage.getItem(KEY);
+      if (raw) return { ...DEFAULTS, ...JSON.parse(raw) };
+    } catch {
+    }
+    return { ...DEFAULTS };
+  }
+  save() {
+    try {
+      localStorage.setItem(KEY, JSON.stringify(this.state));
+    } catch {
+    }
+  }
+};
+var settings = new SettingsStore();
+function toggleFullscreen() {
+  if (typeof document === "undefined") return;
+  const doc = document;
+  const el = document.documentElement;
+  if (document.fullscreenElement || doc.webkitFullscreenElement) {
+    (document.exitFullscreen ?? doc.webkitExitFullscreen)?.call(document);
+  } else {
+    (el.requestFullscreen ?? el.webkitRequestFullscreen)?.call(el);
+  }
+}
+
+// src/ui/shell.ts
+var Shell = class {
+  paused = false;
+  opts;
+  keyHandler;
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.keyHandler = (e) => {
+      if (e.code === "Escape") {
+        e.preventDefault();
+        this.toggle();
+      }
+    };
+    if (typeof document !== "undefined") document.addEventListener("keydown", this.keyHandler);
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  toggle() {
+    this.paused ? this.resume() : this.pause();
+  }
+  pause() {
+    if (this.paused) return;
+    this.paused = true;
+    audio.blip(440);
+    this.opts.onPause?.(true);
+    this.render();
+  }
+  resume() {
+    if (!this.paused) return;
+    this.paused = false;
+    hideScreen();
+    this.opts.onPause?.(false);
+  }
+  render() {
+    const s = settings.get();
+    const vol = (label, v) => `${label}: ${Math.round(v * 100)}`;
+    showScreen({
+      title: this.opts.title ?? "Paused",
+      body: `<div style="font-size:13px;text-align:left;line-height:1.9">${vol("Master", s.master)} \xB7 ${vol("Music", s.music)} \xB7 ${vol("Sfx", s.sfx)}<br/><span style="opacity:.7">Use the menu, or keys: M mute \xB7 F fullscreen</span></div>`,
+      actions: [
+        { label: "Resume", primary: true, onSelect: () => this.resume() },
+        { label: s.muted ? "Unmute (M)" : "Mute (M)", onSelect: () => {
+          settings.set({ muted: !settings.get().muted });
+          this.render();
+        } },
+        { label: "Music \u2212/+", onSelect: () => {
+          const m = Math.min(1, settings.get().music + 0.1) % 1.05;
+          settings.set({ music: m > 1 ? 0 : m });
+          this.render();
+        } },
+        { label: "Fullscreen (F)", onSelect: () => toggleFullscreen() },
+        ...this.opts.onRestart ? [{ label: "Restart", onSelect: () => {
+          this.resume();
+          this.opts.onRestart();
+        } }] : [],
+        ...this.opts.onQuit ? [{ label: "Quit", onSelect: () => {
+          this.resume();
+          this.opts.onQuit();
+        } }] : []
+      ]
+    });
+  }
+  dispose() {
+    if (typeof document !== "undefined") document.removeEventListener("keydown", this.keyHandler);
+    hideScreen();
+  }
+};
+
+// src/verify/solver.ts
+function solve(puzzle, options = {}) {
+  const maxDepth = options.maxDepth ?? 60;
+  const nodeCap = options.nodeCap ?? 1e6;
+  const start = puzzle.initial(options.level);
+  if (puzzle.isWin(start)) return { solvable: true, path: [], depth: 0, nodes: 0, exhausted: false };
+  let frontier = [{ state: start, path: [] }];
+  const seen = /* @__PURE__ */ new Set([puzzle.key(start)]);
+  let nodes = 0;
+  for (let depth = 0; depth < maxDepth && frontier.length > 0; depth++) {
+    const next = [];
+    for (const { state, path } of frontier) {
+      for (const move of puzzle.moves(state)) {
+        if (nodes >= nodeCap) return { solvable: false, nodes, exhausted: true };
+        nodes++;
+        const after = puzzle.apply(state, move);
+        if (puzzle.isDead?.(after)) continue;
+        if (puzzle.isWin(after)) {
+          return { solvable: true, path: [...path, move], depth: depth + 1, nodes, exhausted: false };
+        }
+        const k = puzzle.key(after);
+        if (!seen.has(k)) {
+          seen.add(k);
+          next.push({ state: after, path: [...path, move] });
+        }
+      }
+    }
+    frontier = next;
+  }
+  return { solvable: false, nodes, exhausted: frontier.length > 0 };
+}
+function assertSolvable(puzzle, options = {}) {
+  const result = solve(puzzle, options);
+  if (!result.solvable) {
+    throw new Error(
+      `hayao: level ${options.level ?? 0} is NOT winnable (expanded ${result.nodes} nodes${result.exhausted ? ", search capped \u2014 raise nodeCap/maxDepth" : ""}).`
+    );
+  }
+  return result;
+}
+
+// src/verify/determinism.ts
+function replay(makeWorld, log) {
+  const world = makeWorld();
+  const hashes = [];
+  for (let i = 0; i < log.frames.length; i++) {
+    world.step(frameActions(log, i));
+    hashes.push(world.hash());
+  }
+  return { finalHash: world.hash(), hashes };
+}
+function checkDeterministic(makeWorld, log) {
+  const a = replay(makeWorld, log);
+  const b = replay(makeWorld, log);
+  let divergedAt = -1;
+  for (let i = 0; i < a.hashes.length; i++) {
+    if (a.hashes[i] !== b.hashes[i]) {
+      divergedAt = i;
+      break;
+    }
+  }
+  return {
+    ok: divergedAt === -1 && a.finalHash === b.finalHash,
+    frames: log.frames.length,
+    divergedAt,
+    finalHash: a.finalHash
+  };
+}
+function assertDeterministic(makeWorld, log) {
+  const report = checkDeterministic(makeWorld, log);
+  if (!report.ok) {
+    throw new Error(
+      `hayao: sim is NON-deterministic \u2014 runs diverged at frame ${report.divergedAt} of ${report.frames}. Check for Math.random/Date.now/Set-iteration/unordered-map in the sim.`
+    );
+  }
+  return report;
+}
+function assertSnapshotStable(makeWorld, log, warmup) {
+  const original = makeWorld();
+  for (let i = 0; i < warmup; i++) original.step(frameActions(log, i));
+  const snap = original.snapshot();
+  const restored = makeWorld();
+  restored.restore(snap);
+  for (let i = warmup; i < log.frames.length; i++) {
+    original.step(frameActions(log, i));
+    restored.step(frameActions(log, i));
+  }
+  const hashA = original.hash();
+  const hashB = restored.hash();
+  return { ok: hashA === hashB, hashA, hashB };
+}
+
+// src/verify/playthrough.ts
+function hold(actions, frames) {
+  return { actions, frames };
+}
+function wait(frames) {
+  return { actions: [], frames };
+}
+function scriptedPlaythrough(world, script) {
+  const probes = [];
+  let total = 0;
+  for (const seg of script) {
+    for (let i = 0; i < seg.frames; i++) world.step(seg.actions ?? []);
+    total += seg.frames;
+    probes.push(world.probe());
+  }
+  return { totalFrames: total, finalHash: world.hash(), probes };
+}
+function pump(world, frames, actions = []) {
+  for (let i = 0; i < frames; i++) world.step(actions);
+}
+
+// src/verify/capture.ts
+function isCaptureMode() {
+  return typeof location !== "undefined" && new URLSearchParams(location.search).has("capture");
+}
+function installCapture(target) {
+  const api = {
+    pump(frames, actions = []) {
+      target.setPaused(true);
+      for (let i = 0; i < frames; i++) target.stepOnce(actions);
+      return target.world.probe();
+    },
+    probe: () => target.world.probe(),
+    hash: () => target.world.hash(),
+    shot: () => target.renderSVG(),
+    async save(path) {
+      const svg = target.renderSVG();
+      try {
+        const res = await fetch("/__shot", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ path, svg })
+        });
+        return res.ok;
+      } catch {
+        return false;
+      }
+    },
+    key(type, code) {
+      document.dispatchEvent(new KeyboardEvent(type, { code, bubbles: true }));
+    },
+    get world() {
+      return target.world;
+    }
+  };
+  globalThis.__hayao = api;
+  return api;
+}
+
+// src/verify/driver.ts
+function scriptToFrames(script) {
+  const out = [];
+  for (const seg of script) {
+    const n2 = seg.frames ?? 1;
+    const hold2 = seg.hold ?? [];
+    for (let i = 0; i < n2; i++) out.push(i === 0 && seg.press ? [...hold2, ...seg.press] : [...hold2]);
+  }
+  return out;
+}
+function drive(world, script, until) {
+  let frames = 0;
+  for (const f of scriptToFrames(script)) {
+    if (until && until(world.probe())) return { frames, matched: true };
+    world.step(f);
+    frames++;
+  }
+  return { frames, matched: until ? until(world.probe()) : false };
+}
+
+// src/verify/bot.ts
+function createPlanBot(plan, execs) {
+  let i = 0;
+  let frames = 0;
+  let mem = {};
+  const fn = (probe) => {
+    const out = [];
+    const step = plan[i];
+    if (!step) return out;
+    frames++;
+    const ctx = {
+      get frames() {
+        return frames;
+      },
+      mem,
+      next() {
+        i++;
+        frames = 0;
+        mem = {};
+      },
+      retry() {
+        frames = 0;
+        mem = {};
+      }
+    };
+    const exec = execs[step.kind];
+    if (!exec) throw new Error(`plan bot: no executor for step kind "${step.kind}"`);
+    exec(step, probe, out, ctx);
+    return out;
+  };
+  const bot = fn;
+  bot.stepIndex = () => i;
+  bot.done = () => i >= plan.length;
+  return bot;
+}
+function steer2D(px, py, tx, ty, out, dead = 8) {
+  if (px < tx - dead) out.push("right");
+  else if (px > tx + dead) out.push("left");
+  if (py < ty - dead) out.push("down");
+  else if (py > ty + dead) out.push("up");
+}
+
+// src/verify/feel.ts
+function recordTimeline(world, frames) {
+  const out = [world.probe()];
+  for (const f of frames) {
+    world.step(f);
+    out.push(world.probe());
+  }
+  return out;
+}
+function firstFrame(timeline, pred) {
+  for (let i = 0; i < timeline.length; i++) if (pred(timeline[i])) return i;
+  return -1;
+}
+function series(timeline, key) {
+  return timeline.map((p) => p[key]);
+}
+function changeFrames(timeline, key) {
+  const out = [];
+  for (let i = 1; i < timeline.length; i++) if (timeline[i][key] !== timeline[i - 1][key]) out.push(i);
+  return out;
+}
+function isMonotonic(values, dir, slack = 0) {
+  for (let i = 1; i < values.length; i++) {
+    if (dir === "up" ? values[i] < values[i - 1] - slack : values[i] > values[i - 1] + slack) return false;
+  }
+  return true;
+}
+function inputDensity(frames) {
+  if (frames.length === 0) return 0;
+  return frames.filter((f) => f.length > 0).length / frames.length;
+}
+function longestLull(eventFrames, totalFrames) {
+  const pts = [0, ...eventFrames, totalFrames];
+  let worst = 0;
+  for (let i = 1; i < pts.length; i++) worst = Math.max(worst, pts[i] - pts[i - 1]);
+  return worst;
+}
+
+// src/verify/filmstrip.ts
+function renderFilmstrip(world, frames, opts) {
+  const panels = Math.max(2, opts.panels ?? 12);
+  const every = Math.max(1, Math.ceil(frames.length / (panels - 1)));
+  const shots = [{ frame: 0, inner: commandsToSVGInner(world.render()) }];
+  for (let i = 0; i < frames.length; i++) {
+    world.step(frames[i]);
+    if ((i + 1) % every === 0 || i === frames.length - 1) {
+      shots.push({ frame: i + 1, inner: commandsToSVGInner(world.render()) });
+    }
+  }
+  const cols = Math.max(1, opts.cols ?? 4);
+  const pw = opts.panelWidth ?? 320;
+  const ph = Math.round(pw * opts.height / opts.width);
+  const labelH = 18;
+  const gap = 8;
+  const cellW = pw + gap;
+  const cellH = ph + labelH + gap;
+  const rows = Math.ceil(shots.length / cols);
+  const totalW = cols * cellW + gap;
+  const totalH = rows * cellH + gap;
+  const bg = opts.background ?? "#ffffff";
+  const cells = shots.map((s, i) => {
+    const x = gap + i % cols * cellW;
+    const y = gap + Math.floor(i / cols) * cellH;
+    return `<g transform="translate(${x} ${y})"><svg width="${pw}" height="${ph}" viewBox="0 0 ${opts.width} ${opts.height}"><rect x="0" y="0" width="${opts.width}" height="${opts.height}" fill="${bg}"/>` + s.inner + `</svg><rect x="0" y="0" width="${pw}" height="${ph}" fill="none" stroke="#999" stroke-width="1"/><text x="${pw / 2}" y="${ph + 13}" font-size="11" font-family="monospace" text-anchor="middle" fill="#555">f ${s.frame} \xB7 ${(s.frame / 60).toFixed(1)}s</text></g>`;
+  }).join("");
+  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();
+  /**
+   * 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
+   * checks the way ad-hoc module variables can.
+   */
+  state = {};
+  width;
+  height;
+  root;
+  activeCamera = null;
+  seed;
+  freeQueue = [];
+  started = false;
+  constructor(config = {}) {
+    this.seed = config.seed ?? 1;
+    this.rng = new Rng(this.seed);
+    this.clock = new Clock(config.clock);
+    this.width = config.width ?? 1280;
+    this.height = config.height ?? 720;
+    this.root = new Node({ name: "root" });
+  }
+  get time() {
+    return this.clock.simTimeSec;
+  }
+  get frame() {
+    return this.clock.frame;
+  }
+  /** Replace the scene root, entering the tree. */
+  setRoot(node) {
+    if (this.root) this.root.exitTree();
+    this.root = node;
+    this.started = false;
+  }
+  requestFree(node) {
+    this.freeQueue.push(node);
+  }
+  ensureStarted() {
+    if (!this.started) {
+      this.root.enterTree(this);
+      this.started = true;
+    }
+  }
+  /**
+   * Advance exactly one fixed step with the given actions held down.
+   * This is THE deterministic transition — call it from Node or the browser loop.
+   */
+  step(actionsDown = []) {
+    this.ensureStarted();
+    this.input.beginFrame(actionsDown);
+    this.root.updateTree(this.clock.dt);
+    this.flushFree();
+    this.clock.tick();
+  }
+  /** Feed real elapsed ms; runs 0+ fixed steps. Returns steps run. */
+  advance(realMs, actionsDown = []) {
+    const steps = this.clock.advance(realMs);
+    for (let i = 0; i < steps; i++) this.step(actionsDown);
+    return steps;
+  }
+  flushFree() {
+    if (this.freeQueue.length === 0) return;
+    const q = this.freeQueue;
+    this.freeQueue = [];
+    for (const node of q) {
+      node.exitTree();
+      node.parent?.removeChild(node);
+      if (this.activeCamera === node) this.activeCamera = null;
+    }
+  }
+  // ── Rendering ────────────────────────────────────────────────
+  /** The view transform (inverse of the active camera), mapping world → screen. */
+  viewTransform() {
+    if (!this.activeCamera) return IDENTITY;
+    const cam = this.activeCamera;
+    const camWorld = cam.worldTransform();
+    const centered = composeTransform(makeTransform({ x: this.width / 2, y: this.height / 2 }, 0, { x: cam.zoom, y: cam.zoom }), invertTransform(camWorld));
+    return centered;
+  }
+  /** Project the whole scene to a display list (already camera-applied). */
+  render() {
+    this.ensureStarted();
+    const out = [];
+    this.root.collectDraw(out, this.viewTransform());
+    return out;
+  }
+  // ── Determinism & saves ──────────────────────────────────────
+  /** Deterministic structural hash of the whole sim state. */
+  hash() {
+    return hashValue({
+      seed: this.seed,
+      rng: this.rng.getState(),
+      clock: this.clock.getState(),
+      input: this.input.getState(),
+      state: this.state,
+      tree: this.root.serialize()
+    });
+  }
+  /** Compact snapshot for undo/time-travel and saves. */
+  snapshot() {
+    return {
+      seed: this.seed,
+      rng: this.rng.getState(),
+      clock: this.clock.getState(),
+      input: this.input.getState(),
+      state: structuredClone(this.state),
+      tree: this.root.serialize()
+    };
+  }
+  /** Restore a snapshot. Rebuilds the tree from data (behaviors are re-attached by scene code). */
+  restore(snap) {
+    this.seed = snap.seed;
+    this.rng.setState(snap.rng);
+    this.clock.setState(snap.clock);
+    this.input.setState(snap.input);
+    this.state = structuredClone(snap.state);
+    resetNodeIds(1e6);
+    this.setRoot(deserializeNode(snap.tree));
+    this.ensureStarted();
+  }
+  /** A compact probe snapshot for the verification harness (override-friendly). */
+  probe() {
+    return {
+      frame: this.frame,
+      time: this.time,
+      hash: this.hash(),
+      nodes: this.root.query("Sprite").length + this.root.query("Text").length
+    };
+  }
+};
+
+// src/app/game.ts
+function defineGame(def) {
+  return {
+    width: 1280,
+    height: 720,
+    seed: 1,
+    background: "#f3ecdb",
+    inputMap: DEFAULT_INPUT_MAP,
+    ...def
+  };
+}
+function createWorld(def, seedOverride) {
+  const world = new World({
+    seed: seedOverride ?? def.seed ?? 1,
+    width: def.width ?? 1280,
+    height: def.height ?? 720,
+    clock: def.clock
+  });
+  world.setRoot(def.build(world));
+  if (def.probe) {
+    world.probe = () => def.probe(world);
+  }
+  return world;
+}
+function gameInputMap(def) {
+  return def.inputMap ?? DEFAULT_INPUT_MAP;
+}
+function runHeadless(def, inputLog) {
+  const world = createWorld(def);
+  const frames = inputLog?.frames ?? [];
+  for (const f of frames) world.step(f);
+  return { world, hash: world.hash(), steps: frames.length };
+}
+
+// src/app/browser.ts
+function runBrowser(def, mount, opts = {}) {
+  const width = def.width ?? 1280;
+  const height = def.height ?? 720;
+  const background = def.background ?? "#f3ecdb";
+  let world = createWorld(def);
+  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 capture = isCaptureMode();
+  const startAudio = () => {
+    audio.start();
+    const s = settings.get();
+    audio.setVolumes(s);
+    window.removeEventListener("pointerdown", startAudio);
+    window.removeEventListener("keydown", startAudio);
+  };
+  window.addEventListener("pointerdown", startAudio);
+  window.addEventListener("keydown", startAudio);
+  const renderFrame = () => renderer.draw(world.render());
+  const restart = () => {
+    world = createWorld(def);
+    renderFrame();
+  };
+  const shell = opts.shell === false ? null : new Shell({
+    title: def.title,
+    onRestart: opts.onRestart ?? restart,
+    onPause: () => {
+    }
+  });
+  let raf = 0;
+  let last = performance.now();
+  const loop = (now) => {
+    const dt = now - last;
+    last = now;
+    if (!capture && !shell?.isPaused) {
+      const steps = world.advance(dt, input.currentActions());
+      if (steps > 0) input.clearPressed();
+    }
+    renderFrame();
+    raf = requestAnimationFrame(loop);
+  };
+  raf = requestAnimationFrame(loop);
+  const handle = {
+    get world() {
+      return world;
+    },
+    renderer,
+    input,
+    stop() {
+      cancelAnimationFrame(raf);
+      input.dispose();
+      shell?.dispose();
+      renderer.dispose?.();
+    },
+    restart
+  };
+  if (capture) {
+    installCapture({
+      get world() {
+        return world;
+      },
+      stepOnce: (actions = []) => {
+        world.step(actions);
+        renderFrame();
+      },
+      renderSVG: () => renderToSVGString(world.render(), width, height, background),
+      setPaused: () => {
+      }
+    });
+  }
+  return handle;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  AnimationPlayer,
+  AudioBus,
+  Camera2D,
+  Canvas2DRenderer,
+  Clock,
+  DEFAULT_INPUT_MAP,
+  DEFAULT_PLATFORMER,
+  DEFAULT_TILE_CHARS,
+  DUSK,
+  EASINGS,
+  EventBus,
+  HeadlessRenderer,
+  IDENTITY,
+  InputRecorder,
+  InputState,
+  KeyboardSource,
+  MEADOW,
+  Node,
+  Node as Node2D,
+  PAD_NEUTRAL,
+  PALETTES,
+  PAPER,
+  PARTICLE_PRESETS,
+  Particles,
+  Rng,
+  Shaker,
+  Shell,
+  Signal,
+  SpatialHash,
+  Sprite,
+  SvgRenderer,
+  TAU,
+  TILE,
+  Text,
+  Timer,
+  VERSION,
+  World,
+  applyTransform,
+  asciiEntities,
+  assertDeterministic,
+  assertSnapshotStable,
+  assertSolvable,
+  audio,
+  blobPath,
+  changeFrames,
+  checkDeterministic,
+  clamp,
+  commandsToSVGInner,
+  composeTransform,
+  createPlanBot,
+  createPlatformerState,
+  createWorld,
+  dashJumpDistance,
+  defineGame,
+  deg2rad,
+  deserializeNode,
+  drive,
+  firstFrame,
+  frameActions,
+  gameInputMap,
+  groundAt,
+  hashString,
+  hashValue,
+  hideScreen,
+  hold,
+  inVisionCone,
+  inputDensity,
+  installCapture,
+  invLerp,
+  invertTransform,
+  isCaptureMode,
+  isMonotonic,
+  jumpAirtime,
+  jumpDistance,
+  jumpHeight,
+  keysToActions,
+  lerp,
+  lineOfSight,
+  longestLull,
+  makeTransform,
+  mapHeight,
+  mapWidth,
+  mix,
+  moveRect,
+  pump,
+  rad2deg,
+  raycastTiles,
+  recordTimeline,
+  rectBlocked,
+  rectContains,
+  rectsOverlap,
+  registerNode,
+  regularPolygon,
+  remap,
+  renderFilmstrip,
+  renderToSVGString,
+  replay,
+  resetNodeIds,
+  runBrowser,
+  runHeadless,
+  scriptToFrames,
+  scriptedPlaythrough,
+  series,
+  setOverlayHost,
+  settings,
+  showScreen,
+  smoothClosedPath,
+  smoothOpenPath,
+  solve,
+  sortCommands,
+  star,
+  steer2D,
+  stepPlatformer,
+  tileAt,
+  tileAtPoint,
+  tilemapFromAscii,
+  toggleFullscreen,
+  vadd,
+  vdist,
+  vdot,
+  vec2,
+  vlen,
+  vnorm,
+  vscale,
+  vsub,
+  wait,
+  withAlpha
+};
+//# sourceMappingURL=index.js.map