@ikijs/editor 0.16.1 → 0.17.0

package/dist/index.mjs

@@ -1559,6 +1559,14 @@ function facePlateHalfOf(layers) {
   return face.cropW / 2;
 }
 var STRAND_MIN_RUN_FRACTION = 0.5;
+var ROW_RUN_ROLES = /* @__PURE__ */ new Set([
+  "face",
+  "hair_front",
+  "hair_back",
+  "body",
+  "arm_L",
+  "arm_R"
+]);
 function createLayerSetMeasurer(canvas) {
   for (const field of ["width", "height"]) {
     const value = canvas[field];
@@ -1588,7 +1596,7 @@ function createLayerSetMeasurer(canvas) {
     if (bbox === null) return null;
     const rowLeft = new Int32Array(canvasH).fill(canvasW);
     const rowRight = new Int32Array(canvasH).fill(-1);
-    const rowRuns = role === "face" || role === "hair_front" || role === "hair_back" ? [] : void 0;
+    const rowRuns = ROW_RUN_ROLES.has(role) ? [] : void 0;
     for (let y = 0; y < canvasH; y++) {
       let runs;
       if (rowRuns !== void 0 && y >= bbox.y && y < bbox.y + bbox.h) {
@@ -1930,7 +1938,13 @@ var PROFILE_VALUES = {
   brow: 0.15,
   breath: 0.03,
   sway: 0.08,
-  blushRest: 0.4
+  blushRest: 0.4,
+  bodySlide: 0.1,
+  bodyNarrow: 0.05,
+  bodyBow: 0.06,
+  bodyRoll: 4,
+  bodyFollowX: 0.3,
+  bodyFollowZ: 0.3
 };
 function deriveProfile(v) {
   const farLead = v.lead * (1 - v.fore / 2);
@@ -2024,9 +2038,32 @@ function deriveProfile(v) {
      *  slide, to the next 0.05. */
     hiddenNeck: Math.ceil(30 * (v.slide + v.lead) - 1e-9) / 20
   };
-  return { TURN: turn, NOD: nod, ROLL_DEG: v.rollDeg, AMPLITUDE: amplitude };
+  const body = {
+    /** BodyAngleX: the upper body's slide, hh. */
+    slide: v.bodySlide,
+    /** BodyAngleX: how much narrower the upper body gets, either way. */
+    narrow: v.bodyNarrow,
+    /** BodyAngleY: the upper body's rise (+) or bow (−), hh. */
+    bow: v.bodyBow,
+    /** BodyAngleZ: the upper body's roll about the hips, degrees. */
+    rollDeg: v.bodyRoll,
+    /** AngleX: the body's follow, as a share of BodyAngleX's motion. */
+    followX: v.bodyFollowX,
+    /** AngleZ: the body's follow, as a share of its roll. */
+    followZ: v.bodyFollowZ,
+    /** The roll the follow gives the body at AngleZ ±30, degrees: β, the
+     *  share of `ROLL_DEG` the head's own roll leaves to the body. */
+    followRoll: v.bodyFollowZ * v.bodyRoll
+  };
+  return {
+    TURN: turn,
+    NOD: nod,
+    ROLL_DEG: v.rollDeg,
+    AMPLITUDE: amplitude,
+    BODY: body
+  };
 }
-var { TURN, NOD, ROLL_DEG, AMPLITUDE } = deriveProfile(PROFILE_VALUES);
+var { TURN, NOD, ROLL_DEG, AMPLITUDE, BODY } = deriveProfile(PROFILE_VALUES);
 var STYLE_KNOBS = [
   "turn",
   "featureLead",
@@ -2056,6 +2093,12 @@ var TurnTargetError = class extends Error {
     this.name = "TurnTargetError";
   }
 };
+var LayerGeometryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LayerGeometryError";
+  }
+};
 var DEFAULT_TURN_TARGETS = Object.freeze({
   eyeShift: round2((TURN.eyeFar + TURN.eyeNear) / 2 - TURN.hairBack),
   farEyeRatio: round2(TURN.eyeFarScale / TURN.eyeNearScale),
@@ -2066,6 +2109,8 @@ var DEFAULT_TURN_TARGETS = Object.freeze({
 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" },
@@ -2097,6 +2142,15 @@ function roleSpec(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",
@@ -2107,6 +2161,16 @@ 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 = [];
@@ -2132,13 +2196,14 @@ function parseLayerRoles(fileNames) {
       `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 P4,
+  StandardParameter as P6,
   parseIkiModel as parseIkiModel3
 } from "@ikijs/format";
 
@@ -2293,6 +2358,16 @@ var DEFAULT_MOTIONS = {
   ]
 };
 
+// src/auto-rig/arms.ts
+import {
+  StandardParameter as P4
+} from "@ikijs/format";
+
+// src/auto-rig/body.ts
+import {
+  StandardParameter as P3
+} from "@ikijs/format";
+
 // src/auto-rig/layout.ts
 function boxOfLayer(layer) {
   return boxOfPixels(layer.bbox, layer.canvasW, layer.canvasH);
@@ -2366,6 +2441,653 @@ function meshPoints(mesh, box) {
   return out;
 }
 
+// src/auto-rig/drivers.ts
+import {
+  StandardParameter as P2
+} from "@ikijs/format";
+var SWAY_RANGE = 20;
+var SWAY_CURVE = 1.4;
+var HAIR_HANG = 0.35;
+var Z_STOPS = [-30, 0, 30];
+function localWarp(parameter, mesh, box, values, f) {
+  const pts = meshPoints(mesh, box);
+  const w = bw(box);
+  const h = bh(box);
+  return {
+    parameter,
+    keyforms: values.map((value) => ({
+      value,
+      offsets: pts.flatMap((p, i) => {
+        const [dx, dy] = f(p, value, i);
+        return [roundTo(dx / w, 1e-4), roundTo(dy / h, 1e-4)];
+      })
+    }))
+  };
+}
+var rollOf = (v, deg = ROLL_DEG) => -v / 30 * deg * DEG;
+function motionReach(warps, mesh, box, extra = [0, 0]) {
+  const out = {
+    left: extra[0],
+    right: extra[0],
+    bottom: extra[1],
+    top: extra[1]
+  };
+  if (mesh === void 0) return out;
+  const pts = meshPoints(mesh, box);
+  for (const warp of warps ?? []) {
+    let l = 0;
+    let r = 0;
+    let b = 0;
+    let t = 0;
+    for (const k of warp.keyforms) {
+      pts.forEach(([x, y], i) => {
+        const px = x + k.offsets[2 * i] * bw(box);
+        const py = y + k.offsets[2 * i + 1] * bh(box);
+        l = Math.max(l, box.x0 - px);
+        r = Math.max(r, px - box.x1);
+        b = Math.max(b, box.y0 - py);
+        t = Math.max(t, py - box.y1);
+      });
+    }
+    out.left += l;
+    out.right += r;
+    out.bottom += b;
+    out.top += t;
+  }
+  return out;
+}
+function blinkFold(param, mesh, box, travel, eye = box) {
+  const yc = eye.y1 - travel * bh(eye);
+  return localWarp(
+    param,
+    mesh,
+    box,
+    [0, 1],
+    ([, y], v) => v === 1 ? [0, 0] : [0, yc - y]
+  );
+}
+function lashFold(param, mesh, lash, eye, travel) {
+  const yc = eye.y1 - travel * bh(eye) - 0.04 * bh(eye);
+  const c = cx(lash);
+  const half = bw(lash) / 2;
+  const sag = 0.3 * bh(lash);
+  return localWarp(param, mesh, lash, [0, 1], ([x, y], v) => {
+    if (v === 1) return [0, 0];
+    const u = (x - c) / half;
+    return [0, yc + (y - lash.y0) * 0.5 - sag * (1 - u * u) - y];
+  });
+}
+function gazeBindings(irisW, share = 1) {
+  const gx = AMPLITUDE.gazeX * irisW * share;
+  const gy = AMPLITUDE.gazeY * irisW * share;
+  return [
+    {
+      parameter: P2.EyeballX,
+      channel: "translateX",
+      from: -round1(gx),
+      to: round1(gx)
+    },
+    {
+      parameter: P2.EyeballY,
+      channel: "translateY",
+      from: -round1(gy),
+      to: round1(gy)
+    }
+  ];
+}
+function gazeReach(irisW, share = 1) {
+  return [AMPLITUDE.gazeX * irisW * share, AMPLITUDE.gazeY * irisW * share];
+}
+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;
+  return [
+    {
+      parameter: y,
+      channel: "translateY",
+      from: -round1(reach),
+      to: round1(reach)
+    },
+    { parameter: a, channel: "rotate", from: -BROW_TILT, to: BROW_TILT }
+  ];
+}
+var BROW_TILT = 15;
+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) => {
+    if (v === 0) return [0, 0];
+    const u = (x - c) / half;
+    const widen = v > 0 ? 0.05 : 0.03;
+    return [v * widen * (x - c), v * a * (u * u - 0.3)];
+  });
+}
+function mouthOpenGrow(mesh, box) {
+  const c = cx(box);
+  return localWarp(
+    P2.MouthOpen,
+    mesh,
+    box,
+    [0, 1],
+    ([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);
+  return localWarp(P2.MouthOpen, mesh, box, [0, 1], ([x], v) => [
+    v * (AMPLITUDE.mouthOpenWidth - 1) * (x - c),
+    0
+  ]);
+}
+function hairSway(param, mesh, box, amp) {
+  return localWarp(
+    param,
+    mesh,
+    box,
+    [-SWAY_RANGE, 0, SWAY_RANGE],
+    ([, y], v) => {
+      const t = Math.max(0, (box.y1 - y) / bh(box));
+      return [v / SWAY_RANGE * amp * t ** SWAY_CURVE, 0];
+    }
+  );
+}
+function tiltHang(mesh, box, pivot, weight, deg = ROLL_DEG) {
+  return localWarp(P2.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);
+    const px = x - pivot[0];
+    const py = y - pivot[1];
+    return [
+      pivot[0] + px * Math.cos(a) - py * Math.sin(a) - x,
+      pivot[1] + px * Math.sin(a) + py * Math.cos(a) - y
+    ];
+  });
+}
+function hairHangWeight(pivotY, bottom) {
+  if (bottom >= pivotY) return () => 0;
+  return (y) => HAIR_HANG * smoothstep(pivotY, bottom, y);
+}
+var round1 = (v) => roundTo(v, 0.1);
+
+// src/auto-rig/grid.ts
+var X_STOPS = [-30, 0, 30];
+var Y_STOPS = [-30, 0, 30];
+function lattice(box, cell, min, max) {
+  const cols = cellsFor(box.x1 - box.x0, cell, min, max);
+  const rows = cellsFor(box.y1 - box.y0, cell, min, max);
+  const points = [];
+  for (let r = 0; r <= rows; r++) {
+    const y = box.y1 - (box.y1 - box.y0) * r / rows;
+    for (let c = 0; c <= cols; c++) {
+      points.push(
+        roundTo(box.x0 + (box.x1 - box.x0) * c / cols, 0.01),
+        roundTo(y, 0.01)
+      );
+    }
+  }
+  return { box, cols, rows, points };
+}
+function bake(l, field) {
+  const out = [];
+  for (const ay of Y_STOPS) {
+    for (const ax of X_STOPS) {
+      const offsets = [];
+      for (let k = 0; k < l.points.length; k += 2) {
+        if (ax === 0 && ay === 0) {
+          offsets.push(0, 0);
+          continue;
+        }
+        const [dx, dy] = field(l.points[k], l.points[k + 1], ax, ay);
+        offsets.push(roundTo(dx, 0.1), roundTo(dy, 0.1));
+      }
+      out.push(offsets);
+    }
+  }
+  return out;
+}
+function keyformAt(keyforms, ax) {
+  const j = Y_STOPS.indexOf(0);
+  const row = X_STOPS.map((_, i) => keyforms[j * X_STOPS.length + i]);
+  return blendStops(X_STOPS, row, ax);
+}
+function blendStops(values, offsets, v) {
+  const x = clamp(v, values[0], values[values.length - 1]);
+  let i = 0;
+  while (i < values.length - 2 && x > values[i + 1]) i++;
+  const t = (x - values[i]) / (values[i + 1] - values[i]);
+  return offsets[i].map((o, k) => o + (offsets[i + 1][k] - o) * t);
+}
+function land(l, offsets, x, y) {
+  const { cols, rows, points } = l;
+  const stride = cols + 1;
+  let col = cols - 1;
+  for (let c = 0; c < cols; c++) {
+    if (x < points[(c + 1) * 2]) {
+      col = c;
+      break;
+    }
+  }
+  let row = rows - 1;
+  for (let r = 0; r < rows; r++) {
+    if (y > points[(r + 1) * stride * 2 + 1]) {
+      row = r;
+      break;
+    }
+  }
+  const x0 = points[col * 2];
+  const x1 = points[(col + 1) * 2];
+  const yT = points[row * stride * 2 + 1];
+  const yB = points[(row + 1) * stride * 2 + 1];
+  const s = clamp((x - x0) / (x1 - x0), 0, 1);
+  const t = clamp((yT - y) / (yT - yB), 0, 1);
+  const at = (r, c) => {
+    const k = (r * stride + c) * 2;
+    return [points[k] + offsets[k], points[k + 1] + offsets[k + 1]];
+  };
+  const p00 = at(row, col);
+  const p10 = at(row, col + 1);
+  const p01 = at(row + 1, col);
+  const p11 = at(row + 1, col + 1);
+  const topX = p00[0] + (p10[0] - p00[0]) * s;
+  const topY = p00[1] + (p10[1] - p00[1]) * s;
+  const botX = p01[0] + (p11[0] - p01[0]) * s;
+  const botY = p01[1] + (p11[1] - p01[1]) * s;
+  return [topX + (botX - topX) * t, topY + (botY - topY) * t];
+}
+
+// src/auto-rig/body.ts
+var BODY_WARP_ID = "bodyWarp";
+var BODY_GRID_PAD = 6;
+var CHEST_DROP = 0.8;
+var HIP_BAND = [0.35, 0.75];
+var LEG_MIN = 0.1;
+var HIP_FRACTION = 0.5;
+var BODY_MESH_PX = 48;
+var BODY_STOPS = [-10, 0, 10];
+var FOLD_MARGIN = 0.01;
+function hipLine(layer) {
+  const { bbox, canvasH, rowRuns } = layer;
+  const top = canvasH / 2 - bbox.y;
+  if (rowRuns !== void 0) {
+    const legMin = LEG_MIN * bbox.w;
+    const last = Math.floor(HIP_BAND[1] * bbox.h);
+    for (let k = Math.ceil(HIP_BAND[0] * bbox.h); k <= last; k++) {
+      const runs = rowRuns[k];
+      let legs = 0;
+      for (let i = 0; i < runs.length; i += 2) {
+        if (runs[i + 1] - runs[i] >= legMin) legs++;
+      }
+      if (legs >= 2) return roundTo(top - k, 0.01);
+    }
+  }
+  if (bbox.y + bbox.h === canvasH) return roundTo(top - bbox.h, 0.01);
+  return roundTo(top - HIP_FRACTION * bbox.h, 0.01);
+}
+function bodyLattice(body, chin, hh, pivots, anchor) {
+  const b = boxOfLayer(body);
+  const g = (v) => Math.round(roundTo(v, 0.01) * 100);
+  const pad = BODY_GRID_PAD * 100;
+  const all = [chin, ...pivots];
+  const a = g(anchor);
+  const p = Math.min(...all.map((q) => g(q.y)));
+  if (p - a < 2) {
+    throw new LayerGeometryError(
+      `auto-rig: layer "${body.fileName}": its hips (y ${anchor}) leave no row line strictly between them and the lowest of the head's and shoulders' pivots (y ${p / 100}), so the body warp cannot plant the legs below the pivots`
+    );
+  }
+  let full = Math.min(g(chin.y - CHEST_DROP * hh), p - pad);
+  if (full - a < pad) {
+    full = Math.min(Math.max(Math.round((a + p) / 2), a + 1), p - 1);
+  }
+  const top = Math.max(g(b.y1), ...all.map((q) => g(q.y))) + pad;
+  const bottom = Math.min(a, g(b.y0)) - pad;
+  const split = (from, to, cells) => {
+    const n = Math.max(1, Math.min(cells, from - to));
+    const out = [from];
+    for (let i = 1; i < n; i++) {
+      out.push(Math.round(from - (from - to) * i / n));
+    }
+    out.push(to);
+    return out;
+  };
+  const bandA = split(top, full, cellsFor((top - full) / 100, 96, 1, 8));
+  const ramp = split(full, a, cellsFor((full - a) / 100, 96, 2, 8));
+  const rows = [...bandA, ...ramp.slice(1, -1)];
+  const ys = [...rows.map((y) => y / 100), anchor, bottom / 100];
+  const weights = [...rows.map((y) => smoothstep(a, full, y)), 0, 0];
+  const x0 = Math.min(b.x0, ...all.map((q) => q.x)) - BODY_GRID_PAD;
+  const x1 = Math.max(b.x1, ...all.map((q) => q.x)) + BODY_GRID_PAD;
+  const cols = cellsFor(x1 - x0, 96, 2, 8);
+  const xs = [];
+  for (let c = 0; c <= cols; c++) {
+    xs.push(roundTo(x0 + (x1 - x0) * c / cols, 0.01));
+  }
+  return { xs, ys, weights, yFull: full / 100 };
+}
+function bodyMesh(b, rows) {
+  const lines = [b.y1, ...rows.filter((y) => y > b.y0 && y < b.y1), b.y0];
+  const ys = [lines[0]];
+  for (let i = 1; i < lines.length; i++) {
+    const [from, to] = [lines[i - 1], lines[i]];
+    const n = Math.ceil((from - to) / BODY_MESH_PX);
+    for (let k = 1; k < n; k++) ys.push(from - (from - to) * k / n);
+    ys.push(to);
+  }
+  const cols = cellsFor(bw(b), BODY_MESH_PX, 2, 16);
+  const vertices = [];
+  const uvs = [];
+  for (const y of ys) {
+    const vy = roundTo((y - cy(b)) / bh(b), 1e-5);
+    for (let c = 0; c <= cols; c++) {
+      const vx = roundTo(c / cols - 0.5, 1e-5);
+      vertices.push(vx, vy);
+      uvs.push(roundTo(vx + 0.5, 1e-5), roundTo(0.5 - vy, 1e-5));
+    }
+  }
+  const indices = [];
+  for (let r = 0; r + 1 < ys.length; r++) {
+    for (let c = 0; c < cols; c++) {
+      const tl = r * (cols + 1) + c;
+      const tr = tl + 1;
+      const bl = tl + cols + 1;
+      const br = bl + 1;
+      indices.push(bl, br, tl, tl, br, tr);
+    }
+  }
+  return { vertices, uvs, indices };
+}
+function buildBodyWarp({
+  body,
+  chin,
+  hh,
+  pivots
+}) {
+  const b = boxOfLayer(body);
+  const anchor = hipLine(body);
+  const { xs, ys, weights } = bodyLattice(body, chin, hh, pivots, anchor);
+  const hx = cx(b);
+  const turn = (x, t) => t * BODY.slide * hh - Math.abs(t) * BODY.narrow * (x - hx);
+  const roll = (x, y, deg) => {
+    const c = Math.cos(deg * DEG) - 1;
+    const s = Math.sin(deg * DEG);
+    const [dx, dy] = [x - hx, y - anchor];
+    return [c * dx - s * dy, s * dx + c * dy];
+  };
+  const warp = (parameter, values, field) => {
+    const extreme = Math.max(...values.map(Math.abs));
+    return {
+      parameter,
+      keyforms: values.map((value) => ({
+        value,
+        offsets: ys.flatMap(
+          (y, r) => xs.flatMap((x) => {
+            const [dx, dy] = field(x, y, value / extreme);
+            return [
+              roundTo(weights[r] * dx, 0.01),
+              roundTo(weights[r] * dy, 0.01)
+            ];
+          })
+        )
+      }))
+    };
+  };
+  const deformer = {
+    kind: "warp",
+    id: BODY_WARP_ID,
+    grid: {
+      cols: xs.length - 1,
+      rows: ys.length - 1,
+      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(
+        P3.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])
+    ]
+  };
+  refuseFold(body, deformer, anchor, [chin, ...pivots]);
+  return { deformer, mesh: bodyMesh(b, ys) };
+}
+function refuseFold(body, d, anchor, pivots) {
+  const { cols, rows, points } = d.grid;
+  const warps = d.warps ?? [];
+  const stride = cols + 1;
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const tl = r * stride + c;
+      const [tr, bl, br] = [tl + 1, tl + stride, tl + stride + 1];
+      const corners = [
+        [bl, br, tl],
+        [br, tr, bl],
+        [tr, tl, br],
+        [tl, bl, tr]
+      ];
+      for (const [p, q, s] of corners) {
+        const fold = leastArea(points, warps, p, q, s);
+        if (fold.least >= FOLD_MARGIN * fold.rest) continue;
+        const lowest = roundTo(Math.min(...pivots.map((v) => v.y)), 0.01);
+        const pose = warps.map((w, i) => `${w.parameter} ${w.keyforms[fold.stops[i]].value}`).join(", ");
+        throw new LayerGeometryError(
+          `auto-rig: layer "${body.fileName}": the body is too short between its hips (y ${anchor}) and the lowest of the head's and shoulders' pivots (y ${lowest}) for its motion: its body warp's cell from x ${points[tl * 2]} to ${points[tr * 2]}, y ${points[tl * 2 + 1]} to ${points[bl * 2 + 1]}, would fold at or near ${pose}`
+        );
+      }
+    }
+  }
+}
+function leastArea(points, warps, p, q, s) {
+  const moves = warps.map(
+    (w) => w.keyforms.map(({ offsets: o }) => [
+      o[q * 2] - o[p * 2],
+      o[q * 2 + 1] - o[p * 2 + 1],
+      o[s * 2] - o[p * 2],
+      o[s * 2 + 1] - o[p * 2 + 1]
+    ])
+  );
+  const cross = (e) => e[0] * e[3] - e[1] * e[2];
+  const edges = [
+    points[q * 2] - points[p * 2],
+    points[q * 2 + 1] - points[p * 2 + 1],
+    points[s * 2] - points[p * 2],
+    points[s * 2 + 1] - points[p * 2 + 1]
+  ];
+  let least = Infinity;
+  let stops = [];
+  const at = [];
+  const walk = (w, ax, ay, bx, by) => {
+    if (w === moves.length) {
+      const area = ax * by - ay * bx;
+      if (area < least) [least, stops] = [area, [...at]];
+      return;
+    }
+    moves[w].forEach(([mx, my, nx, ny], k) => {
+      at[w] = k;
+      walk(w + 1, ax + mx, ay + my, bx + nx, by + ny);
+    });
+  };
+  walk(0, edges[0], edges[1], edges[2], edges[3]);
+  for (const m of moves) {
+    let most = 0;
+    for (let k = 1; k < m.length; k++) {
+      most = Math.max(most, cross(m[k].map((v, i) => v - m[k - 1][i])));
+    }
+    least -= most / 4;
+  }
+  return { rest: cross(edges), least, stops };
+}
+function headOwnRoll(hasBody) {
+  return hasBody ? ROLL_DEG - BODY.followRoll : ROLL_DEG;
+}
+function headOwnBreath(hasBody) {
+  return hasBody ? AMPLITUDE.breathHead - AMPLITUDE.breathBody : AMPLITUDE.breathHead;
+}
+
+// src/auto-rig/arms.ts
+var ELBOW_AT = 0.42;
+var CAP_ROWS = [0.1, 0.3];
+var CAP_SEGMENTS = 12;
+var ARM_RANGE = [-30, 150];
+var ARM_PARAMS = {
+  arm_L: { arm: P4.ArmLeft, elbow: P4.ElbowLeft },
+  arm_R: { arm: P4.ArmRight, elbow: P4.ElbowRight }
+};
+var ARM_IDS = {
+  arm_L: {
+    forearm: "forearm_L",
+    armDeformer: "armDeformer_L",
+    forearmDeformer: "forearmDeformer_L"
+  },
+  arm_R: {
+    forearm: "forearm_R",
+    armDeformer: "armDeformer_R",
+    forearmDeformer: "forearmDeformer_R"
+  }
+};
+function armGeometry(layer, bodyAxisX) {
+  const { bbox, canvasW, canvasH, rowRuns } = layer;
+  const b = boxOfLayer(layer);
+  const span = (k) => {
+    const runs = rowRuns?.[k] ?? [];
+    if (runs.length === 0) return [bbox.x, bbox.x + bbox.w];
+    let [s2, e2] = [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]];
+    }
+    return [s2, e2];
+  };
+  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 ke = Math.round(ks + ELBOW_AT * (last - ks));
+  if (ke <= ks) {
+    throw new LayerGeometryError(
+      `auto-rig: layer "${layer.fileName}": the arm is too short for its width to place a shoulder above an elbow (draw the arm hanging, shoulder at the top)`
+    );
+  }
+  const elbow = { x: roundTo(centreX(ke), 0.01), y: roundTo(rowY(ke), 0.01) };
+  const [s, e] = span(ke);
+  const capRadius = Math.min(
+    (e - s) / 2 + 1,
+    elbow.x - b.x0,
+    b.x1 - elbow.x,
+    b.y1 - elbow.y
+  );
+  return {
+    shoulder,
+    shoulderRadius: ru,
+    elbow,
+    capRadius,
+    side: shoulder.x > bodyAxisX ? 1 : -1
+  };
+}
+function meshOf(vertices, indices) {
+  const uvs = vertices.map(
+    (v, i) => roundTo(i % 2 === 0 ? v + 0.5 : 0.5 - v, 1e-5)
+  );
+  return { vertices, uvs, indices };
+}
+function armParts(role, layer, g, order) {
+  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) => [
+    -0.5,
+    top,
+    0.5,
+    top,
+    -0.5,
+    bottom,
+    0.5,
+    bottom
+  ];
+  const quad = [2, 3, 0, 0, 3, 1];
+  const cap = [lx(g.elbow.x), seam];
+  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) => ({
+    id,
+    color: [1, 1, 1, 1],
+    width: bw(b),
+    height: bh(b),
+    transform: { x: cx(b), y: cy(b) },
+    order: at,
+    deformer,
+    mesh
+  });
+  const ids = ARM_IDS[role];
+  return [
+    part(role, ids.armDeformer, order, meshOf(band(0.5, seam), quad)),
+    part(
+      ids.forearm,
+      ids.forearmDeformer,
+      order + 1,
+      meshOf([...band(seam, -0.5), ...cap], [...quad, ...fan])
+    )
+  ];
+}
+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)]
+    },
+    {
+      id: ids.forearmDeformer,
+      parent: ids.armDeformer,
+      pivot: { ...g.elbow },
+      bindings: [rotate(params.elbow)]
+    }
+  ];
+}
+
 // src/auto-rig/checks.ts
 var finite = (v) => typeof v === "number" && Number.isFinite(v);
 var isObject = (v) => typeof v === "object" && v !== null;
@@ -2469,6 +3191,7 @@ function checkLayers(layers, canvas) {
   if (missing.length > 0) {
     throw new Error(`auto-rig: missing required role(s) ${missing.join(", ")}`);
   }
+  checkArmsHaveBody(seen);
 }
 function checkHeadEdges(edges, byRole) {
   if (edges === void 0) return;
@@ -2551,129 +3274,43 @@ function checkStrandEdges(strand, irises, hair) {
       ["irisInner", inner]
     ]) {
       if (x < iris.x0 || x > iris.x1) {
-        throw new TurnTargetError(`${at}.${k} ${x} is off its iris's crop`);
-      }
-    }
-    if (sign * (outer - inner) <= 0) {
-      throw new TurnTargetError(
-        `${at}.irisOuter ${outer} is not strictly outward of irisInner ${inner}`
-      );
-    }
-    for (const [k, x] of [
-      ["runOuter", runOuter],
-      ["runFace", runFace]
-    ]) {
-      if (x !== null && (x < hair.x0 || x > hair.x1)) {
-        throw new TurnTargetError(`${at}.${k} ${x} is off hair_front's crop`);
-      }
-    }
-    if (sign * (runOuter - cx(iris)) <= 0) {
-      throw new TurnTargetError(
-        `${at}.runOuter ${runOuter} is not strictly outward of its iris's centre`
-      );
-    }
-    if (runFace !== null && sign * (runOuter - runFace) <= 0) {
-      throw new TurnTargetError(
-        `${at}.runOuter ${runOuter} is not strictly outward of runFace ${runFace}`
-      );
-    }
-    if (runFace !== null && sign * (runFace - cx(other)) <= 0) {
-      throw new TurnTargetError(
-        `${at}.runFace ${runFace} reaches the other iris's centre; a run that does is a fringe, runFace null`
-      );
-    }
-  }
-}
-
-// src/auto-rig/context.ts
-import { StandardParameter as P2 } from "@ikijs/format";
-
-// src/auto-rig/grid.ts
-var X_STOPS = [-30, 0, 30];
-var Y_STOPS = [-30, 0, 30];
-function lattice(box, cell, min, max) {
-  const cols = cellsFor(box.x1 - box.x0, cell, min, max);
-  const rows = cellsFor(box.y1 - box.y0, cell, min, max);
-  const points = [];
-  for (let r = 0; r <= rows; r++) {
-    const y = box.y1 - (box.y1 - box.y0) * r / rows;
-    for (let c = 0; c <= cols; c++) {
-      points.push(
-        roundTo(box.x0 + (box.x1 - box.x0) * c / cols, 0.01),
-        roundTo(y, 0.01)
-      );
-    }
-  }
-  return { box, cols, rows, points };
-}
-function bake(l, field) {
-  const out = [];
-  for (const ay of Y_STOPS) {
-    for (const ax of X_STOPS) {
-      const offsets = [];
-      for (let k = 0; k < l.points.length; k += 2) {
-        if (ax === 0 && ay === 0) {
-          offsets.push(0, 0);
-          continue;
-        }
-        const [dx, dy] = field(l.points[k], l.points[k + 1], ax, ay);
-        offsets.push(roundTo(dx, 0.1), roundTo(dy, 0.1));
+        throw new TurnTargetError(`${at}.${k} ${x} is off its iris's crop`);
       }
-      out.push(offsets);
     }
-  }
-  return out;
-}
-function keyformAt(keyforms, ax) {
-  const j = Y_STOPS.indexOf(0);
-  const row = X_STOPS.map((_, i) => keyforms[j * X_STOPS.length + i]);
-  return blendStops(X_STOPS, row, ax);
-}
-function blendStops(values, offsets, v) {
-  const x = clamp(v, values[0], values[values.length - 1]);
-  let i = 0;
-  while (i < values.length - 2 && x > values[i + 1]) i++;
-  const t = (x - values[i]) / (values[i + 1] - values[i]);
-  return offsets[i].map((o, k) => o + (offsets[i + 1][k] - o) * t);
-}
-function land(l, offsets, x, y) {
-  const { cols, rows, points } = l;
-  const stride = cols + 1;
-  let col = cols - 1;
-  for (let c = 0; c < cols; c++) {
-    if (x < points[(c + 1) * 2]) {
-      col = c;
-      break;
+    if (sign * (outer - inner) <= 0) {
+      throw new TurnTargetError(
+        `${at}.irisOuter ${outer} is not strictly outward of irisInner ${inner}`
+      );
     }
-  }
-  let row = rows - 1;
-  for (let r = 0; r < rows; r++) {
-    if (y > points[(r + 1) * stride * 2 + 1]) {
-      row = r;
-      break;
+    for (const [k, x] of [
+      ["runOuter", runOuter],
+      ["runFace", runFace]
+    ]) {
+      if (x !== null && (x < hair.x0 || x > hair.x1)) {
+        throw new TurnTargetError(`${at}.${k} ${x} is off hair_front's crop`);
+      }
+    }
+    if (sign * (runOuter - cx(iris)) <= 0) {
+      throw new TurnTargetError(
+        `${at}.runOuter ${runOuter} is not strictly outward of its iris's centre`
+      );
+    }
+    if (runFace !== null && sign * (runOuter - runFace) <= 0) {
+      throw new TurnTargetError(
+        `${at}.runOuter ${runOuter} is not strictly outward of runFace ${runFace}`
+      );
+    }
+    if (runFace !== null && sign * (runFace - cx(other)) <= 0) {
+      throw new TurnTargetError(
+        `${at}.runFace ${runFace} reaches the other iris's centre; a run that does is a fringe, runFace null`
+      );
     }
   }
-  const x0 = points[col * 2];
-  const x1 = points[(col + 1) * 2];
-  const yT = points[row * stride * 2 + 1];
-  const yB = points[(row + 1) * stride * 2 + 1];
-  const s = clamp((x - x0) / (x1 - x0), 0, 1);
-  const t = clamp((yT - y) / (yT - yB), 0, 1);
-  const at = (r, c) => {
-    const k = (r * stride + c) * 2;
-    return [points[k] + offsets[k], points[k + 1] + offsets[k + 1]];
-  };
-  const p00 = at(row, col);
-  const p10 = at(row, col + 1);
-  const p01 = at(row + 1, col);
-  const p11 = at(row + 1, col + 1);
-  const topX = p00[0] + (p10[0] - p00[0]) * s;
-  const topY = p00[1] + (p10[1] - p00[1]) * s;
-  const botX = p01[0] + (p11[0] - p01[0]) * s;
-  const botY = p01[1] + (p11[1] - p01[1]) * s;
-  return [topX + (botX - topX) * t, topY + (botY - topY) * t];
 }
 
+// src/auto-rig/context.ts
+import { StandardParameter as P5 } from "@ikijs/format";
+
 // src/auto-rig/head.ts
 function outerEdge(runs, axisX, side) {
   if (runs.length === 0) return void 0;
@@ -3703,6 +4340,7 @@ function familyField(m, family) {
     case "hair_back":
       return hairField(m, m.hairBack, NOD.hairBack);
     case "body":
+    case "arm":
       return () => [0, 0];
   }
 }
@@ -3802,7 +4440,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 === P2.AngleX);
+    const warp = part?.warps?.find((w) => w.parameter === P5.AngleX);
     if (part === void 0 || part.mesh === void 0 || !g && !warp) {
       return x + field(role)(x, y, ax, 0)[0];
     }
@@ -4511,179 +5149,6 @@ function buildTurn(frame, landmarks, q) {
   };
 }
 
-// src/auto-rig/drivers.ts
-import {
-  StandardParameter as P3
-} from "@ikijs/format";
-var SWAY_RANGE = 20;
-var SWAY_CURVE = 1.4;
-var HAIR_HANG = 0.35;
-var Z_STOPS = [-30, 0, 30];
-function localWarp(parameter, mesh, box, values, f) {
-  const pts = meshPoints(mesh, box);
-  const w = bw(box);
-  const h = bh(box);
-  return {
-    parameter,
-    keyforms: values.map((value) => ({
-      value,
-      offsets: pts.flatMap((p, i) => {
-        const [dx, dy] = f(p, value, i);
-        return [roundTo(dx / w, 1e-4), roundTo(dy / h, 1e-4)];
-      })
-    }))
-  };
-}
-var rollOf = (v) => -v / 30 * ROLL_DEG * DEG;
-function motionReach(warps, mesh, box, extra = [0, 0]) {
-  const out = {
-    left: extra[0],
-    right: extra[0],
-    bottom: extra[1],
-    top: extra[1]
-  };
-  if (mesh === void 0) return out;
-  const pts = meshPoints(mesh, box);
-  for (const warp of warps ?? []) {
-    let l = 0;
-    let r = 0;
-    let b = 0;
-    let t = 0;
-    for (const k of warp.keyforms) {
-      pts.forEach(([x, y], i) => {
-        const px = x + k.offsets[2 * i] * bw(box);
-        const py = y + k.offsets[2 * i + 1] * bh(box);
-        l = Math.max(l, box.x0 - px);
-        r = Math.max(r, px - box.x1);
-        b = Math.max(b, box.y0 - py);
-        t = Math.max(t, py - box.y1);
-      });
-    }
-    out.left += l;
-    out.right += r;
-    out.bottom += b;
-    out.top += t;
-  }
-  return out;
-}
-function blinkFold(param, mesh, box, travel, eye = box) {
-  const yc = eye.y1 - travel * bh(eye);
-  return localWarp(
-    param,
-    mesh,
-    box,
-    [0, 1],
-    ([, y], v) => v === 1 ? [0, 0] : [0, yc - y]
-  );
-}
-function lashFold(param, mesh, lash, eye, travel) {
-  const yc = eye.y1 - travel * bh(eye) - 0.04 * bh(eye);
-  const c = cx(lash);
-  const half = bw(lash) / 2;
-  const sag = 0.3 * bh(lash);
-  return localWarp(param, mesh, lash, [0, 1], ([x, y], v) => {
-    if (v === 1) return [0, 0];
-    const u = (x - c) / half;
-    return [0, yc + (y - lash.y0) * 0.5 - sag * (1 - u * u) - y];
-  });
-}
-function gazeBindings(irisW, share = 1) {
-  const gx = AMPLITUDE.gazeX * irisW * share;
-  const gy = AMPLITUDE.gazeY * irisW * share;
-  return [
-    {
-      parameter: P3.EyeballX,
-      channel: "translateX",
-      from: -round1(gx),
-      to: round1(gx)
-    },
-    {
-      parameter: P3.EyeballY,
-      channel: "translateY",
-      from: -round1(gy),
-      to: round1(gy)
-    }
-  ];
-}
-function gazeReach(irisW, share = 1) {
-  return [AMPLITUDE.gazeX * irisW * share, AMPLITUDE.gazeY * irisW * share];
-}
-function browReach(hh) {
-  return AMPLITUDE.brow * hh;
-}
-function browBindings(side, reach) {
-  const y = side === "L" ? P3.BrowLeftY : P3.BrowRightY;
-  const a = side === "L" ? P3.BrowLeftAngle : P3.BrowRightAngle;
-  return [
-    {
-      parameter: y,
-      channel: "translateY",
-      from: -round1(reach),
-      to: round1(reach)
-    },
-    { parameter: a, channel: "rotate", from: -BROW_TILT, to: BROW_TILT }
-  ];
-}
-var BROW_TILT = 15;
-function mouthForm(mesh, box) {
-  const a = 0.3 * bh(box);
-  const c = cx(box);
-  const half = bw(box) / 2;
-  return localWarp(P3.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;
-    return [v * widen * (x - c), v * a * (u * u - 0.3)];
-  });
-}
-function mouthOpenGrow(mesh, box) {
-  const c = cx(box);
-  return localWarp(
-    P3.MouthOpen,
-    mesh,
-    box,
-    [0, 1],
-    ([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);
-  return localWarp(P3.MouthOpen, mesh, box, [0, 1], ([x], v) => [
-    v * (AMPLITUDE.mouthOpenWidth - 1) * (x - c),
-    0
-  ]);
-}
-function hairSway(param, mesh, box, amp) {
-  return localWarp(
-    param,
-    mesh,
-    box,
-    [-SWAY_RANGE, 0, SWAY_RANGE],
-    ([, y], v) => {
-      const t = Math.max(0, (box.y1 - y) / bh(box));
-      return [v / SWAY_RANGE * amp * t ** SWAY_CURVE, 0];
-    }
-  );
-}
-function tiltHang(mesh, box, pivot, weight) {
-  return localWarp(P3.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);
-    const px = x - pivot[0];
-    const py = y - pivot[1];
-    return [
-      pivot[0] + px * Math.cos(a) - py * Math.sin(a) - x,
-      pivot[1] + px * Math.sin(a) + py * Math.cos(a) - y
-    ];
-  });
-}
-function hairHangWeight(pivotY, bottom) {
-  if (bottom >= pivotY) return () => 0;
-  return (y) => HAIR_HANG * smoothstep(pivotY, bottom, y);
-}
-var round1 = (v) => roundTo(v, 0.1);
-
 // src/auto-rig/generate.ts
 var MESH_CELLS = {
   face: { px: 28, min: 4, max: 24 },
@@ -4710,6 +5175,7 @@ var WARP_ID = {
   mouth: "mouthWarp"
 };
 var isGridFamily = (f) => f in WARP_ID;
+var isArm = (spec) => spec.family === "arm";
 var GRID_PAD = 6;
 function generateIkiFromLayerSet(layers, canvas, options = {}) {
   checkLayers(layers, canvas);
@@ -4758,6 +5224,18 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     chinSlide: chinSlide(fit.model)
   });
   const turn = { ...fit.model, frame };
+  const arms = /* @__PURE__ */ new Map();
+  for (const spec of ROLE_TABLE) {
+    const layer = byRole.get(spec.role);
+    if (layer === void 0 || !isArm(spec)) continue;
+    arms.set(spec.role, armGeometry(layer, cx(box("body"))));
+  }
+  const bodyWarp = has("body") ? buildBodyWarp({
+    body: byRole.get("body"),
+    chin: { x: frame.axisX, y: frame.chinY },
+    hh: frame.hh,
+    pivots: [...arms.values()].map((g) => g.shoulder)
+  }) : void 0;
   const parts = [];
   const reach = /* @__PURE__ */ new Map();
   let regionOf = [];
@@ -4765,6 +5243,12 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
   for (const spec of ROLE_TABLE) {
     const layer = byRole.get(spec.role);
     if (layer === void 0) continue;
+    if (isArm(spec)) {
+      parts.push(
+        ...armParts(spec.role, layer, arms.get(spec.role), parts.length)
+      );
+      continue;
+    }
     const built = buildPart(
       spec,
       boxOfLayer(layer),
@@ -4783,7 +5267,9 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
   }
   const grids = /* @__PURE__ */ new Map();
   for (const family of Object.keys(WARP_ID)) {
-    const members = parts.filter((p) => roleSpec(p.id).family === family);
+    const members = parts.filter(
+      (p) => roleSpec(roleOfPart(p.id)).family === family
+    );
     if (members.length === 0) continue;
     const area = unionBoxes(
       members.map((p) => {
@@ -4805,13 +5291,19 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     });
   }
   for (const part of parts) {
-    const family = roleSpec(part.id).family;
+    const family = roleSpec(roleOfPart(part.id)).family;
     if (isGridFamily(family)) {
       part.deformer = WARP_ID[family];
       continue;
     }
-    part.deformer = family === "body" ? "bodyDeformer" : "headDeformer";
-    if (family === "body" || part.mesh === void 0) continue;
+    if (family === "body") {
+      part.deformer = BODY_WARP_ID;
+      part.mesh = bodyWarp.mesh;
+      continue;
+    }
+    if (family === "arm") continue;
+    part.deformer = "headDeformer";
+    if (part.mesh === void 0) continue;
     const own = familyField(turn, family);
     const fieldOf = part.id === "face" ? plateFields(turn, regionOf, own) : () => own;
     part.warps = [
@@ -4826,7 +5318,7 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     canvas: { width: canvas.width, height: canvas.height },
     parameters,
     parts,
-    deformers: deformers(frame, grids, has("body") ? box("body") : void 0),
+    deformers: deformers(frame, grids, bodyWarp?.deformer, arms),
     ...has("hair_front") ? { physics: hairPhysics() } : {},
     expressions: defaultExpressions(new Set(parameters.map((p) => p.id))),
     motions: DEFAULT_MOTIONS
@@ -4846,14 +5338,14 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
 function turnWarps(mesh, b, fieldOf) {
   return [
     localWarp(
-      P4.AngleX,
+      P6.AngleX,
       mesh,
       b,
       X_STOPS,
       ([x, y], v, i) => v === 0 ? [0, 0] : [fieldOf(i)(x, y, v, 0)[0], 0]
     ),
     localWarp(
-      P4.AngleY,
+      P6.AngleY,
       mesh,
       b,
       Y_STOPS,
@@ -4901,16 +5393,22 @@ 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" ? P4.EyeOpenLeft : P4.EyeOpenRight;
+  const eyeOpen = side === "L" ? P6.EyeOpenLeft : P6.EyeOpenRight;
   const hh = frame.hh;
   switch (spec.role) {
     case "face":
       if (region?.some((r) => r === "neck")) {
         const isNeck = region.map((r) => r === "neck");
         warps.push(
-          tiltHang(mesh, b, pivot, (_y, i) => isNeck[i] ? 1 : 0),
+          tiltHang(
+            mesh,
+            b,
+            pivot,
+            (_y, i) => isNeck[i] ? 1 : 0,
+            headOwnRoll(byRole.has("body"))
+          ),
           localWarp(
-            P4.Breath,
+            P6.Breath,
             mesh,
             b,
             [0, 1],
@@ -4957,8 +5455,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
       if (byRole.has("mouth_open")) {
         warps.push(mouthWiden(mesh, b));
         bindings.push(
-          { parameter: P4.MouthOpen, channel: "opacity", from: 1, to: 0 },
-          { parameter: P4.MouthOpen, channel: "opacity", from: 1, to: 0 }
+          { parameter: P6.MouthOpen, channel: "opacity", from: 1, to: 0 },
+          { parameter: P6.MouthOpen, channel: "opacity", from: 1, to: 0 }
         );
         extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       } else {
@@ -4968,19 +5466,19 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
         );
         bindings.push(
           {
-            parameter: P4.MouthOpen,
+            parameter: P6.MouthOpen,
             channel: "scaleY",
             from: 0,
             to: roundTo(grow, 0.01)
           },
           {
-            parameter: P4.MouthOpen,
+            parameter: P6.MouthOpen,
             channel: "scaleX",
             from: 0,
             to: roundTo(AMPLITUDE.mouthOpenWidth - 1, 0.01)
           },
           {
-            parameter: P4.MouthOpen,
+            parameter: P6.MouthOpen,
             channel: "translateY",
             from: 0,
             to: -roundTo(grow * bh(b) / 2, 0.01)
@@ -4992,7 +5490,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
     case "mouth_open":
       warps.push(mouthForm(mesh, b), mouthOpenGrow(mesh, b));
       bindings.push({
-        parameter: P4.MouthOpen,
+        parameter: P6.MouthOpen,
         channel: "opacity",
         from: 0,
         to: 1
@@ -5002,7 +5500,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
     case "blush_L":
     case "blush_R":
       bindings.push({
-        parameter: P4.Cheek,
+        parameter: P6.Cheek,
         channel: "opacity",
         from: AMPLITUDE.blushRest,
         to: 1
@@ -5013,8 +5511,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(P4.HairSwayX, mesh, b, amp),
-          hairSway(P4.HairSwayZ, mesh, b, amp)
+          hairSway(P6.HairSwayX, mesh, b, amp),
+          hairSway(P6.HairSwayZ, mesh, b, amp)
         );
       }
       warps.push(tiltHang(mesh, b, pivot, hairHangWeight(frame.chinY, b.y0)));
@@ -5087,33 +5585,24 @@ function meshScale(role, frame) {
       return Infinity;
   }
 }
-function deformers(frame, grids, body) {
+function deformers(frame, grids, bodyWarp, arms) {
   const out = [];
-  if (body !== void 0) {
-    out.push({
-      id: "bodyDeformer",
-      pivot: { x: roundTo(cx(body), 0.01), y: roundTo(body.y1, 0.01) },
-      bindings: [
-        {
-          parameter: P4.Breath,
-          channel: "translateY",
-          from: 0,
-          to: roundTo(AMPLITUDE.breathBody * frame.hh, 0.01)
-        }
-      ]
-    });
-  }
+  if (bodyWarp !== void 0) out.push(bodyWarp);
+  for (const [role, g] of arms) out.push(...armDeformers(role, g));
+  const hasBody = bodyWarp !== void 0;
+  const roll = headOwnRoll(hasBody);
   out.push({
     id: "headDeformer",
+    ...hasBody ? { parent: BODY_WARP_ID } : {},
     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: P4.AngleZ, channel: "rotate", from: ROLL_DEG, to: -ROLL_DEG },
+      { parameter: P6.AngleZ, channel: "rotate", from: roll, to: -roll },
       {
-        parameter: P4.Breath,
+        parameter: P6.Breath,
         channel: "translateY",
         from: 0,
-        to: roundTo(AMPLITUDE.breathHead * frame.hh, 0.01)
+        to: roundTo(headOwnBreath(hasBody) * frame.hh, 0.01)
       }
     ]
   });
@@ -5128,8 +5617,8 @@ function deformers(frame, grids, body) {
         points: g.lattice.points
       },
       warp2d: {
-        parameter: P4.AngleX,
-        parameterY: P4.AngleY,
+        parameter: P6.AngleX,
+        parameterY: P6.AngleY,
         valuesX: X_STOPS,
         valuesY: Y_STOPS,
         keyforms2d: g.keyforms.map((offsets) => ({ offsets }))
@@ -5142,16 +5631,16 @@ function hairPhysics() {
   return [
     {
       id: "hairSway",
-      input: { parameter: P4.AngleX, weight: 1 },
-      output: { parameter: P4.HairSwayX, scale: 5 },
+      input: { parameter: P6.AngleX, weight: 1 },
+      output: { parameter: P6.HairSwayX, scale: 5 },
       mass: 1,
       stiffness: 30,
       damping: 3
     },
     {
       id: "hairTilt",
-      input: { parameter: P4.AngleZ, weight: 1 },
-      output: { parameter: P4.HairSwayZ, scale: 8 },
+      input: { parameter: P6.AngleZ, weight: 1 },
+      output: { parameter: P6.HairSwayZ, scale: 8 },
       mass: 1,
       stiffness: 25,
       damping: 2.5
@@ -5161,32 +5650,46 @@ function hairPhysics() {
 function declareParameters(roles) {
   const out = [];
   const add = (id, name, min, max, def) => out.push({ id, name, min, max, default: def });
-  add(P4.AngleX, "Head Angle", -30, 30, 0);
-  add(P4.AngleY, "Head Angle Y", -30, 30, 0);
-  add(P4.AngleZ, "Head Angle Z", -30, 30, 0);
-  add(P4.EyeOpenLeft, "Eye L", 0, 1, 1);
-  add(P4.EyeOpenRight, "Eye R", 0, 1, 1);
+  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);
+  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);
+  }
+  const [armMin, armMax] = ARM_RANGE;
+  if (roles.has("arm_L")) {
+    add(P6.ArmLeft, "Arm L", armMin, armMax, 0);
+    add(P6.ElbowLeft, "Elbow L", armMin, armMax, 0);
+  }
+  if (roles.has("arm_R")) {
+    add(P6.ArmRight, "Arm R", armMin, armMax, 0);
+    add(P6.ElbowRight, "Elbow R", armMin, armMax, 0);
+  }
+  add(P6.EyeOpenLeft, "Eye L", 0, 1, 1);
+  add(P6.EyeOpenRight, "Eye R", 0, 1, 1);
   if ([...roles].some((r) => /^(iris|pupil|highlight)_/.test(r))) {
-    add(P4.EyeballX, "Gaze X", -1, 1, 0);
-    add(P4.EyeballY, "Gaze Y", -1, 1, 0);
+    add(P6.EyeballX, "Gaze X", -1, 1, 0);
+    add(P6.EyeballY, "Gaze Y", -1, 1, 0);
   }
-  add(P4.MouthOpen, "Mouth Open", 0, 1, 0);
-  add(P4.MouthForm, "Mouth Form", -1, 1, 0);
+  add(P6.MouthOpen, "Mouth Open", 0, 1, 0);
+  add(P6.MouthForm, "Mouth Form", -1, 1, 0);
   if (roles.has("brow_L")) {
-    add(P4.BrowLeftY, "Brow L Y", -1, 1, 0);
-    add(P4.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
+    add(P6.BrowLeftY, "Brow L Y", -1, 1, 0);
+    add(P6.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
   }
   if (roles.has("brow_R")) {
-    add(P4.BrowRightY, "Brow R Y", -1, 1, 0);
-    add(P4.BrowRightAngle, "Brow R Angle", -1, 1, 0);
+    add(P6.BrowRightY, "Brow R Y", -1, 1, 0);
+    add(P6.BrowRightAngle, "Brow R Angle", -1, 1, 0);
   }
   if (roles.has("blush_L") || roles.has("blush_R")) {
-    add(P4.Cheek, "Cheek", 0, 1, 0);
+    add(P6.Cheek, "Cheek", 0, 1, 0);
   }
-  add(P4.Breath, "Breath", 0, 1, 0);
+  add(P6.Breath, "Breath", 0, 1, 0);
   if (roles.has("hair_front")) {
-    add(P4.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
-    add(P4.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(P6.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(P6.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
   }
   return out;
 }
@@ -5204,6 +5707,7 @@ export {
   DeletePhysicsRig,
   EditorDocument,
   HEAD_BAND,
+  LayerGeometryError,
   SPECK_CORE_FRACTION,
   SetDeformerBindings,
   SetDeformerParent,
@@ -5238,6 +5742,7 @@ export {
   isSpeckCore,
   packAtlas,
   parseLayerRoles,
+  partIdsOfRole,
   upsertGridKeyform,
   uvRectFor,
   validateDeformerDelete,