@ikijs/editor 0.4.0 → 0.6.0

package/dist/index.mjs

@@ -1603,11 +1603,27 @@ import {
   StandardParameter,
   parseIkiModel as parseIkiModel3
 } from "@ikijs/format";
+var TURN_GROUP_IDS = [
+  "faceWarp",
+  "eyeWarp_L",
+  "eyeWarp_R",
+  "mouthWarp",
+  "noseWarp",
+  "browWarp_L",
+  "browWarp_R",
+  "blushWarp_L",
+  "blushWarp_R"
+];
+var TURN_GROUP_ID_SET = new Set(TURN_GROUP_IDS);
+function isTurnGroup(id) {
+  return TURN_GROUP_ID_SET.has(id);
+}
 var ROLE_TABLE = {
   // The silhouette behind the face. It rides the rigid head (not faceWarp,
-  // whose grid it would stretch across the shoulders) as a MESH: it bends on
-  // the turn through its own part warp (bakeHairBackTurnWarp) and swings its
-  // ends on the hair-sway warps.
+  // whose grid it would stretch across the shoulders) as a MESH, so its ends
+  // can swing on the hair-sway warps. It holds the head's outline STILL
+  // through the turn — the head it hangs off no longer travels and it has no
+  // turn warp of its own — while the face slides inside it.
   hair_back: { deformer: "headDeformer", order: 0, mesh: true },
   // The torso. It rides its own rigid deformer, not the head's: the head turns
   // about the neck pivot while the shoulders follow at BODY_TURN_FOLLOW and
@@ -1615,34 +1631,43 @@ var ROLE_TABLE = {
   // reading as a floating head. Drawn over the back hair so long hair falls
   // behind the shoulders.
   body: { deformer: "bodyDeformer", order: 5, mesh: false },
+  // The face plate and everything painted on it ride per-group turn warps
+  // under the head (TurnGroupId): the plate its own, each eye stack its
+  // side's, both mouth drawings one, the nose, each brow and each blush their
+  // own. A group's grid is sized to its members alone and baked from the one
+  // solved surface with the family's turn depth in its keyforms, so a feature
+  // slides across the plate on its own grid instead of a translate binding
+  // (see generateIkiFromLayerSet).
   face: { deformer: "faceWarp", order: 10, mesh: true },
-  nose: { deformer: "faceWarp", order: 15, mesh: true },
-  blush_L: { deformer: "faceWarp", order: 20, mesh: true },
-  blush_R: { deformer: "faceWarp", order: 20, mesh: true },
-  mouth: { deformer: "faceWarp", order: 25, mesh: true },
+  nose: { deformer: "noseWarp", order: 15, mesh: true },
+  blush_L: { deformer: "blushWarp_L", order: 20, mesh: true },
+  blush_R: { deformer: "blushWarp_R", order: 20, mesh: true },
+  mouth: { deformer: "mouthWarp", order: 25, mesh: true },
   // An OPTIONAL second mouth drawing, open. When present the two cross-fade on
   // MouthOpen instead of the closed one being stretched, which is the
   // difference between a portrait rig and one that can lip-sync.
-  mouth_open: { deformer: "faceWarp", order: 26, mesh: true },
-  eye_L: { deformer: "faceWarp", order: 30, mesh: true, eyeSide: "L" },
-  eye_R: { deformer: "faceWarp", order: 30, mesh: true, eyeSide: "R" },
-  iris_L: { deformer: "faceWarp", order: 31, mesh: true, eyeSide: "L" },
-  iris_R: { deformer: "faceWarp", order: 31, mesh: true, eyeSide: "R" },
-  pupil_L: { deformer: "faceWarp", order: 32, mesh: true, eyeSide: "L" },
-  pupil_R: { deformer: "faceWarp", order: 32, mesh: true, eyeSide: "R" },
-  highlight_L: { deformer: "faceWarp", order: 33, mesh: true, eyeSide: "L" },
-  highlight_R: { deformer: "faceWarp", order: 33, mesh: true, eyeSide: "R" },
+  mouth_open: { deformer: "mouthWarp", order: 26, mesh: true },
+  eye_L: { deformer: "eyeWarp_L", order: 30, mesh: true, eyeSide: "L" },
+  eye_R: { deformer: "eyeWarp_R", order: 30, mesh: true, eyeSide: "R" },
+  iris_L: { deformer: "eyeWarp_L", order: 31, mesh: true, eyeSide: "L" },
+  iris_R: { deformer: "eyeWarp_R", order: 31, mesh: true, eyeSide: "R" },
+  pupil_L: { deformer: "eyeWarp_L", order: 32, mesh: true, eyeSide: "L" },
+  pupil_R: { deformer: "eyeWarp_R", order: 32, mesh: true, eyeSide: "R" },
+  highlight_L: { deformer: "eyeWarp_L", order: 33, mesh: true, eyeSide: "L" },
+  highlight_R: { deformer: "eyeWarp_R", order: 33, mesh: true, eyeSide: "R" },
   // Upper lashes: an OPTIONAL separate layer ABOVE the iris that folds down to
   // the closed-eye seam (the same crease the white folds to), covering the cut
   // eyeball cleanly. When absent, the white's own fold is the only closed line.
-  lash_L: { deformer: "faceWarp", order: 34, mesh: true, eyeSide: "L" },
-  lash_R: { deformer: "faceWarp", order: 34, mesh: true, eyeSide: "R" },
-  brow_L: { deformer: "faceWarp", order: 40, mesh: true },
-  brow_R: { deformer: "faceWarp", order: 40, mesh: true },
-  // Front hair rides faceWarp (mesh) so it follows the head-turn curvature with
-  // the face instead of detaching as a rigid blob; its bbox joins the faceWarp
-  // grid union so the grid covers it.
-  hair_front: { deformer: "faceWarp", order: 50, mesh: true }
+  lash_L: { deformer: "eyeWarp_L", order: 34, mesh: true, eyeSide: "L" },
+  lash_R: { deformer: "eyeWarp_R", order: 34, mesh: true, eyeSide: "R" },
+  brow_L: { deformer: "browWarp_L", order: 40, mesh: true },
+  brow_R: { deformer: "browWarp_R", order: 40, mesh: true },
+  // The bangs ride the rigid head, like the back hair, and bind to no grid:
+  // every motion of their own — the silhouette hold, the turn lead, the nod
+  // and the sway — is a per-vertex warp attached in generateIkiFromLayerSet,
+  // so they draw the head's outline where the plate under them bends and
+  // slides (see bakeHairFrontSilhouetteWarp).
+  hair_front: { deformer: "headDeformer", order: 50, mesh: true }
 };
 var REQUIRED_ROLES = ["face", "eye_L", "eye_R", "mouth"];
 var ALIAS_MAP = {
@@ -1730,6 +1755,27 @@ function validateLayerInputs(layers, canvas) {
         `auto-rig: validateLayerInputs: role "${role}" canvas size (${canvasW}\xD7${canvasH}) does not match canvas arg (${canvas.width}\xD7${canvas.height})`
       );
     }
+    if (layer.rowHalfWidths !== void 0) {
+      const rows = layer.rowHalfWidths;
+      if (!Array.isArray(rows)) {
+        throw new Error(
+          `auto-rig: validateLayerInputs: role "${role}" rowHalfWidths must be an array with one entry per crop row`
+        );
+      }
+      if (rows.length !== cropH) {
+        throw new Error(
+          `auto-rig: validateLayerInputs: role "${role}" rowHalfWidths has ${rows.length} entries, not one per crop row (cropH ${cropH})`
+        );
+      }
+      for (let i = 0; i < rows.length; i++) {
+        const a = rows[i];
+        if (typeof a !== "number" || !Number.isFinite(a) || a < 0 || a > cropW / 2) {
+          throw new Error(
+            `auto-rig: validateLayerInputs: role "${role}" rowHalfWidths[${i}] is ${String(a)}, not a finite number in [0, ${cropW / 2}] (half the crop's width)`
+          );
+        }
+      }
+    }
   }
 }
 function generateGridPoints(cols, rows, minX, maxX, minY, maxY) {
@@ -1785,44 +1831,123 @@ function meshCellsFor(w, h) {
   );
   return { cols: cells(w), rows: cells(h) };
 }
-var FACE_GRID_CELLS = 6;
+var FACE_PLATE_CELLS = 10;
+var FEATURE_GRID_CELLS = 4;
+var TURN_LATTICE_CELL_PX = 16;
+var GRID_MARGIN = 0.12;
 var HEAD_CYLINDER_RADIUS_FACTOR = 0.6 / 0.5;
 var HEAD_TURN_MAX_DEG = 30;
 var HEAD_TURN_STOPS = [-30, -15, 0, 15, 30];
-function headTurnParallaxUnit(gridHalfWidth) {
-  return gridHalfWidth * HEAD_CYLINDER_RADIUS_FACTOR * Math.sin(HEAD_TURN_MAX_DEG * (Math.PI / 180));
-}
-function gridReach(grid, axis, center) {
-  let reach = 0;
-  for (let i = axis; i < grid.points.length; i += 2) {
-    reach = Math.max(reach, Math.abs(grid.points[i] - center));
-  }
-  return reach;
+function headTurnParallaxUnit(radius) {
+  return radius * Math.sin(HEAD_TURN_MAX_DEG * (Math.PI / 180));
 }
 function pinnedCylinderBend(local, radius, theta) {
   const alpha = Math.asin(Math.max(-1, Math.min(1, local / radius)));
   return radius * Math.sin(alpha + theta) - local - radius * Math.sin(theta);
 }
-function bakeHeadTurnGridWarp2DCentered(grid, parameterX, parameterY, centerX, centerY) {
+function boundedCylinderBend(local, radius, theta) {
+  const bound = radius / HEAD_CYLINDER_RADIUS_FACTOR;
+  const onSurface = Math.max(-bound, Math.min(bound, local));
+  return pinnedCylinderBend(onSurface, radius, theta);
+}
+function turnSlide(travel, angleX) {
+  return travel * angleX / HEAD_TURN_MAX_DEG;
+}
+var FACE_ROW_MIN_FRACTION = 0.15;
+var FACE_ROW_SMOOTHING = 0.05;
+var CHIN_SWING = 0.08;
+function faceRowProfile(face, faceCenterY) {
+  const raw = face.rowHalfWidths;
+  if (raw === void 0) return void 0;
+  const n = raw.length;
+  let aMax = 0;
+  let widest = -1;
+  for (let i = 0; i < n; i++) {
+    if (raw[i] > 0 && raw[i] >= aMax) {
+      aMax = raw[i];
+      widest = i;
+    }
+  }
+  if (widest < 0) return void 0;
+  const filled = [];
+  for (let i = 0; i < n; i++) {
+    filled.push(i < widest ? aMax : raw[i] > 0 ? raw[i] : filled[i - 1]);
+  }
+  const half = Math.max(1, Math.round(FACE_ROW_SMOOTHING * n / 2));
+  const floor = FACE_ROW_MIN_FRACTION * aMax;
+  const rows = [];
+  for (let i = 0; i < n; i++) {
+    if (i < widest) {
+      rows.push(aMax);
+      continue;
+    }
+    let sum = 0;
+    for (let k = i - half; k <= i + half; k++) {
+      sum += filled[Math.max(0, Math.min(n - 1, k))];
+    }
+    rows.push(Math.max(floor, sum / (2 * half + 1)));
+  }
+  const top = faceCenterY + face.cropH / 2;
+  const rowAt = (y) => Math.max(0, Math.min(n - 1, top - y - 0.5));
+  return {
+    at: (y) => {
+      const r = rowAt(y);
+      const i = Math.floor(r);
+      if (i + 1 >= n) return rows[n - 1];
+      return rows[i] + (rows[i + 1] - rows[i]) * (r - i);
+    },
+    aMax,
+    widestY: top - widest - 0.5,
+    faceHalfWidth: face.cropW / 2
+  };
+}
+function turnSurface(spec) {
+  const { faceCenterX, faceCenterY, radius, travel, nodRadius, lattice } = spec;
+  const { profile } = spec;
+  let radiusAt = (_y) => radius;
+  let swingAt = (_y) => 0;
+  if (profile !== void 0) {
+    const aEye = profile.at(spec.eyeRowY ?? faceCenterY);
+    radiusAt = (y) => radius * (profile.at(y) / aEye);
+    swingAt = (y) => y < profile.widestY ? -CHIN_SWING * profile.faceHalfWidth * Math.max(0, 1 - profile.at(y) / profile.aMax) : 0;
+  }
+  return {
+    faceCenterX,
+    faceCenterY,
+    radius,
+    travel,
+    nodRadius,
+    lattice,
+    radiusAt,
+    swingAt,
+    mapAt: (deg, y) => turnColumnMap(
+      lattice,
+      faceCenterX,
+      radiusAt(y),
+      deg,
+      travel + swingAt(y)
+    ),
+    nodBendAt: (y, angleY) => pinnedCylinderBend(
+      y - faceCenterY,
+      nodRadius,
+      angleY * NOD_BEND * (Math.PI / 180)
+    )
+  };
+}
+function bakeTurnGroupWarp2D(grid, parameterX, parameterY, surface, shiftAt) {
   const STOPS = [...HEAD_TURN_STOPS];
-  const RADIUS_X = gridReach(grid, 0, centerX) * HEAD_CYLINDER_RADIUS_FACTOR;
-  const RADIUS_Y = gridReach(grid, 1, centerY) * HEAD_CYLINDER_RADIUS_FACTOR;
   const pointCount = grid.points.length / 2;
-  const DEG_TO_RAD = Math.PI / 180;
   const keyforms2d = [];
   for (const angleY of STOPS) {
-    const thetaY = angleY * NOD_BEND * DEG_TO_RAD;
     for (const angleX of STOPS) {
-      const thetaX = angleX * DEG_TO_RAD;
+      const shift = shiftAt(angleX);
       const offsets = [];
       for (let i = 0; i < pointCount; i++) {
+        const x = grid.points[i * 2];
+        const y = grid.points[i * 2 + 1];
         offsets.push(
-          pinnedCylinderBend(grid.points[i * 2] - centerX, RADIUS_X, thetaX),
-          pinnedCylinderBend(
-            grid.points[i * 2 + 1] - centerY,
-            RADIUS_Y,
-            thetaY
-          )
+          angleX === 0 ? 0 : surface.mapAt(angleX, y).mapX(x + shift) - x,
+          angleY === 0 ? 0 : surface.nodBendAt(y, angleY)
         );
       }
       keyforms2d.push({ offsets });
@@ -1836,16 +1961,967 @@ function bakeHeadTurnGridWarp2DCentered(grid, parameterX, parameterY, centerX, c
     keyforms2d
   };
 }
+function turnColumnMap(grid, faceCenterX, radiusX, angleX, travel) {
+  if (Math.abs(angleX) > HEAD_TURN_MAX_DEG) {
+    throw new Error(
+      `auto-rig: turnColumnMap: angleX ${angleX}\xB0 is outside the turn's \xB1${HEAD_TURN_MAX_DEG}\xB0 range`
+    );
+  }
+  const theta = angleX * (Math.PI / 180);
+  const slide = turnSlide(travel, angleX);
+  const restX = [];
+  const warpedX = [];
+  for (let col = 0; col <= grid.cols; col++) {
+    const x = grid.points[col * 2];
+    restX.push(x);
+    warpedX.push(
+      x + boundedCylinderBend(x - faceCenterX, radiusX, theta) + slide
+    );
+  }
+  const cellFor = (v, edges) => {
+    let lo = 0;
+    let hi = grid.cols - 1;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (v < edges[mid + 1]) hi = mid;
+      else lo = mid + 1;
+    }
+    return lo;
+  };
+  const sample = (edges, values, v) => {
+    const c = cellFor(v, edges);
+    const s = Math.max(
+      0,
+      Math.min(1, (v - edges[c]) / (edges[c + 1] - edges[c]))
+    );
+    if (s === 0) return values[c];
+    if (s === 1) return values[c + 1];
+    return values[c] + (values[c + 1] - values[c]) * s;
+  };
+  return {
+    restX,
+    warpedX,
+    mapX: (x) => sample(restX, warpedX, x),
+    invertX: (X) => sample(warpedX, restX, X)
+  };
+}
+function renderedLandingX(part, vertexLanding, px, py) {
+  const { cols, rows } = part;
+  const u = (px - part.x + part.cropW / 2) / part.cropW * cols;
+  const v = (part.y + part.cropH / 2 - py) / part.cropH * rows;
+  const col = Math.max(0, Math.min(cols - 1, Math.floor(u)));
+  const row = Math.max(0, Math.min(rows - 1, Math.floor(v)));
+  const fx = Math.max(0, Math.min(1, u - col));
+  const fy = Math.max(0, Math.min(1, v - row));
+  const cos = Math.cos(part.rotation * (Math.PI / 180));
+  const sin = Math.sin(part.rotation * (Math.PI / 180));
+  const landingAt = (c, r) => {
+    const lx = (-part.cropW / 2 + c / cols * part.cropW) * part.scaleX;
+    const ly = (part.cropH / 2 - r / rows * part.cropH) * part.scaleY;
+    return vertexLanding(
+      part.x + cos * lx - sin * ly,
+      part.y + sin * lx + cos * ly
+    );
+  };
+  const tl = landingAt(col, row);
+  const br = landingAt(col + 1, row + 1);
+  if (fx <= fy) {
+    const bl = landingAt(col, row + 1);
+    return tl + fy * (bl - tl) + fx * (br - bl);
+  }
+  const tr = landingAt(col + 1, row);
+  return tl + fx * (tr - tl) + fy * (br - tr);
+}
+function gridChildLandingX(grid, nodeLanding, x, y) {
+  const { cols, rows, points } = grid;
+  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 xLeft = points[col * 2];
+  const xRight = points[(col + 1) * 2];
+  const yTop = points[row * stride * 2 + 1];
+  const yBottom = points[(row + 1) * stride * 2 + 1];
+  const s = Math.max(0, Math.min(1, (x - xLeft) / (xRight - xLeft)));
+  const t = Math.max(0, Math.min(1, (yTop - y) / (yTop - yBottom)));
+  const at = (c, r) => nodeLanding(points[(r * stride + c) * 2], points[(r * stride + c) * 2 + 1]);
+  const top = at(col, row) + (at(col + 1, row) - at(col, row)) * s;
+  const bot = at(col, row + 1) + (at(col + 1, row + 1) - at(col, row + 1)) * s;
+  return top + (bot - top) * t;
+}
+function carrierLandingX(carrier, nodeLanding, px, py) {
+  return renderedLandingX(
+    carrier.part,
+    (vx, vy) => gridChildLandingX(carrier.grid, nodeLanding, vx, vy),
+    px,
+    py
+  );
+}
+function rowMapsOf(surface) {
+  const maps = /* @__PURE__ */ new Map();
+  return (deg, nodeY) => {
+    let byRow = maps.get(deg);
+    if (byRow === void 0) {
+      byRow = /* @__PURE__ */ new Map();
+      maps.set(deg, byRow);
+    }
+    let map = byRow.get(nodeY);
+    if (map === void 0) {
+      map = surface.mapAt(deg, nodeY);
+      byRow.set(nodeY, map);
+    }
+    return map;
+  };
+}
+function plateLandingOn(plate, mapAt) {
+  return (deg, x, y) => carrierLandingX(
+    plate,
+    (nodeX, nodeY) => mapAt(deg, nodeY).mapX(nodeX),
+    x,
+    y
+  );
+}
+function plateGuardRowsFor(face, hairFront) {
+  const rowsOf = (part, y) => {
+    const { rows } = meshCellsFor(part.cropW, part.cropH);
+    return Array.from(
+      { length: rows + 1 },
+      (_, r) => y + (part.cropH / 2 - r / rows * part.cropH)
+    );
+  };
+  const faceRows = rowsOf(face, face.y);
+  if (hairFront === void 0) return faceRows;
+  const top = face.y + face.cropH / 2;
+  const bottom = face.y - face.cropH / 2;
+  return [
+    ...faceRows,
+    ...rowsOf(hairFront, hairFront.centerY).map(
+      (y) => Math.max(bottom, Math.min(top, y))
+    )
+  ];
+}
+function plateGuardsOf(carriers, faceHalfWidth, profile, hairFront) {
+  const plate = carriers.get("face");
+  if (plate === void 0) {
+    throw new Error("auto-rig: plateGuardsOf: the carriers have no face");
+  }
+  return {
+    plate,
+    edgeAt: profile === void 0 ? () => faceHalfWidth : profile.at,
+    plateGuardRows: plateGuardRowsFor(plate.part, hairFront)
+  };
+}
+var TurnTargetError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TurnTargetError";
+  }
+};
+var DEFAULT_TURN_TARGETS = {
+  eyeShift: 0.22,
+  farEyeRatio: 0.67,
+  silhouetteRatio: 1
+};
+var NOSE_SHIFT_SHARE = 1.36;
+var MOUTH_SHIFT_SHARE = 1.18;
+var TURN_RATIO_MAX = 1.5;
+var SILHOUETTE_RATIO_MIN = 0.5;
+function resolveTurnTargets(targets = {}) {
+  const eyeShift = targets.eyeShift ?? DEFAULT_TURN_TARGETS.eyeShift;
+  const check = (field, value, ok, expected) => {
+    if (value === void 0) return;
+    if (!Number.isFinite(value) || !ok(value)) {
+      const derived = (field === "noseShift" || field === "mouthShift") && targets[field] === void 0;
+      const from = derived ? `, derived from turnTargets.eyeShift (${eyeShift}),` : "";
+      throw new TurnTargetError(
+        `auto-rig: turnTargets.${field} (${value})${from} must be ${expected}`
+      );
+    }
+  };
+  const farEyeRatio = targets.farEyeRatio ?? DEFAULT_TURN_TARGETS.farEyeRatio;
+  const silhouetteRatio = targets.silhouetteRatio ?? DEFAULT_TURN_TARGETS.silhouetteRatio;
+  const noseShift = targets.noseShift ?? NOSE_SHIFT_SHARE * eyeShift;
+  const mouthShift = targets.mouthShift ?? MOUTH_SHIFT_SHARE * eyeShift;
+  const isShift = (v) => Math.abs(v) <= 1;
+  const shiftRange = "a fraction of the head half-width, |value| <= 1";
+  check("eyeShift", eyeShift, isShift, shiftRange);
+  check(
+    "farEyeRatio",
+    farEyeRatio,
+    (v) => v > 0 && v <= TURN_RATIO_MAX,
+    `in (0, ${TURN_RATIO_MAX}]`
+  );
+  check(
+    "silhouetteRatio",
+    silhouetteRatio,
+    (v) => v >= SILHOUETTE_RATIO_MIN && v <= TURN_RATIO_MAX,
+    `in [${SILHOUETTE_RATIO_MIN}, ${TURN_RATIO_MAX}]`
+  );
+  check("noseShift", noseShift, isShift, shiftRange);
+  check("mouthShift", mouthShift, isShift, shiftRange);
+  check("headHalfWidth", targets.headHalfWidth, (v) => v > 0, "positive");
+  const defaulted = new Set(
+    [
+      "eyeShift",
+      "farEyeRatio",
+      "silhouetteRatio",
+      "noseShift",
+      "mouthShift"
+    ].filter((field) => targets[field] === void 0)
+  );
+  return {
+    eyeShift,
+    farEyeRatio,
+    silhouetteRatio,
+    noseShift,
+    mouthShift,
+    headHalfWidth: targets.headHalfWidth,
+    defaulted
+  };
+}
+function turnLandmarks(layers, carriers) {
+  const markOf = (role) => {
+    const layer = layers.find((l) => l.role === role);
+    if (!layer) return void 0;
+    const t = bboxToTransform(layer.bbox, layer.canvasW, layer.canvasH, role);
+    const mark = { x: t.x, y: t.y, w: layer.cropW };
+    const carrier = carriers?.get(role);
+    if (carrier !== void 0) mark.carrier = carrier;
+    return mark;
+  };
+  const pairOf = (left, right) => {
+    const l = markOf(left);
+    const r = markOf(right);
+    return l && r ? [l, r] : void 0;
+  };
+  const one = (role) => {
+    const m = markOf(role);
+    return m ? [m] : [];
+  };
+  return {
+    eye: pairOf("eye_L", "eye_R") ?? [],
+    nose: one("nose"),
+    mouth: one("mouth")
+  };
+}
+function eyeRowOf(landmarks, fallback) {
+  const [l, r] = landmarks.eye;
+  return landmarks.eye.length === 2 && l.y !== void 0 && r.y !== void 0 ? (l.y + r.y) / 2 : fallback;
+}
+var TURN_BISECT_STEPS = 40;
+var TURN_DEPTH_EPS = 1e-6;
+function landmarkLandingX(landmark, mapAt, shift, px, py) {
+  if (landmark.carrier === void 0) return mapAt(py).mapX(px + shift);
+  return carrierLandingX(
+    landmark.carrier,
+    (nodeX, nodeY) => mapAt(nodeY).mapX(nodeX + shift),
+    px,
+    py
+  );
+}
+function familyReachPx(landmarks, plateEdgeX) {
+  const farEdge = Math.min(...landmarks.map((l) => l.x - l.w / 2));
+  return Math.max(0, farEdge - plateEdgeX);
+}
+function solveTurnDepthSigned(target, landmarks, unit, mapAt, plateEdgeX) {
+  if (landmarks.length === 0) {
+    throw new Error("auto-rig: solveTurnDepth: no landmark to slide");
+  }
+  const cap = familyReachPx(landmarks, plateEdgeX) / unit;
+  const achieved = (d) => landmarks.reduce(
+    (sum, l) => sum + (landmarkLandingX(l, mapAt, -d * unit, l.x, l.y ?? 0) - l.x),
+    0
+  ) / landmarks.length;
+  const atCap = achieved(cap);
+  const atRest = achieved(0);
+  const attainable = [atCap, atRest];
+  if (target > atRest + TURN_DEPTH_EPS)
+    return { reached: false, depth: 0, achieved: atRest, attainable };
+  if (target < atCap - TURN_DEPTH_EPS)
+    return { reached: false, depth: cap, achieved: atCap, attainable };
+  const clampedTarget = Math.min(Math.max(target, atCap), atRest);
+  let lo = 0;
+  let hi = cap;
+  for (let i = 0; i < TURN_BISECT_STEPS; i++) {
+    const mid = (lo + hi) / 2;
+    if (achieved(mid) > clampedTarget) lo = mid;
+    else hi = mid;
+  }
+  const depth = (lo + hi) / 2;
+  return { reached: true, depth, achieved: achieved(depth), attainable };
+}
+var TURN_SWEEP_MAX_FACTOR = 8;
+var TURN_SWEEP_SAMPLES = 32;
+var HOLD_CLEARANCE = 1;
+var TURN_HOLD_SAMPLES = 16;
+var TURN_SETTLE_PASSES = 24;
+function hairFrontHoldTarget(x, y, deg, faceCenterX, plateLandingAt, edgeAt, holdBase, holdEdge) {
+  const local = x - faceCenterX;
+  const dist = Math.abs(local);
+  const side = Math.sign(local);
+  const painted = edgeAt(y);
+  if (dist <= painted) return plateLandingAt(deg, x, y);
+  if (dist <= holdBase) {
+    const inner = plateLandingAt(deg, faceCenterX + side * painted, y);
+    const u = (dist - painted) / (holdBase - painted);
+    return inner + (faceCenterX + side * holdEdge - inner) * u;
+  }
+  return x + side * (holdEdge - holdBase);
+}
+function hairFrontLandingAt(x, y, hairFront, holdTargetAt, leadTipShift) {
+  const { cols, rows } = meshCellsFor(hairFront.cropW, hairFront.cropH);
+  const top = hairFront.centerY + hairFront.cropH / 2;
+  return renderedLandingX(
+    {
+      x: hairFront.x,
+      y: hairFront.centerY,
+      cropW: hairFront.cropW,
+      cropH: hairFront.cropH,
+      cols,
+      rows,
+      scaleX: 1,
+      scaleY: 1,
+      rotation: 0
+    },
+    (vx, vy) => holdTargetAt(vx, vy) - leadTipShift * Math.pow((top - vy) / hairFront.cropH, HAIR_SWAY_CURL),
+    x,
+    y
+  );
+}
+function shellTravelCap(faceCenterX, edgeAt, plateGuardRows, askedTravel, bendOnlyLandingAt, holdEdgeAt) {
+  let cap = Infinity;
+  for (const deg of HEAD_TURN_STOPS) {
+    if (deg === 0) continue;
+    const slideSign = turnSlide(askedTravel, deg) < 0 ? -1 : 1;
+    const towardReach = plateSideReachAt(
+      bendOnlyLandingAt,
+      faceCenterX,
+      edgeAt,
+      plateGuardRows,
+      deg,
+      slideSign
+    );
+    cap = Math.min(
+      cap,
+      Math.max(0, holdEdgeAt(deg, slideSign) - HOLD_CLEARANCE - towardReach) * HEAD_TURN_MAX_DEG / Math.abs(deg)
+    );
+  }
+  return cap;
+}
+function aitken(x0, x1, x2, cap) {
+  const d1 = x1 - x0;
+  const d2 = x2 - x1;
+  const denominator = d2 - d1;
+  if (denominator === 0) return x2;
+  const x = x2 - d2 * d2 / denominator;
+  return Number.isFinite(x) ? Math.min(cap, Math.max(0, x)) : x2;
+}
+function evaluateTurnCandidate(ctx, radius) {
+  const surfaceAt = (travel) => turnSurface({
+    faceCenterX: ctx.faceCenterX,
+    faceCenterY: ctx.faceCenterY,
+    radius,
+    travel,
+    nodRadius: ctx.nodRadius,
+    lattice: ctx.lattice,
+    profile: ctx.profile,
+    eyeRowY: ctx.eyeRowY
+  });
+  const bendOnlyLandingAt = plateLandingOn(ctx.plate, rowMapsOf(surfaceAt(0)));
+  const measuredEdgeAt = (side) => {
+    const candidates = side < 0 ? ctx.headEdges?.left : ctx.headEdges?.right;
+    if (candidates === void 0 || candidates.length === 0) return void 0;
+    const xs = candidates.map((c) => c.x);
+    return side < 0 ? Math.min(...xs) : Math.max(...xs);
+  };
+  const shellHalfWidthAt = (side) => {
+    const edge = measuredEdgeAt(side);
+    return edge === void 0 ? ctx.headHalfWidth : side * (edge - ctx.faceCenterX);
+  };
+  const unit = headTurnParallaxUnit(radius);
+  const leadTipShift = ctx.hairFrontSilhouette === void 0 ? 0 : HAIR_FRONT_DEPTH * unit;
+  const evaluateHold = (ratio, depths2) => {
+    const holdEdgeFrom = (base) => (deg) => base * (1 + (ratio - 1) * Math.abs(deg) / HEAD_TURN_MAX_DEG);
+    const travel = ctx.headHalfWidth === void 0 ? ctx.travel : Math.min(
+      ctx.travel,
+      shellTravelCap(
+        ctx.faceCenterX,
+        ctx.edgeAt,
+        ctx.plateGuardRows,
+        ctx.travel,
+        bendOnlyLandingAt,
+        (deg, side) => {
+          const rest = shellHalfWidthAt(side);
+          return Math.min(rest, holdEdgeFrom(rest)(deg));
+        }
+      )
+    );
+    const surface = surfaceAt(travel);
+    const rowMaps = rowMapsOf(surface);
+    const mapAt = (y) => rowMaps(-HEAD_TURN_MAX_DEG, y);
+    const plateLandingAt = plateLandingOn(ctx.plate, rowMaps);
+    const holdBase = ctx.headHalfWidth ?? plateReach(
+      plateLandingAt,
+      ctx.faceCenterX,
+      ctx.edgeAt,
+      ctx.plateGuardRows
+    ) + HOLD_CLEARANCE;
+    const holdEdgeAt = holdEdgeFrom(holdBase);
+    let foldLowerBound = -Infinity;
+    let folds = false;
+    for (const deg of HEAD_TURN_STOPS) {
+      if (deg === 0) continue;
+      const reach = plateReachAt(
+        plateLandingAt,
+        ctx.faceCenterX,
+        ctx.edgeAt,
+        ctx.plateGuardRows,
+        deg
+      );
+      foldLowerBound = Math.max(
+        foldLowerBound,
+        1 + ((reach + HOLD_CLEARANCE) / holdBase - 1) * (HEAD_TURN_MAX_DEG / Math.abs(deg))
+      );
+      if (holdEdgeAt(deg) <= reach) folds = true;
+    }
+    const restAt = (side) => {
+      const edge = measuredEdgeAt(side);
+      if (edge !== void 0) return edge;
+      return ctx.headHalfWidth !== void 0 || ctx.hairFrontSilhouette === void 0 ? ctx.faceCenterX + side * holdBase : ctx.hairFrontSilhouette.x + side * ctx.hairFrontSilhouette.cropW / 2;
+    };
+    const hairFrontAt = (x) => ctx.hairFrontSilhouette === void 0 ? x : hairFrontLandingAt(
+      x,
+      ctx.eyeRowY,
+      ctx.hairFrontSilhouette,
+      (vx, vy) => hairFrontHoldTarget(
+        vx,
+        vy,
+        -HEAD_TURN_MAX_DEG,
+        ctx.faceCenterX,
+        plateLandingAt,
+        ctx.edgeAt,
+        holdBase,
+        holdEdgeAt(-HEAD_TURN_MAX_DEG)
+      ),
+      leadTipShift
+    );
+    const landingOfRole = (role, x) => {
+      if (role === "hair_front") return hairFrontAt(x);
+      if (role === "hair_back") {
+        return x;
+      }
+      if (role === "body") {
+        return x - BODY_TURN_FOLLOW * travel;
+      }
+      if (role === "face" || FEATURE_NOD_DEPTH[roleFamily(role)] !== void 0) {
+        const carrier = ctx.carriers.get(role);
+        if (carrier === void 0) {
+          throw new Error(
+            `auto-rig: evaluateTurnCandidate: headEdges names "${role}", which this layer set has no layer for`
+          );
+        }
+        const shift = role === "face" ? 0 : -depths2[turnFamily(role)] * unit;
+        return carrierLandingX(
+          carrier,
+          (nodeX, nodeY) => mapAt(nodeY).mapX(nodeX + shift),
+          x,
+          ctx.eyeRowY
+        );
+      }
+      throw new Error(
+        `auto-rig: evaluateTurnCandidate: unrecognised role "${role}"`
+      );
+    };
+    const landingAt = (side) => {
+      const candidates = side < 0 ? ctx.headEdges?.left : ctx.headEdges?.right;
+      if (candidates === void 0 || candidates.length === 0) {
+        return hairFrontAt(restAt(side));
+      }
+      const landings = candidates.map((c) => landingOfRole(c.role, c.x));
+      return side < 0 ? Math.min(...landings) : Math.max(...landings);
+    };
+    return {
+      ratio,
+      travel,
+      mapAt,
+      surface,
+      holdBase,
+      holdEdgeAt,
+      folds,
+      foldLowerBound,
+      // How far the silhouette's own centre drifts off the face centre at full
+      // turn, against how far it already sat off centre at rest (zero unless
+      // hair_front's crop is itself off-centre) — the held shell keeps its own
+      // place while the face slides inside it, so this is the drift the hold
+      // and the bangs' lead leave behind, and the slide itself shows up in the
+      // eye cue instead of cancelling out of it.
+      // `measure_turn_reference` reads the eye pair against THIS moved centre,
+      // not the face centre, so it is what the eye cue is corrected by.
+      silhouetteCenterShift: (landingAt(1) + landingAt(-1)) / 2 - (restAt(1) + restAt(-1)) / 2,
+      // What a render actually shows: the real landing span over the real rest
+      // span, the same pair silhouetteCenterShift reads — the measure the
+      // hold is FITTED against, see this function's own doc.
+      renderedSilhouetteRatio: (landingAt(1) - landingAt(-1)) / (restAt(1) - restAt(-1)),
+      restSpan: restAt(1) - restAt(-1)
+    };
+  };
+  const holdRange = (depths2) => {
+    const ceiling = evaluateHold(TURN_RATIO_MAX, depths2);
+    if (ceiling.folds) return void 0;
+    let floor = evaluateHold(
+      Math.min(ceiling.foldLowerBound, ceiling.ratio),
+      depths2
+    );
+    if (floor.folds) {
+      let lo = floor;
+      let hi = ceiling;
+      for (let i = 0; i < TURN_BISECT_STEPS; i++) {
+        const mid = evaluateHold((lo.ratio + hi.ratio) / 2, depths2);
+        if (mid.folds) lo = mid;
+        else hi = mid;
+      }
+      floor = hi;
+    }
+    const samples = [floor];
+    for (let i = 1; i < TURN_HOLD_SAMPLES; i++) {
+      const sample = evaluateHold(
+        floor.ratio + (ceiling.ratio - floor.ratio) * i / TURN_HOLD_SAMPLES,
+        depths2
+      );
+      if (!sample.folds) samples.push(sample);
+    }
+    samples.push(ceiling);
+    return samples;
+  };
+  const silhouetteMiss = (span) => {
+    const lower = Math.max(span?.[0] ?? Infinity, SILHOUETTE_RATIO_MIN);
+    const upper = Math.min(span?.[1] ?? -Infinity, TURN_RATIO_MAX);
+    return lower > upper ? { blocked: "silhouetteRatio", lower: Infinity, upper: -Infinity } : { blocked: "silhouetteRatio", lower, upper };
+  };
+  const asked = ctx.silhouetteRatio;
+  const fitHold = (depths2) => {
+    const natural = evaluateHold(asked, depths2);
+    const eps = TURN_DEPTH_EPS / natural.restSpan;
+    if (!natural.folds && Math.abs(natural.renderedSilhouetteRatio - asked) <= eps) {
+      return { hold: natural, silhouetteClamped: false };
+    }
+    const samples = holdRange(depths2);
+    if (samples === void 0) return void 0;
+    const rendered = samples.map((h) => h.renderedSilhouetteRatio);
+    const span = [
+      Math.min(...rendered),
+      Math.max(...rendered)
+    ];
+    const nearer = (a, b) => {
+      const ea = Math.abs(a.renderedSilhouetteRatio - asked);
+      const eb = Math.abs(b.renderedSilhouetteRatio - asked);
+      if (ea <= eps && eb <= eps) {
+        return Math.abs(a.ratio - asked) <= Math.abs(b.ratio - asked) ? a : b;
+      }
+      return ea <= eb ? a : b;
+    };
+    if (asked < span[0] - eps || asked > span[1] + eps) {
+      const wanted = asked < span[0] ? span[0] : span[1];
+      const hold = samples.reduce(
+        (a, b) => Math.abs(b.renderedSilhouetteRatio - wanted) < Math.abs(a.renderedSilhouetteRatio - wanted) ? b : a
+      );
+      return { hold, silhouetteClamped: true, span };
+    }
+    let best = samples.reduce(nearer);
+    let lo;
+    let hi;
+    for (let i = 0; i + 1 < samples.length; i++) {
+      const a = samples[i].renderedSilhouetteRatio - asked;
+      const b = samples[i + 1].renderedSilhouetteRatio - asked;
+      if (a * b <= 0) {
+        lo = samples[i];
+        hi = samples[i + 1];
+        break;
+      }
+    }
+    for (let i = 0; lo !== void 0 && hi !== void 0; i++) {
+      if (i >= TURN_BISECT_STEPS || Math.abs(best.renderedSilhouetteRatio - asked) <= eps) {
+        break;
+      }
+      const mid = evaluateHold((lo.ratio + hi.ratio) / 2, depths2);
+      if (!mid.folds) best = nearer(best, mid);
+      if ((mid.renderedSilhouetteRatio - asked) * (lo.renderedSilhouetteRatio - asked) > 0) {
+        lo = mid;
+      } else {
+        hi = mid;
+      }
+    }
+    return { hold: best, silhouetteClamped: false };
+  };
+  let depths = { eye: 0, nose: 0, mouth: 0 };
+  let seed;
+  for (let pass = 0; ; pass++) {
+    const fitted = fitHold(depths);
+    if (fitted === void 0) return silhouetteMiss();
+    const { hold, silhouetteClamped, span } = fitted;
+    if (hold.folds) {
+      throw new Error(
+        "auto-rig: evaluateTurnCandidate: the hold it settled on folds"
+      );
+    }
+    const eye = solveTurnDepthSigned(
+      hold.silhouetteCenterShift - ctx.eyeShift * ctx.hh,
+      ctx.landmarks.eye,
+      unit,
+      hold.mapAt,
+      ctx.plateEdgeX
+    );
+    const features = solveFeatureDepths(
+      ctx,
+      (-eye.achieved + hold.silhouetteCenterShift) / ctx.hh,
+      unit,
+      hold.mapAt,
+      hold.silhouetteCenterShift
+    );
+    const solved = {
+      eye: eye.depth,
+      nose: features.nose.depth,
+      mouth: features.mouth.depth
+    };
+    const settled = evaluateHold(hold.ratio, solved);
+    if (Math.abs(settled.silhouetteCenterShift - hold.silhouetteCenterShift) > TURN_DEPTH_EPS || Math.abs(settled.renderedSilhouetteRatio - hold.renderedSilhouetteRatio) * hold.restSpan > TURN_DEPTH_EPS) {
+      if (pass + 1 >= TURN_SETTLE_PASSES) return { blocked: "settle" };
+      if (seed === void 0) {
+        seed = depths;
+        depths = solved;
+      } else {
+        const capOf = (marks) => familyReachPx(marks, ctx.plateEdgeX) / unit;
+        depths = {
+          eye: aitken(
+            seed.eye,
+            depths.eye,
+            solved.eye,
+            capOf(ctx.landmarks.eye)
+          ),
+          nose: aitken(
+            seed.nose,
+            depths.nose,
+            solved.nose,
+            capOf(ctx.landmarks.nose)
+          ),
+          mouth: aitken(
+            seed.mouth,
+            depths.mouth,
+            solved.mouth,
+            capOf(ctx.landmarks.mouth)
+          )
+        };
+        seed = void 0;
+      }
+      continue;
+    }
+    const {
+      travel,
+      mapAt,
+      surface,
+      holdBase,
+      holdEdgeAt,
+      silhouetteCenterShift,
+      renderedSilhouetteRatio
+    } = settled;
+    if (silhouetteClamped && !ctx.clampSilhouetteRatio) {
+      return silhouetteMiss(span);
+    }
+    if (!eye.reached && !ctx.clampEyeShift) {
+      return {
+        blocked: "eyeShift",
+        // eyeShift is a MAGNITUDE (the sign is ignored — see TurnTargets), so
+        // a negative lower bound here would advertise a value the field's own
+        // contract already rules out; 0 is the true floor.
+        offeredShift: [
+          Math.max(0, (-eye.attainable[1] + silhouetteCenterShift) / ctx.hh),
+          (-eye.attainable[0] + silhouetteCenterShift) / ctx.hh
+        ]
+      };
+    }
+    const eyeShiftPx = -eye.depth * unit;
+    const scaleOf = (l) => (landmarkLandingX(l, mapAt, eyeShiftPx, l.x + l.w / 2, l.y ?? 0) - landmarkLandingX(l, mapAt, eyeShiftPx, l.x - l.w / 2, l.y ?? 0)) / l.w;
+    const far = ctx.landmarks.eye.reduce((a, b) => b.x < a.x ? b : a);
+    const near = ctx.landmarks.eye.reduce((a, b) => b.x > a.x ? b : a);
+    return {
+      radius,
+      ratio: scaleOf(far) / scaleOf(near),
+      unit,
+      travel,
+      mapAt,
+      surface,
+      holdBase,
+      holdEdgeAt,
+      eye,
+      nose: features.nose,
+      mouth: features.mouth,
+      silhouetteClamped,
+      silhouetteCenterShift,
+      renderedSilhouetteRatio
+    };
+  }
+}
+function sweepTurnRadii(ctx) {
+  const minRadius = ctx.faceHalfWidth * HEAD_CYLINDER_RADIUS_FACTOR;
+  const maxRadius = ctx.faceHalfWidth * TURN_SWEEP_MAX_FACTOR;
+  const candidates = [];
+  let heldRatioLower = Infinity;
+  let heldRatioUpper = -Infinity;
+  let offeredShift;
+  let unsettled = 0;
+  for (let i = 0; i < TURN_SWEEP_SAMPLES; i++) {
+    const radius = minRadius * Math.pow(maxRadius / minRadius, i / (TURN_SWEEP_SAMPLES - 1));
+    const result = evaluateTurnCandidate(ctx, radius);
+    if (!("blocked" in result)) {
+      candidates.push({ ...result, sweepIndex: i });
+    } else if (result.blocked === "silhouetteRatio") {
+      heldRatioLower = Math.min(heldRatioLower, result.lower);
+      heldRatioUpper = Math.max(heldRatioUpper, result.upper);
+    } else if (result.blocked === "settle") {
+      unsettled++;
+    } else {
+      offeredShift = offeredShift ? [
+        Math.min(offeredShift[0], result.offeredShift[0]),
+        Math.max(offeredShift[1], result.offeredShift[1])
+      ] : result.offeredShift;
+    }
+  }
+  return {
+    candidates,
+    heldRatioLower,
+    heldRatioUpper,
+    offeredShift,
+    unsettled
+  };
+}
+function ratioClusters(candidates) {
+  const clusters = [];
+  let run = [];
+  const close = () => {
+    if (run.length === 0) return;
+    const ratios = run.map((c) => c.ratio);
+    clusters.push({
+      candidates: run,
+      ratios: [Math.min(...ratios), Math.max(...ratios)]
+    });
+    run = [];
+  };
+  for (const candidate of candidates) {
+    const previous = run[run.length - 1];
+    if (previous !== void 0 && candidate.sweepIndex !== previous.sweepIndex + 1) {
+      close();
+    }
+    run.push(candidate);
+  }
+  close();
+  return clusters;
+}
+function fitTurnRadius(ctx, candidates, target) {
+  let lo = candidates[0];
+  let hi = candidates[candidates.length - 1];
+  for (let i = candidates.length - 2; i >= 0; i--) {
+    if ((candidates[i].ratio - target) * (candidates[i + 1].ratio - target) <= 0) {
+      lo = candidates[i];
+      hi = candidates[i + 1];
+      break;
+    }
+  }
+  for (let i = 0; i < TURN_BISECT_STEPS; i++) {
+    const mid = evaluateTurnCandidate(ctx, Math.sqrt(lo.radius * hi.radius));
+    if ("blocked" in mid) break;
+    if ((mid.ratio - target) * (lo.ratio - target) <= 0) hi = mid;
+    else lo = mid;
+  }
+  return Math.abs(lo.ratio - target) <= Math.abs(hi.ratio - target) ? lo : hi;
+}
+function solveFeatureDepths(ctx, eyeShift, unit, mapAt, silhouetteCenterShift) {
+  const solve = (measured, marks, share) => solveTurnDepthSigned(
+    silhouetteCenterShift - (measured ?? Math.abs(share * eyeShift)) * ctx.hh,
+    marks,
+    unit,
+    mapAt,
+    ctx.plateEdgeX
+  );
+  return {
+    nose: solve(ctx.noseShift, ctx.landmarks.nose, NOSE_SHIFT_SHARE),
+    mouth: solve(ctx.mouthShift, ctx.landmarks.mouth, MOUTH_SHIFT_SHARE)
+  };
+}
+function solveTurnModel(targets, landmarks, lattice, faceCenterX, faceHalfWidth, faceCenterY, nodRadius, carriers, profile, hairFront, headEdges) {
+  if (targets.headHalfWidth !== void 0 && targets.headHalfWidth <= faceHalfWidth) {
+    throw new TurnTargetError(
+      `auto-rig: turnTargets.headHalfWidth (${targets.headHalfWidth}) must be wider than the face plate's own half-width (${faceHalfWidth})`
+    );
+  }
+  const eyeRowY = eyeRowOf(landmarks, faceCenterY);
+  const ctx = {
+    landmarks,
+    lattice,
+    faceCenterX,
+    faceCenterY,
+    nodRadius,
+    eyeRowY,
+    faceHalfWidth,
+    // The slide's hard stop is the CROP's edge, profile or not: the far eye
+    // may sit on the plate's transparent margin, as it does on the hero.
+    plateEdgeX: faceCenterX - faceHalfWidth,
+    carriers,
+    profile,
+    ...plateGuardsOf(carriers, faceHalfWidth, profile, hairFront),
+    // What this plate asks the turn for; each candidate caps it to its own
+    // shell — see TurnSolveContext.travel.
+    travel: headTurnTravel(faceHalfWidth),
+    headHalfWidth: targets.headHalfWidth,
+    // The pixels the shift fractions are fractions of. Without a measured head
+    // the face plate stands in for it — see TurnTargets.headHalfWidth.
+    hh: targets.headHalfWidth ?? faceHalfWidth,
+    silhouetteRatio: targets.silhouetteRatio,
+    // The sign is ignored (see TurnTargets.eyeShift) — taken here, once, so
+    // every downstream use already has the magnitude.
+    eyeShift: Math.abs(targets.eyeShift),
+    clampEyeShift: targets.defaulted.has("eyeShift"),
+    noseShift: targets.defaulted.has("noseShift") ? void 0 : Math.abs(targets.noseShift),
+    mouthShift: targets.defaulted.has("mouthShift") ? void 0 : Math.abs(targets.mouthShift),
+    clampSilhouetteRatio: targets.defaulted.has("silhouetteRatio"),
+    hairFrontSilhouette: hairFront,
+    // A companion to a MEASURED headHalfWidth only — see its own doc.
+    headEdges: targets.headHalfWidth === void 0 ? void 0 : headEdges
+  };
+  const clamped = [];
+  const clampInto = (value, [lo, hi]) => Math.min(Math.max(value, lo), hi);
+  const pass = sweepTurnRadii(ctx);
+  if (pass.candidates.length === 0) {
+    if (pass.unsettled > 0) {
+      const refused = TURN_SWEEP_SAMPLES - pass.unsettled;
+      throw new TurnTargetError(
+        `auto-rig: headEdges: no sampled radius carries the turn \u2014 the silhouette and the depths its headEdges owners ride on did not settle within ${TURN_SETTLE_PASSES} passes at ${pass.unsettled} of the ${TURN_SWEEP_SAMPLES} radii${refused > 0 ? `, and the targets refused the other ${refused}` : ""}`
+      );
+    }
+    return pass.offeredShift ? {
+      unreachable: true,
+      field: "eyeShift",
+      value: targets.eyeShift,
+      attainable: pass.offeredShift
+    } : {
+      unreachable: true,
+      field: "silhouetteRatio",
+      value: targets.silhouetteRatio,
+      // Two different bounds, not one number twice, and computed the
+      // same way regardless of which ratio was actually rejected: both
+      // are ratios a RENDER could have shown (the measure the caller's
+      // own number came from), the narrowest and the widest any radius
+      // could be fitted to, with every ratio between them one it can be
+      // fitted to exactly; see evaluateTurnCandidate, which clips each
+      // radius' own range to the domain `resolveTurnTargets` accepts
+      // before it gets here. Absent when that left every radius with
+      // nothing: no ratio a caller is allowed to ask for renders at all.
+      attainable: pass.heldRatioLower === Infinity || pass.heldRatioUpper === -Infinity ? void 0 : [pass.heldRatioLower, pass.heldRatioUpper]
+    };
+  }
+  const clusters = ratioClusters(pass.candidates);
+  const distanceTo = (c) => Math.max(
+    c.ratios[0] - targets.farEyeRatio,
+    targets.farEyeRatio - c.ratios[1],
+    0
+  );
+  let farEyeRatio = targets.farEyeRatio;
+  let cluster = clusters.find(
+    (c) => farEyeRatio >= c.ratios[0] - TURN_DEPTH_EPS && farEyeRatio <= c.ratios[1] + TURN_DEPTH_EPS
+  );
+  if (cluster === void 0) {
+    cluster = clusters.reduce(
+      (a, b) => distanceTo(b) < distanceTo(a) ? b : a
+    );
+    if (!targets.defaulted.has("farEyeRatio")) {
+      return {
+        unreachable: true,
+        field: "farEyeRatio",
+        value: targets.farEyeRatio,
+        attainable: cluster.ratios
+      };
+    }
+    farEyeRatio = clampInto(farEyeRatio, cluster.ratios);
+    clamped.push("farEyeRatio");
+  }
+  const best = fitTurnRadius(ctx, cluster.candidates, farEyeRatio);
+  if (Math.abs(best.ratio - farEyeRatio) > TURN_DEPTH_EPS) {
+    if (!targets.defaulted.has("farEyeRatio")) {
+      return {
+        unreachable: true,
+        field: "farEyeRatio",
+        value: targets.farEyeRatio,
+        attainable: cluster.ratios
+      };
+    }
+    if (!clamped.includes("farEyeRatio")) clamped.push("farEyeRatio");
+  }
+  if (!best.eye.reached) clamped.push("eyeShift");
+  if (best.silhouetteClamped) clamped.push("silhouetteRatio");
+  const eyeShift = (-best.eye.achieved + best.silhouetteCenterShift) / ctx.hh;
+  for (const [field, solution] of [
+    ["noseShift", best.nose],
+    ["mouthShift", best.mouth]
+  ]) {
+    if (solution.reached) continue;
+    if (!targets.defaulted.has(field)) {
+      return {
+        unreachable: true,
+        field,
+        value: targets[field],
+        // noseShift/mouthShift are MAGNITUDES too (see solveFeatureDepths),
+        // so a negative lower bound here would advertise a value the field's
+        // own contract already rules out; 0 is the true floor.
+        attainable: [
+          Math.max(
+            0,
+            (-solution.attainable[1] + best.silhouetteCenterShift) / ctx.hh
+          ),
+          (-solution.attainable[0] + best.silhouetteCenterShift) / ctx.hh
+        ]
+      };
+    }
+    clamped.push(field);
+  }
+  return {
+    unreachable: false,
+    radius: best.radius,
+    holdBase: best.holdBase,
+    holdEdgeAt: best.holdEdgeAt,
+    travel: best.travel,
+    surface: best.surface,
+    depths: {
+      eye: best.eye.depth,
+      nose: best.nose.depth,
+      mouth: best.mouth.depth
+    },
+    achieved: {
+      eyeShift,
+      farEyeRatio: best.ratio,
+      silhouetteRatio: best.renderedSilhouetteRatio
+    },
+    clamped
+  };
+}
 var EYE_STACK_PREFIXES = ["eye_", "iris_", "pupil_", "highlight_"];
 var HAIR_FRONT_DEPTH = 0.1;
-var HAIR_BACK_DEPTH = -0.08;
 var NOD_TRAVEL = 30;
 var NOD_BEND = 0.5;
 var HAIR_BACK_NOD_DEPTH = -0.135;
 function headNodParallaxUnit(gridHalfHeight) {
   return gridHalfHeight * HEAD_CYLINDER_RADIUS_FACTOR * Math.sin(HEAD_TURN_MAX_DEG * NOD_BEND * (Math.PI / 180));
 }
-var FEATURE_DEPTH = {
+var FEATURE_NOD_DEPTH = {
   eye: 0.04,
   iris: 0.04,
   pupil: 0.04,
@@ -1857,34 +2933,30 @@ var FEATURE_DEPTH = {
   mouth_open: 0.04,
   nose: 0.08
 };
-var HAIR_FRONT_NOD_DEPTH = FEATURE_DEPTH.brow;
+var HAIR_FRONT_NOD_DEPTH = FEATURE_NOD_DEPTH.brow;
 function roleFamily(role) {
   return role.replace(/_[LR]$/, "");
 }
+function turnFamily(role) {
+  const family = roleFamily(role);
+  if (family === "nose") return "nose";
+  if (family === "mouth" || family === "mouth_open") return "mouth";
+  return "eye";
+}
 function featureParallaxBindings(role, options) {
   if (!options.hasNose) return [];
-  const depth = FEATURE_DEPTH[roleFamily(role)];
-  if (depth === void 0) return [];
-  const bindings = [];
-  const shiftX = depth * (options.parallaxUnit ?? 0);
-  if (shiftX !== 0) {
-    bindings.push({
-      parameter: StandardParameter.AngleX,
-      channel: "translateX",
-      from: -shiftX,
-      to: shiftX
-    });
-  }
-  const shiftY = depth * (options.parallaxUnitY ?? 0);
-  if (shiftY !== 0) {
-    bindings.push({
+  const nodDepth = FEATURE_NOD_DEPTH[roleFamily(role)];
+  if (nodDepth === void 0) return [];
+  const shiftY = nodDepth * (options.parallaxUnitY ?? 0);
+  if (shiftY === 0) return [];
+  return [
+    {
       parameter: StandardParameter.AngleY,
       channel: "translateY",
       from: -shiftY,
       to: shiftY
-    });
-  }
-  return bindings;
+    }
+  ];
 }
 function bindingsForRole(spec, role, cropW, cropH, options = {}) {
   return [
@@ -1992,31 +3064,17 @@ function roleOwnBindings(spec, role, cropW, cropH, options) {
       ];
     }
   }
-  if (role === "hair_front" || role === "hair_back") {
-    const isFront = role === "hair_front";
-    const parallax = [];
-    if (!isFront) {
-      const shiftX = HAIR_BACK_DEPTH * (options.parallaxUnit ?? 0);
-      if (shiftX !== 0) {
-        parallax.push({
-          parameter: StandardParameter.AngleX,
-          channel: "translateX",
-          from: -shiftX,
-          to: shiftX
-        });
-      }
-    }
-    const frontDepth = options.hasNose ? HAIR_FRONT_NOD_DEPTH : 0;
-    const shiftY = (isFront ? frontDepth : HAIR_BACK_NOD_DEPTH) * (options.parallaxUnitY ?? 0);
-    if (shiftY !== 0) {
-      parallax.push({
+  if (role === "hair_back") {
+    const shiftY = HAIR_BACK_NOD_DEPTH * (options.parallaxUnitY ?? 0);
+    if (shiftY === 0) return [];
+    return [
+      {
         parameter: StandardParameter.AngleY,
         channel: "translateY",
         from: -shiftY,
         to: shiftY
-      });
-    }
-    return parallax;
+      }
+    ];
   }
   return [];
 }
@@ -2039,40 +3097,106 @@ function bakeEyelidFoldWarp(mesh, parameter, creaseOffsetY, k) {
     ]
   };
 }
-var HAIR_BACK_BEND_RADIUS_FACTOR = 2.5;
-var HAIR_BACK_FAR_BULGE = 0.22;
-function bakeHairBackTurnWarp(mesh, parameter) {
-  let left = Infinity;
-  let right = -Infinity;
-  for (let i = 0; i < mesh.vertices.length; i += 2) {
-    left = Math.min(left, mesh.vertices[i]);
-    right = Math.max(right, mesh.vertices[i]);
+function bakeNodWarp(mesh, partY, surface, nodTravel) {
+  const keyforms = HEAD_TURN_STOPS.map((deg) => {
+    const t = nodTravel * deg / HEAD_TURN_MAX_DEG;
+    const offsets = [];
+    for (let i = 0; i < mesh.vertices.length; i += 2) {
+      const y = partY + mesh.vertices[i + 1];
+      offsets.push(0, deg === 0 ? 0 : t + surface.nodBendAt(y + t, deg));
+    }
+    return { value: deg, offsets };
+  });
+  return { parameter: StandardParameter.AngleY, keyforms };
+}
+function plateReach(plateLandingAt, faceCenterX, edgeAt, plateGuardRows) {
+  let reach = 0;
+  for (const deg of HEAD_TURN_STOPS) {
+    reach = Math.max(
+      reach,
+      plateReachAt(plateLandingAt, faceCenterX, edgeAt, plateGuardRows, deg)
+    );
+  }
+  return reach;
+}
+function plateSideReachAt(plateLandingAt, faceCenterX, edgeAt, plateGuardRows, deg, side) {
+  let reach = 0;
+  for (const y of plateGuardRows) {
+    const dest = plateLandingAt(deg, faceCenterX + side * edgeAt(y), y);
+    reach = Math.max(reach, Math.abs(dest - faceCenterX));
+  }
+  return reach;
+}
+function plateReachAt(plateLandingAt, faceCenterX, edgeAt, plateGuardRows, deg) {
+  return Math.max(
+    plateSideReachAt(
+      plateLandingAt,
+      faceCenterX,
+      edgeAt,
+      plateGuardRows,
+      deg,
+      -1
+    ),
+    plateSideReachAt(
+      plateLandingAt,
+      faceCenterX,
+      edgeAt,
+      plateGuardRows,
+      deg,
+      1
+    )
+  );
+}
+function bakeHairFrontSilhouetteWarp(mesh, partX, partY, faceCenterX, plateLandingAt, edgeAt, holdBase, holdEdgeAt, plateGuardRows) {
+  if (holdEdgeAt(0) !== holdBase) {
+    throw new Error(
+      `auto-rig: bakeHairFrontSilhouetteWarp: holdEdgeAt(0) is ${holdEdgeAt(0)}, not the hold edge's own rest distance ${holdBase}, so the bangs would move in the rest pose`
+    );
   }
-  const halfWidth = (right - left) / 2;
-  const radius = halfWidth * HAIR_BACK_BEND_RADIUS_FACTOR;
-  const bulge = HAIR_BACK_FAR_BULGE * halfWidth;
-  const DEG_TO_RAD = Math.PI / 180;
   const keyforms = HEAD_TURN_STOPS.map((deg) => {
-    const theta = deg * DEG_TO_RAD;
-    const s = Math.sign(deg);
-    const turnFraction = Math.abs(deg) / HEAD_TURN_MAX_DEG;
-    const fullTheta = s * HEAD_TURN_MAX_DEG * DEG_TO_RAD;
-    const bulgeAtStop = bulge * deg / HEAD_TURN_MAX_DEG;
+    const holdEdge = holdEdgeAt(deg);
+    const reach = [-1, 1].map(
+      (side) => plateSideReachAt(
+        plateLandingAt,
+        faceCenterX,
+        edgeAt,
+        plateGuardRows,
+        deg,
+        side
+      )
+    );
+    const reached = Math.max(reach[0], reach[1]);
+    if (holdEdge <= reached) {
+      const side = reach[1] > reach[0] ? 1 : -1;
+      throw new Error(
+        `auto-rig: bakeHairFrontSilhouetteWarp: at ${deg}\xB0 on the ${side < 0 ? "-x" : "+x"} side the hold edge sits ${holdEdge} from the face centre but the plate's edge maps to ${reached}, so the ramp between them would fold`
+      );
+    }
     const offsets = [];
     for (let i = 0; i < mesh.vertices.length; i += 2) {
-      const x = mesh.vertices[i];
-      const far = Math.max(0, -s * x / halfWidth);
-      const bend = far > 0 ? turnFraction * pinnedCylinderBend(x, radius, fullTheta) : pinnedCylinderBend(x, radius, theta);
-      offsets.push(bend - bulgeAtStop * far, 0);
+      const x = partX + mesh.vertices[i];
+      const y = partY + mesh.vertices[i + 1];
+      offsets.push(
+        deg === 0 ? 0 : hairFrontHoldTarget(
+          x,
+          y,
+          deg,
+          faceCenterX,
+          plateLandingAt,
+          edgeAt,
+          holdBase,
+          holdEdge
+        ) - x,
+        0
+      );
     }
     return { value: deg, offsets };
   });
-  return { parameter, keyforms };
+  return { parameter: StandardParameter.AngleX, keyforms };
 }
 var HAIR_SWAY_TIP_FRACTION = 0.09;
 var HAIR_SWAY_CURL = 1.5;
 var HAIR_SWAY_RANGE = 20;
-var HAIR_SWAY_PEAK_FRACTION = 0.56;
 function bakeHairSwayWarp(mesh, parameter, tipShift, range) {
   let top = -Infinity;
   let bottom = Infinity;
@@ -2095,116 +3219,385 @@ function bakeHairSwayWarp(mesh, parameter, tipShift, range) {
     ]
   };
 }
-var HEAD_TURN_TRAVEL = 50;
+var HEAD_TURN_TRAVEL_RATIO = 0.25;
+function headTurnTravel(faceHalfWidth) {
+  return HEAD_TURN_TRAVEL_RATIO * faceHalfWidth;
+}
 var BODY_TURN_FOLLOW = 0.3;
 var HEAD_BREATH_BOB = -12;
 var BODY_BREATH_FOLLOW = 0.5;
-function generateIkiFromLayerSet(layers, canvas) {
+var STANDARD_PARAMETERS = [
+  {
+    id: StandardParameter.MouthOpen,
+    name: "Mouth Open",
+    min: 0,
+    max: 1,
+    default: 0
+  },
+  {
+    id: StandardParameter.MouthForm,
+    name: "Mouth Form",
+    min: -1,
+    max: 1,
+    default: 0
+  },
+  {
+    id: StandardParameter.EyeOpenLeft,
+    name: "Eye L",
+    min: 0,
+    max: 1,
+    default: 1
+  },
+  {
+    id: StandardParameter.EyeOpenRight,
+    name: "Eye R",
+    min: 0,
+    max: 1,
+    default: 1
+  },
+  {
+    id: StandardParameter.EyeballX,
+    name: "Gaze X",
+    min: -1,
+    max: 1,
+    default: 0
+  },
+  {
+    id: StandardParameter.EyeballY,
+    name: "Gaze Y",
+    min: -1,
+    max: 1,
+    default: 0
+  },
+  {
+    id: StandardParameter.AngleX,
+    name: "Head Angle",
+    min: -30,
+    max: 30,
+    default: 0
+  },
+  {
+    id: StandardParameter.AngleY,
+    name: "Head Angle Y",
+    min: -30,
+    max: 30,
+    default: 0
+  },
+  {
+    id: StandardParameter.AngleZ,
+    name: "Head Angle Z",
+    min: -30,
+    max: 30,
+    default: 0
+  },
+  {
+    id: StandardParameter.Breath,
+    name: "Breath",
+    min: 0,
+    max: 1,
+    default: 0
+  },
+  {
+    id: StandardParameter.BrowLeftY,
+    name: "Brow L Y",
+    min: -1,
+    max: 1,
+    default: 0
+  },
+  {
+    id: StandardParameter.BrowRightY,
+    name: "Brow R Y",
+    min: -1,
+    max: 1,
+    default: 0
+  },
+  {
+    id: StandardParameter.BrowLeftAngle,
+    name: "Brow L Angle",
+    min: -1,
+    max: 1,
+    default: 0
+  },
+  {
+    id: StandardParameter.BrowRightAngle,
+    name: "Brow R Angle",
+    min: -1,
+    max: 1,
+    default: 0
+  }
+];
+function transformUnder(bindings, valueOf) {
+  const trs = { x: 0, y: 0, rotation: 0, scaleX: 1, scaleY: 1 };
+  bindings.forEach((binding, i) => {
+    const value = valueOf(binding, i);
+    switch (binding.channel) {
+      case "translateX":
+        trs.x += value;
+        break;
+      case "translateY":
+        trs.y += value;
+        break;
+      case "rotate":
+        trs.rotation += value;
+        break;
+      case "scaleX":
+        trs.scaleX += value;
+        break;
+      case "scaleY":
+        trs.scaleY += value;
+        break;
+      case "opacity":
+        break;
+    }
+  });
+  return trs;
+}
+function defaultPoseOf(bindings) {
+  return transformUnder(bindings, (binding) => {
+    const p = STANDARD_PARAMETERS.find((p2) => p2.id === binding.parameter);
+    if (p === void 0) {
+      throw new Error(
+        `auto-rig: defaultPoseOf: "${binding.parameter}" is not a standard parameter`
+      );
+    }
+    const t = (p.default - p.min) / (p.max - p.min);
+    return binding.from + (binding.to - binding.from) * t;
+  });
+}
+function groupGridFor(members, cells, turnShiftPx, nodShiftPx) {
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (const member of members) {
+    const rest = member.mesh.vertices;
+    const shapes = [rest];
+    for (const warp of member.warps) {
+      for (const keyform of warp.keyforms) {
+        shapes.push(rest.map((v, i) => v + keyform.offsets[i]));
+      }
+    }
+    const geometric = member.bindings.filter((b) => b.channel !== "opacity");
+    for (let corner = 0; corner < 1 << geometric.length; corner++) {
+      const trs = transformUnder(
+        geometric,
+        (b, i) => (corner & 1 << i) === 0 ? b.from : b.to
+      );
+      const cos = Math.cos(trs.rotation * (Math.PI / 180));
+      const sin = Math.sin(trs.rotation * (Math.PI / 180));
+      for (const shape of shapes) {
+        for (let i = 0; i < shape.length; i += 2) {
+          const sx = shape[i] * trs.scaleX;
+          const sy = shape[i + 1] * trs.scaleY;
+          const x = member.transform.x + trs.x + cos * sx - sin * sy;
+          const y = member.transform.y + trs.y + sin * sx + cos * sy;
+          minX = Math.min(minX, x);
+          maxX = Math.max(maxX, x);
+          minY = Math.min(minY, y);
+          maxY = Math.max(maxY, y);
+        }
+      }
+    }
+  }
+  minX -= turnShiftPx;
+  maxX += turnShiftPx;
+  minY -= nodShiftPx;
+  maxY += nodShiftPx;
+  const marginX = (maxX - minX) * GRID_MARGIN + 1;
+  const marginY = (maxY - minY) * GRID_MARGIN + 1;
+  return {
+    cols: cells,
+    rows: cells,
+    points: generateGridPoints(
+      cells,
+      cells,
+      minX - marginX,
+      maxX + marginX,
+      minY - marginY,
+      maxY + marginY
+    )
+  };
+}
+function eyelidFoldFor(layers, layer, mesh, t) {
+  const side = ROLE_TABLE[layer.role].eyeSide;
+  const isLash = layer.role.startsWith("lash_");
+  if (side === void 0 || !(layer.role.startsWith("eye_") || isLash)) {
+    return void 0;
+  }
+  const white = layers.find((l) => l.role === `eye_${side}`);
+  const creaseWorldY = bboxToTransform(white.bbox, white.canvasW, white.canvasH, white.role).y - EYELID_FOLD_CREASE * white.cropH;
+  const hasLash = layers.some((l) => l.role === `lash_${side}`);
+  return bakeEyelidFoldWarp(
+    mesh,
+    side === "L" ? StandardParameter.EyeOpenLeft : StandardParameter.EyeOpenRight,
+    creaseWorldY - t.y,
+    isLash ? LASH_FOLD_K : hasLash ? 0 : EYELID_FOLD_K
+  );
+}
+function turnSetup(layers) {
+  const faceLayer = layers.find((l) => l.role === "face");
+  const faceTransform = bboxToTransform(
+    faceLayer.bbox,
+    faceLayer.canvasW,
+    faceLayer.canvasH,
+    "face"
+  );
+  const faceCenterX = faceTransform.x;
+  const faceCenterY = faceTransform.y;
+  const faceHalfWidth = faceLayer.cropW / 2;
+  const plateEdgeX = faceCenterX - faceHalfWidth;
+  const hasNose = layers.some((l) => l.role === "nose");
+  const hasMouthOpen = layers.some((l) => l.role === "mouth_open");
+  const turnLayers = layers.filter(
+    (l) => isTurnGroup(ROLE_TABLE[l.role].deformer) || l.role === "hair_front"
+  );
+  const turnYs = turnLayers.map((l) => ({
+    y: bboxToTransform(l.bbox, l.canvasW, l.canvasH, l.role).y,
+    h: l.cropH
+  }));
+  let unionMinY = Math.min(...turnYs.map(({ y, h }) => y - h / 2));
+  let unionMaxY = Math.max(...turnYs.map(({ y, h }) => y + h / 2));
+  const spanY = unionMaxY - unionMinY;
+  unionMinY -= spanY * GRID_MARGIN;
+  unionMaxY += spanY * GRID_MARGIN;
+  const halfH = Math.max(faceCenterY - unionMinY, unionMaxY - faceCenterY);
+  const nodRadius = halfH * HEAD_CYLINDER_RADIUS_FACTOR;
+  const parallaxUnitY = headNodParallaxUnit(halfH);
+  const members = [];
+  for (const layer of layers) {
+    const spec = ROLE_TABLE[layer.role];
+    if (!isTurnGroup(spec.deformer)) continue;
+    const { role, cropW, cropH } = layer;
+    const t = bboxToTransform(layer.bbox, layer.canvasW, layer.canvasH, role);
+    const { cols, rows } = meshCellsFor(cropW, cropH);
+    const mesh = createPixelGridMesh(cols, rows, cropW, cropH);
+    const bindings = bindingsForRole(spec, role, cropW, cropH, {
+      hasMouthOpen
+    });
+    const fold = eyelidFoldFor(layers, layer, mesh, t);
+    const pose = defaultPoseOf(bindings);
+    members.push({
+      role,
+      group: spec.deformer,
+      transform: t,
+      part: {
+        x: t.x + pose.x,
+        y: t.y + pose.y,
+        cropW,
+        cropH,
+        cols,
+        rows,
+        scaleX: pose.scaleX,
+        scaleY: pose.scaleY,
+        rotation: pose.rotation
+      },
+      mesh,
+      bindings,
+      warps: fold === void 0 ? [] : [fold]
+    });
+  }
+  const landmarks = turnLandmarks(layers);
+  const turnShiftOf = (marks) => hasNose && marks.length > 0 ? familyReachPx(marks, plateEdgeX) : 0;
+  const turnShift = {
+    eye: turnShiftOf(landmarks.eye),
+    nose: turnShiftOf(landmarks.nose),
+    mouth: turnShiftOf(landmarks.mouth)
+  };
+  const groupGrids = /* @__PURE__ */ new Map();
+  for (const { group, role } of members) {
+    if (groupGrids.has(group)) continue;
+    const own = members.filter((m) => m.group === group);
+    const isPlate = group === "faceWarp";
+    const nodShiftPx = hasNose ? Math.max(
+      ...own.map((m) => FEATURE_NOD_DEPTH[roleFamily(m.role)] ?? 0)
+    ) * parallaxUnitY : 0;
+    groupGrids.set(
+      group,
+      groupGridFor(
+        own,
+        isPlate ? FACE_PLATE_CELLS : FEATURE_GRID_CELLS,
+        isPlate ? 0 : turnShift[turnFamily(role)],
+        nodShiftPx
+      )
+    );
+  }
+  const carriers = new Map(
+    members.map((m) => [
+      m.role,
+      { grid: groupGrids.get(m.group), part: m.part }
+    ])
+  );
+  const maxShift = Math.max(turnShift.eye, turnShift.nose, turnShift.mouth);
+  let reach = 0;
+  for (const grid of groupGrids.values()) {
+    reach = Math.max(
+      reach,
+      faceCenterX - grid.points[0] + maxShift,
+      grid.points[grid.cols * 2] - faceCenterX + maxShift
+    );
+  }
+  const halfCells = Math.floor(reach / TURN_LATTICE_CELL_PX) + 1;
+  const points = [];
+  for (const y of [unionMaxY, unionMinY]) {
+    for (let k = -halfCells; k <= halfCells; k++) {
+      points.push(faceCenterX + k * TURN_LATTICE_CELL_PX, y);
+    }
+  }
+  const lattice = { cols: 2 * halfCells, rows: 1, points };
+  const hairFrontLayer = layers.find((l) => l.role === "hair_front");
+  const hairFront = hairFrontLayer && (() => {
+    const t = bboxToTransform(
+      hairFrontLayer.bbox,
+      hairFrontLayer.canvasW,
+      hairFrontLayer.canvasH,
+      "hair_front"
+    );
+    return {
+      x: t.x,
+      centerY: t.y,
+      cropW: hairFrontLayer.cropW,
+      cropH: hairFrontLayer.cropH
+    };
+  })();
+  const eyeRowY = eyeRowOf(landmarks, faceCenterY);
+  const profile = faceRowProfile(faceLayer, faceCenterY);
+  return {
+    landmarks: turnLandmarks(layers, carriers),
+    lattice,
+    faceCenterX,
+    faceHalfWidth,
+    faceCenterY,
+    nodRadius,
+    carriers,
+    profile,
+    hairFront,
+    eyeRowY,
+    ...plateGuardsOf(carriers, faceHalfWidth, profile, hairFront),
+    members,
+    groupGrids,
+    parallaxUnitY,
+    hasNose,
+    hasMouthOpen
+  };
+}
+function solveInputsOf(s) {
+  return [
+    s.landmarks,
+    s.lattice,
+    s.faceCenterX,
+    s.faceHalfWidth,
+    s.faceCenterY,
+    s.nodRadius,
+    s.carriers,
+    s.profile,
+    s.hairFront
+  ];
+}
+function generateIkiFromLayerSet(layers, canvas, options = {}) {
   validateLayerInputs(layers, canvas);
   const hasHair = layers.some((l) => l.role === "hair_front");
-  const hasMouthOpen = layers.some((l) => l.role === "mouth_open");
-  const hasNose = layers.some((l) => l.role === "nose");
   const bodyLayer = layers.find((l) => l.role === "body");
-  const parameters = [
-    {
-      id: StandardParameter.MouthOpen,
-      name: "Mouth Open",
-      min: 0,
-      max: 1,
-      default: 0
-    },
-    {
-      id: StandardParameter.MouthForm,
-      name: "Mouth Form",
-      min: -1,
-      max: 1,
-      default: 0
-    },
-    {
-      id: StandardParameter.EyeOpenLeft,
-      name: "Eye L",
-      min: 0,
-      max: 1,
-      default: 1
-    },
-    {
-      id: StandardParameter.EyeOpenRight,
-      name: "Eye R",
-      min: 0,
-      max: 1,
-      default: 1
-    },
-    {
-      id: StandardParameter.EyeballX,
-      name: "Gaze X",
-      min: -1,
-      max: 1,
-      default: 0
-    },
-    {
-      id: StandardParameter.EyeballY,
-      name: "Gaze Y",
-      min: -1,
-      max: 1,
-      default: 0
-    },
-    {
-      id: StandardParameter.AngleX,
-      name: "Head Angle",
-      min: -30,
-      max: 30,
-      default: 0
-    },
-    {
-      id: StandardParameter.AngleY,
-      name: "Head Angle Y",
-      min: -30,
-      max: 30,
-      default: 0
-    },
-    {
-      id: StandardParameter.AngleZ,
-      name: "Head Angle Z",
-      min: -30,
-      max: 30,
-      default: 0
-    },
-    {
-      id: StandardParameter.Breath,
-      name: "Breath",
-      min: 0,
-      max: 1,
-      default: 0
-    },
-    {
-      id: StandardParameter.BrowLeftY,
-      name: "Brow L Y",
-      min: -1,
-      max: 1,
-      default: 0
-    },
-    {
-      id: StandardParameter.BrowRightY,
-      name: "Brow R Y",
-      min: -1,
-      max: 1,
-      default: 0
-    },
-    {
-      id: StandardParameter.BrowLeftAngle,
-      name: "Brow L Angle",
-      min: -1,
-      max: 1,
-      default: 0
-    },
-    {
-      id: StandardParameter.BrowRightAngle,
-      name: "Brow R Angle",
-      min: -1,
-      max: 1,
-      default: 0
-    }
-  ];
+  const parameters = [...STANDARD_PARAMETERS];
   if (hasHair) {
     parameters.push(
       {
@@ -2223,97 +3616,88 @@ function generateIkiFromLayerSet(layers, canvas) {
       }
     );
   }
-  const faceLayers = layers.filter((l) => l.role === "face");
-  const faceLayer = faceLayers[0];
-  const faceTransform = bboxToTransform(
-    faceLayer.bbox,
-    faceLayer.canvasW,
-    faceLayer.canvasH,
-    "face"
-  );
-  const faceCenterX = faceTransform.x;
-  const faceCropH = faceLayer.cropH;
-  const faceWarpLayers = layers.filter(
-    (l) => ROLE_TABLE[l.role].deformer === "faceWarp"
-  );
-  let unionMinX = -canvas.width / 2;
-  let unionMaxX = canvas.width / 2;
-  let unionMinY = -canvas.height / 2;
-  let unionMaxY = canvas.height / 2;
-  if (faceWarpLayers.length > 0) {
-    const transforms = faceWarpLayers.map(
-      (l) => bboxToTransform(l.bbox, l.canvasW, l.canvasH, l.role)
-    );
-    unionMinX = Math.min(
-      ...transforms.map((t, i) => t.x - faceWarpLayers[i].cropW / 2)
-    );
-    unionMaxX = Math.max(
-      ...transforms.map((t, i) => t.x + faceWarpLayers[i].cropW / 2)
-    );
-    unionMinY = Math.min(
-      ...transforms.map((t, i) => t.y - faceWarpLayers[i].cropH / 2)
-    );
-    unionMaxY = Math.max(
-      ...transforms.map((t, i) => t.y + faceWarpLayers[i].cropH / 2)
+  const setup = turnSetup(layers);
+  const {
+    lattice,
+    faceCenterX,
+    faceHalfWidth,
+    faceCenterY,
+    nodRadius,
+    profile,
+    eyeRowY,
+    plate,
+    edgeAt,
+    plateGuardRows,
+    members,
+    groupGrids,
+    parallaxUnitY,
+    hasNose,
+    hasMouthOpen
+  } = setup;
+  const faceCropH = plate.part.cropH;
+  const turn = hasNose ? solveTurnModel(
+    resolveTurnTargets(options.turnTargets),
+    ...solveInputsOf(setup),
+    options.headEdges
+  ) : void 0;
+  if (turn?.unreachable) {
+    throw new TurnTargetError(
+      turn.attainable === void 0 ? (
+        // Only a silhouette can land here: nothing the field's own accepted
+        // range allows renders on this layer set, so there is no interval to
+        // offer instead — see `silhouetteMiss` in evaluateTurnCandidate.
+        `auto-rig: turnTargets.${turn.field} ${turn.value} is unreachable for this layer set, and so is every ${turn.field} in [${SILHOUETTE_RATIO_MIN}, ${TURN_RATIO_MAX}]`
+      ) : `auto-rig: turnTargets.${turn.field} ${turn.value} is unreachable for this layer set (attainable ${turn.attainable[0]}\u2026${turn.attainable[1]})`
     );
-    const spanX = unionMaxX - unionMinX;
-    const spanY = unionMaxY - unionMinY;
-    const MARGIN = 0.12;
-    unionMinX -= spanX * MARGIN;
-    unionMaxX += spanX * MARGIN;
-    unionMinY -= spanY * MARGIN;
-    unionMaxY += spanY * MARGIN;
-  }
-  const halfW = Math.max(faceCenterX - unionMinX, unionMaxX - faceCenterX);
-  const faceGridMinX = faceCenterX - halfW;
-  const faceGridMaxX = faceCenterX + halfW;
-  const faceGrid = {
-    cols: FACE_GRID_CELLS,
-    rows: FACE_GRID_CELLS,
-    points: generateGridPoints(
-      FACE_GRID_CELLS,
-      FACE_GRID_CELLS,
-      faceGridMinX,
-      faceGridMaxX,
-      unionMinY,
-      unionMaxY
-    )
-  };
-  const faceCenterY = faceTransform.y;
-  const halfH = Math.max(faceCenterY - unionMinY, unionMaxY - faceCenterY);
-  const parallaxUnit = headTurnParallaxUnit(halfW);
-  const parallaxUnitY = headNodParallaxUnit(halfH);
-  const faceBottom = faceTransform.y - faceCropH / 2;
+  }
+  if (turn) {
+    options.onTurnSolved?.({
+      radius: turn.radius,
+      holdBase: turn.holdBase,
+      depths: turn.depths,
+      achieved: turn.achieved,
+      clamped: turn.clamped
+    });
+  }
+  const latticeReach = Math.max(
+    faceCenterX - lattice.points[0],
+    lattice.points[lattice.cols * 2] - faceCenterX
+  );
+  const surface = turn?.surface ?? turnSurface({
+    faceCenterX,
+    faceCenterY,
+    radius: latticeReach * HEAD_CYLINDER_RADIUS_FACTOR,
+    travel: headTurnTravel(faceHalfWidth),
+    nodRadius,
+    lattice,
+    profile,
+    eyeRowY
+  });
+  const parallaxUnit = headTurnParallaxUnit(surface.radius);
+  const plateLandingAt = plateLandingOn(plate, rowMapsOf(surface));
+  const faceBottom = faceCenterY - faceCropH / 2;
   const neckPivot = {
     x: faceCenterX,
     y: faceBottom - faceCropH * 0.15
     // 15% below face bottom = neck
   };
-  const faceWarp2d = bakeHeadTurnGridWarp2DCentered(
-    faceGrid,
-    StandardParameter.AngleX,
-    StandardParameter.AngleY,
-    faceCenterX,
-    faceCenterY
-  );
   const deformers = [
     // headDeformer: rigid matrix rotating/translating the whole head about the
-    // neck pivot; bindings mirror sample-model.ts exactly.
+    // neck pivot. Same bindings as sample-model.ts apart from the turn, which
+    // moves the face inside the head rather than the head itself (see below).
     {
       id: "headDeformer",
       pivot: neckPivot,
       bindings: [
-        // The turn is a pure yaw: no roll rides on AngleX. The sample model's
-        // ±6° "lean into the turn" was tried here and dropped — rotating about
-        // the neck pivot swings the crown (~500px above it) far more than the
-        // chin, so the top of the head appeared to lunge ahead of the face on
-        // every turn. Roll is AngleZ's job, below.
-        {
-          parameter: StandardParameter.AngleX,
-          channel: "translateX",
-          from: -HEAD_TURN_TRAVEL,
-          to: HEAD_TURN_TRAVEL
-        },
+        // No AngleX binding: the turn moves NOTHING rigidly. Its sideways
+        // travel is baked into every group grid (the surface's `travel`, see
+        // bakeTurnGroupWarp2D) so the face slides inside a silhouette the
+        // bangs hold; a translate here would take the hair shell with it. Nor
+        // is the turn a roll — the sample model's ±6° "lean into the turn" was
+        // tried here and dropped, since rotating about the neck pivot swings
+        // the crown (~500px above it) far more than the chin, so the top of
+        // the head appeared to lunge ahead of the face on every turn. Roll is
+        // AngleZ's job, below.
         // Nod: a vertical translate only. No rotate — a pitch expressed as a
         // rigid rotation would sum with the AngleZ roll below at diagonal
         // poses, collapsing pitch into roll.
@@ -2342,19 +3726,25 @@ function generateIkiFromLayerSet(layers, canvas) {
           to: HEAD_BREATH_BOB
         }
       ]
-    },
-    // faceWarp: cylinder-bend warp parented to headDeformer; grid is symmetric
-    // about faceCenterX so the bake's cylinder axis aligns with the face center.
-    // One 2D warp carries both the turn and the nod (a deformer holds either
-    // `warps` or `warp2d`, never both).
-    {
-      kind: "warp",
-      id: "faceWarp",
-      parent: "headDeformer",
-      grid: faceGrid,
-      warp2d: faceWarp2d
     }
   ];
+  for (const [group, grid] of groupGrids) {
+    const family = turnFamily(members.find((m) => m.group === group).role);
+    const depth = group === "faceWarp" ? 0 : turn?.depths[family] ?? 0;
+    deformers.push({
+      kind: "warp",
+      id: group,
+      parent: "headDeformer",
+      grid,
+      warp2d: bakeTurnGroupWarp2D(
+        grid,
+        StandardParameter.AngleX,
+        StandardParameter.AngleY,
+        surface,
+        (deg) => depth * parallaxUnit * deg / HEAD_TURN_MAX_DEG
+      )
+    });
+  }
   if (bodyLayer) {
     const bt = bboxToTransform(
       bodyLayer.bbox,
@@ -2366,12 +3756,13 @@ function generateIkiFromLayerSet(layers, canvas) {
       id: "bodyDeformer",
       pivot: { x: bt.x, y: bt.y - bodyLayer.cropH / 2 },
       bindings: [
-        // Low-weight follow of the turn, same direction as the head.
+        // Low-weight follow of the turn, same direction as the face's own
+        // slide — the only rigid part of the travel left.
         {
           parameter: StandardParameter.AngleX,
           channel: "translateX",
-          from: -BODY_TURN_FOLLOW * HEAD_TURN_TRAVEL,
-          to: BODY_TURN_FOLLOW * HEAD_TURN_TRAVEL
+          from: -BODY_TURN_FOLLOW * surface.travel,
+          to: BODY_TURN_FOLLOW * surface.travel
         },
         // Breath: follow the head's bob, same direction, half amplitude.
         {
@@ -2383,33 +3774,21 @@ function generateIkiFromLayerSet(layers, canvas) {
       ]
     });
   }
-  const eyeCreaseBySide = {};
-  for (const layer of layers) {
-    const side = ROLE_TABLE[layer.role].eyeSide;
-    if ((layer.role === "eye_L" || layer.role === "eye_R") && side) {
-      const ey = bboxToTransform(
-        layer.bbox,
-        layer.canvasW,
-        layer.canvasH,
-        layer.role
-      ).y;
-      eyeCreaseBySide[side] = ey - EYELID_FOLD_CREASE * layer.cropH;
-    }
-  }
+  const memberByRole = new Map(members.map((m) => [m.role, m]));
   const parts = layers.map((layer) => {
     const { role, bbox, cropW, cropH, canvasW, canvasH } = layer;
     const spec = ROLE_TABLE[role];
     const t = bboxToTransform(bbox, canvasW, canvasH, role);
     const roleBindings = bindingsForRole(spec, role, cropW, cropH, {
       hasMouthOpen,
-      parallaxUnit,
       parallaxUnitY,
       hasNose
     });
     const deformerId = spec.deformer === "none" ? void 0 : spec.deformer;
     if (spec.mesh) {
+      const member = memberByRole.get(role);
       const { cols, rows } = meshCellsFor(cropW, cropH);
-      const mesh = createPixelGridMesh(cols, rows, cropW, cropH);
+      const mesh = member?.mesh ?? createPixelGridMesh(cols, rows, cropW, cropH);
       const part = {
         id: role,
         color: [1, 1, 1, 1],
@@ -2424,23 +3803,38 @@ function generateIkiFromLayerSet(layers, canvas) {
         part.bindings = roleBindings;
       }
       if ((role === "hair_front" || role === "hair_back") && hasHair) {
-        let tipShift = HAIR_SWAY_TIP_FRACTION * cropH;
-        let leadWarp;
+        const tipShift = HAIR_SWAY_TIP_FRACTION * cropH;
+        const ownWarps = [];
         if (role === "hair_front") {
-          const shift = HAIR_FRONT_DEPTH * parallaxUnit;
-          const headroom = Math.min(
-            faceGridMaxX - (t.x + cropW / 2),
-            t.x - cropW / 2 - faceGridMinX
-          ) - shift;
-          tipShift = Math.min(
-            tipShift,
-            Math.max(0, headroom) / HAIR_SWAY_PEAK_FRACTION
+          ownWarps.push(
+            bakeHairSwayWarp(
+              mesh,
+              StandardParameter.AngleX,
+              HAIR_FRONT_DEPTH * parallaxUnit,
+              HEAD_TURN_MAX_DEG
+            )
           );
-          leadWarp = bakeHairSwayWarp(
-            mesh,
-            StandardParameter.AngleX,
-            shift,
-            HEAD_TURN_MAX_DEG
+          const holdBase = turn?.holdBase ?? plateReach(plateLandingAt, faceCenterX, edgeAt, plateGuardRows) + HOLD_CLEARANCE;
+          ownWarps.push(
+            bakeHairFrontSilhouetteWarp(
+              mesh,
+              t.x,
+              t.y,
+              faceCenterX,
+              plateLandingAt,
+              edgeAt,
+              holdBase,
+              turn?.holdEdgeAt ?? (() => holdBase),
+              plateGuardRows
+            )
+          );
+          ownWarps.push(
+            bakeNodWarp(
+              mesh,
+              t.y,
+              surface,
+              hasNose ? HAIR_FRONT_NOD_DEPTH * parallaxUnitY : 0
+            )
           );
         }
         part.warps = [
@@ -2456,29 +3850,12 @@ function generateIkiFromLayerSet(layers, canvas) {
             tipShift,
             HAIR_SWAY_RANGE
           ),
-          ...leadWarp ? [leadWarp] : []
-        ];
-      }
-      if (role === "hair_back") {
-        part.warps = [
-          ...part.warps ?? [],
-          bakeHairBackTurnWarp(mesh, StandardParameter.AngleX)
+          ...ownWarps
         ];
       }
       if (spec.eyeSide !== void 0) {
-        const isLash = role.startsWith("lash_");
-        if (role.startsWith("eye_") || isLash) {
-          const openParam = spec.eyeSide === "L" ? StandardParameter.EyeOpenLeft : StandardParameter.EyeOpenRight;
-          const creaseWorldY = eyeCreaseBySide[spec.eyeSide] ?? t.y - EYELID_FOLD_CREASE * cropH;
-          const hasLash = layers.some((l) => l.role === `lash_${spec.eyeSide}`);
-          part.warps = [
-            bakeEyelidFoldWarp(
-              mesh,
-              openParam,
-              creaseWorldY - t.y,
-              isLash ? LASH_FOLD_K : hasLash ? 0 : EYELID_FOLD_K
-            )
-          ];
+        if (role.startsWith("eye_") || role.startsWith("lash_")) {
+          part.warps = [...member.warps];
         } else {
           part.clip = { masks: [`eye_${spec.eyeSide}`] };
         }
@@ -2542,6 +3919,7 @@ export {
   AddPart,
   AddPhysicsRig,
   CaptureGridKeyform,
+  DEFAULT_TURN_TARGETS,
   DeleteDeformer,
   DeletePart,
   DeletePhysicsRig,
@@ -2561,6 +3939,7 @@ export {
   SetPartTransform,
   SetPartWidth,
   SetPhysicsRig,
+  TurnTargetError,
   UV_INSET_PX,
   captureBindingEndpoint,
   computeGridOffsets,