@ikijs/editor 0.18.0 → 0.20.0

package/dist/index.mjs

@@ -1565,7 +1565,13 @@ var ROW_RUN_ROLES = /* @__PURE__ */ new Set([
   "hair_back",
   "body",
   "arm_L",
-  "arm_R"
+  "arm_R",
+  "forearm_pose_L",
+  "forearm_pose_R"
+]);
+var REST_HIDDEN_ROLES = /* @__PURE__ */ new Set([
+  "forearm_pose_L",
+  "forearm_pose_R"
 ]);
 function createLayerSetMeasurer(canvas) {
   for (const field of ["width", "height"]) {
@@ -1596,6 +1602,7 @@ function createLayerSetMeasurer(canvas) {
     if (bbox === null) return null;
     const rowLeft = new Int32Array(canvasH).fill(canvasW);
     const rowRight = new Int32Array(canvasH).fill(-1);
+    const hidden = REST_HIDDEN_ROLES.has(role);
     const rowRuns = ROW_RUN_ROLES.has(role) ? [] : void 0;
     for (let y = 0; y < canvasH; y++) {
       let runs;
@@ -1611,14 +1618,14 @@ function createLayerSetMeasurer(canvas) {
           runs.push(x);
           inRun = on;
         }
-        if (!on) continue;
+        if (!on || hidden) continue;
         opaque[p] = 1;
         if (x < rowLeft[y]) rowLeft[y] = x;
         if (x > rowRight[y]) rowRight[y] = x;
       }
       if (runs !== void 0 && inRun) runs.push(canvasW);
     }
-    rowSpansByRole.push({ role, rowLeft, rowRight });
+    if (!hidden) rowSpansByRole.push({ role, rowLeft, rowRight });
     const layer = {
       role,
       fileName,
@@ -2684,7 +2691,11 @@ 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: P3.ArmLeft, elbow: P3.ElbowLeft },
   arm_R: { arm: P3.ArmRight, elbow: P3.ElbowRight }
@@ -2692,49 +2703,67 @@ var ARM_PARAMS = {
 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"
   }
 };
-function armGeometry(layer, bodyAxisX) {
+function endPivot(layer, end) {
   const { bbox, canvasW, canvasH, rowRuns } = layer;
-  const b = boxOfLayer(layer);
-  const span = (k) => {
+  const span = runSpan(layer);
+  const from = (k) => end === "top" ? k : bbox.h - 1 - k;
+  const painted = rowRuns?.flatMap((runs, k) => runs.length > 0 ? [k] : []) ?? [];
+  const firstK = end === "top" ? painted[0] ?? 0 : painted.at(-1) ?? bbox.h - 1;
+  const lo = Math.ceil(CAP_ROWS[0] * bbox.h);
+  const hi = Math.max(lo, Math.floor(CAP_ROWS[1] * bbox.h));
+  const widths = [];
+  for (let k = lo; k <= hi; k++) {
+    const [s2, e2] = span(from(k));
+    widths.push(e2 - s2);
+  }
+  widths.sort((p, q) => p - q);
+  const radius = widths[widths.length >> 1] / 2;
+  const ks = end === "top" ? firstK + radius : firstK - radius;
+  const [s, e] = span(Math.round(ks));
+  return {
+    point: {
+      x: roundTo((s + e) / 2 - canvasW / 2, 0.01),
+      y: roundTo(canvasH / 2 - (bbox.y + ks + 0.5), 0.01)
+    },
+    radius,
+    row: ks
+  };
+}
+function runSpan(layer) {
+  const { bbox, rowRuns } = layer;
+  return (k) => {
     const runs = rowRuns?.[k] ?? [];
     if (runs.length === 0) return [bbox.x, bbox.x + bbox.w];
-    let [s2, e2] = [runs[0], runs[1]];
+    let [s, e] = [runs[0], runs[1]];
     for (let i = 2; i < runs.length; i += 2) {
-      if (runs[i + 1] - runs[i] > e2 - s2) [s2, e2] = [runs[i], runs[i + 1]];
+      if (runs[i + 1] - runs[i] > e - s) [s, e] = [runs[i], runs[i + 1]];
     }
-    return [s2, e2];
+    return [s, e];
   };
+}
+function armGeometry(layer, bodyAxisX) {
+  const { bbox, canvasW, canvasH, rowRuns } = layer;
+  const b = boxOfLayer(layer);
+  const span = runSpan(layer);
   const centreX = (k) => {
     const [s2, e2] = span(k);
     return (s2 + e2) / 2 - canvasW / 2;
   };
   const rowY = (k) => canvasH / 2 - (bbox.y + k + 0.5);
   const painted = rowRuns?.flatMap((runs, k) => runs.length > 0 ? [k] : []) ?? [];
-  const first = painted[0] ?? 0;
   const last = painted.at(-1) ?? bbox.h - 1;
-  const lo = Math.ceil(CAP_ROWS[0] * bbox.h);
-  const hi = Math.max(lo, Math.floor(CAP_ROWS[1] * bbox.h));
-  const widths = [];
-  for (let k = lo; k <= hi; k++) {
-    const [s2, e2] = span(k);
-    widths.push(e2 - s2);
-  }
-  widths.sort((p, q) => p - q);
-  const ru = widths[widths.length >> 1] / 2;
-  const ks = first + ru;
-  const shoulder = {
-    x: roundTo(centreX(Math.round(ks)), 0.01),
-    y: roundTo(rowY(ks), 0.01)
-  };
+  const { point: shoulder, radius: ru, row: ks } = endPivot(layer, "top");
   const ke = Math.round(ks + ELBOW_AT * (last - ks));
   if (ke <= ks) {
     throw new LayerGeometryError(
@@ -2749,11 +2778,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
   };
 }
@@ -2763,84 +2811,190 @@ function meshOf(vertices, indices) {
   );
   return { vertices, uvs, indices };
 }
-function armParts(role, layer, g, order) {
+function armParts(role, layer, g, order, poseSwitch) {
   const b = boxOfLayer(layer);
   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, swaps = false) => ({
     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
+    mesh,
+    ...swaps && poseSwitch !== void 0 ? {
+      bindings: [
+        {
+          parameter: poseSwitch,
+          channel: "opacity",
+          from: 1,
+          to: 0
+        }
+      ]
+    } : {}
   });
   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]
+      },
+      true
+    ),
+    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),
+      true
     )
   ];
 }
+var rotateBinding = (parameter, range, sign) => ({
+  parameter,
+  channel: "rotate",
+  from: sign * range[0],
+  to: sign * range[1]
+});
 function armDeformers(role, g) {
   const ids = ARM_IDS[role];
   const params = ARM_PARAMS[role];
-  const rotate = (parameter) => ({
-    parameter,
-    channel: "rotate",
-    from: g.side * ARM_RANGE[0],
-    to: g.side * ARM_RANGE[1]
-  });
   return [
     {
       id: ids.armDeformer,
       parent: BODY_WARP_ID,
       pivot: { ...g.shoulder },
-      bindings: [rotate(params.arm)]
+      bindings: [rotateBinding(params.arm, ARM_RANGE, g.side)]
     },
     {
       id: ids.forearmDeformer,
       parent: ids.armDeformer,
       pivot: { ...g.elbow },
-      bindings: [rotate(params.elbow)]
+      bindings: [rotateBinding(params.elbow, ELBOW_RANGE, -g.side)]
     }
   ];
 }
 
+// src/auto-rig/forearm-pose.ts
+import {
+  StandardParameter as P4
+} from "@ikijs/format";
+var ARM_OF_POSE = {
+  forearm_pose_L: "arm_L",
+  forearm_pose_R: "arm_R"
+};
+var POSE_OF_ARM = {
+  arm_L: "forearm_pose_L",
+  arm_R: "forearm_pose_R"
+};
+var POSE_PARAMS = {
+  forearm_pose_L: { pose: P4.ArmPoseLeft, angle: P4.ArmPoseAngleLeft },
+  forearm_pose_R: { pose: P4.ArmPoseRight, angle: P4.ArmPoseAngleRight }
+};
+var POSE_IDS = {
+  forearm_pose_L: "armPoseDeformer_L",
+  forearm_pose_R: "armPoseDeformer_R"
+};
+var POSE_ANGLE_RANGE = [-15, 15];
+function forearmPoseGeometry(layer) {
+  const { point, radius } = endPivot(layer, "bottom");
+  const first = layer.rowRuns?.findIndex((runs) => runs.length > 0) ?? -1;
+  const k = first < 0 ? 0 : first;
+  return {
+    pivot: point,
+    radius,
+    top: roundTo(layer.canvasH / 2 - (layer.bbox.y + k + 0.5), 0.01)
+  };
+}
+function forearmPosePart(role, layer, order) {
+  const b = boxOfLayer(layer);
+  return {
+    id: role,
+    color: [1, 1, 1, 1],
+    width: bw(b),
+    height: bh(b),
+    transform: { x: cx(b), y: cy(b) },
+    order,
+    deformer: POSE_IDS[role],
+    bindings: [
+      { parameter: POSE_PARAMS[role].pose, channel: "opacity", from: 0, to: 1 }
+    ]
+  };
+}
+function forearmPoseDeformer(role, arm) {
+  return {
+    id: POSE_IDS[role],
+    parent: ARM_IDS[ARM_OF_POSE[role]].armDeformer,
+    pivot: { ...arm.elbow },
+    bindings: [
+      rotateBinding(POSE_PARAMS[role].angle, POSE_ANGLE_RANGE, -arm.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: ["arm_L", "forearm_L"] },
-  { role: "arm_R", family: "arm", parts: ["arm_R", "forearm_R"] },
+  { 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" },
@@ -2861,7 +3015,10 @@ var ROLE_TABLE = [
   { role: "lash_R", family: "eye_R" },
   { role: "brow_L", family: "brow_L" },
   { role: "brow_R", family: "brow_R" },
-  { role: "hair_front", family: "hair_front" }
+  { role: "hair_front", family: "hair_front" },
+  // Drawn above the face and the hair: a raised hand passes them.
+  { role: "forearm_pose_L", family: "forearm_pose" },
+  { role: "forearm_pose_R", family: "forearm_pose" }
 ];
 var REQUIRED_ROLES = ROLE_TABLE.filter(
   (r) => r.required
@@ -2901,6 +3058,16 @@ function checkArmsHaveBody(roles) {
     );
   }
 }
+function checkPosesHaveArms(roles) {
+  const has = new Set(roles);
+  for (const side of ["L", "R"]) {
+    if (has.has(`forearm_pose_${side}`) && !has.has(`arm_${side}`)) {
+      throw new Error(
+        `auto-rig: forearm_pose_${side} needs an arm_${side} layer (a pose forearm hangs from its arm's elbow)`
+      );
+    }
+  }
+}
 function parseLayerRoles(fileNames) {
   const seen = /* @__PURE__ */ new Map();
   const out = [];
@@ -2927,42 +3094,43 @@ function parseLayerRoles(fileNames) {
     );
   }
   checkArmsHaveBody(seen.keys());
+  checkPosesHaveArms(seen.keys());
   return out;
 }
 
 // src/auto-rig/generate.ts
 import {
   IKI_FORMAT_VERSION as IKI_FORMAT_VERSION2,
-  StandardParameter as P6,
+  StandardParameter as P7,
   parseIkiModel as parseIkiModel3
 } from "@ikijs/format";
 
 // src/auto-rig/animations.ts
 import {
-  StandardParameter as P4
+  StandardParameter as P5
 } from "@ikijs/format";
 function browsY(y) {
   return [
-    { parameter: P4.BrowLeftY, value: y, blend: "add" },
-    { parameter: P4.BrowRightY, value: y, blend: "add" }
+    { parameter: P5.BrowLeftY, value: y, blend: "add" },
+    { parameter: P5.BrowRightY, value: y, blend: "add" }
   ];
 }
 function browsTilt(innerDown) {
   return [
-    { parameter: P4.BrowLeftAngle, value: innerDown, blend: "add" },
-    { parameter: P4.BrowRightAngle, value: -innerDown, blend: "add" }
+    { parameter: P5.BrowLeftAngle, value: innerDown, blend: "add" },
+    { parameter: P5.BrowRightAngle, value: -innerDown, blend: "add" }
   ];
 }
 function cheek(value) {
-  return { parameter: P4.Cheek, value, blend: "add" };
+  return { parameter: P5.Cheek, value, blend: "add" };
 }
-var BROWS = [P4.BrowLeftY, P4.BrowRightY, P4.BrowLeftAngle, P4.BrowRightAngle];
+var BROWS = [P5.BrowLeftY, P5.BrowRightY, P5.BrowLeftAngle, P5.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" },
+      { parameter: P5.MouthForm, value: 1, blend: "add" },
       ...browsY(0.25),
       cheek(0.4)
     ]
@@ -2971,10 +3139,10 @@ var EXPRESSIONS = [
     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" },
+      { parameter: P5.EyeOpenLeft, value: 0, blend: "multiply" },
+      { parameter: P5.EyeOpenRight, value: 0, blend: "multiply" },
+      { parameter: P5.MouthForm, value: 1, blend: "add" },
+      { parameter: P5.MouthOpen, value: 0.8, blend: "overwrite" },
       ...browsY(0.4),
       cheek(0.65)
     ]
@@ -2986,7 +3154,7 @@ var EXPRESSIONS = [
     parameters: [
       ...browsY(-0.5),
       ...browsTilt(0.8),
-      { parameter: P4.MouthForm, value: -0.9, blend: "add" }
+      { parameter: P5.MouthForm, value: -0.9, blend: "add" }
     ]
   },
   {
@@ -2996,7 +3164,7 @@ var EXPRESSIONS = [
     parameters: [
       ...browsY(0.35),
       ...browsTilt(-0.8),
-      { parameter: P4.MouthForm, value: -0.8, blend: "add" }
+      { parameter: P5.MouthForm, value: -0.8, blend: "add" }
     ]
   },
   {
@@ -3004,18 +3172,18 @@ var EXPRESSIONS = [
     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" }
+      { parameter: P5.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],
+    needs: [P5.Cheek],
     parameters: [
       cheek(1),
       // Gaze down.
-      { parameter: P4.EyeballY, value: -0.65, blend: "add" },
-      { parameter: P4.MouthForm, value: 0.4, blend: "add" },
+      { parameter: P5.EyeballY, value: -0.65, blend: "add" },
+      { parameter: P5.MouthForm, value: 0.4, blend: "add" },
       ...browsTilt(-0.25)
     ]
   }
@@ -3028,14 +3196,14 @@ function defaultExpressions(declared) {
     parameters: e.parameters.filter((t) => declared.has(t.parameter))
   }));
 }
-var DEFAULT_MOTIONS = {
+var HEAD_MOTIONS = {
   Nod: [
     {
       description: "Nods yes: agreement, acknowledgement, understanding.",
       duration: 1,
       curves: [
         {
-          parameter: P4.AngleY,
+          parameter: P5.AngleY,
           keys: [
             [0, 0],
             [0.3, -18],
@@ -3056,7 +3224,7 @@ var DEFAULT_MOTIONS = {
       fadeIn: 0.15,
       curves: [
         {
-          parameter: P4.AngleX,
+          parameter: P5.AngleX,
           keys: [
             [0, 0],
             [0.2, -18],
@@ -3075,7 +3243,7 @@ var DEFAULT_MOTIONS = {
       duration: 1.4,
       curves: [
         {
-          parameter: P4.AngleZ,
+          parameter: P5.AngleZ,
           keys: [
             [0, 0],
             [0.35, 20],
@@ -3087,6 +3255,55 @@ var DEFAULT_MOTIONS = {
     }
   ]
 };
+var WAVE = {
+  Wave: [
+    {
+      description: "Waves hello with the right hand: greeting, goodbye, getting attention.",
+      duration: 2.2,
+      fadeIn: 0.15,
+      fadeOut: 0.15,
+      curves: [
+        {
+          parameter: P5.ArmPoseRight,
+          interpolation: "linear",
+          keys: [
+            [0, 0],
+            [0.15, 1],
+            [2.05, 1],
+            [2.2, 0]
+          ]
+        },
+        {
+          parameter: P5.ArmRight,
+          keys: [
+            [0, 0],
+            [0.4, 10],
+            [1.8, 10],
+            [2.2, 0]
+          ]
+        },
+        {
+          parameter: P5.ArmPoseAngleRight,
+          keys: [
+            [0, 0],
+            [0.5, 0],
+            [0.7, 12],
+            [1, -12],
+            [1.3, 12],
+            [1.7, 0],
+            [2.2, 0]
+          ]
+        }
+      ]
+    }
+  ]
+};
+function defaultMotions(declared) {
+  const waves = [P5.ArmRight, P5.ArmPoseRight, P5.ArmPoseAngleRight].every(
+    (id) => declared.has(id)
+  );
+  return waves ? { ...HEAD_MOTIONS, ...WAVE } : HEAD_MOTIONS;
+}
 
 // src/auto-rig/checks.ts
 var finite = (v) => typeof v === "number" && Number.isFinite(v);
@@ -3192,6 +3409,7 @@ function checkLayers(layers, canvas) {
     throw new Error(`auto-rig: missing required role(s) ${missing.join(", ")}`);
   }
   checkArmsHaveBody(seen);
+  checkPosesHaveArms(seen);
 }
 function checkHeadEdges(edges, byRole) {
   if (edges === void 0) return;
@@ -3309,7 +3527,7 @@ function checkStrandEdges(strand, irises, hair) {
 }
 
 // src/auto-rig/context.ts
-import { StandardParameter as P5 } from "@ikijs/format";
+import { StandardParameter as P6 } from "@ikijs/format";
 
 // src/auto-rig/head.ts
 function outerEdge(runs, axisX, side) {
@@ -4341,6 +4559,7 @@ function familyField(m, family) {
       return hairField(m, m.hairBack, NOD.hairBack);
     case "body":
     case "arm":
+    case "forearm_pose":
       return () => [0, 0];
   }
 }
@@ -4440,7 +4659,7 @@ function renderedLander(turn, parts, grids, from = /* @__PURE__ */ new Map()) {
     const family = roleSpec(role).family;
     const part = parts.find((p) => p.id === role);
     const g = grids.get(family);
-    const warp = part?.warps?.find((w) => w.parameter === P5.AngleX);
+    const warp = part?.warps?.find((w) => w.parameter === P6.AngleX);
     if (part === void 0 || part.mesh === void 0 || !g && !warp) {
       return x + field(role)(x, y, ax, 0)[0];
     }
@@ -5176,6 +5395,7 @@ var WARP_ID = {
 };
 var isGridFamily = (f) => f in WARP_ID;
 var isArm = (spec) => spec.family === "arm";
+var isPose = (spec) => spec.family === "forearm_pose";
 var GRID_PAD = 6;
 function generateIkiFromLayerSet(layers, canvas, options = {}) {
   checkLayers(layers, canvas);
@@ -5244,11 +5464,22 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     const layer = byRole.get(spec.role);
     if (layer === void 0) continue;
     if (isArm(spec)) {
+      const pose = POSE_OF_ARM[spec.role];
       parts.push(
-        ...armParts(spec.role, layer, arms.get(spec.role), parts.length)
+        ...armParts(
+          spec.role,
+          layer,
+          arms.get(spec.role),
+          parts.length,
+          has(pose) ? POSE_PARAMS[pose].pose : void 0
+        )
       );
       continue;
     }
+    if (isPose(spec)) {
+      parts.push(forearmPosePart(spec.role, layer, parts.length));
+      continue;
+    }
     const built = buildPart(
       spec,
       boxOfLayer(layer),
@@ -5301,7 +5532,7 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       part.mesh = bodyWarp.mesh;
       continue;
     }
-    if (family === "arm") continue;
+    if (family === "arm" || family === "forearm_pose") continue;
     part.deformer = "headDeformer";
     if (part.mesh === void 0) continue;
     const own = familyField(turn, family);
@@ -5318,10 +5549,10 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     canvas: { width: canvas.width, height: canvas.height },
     parameters,
     parts,
-    deformers: deformers(frame, grids, bodyWarp?.deformer, arms),
+    deformers: deformers(frame, grids, bodyWarp?.deformer, arms, byRole),
     ...has("hair_front") ? { physics: hairPhysics() } : {},
     expressions: defaultExpressions(new Set(parameters.map((p) => p.id))),
-    motions: DEFAULT_MOTIONS
+    motions: defaultMotions(new Set(parameters.map((p) => p.id)))
   };
   const valid = parseIkiModel3(model);
   if (hasNose && options.onTurnSolved) {
@@ -5338,14 +5569,14 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
 function turnWarps(mesh, b, fieldOf) {
   return [
     localWarp(
-      P6.AngleX,
+      P7.AngleX,
       mesh,
       b,
       X_STOPS,
       ([x, y], v, i) => v === 0 ? [0, 0] : [fieldOf(i)(x, y, v, 0)[0], 0]
     ),
     localWarp(
-      P6.AngleY,
+      P7.AngleY,
       mesh,
       b,
       Y_STOPS,
@@ -5393,7 +5624,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
   }
   if (mesh !== void 0) part.mesh = mesh;
   const side = spec.role.endsWith("_L") ? "L" : "R";
-  const eyeOpen = side === "L" ? P6.EyeOpenLeft : P6.EyeOpenRight;
+  const eyeOpen = side === "L" ? P7.EyeOpenLeft : P7.EyeOpenRight;
   const hh = frame.hh;
   switch (spec.role) {
     case "face":
@@ -5408,7 +5639,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
             headOwnRoll(byRole.has("body"))
           ),
           localWarp(
-            P6.Breath,
+            P7.Breath,
             mesh,
             b,
             [0, 1],
@@ -5455,8 +5686,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
       if (byRole.has("mouth_open")) {
         warps.push(mouthWiden(mesh, b));
         bindings.push(
-          { parameter: P6.MouthOpen, channel: "opacity", from: 1, to: 0 },
-          { parameter: P6.MouthOpen, channel: "opacity", from: 1, to: 0 }
+          { parameter: P7.MouthOpen, channel: "opacity", from: 1, to: 0 },
+          { parameter: P7.MouthOpen, channel: "opacity", from: 1, to: 0 }
         );
         extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       } else {
@@ -5466,19 +5697,19 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
         );
         bindings.push(
           {
-            parameter: P6.MouthOpen,
+            parameter: P7.MouthOpen,
             channel: "scaleY",
             from: 0,
             to: roundTo(grow, 0.01)
           },
           {
-            parameter: P6.MouthOpen,
+            parameter: P7.MouthOpen,
             channel: "scaleX",
             from: 0,
             to: roundTo(AMPLITUDE.mouthOpenWidth - 1, 0.01)
           },
           {
-            parameter: P6.MouthOpen,
+            parameter: P7.MouthOpen,
             channel: "translateY",
             from: 0,
             to: -roundTo(grow * bh(b) / 2, 0.01)
@@ -5490,7 +5721,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
     case "mouth_open":
       warps.push(mouthForm(mesh, b), mouthOpenGrow(mesh, b));
       bindings.push({
-        parameter: P6.MouthOpen,
+        parameter: P7.MouthOpen,
         channel: "opacity",
         from: 0,
         to: 1
@@ -5500,7 +5731,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
     case "blush_L":
     case "blush_R":
       bindings.push({
-        parameter: P6.Cheek,
+        parameter: P7.Cheek,
         channel: "opacity",
         from: AMPLITUDE.blushRest,
         to: 1
@@ -5511,8 +5742,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
       if (byRole.has("hair_front")) {
         const amp = style.sway * AMPLITUDE.sway * hh;
         warps.push(
-          hairSway(P6.HairSwayX, mesh, b, amp),
-          hairSway(P6.HairSwayZ, mesh, b, amp)
+          hairSway(P7.HairSwayX, mesh, b, amp),
+          hairSway(P7.HairSwayZ, mesh, b, amp)
         );
       }
       warps.push(tiltHang(mesh, b, pivot, hairHangWeight(frame.chinY, b.y0)));
@@ -5585,10 +5816,14 @@ function meshScale(role, frame) {
       return Infinity;
   }
 }
-function deformers(frame, grids, bodyWarp, arms) {
+function deformers(frame, grids, bodyWarp, arms, byRole) {
   const out = [];
   if (bodyWarp !== void 0) out.push(bodyWarp);
   for (const [role, g] of arms) out.push(...armDeformers(role, g));
+  for (const [role, arm] of arms) {
+    const pose = POSE_OF_ARM[role];
+    if (byRole.has(pose)) out.push(forearmPoseDeformer(pose, arm));
+  }
   const hasBody = bodyWarp !== void 0;
   const roll = headOwnRoll(hasBody);
   out.push({
@@ -5597,9 +5832,9 @@ function deformers(frame, grids, bodyWarp, arms) {
     pivot: { x: roundTo(frame.axisX, 0.01), y: roundTo(frame.chinY, 0.01) },
     bindings: [
       // AngleZ is clockwise-positive (Live2D's); a rotation is CCW-positive.
-      { parameter: P6.AngleZ, channel: "rotate", from: roll, to: -roll },
+      { parameter: P7.AngleZ, channel: "rotate", from: roll, to: -roll },
       {
-        parameter: P6.Breath,
+        parameter: P7.Breath,
         channel: "translateY",
         from: 0,
         to: roundTo(headOwnBreath(hasBody) * frame.hh, 0.01)
@@ -5617,8 +5852,8 @@ function deformers(frame, grids, bodyWarp, arms) {
         points: g.lattice.points
       },
       warp2d: {
-        parameter: P6.AngleX,
-        parameterY: P6.AngleY,
+        parameter: P7.AngleX,
+        parameterY: P7.AngleY,
         valuesX: X_STOPS,
         valuesY: Y_STOPS,
         keyforms2d: g.keyforms.map((offsets) => ({ offsets }))
@@ -5631,16 +5866,16 @@ function hairPhysics() {
   return [
     {
       id: "hairSway",
-      input: { parameter: P6.AngleX, weight: 1 },
-      output: { parameter: P6.HairSwayX, scale: 5 },
+      input: { parameter: P7.AngleX, weight: 1 },
+      output: { parameter: P7.HairSwayX, scale: 5 },
       mass: 1,
       stiffness: 30,
       damping: 3
     },
     {
       id: "hairTilt",
-      input: { parameter: P6.AngleZ, weight: 1 },
-      output: { parameter: P6.HairSwayZ, scale: 8 },
+      input: { parameter: P7.AngleZ, weight: 1 },
+      output: { parameter: P7.HairSwayZ, scale: 8 },
       mass: 1,
       stiffness: 25,
       damping: 2.5
@@ -5650,46 +5885,55 @@ function hairPhysics() {
 function declareParameters(roles) {
   const out = [];
   const add = (id, name, min, max, def) => out.push({ id, name, min, max, default: def });
-  add(P6.AngleX, "Head Angle", -30, 30, 0);
-  add(P6.AngleY, "Head Angle Y", -30, 30, 0);
-  add(P6.AngleZ, "Head Angle Z", -30, 30, 0);
+  add(P7.AngleX, "Head Angle", -30, 30, 0);
+  add(P7.AngleY, "Head Angle Y", -30, 30, 0);
+  add(P7.AngleZ, "Head Angle Z", -30, 30, 0);
   if (roles.has("body")) {
-    add(P6.BodyAngleX, "Body Angle X", -10, 10, 0);
-    add(P6.BodyAngleY, "Body Angle Y", -10, 10, 0);
-    add(P6.BodyAngleZ, "Body Angle Z", -10, 10, 0);
+    add(P7.BodyAngleX, "Body Angle X", -10, 10, 0);
+    add(P7.BodyAngleY, "Body Angle Y", -10, 10, 0);
+    add(P7.BodyAngleZ, "Body Angle Z", -10, 10, 0);
   }
+  const addPose = (side, pose, angle) => {
+    add(pose, `Arm Pose ${side}`, 0, 1, 0);
+    add(angle, `Arm Pose Angle ${side}`, ...POSE_ANGLE_RANGE, 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(P7.ArmLeft, "Arm L", armMin, armMax, 0);
+    add(P7.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
+    if (roles.has("forearm_pose_L"))
+      addPose("L", P7.ArmPoseLeft, P7.ArmPoseAngleLeft);
   }
   if (roles.has("arm_R")) {
-    add(P6.ArmRight, "Arm R", armMin, armMax, 0);
-    add(P6.ElbowRight, "Elbow R", armMin, armMax, 0);
+    add(P7.ArmRight, "Arm R", armMin, armMax, 0);
+    add(P7.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
+    if (roles.has("forearm_pose_R"))
+      addPose("R", P7.ArmPoseRight, P7.ArmPoseAngleRight);
   }
-  add(P6.EyeOpenLeft, "Eye L", 0, 1, 1);
-  add(P6.EyeOpenRight, "Eye R", 0, 1, 1);
+  add(P7.EyeOpenLeft, "Eye L", 0, 1, 1);
+  add(P7.EyeOpenRight, "Eye R", 0, 1, 1);
   if ([...roles].some((r) => /^(iris|pupil|highlight)_/.test(r))) {
-    add(P6.EyeballX, "Gaze X", -1, 1, 0);
-    add(P6.EyeballY, "Gaze Y", -1, 1, 0);
+    add(P7.EyeballX, "Gaze X", -1, 1, 0);
+    add(P7.EyeballY, "Gaze Y", -1, 1, 0);
   }
-  add(P6.MouthOpen, "Mouth Open", 0, 1, 0);
-  add(P6.MouthForm, "Mouth Form", -1, 1, 0);
+  add(P7.MouthOpen, "Mouth Open", 0, 1, 0);
+  add(P7.MouthForm, "Mouth Form", -1, 1, 0);
   if (roles.has("brow_L")) {
-    add(P6.BrowLeftY, "Brow L Y", -1, 1, 0);
-    add(P6.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
+    add(P7.BrowLeftY, "Brow L Y", -1, 1, 0);
+    add(P7.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
   }
   if (roles.has("brow_R")) {
-    add(P6.BrowRightY, "Brow R Y", -1, 1, 0);
-    add(P6.BrowRightAngle, "Brow R Angle", -1, 1, 0);
+    add(P7.BrowRightY, "Brow R Y", -1, 1, 0);
+    add(P7.BrowRightAngle, "Brow R Angle", -1, 1, 0);
   }
   if (roles.has("blush_L") || roles.has("blush_R")) {
-    add(P6.Cheek, "Cheek", 0, 1, 0);
+    add(P7.Cheek, "Cheek", 0, 1, 0);
   }
-  add(P6.Breath, "Breath", 0, 1, 0);
+  add(P7.Breath, "Breath", 0, 1, 0);
   if (roles.has("hair_front")) {
-    add(P6.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
-    add(P6.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(P7.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(P7.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
   }
   return out;
 }
@@ -5736,6 +5980,7 @@ export {
   createLayerSetMeasurer,
   denseCoreOf,
   detectAlphaBbox,
+  forearmPoseGeometry,
   foregroundSpan,
   generateIkiFromLayerSet,
   headHalfOf,