@ikijs/editor 0.28.0 → 0.30.0

package/dist/index.js

@@ -1652,6 +1652,8 @@ var ROW_RUN_ROLES = /* @__PURE__ */ new Set([
   "face",
   "hair_front",
   "hair_back",
+  "hair_side_L",
+  "hair_side_R",
   "body",
   "arm_L",
   "arm_R",
@@ -2081,8 +2083,9 @@ function deriveProfile(v) {
     /** 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. */
+    /** The front hair (its bangs and its own side strands; a `hair_side_*` lock
+     *  takes it only down to its root, `hairSideField`) 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
@@ -2298,177 +2301,15 @@ function meshPoints(mesh, box) {
   return out;
 }
 
-// src/auto-rig/roles.ts
-var import_format3 = require("@ikijs/format");
-var LIP_ROLES = ["mouth_inner", "lip_lower", "lip_upper"];
-var isLipRole = (role) => LIP_ROLES.includes(role);
-var LIP_INSIDE_ROLES = ["mouth_tongue", "mouth_teeth"];
-var isLipInsideRole = (role) => LIP_INSIDE_ROLES.includes(role);
-var SHUT_BY = new Map([
-  ["eye_L", import_format3.StandardParameter.EyeOpenLeft],
-  ["lash_lower_L", import_format3.StandardParameter.EyeOpenLeft],
-  ["eye_R", import_format3.StandardParameter.EyeOpenRight],
-  ["lash_lower_R", import_format3.StandardParameter.EyeOpenRight],
-  ...[...LIP_ROLES, ...LIP_INSIDE_ROLES].map((id) => [
-    id,
-    import_format3.StandardParameter.MouthOpen
-  ])
-]);
-var ROLE_TABLE = [
-  { role: "hair_back", family: "hair_back" },
-  { role: "body", family: "body" },
-  { role: "arm_L", family: "arm", parts: ["elbow_L", "forearm_L", "arm_L"] },
-  { role: "arm_R", family: "arm", parts: ["elbow_R", "forearm_R", "arm_R"] },
-  { role: "face", family: "face", required: true },
-  { role: "blush_L", family: "face" },
-  { role: "blush_R", family: "face" },
-  { role: "nose", family: "nose" },
-  { role: "mouth", family: "mouth" },
-  { role: "mouth_open", family: "mouth" },
-  // The lip set, back to front: the interior, the tongue and the teeth clipped
-  // to it, the lower lip's skin, the upper lip and its line over both. It
-  // folds open instead of crossfading (`mouth.ts`), so it stands in for
-  // `mouth`, never beside it.
-  { role: "mouth_inner", family: "mouth" },
-  { role: "mouth_tongue", family: "mouth" },
-  { role: "mouth_teeth", family: "mouth" },
-  { role: "lip_lower", family: "mouth" },
-  { role: "lip_upper", family: "mouth" },
-  { role: "eye_L", family: "eye_L", required: true },
-  { role: "eye_R", family: "eye_R", required: true },
-  { role: "iris_L", family: "eye_L" },
-  { role: "iris_R", family: "eye_R" },
-  { role: "pupil_L", family: "eye_L" },
-  { role: "pupil_R", family: "eye_R" },
-  { role: "highlight_L", family: "eye_L" },
-  { role: "highlight_R", family: "eye_R" },
-  { role: "lash_lower_L", family: "eye_L" },
-  { role: "lash_lower_R", family: "eye_R" },
-  { role: "lash_L", family: "eye_L" },
-  { role: "lash_R", family: "eye_R" },
-  { role: "brow_L", family: "brow_L" },
-  { role: "brow_R", family: "brow_R" },
-  { role: "hair_front", family: "hair_front" },
-  // Drawn above the face and the hair: a raised hand passes them.
-  { role: "forearm_pose_L", family: "forearm_pose" },
-  { role: "forearm_pose_R", family: "forearm_pose" }
-];
-var REQUIRED_ROLES = ROLE_TABLE.filter(
-  (r) => r.required
-).map((r) => r.role);
-var SPEC_BY_ROLE = new Map(ROLE_TABLE.map((r, i) => [r.role, { ...r, i }]));
-function roleSpec(role) {
-  const spec = SPEC_BY_ROLE.get(role);
-  if (spec === void 0) throw new Error(`auto-rig: unknown role "${role}"`);
-  return spec;
-}
-function partIdsOfRole(role) {
-  return roleSpec(role).parts ?? [role];
-}
-var ROLE_BY_PART = new Map(
-  ROLE_TABLE.flatMap((r) => (r.parts ?? []).map((p) => [p, r.role]))
-);
-function roleOfPart(partId) {
-  return ROLE_BY_PART.get(partId) ?? partId;
-}
-var ALIASES = {
-  eyebrow_L: "brow_L",
-  eyebrow_R: "brow_R",
-  eye_white_L: "eye_L",
-  eye_white_R: "eye_R"
-};
-function roleOf(fileName) {
-  const role = fileName.replace(/\.[^.]+$/, "").toLowerCase().replace(/[-\s]+/g, "_").replace(/_([lr])$/, (_, s) => `_${s.toUpperCase()}`);
-  return ALIASES[role] ?? role;
-}
-function checkArmsHaveBody(roles) {
-  const has = new Set(roles);
-  if (has.has("body")) return;
-  const arm = ROLE_TABLE.find((r) => r.family === "arm" && has.has(r.role));
-  if (arm !== void 0) {
-    throw new Error(
-      `auto-rig: ${arm.role} needs a body layer (an arm hangs from the body's shoulder)`
-    );
-  }
-}
-function checkMouth(roles) {
-  const has = new Set(roles);
-  const present = LIP_ROLES.filter((r) => has.has(r));
-  const inside = LIP_INSIDE_ROLES.filter((r) => has.has(r));
-  if (inside.length > 0 && present.length === 0) {
-    throw new Error(
-      `auto-rig: ${inside[0]} needs the lip set ${LIP_ROLES.join(", ")} (it is cut from the interior and clipped to it)`
-    );
-  }
-  if (present.length === 0) {
-    if (!has.has("mouth")) {
-      throw new Error(
-        `auto-rig: missing required role mouth (or the lip set ${LIP_ROLES.join(", ")})`
-      );
-    }
-    return;
-  }
-  if (present.length < LIP_ROLES.length) {
-    throw new Error(
-      `auto-rig: the lip set is partial: missing ${LIP_ROLES.filter((r) => !has.has(r)).join(", ")}`
-    );
-  }
-  const mixed = ["mouth", "mouth_open"].filter((r) => has.has(r));
-  if (mixed.length > 0) {
-    throw new Error(
-      `auto-rig: the lip set cannot be mixed with ${mixed.join(", ")} (the lip set replaces the mouth drawings; use one or the other)`
-    );
-  }
-}
-function checkPosesHaveArms(roles) {
-  const has = new Set(roles);
-  for (const side of ["L", "R"]) {
-    if (has.has(`forearm_pose_${side}`) && !has.has(`arm_${side}`)) {
-      throw new Error(
-        `auto-rig: forearm_pose_${side} needs an arm_${side} layer (a pose forearm hangs from its arm's elbow)`
-      );
-    }
-  }
-}
-function parseLayerRoles(fileNames) {
-  const seen = /* @__PURE__ */ new Map();
-  const out = [];
-  for (const fileName of fileNames) {
-    const role = roleOf(fileName);
-    if (!SPEC_BY_ROLE.has(role)) {
-      throw new Error(
-        `auto-rig: "${fileName}" names no known role (expected one of ${ROLE_TABLE.map((r) => r.role).join(", ")})`
-      );
-    }
-    const prior = seen.get(role);
-    if (prior !== void 0) {
-      throw new Error(
-        `auto-rig: role "${role}" is named twice ("${prior}" and "${fileName}")`
-      );
-    }
-    seen.set(role, fileName);
-    out.push({ role, fileName });
-  }
-  const missing = REQUIRED_ROLES.filter((r) => !seen.has(r));
-  if (missing.length > 0) {
-    throw new Error(
-      `auto-rig: missing required role${missing.length > 1 ? "s" : ""} ${missing.join(", ")}`
-    );
-  }
-  checkMouth(seen.keys());
-  checkArmsHaveBody(seen.keys());
-  checkPosesHaveArms(seen.keys());
-  return out;
-}
-
 // src/auto-rig/mouth.ts
 var import_format5 = require("@ikijs/format");
 
 // src/auto-rig/drivers.ts
-var import_format4 = require("@ikijs/format");
+var import_format3 = require("@ikijs/format");
 var SWAY_RANGE = 20;
 var SWAY_CURVE = 1.4;
 var HAIR_HANG = 0.35;
+var LOCK_HANG_SPAN = 1;
 var Z_STOPS = [-30, 0, 30];
 function localWarp(parameter, mesh, box, values, f) {
   const pts = meshPoints(mesh, box);
@@ -2543,13 +2384,13 @@ function gazeBindings(irisW, share = 1) {
   const gy = AMPLITUDE.gazeY * irisW * share;
   return [
     {
-      parameter: import_format4.StandardParameter.EyeballX,
+      parameter: import_format3.StandardParameter.EyeballX,
       channel: "translateX",
       from: -round1(gx),
       to: round1(gx)
     },
     {
-      parameter: import_format4.StandardParameter.EyeballY,
+      parameter: import_format3.StandardParameter.EyeballY,
       channel: "translateY",
       from: -round1(gy),
       to: round1(gy)
@@ -2563,8 +2404,8 @@ function browReach(hh) {
   return AMPLITUDE.brow * hh;
 }
 function browBindings(side, reach) {
-  const y = side === "L" ? import_format4.StandardParameter.BrowLeftY : import_format4.StandardParameter.BrowRightY;
-  const a = side === "L" ? import_format4.StandardParameter.BrowLeftAngle : import_format4.StandardParameter.BrowRightAngle;
+  const y = side === "L" ? import_format3.StandardParameter.BrowLeftY : import_format3.StandardParameter.BrowRightY;
+  const a = side === "L" ? import_format3.StandardParameter.BrowLeftAngle : import_format3.StandardParameter.BrowRightAngle;
   return [
     {
       parameter: y,
@@ -2583,7 +2424,7 @@ var mouthFrameOf = (box) => ({
 });
 function mouthForm(mesh, box, frame = mouthFrameOf(box)) {
   const { c, half, amp: a } = frame;
-  return localWarp(import_format4.StandardParameter.MouthForm, mesh, box, [-1, 0, 1], ([x], v) => {
+  return localWarp(import_format3.StandardParameter.MouthForm, mesh, box, [-1, 0, 1], ([x], v) => {
     if (v === 0) return [0, 0];
     const u = (x - c) / half;
     const widen = v > 0 ? 0.05 : 0.03;
@@ -2593,7 +2434,7 @@ function mouthForm(mesh, box, frame = mouthFrameOf(box)) {
 function mouthOpenGrow(mesh, box) {
   const c = cx(box);
   return localWarp(
-    import_format4.StandardParameter.MouthOpen,
+    import_format3.StandardParameter.MouthOpen,
     mesh,
     box,
     [0, 1],
@@ -2602,25 +2443,38 @@ function mouthOpenGrow(mesh, box) {
 }
 function mouthWiden(mesh, box, frame = mouthFrameOf(box)) {
   const c = frame.c;
-  return localWarp(import_format4.StandardParameter.MouthOpen, mesh, box, [0, 1], ([x], v) => [
+  return localWarp(import_format3.StandardParameter.MouthOpen, mesh, box, [0, 1], ([x], v) => [
     v * (AMPLITUDE.mouthOpenWidth - 1) * (x - c),
     0
   ]);
 }
+function swayAt(b, y) {
+  return Math.min(1, Math.max(0, (b.y1 - y) / bh(b))) ** SWAY_CURVE;
+}
 function hairSway(param, mesh, box, amp) {
+  return localWarp(
+    param,
+    mesh,
+    box,
+    [-SWAY_RANGE, 0, SWAY_RANGE],
+    ([, y], v) => [v / SWAY_RANGE * amp * swayAt(box, y), 0]
+  );
+}
+function lockSway(param, mesh, box, amp, attach) {
   return localWarp(
     param,
     mesh,
     box,
     [-SWAY_RANGE, 0, SWAY_RANGE],
     ([, y], v) => {
-      const t = Math.max(0, (box.y1 - y) / bh(box));
-      return [v / SWAY_RANGE * amp * t ** SWAY_CURVE, 0];
+      const w = attach.weight(y);
+      const share = (1 - w) * swayAt(attach.box, y) + w * swayAt(box, y);
+      return [v / SWAY_RANGE * amp * share, 0];
     }
   );
 }
 function tiltHang(mesh, box, pivot, weight, deg = ROLL_DEG) {
-  return localWarp(import_format4.StandardParameter.AngleZ, mesh, box, Z_STOPS, ([x, y], v, i) => {
+  return localWarp(import_format3.StandardParameter.AngleZ, mesh, box, Z_STOPS, ([x, y], v, i) => {
     const g = weight(y, i);
     if (g === 0 || v === 0) return [0, 0];
     const a = -g * rollOf(v, deg);
@@ -2636,8 +2490,191 @@ function hairHangWeight(pivotY, bottom) {
   if (bottom >= pivotY) return () => 0;
   return (y) => HAIR_HANG * smoothstep(pivotY, bottom, y);
 }
+function lockHangWeight(pivotY, bottom, hh) {
+  return hairHangWeight(pivotY, Math.min(bottom, pivotY - LOCK_HANG_SPAN * hh));
+}
 var round1 = (v) => roundTo(v, 0.1);
 
+// src/auto-rig/roles.ts
+var import_format4 = require("@ikijs/format");
+var LIP_ROLES = ["mouth_inner", "lip_lower", "lip_upper"];
+var isLipRole = (role) => LIP_ROLES.includes(role);
+var LIP_INSIDE_ROLES = ["mouth_tongue", "mouth_teeth"];
+var isLipInsideRole = (role) => LIP_INSIDE_ROLES.includes(role);
+var SHUT_BY = new Map([
+  ["eye_L", import_format4.StandardParameter.EyeOpenLeft],
+  ["lash_lower_L", import_format4.StandardParameter.EyeOpenLeft],
+  ["eye_R", import_format4.StandardParameter.EyeOpenRight],
+  ["lash_lower_R", import_format4.StandardParameter.EyeOpenRight],
+  ...[...LIP_ROLES, ...LIP_INSIDE_ROLES].map((id) => [
+    id,
+    import_format4.StandardParameter.MouthOpen
+  ])
+]);
+var ROLE_TABLE = [
+  { role: "hair_back", family: "hair_back" },
+  { role: "body", family: "body" },
+  { role: "arm_L", family: "arm", parts: ["elbow_L", "forearm_L", "arm_L"] },
+  { role: "arm_R", family: "arm", parts: ["elbow_R", "forearm_R", "arm_R"] },
+  { role: "face", family: "face", required: true },
+  { role: "blush_L", family: "face" },
+  { role: "blush_R", family: "face" },
+  { role: "nose", family: "nose" },
+  { role: "mouth", family: "mouth" },
+  { role: "mouth_open", family: "mouth" },
+  // The lip set, back to front: the interior, the tongue and the teeth clipped
+  // to it, the lower lip's skin, the upper lip and its line over both. It
+  // folds open instead of crossfading (`mouth.ts`), so it stands in for
+  // `mouth`, never beside it.
+  { role: "mouth_inner", family: "mouth" },
+  { role: "mouth_tongue", family: "mouth" },
+  { role: "mouth_teeth", family: "mouth" },
+  { role: "lip_lower", family: "mouth" },
+  { role: "lip_upper", family: "mouth" },
+  { role: "eye_L", family: "eye_L", required: true },
+  { role: "eye_R", family: "eye_R", required: true },
+  { role: "iris_L", family: "eye_L" },
+  { role: "iris_R", family: "eye_R" },
+  { role: "pupil_L", family: "eye_L" },
+  { role: "pupil_R", family: "eye_R" },
+  { role: "highlight_L", family: "eye_L" },
+  { role: "highlight_R", family: "eye_R" },
+  { role: "lash_lower_L", family: "eye_L" },
+  { role: "lash_lower_R", family: "eye_R" },
+  { role: "lash_L", family: "eye_L" },
+  { role: "lash_R", family: "eye_R" },
+  { role: "brow_L", family: "brow_L" },
+  { role: "brow_R", family: "brow_R" },
+  // The front side locks: over the brows and lashes, under the bangs, which
+  // hide their roots.
+  { role: "hair_side_L", family: "hair_side" },
+  { role: "hair_side_R", family: "hair_side" },
+  { role: "hair_front", family: "hair_front" },
+  // Drawn above the face and the hair: a raised hand passes them.
+  { role: "forearm_pose_L", family: "forearm_pose" },
+  { role: "forearm_pose_R", family: "forearm_pose" }
+];
+var REQUIRED_ROLES = ROLE_TABLE.filter(
+  (r) => r.required
+).map((r) => r.role);
+var SPEC_BY_ROLE = new Map(ROLE_TABLE.map((r, i) => [r.role, { ...r, i }]));
+function roleSpec(role) {
+  const spec = SPEC_BY_ROLE.get(role);
+  if (spec === void 0) throw new Error(`auto-rig: unknown role "${role}"`);
+  return spec;
+}
+function partIdsOfRole(role) {
+  return roleSpec(role).parts ?? [role];
+}
+var ROLE_BY_PART = new Map(
+  ROLE_TABLE.flatMap((r) => (r.parts ?? []).map((p) => [p, r.role]))
+);
+function roleOfPart(partId) {
+  return ROLE_BY_PART.get(partId) ?? partId;
+}
+var ALIASES = {
+  eyebrow_L: "brow_L",
+  eyebrow_R: "brow_R",
+  eye_white_L: "eye_L",
+  eye_white_R: "eye_R"
+};
+function roleOf(fileName) {
+  const role = fileName.replace(/\.[^.]+$/, "").toLowerCase().replace(/[-\s]+/g, "_").replace(/_([lr])$/, (_, s) => `_${s.toUpperCase()}`);
+  return ALIASES[role] ?? role;
+}
+function checkArmsHaveBody(roles) {
+  const has = new Set(roles);
+  if (has.has("body")) return;
+  const arm = ROLE_TABLE.find((r) => r.family === "arm" && has.has(r.role));
+  if (arm !== void 0) {
+    throw new Error(
+      `auto-rig: ${arm.role} needs a body layer (an arm hangs from the body's shoulder)`
+    );
+  }
+}
+function checkSidesHaveFront(roles) {
+  const has = new Set(roles);
+  if (has.has("hair_front")) return;
+  const side = ROLE_TABLE.find(
+    (r) => r.family === "hair_side" && has.has(r.role)
+  );
+  if (side !== void 0) {
+    throw new Error(
+      `auto-rig: ${side.role} needs a hair_front layer (a side lock's root hides under the bangs)`
+    );
+  }
+}
+function checkMouth(roles) {
+  const has = new Set(roles);
+  const present = LIP_ROLES.filter((r) => has.has(r));
+  const inside = LIP_INSIDE_ROLES.filter((r) => has.has(r));
+  if (inside.length > 0 && present.length === 0) {
+    throw new Error(
+      `auto-rig: ${inside[0]} needs the lip set ${LIP_ROLES.join(", ")} (it is cut from the interior and clipped to it)`
+    );
+  }
+  if (present.length === 0) {
+    if (!has.has("mouth")) {
+      throw new Error(
+        `auto-rig: missing required role mouth (or the lip set ${LIP_ROLES.join(", ")})`
+      );
+    }
+    return;
+  }
+  if (present.length < LIP_ROLES.length) {
+    throw new Error(
+      `auto-rig: the lip set is partial: missing ${LIP_ROLES.filter((r) => !has.has(r)).join(", ")}`
+    );
+  }
+  const mixed = ["mouth", "mouth_open"].filter((r) => has.has(r));
+  if (mixed.length > 0) {
+    throw new Error(
+      `auto-rig: the lip set cannot be mixed with ${mixed.join(", ")} (the lip set replaces the mouth drawings; use one or the other)`
+    );
+  }
+}
+function checkPosesHaveArms(roles) {
+  const has = new Set(roles);
+  for (const side of ["L", "R"]) {
+    if (has.has(`forearm_pose_${side}`) && !has.has(`arm_${side}`)) {
+      throw new Error(
+        `auto-rig: forearm_pose_${side} needs an arm_${side} layer (a pose forearm hangs from its arm's elbow)`
+      );
+    }
+  }
+}
+function parseLayerRoles(fileNames) {
+  const seen = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const fileName of fileNames) {
+    const role = roleOf(fileName);
+    if (!SPEC_BY_ROLE.has(role)) {
+      throw new Error(
+        `auto-rig: "${fileName}" names no known role (expected one of ${ROLE_TABLE.map((r) => r.role).join(", ")})`
+      );
+    }
+    const prior = seen.get(role);
+    if (prior !== void 0) {
+      throw new Error(
+        `auto-rig: role "${role}" is named twice ("${prior}" and "${fileName}")`
+      );
+    }
+    seen.set(role, fileName);
+    out.push({ role, fileName });
+  }
+  const missing = REQUIRED_ROLES.filter((r) => !seen.has(r));
+  if (missing.length > 0) {
+    throw new Error(
+      `auto-rig: missing required role${missing.length > 1 ? "s" : ""} ${missing.join(", ")}`
+    );
+  }
+  checkMouth(seen.keys());
+  checkArmsHaveBody(seen.keys());
+  checkPosesHaveArms(seen.keys());
+  checkSidesHaveFront(seen.keys());
+  return out;
+}
+
 // src/auto-rig/mouth.ts
 var UPPER_SHARE = 0.4;
 var CLOSED_SAG_MAX = 0.1;
@@ -3033,6 +3070,7 @@ function buildHeadFrame(layers, opts) {
   let paintedHalfAt = () => plateHalf;
   let neck;
   let ears;
+  let headHalfAt = (y) => paintedHalfAt(y);
   let headMax = plateHalf;
   let chinY = face.y0;
   let cutAt = () => face.y0 - 1;
@@ -3051,6 +3089,12 @@ function buildHeadFrame(layers, opts) {
       const t = clamp(r - i, 0, 1);
       return prof[i] + (prof[j] - prof[i]) * t;
     };
+    const readRows = (rows) => (y) => {
+      const r = canvasH / 2 - y - faceLayer.bbox.y - 0.5;
+      const i = clamp(Math.floor(r), 0, rows.length - 1);
+      const j = Math.min(i + 1, rows.length - 1);
+      return rows[i] + (rows[j] - rows[i]) * clamp(r - i, 0, 1);
+    };
     const rawRows = raw;
     const earless = (chin) => {
       const rowOf = (y) => Math.round(canvasH / 2 - y - faceLayer.bbox.y - 0.5);
@@ -3151,6 +3195,7 @@ function buildHeadFrame(layers, opts) {
         canvasH / 2 - nk.topY - faceLayer.bbox.y - 0.5
       );
       const head = earless(chinY);
+      headHalfAt = readRows(head);
       headMax = Math.max(...head);
       const outlineAt = (d) => {
         for (let r = neckRow; r >= 0; r--) {
@@ -3193,6 +3238,7 @@ function buildHeadFrame(layers, opts) {
       };
     } else {
       const head = earless(chinY);
+      headHalfAt = readRows(head);
       headMax = Math.max(...head);
       if (ears !== void 0) {
         const bottomOf = (d) => {
@@ -3240,6 +3286,7 @@ function buildHeadFrame(layers, opts) {
     chinY,
     hh,
     paintedHalfAt,
+    headHalfAt,
     wMax,
     headMax,
     hasProfile: profile !== null,
@@ -3257,6 +3304,96 @@ function buildHeadFrame(layers, opts) {
   };
 }
 
+// src/auto-rig/hair-side-room.ts
+var round3 = (v) => Math.round(v * 1e3) / 1e3;
+var signed = (v) => round3(v) + 0;
+function headEdge(ctx, land2, y, side, ax) {
+  const { frame } = ctx;
+  return land2("face", frame.axisX + side * frame.headHalfAt(y), y, ax);
+}
+var LOCKS = ["hair_side_L", "hair_side_R"];
+function hairSideRoom(ctx, land2, boxes) {
+  const out = {};
+  for (const role of LOCKS) {
+    const box = boxes[role];
+    if (box === void 0) continue;
+    const side = (box.x0 + box.x1) / 2 < ctx.frame.axisX ? -1 : 1;
+    const key = side < 0 ? "left" : "right";
+    if (out[key] !== void 0) continue;
+    out[key] = lockRoom(ctx, land2, boxes, role, box, side);
+  }
+  return out.left || out.right ? out : void 0;
+}
+function lockRoom(ctx, land2, boxes, role, box, side) {
+  const { frame } = ctx;
+  if (frame.hairRuns(role, box.y1 - 0.5) === void 0) {
+    return { role, unavailable: "no rowRuns" };
+  }
+  const room = { role };
+  const stops = farStops(side);
+  let cover;
+  for (let i = 0; i < Math.ceil(box.y1 - box.y0); i++) {
+    const y2 = box.y1 - i - 0.5;
+    if (y2 < frame.face.y0 || y2 > frame.face.y1) continue;
+    const outer2 = outerEdge(frame.hairRuns(role, y2) ?? [], frame.axisX, side);
+    if (outer2 === void 0) continue;
+    const rest = side * (outer2 - frame.axisX) - frame.headHalfAt(y2);
+    if (rest < 0) continue;
+    for (const ax of stops) {
+      const px = side * (land2(role, outer2, y2, ax) - headEdge(ctx, land2, y2, side, ax));
+      if (cover === void 0 || px < cover.px)
+        cover = { deg: ax, px, y: y2, rest };
+    }
+  }
+  if (cover !== void 0) {
+    room.cover = {
+      deg: cover.deg,
+      px: signed(cover.px),
+      y: round3(cover.y),
+      rest: signed(cover.rest)
+    };
+  }
+  const eye = side < 0 ? ctx.eyeBoxes.left : ctx.eyeBoxes.right;
+  const eyeRole = (side < 0 ? ctx.left : ctx.right).role.replace(
+    /^iris_/,
+    "eye_"
+  );
+  const y = cy(eye);
+  const runs = frame.hairRuns(role, y) ?? [];
+  const outer = outerEdge(runs, frame.axisX, side);
+  if (outer === void 0) return room;
+  const inner = outer - side * runReach(runs, outer, side).inward;
+  const lashRole = eyeRole.replace(/^eye_/, "lash_");
+  const lash = boxes[lashRole];
+  let tail;
+  for (const ax of stops) {
+    const lock = land2(role, inner, y, ax);
+    const corner = land2(eyeRole, side < 0 ? eye.x0 : eye.x1, y, ax);
+    const eyeToLock = side * (lock - corner);
+    if (tail !== void 0 && eyeToLock >= tail.eyeToLock) continue;
+    tail = {
+      deg: ax,
+      eyeToLock,
+      eyeToPlate: side * (headEdge(ctx, land2, y, side, ax) - corner)
+    };
+    if (lash !== void 0) {
+      const tip = land2(lashRole, side < 0 ? lash.x0 : lash.x1, y, ax);
+      tail.lashToLock = side * (lock - tip);
+    }
+  }
+  if (tail !== void 0) {
+    room.tail = {
+      deg: tail.deg,
+      eyeToLock: signed(tail.eyeToLock),
+      ...tail.lashToLock !== void 0 && {
+        lashToLock: signed(tail.lashToLock)
+      },
+      eyeToPlate: signed(tail.eyeToPlate)
+    };
+  }
+  return room;
+}
+
 // src/auto-rig/fields.ts
 var NOSE_TILT_DEG = 6;
 function nodDy(v, ay, hh) {
@@ -3458,12 +3595,12 @@ function hairFrontBends(frame, boxes) {
 }
 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 capTop = m.hairFrontGrid?.ys.find((y) => y <= f.face.y1) ?? f.face.y1;
   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) => {
@@ -3496,22 +3633,60 @@ function hairFrontField(m) {
   );
   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);
+    const b = ride.blend(x, 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 * boundOf(x, y, s) + a * (m.shellScale - 1) * (x - f.axisX);
+    const rx = s * a * boundOf(x, Math.min(y, capTop), 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)];
+    return [rx, by + crownBlend(m, y) * (ry - by)];
+  };
+}
+var SIDE_ROOT_BLEND = 0.2;
+function sideRootBlend(f, role, box) {
+  let rootEnd = box.y1 - (box.y1 - box.y0) / 4;
+  if (f.hairRuns(role, box.y1 - 0.5) !== void 0 && f.hairRuns("hair_front", box.y1 - 0.5) !== void 0) {
+    const shows = (y) => {
+      const lock = f.hairRuns(role, y);
+      const front = f.hairRuns("hair_front", y);
+      for (let k = 0; k < lock.length; k += 2) {
+        for (let px = lock[k]; px < lock[k + 1]; px++) {
+          if (!paints(front, px)) return true;
+        }
+      }
+      return false;
+    };
+    const rows = Array.from(
+      { length: Math.round(box.y1 - box.y0) },
+      (_, i2) => i2
+    );
+    const i = rows.findIndex((i2) => shows(box.y1 - i2 - 0.5));
+    rootEnd = i < 0 ? box.y0 : box.y1 - i;
+  }
+  const end = rootEnd - SIDE_ROOT_BLEND * f.hh;
+  return { rootEnd, weight: (y) => smoothstep(rootEnd, end, y) };
+}
+function hairSideField(m) {
+  const front = hairFrontField(m);
+  const face = faceField(m);
+  const locks = ["hair_side_L", "hair_side_R"].flatMap((role) => {
+    const box = m.boxes[role];
+    return box === void 0 ? [] : [{ box, ...sideRootBlend(m.frame, role, box) }];
+  });
+  return (x, y, ax, ay) => {
+    const lock = locks.find((l) => x >= l.box.x0 && x <= l.box.x1);
+    if (lock === void 0) return face(x, y, ax, ay);
+    const t = lock.weight(y);
+    if (t === 0) return front(x, y, ax, ay);
+    if (t === 1) return face(x, y, ax, ay);
+    const [fx, fy] = front(x, y, ax, ay);
+    const [gx, gy] = face(x, y, ax, ay);
+    return [fx * (1 - t) + gx * t, fy * (1 - t) + gy * t];
   };
 }
 function crownBlend(m, y) {
@@ -3648,17 +3823,17 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
     sides.forEach((side, k) => {
       const edge = outerEdge(front, f.axisX, side);
       if (edge === void 0) return;
-      let outward = Infinity;
+      let outward2 = 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);
+        outward2 = Math.min(outward2, c.outward);
         inward = Math.min(inward, c.inward);
       }
       offset[k][i] = side * (edge - f.axisX);
-      reachOut[k][i] = outward;
+      reachOut[k][i] = outward2;
       reachIn[k][i] = inward;
-      if (i < capRows && runReach(backRows[i - j0], edge, side).inward > 0)
+      if (i < capRows && y <= f.face.y1 && runReach(backRows[i - j0], edge, side).inward > 0)
         bound[k][i] = 1;
     });
   }
@@ -3668,12 +3843,12 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
     const [i0, i1] = rowWindow(ys, r, count);
     sides.forEach((side, k) => {
       let d = Infinity;
-      let outward = Infinity;
+      let outward2 = 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]);
-        outward = Math.min(outward, reachOut[k][i]);
+        outward2 = Math.min(outward2, reachOut[k][i]);
         inward = Math.min(inward, reachIn[k][i]);
       }
       end[r * 2 + k] = d;
@@ -3682,7 +3857,7 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
       sides.forEach((s, j) => {
         const allow = Math.min(
           coreAt(x, ys[r], s),
-          m.shellScale * (s === side ? outward : inward) - drift
+          m.shellScale * (s === side ? outward2 : inward) - drift
         );
         lift[(r * 2 + k) * 2 + j] = Math.max(0, allow - followAt(x, ys[r], s));
       });
@@ -3753,73 +3928,117 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
     return quarter.map((q) => scale * q);
   };
   const cuts = new Float64Array(n * 2 * nc);
-  const blend = new Float64Array(n * 2);
+  const blend = new Float64Array(n * 2 * nc);
+  const motion = new Array(n * 2);
+  const outward = sides.map((side) => {
+    const cols = xs.map((_, c) => c).filter((c) => side * (xs[c] - f.axisX) >= 0);
+    return side < 0 ? cols.reverse() : cols;
+  });
   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;
+    if (wr[r] < 1) continue;
     const edges = [];
+    const copied = r > 0 && wr[r - 1] < 1;
     const [i0, i1] = rowWindow(ys, r, capRows);
     for (let i = i0; i < i1; i++) {
+      const y = top - i - 0.5;
       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]
-        });
+        for (const at2 of [
+          readAt(r, x, y),
+          copied && y > ys[r] ? readAt(r - 1, x, y) : void 0
+        ]) {
+          if (at2 === void 0) continue;
+          edges.push({
+            side,
+            x,
+            at: at2,
+            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];
-        }
+      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;
+      const b = blend.subarray((r * 2 + j) * nc, (r * 2 + j + 1) * nc);
       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);
+        const { c, t } = gridCol(xs, e.at);
+        for (const [cc, weight] of [
+          [c, 1 - t],
+          [c + 1, t]
+        ]) {
+          if (weight <= 0) continue;
+          const rel = after[cc] + drift;
+          if (rel > hi) b[cc] = Math.max(b[cc], 1 - hi / rel);
+          else if (rel < lo) b[cc] = Math.max(b[cc], 1 - lo / rel);
+        }
       }
-      blend[r * 2 + j] = b;
+      motion[r * 2 + j] = after.map((v) => v + drift);
       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 (r <= last || wr[r] < 1)
-        blend[r * 2 + j] = Math.max(blend[r * 2 + j], blend[(r + 1) * 2 + j]);
-    }
+  for (let r = 0; r < n; r++) {
+    sides.forEach((s, j) => {
+      motion[r * 2 + j] ??= xs.map(
+        (x) => followAt(x, ys[r], s) + liftAt(x, ys[r], s) + drift
+      );
+    });
   }
+  const at = (r, j, c) => (r * 2 + j) * nc + c;
   let zero = last + 1;
   while (zero < n && ys[zero] > eyeTop) zero++;
   while (zero > last + 1 && zero < n && ys[zero] < irisTop - 0.5) zero--;
   const endY = zero < n ? ys[zero] : Math.min(Math.max(eyeTop, irisTop - 0.5), ys[n - 1] - 1);
-  for (let j = 0; j < 2 && last < n - 1; j++) {
-    for (let r = 1; r < zero; r++) {
-      for (let q = 0; q < r && q <= last; q++) {
-        if (wr[q] < 1) continue;
-        blend[r * 2 + j] = Math.max(
-          blend[r * 2 + j],
-          blend[q * 2 + j] * (ys[r] - endY) / (ys[q] - endY)
-        );
+  for (let pass = 0; pass < 8; pass++) {
+    const was = blend.slice();
+    for (let j = 0; j < 2; j++) {
+      for (let r = n - 2; r >= 0; r--) {
+        if (r > last && wr[r] >= 1) continue;
+        for (let c = 0; c < nc; c++)
+          blend[at(r, j, c)] = Math.max(
+            blend[at(r, j, c)],
+            blend[at(r + 1, j, c)]
+          );
       }
     }
+    for (let j = 0; j < 2 && last < n - 1; j++) {
+      for (let r = 1; r < zero; r++) {
+        for (let q = 0; q < r && q <= last; q++) {
+          if (wr[q] < 1) continue;
+          const k = (ys[r] - endY) / (ys[q] - endY);
+          for (let c = 0; c < nc; c++)
+            blend[at(r, j, c)] = Math.max(
+              blend[at(r, j, c)],
+              blend[at(q, j, c)] * k
+            );
+        }
+      }
+    }
+    for (let r = 0; r < n; r++) {
+      sides.forEach(
+        (s, j) => spreadBlend(
+          blend.subarray(at(r, j, 0), at(r, j, nc)),
+          motion[r * 2 + j],
+          xs,
+          outward,
+          s
+        )
+      );
+    }
+    if (blend.every((v, i) => v === was[i])) break;
   }
   const cutRow = (r, j, x) => r > last ? 0 : along(cuts.subarray((r * 2 + j) * nc, (r * 2 + j + 1) * nc), x);
   return {
@@ -3832,158 +4051,47 @@ function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
       const { r, t } = gridRow(ys, y, true);
       return cutRow(r, j, x) * (1 - t) + cutRow(r + 1, j, x) * t;
     },
-    blend: (y, s) => {
+    blend: (x, 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;
+      const row = (q) => along(blend.subarray(at(q, j, 0), at(q, j, nc)), x);
+      return row(r) * (1 - t) + row(r + 1) * 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) => {
-    const { c } = gridCol(xs, x);
-    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;
+function spreadBlend(b, a, xs, outward, s) {
+  const fit = (ci, co, g) => {
+    const quarter = Math.abs(xs[co] - xs[ci]) / 4;
+    const today = g * (a[co] - a[ci]);
+    const [lo, hi] = [
+      Math.min(today, 0) - quarter,
+      Math.max(today, 0) + quarter
+    ];
+    const ga = g * a[ci];
+    if (ga === 0) return;
+    const outer = g * (1 - b[co]) * a[co];
+    const [b0, b1] = [1 - (outer - hi) / ga, 1 - (outer - lo) / ga];
+    const least = Math.max(b[ci], Math.min(b0, b1));
+    if (least <= Math.min(1, Math.max(b0, b1))) b[ci] = least;
+    else if (Math.min(b0, b1) > 1) b[ci] = 1;
   };
-  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 false;
-        });
-        if (bares) c = 0;
-        least = Math.min(least, m.shellScale * c / R);
-      }
-      slack[side][i] = least - w;
+  for (const cols of outward) {
+    for (let i = 1; i < cols.length; i++)
+      b[cols[i]] = Math.max(b[cols[i]], b[cols[i - 1]]);
+  }
+  const [left, right] = outward.map((cols) => cols[0]);
+  const across = left !== void 0 && right !== void 0 && left !== right;
+  for (let pass = 0; pass < 2; pass++) {
+    outward.forEach((cols, k) => {
+      const g = (k === 0 ? -1 : 1) * s;
+      for (let i = cols.length - 1; i > 0; i--) fit(cols[i - 1], cols[i], g);
     });
-    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, 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]);
+    if (across) {
+      if (b[left] <= b[right]) fit(left, right, s);
+      else fit(right, left, -s);
     }
-    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) {
@@ -4001,6 +4109,8 @@ function familyField(m, family) {
       return mouthField(m);
     case "hair_front":
       return hairFrontField(m);
+    case "hair_side":
+      return hairSideField(m);
     case "hair_back":
       return hairField(m, m.hairBack, NOD.hairBack);
     case "body":
@@ -4157,16 +4267,16 @@ function strandOverlaps(ctx, land2, holdBase) {
     if (px <= 0) continue;
     out[key] = {
       deg,
-      px: round3(px),
-      hh: round3(px) / holdBase,
-      restPx: round3(restPx),
+      px: round32(px),
+      hh: round32(px) / holdBase,
+      restPx: round32(restPx),
       // A fringe spanning the face has no side to hold the iris clear of.
       held: strand.runFace !== null && px <= restPx + STRAND_SLACK
     };
   }
   return out.left || out.right ? out : void 0;
 }
-var round3 = (v) => Math.round(v * 1e3) / 1e3;
+var round32 = (v) => Math.round(v * 1e3) / 1e3;
 var STRAND_SLACK = 0.5;
 function bisect(f, lo, hi, it = 50) {
   for (let i = 0; i < it; i++) {
@@ -4381,7 +4491,7 @@ function turnReport(ctx, fit, rendered) {
   const plate = depth(m.face);
   const w = frame.paintedHalfAt(frame.eyeY);
   const report = {
-    radius: round3(w * w / (2 * Math.max(1e-3, eye - plate))),
+    radius: round32(w * w / (2 * Math.max(1e-3, eye - plate))),
     holdBase: hb,
     depths: {
       eye: round4(eye / hb),
@@ -4397,6 +4507,8 @@ function turnReport(ctx, fit, rendered) {
   };
   const overlap = strandOverlaps(ctx, rendered, hb);
   if (overlap !== void 0) report.strandOverlap = overlap;
+  const hairSide = hairSideRoom(ctx, rendered, m.boxes);
+  if (hairSide !== void 0) report.hairSide = hairSide;
   return report;
 }
 var round4 = (v) => Math.round(v * 1e4) / 1e4;
@@ -4552,7 +4664,7 @@ var RIG_PLAN_FIELDS = [
     fitBy: null,
     provisional: false,
     migratedFrom: "outlineFollow",
-    what: "the front hair's outer edge's share where it draws the head's outline (0: the outline holds, though where back hair paints behind it, it may ride further, as far as that back hair reaches; at hair.follow the side locks ride whole)"
+    what: "the front hair's outer edge's share where it draws the head's outline (0: the outline holds, though where back hair paints behind it, it may ride further, as far as that back hair reaches; at hair.follow the front hair's side strands ride whole)"
   },
   {
     path: "hair.sway",
@@ -5606,6 +5718,7 @@ function checkLayers(layers, canvas) {
   }
   checkArmsHaveBody(seen);
   checkPosesHaveArms(seen);
+  checkSidesHaveFront(seen);
 }
 function checkHeadEdges(edges, byRole) {
   if (edges === void 0) return;
@@ -6330,6 +6443,10 @@ var MESH_CELLS = {
   face: { px: 28, min: 4, max: 24 },
   // The front hair eases from riding the face to holding the outline.
   hair_front: { px: 32, min: 3, max: 24 },
+  // A side lock's rows come from `sideLockGrid`: even ones, plus the root
+  // band's (`sideRootBlend`), which a long lock's coarse cells would straddle.
+  hair_side_L: { px: 20, min: 3, max: 24 },
+  hair_side_R: { px: 20, min: 3, max: 24 },
   hair_back: { px: 56, min: 3, max: 18 }
 };
 var NECK_CELLS = { px: 20, min: 3, max: 12 };
@@ -6381,7 +6498,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", "iris_L", "iris_R", "brow_L", "brow_R"].filter(has).map((r) => [r, box(r)])
+    [
+      "eye_L",
+      "eye_R",
+      "iris_L",
+      "iris_R",
+      "brow_L",
+      "brow_R",
+      "hair_side_L",
+      "hair_side_R",
+      "lash_L",
+      "lash_R"
+    ].filter(has).map((r) => [r, box(r)])
   );
   const landmarks = {
     boxes,
@@ -6586,6 +6714,8 @@ function buildPart(spec, b, order, frame, byRole, plan, frontGrid, lips) {
     headStart = fm.headStart;
   } else if (spec.role === "hair_front") {
     mesh = columnMesh(b, frontGrid);
+  } else if (spec.role === "hair_side_L" || spec.role === "hair_side_R") {
+    mesh = columnMesh(b, sideLockGrid(b, frame, spec.role));
   } else if (lips !== void 0 && (isLipRole(spec.role) || isLipInsideRole(spec.role))) {
     ({ mesh, xs: knotXs } = mouthMesh(b, lips.knots));
   } else if (spec.family !== "body") {
@@ -6600,6 +6730,7 @@ function buildPart(spec, b, order, frame, byRole, plan, frontGrid, lips) {
   const side = spec.role.endsWith("_L") ? "L" : "R";
   const eyeOpen = side === "L" ? import_format12.StandardParameter.EyeOpenLeft : import_format12.StandardParameter.EyeOpenRight;
   const hh = frame.hh;
+  const swayAmp = plan.hair.sway * plan.profile.AMPLITUDE.sway * hh;
   switch (spec.role) {
     case "face":
       if (region?.some((r) => r === "neck")) {
@@ -6736,18 +6867,30 @@ function buildPart(spec, b, order, frame, byRole, plan, frontGrid, lips) {
     case "hair_front":
     case "hair_back":
       if (byRole.has("hair_front")) {
-        const amp = plan.hair.sway * plan.profile.AMPLITUDE.sway * hh;
         if (spec.role === "hair_front") {
           warps.push(
-            hairSway(import_format12.StandardParameter.HairSwayX, mesh, b, amp),
-            hairSway(import_format12.StandardParameter.HairSwayZ, mesh, b, amp)
+            hairSway(import_format12.StandardParameter.HairSwayX, mesh, b, swayAmp),
+            hairSway(import_format12.StandardParameter.HairSwayZ, mesh, b, swayAmp)
           );
         } else {
-          warps.push(hairSway(import_format12.StandardParameter.HairBackSway, mesh, b, amp));
+          warps.push(hairSway(import_format12.StandardParameter.HairBackSway, mesh, b, swayAmp));
         }
       }
       warps.push(tiltHang(mesh, b, pivot, hairHangWeight(frame.chinY, b.y0)));
       break;
+    case "hair_side_L":
+    case "hair_side_R": {
+      const attach = {
+        box: box("hair_front"),
+        weight: sideRootBlend(frame, spec.role, b).weight
+      };
+      warps.push(
+        lockSway(import_format12.StandardParameter.HairSwayX, mesh, b, swayAmp, attach),
+        lockSway(import_format12.StandardParameter.HairSwayZ, mesh, b, swayAmp, attach),
+        tiltHang(mesh, b, pivot, lockHangWeight(frame.chinY, b.y0, hh))
+      );
+      break;
+    }
   }
   if (warps.length > 0) part.warps = warps;
   if (bindings.length > 0) part.bindings = bindings;
@@ -6804,9 +6947,34 @@ function hairFrontGrid(b, frame, boxes) {
   }
   return { xs, ys };
 }
+var BLEND_ROWS = 3;
+function sideLockGrid(b, frame, role) {
+  const cells = MESH_CELLS[role];
+  const px = Math.min(cells.px, meshScale(role, frame));
+  const cols = cellsFor(bw(b), px, cells.min, cells.max);
+  const rows = cellsFor(bh(b), px, cells.min, cells.max);
+  const xs = Array.from(
+    { length: cols + 1 },
+    (_, c) => b.x0 + bw(b) * c / cols
+  );
+  const ys = Array.from(
+    { length: rows + 1 },
+    (_, r) => b.y1 - bh(b) * r / rows
+  );
+  const { rootEnd } = sideRootBlend(frame, role, b);
+  const end = rootEnd - SIDE_ROOT_BLEND * frame.hh;
+  for (let i = 0; i <= BLEND_ROWS + 1; i++) {
+    const y = rootEnd + (end - rootEnd) * i / (BLEND_ROWS + 1);
+    if (y > b.y0 + 0.25 && y < b.y1 - 0.25 && ys.every((v) => Math.abs(v - y) > 0.25))
+      ys.push(y);
+  }
+  return { xs, ys: ys.sort((p, q) => q - p) };
+}
 function meshScale(role, frame) {
   switch (role) {
     case "hair_front":
+    case "hair_side_L":
+    case "hair_side_R":
     case "hair_back":
       return Math.max(2, (frame.shellRight - frame.shellLeft) / 9);
     default: