@ikijs/editor 0.5.0 → 0.7.0

package/dist/index.mjs

@@ -1603,6 +1603,21 @@ 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, so its ends
@@ -1616,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 = {
@@ -1731,6 +1755,146 @@ 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 validateStrandEdges(layers, strandEdges) {
+  if (strandEdges === void 0) return;
+  const where = "auto-rig: validateStrandEdges: strandEdges";
+  const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+  if (!isPlainObject(strandEdges)) {
+    throw new Error(
+      `${where} must be a plain object with optional left / right sides`
+    );
+  }
+  for (const key of ["left", "right"]) {
+    const raw = strandEdges[key];
+    if (raw === void 0) continue;
+    const path = `${where}.${key}`;
+    if (!isPlainObject(raw)) {
+      throw new Error(`${path} must be a plain object`);
+    }
+    for (const field of ["y", "irisOuter", "irisInner", "runOuter"]) {
+      const v = raw[field];
+      if (typeof v !== "number" || !Number.isFinite(v)) {
+        throw new Error(
+          `${path}.${field} is ${String(v)}, not a finite number`
+        );
+      }
+    }
+    const rawFace = raw.runFace;
+    if (rawFace !== null && (typeof rawFace !== "number" || !Number.isFinite(rawFace))) {
+      throw new Error(
+        `${path}.runFace is ${String(rawFace)}, not a finite number or null`
+      );
+    }
+    const { y, irisOuter, irisInner, runOuter, runFace } = raw;
+    const cropOf = (role) => {
+      const layer = layers.find((l) => l.role === role);
+      if (layer === void 0) {
+        throw new Error(
+          `${path} needs a "${role}" layer to be measured on, and this layer set has none`
+        );
+      }
+      const t = bboxToTransform(layer.bbox, layer.canvasW, layer.canvasH, role);
+      return {
+        role,
+        x: t.x,
+        left: t.x - layer.cropW / 2,
+        right: t.x + layer.cropW / 2,
+        bottom: t.y - layer.cropH / 2,
+        top: t.y + layer.cropH / 2
+      };
+    };
+    const hair = cropOf("hair_front");
+    const [lowIris, highIris] = [cropOf("iris_L"), cropOf("iris_R")].sort(
+      (a, b) => a.x - b.x
+    );
+    const sign = key === "left" ? -1 : 1;
+    const iris = key === "left" ? lowIris : highIris;
+    const other = key === "left" ? highIris : lowIris;
+    const fail = (field, value, why) => new Error(`${path}.${field} (${value}) ${why}`);
+    for (const crop of [iris, hair]) {
+      if (y < crop.bottom || y > crop.top) {
+        throw fail(
+          "y",
+          y,
+          `lies outside the "${crop.role}" crop's rows (${crop.bottom}\u2026${crop.top})`
+        );
+      }
+    }
+    for (const [field, x] of [
+      ["irisOuter", irisOuter],
+      ["irisInner", irisInner]
+    ]) {
+      if (x < iris.left || x > iris.right) {
+        throw fail(
+          field,
+          x,
+          `lies outside the "${iris.role}" crop's columns (${iris.left}\u2026${iris.right})`
+        );
+      }
+    }
+    if (sign * (irisOuter - irisInner) <= 0) {
+      throw fail(
+        "irisOuter",
+        irisOuter,
+        `must lie strictly outward of strandEdges.${key}.irisInner (${irisInner})`
+      );
+    }
+    for (const [field, x] of [
+      ["runOuter", runOuter],
+      ["runFace", runFace]
+    ]) {
+      if (x !== null && (x < hair.left || x > hair.right)) {
+        throw fail(
+          field,
+          x,
+          `lies outside the "hair_front" crop's columns (${hair.left}\u2026${hair.right})`
+        );
+      }
+    }
+    if (sign * (runOuter - iris.x) <= 0) {
+      throw fail(
+        "runOuter",
+        runOuter,
+        `must lie strictly outward of the "${iris.role}" crop's centre (${iris.x})`
+      );
+    }
+    if (runFace !== null && sign * (runOuter - runFace) <= 0) {
+      throw fail(
+        "runOuter",
+        runOuter,
+        `must lie strictly outward of strandEdges.${key}.runFace (${runFace})`
+      );
+    }
+    if (runFace !== null && sign * (runFace - other.x) <= 0) {
+      throw fail(
+        "runFace",
+        runFace,
+        `must lie strictly on this side of the "${other.role}" crop's centre (${other.x}); a run that reaches it has no face-side end here, which is runFace null`
+      );
+    }
   }
 }
 function generateGridPoints(cols, rows, minX, maxX, minY, maxY) {
@@ -1786,20 +1950,16 @@ 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(radius) {
   return radius * 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 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);
@@ -1812,27 +1972,107 @@ function boundedCylinderBend(local, radius, theta) {
 function turnSlide(travel, angleX) {
   return travel * angleX / HEAD_TURN_MAX_DEG;
 }
-function bakeHeadTurnGridWarp2DCentered(grid, parameterX, parameterY, centerX, centerY, radiusX, travel) {
+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, anchor) {
   const STOPS = [...HEAD_TURN_STOPS];
-  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 slide = turnSlide(travel, angleX);
+      const shift = shiftAt(angleX);
+      const mapAt = (nodeY) => surface.mapAt(angleX, nodeY);
       const offsets = [];
       for (let i = 0; i < pointCount; i++) {
-        offsets.push(
-          boundedCylinderBend(grid.points[i * 2] - centerX, radiusX, thetaX) + slide,
-          pinnedCylinderBend(
-            grid.points[i * 2 + 1] - centerY,
-            RADIUS_Y,
-            thetaY
-          )
-        );
+        const x = grid.points[i * 2];
+        const y = grid.points[i * 2 + 1];
+        const nodDy = angleY === 0 ? 0 : surface.nodBendAt(y, angleY);
+        if (angleX === 0) {
+          offsets.push(0, nodDy);
+          continue;
+        }
+        const landed = groupNodeLanding(anchor, mapAt, angleX, shift, x, y);
+        const turnDy = landed.y - y;
+        offsets.push(landed.x - x, angleY === 0 ? turnDy : turnDy + nodDy);
       }
       keyforms2d.push({ offsets });
     }
@@ -1863,30 +2103,163 @@ function turnColumnMap(grid, faceCenterX, radiusX, angleX, travel) {
     );
   }
   const cellFor = (v, edges) => {
-    for (let c = 0; c < grid.cols; c++) {
-      if (v < edges[c + 1]) return c;
+    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 grid.cols - 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) {
-      const c = cellFor(x, restX);
-      const s = Math.max(
-        0,
-        Math.min(1, (x - restX[c]) / (restX[c + 1] - restX[c]))
-      );
-      return warpedX[c] + (warpedX[c + 1] - warpedX[c]) * s;
-    },
-    invertX(X) {
-      const c = cellFor(X, warpedX);
-      const s = Math.max(
-        0,
-        Math.min(1, (X - warpedX[c]) / (warpedX[c + 1] - warpedX[c]))
-      );
-      return restX[c] + (restX[c + 1] - restX[c]) * s;
+    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 groupNodeLanding(anchor, mapAt, deg, shift, nodeX, nodeY) {
+  if (anchor === void 0) {
+    return { x: mapAt(nodeY).mapX(nodeX + shift), y: nodeY };
+  }
+  const anchorRow = mapAt(anchor.y);
+  const pivotX = anchorRow.mapX(anchor.x + shift);
+  const dx = mapAt(nodeY).mapX(nodeX) - anchorRow.mapX(anchor.x);
+  const dy = nodeY - anchor.y;
+  const phi = anchor.tiltDeg * deg / HEAD_TURN_MAX_DEG * (Math.PI / 180);
+  const cos = Math.cos(phi);
+  const sin = Math.sin(phi);
+  return {
+    x: pivotX + cos * dx - sin * dy,
+    y: anchor.y + sin * dx + cos * dy
+  };
+}
+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 {
@@ -1957,12 +2330,15 @@ function resolveTurnTargets(targets = {}) {
     defaulted
   };
 }
-function turnLandmarks(layers) {
+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);
-    return { x: t.x, y: t.y, w: layer.cropW };
+    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);
@@ -1979,23 +2355,67 @@ function turnLandmarks(layers) {
     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 solveTurnDepthSigned(target, landmarks, unit, map, holdEdgeX, plateEdgeX) {
+function landmarkLandingX(landmark, mapAt, deg, shift, px, py) {
+  const { carrier } = landmark;
+  if (carrier === void 0) return mapAt(py).mapX(px + shift);
+  return carrierLandingX(
+    carrier,
+    (nodeX, nodeY) => groupNodeLanding(carrier.anchor, mapAt, deg, shift, nodeX, nodeY).x,
+    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 familyDepthCap(landmarks, plateEdgeX, unit) {
+  return familyReachPx(landmarks, plateEdgeX) / unit;
+}
+function solveTurnDepthSigned(target, landmarks, unit, mapAt, plateEdgeX, maxDepth) {
   if (landmarks.length === 0) {
     throw new Error("auto-rig: solveTurnDepth: no landmark to slide");
   }
-  const farEdge = Math.min(...landmarks.map((l) => l.x - l.w / 2));
-  const floor = Math.max(map.invertX(holdEdgeX), map.restX[0], plateEdgeX);
-  const cap = Math.max(0, (farEdge - floor) / unit);
-  const achieved = (d) => landmarks.reduce((sum, l) => sum + (map.mapX(l.x - d * unit) - l.x), 0) / landmarks.length;
+  const plateCap = familyDepthCap(landmarks, plateEdgeX, unit);
+  const cap = maxDepth === void 0 ? plateCap : Math.min(plateCap, maxDepth);
+  const achieved = (d) => landmarks.reduce(
+    (sum, l) => sum + (landmarkLandingX(
+      l,
+      mapAt,
+      -HEAD_TURN_MAX_DEG,
+      -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 };
+  if (target > atRest + TURN_DEPTH_EPS) {
+    return {
+      reached: false,
+      depth: 0,
+      achieved: atRest,
+      attainable,
+      limit: "floor"
+    };
+  }
+  if (target < atCap - TURN_DEPTH_EPS) {
+    return {
+      reached: false,
+      depth: cap,
+      achieved: atCap,
+      attainable,
+      limit: "cap"
+    };
+  }
   const clampedTarget = Math.min(Math.max(target, atCap), atRest);
   let lo = 0;
   let hi = cap;
@@ -2011,68 +2431,52 @@ var TURN_SWEEP_MAX_FACTOR = 8;
 var TURN_SWEEP_SAMPLES = 32;
 var HOLD_CLEARANCE = 1;
 var TURN_HOLD_SAMPLES = 16;
-var TURN_HOLD_SATURATION_PASSES = 4;
-function hairFrontHoldTarget(x, faceCenterX, faceHalfWidth, holdBase, holdEdge, map) {
+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 sideIdx = side < 0 ? 0 : 1;
-  if (dist <= faceHalfWidth) return map.mapX(x);
+  const painted = edgeAt(y);
+  if (dist <= painted) return plateLandingAt(deg, x, y);
   if (dist <= holdBase) {
-    const inner = map.mapX(faceCenterX + side * faceHalfWidth);
-    const u = (dist - faceHalfWidth) / (holdBase - faceHalfWidth);
-    return inner + (faceCenterX + side * holdEdge[sideIdx] - inner) * u;
+    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[sideIdx] - holdBase);
+  return x + side * (holdEdge - holdBase);
 }
-function hairFrontLandingAt(x, hairFront, faceCenterX, faceHalfWidth, holdBase, cappedHoldEdge, map, leadTipShift, leadRow) {
+function hairFrontLandingAt(x, y, hairFront, holdTargetAt, leadShift) {
   const { cols, rows } = meshCellsFor(hairFront.cropW, hairFront.cropH);
-  const preBindAt = (col2) => {
-    const colX = hairFront.x - hairFront.cropW / 2 + col2 / cols * hairFront.cropW;
-    const target = hairFrontHoldTarget(
-      colX,
-      faceCenterX,
-      faceHalfWidth,
-      holdBase,
-      cappedHoldEdge,
-      map
-    );
-    return map.invertX(target);
-  };
-  const leadAt = (row2) => -leadTipShift * Math.pow(row2 / rows, HAIR_SWAY_CURL);
-  const bracket = (v, cells) => {
-    const lo = Math.max(0, Math.min(cells, Math.floor(v)));
-    return {
-      lo,
-      hi: Math.max(0, Math.min(cells, lo + 1)),
-      t: Math.max(0, Math.min(1, v - lo))
-    };
-  };
-  const col = bracket(
-    (x - hairFront.x + hairFront.cropW / 2) / hairFront.cropW * cols,
-    cols
+  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) + leadShift * Math.pow((top - vy) / hairFront.cropH, HAIR_SWAY_CURL),
+    x,
+    y
   );
-  const row = bracket(leadRow * rows, rows);
-  const landingAt = (c, r) => map.mapX(preBindAt(c) + leadAt(r));
-  const tl = landingAt(col.lo, row.lo);
-  const br = landingAt(col.hi, row.hi);
-  if (col.t <= row.t) {
-    const bl = landingAt(col.lo, row.hi);
-    return tl + row.t * (bl - tl) + col.t * (br - bl);
-  }
-  const tr = landingAt(col.hi, row.lo);
-  return tl + col.t * (tr - tl) + row.t * (br - tr);
-}
-function shellTravelCap(faceCenterX, faceHalfWidth, askedTravel, bendOnlyMapAt, holdEdgeAt) {
+}
+function shellTravelCap(faceCenterX, edgeAt, plateGuardRows, askedTravel, bendOnlyLandingAt, holdEdgeAt) {
   let cap = Infinity;
   for (const deg of HEAD_TURN_STOPS) {
     if (deg === 0) continue;
-    const map = bendOnlyMapAt(deg);
     const slideSign = turnSlide(askedTravel, deg) < 0 ? -1 : 1;
-    const towardReach = Math.max(
-      ...[-1, 1].map(
-        (side) => slideSign * (map.mapX(faceCenterX + side * faceHalfWidth) - faceCenterX)
-      )
+    const towardReach = plateSideReachAt(
+      bendOnlyLandingAt,
+      faceCenterX,
+      edgeAt,
+      plateGuardRows,
+      deg,
+      slideSign
     );
     cap = Math.min(
       cap,
@@ -2081,8 +2485,39 @@ function shellTravelCap(faceCenterX, faceHalfWidth, askedTravel, bendOnlyMapAt,
   }
   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 strandDepthCap(margins, plateCap) {
+  const holds = (depth) => margins.every((m) => m(depth) >= 0);
+  if (holds(plateCap)) return plateCap;
+  if (!holds(0)) return void 0;
+  let lo = 0;
+  let hi = plateCap;
+  for (let i = 0; i < TURN_BISECT_STEPS; i++) {
+    const mid = (lo + hi) / 2;
+    if (holds(mid)) lo = mid;
+    else hi = mid;
+  }
+  return lo;
+}
 function evaluateTurnCandidate(ctx, radius) {
-  const bendOnlyMapAt = (deg) => turnColumnMap(ctx.faceGrid, ctx.faceCenterX, radius, deg, 0);
+  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;
@@ -2094,66 +2529,160 @@ function evaluateTurnCandidate(ctx, radius) {
     return edge === void 0 ? ctx.headHalfWidth : side * (edge - ctx.faceCenterX);
   };
   const unit = headTurnParallaxUnit(radius);
-  const leadTipShift = ctx.hairFrontLeadFraction === void 0 ? 0 : HAIR_FRONT_DEPTH * unit;
-  const leadRow = ctx.hairFrontLeadFraction ?? 0;
-  const evaluateHold = (ratio) => {
+  const plateCapOf = (marks) => familyDepthCap(marks, ctx.plateEdgeX, unit);
+  const eyePlateCap = plateCapOf(ctx.landmarks.eye);
+  const leadTipShift = ctx.hairFrontSilhouette === void 0 ? 0 : HAIR_FRONT_DEPTH * unit;
+  const bangsLandingAt = (hold, plateLandingAt, deg, leadShift, x, y) => hairFrontLandingAt(
+    x,
+    y,
+    ctx.hairFrontSilhouette,
+    (vx, vy) => hairFrontHoldTarget(
+      vx,
+      vy,
+      deg,
+      ctx.faceCenterX,
+      plateLandingAt,
+      ctx.edgeAt,
+      hold.holdBase,
+      hold.holdEdgeAt(deg)
+    ),
+    leadShift
+  );
+  const strandStopsOn = (hold) => {
+    const rowMaps = rowMapsOf(hold.surface);
+    const plateLandingAt = plateLandingOn(ctx.plate, rowMaps);
+    return (ctx.strands ?? []).map((strand) => {
+      const iris = {
+        x: strand.carrier.part.x,
+        w: strand.carrier.part.cropW,
+        carrier: strand.carrier
+      };
+      const stops = HEAD_TURN_STOPS.filter(
+        (deg) => Math.sign(deg) === strand.side
+      ).map((deg) => {
+        const runAt = (x) => bangsLandingAt(
+          hold,
+          plateLandingAt,
+          deg,
+          leadTipShift * deg / HEAD_TURN_MAX_DEG,
+          x,
+          strand.y
+        );
+        return {
+          deg,
+          runOuter: runAt(strand.runOuter),
+          runFace: strand.runFace === null ? null : runAt(strand.runFace),
+          irisAt: (depth, x) => landmarkLandingX(
+            iris,
+            (y) => rowMaps(deg, y),
+            deg,
+            depth * unit * deg / HEAD_TURN_MAX_DEG,
+            x,
+            strand.y
+          )
+        };
+      });
+      const { runFace } = strand;
+      if (runFace === null) return { strand, stops, margins: void 0 };
+      const allowance = Math.min(0, strand.side * (runFace - strand.irisOuter));
+      const margins = stops.map(
+        (stop) => (depth) => strand.side * (stop.runFace - stop.irisAt(depth, strand.irisOuter)) - allowance
+      );
+      return { strand, stops, margins };
+    });
+  };
+  const strandOverlapOf = (sides, depth) => {
+    const overlap = {};
+    for (const { strand, stops, margins } of sides) {
+      const s = strand.side;
+      const covered = (irisOuter, irisInner, runOuter, runFace) => Math.max(
+        0,
+        Math.min(s * irisOuter, s * runOuter) - Math.max(s * irisInner, runFace === null ? -Infinity : s * runFace)
+      );
+      let worst;
+      for (const stop of stops) {
+        const px = covered(
+          stop.irisAt(depth, strand.irisOuter),
+          stop.irisAt(depth, strand.irisInner),
+          stop.runOuter,
+          stop.runFace
+        );
+        if (px > 0 && (worst === void 0 || px > worst.px)) {
+          worst = { deg: stop.deg, px };
+        }
+      }
+      if (worst === void 0) continue;
+      overlap[s < 0 ? "left" : "right"] = {
+        deg: worst.deg,
+        px: worst.px,
+        hh: worst.px / ctx.hh,
+        restPx: covered(
+          strand.irisOuter,
+          strand.irisInner,
+          strand.runOuter,
+          strand.runFace
+        ),
+        held: margins !== void 0 && margins.every((m) => m(depth) >= 0)
+      };
+    }
+    return overlap.left === void 0 && overlap.right === void 0 ? void 0 : overlap;
+  };
+  const evaluateHold = (ratio, depths2) => {
     const holdEdgeFrom = (base) => (deg) => base * (1 + (ratio - 1) * Math.abs(deg) / HEAD_TURN_MAX_DEG);
-    const travel2 = ctx.headHalfWidth === void 0 ? ctx.travel : Math.min(
+    const travel = ctx.headHalfWidth === void 0 ? ctx.travel : Math.min(
       ctx.travel,
       shellTravelCap(
         ctx.faceCenterX,
-        ctx.faceHalfWidth,
+        ctx.edgeAt,
+        ctx.plateGuardRows,
         ctx.travel,
-        bendOnlyMapAt,
+        bendOnlyLandingAt,
         (deg, side) => {
           const rest = shellHalfWidthAt(side);
           return Math.min(rest, holdEdgeFrom(rest)(deg));
         }
       )
     );
-    const columnMapAt = (deg) => turnColumnMap(ctx.faceGrid, ctx.faceCenterX, radius, deg, travel2);
-    const holdBase2 = ctx.headHalfWidth ?? plateReach(ctx.faceCenterX, ctx.faceHalfWidth, columnMapAt) + HOLD_CLEARANCE;
-    const holdEdgeAt2 = holdEdgeFrom(holdBase2);
+    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(
-        columnMapAt(deg),
+        plateLandingAt,
         ctx.faceCenterX,
-        ctx.faceHalfWidth
+        ctx.edgeAt,
+        ctx.plateGuardRows,
+        deg
       );
       foldLowerBound = Math.max(
         foldLowerBound,
-        1 + ((reach + HOLD_CLEARANCE) / holdBase2 - 1) * (HEAD_TURN_MAX_DEG / Math.abs(deg))
+        1 + ((reach + HOLD_CLEARANCE) / holdBase - 1) * (HEAD_TURN_MAX_DEG / Math.abs(deg))
       );
-      if (holdEdgeAt2(deg) <= reach) folds = true;
+      if (holdEdgeAt(deg) <= reach) folds = true;
     }
-    const map2 = columnMapAt(-HEAD_TURN_MAX_DEG);
-    const requestedHoldEdge = holdEdgeAt2(HEAD_TURN_MAX_DEG);
-    const gridReach2 = [
-      Math.abs(map2.warpedX[0] - ctx.faceCenterX),
-      Math.abs(map2.warpedX[map2.warpedX.length - 1] - ctx.faceCenterX)
-    ];
-    const cappedHoldEdge = [
-      Math.min(requestedHoldEdge, gridReach2[0] - HOLD_CLEARANCE),
-      Math.min(requestedHoldEdge, gridReach2[1] - HOLD_CLEARANCE)
-    ];
     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 * holdBase2 : ctx.hairFrontSilhouette.x + side * ctx.hairFrontSilhouette.cropW / 2;
+      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(
+    const hairFrontAt = (x) => ctx.hairFrontSilhouette === void 0 ? x : bangsLandingAt(
+      { holdBase, holdEdgeAt },
+      plateLandingAt,
+      -HEAD_TURN_MAX_DEG,
+      -leadTipShift,
       x,
-      ctx.hairFrontSilhouette,
-      ctx.faceCenterX,
-      ctx.faceHalfWidth,
-      holdBase2,
-      cappedHoldEdge,
-      map2,
-      leadTipShift,
-      leadRow
+      ctx.eyeRowY
     );
     const landingOfRole = (role, x) => {
       if (role === "hair_front") return hairFrontAt(x);
@@ -2161,10 +2690,29 @@ function evaluateTurnCandidate(ctx, radius) {
         return x;
       }
       if (role === "body") {
-        return x - BODY_TURN_FOLLOW * travel2;
+        return x - BODY_TURN_FOLLOW * travel;
       }
       if (role === "face" || FEATURE_NOD_DEPTH[roleFamily(role)] !== void 0) {
-        return map2.mapX(x);
+        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) => groupNodeLanding(
+            carrier.anchor,
+            mapAt,
+            -HEAD_TURN_MAX_DEG,
+            shift,
+            nodeX,
+            nodeY
+          ).x,
+          x,
+          ctx.eyeRowY
+        );
       }
       throw new Error(
         `auto-rig: evaluateTurnCandidate: unrecognised role "${role}"`
@@ -2180,13 +2728,13 @@ function evaluateTurnCandidate(ctx, radius) {
     };
     return {
       ratio,
-      travel: travel2,
-      map: map2,
-      holdBase: holdBase2,
-      holdEdgeAt: holdEdgeAt2,
+      travel,
+      mapAt,
+      surface,
+      holdBase,
+      holdEdgeAt,
       folds,
       foldLowerBound,
-      gridReach: gridReach2,
       // 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
@@ -2203,24 +2751,18 @@ function evaluateTurnCandidate(ctx, radius) {
       restSpan: restAt(1) - restAt(-1)
     };
   };
-  const saturatedHold = () => {
-    let hold2 = evaluateHold(1);
-    for (let i = 0; i < TURN_HOLD_SATURATION_PASSES; i++) {
-      const needed = (Math.max(hold2.gridReach[0], hold2.gridReach[1]) - HOLD_CLEARANCE) / hold2.holdBase;
-      if (needed <= hold2.ratio) break;
-      hold2 = evaluateHold(needed);
-    }
-    return hold2;
-  };
-  const holdRange = () => {
-    const ceiling = saturatedHold();
+  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));
+    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);
+        const mid = evaluateHold((lo.ratio + hi.ratio) / 2, depths2);
         if (mid.folds) lo = mid;
         else hi = mid;
       }
@@ -2229,7 +2771,8 @@ function evaluateTurnCandidate(ctx, radius) {
     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
+        floor.ratio + (ceiling.ratio - floor.ratio) * i / TURN_HOLD_SAMPLES,
+        depths2
       );
       if (!sample.folds) samples.push(sample);
     }
@@ -2242,15 +2785,14 @@ function evaluateTurnCandidate(ctx, radius) {
     return lower > upper ? { blocked: "silhouetteRatio", lower: Infinity, upper: -Infinity } : { blocked: "silhouetteRatio", lower, upper };
   };
   const asked = ctx.silhouetteRatio;
-  const natural = evaluateHold(asked);
-  const eps = TURN_DEPTH_EPS / natural.restSpan;
-  let hold;
-  let silhouetteClamped = false;
-  if (!natural.folds && Math.abs(natural.renderedSilhouetteRatio - asked) <= eps) {
-    hold = natural;
-  } else {
-    const samples = holdRange();
-    if (samples === void 0) return silhouetteMiss();
+  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),
@@ -2265,91 +2807,169 @@ function evaluateTurnCandidate(ctx, radius) {
       return ea <= eb ? a : b;
     };
     if (asked < span[0] - eps || asked > span[1] + eps) {
-      if (!ctx.clampSilhouetteRatio) return silhouetteMiss(span);
       const wanted = asked < span[0] ? span[0] : span[1];
-      hold = samples.reduce(
+      const hold = samples.reduce(
         (a, b) => Math.abs(b.renderedSilhouetteRatio - wanted) < Math.abs(a.renderedSilhouetteRatio - wanted) ? b : a
       );
-      silhouetteClamped = true;
-    } else {
-      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;
-        }
+      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);
-        if (!mid.folds) best = nearer(best, mid);
-        if ((mid.renderedSilhouetteRatio - asked) * (lo.renderedSilhouetteRatio - asked) > 0) {
-          lo = mid;
-        } else {
-          hi = mid;
-        }
+    }
+    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;
       }
-      hold = best;
     }
-  }
-  if (hold.folds) {
-    throw new Error(
-      "auto-rig: evaluateTurnCandidate: the hold it settled on folds"
+    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 strandSides = ctx.strands === void 0 ? void 0 : strandStopsOn(hold);
+    let strandFeasible = true;
+    let maxDepth;
+    if (strandSides !== void 0) {
+      const margins = strandSides.map((s) => s.margins);
+      const cap = margins.every((m) => m !== void 0) ? strandDepthCap(
+        margins.flatMap((m) => m),
+        eyePlateCap
+      ) : void 0;
+      strandFeasible = cap !== void 0;
+      maxDepth = cap ?? 0;
+    }
+    const eye = solveTurnDepthSigned(
+      hold.silhouetteCenterShift - ctx.eyeShift * ctx.hh,
+      ctx.landmarks.eye,
+      unit,
+      hold.mapAt,
+      ctx.plateEdgeX,
+      maxDepth
     );
-  }
-  const {
-    travel,
-    map,
-    holdBase,
-    holdEdgeAt,
-    silhouetteCenterShift,
-    renderedSilhouetteRatio
-  } = hold;
-  const holdEdgeX = ctx.faceCenterX - holdEdgeAt(HEAD_TURN_MAX_DEG);
-  const eye = solveTurnDepthSigned(
-    silhouetteCenterShift - ctx.eyeShift * ctx.hh,
-    ctx.landmarks.eye,
-    unit,
-    map,
-    holdEdgeX,
-    ctx.plateEdgeX
-  );
-  if (!eye.reached && !ctx.clampEyeShift) {
+    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 {
+        depths = {
+          eye: aitken(seed.eye, depths.eye, solved.eye, eyePlateCap),
+          nose: aitken(
+            seed.nose,
+            depths.nose,
+            solved.nose,
+            plateCapOf(ctx.landmarks.nose)
+          ),
+          mouth: aitken(
+            seed.mouth,
+            depths.mouth,
+            solved.mouth,
+            plateCapOf(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 && eye.limit === "floor" && !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,
+      -HEAD_TURN_MAX_DEG,
+      eyeShiftPx,
+      l.x + l.w / 2,
+      l.y ?? 0
+    ) - landmarkLandingX(
+      l,
+      mapAt,
+      -HEAD_TURN_MAX_DEG,
+      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);
+    const strandOverlap = strandSides === void 0 ? void 0 : strandOverlapOf(strandSides, eye.depth);
     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
-      ]
+      radius,
+      ratio: scaleOf(far) / scaleOf(near),
+      unit,
+      travel,
+      mapAt,
+      surface,
+      holdBase,
+      holdEdgeAt,
+      eye,
+      nose: features.nose,
+      mouth: features.mouth,
+      silhouetteClamped,
+      silhouetteCenterShift,
+      renderedSilhouetteRatio,
+      strandFeasible,
+      ...strandOverlap === void 0 ? {} : { strandOverlap }
     };
   }
-  const scaleOf = (l) => (map.mapX(l.x + l.w / 2 - eye.depth * unit) - map.mapX(l.x - l.w / 2 - eye.depth * unit)) / 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,
-    map,
-    holdBase,
-    holdEdgeAt,
-    holdEdgeX,
-    eye,
-    silhouetteClamped,
-    silhouetteCenterShift,
-    renderedSilhouetteRatio
-  };
 }
 function sweepTurnRadii(ctx) {
   const minRadius = ctx.faceHalfWidth * HEAD_CYLINDER_RADIUS_FACTOR;
@@ -2358,6 +2978,7 @@ function sweepTurnRadii(ctx) {
   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);
@@ -2366,6 +2987,8 @@ function sweepTurnRadii(ctx) {
     } 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]),
@@ -2373,7 +2996,16 @@ function sweepTurnRadii(ctx) {
       ] : result.offeredShift;
     }
   }
-  return { candidates, heldRatioLower, heldRatioUpper, offeredShift };
+  return {
+    candidates,
+    heldRatioLower,
+    heldRatioUpper,
+    offeredShift,
+    unsettled
+  };
+}
+function runHolds(run, ratio) {
+  return ratio >= run.ratios[0] - TURN_DEPTH_EPS && ratio <= run.ratios[1] + TURN_DEPTH_EPS;
 }
 function ratioClusters(candidates) {
   const clusters = [];
@@ -2397,7 +3029,7 @@ function ratioClusters(candidates) {
   close();
   return clusters;
 }
-function fitTurnRadius(ctx, candidates, target) {
+function fitTurnRadius(ctx, candidates, target, accept) {
   let lo = candidates[0];
   let hi = candidates[candidates.length - 1];
   for (let i = candidates.length - 2; i >= 0; i--) {
@@ -2407,79 +3039,102 @@ function fitTurnRadius(ctx, candidates, target) {
       break;
     }
   }
+  return bisectTurnRadius(
+    lo,
+    hi,
+    target,
+    (radius) => {
+      const mid = evaluateTurnCandidate(ctx, radius);
+      return "blocked" in mid ? void 0 : mid;
+    },
+    accept
+  );
+}
+function bisectTurnRadius(lo, hi, target, evaluate, accept) {
+  if (!accept(lo) || !accept(hi)) {
+    throw new Error(
+      "auto-rig: bisectTurnRadius: a bracket end is not accepted"
+    );
+  }
+  const miss = (c) => Math.abs(c.ratio - target);
+  let nearest = miss(lo) <= miss(hi) ? lo : hi;
   for (let i = 0; i < TURN_BISECT_STEPS; i++) {
-    const mid = evaluateTurnCandidate(ctx, Math.sqrt(lo.radius * hi.radius));
-    if ("blocked" in mid) break;
+    const mid = evaluate(Math.sqrt(lo.radius * hi.radius));
+    if (mid === void 0) break;
+    if (accept(mid) && miss(mid) < miss(nearest)) nearest = mid;
     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;
+  if (accept(lo) && accept(hi)) return miss(lo) <= miss(hi) ? lo : hi;
+  return nearest;
 }
-function solveFeatureDepths(ctx, targets, best, eyeShift) {
-  const clamped = [];
-  const solved = {};
-  const families = [
-    ["noseShift", ctx.landmarks.nose, NOSE_SHIFT_SHARE],
-    ["mouthShift", ctx.landmarks.mouth, MOUTH_SHIFT_SHARE]
-  ];
-  for (const [field, marks, share] of families) {
-    const m = Math.abs(
-      targets.defaulted.has(field) ? share * eyeShift : targets[field]
-    );
-    const solution = solveTurnDepthSigned(
-      best.silhouetteCenterShift - m * ctx.hh,
-      marks,
-      best.unit,
-      best.map,
-      best.holdEdgeX,
-      ctx.plateEdgeX
-    );
-    if (!solution.reached) {
-      if (!targets.defaulted.has(field)) {
-        return {
-          blocked: field,
-          // noseShift/mouthShift are MAGNITUDES too (see the correction
-          // above), 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);
-    }
-    solved[field] = solution.depth;
-  }
+function strandPreferredCandidates(candidates, farEyeRatio) {
+  const feasible = candidates.filter((c) => c.strandFeasible);
+  if (feasible.length === candidates.length) return candidates;
+  const holds = ratioClusters(feasible).some(
+    (run) => runHolds(run, farEyeRatio)
+  );
+  return holds ? feasible : candidates;
+}
+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: solved.noseShift,
-    mouth: solved.mouthShift,
-    clamped
+    nose: solve(ctx.noseShift, ctx.landmarks.nose, NOSE_SHIFT_SHARE),
+    mouth: solve(ctx.mouthShift, ctx.landmarks.mouth, MOUTH_SHIFT_SHARE)
   };
 }
-function solveTurnModel(targets, landmarks, faceGrid, faceCenterX, faceHalfWidth, hairFront, headEdges) {
+function solveTurnModel(targets, landmarks, lattice, faceCenterX, faceHalfWidth, faceCenterY, nodRadius, carriers, profile, hairFront, headEdges, strandEdges) {
   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 = landmarks.eye.length === 2 && landmarks.eye[0].y !== void 0 && landmarks.eye[1].y !== void 0 ? (landmarks.eye[0].y + landmarks.eye[1].y) / 2 : void 0;
-  const hairFrontLeadFraction = hairFront === void 0 || eyeRowY === void 0 ? void 0 : Math.max(
-    0,
-    Math.min(
-      1,
-      (hairFront.centerY + hairFront.cropH / 2 - eyeRowY) / hairFront.cropH
-    )
+  const eyeRowY = eyeRowOf(landmarks, faceCenterY);
+  let strands;
+  const strandSides = ["left", "right"].filter(
+    (key) => strandEdges?.[key] !== void 0
   );
+  if (strandSides.length > 0) {
+    if (hairFront === void 0) {
+      throw new Error(
+        "auto-rig: solveTurnModel: strandEdges was given, but there is no hair_front to land its runs on"
+      );
+    }
+    const irises = ["iris_L", "iris_R"].map((role) => carriers.get(role)).filter((c) => c !== void 0).sort((a, b) => a.part.x - b.part.x);
+    strands = strandSides.map((key) => {
+      const carrier = irises.length === 2 ? irises[key === "left" ? 0 : 1] : void 0;
+      if (carrier === void 0) {
+        throw new Error(
+          `auto-rig: solveTurnModel: strandEdges.${key} has no iris carrier to land`
+        );
+      }
+      return {
+        ...strandEdges[key],
+        side: key === "left" ? -1 : 1,
+        carrier
+      };
+    });
+  }
   const ctx = {
     landmarks,
-    faceGrid,
+    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),
@@ -2492,16 +3147,23 @@ function solveTurnModel(targets, landmarks, faceGrid, faceCenterX, faceHalfWidth
     // 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"),
-    hairFrontLeadFraction,
-    hairFrontSilhouette: hairFront === void 0 ? void 0 : { x: hairFront.x, cropW: hairFront.cropW, cropH: hairFront.cropH },
+    hairFrontSilhouette: hairFront,
     // A companion to a MEASURED headHalfWidth only — see its own doc.
-    headEdges: targets.headHalfWidth === void 0 ? void 0 : headEdges
+    headEdges: targets.headHalfWidth === void 0 ? void 0 : headEdges,
+    strands
   };
-  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",
@@ -2523,72 +3185,107 @@ function solveTurnModel(targets, landmarks, faceGrid, faceCenterX, faceHalfWidth
       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
+  const fitFrom = (pool, accept) => {
+    const clamped = [];
+    const clusters = ratioClusters(pool);
+    const distanceTo = (c) => Math.max(
+      c.ratios[0] - targets.farEyeRatio,
+      targets.farEyeRatio - c.ratios[1],
+      0
     );
-    if (!targets.defaulted.has("farEyeRatio")) {
-      return {
-        unreachable: true,
-        field: "farEyeRatio",
-        value: targets.farEyeRatio,
-        attainable: cluster.ratios
-      };
+    let farEyeRatio = targets.farEyeRatio;
+    let cluster = clusters.find((c) => runHolds(c, farEyeRatio));
+    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");
     }
-    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
-      };
+    const best = fitTurnRadius(ctx, cluster.candidates, farEyeRatio, accept);
+    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);
     }
-    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;
-  const features = solveFeatureDepths(ctx, targets, best, eyeShift);
-  if ("blocked" in features) {
     return {
-      unreachable: true,
-      field: features.blocked,
-      value: targets[features.blocked],
-      attainable: features.attainable
+      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,
+      ...best.strandOverlap === void 0 ? {} : { strandOverlap: best.strandOverlap }
     };
-  }
-  return {
-    unreachable: false,
-    radius: best.radius,
-    holdBase: best.holdBase,
-    holdEdgeAt: best.holdEdgeAt,
-    travel: best.travel,
-    depths: { eye: best.eye.depth, nose: features.nose, mouth: features.mouth },
-    achieved: {
-      eyeShift,
-      farEyeRatio: best.ratio,
-      silhouetteRatio: best.renderedSilhouetteRatio
-    },
-    clamped: [...clamped, ...features.clamped]
   };
+  const preferred = strandPreferredCandidates(
+    pass.candidates,
+    targets.farEyeRatio
+  );
+  if (preferred !== pass.candidates) {
+    const fitted = fitFrom(preferred, (c) => c.strandFeasible);
+    if (!fitted.unreachable && !fitted.clamped.includes("farEyeRatio")) {
+      return fitted;
+    }
+  }
+  return fitFrom(pass.candidates, () => true);
 }
 var EYE_STACK_PREFIXES = ["eye_", "iris_", "pupil_", "highlight_"];
 var HAIR_FRONT_DEPTH = 0.1;
+var MOUTH_TURN_TILT_DEG = 5;
 var NOD_TRAVEL = 30;
 var NOD_BEND = 0.5;
 var HAIR_BACK_NOD_DEPTH = -0.135;
@@ -2621,27 +3318,16 @@ function featureParallaxBindings(role, options) {
   if (!options.hasNose) return [];
   const nodDepth = FEATURE_NOD_DEPTH[roleFamily(role)];
   if (nodDepth === void 0) return [];
-  const bindings = [];
-  const turnDepth = options.turnDepths?.[turnFamily(role)] ?? 0;
-  const shiftX = turnDepth * (options.parallaxUnit ?? 0);
-  if (shiftX !== 0) {
-    bindings.push({
-      parameter: StandardParameter.AngleX,
-      channel: "translateX",
-      from: -shiftX,
-      to: shiftX
-    });
-  }
   const shiftY = nodDepth * (options.parallaxUnitY ?? 0);
-  if (shiftY !== 0) {
-    bindings.push({
+  if (shiftY === 0) return [];
+  return [
+    {
       parameter: StandardParameter.AngleY,
       channel: "translateY",
       from: -shiftY,
       to: shiftY
-    });
-  }
-  return bindings;
+    }
+  ];
 }
 function bindingsForRole(spec, role, cropW, cropH, options = {}) {
   return [
@@ -2749,20 +3435,17 @@ function roleOwnBindings(spec, role, cropW, cropH, options) {
       ];
     }
   }
-  if (role === "hair_front" || role === "hair_back") {
-    const isFront = role === "hair_front";
-    const parallax = [];
-    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 [];
 }
@@ -2785,64 +3468,98 @@ function bakeEyelidFoldWarp(mesh, parameter, creaseOffsetY, k) {
     ]
   };
 }
-function plateReach(faceCenterX, faceHalfWidth, columnMapAt) {
+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(columnMapAt(deg), faceCenterX, faceHalfWidth)
+      plateReachAt(plateLandingAt, faceCenterX, edgeAt, plateGuardRows, deg)
     );
   }
   return reach;
 }
-function plateReachAt(map, faceCenterX, faceHalfWidth) {
+function plateSideReachAt(plateLandingAt, faceCenterX, edgeAt, plateGuardRows, deg, side) {
   let reach = 0;
-  for (const side of [-1, 1]) {
-    const dest = map.mapX(faceCenterX + side * faceHalfWidth);
+  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 bakeHairFrontSilhouetteWarp(mesh, partX, faceCenterX, faceHalfWidth, holdBase, holdEdgeAt, columnMapAt) {
+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 SIDES = [-1, 1];
   const keyforms = HEAD_TURN_STOPS.map((deg) => {
-    const map = columnMapAt(deg);
-    const requestedHoldEdge = holdEdgeAt(deg);
-    const plateDest = SIDES.map(
-      (side) => map.mapX(faceCenterX + side * faceHalfWidth)
+    const holdEdge = holdEdgeAt(deg);
+    const reach = [-1, 1].map(
+      (side) => plateSideReachAt(
+        plateLandingAt,
+        faceCenterX,
+        edgeAt,
+        plateGuardRows,
+        deg,
+        side
+      )
     );
-    const reached = plateReachAt(map, faceCenterX, faceHalfWidth);
-    if (requestedHoldEdge <= reached) {
-      const side = Math.abs(plateDest[1] - faceCenterX) > Math.abs(plateDest[0] - faceCenterX) ? 1 : -1;
+    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 ${requestedHoldEdge} from the face centre but the plate's edge maps to ${reached}, so the ramp between them would fold`
+        `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 holdEdge = deg === 0 ? [requestedHoldEdge, requestedHoldEdge] : SIDES.map(
-      (_side, idx) => Math.min(
-        requestedHoldEdge,
-        Math.abs(
-          map.warpedX[idx === 0 ? 0 : map.warpedX.length - 1] - faceCenterX
-        ) - HOLD_CLEARANCE
-      )
-    );
     const offsets = [];
     for (let i = 0; i < mesh.vertices.length; i += 2) {
       const x = partX + mesh.vertices[i];
-      const target = hairFrontHoldTarget(
-        x,
-        faceCenterX,
-        faceHalfWidth,
-        holdBase,
-        holdEdge,
-        map
+      const y = partY + mesh.vertices[i + 1];
+      offsets.push(
+        deg === 0 ? 0 : hairFrontHoldTarget(
+          x,
+          y,
+          deg,
+          faceCenterX,
+          plateLandingAt,
+          edgeAt,
+          holdBase,
+          holdEdge
+        ) - x,
+        0
       );
-      offsets.push(map.invertX(target) - x, 0);
     }
     return { value: deg, offsets };
   });
@@ -2851,7 +3568,6 @@ function bakeHairFrontSilhouetteWarp(mesh, partX, faceCenterX, faceHalfWidth, ho
 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;
@@ -2881,112 +3597,385 @@ function headTurnTravel(faceHalfWidth) {
 var BODY_TURN_FOLLOW = 0.3;
 var HEAD_BREATH_BOB = -12;
 var BODY_BREATH_FOLLOW = 0.5;
+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 mouthAt = members.find((m) => m.role === "mouth").transform;
+  const mouthAnchor = {
+    x: mouthAt.x,
+    y: mouthAt.y,
+    tiltDeg: MOUTH_TURN_TILT_DEG
+  };
+  const carriers = new Map(
+    members.map((m) => [
+      m.role,
+      m.group === "mouthWarp" ? { grid: groupGrids.get(m.group), part: m.part, anchor: mouthAnchor } : { 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);
+  validateStrandEdges(layers, options.strandEdges);
   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(
       {
@@ -3005,87 +3994,31 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       }
     );
   }
-  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 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 faceHalfWidth = faceLayer.cropW / 2;
-  const hairFrontLayer = layers.find((l) => l.role === "hair_front");
-  const turn = hasNose ? solveTurnModel(
-    resolveTurnTargets(options.turnTargets),
-    turnLandmarks(layers),
-    faceGrid,
+  const setup = turnSetup(layers);
+  const {
+    lattice,
     faceCenterX,
     faceHalfWidth,
-    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
-      };
-    })(),
-    options.headEdges
+    faceCenterY,
+    nodRadius,
+    profile,
+    eyeRowY,
+    plate,
+    edgeAt,
+    plateGuardRows,
+    members,
+    groupGrids,
+    carriers,
+    parallaxUnitY,
+    hasNose,
+    hasMouthOpen
+  } = setup;
+  const faceCropH = plate.part.cropH;
+  const turn = hasNose ? solveTurnModel(
+    resolveTurnTargets(options.turnTargets),
+    ...solveInputsOf(setup),
+    options.headEdges,
+    options.strandEdges
   ) : void 0;
   if (turn?.unreachable) {
     throw new TurnTargetError(
@@ -3103,28 +4036,32 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       holdBase: turn.holdBase,
       depths: turn.depths,
       achieved: turn.achieved,
-      clamped: turn.clamped
+      clamped: turn.clamped,
+      ...turn.strandOverlap === void 0 ? {} : { strandOverlap: turn.strandOverlap }
     });
   }
-  const faceRadius = turn?.radius ?? halfW * HEAD_CYLINDER_RADIUS_FACTOR;
-  const headTravel = turn?.travel ?? headTurnTravel(faceHalfWidth);
-  const parallaxUnit = headTurnParallaxUnit(faceRadius);
-  const parallaxUnitY = headNodParallaxUnit(halfH);
-  const faceBottom = faceTransform.y - faceCropH / 2;
+  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,
-    faceRadius,
-    headTravel
-  );
   const deformers = [
     // headDeformer: rigid matrix rotating/translating the whole head about the
     // neck pivot. Same bindings as sample-model.ts apart from the turn, which
@@ -3134,14 +4071,14 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       pivot: neckPivot,
       bindings: [
         // No AngleX binding: the turn moves NOTHING rigidly. Its sideways
-        // travel is baked into faceWarp's own grid (see
-        // bakeHeadTurnGridWarp2DCentered's `travel`) 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.
+        // 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.
@@ -3170,19 +4107,27 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
           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 { role } = members.find((m) => m.group === group);
+    const family = turnFamily(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,
+        carriers.get(role).anchor
+      )
+    });
+  }
   if (bodyLayer) {
     const bt = bboxToTransform(
       bodyLayer.bbox,
@@ -3199,8 +4144,8 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
         {
           parameter: StandardParameter.AngleX,
           channel: "translateX",
-          from: -BODY_TURN_FOLLOW * headTravel,
-          to: BODY_TURN_FOLLOW * headTravel
+          from: -BODY_TURN_FOLLOW * surface.travel,
+          to: BODY_TURN_FOLLOW * surface.travel
         },
         // Breath: follow the head's bob, same direction, half amplitude.
         {
@@ -3212,34 +4157,21 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       ]
     });
   }
-  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,
-      turnDepths: turn?.depths
+      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],
@@ -3254,35 +4186,38 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
         part.bindings = roleBindings;
       }
       if ((role === "hair_front" || role === "hair_back") && hasHair) {
-        let tipShift = HAIR_SWAY_TIP_FRACTION * cropH;
-        let leadWarp;
-        let silhouetteWarp;
+        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
+            )
           );
-          const columnMapAt = (deg) => turnColumnMap(faceGrid, faceCenterX, faceRadius, deg, headTravel);
-          const holdBase = turn?.holdBase ?? plateReach(faceCenterX, faceHalfWidth, columnMapAt) + HOLD_CLEARANCE;
-          silhouetteWarp = bakeHairFrontSilhouetteWarp(
-            mesh,
-            t.x,
-            faceCenterX,
-            faceHalfWidth,
-            holdBase,
-            turn?.holdEdgeAt ?? (() => holdBase),
-            columnMapAt
+          ownWarps.push(
+            bakeNodWarp(
+              mesh,
+              t.y,
+              surface,
+              hasNose ? HAIR_FRONT_NOD_DEPTH * parallaxUnitY : 0
+            )
           );
         }
         part.warps = [
@@ -3298,24 +4233,12 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
             tipShift,
             HAIR_SWAY_RANGE
           ),
-          ...leadWarp ? [leadWarp] : [],
-          ...silhouetteWarp ? [silhouetteWarp] : []
+          ...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}`] };
         }