@ikijs/editor 0.12.1 → 0.13.0

package/dist/index.js

@@ -1963,14 +1963,155 @@ function createDefaultWarpDeformer(model) {
   };
 }
 
+// src/auto-rig/profile.ts
+var PROFILE_VALUES = {
+  slide: 0.12,
+  lead: 0.1,
+  noseDepth: 2,
+  hairFollow: 1,
+  fore: 0.2,
+  backShare: 0.1,
+  earFar: 0.5,
+  nodDown: 0.18,
+  nodUp: 0.1,
+  nodLead: 0.06,
+  chinShare: 0.75,
+  rollDeg: 14,
+  gaze: 0.2,
+  blink: 0.6,
+  mouthOpen: 0.8,
+  mouthWiden: 1.2,
+  brow: 0.15,
+  breath: 0.03,
+  sway: 0.08
+};
+function deriveProfile(v) {
+  const farLead = v.lead * (1 - v.fore / 2);
+  const nearLead = v.lead * (1 + v.fore / 2);
+  const turn = {
+    /** The face plate's translation. */
+    face: v.slide,
+    /** The chin tip's lead over the plate. */
+    chinLead: v.lead,
+    /** The plate's width at full turn: eye and cheek rows, then the jaw. The
+     *  plate translates; it does not narrow. */
+    widthUpper: 1,
+    widthJaw: 1,
+    eyeFar: v.slide + farLead,
+    eyeNear: v.slide + nearLead,
+    /** Each eye's width at full turn, about its own centre. */
+    eyeFarScale: 1 - v.fore,
+    eyeNearScale: 1 + v.fore / 2,
+    browFar: v.slide + farLead,
+    browNear: v.slide + nearLead,
+    nose: v.slide + v.noseDepth * v.lead,
+    mouth: v.slide + v.lead,
+    mouthWidth: 1,
+    /** The mouth's far corner rises (its near end drops) by this much: it
+     *  stays level. */
+    mouthTiltDeg: 0,
+    /** The front hair (bangs and side locks) rides the face at this share of
+     *  its translation. */
+    hairFollow: v.hairFollow,
+    /** The head's outline at the eye row holds: where the 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). On the cap (the
+     *  rows above the eyes) it follows less where the turn would otherwise
+     *  carry it further outside its back hair than the nod alone does. */
+    outlineFollow: 0,
+    /** The back hair's slight counter-motion. */
+    hairBack: -v.backShare * v.slide,
+    /** The ears lag the plate: the far one's outer edge moves this share of
+     *  its slide; the near one rides the head. */
+    earFar: v.earFar,
+    earNear: 1,
+    /** The far ear's width at full turn, about its outer edge, where the head
+     *  leaves it room; less where it does not. */
+    earFarScale: 1 - v.fore
+  };
+  const mid = v.nodDown * (1 + v.chinShare) / 2;
+  const feature = (depth) => ({
+    up: -(v.nodUp + depth * v.nodLead),
+    down: mid + depth * v.nodLead
+  });
+  const nod = {
+    faceTop: { up: -v.nodUp, down: v.nodDown },
+    chin: { up: -v.nodUp, down: v.chinShare * v.nodDown },
+    eye: feature(1),
+    /** Eye height at the extreme, about the eye's centre: it holds. */
+    eyeHeight: { up: 1, down: 1 },
+    brow: feature(1),
+    nose: feature(v.noseDepth),
+    mouth: feature(1),
+    hairFront: { up: -v.hairFollow * v.nodUp, down: v.hairFollow * v.nodDown },
+    /** The front hair's cap top: half the plate's rise looking up; looking
+     *  down the plate's top, which the rig slides only as far as the back
+     *  hair covers the crown behind it. */
+    hairFrontTop: { up: -v.nodUp / 2, down: v.nodDown },
+    hairBack: { up: -v.backShare * v.nodUp, down: v.backShare * v.nodDown }
+  };
+  const amplitude = {
+    /** Iris travel, in iris widths. */
+    gazeX: v.gaze,
+    gazeY: v.gaze / 2,
+    /** How far the upper lid comes down, over the eye's height. */
+    blink: v.blink,
+    /** A single mouth drawing opens to this height over its rest width. */
+    mouthOpenHeight: v.mouthOpen,
+    /** The mouth widens this much open. */
+    mouthOpenWidth: v.mouthWiden,
+    /** Brow raise / lower, hh. */
+    brow: v.brow,
+    /** Breath lifts the shoulders and the head, hh. */
+    breathBody: v.breath,
+    breathHead: v.breath * 2 / 3,
+    /** Hair tip travel at full sway (±20), hh. */
+    sway: v.sway,
+    /** The neck under the face reaches this far above the jaw, hh — what the
+     *  chin uncovers as it slides off it: half again the chin's full-turn
+     *  slide, to the next 0.05. */
+    hiddenNeck: Math.ceil(30 * (v.slide + v.lead) - 1e-9) / 20
+  };
+  return { TURN: turn, NOD: nod, ROLL_DEG: v.rollDeg, AMPLITUDE: amplitude };
+}
+var { TURN, NOD, ROLL_DEG, AMPLITUDE } = deriveProfile(PROFILE_VALUES);
+var STYLE_KNOBS = [
+  "turn",
+  "featureLead",
+  "hairFollow",
+  "outlineFollow",
+  "blink",
+  "sway"
+];
+function resolveStyle(style, check) {
+  const s = style ?? {};
+  const get = (key, def, lo, hi) => s[key] === void 0 ? def : check(`style.${key}`, s[key], lo, hi);
+  return {
+    turn: get("turn", 1, 0, 3),
+    featureLead: get("featureLead", 1, 0, 3),
+    hairFollow: get("hairFollow", TURN.hairFollow, 0, 2),
+    outlineFollow: get("outlineFollow", TURN.outlineFollow, 0, 2),
+    blink: get("blink", AMPLITUDE.blink, 0.1, 1),
+    sway: get("sway", 1, 0, 5)
+  };
+}
+
 // src/auto-rig/types.ts
+var round2 = (v) => Math.round(v * 100) / 100;
 var TurnTargetError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "TurnTargetError";
   }
 };
-var DEFAULT_TURN_TARGETS = Object.freeze({ eyeShift: 0.22, farEyeRatio: 0.78, silhouetteRatio: 1 });
+var DEFAULT_TURN_TARGETS = Object.freeze({
+  eyeShift: round2((TURN.eyeFar + TURN.eyeNear) / 2 - TURN.hairBack),
+  farEyeRatio: round2(TURN.eyeFarScale / TURN.eyeNearScale),
+  silhouetteRatio: 1
+});
 
 // src/auto-rig/roles.ts
 var ROLE_TABLE = [
@@ -2427,110 +2568,6 @@ function land(l, offsets, x, y) {
   return [topX + (botX - topX) * t, topY + (botY - topY) * t];
 }
 
-// src/auto-rig/profile.ts
-var HH_PER_EYE_TO_CHIN = 1.017;
-var TURN = {
-  /** The face plate's translation (its cheek edges, 0.118 / 0.126). */
-  face: 0.118,
-  /** The chin tip's lead over the plate (it moves 0.194). */
-  chinLead: 0.076,
-  /** The plate's width at full turn: eye and cheek rows, then the jaw. */
-  widthUpper: 0.985,
-  widthJaw: 0.96,
-  eyeFar: 0.192,
-  eyeNear: 0.23,
-  /** Each eye's width at full turn, about its own centre. */
-  eyeFarScale: 0.85,
-  eyeNearScale: 1.085,
-  browFar: 0.213,
-  browNear: 0.243,
-  nose: 0.301,
-  mouth: 0.213,
-  mouthWidth: 0.975,
-  /** The mouth's far corner rises (its near end drops) by this much. */
-  mouthTiltDeg: 4.4,
-  /** The front hair (bangs and side locks) rides the face at this share of
-   *  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 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,
-  /** The ears lag the plate: the far one moves this share of its slide, the
-   *  near one this at its widest reach, its root riding the head (the
-   *  samples' parallax ratios, 0.44 and 0.87). */
-  earFar: 0.44,
-  earNear: 0.87
-};
-var NOD = {
-  faceTop: { up: -0.081, down: 0.178 },
-  chin: { up: -0.0875, down: 0.109 },
-  eye: { up: -0.167, down: 0.202 },
-  /** Eye height at the extreme, about the eye's centre. */
-  eyeHeight: { up: 0.994, down: 0.96 },
-  brow: { up: -0.167, down: 0.223 },
-  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;
-var AMPLITUDE = {
-  /** Iris travel, in iris widths (X 0.045 hh, Y 0.031 hh on the samples). */
-  gazeX: 0.17,
-  gazeY: 0.11,
-  /** How far the upper lid comes down, over the eye's height (Haru 0.30,
-   *  Mao 0.58, Hiyori 0.67). */
-  blink: 0.58,
-  /** A single mouth drawing opens to this height over its rest width. */
-  mouthOpenHeight: 0.77,
-  /** The mouth widens this much open. */
-  mouthOpenWidth: 1.15,
-  /** Brow raise / lower, hh. */
-  brow: 0.089,
-  /** Breath lifts the shoulders and the head, hh. */
-  breathBody: 0.025,
-  breathHead: 0.016,
-  /** Hair tip travel at full sway (±20), hh (the keyform ranges at ±1 have a
-   *  median of 0.05–0.06 hh). */
-  sway: 0.06,
-  /** The neck under the face reaches this far above the jaw, hh — what the
-   *  chin uncovers as it slides off it. */
-  hiddenNeck: 0.3
-};
-var STYLE_KNOBS = [
-  "turn",
-  "featureLead",
-  "hairFollow",
-  "outlineFollow",
-  "blink",
-  "sway"
-];
-function resolveStyle(style, check) {
-  const s = style ?? {};
-  const get = (key, def, lo, hi) => s[key] === void 0 ? def : check(`style.${key}`, s[key], lo, hi);
-  return {
-    turn: get("turn", 1, 0, 3),
-    featureLead: get("featureLead", 1, 0, 3),
-    hairFollow: get("hairFollow", TURN.hairFollow, 0, 2),
-    outlineFollow: get("outlineFollow", TURN.outlineFollow, 0, 2),
-    blink: get("blink", AMPLITUDE.blink, 0.1, 1),
-    sway: get("sway", 1, 0, 5)
-  };
-}
-
 // src/auto-rig/head.ts
 function outerEdge(runs, axisX, side) {
   if (runs.length === 0) return void 0;
@@ -2743,7 +2780,7 @@ function buildHeadFrame(layers, opts) {
         return face.y1;
       };
       const chin = chinY;
-      const shade = JAW_SHADE * HH_PER_EYE_TO_CHIN * Math.max(1, eyeY - chin);
+      const shade = JAW_SHADE * Math.max(1, eyeY - chin);
       const reach = opts.chinSlide === void 0 ? nk.waist : clamp(
         nk.waist - opts.chinSlide - CUT_MARGIN - (CUT_LOW + 1),
         0,
@@ -2792,7 +2829,7 @@ function buildHeadFrame(layers, opts) {
       }
     }
   }
-  const hh = HH_PER_EYE_TO_CHIN * Math.max(1, eyeY - chinY);
+  const hh = Math.max(1, eyeY - chinY);
   const headHalf = opts.headHalfWidth;
   const hairShell = headHalf !== void 0;
   let shellLeft = axisX - plateHalf;
@@ -2886,16 +2923,45 @@ function earField(m) {
     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);
+    const span = Math.max(1, ears.outer - attach);
+    if (sideOf(m, x, s) === "far") {
+      const rim2 = TURN.earFar * m.face;
+      const root2 = earRoot(m, face, y, s);
+      const lead = Math.max(
+        0,
+        Math.min((1 - m.earFarScale) * span, root2 - rim2)
+      );
+      let along = rim2 + lead * (ears.outer - d) / span;
+      if (d < attach) along = Math.min(along, s * face(x, y, 30 * s, 0)[0]);
+      return [s * a * along, dy];
+    }
     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));
+    const t = Math.min(1, (d - attach) / span);
     return [root + (rim - root) * t, dy];
   };
 }
+function earRoot(m, face, y, s) {
+  const f = m.frame;
+  return s * face(f.axisX + s * f.ears.attachAt(y), y, 30 * s, 0)[0];
+}
+function farEarCovered(m) {
+  const ears = m.frame.ears;
+  if (ears === void 0) return true;
+  const face = faceField(m);
+  const rim = TURN.earFar * m.face;
+  const y0 = ears.bottom - 2;
+  const y1 = ears.top + 2;
+  const n = Math.max(1, Math.ceil(y1 - y0));
+  for (let i = 0; i <= n; i++) {
+    const y = y0 + (y1 - y0) * i / n;
+    for (const s of [-1, 1]) if (earRoot(m, face, y, s) < rim) return false;
+  }
+  return true;
+}
 function chinSlide(m) {
   const f = m.frame;
   return Math.abs(faceField(m)(f.axisX, f.chinY, 30, 0)[0]);
@@ -3038,14 +3104,19 @@ function hairFrontField(m) {
     );
     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 ride = outerRide(m, inner, coreAt, followAt, eyeY + 1.5 * eyeH);
+  const followOf = (x, y, s) => followAt(x, y, s) + (ride === void 0 ? 0 : ride.lift(x, y, s));
   const drift = Math.abs(m.hairBack);
   const crown = crownRide(m, cap, (x, y, s) => followOf(x, y, s) + drift);
+  const boundOf = (x, y, s) => {
+    if (ride === void 0) return followOf(x, y, s);
+    const b = ride.blend(y, s);
+    return (1 - b) * (followOf(x, y, s) + ride.cut(x, y, s)) - b * 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 rx = s * a * boundOf(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);
@@ -3065,6 +3136,18 @@ function gridRow(ys, y, snap = false) {
   const r = Math.min(n - 2, Math.floor(v));
   return { r, t: v - r };
 }
+function gridCol(xs, x) {
+  let c = 0;
+  while (c < xs.length - 2 && xs[c + 1] < x) c++;
+  return { c, t: clamp((x - xs[c]) / (xs[c + 1] - xs[c]), 0, 1) };
+}
+function rowWindow(ys, r, limit) {
+  const n = ys.length;
+  return [
+    Math.max(0, Math.floor(ys[0] - ys[Math.max(0, r - 1)])),
+    Math.min(limit, Math.ceil(ys[0] - ys[Math.min(n - 1, r + 1)]))
+  ];
+}
 function renderedCrownBlend(m, ys) {
   const wr = ys.map((y) => crownBlend(m, y));
   return {
@@ -3140,10 +3223,11 @@ function paints(runs, px) {
   }
   return false;
 }
-function outerRide(m, inner, coreAt, followAt) {
+function outerRide(m, inner, coreAt, followAt, capLimit) {
   const f = m.frame;
-  const ys = m.hairFrontGrid?.ys;
-  if (ys === void 0) return void 0;
+  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;
@@ -3152,6 +3236,9 @@ function outerRide(m, inner, coreAt, followAt) {
   const sides = [-1, 1];
   const n = ys.length;
   const count = Math.round(top - ys[n - 1]);
+  let last = 0;
+  while (last + 1 < n && ys[last + 1] >= capLimit) last++;
+  const capRows = last === 0 ? 0 : Math.min(count, Math.floor(top - ys[last] - 0.5) + 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);
@@ -3160,8 +3247,9 @@ function outerRide(m, inner, coreAt, followAt) {
     (_, 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));
+  const reachOut = sides.map(() => new Float64Array(count));
+  const reachIn = sides.map(() => new Float64Array(count));
+  const bound = sides.map(() => new Uint8Array(count));
   for (let i = 0; i < count; i++) {
     const y = top - i - 0.5;
     const front = f.hairRuns("hair_front", y);
@@ -3176,24 +3264,25 @@ function outerRide(m, inner, coreAt, followAt) {
         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;
+      reachOut[k][i] = outward;
+      reachIn[k][i] = inward;
+      if (i < capRows && runReach(backRows[i - j0], edge, side).inward > 0)
+        bound[k][i] = 1;
     });
   }
   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)]));
+    const [i0, i1] = rowWindow(ys, r, count);
     sides.forEach((side, k) => {
       let d = Infinity;
-      let allowFar = Infinity;
-      let allowNear = Infinity;
+      let outward = Infinity;
+      let inward = 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]);
+        outward = Math.min(outward, reachOut[k][i]);
+        inward = Math.min(inward, reachIn[k][i]);
       }
       end[r * 2 + k] = d;
       if (d === Infinity || d <= inner) return;
@@ -3201,7 +3290,7 @@ function outerRide(m, inner, coreAt, followAt) {
       sides.forEach((s, j) => {
         const allow = Math.min(
           coreAt(x, ys[r], s),
-          s === side ? allowFar : allowNear
+          m.shellScale * (s === side ? outward : inward) - drift
         );
         lift[(r * 2 + k) * 2 + j] = Math.max(0, allow - followAt(x, ys[r], s));
       });
@@ -3211,7 +3300,7 @@ function outerRide(m, inner, coreAt, followAt) {
     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 liftAt = (x, y, s) => {
     const d = Math.abs(x - f.axisX);
     if (s === 0 || d <= inner) return 0;
     const k = x < f.axisX ? 0 : 1;
@@ -3219,6 +3308,130 @@ function outerRide(m, inner, coreAt, followAt) {
     const { r, t } = gridRow(ys, y, true);
     return rowRide(r, k, j, d) * (1 - t) + rowRide(r + 1, k, j, d) * t;
   };
+  const nc = xs.length;
+  const along = (v, x) => {
+    const { c, t } = gridCol(xs, x);
+    return v[c] + (v[c + 1] - v[c]) * t;
+  };
+  const readAt = (r, x, y) => {
+    const { c, t: fx } = gridCol(xs, x);
+    const dx = xs[c + 1] - xs[c];
+    if (r + 1 < n && y <= ys[r] && y >= ys[r + 1]) {
+      const fy = (ys[r] - y) / (ys[r] - ys[r + 1]);
+      if (fy >= 1) return void 0;
+      return fx <= fy ? xs[c] : xs[c] + (fx - fy) / (1 - fy) * dx;
+    }
+    if (r > 0 && y > ys[r] && y < ys[r - 1]) {
+      const fy = (ys[r - 1] - y) / (ys[r - 1] - ys[r]);
+      return fx <= fy ? xs[c] + fx / fy * dx : xs[c + 1];
+    }
+    return void 0;
+  };
+  const ahead = (e, s) => s === e.side ? e.outward : e.inward;
+  const behind = (e, s) => s === e.side ? e.inward : e.outward;
+  const capCut = (r, s, side, today, mine) => {
+    const reach = Math.max(...mine.map((e) => side * (e.x - f.axisX)));
+    const quarter = new Float64Array(nc);
+    const cols = xs.map((_, c) => c).filter((c) => (xs[c] < f.axisX ? -1 : 1) === side);
+    if (side < 0) cols.reverse();
+    let total = 0;
+    let x0 = f.axisX;
+    let d0 = s * followAt(f.axisX, ys[r], s);
+    let open = true;
+    for (const c of cols) {
+      if (open) {
+        const d = (m.shellScale - 1) * (xs[c] - f.axisX) + s * today[c];
+        const rest = side * (xs[c] - x0);
+        const full = rest + side * (d - d0);
+        total += Math.max(0, Math.min(full, rest)) / 4;
+        x0 = xs[c];
+        d0 = d;
+        open = side * (xs[c] - f.axisX) < reach;
+      }
+      quarter[c] = total;
+    }
+    let scale = 0;
+    for (const e of mine) {
+      const need = along(today, e.at) - (m.shellScale * ahead(e, s) - drift);
+      if (need <= 0) continue;
+      const q = along(quarter, e.at);
+      scale = Math.max(scale, q > 0 ? need / q : 1);
+    }
+    scale = Math.min(1, scale);
+    return quarter.map((q) => scale * q);
+  };
+  const cuts = new Float64Array(n * 2 * nc);
+  const blend = new Float64Array(n * 2);
+  const wr = ys.map((y) => crownBlend(m, y));
+  for (let r = 0; r <= last && capRows > 0; r++) {
+    const w = wr[r];
+    if (w <= 0) continue;
+    const edges = [];
+    const [i0, i1] = rowWindow(ys, r, capRows);
+    for (let i = i0; i < i1; i++) {
+      sides.forEach((side, k) => {
+        if (bound[k][i] === 0) return;
+        const x = f.axisX + side * offset[k][i];
+        const at = readAt(r, x, top - i - 0.5);
+        if (at === void 0) return;
+        edges.push({
+          side,
+          x,
+          at,
+          outward: reachOut[k][i],
+          inward: reachIn[k][i]
+        });
+      });
+    }
+    if (edges.length === 0) continue;
+    sides.forEach((s, j) => {
+      const today = xs.map((x) => followAt(x, ys[r], s) + liftAt(x, ys[r], s));
+      const after = today.slice();
+      if (w >= 1) {
+        for (const side of sides) {
+          const mine = edges.filter((e) => e.side === side);
+          if (mine.length === 0) continue;
+          const cut = capCut(r, s, side, today, mine);
+          for (let c = 0; c < nc; c++) after[c] -= cut[c];
+        }
+      }
+      let b = 0;
+      for (const e of edges) {
+        const rel = w * (along(after, e.at) + drift);
+        const hi = m.shellScale * ahead(e, s);
+        const lo = -m.shellScale * behind(e, s);
+        if (rel > hi) b = Math.max(b, 1 - hi / rel);
+        else if (rel < lo) b = Math.max(b, 1 - lo / rel);
+      }
+      blend[r * 2 + j] = b;
+      for (let c = 0; c < nc; c++)
+        cuts[(r * 2 + j) * nc + c] = after[c] - today[c];
+    });
+  }
+  for (let j = 0; j < 2; j++) {
+    for (let r = n - 2; r >= 0; r--) {
+      if (wr[r] < 1)
+        blend[r * 2 + j] = Math.max(blend[r * 2 + j], blend[(r + 1) * 2 + j]);
+    }
+  }
+  const cutRow = (r, j, x) => r > last ? 0 : along(cuts.subarray((r * 2 + j) * nc, (r * 2 + j + 1) * nc), x);
+  return {
+    lift: liftAt,
+    // Between vertex rows, as the render interpolates; a vertex reads its own
+    // row's alone.
+    cut: (x, y, s) => {
+      if (s === 0) return 0;
+      const j = s < 0 ? 0 : 1;
+      const { r, t } = gridRow(ys, y, true);
+      return cutRow(r, j, x) * (1 - t) + cutRow(r + 1, j, x) * t;
+    },
+    blend: (y, s) => {
+      if (s === 0) return 0;
+      const j = s < 0 ? 0 : 1;
+      const { r, t } = gridRow(ys, y, true);
+      return blend[r * 2 + j] * (1 - t) + blend[(r + 1) * 2 + j] * t;
+    }
+  };
 }
 function crownRide(m, cap, relAt) {
   const f = m.frame;
@@ -3258,8 +3471,7 @@ function crownRide(m, cap, relAt) {
     return rel[at];
   };
   const cellR = (x, y, k) => {
-    let c = 0;
-    while (c < xs.length - 2 && xs[c + 1] < x) c++;
+    const { c } = gridCol(xs, x);
     const { r } = gridRow(ys, y);
     return Math.max(
       relOf(r, c, k),
@@ -3349,8 +3561,7 @@ function crownRide(m, cap, relAt) {
     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)]));
+      const [i0, i1] = rowWindow(ys, r, count);
       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]);
@@ -4019,6 +4230,18 @@ function fitTurn(ctx, targets, style, build) {
     }
     p.shell = bisect((k) => at(k) - s, SHELL_RANGE[0], SHELL_RANGE[1]);
   }
+  const covered = (shell) => farEarCovered(build({ ...p, shell }));
+  if (!covered(p.shell) && covered(Math.max(1, p.shell))) {
+    let lo = p.shell;
+    let hi = Math.max(1, p.shell);
+    for (let i = 0; i < 50; i++) {
+      const mid = (lo + hi) / 2;
+      if (covered(mid)) hi = mid;
+      else lo = mid;
+    }
+    p.shell = hi;
+    clamped.push("silhouetteRatio");
+  }
   const hb = ctx.restHalf;
   const feature = (key, family, at, box) => {
     const base = build(p);
@@ -4177,6 +4400,7 @@ function buildTurn(frame, landmarks, q) {
     hairOuter: q.outline * face,
     hairBack: A * hh * TURN.hairBack,
     shellScale: q.shell,
+    earFarScale: 1 + A * (TURN.earFarScale - 1),
     ...landmarks
   };
 }