@ikijs/editor 0.10.1 → 0.12.0

package/dist/index.js

@@ -1632,7 +1632,6 @@ function createLayerSetMeasurer(canvas) {
   const opaque = new Uint8Array(canvasW * canvasH);
   const layerInputs = [];
   const rowSpansByRole = [];
-  let hairFrontMask;
   function add({ role, fileName, rgba }) {
     if (rgba.length !== rgbaLength) {
       throw new Error(
@@ -1643,19 +1642,29 @@ function createLayerSetMeasurer(canvas) {
     if (bbox === null) return null;
     const rowLeft = new Int32Array(canvasH).fill(canvasW);
     const rowRight = new Int32Array(canvasH).fill(-1);
-    const ownMask = role === "hair_front" ? new Uint8Array(canvasW * canvasH) : void 0;
+    const rowRuns = role === "face" || role === "hair_front" || role === "hair_back" ? [] : void 0;
     for (let y = 0; y < canvasH; y++) {
+      let runs;
+      if (rowRuns !== void 0 && y >= bbox.y && y < bbox.y + bbox.h) {
+        runs = [];
+        rowRuns.push(runs);
+      }
+      let inRun = false;
       for (let x = 0; x < canvasW; x++) {
         const p = y * canvasW + x;
-        if (rgba[p * 4 + 3] < ALPHA_OPAQUE) continue;
+        const on = rgba[p * 4 + 3] >= ALPHA_OPAQUE;
+        if (runs !== void 0 && on !== inRun) {
+          runs.push(x);
+          inRun = on;
+        }
+        if (!on) continue;
         opaque[p] = 1;
-        if (ownMask !== void 0) ownMask[p] = 1;
         if (x < rowLeft[y]) rowLeft[y] = x;
         if (x > rowRight[y]) rowRight[y] = x;
       }
+      if (runs !== void 0 && inRun) runs.push(canvasW);
     }
     rowSpansByRole.push({ role, rowLeft, rowRight });
-    if (ownMask !== void 0) hairFrontMask = ownMask;
     const layer = {
       role,
       fileName,
@@ -1665,6 +1674,7 @@ function createLayerSetMeasurer(canvas) {
       cropW: bbox.w,
       cropH: bbox.h
     };
+    if (rowRuns !== void 0) layer.rowRuns = rowRuns;
     if (role === "face") {
       const rowHalfWidths = [];
       for (let y = bbox.y; y < bbox.y + bbox.h; y++) {
@@ -1709,8 +1719,10 @@ function createLayerSetMeasurer(canvas) {
     }
     let strandEdges;
     const irisLayers = layerInputs.filter((l) => l.role === "iris_L" || l.role === "iris_R").sort((a, b) => a.bbox.x + a.bbox.w / 2 - (b.bbox.x + b.bbox.w / 2));
-    if (hairFrontMask !== void 0 && irisLayers.length === 2) {
-      const mask = hairFrontMask;
+    const hairFront = layerInputs.find((l) => l.role === "hair_front");
+    const hairRuns = hairFront?.rowRuns;
+    if (hairFront !== void 0 && hairRuns !== void 0 && irisLayers.length === 2) {
+      const hairTop = hairFront.bbox.y;
       const half = canvasW / 2;
       const strandOn = (iris, other, side) => {
         const r = Math.floor(iris.bbox.y + iris.bbox.h / 2);
@@ -1721,15 +1733,11 @@ function createLayerSetMeasurer(canvas) {
         if (span2.rowRight[r] < span2.rowLeft[r]) return void 0;
         const minRun = STRAND_MIN_RUN_FRACTION * (span2.rowRight[r] + 1 - span2.rowLeft[r]);
         const strand = new Uint8Array(canvasW);
-        for (let a = 0; a < canvasW; ) {
-          if (mask[r * canvasW + a] !== 1) {
-            a++;
-            continue;
+        const runs = r >= hairTop && r < hairTop + hairRuns.length ? hairRuns[r - hairTop] : [];
+        for (let k = 0; k < runs.length; k += 2) {
+          if (runs[k + 1] - runs[k] >= minRun) {
+            strand.fill(1, runs[k], runs[k + 1]);
           }
-          let b = a;
-          while (b < canvasW && mask[r * canvasW + b] === 1) b++;
-          if (b - a >= minRun) strand.fill(1, a, b);
-          a = b;
         }
         const strandAt = (x2) => x2 >= 0 && x2 < canvasW && strand[x2] === 1;
         const outerBoundary = (x2) => (side < 0 ? x2 : x2 + 1) - half;
@@ -2171,6 +2179,23 @@ function checkLayers(layers, canvas) {
         }
       });
     }
+    if (l.rowRuns !== void 0) {
+      const rows = l.rowRuns;
+      if (!Array.isArray(rows) || rows.length !== h) {
+        throw new Error(
+          `${at}: rowRuns must have one entry per crop row (${h})`
+        );
+      }
+      rows.forEach((runs, i) => {
+        if (!Array.isArray(runs) || runs.length % 2 !== 0 || !runs.every(
+          (c, k) => Number.isInteger(c) && c >= x && c <= x + w && (k === 0 || c > runs[k - 1])
+        )) {
+          throw new Error(
+            `${at}: rowRuns[${i}] ${JSON.stringify(runs)} is not an even-length, strictly increasing list of columns inside its crop (${x}..${x + w})`
+          );
+        }
+      });
+    }
     if (l.jawRows !== void 0) {
       const cols = l.jawRows;
       if (!Array.isArray(cols) || cols.length !== w) {
@@ -2428,7 +2453,11 @@ var TURN = {
    *  its translation (bangs 1.18×, side locks at the eye row ≈ 1.0×). */
   hairFollow: 1.1,
   /** The head's outline at the eye row holds (−0.014 / −0.004 hh): where the
-   *  front hair draws it, its outer edge follows the face this much. */
+   *  front hair draws it, its outer edge follows the face this much on a row
+   *  where no back hair paints behind that edge. Where back hair does, the
+   *  edge rides further, as far as that back hair stays behind it through
+   *  the turn and the nod, up to the face's follow there (`hairFollow`;
+   *  over the far eye's rows, as far as that eye's outer corner goes). */
   outlineFollow: 0,
   /** The back hair's slight counter-motion. */
   hairBack: -0.027,
@@ -2448,6 +2477,13 @@ var NOD = {
   nose: { up: -0.207, down: 0.193 },
   mouth: { up: -0.172, down: 0.177 },
   hairFront: { up: -0.11, down: 0.189 },
+  /** The front hair's cap top. The samples' cap top moves 1.215× their face's
+   *  centroid looking down (Mao 1.236, Haru 1.626, Hiyori 1.194, Natori
+   *  0.730) and 0.415× looking up (0.385, 0.430, 0.400, 0.487); each ratio
+   *  times the plate's own nod halfway between its top and the chin (0.1435
+   *  down, 0.084 up). Looking down, the rig slides it only as far as the
+   *  back hair covers the crown behind it. */
+  hairFrontTop: { up: -0.035, down: 0.174 },
   hairBack: { up: -0.011, down: 0.025 }
 };
 var ROLL_DEG = 10;
@@ -2495,433 +2531,82 @@ function resolveStyle(style, check) {
   };
 }
 
-// src/auto-rig/fields.ts
-var NOSE_TILT_DEG = 6;
-function nodDy(v, ay, hh) {
-  const up = Math.max(0, ay) / 30;
-  const down = Math.max(0, -ay) / 30;
-  return -(up * v.up + down * v.down) * hh;
-}
-function spin(x, y, ox, oy, a) {
-  if (a === 0) return [0, 0];
-  const px = x - ox;
-  const py = y - oy;
-  return [
-    px * Math.cos(a) - py * Math.sin(a) - px,
-    px * Math.sin(a) + py * Math.cos(a) - py
-  ];
-}
-function faceField(m) {
-  const f = m.frame;
-  return (x, y, ax, ay) => {
-    const s = Math.sign(ax);
-    const a = Math.abs(ax) / 30;
-    const chin = smoothstep(f.mouthY, f.chinY, y);
-    const width = m.widthUpper + (m.widthJaw - m.widthUpper) * smoothstep(f.cheekY, f.jawY, y);
-    const shell = f.hairShell ? 0 : m.shellScale - 1;
-    const dx = s * a * (m.face + m.chinLead * chin) + a * (width - 1 + shell) * (x - f.axisX);
-    const t = Math.min(
-      1,
-      Math.max(0, (f.face.y1 - y) / Math.max(1, f.face.y1 - f.chinY))
-    );
-    const v = {
-      up: NOD.faceTop.up + (NOD.chin.up - NOD.faceTop.up) * t,
-      down: NOD.faceTop.down + (NOD.chin.down - NOD.faceTop.down) * t
-    };
-    return [dx, nodDy(v, ay, f.hh)];
-  };
-}
-function earField(m) {
-  const f = m.frame;
-  const ears = f.ears;
-  if (ears === void 0) return () => [0, 0];
-  const face = faceField(m);
-  return (x, y, ax, ay) => {
-    const s = Math.sign(ax);
-    const a = Math.abs(ax) / 30;
-    const dy = face(x, y, 0, ay)[1];
-    if (sideOf(m, x, s) === "far") return [s * a * TURN.earFar * m.face, dy];
-    const d = Math.abs(x - f.axisX);
-    const attach = ears.attachAt(y);
-    if (d <= attach) return [face(x, y, ax, 0)[0], dy];
-    const root = face(f.axisX + Math.sign(x - f.axisX) * attach, y, ax, 0)[0];
-    const rim = s * a * TURN.earNear * m.face;
-    const t = Math.min(1, (d - attach) / Math.max(1, ears.outer - attach));
-    return [root + (rim - root) * t, dy];
-  };
-}
-function chinSlide(m) {
-  const f = m.frame;
-  return Math.abs(faceField(m)(f.axisX, f.chinY, 30, 0)[0]);
-}
-var NECK_SHADE_MAX = 0.45;
-var NECK_SHADE_FULL = 0.2;
-function neckField(m) {
-  const f = m.frame;
-  const nk = f.neck;
-  if (nk === void 0) return () => [0, 0];
-  const face = faceField(m);
-  const full = chinSlide(m);
-  const share = Math.min(1, NECK_SHADE_MAX * nk.waist / Math.max(1e-6, full));
-  const bottom = f.face.y0;
-  const tip = f.cutAt(f.axisX);
-  const top = tip - NECK_SHADE_FULL * (tip - bottom);
-  return (x, y, ax) => {
-    const wy = Math.min(
-      1,
-      Math.max(0, (y - bottom) / Math.max(1, top - bottom))
-    );
-    const wx = Math.max(0, 1 - Math.abs(x - f.axisX) / nk.waist);
-    return [share * face(f.axisX, f.chinY, ax, 0)[0] * wx * wy, 0];
-  };
-}
-function sideOf(m, x, s) {
-  return s * (x - m.frame.axisX) > 0 ? "far" : "near";
+// src/auto-rig/head.ts
+function outerEdge(runs, axisX, side) {
+  if (runs.length === 0) return void 0;
+  const x = side > 0 ? runs[runs.length - 1] : runs[0];
+  return side * (x - axisX) > 0 ? x : void 0;
 }
-function eyeField(m, box) {
-  const xe = cx(box);
-  const ye = cy(box);
-  const hh = m.frame.hh;
-  return (x, y, ax, ay) => {
-    const s = Math.sign(ax);
-    const a = Math.abs(ax) / 30;
-    const side = sideOf(m, xe, s);
-    const dx = s * a * m.eye[side] + a * (m.eyeScale[side] - 1) * (x - xe);
-    const up = Math.max(0, ay) / 30;
-    const down = Math.max(0, -ay) / 30;
-    const squash = up * (NOD.eyeHeight.up - 1) + down * (NOD.eyeHeight.down - 1);
-    return [dx, nodDy(NOD.eye, ay, hh) + squash * (y - ye)];
-  };
+function runReach(runs, x, side) {
+  const px = side > 0 ? x - 1 : x;
+  for (let k = 0; k < runs.length; k += 2) {
+    const [a, b] = [runs[k], runs[k + 1]];
+    if (a <= px && px + 1 <= b) {
+      return side > 0 ? { inward: x - a, outward: b - x } : { inward: b - x, outward: x - a };
+    }
+  }
+  return { inward: 0, outward: 0 };
 }
-function browField(m, box) {
-  const xb = cx(box);
-  return (_x, _y, ax, ay) => {
-    const s = Math.sign(ax);
-    const a = Math.abs(ax) / 30;
-    return [s * a * m.brow[sideOf(m, xb, s)], nodDy(NOD.brow, ay, m.frame.hh)];
-  };
+function filledProfile(rows) {
+  if (rows === void 0 || !rows.some((v) => v > 0)) return null;
+  const out = rows.slice();
+  const first = out.findIndex((v) => v > 0);
+  for (let i = 0; i < first; i++) out[i] = out[first];
+  for (let i = first + 1; i < out.length; i++)
+    if (!(out[i] > 0)) out[i] = out[i - 1];
+  return out;
 }
-function noseField(m) {
-  const at = m.noseAt;
-  const top = m.noseTopY ?? at.y;
-  return (x, y, ax, ay) => {
-    const s = Math.sign(ax);
-    const a = Math.abs(ax) / 30;
-    const [tx, ty] = spin(
-      x,
-      y,
-      at.x,
-      top,
-      s * a * m.tilt * NOSE_TILT_DEG * DEG
-    );
-    return [s * a * m.nose + tx, nodDy(NOD.nose, ay, m.frame.hh) + ty];
-  };
+var smoothProfile = (rows) => boxSmooth(rows, Math.max(1, Math.round(rows.length * 0.01)));
+var EAR_STEP = 0.03;
+var EAR_ROWS = 3;
+function findEars(raw, wMax, firstRow, lastRow, minRows, maxRows) {
+  const step = Math.max(4, EAR_STEP * wMax);
+  for (let t = Math.max(firstRow, EAR_ROWS); t < lastRow; t++) {
+    if (raw[t] - raw[t - EAR_ROWS] < step) continue;
+    for (let b = t + minRows; b <= Math.min(lastRow, t + maxRows); b++) {
+      if (raw[b - EAR_ROWS] - raw[b] >= step) {
+        return { top: t - EAR_ROWS, bottom: b };
+      }
+    }
+    return void 0;
+  }
+  return void 0;
 }
-function mouthField(m) {
-  const c = m.mouthAt;
-  return (x, y, ax, ay) => {
-    const s = Math.sign(ax);
-    const a = Math.abs(ax) / 30;
-    const wx = c.x + (x - c.x) * (1 + a * (m.mouthWidth - 1));
-    const [tx, ty] = spin(
-      wx,
-      y,
-      c.x,
-      c.y,
-      s * a * m.tilt * TURN.mouthTiltDeg * DEG
-    );
-    return [
-      s * a * m.mouth + wx - x + tx,
-      nodDy(NOD.mouth, ay, m.frame.hh) + ty
-    ];
-  };
+function boxSmooth(v, k) {
+  return v.map((_, i) => {
+    let s = 0;
+    let n = 0;
+    for (let j = i - k; j <= i + k; j++) {
+      if (j < 0 || j >= v.length) continue;
+      s += v[j];
+      n++;
+    }
+    return s / n;
+  });
 }
-function hairField(m, shift, nod) {
-  const f = m.frame;
-  return (x, _y, ax, ay) => {
-    const s = Math.sign(ax);
-    const a = Math.abs(ax) / 30;
-    return [
-      s * a * shift + a * (m.shellScale - 1) * (x - f.axisX),
-      nodDy(nod, ay, f.hh)
-    ];
-  };
+var CUT_MARGIN = 2;
+var CUT_LOW = 3;
+function fadeToOutline(d, nk) {
+  return Math.max(0, 1 - d / nk.waist);
 }
-function hairFrontBends(frame, boxes) {
-  const f = frame;
-  const eyes = [boxes.eye_L, boxes.eye_R].filter(
-    (e) => e !== void 0
-  );
-  const inner = Math.max(
-    1,
-    Math.min(
-      f.paintedHalfAt(f.eyeY),
-      ...eyes.map((e) => Math.max(f.axisX - e.x0, e.x1 - f.axisX))
-    )
-  );
-  return {
-    inner,
-    left: Math.max(inner + 1, f.axisX - f.shellLeft),
-    right: Math.max(inner + 1, f.shellRight - f.axisX)
+var STROKE_RUN = 4;
+var STROKE_SLACK = 6;
+var JAW_SHADE = 0.05;
+function buildHeadFrame(layers, opts) {
+  const byRole = new Map(layers.map((l) => [l.role, l]));
+  const faceLayer = byRole.get("face");
+  const { canvasW, canvasH } = faceLayer;
+  const face = boxOfLayer(faceLayer);
+  const axisX = cx(face);
+  const plateHalf = faceLayer.cropW / 2;
+  const centreY = (role) => {
+    const l = byRole.get(role);
+    return l === void 0 ? void 0 : cy(boxOfLayer(l));
   };
-}
-function hairFrontField(m) {
-  const f = m.frame;
-  const back = hairField(m, m.hairBack, NOD.hairBack);
-  const top = f.face.y1;
-  const eyes = [m.boxes.eye_L, m.boxes.eye_R].filter(
-    (e) => e !== void 0
-  );
-  const { inner, left, right } = hairFrontBends(f, m.boxes);
-  const eyeY = eyes.length > 0 ? eyes.reduce((t, e) => t + cy(e), 0) / eyes.length : f.eyeY;
-  const eyeH = eyes.length > 0 ? eyes.reduce((t, e) => t + (e.y1 - e.y0), 0) / eyes.length : 1;
-  return (x, y, ax, ay) => {
-    const s = Math.sign(ax);
-    const a = Math.abs(ax) / 30;
-    const u = s * (x - f.axisX);
-    const across = Math.min(1, Math.max(0, (u + inner) / (2 * inner)));
-    const band = 1 - smoothstep(eyeH / 2, 1.5 * eyeH, Math.abs(y - eyeY));
-    const core = m.hairFront + (m.hairFar - m.hairFront) * across * band;
-    const out = Math.min(
-      1,
-      Math.max(
-        0,
-        (Math.abs(x - f.axisX) - inner) / ((x < f.axisX ? left : right) - inner)
-      )
-    );
-    const follow = core + (m.hairOuter - core) * out;
-    const rx = s * a * follow + a * (m.shellScale - 1) * (x - f.axisX);
-    const ry = nodDy(NOD.hairFront, ay, f.hh);
-    const [bx, by] = back(x, y, ax, ay);
-    const w = 1 - smoothstep(top, Math.max(top + 1, m.hairTop), y);
-    return [bx + w * (rx - bx), by + w * (ry - by)];
-  };
-}
-function familyField(m, family) {
-  switch (family) {
-    case "face":
-      return faceField(m);
-    case "eye_L":
-    case "eye_R":
-      return eyeField(m, m.boxes[family]);
-    case "brow_L":
-    case "brow_R":
-      return browField(m, m.boxes[family]);
-    case "nose":
-      return noseField(m);
-    case "mouth":
-      return mouthField(m);
-    case "hair_front":
-      return hairFrontField(m);
-    case "hair_back":
-      return hairField(m, m.hairBack, NOD.hairBack);
-    case "body":
-      return () => [0, 0];
-  }
-}
-
-// src/auto-rig/context.ts
-function sidePair(byRole, a, b) {
-  const la = byRole.get(a);
-  const lb = byRole.get(b);
-  if (la === void 0 || lb === void 0) return void 0;
-  const [lo, hi] = [
-    { role: a, box: boxOfLayer(la) },
-    { role: b, box: boxOfLayer(lb) }
-  ].sort((p, q) => cx(p.box) - cx(q.box));
-  return { left: lo, right: hi };
-}
-function sideIrises(byRole) {
-  const pair = sidePair(byRole, "iris_L", "iris_R");
-  return pair === void 0 ? {} : { left: pair.left.box, right: pair.right.box };
-}
-function solveContext(frame, byRole, options, hasNose) {
-  const box = (role) => boxOfLayer(byRole.get(role));
-  const row = (s, strand2, sideSign) => {
-    if (strand2 !== void 0) {
-      const lo = sideSign < 0 ? strand2.irisOuter : strand2.irisInner;
-      const hi = sideSign < 0 ? strand2.irisInner : strand2.irisOuter;
-      return { role: s.role, lo, hi, y: strand2.y };
-    }
-    const inset = bw(s.box) > 4 ? 1 : 0;
-    return {
-      role: s.role,
-      lo: s.box.x0 + inset,
-      hi: s.box.x1 - inset,
-      y: cy(s.box)
-    };
-  };
-  const eyes = sidePair(byRole, "eye_L", "eye_R");
-  const irises = sidePair(byRole, "iris_L", "iris_R");
-  const pair = irises ?? eyes;
-  const strand = irises ? options.strandEdges : void 0;
-  const left = row(pair.left, strand?.left, -1);
-  const right = row(pair.right, strand?.right, 1);
-  let candidates;
-  const edges = options.headEdges;
-  if (frame.hairShell && edges && edges.left.length > 0 && edges.right.length > 0) {
-    candidates = {
-      left: edges.left.map((e) => ({ role: e.role, x: e.x })),
-      // A right edge names its outermost pixel column; the boundary is one on.
-      right: edges.right.map((e) => ({ role: e.role, x: e.x + 1 }))
-    };
-  } else if (frame.hairShell) {
-    candidates = {
-      left: [{ role: "hair_back", x: frame.shellLeft }],
-      right: [{ role: "hair_back", x: frame.shellRight }]
-    };
-  } else {
-    const w = frame.paintedHalfAt(frame.eyeY);
-    candidates = {
-      left: [{ role: "face", x: frame.axisX - w }],
-      right: [{ role: "face", x: frame.axisX + w }]
-    };
-  }
-  const restHalf = (Math.max(...candidates.right.map((c) => c.x)) - Math.min(...candidates.left.map((c) => c.x))) / 2;
-  const nose = byRole.get("nose");
-  let noseAt;
-  let noseBox;
-  if (hasNose && nose !== void 0) {
-    noseBox = nose.denseCore ? boxOfPixels(nose.denseCore, nose.canvasW, nose.canvasH) : boxOfLayer(nose);
-    noseAt = { x: cx(noseBox), y: cy(noseBox) };
-  }
-  const mouthBox = byRole.has("mouth_open") ? unionBoxes([box("mouth"), box("mouth_open")]) : box("mouth");
-  const m = box("mouth");
-  return {
-    frame,
-    left,
-    right,
-    candidates,
-    restHalf,
-    strand,
-    hasHairFront: byRole.has("hair_front"),
-    eyeBoxes: { left: eyes.left.box, right: eyes.right.box },
-    noseAt,
-    noseBox,
-    mouthAt: { x: cx(m), y: cy(m) },
-    mouthBox
-  };
-}
-function renderedLander(turn, parts, grids, from = /* @__PURE__ */ new Map()) {
-  const analytic = /* @__PURE__ */ new Map();
-  const landed = /* @__PURE__ */ new Map();
-  const field = (role) => {
-    const family = roleSpec(role).family;
-    let f = analytic.get(family);
-    if (f === void 0) analytic.set(family, f = familyField(turn, family));
-    return f;
-  };
-  return (role, x, y, ax) => {
-    const family = roleSpec(role).family;
-    const part = parts.find((p) => p.id === role);
-    const g = grids.get(family);
-    const warp = part?.warps?.find((w) => w.parameter === import_format3.StandardParameter.AngleX);
-    if (part === void 0 || part.mesh === void 0 || !g && !warp) {
-      return x + field(role)(x, y, ax, 0)[0];
-    }
-    const box = {
-      x0: part.transform.x - part.width / 2,
-      x1: part.transform.x + part.width / 2,
-      y0: part.transform.y - part.height / 2,
-      y1: part.transform.y + part.height / 2
-    };
-    const rest = meshPoints(part.mesh, box);
-    const key = `${role}@${ax}`;
-    let xs = landed.get(key);
-    if (xs === void 0) {
-      if (g) {
-        const offsets = keyformAt(g.keyforms, ax);
-        xs = rest.map(([px, py]) => land(g.lattice, offsets, px, py)[0]);
-      } else {
-        const k = warp.keyforms;
-        const offsets = blendStops(
-          k.map((kf) => kf.value),
-          k.map((kf) => kf.offsets),
-          ax
-        );
-        xs = rest.map(([px], i) => px + offsets[2 * i] * bw(box));
-      }
-      landed.set(key, xs);
-    }
-    const idx = part.mesh.indices;
-    for (let t = from.get(role) ?? 0; t < idx.length; t += 3) {
-      const [a, b, c] = [idx[t], idx[t + 1], idx[t + 2]];
-      const [ax0, ay0] = rest[a];
-      const [bx0, by0] = rest[b];
-      const [cx0, cy0] = rest[c];
-      const d = (by0 - cy0) * (ax0 - cx0) + (cx0 - bx0) * (ay0 - cy0);
-      if (Math.abs(d) < 1e-9) continue;
-      const u = ((by0 - cy0) * (x - cx0) + (cx0 - bx0) * (y - cy0)) / d;
-      const v = ((cy0 - ay0) * (x - cx0) + (ax0 - cx0) * (y - cy0)) / d;
-      const w = 1 - u - v;
-      if (u < -1e-6 || v < -1e-6 || w < -1e-6) continue;
-      return u * xs[a] + v * xs[b] + w * xs[c];
-    }
-    return x + field(role)(x, y, ax, 0)[0];
-  };
-}
-
-// src/auto-rig/head.ts
-function filledProfile(rows) {
-  if (rows === void 0 || !rows.some((v) => v > 0)) return null;
-  const out = rows.slice();
-  const first = out.findIndex((v) => v > 0);
-  for (let i = 0; i < first; i++) out[i] = out[first];
-  for (let i = first + 1; i < out.length; i++)
-    if (!(out[i] > 0)) out[i] = out[i - 1];
-  return out;
-}
-var smoothProfile = (rows) => boxSmooth(rows, Math.max(1, Math.round(rows.length * 0.01)));
-var EAR_STEP = 0.03;
-var EAR_ROWS = 3;
-function findEars(raw, wMax, firstRow, lastRow, minRows, maxRows) {
-  const step = Math.max(4, EAR_STEP * wMax);
-  for (let t = Math.max(firstRow, EAR_ROWS); t < lastRow; t++) {
-    if (raw[t] - raw[t - EAR_ROWS] < step) continue;
-    for (let b = t + minRows; b <= Math.min(lastRow, t + maxRows); b++) {
-      if (raw[b - EAR_ROWS] - raw[b] >= step) {
-        return { top: t - EAR_ROWS, bottom: b };
-      }
-    }
-    return void 0;
-  }
-  return void 0;
-}
-function boxSmooth(v, k) {
-  return v.map((_, i) => {
-    let s = 0;
-    let n = 0;
-    for (let j = i - k; j <= i + k; j++) {
-      if (j < 0 || j >= v.length) continue;
-      s += v[j];
-      n++;
-    }
-    return s / n;
-  });
-}
-var CUT_MARGIN = 2;
-var CUT_LOW = 3;
-function fadeToOutline(d, nk) {
-  return Math.max(0, 1 - d / nk.waist);
-}
-var STROKE_RUN = 4;
-var STROKE_SLACK = 6;
-var JAW_SHADE = 0.05;
-function buildHeadFrame(layers, opts) {
-  const byRole = new Map(layers.map((l) => [l.role, l]));
-  const faceLayer = byRole.get("face");
-  const { canvasW, canvasH } = faceLayer;
-  const face = boxOfLayer(faceLayer);
-  const axisX = cx(face);
-  const plateHalf = faceLayer.cropW / 2;
-  const centreY = (role) => {
-    const l = byRole.get(role);
-    return l === void 0 ? void 0 : cy(boxOfLayer(l));
-  };
-  const pair = (a, b) => {
-    const ya = centreY(a);
-    const yb = centreY(b);
-    return ya === void 0 || yb === void 0 ? void 0 : (ya + yb) / 2;
+  const pair = (a, b) => {
+    const ya = centreY(a);
+    const yb = centreY(b);
+    return ya === void 0 || yb === void 0 ? void 0 : (ya + yb) / 2;
   };
   const eyeY = pair("iris_L", "iris_R") ?? pair("eye_L", "eye_R");
   const mouthY = centreY("mouth");
@@ -3081,68 +2766,768 @@ function buildHeadFrame(layers, opts) {
         }
         return m;
       });
-      if (opts.chinSlide !== void 0 && banded >= 0)
-        nk.bandEnd = banded + CUT_LOW + 1;
-      cutAt = (x) => {
-        const f = x - (faceLayer.bbox.x - canvasW / 2) - 0.5;
-        const i = clamp(Math.floor(f), 0, low.length - 1);
-        const j = Math.min(i + 1, low.length - 1);
-        const t = clamp(f - i, 0, 1);
-        return Math.max(face.y0, low[i] + (low[j] - low[i]) * t);
-      };
-    } else {
-      const head = earless(chinY);
-      headMax = Math.max(...head);
-      if (ears !== void 0) {
-        const bottomOf = (d) => {
-          for (let r = head.length - 1; r >= 0; r--) {
-            if (head[r] >= d) return rowY(r) - 0.5;
+      if (opts.chinSlide !== void 0 && banded >= 0)
+        nk.bandEnd = banded + CUT_LOW + 1;
+      cutAt = (x) => {
+        const f = x - (faceLayer.bbox.x - canvasW / 2) - 0.5;
+        const i = clamp(Math.floor(f), 0, low.length - 1);
+        const j = Math.min(i + 1, low.length - 1);
+        const t = clamp(f - i, 0, 1);
+        return Math.max(face.y0, low[i] + (low[j] - low[i]) * t);
+      };
+    } else {
+      const head = earless(chinY);
+      headMax = Math.max(...head);
+      if (ears !== void 0) {
+        const bottomOf = (d) => {
+          for (let r = head.length - 1; r >= 0; r--) {
+            if (head[r] >= d) return rowY(r) - 0.5;
+          }
+          return face.y1;
+        };
+        cutAt = (x) => {
+          const y = bottomOf(Math.abs(x - axisX));
+          return y >= face.y1 ? face.y1 : Math.max(face.y0, y - CUT_MARGIN);
+        };
+      }
+    }
+  }
+  const hh = HH_PER_EYE_TO_CHIN * Math.max(1, eyeY - chinY);
+  const headHalf = opts.headHalfWidth;
+  const hairShell = headHalf !== void 0;
+  let shellLeft = axisX - plateHalf;
+  let shellRight = axisX + plateHalf;
+  if (hairShell) {
+    if (opts.headEdges && opts.headEdges.left.length > 0 && opts.headEdges.right.length > 0) {
+      shellLeft = Math.min(...opts.headEdges.left.map((e) => e.x));
+      shellRight = Math.max(...opts.headEdges.right.map((e) => e.x)) + 1;
+    } else {
+      shellLeft = axisX - headHalf;
+      shellRight = axisX + headHalf;
+    }
+  }
+  const runsOf = (role, y) => {
+    const l = byRole.get(role);
+    if (l?.rowRuns === void 0) return void 0;
+    const runs = l.rowRuns[Math.floor(canvasH / 2 - y) - l.bbox.y];
+    return runs === void 0 ? [] : runs.map((c) => c - canvasW / 2);
+  };
+  const hairRuns = (role, y) => runsOf(role, y);
+  const faceRuns = (y) => runsOf("face", y);
+  return {
+    canvasW,
+    canvasH,
+    face,
+    axisX,
+    eyeY,
+    mouthY,
+    chinY,
+    hh,
+    paintedHalfAt,
+    wMax,
+    headMax,
+    hasProfile: profile !== null,
+    neck,
+    ears,
+    cutAt,
+    cheekY: eyeY - 0.5 * (eyeY - chinY),
+    jawY: eyeY - 0.8 * (eyeY - chinY),
+    shellLeft,
+    shellRight,
+    hairShell,
+    holdBase: headHalf ?? plateHalf,
+    hairRuns,
+    faceRuns
+  };
+}
+
+// src/auto-rig/fields.ts
+var NOSE_TILT_DEG = 6;
+function nodDy(v, ay, hh) {
+  const up = Math.max(0, ay) / 30;
+  const down = Math.max(0, -ay) / 30;
+  return -(up * v.up + down * v.down) * hh;
+}
+function spin(x, y, ox, oy, a) {
+  if (a === 0) return [0, 0];
+  const px = x - ox;
+  const py = y - oy;
+  return [
+    px * Math.cos(a) - py * Math.sin(a) - px,
+    px * Math.sin(a) + py * Math.cos(a) - py
+  ];
+}
+function faceField(m) {
+  const f = m.frame;
+  return (x, y, ax, ay) => {
+    const s = Math.sign(ax);
+    const a = Math.abs(ax) / 30;
+    const chin = smoothstep(f.mouthY, f.chinY, y);
+    const width = m.widthUpper + (m.widthJaw - m.widthUpper) * smoothstep(f.cheekY, f.jawY, y);
+    const shell = f.hairShell ? 0 : m.shellScale - 1;
+    const dx = s * a * (m.face + m.chinLead * chin) + a * (width - 1 + shell) * (x - f.axisX);
+    const t = Math.min(
+      1,
+      Math.max(0, (f.face.y1 - y) / Math.max(1, f.face.y1 - f.chinY))
+    );
+    const v = {
+      up: NOD.faceTop.up + (NOD.chin.up - NOD.faceTop.up) * t,
+      down: NOD.faceTop.down + (NOD.chin.down - NOD.faceTop.down) * t
+    };
+    return [dx, nodDy(v, ay, f.hh)];
+  };
+}
+function earField(m) {
+  const f = m.frame;
+  const ears = f.ears;
+  if (ears === void 0) return () => [0, 0];
+  const face = faceField(m);
+  return (x, y, ax, ay) => {
+    const s = Math.sign(ax);
+    const a = Math.abs(ax) / 30;
+    const dy = face(x, y, 0, ay)[1];
+    if (sideOf(m, x, s) === "far") return [s * a * TURN.earFar * m.face, dy];
+    const d = Math.abs(x - f.axisX);
+    const attach = ears.attachAt(y);
+    if (d <= attach) return [face(x, y, ax, 0)[0], dy];
+    const root = face(f.axisX + Math.sign(x - f.axisX) * attach, y, ax, 0)[0];
+    const rim = s * a * TURN.earNear * m.face;
+    const t = Math.min(1, (d - attach) / Math.max(1, ears.outer - attach));
+    return [root + (rim - root) * t, dy];
+  };
+}
+function chinSlide(m) {
+  const f = m.frame;
+  return Math.abs(faceField(m)(f.axisX, f.chinY, 30, 0)[0]);
+}
+var NECK_SHADE_MAX = 0.45;
+var NECK_SHADE_FULL = 0.2;
+function neckField(m) {
+  const f = m.frame;
+  const nk = f.neck;
+  if (nk === void 0) return () => [0, 0];
+  const face = faceField(m);
+  const full = chinSlide(m);
+  const share = Math.min(1, NECK_SHADE_MAX * nk.waist / Math.max(1e-6, full));
+  const bottom = f.face.y0;
+  const tip = f.cutAt(f.axisX);
+  const top = tip - NECK_SHADE_FULL * (tip - bottom);
+  return (x, y, ax) => {
+    const wy = Math.min(
+      1,
+      Math.max(0, (y - bottom) / Math.max(1, top - bottom))
+    );
+    const wx = Math.max(0, 1 - Math.abs(x - f.axisX) / nk.waist);
+    return [share * face(f.axisX, f.chinY, ax, 0)[0] * wx * wy, 0];
+  };
+}
+function sideOf(m, x, s) {
+  return s * (x - m.frame.axisX) > 0 ? "far" : "near";
+}
+function eyeField(m, box) {
+  const xe = cx(box);
+  const ye = cy(box);
+  const hh = m.frame.hh;
+  return (x, y, ax, ay) => {
+    const s = Math.sign(ax);
+    const a = Math.abs(ax) / 30;
+    const side = sideOf(m, xe, s);
+    const dx = s * a * m.eye[side] + a * (m.eyeScale[side] - 1) * (x - xe);
+    const up = Math.max(0, ay) / 30;
+    const down = Math.max(0, -ay) / 30;
+    const squash = up * (NOD.eyeHeight.up - 1) + down * (NOD.eyeHeight.down - 1);
+    return [dx, nodDy(NOD.eye, ay, hh) + squash * (y - ye)];
+  };
+}
+function browField(m, box) {
+  const xb = cx(box);
+  return (_x, _y, ax, ay) => {
+    const s = Math.sign(ax);
+    const a = Math.abs(ax) / 30;
+    return [s * a * m.brow[sideOf(m, xb, s)], nodDy(NOD.brow, ay, m.frame.hh)];
+  };
+}
+function noseField(m) {
+  const at = m.noseAt;
+  const top = m.noseTopY ?? at.y;
+  return (x, y, ax, ay) => {
+    const s = Math.sign(ax);
+    const a = Math.abs(ax) / 30;
+    const [tx, ty] = spin(
+      x,
+      y,
+      at.x,
+      top,
+      s * a * m.tilt * NOSE_TILT_DEG * DEG
+    );
+    return [s * a * m.nose + tx, nodDy(NOD.nose, ay, m.frame.hh) + ty];
+  };
+}
+function mouthField(m) {
+  const c = m.mouthAt;
+  return (x, y, ax, ay) => {
+    const s = Math.sign(ax);
+    const a = Math.abs(ax) / 30;
+    const wx = c.x + (x - c.x) * (1 + a * (m.mouthWidth - 1));
+    const [tx, ty] = spin(
+      wx,
+      y,
+      c.x,
+      c.y,
+      s * a * m.tilt * TURN.mouthTiltDeg * DEG
+    );
+    return [
+      s * a * m.mouth + wx - x + tx,
+      nodDy(NOD.mouth, ay, m.frame.hh) + ty
+    ];
+  };
+}
+function hairField(m, shift, nod) {
+  const f = m.frame;
+  return (x, _y, ax, ay) => {
+    const s = Math.sign(ax);
+    const a = Math.abs(ax) / 30;
+    return [
+      s * a * shift + a * (m.shellScale - 1) * (x - f.axisX),
+      nodDy(nod, ay, f.hh)
+    ];
+  };
+}
+function hairFrontBends(frame, boxes) {
+  const f = frame;
+  const eyes = [boxes.eye_L, boxes.eye_R].filter(
+    (e) => e !== void 0
+  );
+  const inner = Math.max(
+    1,
+    Math.min(
+      f.paintedHalfAt(f.eyeY),
+      ...eyes.map((e) => Math.max(f.axisX - e.x0, e.x1 - f.axisX))
+    )
+  );
+  return {
+    inner,
+    left: Math.max(inner + 1, f.axisX - f.shellLeft),
+    right: Math.max(inner + 1, f.shellRight - f.axisX)
+  };
+}
+function hairFrontField(m) {
+  const f = m.frame;
+  const back = hairField(m, m.hairBack, NOD.hairBack);
+  const cap = { up: NOD.hairFrontTop.up, down: capSlide(m) };
+  const eyes = [m.boxes.eye_L, m.boxes.eye_R].filter(
+    (e) => e !== void 0
+  );
+  const { inner, left, right } = hairFrontBends(f, m.boxes);
+  const eyeY = eyes.length > 0 ? eyes.reduce((t, e) => t + cy(e), 0) / eyes.length : f.eyeY;
+  const eyeH = eyes.length > 0 ? eyes.reduce((t, e) => t + (e.y1 - e.y0), 0) / eyes.length : 1;
+  const coreAt = (x, y, s) => {
+    const u = s * (x - f.axisX);
+    const across = Math.min(1, Math.max(0, (u + inner) / (2 * inner)));
+    const band = 1 - smoothstep(eyeH / 2, 1.5 * eyeH, Math.abs(y - eyeY));
+    return m.hairFront + (m.hairFar - m.hairFront) * across * band;
+  };
+  const followAt = (x, y, s) => {
+    const core = coreAt(x, y, s);
+    const out = Math.min(
+      1,
+      Math.max(
+        0,
+        (Math.abs(x - f.axisX) - inner) / ((x < f.axisX ? left : right) - inner)
+      )
+    );
+    return core + (m.hairOuter - core) * out;
+  };
+  const ride = outerRide(m, inner, coreAt, followAt);
+  const followOf = (x, y, s) => followAt(x, y, s) + (ride === void 0 ? 0 : ride(x, y, s));
+  const drift = Math.abs(m.hairBack);
+  const crown = crownRide(m, cap, (x, y, s) => followOf(x, y, s) + drift);
+  return (x, y, ax, ay) => {
+    const s = Math.sign(ax);
+    const a = Math.abs(ax) / 30;
+    const rx = s * a * followOf(x, y, s) + a * (m.shellScale - 1) * (x - f.axisX);
+    const ry = nodDy(NOD.hairFront, ay, f.hh);
+    const bx = back(x, y, ax, ay)[0];
+    const by = nodDy(cap, ay, f.hh);
+    const w = crownBlend(m, y);
+    const wx = crown === void 0 ? w : w + crown(y, s);
+    return [bx + wx * (rx - bx), by + w * (ry - by)];
+  };
+}
+function crownBlend(m, y) {
+  const top = m.frame.face.y1;
+  return 1 - smoothstep(top, Math.max(top + 1, m.hairTop), y);
+}
+function gridRow(ys, y, snap = false) {
+  const n = ys.length;
+  let v = clamp((ys[0] - y) / (ys[0] - ys[n - 1]) * (n - 1), 0, n - 1);
+  if (snap && Math.abs(v - Math.round(v)) < 1e-3) v = Math.round(v);
+  const r = Math.min(n - 2, Math.floor(v));
+  return { r, t: v - r };
+}
+function renderedCrownBlend(m, ys) {
+  const wr = ys.map((y) => crownBlend(m, y));
+  return {
+    wr,
+    blendAt: (y) => {
+      const { r, t } = gridRow(ys, y);
+      return wr[r] + (wr[r + 1] - wr[r]) * t;
+    }
+  };
+}
+var CAP_COVER_LOSS = 0.01;
+function capSlide(m) {
+  const f = m.frame;
+  const least = NOD.hairBack.down;
+  const grid = m.hairFrontGrid;
+  if (grid === void 0 || f.hairRuns("hair_front", grid.ys[0]) === void 0 || f.hairRuns("hair_back", grid.ys[0]) === void 0) {
+    return least;
+  }
+  const { xs, ys } = grid;
+  const top = ys[0];
+  const n = ys.length;
+  const bangs = NOD.hairFront.down;
+  const { wr, blendAt } = renderedCrownBlend(m, ys);
+  const flat = ys[wr.findIndex((w) => w >= 1)] ?? ys[n - 1];
+  const x0 = xs[0];
+  const tops = new Float64Array(Math.round(xs[xs.length - 1] - x0)).fill(NaN);
+  for (let i = 0; i < top - flat; i++) {
+    const runs = f.hairRuns("hair_front", top - i - 0.5);
+    for (let k = 0; k < runs.length; k += 2) {
+      for (let px = runs[k]; px < runs[k + 1]; px++) {
+        const j = Math.round(px - x0);
+        if (Number.isNaN(tops[j])) tops[j] = i;
+      }
+    }
+  }
+  const hh = f.hh;
+  const most = Math.ceil(Math.max(bangs, NOD.hairFrontTop.down) * hh);
+  const bared = (s) => clamp(Math.ceil(s - 0.5), 0, most);
+  const dropAt = (w, slide) => (w * bangs + (1 - w) * slide) * hh;
+  const backNod = NOD.hairBack.down * hh;
+  const backRows = /* @__PURE__ */ new Map();
+  const columns = [];
+  tops.forEach((i, j) => {
+    if (Number.isNaN(i)) return;
+    const w = blendAt(top - i);
+    const empty = new Int32Array(most + 1);
+    for (let r = 0; r < most; r++) {
+      const at = Math.floor(i + r + 0.5 - backNod);
+      let runs = backRows.get(at);
+      if (runs === void 0) {
+        runs = f.hairRuns("hair_back", top - at - 0.5);
+        backRows.set(at, runs);
+      }
+      empty[r + 1] = empty[r] + (paints(runs, x0 + j) ? 0 : 1);
+    }
+    columns.push({ w, empty, base: empty[bared(dropAt(w, least))] });
+  });
+  const budget = CAP_COVER_LOSS * hh;
+  const fits = (slide) => columns.every((c) => c.empty[bared(dropAt(c.w, slide))] - c.base <= budget);
+  let lo = least;
+  let hi = NOD.hairFrontTop.down;
+  if (fits(hi)) return hi;
+  for (let k = 0; k < 30; k++) {
+    const mid = (lo + hi) / 2;
+    if (fits(mid)) lo = mid;
+    else hi = mid;
+  }
+  return lo;
+}
+function paints(runs, px) {
+  for (let k = 0; k < runs.length; k += 2) {
+    if (runs[k] <= px && px + 1 <= runs[k + 1]) return true;
+  }
+  return false;
+}
+function outerRide(m, inner, coreAt, followAt) {
+  const f = m.frame;
+  const ys = m.hairFrontGrid?.ys;
+  if (ys === void 0) return void 0;
+  const top = ys[0];
+  if (f.hairRuns("hair_front", top) === void 0 || f.hairRuns("hair_back", top) === void 0) {
+    return void 0;
+  }
+  const drift = Math.abs(m.hairBack);
+  const sides = [-1, 1];
+  const n = ys.length;
+  const count = Math.round(top - ys[n - 1]);
+  const below = (NOD.hairFront.down - NOD.hairBack.down) * f.hh;
+  const above = (NOD.hairBack.up - NOD.hairFront.up) * f.hh;
+  const j0 = Math.floor(-above);
+  const backRows = Array.from(
+    { length: Math.ceil(count + below) - j0 },
+    (_, j) => f.hairRuns("hair_back", top - (j + j0) - 0.5)
+  );
+  const offset = sides.map(() => new Float64Array(count).fill(NaN));
+  const far = sides.map(() => new Float64Array(count));
+  const near = sides.map(() => new Float64Array(count));
+  for (let i = 0; i < count; i++) {
+    const y = top - i - 0.5;
+    const front = f.hairRuns("hair_front", y);
+    sides.forEach((side, k) => {
+      const edge = outerEdge(front, f.axisX, side);
+      if (edge === void 0) return;
+      let outward = Infinity;
+      let inward = Infinity;
+      for (let j = Math.floor(i - above); j < Math.ceil(i + 1 + below); j++) {
+        const c = runReach(backRows[j - j0], edge, side);
+        outward = Math.min(outward, c.outward);
+        inward = Math.min(inward, c.inward);
+      }
+      offset[k][i] = side * (edge - f.axisX);
+      far[k][i] = m.shellScale * outward - drift;
+      near[k][i] = m.shellScale * inward - drift;
+    });
+  }
+  const end = new Float64Array(n * 2);
+  const lift = new Float64Array(n * 4);
+  for (let r = 0; r < n; r++) {
+    const i0 = Math.max(0, Math.floor(top - ys[Math.max(0, r - 1)]));
+    const i1 = Math.min(count, Math.ceil(top - ys[Math.min(n - 1, r + 1)]));
+    sides.forEach((side, k) => {
+      let d = Infinity;
+      let allowFar = Infinity;
+      let allowNear = Infinity;
+      for (let i = i0; i < i1; i++) {
+        if (Number.isNaN(offset[k][i])) continue;
+        d = Math.min(d, offset[k][i]);
+        allowFar = Math.min(allowFar, far[k][i]);
+        allowNear = Math.min(allowNear, near[k][i]);
+      }
+      end[r * 2 + k] = d;
+      if (d === Infinity || d <= inner) return;
+      const x = f.axisX + side * d;
+      sides.forEach((s, j) => {
+        const allow = Math.min(
+          coreAt(x, ys[r], s),
+          s === side ? allowFar : allowNear
+        );
+        lift[(r * 2 + k) * 2 + j] = Math.max(0, allow - followAt(x, ys[r], s));
+      });
+    });
+  }
+  const rowRide = (r, k, j, d) => {
+    const v = lift[(r * 2 + k) * 2 + j];
+    return v === 0 ? 0 : v * Math.min(1, (d - inner) / (end[r * 2 + k] - inner));
+  };
+  return (x, y, s) => {
+    const d = Math.abs(x - f.axisX);
+    if (s === 0 || d <= inner) return 0;
+    const k = x < f.axisX ? 0 : 1;
+    const j = s < 0 ? 0 : 1;
+    const { r, t } = gridRow(ys, y, true);
+    return rowRide(r, k, j, d) * (1 - t) + rowRide(r + 1, k, j, d) * t;
+  };
+}
+function crownRide(m, cap, relAt) {
+  const f = m.frame;
+  const grid = m.hairFrontGrid;
+  if (grid === void 0) return void 0;
+  const { xs, ys } = grid;
+  const top = ys[0];
+  if (f.hairRuns("hair_front", top) === void 0 || f.hairRuns("hair_back", top) === void 0) {
+    return void 0;
+  }
+  const n = ys.length;
+  const count = Math.round(top - ys[n - 1]);
+  const hh = f.hh;
+  const face = faceField(m);
+  const { wr, blendAt } = renderedCrownBlend(m, ys);
+  const backRows = /* @__PURE__ */ new Map();
+  const backAt = (j) => {
+    let runs = backRows.get(j);
+    if (runs === void 0) {
+      runs = f.hairRuns("hair_back", top - j - 0.5);
+      backRows.set(j, runs);
+    }
+    return runs;
+  };
+  const faceAt = (j) => {
+    const y = top - j - 0.5;
+    return f.faceRuns(y) ?? (y > f.face.y0 && y < f.face.y1 ? [f.face.x0, f.face.x1] : []);
+  };
+  const passed = (i, dys) => [
+    Math.floor(i - Math.max(0, ...dys)),
+    Math.ceil(i + 1 - Math.min(0, ...dys))
+  ];
+  const rel = new Float64Array(n * xs.length * 2).fill(NaN);
+  const relOf = (r, c, k) => {
+    const at = (r * xs.length + c) * 2 + k;
+    if (Number.isNaN(rel[at])) rel[at] = relAt(xs[c], ys[r], k === 0 ? -1 : 1);
+    return rel[at];
+  };
+  const cellR = (x, y, k) => {
+    let c = 0;
+    while (c < xs.length - 2 && xs[c + 1] < x) c++;
+    const { r } = gridRow(ys, y);
+    return Math.max(
+      relOf(r, c, k),
+      relOf(r, c + 1, k),
+      relOf(r + 1, c, k),
+      relOf(r + 1, c + 1, k)
+    );
+  };
+  const someAngle = (pairs) => {
+    let lo = 0;
+    let hi = 1;
+    for (const [c0, c1] of pairs) {
+      if (c1 === 0) {
+        if (c0 <= 0) return false;
+      } else if (c1 > 0) lo = Math.max(lo, -c0 / c1);
+      else hi = Math.min(hi, -c0 / c1);
+    }
+    return lo < hi;
+  };
+  const slack = [-1, 1].map(() => new Float64Array(count).fill(NaN));
+  const slackAt = (i, k) => {
+    if (!Number.isNaN(slack[k][i])) return slack[k][i];
+    const y = top - i - 0.5;
+    const w = blendAt(y);
+    const nod = {
+      up: w * NOD.hairFront.up + (1 - w) * cap.up,
+      down: w * NOD.hairFront.down + (1 - w) * cap.down
+    };
+    const ays = [-30, 30];
+    const [b0, b1] = passed(
+      i,
+      ays.map((ay) => nodDy(nod, ay, hh) - nodDy(NOD.hairBack, ay, hh))
+    );
+    const band = [];
+    for (let j = b0; j < b1; j++) band.push(backAt(j));
+    const faces = [];
+    const [f0, f1] = passed(
+      i,
+      ays.map((ay) => nodDy(nod, ay, hh) - face(f.axisX, y, 0, ay)[1])
+    );
+    for (let j = f0; j < f1; j++)
+      faces.push({ y: top - j - 0.5, runs: faceAt(j) });
+    const front = f.hairRuns("hair_front", y);
+    [-1, 1].forEach((s, side) => {
+      let least = Infinity;
+      const far = outerEdge(front, f.axisX, s);
+      if (far !== void 0) {
+        const R = cellR(far, y, side);
+        const c = Math.min(...band.map((b) => runReach(b, far, s).outward));
+        if (R > 0) least = Math.min(least, m.shellScale * c / R);
+      }
+      for (let t = s > 0 ? 0 : 1; t < front.length; t += 2) {
+        const x = front[t];
+        const R = cellR(x, y, side);
+        if (R <= 0) continue;
+        let c = Math.min(
+          ...band.map((b) => runReach(b, x, s > 0 ? -1 : 1).inward)
+        );
+        const sh = (m.shellScale - 1) * (x - f.axisX);
+        const d0 = sh + s * m.hairBack;
+        const d1 = d0 + s * R;
+        const lo = Math.min(d0, d1);
+        const hi = Math.max(d0, d1);
+        const bares = faces.some(({ y: fy, runs }) => {
+          for (let r = 0; r < runs.length; r += 2) {
+            const e0 = runs[r];
+            const e1 = runs[r + 1];
+            const de0 = face(e0, fy, 30 * s, 0)[0];
+            const de1 = face(e1, fy, 30 * s, 0)[0];
+            if (someAngle([
+              [e1 - x, de1 - lo],
+              [x - e0, hi - de0]
+            ])) {
+              return true;
+            }
           }
-          return face.y1;
-        };
-        cutAt = (x) => {
-          const y = bottomOf(Math.abs(x - axisX));
-          return y >= face.y1 ? face.y1 : Math.max(face.y0, y - CUT_MARGIN);
-        };
+          return false;
+        });
+        if (bares) c = 0;
+        least = Math.min(least, m.shellScale * c / R);
       }
-    }
+      slack[side][i] = least - w;
+    });
+    return slack[k][i];
+  };
+  const extra = [0, 1].map((k) => {
+    const out = wr.slice();
+    for (let r = 0; r < n; r++) {
+      if (wr[r] >= 1) continue;
+      const i0 = Math.max(0, Math.floor(top - ys[Math.max(0, r - 1)]));
+      const i1 = Math.min(count, Math.ceil(top - ys[Math.min(n - 1, r + 1)]));
+      let least = Infinity;
+      for (let i = i0; i < i1; i++) least = Math.min(least, slackAt(i, k));
+      out[r] = wr[r] + clamp(least, 0, 1 - wr[r]);
+    }
+    for (let r = n - 2; r >= 0; r--) {
+      if (wr[r] < 1) out[r] = Math.max(wr[r], Math.min(out[r], out[r + 1]));
+    }
+    return out.map((v, r) => v - wr[r]);
+  });
+  return (y, s) => {
+    if (s === 0) return 0;
+    const e = extra[s < 0 ? 0 : 1];
+    const { r, t } = gridRow(ys, y, true);
+    return e[r] * (1 - t) + e[r + 1] * t;
+  };
+}
+function familyField(m, family) {
+  switch (family) {
+    case "face":
+      return faceField(m);
+    case "eye_L":
+    case "eye_R":
+      return eyeField(m, m.boxes[family]);
+    case "brow_L":
+    case "brow_R":
+      return browField(m, m.boxes[family]);
+    case "nose":
+      return noseField(m);
+    case "mouth":
+      return mouthField(m);
+    case "hair_front":
+      return hairFrontField(m);
+    case "hair_back":
+      return hairField(m, m.hairBack, NOD.hairBack);
+    case "body":
+      return () => [0, 0];
   }
-  const hh = HH_PER_EYE_TO_CHIN * Math.max(1, eyeY - chinY);
-  const headHalf = opts.headHalfWidth;
-  const hairShell = headHalf !== void 0;
-  let shellLeft = axisX - plateHalf;
-  let shellRight = axisX + plateHalf;
-  if (hairShell) {
-    if (opts.headEdges && opts.headEdges.left.length > 0 && opts.headEdges.right.length > 0) {
-      shellLeft = Math.min(...opts.headEdges.left.map((e) => e.x));
-      shellRight = Math.max(...opts.headEdges.right.map((e) => e.x)) + 1;
-    } else {
-      shellLeft = axisX - headHalf;
-      shellRight = axisX + headHalf;
+}
+
+// src/auto-rig/context.ts
+function sidePair(byRole, a, b) {
+  const la = byRole.get(a);
+  const lb = byRole.get(b);
+  if (la === void 0 || lb === void 0) return void 0;
+  const [lo, hi] = [
+    { role: a, box: boxOfLayer(la) },
+    { role: b, box: boxOfLayer(lb) }
+  ].sort((p, q) => cx(p.box) - cx(q.box));
+  return { left: lo, right: hi };
+}
+function sideIrises(byRole) {
+  const pair = sidePair(byRole, "iris_L", "iris_R");
+  return pair === void 0 ? {} : { left: pair.left.box, right: pair.right.box };
+}
+function solveContext(frame, byRole, options, hasNose) {
+  const box = (role) => boxOfLayer(byRole.get(role));
+  const row = (s, strand2, sideSign) => {
+    if (strand2 !== void 0) {
+      const lo = sideSign < 0 ? strand2.irisOuter : strand2.irisInner;
+      const hi = sideSign < 0 ? strand2.irisInner : strand2.irisOuter;
+      return { role: s.role, lo, hi, y: strand2.y };
     }
+    const inset = bw(s.box) > 4 ? 1 : 0;
+    return {
+      role: s.role,
+      lo: s.box.x0 + inset,
+      hi: s.box.x1 - inset,
+      y: cy(s.box)
+    };
+  };
+  const eyes = sidePair(byRole, "eye_L", "eye_R");
+  const irises = sidePair(byRole, "iris_L", "iris_R");
+  const pair = irises ?? eyes;
+  const strand = irises ? options.strandEdges : void 0;
+  const left = row(pair.left, strand?.left, -1);
+  const right = row(pair.right, strand?.right, 1);
+  let candidates;
+  const edges = options.headEdges;
+  if (frame.hairShell && edges && edges.left.length > 0 && edges.right.length > 0) {
+    candidates = {
+      left: edges.left.map((e) => ({ role: e.role, x: e.x })),
+      // A right edge names its outermost pixel column; the boundary is one on.
+      right: edges.right.map((e) => ({ role: e.role, x: e.x + 1 }))
+    };
+  } else if (frame.hairShell) {
+    candidates = {
+      left: [{ role: "hair_back", x: frame.shellLeft }],
+      right: [{ role: "hair_back", x: frame.shellRight }]
+    };
+  } else {
+    const w = frame.paintedHalfAt(frame.eyeY);
+    candidates = {
+      left: [{ role: "face", x: frame.axisX - w }],
+      right: [{ role: "face", x: frame.axisX + w }]
+    };
+  }
+  const restHalf = (Math.max(...candidates.right.map((c) => c.x)) - Math.min(...candidates.left.map((c) => c.x))) / 2;
+  const nose = byRole.get("nose");
+  let noseAt;
+  let noseBox;
+  if (hasNose && nose !== void 0) {
+    noseBox = nose.denseCore ? boxOfPixels(nose.denseCore, nose.canvasW, nose.canvasH) : boxOfLayer(nose);
+    noseAt = { x: cx(noseBox), y: cy(noseBox) };
   }
+  const mouthBox = byRole.has("mouth_open") ? unionBoxes([box("mouth"), box("mouth_open")]) : box("mouth");
+  const m = box("mouth");
   return {
-    canvasW,
-    canvasH,
-    face,
-    axisX,
-    eyeY,
-    mouthY,
-    chinY,
-    hh,
-    paintedHalfAt,
-    wMax,
-    headMax,
-    hasProfile: profile !== null,
-    neck,
-    ears,
-    cutAt,
-    cheekY: eyeY - 0.5 * (eyeY - chinY),
-    jawY: eyeY - 0.8 * (eyeY - chinY),
-    shellLeft,
-    shellRight,
-    hairShell,
-    holdBase: headHalf ?? plateHalf
+    frame,
+    left,
+    right,
+    candidates,
+    restHalf,
+    strand,
+    hasHairFront: byRole.has("hair_front"),
+    eyeBoxes: { left: eyes.left.box, right: eyes.right.box },
+    noseAt,
+    noseBox,
+    mouthAt: { x: cx(m), y: cy(m) },
+    mouthBox
+  };
+}
+function renderedLander(turn, parts, grids, from = /* @__PURE__ */ new Map()) {
+  const analytic = /* @__PURE__ */ new Map();
+  const landed = /* @__PURE__ */ new Map();
+  const field = (role) => {
+    const family = roleSpec(role).family;
+    let f = analytic.get(family);
+    if (f === void 0) analytic.set(family, f = familyField(turn, family));
+    return f;
+  };
+  return (role, x, y, ax) => {
+    const family = roleSpec(role).family;
+    const part = parts.find((p) => p.id === role);
+    const g = grids.get(family);
+    const warp = part?.warps?.find((w) => w.parameter === import_format3.StandardParameter.AngleX);
+    if (part === void 0 || part.mesh === void 0 || !g && !warp) {
+      return x + field(role)(x, y, ax, 0)[0];
+    }
+    const box = {
+      x0: part.transform.x - part.width / 2,
+      x1: part.transform.x + part.width / 2,
+      y0: part.transform.y - part.height / 2,
+      y1: part.transform.y + part.height / 2
+    };
+    const rest = meshPoints(part.mesh, box);
+    const key = `${role}@${ax}`;
+    let xs = landed.get(key);
+    if (xs === void 0) {
+      if (g) {
+        const offsets = keyformAt(g.keyforms, ax);
+        xs = rest.map(([px, py]) => land(g.lattice, offsets, px, py)[0]);
+      } else {
+        const k = warp.keyforms;
+        const offsets = blendStops(
+          k.map((kf) => kf.value),
+          k.map((kf) => kf.offsets),
+          ax
+        );
+        xs = rest.map(([px], i) => px + offsets[2 * i] * bw(box));
+      }
+      landed.set(key, xs);
+    }
+    const idx = part.mesh.indices;
+    for (let t = from.get(role) ?? 0; t < idx.length; t += 3) {
+      const [a, b, c] = [idx[t], idx[t + 1], idx[t + 2]];
+      const [ax0, ay0] = rest[a];
+      const [bx0, by0] = rest[b];
+      const [cx0, cy0] = rest[c];
+      const d = (by0 - cy0) * (ax0 - cx0) + (cx0 - bx0) * (ay0 - cy0);
+      if (Math.abs(d) < 1e-9) continue;
+      const u = ((by0 - cy0) * (x - cx0) + (cx0 - bx0) * (y - cy0)) / d;
+      const v = ((cy0 - ay0) * (x - cx0) + (ax0 - cx0) * (y - cy0)) / d;
+      const w = 1 - u - v;
+      if (u < -1e-6 || v < -1e-6 || w < -1e-6) continue;
+      return u * xs[a] + v * xs[b] + w * xs[c];
+    }
+    return x + field(role)(x, y, ax, 0)[0];
   };
 }
 
@@ -4021,14 +4406,18 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
   };
   const solveFrame = buildHeadFrame(layers, frameOptions);
   const ctx = solveContext(solveFrame, byRole, turnOptions, hasNose);
+  const boxes = Object.fromEntries(
+    ["eye_L", "eye_R", "brow_L", "brow_R"].filter(has).map((r) => [r, box(r)])
+  );
   const landmarks = {
-    boxes: Object.fromEntries(
-      ["eye_L", "eye_R", "brow_L", "brow_R"].filter(has).map((r) => [r, box(r)])
-    ),
+    boxes,
     noseAt: ctx.noseAt,
     noseTopY: ctx.noseBox?.y1,
     mouthAt: ctx.mouthAt,
-    hairTop: has("hair_front") ? box("hair_front").y1 : solveFrame.face.y1
+    hairTop: has("hair_front") ? box("hair_front").y1 : solveFrame.face.y1,
+    // The field reads the grid the mesh is built on (the rebuilt frame below
+    // differs only in the jaw's cut, which the grid does not read).
+    hairFrontGrid: has("hair_front") ? hairFrontGrid(box("hair_front"), solveFrame, boxes) : void 0
   };
   const build = (q) => buildTurn(solveFrame, landmarks, q);
   const fit = fitTurn(ctx, targets, style, build);
@@ -4050,7 +4439,8 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       parts.length,
       frame,
       byRole,
-      style
+      style,
+      landmarks.hairFrontGrid
     );
     if (built.region !== void 0) {
       regionOf = built.region;
@@ -4141,7 +4531,7 @@ function plateFields(turn, region, head) {
   const neck = neckField(turn);
   return (i) => region[i] === "ear" ? ear : region[i] === "neck" ? neck : head;
 }
-function buildPart(spec, b, order, frame, byRole, style) {
+function buildPart(spec, b, order, frame, byRole, style, frontGrid) {
   const box = (role) => boxOfLayer(byRole.get(role));
   const part = {
     id: spec.role,
@@ -4164,30 +4554,15 @@ function buildPart(spec, b, order, frame, byRole, style) {
     mesh = fm.mesh;
     region = fm.region;
     headStart = fm.headStart;
+  } else if (spec.role === "hair_front") {
+    mesh = columnMesh(b, frontGrid);
   } else if (spec.family !== "body") {
     const cells = MESH_CELLS[spec.role] ?? FEATURE_MESH_CELLS;
     const px = Math.min(cells.px, meshScale(spec.role, frame));
-    const cols = cellsFor(bw(b), px, cells.min, cells.max);
-    const rows = cellsFor(bh(b), px, cells.min, cells.max);
-    if (spec.role === "hair_front") {
-      const boxes = Object.fromEntries(
-        ["eye_L", "eye_R"].filter((r) => byRole.has(r)).map((r) => [r, box(r)])
-      );
-      const { inner, left, right } = hairFrontBends(frame, boxes);
-      mesh = columnMesh(
-        b,
-        [
-          frame.axisX - left,
-          frame.axisX - inner,
-          frame.axisX + inner,
-          frame.axisX + right
-        ],
-        cols,
-        rows
-      );
-    } else {
-      mesh = gridMesh(cols, rows);
-    }
+    mesh = gridMesh(
+      cellsFor(bw(b), px, cells.min, cells.max),
+      cellsFor(bh(b), px, cells.min, cells.max)
+    );
   }
   if (mesh !== void 0) part.mesh = mesh;
   const side = spec.role.endsWith("_L") ? "L" : "R";
@@ -4306,16 +4681,35 @@ function buildPart(spec, b, order, frame, byRole, style) {
     headStart
   };
 }
-function columnMesh(b, at, cols, rows) {
+function hairFrontGrid(b, frame, boxes) {
+  const cells = MESH_CELLS.hair_front;
+  const px = Math.min(cells.px, meshScale("hair_front", frame));
+  const cols = cellsFor(bw(b), px, cells.min, cells.max);
+  const rows = cellsFor(bh(b), px, cells.min, cells.max);
+  const { inner, left, right } = hairFrontBends(frame, boxes);
   const step = bw(b) / cols;
   const xs = Array.from({ length: cols + 1 }, (_, c) => b.x0 + c * step);
-  for (const x of at) {
+  for (const x of [
+    frame.axisX - left,
+    frame.axisX - inner,
+    frame.axisX + inner,
+    frame.axisX + right
+  ]) {
     if (x <= b.x0 + 0.25 || x >= b.x1 - 0.25) continue;
     const near = xs.findIndex((v) => Math.abs(v - x) < 0.3 * step);
     if (near > 0 && near < xs.length - 1) xs[near] = x;
     else if (near < 0) xs.push(x);
   }
   xs.sort((p, q) => p - q);
+  const ys = Array.from(
+    { length: rows + 1 },
+    (_, r) => b.y1 - bh(b) * r / rows
+  );
+  return { xs, ys };
+}
+function columnMesh(b, grid) {
+  const { xs } = grid;
+  const rows = grid.ys.length - 1;
   const vertices = [];
   const uvs = [];
   for (let r = 0; r <= rows; r++) {