@ikijs/editor 0.17.0 → 0.19.0

package/dist/index.mjs

@@ -2105,267 +2105,14 @@ var DEFAULT_TURN_TARGETS = Object.freeze({
   silhouetteRatio: 1
 });
 
-// src/auto-rig/roles.ts
-var ROLE_TABLE = [
-  { role: "hair_back", family: "hair_back" },
-  { role: "body", family: "body" },
-  { role: "arm_L", family: "arm", parts: ["arm_L", "forearm_L"] },
-  { role: "arm_R", family: "arm", parts: ["arm_R", "forearm_R"] },
-  { role: "face", family: "face", required: true },
-  { role: "blush_L", family: "face" },
-  { role: "blush_R", family: "face" },
-  { role: "nose", family: "nose" },
-  { role: "mouth", family: "mouth", required: true },
-  { role: "mouth_open", family: "mouth" },
-  { role: "eye_L", family: "eye_L", required: true },
-  { role: "eye_R", family: "eye_R", required: true },
-  { role: "iris_L", family: "eye_L" },
-  { role: "iris_R", family: "eye_R" },
-  { role: "pupil_L", family: "eye_L" },
-  { role: "pupil_R", family: "eye_R" },
-  { role: "highlight_L", family: "eye_L" },
-  { role: "highlight_R", family: "eye_R" },
-  { role: "lash_lower_L", family: "eye_L" },
-  { role: "lash_lower_R", family: "eye_R" },
-  { role: "lash_L", family: "eye_L" },
-  { role: "lash_R", family: "eye_R" },
-  { role: "brow_L", family: "brow_L" },
-  { role: "brow_R", family: "brow_R" },
-  { role: "hair_front", family: "hair_front" }
-];
-var REQUIRED_ROLES = ROLE_TABLE.filter(
-  (r) => r.required
-).map((r) => r.role);
-var SPEC_BY_ROLE = new Map(ROLE_TABLE.map((r, i) => [r.role, { ...r, i }]));
-function roleSpec(role) {
-  const spec = SPEC_BY_ROLE.get(role);
-  if (spec === void 0) throw new Error(`auto-rig: unknown role "${role}"`);
-  return spec;
-}
-function partIdsOfRole(role) {
-  return roleSpec(role).parts ?? [role];
-}
-var ROLE_BY_PART = new Map(
-  ROLE_TABLE.flatMap((r) => (r.parts ?? []).map((p) => [p, r.role]))
-);
-function roleOfPart(partId) {
-  return ROLE_BY_PART.get(partId) ?? partId;
-}
-var ALIASES = {
-  eyebrow_L: "brow_L",
-  eyebrow_R: "brow_R",
-  eye_white_L: "eye_L",
-  eye_white_R: "eye_R"
-};
-function roleOf(fileName) {
-  const role = fileName.replace(/\.[^.]+$/, "").toLowerCase().replace(/[-\s]+/g, "_").replace(/_([lr])$/, (_, s) => `_${s.toUpperCase()}`);
-  return ALIASES[role] ?? role;
-}
-function checkArmsHaveBody(roles) {
-  const has = new Set(roles);
-  if (has.has("body")) return;
-  const arm = ROLE_TABLE.find((r) => r.family === "arm" && has.has(r.role));
-  if (arm !== void 0) {
-    throw new Error(
-      `auto-rig: ${arm.role} needs a body layer (an arm hangs from the body's shoulder)`
-    );
-  }
-}
-function parseLayerRoles(fileNames) {
-  const seen = /* @__PURE__ */ new Map();
-  const out = [];
-  for (const fileName of fileNames) {
-    const role = roleOf(fileName);
-    if (!SPEC_BY_ROLE.has(role)) {
-      throw new Error(
-        `auto-rig: "${fileName}" names no known role (expected one of ${ROLE_TABLE.map((r) => r.role).join(", ")})`
-      );
-    }
-    const prior = seen.get(role);
-    if (prior !== void 0) {
-      throw new Error(
-        `auto-rig: role "${role}" is named twice ("${prior}" and "${fileName}")`
-      );
-    }
-    seen.set(role, fileName);
-    out.push({ role, fileName });
-  }
-  const missing = REQUIRED_ROLES.filter((r) => !seen.has(r));
-  if (missing.length > 0) {
-    throw new Error(
-      `auto-rig: missing required role${missing.length > 1 ? "s" : ""} ${missing.join(", ")}`
-    );
-  }
-  checkArmsHaveBody(seen.keys());
-  return out;
-}
-
-// src/auto-rig/generate.ts
-import {
-  IKI_FORMAT_VERSION as IKI_FORMAT_VERSION2,
-  StandardParameter as P6,
-  parseIkiModel as parseIkiModel3
-} from "@ikijs/format";
-
-// src/auto-rig/animations.ts
-import {
-  StandardParameter as P
-} from "@ikijs/format";
-function browsY(y) {
-  return [
-    { parameter: P.BrowLeftY, value: y, blend: "add" },
-    { parameter: P.BrowRightY, value: y, blend: "add" }
-  ];
-}
-function browsTilt(innerDown) {
-  return [
-    { parameter: P.BrowLeftAngle, value: innerDown, blend: "add" },
-    { parameter: P.BrowRightAngle, value: -innerDown, blend: "add" }
-  ];
-}
-function cheek(value) {
-  return { parameter: P.Cheek, value, blend: "add" };
-}
-var BROWS = [P.BrowLeftY, P.BrowRightY, P.BrowLeftAngle, P.BrowRightAngle];
-var EXPRESSIONS = [
-  {
-    id: "smile",
-    description: "Smiling and pleased: warm, friendly, content. For greetings, thanks, agreement and gentle happiness.",
-    parameters: [
-      { parameter: P.MouthForm, value: 1, blend: "add" },
-      ...browsY(0.25),
-      cheek(0.4)
-    ]
-  },
-  {
-    id: "laugh",
-    description: "Laughing, eyes shut and mouth open: delighted, amused. For jokes, playfulness and big joy.",
-    parameters: [
-      { parameter: P.EyeOpenLeft, value: 0, blend: "multiply" },
-      { parameter: P.EyeOpenRight, value: 0, blend: "multiply" },
-      { parameter: P.MouthForm, value: 1, blend: "add" },
-      { parameter: P.MouthOpen, value: 0.8, blend: "overwrite" },
-      ...browsY(0.4),
-      cheek(0.65)
-    ]
-  },
-  {
-    id: "angry",
-    description: "Angry or annoyed, frowning. For irritation, frustration, indignation or scolding.",
-    needs: BROWS,
-    parameters: [
-      ...browsY(-0.5),
-      ...browsTilt(0.8),
-      { parameter: P.MouthForm, value: -0.9, blend: "add" }
-    ]
-  },
-  {
-    id: "sad",
-    description: "Sad or disappointed, downcast. For sorrow, regret, apology or sympathy.",
-    needs: BROWS,
-    parameters: [
-      ...browsY(0.35),
-      ...browsTilt(-0.8),
-      { parameter: P.MouthForm, value: -0.8, blend: "add" }
-    ]
-  },
-  {
-    id: "surprised",
-    description: "Surprised, mouth dropped open: startled, amazed. For shock, sudden news or disbelief.",
-    parameters: [
-      ...browsY(0.8),
-      { parameter: P.MouthOpen, value: 0.9, blend: "overwrite" }
-    ]
-  },
-  {
-    id: "shy",
-    description: "Shy or embarrassed: bashful, flustered. For being praised, teased or caught off guard.",
-    needs: [P.Cheek],
-    parameters: [
-      cheek(1),
-      // Gaze down.
-      { parameter: P.EyeballY, value: -0.65, blend: "add" },
-      { parameter: P.MouthForm, value: 0.4, blend: "add" },
-      ...browsTilt(-0.25)
-    ]
-  }
-];
-function defaultExpressions(declared) {
-  return EXPRESSIONS.filter(
-    (e) => e.needs === void 0 || e.needs.some((id) => declared.has(id))
-  ).map(({ needs: _needs, ...e }) => ({
-    ...e,
-    parameters: e.parameters.filter((t) => declared.has(t.parameter))
-  }));
-}
-var DEFAULT_MOTIONS = {
-  Nod: [
-    {
-      description: "Nods yes: agreement, acknowledgement, understanding.",
-      duration: 1,
-      curves: [
-        {
-          parameter: P.AngleY,
-          keys: [
-            [0, 0],
-            [0.3, -18],
-            [0.6, 4],
-            [0.8, -1],
-            [1, 0]
-          ]
-        }
-      ]
-    }
-  ],
-  Shake: [
-    {
-      description: "Shakes the head no: disagreement, refusal, disbelief.",
-      duration: 1.2,
-      // The first swing peaks at 0.2 s, which the default fade would still
-      // be damping.
-      fadeIn: 0.15,
-      curves: [
-        {
-          parameter: P.AngleX,
-          keys: [
-            [0, 0],
-            [0.2, -18],
-            [0.45, 18],
-            [0.7, -16],
-            [0.95, 10],
-            [1.2, 0]
-          ]
-        }
-      ]
-    }
-  ],
-  Tilt: [
-    {
-      description: "Tilts the head to one side and back: curiosity, puzzlement, a question.",
-      duration: 1.4,
-      curves: [
-        {
-          parameter: P.AngleZ,
-          keys: [
-            [0, 0],
-            [0.35, 20],
-            [1, 20],
-            [1.4, 0]
-          ]
-        }
-      ]
-    }
-  ]
-};
-
 // src/auto-rig/arms.ts
 import {
-  StandardParameter as P4
+  StandardParameter as P3
 } from "@ikijs/format";
 
 // src/auto-rig/body.ts
 import {
-  StandardParameter as P3
+  StandardParameter as P2
 } from "@ikijs/format";
 
 // src/auto-rig/layout.ts
@@ -2443,7 +2190,7 @@ function meshPoints(mesh, box) {
 
 // src/auto-rig/drivers.ts
 import {
-  StandardParameter as P2
+  StandardParameter as P
 } from "@ikijs/format";
 var SWAY_RANGE = 20;
 var SWAY_CURVE = 1.4;
@@ -2522,13 +2269,13 @@ function gazeBindings(irisW, share = 1) {
   const gy = AMPLITUDE.gazeY * irisW * share;
   return [
     {
-      parameter: P2.EyeballX,
+      parameter: P.EyeballX,
       channel: "translateX",
       from: -round1(gx),
       to: round1(gx)
     },
     {
-      parameter: P2.EyeballY,
+      parameter: P.EyeballY,
       channel: "translateY",
       from: -round1(gy),
       to: round1(gy)
@@ -2542,8 +2289,8 @@ function browReach(hh) {
   return AMPLITUDE.brow * hh;
 }
 function browBindings(side, reach) {
-  const y = side === "L" ? P2.BrowLeftY : P2.BrowRightY;
-  const a = side === "L" ? P2.BrowLeftAngle : P2.BrowRightAngle;
+  const y = side === "L" ? P.BrowLeftY : P.BrowRightY;
+  const a = side === "L" ? P.BrowLeftAngle : P.BrowRightAngle;
   return [
     {
       parameter: y,
@@ -2559,7 +2306,7 @@ function mouthForm(mesh, box) {
   const a = 0.3 * bh(box);
   const c = cx(box);
   const half = bw(box) / 2;
-  return localWarp(P2.MouthForm, mesh, box, [-1, 0, 1], ([x], v) => {
+  return localWarp(P.MouthForm, mesh, box, [-1, 0, 1], ([x], v) => {
     if (v === 0) return [0, 0];
     const u = (x - c) / half;
     const widen = v > 0 ? 0.05 : 0.03;
@@ -2569,7 +2316,7 @@ function mouthForm(mesh, box) {
 function mouthOpenGrow(mesh, box) {
   const c = cx(box);
   return localWarp(
-    P2.MouthOpen,
+    P.MouthOpen,
     mesh,
     box,
     [0, 1],
@@ -2578,7 +2325,7 @@ function mouthOpenGrow(mesh, box) {
 }
 function mouthWiden(mesh, box) {
   const c = cx(box);
-  return localWarp(P2.MouthOpen, mesh, box, [0, 1], ([x], v) => [
+  return localWarp(P.MouthOpen, mesh, box, [0, 1], ([x], v) => [
     v * (AMPLITUDE.mouthOpenWidth - 1) * (x - c),
     0
   ]);
@@ -2596,7 +2343,7 @@ function hairSway(param, mesh, box, amp) {
   );
 }
 function tiltHang(mesh, box, pivot, weight, deg = ROLL_DEG) {
-  return localWarp(P2.AngleZ, mesh, box, Z_STOPS, ([x, y], v, i) => {
+  return localWarp(P.AngleZ, mesh, box, Z_STOPS, ([x, y], v, i) => {
     const g = weight(y, i);
     if (g === 0 || v === 0) return [0, 0];
     const a = -g * rollOf(v, deg);
@@ -2845,16 +2592,16 @@ function buildBodyWarp({
       points: ys.flatMap((y) => xs.flatMap((x) => [x, y]))
     },
     warps: [
-      warp(P3.BodyAngleX, BODY_STOPS, (x, _y, t) => [turn(x, t), 0]),
-      warp(P3.BodyAngleY, BODY_STOPS, (_x, _y, t) => [0, t * BODY.bow * hh]),
+      warp(P2.BodyAngleX, BODY_STOPS, (x, _y, t) => [turn(x, t), 0]),
+      warp(P2.BodyAngleY, BODY_STOPS, (_x, _y, t) => [0, t * BODY.bow * hh]),
       warp(
-        P3.BodyAngleZ,
+        P2.BodyAngleZ,
         BODY_STOPS,
         (x, y, t) => roll(x, y, -t * BODY.rollDeg)
       ),
-      warp(P3.AngleX, X_STOPS, (x, _y, t) => [BODY.followX * turn(x, t), 0]),
-      warp(P3.AngleZ, Z_STOPS, (x, y, t) => roll(x, y, -t * BODY.followRoll)),
-      warp(P3.Breath, [0, 1], (_x, _y, t) => [0, t * AMPLITUDE.breathBody * hh])
+      warp(P2.AngleX, X_STOPS, (x, _y, t) => [BODY.followX * turn(x, t), 0]),
+      warp(P2.AngleZ, Z_STOPS, (x, y, t) => roll(x, y, -t * BODY.followRoll)),
+      warp(P2.Breath, [0, 1], (_x, _y, t) => [0, t * AMPLITUDE.breathBody * hh])
     ]
   };
   refuseFold(body, deformer, anchor, [chin, ...pivots]);
@@ -2937,19 +2684,25 @@ function headOwnBreath(hasBody) {
 var ELBOW_AT = 0.42;
 var CAP_ROWS = [0.1, 0.3];
 var CAP_SEGMENTS = 12;
-var ARM_RANGE = [-30, 150];
+var CAP_INSET = 3;
+var capInset = (i) => Math.round(CAP_INSET * Math.min(1, Math.min(i, CAP_SEGMENTS - i) / 2));
+var CAP_RIM = 0.25;
+var ARM_RANGE = [-8, 32];
+var ELBOW_RANGE = [-10, 90];
 var ARM_PARAMS = {
-  arm_L: { arm: P4.ArmLeft, elbow: P4.ElbowLeft },
-  arm_R: { arm: P4.ArmRight, elbow: P4.ElbowRight }
+  arm_L: { arm: P3.ArmLeft, elbow: P3.ElbowLeft },
+  arm_R: { arm: P3.ArmRight, elbow: P3.ElbowRight }
 };
 var ARM_IDS = {
   arm_L: {
     forearm: "forearm_L",
+    cap: "elbow_L",
     armDeformer: "armDeformer_L",
     forearmDeformer: "forearmDeformer_L"
   },
   arm_R: {
     forearm: "forearm_R",
+    cap: "elbow_R",
     armDeformer: "armDeformer_R",
     forearmDeformer: "forearmDeformer_R"
   }
@@ -3002,11 +2755,30 @@ function armGeometry(layer, bodyAxisX) {
     b.x1 - elbow.x,
     b.y1 - elbow.y
   );
+  const inside = (x, y) => {
+    const k = Math.floor(y) - bbox.y;
+    if (k < 0 || k >= bbox.h) return false;
+    const [rs, re] = span(k);
+    return rs < x && x < re;
+  };
+  const capRays = Array.from({ length: CAP_SEGMENTS + 1 }, (_, i) => {
+    const a = Math.PI * i / CAP_SEGMENTS;
+    let t = 1;
+    while (t <= capRadius + CAP_INSET && inside(
+      elbow.x + canvasW / 2 + t * Math.cos(a),
+      canvasH / 2 - elbow.y - t * Math.sin(a)
+    )) {
+      t++;
+    }
+    return Math.min(capRadius, Math.max(1, t - capInset(i)));
+  });
   return {
     shoulder,
     shoulderRadius: ru,
     elbow,
     capRadius,
+    capRays,
+    seamRun: [s - bbox.x, e - bbox.x],
     side: shoulder.x > bodyAxisX ? 1 : -1
   };
 }
@@ -3021,73 +2793,358 @@ function armParts(role, layer, g, order) {
   const lx = (x) => roundTo((x - cx(b)) / bw(b), 1e-5);
   const ly = (y) => roundTo((y - cy(b)) / bh(b), 1e-5);
   const seam = ly(g.elbow.y);
-  const band = (top, bottom) => [
+  const band = (top2, bottom) => [
     -0.5,
-    top,
+    top2,
     0.5,
-    top,
+    top2,
     -0.5,
     bottom,
     0.5,
     bottom
   ];
   const quad = [2, 3, 0, 0, 3, 1];
-  const cap = [lx(g.elbow.x), seam];
+  const rays = g.capRays.length;
+  const top = (rays - 1) / 2;
+  const at = (i, r) => {
+    const a = Math.PI * i / (rays - 1);
+    return [lx(g.elbow.x + r * Math.cos(a)), ly(g.elbow.y + r * Math.sin(a))];
+  };
+  const width = (i) => Math.min(CAP_RIM * g.capRadius, g.capRays[i] / 2);
+  const ringRays = Array.from({ length: rays }, (_, i) => i);
+  ringRays.splice(top, 0, top);
+  const vertices = [lx(g.elbow.x), seam];
+  for (let i = 0; i < rays; i++) {
+    vertices.push(...at(i, g.capRays[i] - width(i)));
+  }
+  const ringInner = vertices.length / 2;
+  for (const i of ringRays) vertices.push(...at(i, g.capRays[i] - width(i)));
+  const ringOuter = vertices.length / 2;
+  for (const i of ringRays) vertices.push(...at(i, g.capRays[i]));
+  const { uvs } = meshOf(vertices, []);
+  const col = (c) => roundTo(Math.min(Math.max(c + 0.5, 0.5), bw(b) - 0.5) / bw(b), 1e-5);
+  const v = roundTo(0.5 - seam, 1e-5);
+  ringRays.forEach((i, j) => {
+    const right = j <= top;
+    const outer = right ? g.seamRun[1] : g.seamRun[0] - 1;
+    const step = right ? -width(i) : width(i);
+    uvs[(ringInner + j) * 2] = col(outer + step);
+    uvs[(ringInner + j) * 2 + 1] = v;
+    uvs[(ringOuter + j) * 2] = col(outer);
+    uvs[(ringOuter + j) * 2 + 1] = v;
+  });
   const fan = [];
-  for (let i = 0; i <= CAP_SEGMENTS; i++) {
-    const a = Math.PI * i / CAP_SEGMENTS;
-    cap.push(
-      lx(g.elbow.x + g.capRadius * Math.cos(a)),
-      ly(g.elbow.y + g.capRadius * Math.sin(a))
-    );
-    if (i > 0) fan.push(4, 4 + i, 5 + i);
-  }
-  const part = (id, deformer, at, mesh) => ({
+  for (let i = 0; i < rays - 1; i++) fan.push(0, 1 + i, 2 + i);
+  const ring = [];
+  for (let j = 0; j < ringRays.length - 1; j++) {
+    if (j === top) continue;
+    const [p, q] = [ringInner + j, ringOuter + j];
+    ring.push(p, q, q + 1, p, q + 1, p + 1);
+  }
+  const part = (id, deformer, z, mesh) => ({
     id,
     color: [1, 1, 1, 1],
     width: bw(b),
     height: bh(b),
     transform: { x: cx(b), y: cy(b) },
-    order: at,
+    order: z,
     deformer,
     mesh
   });
   const ids = ARM_IDS[role];
   return [
-    part(role, ids.armDeformer, order, meshOf(band(0.5, seam), quad)),
+    part(ids.cap, ids.forearmDeformer, order, {
+      vertices,
+      uvs,
+      indices: [...fan, ...ring]
+    }),
+    part(role, ids.armDeformer, order + 1, meshOf(band(0.5, seam), quad)),
     part(
       ids.forearm,
       ids.forearmDeformer,
-      order + 1,
-      meshOf([...band(seam, -0.5), ...cap], [...quad, ...fan])
+      order + 2,
+      meshOf(band(seam, -0.5), quad)
     )
   ];
 }
 function armDeformers(role, g) {
   const ids = ARM_IDS[role];
   const params = ARM_PARAMS[role];
-  const rotate = (parameter) => ({
+  const rotate = (parameter, range, sign) => ({
     parameter,
     channel: "rotate",
-    from: g.side * ARM_RANGE[0],
-    to: g.side * ARM_RANGE[1]
+    from: sign * range[0],
+    to: sign * range[1]
   });
   return [
     {
       id: ids.armDeformer,
       parent: BODY_WARP_ID,
       pivot: { ...g.shoulder },
-      bindings: [rotate(params.arm)]
+      bindings: [rotate(params.arm, ARM_RANGE, g.side)]
     },
     {
       id: ids.forearmDeformer,
       parent: ids.armDeformer,
       pivot: { ...g.elbow },
-      bindings: [rotate(params.elbow)]
+      bindings: [rotate(params.elbow, ELBOW_RANGE, -g.side)]
     }
   ];
 }
 
+// src/auto-rig/roles.ts
+var ROLE_TABLE = [
+  { role: "hair_back", family: "hair_back" },
+  { role: "body", family: "body" },
+  { role: "arm_L", family: "arm", parts: ["elbow_L", "arm_L", "forearm_L"] },
+  { role: "arm_R", family: "arm", parts: ["elbow_R", "arm_R", "forearm_R"] },
+  { role: "face", family: "face", required: true },
+  { role: "blush_L", family: "face" },
+  { role: "blush_R", family: "face" },
+  { role: "nose", family: "nose" },
+  { role: "mouth", family: "mouth", required: true },
+  { role: "mouth_open", family: "mouth" },
+  { role: "eye_L", family: "eye_L", required: true },
+  { role: "eye_R", family: "eye_R", required: true },
+  { role: "iris_L", family: "eye_L" },
+  { role: "iris_R", family: "eye_R" },
+  { role: "pupil_L", family: "eye_L" },
+  { role: "pupil_R", family: "eye_R" },
+  { role: "highlight_L", family: "eye_L" },
+  { role: "highlight_R", family: "eye_R" },
+  { role: "lash_lower_L", family: "eye_L" },
+  { role: "lash_lower_R", family: "eye_R" },
+  { role: "lash_L", family: "eye_L" },
+  { role: "lash_R", family: "eye_R" },
+  { role: "brow_L", family: "brow_L" },
+  { role: "brow_R", family: "brow_R" },
+  { role: "hair_front", family: "hair_front" }
+];
+var REQUIRED_ROLES = ROLE_TABLE.filter(
+  (r) => r.required
+).map((r) => r.role);
+var SPEC_BY_ROLE = new Map(ROLE_TABLE.map((r, i) => [r.role, { ...r, i }]));
+function roleSpec(role) {
+  const spec = SPEC_BY_ROLE.get(role);
+  if (spec === void 0) throw new Error(`auto-rig: unknown role "${role}"`);
+  return spec;
+}
+function partIdsOfRole(role) {
+  return roleSpec(role).parts ?? [role];
+}
+var ROLE_BY_PART = new Map(
+  ROLE_TABLE.flatMap((r) => (r.parts ?? []).map((p) => [p, r.role]))
+);
+function roleOfPart(partId) {
+  return ROLE_BY_PART.get(partId) ?? partId;
+}
+var ALIASES = {
+  eyebrow_L: "brow_L",
+  eyebrow_R: "brow_R",
+  eye_white_L: "eye_L",
+  eye_white_R: "eye_R"
+};
+function roleOf(fileName) {
+  const role = fileName.replace(/\.[^.]+$/, "").toLowerCase().replace(/[-\s]+/g, "_").replace(/_([lr])$/, (_, s) => `_${s.toUpperCase()}`);
+  return ALIASES[role] ?? role;
+}
+function checkArmsHaveBody(roles) {
+  const has = new Set(roles);
+  if (has.has("body")) return;
+  const arm = ROLE_TABLE.find((r) => r.family === "arm" && has.has(r.role));
+  if (arm !== void 0) {
+    throw new Error(
+      `auto-rig: ${arm.role} needs a body layer (an arm hangs from the body's shoulder)`
+    );
+  }
+}
+function parseLayerRoles(fileNames) {
+  const seen = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const fileName of fileNames) {
+    const role = roleOf(fileName);
+    if (!SPEC_BY_ROLE.has(role)) {
+      throw new Error(
+        `auto-rig: "${fileName}" names no known role (expected one of ${ROLE_TABLE.map((r) => r.role).join(", ")})`
+      );
+    }
+    const prior = seen.get(role);
+    if (prior !== void 0) {
+      throw new Error(
+        `auto-rig: role "${role}" is named twice ("${prior}" and "${fileName}")`
+      );
+    }
+    seen.set(role, fileName);
+    out.push({ role, fileName });
+  }
+  const missing = REQUIRED_ROLES.filter((r) => !seen.has(r));
+  if (missing.length > 0) {
+    throw new Error(
+      `auto-rig: missing required role${missing.length > 1 ? "s" : ""} ${missing.join(", ")}`
+    );
+  }
+  checkArmsHaveBody(seen.keys());
+  return out;
+}
+
+// src/auto-rig/generate.ts
+import {
+  IKI_FORMAT_VERSION as IKI_FORMAT_VERSION2,
+  StandardParameter as P6,
+  parseIkiModel as parseIkiModel3
+} from "@ikijs/format";
+
+// src/auto-rig/animations.ts
+import {
+  StandardParameter as P4
+} from "@ikijs/format";
+function browsY(y) {
+  return [
+    { parameter: P4.BrowLeftY, value: y, blend: "add" },
+    { parameter: P4.BrowRightY, value: y, blend: "add" }
+  ];
+}
+function browsTilt(innerDown) {
+  return [
+    { parameter: P4.BrowLeftAngle, value: innerDown, blend: "add" },
+    { parameter: P4.BrowRightAngle, value: -innerDown, blend: "add" }
+  ];
+}
+function cheek(value) {
+  return { parameter: P4.Cheek, value, blend: "add" };
+}
+var BROWS = [P4.BrowLeftY, P4.BrowRightY, P4.BrowLeftAngle, P4.BrowRightAngle];
+var EXPRESSIONS = [
+  {
+    id: "smile",
+    description: "Smiling and pleased: warm, friendly, content. For greetings, thanks, agreement and gentle happiness.",
+    parameters: [
+      { parameter: P4.MouthForm, value: 1, blend: "add" },
+      ...browsY(0.25),
+      cheek(0.4)
+    ]
+  },
+  {
+    id: "laugh",
+    description: "Laughing, eyes shut and mouth open: delighted, amused. For jokes, playfulness and big joy.",
+    parameters: [
+      { parameter: P4.EyeOpenLeft, value: 0, blend: "multiply" },
+      { parameter: P4.EyeOpenRight, value: 0, blend: "multiply" },
+      { parameter: P4.MouthForm, value: 1, blend: "add" },
+      { parameter: P4.MouthOpen, value: 0.8, blend: "overwrite" },
+      ...browsY(0.4),
+      cheek(0.65)
+    ]
+  },
+  {
+    id: "angry",
+    description: "Angry or annoyed, frowning. For irritation, frustration, indignation or scolding.",
+    needs: BROWS,
+    parameters: [
+      ...browsY(-0.5),
+      ...browsTilt(0.8),
+      { parameter: P4.MouthForm, value: -0.9, blend: "add" }
+    ]
+  },
+  {
+    id: "sad",
+    description: "Sad or disappointed, downcast. For sorrow, regret, apology or sympathy.",
+    needs: BROWS,
+    parameters: [
+      ...browsY(0.35),
+      ...browsTilt(-0.8),
+      { parameter: P4.MouthForm, value: -0.8, blend: "add" }
+    ]
+  },
+  {
+    id: "surprised",
+    description: "Surprised, mouth dropped open: startled, amazed. For shock, sudden news or disbelief.",
+    parameters: [
+      ...browsY(0.8),
+      { parameter: P4.MouthOpen, value: 0.9, blend: "overwrite" }
+    ]
+  },
+  {
+    id: "shy",
+    description: "Shy or embarrassed: bashful, flustered. For being praised, teased or caught off guard.",
+    needs: [P4.Cheek],
+    parameters: [
+      cheek(1),
+      // Gaze down.
+      { parameter: P4.EyeballY, value: -0.65, blend: "add" },
+      { parameter: P4.MouthForm, value: 0.4, blend: "add" },
+      ...browsTilt(-0.25)
+    ]
+  }
+];
+function defaultExpressions(declared) {
+  return EXPRESSIONS.filter(
+    (e) => e.needs === void 0 || e.needs.some((id) => declared.has(id))
+  ).map(({ needs: _needs, ...e }) => ({
+    ...e,
+    parameters: e.parameters.filter((t) => declared.has(t.parameter))
+  }));
+}
+var DEFAULT_MOTIONS = {
+  Nod: [
+    {
+      description: "Nods yes: agreement, acknowledgement, understanding.",
+      duration: 1,
+      curves: [
+        {
+          parameter: P4.AngleY,
+          keys: [
+            [0, 0],
+            [0.3, -18],
+            [0.6, 4],
+            [0.8, -1],
+            [1, 0]
+          ]
+        }
+      ]
+    }
+  ],
+  Shake: [
+    {
+      description: "Shakes the head no: disagreement, refusal, disbelief.",
+      duration: 1.2,
+      // The first swing peaks at 0.2 s, which the default fade would still
+      // be damping.
+      fadeIn: 0.15,
+      curves: [
+        {
+          parameter: P4.AngleX,
+          keys: [
+            [0, 0],
+            [0.2, -18],
+            [0.45, 18],
+            [0.7, -16],
+            [0.95, 10],
+            [1.2, 0]
+          ]
+        }
+      ]
+    }
+  ],
+  Tilt: [
+    {
+      description: "Tilts the head to one side and back: curiosity, puzzlement, a question.",
+      duration: 1.4,
+      curves: [
+        {
+          parameter: P4.AngleZ,
+          keys: [
+            [0, 0],
+            [0.35, 20],
+            [1, 20],
+            [1.4, 0]
+          ]
+        }
+      ]
+    }
+  ]
+};
+
 // src/auto-rig/checks.ts
 var finite = (v) => typeof v === "number" && Number.isFinite(v);
 var isObject = (v) => typeof v === "object" && v !== null;
@@ -5659,13 +5716,14 @@ function declareParameters(roles) {
     add(P6.BodyAngleZ, "Body Angle Z", -10, 10, 0);
   }
   const [armMin, armMax] = ARM_RANGE;
+  const [elbowMin, elbowMax] = ELBOW_RANGE;
   if (roles.has("arm_L")) {
     add(P6.ArmLeft, "Arm L", armMin, armMax, 0);
-    add(P6.ElbowLeft, "Elbow L", armMin, armMax, 0);
+    add(P6.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
   }
   if (roles.has("arm_R")) {
     add(P6.ArmRight, "Arm R", armMin, armMax, 0);
-    add(P6.ElbowRight, "Elbow R", armMin, armMax, 0);
+    add(P6.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
   }
   add(P6.EyeOpenLeft, "Eye L", 0, 1, 1);
   add(P6.EyeOpenRight, "Eye R", 0, 1, 1);
@@ -5726,6 +5784,7 @@ export {
   SetPhysicsRig,
   TurnTargetError,
   UV_INSET_PX,
+  armGeometry,
   captureBindingEndpoint,
   computeGridOffsets,
   createDefaultMatrixDeformer,