@ikijs/editor 0.19.0 → 0.21.0

package/dist/index.mjs

@@ -1565,7 +1565,16 @@ var ROW_RUN_ROLES = /* @__PURE__ */ new Set([
   "hair_back",
   "body",
   "arm_L",
-  "arm_R"
+  "arm_R",
+  "forearm_pose_L",
+  "forearm_pose_R",
+  "mouth_inner",
+  "lip_lower",
+  "lip_upper"
+]);
+var REST_HIDDEN_ROLES = /* @__PURE__ */ new Set([
+  "forearm_pose_L",
+  "forearm_pose_R"
 ]);
 function createLayerSetMeasurer(canvas) {
   for (const field of ["width", "height"]) {
@@ -1596,6 +1605,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 +1621,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,
@@ -2177,6 +2187,29 @@ function gridMesh(cols, rows) {
   }
   return { vertices, uvs, indices };
 }
+function columnMesh(b, grid) {
+  const { xs } = grid;
+  const rows = grid.ys.length - 1;
+  const vertices = [];
+  const uvs = [];
+  for (let r = 0; r <= rows; r++) {
+    for (const x of xs) {
+      const u = (x - b.x0) / bw(b);
+      vertices.push(roundTo(u - 0.5, 1e-5), roundTo(0.5 - r / rows, 1e-5));
+      uvs.push(roundTo(u, 1e-5), roundTo(r / rows, 1e-5));
+    }
+  }
+  const n = xs.length;
+  const indices = [];
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c + 1 < n; c++) {
+      const tl = r * n + c;
+      const bl = tl + n;
+      indices.push(bl, bl + 1, tl, tl, bl + 1, tl + 1);
+    }
+  }
+  return { vertices, uvs, indices };
+}
 function meshPoints(mesh, box) {
   const out = [];
   for (let i = 0; i < mesh.vertices.length; i += 2) {
@@ -2302,10 +2335,13 @@ function browBindings(side, reach) {
   ];
 }
 var BROW_TILT = 15;
-function mouthForm(mesh, box) {
-  const a = 0.3 * bh(box);
-  const c = cx(box);
-  const half = bw(box) / 2;
+var mouthFrameOf = (box) => ({
+  c: cx(box),
+  half: bw(box) / 2,
+  amp: 0.3 * bh(box)
+});
+function mouthForm(mesh, box, frame = mouthFrameOf(box)) {
+  const { c, half, amp: a } = frame;
   return localWarp(P.MouthForm, mesh, box, [-1, 0, 1], ([x], v) => {
     if (v === 0) return [0, 0];
     const u = (x - c) / half;
@@ -2323,8 +2359,8 @@ function mouthOpenGrow(mesh, box) {
     ([x, y], v) => v === 1 ? [(AMPLITUDE.mouthOpenWidth - 1) * (x - c), 0] : [0, box.y1 + (y - box.y1) * 0.2 - y]
   );
 }
-function mouthWiden(mesh, box) {
-  const c = cx(box);
+function mouthWiden(mesh, box, frame = mouthFrameOf(box)) {
+  const c = frame.c;
   return localWarp(P.MouthOpen, mesh, box, [0, 1], ([x], v) => [
     v * (AMPLITUDE.mouthOpenWidth - 1) * (x - c),
     0
@@ -2707,40 +2743,56 @@ var ARM_IDS = {
     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(
@@ -2788,7 +2840,7 @@ 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);
@@ -2841,7 +2893,7 @@ function armParts(role, layer, g, order) {
     const [p, q] = [ringInner + j, ringOuter + j];
     ring.push(p, q, q + 1, p, q + 1, p + 1);
   }
-  const part = (id, deformer, z, mesh) => ({
+  const part = (id, deformer, z, mesh, swaps = false) => ({
     id,
     color: [1, 1, 1, 1],
     width: bw(b),
@@ -2849,50 +2901,126 @@ function armParts(role, layer, g, order) {
     transform: { x: cx(b), y: cy(b) },
     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(ids.cap, ids.forearmDeformer, order, {
-      vertices,
-      uvs,
-      indices: [...fan, ...ring]
-    }),
+    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 + 2,
-      meshOf(band(seam, -0.5), quad)
+      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, range, sign) => ({
-    parameter,
-    channel: "rotate",
-    from: sign * range[0],
-    to: sign * range[1]
-  });
   return [
     {
       id: ids.armDeformer,
       parent: BODY_WARP_ID,
       pivot: { ...g.shoulder },
-      bindings: [rotate(params.arm, ARM_RANGE, g.side)]
+      bindings: [rotateBinding(params.arm, ARM_RANGE, g.side)]
     },
     {
       id: ids.forearmDeformer,
       parent: ids.armDeformer,
       pivot: { ...g.elbow },
-      bindings: [rotate(params.elbow, ELBOW_RANGE, -g.side)]
+      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 LIP_ROLES = ["mouth_inner", "lip_lower", "lip_upper"];
+var isLipRole = (role) => LIP_ROLES.includes(role);
 var ROLE_TABLE = [
   { role: "hair_back", family: "hair_back" },
   { role: "body", family: "body" },
@@ -2902,8 +3030,14 @@ var ROLE_TABLE = [
   { role: "blush_L", family: "face" },
   { role: "blush_R", family: "face" },
   { role: "nose", family: "nose" },
-  { role: "mouth", family: "mouth", required: true },
+  { role: "mouth", family: "mouth" },
   { role: "mouth_open", family: "mouth" },
+  // The lip set, back to front: the interior, the lower lip's skin, the upper
+  // lip and its line over both. It folds open instead of crossfading
+  // (`mouth.ts`), so it stands in for `mouth`, never beside it.
+  { role: "mouth_inner", family: "mouth" },
+  { role: "lip_lower", family: "mouth" },
+  { role: "lip_upper", family: "mouth" },
   { role: "eye_L", family: "eye_L", required: true },
   { role: "eye_R", family: "eye_R", required: true },
   { role: "iris_L", family: "eye_L" },
@@ -2918,7 +3052,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
@@ -2958,6 +3095,39 @@ function checkArmsHaveBody(roles) {
     );
   }
 }
+function checkMouth(roles) {
+  const has = new Set(roles);
+  const present = LIP_ROLES.filter((r) => has.has(r));
+  if (present.length === 0) {
+    if (!has.has("mouth")) {
+      throw new Error(
+        `auto-rig: missing required role mouth (or the lip set ${LIP_ROLES.join(", ")})`
+      );
+    }
+    return;
+  }
+  if (present.length < LIP_ROLES.length) {
+    throw new Error(
+      `auto-rig: the lip set is partial: missing ${LIP_ROLES.filter((r) => !has.has(r)).join(", ")}`
+    );
+  }
+  const mixed = ["mouth", "mouth_open"].filter((r) => has.has(r));
+  if (mixed.length > 0) {
+    throw new Error(
+      `auto-rig: the lip set cannot be mixed with ${mixed.join(", ")} (the lip set replaces the mouth drawings; use one or the other)`
+    );
+  }
+}
+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 = [];
@@ -2983,43 +3153,45 @@ function parseLayerRoles(fileNames) {
       `auto-rig: missing required role${missing.length > 1 ? "s" : ""} ${missing.join(", ")}`
     );
   }
+  checkMouth(seen.keys());
   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 P8,
   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)
     ]
@@ -3028,10 +3200,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)
     ]
@@ -3043,7 +3215,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" }
     ]
   },
   {
@@ -3053,7 +3225,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" }
     ]
   },
   {
@@ -3061,18 +3233,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)
     ]
   }
@@ -3085,14 +3257,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],
@@ -3113,7 +3285,7 @@ var DEFAULT_MOTIONS = {
       fadeIn: 0.15,
       curves: [
         {
-          parameter: P4.AngleX,
+          parameter: P5.AngleX,
           keys: [
             [0, 0],
             [0.2, -18],
@@ -3132,7 +3304,7 @@ var DEFAULT_MOTIONS = {
       duration: 1.4,
       curves: [
         {
-          parameter: P4.AngleZ,
+          parameter: P5.AngleZ,
           keys: [
             [0, 0],
             [0.35, 20],
@@ -3144,6 +3316,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);
@@ -3248,7 +3469,16 @@ function checkLayers(layers, canvas) {
   if (missing.length > 0) {
     throw new Error(`auto-rig: missing required role(s) ${missing.join(", ")}`);
   }
+  checkMouth(seen);
+  for (const l of layers) {
+    if (l.rowRuns === void 0 && isLipRole(l.role)) {
+      throw new Error(
+        `auto-rig: layer "${l.fileName}": the lip set needs rowRuns (the fold reads the opening's rows off them; measure with createLayerSetMeasurer)`
+      );
+    }
+  }
   checkArmsHaveBody(seen);
+  checkPosesHaveArms(seen);
 }
 function checkHeadEdges(edges, byRole) {
   if (edges === void 0) return;
@@ -3366,7 +3596,182 @@ function checkStrandEdges(strand, irises, hair) {
 }
 
 // src/auto-rig/context.ts
-import { StandardParameter as P5 } from "@ikijs/format";
+import { StandardParameter as P7 } from "@ikijs/format";
+
+// src/auto-rig/mouth.ts
+import {
+  StandardParameter as P6
+} from "@ikijs/format";
+var UPPER_SHARE = 0.3;
+var MOUTH_KNOT_PX = 4;
+var isLipSet = (byRole) => LIP_ROLES.every((r) => byRole.has(r));
+function columnRuns(layer) {
+  const cols = /* @__PURE__ */ new Map();
+  (layer.rowRuns ?? []).forEach((runs, k) => {
+    for (let i = 0; i < runs.length; i += 2) {
+      for (let c = runs[i]; c < runs[i + 1]; c++) {
+        const list = cols.get(c) ?? [];
+        const last = list[list.length - 1];
+        if (last !== void 0 && last[1] === k) last[1] = k + 1;
+        else list.push([k, k + 1]);
+        cols.set(c, list);
+      }
+    }
+  });
+  return cols;
+}
+var edgesOf = (layer, run) => ({
+  top: layer.canvasH / 2 - (layer.bbox.y + run[0]),
+  bottom: layer.canvasH / 2 - (layer.bbox.y + run[1])
+});
+function mouthOpening(byRole) {
+  const inner = byRole.get("mouth_inner");
+  const upper = byRole.get("lip_upper");
+  const lower = byRole.get("lip_lower");
+  const innerCols = columnRuns(inner);
+  if (innerCols.size === 0) {
+    throw new LayerGeometryError(
+      `auto-rig: layer "${inner.fileName}": mouth_inner has no opaque pixel (alpha \u2265 128) to read the opening off`
+    );
+  }
+  const upperCols = columnRuns(upper);
+  const lowerCols = columnRuns(lower);
+  const cols = [...innerCols.keys()];
+  const x0 = Math.min(...cols);
+  const x1 = Math.max(...cols);
+  const read = (col) => {
+    const runs = innerCols.get(col);
+    if (runs === void 0) return void 0;
+    const T = edgesOf(inner, runs[0]).top;
+    const Bb = edgesOf(inner, runs[runs.length - 1]).bottom;
+    const line = [...upperCols.get(col) ?? []].reverse().map((r) => edgesOf(upper, r)).find((e) => e.top >= T);
+    const Tu = line?.bottom ?? T;
+    const lineTop = line?.top ?? T;
+    const skin = lowerCols.get(col)?.[0];
+    return {
+      T,
+      Bb,
+      Tu,
+      lineTop,
+      lineH: lineTop - Tu,
+      Bl: skin === void 0 ? Bb : edgesOf(lower, skin).top,
+      H: T - Bb,
+      seam: T - UPPER_SHARE * (T - Bb)
+    };
+  };
+  const reads = [];
+  for (let c = x0; c <= x1; c++) {
+    let r;
+    for (let d = 0; (r = read(c - d) ?? read(c + d)) === void 0; d++) ;
+    reads.push(r);
+  }
+  const base = (col) => reads[Math.min(x1, Math.max(x0, col)) - x0];
+  const centre = Math.round((x0 + x1) / 2);
+  const w = base(centre).lineH;
+  return {
+    x0,
+    x1,
+    centre,
+    canvasW: inner.canvasW,
+    w,
+    at(col) {
+      const b = base(col);
+      return { ...b, overlap: Math.max(0, Math.min(w, b.lineH)) };
+    }
+  };
+}
+function mouthFold(role, opening) {
+  return (col, y, v) => {
+    if (v === 1) return 0;
+    if (role !== "mouth_inner" && (col < opening.x0 || col > opening.x1))
+      return 0;
+    const c = opening.at(col);
+    const k = 1 - v;
+    switch (role) {
+      case "lip_upper":
+        return (c.seam - c.Tu) * k;
+      case "lip_lower":
+        return (c.seam + c.overlap - c.Bl) * k;
+      case "mouth_inner":
+        return (c.seam + c.overlap - y) * k;
+    }
+  };
+}
+function columnOfKnot(knot, opening, role) {
+  const boundary = Math.round(knot + opening.canvasW / 2);
+  const col = boundary === opening.x1 + 1 ? opening.x1 : boundary;
+  if (col >= opening.x0 && col <= opening.x1) return col;
+  return role === "mouth_inner" ? Math.min(opening.x1, Math.max(opening.x0, col)) : void 0;
+}
+function mouthFoldWarp(role, mesh, xs, box, opening) {
+  const fold = mouthFold(role, opening);
+  return localWarp(P6.MouthOpen, mesh, box, [0, 1], (p, v, i) => {
+    const col = columnOfKnot(xs[i % xs.length], opening, role);
+    return [0, col === void 0 ? 0 : fold(col, p[1], v)];
+  });
+}
+function mouthKnots(union, opening) {
+  const half = opening.canvasW / 2;
+  const step = MOUTH_KNOT_PX;
+  const xs = [union.x0];
+  while (xs[xs.length - 1] + step < union.x1 - 0.3 * step)
+    xs.push(xs[xs.length - 1] + step);
+  xs.push(union.x1);
+  const fixed = /* @__PURE__ */ new Set([union.x0, union.x1]);
+  for (const x of [opening.x0 - half, opening.x1 + 1 - half]) {
+    fixed.add(x);
+    if (xs.includes(x)) continue;
+    const near = xs.findIndex((v) => Math.abs(v - x) < 0.3 * step);
+    if (near >= 0 && !fixed.has(xs[near])) xs[near] = x;
+    else xs.push(x);
+  }
+  xs.sort((p, q) => p - q);
+  for (const x of xs) {
+    if (!Number.isInteger(x + half)) {
+      throw new Error(
+        `auto-rig: mouth knot ${x} is not an integer canvas boundary`
+      );
+    }
+  }
+  return xs;
+}
+function mouthMesh(box, knots) {
+  const xs = [box.x0, ...knots.filter((k) => k > box.x0 && k < box.x1), box.x1];
+  const rows = cellsFor(bh(box), MOUTH_KNOT_PX, 2, 40);
+  const ys = Array.from(
+    { length: rows + 1 },
+    (_, r) => box.y1 - bh(box) * r / rows
+  );
+  return { mesh: columnMesh(box, { xs, ys }), xs };
+}
+function buildMouthRig(byRole) {
+  const opening = mouthOpening(byRole);
+  const union = unionBoxes(LIP_ROLES.map((r) => boxOfLayer(byRole.get(r))));
+  return {
+    opening,
+    frame: mouthFrameOf(union),
+    knots: mouthKnots(union, opening),
+    union
+  };
+}
+function mouthAnchor(byRole) {
+  const box = (role) => boxOfLayer(byRole.get(role));
+  if (isLipSet(byRole)) {
+    const opening = mouthOpening(byRole);
+    return {
+      at: {
+        x: cx(box("mouth_inner")),
+        y: opening.at(opening.centre).seam
+      },
+      box: unionBoxes(LIP_ROLES.map(box))
+    };
+  }
+  const m = box("mouth");
+  return {
+    at: { x: cx(m), y: cy(m) },
+    box: byRole.has("mouth_open") ? unionBoxes([m, box("mouth_open")]) : m
+  };
+}
 
 // src/auto-rig/head.ts
 function outerEdge(runs, axisX, side) {
@@ -3446,7 +3851,7 @@ function buildHeadFrame(layers, opts) {
     return ya === void 0 || yb === void 0 ? void 0 : (ya + yb) / 2;
   };
   const eyeY = pair("iris_L", "iris_R") ?? pair("eye_L", "eye_R");
-  const mouthY = centreY("mouth");
+  const mouthY = mouthAnchor(byRole).at.y;
   const rowY = (r) => canvasH / 2 - (faceLayer.bbox.y + r + 0.5);
   const raw = filledProfile(faceLayer.rowHalfWidths);
   const profile = raw === null ? null : smoothProfile(raw);
@@ -4398,6 +4803,7 @@ function familyField(m, family) {
       return hairField(m, m.hairBack, NOD.hairBack);
     case "body":
     case "arm":
+    case "forearm_pose":
       return () => [0, 0];
   }
 }
@@ -4418,7 +4824,6 @@ function sideIrises(byRole) {
   return pair === void 0 ? {} : { left: pair.left.box, right: pair.right.box };
 }
 function solveContext(frame, byRole, options, hasNose) {
-  const box = (role) => boxOfLayer(byRole.get(role));
   const row = (s, strand2, sideSign) => {
     if (strand2 !== void 0) {
       const lo = sideSign < 0 ? strand2.irisOuter : strand2.irisInner;
@@ -4467,8 +4872,7 @@ function solveContext(frame, byRole, options, hasNose) {
     noseBox = nose.denseCore ? boxOfPixels(nose.denseCore, nose.canvasW, nose.canvasH) : boxOfLayer(nose);
     noseAt = { x: cx(noseBox), y: cy(noseBox) };
   }
-  const mouthBox = byRole.has("mouth_open") ? unionBoxes([box("mouth"), box("mouth_open")]) : box("mouth");
-  const m = box("mouth");
+  const mouth = mouthAnchor(byRole);
   return {
     frame,
     left,
@@ -4480,8 +4884,8 @@ function solveContext(frame, byRole, options, hasNose) {
     eyeBoxes: { left: eyes.left.box, right: eyes.right.box },
     noseAt,
     noseBox,
-    mouthAt: { x: cx(m), y: cy(m) },
-    mouthBox
+    mouthAt: mouth.at,
+    mouthBox: mouth.box
   };
 }
 function renderedLander(turn, parts, grids, from = /* @__PURE__ */ new Map()) {
@@ -4497,7 +4901,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 === P7.AngleX);
     if (part === void 0 || part.mesh === void 0 || !g && !warp) {
       return x + field(role)(x, y, ax, 0)[0];
     }
@@ -5233,6 +5637,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);
@@ -5293,6 +5698,7 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     hh: frame.hh,
     pivots: [...arms.values()].map((g) => g.shoulder)
   }) : void 0;
+  const lips = isLipSet(byRole) ? buildMouthRig(byRole) : void 0;
   const parts = [];
   const reach = /* @__PURE__ */ new Map();
   let regionOf = [];
@@ -5301,11 +5707,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),
@@ -5313,7 +5730,8 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       frame,
       byRole,
       style,
-      landmarks.hairFrontGrid
+      landmarks.hairFrontGrid,
+      lips
     );
     if (built.region !== void 0) {
       regionOf = built.region;
@@ -5358,7 +5776,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);
@@ -5375,10 +5793,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) {
@@ -5395,14 +5813,14 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
 function turnWarps(mesh, b, fieldOf) {
   return [
     localWarp(
-      P6.AngleX,
+      P8.AngleX,
       mesh,
       b,
       X_STOPS,
       ([x, y], v, i) => v === 0 ? [0, 0] : [fieldOf(i)(x, y, v, 0)[0], 0]
     ),
     localWarp(
-      P6.AngleY,
+      P8.AngleY,
       mesh,
       b,
       Y_STOPS,
@@ -5415,7 +5833,7 @@ function plateFields(turn, region, head) {
   const neck = neckField(turn);
   return (i) => region[i] === "ear" ? ear : region[i] === "neck" ? neck : head;
 }
-function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
+function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
   const box = (role) => boxOfLayer(byRole.get(role));
   const part = {
     id: spec.role,
@@ -5430,6 +5848,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
   const bindings = [];
   let extra = [0, 0];
   let mesh;
+  let knotXs;
   let region;
   let headStart = 0;
   if (spec.role === "face") {
@@ -5440,6 +5859,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
     headStart = fm.headStart;
   } else if (spec.role === "hair_front") {
     mesh = columnMesh(b, frontGrid);
+  } else if (lips !== void 0 && isLipRole(spec.role)) {
+    ({ mesh, xs: knotXs } = mouthMesh(b, lips.knots));
   } else if (spec.family !== "body") {
     const cells = MESH_CELLS[spec.role] ?? FEATURE_MESH_CELLS;
     const px = Math.min(cells.px, meshScale(spec.role, frame));
@@ -5450,7 +5871,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" ? P8.EyeOpenLeft : P8.EyeOpenRight;
   const hh = frame.hh;
   switch (spec.role) {
     case "face":
@@ -5465,7 +5886,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
             headOwnRoll(byRole.has("body"))
           ),
           localWarp(
-            P6.Breath,
+            P8.Breath,
             mesh,
             b,
             [0, 1],
@@ -5512,8 +5933,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: P8.MouthOpen, channel: "opacity", from: 1, to: 0 },
+          { parameter: P8.MouthOpen, channel: "opacity", from: 1, to: 0 }
         );
         extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       } else {
@@ -5523,19 +5944,19 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
         );
         bindings.push(
           {
-            parameter: P6.MouthOpen,
+            parameter: P8.MouthOpen,
             channel: "scaleY",
             from: 0,
             to: roundTo(grow, 0.01)
           },
           {
-            parameter: P6.MouthOpen,
+            parameter: P8.MouthOpen,
             channel: "scaleX",
             from: 0,
             to: roundTo(AMPLITUDE.mouthOpenWidth - 1, 0.01)
           },
           {
-            parameter: P6.MouthOpen,
+            parameter: P8.MouthOpen,
             channel: "translateY",
             from: 0,
             to: -roundTo(grow * bh(b) / 2, 0.01)
@@ -5547,17 +5968,26 @@ 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: P8.MouthOpen,
         channel: "opacity",
         from: 0,
         to: 1
       });
       extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       break;
+    case "mouth_inner":
+    case "lip_lower":
+    case "lip_upper":
+      warps.push(
+        mouthFoldWarp(spec.role, mesh, knotXs, b, lips.opening),
+        mouthForm(mesh, b, lips.frame),
+        mouthWiden(mesh, b, lips.frame)
+      );
+      break;
     case "blush_L":
     case "blush_R":
       bindings.push({
-        parameter: P6.Cheek,
+        parameter: P8.Cheek,
         channel: "opacity",
         from: AMPLITUDE.blushRest,
         to: 1
@@ -5568,8 +5998,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(P8.HairSwayX, mesh, b, amp),
+          hairSway(P8.HairSwayZ, mesh, b, amp)
         );
       }
       warps.push(tiltHang(mesh, b, pivot, hairHangWeight(frame.chinY, b.y0)));
@@ -5610,29 +6040,6 @@ function hairFrontGrid(b, frame, boxes) {
   );
   return { xs, ys };
 }
-function columnMesh(b, grid) {
-  const { xs } = grid;
-  const rows = grid.ys.length - 1;
-  const vertices = [];
-  const uvs = [];
-  for (let r = 0; r <= rows; r++) {
-    for (const x of xs) {
-      const u = (x - b.x0) / bw(b);
-      vertices.push(roundTo(u - 0.5, 1e-5), roundTo(0.5 - r / rows, 1e-5));
-      uvs.push(roundTo(u, 1e-5), roundTo(r / rows, 1e-5));
-    }
-  }
-  const n = xs.length;
-  const indices = [];
-  for (let r = 0; r < rows; r++) {
-    for (let c = 0; c + 1 < n; c++) {
-      const tl = r * n + c;
-      const bl = tl + n;
-      indices.push(bl, bl + 1, tl, tl, bl + 1, tl + 1);
-    }
-  }
-  return { vertices, uvs, indices };
-}
 function meshScale(role, frame) {
   switch (role) {
     case "hair_front":
@@ -5642,10 +6049,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({
@@ -5654,9 +6065,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: P8.AngleZ, channel: "rotate", from: roll, to: -roll },
       {
-        parameter: P6.Breath,
+        parameter: P8.Breath,
         channel: "translateY",
         from: 0,
         to: roundTo(headOwnBreath(hasBody) * frame.hh, 0.01)
@@ -5674,8 +6085,8 @@ function deformers(frame, grids, bodyWarp, arms) {
         points: g.lattice.points
       },
       warp2d: {
-        parameter: P6.AngleX,
-        parameterY: P6.AngleY,
+        parameter: P8.AngleX,
+        parameterY: P8.AngleY,
         valuesX: X_STOPS,
         valuesY: Y_STOPS,
         keyforms2d: g.keyforms.map((offsets) => ({ offsets }))
@@ -5688,16 +6099,16 @@ function hairPhysics() {
   return [
     {
       id: "hairSway",
-      input: { parameter: P6.AngleX, weight: 1 },
-      output: { parameter: P6.HairSwayX, scale: 5 },
+      input: { parameter: P8.AngleX, weight: 1 },
+      output: { parameter: P8.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: P8.AngleZ, weight: 1 },
+      output: { parameter: P8.HairSwayZ, scale: 8 },
       mass: 1,
       stiffness: 25,
       damping: 2.5
@@ -5707,47 +6118,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(P8.AngleX, "Head Angle", -30, 30, 0);
+  add(P8.AngleY, "Head Angle Y", -30, 30, 0);
+  add(P8.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(P8.BodyAngleX, "Body Angle X", -10, 10, 0);
+    add(P8.BodyAngleY, "Body Angle Y", -10, 10, 0);
+    add(P8.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", elbowMin, elbowMax, 0);
+    add(P8.ArmLeft, "Arm L", armMin, armMax, 0);
+    add(P8.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
+    if (roles.has("forearm_pose_L"))
+      addPose("L", P8.ArmPoseLeft, P8.ArmPoseAngleLeft);
   }
   if (roles.has("arm_R")) {
-    add(P6.ArmRight, "Arm R", armMin, armMax, 0);
-    add(P6.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
+    add(P8.ArmRight, "Arm R", armMin, armMax, 0);
+    add(P8.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
+    if (roles.has("forearm_pose_R"))
+      addPose("R", P8.ArmPoseRight, P8.ArmPoseAngleRight);
   }
-  add(P6.EyeOpenLeft, "Eye L", 0, 1, 1);
-  add(P6.EyeOpenRight, "Eye R", 0, 1, 1);
+  add(P8.EyeOpenLeft, "Eye L", 0, 1, 1);
+  add(P8.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(P8.EyeballX, "Gaze X", -1, 1, 0);
+    add(P8.EyeballY, "Gaze Y", -1, 1, 0);
   }
-  add(P6.MouthOpen, "Mouth Open", 0, 1, 0);
-  add(P6.MouthForm, "Mouth Form", -1, 1, 0);
+  add(P8.MouthOpen, "Mouth Open", 0, 1, 0);
+  add(P8.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(P8.BrowLeftY, "Brow L Y", -1, 1, 0);
+    add(P8.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(P8.BrowRightY, "Brow R Y", -1, 1, 0);
+    add(P8.BrowRightAngle, "Brow R Angle", -1, 1, 0);
   }
   if (roles.has("blush_L") || roles.has("blush_R")) {
-    add(P6.Cheek, "Cheek", 0, 1, 0);
+    add(P8.Cheek, "Cheek", 0, 1, 0);
   }
-  add(P6.Breath, "Breath", 0, 1, 0);
+  add(P8.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(P8.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(P8.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
   }
   return out;
 }
@@ -5794,6 +6213,7 @@ export {
   createLayerSetMeasurer,
   denseCoreOf,
   detectAlphaBbox,
+  forearmPoseGeometry,
   foregroundSpan,
   generateIkiFromLayerSet,
   headHalfOf,