hayao 0.4.0 → 0.4.2

package/dist/index.js

@@ -1831,6 +1831,1366 @@ var VerletChain = class extends Node {
   }
 };
 
+// src/anim/clip.ts
+var CLIP_CHANNELS = ["x", "y", "rotation", "scaleX", "scaleY", "opacity"];
+function clipTime(def, elapsed) {
+  const d = def.duration;
+  if (d <= 0) return 0;
+  if (def.loop === "once") return elapsed < 0 ? 0 : elapsed > d ? d : elapsed;
+  if (def.loop === "loop") {
+    const m2 = elapsed % d;
+    return m2 < 0 ? m2 + d : m2;
+  }
+  const p = 2 * d;
+  let m = elapsed % p;
+  if (m < 0) m += p;
+  return m <= d ? m : p - m;
+}
+function clipFinished(def, elapsed) {
+  return def.loop === "once" && def.duration > 0 && elapsed >= def.duration;
+}
+function sampleTrack(keys, t) {
+  const n5 = keys.length;
+  if (n5 === 0) return 0;
+  if (n5 === 1 || t <= keys[0].t) return keys[0].v;
+  if (t >= keys[n5 - 1].t) return keys[n5 - 1].v;
+  let lo = 0;
+  let hi = n5 - 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (keys[mid].t < t) lo = mid + 1;
+    else hi = mid;
+  }
+  const b = keys[hi];
+  const a = keys[hi - 1];
+  const span = b.t - a.t;
+  if (span <= 0) return b.v;
+  const raw = (t - a.t) / span;
+  const ease = EASINGS[b.ease ?? "linear"] ?? EASINGS.linear;
+  return a.v + (b.v - a.v) * ease(raw);
+}
+function sampleClip(def, elapsed) {
+  const t = clipTime(def, elapsed);
+  return def.tracks.map((tr) => ({ target: tr.target, channel: tr.channel, value: sampleTrack(tr.keys, t) }));
+}
+function clipEvents(def, prev, next) {
+  const evs = def.events;
+  if (!evs || evs.length === 0 || next <= prev) return [];
+  const d = def.duration;
+  const out = [];
+  const inWindow = (t, lo, hi) => t > lo && t <= hi;
+  const emit = (lo, hi) => {
+    for (const e of evs) if (inWindow(e.t, lo, hi)) out.push(e.name);
+  };
+  if (def.loop === "once" || d <= 0) {
+    const lo = prev < 0 ? 0 : prev > d ? d : prev;
+    const hi = next < 0 ? 0 : next > d ? d : next;
+    emit(lo, hi);
+    return out;
+  }
+  const prevLocal = clipTime(def, prev);
+  const nextLocal = clipTime(def, next);
+  const periodLen = def.loop === "pingpong" ? 2 * d : d;
+  const wraps = Math.floor(next / periodLen) - Math.floor(prev / periodLen);
+  if (def.loop === "pingpong") {
+    if (wraps === 0 && nextLocal >= prevLocal) emit(prevLocal, nextLocal);
+    else if (wraps === 0) emit(nextLocal, prevLocal);
+    else {
+      emit(Math.min(prevLocal, nextLocal), d);
+      emit(0, Math.max(prevLocal, nextLocal));
+    }
+    return out;
+  }
+  if (wraps === 0 && nextLocal >= prevLocal) {
+    emit(prevLocal, nextLocal);
+  } else {
+    emit(prevLocal, d);
+    emit(0, nextLocal);
+  }
+  return out;
+}
+function clipIssues(def, knownTargets) {
+  const issues = [];
+  if (!(def.duration > 0)) issues.push(`duration must be > 0 (got ${def.duration})`);
+  if (def.loop !== "loop" && def.loop !== "once" && def.loop !== "pingpong") {
+    issues.push(`loop must be 'loop' | 'once' | 'pingpong' (got '${String(def.loop)}')`);
+  }
+  if (!def.tracks || def.tracks.length === 0) issues.push("clip has no tracks");
+  const known = knownTargets ? new Set(knownTargets) : null;
+  (def.tracks ?? []).forEach((tr, i) => {
+    const where = `track ${i} (${tr.target}/${tr.channel})`;
+    if (!CLIP_CHANNELS.includes(tr.channel)) issues.push(`${where}: unknown channel '${tr.channel}'`);
+    if (known && !known.has(tr.target)) issues.push(`${where}: target '${tr.target}' is not in the rig`);
+    if (!tr.keys || tr.keys.length === 0) {
+      issues.push(`${where}: no keyframes`);
+    } else {
+      for (let k = 0; k < tr.keys.length; k++) {
+        const key = tr.keys[k];
+        if (!Number.isFinite(key.t) || !Number.isFinite(key.v)) issues.push(`${where}: key ${k} has non-finite t/v`);
+        if (key.t < 0 || key.t > def.duration) issues.push(`${where}: key ${k} time ${key.t} is outside [0, ${def.duration}]`);
+        if (k > 0 && key.t < tr.keys[k - 1].t) issues.push(`${where}: keys must be ascending in t (key ${k} = ${key.t} < ${tr.keys[k - 1].t})`);
+        if (key.ease !== void 0 && !(key.ease in EASINGS)) issues.push(`${where}: key ${k} unknown ease '${String(key.ease)}'`);
+      }
+    }
+  });
+  (def.events ?? []).forEach((e, i) => {
+    if (!Number.isFinite(e.t) || e.t < 0 || e.t > def.duration) issues.push(`event ${i} ('${e.name}') time ${e.t} is outside [0, ${def.duration}]`);
+    if (!e.name) issues.push(`event ${i} has no name`);
+  });
+  return [...new Set(issues)];
+}
+
+// src/anim/blend.ts
+var poseKey = (target, channel) => `${target}/${channel}`;
+function samplePose(def, phase) {
+  const local = clipTime(def, phase * def.duration);
+  const pose = {};
+  for (const tr of def.tracks) pose[poseKey(tr.target, tr.channel)] = sampleTrack(tr.keys, local);
+  return pose;
+}
+function mixPose(a, b, t, out = {}) {
+  for (const k in out) delete out[k];
+  for (const k in a) {
+    out[k] = k in b ? a[k] + (b[k] - a[k]) * t : a[k];
+  }
+  for (const k in b) {
+    if (!(k in a)) out[k] = b[k];
+  }
+  return out;
+}
+var Blend1D = class {
+  samples;
+  constructor(samples) {
+    this.samples = samples.slice().sort((p, q) => p.x - q.x);
+  }
+  /** The clip weights at parameter `param` (sums to 1; empty space → {}). */
+  weights(param) {
+    const s = this.samples;
+    if (s.length === 0) return [];
+    if (s.length === 1 || param <= s[0].x) return [{ clip: s[0].clip, weight: 1 }];
+    if (param >= s[s.length - 1].x) return [{ clip: s[s.length - 1].clip, weight: 1 }];
+    let i = 0;
+    while (i < s.length - 1 && s[i + 1].x <= param) i++;
+    const a = s[i];
+    const b = s[i + 1];
+    const span = b.x - a.x;
+    const t = span <= 0 ? 0 : (param - a.x) / span;
+    return [
+      { clip: a.clip, weight: 1 - t },
+      { clip: b.clip, weight: t }
+    ];
+  }
+  /** Blend the neighbor clips at `param`, all sampled at normalized `phase`. */
+  sample(param, phase) {
+    const w = this.weights(param);
+    if (w.length === 0) return {};
+    let pose = samplePose(w[0].clip, phase);
+    if (w.length === 2) pose = mixPose(pose, samplePose(w[1].clip, phase), w[1].weight);
+    return pose;
+  }
+};
+var Blend2D = class {
+  samples;
+  constructor(samples) {
+    this.samples = samples.map((s) => ({ clip: s.clip, x: s.x, y: s.y ?? 0 }));
+  }
+  /** Clip weights at (px,py): nearest-3 barycentric, clamped + renormalized. */
+  weights(px, py) {
+    const s = this.samples;
+    if (s.length === 0) return [];
+    if (s.length <= 3) return this.barycentric(s, px, py);
+    const idx = s.map((_, i) => i);
+    idx.sort((a, b) => {
+      const da = (s[a].x - px) ** 2 + (s[a].y - py) ** 2;
+      const db = (s[b].x - px) ** 2 + (s[b].y - py) ** 2;
+      return da - db || a - b;
+    });
+    return this.barycentric([s[idx[0]], s[idx[1]], s[idx[2]]], px, py);
+  }
+  barycentric(tri, px, py) {
+    if (tri.length === 1) return [{ clip: tri[0].clip, weight: 1 }];
+    if (tri.length === 2) {
+      const [a2, b2] = tri;
+      const dx = b2.x - a2.x;
+      const dy = b2.y - a2.y;
+      const len2 = dx * dx + dy * dy;
+      const t = len2 <= 0 ? 0 : clamp(((px - a2.x) * dx + (py - a2.y) * dy) / len2, 0, 1);
+      return [
+        { clip: a2.clip, weight: 1 - t },
+        { clip: b2.clip, weight: t }
+      ];
+    }
+    const [a, b, c] = tri;
+    const det = (b.y - c.y) * (a.x - c.x) + (c.x - b.x) * (a.y - c.y);
+    let wa;
+    let wb;
+    if (det === 0) {
+      wa = wb = 1 / 3;
+    } else {
+      wa = ((b.y - c.y) * (px - c.x) + (c.x - b.x) * (py - c.y)) / det;
+      wb = ((c.y - a.y) * (px - c.x) + (a.x - c.x) * (py - c.y)) / det;
+    }
+    let wc = 1 - wa - wb;
+    wa = wa < 0 ? 0 : wa;
+    wb = wb < 0 ? 0 : wb;
+    wc = wc < 0 ? 0 : wc;
+    const sum = wa + wb + wc;
+    if (sum <= 0) return [{ clip: a.clip, weight: 1 }];
+    return [
+      { clip: a.clip, weight: wa / sum },
+      { clip: b.clip, weight: wb / sum },
+      { clip: c.clip, weight: wc / sum }
+    ];
+  }
+  /** Blend the nearest-3 clips at (px,py), all sampled at normalized `phase`. */
+  sample(px, py, phase) {
+    const w = this.weights(px, py);
+    if (w.length === 0) return {};
+    const out = {};
+    for (const { clip: clip2, weight } of w) {
+      if (weight === 0) continue;
+      const p = samplePose(clip2, phase);
+      for (const k in p) out[k] = (out[k] ?? 0) + p[k] * weight;
+    }
+    return out;
+  }
+};
+function blendIssues(samples, dims = 1) {
+  const issues = [];
+  if (!samples || samples.length === 0) {
+    issues.push("blend space has no samples");
+    return issues;
+  }
+  samples.forEach((s, i) => {
+    if (!Number.isFinite(s.x)) issues.push(`sample ${i}: x is not finite`);
+    if (dims === 2 && !Number.isFinite(s.y ?? 0)) issues.push(`sample ${i}: y is not finite`);
+    if (!s.clip) issues.push(`sample ${i}: missing clip`);
+  });
+  const seen = /* @__PURE__ */ new Map();
+  samples.forEach((s, i) => {
+    const key = dims === 2 ? `${s.x},${s.y ?? 0}` : `${s.x}`;
+    if (seen.has(key)) issues.push(`sample ${i} duplicates the position of sample ${seen.get(key)} (${key})`);
+    else seen.set(key, i);
+  });
+  return [...new Set(issues)];
+}
+
+// src/anim/skeleton.ts
+var Bone2D = class extends Node {
+  type = "Bone2D";
+  /** Reach in local px along +x. Used by IK, skinning, and the debug overlay. */
+  length;
+  constructor(config = {}) {
+    super(config);
+    this.length = config.length ?? 0;
+  }
+  /** Tip position in LOCAL space (root is the node origin; tip is `length` along +x). */
+  get tip() {
+    return { x: this.length, y: 0 };
+  }
+  serializeProps() {
+    return { length: this.length };
+  }
+  applyProps(props) {
+    if (typeof props.length === "number") this.length = props.length;
+  }
+};
+var Skeleton = class {
+  constructor(root) {
+    this.root = root;
+    this.index(root, "");
+  }
+  root;
+  byPath = /* @__PURE__ */ new Map();
+  index(node, path) {
+    if (path !== "") this.byPath.set(path, node);
+    for (const c of node.children) {
+      const childPath = path === "" ? c.name : `${path}/${c.name}`;
+      this.index(c, childPath);
+    }
+  }
+  /** Resolve a track/IK target path to a node (null if the rig lacks it). */
+  resolve(path) {
+    return this.byPath.get(path) ?? null;
+  }
+  /** All target paths in the rig — feed to `clipIssues(def, skeleton.targets())`. */
+  targets() {
+    return [...this.byPath.keys()];
+  }
+  /** Only the Bone2D joints, by path (for IK / skinning). */
+  bones() {
+    const out = [];
+    for (const node of this.byPath.values()) if (node instanceof Bone2D) out.push(node);
+    return out;
+  }
+};
+function buildSkeleton(root) {
+  return new Skeleton(root);
+}
+function resolveTracks(def, skeleton) {
+  const out = [];
+  for (const tr of def.tracks) {
+    const node = skeleton.resolve(tr.target);
+    if (node) out.push({ node, channel: tr.channel, keys: tr.keys, target: tr.target });
+  }
+  return out;
+}
+function applyChannel(node, channel, value) {
+  switch (channel) {
+    case "x":
+      node.pos.x = value;
+      break;
+    case "y":
+      node.pos.y = value;
+      break;
+    case "rotation":
+      node.rotation = value;
+      break;
+    case "scaleX":
+      node.scale.x = value;
+      break;
+    case "scaleY":
+      node.scale.y = value;
+      break;
+    case "opacity":
+      applyOpacity(node, value);
+      break;
+  }
+}
+function applyOpacity(node, value) {
+  const withPaint = node;
+  if (withPaint.paint) withPaint.paint.opacity = value;
+}
+
+// src/scene/clipPlayer.ts
+var ClipPlayer = class extends Node {
+  type = "ClipPlayer";
+  rig;
+  skeleton = null;
+  clips = /* @__PURE__ */ new Map();
+  currentName = null;
+  elapsed = 0;
+  // Crossfade state: the clip we are fading FROM, its frozen playhead, and progress.
+  prevName = null;
+  prevElapsed = 0;
+  fadeDur = 0;
+  fadeT = 0;
+  // Reusable pose buffers for the crossfade path (allocation-free).
+  poseA = {};
+  poseB = {};
+  poseMix = {};
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+    this.rig = config.rig ?? null;
+  }
+  onReady() {
+    if (!this.rig) this.rig = this.parent;
+    this.rebind();
+  }
+  /** Register a clip under `name`. Rebinds its tracks against the current rig. */
+  add(name, def) {
+    this.clips.set(name, { def, tracks: this.rig ? resolveTracks(def, this.ensureSkeleton()) : [] });
+    return this;
+  }
+  /** Re-resolve the rig + every clip's tracks (call after the rig subtree changes). */
+  rebind(rig) {
+    if (rig) this.rig = rig;
+    if (!this.rig) return;
+    this.skeleton = buildSkeleton(this.rig);
+    for (const [, entry] of this.clips) entry.tracks = resolveTracks(entry.def, this.skeleton);
+  }
+  ensureSkeleton() {
+    if (!this.skeleton && this.rig) this.skeleton = buildSkeleton(this.rig);
+    return this.skeleton;
+  }
+  /**
+   * Play `name`, optionally crossfading over `fade` seconds from whatever is
+   * playing. Restarting the same clip with no fade rewinds it. A fade freezes the
+   * outgoing clip's playhead and blends it out with EASINGS.quadInOut.
+   */
+  play(name, opts = {}) {
+    if (!this.clips.has(name)) return;
+    const fade = opts.fade ?? 0;
+    if (fade > 0 && this.currentName && this.currentName !== name) {
+      this.prevName = this.currentName;
+      this.prevElapsed = this.elapsed;
+      this.fadeDur = fade;
+      this.fadeT = 0;
+    } else {
+      this.prevName = null;
+      this.fadeDur = 0;
+      this.fadeT = 0;
+    }
+    this.currentName = name;
+    this.elapsed = 0;
+  }
+  /** Stop playback (freezes the rig at its current pose). */
+  stop() {
+    this.currentName = null;
+    this.prevName = null;
+    this.fadeDur = 0;
+  }
+  /** Current playhead in seconds (raw elapsed, pre-loop-wrap). */
+  get time() {
+    return this.elapsed;
+  }
+  /** The clip currently playing, or null. */
+  get current() {
+    return this.currentName;
+  }
+  /** Fired with the event name each time the playhead crosses a clip event. */
+  get event() {
+    return this.signal("event");
+  }
+  /** Fired when a `once` clip reaches its end. */
+  get finished() {
+    return this.signal("finished");
+  }
+  onProcess(dt) {
+    const name = this.currentName;
+    if (!name) return;
+    const entry = this.clips.get(name);
+    if (!entry) return;
+    const prevElapsed = this.elapsed;
+    this.elapsed += dt;
+    if (this.fadeDur > 0 && this.prevName) {
+      this.fadeT += dt;
+      const raw = this.fadeT >= this.fadeDur ? 1 : this.fadeT / this.fadeDur;
+      const w = EASINGS.quadInOut(raw);
+      const prevEntry = this.clips.get(this.prevName);
+      if (prevEntry) this.samplePose(prevEntry, this.prevElapsed, this.poseA);
+      this.samplePose(entry, this.elapsed, this.poseB);
+      mixPose(this.poseA, this.poseB, w, this.poseMix);
+      this.applyPose(entry, this.poseMix);
+      if (raw >= 1) {
+        this.prevName = null;
+        this.fadeDur = 0;
+      }
+    } else {
+      this.applyDirect(entry, this.elapsed);
+    }
+    if (entry.def.events && entry.def.events.length > 0) {
+      const names = clipEvents(entry.def, prevElapsed, this.elapsed);
+      for (const ev of names) this.emit("event", ev);
+    }
+    if (clipFinished(entry.def, this.elapsed) && !clipFinished(entry.def, prevElapsed)) {
+      this.emit("finished", name);
+    }
+  }
+  /** Direct steady-state apply: sample each bound track and write its channel. */
+  applyDirect(entry, elapsed) {
+    const t = clipTime(entry.def, elapsed);
+    const tracks = entry.tracks;
+    for (let i = 0; i < tracks.length; i++) {
+      const tr = tracks[i];
+      applyChannel(tr.node, tr.channel, sampleTrack(tr.keys, t));
+    }
+  }
+  /** Sample an entry's bound tracks into a reusable Pose (clears then fills). */
+  samplePose(entry, elapsed, out) {
+    for (const k in out) delete out[k];
+    const t = clipTime(entry.def, elapsed);
+    const tracks = entry.tracks;
+    for (let i = 0; i < tracks.length; i++) {
+      const tr = tracks[i];
+      out[poseKey(tr.target, tr.channel)] = sampleTrack(tr.keys, t);
+    }
+  }
+  /** Write a mixed pose back onto the incoming entry's bound nodes. */
+  applyPose(entry, pose) {
+    const tracks = entry.tracks;
+    for (let i = 0; i < tracks.length; i++) {
+      const tr = tracks[i];
+      const v = pose[poseKey(tr.target, tr.channel)];
+      if (v !== void 0) applyChannel(tr.node, tr.channel, v);
+    }
+  }
+};
+
+// src/anim/ik.ts
+function solveTwoBoneIK(root, l0, l1, target, bendDir = 1) {
+  const dx = target.x - root.x;
+  const dy = target.y - root.y;
+  let dist = dhypot(dx, dy);
+  const maxReach = l0 + l1;
+  const minReach = Math.abs(l0 - l1);
+  let reachable = true;
+  if (dist > maxReach) {
+    dist = maxReach;
+    reachable = false;
+  } else if (dist < minReach) {
+    dist = minReach || 1e-9;
+    reachable = false;
+  }
+  if (dist < 1e-9) dist = 1e-9;
+  const toTarget = datan2(dy, dx);
+  const cosRoot = clampUnit((l0 * l0 + dist * dist - l1 * l1) / (2 * l0 * dist));
+  const rootInterior = dacos(cosRoot);
+  const cosMid = clampUnit((l0 * l0 + l1 * l1 - dist * dist) / (2 * l0 * l1));
+  const midInterior = dacos(cosMid);
+  const angle0 = toTarget - bendDir * rootInterior;
+  const angle1 = angle0 + bendDir * (Math.PI - midInterior);
+  return { angle0, angle1, reachable };
+}
+function clampUnit(v) {
+  return v < -1 ? -1 : v > 1 ? 1 : v;
+}
+function dacos(x) {
+  return datan2(Math.sqrt(1 - x * x), x);
+}
+function solveFabrik(root, lengths, target, opts = {}) {
+  const n5 = lengths.length;
+  const maxIter = opts.maxIter ?? 16;
+  const tolerance = opts.tolerance ?? 1e-4;
+  const total = lengths.reduce((a, b) => a + b, 0);
+  const joints = [];
+  for (let i = 0; i <= n5; i++) {
+    const seed = opts.initial?.[i];
+    joints.push(seed ? { x: seed.x, y: seed.y } : { x: root.x + (i === 0 ? 0 : 1e-6 * i), y: root.y });
+  }
+  joints[0] = { x: root.x, y: root.y };
+  const rootToTarget = dhypot(target.x - root.x, target.y - root.y);
+  if (rootToTarget > total) {
+    const ux = (target.x - root.x) / (rootToTarget || 1);
+    const uy = (target.y - root.y) / (rootToTarget || 1);
+    let px = root.x;
+    let py = root.y;
+    joints[0] = { x: px, y: py };
+    for (let i = 0; i < n5; i++) {
+      px += ux * lengths[i];
+      py += uy * lengths[i];
+      joints[i + 1] = { x: px, y: py };
+    }
+    return { joints, angles: anglesOf(joints), reachable: false, iterations: 0 };
+  }
+  let iter = 0;
+  for (; iter < maxIter; iter++) {
+    const end = joints[n5];
+    if (dhypot(end.x - target.x, end.y - target.y) <= tolerance) break;
+    joints[n5] = { x: target.x, y: target.y };
+    for (let i = n5 - 1; i >= 0; i--) {
+      const a = joints[i];
+      const b = joints[i + 1];
+      const d = dhypot(a.x - b.x, a.y - b.y) || 1e-9;
+      const r = lengths[i] / d;
+      joints[i] = { x: b.x + (a.x - b.x) * r, y: b.y + (a.y - b.y) * r };
+    }
+    joints[0] = { x: root.x, y: root.y };
+    for (let i = 0; i < n5; i++) {
+      const a = joints[i];
+      const b = joints[i + 1];
+      const d = dhypot(a.x - b.x, a.y - b.y) || 1e-9;
+      const r = lengths[i] / d;
+      joints[i + 1] = { x: a.x + (b.x - a.x) * r, y: a.y + (b.y - a.y) * r };
+    }
+  }
+  return { joints, angles: anglesOf(joints), reachable: true, iterations: iter };
+}
+function anglesOf(joints) {
+  const out = [];
+  for (let i = 0; i < joints.length - 1; i++) {
+    out.push(datan2(joints[i + 1].y - joints[i].y, joints[i + 1].x - joints[i].x));
+  }
+  return out;
+}
+
+// src/scene/ikTarget.ts
+var IkTarget = class extends Node {
+  type = "IkTarget";
+  bones;
+  bendDir;
+  maxIter;
+  /** True if the chain reached the target on the last solve (else it was clamped). */
+  reached = true;
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+    this.bones = config.bones ?? [];
+    this.bendDir = config.bendDir ?? 1;
+    this.maxIter = config.maxIter ?? 16;
+  }
+  /** Repoint the solver at a new chain (root-first). */
+  setBones(bones) {
+    this.bones = bones;
+  }
+  onProcess(_dt) {
+    const bones = this.bones;
+    if (bones.length < 1) return;
+    const rootBone = bones[0];
+    const rootParent = rootBone.parent;
+    if (!rootParent) return;
+    const wt = this.worldTransform();
+    const goalWorld = { x: wt.e, y: wt.f };
+    const parentWorld = rootParent.worldTransform();
+    const invParent = invertTransform(parentWorld);
+    const goal = applyInv(invParent, goalWorld);
+    const rootLocal = { x: rootBone.pos.x, y: rootBone.pos.y };
+    if (bones.length === 2) {
+      const res2 = solveTwoBoneIK(rootLocal, bones[0].length, bones[1].length, goal, this.bendDir);
+      this.reached = res2.reachable;
+      bones[0].rotation = res2.angle0;
+      bones[1].rotation = res2.angle1 - res2.angle0;
+      return;
+    }
+    const lengths = bones.map((b) => b.length);
+    const initial = this.currentJoints(rootLocal);
+    const res = solveFabrik(rootLocal, lengths, goal, { maxIter: this.maxIter, initial });
+    this.reached = res.reachable;
+    let parentAngle = 0;
+    for (let i = 0; i < bones.length; i++) {
+      bones[i].rotation = res.angles[i] - parentAngle;
+      parentAngle = res.angles[i];
+    }
+  }
+  /** Current joint positions (parent space) for FABRIK seeding — stable elbow side. */
+  currentJoints(rootLocal) {
+    const joints = [{ x: rootLocal.x, y: rootLocal.y }];
+    let angle = 0;
+    let px = rootLocal.x;
+    let py = rootLocal.y;
+    for (const b of this.bones) {
+      angle += b.rotation;
+      px += dcos(angle) * b.length;
+      py += dsin(angle) * b.length;
+      joints.push({ x: px, y: py });
+    }
+    return joints;
+  }
+};
+function applyInv(inv, p) {
+  return { x: inv.a * p.x + inv.c * p.y + inv.e, y: inv.b * p.x + inv.d * p.y + inv.f };
+}
+
+// src/scene/skeletonDebug.ts
+var SkeletonDebug = class extends Node {
+  type = "SkeletonDebug";
+  rig;
+  boneColor;
+  pivotColor;
+  pivotRadius;
+  strokeWidth;
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+    this.rig = config.rig ?? null;
+    this.boneColor = config.boneColor ?? "#e0483b";
+    this.pivotColor = config.pivotColor ?? "#f4d35e";
+    this.pivotRadius = config.pivotRadius ?? 3;
+    this.strokeWidth = config.strokeWidth ?? 2;
+  }
+  onReady() {
+    if (!this.rig) this.rig = this.parent;
+  }
+  // The overlay draws in WORLD space directly (each command carries the bone's own
+  // world transform), so `world` — the debug node's own frame — is only the base
+  // the rig's world transforms are already absolute against. We walk the rig and
+  // emit per-bone commands with each bone's worldTransform().
+  draw(out, _world) {
+    const rig = this.rig;
+    if (!rig) return;
+    this.emitFor(rig, out);
+  }
+  emitFor(node, out) {
+    if (node instanceof Bone2D) {
+      const wt = node.worldTransform();
+      out.push({
+        kind: "poly",
+        points: [0, 0, node.length, 0],
+        closed: false,
+        stroke: this.boneColor,
+        strokeWidth: this.strokeWidth,
+        round: true,
+        transform: wt,
+        z: this.z,
+        transient: true
+      });
+      out.push({
+        kind: "circle",
+        cx: 0,
+        cy: 0,
+        radius: this.pivotRadius,
+        fill: this.pivotColor,
+        transform: wt,
+        z: this.z,
+        transient: true
+      });
+      if (node.pivot) {
+        const at2 = composeTransform(wt, makeTransform({ x: node.pivot.x, y: node.pivot.y }, 0, { x: 1, y: 1 }));
+        out.push({
+          kind: "circle",
+          cx: 0,
+          cy: 0,
+          radius: this.pivotRadius * 0.6,
+          stroke: this.pivotColor,
+          strokeWidth: 1,
+          transform: at2,
+          z: this.z,
+          transient: true
+        });
+      }
+    }
+    for (const c of node.children) this.emitFor(c, out);
+  }
+};
+
+// src/art/palette.ts
+var KENTO = {
+  // neutrals: light ground → dark ink, one continuous ramp
+  gofun: "#f7f1e2",
+  // 胡粉  shell-white, lightest paper
+  washi: "#efe7d3",
+  // 和紙  default light ground
+  kinu: "#e4d8bd",
+  //  絹    warm raised panel / card
+  line: "#d8cbac",
+  //  ─     hairline / grid on light
+  kinako: "#b9a882",
+  // 黄粉  tan mid-neutral / muted ink on dark
+  stone: "#6c6252",
+  // 石    secondary text on light (AA at body size)
+  sumiSoft: "#494133",
+  // 墨薄  body ink
+  sumi: "#23201a",
+  // 墨    primary ink / default dark-ish ground
+  kuro: "#181820",
+  // 玄    cool near-black ground for dark games
+  yohaku: "#12121a",
+  // 余白  deepest dark ground
+  darkLine: "#2c2c36",
+  //     hairline / grid on dark
+  // eight hues: `Deep` for light-mode fills, bright for dark-mode / emphasis
+  shuDeep: "#b23a24",
+  shu: "#d9583c",
+  //   朱  vermilion
+  kakiDeep: "#bf6a1c",
+  kaki: "#e79a49",
+  //  柿  persimmon / orange
+  koDeep: "#94741d",
+  ko: "#e3c054",
+  //     黄土 ochre-gold
+  matsuDeep: "#4a7a3a",
+  matsu: "#8bad52",
+  // 松葉 pine green
+  asagiDeep: "#2c7a90",
+  asagi: "#57bad2",
+  // 浅葱 teal-cyan
+  aiDeep: "#2b4257",
+  ai: "#5a86ad",
+  //     藍  indigo
+  fujiDeep: "#63548c",
+  fuji: "#a091cf",
+  //  藤  wisteria violet
+  sakuDeep: "#b0506e",
+  saku: "#e097ac"
+  //  桜  dusty rose
+};
+var MEADOW = {
+  name: "meadow",
+  bg: KENTO.washi,
+  ink: KENTO.sumi,
+  inkSoft: KENTO.sumiSoft,
+  line: KENTO.line,
+  accent: KENTO.shuDeep,
+  accent2: KENTO.aiDeep,
+  good: KENTO.matsuDeep,
+  warn: KENTO.kakiDeep,
+  // deep tones so categorical fills hold contrast on the light ground
+  ramp: [KENTO.shuDeep, KENTO.kakiDeep, KENTO.koDeep, KENTO.matsuDeep, KENTO.asagiDeep, KENTO.aiDeep, KENTO.fujiDeep, KENTO.sakuDeep],
+  swatches: KENTO
+};
+var DUSK = {
+  name: "dusk",
+  bg: KENTO.kuro,
+  ink: KENTO.gofun,
+  inkSoft: KENTO.kinako,
+  line: KENTO.darkLine,
+  accent: KENTO.shu,
+  accent2: KENTO.asagi,
+  good: KENTO.matsu,
+  warn: KENTO.ko,
+  // bright tones so categorical fills pop on the dark ground
+  ramp: [KENTO.shu, KENTO.kaki, KENTO.ko, KENTO.matsu, KENTO.asagi, KENTO.ai, KENTO.fuji, KENTO.saku],
+  swatches: KENTO
+};
+var PAPER = {
+  name: "paper",
+  bg: KENTO.gofun,
+  ink: KENTO.sumi,
+  inkSoft: KENTO.stone,
+  line: KENTO.kinu,
+  accent: KENTO.sakuDeep,
+  accent2: KENTO.asagiDeep,
+  good: KENTO.matsuDeep,
+  warn: KENTO.kakiDeep,
+  ramp: [KENTO.sakuDeep, KENTO.kakiDeep, KENTO.koDeep, KENTO.matsuDeep, KENTO.asagiDeep, KENTO.aiDeep, KENTO.fujiDeep, KENTO.shuDeep],
+  swatches: KENTO
+};
+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 n5 = parseInt(h, 16);
+  return [n5 >> 16 & 255, n5 >> 8 & 255, n5 & 255];
+}
+function rgbToHex(r, g, b) {
+  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)
+  );
+}
+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, n5) {
+  if (n5 <= 0) return [];
+  if (n5 === 1) return [sampleGradient(stops, 0)];
+  return Array.from({ length: n5 }, (_, i) => sampleGradient(stops, i / (n5 - 1)));
+}
+
+// src/render/commands.ts
+var LAYER_WORLD = 0;
+var LAYER_LIGHT = 0.5;
+var LAYER_HUD = 1;
+function sortCommands(cmds) {
+  return cmds.map((c, i) => [c, i]).sort((a, b) => (a[0].layer ?? 0) - (b[0].layer ?? 0) || a[0].z - b[0].z || a[1] - b[1]).map(([c]) => c);
+}
+
+// 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/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/scene/shadow2d.ts
+function occludersFromTilemap(map) {
+  const grid = [];
+  for (let ty = 0; ty < map.rows; ty++) {
+    const row = [];
+    for (let tx = 0; tx < map.cols; tx++) row.push(tileAt(map, tx, ty) === TILE.SOLID);
+    grid.push(row);
+  }
+  return marchingSquaresContours(grid, { cell: map.tileSize });
+}
+function cullSegments(light, radius, segs) {
+  const out = [];
+  const r2 = radius * radius;
+  for (const s of segs) {
+    const dax = s.a.x - light.x;
+    const day = s.a.y - light.y;
+    const dbx = s.b.x - light.x;
+    const dby = s.b.y - light.y;
+    const da2 = dax * dax + day * day;
+    const db2 = dbx * dbx + dby * dby;
+    if (da2 <= r2 || db2 <= r2 || closestDist2(light, s) <= r2) out.push(s);
+  }
+  return out;
+}
+function closestDist2(p, s) {
+  const ex = s.b.x - s.a.x;
+  const ey = s.b.y - s.a.y;
+  const len2 = ex * ex + ey * ey;
+  if (len2 === 0) {
+    const dx2 = p.x - s.a.x;
+    const dy2 = p.y - s.a.y;
+    return dx2 * dx2 + dy2 * dy2;
+  }
+  let t = ((p.x - s.a.x) * ex + (p.y - s.a.y) * ey) / len2;
+  t = t < 0 ? 0 : t > 1 ? 1 : t;
+  const cx = s.a.x + ex * t;
+  const cy = s.a.y + ey * t;
+  const dx = p.x - cx;
+  const dy = p.y - cy;
+  return dx * dx + dy * dy;
+}
+function shadowQuads(light, radius, segs) {
+  const E = 2 * radius;
+  const quads = [];
+  for (const s of segs) {
+    const ax = s.a.x;
+    const ay = s.a.y;
+    const bx = s.b.x;
+    const by = s.b.y;
+    const adx = ax - light.x;
+    const ady = ay - light.y;
+    const bdx = bx - light.x;
+    const bdy = by - light.y;
+    const al = dhypot(adx, ady);
+    const bl = dhypot(bdx, bdy);
+    if (al === 0 || bl === 0) continue;
+    const aex = ax + adx / al * E;
+    const aey = ay + ady / al * E;
+    const bex = bx + bdx / bl * E;
+    const bey = by + bdy / bl * E;
+    quads.push([ax, ay, bx, by, bex, bey, aex, aey]);
+  }
+  return quads;
+}
+
+// src/scene/light.ts
+var PointLight = class extends Node {
+  type = "PointLight";
+  radius;
+  color;
+  intensity;
+  falloff;
+  flicker;
+  /** Current intensity after flicker — read by the LightLayer during draw. */
+  litIntensity;
+  rng;
+  phase = 0;
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+    this.radius = config.radius ?? 160;
+    this.color = config.color ?? "#ffe6b0";
+    this.intensity = config.intensity ?? 1;
+    this.falloff = config.falloff ?? 1;
+    this.flicker = config.flicker ?? { amount: 0, speed: 0 };
+    this.litIntensity = this.intensity;
+    this.rng = new Rng(config.seed ?? 43);
+  }
+  onProcess(dt) {
+    if (this.flicker.amount <= 0) {
+      this.litIntensity = this.intensity;
+      return;
+    }
+    this.phase += dt * this.flicker.speed;
+    const wobble = dsin(this.phase) * 0.5 + (this.rng.float() - 0.5);
+    const factor = 1 + wobble * this.flicker.amount;
+    this.litIntensity = Math.max(0, this.intensity * factor);
+  }
+  serializeProps() {
+    return {};
+  }
+};
+var LightLayer = class extends Node {
+  type = "LightLayer";
+  ambient;
+  softShadows;
+  width;
+  height;
+  occluders = [];
+  constructor(config = {}) {
+    super(config);
+    this.cosmetic = true;
+    this.ambient = {
+      color: config.ambient?.color ?? DUSK.bg,
+      level: config.ambient?.level ?? 0
+    };
+    this.softShadows = config.softShadows ?? false;
+    this.width = config.width ?? 1280;
+    this.height = config.height ?? 720;
+  }
+  /** Set the occluder edges (design-space segments) this layer casts shadows from. */
+  setOccluders(segs) {
+    this.occluders = segs;
+  }
+  draw(out, world) {
+    const ambientFill = this.ambient.level >= 1 ? "#ffffff" : mixLinear(this.ambient.color, "#ffffff", clamp012(this.ambient.level));
+    const ambient = {
+      kind: "rect",
+      x: 0,
+      y: 0,
+      w: this.width,
+      h: this.height,
+      fill: ambientFill,
+      blend: "multiply",
+      transform: IDENTITY,
+      z: 0,
+      layer: LAYER_LIGHT
+    };
+    out.push(ambient);
+    for (const child of this.children) {
+      if (!(child instanceof PointLight) || !child.visible) continue;
+      const lt = child.localTransform();
+      const lx = lt.e;
+      const ly = lt.f;
+      const radius = child.radius;
+      const intensity = Math.max(0, Math.min(1, child.litIntensity));
+      const tint = child.color;
+      const core = mixLinear("#000000", tint, intensity);
+      const mid = mixLinear("#000000", tint, intensity * 0.5);
+      const edge = "#000000";
+      const midStop = clamp012(0.6 / Math.max(0.01, child.falloff));
+      const pool = {
+        kind: "circle",
+        cx: lx,
+        cy: ly,
+        radius,
+        gradient: {
+          type: "radial",
+          cx: 0.5,
+          cy: 0.5,
+          r: 0.5,
+          stops: [
+            { offset: 0, color: core },
+            { offset: midStop, color: mid },
+            { offset: 1, color: edge }
+          ]
+        },
+        blend: "screen",
+        transform: world,
+        z: 0,
+        layer: LAYER_LIGHT
+      };
+      out.push(pool);
+      if (this.occluders.length) {
+        const culled = cullSegments({ x: lx, y: ly }, radius, this.occluders);
+        const quads = shadowQuads({ x: lx, y: ly }, radius, culled);
+        for (const q of quads) {
+          out.push(shadowPoly(q, ambientFill, world, 1));
+          if (this.softShadows) out.push(shadowPoly(expandQuad(q), ambientFill, world, 0.5));
+        }
+      }
+    }
+  }
+};
+var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function shadowPoly(points, fill, world, opacity) {
+  const c = {
+    kind: "poly",
+    points,
+    closed: true,
+    fill,
+    blend: "multiply",
+    transform: world,
+    z: 0,
+    layer: LAYER_LIGHT
+  };
+  if (opacity !== 1) c.opacity = opacity;
+  return c;
+}
+function expandQuad(q) {
+  const midNearX = (q[0] + q[2]) / 2;
+  const midNearY = (q[1] + q[3]) / 2;
+  const spread = (fx, fy) => {
+    const dx = fx - midNearX;
+    const dy = fy - midNearY;
+    const l = dhypot(dx, dy);
+    if (l === 0) return [fx, fy];
+    const px = -dy / l;
+    const py = dx / l;
+    const s = l * 0.08;
+    return [fx + px * s, fy + py * s];
+  };
+  const [aex, aey] = spread(q[6], q[7]);
+  const [bex, bey] = spread(q[4], q[5]);
+  return [q[0], q[1], q[2], q[3], bex, bey, aex, aey];
+}
+
 // src/scene/registry.ts
 var registry = /* @__PURE__ */ new Map();
 function registerNode(type, factory) {
@@ -1842,6 +3202,10 @@ registerNode("Text", () => new Text({ text: "" }));
 registerNode("Camera2D", () => new Camera2D());
 registerNode("Timer", () => new Timer({ duration: 1 }));
 registerNode("AnimationPlayer", () => new AnimationPlayer());
+registerNode("Bone2D", () => new Bone2D());
+registerNode("ClipPlayer", () => new ClipPlayer());
+registerNode("PointLight", () => new PointLight());
+registerNode("LightLayer", () => new LightLayer());
 function deserializeNode(data) {
   const factory = registry.get(data.type);
   if (!factory) throw new Error(`hayao: unknown node type "${data.type}" (register it first)`);
@@ -2306,49 +3670,6 @@ var DEFAULT_GAMEPAD_MAP = {
   15: "right"
 };
 
-// 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)];
@@ -3631,11 +4952,6 @@ function rayCastRigid(rw, x0, y0, x1, y1, mask = 65535) {
   return best;
 }
 
-// src/render/commands.ts
-function sortCommands(cmds) {
-  return cmds.map((c, i) => [c, i]).sort((a, b) => (a[0].layer ?? 0) - (b[0].layer ?? 0) || a[0].z - b[0].z || a[1] - b[1]).map(([c]) => c);
-}
-
 // src/render/paint.ts
 var n = (v) => Number.isInteger(v) ? String(v) : (Math.round(v * 1e3) / 1e3).toString();
 function toStops(stops) {
@@ -3745,6 +5061,41 @@ function canvasGradient(ctx, g, bbox) {
   return grad;
 }
 
+// src/render/lightRun.ts
+function splitByLightLayer(sorted) {
+  const below = [];
+  const light = [];
+  const above = [];
+  for (const c of sorted) {
+    const layer = c.layer ?? 0;
+    if (layer === LAYER_LIGHT) light.push(c);
+    else if (layer < LAYER_LIGHT) below.push(c);
+    else above.push(c);
+  }
+  return { below, light, above };
+}
+function parseLightRun(run) {
+  if (run.length === 0) return null;
+  const first = run[0];
+  if (first.kind !== "rect" || first.blend !== "multiply") return null;
+  const ambient = first;
+  const lights = [];
+  let i = 1;
+  while (i < run.length) {
+    const c = run[i];
+    if (c.kind !== "circle" || c.blend !== "screen") return null;
+    const light = { circle: c, shadows: [] };
+    i++;
+    while (i < run.length && run[i].kind === "poly" && run[i].blend === "multiply") {
+      light.shadows.push(run[i]);
+      i++;
+    }
+    lights.push(light);
+  }
+  return { ambient, lights };
+}
+var isLightCommand = (c) => (c.layer ?? 0) === LAYER_LIGHT;
+
 // src/render/renderer.ts
 function clientToDesign(rect, width, height, clientX, clientY) {
   const scale = Math.min(rect.width / width, rect.height / height) || 1;
@@ -3782,6 +5133,7 @@ function paintAttrs(p, fillOverride, filterId) {
   }
   if (p.opacity !== void 0 && p.opacity !== 1) parts.push(`opacity="${n2(p.opacity)}"`);
   if (filterId) parts.push(`filter="url(#${filterId})"`);
+  if (p.blend) parts.push(`style="mix-blend-mode:${p.blend}"`);
   return parts.join(" ");
 }
 function escapeText(s) {
@@ -3852,20 +5204,62 @@ function commandToSVG(c, defs, idBase) {
     }
   }
 }
-function commandsToSVGInner(commands, idPrefix = "h") {
+function polyPoints(p) {
+  const pts = [];
+  for (let i = 0; i < p.points.length; i += 2) pts.push(`${n2(p.points[i])},${n2(p.points[i + 1])}`);
+  return pts.join(" ");
+}
+function lightRunToSVG(parsed, defs, idPrefix, viewW, viewH) {
+  const a = parsed.ambient;
+  const ambientRect = `<rect x="${n2(a.x)}" y="${n2(a.y)}" width="${n2(a.w)}" height="${n2(a.h)}" transform="${matrix(a.transform)}" fill="${a.fill ?? "#000"}"/>`;
+  const groups = [];
+  parsed.lights.forEach((light, li) => {
+    const c = light.circle;
+    const gid = `${idPrefix}lg${li}`;
+    if (c.gradient) defs.push(gradientDef(c.gradient, gid));
+    const fill = c.gradient ? `url(#${gid})` : c.fill ?? "#fff";
+    const circle = `<circle cx="${n2(c.cx)}" cy="${n2(c.cy)}" r="${n2(c.radius)}" transform="${matrix(c.transform)}" fill="${fill}"/>`;
+    const mid = `${idPrefix}lm${li}`;
+    const shadowPolys = light.shadows.map((s) => {
+      const grey = s.opacity !== void 0 && s.opacity !== 1 ? Math.round((1 - s.opacity) * 255) : 0;
+      const shade = `#${grey.toString(16).padStart(2, "0").repeat(3)}`;
+      return `<polygon points="${polyPoints(s)}" transform="${matrix(s.transform)}" fill="${shade}"/>`;
+    }).join("");
+    if (light.shadows.length) {
+      defs.push(
+        `<mask id="${mid}"><rect x="0" y="0" width="${n2(viewW)}" height="${n2(viewH)}" fill="#ffffff"/>${shadowPolys}</mask>`
+      );
+      groups.push(`<g style="mix-blend-mode:screen" mask="url(#${mid})">${circle}</g>`);
+    } else {
+      groups.push(`<g style="mix-blend-mode:screen">${circle}</g>`);
+    }
+  });
+  return `<g style="mix-blend-mode:multiply; isolation:isolate">${ambientRect}${groups.join("")}</g>`;
+}
+function commandsToSVGInner(commands, idPrefix = "h", viewW = 1280, viewH = 720) {
   const defs = [];
-  const body = sortCommands(commands).map((c, i) => {
+  const sorted = sortCommands(commands);
+  const { below, light, above } = splitByLightLayer(sorted);
+  const parsed = light.length ? parseLightRun(light) : null;
+  const flatList = parsed ? [...below, ...above] : sorted;
+  const render = (list, offset) => list.map((c, i) => {
     const bad = invalidCommandReason(c);
     if (bad) {
       warnCommandOnce(c.kind, bad, c);
       return "";
     }
-    return commandToSVG(c, defs, `${idPrefix}${i}`);
+    return commandToSVG(c, defs, `${idPrefix}${offset + i}`);
   }).join("");
+  let body;
+  if (parsed) {
+    body = render(below, 0) + lightRunToSVG(parsed, defs, idPrefix, viewW, viewH) + render(above, below.length);
+  } else {
+    body = render(flatList, 0);
+  }
   return (defs.length ? `<defs>${defs.join("")}</defs>` : "") + body;
 }
 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>`;
+  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, "h", width, height) + `</svg>`;
 }
 
 // src/render/svg.ts
@@ -4028,36 +5422,123 @@ function paintCommand(ctx, c) {
       break;
   }
 }
+function paintOne(ctx, c) {
+  const bad = invalidCommandReason(c);
+  if (bad) {
+    warnCommandOnce(c.kind, bad, c);
+    return;
+  }
+  ctx.save();
+  try {
+    const t = c.transform;
+    ctx.transform(t.a, t.b, t.c, t.d, t.e, t.f);
+    ctx.globalAlpha = c.opacity ?? 1;
+    const sh = c.shadow;
+    if (sh) {
+      ctx.shadowColor = sh.color;
+      ctx.shadowBlur = sh.blur;
+      ctx.shadowOffsetX = sh.dx ?? 0;
+      ctx.shadowOffsetY = sh.dy ?? 0;
+    }
+    const dash = c.lineDash;
+    if (dash && dash.length) ctx.setLineDash(dash);
+    if (c.blend) ctx.globalCompositeOperation = c.blend;
+    paintCommand(ctx, c);
+  } catch (err) {
+    warnCommandOnce(c.kind, "paint threw", err);
+  }
+  ctx.restore();
+}
+var lightBufferCache = /* @__PURE__ */ new WeakMap();
+function makeCanvas(ctx, w, h) {
+  if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(w, h);
+  const doc = ctx.canvas.ownerDocument;
+  if (doc && typeof doc.createElement === "function") {
+    const el = doc.createElement("canvas");
+    el.width = w;
+    el.height = h;
+    return el;
+  }
+  return null;
+}
+function lightBuffers(ctx, w, h) {
+  const cached = lightBufferCache.get(ctx);
+  if (cached && cached.w === w && cached.h === h) return cached;
+  const buffer = makeCanvas(ctx, w, h);
+  const scratch = makeCanvas(ctx, w, h);
+  if (!buffer || !scratch) return null;
+  buffer.width = w;
+  buffer.height = h;
+  scratch.width = w;
+  scratch.height = h;
+  const bufs = { buffer, scratch, w, h };
+  lightBufferCache.set(ctx, bufs);
+  return bufs;
+}
+function compositeLightRun(ctx, parsed, width, height, scale) {
+  const w = Math.max(1, Math.round(width * scale));
+  const h = Math.max(1, Math.round(height * scale));
+  const bufs = lightBuffers(ctx, w, h);
+  if (!bufs) return false;
+  const bctx = bufs.buffer.getContext("2d");
+  const sctx = bufs.scratch.getContext("2d");
+  if (!bctx || !sctx) return false;
+  bctx.setTransform(1, 0, 0, 1, 0, 0);
+  bctx.globalCompositeOperation = "source-over";
+  bctx.clearRect(0, 0, w, h);
+  bctx.setTransform(scale, 0, 0, scale, 0, 0);
+  paintOne(bctx, { ...parsed.ambient, blend: void 0 });
+  for (const light of parsed.lights) {
+    sctx.setTransform(1, 0, 0, 1, 0, 0);
+    sctx.globalCompositeOperation = "source-over";
+    sctx.clearRect(0, 0, w, h);
+    sctx.setTransform(scale, 0, 0, scale, 0, 0);
+    paintOne(sctx, { ...light.circle, blend: void 0 });
+    for (const q of light.shadows) {
+      sctx.save();
+      const t = q.transform;
+      sctx.setTransform(scale, 0, 0, scale, 0, 0);
+      sctx.transform(t.a, t.b, t.c, t.d, t.e, t.f);
+      sctx.globalCompositeOperation = "destination-out";
+      sctx.globalAlpha = q.opacity ?? 1;
+      paintCommand(sctx, { ...q, blend: void 0, fill: "#000000" });
+      sctx.restore();
+    }
+    bctx.setTransform(1, 0, 0, 1, 0, 0);
+    bctx.globalCompositeOperation = "lighter";
+    bctx.globalAlpha = 1;
+    bctx.drawImage(bufs.scratch, 0, 0);
+  }
+  ctx.save();
+  ctx.setTransform(1, 0, 0, 1, 0, 0);
+  ctx.globalCompositeOperation = "multiply";
+  ctx.globalAlpha = 1;
+  ctx.drawImage(bufs.buffer, 0, 0);
+  ctx.restore();
+  ctx.setTransform(scale, 0, 0, scale, 0, 0);
+  ctx.globalCompositeOperation = "source-over";
+  return true;
+}
 function drawToCanvas2D(ctx, commands, width, height, background, scale) {
   ctx.setTransform(scale, 0, 0, scale, 0, 0);
+  ctx.globalCompositeOperation = "source-over";
   ctx.fillStyle = background;
   ctx.fillRect(0, 0, width, height);
-  for (const c of sortCommands(commands)) {
-    const bad = invalidCommandReason(c);
-    if (bad) {
-      warnCommandOnce(c.kind, bad, c);
-      continue;
+  const sorted = sortCommands(commands);
+  const { below, light, above } = splitByLightLayer(sorted);
+  for (const c of below) paintOne(ctx, c);
+  if (light.length) {
+    const parsed = parseLightRun(light);
+    const composited = parsed ? compositeLightRun(ctx, parsed, width, height, scale) : false;
+    if (!composited) {
+      ctx.setTransform(scale, 0, 0, scale, 0, 0);
+      for (const c of light) paintOne(ctx, c);
+      ctx.setTransform(scale, 0, 0, scale, 0, 0);
+      ctx.globalCompositeOperation = "source-over";
     }
-    ctx.save();
-    try {
-      const t = c.transform;
-      ctx.transform(t.a, t.b, t.c, t.d, t.e, t.f);
-      ctx.globalAlpha = c.opacity ?? 1;
-      const sh = c.shadow;
-      if (sh) {
-        ctx.shadowColor = sh.color;
-        ctx.shadowBlur = sh.blur;
-        ctx.shadowOffsetX = sh.dx ?? 0;
-        ctx.shadowOffsetY = sh.dy ?? 0;
-      }
-      const dash = c.lineDash;
-      if (dash && dash.length) ctx.setLineDash(dash);
-      paintCommand(ctx, c);
-    } catch (err) {
-      warnCommandOnce(c.kind, "paint threw", err);
-    }
-    ctx.restore();
   }
+  ctx.setTransform(scale, 0, 0, scale, 0, 0);
+  for (const c of above) paintOne(ctx, c);
 }
 
 // src/render/canvas.ts
@@ -4640,265 +6121,58 @@ var HeadlessRenderer = class {
   toSVGString() {
     return renderToSVGString(this.last, this.width, this.height, this.background);
   }
-};
-
-// 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 KENTO = {
-  // neutrals: light ground → dark ink, one continuous ramp
-  gofun: "#f7f1e2",
-  // 胡粉  shell-white, lightest paper
-  washi: "#efe7d3",
-  // 和紙  default light ground
-  kinu: "#e4d8bd",
-  //  絹    warm raised panel / card
-  line: "#d8cbac",
-  //  ─     hairline / grid on light
-  kinako: "#b9a882",
-  // 黄粉  tan mid-neutral / muted ink on dark
-  stone: "#6c6252",
-  // 石    secondary text on light (AA at body size)
-  sumiSoft: "#494133",
-  // 墨薄  body ink
-  sumi: "#23201a",
-  // 墨    primary ink / default dark-ish ground
-  kuro: "#181820",
-  // 玄    cool near-black ground for dark games
-  yohaku: "#12121a",
-  // 余白  deepest dark ground
-  darkLine: "#2c2c36",
-  //     hairline / grid on dark
-  // eight hues: `Deep` for light-mode fills, bright for dark-mode / emphasis
-  shuDeep: "#b23a24",
-  shu: "#d9583c",
-  //   朱  vermilion
-  kakiDeep: "#bf6a1c",
-  kaki: "#e79a49",
-  //  柿  persimmon / orange
-  koDeep: "#94741d",
-  ko: "#e3c054",
-  //     黄土 ochre-gold
-  matsuDeep: "#4a7a3a",
-  matsu: "#8bad52",
-  // 松葉 pine green
-  asagiDeep: "#2c7a90",
-  asagi: "#57bad2",
-  // 浅葱 teal-cyan
-  aiDeep: "#2b4257",
-  ai: "#5a86ad",
-  //     藍  indigo
-  fujiDeep: "#63548c",
-  fuji: "#a091cf",
-  //  藤  wisteria violet
-  sakuDeep: "#b0506e",
-  saku: "#e097ac"
-  //  桜  dusty rose
-};
-var MEADOW = {
-  name: "meadow",
-  bg: KENTO.washi,
-  ink: KENTO.sumi,
-  inkSoft: KENTO.sumiSoft,
-  line: KENTO.line,
-  accent: KENTO.shuDeep,
-  accent2: KENTO.aiDeep,
-  good: KENTO.matsuDeep,
-  warn: KENTO.kakiDeep,
-  // deep tones so categorical fills hold contrast on the light ground
-  ramp: [KENTO.shuDeep, KENTO.kakiDeep, KENTO.koDeep, KENTO.matsuDeep, KENTO.asagiDeep, KENTO.aiDeep, KENTO.fujiDeep, KENTO.sakuDeep],
-  swatches: KENTO
-};
-var DUSK = {
-  name: "dusk",
-  bg: KENTO.kuro,
-  ink: KENTO.gofun,
-  inkSoft: KENTO.kinako,
-  line: KENTO.darkLine,
-  accent: KENTO.shu,
-  accent2: KENTO.asagi,
-  good: KENTO.matsu,
-  warn: KENTO.ko,
-  // bright tones so categorical fills pop on the dark ground
-  ramp: [KENTO.shu, KENTO.kaki, KENTO.ko, KENTO.matsu, KENTO.asagi, KENTO.ai, KENTO.fuji, KENTO.saku],
-  swatches: KENTO
-};
-var PAPER = {
-  name: "paper",
-  bg: KENTO.gofun,
-  ink: KENTO.sumi,
-  inkSoft: KENTO.stone,
-  line: KENTO.kinu,
-  accent: KENTO.sakuDeep,
-  accent2: KENTO.asagiDeep,
-  good: KENTO.matsuDeep,
-  warn: KENTO.kakiDeep,
-  ramp: [KENTO.sakuDeep, KENTO.kakiDeep, KENTO.koDeep, KENTO.matsuDeep, KENTO.asagiDeep, KENTO.aiDeep, KENTO.fujiDeep, KENTO.shuDeep],
-  swatches: KENTO
-};
-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 n5 = parseInt(h, 16);
-  return [n5 >> 16 & 255, n5 >> 8 & 255, n5 & 255];
-}
-function rgbToHex(r, g, b) {
-  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)
-  );
-}
-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;
+};
+
+// 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 });
   };
-  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, n5) {
-  if (n5 <= 0) return [];
-  if (n5 === 1) return [sampleGradient(stops, 0)];
-  return Array.from({ length: n5 }, (_, i) => sampleGradient(stops, i / (n5 - 1)));
+  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/shapes.ts
 function regularPolygon(sides, radius, rotation = 0) {
@@ -5381,188 +6655,6 @@ var BitmapText = class extends Node {
   }
 };
 
-// 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) };
@@ -8714,6 +9806,41 @@ function telegraphIssues(timeline, minFrames, label = "threat") {
   }
   return dedupe(issues);
 }
+var litLuminance = (fill, level) => relLuminance(fill) * level;
+function lightingIssues(commands, avatarFill, avatarWorld, opts = {}) {
+  const minLit = opts.minLitLevel ?? 0.35;
+  const { light } = splitByLightLayer(sortCommands(commands));
+  const parsed = light.length ? parseLightRun(light) : null;
+  if (!parsed) return [];
+  let level = relLuminance(parsed.ambient.fill ?? "#000000");
+  for (const l of parsed.lights) {
+    const c = l.circle;
+    const p = applyTransform(invertTransform(c.transform), avatarWorld);
+    const d = dhypot(p.x - c.cx, p.y - c.cy);
+    if (d >= c.radius) continue;
+    const peak2 = poolPeak(c);
+    const reach = 1 - d / c.radius;
+    level = Math.min(1, level + peak2 * reach);
+  }
+  const issues = [];
+  if (level < minLit) {
+    const lum = litLuminance(avatarFill, level);
+    issues.push(
+      `avatar (${avatarFill}) sits in light level ${level.toFixed(2)} (needs \u2265 ${minLit}) \u2014 it sinks into the ambient darkness (effective luminance ${lum.toFixed(3)}); add a pool over it or raise ambient level`
+    );
+  }
+  return issues;
+}
+function poolPeak(c) {
+  const g = c.gradient;
+  if (g && g.stops.length) {
+    let max = 0;
+    for (const s of g.stops) max = Math.max(max, relLuminance(s.color));
+    return max;
+  }
+  const fill = c.fill;
+  return fill ? relLuminance(fill) : 1;
+}
 function cameraIssues(samples, opts = {}) {
   const dt = opts.dt ?? 1 / 60;
   const maxSpeed = opts.maxSpeed ?? 1800;
@@ -8755,6 +9882,11 @@ function runFeelGates(spec, ctx = {}) {
     if (ctx.commands) sections.push({ gate: "salience", issues: salienceIssues(ctx.commands, spec.avatarFill, bg) });
     else skipped.push("salience (no rendered frame)");
   }
+  if (spec.lit) {
+    if (spec.avatarFill && ctx.commands && ctx.avatarWorld) {
+      sections.push({ gate: "lighting", issues: lightingIssues(ctx.commands, spec.avatarFill, ctx.avatarWorld) });
+    } else skipped.push("lighting (needs avatarFill + rendered frame + avatarWorld)");
+  }
   if (spec.scrolls) {
     if (ctx.camSamples && ctx.camSamples.length >= 3) {
       const issues = cameraIssues(ctx.camSamples, { dt: ctx.dt });
@@ -12757,7 +13889,7 @@ function runStudio(baseDef, mount, opts = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.4.0";
+var VERSION = "0.4.1";
 export {
   ALBUM,
   AMBIENT_PRESETS,
@@ -12766,11 +13898,16 @@ export {
   AudioBus,
   BLOOM_PIPELINE,
   BitmapText,
+  Blend1D,
+  Blend2D,
+  Bone2D,
   BroadcastChannelTransport,
+  CLIP_CHANNELS,
   Camera2D,
   CameraController,
   Canvas2DRenderer,
   CinematicPlayer,
+  ClipPlayer,
   Clock,
   Coroutines,
   DEFAULT_GAMEPAD_MAP,
@@ -12793,12 +13930,17 @@ export {
   HeadlessRenderer,
   IDENTITY,
   INSTRUMENTS,
+  IkTarget,
   InputBuffer,
   InputRecorder,
   InputState,
   IsoPrism,
   KENTO,
   KeyboardSource,
+  LAYER_HUD,
+  LAYER_LIGHT,
+  LAYER_WORLD,
+  LightLayer,
   LocalStorageAdapter,
   LockstepSession,
   LoopbackHub,
@@ -12824,6 +13966,7 @@ export {
   PhaseClock,
   PixelBuffer,
   PlayerInput,
+  PointLight,
   PointerSource,
   RingBuffer,
   Rng,
@@ -12838,6 +13981,8 @@ export {
   Shaker,
   Shell,
   Signal,
+  Skeleton,
+  SkeletonDebug,
   SnapshotRing,
   SpatialHash,
   Sprite,
@@ -12863,6 +14008,7 @@ export {
   albumTrack,
   all,
   analyzePlaytest,
+  applyChannel,
   applyImpulse,
   applyReverb,
   applyTransform,
@@ -12880,10 +14026,12 @@ export {
   availableUpgrades,
   bandBalance,
   bfs,
+  blendIssues,
   blobPath,
   bodyAABB,
   bodyContains,
   bootDom,
+  buildSkeleton,
   cadenceResolves,
   cameraIssues,
   canvasGradient,
@@ -12896,6 +14044,10 @@ export {
   chordNotes,
   clamp,
   clientToDesign,
+  clipEvents,
+  clipFinished,
+  clipIssues,
+  clipTime,
   collide,
   commandsToSVGInner,
   composeCampaign,
@@ -12910,6 +14062,7 @@ export {
   createStereo,
   createWorld,
   crestFactorDb,
+  cullSegments,
   dashJumpDistance,
   datan,
   datan2,
@@ -12992,6 +14145,7 @@ export {
   invertTransform,
   isCaptureMode,
   isGround,
+  isLightCommand,
   isMonotonic,
   iso,
   joinRoom,
@@ -13010,6 +14164,7 @@ export {
   levelIssues,
   levelReachable,
   levelToTilemap,
+  lightingIssues,
   lineOfSight,
   linearGradient,
   lintSong,
@@ -13035,6 +14190,7 @@ export {
   mix,
   mixLinear,
   mixMono,
+  mixPose,
   moveRect,
   mutateColor,
   netMessage,
@@ -13042,11 +14198,13 @@ export {
   nineSlice,
   normalize,
   noteToMidi,
+  occludersFromTilemap,
   onsetDensity,
   openVoicing,
   packVarints,
   panFromOffset,
   panGains,
+  parseLightRun,
   parseRich,
   parseSnapshot,
   passableFromTilemap,
@@ -13062,6 +14220,7 @@ export {
   pointQuery,
   pollDirector,
   polygonBox,
+  poseKey,
   progression,
   progressionPuzzle,
   proveCompletable,
@@ -13097,6 +14256,7 @@ export {
   replaySession,
   resetNodeIds,
   resetZzfxWarnings,
+  resolveTracks,
   resolveTuning,
   rigidStep,
   rleDecode,
@@ -13110,7 +14270,10 @@ export {
   runHeadless,
   runStudio,
   salienceIssues,
+  sampleClip,
   sampleGradient,
+  samplePose,
+  sampleTrack,
   scaleMidis,
   scalePitchClasses,
   scatter,
@@ -13127,6 +14290,7 @@ export {
   settings,
   shadeHex,
   shadowDef,
+  shadowQuads,
   shapeBBox,
   shapeBox,
   showScreen,
@@ -13140,13 +14304,16 @@ export {
   softClipInPlace,
   solidNeighbours,
   solve,
+  solveFabrik,
   solveJoint,
+  solveTwoBoneIK,
   songBeats,
   songDuration,
   sortCommands,
   spatialMix,
   specFromZzfx,
   spectralCentroid,
+  splitByLightLayer,
   spring,
   springStep,
   star,