@energy8platform/golem 0.7.0 → 0.8.0

package/dist/lib/tool-schema.d.ts

@@ -1,3 +1,3 @@
 import type { ToolDef } from "./rig-api";
-/** draft-07, every ref inlined, no `$schema` key — the tool's own strict zod object, so unknown keys stay refused */
+/** draft 2020-12, every ref inlined, no `$schema` key — the tool's own strict zod object, so unknown keys stay refused */
 export declare function jsonSchemaOf(tool: ToolDef): Record<string, unknown>;

package/dist/lib/tools.js

@@ -293,7 +293,7 @@ var Key = z.object({
   /** Optional independent easing for numeric-array components (for example Spine RGBA curves). */
   componentEase: z.array(Ease).min(1).optional()
 });
-var Interpolation = { interpolation: z.enum(["segment", "pchip"]).optional() };
+var Interpolation = { interpolation: z.enum(["segment", "pchip", "spline"]).optional() };
 var Track = z.discriminatedUnion("target", [
   z.object({ target: z.literal("control"), id: Id, prop: z.literal("value"), ...Interpolation, keys: z.array(Key).min(1) }),
   z.object({ target: z.literal("bone"), id: Id, prop: BoneProp, ...Interpolation, keys: z.array(Key).min(1) }),
@@ -727,6 +727,57 @@ function smoothValue(track, i, t, component, loop) {
   const u = (t - k[i].t) / h(i), u2 = u * u, u3 = u2 * u;
   return (2 * u3 - 3 * u2 + 1) * v(i) + (u3 - 2 * u2 + u) * h(i) * tangent(i) + (-2 * u3 + 3 * u2) * v(i + 1) + (u3 - u2) * h(i) * tangent(i + 1);
 }
+function tridiagonal(a, b, c, r) {
+  const n = b.length, cp = [], x = [];
+  let beta = b[0];
+  x[0] = r[0] / beta;
+  for (let i = 1; i < n; i++) {
+    cp[i] = c[i - 1] / beta;
+    beta = b[i] - a[i] * cp[i];
+    x[i] = (r[i] - a[i] * x[i - 1]) / beta;
+  }
+  for (let i = n - 2; i >= 0; i--) x[i] -= cp[i + 1] * x[i + 1];
+  return x;
+}
+function splineMoments(t, v, periodic) {
+  const n = t.length, h = (j2) => t[j2 + 1] - t[j2], d = (j2) => (v[j2 + 1] - v[j2]) / h(j2);
+  if (!periodic) {
+    const a2 = [], b2 = [], c2 = [], r2 = [];
+    for (let i = 0; i < n; i++) {
+      const hp = i > 0 ? h(i - 1) : 0, hn = i < n - 1 ? h(i) : 0;
+      a2.push(hp);
+      b2.push(2 * (hp + hn));
+      c2.push(hn);
+      r2.push(6 * ((i < n - 1 ? d(i) : 0) - (i > 0 ? d(i - 1) : 0)));
+    }
+    return tridiagonal(a2, b2, c2, r2);
+  }
+  const m = n - 1, a = [], b = [], c = [], r = [];
+  for (let i = 0; i < m; i++) {
+    const p = (i + m - 1) % m;
+    a.push(h(p));
+    b.push(2 * (h(p) + h(i)));
+    c.push(h(i));
+    r.push(6 * (d(i) - d(p)));
+  }
+  const top = a[0], bottom = c[m - 1], gamma = -b[0];
+  const bb = [...b];
+  bb[0] -= gamma;
+  bb[m - 1] -= bottom * top / gamma;
+  const x = tridiagonal(a, bb, c, r), u = new Array(m).fill(0);
+  u[0] = gamma;
+  u[m - 1] = bottom;
+  const z4 = tridiagonal(a, bb, c, u);
+  const f = (x[0] + top * x[m - 1] / gamma) / (1 + z4[0] + top * z4[m - 1] / gamma);
+  const M = x.map((xi, i) => xi - f * z4[i]);
+  return [...M, M[0]];
+}
+function splineValue(track, i, t, component, loop) {
+  const k = track.keys, ts = k.map((x) => x.t), vs = k.map((x) => component === void 0 ? x.v : x.v[component]);
+  const M = splineMoments(ts, vs, loop && k.length > 3 && vs[0] === vs[k.length - 1]);
+  const H = ts[i + 1] - ts[i], A = (ts[i + 1] - t) / H, B = (t - ts[i]) / H;
+  return A * vs[i] + B * vs[i + 1] + ((A ** 3 - A) * M[i] + (B ** 3 - B) * M[i + 1]) * H * H / 6;
+}
 function sample(track, t, loop = false) {
   const keys = track.keys;
   if (t <= keys[0].t) return keys[0].v;
@@ -738,11 +789,13 @@ function sample(track, t, loop = false) {
   if (a.ease === "step") return a.v;
   if (typeof a.v === "number" && typeof b.v === "number") {
     if (track.interpolation === "pchip") return smoothValue(track, i, t, void 0, loop);
+    if (track.interpolation === "spline") return splineValue(track, i, t, void 0, loop);
     const u = ease(a.ease)((t - a.t) / (b.t - a.t));
     return a.v + (b.v - a.v) * u;
   }
   if (Array.isArray(a.v) && Array.isArray(b.v) && typeof a.v[0] === "number") {
     if (track.interpolation === "pchip") return a.v.map((_, j2) => smoothValue(track, i, t, j2, loop));
+    if (track.interpolation === "spline") return a.v.map((_, j2) => splineValue(track, i, t, j2, loop));
     const phase = (t - a.t) / (b.t - a.t), av = a.v, bv = b.v;
     return av.map((v, k) => v + ((bv[k] ?? v) - v) * ease(a.componentEase?.[k] ?? a.ease)(phase));
   }
@@ -2474,7 +2527,8 @@ function adjustTrack(doc, animId, track, adj) {
     return { ...k, t: r42(adj.timeScale ? k.t * adj.timeScale : k.t), v: r42(v) };
   });
   const duration = Math.max(anim.duration, keys[keys.length - 1].t);
-  const next = { ...anim, duration, tracks: anim.tracks.map((t) => same(t) ? { ...t, keys } : t), preset: void 0 };
+  const interpolation = track.interpolation ?? tr.interpolation;
+  const next = { ...anim, duration, tracks: anim.tracks.map((t) => same(t) ? { ...t, keys, ...interpolation && { interpolation } } : t), preset: void 0 };
   return { ...doc, animations: doc.animations.map((a) => a.id === animId ? next : a) };
 }
 function removeAnimation(doc, id) {
@@ -2891,19 +2945,20 @@ var requireSlot = (doc, id) => {
   if (!s) throw new Error(`unknown slot "${id}"`);
   return s;
 };
-function sampled(duration, n, f, ease2 = "linear") {
+function sampled(duration, n, f) {
   const keys = [];
   for (let i = 0; i <= n; i++) {
     const t = +(duration * i / n).toFixed(4);
-    keys.push({ t, v: +f(t).toFixed(4) + 0, ease: ease2 });
+    keys.push({ t, v: +f(t).toFixed(4) + 0, ease: "linear" });
   }
   return keys;
 }
-function boneTrack(bone, prop, keys) {
-  return { target: "bone", id: bone.id, prop, keys };
+var smooth = "spline";
+function boneTrack(bone, prop, keys, interpolation) {
+  return { target: "bone", id: bone.id, prop, keys, ...interpolation && { interpolation } };
 }
-function deformTrack(slot, prop, keys) {
-  return slot.attachment ? { target: "deform", id: slot.attachment, prop, keys } : void 0;
+function deformTrack(slot, prop, keys, interpolation) {
+  return slot.attachment ? { target: "deform", id: slot.attachment, prop, keys, ...interpolation && { interpolation } } : void 0;
 }
 var pushTrack = (tracks, t) => {
   if (t) tracks.push(t);
@@ -2927,18 +2982,18 @@ var idleBreathing = {
     const armsR = byRole(doc, "arm_r", "arm_upper_r");
     const chest = slotOfBone(doc, torso);
     if (chest?.attachment) {
-      pushTrack(tracks, deformTrack(chest, "bulge", sampled(T2, 8, (t) => p.amplitude * Math.sin(w * t), "ease_in_out")));
+      pushTrack(tracks, deformTrack(chest, "bulge", sampled(T2, 8, (t) => p.amplitude * Math.sin(w * t)), smooth));
     } else {
       const r = torso.transform;
-      tracks.push(boneTrack(torso, "scaleY", sampled(T2, 8, (t) => r.scaleY + p.amplitude * Math.sin(w * t), "ease_in_out")));
-      tracks.push(boneTrack(torso, "scaleX", sampled(T2, 8, (t) => r.scaleX - p.amplitude * 0.4 * Math.sin(w * t), "ease_in_out")));
+      tracks.push(boneTrack(torso, "scaleY", sampled(T2, 8, (t) => r.scaleY + p.amplitude * Math.sin(w * t)), smooth));
+      tracks.push(boneTrack(torso, "scaleX", sampled(T2, 8, (t) => r.scaleX - p.amplitude * 0.4 * Math.sin(w * t)), smooth));
     }
     for (const h of heads)
-      tracks.push(boneTrack(h, "y", sampled(T2, 8, (t) => h.transform.y - p.headBob * Math.sin(w * t + 0.4), "ease_in_out")));
+      tracks.push(boneTrack(h, "y", sampled(T2, 8, (t) => h.transform.y - p.headBob * Math.sin(w * t + 0.4)), smooth));
     for (const a of armsL)
-      tracks.push(boneTrack(a, "rotation", sampled(T2, 8, (t) => a.transform.rotation + p.armSway * Math.sin(w * t + 0.8), "ease_in_out")));
+      tracks.push(boneTrack(a, "rotation", sampled(T2, 8, (t) => a.transform.rotation + p.armSway * Math.sin(w * t + 0.8)), smooth));
     for (const a of armsR)
-      tracks.push(boneTrack(a, "rotation", sampled(T2, 8, (t) => a.transform.rotation - p.armSway * Math.sin(w * t + 0.8), "ease_in_out")));
+      tracks.push(boneTrack(a, "rotation", sampled(T2, 8, (t) => a.transform.rotation - p.armSway * Math.sin(w * t + 0.8)), smooth));
     return finish(this.name, p.id, T2, true, tracks, p);
   }
 };
@@ -2947,22 +3002,20 @@ var winBounce = {
   defaults: { id: "win", duration: 1.2, height: 40, bounces: 2, squash: 0.15 },
   build(doc, p) {
     const b = root(doc), r = b.transform, tracks = [];
-    const yK = [[0, r.y, "ease_out"]];
-    const sxK = [[0, r.scaleX, "ease_out"]];
-    const syK = [[0, r.scaleY, "ease_out"]];
+    const yK = [[0, r.y]], sxK = [[0, r.scaleX]], syK = [[0, r.scaleY]];
     const per = p.duration / p.bounces;
     for (let i = 0; i < p.bounces; i++) {
       const t0 = i * per, h = p.height * 0.55 ** i, s = p.squash * 0.7 ** i;
-      sxK.push([t0 + per * 0.08, r.scaleX * (1 + s), "ease_out"], [t0 + per * 0.5, r.scaleX * (1 - s * 0.6), "ease_in"], [t0 + per * 0.95, r.scaleX * (1 + s), "ease_out"]);
-      syK.push([t0 + per * 0.08, r.scaleY * (1 - s), "ease_out"], [t0 + per * 0.5, r.scaleY * (1 + s * 0.6), "ease_in"], [t0 + per * 0.95, r.scaleY * (1 - s), "ease_out"]);
-      yK.push([t0 + per * 0.08, r.y, "ease_out"], [t0 + per * 0.5, r.y - h, "ease_in"], [t0 + per * 0.95, r.y, "ease_out"]);
+      sxK.push([t0 + per * 0.08, r.scaleX * (1 + s)], [t0 + per * 0.5, r.scaleX * (1 - s * 0.6)], [t0 + per * 0.95, r.scaleX * (1 + s)]);
+      syK.push([t0 + per * 0.08, r.scaleY * (1 - s)], [t0 + per * 0.5, r.scaleY * (1 + s * 0.6)], [t0 + per * 0.95, r.scaleY * (1 - s)]);
+      yK.push([t0 + per * 0.08, r.y], [t0 + per * 0.5, r.y - h], [t0 + per * 0.95, r.y]);
     }
     yK.push([p.duration, r.y]);
     sxK.push([p.duration, r.scaleX]);
     syK.push([p.duration, r.scaleY]);
-    tracks.push(boneTrack(b, "y", K(...yK)), boneTrack(b, "scaleX", K(...sxK)), boneTrack(b, "scaleY", K(...syK)));
+    tracks.push(boneTrack(b, "y", K(...yK), "pchip"), boneTrack(b, "scaleX", K(...sxK), smooth), boneTrack(b, "scaleY", K(...syK), smooth));
     for (const h of byRole(doc, "head"))
-      tracks.push(boneTrack(h, "rotation", K([0, h.transform.rotation], [p.duration * 0.25, h.transform.rotation - 6, "back_out"], [p.duration * 0.6, h.transform.rotation + 4], [p.duration, h.transform.rotation])));
+      tracks.push(boneTrack(h, "rotation", K([0, h.transform.rotation], [p.duration * 0.25, h.transform.rotation - 6], [p.duration * 0.6, h.transform.rotation + 4], [p.duration, h.transform.rotation]), smooth));
     const anim = finish(this.name, p.id, p.duration, false, tracks, p);
     anim.events.push({ t: 0, name: "win_start" }, { t: per * 0.95, name: "land" });
     return anim;
@@ -2975,8 +3028,8 @@ var anticipationShake = {
     const b = root(doc), r = b.transform, tracks = [];
     const n = Math.ceil(p.duration * p.frequency * 4);
     const env = (t) => p.grow ? t / p.duration : 1;
-    tracks.push(boneTrack(b, "x", sampled(p.duration, n, (t) => r.x + p.amplitude * env(t) * Math.sin(2 * Math.PI * p.frequency * t), "linear")));
-    tracks.push(boneTrack(b, "rotation", sampled(p.duration, n, (t) => r.rotation + 0.6 * p.amplitude * env(t) * Math.sin(2 * Math.PI * p.frequency * t + 1.2), "linear")));
+    tracks.push(boneTrack(b, "x", sampled(p.duration, n, (t) => r.x + p.amplitude * env(t) * Math.sin(2 * Math.PI * p.frequency * t)), smooth));
+    tracks.push(boneTrack(b, "rotation", sampled(p.duration, n, (t) => r.rotation + 0.6 * p.amplitude * env(t) * Math.sin(2 * Math.PI * p.frequency * t + 1.2)), smooth));
     tracks.push(boneTrack(b, "scaleX", K([0, r.scaleX, "ease_in"], [p.duration, r.scaleX * p.scaleUp])));
     tracks.push(boneTrack(b, "scaleY", K([0, r.scaleY, "ease_in"], [p.duration, r.scaleY * p.scaleUp])));
     return finish(this.name, p.id, p.duration, false, tracks, p);
@@ -3001,6 +3054,7 @@ var mouthTalk = {
     if (!p.frames.length) throw new Error("mouth_talk: frames must not be empty");
     const n = Math.max(1, Math.round(p.duration * p.rate));
     const keys = S(...Array.from({ length: n }, (_, i) => [+(i / p.rate).toFixed(4), p.frames[i % p.frames.length]]));
+    if (keys.at(-1).t < p.duration && keys.at(-1).v !== keys[0].v) keys.push(...S([p.duration, keys[0].v]));
     return finish(this.name, p.id, p.duration, true, [slotTrack(slot, "attachment", keys)], p);
   }
 };
@@ -3018,10 +3072,10 @@ var symbolIdle = {
   build(doc, p) {
     const b = root(doc), r = b.transform, T2 = p.period, w = 2 * Math.PI / T2, tracks = [];
     const rise = (t) => 0.5 - 0.5 * Math.cos(w * t);
-    tracks.push(boneTrack(b, "y", sampled(T2, 8, (t) => r.y - p.float * rise(t), "ease_in_out")));
-    if (p.tilt) tracks.push(boneTrack(b, "rotation", sampled(T2, 8, (t) => r.rotation + p.tilt * Math.sin(w * t), "ease_in_out")));
+    tracks.push(boneTrack(b, "y", sampled(T2, 8, (t) => r.y - p.float * rise(t)), smooth));
+    if (p.tilt) tracks.push(boneTrack(b, "rotation", sampled(T2, 8, (t) => r.rotation + p.tilt * Math.sin(w * t)), smooth));
     if (p.pulse) for (const s of doc.slots.filter((s2) => s2.bone === b.id && s2.attachment))
-      pushTrack(tracks, deformTrack(s, "bulge", sampled(T2, 8, (t) => p.pulse * rise(t), "ease_in_out")));
+      pushTrack(tracks, deformTrack(s, "bulge", sampled(T2, 8, (t) => p.pulse * rise(t)), smooth));
     return finish(this.name, p.id, T2, true, tracks, p);
   }
 };
@@ -3031,12 +3085,12 @@ var symbolWin = {
   build(doc, p) {
     const b = root(doc), r = b.transform, d = p.duration, tracks = [];
     for (const [prop, rest] of [["scaleX", r.scaleX], ["scaleY", r.scaleY]])
-      tracks.push(boneTrack(b, prop, K([0, rest, "ease_out"], [d * 0.2, rest * (1 + p.pop), "ease_in_out"], [d * 0.5, rest * (1 - p.pop * 0.3), "ease_out"], [d, rest])));
+      tracks.push(boneTrack(b, prop, K([0, rest], [d * 0.2, rest * (1 + p.pop)], [d * 0.5, rest * (1 - p.pop * 0.3)], [d, rest]), smooth));
     if (p.wobble) {
       const n = Math.max(8, p.wobbles * 4);
-      const keys = sampled(d, n, (t) => p.wobble * Math.exp(-3 * t / d) * Math.sin(2 * Math.PI * p.wobbles * t / d), "ease_in_out");
+      const keys = sampled(d, n, (t) => p.wobble * Math.exp(-3 * t / d) * Math.sin(2 * Math.PI * p.wobbles * t / d));
       keys[keys.length - 1].v = 0;
-      for (const s of doc.slots.filter((s2) => s2.bone === b.id && s2.attachment)) pushTrack(tracks, deformTrack(s, "sway", keys));
+      for (const s of doc.slots.filter((s2) => s2.bone === b.id && s2.attachment)) pushTrack(tracks, deformTrack(s, "sway", keys, smooth));
     }
     const anim = finish(this.name, p.id, d, false, tracks, p);
     anim.events.push({ t: 0, name: "win_start" });
@@ -3050,11 +3104,11 @@ var weightShift = {
     const T2 = p.period, w = 2 * Math.PI / T2, N = 16, tracks = [];
     const hips = byRole(doc, "hips")[0] ?? root(doc), hr = hips.transform;
     const s = (t) => Math.sin(w * t);
-    tracks.push(boneTrack(hips, "x", sampled(T2, N, (t) => hr.x + p.shift * s(t))));
-    if (p.dip) tracks.push(boneTrack(hips, "y", sampled(T2, N, (t) => hr.y + p.dip * s(t) ** 2)));
+    tracks.push(boneTrack(hips, "x", sampled(T2, N, (t) => hr.x + p.shift * s(t)), smooth));
+    if (p.dip) tracks.push(boneTrack(hips, "y", sampled(T2, N, (t) => hr.y + p.dip * s(t) ** 2), smooth));
     const torso = byRole(doc, "torso", "body")[0];
-    if (torso && torso !== hips) tracks.push(boneTrack(torso, "rotation", sampled(T2, N, (t) => torso.transform.rotation - p.lean * s(t))));
-    for (const h of byRole(doc, "head")) tracks.push(boneTrack(h, "rotation", sampled(T2, N, (t) => h.transform.rotation + p.lean / 2 * s(t))));
+    if (torso && torso !== hips) tracks.push(boneTrack(torso, "rotation", sampled(T2, N, (t) => torso.transform.rotation - p.lean * s(t)), smooth));
+    for (const h of byRole(doc, "head")) tracks.push(boneTrack(h, "rotation", sampled(T2, N, (t) => h.transform.rotation + p.lean / 2 * s(t)), smooth));
     for (const leg of byRole(doc, "leg_l", "leg_r")) {
       const slot = slotOfBone(doc, leg), att = slot && doc.attachments.find((a) => a.id === slot.attachment && a.type === "region");
       const asset = att && att.type === "region" ? doc.assets.find((a) => a.id === att.asset) : void 0;
@@ -3064,8 +3118,8 @@ var weightShift = {
         length = Math.max(...[[0, -h / 2], [w2 / 2, 0], [0, h / 2], [-w2 / 2, 0]].map(([x, y]) => Math.hypot(...apply(m, x, y))));
       }
       if (!(length > p.shift)) continue;
-      tracks.push(boneTrack(leg, "rotation", sampled(T2, N, (t) => leg.transform.rotation + Math.asin(p.shift * s(t) / length) * 180 / Math.PI)));
-      if (p.dip) tracks.push(boneTrack(leg, "y", sampled(T2, N, (t) => leg.transform.y - p.dip * s(t) ** 2)));
+      tracks.push(boneTrack(leg, "rotation", sampled(T2, N, (t) => leg.transform.rotation + Math.asin(p.shift * s(t) / length) * 180 / Math.PI), smooth));
+      if (p.dip) tracks.push(boneTrack(leg, "y", sampled(T2, N, (t) => leg.transform.y - p.dip * s(t) ** 2), smooth));
     }
     return finish(this.name, p.id, T2, true, tracks, p);
   }
@@ -3308,13 +3362,13 @@ function motionQuality(doc, anim, opts = {}) {
       const before = delta(values(k.v), values(p.v)), after = delta(values(n.v), values(k.v));
       const pass = before.some((v, j2) => v * after[j2] > 1e-6);
       const speed = Math.max(magnitude(before) / (k.t - p.t), magnitude(after) / (n.t - k.t));
-      if (pass && Math.max(magnitude(left), magnitude(right)) < speed * 0.02) report("pass_key_stop", id, `motion stops at a pass-through key; use track interpolation pchip or matched tangents`, k.t);
+      if (pass && Math.max(magnitude(left), magnitude(right)) < speed * 0.02) report("pass_key_stop", id, `motion stops at a pass-through key; use track interpolation pchip or spline, or matched tangents`, k.t);
       const jump = magnitude(delta(left, right));
       if (jump > Math.max(0.1, speed * 0.1)) report("velocity_jump", id, `velocity jumps ${jump.toFixed(3)} units/s across this key`, k.t);
       const acceleration = (a, b, c) => values(at(b)).map((v, j2) => (values(at(c))[j2] - 2 * v + values(at(a))[j2]) / (h * h));
       const al = acceleration(k.t - 2 * h, k.t - h, k.t), ar = acceleration(k.t, k.t + h, k.t + 2 * h);
       const aj = magnitude(delta(al, ar));
-      if (aj > Math.max(1, speed / Math.min(k.t - p.t, n.t - k.t) * 2)) report("acceleration_jump", id, `acceleration changes by ${aj.toFixed(2)} units/s\xB2 at this key; PCHIP guarantees velocity, not acceleration continuity`, k.t, "info");
+      if (aj > Math.max(1, speed / Math.min(k.t - p.t, n.t - k.t) * 2)) report("acceleration_jump", id, `acceleration changes by ${aj.toFixed(2)} units/s\xB2 at this key; PCHIP guarantees velocity, not acceleration continuity \u2014 spline does both`, k.t, "info");
     }
   }
   const steps = Math.max(2, Math.ceil(D * 60));
@@ -3796,6 +3850,17 @@ function checkRig(doc, opts = {}) {
     out.push({ level: "warn", code: "never_visible", subject: s.id, message: `slot "${s.id}" has no attachment and no animation ever shows one` });
   return out;
 }
+function summarizeIgnoring(findings, rules, max) {
+  const hits = (r, f) => r.code === f.code && (r.subject ?? f.subject) === f.subject && (r.animation ?? f.animation) === f.animation;
+  const kept = findings.filter((f) => !rules.some((r) => hits(r, f)));
+  const idle = rules.filter((r) => !findings.some((f) => hits(r, f)));
+  const notes = [
+    ...kept.length < findings.length ? [`  (${findings.length - kept.length} ignored)`] : [],
+    ...idle.map((r) => `  ignore matched nothing: ${JSON.stringify(r)}`)
+  ];
+  return [summarize(kept, max), ...notes].join("\n");
+}
+var where = (f) => `${f.subject}${f.animation ? ` in ${f.animation}` : ""}${f.time !== void 0 ? ` @${+f.time.toFixed(4)}s` : ""}`;
 function summarize(findings, max = 12) {
   if (!findings.length) return "check: OK";
   const rank = { error: 0, warn: 1, info: 2 };
@@ -3810,7 +3875,7 @@ function summarize(findings, max = 12) {
   const lines = [];
   for (const f of sorted) {
     const shown = shownPerCode.get(f.code) ?? 0;
-    if (shown < PER_CODE) lines.push(`  [${f.level}] ${f.code}: ${f.message}`);
+    if (shown < PER_CODE) lines.push(`  [${f.level}] ${f.code} ${where(f)}: ${f.message}`);
     else if (shown === PER_CODE) lines.push(`  \u2026 ${codeTotal.get(f.code) - PER_CODE} more ${f.code}`);
     shownPerCode.set(f.code, shown + 1);
   }
@@ -4001,7 +4066,7 @@ function packRects(rects, opts = {}) {
       shelf = Math.max(shelf, r.height);
     }
     const height = y + shelf + pad;
-    if (height <= max) return { width, height, frames };
+    if (height <= max) return { width: Math.max(pad, ...[...frames.values()].map(([fx, , fw]) => fx + fw)) + pad, height, frames };
     if (width >= max) throw new Error(`atlas does not fit in ${max}\xD7${max} (needs ${width}\xD7${height})`);
     width *= 2;
   }
@@ -5608,7 +5673,8 @@ function previewCheck(doc, animation) {
   const a = animation ? doc.animations.find((x) => x.id === animation) : void 0;
   return a ? `check: OK for "${a.id}" (${a.tracks.length} tracks, ${a.duration}s${a.loop ? " loop" : ""})` : "check: OK (rest pose)";
 }
-var TrackRef = { interpolation: z3.enum(["segment", "pchip"]).optional().describe("pchip: smooth through numeric keys, preserving extrema; segment: per-key easing"), target: z3.enum(["bone", "slot", "deform", "ik", "transform", "path", "drawOrder", "control"]), id: z3.string(), prop: z3.string() };
+var TrackId = { target: z3.enum(["bone", "slot", "deform", "ik", "transform", "path", "drawOrder", "control"]), id: z3.string(), prop: z3.string() };
+var TrackRef = { interpolation: z3.enum(["segment", "pchip", "spline"]).optional().describe("segment: per-key easing; pchip: smooth through numeric keys, never past them (continuous velocity); spline: C2 cubic through them, continuous acceleration too, may overshoot between keys \u2014 for sampled curves"), ...TrackId };
 tool(
   "rig_set_control",
   "Create or replace a semantic control with a finite min/max/default range. Animate target=control, prop=value. Changing a range requires matching binding grids.",
@@ -5801,11 +5867,21 @@ tool(
 );
 tool(
   "rig_check",
-  "Cheap self-critique without rendering: out_of_canvas (slot leaves the canvas, worst time), static_track, loop_seam, deform_flip (lattice folds over itself \u2014 an error), mesh_fold (a skinned/deformed mesh folds over itself: error when \u2265 5 % of the mesh folds, warning below \u2014 a dense mesh bent hard at a joint pinches the odd hairline triangle), weights_sum (skinned mesh vertex weights not summing to 1), patch_offset (a slot sits away from its asset's source bbox), rest_overlap, unused_asset, never_visible, and for constraints: constraint_dead (every mix is 0 at rest and no track lifts one \u2014 the solver skips it), constraint_cycle (the target is a bone the constraint drives, or hangs off one: it reads what it writes \u2014 an error), ik_unreachable (the target sits beyond the chain's reach for over 20 % of an animation, so the limb hangs straight), path_missing (a path constraint whose target slot never shows a path attachment \u2014 an error). Motion diagnostics also cover pass_key_stop, velocity_jump, acceleration_jump, loop_velocity and constraint_order; provide secondaryBones, frontOf slot pairs and named attachment UV landmarks for brief-specific frozen-motion, ordering and swap-registration checks. Findings are sorted by severity. Run it before spending vision tokens on a preview.",
-  { path: Path, animation: z3.string().optional().describe("limit to one animation (rest pose is always checked)"), fps: z3.number().positive().optional(), deformFps: z3.number().positive().optional(), secondaryBones: z3.array(z3.string()).optional(), frontOf: z3.array(z3.tuple([z3.string(), z3.string()])).optional(), landmarks: z3.record(z3.record(z3.tuple([z3.number(), z3.number()]))).optional(), landmarkTolerance: z3.number().nonnegative().optional() },
-  async ({ path, ...opts }) => {
+  "Cheap self-critique without rendering: out_of_canvas (slot leaves the canvas, worst time), static_track, loop_seam, deform_flip (lattice folds over itself \u2014 an error), mesh_fold (a skinned/deformed mesh folds over itself: error when \u2265 5 % of the mesh folds, warning below \u2014 a dense mesh bent hard at a joint pinches the odd hairline triangle), weights_sum (skinned mesh vertex weights not summing to 1), patch_offset (a slot sits away from its asset's source bbox), rest_overlap, unused_asset, never_visible, and for constraints: constraint_dead (every mix is 0 at rest and no track lifts one \u2014 the solver skips it), constraint_cycle (the target is a bone the constraint drives, or hangs off one: it reads what it writes \u2014 an error), ik_unreachable (the target sits beyond the chain's reach for over 20 % of an animation, so the limb hangs straight), path_missing (a path constraint whose target slot never shows a path attachment \u2014 an error). Motion diagnostics also cover pass_key_stop, velocity_jump, acceleration_jump, loop_velocity and constraint_order; provide secondaryBones, frontOf slot pairs and named attachment UV landmarks for brief-specific frozen-motion, ordering and swap-registration checks. Findings are sorted by severity; each line names its subject (a track as target.id.prop), animation and time. `ignore` drops findings you have read and accept \u2014 by code, narrowed by subject and animation; the reply counts them and names a rule that matched nothing. Run it before spending vision tokens on a preview.",
+  {
+    path: Path,
+    animation: z3.string().optional().describe("limit to one animation (rest pose is always checked)"),
+    fps: z3.number().positive().optional(),
+    deformFps: z3.number().positive().optional(),
+    secondaryBones: z3.array(z3.string()).optional(),
+    frontOf: z3.array(z3.tuple([z3.string(), z3.string()])).optional(),
+    landmarks: z3.record(z3.record(z3.tuple([z3.number(), z3.number()]))).optional(),
+    landmarkTolerance: z3.number().nonnegative().optional(),
+    ignore: z3.array(z3.object({ code: z3.string(), subject: z3.string().optional(), animation: z3.string().optional() }).strict()).optional()
+  },
+  async ({ path, ignore = [], ...opts }) => {
     try {
-      return text(summarize(checkRig(await load(path), opts), 100));
+      return text(summarizeIgnoring(checkRig(await load(path), opts), ignore, 100));
     } catch (e) {
       return fail(e);
     }
@@ -6422,9 +6498,9 @@ tool(
 );
 tool(
   "rig_adjust_track",
-  "Re-tune an existing track without retyping keys: amplitude scales its deviation from the rest value (0.5 = half as strong, 2 = twice; scale props as ratios), offset adds a constant, timeScale stretches its key times (duration grows to fit). Drops the preset link.",
+  "Re-tune an existing track without retyping keys: amplitude scales its deviation from the rest value (0.5 = half as strong, 2 = twice; scale props as ratios), offset adds a constant, timeScale stretches its key times (duration grows to fit), interpolation switches segment / pchip / spline. Drops the preset link.",
   { path: Path, animation: z3.string(), ...TrackRef, amplitude: z3.number().optional(), offset: z3.number().optional(), timeScale: z3.number().positive().optional() },
-  async ({ path, animation, target, id, prop, ...adj }) => mutate(path, (d) => adjustTrack(d, animation, { target, id, prop }, adj))
+  async ({ path, animation, target, id, prop, interpolation, ...adj }) => mutate(path, (d) => adjustTrack(d, animation, { target, id, prop, interpolation }, adj))
 );
 tool(
   "rig_set_animation",
@@ -6442,7 +6518,7 @@ tool(
 tool(
   "rig_remove_keys",
   "Remove the keys of one track at the given times; an emptied track is dropped. Drops the preset link.",
-  { path: Path, animation: z3.string(), ...TrackRef, times: z3.array(z3.number()).min(1) },
+  { path: Path, animation: z3.string(), ...TrackId, times: z3.array(z3.number()).min(1) },
   async ({ path, animation, target, id, prop, times: times2 }) => mutate(path, (d) => removeKeys(d, animation, { target, id, prop }, times2))
 );
 tool(
@@ -6620,9 +6696,15 @@ async function callToolVersioned(name, args) {
 
 // src/tool-schema.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
+function prefixItems(node) {
+  if (Array.isArray(node)) return node.map(prefixItems);
+  if (!node || typeof node !== "object") return node;
+  const { items, ...rest } = Object.fromEntries(Object.entries(node).map(([k, v]) => [k, prefixItems(v)]));
+  return items === void 0 ? rest : Array.isArray(items) ? { ...rest, prefixItems: items } : { ...rest, items };
+}
 function jsonSchemaOf(tool2) {
   const { $schema: _drop, ...schema } = zodToJsonSchema(tool2.input, { $refStrategy: "none" });
-  return schema;
+  return prefixItems(schema);
 }
 export {
   callTool,