reframe-video 0.2.0 → 0.4.0

package/dist/index.js

@@ -15,22 +15,22 @@ function locate(segCount, u) {
   return { i, t: scaled - i };
 }
 function controls(points, closed, i) {
-  const n = points.length;
+  const n3 = points.length;
   const at = (k) => {
-    if (closed) return points[(k % n + n) % n];
-    return points[Math.max(0, Math.min(n - 1, k))];
+    if (closed) return points[(k % n3 + n3) % n3];
+    return points[Math.max(0, Math.min(n3 - 1, k))];
   };
   return [at(i - 1), at(i), at(i + 1), at(i + 2)];
 }
 function segCountOf(points, closed) {
-  const n = points.length;
-  if (n < 2) return 0;
-  return closed ? n : n - 1;
+  const n3 = points.length;
+  if (n3 < 2) return 0;
+  return closed ? n3 : n3 - 1;
 }
 function pathPoint(points, closed, u, curviness = 1) {
-  const n = points.length;
-  if (n === 0) return [0, 0];
-  if (n === 1) return [points[0][0], points[0][1]];
+  const n3 = points.length;
+  if (n3 === 0) return [0, 0];
+  if (n3 === 1) return [points[0][0], points[0][1]];
   const segs = segCountOf(points, closed);
   const { i, t } = locate(segs, u);
   const [p0, p1, p2, p3] = controls(points, closed, i);
@@ -49,8 +49,8 @@ function pathPoint(points, closed, u, curviness = 1) {
   return [H(p0[0], p1[0], p2[0], p3[0]), H(p0[1], p1[1], p2[1], p3[1])];
 }
 function pathTangentAngle(points, closed, u, curviness = 1) {
-  const n = points.length;
-  if (n < 2) return 0;
+  const n3 = points.length;
+  if (n3 < 2) return 0;
   const segs = segCountOf(points, closed);
   const { i, t } = locate(segs, u);
   const [p0, p1, p2, p3] = controls(points, closed, i);
@@ -816,7 +816,7 @@ function applyOverlay(ir, overlay, layer, report, baseNodeIds) {
       );
       continue;
     }
-    const index = ir.nodes.findIndex((n) => n.id === id);
+    const index = ir.nodes.findIndex((n3) => n3.id === id);
     if (index < 0) {
       orphan(
         `removeNodes.${id}`,
@@ -884,14 +884,14 @@ function makeRng(seed) {
 var clamp01 = (x) => Math.max(0, Math.min(1, x));
 var SET = 1 / 120;
 function ctx(o) {
-  const rand = makeRng((o.seed ?? 0) + 1);
+  const rand2 = makeRng((o.seed ?? 0) + 1);
   return {
     e: clamp01(o.energy ?? 0.5),
     sp: Math.max(0.25, o.speed ?? 1),
     it: clamp01(o.intensity ?? 0.5),
     from: o.from,
-    rand,
-    jit: (amp) => (rand() - 0.5) * 2 * amp,
+    rand: rand2,
+    jit: (amp) => (rand2() - 0.5) * 2 * amp,
     g: o.target.group,
     cx: o.target.center[0],
     cy: o.target.center[1],
@@ -1263,9 +1263,936 @@ function devicePreset(name, opts = {}) {
   );
 }
 
+// ../core/src/rig.ts
+var DEFAULT_LINE = "#FFE3D2";
+var DEFAULT_FILL = "#0E1424";
+var LINE_W = 5;
+var GLOW_W = 16;
+var K = 0.5523;
+var n = (v) => Number(v.toFixed(2));
+function capsulePath(hw, len) {
+  const yT = hw;
+  const yB = Math.max(hw, len - hw);
+  const k = hw * K;
+  return `M ${n(-hw)} ${n(yT)} C ${n(-hw)} ${n(yT - k)} ${n(-k)} ${n(yT - hw)} 0 ${n(yT - hw)} C ${n(k)} ${n(yT - hw)} ${n(hw)} ${n(yT - k)} ${n(hw)} ${n(yT)} L ${n(hw)} ${n(yB)} C ${n(hw)} ${n(yB + k)} ${n(k)} ${n(yB + hw)} 0 ${n(yB + hw)} C ${n(-k)} ${n(yB + hw)} ${n(-hw)} ${n(yB + k)} ${n(-hw)} ${n(yB)} Z`;
+}
+function ovalPath(a, b, cx = 0, cy = 0) {
+  const ka = n(a * K), kb = n(b * K);
+  const t = n(cy - b), bo = n(cy + b), c = n(cy), A = n(a), L = n(-a), X = n(cx);
+  return `M ${X} ${t} C ${n(cx + ka)} ${t} ${n(cx + A)} ${n(cy - kb)} ${n(cx + A)} ${c} C ${n(cx + A)} ${n(cy + kb)} ${n(cx + ka)} ${bo} ${X} ${bo} C ${n(cx - ka)} ${bo} ${n(cx + L)} ${n(cy + kb)} ${n(cx + L)} ${c} C ${n(cx + L)} ${n(cy - kb)} ${n(cx - ka)} ${t} ${X} ${t} Z`;
+}
+function boneShape(jointId, bone, o) {
+  if (bone.shape) return bone.shape;
+  const len = bone.length ?? 0;
+  if (len <= 0) return [];
+  const d = capsulePath((bone.width ?? 20) / 2, len);
+  const nodes = [];
+  if (o.glow) nodes.push(path({ id: `${jointId}-glow`, d, x: 0, y: 0, fill: "none", stroke: o.glow, strokeWidth: GLOW_W, opacity: 0.18 }));
+  nodes.push(path({ id: `${jointId}-shape`, d, x: 0, y: 0, fill: o.fill, stroke: o.color, strokeWidth: LINE_W }));
+  return nodes;
+}
+function buildBone(bone, id, o) {
+  const jointId = `${id}-${bone.name}`;
+  return group(
+    { id: jointId, x: bone.at[0], y: bone.at[1], rotation: bone.rotation ?? 0 },
+    [...boneShape(jointId, bone, o), ...(bone.children ?? []).map((c) => buildBone(c, id, o))]
+  );
+}
+function rig(root, opts = {}) {
+  const id = opts.id ?? "rig";
+  const o = { color: opts.color ?? DEFAULT_LINE, fill: opts.fill ?? DEFAULT_FILL, glow: opts.glow };
+  return group(
+    { id, x: opts.x ?? 0, y: opts.y ?? 0, scale: opts.scale ?? 1, opacity: opts.opacity ?? 1 },
+    [buildBone(root, id, o)]
+  );
+}
+function rigPose(id, pose) {
+  const out = {};
+  for (const [name, deg] of Object.entries(pose)) out[`${id}-${name}`] = { rotation: deg };
+  return out;
+}
+function poseTo(id, pose, opts = {}) {
+  const tweens = Object.entries(pose).map(
+    ([name, deg]) => tween(`${id}-${name}`, { rotation: deg }, { duration: opts.duration ?? 0.5, ease: opts.ease ?? "easeInOutCubic" })
+  );
+  return opts.stagger ? stagger(opts.stagger, ...tweens) : par(...tweens);
+}
+function ikReach(upper, lower, dx, dy, flip = false) {
+  const D = Math.hypot(dx, dy);
+  const cos2 = Math.max(-1, Math.min(1, (D * D - upper * upper - lower * lower) / (2 * upper * lower)));
+  const theta2 = (flip ? -1 : 1) * Math.acos(cos2);
+  const vx = -lower * Math.sin(theta2);
+  const vy = upper + lower * Math.cos(theta2);
+  const theta1 = Math.atan2(dy, dx) - Math.atan2(vy, vx);
+  const deg = (r) => r * 180 / Math.PI;
+  return [deg(theta1), deg(theta2)];
+}
+function humanoid(opts = {}) {
+  const line2 = opts.color ?? DEFAULT_LINE;
+  const fill = opts.fill ?? DEFAULT_FILL;
+  const glow = opts.glow;
+  const blob = (jid, a, b, cy) => {
+    const d = ovalPath(a, b, 0, cy);
+    const nodes = [];
+    if (glow) nodes.push(path({ id: `${jid}-glow`, d, x: 0, y: 0, fill: "none", stroke: glow, strokeWidth: GLOW_W, opacity: 0.18 }));
+    nodes.push(path({ id: `${jid}-shape`, d, x: 0, y: 0, fill, stroke: line2, strokeWidth: LINE_W }));
+    return nodes;
+  };
+  const id = opts.id ?? "rig";
+  const root = {
+    name: "chest",
+    at: [0, 0],
+    shape: blob(`${id}-chest`, 44, 62, 22),
+    children: [
+      { name: "head", at: [0, -42], rotation: 0, shape: blob(`${id}-head`, 40, 42, -34) },
+      { name: "armUpperL", at: [-42, -20], length: 60, width: 20, rotation: 10, children: [
+        { name: "armLowerL", at: [0, 60], length: 56, width: 16, rotation: 8 }
+      ] },
+      { name: "armUpperR", at: [42, -20], length: 60, width: 20, rotation: -10, children: [
+        { name: "armLowerR", at: [0, 60], length: 56, width: 16, rotation: -8 }
+      ] },
+      { name: "legUpperL", at: [-20, 76], length: 76, width: 26, rotation: 3, children: [
+        { name: "legLowerL", at: [0, 76], length: 72, width: 22, rotation: -2 }
+      ] },
+      { name: "legUpperR", at: [20, 76], length: 76, width: 26, rotation: -3, children: [
+        { name: "legLowerR", at: [0, 76], length: 72, width: 22, rotation: 2 }
+      ] }
+    ]
+  };
+  return rig(root, opts);
+}
+
+// ../core/src/characterPreset.ts
+var CHARACTER_PRESET_NAMES = ["walk", "run", "jump", "dance", "wave", "cheer"];
+var THIGH = 76;
+var SHIN = 72;
+var clamp012 = (x) => Math.max(0, Math.min(1, x));
+function makeRng2(seed) {
+  let a = seed >>> 0 || 2654435769;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var dur2 = (base, sp) => base / sp;
+function ctx2(o) {
+  const rand2 = makeRng2((o.seed ?? 0) + 1);
+  return {
+    g: o.target,
+    label: o.label,
+    e: clamp012(o.energy ?? 0.5),
+    sp: Math.max(0.25, o.speed ?? 1),
+    cycles: Math.max(1, Math.round(o.cycles ?? 4)),
+    facing: o.facing ?? 1,
+    at: o.at ?? [0, 0],
+    travel: o.travel,
+    rand: rand2,
+    jit: (amp) => (rand2() - 0.5) * 2 * amp
+  };
+}
+var round = (v) => Math.round(v * 1e3) / 1e3;
+function footPos(p, stride, lift) {
+  p = (p % 1 + 1) % 1;
+  if (p < 0.5) {
+    const u2 = p / 0.5;
+    return [stride * (1 - 2 * u2), 138];
+  }
+  const u = (p - 0.5) / 0.5;
+  return [-stride + 2 * stride * u, 138 - Math.sin(Math.PI * u) * lift];
+}
+function gaitPose(ph, stride, lift, armSwing, facing) {
+  const fl = footPos(ph, stride, lift);
+  const fr = footPos(ph + 0.5, stride, lift);
+  const [hipL, kneeL] = ikReach(THIGH, SHIN, facing * fl[0], fl[1], facing < 0);
+  const [hipR, kneeR] = ikReach(THIGH, SHIN, facing * fr[0], fr[1], facing < 0);
+  const swing = Math.cos(2 * Math.PI * ph);
+  return {
+    legUpperL: round(hipL),
+    legLowerL: round(kneeL),
+    legUpperR: round(hipR),
+    legLowerR: round(kneeR),
+    armUpperR: round(-10 - armSwing * swing),
+    armLowerR: -16,
+    armUpperL: round(10 + armSwing * swing),
+    armLowerL: 16
+  };
+}
+function gait(c, run) {
+  const stride = (run ? 34 : 24) + (run ? 40 : 30) * c.e + c.jit(3);
+  const lift = run ? 40 : 26;
+  const armSwing = (run ? 26 : 16) + 20 * c.e;
+  const halfDur = (run ? 0.26 : 0.42) + c.jit(0.02);
+  const lean = run ? c.facing * -6 : 0;
+  const steps = c.cycles * 2;
+  const d = dur2(halfDur, c.sp);
+  const intro = dur2(0.16, c.sp);
+  const keys = [];
+  for (let k = 0; k <= steps; k++) {
+    const pose = { ...gaitPose(k / 2, stride, lift, armSwing, c.facing), chest: lean };
+    keys.push(poseTo(c.g, pose, { duration: k === 0 ? intro : d, ease: k === 0 ? "easeOutQuad" : "linear" }));
+  }
+  const total = intro + steps * d;
+  const travel = c.travel ?? stride * 2;
+  const children = [seq(...keys)];
+  if (travel !== 0) {
+    children.push(tween(c.g, { x: c.at[0] + c.facing * travel * c.cycles }, { duration: total, ease: "linear", label: "travel" }));
+  }
+  return beat(run ? "run" : "walk", {}, [par(...children)]);
+}
+function jumpBeat(c) {
+  const h = 120 + 150 * c.e;
+  const [y0] = [c.at[1]];
+  const CROUCH = { legUpperL: 18, legLowerL: 54, legUpperR: -18, legLowerR: 54, armUpperL: 28, armUpperR: -28 };
+  const LAUNCH = { legUpperL: 0, legLowerL: 0, legUpperR: 0, legLowerR: 0, armUpperL: 150, armUpperR: -150 };
+  const TUCK = { legUpperL: -28, legLowerL: 66, legUpperR: -28, legLowerR: 66, armUpperL: 124, armUpperR: -124 };
+  const REST = { legUpperL: 3, legLowerL: -2, legUpperR: -3, legLowerR: 2, armUpperL: 10, armLowerL: 8, armUpperR: -10, armLowerR: -8 };
+  const j = c.jit(0.03);
+  return beat("jump", {}, [
+    seq(
+      par(poseTo(c.g, CROUCH, { duration: dur2(0.24, c.sp), ease: "easeOutQuad" }), tween(c.g, { y: y0 + 26 }, { duration: dur2(0.24, c.sp), ease: "easeOutQuad" })),
+      par(poseTo(c.g, LAUNCH, { duration: dur2(0.22 + j, c.sp), ease: "easeOutCubic" }), tween(c.g, { y: y0 - h }, { duration: dur2(0.36, c.sp), ease: "easeOutCubic", label: "launch" })),
+      poseTo(c.g, TUCK, { duration: dur2(0.22, c.sp) }),
+      par(poseTo(c.g, CROUCH, { duration: dur2(0.28, c.sp), ease: "easeInQuad" }), tween(c.g, { y: y0 + 18 }, { duration: dur2(0.3, c.sp), ease: "easeInCubic", label: "land" })),
+      par(poseTo(c.g, REST, { duration: dur2(0.45, c.sp), ease: "easeOutBack" }), tween(c.g, { y: y0 }, { duration: dur2(0.45, c.sp), ease: "easeOutBack" }))
+    )
+  ]);
+}
+function danceBeat(c) {
+  const y0 = c.at[1];
+  const sway = 8 + 6 * c.e;
+  const armUp = 130 + 30 * c.e;
+  const A = { chest: sway, head: -sway * 0.5, armUpperR: -armUp, armLowerR: -20, armUpperL: 40, armLowerL: 30, legUpperL: 8, legUpperR: -2 };
+  const B = { chest: -sway, head: sway * 0.5, armUpperL: armUp, armLowerL: 20, armUpperR: -40, armLowerR: -30, legUpperL: 2, legUpperR: -8 };
+  const d = dur2(0.34, c.sp);
+  const keys = [];
+  for (let k = 0; k < c.cycles * 2; k++) {
+    const pose = k % 2 === 0 ? A : B;
+    keys.push(par(
+      poseTo(c.g, pose, { duration: d, ease: "easeInOutQuad" }),
+      tween(c.g, { y: y0 - (k % 2 === 0 ? 14 : 0) }, { duration: d, ease: "easeInOutQuad" })
+    ));
+  }
+  keys.push(tween(c.g, { y: y0 }, { duration: d }));
+  return beat("dance", {}, [seq(...keys)]);
+}
+function waveBeat(c) {
+  const n3 = 3 + Math.round(c.rand() * 2);
+  const amp = 16 + 10 * c.e;
+  const steps = [poseTo(c.g, { armUpperR: -150, armLowerR: -24 }, { duration: dur2(0.4, c.sp), ease: "easeOutBack" })];
+  for (let k = 0; k < n3; k++) {
+    steps.push(poseTo(c.g, { armLowerR: -24 + (k % 2 === 0 ? amp : -amp) }, { duration: dur2(0.22, c.sp), ease: "easeInOutQuad" }));
+  }
+  steps.push(poseTo(c.g, { armUpperR: -10, armLowerR: -8 }, { duration: dur2(0.4, c.sp), ease: "easeInOutCubic" }));
+  return beat("wave", {}, [seq(...steps)]);
+}
+function cheerBeat(c) {
+  const y0 = c.at[1];
+  const UP = { armUpperL: 152, armLowerL: 8, armUpperR: -152, armLowerR: -8 };
+  const d = dur2(0.3, c.sp);
+  const keys = [poseTo(c.g, UP, { duration: dur2(0.35, c.sp), ease: "easeOutBack" })];
+  for (let k = 0; k < c.cycles; k++) {
+    keys.push(par(tween(c.g, { y: y0 - 28 }, { duration: d, ease: "easeOutQuad" }), poseTo(c.g, { armUpperL: 160, armUpperR: -160 }, { duration: d })));
+    keys.push(par(tween(c.g, { y: y0 }, { duration: d, ease: "easeInQuad" }), poseTo(c.g, { armUpperL: 145, armUpperR: -145 }, { duration: d })));
+  }
+  return beat("cheer", {}, [seq(...keys)]);
+}
+function characterPreset(name, opts) {
+  const c = ctx2(opts);
+  let tl;
+  switch (name) {
+    case "walk":
+      tl = gait(c, false);
+      break;
+    case "run":
+      tl = gait(c, true);
+      break;
+    case "jump":
+      tl = jumpBeat(c);
+      break;
+    case "dance":
+      tl = danceBeat(c);
+      break;
+    case "wave":
+      tl = waveBeat(c);
+      break;
+    case "cheer":
+      tl = cheerBeat(c);
+      break;
+    default: {
+      const _exhaustive = name;
+      throw new Error(`unknown characterPreset "${_exhaustive}"`);
+    }
+  }
+  return c.label && tl.kind === "beat" ? { ...tl, name: c.label } : tl;
+}
+
+// ../core/src/figure.ts
+var K2 = 0.5523;
+var n2 = (v) => Number(v.toFixed(2));
+function limb(a, b, y0, y1) {
+  const ka = n2(a * K2), kb = n2(b * K2);
+  return `M ${-a} ${y0} C ${-a} ${n2(y0 - ka)} ${-ka} ${n2(y0 - a)} 0 ${n2(y0 - a)} C ${ka} ${n2(y0 - a)} ${a} ${n2(y0 - ka)} ${a} ${y0} L ${b} ${y1} C ${b} ${n2(y1 + kb)} ${kb} ${n2(y1 + b)} 0 ${n2(y1 + b)} C ${-kb} ${n2(y1 + b)} ${-b} ${n2(y1 + kb)} ${-b} ${y1} Z`;
+}
+function rrect(a, b, y0, y1, r) {
+  return `M ${n2(-a + r)} ${y0} L ${n2(a - r)} ${y0} Q ${a} ${y0} ${a} ${n2(y0 + r)} L ${b} ${n2(y1 - r)} Q ${b} ${y1} ${n2(b - r)} ${y1} L ${n2(-b + r)} ${y1} Q ${-b} ${y1} ${-b} ${n2(y1 - r)} L ${-a} ${n2(y0 + r)} Q ${-a} ${y0} ${n2(-a + r)} ${y0} Z`;
+}
+function darken(hex, f) {
+  const h = hex.replace("#", "");
+  const v = parseInt(h.length === 3 ? [...h].map((c) => c + c).join("") : h, 16);
+  const ch = (s) => Math.max(0, Math.min(255, Math.round((v >> s & 255) * (1 - f))));
+  const hx = (x) => x.toString(16).padStart(2, "0");
+  return `#${hx(ch(16))}${hx(ch(8))}${hx(ch(0))}`;
+}
+var DEF = {
+  clean: { skin: "#E9B58E", hair: "#2B313F", top: "#E86C4A", pants: "#39425C", shoe: "#20242F", accent: "#E86C4A" },
+  cute: { skin: "#FFD2A6", hair: "#5B4636", top: "#FF7E5F", pants: "#3E6F8E", shoe: "#272B38", accent: "#FF7E5F" }
+};
+function resolvePal(style, p = {}) {
+  const d = DEF[style];
+  const accent = p.accent ?? d.accent;
+  const top = p.top ?? (style === "clean" ? accent : d.top);
+  const skin = p.skin ?? d.skin;
+  const hair = p.hair ?? d.hair;
+  const pants = p.pants ?? d.pants;
+  const shoe = p.shoe ?? d.shoe;
+  return {
+    skin,
+    skinSh: darken(skin, 0.12),
+    hair,
+    hairSh: darken(hair, 0.14),
+    top,
+    topSh: darken(top, 0.12),
+    pants,
+    pantsSh: darken(pants, 0.14),
+    shoe,
+    shoeSh: darken(shoe, 0.22),
+    eye: "#2B313F",
+    cheek: "#FF9E7E",
+    white: "#FFFFFF",
+    mouth: "#8A4233"
+  };
+}
+var fp = (id, d, fill, stroke, sw = 0, opacity = 1) => path({ id, d, x: 0, y: 0, fill, opacity, ...stroke && sw > 0 ? { stroke, strokeWidth: sw } : {} });
+function cleanParts(p, face) {
+  const HC = -42;
+  return {
+    upperArm: (j) => [fp(`${j}-sleeve`, limb(12, 10, 2, 58), p.top)],
+    forearm: (j) => [
+      fp(`${j}-elbow`, ovalPath(10, 10, 0, 3), p.skin),
+      fp(`${j}-fore`, limb(10, 8, 2, 48), p.skin),
+      fp(`${j}-hand`, ovalPath(11, 12, 0, 50), p.skin)
+    ],
+    thigh: (j) => [fp(`${j}-thigh`, limb(15, 13, 2, 72), p.pants)],
+    shin: (j) => [
+      fp(`${j}-knee`, ovalPath(13, 13, 0, 2), p.pants),
+      fp(`${j}-shin`, limb(13, 11, 2, 62), p.pants),
+      fp(`${j}-shoe`, ovalPath(15, 9, 4, 67), p.shoe)
+    ],
+    torso: (j) => [
+      fp(`${j}-shadow`, rrect(38, 26, -28, 52, 20), p.topSh),
+      fp(`${j}-top`, rrect(40, 27, -30, 52, 22), p.top),
+      fp(`${j}-pelvis`, rrect(29, 24, 46, 104, 14), p.pants)
+    ],
+    head: (j) => [
+      fp(`${j}-neck`, rrect(9, 9, 2, 22, 5), p.skin),
+      fp(`${j}-skin`, ovalPath(42, 46, 0, HC), p.skin),
+      fp(`${j}-hair`, ovalPath(44, 27, 0, HC - 31), p.hair),
+      fp(`${j}-hairL`, ovalPath(8, 14, -39, HC - 18), p.hair),
+      fp(`${j}-hairR`, ovalPath(8, 14, 39, HC - 18), p.hair),
+      ...face ? [fp(`${j}-eyeL`, ovalPath(5, 7, -14, HC + 2), p.eye), fp(`${j}-eyeR`, ovalPath(5, 7, 14, HC + 2), p.eye)] : []
+    ]
+  };
+}
+var CUTE_HAIR = "M -64 -54 C -78 -96 -50 -126 0 -126 C 50 -126 78 -96 64 -54 C 60 -34 48 -28 41 -33 C 35 -54 23 -60 9 -60 C 3 -60 -3 -60 -9 -60 C -23 -60 -35 -54 -41 -33 C -48 -28 -60 -34 -64 -54 Z";
+function cuteParts(p, face) {
+  const HC = -50;
+  return {
+    upperArm: (j) => [fp(`${j}-sleeve`, limb(15, 13, 2, 58), p.top, p.topSh, 2.5)],
+    forearm: (j) => [
+      fp(`${j}-elbow`, ovalPath(12, 12, 0, 3), p.skin, p.skinSh, 2.5),
+      fp(`${j}-fore`, limb(12, 10, 2, 46), p.skin, p.skinSh, 2.5),
+      fp(`${j}-hand`, ovalPath(13, 14, 0, 50), p.skin, p.skinSh, 2.5)
+    ],
+    thigh: (j) => [fp(`${j}-thigh`, limb(19, 16, 2, 72), p.pants, p.pantsSh, 2.5)],
+    shin: (j) => [
+      fp(`${j}-knee`, ovalPath(16, 16, 0, 2), p.pants, p.pantsSh, 2.5),
+      fp(`${j}-shin`, limb(15, 12, 2, 60), p.pants, p.pantsSh, 2.5),
+      fp(`${j}-shoe`, ovalPath(18, 11, 5, 66), p.shoe, darken(p.shoe, 0.25), 2.5)
+    ],
+    torso: (j) => [
+      fp(`${j}-shadow`, rrect(40, 34, -18, 52, 16), p.topSh),
+      fp(`${j}-top`, rrect(42, 35, -20, 52, 18), p.top, p.topSh, 2.5),
+      fp(`${j}-pelvis`, rrect(36, 30, 46, 104, 16), p.pants, p.pantsSh, 2.5)
+    ],
+    head: (j) => [
+      fp(`${j}-neck`, ovalPath(15, 12, 0, 12), p.skinSh),
+      fp(`${j}-skin`, ovalPath(42, 46, 0, HC + 4), p.skin, p.skinSh, 2.5),
+      fp(`${j}-cheekL`, ovalPath(11, 8, -40, HC + 22), p.cheek, void 0, 0, 0.5),
+      fp(`${j}-cheekR`, ovalPath(11, 8, 40, HC + 22), p.cheek, void 0, 0, 0.5),
+      fp(`${j}-hair`, CUTE_HAIR, p.hair, p.hairSh, 2),
+      ...face ? [
+        fp(`${j}-eyeL`, ovalPath(10, 13, -25, HC + 8), p.eye),
+        fp(`${j}-eyeR`, ovalPath(10, 13, 25, HC + 8), p.eye),
+        fp(`${j}-glL`, ovalPath(3.4, 3.4, -28, HC + 3), p.white),
+        fp(`${j}-glR`, ovalPath(3.4, 3.4, 22, HC + 3), p.white),
+        path({ id: `${j}-mouth`, d: "M -15 0 Q 0 15 15 0", x: 0, y: HC + 28, fill: "none", stroke: p.mouth, strokeWidth: 5 })
+      ] : []
+    ]
+  };
+}
+function buildSkeleton(id, S) {
+  const arm = (side, x, r1, r2) => ({
+    name: `armUpper${side}`,
+    at: [x, -14],
+    length: 60,
+    width: 0,
+    rotation: r1,
+    shape: S.upperArm(`${id}-armUpper${side}`),
+    children: [{ name: `armLower${side}`, at: [0, 60], length: 56, width: 0, rotation: r2, shape: S.forearm(`${id}-armLower${side}`) }]
+  });
+  const leg = (side, x, r1, r2) => ({
+    name: `legUpper${side}`,
+    at: [x, 76],
+    length: 76,
+    width: 0,
+    rotation: r1,
+    shape: S.thigh(`${id}-legUpper${side}`),
+    children: [{ name: `legLower${side}`, at: [0, 76], length: 72, width: 0, rotation: r2, shape: S.shin(`${id}-legLower${side}`) }]
+  });
+  return {
+    name: "chest",
+    at: [0, 0],
+    shape: S.torso(`${id}-chest`),
+    children: [
+      { name: "head", at: [0, -42], rotation: 0, shape: S.head(`${id}-head`) },
+      arm("L", -40, 8, 6),
+      arm("R", 40, -8, -6),
+      leg("L", -20, 3, -2),
+      leg("R", 20, -3, 2)
+    ]
+  };
+}
+function figure(opts = {}) {
+  const style = opts.style ?? "clean";
+  const pal = resolvePal(style, opts.palette);
+  const face = opts.face ?? true;
+  const id = opts.id ?? "figure";
+  const parts = style === "clean" ? cleanParts(pal, face) : cuteParts(pal, face);
+  const rigOpts = { id };
+  if (opts.x !== void 0) rigOpts.x = opts.x;
+  if (opts.y !== void 0) rigOpts.y = opts.y;
+  if (opts.scale !== void 0) rigOpts.scale = opts.scale;
+  if (opts.opacity !== void 0) rigOpts.opacity = opts.opacity;
+  return rig(buildSkeleton(id, parts), rigOpts);
+}
+
+// ../core/src/textMetrics.ts
+var INTER_ADVANCE = {
+  "400": {
+    "0": 63.09,
+    "1": 40.67,
+    "2": 60.99,
+    "3": 61.77,
+    "4": 64.6,
+    "5": 59.33,
+    "6": 62.01,
+    "7": 56.59,
+    "8": 61.87,
+    "9": 62.01,
+    " ": 28.13,
+    "!": 28.76,
+    '"': 46.58,
+    "#": 63.33,
+    "$": 64.16,
+    "%": 98.19,
+    "&": 64.4,
+    "'": 29.98,
+    "(": 36.47,
+    ")": 36.47,
+    "*": 50.1,
+    "+": 66.16,
+    ",": 28.81,
+    "-": 46,
+    ".": 28.81,
+    "/": 36.04,
+    ":": 28.81,
+    ";": 30.18,
+    "<": 66.16,
+    "=": 66.16,
+    ">": 66.16,
+    "?": 51.12,
+    "@": 96.58,
+    "A": 68.99,
+    "B": 65.43,
+    "C": 73.05,
+    "D": 72.17,
+    "E": 60.11,
+    "F": 59.03,
+    "G": 74.61,
+    "H": 74.32,
+    "I": 26.86,
+    "J": 57.08,
+    "K": 67.19,
+    "L": 56.54,
+    "M": 90.33,
+    "N": 75.34,
+    "O": 76.46,
+    "P": 63.87,
+    "Q": 76.46,
+    "R": 64.36,
+    "S": 64.16,
+    "T": 64.55,
+    "U": 74.41,
+    "V": 68.99,
+    "W": 98.54,
+    "X": 68.21,
+    "Y": 67.87,
+    "Z": 62.89,
+    "[": 36.47,
+    "\\": 36.04,
+    "]": 36.47,
+    "^": 47.12,
+    "_": 45.61,
+    "`": 32.28,
+    "a": 56.15,
+    "b": 61.23,
+    "c": 57.13,
+    "d": 61.23,
+    "e": 58.3,
+    "f": 37.01,
+    "g": 61.33,
+    "h": 59.13,
+    "i": 24.22,
+    "j": 24.22,
+    "k": 54.88,
+    "l": 24.22,
+    "m": 87.6,
+    "n": 59.08,
+    "o": 59.96,
+    "p": 61.23,
+    "q": 61.23,
+    "r": 37.65,
+    "s": 52.78,
+    "t": 32.71,
+    "u": 59.13,
+    "v": 56.2,
+    "w": 81.84,
+    "x": 54.59,
+    "y": 56.2,
+    "z": 55.22,
+    "{": 42.63,
+    "|": 33.25,
+    "}": 42.63,
+    "~": 66.16
+  },
+  "700": {
+    "0": 67.43,
+    "1": 43.12,
+    "2": 62.94,
+    "3": 64.55,
+    "4": 67.63,
+    "5": 62.21,
+    "6": 64.94,
+    "7": 58.15,
+    "8": 65.09,
+    "9": 64.94,
+    " ": 23.68,
+    "!": 33.79,
+    '"': 55.13,
+    "#": 64.89,
+    "$": 65.48,
+    "%": 101.56,
+    "&": 67.19,
+    "'": 33.89,
+    "(": 37.7,
+    ")": 37.7,
+    "*": 55.91,
+    "+": 67.87,
+    ",": 33.4,
+    "-": 46.78,
+    ".": 33.4,
+    "/": 38.82,
+    ":": 33.4,
+    ";": 34.28,
+    "<": 67.87,
+    "=": 67.87,
+    ">": 67.87,
+    "?": 55.96,
+    "@": 101.61,
+    "A": 74.66,
+    "B": 66.16,
+    "C": 73.97,
+    "D": 72.22,
+    "E": 60.74,
+    "F": 58.69,
+    "G": 75.05,
+    "H": 74.71,
+    "I": 28.08,
+    "J": 58.45,
+    "K": 71.92,
+    "L": 56.54,
+    "M": 93.16,
+    "N": 76.22,
+    "O": 77.05,
+    "P": 64.79,
+    "Q": 77.69,
+    "R": 65.67,
+    "S": 65.48,
+    "T": 66.75,
+    "U": 73.19,
+    "V": 74.66,
+    "W": 103.76,
+    "X": 73.83,
+    "Y": 73.1,
+    "Z": 66.41,
+    "[": 37.7,
+    "\\": 38.82,
+    "]": 37.7,
+    "^": 48.68,
+    "_": 47.61,
+    "`": 36.52,
+    "a": 58.06,
+    "b": 63.04,
+    "c": 58.84,
+    "d": 63.04,
+    "e": 59.57,
+    "f": 39.79,
+    "g": 63.18,
+    "h": 62.26,
+    "i": 27.1,
+    "j": 27.1,
+    "k": 58.01,
+    "l": 27.1,
+    "m": 91.26,
+    "n": 62.26,
+    "o": 61.33,
+    "p": 63.04,
+    "q": 63.04,
+    "r": 40.72,
+    "s": 56.01,
+    "t": 36.62,
+    "u": 62.26,
+    "v": 59.96,
+    "w": 85.01,
+    "x": 58.01,
+    "y": 60.21,
+    "z": 57.28,
+    "{": 46.88,
+    "|": 37.16,
+    "}": 46.88,
+    "~": 67.87
+  },
+  "800": {
+    "0": 69.19,
+    "1": 44.14,
+    "2": 63.77,
+    "3": 65.67,
+    "4": 68.85,
+    "5": 63.38,
+    "6": 66.16,
+    "7": 58.79,
+    "8": 66.41,
+    "9": 66.16,
+    " ": 21.88,
+    "!": 35.84,
+    '"': 58.64,
+    "#": 65.53,
+    "$": 66.02,
+    "%": 102.93,
+    "&": 68.31,
+    "'": 35.45,
+    "(": 38.23,
+    ")": 38.23,
+    "*": 58.25,
+    "+": 68.55,
+    ",": 35.25,
+    "-": 47.12,
+    ".": 35.25,
+    "/": 39.99,
+    ":": 35.25,
+    ";": 35.99,
+    "<": 68.55,
+    "=": 68.55,
+    ">": 68.55,
+    "?": 57.91,
+    "@": 103.61,
+    "A": 76.95,
+    "B": 66.46,
+    "C": 74.37,
+    "D": 72.27,
+    "E": 60.99,
+    "F": 58.54,
+    "G": 75.24,
+    "H": 74.85,
+    "I": 28.56,
+    "J": 58.98,
+    "K": 73.83,
+    "L": 56.54,
+    "M": 94.34,
+    "N": 76.56,
+    "O": 77.29,
+    "P": 65.19,
+    "Q": 78.17,
+    "R": 66.21,
+    "S": 66.02,
+    "T": 67.68,
+    "U": 72.71,
+    "V": 76.95,
+    "W": 105.86,
+    "X": 76.12,
+    "Y": 75.2,
+    "Z": 67.87,
+    "[": 38.23,
+    "\\": 39.99,
+    "]": 38.23,
+    "^": 49.32,
+    "_": 48.44,
+    "`": 38.23,
+    "a": 58.84,
+    "b": 63.77,
+    "c": 59.52,
+    "d": 63.77,
+    "e": 60.06,
+    "f": 40.97,
+    "g": 63.92,
+    "h": 63.53,
+    "i": 28.32,
+    "j": 28.32,
+    "k": 59.28,
+    "l": 28.32,
+    "m": 92.72,
+    "n": 63.53,
+    "o": 61.91,
+    "p": 63.77,
+    "q": 63.77,
+    "r": 41.99,
+    "s": 57.32,
+    "t": 38.18,
+    "u": 63.53,
+    "v": 61.52,
+    "w": 86.28,
+    "x": 59.42,
+    "y": 61.82,
+    "z": 58.11,
+    "{": 48.63,
+    "|": 38.77,
+    "}": 48.63,
+    "~": 68.55
+  }
+};
+var INTER_FALLBACK = {
+  "400": 56.16,
+  "700": 58.74,
+  "800": 59.79
+};
+
+// ../core/src/textFx.ts
+var clamp013 = (v) => Math.max(0, Math.min(1, v));
+var fract = (v) => v - Math.floor(v);
+var rand = (i, salt) => fract(Math.sin(i * 127.1 + salt * 311.7) * 43758.5453);
+var dur3 = (base, sp) => base / sp;
+var SCRAMBLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789#%&@";
+var advance = (ch, weight, fontSize) => (INTER_ADVANCE[weight]?.[ch] ?? INTER_FALLBACK[weight]) * (fontSize / 100);
+function splitText(textStr, opts) {
+  const { id, x, y, fontSize } = opts;
+  const weight = opts.fontWeight ?? 800;
+  const fill = opts.fill ?? "#FFFFFF";
+  const ls = opts.letterSpacing ?? 0;
+  const align = opts.align ?? "center";
+  const unit = opts.unit ?? "glyph";
+  const opacity = opts.opacity ?? 0;
+  const chars = [...textStr];
+  let total = 0;
+  chars.forEach((ch, i) => {
+    total += advance(ch, weight, fontSize) + (i < chars.length - 1 ? ls : 0);
+  });
+  let cursor = align === "center" ? x - total / 2 : x;
+  const glyphs = [];
+  const nodes = [];
+  const mk = (ch, cx, adv, lsProp) => {
+    const g = { id: `${id}-${glyphs.length}`, ch, x: cx, y, advance: adv, i: glyphs.length };
+    glyphs.push(g);
+    nodes.push(
+      text({
+        id: g.id,
+        x: cx,
+        y,
+        content: ch,
+        fontFamily: "Inter",
+        fontSize,
+        fontWeight: weight,
+        fill,
+        anchor: "center",
+        opacity,
+        ...lsProp ? { letterSpacing: lsProp } : {}
+      })
+    );
+  };
+  if (unit === "word") {
+    let i = 0;
+    while (i < chars.length) {
+      if (chars[i] === " ") {
+        cursor += advance(" ", weight, fontSize) + ls;
+        i++;
+        continue;
+      }
+      let word = "";
+      let w = 0;
+      const startCursor = cursor;
+      while (i < chars.length && chars[i] !== " ") {
+        const a = advance(chars[i], weight, fontSize);
+        word += chars[i];
+        w += a + (chars[i + 1] && chars[i + 1] !== " " ? ls : 0);
+        i++;
+      }
+      mk(word, startCursor + w / 2, w, ls);
+      cursor = startCursor + w + ls;
+    }
+  } else {
+    chars.forEach((ch) => {
+      const a = advance(ch, weight, fontSize);
+      if (ch !== " ") mk(ch, cursor + a / 2, a);
+      cursor += a + ls;
+    });
+  }
+  return { nodes, glyphs, ids: glyphs.map((g) => g.id), width: total, x, y, fontSize };
+}
+var ctx3 = (o) => ({
+  sp: Math.max(0.25, o.speed ?? 1),
+  e: clamp013(o.energy ?? 0.5),
+  seed: o.seed ?? 0,
+  fs: 0,
+  stag: o.stagger
+});
+var IN_STAGGER = { typewriter: 0.065, cascade: 0.04, rise: 0.03, bounce: 0.045, assemble: 0.05, decode: 0.05 };
+function glyphIn(name, g, c) {
+  const set = (props) => tween(g.id, props, { duration: 1e-3 });
+  const rs = (salt) => rand(g.i, salt + c.seed);
+  switch (name) {
+    case "typewriter":
+      return tween(g.id, { opacity: 1 }, { duration: dur3(0.04, c.sp), ease: "linear" });
+    case "cascade":
+      return seq(
+        set({ y: g.y + 56, opacity: 0 }),
+        par(
+          tween(g.id, { opacity: 1 }, { duration: dur3(0.22, c.sp), ease: "easeOutQuad" }),
+          tween(g.id, { y: g.y }, { duration: dur3(0.34, c.sp), ease: "easeOutCubic" })
+        )
+      );
+    case "rise":
+      return seq(
+        set({ y: g.y + 36, opacity: 0 }),
+        par(
+          tween(g.id, { opacity: 1 }, { duration: dur3(0.3, c.sp), ease: "easeOutQuad" }),
+          tween(g.id, { y: g.y }, { duration: dur3(0.4, c.sp), ease: "easeOutQuad" })
+        )
+      );
+    case "bounce":
+      return seq(
+        set({ y: g.y - 80 * (0.6 + c.e), opacity: 0, scale: 0.7 }),
+        par(
+          tween(g.id, { opacity: 1 }, { duration: dur3(0.2, c.sp), ease: "easeOutQuad" }),
+          tween(g.id, { y: g.y, scale: 1 }, { duration: dur3(0.7, c.sp), ease: "easeOutBounce" })
+        )
+      );
+    case "assemble":
+      return seq(
+        set({ x: g.x + (rs(11) - 0.5) * 1e3 * (0.5 + c.e), y: g.y + (rs(12) - 0.5) * 640, rotation: (rs(13) - 0.5) * 200, scale: 0.4, opacity: 0 }),
+        par(
+          tween(g.id, { opacity: 1 }, { duration: dur3(0.4, c.sp), ease: "easeOutQuad" }),
+          tween(g.id, { x: g.x, y: g.y, rotation: 0, scale: 1 }, { duration: dur3(0.8, c.sp), ease: "easeOutExpo" })
+        )
+      );
+    case "decode": {
+      const steps = 4 + Math.floor(rs(7) * 3);
+      const flicker = [set({ opacity: 1 })];
+      for (let k = 0; k < steps; k++) {
+        flicker.push(tween(g.id, { content: SCRAMBLE[Math.floor(rand(g.i, 20 + k + c.seed) * SCRAMBLE.length)] }, { duration: dur3(0.05, c.sp), ease: "linear" }));
+      }
+      flicker.push(tween(g.id, { content: g.ch }, { duration: dur3(0.05, c.sp), ease: "linear" }));
+      return seq(...flicker);
+    }
+  }
+}
+function textIn(name, block, opts = {}) {
+  const c = { ...ctx3(opts), fs: block.fontSize };
+  const interval = (c.stag ?? IN_STAGGER[name]) / c.sp;
+  return beat(opts.label ?? `text-in-${name}`, {}, [stagger(interval, ...block.glyphs.map((g) => glyphIn(name, g, c)))]);
+}
+function textLoop(name, block, opts = {}) {
+  const win = { ...opts.from !== void 0 && { from: opts.from }, ...opts.until !== void 0 && { until: opts.until }, ...opts.ramp !== void 0 && { ramp: opts.ramp } };
+  const f = opts.frequency ?? (name === "wave" ? 0.9 : name === "shimmer" ? 1.4 : 0.7);
+  const ps = opts.phaseStep ?? 0.55;
+  return block.glyphs.map((g, i) => {
+    switch (name) {
+      case "wave":
+        return oscillate(g.id, "y", { amplitude: opts.amplitude ?? 9, frequency: f, phase: i * ps }, win);
+      case "shimmer":
+        return oscillate(g.id, "opacity", { amplitude: opts.amplitude ?? 0.25, frequency: f, phase: i * ps }, win);
+      case "wobble":
+        return oscillate(g.id, "rotation", { amplitude: opts.amplitude ?? 6, frequency: f, phase: i * ps }, win);
+      case "float":
+        return oscillate(g.id, "y", { amplitude: opts.amplitude ?? 5, frequency: f, phase: i * ps }, win);
+    }
+  });
+}
+var OUT_STAGGER = { shatter: 0.02, fly: 0.012, dissolve: 0, fall: 0.02, collapse: 0.02 };
+function glyphOut(name, g, c, block, dir) {
+  const rs = (salt) => rand(g.i, salt + c.seed);
+  switch (name) {
+    case "shatter":
+      return par(
+        tween(g.id, { x: g.x + (rs(21) - 0.5) * 1100 * (0.6 + c.e), y: g.y + (rs(22) - 0.5) * 760 }, { duration: dur3(0.7, c.sp), ease: "easeInCubic" }),
+        tween(g.id, { rotation: (rs(23) - 0.5) * 300, opacity: 0 }, { duration: dur3(0.7, c.sp), ease: "easeInQuad" })
+      );
+    case "fly":
+      return par(
+        tween(g.id, { x: g.x + dir[0] * 1200, y: g.y + dir[1] * 1200 }, { duration: dur3(0.6, c.sp), ease: "easeInCubic" }),
+        tween(g.id, { opacity: 0 }, { duration: dur3(0.5, c.sp), ease: "easeInQuad" })
+      );
+    case "dissolve":
+      return seq(wait(rs(31) * 0.5), par(
+        tween(g.id, { opacity: 0 }, { duration: dur3(0.4, c.sp), ease: "easeInQuad" }),
+        tween(g.id, { scale: 1.4 }, { duration: dur3(0.4, c.sp), ease: "easeOutQuad" })
+      ));
+    case "fall":
+      return par(
+        tween(g.id, { y: g.y + 700 + rs(41) * 200 }, { duration: dur3(0.8, c.sp), ease: "easeInQuad" }),
+        tween(g.id, { rotation: (rs(42) - 0.5) * 120, opacity: 0 }, { duration: dur3(0.8, c.sp), ease: "easeInQuad" })
+      );
+    case "collapse":
+      return par(
+        tween(g.id, { x: block.x, y: block.y, scale: 0.2 }, { duration: dur3(0.5, c.sp), ease: "easeInBack" }),
+        tween(g.id, { opacity: 0 }, { duration: dur3(0.5, c.sp), ease: "easeInQuad" })
+      );
+  }
+}
+function textOut(name, block, opts = {}) {
+  const c = { ...ctx3(opts), fs: block.fontSize };
+  const dir = opts.dir ?? [0, -1];
+  const steps = block.glyphs.map((g) => glyphOut(name, g, c, block, dir));
+  const interval = (c.stag ?? OUT_STAGGER[name]) / c.sp;
+  const body = interval > 0 ? stagger(interval, ...steps) : par(...steps);
+  return beat(opts.label ?? `text-out-${name}`, {}, [body]);
+}
+function textTypeCues(block, opts) {
+  const interval = opts.interval ?? 0.065;
+  const gain = opts.gain ?? 0.4;
+  const off = opts.offset ?? 0;
+  const KEYS = ["001", "004", "007", "010", "014"];
+  return block.glyphs.map((g, i) => ({
+    at: opts.at,
+    offset: off + i * interval,
+    file: `keypress-${KEYS[i % KEYS.length]}.wav`,
+    gain: gain + 0.2 * rand(i, 31)
+  }));
+}
+
 // ../core/src/motionOps.ts
 var MOTION_OPS = ["rotate", "zoom", "ken-burns", "slide-in", "fade", "draw-on", "pulse"];
-var clamp012 = (n) => Math.max(0, Math.min(1, n));
+var clamp014 = (n3) => Math.max(0, Math.min(1, n3));
 function settleEase2(e) {
   return e < 0.34 ? "easeOutCubic" : e < 0.67 ? "easeOutBack" : "easeOutElastic";
 }
@@ -1283,7 +2210,7 @@ function fromVec2(from, dist) {
 }
 var motionOpLabel = (name, target) => `op-${name}-${target}`;
 function motionOp(name, target, opts = {}) {
-  const e = clamp012(opts.energy ?? 0.5);
+  const e = clamp014(opts.energy ?? 0.5);
   const sp = Math.max(0.25, opts.speed ?? 1);
   const amt = opts.amount ?? 1;
   const b = { scale: 1, x: 0, y: 0, rotation: 0, ...opts.base };
@@ -1493,8 +2420,8 @@ function valueNoise(x, seed) {
   const b = hash01(i + 1, seed) * 2 - 1;
   return a + (b - a) * u;
 }
-function hash01(n, seed) {
-  let h = n * 374761393 + seed * 668265263 | 0;
+function hash01(n3, seed) {
+  let h = n3 * 374761393 + seed * 668265263 | 0;
   h = h ^ h >>> 13 | 0;
   h = Math.imul(h, 1274126177);
   h = (h ^ h >>> 16) >>> 0;
@@ -1587,8 +2514,8 @@ function isColor(v) {
 function parseColor(hex) {
   let h = hex.slice(1);
   if (h.length <= 4) h = [...h].map((c) => c + c).join("");
-  const n = parseInt(h.padEnd(8, "f"), 16);
-  return [n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255];
+  const n3 = parseInt(h.padEnd(8, "f"), 16);
+  return [n3 >>> 24 & 255, n3 >>> 16 & 255, n3 >>> 8 & 255, n3 & 255];
 }
 function formatColor([r, g, b, a]) {
   const hex = (v) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, "0");
@@ -1608,19 +2535,68 @@ function lerpValue(from, to2, u) {
       a[3] + (b[3] - a[3]) * u
     ]);
   }
+  if (looksLikePath(from) && looksLikePath(to2)) {
+    const a = tokenizePath(from);
+    const b = tokenizePath(to2);
+    if (a && b && morphCompatible(a, b)) return morphPath(a, b, u);
+    return u < 0.5 ? from : to2;
+  }
   return to2;
 }
+var PATH_BODY = /^[\sMmLlHhVvCcSsQqTtAaZz0-9.,eE+-]+$/;
+function looksLikePath(v) {
+  return typeof v === "string" && /^\s*[Mm]/.test(v) && PATH_BODY.test(v);
+}
+var PATH_TOKEN = /([MmLlHhVvCcSsQqTtAaZz])|(-?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?)/g;
+function tokenizePath(d) {
+  const out = [];
+  let cur = null;
+  let m;
+  PATH_TOKEN.lastIndex = 0;
+  while (m = PATH_TOKEN.exec(d)) {
+    if (m[1]) out.push(cur = { cmd: m[1], nums: [] });
+    else if (m[2]) {
+      if (!cur) return null;
+      cur.nums.push(parseFloat(m[2]));
+    }
+  }
+  return out.length ? out : null;
+}
+function morphCompatible(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const ca = a[i];
+    const cb = b[i];
+    if (ca.cmd !== cb.cmd || ca.nums.length !== cb.nums.length) return false;
+    if (ca.cmd === "A" || ca.cmd === "a") return false;
+  }
+  return true;
+}
+var fmtNum = (v) => {
+  const r = Number(v.toFixed(3));
+  return Object.is(r, -0) ? "0" : String(r);
+};
+function morphPath(a, b, u) {
+  let s = "";
+  for (let i = 0; i < a.length; i++) {
+    const an = a[i].nums;
+    const bn = b[i].nums;
+    s += (i ? " " : "") + a[i].cmd;
+    for (let j = 0; j < an.length; j++) s += " " + fmtNum(an[j] + (bn[j] - an[j]) * u);
+  }
+  return s;
+}
 
 // ../core/src/evaluate.ts
 var IDENTITY = [1, 0, 0, 1, 0, 0];
-function multiply(m, n) {
+function multiply(m, n3) {
   return [
-    m[0] * n[0] + m[2] * n[1],
-    m[1] * n[0] + m[3] * n[1],
-    m[0] * n[2] + m[2] * n[3],
-    m[1] * n[2] + m[3] * n[3],
-    m[0] * n[4] + m[2] * n[5] + m[4],
-    m[1] * n[4] + m[3] * n[5] + m[5]
+    m[0] * n3[0] + m[2] * n3[1],
+    m[1] * n3[0] + m[3] * n3[1],
+    m[0] * n3[2] + m[2] * n3[3],
+    m[1] * n3[2] + m[3] * n3[3],
+    m[0] * n3[4] + m[2] * n3[5] + m[4],
+    m[1] * n3[4] + m[3] * n3[5] + m[5]
   ];
 }
 function localMatrix(x, y, rotationDeg, scale, scaleX = 1, scaleY = 1, skewXDeg = 0, skewYDeg = 0) {
@@ -1635,9 +2611,9 @@ function localMatrix(x, y, rotationDeg, scale, scaleX = 1, scaleY = 1, skewXDeg
   const tx = Math.tan(skewXDeg * Math.PI / 180);
   const ty = Math.tan(skewYDeg * Math.PI / 180);
   const R = [c, s, -s, c, 0, 0];
-  const K = [1, ty, tx, 1, 0, 0];
+  const K3 = [1, ty, tx, 1, 0, 0];
   const S = [scale * scaleX, 0, 0, scale * scaleY, 0, 0];
-  const m = multiply(R, multiply(K, S));
+  const m = multiply(R, multiply(K3, S));
   return [m[0], m[1], m[2], m[3], x, y];
 }
 var ANCHOR_FACTORS = {
@@ -1937,29 +2913,29 @@ function sketchToTimeline(sketch, nodeIds) {
   const steps = [];
   events.forEach((ev, i) => {
     const node = nodeIds[i % nodeIds.length];
-    const dur2 = Math.max(0.05, ev.t1 - ev.t0);
+    const dur4 = Math.max(0.05, ev.t1 - ev.t0);
     const ease = easeFor(ev.easing);
     let motion;
     switch (ev.kind) {
       case "enter":
-        motion = tween(node, { opacity: 1 }, { duration: dur2, ease });
+        motion = tween(node, { opacity: 1 }, { duration: dur4, ease });
         break;
       case "exit":
-        motion = tween(node, { opacity: 0 }, { duration: dur2, ease });
+        motion = tween(node, { opacity: 0 }, { duration: dur4, ease });
         break;
       case "emphasis": {
         const peak = 1 + Math.max(0.08, Math.min(0.5, ev.magnitude));
         motion = seq(
-          tween(node, { scale: peak }, { duration: dur2 / 2, ease: "easeOutCubic" }),
-          tween(node, { scale: 1 }, { duration: dur2 / 2, ease: "easeInOutQuad" })
+          tween(node, { scale: peak }, { duration: dur4 / 2, ease: "easeOutCubic" }),
+          tween(node, { scale: 1 }, { duration: dur4 / 2, ease: "easeInOutQuad" })
         );
         break;
       }
       case "scale":
-        motion = tween(node, { scale: 1 + Math.max(-0.5, Math.min(0.5, ev.magnitude)) }, { duration: dur2, ease });
+        motion = tween(node, { scale: 1 + Math.max(-0.5, Math.min(0.5, ev.magnitude)) }, { duration: dur4, ease });
         break;
       case "move":
-        motion = tween(node, { opacity: 1 }, { duration: dur2, ease });
+        motion = tween(node, { opacity: 1 }, { duration: dur4, ease });
         break;
     }
     steps.push(ev.t0 > 0 ? seq(wait(ev.t0), motion) : motion);
@@ -1967,6 +2943,7 @@ function sketchToTimeline(sketch, nodeIds) {
   return par(...steps);
 }
 export {
+  CHARACTER_PRESET_NAMES,
   DEFAULT_CROSSFADE,
   DEFAULT_FPS,
   DEFAULT_MOTIONPATH_DURATION,
@@ -1980,6 +2957,7 @@ export {
   SFX_DURATION,
   SceneValidationError,
   beat,
+  characterPreset,
   collectImageSrcs,
   compileComposition,
   compileScene,
@@ -1991,8 +2969,11 @@ export {
   deviceScreenCenter,
   ellipse,
   evaluate,
+  figure,
   formatComposeReport,
   group,
+  humanoid,
+  ikReach,
   image,
   isColor,
   lerpValue,
@@ -2003,21 +2984,30 @@ export {
   motionPreset,
   nodeParentMatrix,
   oscillate,
+  ovalPath,
   par,
   path,
   pathPoint,
   pathTangentAngle,
+  poseTo,
   rect,
   resolveAudioPlan,
   resolveCompositionAudioPlan,
   resolveEase,
+  rig,
+  rigPose,
   sampleBehavior,
   sampleProp,
   scene,
   seq,
   sketchToTimeline,
+  splitText,
   stagger,
   text,
+  textIn,
+  textLoop,
+  textOut,
+  textTypeCues,
   to,
   tween,
   validateComposition,