@ikijs/editor 0.24.1 → 0.25.1

package/dist/index.mjs

@@ -1476,8 +1476,8 @@ function foregroundSpan(mask, width, height, rowLo, rowHi) {
   }
   return { left, right };
 }
-function headHalfOf(span) {
-  return (span.right - span.left + 1) / 2;
+function headHalfOf(span2) {
+  return (span2.right - span2.left + 1) / 2;
 }
 var DARK_SHARE = 0.55;
 function jawRowsOf(rgba, canvasW, bbox, rowLeft, rowRight) {
@@ -1487,9 +1487,9 @@ function jawRowsOf(rgba, canvasW, bbox, rowLeft, rowRight) {
   let widest = bbox.y;
   let widestSpan = -1;
   for (let y = bbox.y; y < bbox.y + bbox.h; y++) {
-    const span = rowRight[y] - rowLeft[y];
-    if (span >= widestSpan) {
-      widestSpan = span;
+    const span2 = rowRight[y] - rowLeft[y];
+    if (span2 >= widestSpan) {
+      widestSpan = span2;
       widest = y;
     }
     for (let x = bbox.x; x < bbox.x + bbox.w; x++) {
@@ -1658,14 +1658,14 @@ function createLayerSetMeasurer(canvas) {
   }
   function finish() {
     const eyeRow = eyeBandRowOf(layerInputs);
-    const span = foregroundSpan(
+    const span2 = foregroundSpan(
       opaque,
       canvasW,
       canvasH,
       eyeRow - HEAD_BAND,
       eyeRow + HEAD_BAND
     );
-    const headHalfWidth = span.right > span.left ? headHalfOf(span) : void 0;
+    const headHalfWidth = span2.right > span2.left ? headHalfOf(span2) : void 0;
     const headHalfWidthApplied = headHalfWidth !== void 0 && headHalfWidth > facePlateHalfOf(layerInputs);
     let headEdges;
     if (headHalfWidthApplied) {
@@ -1693,9 +1693,9 @@ function createLayerSetMeasurer(canvas) {
         const centre = iris.bbox.x + iris.bbox.w / 2;
         const otherX = other.bbox.x + other.bbox.w / 2 - half;
         const c = side < 0 ? Math.ceil(centre) - 1 : Math.floor(centre);
-        const span2 = rowSpansByRole.find((s) => s.role === iris.role);
-        if (span2.rowRight[r] < span2.rowLeft[r]) return void 0;
-        const minRun = STRAND_MIN_RUN_FRACTION * (span2.rowRight[r] + 1 - span2.rowLeft[r]);
+        const span3 = rowSpansByRole.find((s) => s.role === iris.role);
+        if (span3.rowRight[r] < span3.rowLeft[r]) return void 0;
+        const minRun = STRAND_MIN_RUN_FRACTION * (span3.rowRight[r] + 1 - span3.rowLeft[r]);
         const strand = new Uint8Array(canvasW);
         const runs = r >= hairTop && r < hairTop + hairRuns.length ? hairRuns[r - hairTop] : [];
         for (let k = 0; k < runs.length; k += 2) {
@@ -1720,8 +1720,8 @@ function createLayerSetMeasurer(canvas) {
         while (strandAt(x)) x += side;
         return {
           y: canvasH / 2 - (r + 0.5),
-          irisOuter: (side < 0 ? span2.rowLeft[r] : span2.rowRight[r] + 1) - half,
-          irisInner: (side < 0 ? span2.rowRight[r] + 1 : span2.rowLeft[r]) - half,
+          irisOuter: (side < 0 ? span3.rowLeft[r] : span3.rowRight[r] + 1) - half,
+          irisInner: (side < 0 ? span3.rowRight[r] + 1 : span3.rowLeft[r]) - half,
           runOuter: outerBoundary(x - side),
           runFace
         };
@@ -2125,6 +2125,12 @@ var DEFAULT_TURN_TARGETS = Object.freeze({
   farEyeRatio: round2(TURN.eyeFarScale / TURN.eyeNearScale),
   silhouetteRatio: 1
 });
+var PatchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PatchError";
+  }
+};
 
 // src/auto-rig/arms.ts
 import {
@@ -2199,15 +2205,16 @@ function gridMesh(cols, rows) {
   return { vertices, uvs, indices };
 }
 function columnMesh(b, grid) {
-  const { xs } = grid;
-  const rows = grid.ys.length - 1;
+  const { xs, ys } = grid;
+  const rows = ys.length - 1;
   const vertices = [];
   const uvs = [];
   for (let r = 0; r <= rows; r++) {
+    const v = (ys[0] - ys[r]) / (ys[0] - ys[rows]);
     for (const x of xs) {
       const u = (x - b.x0) / bw(b);
-      vertices.push(roundTo(u - 0.5, 1e-5), roundTo(0.5 - r / rows, 1e-5));
-      uvs.push(roundTo(u, 1e-5), roundTo(r / rows, 1e-5));
+      vertices.push(roundTo(u - 0.5, 1e-5), roundTo(0.5 - v, 1e-5));
+      uvs.push(roundTo(u, 1e-5), roundTo(v, 1e-5));
     }
   }
   const n = xs.length;
@@ -2756,7 +2763,7 @@ var ARM_IDS = {
 };
 function endPivot(layer, end) {
   const { bbox, canvasW, canvasH, rowRuns } = layer;
-  const span = runSpan(layer);
+  const span2 = runSpan(layer);
   const from = (k) => end === "top" ? k : bbox.h - 1 - k;
   const painted = rowRuns?.flatMap((runs, k) => runs.length > 0 ? [k] : []) ?? [];
   const firstK = end === "top" ? painted[0] ?? 0 : painted.at(-1) ?? bbox.h - 1;
@@ -2764,13 +2771,13 @@ function endPivot(layer, end) {
   const hi = Math.max(lo, Math.floor(CAP_ROWS[1] * bbox.h));
   const widths = [];
   for (let k = lo; k <= hi; k++) {
-    const [s2, e2] = span(from(k));
+    const [s2, e2] = span2(from(k));
     widths.push(e2 - s2);
   }
   widths.sort((p, q) => p - q);
   const radius = widths[widths.length >> 1] / 2;
   const ks = end === "top" ? firstK + radius : firstK - radius;
-  const [s, e] = span(Math.round(ks));
+  const [s, e] = span2(Math.round(ks));
   return {
     point: {
       x: roundTo((s + e) / 2 - canvasW / 2, 0.01),
@@ -2795,9 +2802,9 @@ function runSpan(layer) {
 function armGeometry(layer, bodyAxisX) {
   const { bbox, canvasW, canvasH, rowRuns } = layer;
   const b = boxOfLayer(layer);
-  const span = runSpan(layer);
+  const span2 = runSpan(layer);
   const centreX = (k) => {
-    const [s2, e2] = span(k);
+    const [s2, e2] = span2(k);
     return (s2 + e2) / 2 - canvasW / 2;
   };
   const rowY = (k) => canvasH / 2 - (bbox.y + k + 0.5);
@@ -2811,7 +2818,7 @@ function armGeometry(layer, bodyAxisX) {
     );
   }
   const elbow = { x: roundTo(centreX(ke), 0.01), y: roundTo(rowY(ke), 0.01) };
-  const [s, e] = span(ke);
+  const [s, e] = span2(ke);
   const capRadius = Math.min(
     (e - s) / 2 + 1,
     elbow.x - b.x0,
@@ -2821,7 +2828,7 @@ function armGeometry(layer, bodyAxisX) {
   const inside = (x, y) => {
     const k = Math.floor(y) - bbox.y;
     if (k < 0 || k >= bbox.h) return false;
-    const [rs, re] = span(k);
+    const [rs, re] = span2(k);
     return rs < x && x < re;
   };
   const capRays = Array.from({ length: CAP_SEGMENTS + 1 }, (_, i) => {
@@ -3031,14 +3038,25 @@ function forearmPoseDeformer(role, arm) {
 
 // src/auto-rig/mouth.ts
 import {
-  StandardParameter as P5
+  StandardParameter as P6
 } from "@ikijs/format";
 
 // src/auto-rig/roles.ts
+import { StandardParameter as P5 } from "@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", P5.EyeOpenLeft],
+  ["lash_lower_L", P5.EyeOpenLeft],
+  ["eye_R", P5.EyeOpenRight],
+  ["lash_lower_R", P5.EyeOpenRight],
+  ...[...LIP_ROLES, ...LIP_INSIDE_ROLES].map((id) => [
+    id,
+    P5.MouthOpen
+  ])
+]);
 var ROLE_TABLE = [
   { role: "hair_back", family: "hair_back" },
   { role: "body", family: "body" },
@@ -3383,7 +3401,7 @@ function columnOfKnot(knot, opening) {
 function mouthFoldWarp(role, mesh, xs, box, opening) {
   const fold = mouthFold(role, opening);
   return localWarp(
-    P5.MouthOpen,
+    P6.MouthOpen,
     mesh,
     box,
     [0, 1],
@@ -3392,13 +3410,13 @@ function mouthFoldWarp(role, mesh, xs, box, opening) {
 }
 function mouthRestShift(byRole) {
   const rig = buildMouthRig(byRole);
-  const fields = /* @__PURE__ */ new Map();
+  const fields2 = /* @__PURE__ */ new Map();
   for (const role of ["lip_upper", "lip_lower"]) {
     const box = boxOfLayer(byRole.get(role));
     const { mesh, xs } = mouthMesh(box, rig.knots);
     const warp = mouthFoldWarp(role, mesh, xs, box, rig.opening);
     const offsets = warp.keyforms[0].offsets;
-    fields.set(role, {
+    fields2.set(role, {
       box,
       xs,
       rows: offsets.length / 2 / xs.length - 1,
@@ -3407,7 +3425,7 @@ function mouthRestShift(byRole) {
   }
   const { canvasW, canvasH } = byRole.get("lip_upper");
   return (role, col, row) => {
-    const { box, xs, rows, dy } = fields.get(role);
+    const { box, xs, rows, dy } = fields2.get(role);
     const x = col + 0.5 - canvasW / 2;
     const y = canvasH / 2 - (row + 0.5);
     if (x < box.x0 || x > box.x1 || y < box.y0 || y > box.y1) return void 0;
@@ -3498,36 +3516,36 @@ function mouthAnchor(byRole) {
 // src/auto-rig/generate.ts
 import {
   IKI_FORMAT_VERSION as IKI_FORMAT_VERSION2,
-  StandardParameter as P8,
+  StandardParameter as P10,
   parseIkiModel as parseIkiModel3
 } from "@ikijs/format";
 
 // src/auto-rig/animations.ts
 import {
-  StandardParameter as P6
+  StandardParameter as P7
 } from "@ikijs/format";
 function browsY(y) {
   return [
-    { parameter: P6.BrowLeftY, value: y, blend: "add" },
-    { parameter: P6.BrowRightY, value: y, blend: "add" }
+    { parameter: P7.BrowLeftY, value: y, blend: "add" },
+    { parameter: P7.BrowRightY, value: y, blend: "add" }
   ];
 }
 function browsTilt(innerDown) {
   return [
-    { parameter: P6.BrowLeftAngle, value: innerDown, blend: "add" },
-    { parameter: P6.BrowRightAngle, value: -innerDown, blend: "add" }
+    { parameter: P7.BrowLeftAngle, value: innerDown, blend: "add" },
+    { parameter: P7.BrowRightAngle, value: -innerDown, blend: "add" }
   ];
 }
 function cheek(value) {
-  return { parameter: P6.Cheek, value, blend: "add" };
+  return { parameter: P7.Cheek, value, blend: "add" };
 }
-var BROWS = [P6.BrowLeftY, P6.BrowRightY, P6.BrowLeftAngle, P6.BrowRightAngle];
+var BROWS = [P7.BrowLeftY, P7.BrowRightY, P7.BrowLeftAngle, P7.BrowRightAngle];
 var EXPRESSIONS = [
   {
     id: "smile",
     description: "Smiling and pleased: warm, friendly, content. For greetings, thanks, agreement and gentle happiness.",
     parameters: [
-      { parameter: P6.MouthForm, value: 1, blend: "add" },
+      { parameter: P7.MouthForm, value: 1, blend: "add" },
       ...browsY(0.25),
       cheek(0.4)
     ]
@@ -3536,10 +3554,10 @@ var EXPRESSIONS = [
     id: "laugh",
     description: "Laughing, eyes shut and mouth open: delighted, amused. For jokes, playfulness and big joy.",
     parameters: [
-      { parameter: P6.EyeOpenLeft, value: 0, blend: "multiply" },
-      { parameter: P6.EyeOpenRight, value: 0, blend: "multiply" },
-      { parameter: P6.MouthForm, value: 1, blend: "add" },
-      { parameter: P6.MouthOpen, value: 0.8, blend: "overwrite" },
+      { parameter: P7.EyeOpenLeft, value: 0, blend: "multiply" },
+      { parameter: P7.EyeOpenRight, value: 0, blend: "multiply" },
+      { parameter: P7.MouthForm, value: 1, blend: "add" },
+      { parameter: P7.MouthOpen, value: 0.8, blend: "overwrite" },
       ...browsY(0.4),
       cheek(0.65)
     ]
@@ -3551,7 +3569,7 @@ var EXPRESSIONS = [
     parameters: [
       ...browsY(-0.5),
       ...browsTilt(0.8),
-      { parameter: P6.MouthForm, value: -0.9, blend: "add" }
+      { parameter: P7.MouthForm, value: -0.9, blend: "add" }
     ]
   },
   {
@@ -3561,7 +3579,7 @@ var EXPRESSIONS = [
     parameters: [
       ...browsY(0.35),
       ...browsTilt(-0.8),
-      { parameter: P6.MouthForm, value: -0.8, blend: "add" }
+      { parameter: P7.MouthForm, value: -0.8, blend: "add" }
     ]
   },
   {
@@ -3569,18 +3587,18 @@ var EXPRESSIONS = [
     description: "Surprised, mouth dropped open: startled, amazed. For shock, sudden news or disbelief.",
     parameters: [
       ...browsY(0.8),
-      { parameter: P6.MouthOpen, value: 0.9, blend: "overwrite" }
+      { parameter: P7.MouthOpen, value: 0.9, blend: "overwrite" }
     ]
   },
   {
     id: "shy",
     description: "Shy or embarrassed: bashful, flustered. For being praised, teased or caught off guard.",
-    needs: [P6.Cheek],
+    needs: [P7.Cheek],
     parameters: [
       cheek(1),
       // Gaze down.
-      { parameter: P6.EyeballY, value: -0.65, blend: "add" },
-      { parameter: P6.MouthForm, value: 0.4, blend: "add" },
+      { parameter: P7.EyeballY, value: -0.65, blend: "add" },
+      { parameter: P7.MouthForm, value: 0.4, blend: "add" },
       ...browsTilt(-0.25)
     ]
   }
@@ -3600,7 +3618,7 @@ var HEAD_MOTIONS = {
       duration: 1,
       curves: [
         {
-          parameter: P6.AngleY,
+          parameter: P7.AngleY,
           keys: [
             [0, 0],
             [0.3, -18],
@@ -3621,7 +3639,7 @@ var HEAD_MOTIONS = {
       fadeIn: 0.15,
       curves: [
         {
-          parameter: P6.AngleX,
+          parameter: P7.AngleX,
           keys: [
             [0, 0],
             [0.2, -18],
@@ -3640,7 +3658,7 @@ var HEAD_MOTIONS = {
       duration: 1.4,
       curves: [
         {
-          parameter: P6.AngleZ,
+          parameter: P7.AngleZ,
           keys: [
             [0, 0],
             [0.35, 20],
@@ -3661,7 +3679,7 @@ var WAVE = {
       fadeOut: 0.15,
       curves: [
         {
-          parameter: P6.ArmPoseRight,
+          parameter: P7.ArmPoseRight,
           interpolation: "linear",
           keys: [
             [0, 0],
@@ -3671,7 +3689,7 @@ var WAVE = {
           ]
         },
         {
-          parameter: P6.ArmRight,
+          parameter: P7.ArmRight,
           keys: [
             [0, 0],
             [0.4, 10],
@@ -3680,7 +3698,7 @@ var WAVE = {
           ]
         },
         {
-          parameter: P6.ArmPoseAngleRight,
+          parameter: P7.ArmPoseAngleRight,
           keys: [
             [0, 0],
             [0.5, 0],
@@ -3696,7 +3714,7 @@ var WAVE = {
   ]
 };
 function defaultMotions(declared) {
-  const waves = [P6.ArmRight, P6.ArmPoseRight, P6.ArmPoseAngleRight].every(
+  const waves = [P7.ArmRight, P7.ArmPoseRight, P7.ArmPoseAngleRight].every(
     (id) => declared.has(id)
   );
   return waves ? { ...HEAD_MOTIONS, ...WAVE } : HEAD_MOTIONS;
@@ -3932,7 +3950,7 @@ function checkStrandEdges(strand, irises, hair) {
 }
 
 // src/auto-rig/context.ts
-import { StandardParameter as P7 } from "@ikijs/format";
+import { StandardParameter as P8 } from "@ikijs/format";
 
 // src/auto-rig/head.ts
 function outerEdge(runs, axisX, side) {
@@ -4041,14 +4059,14 @@ function buildHeadFrame(layers, opts) {
     const rawRows = raw;
     const earless = (chin) => {
       const rowOf = (y) => Math.round(canvasH / 2 - y - faceLayer.bbox.y - 0.5);
-      const span = Math.max(1, eyeY - chin);
+      const span2 = Math.max(1, eyeY - chin);
       const found = findEars(
         rawRows,
         wMax,
         Math.round(0.2 * rawRows.length),
         Math.min(rawRows.length - 1, rowOf(chin)),
-        Math.round(0.1 * span),
-        Math.round(0.8 * span)
+        Math.round(0.1 * span2),
+        Math.round(0.8 * span2)
       );
       if (found === void 0) return profile;
       const { top, bottom } = found;
@@ -4082,16 +4100,16 @@ function buildHeadFrame(layers, opts) {
         }
       }
       if (neckRow >= 0 && n - neckRow >= 0.12 * n) {
-        let span = 0;
+        let span2 = 0;
         let waist = Infinity;
         for (let r = neckRow; r < n; r++) {
-          span = Math.max(span, profile[r]);
+          span2 = Math.max(span2, profile[r]);
           if (r < n - tail) waist = Math.min(waist, profile[r]);
         }
         neck = {
           topY: rowY(neckRow),
           half: profile[neckRow],
-          span,
+          span: span2,
           waist: Math.min(waist, profile[neckRow])
         };
       }
@@ -4291,22 +4309,22 @@ function earField(m) {
     const dy = face(x, y, 0, ay)[1];
     const d = Math.abs(x - f.axisX);
     const attach = ears.attachAt(y);
-    const span = Math.max(1, ears.outer - attach);
+    const span2 = 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)
+        Math.min((1 - m.earFarScale) * span2, root2 - rim2)
       );
-      let along = rim2 + lead * (ears.outer - d) / span;
+      let along = rim2 + lead * (ears.outer - d) / span2;
       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) / span);
+    const t = Math.min(1, (d - attach) / span2);
     return [root + (rim - root) * t, dy];
   };
 }
@@ -4470,7 +4488,17 @@ function hairFrontField(m) {
     );
     return core + (m.hairOuter - core) * out;
   };
-  const ride = outerRide(m, inner, coreAt, followAt, eyeY + 1.5 * eyeH);
+  const ride = outerRide(
+    m,
+    inner,
+    coreAt,
+    followAt,
+    eyeY + 1.5 * eyeH,
+    eyeY + eyeH / 2,
+    Math.max(
+      ...[m.boxes.iris_L, m.boxes.iris_R].map((b) => b?.y1 ?? -Infinity)
+    )
+  );
   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);
@@ -4497,9 +4525,12 @@ function crownBlend(m, 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);
+  const yc = clamp(y, ys[n - 1], ys[0]);
+  let r = 0;
+  while (r < n - 2 && ys[r + 1] >= yc) r++;
+  let v = r + (ys[r] - yc) / (ys[r] - ys[r + 1]);
   if (snap && Math.abs(v - Math.round(v)) < 1e-3) v = Math.round(v);
-  const r = Math.min(n - 2, Math.floor(v));
+  r = Math.min(n - 2, Math.floor(v));
   return { r, t: v - r };
 }
 function gridCol(xs, x) {
@@ -4589,7 +4620,7 @@ function paints(runs, px) {
   }
   return false;
 }
-function outerRide(m, inner, coreAt, followAt, capLimit) {
+function outerRide(m, inner, coreAt, followAt, capLimit, eyeTop, irisTop) {
   const f = m.frame;
   const grid = m.hairFrontGrid;
   if (grid === void 0) return void 0;
@@ -4776,10 +4807,25 @@ function outerRide(m, inner, coreAt, followAt, capLimit) {
   }
   for (let j = 0; j < 2; j++) {
     for (let r = n - 2; r >= 0; r--) {
-      if (wr[r] < 1)
+      if (r <= last || wr[r] < 1)
         blend[r * 2 + j] = Math.max(blend[r * 2 + j], blend[(r + 1) * 2 + j]);
     }
   }
+  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)
+        );
+      }
+    }
+  }
   const cutRow = (r, j, x) => r > last ? 0 : along(cuts.subarray((r * 2 + j) * nc, (r * 2 + j + 1) * nc), x);
   return {
     lift: liftAt,
@@ -5062,7 +5108,7 @@ function renderedLander(turn, parts, grids, from = /* @__PURE__ */ new Map()) {
     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 === P7.AngleX);
+    const warp = part?.warps?.find((w) => w.parameter === P8.AngleX);
     if (part === void 0 || part.mesh === void 0 || !g && !warp) {
       return x + field(role)(x, y, ax, 0)[0];
     }
@@ -5201,11 +5247,11 @@ function buildFaceMesh(frame, b, head, neckCells) {
   const indices = [];
   const neck = frame.neck;
   if (neck !== void 0) {
-    const span = neck.span + pad;
-    const nc = cellsFor(2 * span, neckCells.px, neckCells.min, neckCells.max);
+    const span2 = neck.span + pad;
+    const nc = cellsFor(2 * span2, neckCells.px, neckCells.min, neckCells.max);
     const xs2 = columns(
-      Math.max(b.x0, frame.axisX - span),
-      Math.min(b.x1, frame.axisX + span),
+      Math.max(b.x0, frame.axisX - span2),
+      Math.min(b.x1, frame.axisX + span2),
       nc
     );
     const sampleBelow = (x) => Math.max(
@@ -5341,6 +5387,11 @@ function buildFaceMesh(frame, b, head, neckCells) {
   return { mesh: { vertices, uvs, indices }, region, headStart };
 }
 
+// src/auto-rig/patches.ts
+import {
+  StandardParameter as P9
+} from "@ikijs/format";
+
 // src/auto-rig/solve.ts
 var RANGES = {
   // [lo, hi, lo exclusive]
@@ -5771,6 +5822,235 @@ function buildTurn(frame, landmarks, q) {
   };
 }
 
+// src/auto-rig/patches.ts
+var OP_KEYS = ["target", "at", "region", "by", "falloff", "why"];
+var REGION_KEYS = ["role", "x", "y"];
+var BY_KEYS = ["dx", "dy"];
+var ROLLS = /* @__PURE__ */ new Set([P9.AngleZ, P9.BodyAngleZ]);
+var REST_IS_ART = "rest is the drawn art, which no patch changes (change it with the layout or by regenerating the layer)";
+function applyPatches(patches, ctx) {
+  if (!Array.isArray(patches)) {
+    throw new PatchError(
+      `patches must be an array, got ${patches === null ? "null" : typeof patches}`
+    );
+  }
+  const sums = /* @__PURE__ */ new Map();
+  const reports = patches.map((op, i) => replay(op, i, ctx, sums));
+  for (const [offsets, s] of sums) {
+    s.terms.forEach((t, k) => {
+      if (t.length === 0) return;
+      const d = t.sort((a, b) => a - b).reduce((a, b) => a + b, 0);
+      offsets[k] = roundTo(offsets[k] + d / s.scale[k % 2], s.step);
+    });
+  }
+  return reports;
+}
+function replay(op, i, ctx, sums) {
+  const name = `patches[${i}]`;
+  const o = fields(name, op, OP_KEYS);
+  const target = text(`${name}.target`, o.target);
+  const at = numbers(`${name}.at`, o.at);
+  const region = fields(`${name}.region`, o.region, REGION_KEYS);
+  const role = text(`${name}.region.role`, region.role);
+  const x = span(`${name}.region.x`, region.x);
+  const y = span(`${name}.region.y`, region.y);
+  const by = fields(`${name}.by`, o.by, BY_KEYS);
+  const dx = finite2(`${name}.by.dx`, by.dx);
+  const dy = finite2(`${name}.by.dy`, by.dy);
+  const falloff = o.falloff === void 0 ? 0 : finite2(`${name}.falloff`, o.falloff, 0);
+  if (o.why !== void 0) text(`${name}.why`, o.why);
+  const box = ctx.boxOf(role);
+  if (box === void 0) {
+    const roles = [...new Set(ctx.parts.map((p) => roleOfPart(p.id)))].filter(
+      (r) => ctx.boxOf(r) !== void 0
+    );
+    throw new PatchError(
+      `${name}.region.role "${role}" is not a layer of this set (roles: ${roles.join(", ")})`
+    );
+  }
+  const stop = resolveStop(name, target, at, ctx);
+  const { points } = stop;
+  const weights = regionWeights(points, box, x, y, falloff * ctx.faceWidth);
+  const hit = weights.flatMap((w, k) => w > 0 ? [k] : []);
+  if (hit.length === 0) {
+    const fx = points.map(([px]) => (px - box.x0) / bw(box));
+    const fy = points.map(([, py]) => (box.y1 - py) / bh(box));
+    const range = (v) => `[${roundTo(Math.min(...v), 0.01)}, ${roundTo(Math.max(...v), 0.01)}]`;
+    throw new PatchError(
+      `${name}.region (falloff ${falloff}) catches none of ${target}'s ${points.length} points; at rest they span x ${range(fx)}, y ${range(fy)} of ${role}'s box`
+    );
+  }
+  let sum = sums.get(stop.offsets);
+  if (sum === void 0) {
+    sum = {
+      terms: stop.offsets.map(() => []),
+      scale: stop.scale,
+      step: stop.step
+    };
+    sums.set(stop.offsets, sum);
+  }
+  const ddx = dx * ctx.faceWidth;
+  const ddy = -dy * ctx.faceWidth;
+  for (const k of hit) {
+    sum.terms[2 * k].push(ddx * weights[k]);
+    sum.terms[2 * k + 1].push(ddy * weights[k]);
+  }
+  const maxW = Math.max(...hit.map((k) => weights[k]));
+  const report = {
+    index: i,
+    target,
+    at,
+    moved: hit.length,
+    of: points.length,
+    maxPx: roundTo(maxW * Math.hypot(dx, dy) * ctx.faceWidth, 0.1)
+  };
+  if (stop.stride !== void 0) {
+    const { stride } = stop;
+    const cols = hit.map((k) => k % stride);
+    const rows = hit.map((k) => Math.floor(k / stride));
+    report.cols = [Math.min(...cols), Math.max(...cols)];
+    report.rows = [Math.min(...rows), Math.max(...rows)];
+  }
+  return report;
+}
+function resolveStop(name, target, at, ctx) {
+  const grid = ctx.grids.get(target);
+  if (grid !== void 0) {
+    const l = grid.lattice.points;
+    const points = [];
+    for (let k = 0; k < l.length; k += 2) points.push([l[k], l[k + 1]]);
+    return {
+      offsets: gridStop(name, at, target, grid.keyforms),
+      points,
+      scale: [1, 1],
+      step: 0.1,
+      stride: grid.lattice.cols + 1
+    };
+  }
+  const part = ctx.parts.find((p) => p.id === target);
+  const b = ctx.boxOf(target);
+  if (part?.mesh === void 0 || part.warps === void 0 || b === void 0) {
+    const parts = ctx.parts.filter(
+      (p) => p.mesh !== void 0 && p.warps !== void 0 && ctx.boxOf(p.id) !== void 0
+    );
+    throw new PatchError(
+      `${name}.target "${target}" is neither a feature grid (${[...ctx.grids.keys()].join(", ")}) nor a mesh part with warps (${parts.map((p) => p.id).join(", ")}); bodyWarp and the matrix deformers are not patchable`
+    );
+  }
+  return {
+    offsets: partStop(name, at, part, part.warps, ctx),
+    points: meshPoints(part.mesh, b),
+    scale: [bw(b), bh(b)],
+    step: 1e-4
+  };
+}
+function gridStop(name, at, id, keyforms) {
+  const i = X_STOPS.indexOf(at[P9.AngleX]);
+  const j = Y_STOPS.indexOf(at[P9.AngleY]);
+  if (Object.keys(at).length !== 2 || i < 0 || j < 0) {
+    throw new PatchError(
+      `${name}.at must name ${P9.AngleX} in [${X_STOPS.join(", ")}] and ${P9.AngleY} in [${Y_STOPS.join(", ")}] for the grid ${id}, got ${JSON.stringify(at)}`
+    );
+  }
+  if (X_STOPS[i] === 0 && Y_STOPS[j] === 0) {
+    throw new PatchError(
+      `${name}.at ${P9.AngleX}=0 ${P9.AngleY}=0 is ${id}'s rest stop: ${REST_IS_ART}; patch a stop with ${P9.AngleX} or ${P9.AngleY} at \xB130 instead`
+    );
+  }
+  return keyforms[j * X_STOPS.length + i];
+}
+function partStop(name, at, part, warps, ctx) {
+  const keys = Object.keys(at);
+  const [param] = keys;
+  const value = at[param];
+  const keyform = keys.length === 1 ? warps.filter((w) => w.parameter === param).flatMap((w) => w.keyforms).find((k) => k.value === value) : void 0;
+  if (keyform === void 0) {
+    throw new PatchError(
+      `${name}.at must name one parameter at one of ${part.id}'s warp stops (${listStops(warps, () => true)}), got ${JSON.stringify(at)}`
+    );
+  }
+  if (ROLLS.has(param)) {
+    throw new PatchError(
+      `${name}.at ${param}: that parameter rolls ${part.id}'s deformer chain, so a displacement at its stop is not on screen axes; patch another of its stops (${listStops(warps, (p) => !ROLLS.has(p))}) or its feature grid instead`
+    );
+  }
+  const isRest = (p, v) => v === ctx.parameters.find((q) => q.id === p)?.default;
+  const isShut = (p, v) => SHUT_BY.get(part.id) === p && v === 0;
+  if (!isRest(param, value) && !isShut(param, value)) return keyform.offsets;
+  const open = listStops(warps, (p, v) => !isRest(p, v) && !isShut(p, v));
+  const grid = part.deformer !== void 0 && ctx.grids.has(part.deformer) ? `its feature grid ${part.deformer} at a ${P9.AngleX} \xD7 ${P9.AngleY} stop` : "";
+  const instead = [open && `another of its stops (${open})`, grid].filter((s) => s !== "").join(" or ");
+  const hint = instead === "" ? "" : `; patch ${instead} instead`;
+  throw new PatchError(
+    isRest(param, value) ? `${name}.at ${param}=${value} is that parameter's default, ${part.id}'s rest stop: ${REST_IS_ART}${hint}` : `${name}.at ${param}=0 is where the rig shuts ${part.id} on purpose, a closure the fold check exempts, so a fold a patch made there would never be reported${hint}`
+  );
+}
+function listStops(warps, keep) {
+  const stops = /* @__PURE__ */ new Map();
+  for (const w of warps) {
+    for (const k of w.keyforms) {
+      if (!keep(w.parameter, k.value)) continue;
+      const s = stops.get(w.parameter) ?? /* @__PURE__ */ new Set();
+      s.add(k.value);
+      stops.set(w.parameter, s);
+    }
+  }
+  return [...stops].map(([p, s]) => `${p}@${[...s].sort((a, b) => a - b).join(",")}`).join(" ");
+}
+function regionWeights(points, box, x, y, fall) {
+  const x0 = box.x0 + x[0] * bw(box);
+  const x1 = box.x0 + x[1] * bw(box);
+  const top = box.y1 - y[0] * bh(box);
+  const bottom = box.y1 - y[1] * bh(box);
+  return points.map(([px, py]) => {
+    const d = Math.hypot(
+      Math.max(x0 - px, 0, px - x1),
+      Math.max(bottom - py, 0, py - top)
+    );
+    return d === 0 ? 1 : d < fall ? smoothstep(fall, 0, d) : 0;
+  });
+}
+function asPatch(check) {
+  try {
+    return check();
+  } catch (e) {
+    throw e instanceof TurnTargetError ? new PatchError(e.message) : e;
+  }
+}
+function fields(name, v, known) {
+  if (v === void 0) throw new PatchError(`${name} is missing`);
+  asPatch(() => checkedKeys(name, v, known));
+  return v;
+}
+function numbers(name, v) {
+  const o = fields(name, v, Object.keys(v ?? {}));
+  return Object.fromEntries(
+    Object.entries(o).map(([k, n]) => [k, finite2(`${name}.${k}`, n)])
+  );
+}
+var finite2 = (name, v, lo = -Infinity) => asPatch(() => checkedNumber(name, v, lo, Infinity));
+function text(name, v) {
+  if (typeof v !== "string") {
+    throw new PatchError(`${name} must be a string, got ${String(v)}`);
+  }
+  return v;
+}
+function span(name, v) {
+  if (!Array.isArray(v) || v.length !== 2) {
+    throw new PatchError(
+      `${name} must be [from, to], got ${JSON.stringify(v)}`
+    );
+  }
+  const lo = finite2(`${name}[0]`, v[0]);
+  const hi = finite2(`${name}[1]`, v[1]);
+  if (lo > hi) {
+    throw new PatchError(
+      `${name} [${lo}, ${hi}] runs backwards: ${name}[0] must not exceed ${name}[1]`
+    );
+  }
+  return [lo, hi];
+}
+
 // src/auto-rig/generate.ts
 var MESH_CELLS = {
   face: { px: 28, min: 4, max: 24 },
@@ -5828,7 +6108,7 @@ 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)])
+    ["eye_L", "eye_R", "iris_L", "iris_R", "brow_L", "brow_R"].filter(has).map((r) => [r, box(r)])
   );
   const landmarks = {
     boxes,
@@ -5948,6 +6228,15 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     ];
   }
   const parameters = declareParameters(new Set(byRole.keys()));
+  const reports = options.patches === void 0 ? void 0 : applyPatches(options.patches, {
+    grids: new Map(
+      [...grids].map(([family, g]) => [WARP_ID[family], g])
+    ),
+    parts,
+    boxOf: (role) => has(role) ? box(role) : void 0,
+    faceWidth: byRole.get("face").cropW,
+    parameters
+  });
   const model = {
     version: IKI_FORMAT_VERSION2,
     name: "auto-rigged",
@@ -5960,6 +6249,7 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     motions: defaultMotions(new Set(parameters.map((p) => p.id)))
   };
   const valid = parseIkiModel3(model);
+  if (reports !== void 0) options.onPatchesApplied?.(reports);
   if (hasNose && options.onTurnSolved) {
     options.onTurnSolved(
       turnReport(
@@ -5974,14 +6264,14 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
 function turnWarps(mesh, b, fieldOf) {
   return [
     localWarp(
-      P8.AngleX,
+      P10.AngleX,
       mesh,
       b,
       X_STOPS,
       ([x, y], v, i) => v === 0 ? [0, 0] : [fieldOf(i)(x, y, v, 0)[0], 0]
     ),
     localWarp(
-      P8.AngleY,
+      P10.AngleY,
       mesh,
       b,
       Y_STOPS,
@@ -6032,7 +6322,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
   }
   if (mesh !== void 0) part.mesh = mesh;
   const side = spec.role.endsWith("_L") ? "L" : "R";
-  const eyeOpen = side === "L" ? P8.EyeOpenLeft : P8.EyeOpenRight;
+  const eyeOpen = side === "L" ? P10.EyeOpenLeft : P10.EyeOpenRight;
   const hh = frame.hh;
   switch (spec.role) {
     case "face":
@@ -6047,7 +6337,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
             headOwnRoll(byRole.has("body"))
           ),
           localWarp(
-            P8.Breath,
+            P10.Breath,
             mesh,
             b,
             [0, 1],
@@ -6094,8 +6384,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
       if (byRole.has("mouth_open")) {
         warps.push(mouthWiden(mesh, b));
         bindings.push(
-          { parameter: P8.MouthOpen, channel: "opacity", from: 1, to: 0 },
-          { parameter: P8.MouthOpen, channel: "opacity", from: 1, to: 0 }
+          { parameter: P10.MouthOpen, channel: "opacity", from: 1, to: 0 },
+          { parameter: P10.MouthOpen, channel: "opacity", from: 1, to: 0 }
         );
         extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       } else {
@@ -6105,19 +6395,19 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
         );
         bindings.push(
           {
-            parameter: P8.MouthOpen,
+            parameter: P10.MouthOpen,
             channel: "scaleY",
             from: 0,
             to: roundTo(grow, 0.01)
           },
           {
-            parameter: P8.MouthOpen,
+            parameter: P10.MouthOpen,
             channel: "scaleX",
             from: 0,
             to: roundTo(AMPLITUDE.mouthOpenWidth - 1, 0.01)
           },
           {
-            parameter: P8.MouthOpen,
+            parameter: P10.MouthOpen,
             channel: "translateY",
             from: 0,
             to: -roundTo(grow * bh(b) / 2, 0.01)
@@ -6129,7 +6419,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
     case "mouth_open":
       warps.push(mouthForm(mesh, b), mouthOpenGrow(mesh, b));
       bindings.push({
-        parameter: P8.MouthOpen,
+        parameter: P10.MouthOpen,
         channel: "opacity",
         from: 0,
         to: 1
@@ -6151,7 +6441,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
     case "blush_L":
     case "blush_R":
       bindings.push({
-        parameter: P8.Cheek,
+        parameter: P10.Cheek,
         channel: "opacity",
         from: AMPLITUDE.blushRest,
         to: 1
@@ -6162,8 +6452,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
       if (byRole.has("hair_front")) {
         const amp = style.sway * AMPLITUDE.sway * hh;
         warps.push(
-          hairSway(P8.HairSwayX, mesh, b, amp),
-          hairSway(P8.HairSwayZ, mesh, b, amp)
+          hairSway(P10.HairSwayX, mesh, b, amp),
+          hairSway(P10.HairSwayZ, mesh, b, amp)
         );
       }
       warps.push(tiltHang(mesh, b, pivot, hairHangWeight(frame.chinY, b.y0)));
@@ -6178,6 +6468,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
     headStart
   };
 }
+var RAMP_ROWS = 3;
+var MIN_RAMP_CELL = 4;
 function hairFrontGrid(b, frame, boxes) {
   const cells = MESH_CELLS.hair_front;
   const px = Math.min(cells.px, meshScale("hair_front", frame));
@@ -6202,6 +6494,24 @@ function hairFrontGrid(b, frame, boxes) {
     { length: rows + 1 },
     (_, r) => b.y1 - bh(b) * r / rows
   );
+  const eyes = [boxes.eye_L, boxes.eye_R].filter((e) => e !== void 0);
+  const irises = [boxes.iris_L, boxes.iris_R].filter((e) => e !== void 0);
+  if (eyes.length > 0 && irises.length > 0) {
+    const eyeY = eyes.reduce((t, e) => t + (e.y0 + e.y1) / 2, 0) / eyes.length;
+    const eyeH = eyes.reduce((t, e) => t + (e.y1 - e.y0), 0) / eyes.length;
+    const hi = Math.min(eyeY + 1.5 * eyeH, b.y1);
+    const lo = Math.max(Math.max(...irises.map((e) => e.y1)) - 0.5, b.y0);
+    for (; ; ) {
+      const edges = [hi, ...ys.filter((y) => y < hi && y > lo), lo];
+      if (edges.length - 2 >= RAMP_ROWS) break;
+      let gap = 0;
+      for (let i = 1; i + 1 < edges.length; i++)
+        if (edges[i] - edges[i + 1] > edges[gap] - edges[gap + 1]) gap = i;
+      if (edges[gap] - edges[gap + 1] < 2 * MIN_RAMP_CELL) break;
+      ys.push((edges[gap] + edges[gap + 1]) / 2);
+      ys.sort((p, q) => q - p);
+    }
+  }
   return { xs, ys };
 }
 function meshScale(role, frame) {
@@ -6229,9 +6539,9 @@ function deformers(frame, grids, bodyWarp, arms, byRole) {
     pivot: { x: roundTo(frame.axisX, 0.01), y: roundTo(frame.chinY, 0.01) },
     bindings: [
       // AngleZ is clockwise-positive (Live2D's); a rotation is CCW-positive.
-      { parameter: P8.AngleZ, channel: "rotate", from: roll, to: -roll },
+      { parameter: P10.AngleZ, channel: "rotate", from: roll, to: -roll },
       {
-        parameter: P8.Breath,
+        parameter: P10.Breath,
         channel: "translateY",
         from: 0,
         to: roundTo(headOwnBreath(hasBody) * frame.hh, 0.01)
@@ -6249,8 +6559,8 @@ function deformers(frame, grids, bodyWarp, arms, byRole) {
         points: g.lattice.points
       },
       warp2d: {
-        parameter: P8.AngleX,
-        parameterY: P8.AngleY,
+        parameter: P10.AngleX,
+        parameterY: P10.AngleY,
         valuesX: X_STOPS,
         valuesY: Y_STOPS,
         keyforms2d: g.keyforms.map((offsets) => ({ offsets }))
@@ -6263,16 +6573,16 @@ function hairPhysics() {
   return [
     {
       id: "hairSway",
-      input: { parameter: P8.AngleX, weight: 1 },
-      output: { parameter: P8.HairSwayX, scale: 5 },
+      input: { parameter: P10.AngleX, weight: 1 },
+      output: { parameter: P10.HairSwayX, scale: 5 },
       mass: 1,
       stiffness: 30,
       damping: 3
     },
     {
       id: "hairTilt",
-      input: { parameter: P8.AngleZ, weight: 1 },
-      output: { parameter: P8.HairSwayZ, scale: 8 },
+      input: { parameter: P10.AngleZ, weight: 1 },
+      output: { parameter: P10.HairSwayZ, scale: 8 },
       mass: 1,
       stiffness: 25,
       damping: 2.5
@@ -6282,13 +6592,13 @@ function hairPhysics() {
 function declareParameters(roles) {
   const out = [];
   const add = (id, name, min, max, def) => out.push({ id, name, min, max, default: def });
-  add(P8.AngleX, "Head Angle", -30, 30, 0);
-  add(P8.AngleY, "Head Angle Y", -30, 30, 0);
-  add(P8.AngleZ, "Head Angle Z", -30, 30, 0);
+  add(P10.AngleX, "Head Angle", -30, 30, 0);
+  add(P10.AngleY, "Head Angle Y", -30, 30, 0);
+  add(P10.AngleZ, "Head Angle Z", -30, 30, 0);
   if (roles.has("body")) {
-    add(P8.BodyAngleX, "Body Angle X", -10, 10, 0);
-    add(P8.BodyAngleY, "Body Angle Y", -10, 10, 0);
-    add(P8.BodyAngleZ, "Body Angle Z", -10, 10, 0);
+    add(P10.BodyAngleX, "Body Angle X", -10, 10, 0);
+    add(P10.BodyAngleY, "Body Angle Y", -10, 10, 0);
+    add(P10.BodyAngleZ, "Body Angle Z", -10, 10, 0);
   }
   const addPose = (side, pose, angle) => {
     add(pose, `Arm Pose ${side}`, 0, 1, 0);
@@ -6297,40 +6607,40 @@ function declareParameters(roles) {
   const [armMin, armMax] = ARM_RANGE;
   const [elbowMin, elbowMax] = ELBOW_RANGE;
   if (roles.has("arm_L")) {
-    add(P8.ArmLeft, "Arm L", armMin, armMax, 0);
-    add(P8.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
+    add(P10.ArmLeft, "Arm L", armMin, armMax, 0);
+    add(P10.ElbowLeft, "Elbow L", elbowMin, elbowMax, 0);
     if (roles.has("forearm_pose_L"))
-      addPose("L", P8.ArmPoseLeft, P8.ArmPoseAngleLeft);
+      addPose("L", P10.ArmPoseLeft, P10.ArmPoseAngleLeft);
   }
   if (roles.has("arm_R")) {
-    add(P8.ArmRight, "Arm R", armMin, armMax, 0);
-    add(P8.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
+    add(P10.ArmRight, "Arm R", armMin, armMax, 0);
+    add(P10.ElbowRight, "Elbow R", elbowMin, elbowMax, 0);
     if (roles.has("forearm_pose_R"))
-      addPose("R", P8.ArmPoseRight, P8.ArmPoseAngleRight);
+      addPose("R", P10.ArmPoseRight, P10.ArmPoseAngleRight);
   }
-  add(P8.EyeOpenLeft, "Eye L", 0, 1, 1);
-  add(P8.EyeOpenRight, "Eye R", 0, 1, 1);
+  add(P10.EyeOpenLeft, "Eye L", 0, 1, 1);
+  add(P10.EyeOpenRight, "Eye R", 0, 1, 1);
   if ([...roles].some((r) => /^(iris|pupil|highlight)_/.test(r))) {
-    add(P8.EyeballX, "Gaze X", -1, 1, 0);
-    add(P8.EyeballY, "Gaze Y", -1, 1, 0);
+    add(P10.EyeballX, "Gaze X", -1, 1, 0);
+    add(P10.EyeballY, "Gaze Y", -1, 1, 0);
   }
-  add(P8.MouthOpen, "Mouth Open", 0, 1, 0);
-  add(P8.MouthForm, "Mouth Form", -1, 1, 0);
+  add(P10.MouthOpen, "Mouth Open", 0, 1, 0);
+  add(P10.MouthForm, "Mouth Form", -1, 1, 0);
   if (roles.has("brow_L")) {
-    add(P8.BrowLeftY, "Brow L Y", -1, 1, 0);
-    add(P8.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
+    add(P10.BrowLeftY, "Brow L Y", -1, 1, 0);
+    add(P10.BrowLeftAngle, "Brow L Angle", -1, 1, 0);
   }
   if (roles.has("brow_R")) {
-    add(P8.BrowRightY, "Brow R Y", -1, 1, 0);
-    add(P8.BrowRightAngle, "Brow R Angle", -1, 1, 0);
+    add(P10.BrowRightY, "Brow R Y", -1, 1, 0);
+    add(P10.BrowRightAngle, "Brow R Angle", -1, 1, 0);
   }
   if (roles.has("blush_L") || roles.has("blush_R")) {
-    add(P8.Cheek, "Cheek", 0, 1, 0);
+    add(P10.Cheek, "Cheek", 0, 1, 0);
   }
-  add(P8.Breath, "Breath", 0, 1, 0);
+  add(P10.Breath, "Breath", 0, 1, 0);
   if (roles.has("hair_front")) {
-    add(P8.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
-    add(P8.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(P10.HairSwayX, "Hair Sway X", -SWAY_RANGE, SWAY_RANGE, 0);
+    add(P10.HairSwayZ, "Hair Sway Z", -SWAY_RANGE, SWAY_RANGE, 0);
   }
   return out;
 }
@@ -6351,6 +6661,8 @@ export {
   LIP_INSIDE_ROLES,
   LIP_ROLES,
   LayerGeometryError,
+  PatchError,
+  SHUT_BY,
   SPECK_CORE_FRACTION,
   SetDeformerBindings,
   SetDeformerParent,