@energy8platform/golem 0.2.0 → 0.3.0

package/dist/editor.js

@@ -2177,8 +2177,8 @@ var init_Matrix = __esm({
         const pivot = transform.pivot;
         const skewX = -Math.atan2(-c5, d5);
         const skewY = Math.atan2(b4, a5);
-        const delta = Math.abs(skewX + skewY);
-        if (delta < 1e-5 || Math.abs(PI_2 - delta) < 1e-5) {
+        const delta2 = Math.abs(skewX + skewY);
+        if (delta2 < 1e-5 || Math.abs(PI_2 - delta2) < 1e-5) {
           transform.rotation = skewY;
           transform.skew.x = transform.skew.y = 0;
         } else {
@@ -8294,11 +8294,11 @@ var init_Ticker = __esm({
           }
           elapsedMS *= this.speed;
           if (this._minElapsedMS) {
-            const delta = currentTime - this._lastFrame | 0;
-            if (delta < this._minElapsedMS) {
+            const delta2 = currentTime - this._lastFrame | 0;
+            if (delta2 < this._minElapsedMS) {
               return;
             }
-            this._lastFrame = currentTime - delta % this._minElapsedMS;
+            this._lastFrame = currentTime - delta2 % this._minElapsedMS;
           }
           this.deltaMS = elapsedMS;
           this.deltaTime = this.deltaMS * _Ticker2.targetFPMS;
@@ -35314,19 +35314,19 @@ function parse2(path2) {
   path2.replace(segment, (_4, cmd, args) => {
     let type = cmd.toLowerCase();
     let command = cmd;
-    const values = parseValues(args);
-    if (type === "m" && values.length > 2) {
-      data.push([command, ...values.splice(0, 2)]);
+    const values2 = parseValues(args);
+    if (type === "m" && values2.length > 2) {
+      data.push([command, ...values2.splice(0, 2)]);
       type = "l";
       command = command === "m" ? "l" : "L";
     }
     while (true) {
-      if (values.length === length[type]) {
-        data.push([command, ...values]);
+      if (values2.length === length[type]) {
+        data.push([command, ...values2]);
         return "";
       }
-      if (values.length < length[type]) throw new Error("malformed path data");
-      data.push([command, ...values.splice(0, length[type])]);
+      if (values2.length < length[type]) throw new Error("malformed path data");
+      data.push([command, ...values2.splice(0, length[type])]);
     }
   });
   return data;
@@ -36596,10 +36596,10 @@ var init_ShapePath = __esm({
       regularPoly(x4, y4, radius, sides, rotation = 0, transform) {
         sides = Math.max(sides | 0, 3);
         const startAngle = -1 * Math.PI / 2 + rotation;
-        const delta = Math.PI * 2 / sides;
+        const delta2 = Math.PI * 2 / sides;
         const polygon = [];
         for (let i6 = 0; i6 < sides; i6++) {
-          const angle = startAngle - i6 * delta;
+          const angle = startAngle - i6 * delta2;
           polygon.push(
             x4 + radius * Math.cos(angle),
             y4 + radius * Math.sin(angle)
@@ -36628,10 +36628,10 @@ var init_ShapePath = __esm({
         const sideLength = radius * Math.sin(Math.PI / sides) - 1e-3;
         corner = Math.min(corner, sideLength);
         const startAngle = -1 * Math.PI / 2 + rotation;
-        const delta = Math.PI * 2 / sides;
+        const delta2 = Math.PI * 2 / sides;
         const internalAngle = (sides - 2) * Math.PI / sides / 2;
         for (let i6 = 0; i6 < sides; i6++) {
-          const angle = i6 * delta + startAngle;
+          const angle = i6 * delta2 + startAngle;
           const x0 = x4 + radius * Math.cos(angle);
           const y0 = y4 + radius * Math.sin(angle);
           const a1 = angle + Math.PI + internalAngle;
@@ -37114,11 +37114,11 @@ var init_GraphicsPath = __esm({
         innerRadius || (innerRadius = radius / 2);
         const startAngle = -1 * Math.PI / 2 + rotation;
         const len = points * 2;
-        const delta = Math.PI * 2 / len;
+        const delta2 = Math.PI * 2 / len;
         const polygon = [];
         for (let i6 = 0; i6 < len; i6++) {
           const r5 = i6 % 2 ? innerRadius : radius;
-          const angle = i6 * delta + startAngle;
+          const angle = i6 * delta2 + startAngle;
           polygon.push(
             x4 + r5 * Math.cos(angle),
             y4 + r5 * Math.sin(angle)
@@ -42707,10 +42707,10 @@ var init_TextStyle = __esm({
        * @param values - Partial style options to assign
        * @returns This TextStyle instance for chaining
        */
-      assign(values) {
-        for (const key in values) {
+      assign(values2) {
+        for (const key in values2) {
           const thisKey = key;
-          this[thisKey] = values[key];
+          this[thisKey] = values2[key];
         }
         return this;
       }
@@ -48027,9 +48027,9 @@ ZodLiteral.create = (value, params2) => {
     ...processCreateParams(params2)
   });
 };
-function createZodEnum(values, params2) {
+function createZodEnum(values2, params2) {
   return new ZodEnum({
-    values,
+    values: values2,
     typeName: ZodFirstPartyTypeKind.ZodEnum,
     ...processCreateParams(params2)
   });
@@ -48085,14 +48085,14 @@ var ZodEnum = class _ZodEnum extends ZodType {
     }
     return enumValues;
   }
-  extract(values, newDef = this._def) {
-    return _ZodEnum.create(values, {
+  extract(values2, newDef = this._def) {
+    return _ZodEnum.create(values2, {
       ...this._def,
       ...newDef
     });
   }
-  exclude(values, newDef = this._def) {
-    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
+  exclude(values2, newDef = this._def) {
+    return _ZodEnum.create(this.options.filter((opt) => !values2.includes(opt)), {
       ...this._def,
       ...newDef
     });
@@ -48130,9 +48130,9 @@ var ZodNativeEnum = class extends ZodType {
     return this._def.values;
   }
 };
-ZodNativeEnum.create = (values, params2) => {
+ZodNativeEnum.create = (values2, params2) => {
   return new ZodNativeEnum({
-    values,
+    values: values2,
     typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
     ...processCreateParams(params2)
   });
@@ -48719,7 +48719,7 @@ function minJacobian(offsets, w5, h6, samples = 17) {
 var ID_RE = /^[a-z][a-z0-9_]*$/;
 var Id = external_exports.string().regex(ID_RE, "snake_case id");
 var Ease = external_exports.union([
-  external_exports.enum(["linear", "step", "ease_in", "ease_out", "ease_in_out", "back_out", "elastic_out"]),
+  external_exports.enum(["linear", "step", "ease_in", "ease_out", "ease_in_out", "minimum_jerk", "back_out", "elastic_out"]),
   // cubic-bezier control points, same semantics as CSS
   external_exports.object({ bezier: external_exports.tuple([external_exports.number(), external_exports.number(), external_exports.number(), external_exports.number()]) })
 ]);
@@ -48751,6 +48751,7 @@ var Asset = external_exports.object({
   /** where this layer came from — provenance for agents */
   origin: external_exports.object({
     sourceImage: external_exports.string().optional(),
+    bboxSpace: external_exports.enum(["source", "document"]).optional(),
     /** bbox in source image: [x, y, w, h] */
     bbox: external_exports.tuple([external_exports.number(), external_exports.number(), external_exports.number(), external_exports.number()]).optional(),
     inpainted: external_exports.boolean().default(false),
@@ -48773,6 +48774,8 @@ var Bone = external_exports.object({
 var Slot = external_exports.object({
   id: Id,
   bone: Id,
+  /** Closed path attachment used as a moving clipping mask. */
+  clip: Id.optional(),
   /** active attachment id; undefined = hidden */
   attachment: Id.optional(),
   alpha: external_exports.number().min(0).max(1).default(1),
@@ -48835,6 +48838,8 @@ var IkConstraint = external_exports.object({
   order: external_exports.number().int().default(0),
   bones: external_exports.array(Id).min(1),
   target: Id,
+  iterations: external_exports.number().int().min(1).max(1e3).optional(),
+  tolerance: external_exports.number().positive().optional(),
   mix: external_exports.number().default(1),
   softness: external_exports.number().default(0),
   bendPositive: external_exports.boolean().default(true),
@@ -48887,7 +48892,7 @@ var BoneProp = external_exports.enum(["x", "y", "rotation", "scaleX", "scaleY",
 var SlotProp = external_exports.enum(["alpha", "attachment", "z", "color"]);
 var DeformProp = external_exports.string().regex(/^(bulge|bend|sway|squash|p[0-2][0-2][xy]|vertices)$/, "deform prop must be bulge|bend|sway|squash|p<row><col>x|y|vertices");
 var IkProp = external_exports.enum(["mix", "softness", "bendPositive", "compress", "stretch"]);
-var TransformProp = external_exports.enum(["mixRotate", "mixX", "mixY", "mixScaleX", "mixScaleY", "mixShearY"]);
+var TransformProp = external_exports.enum(["mixRotate", "mixX", "mixY", "mixScaleX", "mixScaleY", "mixShearY", "x", "y", "rotation", "scaleX", "scaleY", "shearY"]);
 var PathProp = external_exports.enum(["position", "spacing", "mixRotate", "mixX", "mixY"]);
 var KeyValue = external_exports.union([external_exports.number(), external_exports.string(), external_exports.null(), external_exports.array(external_exports.number()), external_exports.array(external_exports.string())]);
 var Key = external_exports.object({
@@ -48896,14 +48901,15 @@ var Key = external_exports.object({
   /** easing INTO the next key */
   ease: Ease.default("ease_in_out")
 });
+var Interpolation = { interpolation: external_exports.enum(["segment", "pchip"]).optional() };
 var Track = external_exports.discriminatedUnion("target", [
-  external_exports.object({ target: external_exports.literal("bone"), id: Id, prop: BoneProp, keys: external_exports.array(Key).min(1) }),
-  external_exports.object({ target: external_exports.literal("slot"), id: Id, prop: SlotProp, keys: external_exports.array(Key).min(1) }),
-  external_exports.object({ target: external_exports.literal("deform"), id: Id, prop: DeformProp, keys: external_exports.array(Key).min(1) }),
-  external_exports.object({ target: external_exports.literal("ik"), id: Id, prop: IkProp, keys: external_exports.array(Key).min(1) }),
-  external_exports.object({ target: external_exports.literal("transform"), id: Id, prop: TransformProp, keys: external_exports.array(Key).min(1) }),
-  external_exports.object({ target: external_exports.literal("path"), id: Id, prop: PathProp, keys: external_exports.array(Key).min(1) }),
-  external_exports.object({ target: external_exports.literal("drawOrder"), id: Id.default("order"), prop: external_exports.literal("order").default("order"), keys: external_exports.array(Key).min(1) })
+  external_exports.object({ target: external_exports.literal("bone"), id: Id, prop: BoneProp, ...Interpolation, keys: external_exports.array(Key).min(1) }),
+  external_exports.object({ target: external_exports.literal("slot"), id: Id, prop: SlotProp, ...Interpolation, keys: external_exports.array(Key).min(1) }),
+  external_exports.object({ target: external_exports.literal("deform"), id: Id, prop: DeformProp, ...Interpolation, keys: external_exports.array(Key).min(1) }),
+  external_exports.object({ target: external_exports.literal("ik"), id: Id, prop: IkProp, ...Interpolation, keys: external_exports.array(Key).min(1) }),
+  external_exports.object({ target: external_exports.literal("transform"), id: Id, prop: TransformProp, ...Interpolation, keys: external_exports.array(Key).min(1) }),
+  external_exports.object({ target: external_exports.literal("path"), id: Id, prop: PathProp, ...Interpolation, keys: external_exports.array(Key).min(1) }),
+  external_exports.object({ target: external_exports.literal("drawOrder"), id: Id.default("order"), prop: external_exports.literal("order").default("order"), ...Interpolation, keys: external_exports.array(Key).min(1) })
 ]);
 var Event2 = external_exports.object({
   t: external_exports.number().nonnegative(),
@@ -49045,6 +49051,10 @@ function validate(doc2) {
     if (a5.frame && !a5.trim && !a5.rotate && (a5.frame[2] !== a5.width || a5.frame[3] !== a5.height)) errs.push(`asset "${a5.id}": frame size must equal width\xD7height (or declare trim/rotate)`);
   }
   for (const s6 of doc2.slots) {
+    if (s6.clip) {
+      const mask = attachments.get(s6.clip);
+      if (mask?.type !== "path" || !mask.closed) errs.push(`slot "${s6.id}": clip must name a closed path attachment`);
+    }
     if (!bones.has(s6.bone)) errs.push(`slot "${s6.id}": unknown bone "${s6.bone}"`);
     if (s6.attachment) {
       const a5 = attachments.get(s6.attachment);
@@ -49076,7 +49086,8 @@ function validate(doc2) {
     }
   }
   for (const c5 of doc2.ik) {
-    if (c5.bones.length > 2) errs.push(`ik "${c5.id}": must have 1 or 2 bones`);
+    for (let i6 = 1; i6 < c5.bones.length; i6++) if (doc2.bones.find((b4) => b4.id === c5.bones[i6])?.parent !== c5.bones[i6 - 1])
+      errs.push(`ik "${c5.id}": bones must form a contiguous parent-to-child chain`);
     for (const b4 of c5.bones) if (!bones.has(b4)) errs.push(`ik "${c5.id}": unknown bone "${b4}"`);
     if (!bones.has(c5.target)) errs.push(`ik "${c5.id}": unknown target bone "${c5.target}"`);
   }
@@ -49148,6 +49159,7 @@ var named = {
   ease_in: (t5) => t5 * t5,
   ease_out: (t5) => 1 - (1 - t5) * (1 - t5),
   ease_in_out: (t5) => t5 < 0.5 ? 2 * t5 * t5 : 1 - (-2 * t5 + 2) ** 2 / 2,
+  minimum_jerk: (t5) => t5 * t5 * t5 * (10 + t5 * (-15 + 6 * t5)),
   back_out: (t5) => 1 + 2.70158 * (t5 - 1) ** 3 + 1.70158 * (t5 - 1) ** 2,
   elastic_out: (t5) => t5 === 0 ? 0 : t5 === 1 ? 1 : 2 ** (-10 * t5) * Math.sin((t5 * 10 - 0.75) * (2 * Math.PI / 3)) + 1
 };
@@ -49179,7 +49191,25 @@ function ease(spec) {
   return f6;
 }
 var pk = (target, id, prop) => `${target}:${id}:${prop}`;
-function sample(track, t5) {
+function smoothValue(track, i6, t5, component, loop2) {
+  const k4 = track.keys, n4 = k4.length;
+  const v6 = (j5) => component === void 0 ? k4[j5].v : k4[j5].v[component];
+  const h6 = (j5) => k4[j5 + 1].t - k4[j5].t;
+  const d5 = (j5) => (v6(j5 + 1) - v6(j5)) / h6(j5);
+  const harmonic = (a5, b4, h0, h1) => a5 * b4 <= 0 ? 0 : 3 * (h0 + h1) / ((2 * h1 + h0) / a5 + (h1 + 2 * h0) / b4);
+  const tangent = (j5) => {
+    if (j5 === 0 || j5 === n4 - 1) {
+      if (loop2 && n4 > 2 && v6(0) === v6(n4 - 1) && k4[0].ease !== "step" && k4[n4 - 2].ease !== "step")
+        return harmonic(d5(n4 - 2), d5(0), h6(n4 - 2), h6(0));
+      return 0;
+    }
+    if (k4[j5 - 1].ease === "step" || k4[j5].ease === "step") return 0;
+    return harmonic(d5(j5 - 1), d5(j5), h6(j5 - 1), h6(j5));
+  };
+  const u6 = (t5 - k4[i6].t) / h6(i6), u22 = u6 * u6, u32 = u22 * u6;
+  return (2 * u32 - 3 * u22 + 1) * v6(i6) + (u32 - 2 * u22 + u6) * h6(i6) * tangent(i6) + (-2 * u32 + 3 * u22) * v6(i6 + 1) + (u32 - u22) * h6(i6) * tangent(i6 + 1);
+}
+function sample(track, t5, loop2 = false) {
   const keys = track.keys;
   if (t5 <= keys[0].t) return keys[0].v;
   const last = keys[keys.length - 1];
@@ -49187,31 +49217,38 @@ function sample(track, t5) {
   let i6 = 0;
   while (keys[i6 + 1].t <= t5) i6++;
   const a5 = keys[i6], b4 = keys[i6 + 1];
+  if (a5.ease === "step") return a5.v;
   if (typeof a5.v === "number" && typeof b4.v === "number") {
+    if (track.interpolation === "pchip") return smoothValue(track, i6, t5, void 0, loop2);
     const u6 = ease(a5.ease)((t5 - a5.t) / (b4.t - a5.t));
     return a5.v + (b4.v - a5.v) * u6;
   }
   if (Array.isArray(a5.v) && Array.isArray(b4.v) && typeof a5.v[0] === "number") {
+    if (track.interpolation === "pchip") return a5.v.map((_4, j5) => smoothValue(track, i6, t5, j5, loop2));
     const u6 = ease(a5.ease)((t5 - a5.t) / (b4.t - a5.t)), av = a5.v, bv = b4.v;
     return av.map((v6, k4) => v6 + ((bv[k4] ?? v6) - v6) * u6);
   }
   return a5.v;
 }
 function poseOf(anim, t5, out2 = /* @__PURE__ */ new Map()) {
-  for (const tr of anim.tracks) out2.set(pk(tr.target, tr.id, tr.prop), sample(tr, t5));
+  for (const tr of anim.tracks) out2.set(pk(tr.target, tr.id, tr.prop), sample(tr, t5, anim.loop && tr.keys[0].t === 0 && tr.keys.at(-1).t === anim.duration));
   return out2;
 }
 function blendPoses(from, to, w5, restOf) {
-  const out2 = new Map(to);
-  for (const [k4, f6] of from) {
-    const cur = to.get(k4);
-    if (typeof f6 === "number") {
+  if (w5 >= 1) return new Map(to);
+  const out2 = /* @__PURE__ */ new Map();
+  for (const k4 of /* @__PURE__ */ new Set([...from.keys(), ...to.keys()])) {
+    const f6 = from.has(k4) ? from.get(k4) : restOf(k4);
+    const cur = to.has(k4) ? to.get(k4) : restOf(k4);
+    if (typeof f6 === "number" && !Array.isArray(cur)) {
       const target = typeof cur === "number" ? cur : restOf(k4);
       out2.set(k4, f6 + (target - f6) * w5);
     } else if (Array.isArray(f6) && typeof f6[0] === "number") {
       const fv = f6, tv = Array.isArray(cur) && typeof cur[0] === "number" ? cur : fv.map(() => 0);
       out2.set(k4, fv.map((v6, i6) => v6 + ((tv[i6] ?? 0) - v6) * w5));
-    } else if (cur === void 0 && w5 < 1) out2.set(k4, f6);
+    } else if (Array.isArray(cur) && typeof cur[0] === "number" && typeof f6 !== "string") {
+      out2.set(k4, cur.map((v6) => v6 * w5));
+    } else out2.set(k4, f6 ?? null);
   }
   return out2;
 }
@@ -49380,10 +49417,43 @@ function aimAt(skel, boneId, tx, ty, mix, compress = false, stretch = false, uni
   updateSubtree(skel, boneId);
 }
 var shortest = (deg) => ((deg + 180) % 360 + 360) % 360 - 180;
+function applyLongIk(skel, c5, tx, ty, mix) {
+  const initial = c5.bones.map((id) => ({ ...skel.bones.get(id) }));
+  const last = c5.bones.at(-1), len = boneOf(skel.doc, last).length;
+  const end = () => apply(skel.bones.get(last).world, len, 0);
+  const tolerance = c5.tolerance ?? 0.05;
+  const root2 = skel.bones.get(c5.bones[0]).world, tip = end();
+  if (Math.abs((tip[0] - root2.tx) * (ty - root2.ty) - (tip[1] - root2.ty) * (tx - root2.tx)) < 1e-7 && Math.hypot(tx - root2.tx, ty - root2.ty) < Math.hypot(tip[0] - root2.tx, tip[1] - root2.ty) - tolerance) {
+    skel.bones.get(last).rotation += cnum(skel, "ik", c5.id, "bendPositive", c5.bendPositive) > 0.5 ? 5 : -5;
+    updateSubtree(skel, last);
+  }
+  for (let iter = 0; iter < (c5.iterations ?? 100); iter++) {
+    const e5 = end();
+    if (Math.hypot(e5[0] - tx, e5[1] - ty) <= tolerance) break;
+    for (let i6 = c5.bones.length - 1; i6 >= 0; i6--) {
+      const id = c5.bones[i6], b4 = boneOf(skel.doc, id), st = skel.bones.get(id), w5 = st.world, e6 = end();
+      const angle = wrapRad(Math.atan2(ty - w5.ty, tx - w5.tx) - Math.atan2(e6[1] - w5.ty, e6[0] - w5.tx));
+      const cos = Math.cos(angle), sin = Math.sin(angle);
+      setEffectiveWorld(skel, b4, st, { ...w5, a: cos * w5.a - sin * w5.b, b: sin * w5.a + cos * w5.b, c: cos * w5.c - sin * w5.d, d: sin * w5.c + cos * w5.d });
+    }
+  }
+  if (mix < 1) {
+    c5.bones.forEach((id, i6) => {
+      const st = skel.bones.get(id), from = initial[i6];
+      for (const p6 of ["rotation", "shearX", "shearY"]) st[p6] = from[p6] + shortest(st[p6] - from[p6]) * mix;
+      for (const p6 of ["x", "y", "scaleX", "scaleY"]) st[p6] = from[p6] + (st[p6] - from[p6]) * mix;
+    });
+    updateSubtree(skel, c5.bones[0]);
+  }
+}
 function applyIk(skel, c5) {
   const mix = cnum(skel, "ik", c5.id, "mix", c5.mix);
   if (mix <= 0) return;
   const target = skel.bones.get(c5.target).world;
+  if (c5.bones.length > 2) {
+    applyLongIk(skel, c5, target.tx, target.ty, mix);
+    return;
+  }
   const bendDir = cnum(skel, "ik", c5.id, "bendPositive", c5.bendPositive) > 0.5 ? 1 : -1;
   const compress = cnum(skel, "ik", c5.id, "compress", c5.compress) > 0.5, stretch = cnum(skel, "ik", c5.id, "stretch", c5.stretch) > 0.5;
   let softness = cnum(skel, "ik", c5.id, "softness", c5.softness);
@@ -49518,6 +49588,7 @@ function applyTransformConstraint(skel, c5) {
   const mixRotate = cnum(skel, "transform", c5.id, "mixRotate", c5.mixRotate), mixX = cnum(skel, "transform", c5.id, "mixX", c5.mixX), mixY = cnum(skel, "transform", c5.id, "mixY", c5.mixY);
   const mixScaleX = cnum(skel, "transform", c5.id, "mixScaleX", c5.mixScaleX), mixScaleY = cnum(skel, "transform", c5.id, "mixScaleY", c5.mixScaleY), mixShearY = cnum(skel, "transform", c5.id, "mixShearY", c5.mixShearY);
   if (!mixRotate && !mixX && !mixY && !mixScaleX && !mixScaleY && !mixShearY) return;
+  c5 = { ...c5, ...Object.fromEntries(["x", "y", "rotation", "scaleX", "scaleY", "shearY"].map((p6) => [p6, cnum(skel, "transform", c5.id, p6, c5[p6])])) };
   const target = skel.bones.get(c5.target), tw = target.world;
   const offsetRotation = c5.rotation * DEG2, offsetShearY = c5.shearY * DEG2;
   for (const id of c5.bones) {
@@ -49955,6 +50026,116 @@ function paintWeights(skel, att, world, opts) {
   return { ...rest, weights };
 }
 
+// src/rig-quality.ts
+var values = (v6) => typeof v6 === "number" ? [v6] : Array.isArray(v6) && v6.every((n4) => typeof n4 === "number") ? v6 : void 0;
+var delta = (a5, b4) => a5.map((v6, i6) => v6 - b4[i6]);
+var magnitude = (a5) => Math.max(0, ...a5.map(Math.abs));
+function motionQuality(doc2, anim, opts = {}) {
+  const out2 = [], D2 = anim.duration;
+  const report = (code, subject, message, time2, level = "warn") => out2.push({ level, code, subject, animation: anim.id, time: time2, message });
+  for (const tr of anim.tracks) {
+    const id = `${tr.target}.${tr.id}.${tr.prop}`, looping = anim.loop && tr.keys[0].t === 0 && tr.keys.at(-1).t === D2;
+    const at = (t5) => sample(tr, t5, looping), numeric = tr.keys.every((k4) => values(k4.v) !== void 0);
+    if (anim.loop) {
+      const first = at(0), last = at(D2), av = values(first), bv = values(last);
+      const diff = av && bv && av.length === bv.length ? magnitude(delta(av, bv)) : first === last || JSON.stringify(first) === JSON.stringify(last) ? 0 : Infinity;
+      if (diff > 1e-3 && typeof first !== "number") report("loop_seam", id, `loop endpoint values differ (${Number.isFinite(diff) ? `max delta ${diff.toFixed(4)}` : "discrete state"}); all channels must close`);
+      if (numeric && diff <= 1e-3 && tr.keys.length > 1) {
+        const h6 = Math.min(D2 / 1e4, (tr.keys[1].t - tr.keys[0].t) / 100, (tr.keys.at(-1).t - tr.keys.at(-2).t) / 100);
+        const va = delta(values(at(h6)), values(at(0))).map((v6) => v6 / h6), vb = delta(values(at(D2)), values(at(D2 - h6))).map((v6) => v6 / h6);
+        const dv = magnitude(delta(va, vb));
+        if (dv > Math.max(0.05, 0.05 * Math.max(magnitude(va), magnitude(vb)))) report("loop_velocity", id, `loop velocity changes by ${dv.toFixed(3)} units/s at the wrap`);
+      }
+    }
+    if (!numeric) continue;
+    for (let i6 = 1; i6 < tr.keys.length - 1; i6++) {
+      const p6 = tr.keys[i6 - 1], k4 = tr.keys[i6], n4 = tr.keys[i6 + 1];
+      if (p6.ease === "step" || k4.ease === "step") continue;
+      const h6 = Math.min(k4.t - p6.t, n4.t - k4.t) / 1e3;
+      const left = delta(values(at(k4.t)), values(at(k4.t - h6))).map((v6) => v6 / h6), right = delta(values(at(k4.t + h6)), values(at(k4.t))).map((v6) => v6 / h6);
+      const before = delta(values(k4.v), values(p6.v)), after = delta(values(n4.v), values(k4.v));
+      const pass = before.some((v6, j5) => v6 * after[j5] > 1e-6);
+      const speed = Math.max(magnitude(before) / (k4.t - p6.t), magnitude(after) / (n4.t - k4.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`, k4.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`, k4.t);
+      const acceleration = (a5, b4, c5) => values(at(b4)).map((v6, j5) => (values(at(c5))[j5] - 2 * v6 + values(at(a5))[j5]) / (h6 * h6));
+      const al = acceleration(k4.t - 2 * h6, k4.t - h6, k4.t), ar = acceleration(k4.t, k4.t + h6, k4.t + 2 * h6);
+      const aj = magnitude(delta(al, ar));
+      if (aj > Math.max(1, speed / Math.min(k4.t - p6.t, n4.t - k4.t) * 2)) report("acceleration_jump", id, `acceleration changes by ${aj.toFixed(2)} units/s\xB2 at this key; PCHIP guarantees velocity, not acceleration continuity`, k4.t, "info");
+    }
+  }
+  const steps = Math.max(2, Math.ceil(D2 * 60));
+  const times3 = new Set(Array.from({ length: steps + 1 }, (_4, i6) => i6 * D2 / steps));
+  for (const tr of anim.tracks) for (const k4 of tr.keys) {
+    times3.add(k4.t);
+    if (k4.t > 0) times3.add(Math.max(0, k4.t - 1e-5));
+  }
+  const samples = [...times3].sort((a5, b4) => a5 - b4).map((t5) => ({ t: t5, pose: poseOf(anim, t5) }));
+  for (const bone of opts.secondaryBones ?? []) {
+    if (!doc2.bones.some((b4) => b4.id === bone)) throw new Error(`unknown secondary bone "${bone}"`);
+    const local = samples.map((s6) => evaluate(doc2, s6.pose).bones.get(bone));
+    const curves = ["rotation", "x", "y"].map((prop) => local.map((b4) => b4[prop]));
+    if (curves.every((v6) => Math.max(...v6) - Math.min(...v6) < 1e-3)) report("secondary_frozen", bone, `declared secondary bone has no local motion in this animation`);
+  }
+  const reported = /* @__PURE__ */ new Set();
+  for (const [front, back] of opts.frontOf ?? []) {
+    if (![front, back].every((id) => doc2.slots.some((s6) => s6.id === id))) throw new Error(`unknown frontOf slots: ${front}, ${back}`);
+    for (const { t: t5, pose: pose2 } of samples) {
+      const skel = evaluate(doc2, pose2);
+      if (!skel.attachment.get(front) || !skel.attachment.get(back)) continue;
+      const visible = (id) => {
+        const slot = doc2.slots.find((s6) => s6.id === id);
+        const color = pose2.get(pk("slot", id, "color")) ?? colorToArray(slot.color);
+        return Number(pose2.get(pk("slot", id, "alpha")) ?? slot.alpha) * color[3] > 0;
+      };
+      if (!visible(front) || !visible(back)) continue;
+      const order = pose2.get(pk("drawOrder", "order", "order"));
+      const z3 = (id) => order ? order.indexOf(id) : Number(pose2.get(pk("slot", id, "z")) ?? doc2.slots.find((s6) => s6.id === id).z);
+      const pair = JSON.stringify([front, back]);
+      if (z3(front) <= z3(back) && !reported.has(pair)) {
+        reported.add(pair);
+        report("draw_order_rule", front, `"${front}" must stay explicitly in front of "${back}" according to the brief (equal z is ambiguous)`, t5);
+      }
+    }
+  }
+  for (const tr of anim.tracks.filter((t5) => t5.target === "slot" && t5.prop === "attachment")) for (const key of tr.keys.filter((k4) => k4.t > 0)) {
+    const a5 = evaluate(doc2, poseOf(anim, Math.max(0, key.t - 1e-6))), b4 = evaluate(doc2, poseOf(anim, key.t));
+    const before = a5.attachment.get(tr.id), after = b4.attachment.get(tr.id);
+    if (!before || !after || before.id === after.id) continue;
+    const landmarksA = opts.landmarks?.[before.id], landmarksB = opts.landmarks?.[after.id];
+    if (!landmarksA && !landmarksB) continue;
+    if (!landmarksA || !landmarksB || !Object.keys(landmarksA).some((name) => landmarksB[name])) {
+      report("landmark_unmeasured", tr.id, `swap ${before.id} \u2192 ${after.id} has no shared declared landmarks`, key.t);
+      continue;
+    }
+    const point = (skel, att, uv) => {
+      if (att.type === "region") {
+        const [w5, h6] = regionSize(doc2, att);
+        return apply(regionMatrix(skel, att.slot, att), (uv[0] - 0.5) * w5, (uv[1] - 0.5) * h6);
+      }
+      if (att.type !== "mesh") return;
+      const v6 = attachmentWorldVertices(skel, att.slot, att);
+      for (let i6 = 0; i6 < att.triangles.length; i6 += 3) {
+        const [ia, ib, ic] = att.triangles.slice(i6, i6 + 3), ux2 = att.uvs[ia * 2], uy2 = att.uvs[ia * 2 + 1], bx = att.uvs[ib * 2] - ux2, by = att.uvs[ib * 2 + 1] - uy2, cx = att.uvs[ic * 2] - ux2, cy = att.uvs[ic * 2 + 1] - uy2, det = bx * cy - by * cx;
+        if (Math.abs(det) < 1e-12) continue;
+        const s6 = ((uv[0] - ux2) * cy - (uv[1] - uy2) * cx) / det, r5 = (bx * (uv[1] - uy2) - by * (uv[0] - ux2)) / det;
+        if (s6 >= -1e-6 && r5 >= -1e-6 && s6 + r5 <= 1 + 1e-6) return [v6[ia * 2] * (1 - s6 - r5) + v6[ib * 2] * s6 + v6[ic * 2] * r5, v6[ia * 2 + 1] * (1 - s6 - r5) + v6[ib * 2 + 1] * s6 + v6[ic * 2 + 1] * r5];
+      }
+    };
+    for (const [name, uv] of Object.entries(landmarksA)) if (landmarksB[name]) {
+      const p6 = point(a5, before, uv), q2 = point(b4, after, landmarksB[name]);
+      if (!p6 || !q2) {
+        report("landmark_unmeasured", tr.id, `landmark "${name}" is outside attachment geometry`, key.t);
+        continue;
+      }
+      const distance = Math.hypot(p6[0] - q2[0], p6[1] - q2[1]);
+      if (distance > (opts.landmarkTolerance ?? 2)) report("attachment_landmark_jump", tr.id, `"${name}" moves ${distance.toFixed(2)}px when ${before.id} changes to ${after.id}`, key.t);
+    }
+  }
+  return out2;
+}
+
 // src/rig-path.ts
 var flatten = (pts) => pts.flatMap((p6) => [p6[0], p6[1]]);
 var anchorCount = (vertexCount2) => Math.floor(vertexCount2 / 3);
@@ -50119,6 +50300,43 @@ function pathFromPoints(skel, slotId, points, closed) {
   }
   return { vertices, closed, lengths: curveLengths(flatten(ctrl.flat()), closed) };
 }
+function constraintDependencies(doc2) {
+  const parent = new Map(doc2.bones.map((b4) => [b4.id, b4.parent]));
+  const ancestors = (id) => {
+    const out2 = /* @__PURE__ */ new Set();
+    for (let b4 = id; b4 && !out2.has(b4); b4 = parent.get(b4)) out2.add(b4);
+    return out2;
+  };
+  const all = [
+    ...doc2.ik.map((c5) => ({ kind: "ik", ...c5 })),
+    ...doc2.transform.map((c5) => ({ kind: "transform", ...c5 })),
+    ...doc2.path.map((c5) => ({ kind: "path", ...c5 }))
+  ].sort((a5, b4) => a5.order - b4.order);
+  const active = (c5) => MIX_PROPS[c5.kind].some((p6) => c5[p6] !== 0 || doc2.animations.some((a5) => a5.tracks.some((t5) => t5.target === c5.kind && t5.id === c5.id && t5.prop === p6 && t5.keys.some((k4) => typeof k4.v === "number" && k4.v !== 0))));
+  const edges = [];
+  all.forEach((reader, ri) => {
+    if (!active(reader)) return;
+    const reads = /* @__PURE__ */ new Set();
+    const add = (b4) => ancestors(b4).forEach((x4) => reads.add(x4));
+    if (reader.kind === "path") {
+      const slot = doc2.slots.find((s6) => s6.id === reader.target);
+      if (slot) add(slot.bone);
+      for (const a5 of doc2.attachments) if (a5.slot === reader.target && a5.type === "path") {
+        for (const list of a5.weights ?? []) for (const inf of list) if (inf.w !== 0) add(inf.bone);
+      }
+    } else add(reader.target);
+    for (const b4 of reader.bones) {
+      const p6 = parent.get(b4);
+      if (p6 && !reader.bones.includes(p6)) add(p6);
+    }
+    all.forEach((writer, wi) => {
+      if (ri === wi || !active(writer)) return;
+      const bone = writer.bones.find((b4) => reads.has(b4));
+      if (bone) edges.push({ reader: reader.id, readerKind: reader.kind, writer: writer.id, writerKind: writer.kind, bone, late: wi > ri });
+    });
+  });
+  return { all, edges };
+}
 
 // src/rig-check.ts
 var FOLD_ERROR_RATIO = 0.05;
@@ -50128,15 +50346,22 @@ var isNumeric = (t5) => t5.target !== "slot" || t5.prop !== "attachment";
 var trackId2 = (t5) => `${t5.target}.${t5.id}.${t5.prop}`;
 var fmt = (n4) => String(Math.round(n4 * 1e3) / 1e3);
 var times = (a5, fps) => {
-  const n4 = Math.max(1, Math.round(a5.duration * fps)), out2 = [];
-  for (let i6 = 0; i6 <= n4; i6++) out2.push(Math.min(a5.duration, i6 / fps));
+  const n4 = Math.max(1, Math.ceil(a5.duration * fps)), out2 = [];
+  for (let i6 = 0; i6 <= n4; i6++) out2.push(a5.duration * i6 / n4);
   return out2;
 };
 function checkRig(doc2, opts = {}) {
   const fps = opts.fps ?? 30, dfps = opts.deformFps ?? 60, overlapMin = opts.overlap ?? 0.6, margin = opts.margin ?? 1;
+  if (![fps, dfps].every((v6) => Number.isFinite(v6) && v6 > 0)) throw new Error("check sampling rates must be positive");
   const anims = opts.animation === void 0 ? doc2.animations : doc2.animations.filter((a5) => a5.id === opts.animation);
   if (opts.animation !== void 0 && !anims.length) throw new Error(`unknown animation "${opts.animation}"`);
   const out2 = [];
+  for (const e5 of constraintDependencies(doc2).edges.filter((e6) => e6.late)) out2.push({
+    level: "warn",
+    code: "constraint_order",
+    subject: e5.reader,
+    message: `constraint "${e5.reader}" reads bone "${e5.bone}" before later constraint "${e5.writer}" moves it; use rig_order_constraints or set explicit order`
+  });
   const W = doc2.meta.width, H3 = doc2.meta.height;
   const overflowOf = (pose2, slotId, skel) => {
     const pts = slotOutline(doc2, pose2, slotId, 4, skel);
@@ -50308,6 +50533,7 @@ function checkRig(doc2, opts = {}) {
     return rest;
   };
   for (const a5 of anims) {
+    out2.push(...motionQuality(doc2, a5, opts));
     for (const t5 of a5.tracks) {
       if (!isNumeric(t5)) continue;
       const vals = t5.keys.map((k4) => k4.v);
@@ -50415,7 +50641,9 @@ function checkRig(doc2, opts = {}) {
         if (!sorted.length) continue;
         const typical = sorted[Math.floor(sorted.length / 2)];
         const worst2 = ds.reduce((m5, x4) => x4.d > m5.d ? x4 : m5, ds[0]);
-        if (worst2.d > Math.max(6, 5 * typical)) {
+        const index = ds.indexOf(worst2);
+        const neighbours = Math.max(ds[index - 1]?.d ?? 0, ds[index + 1]?.d ?? 0);
+        if (worst2.d > Math.max(6, 5 * typical, 3 * neighbours)) {
           const stepped = stepTimes.some((st) => st > worst2.t - 1 / dfps - 1e-9 && st <= worst2.t + 1e-9);
           out2.push({
             level: stepped ? "info" : "warn",
@@ -50466,7 +50694,7 @@ function checkRig(doc2, opts = {}) {
   for (const att of doc2.attachments) {
     if (att.type !== "region") continue;
     const asset = doc2.assets.find((a5) => a5.id === att.asset), bbox = asset?.origin?.bbox;
-    if (!asset || !bbox || !doc2.slots.some((s6) => s6.id === att.slot)) continue;
+    if (!asset || !bbox || asset.origin?.bboxSpace === "source" || !doc2.slots.some((s6) => s6.id === att.slot)) continue;
     const [cx, cy] = apply(regionMatrix(restWorld, att.slot, att), 0, 0);
     const ex2 = bbox[0] + bbox[2] / 2, ey2 = bbox[1] + bbox[3] / 2, dx = cx - ex2, dy = cy - ey2;
     const dist = Math.hypot(dx, dy);
@@ -50511,7 +50739,8 @@ function checkRig(doc2, opts = {}) {
   for (const att of doc2.attachments) if (att.type !== "path" && shownAttachments.has(att.id)) used.add(att.asset);
   for (const asset of doc2.assets) if (!used.has(asset.id))
     out2.push({ level: "info", code: "unused_asset", subject: asset.id, message: `asset "${asset.id}" is not shown by any attachment at rest or in any animation` });
-  for (const s6 of doc2.slots) if (!s6.attachment && !swappedIn.has(s6.id))
+  const maskSlots = new Set(doc2.slots.flatMap((s6) => s6.clip ? [doc2.attachments.find((a5) => a5.id === s6.clip)?.slot] : []));
+  for (const s6 of doc2.slots) if (!s6.attachment && !swappedIn.has(s6.id) && !maskSlots.has(s6.id))
     out2.push({ level: "warn", code: "never_visible", subject: s6.id, message: `slot "${s6.id}" has no attachment and no animation ever shows one` });
   return out2;
 }
@@ -50913,10 +51142,11 @@ function setPathAttachment(doc2, id, slot, geom) {
 function setKeys(doc2, animId2, track, keys, duration, opts = {}) {
   const anim = doc2.animations.find((a5) => a5.id === animId2) ?? { id: animId2, duration: duration ?? 1, loop: false, tracks: [], events: [] };
   const same2 = (t5) => t5.target === track.target && t5.id === track.id && t5.prop === track.prop;
+  const old = anim.tracks.find(same2);
   const given = keys.map((k4) => ({ ...k4, ease: k4.ease ?? "ease_in_out" }));
   const kept = opts.merge ? (anim.tracks.find(same2)?.keys ?? []).filter((k4) => !given.some((g4) => Math.abs(g4.t - k4.t) < 1e-9)) : [];
   const sorted = [...kept, ...given].sort((a5, b4) => a5.t - b4.t);
-  const edited = { ...track, keys: sorted };
+  const edited = { ...old, ...track, interpolation: track.interpolation ?? old?.interpolation, keys: sorted };
   const tracks = anim.tracks.some(same2) ? anim.tracks.map((t5) => same2(t5) ? edited : t5) : [...anim.tracks, edited];
   const dur = duration ?? Math.max(anim.duration, ...sorted.map((k4) => k4.t));
   const next = { ...anim, tracks, duration: dur, preset: void 0 };
@@ -51796,7 +52026,7 @@ function KeyDiamond({ track, value }) {
       void commit("rig_remove_keys", { animation: anim.id, ...track, times: [t5] });
       return;
     }
-    const v6 = tr ? sample(tr, t5) : value;
+    const v6 = tr ? sample(tr, t5, anim.loop && tr.keys[0].t === 0 && tr.keys.at(-1).t === anim.duration) : value;
     const ease2 = track.prop === "attachment" ? { ease: "step" } : {};
     void commit("rig_set_keys", { animation: anim.id, ...track, merge: true, keys: [{ t: t5, v: v6, ...ease2 }] });
   };
@@ -51846,6 +52076,16 @@ function BoneForm({ d: d5, id }) {
     /* @__PURE__ */ u4(Num, { label: "length", value: b4.length, onCommit: (v6) => setField({ length: v6 }) }),
     /* @__PURE__ */ u4(Sel, { label: "inherit", value: b4.inherit, options: INHERIT.map((v6) => [v6, v6]), onCommit: (v6) => setField({ inherit: v6 }) }),
     /* @__PURE__ */ u4(Txt, { label: "color", value: b4.color ?? "", onCommit: (v6) => setField({ color: v6 }) }),
+    anim && /* @__PURE__ */ u4(S, { children: [
+      /* @__PURE__ */ u4("button", { onClick: () => {
+        const target = prompt("Follow bone at the current time (world pose is preserved)");
+        if (target) void commit("rig_attach_to_bone", { animation: anim.id, bone: id, target, t: time.value });
+      }, children: "attach at contact" }),
+      /* @__PURE__ */ u4("button", { onClick: () => {
+        const driver = prompt("Driver bone for baked secondary rotation", b4.parent ?? "root");
+        if (driver) void commit("rig_bake_secondary", { animation: anim.id, driver, bones: [id] });
+      }, children: "bake secondary motion" })
+    ] }),
     /* @__PURE__ */ u4("h4", { children: [
       "transform",
       anim ? " (posed)" : ""
@@ -51912,6 +52152,15 @@ function SlotForm({ d: d5, id }) {
       }
     ),
     /* @__PURE__ */ u4(Num, { label: "z", value: z3, track: track("z"), onCommit: (v6) => anim ? setKey("z", Math.round(v6)) : setSlot({ z: Math.round(v6) }) }),
+    /* @__PURE__ */ u4(
+      Sel,
+      {
+        label: "clip mask",
+        value: s6.clip ?? "",
+        options: [["", "none"], ...d5.attachments.filter((a5) => a5.type === "path" && a5.closed).map((a5) => [a5.id, a5.id])],
+        onCommit: (v6) => setSlot({ clip: v6 || null })
+      }
+    ),
     /* @__PURE__ */ u4(Sel, { label: "blend", value: s6.blend, options: BLEND.map((v6) => [v6, v6]), onCommit: (v6) => setSlot({ blend: v6 }) }),
     /* @__PURE__ */ u4(Txt, { label: "color", value: s6.color, onCommit: (v6) => setSlot({ color: v6 }) })
   ] });
@@ -52053,7 +52302,15 @@ function WeightsPanel({ d: d5, a: a5 }) {
       /* @__PURE__ */ u4("input", { type: "checkbox", checked: candidates.includes(x4.id), onChange: (e5) => toggle(x4.id, e5.currentTarget.checked) }),
       x4.id
     ] }, x4.id)),
-    /* @__PURE__ */ u4("button", { class: "auto-weights", title: "re-skin this mesh to the checked bones by distance", onClick: autoWeights, children: "auto weights" })
+    /* @__PURE__ */ u4("button", { class: "auto-weights", title: "re-skin this mesh to the checked bones by distance", onClick: autoWeights, children: "auto weights" }),
+    /* @__PURE__ */ u4("button", { disabled: candidates.length < 2, onClick: () => void commit("rig_gradient_weights", { id: a5.id, bones: candidates }), children: "chain gradient" }),
+    /* @__PURE__ */ u4("p", { class: "hint", children: [
+      "Gradient order: ",
+      candidates.join(" \u2192 "),
+      ". Uncheck and select bones in chain order."
+    ] }),
+    /* @__PURE__ */ u4("button", { disabled: !a5.weights, onClick: () => void commit("rig_smooth_weights", { id: a5.id, locked: selectedVertices.value }), children: "smooth (keep selected fixed)" }),
+    /* @__PURE__ */ u4("button", { disabled: !selectedVertices.value.length, onClick: () => void commit("rig_pin_weights", { id: a5.id, bone: b4.bone, vertices: selectedVertices.value }), children: "bind selected to brush bone" })
   ] });
 }
 function VertexForm({ d: d5, id, index }) {
@@ -52153,8 +52410,6 @@ function ConstraintHead({ d: d5, kind, c: c5, set }) {
     const unknown = bones.filter((b4) => !d5.bones.some((x4) => x4.id === b4));
     if (!bones.length) setStatus(`${c5.id}: a constraint drives at least one bone`, "warn");
     else if (unknown.length) setStatus(`${c5.id}: no bone "${unknown.join('", "')}" in this rig`, "warn");
-    else if (kind === "ik" && bones.length > 2)
-      setStatus(`${c5.id}: an IK chain is one or two bones (the format has no longer ones), got ${bones.length}`, "warn");
     else if (bones.join(",") !== c5.bones.join(",")) set({ bones });
   };
   const options = kind === "path" ? d5.slots.filter((s6) => d5.attachments.some((a5) => a5.slot === s6.id && a5.type === "path")).map((s6) => [s6.id, s6.id]) : d5.bones.map((b4) => [b4.id, b4.id]);
@@ -52167,15 +52422,23 @@ function ConstraintHead({ d: d5, kind, c: c5, set }) {
     /* @__PURE__ */ u4(Sel, { label: "target", name: "target", value: c5.target, options, onCommit: (v6) => set({ target: v6 }) })
   ] });
 }
-var Order = ({ value, set }) => /* @__PURE__ */ u4(Num, { label: "order", name: "order", value, onCommit: (v6) => set({ order: Math.round(v6) }) });
+var Order = ({ value, set }) => /* @__PURE__ */ u4(S, { children: [
+  /* @__PURE__ */ u4(Num, { label: "order", name: "order", value, onCommit: (v6) => set({ order: Math.round(v6) }) }),
+  /* @__PURE__ */ u4("button", { onClick: () => void commit("rig_order_constraints", {}), children: "order by dependencies" })
+] });
 function IkForm({ d: d5, c: c5 }) {
   const o5 = constraintOps("ik", c5.id);
   return /* @__PURE__ */ u4(S, { children: [
     /* @__PURE__ */ u4("h4", { children: "ik constraint" }),
     /* @__PURE__ */ u4(ConstraintHead, { d: d5, kind: "ik", c: c5, set: o5.set }),
     /* @__PURE__ */ u4(Num, { label: "mix", name: "mix", step: 0.05, value: o5.value("mix", c5.mix), track: o5.track("mix"), onCommit: (v6) => o5.num("mix", v6) }),
-    /* @__PURE__ */ u4(Num, { label: "softness", name: "softness", value: o5.value("softness", c5.softness), track: o5.track("softness"), onCommit: (v6) => o5.num("softness", v6) }),
-    IK_FLAGS.map((f6) => /* @__PURE__ */ u4(Chk, { label: f6, name: f6, value: c5[f6], onCommit: (v6) => o5.set({ [f6]: v6 }) }, f6)),
+    c5.bones.length > 2 && /* @__PURE__ */ u4(S, { children: [
+      /* @__PURE__ */ u4(Num, { label: "iterations", value: c5.iterations ?? 100, onCommit: (v6) => o5.set({ iterations: Math.round(v6) }) }),
+      /* @__PURE__ */ u4(Num, { label: "tolerance", value: c5.tolerance ?? 0.05, step: 0.01, onCommit: (v6) => o5.set({ tolerance: v6 }) })
+    ] }),
+    c5.bones.length <= 2 && /* @__PURE__ */ u4(Num, { label: "softness", name: "softness", value: o5.value("softness", c5.softness), track: o5.track("softness"), onCommit: (v6) => o5.num("softness", v6) }),
+    IK_FLAGS.filter((f6) => c5.bones.length <= 2 || f6 === "bendPositive").map((f6) => /* @__PURE__ */ u4(Chk, { label: f6, name: f6, value: c5[f6], onCommit: (v6) => o5.set({ [f6]: v6 }) }, f6)),
+    c5.bones.length > 2 && /* @__PURE__ */ u4("p", { class: "hint", children: "Long chains bend without stretching. Use a path to control the shape between the root and tip." }),
     /* @__PURE__ */ u4(Order, { value: c5.order, set: o5.set })
   ] });
 }
@@ -52186,7 +52449,7 @@ function TransformForm({ d: d5, c: c5 }) {
     /* @__PURE__ */ u4(ConstraintHead, { d: d5, kind: "transform", c: c5, set: o5.set }),
     TRANSFORM_FLAGS.map((f6) => /* @__PURE__ */ u4(Chk, { label: f6, name: f6, value: c5[f6], onCommit: (v6) => o5.set({ [f6]: v6 }) }, f6)),
     /* @__PURE__ */ u4("h4", { children: "offset" }),
-    TRANSFORM_OFFSETS.map((p6) => /* @__PURE__ */ u4(Num, { label: p6, name: p6, value: c5[p6], step: p6.startsWith("scale") ? 0.05 : 1, onCommit: (v6) => o5.set({ [p6]: v6 }) }, p6)),
+    TRANSFORM_OFFSETS.map((p6) => /* @__PURE__ */ u4(Num, { label: p6, name: p6, value: o5.value(p6, c5[p6]), track: o5.track(p6), step: p6.startsWith("scale") ? 0.05 : 1, onCommit: (v6) => o5.num(p6, v6) }, p6)),
     /* @__PURE__ */ u4("h4", { children: "mix" }),
     MIX_PROPS.transform.map((p6) => /* @__PURE__ */ u4(Num, { label: p6, name: p6, step: 0.05, value: o5.value(p6, c5[p6]), track: o5.track(p6), onCommit: (v6) => o5.num(p6, v6) }, p6)),
     /* @__PURE__ */ u4(Order, { value: c5.order, set: o5.set })
@@ -52197,13 +52460,13 @@ function PathForm({ d: d5, c: c5 }) {
   return /* @__PURE__ */ u4(S, { children: [
     /* @__PURE__ */ u4("h4", { children: "path constraint" }),
     /* @__PURE__ */ u4(ConstraintHead, { d: d5, kind: "path", c: c5, set: o5.set }),
-    PATH_MODES.map(([p6, values]) => /* @__PURE__ */ u4(
+    PATH_MODES.map(([p6, values2]) => /* @__PURE__ */ u4(
       Sel,
       {
         label: p6,
         name: p6,
         value: c5[p6],
-        options: values.map((v6) => [v6, v6]),
+        options: values2.map((v6) => [v6, v6]),
         onCommit: (v6) => o5.set({ [p6]: v6 })
       },
       p6
@@ -52508,7 +52771,25 @@ function TrackSliders() {
   h2(() => () => cancelReleases(group), [group]);
   if (!a5 || !ref || !d5) return null;
   const tr = a5.tracks.find((t5) => t5.target === ref.target && t5.id === ref.id && t5.prop === ref.prop);
-  if (!tr || tr.keys.some((k4) => typeof k4.v !== "number")) return null;
+  if (!tr || tr.keys.some((k4) => typeof k4.v !== "number" && !(Array.isArray(k4.v) && k4.v.every((v6) => typeof v6 === "number")))) return null;
+  const interpolation = /* @__PURE__ */ u4(
+    Sel,
+    {
+      label: "interpolation",
+      value: tr.interpolation ?? "segment",
+      options: [["segment", "per-key easing"], ["pchip", "smooth through keys"]],
+      onCommit: (v6) => void commit("rig_set_keys", { animation: a5.id, ...ref, interpolation: v6, keys: tr.keys })
+    }
+  );
+  if (tr.keys.some((k4) => typeof k4.v !== "number")) return /* @__PURE__ */ u4("div", { class: "track-adjust", children: [
+    /* @__PURE__ */ u4("h4", { children: [
+      "track \xB7 ",
+      ref.id,
+      ".",
+      ref.prop
+    ] }),
+    interpolation
+  ] });
   const cur = adjust.value.key === key ? adjust.value : { key, ...NEUTRAL };
   const vs = tr.keys.map((k4) => k4.v);
   const R2 = Math.max(1, Math.max(...vs) - Math.min(...vs));
@@ -52543,6 +52824,7 @@ function TrackSliders() {
       ".",
       ref.prop
     ] }),
+    interpolation,
     Object.keys(NEUTRAL).map((k4) => /* @__PURE__ */ u4(
       Slider,
       {
@@ -52559,7 +52841,7 @@ function TrackSliders() {
     ))
   ] });
 }
-var EASES = ["linear", "step", "ease_in", "ease_out", "ease_in_out", "back_out", "elastic_out", "bezier"];
+var EASES = ["linear", "step", "ease_in", "ease_out", "ease_in_out", "minimum_jerk", "back_out", "elastic_out", "bezier"];
 var BEZ_DEFAULT = [0.25, 0.1, 0.25, 1];
 var EW = 100;
 var EPAD = 15;
@@ -52619,6 +52901,26 @@ function KeyEase() {
   const tr = a5.tracks.find((k4) => k4.target === track.target && k4.id === track.id && k4.prop === track.prop);
   const key = tr?.keys.find((k4) => Math.abs(k4.t - times3[0]) < 1e-6);
   if (!key) return null;
+  if (tr?.interpolation === "pchip") return /* @__PURE__ */ u4(S, { children: [
+    /* @__PURE__ */ u4("h4", { children: [
+      "key ",
+      fmt2(key.t),
+      "s \xB7 ",
+      track.id,
+      ".",
+      track.prop
+    ] }),
+    /* @__PURE__ */ u4("p", { children: "Velocity is matched through neighbouring keys. Select per-key easing above to edit segment curves." }),
+    /* @__PURE__ */ u4(
+      Sel,
+      {
+        label: "segment",
+        value: key.ease === "step" ? "step" : "smooth",
+        options: [["smooth", "smooth"], ["step", "hold until next key"]],
+        onCommit: (v6) => void commit("rig_set_keys", { animation: a5.id, ...track, merge: true, keys: [{ t: key.t, v: key.v, ease: v6 === "step" ? "step" : "linear" }] })
+      }
+    )
+  ] });
   const bez = typeof key.ease === "string" ? BEZ_DEFAULT : key.ease.bezier;
   const set = (ease2) => void commit("rig_set_keys", {
     animation: a5.id,
@@ -53117,7 +53419,7 @@ var BoneGizmo = class {
   begin(handle, p6) {
     const skel = this.ctx.skel(), doc2 = this.ctx.shown(), st = skel.bones.get(this.boneId);
     if (!st) return;
-    const values = { x: st.x, y: st.y, rotation: st.rotation, scaleX: st.scaleX, scaleY: st.scaleY };
+    const values2 = { x: st.x, y: st.y, rotation: st.rotation, scaleX: st.scaleX, scaleY: st.scaleY };
     const parent = parentWorld(skel, doc2, this.boneId);
     const [lx, ly] = parent ? toLocal(parent, p6[0], p6[1]) : p6;
     this.patch = void 0;
@@ -53127,11 +53429,11 @@ var BoneGizmo = class {
       joint: [st.world.tx, st.world.ty],
       doc: doc2,
       skel,
-      values,
+      values: values2,
       time: this.ctx.time(),
       // parent-local, so the scale ratio ignores the parent's scale; the axis is whichever grip was grabbed (x or y)
-      axis: unit(lx - values.x, ly - values.y),
-      along: Math.hypot(lx - values.x, ly - values.y)
+      axis: unit(lx - values2.x, ly - values2.y),
+      along: Math.hypot(lx - values2.x, ly - values2.y)
     };
   }
   drag(p6, mods) {
@@ -53337,20 +53639,20 @@ var VertexGizmo = class {
     const anim = doc2.animations.find((a5) => a5.id === this.ctx.animId());
     const tr = anim?.tracks.find((x4) => x4.target === "deform" && x4.id === this.attachmentId && x4.prop === "vertices");
     if (!tr || !tr.keys.length) return void 0;
-    const v6 = sample(tr, t5);
+    const v6 = sample(tr, t5, !!anim?.loop && tr.keys[0].t === 0 && tr.keys.at(-1).t === anim.duration);
     return Array.isArray(v6) && v6.length === deformLength(att) && typeof v6[0] === "number" ? v6.slice() : void 0;
   }
   drag(p6, _mods) {
     const s6 = this.start;
     if (!s6) return this.ctx.shown();
-    const delta = [p6[0] - s6.p[0], p6[1] - s6.p[1]];
-    this.delta = delta;
+    const delta2 = [p6[0] - s6.p[0], p6[1] - s6.p[1]];
+    this.delta = delta2;
     if (this.ctx.mode() !== "animate") {
-      const patch = this.shift(s6, this.localDeltas(s6, delta));
+      const patch = this.shift(s6, this.localDeltas(s6, delta2));
       this.patch = patch;
       return s6.att.type === "path" ? setPathAttachment(s6.doc, this.attachmentId, s6.att.slot, { ...patch, closed: s6.att.closed }).doc : setMesh(s6.doc, this.attachmentId, patch).doc;
     }
-    this.offsets = this.localDeltas(s6, delta, s6.base?.slice()).map(round6);
+    this.offsets = this.localDeltas(s6, delta2, s6.base?.slice()).map(round6);
     const anim = this.ctx.animId();
     if (!anim) return s6.doc;
     return setKeys(
@@ -53368,9 +53670,9 @@ var VertexGizmo = class {
    * rather than handed over, so no future in-place writer downstream can spoil the next move's baseline.
    * Rebuilt from that base every move, so a gesture never accumulates.
    */
-  localDeltas(s6, delta, base) {
+  localDeltas(s6, delta2, base) {
     let out2 = base;
-    for (const i6 of s6.indices) out2 = deformOffsetsFor(s6.skel, s6.att, out2, i6, delta);
+    for (const i6 of s6.indices) out2 = deformOffsetsFor(s6.skel, s6.att, out2, i6, delta2);
     return out2 ?? [];
   }
   /**
@@ -53400,12 +53702,12 @@ var VertexGizmo = class {
     return { vertices: s6.att.vertices.map((v6, k4) => moved.has(k4 >> 1) ? round6(v6 + off[k4]) : v6) };
   }
   commit() {
-    const s6 = this.start, delta = this.delta, patch = this.patch, offsets = this.offsets;
+    const s6 = this.start, delta2 = this.delta, patch = this.patch, offsets = this.offsets;
     this.start = void 0;
     this.delta = void 0;
     this.patch = void 0;
     this.offsets = void 0;
-    if (!s6 || !delta || Math.hypot(delta[0], delta[1]) <= 1e-6) return void 0;
+    if (!s6 || !delta2 || Math.hypot(delta2[0], delta2[1]) <= 1e-6) return void 0;
     if (this.ctx.mode() !== "animate") {
       if (!patch) return void 0;
       return s6.att.type === "path" ? { tool: "rig_set_path_attachment", args: { id: this.attachmentId, slot: s6.att.slot, ...patch, closed: s6.att.closed } } : { tool: "rig_set_mesh", args: { id: this.attachmentId, ...patch } };
@@ -57351,6 +57653,7 @@ var import_gifenc = __toESM(require_gifenc(), 1);
 var AnimationState = class {
   constructor(sink, opts = {}) {
     this.sink = sink;
+    this.opts = opts;
     this.defaultMix = opts.mix ?? 0;
   }
   onEvent;
@@ -57375,11 +57678,18 @@ var AnimationState = class {
   }
   channel(id, loop2, priority = 0) {
     const anim = this.sink.doc.animations.find((a5) => a5.id === id);
-    if (!anim) throw new Error(`unknown animation "${id}"`);
+    if (!anim) {
+      const message = `unknown animation "${id}"; available: ${this.sink.doc.animations.map((a5) => a5.id).join(", ")}`;
+      if (this.opts.missingAnimation === "throw") throw new Error(message);
+      (this.opts.onWarning ?? console.warn)(message);
+      return void 0;
+    }
     return { anim, time: 0, loop: loop2 ?? anim.loop, done: false, priority, fresh: true };
   }
   setBase(id, opts = {}) {
-    this.base = id === void 0 ? void 0 : this.channel(id);
+    const next = id === void 0 ? void 0 : this.channel(id);
+    if (id !== void 0 && !next) return;
+    this.base = next;
     if (!this.main || this.main.done) {
       this.main = void 0;
       this.beginMix(opts.mix);
@@ -57388,6 +57698,16 @@ var AnimationState = class {
   }
   play(id, opts = {}) {
     const ch = this.channel(id, opts.loop, opts.priority ?? 0);
+    if (!ch) {
+      this.main?.settle?.("interrupted");
+      for (const queued of this.queue) queued.settle?.("dropped");
+      this.main = void 0;
+      this.queue = [];
+      this.beginMix(opts.mix);
+      this.update(0);
+      opts.onComplete?.("dropped");
+      return Promise.resolve("dropped");
+    }
     const promise2 = new Promise((resolve) => {
       ch.settle = (r5) => {
         ch.settle = void 0;
@@ -57408,7 +57728,10 @@ var AnimationState = class {
   /** Independent loop on top of the shown pose; `undefined` removes it. */
   setOverlay(name, id) {
     if (id === void 0) this.overlays.delete(name);
-    else this.overlays.set(name, this.channel(id));
+    else {
+      const ch = this.channel(id);
+      if (ch) this.overlays.set(name, ch);
+    }
   }
   /** Clear everything and show the setup pose. Pending plays resolve as "stopped". */
   stop() {
@@ -57493,6 +57816,7 @@ function hit(t5, prev, cur, d5, loop2) {
 // src/rig-runtime.ts
 var DEG4 = Math.PI / 180;
 var MESH_GRID = 9;
+var GHOST_ALPHA = 0.5;
 async function createTextures(doc2, loadSource) {
   const bySrc = /* @__PURE__ */ new Map(), out2 = /* @__PURE__ */ new Map();
   for (const a5 of doc2.assets) {
@@ -57532,7 +57856,7 @@ function atlasUV(asset, u6, v6, sourceW, sourceH) {
 var rgbOf = (c5) => Math.round(c5[0] * 255) << 16 | Math.round(c5[1] * 255) << 8 | Math.round(c5[2] * 255);
 var sameNumbers = (a5, b4) => a5 === b4 || a5.length === b4.length && a5.every((v6, i6) => v6 === b4[i6]);
 var RigPlayer = class {
-  /** `mix`: default crossfade seconds for state transitions (setBase, completion → base); play() passes its own */
+  /** Default crossfade is 0.18 seconds; explicit mix: 0 requests a hard cut. */
   constructor(doc2, textures, opts = {}) {
     this.doc = doc2;
     parse(doc2);
@@ -57571,7 +57895,7 @@ var RigPlayer = class {
       this.items.push(item);
       this.view.addChild(item.node);
     }
-    this.state = new AnimationState(this, { mix: opts.mix ?? 0 });
+    this.state = new AnimationState(this, { ...opts, mix: opts.mix ?? 0.18 });
     this.setPose(/* @__PURE__ */ new Map());
   }
   view = new Container();
@@ -57582,6 +57906,9 @@ var RigPlayer = class {
   pages = /* @__PURE__ */ new Map();
   /** slots the editor hides; honoured by setPose */
   hidden = /* @__PURE__ */ new Set();
+  /** slots the editor has selected; setPose draws them at GHOST_ALPHA at least */
+  ghosts = /* @__PURE__ */ new Set();
+  clipGraphics = /* @__PURE__ */ new Map();
   /** whole atlas page as a plain texture (identity uv mapping) for skinned meshes */
   pageTexture(tex) {
     let page = this.pages.get(tex.source);
@@ -57593,7 +57920,7 @@ var RigPlayer = class {
     this.state.onEvent = opts.onEvent;
     return this.state.play(animId2, {
       loop: opts.loop,
-      mix: opts.mix ?? 0,
+      mix: opts.mix,
       ifBusy: "interrupt",
       onComplete: (r5) => {
         if (r5 === "completed") opts.onComplete?.();
@@ -57622,6 +57949,10 @@ var RigPlayer = class {
     if (visible) this.hidden.delete(slotId);
     else this.hidden.add(slotId);
   }
+  /** Editor-only: draw these slots at GHOST_ALPHA at least, whatever the pose says (an empty list clears it). */
+  setGhostSlots(slotIds) {
+    this.ghosts = new Set(slotIds);
+  }
   /** Stop playback and immediately restore the complete setup pose. */
   stop() {
     this.state.stop();
@@ -57633,12 +57964,32 @@ var RigPlayer = class {
   /** Apply a pose (rest where silent) to the display objects. */
   setPose(pose2) {
     const skel = this.skel = evaluate(this.doc, pose2);
+    const clips = new Set(this.doc.slots.flatMap((s6) => s6.clip ? [s6.clip] : []));
+    for (const [id, g4] of this.clipGraphics) if (!clips.has(id)) {
+      g4.destroy();
+      this.clipGraphics.delete(id);
+    }
+    for (const id of clips) {
+      const att = this.doc.attachments.find((a5) => a5.id === id);
+      if (att?.type !== "path" || !att.closed) continue;
+      let g4 = this.clipGraphics.get(id);
+      if (!g4) {
+        g4 = new Graphics();
+        this.clipGraphics.set(id, g4);
+        this.view.addChild(g4);
+      }
+      const vertices = attachmentWorldVertices(skel, att.slot, att);
+      const n4 = Math.max(32, vertices.length * 4);
+      const points = samplePath(vertices, true, att.lengths, true, Array.from({ length: n4 }, (_4, i6) => i6 / n4), true);
+      g4.clear().poly(points.flatMap((p6) => [p6.x, p6.y]), true).fill(16777215);
+    }
     const m5 = new Matrix();
     const orderV = pose2.get(pk("drawOrder", "order", "order"));
     const order = /* @__PURE__ */ new Map();
     if (Array.isArray(orderV)) orderV.forEach((id, i6) => order.set(id, i6));
     for (const it of this.items) {
       const s6 = it.slot, shown2 = skel.attachment.get(s6.id);
+      it.node.mask = s6.clip ? this.clipGraphics.get(s6.clip) ?? null : null;
       if (shown2 !== it.att || this.hidden.has(s6.id)) {
         it.node.visible = false;
         continue;
@@ -57646,7 +57997,8 @@ var RigPlayer = class {
       it.node.visible = true;
       const colorV = pose2.get(pk("slot", s6.id, "color"));
       const color = Array.isArray(colorV) && typeof colorV[0] === "number" ? colorV : colorToArray(s6.color);
-      it.node.alpha = numOf(pose2, pk("slot", s6.id, "alpha"), s6.alpha) * color[3];
+      const alpha = numOf(pose2, pk("slot", s6.id, "alpha"), s6.alpha) * color[3];
+      it.node.alpha = this.ghosts.has(s6.id) ? Math.max(alpha, GHOST_ALPHA) : alpha;
       it.node.tint = rgbOf(color);
       it.node.zIndex = order.size ? order.get(s6.id) ?? 0 : numOf(pose2, pk("slot", s6.id, "z"), s6.z);
       if (it.skinned) {
@@ -57979,6 +58331,7 @@ var Stage = class {
     }));
     this.dispose.push(j3(() => {
       hiddenSlots.value;
+      selection.value;
       f3(() => this.applyPose());
     }));
     this.dispose.push(j3(() => {
@@ -58088,7 +58441,7 @@ var Stage = class {
     for (const l6 of this.labelPool.values()) l6.destroy();
     this.labelPool.clear();
     this.labels.removeChildren();
-    this.player = new RigPlayer(d5, this.textures);
+    this.player = new RigPlayer(d5, this.textures, { mix: 0 });
     this.structKey = structureKeyOf(d5);
     this.player.view.visible = !this.atlasOn;
     this.camera.addChildAt(this.player.view, 1);
@@ -58113,6 +58466,7 @@ var Stage = class {
     if (!p6 || !d5) return;
     const hidden = hiddenSlots.value;
     for (const s6 of d5.slots) p6.setSlotVisible(s6.id, !hidden.has(s6.id));
+    p6.setGhostSlots(playing.peek() ? [] : this.selectedSlots(d5));
     const anim = currentAnim.value;
     if (mode.value === "animate" && anim) {
       void p6.play(anim.id, { loop: loop.value });
@@ -58126,6 +58480,21 @@ var Stage = class {
     }
     this.drawOverlay();
   }
+  /**
+   * The slots the selection is about — a slot, the one an attachment (or a vertex of it) hangs in, or every slot on
+   * a selected bone. The player draws them half-visible at least, so a part faded out at rest (runes that only light
+   * up in `win`) is not an invisible box of grips. Not while playing: the animation's own fade is what is watched.
+   */
+  selectedSlots(d5) {
+    const sel = selection.peek();
+    if (sel?.kind === "slot") return [sel.id];
+    if (sel?.kind === "attachment" || sel?.kind === "vertex") {
+      const a5 = d5.attachments.find((a6) => a6.id === sel.id);
+      return a5 ? [a5.slot] : [];
+    }
+    if (sel?.kind === "bone") return d5.slots.filter((s6) => s6.bone === sel.id).map((s6) => s6.id);
+    return [];
+  }
   // ---------- reference underlay ----------
   reference;
   referenceSrc;
@@ -58204,6 +58573,25 @@ var Stage = class {
    * is on screen. The overlay (bones, labels, gizmos) is switched off for the duration, so nothing of the editor
    * ends up in it; the paper stays, which is what makes every pixel opaque — GIF has no partial transparency.
    */
+  async exportPng() {
+    if (!this.player || this.exporting) return;
+    const p6 = this.player, d5 = shown.peek();
+    if (!d5) return;
+    this.exporting = true;
+    const wasPlaying = playing.peek();
+    playing.value = false;
+    p6.setGhostSlots([]);
+    p6.setPose(pose.peek());
+    try {
+      return await this.app.renderer.extract.base64({ target: p6.view, frame: new Rectangle(0, 0, d5.meta.width, d5.meta.height), clearColor: [0, 0, 0, 0] });
+    } finally {
+      this.exporting = false;
+      if (!this.destroyed) {
+        playing.value = wasPlaying;
+        this.applyPose();
+      }
+    }
+  }
   async exportGif(fps = FPS) {
     const d5 = shown.peek(), anim = currentAnim.peek(), p6 = this.player;
     if (!p6 || !d5 || !anim || mode.peek() !== "animate") {
@@ -58215,12 +58603,13 @@ var Stage = class {
     const wasPlaying = playing.peek();
     playing.value = false;
     this.overlay.visible = false;
+    p6.setGhostSlots([]);
     try {
       const w5 = d5.meta.width, h6 = d5.meta.height, n4 = Math.max(1, Math.round(anim.duration * fps));
       const frame = new Rectangle(0, 0, w5, h6), gif = (0, import_gifenc.GIFEncoder)();
       for (let i6 = 0; i6 < n4; i6++) {
         if (this.destroyed) return;
-        void p6.play(anim.id, { loop: false });
+        void p6.play(anim.id, { loop: false, mix: 0 });
         p6.tick(i6 / fps);
         const { pixels } = this.app.renderer.extract.pixels({ target: this.camera, frame });
         const palette = (0, import_gifenc.quantize)(pixels, 256);
@@ -59380,7 +59769,7 @@ var Timeline = class {
       selectedTrack.value = ref;
       selectedKeys.value = [t5];
     });
-    void commit("rig_set_keys", { animation: id, ...ref, keys: [{ t: t5, v: sample(tr, t5), ease: prev?.ease }], merge: true });
+    void commit("rig_set_keys", { animation: id, ...ref, keys: [{ t: t5, v: sample(tr, t5, anim.loop && tr.keys[0].t === 0 && tr.keys.at(-1).t === anim.duration), ease: prev?.ease }], merge: true });
   }
   bindPointer() {
     const c5 = this.canvas;
@@ -59546,6 +59935,30 @@ async function exportGif() {
   a5.click();
   setTimeout(() => URL.revokeObjectURL(url), 1e4);
 }
+async function exportMp4() {
+  const animation = animId.peek();
+  if (!animation) {
+    setStatus("Select an animation first", "warn");
+    return;
+  }
+  const outFile = prompt("Save MP4 to (path relative to this rig, or absolute)", `../previews/${shown.peek()?.meta.name ?? "rig"}-${animation}.mp4`);
+  if (!outFile) return;
+  setStatus("Rendering MP4 at 60 fps\u2026");
+  try {
+    const r5 = await callTool(rigPath, "rig_export_video", { animation, outFile, fps: 60 });
+    setStatus(r5.text, r5.isError ? "warn" : "info");
+  } catch (e5) {
+    setStatus(String(e5), "warn");
+  }
+}
+async function exportPng() {
+  const url = await stage?.exportPng();
+  if (!url) return;
+  const a5 = document.createElement("a");
+  a5.href = url;
+  a5.download = `${shown.peek()?.meta.name ?? "rig"}.png`;
+  a5.click();
+}
 function setMode(m5) {
   if (m5 === "animate" && !shown.value?.animations.length) {
     setStatus("no animations \u2014 create one in the properties panel", "warn");
@@ -59772,6 +60185,8 @@ function TopBar() {
         children: "gif"
       }
     ),
+    /* @__PURE__ */ u4("button", { class: "mp4", onClick: click(() => void exportMp4()), children: "mp4 \xB7 60 fps" }),
+    /* @__PURE__ */ u4("button", { class: "png", title: "transparent PNG of the current pose", onClick: click(() => void exportPng()), children: "png" }),
     /* @__PURE__ */ u4("button", { class: "fit", title: "fit the document to the viewport (F)", onClick: click(() => stage?.fit()), children: "fit" }),
     /* @__PURE__ */ u4(
       "button",