@ikijs/editor 0.21.0 → 0.23.0

package/dist/index.mjs

@@ -3018,9 +3018,16 @@ function forearmPoseDeformer(role, arm) {
   };
 }
 
+// src/auto-rig/mouth.ts
+import {
+  StandardParameter as P5
+} from "@ikijs/format";
+
 // src/auto-rig/roles.ts
 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 ROLE_TABLE = [
   { role: "hair_back", family: "hair_back" },
   { role: "body", family: "body" },
@@ -3032,10 +3039,13 @@ var ROLE_TABLE = [
   { role: "nose", family: "nose" },
   { role: "mouth", family: "mouth" },
   { role: "mouth_open", family: "mouth" },
-  // The lip set, back to front: the interior, 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.
+  // 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 },
@@ -3098,6 +3108,12 @@ function checkArmsHaveBody(roles) {
 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(
@@ -3159,6 +3175,301 @@ function parseLayerRoles(fileNames) {
   return out;
 }
 
+// src/auto-rig/mouth.ts
+var UPPER_SHARE = 0.4;
+var UPPER_THIN = 0.7;
+var END_TAPER = 0.35;
+var END_TAPER_FROM = 0.7;
+var FLICK_PULL = 0.5;
+var FLICK_SQUASH = 0.25;
+var MOUTH_KNOT_PX = 4;
+var isLipSet = (byRole) => LIP_ROLES.every((r) => byRole.has(r));
+function columnRuns(layer) {
+  const cols = /* @__PURE__ */ new Map();
+  (layer.rowRuns ?? []).forEach((runs, k) => {
+    for (let i = 0; i < runs.length; i += 2) {
+      for (let c = runs[i]; c < runs[i + 1]; c++) {
+        const list = cols.get(c) ?? [];
+        const last = list[list.length - 1];
+        if (last !== void 0 && last[1] === k) last[1] = k + 1;
+        else list.push([k, k + 1]);
+        cols.set(c, list);
+      }
+    }
+  });
+  return cols;
+}
+var edgesOf = (layer, run) => ({
+  top: layer.canvasH / 2 - (layer.bbox.y + run[0]),
+  bottom: layer.canvasH / 2 - (layer.bbox.y + run[1])
+});
+function mouthOpening(byRole) {
+  const inner = byRole.get("mouth_inner");
+  const upper = byRole.get("lip_upper");
+  const lower = byRole.get("lip_lower");
+  const innerCols = columnRuns(inner);
+  if (innerCols.size === 0) {
+    throw new LayerGeometryError(
+      `auto-rig: layer "${inner.fileName}": mouth_inner has no opaque pixel (alpha \u2265 128) to read the opening off`
+    );
+  }
+  const upperCols = columnRuns(upper);
+  const lowerCols = columnRuns(lower);
+  const cols = [...innerCols.keys()];
+  const x0 = Math.min(...cols);
+  const x1 = Math.max(...cols);
+  const read = (col) => {
+    const runs = innerCols.get(col);
+    if (runs === void 0) return void 0;
+    const T = edgesOf(inner, runs[0]).top;
+    const Bb = edgesOf(inner, runs[runs.length - 1]).bottom;
+    const line = [...upperCols.get(col) ?? []].reverse().map((r) => edgesOf(upper, r)).find((e) => e.top >= T);
+    const Tu = line?.bottom ?? T;
+    const lineTop = line?.top ?? T;
+    const skin = lowerCols.get(col)?.[0];
+    return {
+      T,
+      Bb,
+      Tu,
+      lineTop,
+      lineH: lineTop - Tu,
+      Bl: skin === void 0 ? Bb : edgesOf(lower, skin).top,
+      H: T - Bb
+    };
+  };
+  const reads = [];
+  for (let c = x0; c <= x1; c++) {
+    let r;
+    for (let d = 0; (r = read(c - d) ?? read(c + d)) === void 0; d++) ;
+    reads.push(r);
+  }
+  const m = (x0 + x1) / 2;
+  let p = 0;
+  let q = 0;
+  if (reads.length >= 4) {
+    let s11 = 0;
+    let s12 = 0;
+    let s22 = 0;
+    let t1 = 0;
+    let t2 = 0;
+    reads.forEach((r, i) => {
+      const x = x0 + i;
+      const b1 = (x - x0) * (x - x1);
+      const b2 = b1 * (x - m);
+      const d = r.T - UPPER_SHARE * r.H - r.Tu;
+      s11 += b1 * b1;
+      s12 += b1 * b2;
+      s22 += b2 * b2;
+      t1 += b1 * d;
+      t2 += b2 * d;
+    });
+    const det = s11 * s22 - s12 * s12;
+    p = (t1 * s22 - t2 * s12) / det;
+    q = (s11 * t2 - s12 * t1) / det;
+  }
+  const columns = reads.map((r, i) => {
+    const x = x0 + i;
+    return { ...r, seam: r.Tu + (x - x0) * (x - x1) * (p + q * (x - m)) };
+  });
+  const clamp2 = (col) => Math.min(x1, Math.max(x0, col));
+  const base = (col) => columns[clamp2(col) - x0];
+  const centre = Math.round((x0 + x1) / 2);
+  const w = base(centre).lineH;
+  const from = END_TAPER_FROM * ((x1 - x0 + 1) / 2);
+  const squash = (col) => {
+    const d = Math.abs(col - centre);
+    const edge = col < centre ? centre - upper.bbox.x : upper.bbox.x + upper.bbox.w - 1 - centre;
+    const t = d <= from ? 0 : d >= edge ? 1 : (d - from) / (edge - from);
+    return 1 - (1 - END_TAPER) * t;
+  };
+  return {
+    x0,
+    x1,
+    centre,
+    canvasW: inner.canvasW,
+    w,
+    at(col) {
+      const b = base(col);
+      const s = squash(clamp2(col));
+      return {
+        ...b,
+        overlap: UPPER_THIN * (b.lineH * (1 - s) / 2 + Math.min(w, b.lineH) * s)
+      };
+    },
+    line(col) {
+      if (col >= x0 && col <= x1) {
+        const b = base(col);
+        return { bottom: b.Tu, top: b.lineTop, squash: squash(col) };
+      }
+      const runs = upperCols.get(col);
+      if (runs === void 0) return void 0;
+      return {
+        bottom: edgesOf(upper, runs[runs.length - 1]).bottom,
+        top: edgesOf(upper, runs[0]).top,
+        squash: FLICK_SQUASH
+      };
+    }
+  };
+}
+function mouthFold(role, opening) {
+  const { x0, x1 } = opening;
+  const stackThin = (c, y) => y > c.Tu ? c.Tu + UPPER_THIN * (y - c.Tu) : y;
+  return (col, y, v) => {
+    const k = 1 - v;
+    const inside = col >= x0 && col <= x1;
+    switch (role) {
+      case "lip_lower": {
+        if (!inside) return [0, 0];
+        const c = opening.at(col);
+        return [0, (c.seam + c.overlap - c.Bl) * k];
+      }
+      case "mouth_inner": {
+        const c = opening.at(col);
+        const S = c.seam + c.overlap;
+        return [0, S + v * (stackThin(c, y) - S) - y];
+      }
+      case "mouth_teeth": {
+        const c = opening.at(col);
+        return [0, stackThin(c, y) - y + (c.seam - c.Tu) * k];
+      }
+      case "mouth_tongue": {
+        const c = opening.at(col);
+        return [0, (c.seam + c.overlap - c.Bb) * k];
+      }
+      case "lip_upper": {
+        let c = col;
+        let line = opening.line(c);
+        while (line === void 0)
+          line = opening.line(c += col < x0 ? 1 : -1);
+        const thin = line.bottom + UPPER_THIN * (y - line.bottom);
+        const mid = line.bottom + UPPER_THIN * (line.top - line.bottom) / 2;
+        const travel = inside ? opening.at(col).seam - line.bottom : 0;
+        const shut = mid + line.squash * (thin - mid) + travel;
+        const pull = inside ? 0 : (1 - FLICK_PULL) * ((col < x0 ? x0 : x1 + 1) - col);
+        return [pull * k, thin - y + (shut - thin) * k];
+      }
+    }
+  };
+}
+function columnOfKnot(knot, opening) {
+  const boundary = Math.round(knot + opening.canvasW / 2);
+  return boundary === opening.x1 + 1 ? opening.x1 : boundary;
+}
+function mouthFoldWarp(role, mesh, xs, box, opening) {
+  const fold = mouthFold(role, opening);
+  return localWarp(
+    P5.MouthOpen,
+    mesh,
+    box,
+    [0, 1],
+    (p, v, i) => fold(columnOfKnot(xs[i % xs.length], opening), p[1], v)
+  );
+}
+function mouthRestShift(byRole) {
+  const rig = buildMouthRig(byRole);
+  const fields = /* @__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, {
+      box,
+      xs,
+      rows: offsets.length / 2 / xs.length - 1,
+      dy: offsets.filter((_, i) => i % 2 === 1).map((o) => o * bh(box))
+    });
+  }
+  const { canvasW, canvasH } = byRole.get("lip_upper");
+  return (role, col, row) => {
+    const { box, xs, rows, dy } = fields.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;
+    let k = 1;
+    while (k < xs.length - 1 && xs[k] < x) k++;
+    const down = (box.y1 - y) / bh(box) * rows;
+    const r = Math.min(rows - 1, Math.floor(down));
+    const fx = (x - xs[k - 1]) / (xs[k] - xs[k - 1]);
+    const fy = down - r;
+    const at = (i, j) => dy[i * xs.length + j];
+    const tl = at(r, k - 1);
+    const br = at(r + 1, k);
+    if (fx <= fy) {
+      const bl = at(r + 1, k - 1);
+      return tl + fy * (bl - tl) + fx * (br - bl);
+    }
+    const tr = at(r, k);
+    return tl + fx * (tr - tl) + fy * (br - tr);
+  };
+}
+function mouthKnots(union, opening) {
+  const half = opening.canvasW / 2;
+  const step = MOUTH_KNOT_PX;
+  const xs = [union.x0];
+  while (xs[xs.length - 1] + step < union.x1 - 0.3 * step)
+    xs.push(xs[xs.length - 1] + step);
+  xs.push(union.x1);
+  const fixed = /* @__PURE__ */ new Set([union.x0, union.x1]);
+  for (const x of [
+    opening.x0 - half,
+    opening.x1 - half,
+    opening.x1 + 1 - half
+  ]) {
+    fixed.add(x);
+    if (xs.includes(x)) continue;
+    const near = xs.findIndex((v) => Math.abs(v - x) < 0.3 * step);
+    if (near >= 0 && !fixed.has(xs[near])) xs[near] = x;
+    else xs.push(x);
+  }
+  xs.sort((p, q) => p - q);
+  for (const x of xs) {
+    if (!Number.isInteger(x + half)) {
+      throw new Error(
+        `auto-rig: mouth knot ${x} is not an integer canvas boundary`
+      );
+    }
+  }
+  return xs;
+}
+function mouthMesh(box, knots) {
+  const xs = [box.x0, ...knots.filter((k) => k > box.x0 && k < box.x1), box.x1];
+  const rows = cellsFor(bh(box), MOUTH_KNOT_PX, 2, 40);
+  const ys = Array.from(
+    { length: rows + 1 },
+    (_, r) => box.y1 - bh(box) * r / rows
+  );
+  return { mesh: columnMesh(box, { xs, ys }), xs };
+}
+function buildMouthRig(byRole) {
+  const opening = mouthOpening(byRole);
+  const union = unionBoxes(LIP_ROLES.map((r) => boxOfLayer(byRole.get(r))));
+  return {
+    opening,
+    frame: mouthFrameOf(union),
+    knots: mouthKnots(union, opening),
+    union
+  };
+}
+function mouthAnchor(byRole) {
+  const box = (role) => boxOfLayer(byRole.get(role));
+  if (isLipSet(byRole)) {
+    const opening = mouthOpening(byRole);
+    return {
+      at: {
+        x: cx(box("mouth_inner")),
+        y: opening.at(opening.centre).seam
+      },
+      box: unionBoxes(LIP_ROLES.map(box))
+    };
+  }
+  const m = box("mouth");
+  return {
+    at: { x: cx(m), y: cy(m) },
+    box: byRole.has("mouth_open") ? unionBoxes([m, box("mouth_open")]) : m
+  };
+}
+
 // src/auto-rig/generate.ts
 import {
   IKI_FORMAT_VERSION as IKI_FORMAT_VERSION2,
@@ -3168,30 +3479,30 @@ import {
 
 // src/auto-rig/animations.ts
 import {
-  StandardParameter as P5
+  StandardParameter as P6
 } from "@ikijs/format";
 function browsY(y) {
   return [
-    { parameter: P5.BrowLeftY, value: y, blend: "add" },
-    { parameter: P5.BrowRightY, value: y, blend: "add" }
+    { parameter: P6.BrowLeftY, value: y, blend: "add" },
+    { parameter: P6.BrowRightY, value: y, blend: "add" }
   ];
 }
 function browsTilt(innerDown) {
   return [
-    { parameter: P5.BrowLeftAngle, value: innerDown, blend: "add" },
-    { parameter: P5.BrowRightAngle, value: -innerDown, blend: "add" }
+    { parameter: P6.BrowLeftAngle, value: innerDown, blend: "add" },
+    { parameter: P6.BrowRightAngle, value: -innerDown, blend: "add" }
   ];
 }
 function cheek(value) {
-  return { parameter: P5.Cheek, value, blend: "add" };
+  return { parameter: P6.Cheek, value, blend: "add" };
 }
-var BROWS = [P5.BrowLeftY, P5.BrowRightY, P5.BrowLeftAngle, P5.BrowRightAngle];
+var BROWS = [P6.BrowLeftY, P6.BrowRightY, P6.BrowLeftAngle, P6.BrowRightAngle];
 var EXPRESSIONS = [
   {
     id: "smile",
     description: "Smiling and pleased: warm, friendly, content. For greetings, thanks, agreement and gentle happiness.",
     parameters: [
-      { parameter: P5.MouthForm, value: 1, blend: "add" },
+      { parameter: P6.MouthForm, value: 1, blend: "add" },
       ...browsY(0.25),
       cheek(0.4)
     ]
@@ -3200,10 +3511,10 @@ var EXPRESSIONS = [
     id: "laugh",
     description: "Laughing, eyes shut and mouth open: delighted, amused. For jokes, playfulness and big joy.",
     parameters: [
-      { parameter: P5.EyeOpenLeft, value: 0, blend: "multiply" },
-      { parameter: P5.EyeOpenRight, value: 0, blend: "multiply" },
-      { parameter: P5.MouthForm, value: 1, blend: "add" },
-      { parameter: P5.MouthOpen, value: 0.8, blend: "overwrite" },
+      { 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" },
       ...browsY(0.4),
       cheek(0.65)
     ]
@@ -3215,7 +3526,7 @@ var EXPRESSIONS = [
     parameters: [
       ...browsY(-0.5),
       ...browsTilt(0.8),
-      { parameter: P5.MouthForm, value: -0.9, blend: "add" }
+      { parameter: P6.MouthForm, value: -0.9, blend: "add" }
     ]
   },
   {
@@ -3225,7 +3536,7 @@ var EXPRESSIONS = [
     parameters: [
       ...browsY(0.35),
       ...browsTilt(-0.8),
-      { parameter: P5.MouthForm, value: -0.8, blend: "add" }
+      { parameter: P6.MouthForm, value: -0.8, blend: "add" }
     ]
   },
   {
@@ -3233,18 +3544,18 @@ var EXPRESSIONS = [
     description: "Surprised, mouth dropped open: startled, amazed. For shock, sudden news or disbelief.",
     parameters: [
       ...browsY(0.8),
-      { parameter: P5.MouthOpen, value: 0.9, blend: "overwrite" }
+      { parameter: P6.MouthOpen, value: 0.9, blend: "overwrite" }
     ]
   },
   {
     id: "shy",
     description: "Shy or embarrassed: bashful, flustered. For being praised, teased or caught off guard.",
-    needs: [P5.Cheek],
+    needs: [P6.Cheek],
     parameters: [
       cheek(1),
       // Gaze down.
-      { parameter: P5.EyeballY, value: -0.65, blend: "add" },
-      { parameter: P5.MouthForm, value: 0.4, blend: "add" },
+      { parameter: P6.EyeballY, value: -0.65, blend: "add" },
+      { parameter: P6.MouthForm, value: 0.4, blend: "add" },
       ...browsTilt(-0.25)
     ]
   }
@@ -3264,7 +3575,7 @@ var HEAD_MOTIONS = {
       duration: 1,
       curves: [
         {
-          parameter: P5.AngleY,
+          parameter: P6.AngleY,
           keys: [
             [0, 0],
             [0.3, -18],
@@ -3285,7 +3596,7 @@ var HEAD_MOTIONS = {
       fadeIn: 0.15,
       curves: [
         {
-          parameter: P5.AngleX,
+          parameter: P6.AngleX,
           keys: [
             [0, 0],
             [0.2, -18],
@@ -3304,7 +3615,7 @@ var HEAD_MOTIONS = {
       duration: 1.4,
       curves: [
         {
-          parameter: P5.AngleZ,
+          parameter: P6.AngleZ,
           keys: [
             [0, 0],
             [0.35, 20],
@@ -3325,7 +3636,7 @@ var WAVE = {
       fadeOut: 0.15,
       curves: [
         {
-          parameter: P5.ArmPoseRight,
+          parameter: P6.ArmPoseRight,
           interpolation: "linear",
           keys: [
             [0, 0],
@@ -3335,7 +3646,7 @@ var WAVE = {
           ]
         },
         {
-          parameter: P5.ArmRight,
+          parameter: P6.ArmRight,
           keys: [
             [0, 0],
             [0.4, 10],
@@ -3344,7 +3655,7 @@ var WAVE = {
           ]
         },
         {
-          parameter: P5.ArmPoseAngleRight,
+          parameter: P6.ArmPoseAngleRight,
           keys: [
             [0, 0],
             [0.5, 0],
@@ -3360,7 +3671,7 @@ var WAVE = {
   ]
 };
 function defaultMotions(declared) {
-  const waves = [P5.ArmRight, P5.ArmPoseRight, P5.ArmPoseAngleRight].every(
+  const waves = [P6.ArmRight, P6.ArmPoseRight, P6.ArmPoseAngleRight].every(
     (id) => declared.has(id)
   );
   return waves ? { ...HEAD_MOTIONS, ...WAVE } : HEAD_MOTIONS;
@@ -3598,181 +3909,6 @@ function checkStrandEdges(strand, irises, hair) {
 // src/auto-rig/context.ts
 import { StandardParameter as P7 } from "@ikijs/format";
 
-// src/auto-rig/mouth.ts
-import {
-  StandardParameter as P6
-} from "@ikijs/format";
-var UPPER_SHARE = 0.3;
-var MOUTH_KNOT_PX = 4;
-var isLipSet = (byRole) => LIP_ROLES.every((r) => byRole.has(r));
-function columnRuns(layer) {
-  const cols = /* @__PURE__ */ new Map();
-  (layer.rowRuns ?? []).forEach((runs, k) => {
-    for (let i = 0; i < runs.length; i += 2) {
-      for (let c = runs[i]; c < runs[i + 1]; c++) {
-        const list = cols.get(c) ?? [];
-        const last = list[list.length - 1];
-        if (last !== void 0 && last[1] === k) last[1] = k + 1;
-        else list.push([k, k + 1]);
-        cols.set(c, list);
-      }
-    }
-  });
-  return cols;
-}
-var edgesOf = (layer, run) => ({
-  top: layer.canvasH / 2 - (layer.bbox.y + run[0]),
-  bottom: layer.canvasH / 2 - (layer.bbox.y + run[1])
-});
-function mouthOpening(byRole) {
-  const inner = byRole.get("mouth_inner");
-  const upper = byRole.get("lip_upper");
-  const lower = byRole.get("lip_lower");
-  const innerCols = columnRuns(inner);
-  if (innerCols.size === 0) {
-    throw new LayerGeometryError(
-      `auto-rig: layer "${inner.fileName}": mouth_inner has no opaque pixel (alpha \u2265 128) to read the opening off`
-    );
-  }
-  const upperCols = columnRuns(upper);
-  const lowerCols = columnRuns(lower);
-  const cols = [...innerCols.keys()];
-  const x0 = Math.min(...cols);
-  const x1 = Math.max(...cols);
-  const read = (col) => {
-    const runs = innerCols.get(col);
-    if (runs === void 0) return void 0;
-    const T = edgesOf(inner, runs[0]).top;
-    const Bb = edgesOf(inner, runs[runs.length - 1]).bottom;
-    const line = [...upperCols.get(col) ?? []].reverse().map((r) => edgesOf(upper, r)).find((e) => e.top >= T);
-    const Tu = line?.bottom ?? T;
-    const lineTop = line?.top ?? T;
-    const skin = lowerCols.get(col)?.[0];
-    return {
-      T,
-      Bb,
-      Tu,
-      lineTop,
-      lineH: lineTop - Tu,
-      Bl: skin === void 0 ? Bb : edgesOf(lower, skin).top,
-      H: T - Bb,
-      seam: T - UPPER_SHARE * (T - Bb)
-    };
-  };
-  const reads = [];
-  for (let c = x0; c <= x1; c++) {
-    let r;
-    for (let d = 0; (r = read(c - d) ?? read(c + d)) === void 0; d++) ;
-    reads.push(r);
-  }
-  const base = (col) => reads[Math.min(x1, Math.max(x0, col)) - x0];
-  const centre = Math.round((x0 + x1) / 2);
-  const w = base(centre).lineH;
-  return {
-    x0,
-    x1,
-    centre,
-    canvasW: inner.canvasW,
-    w,
-    at(col) {
-      const b = base(col);
-      return { ...b, overlap: Math.max(0, Math.min(w, b.lineH)) };
-    }
-  };
-}
-function mouthFold(role, opening) {
-  return (col, y, v) => {
-    if (v === 1) return 0;
-    if (role !== "mouth_inner" && (col < opening.x0 || col > opening.x1))
-      return 0;
-    const c = opening.at(col);
-    const k = 1 - v;
-    switch (role) {
-      case "lip_upper":
-        return (c.seam - c.Tu) * k;
-      case "lip_lower":
-        return (c.seam + c.overlap - c.Bl) * k;
-      case "mouth_inner":
-        return (c.seam + c.overlap - y) * k;
-    }
-  };
-}
-function columnOfKnot(knot, opening, role) {
-  const boundary = Math.round(knot + opening.canvasW / 2);
-  const col = boundary === opening.x1 + 1 ? opening.x1 : boundary;
-  if (col >= opening.x0 && col <= opening.x1) return col;
-  return role === "mouth_inner" ? Math.min(opening.x1, Math.max(opening.x0, col)) : void 0;
-}
-function mouthFoldWarp(role, mesh, xs, box, opening) {
-  const fold = mouthFold(role, opening);
-  return localWarp(P6.MouthOpen, mesh, box, [0, 1], (p, v, i) => {
-    const col = columnOfKnot(xs[i % xs.length], opening, role);
-    return [0, col === void 0 ? 0 : fold(col, p[1], v)];
-  });
-}
-function mouthKnots(union, opening) {
-  const half = opening.canvasW / 2;
-  const step = MOUTH_KNOT_PX;
-  const xs = [union.x0];
-  while (xs[xs.length - 1] + step < union.x1 - 0.3 * step)
-    xs.push(xs[xs.length - 1] + step);
-  xs.push(union.x1);
-  const fixed = /* @__PURE__ */ new Set([union.x0, union.x1]);
-  for (const x of [opening.x0 - half, opening.x1 + 1 - half]) {
-    fixed.add(x);
-    if (xs.includes(x)) continue;
-    const near = xs.findIndex((v) => Math.abs(v - x) < 0.3 * step);
-    if (near >= 0 && !fixed.has(xs[near])) xs[near] = x;
-    else xs.push(x);
-  }
-  xs.sort((p, q) => p - q);
-  for (const x of xs) {
-    if (!Number.isInteger(x + half)) {
-      throw new Error(
-        `auto-rig: mouth knot ${x} is not an integer canvas boundary`
-      );
-    }
-  }
-  return xs;
-}
-function mouthMesh(box, knots) {
-  const xs = [box.x0, ...knots.filter((k) => k > box.x0 && k < box.x1), box.x1];
-  const rows = cellsFor(bh(box), MOUTH_KNOT_PX, 2, 40);
-  const ys = Array.from(
-    { length: rows + 1 },
-    (_, r) => box.y1 - bh(box) * r / rows
-  );
-  return { mesh: columnMesh(box, { xs, ys }), xs };
-}
-function buildMouthRig(byRole) {
-  const opening = mouthOpening(byRole);
-  const union = unionBoxes(LIP_ROLES.map((r) => boxOfLayer(byRole.get(r))));
-  return {
-    opening,
-    frame: mouthFrameOf(union),
-    knots: mouthKnots(union, opening),
-    union
-  };
-}
-function mouthAnchor(byRole) {
-  const box = (role) => boxOfLayer(byRole.get(role));
-  if (isLipSet(byRole)) {
-    const opening = mouthOpening(byRole);
-    return {
-      at: {
-        x: cx(box("mouth_inner")),
-        y: opening.at(opening.centre).seam
-      },
-      box: unionBoxes(LIP_ROLES.map(box))
-    };
-  }
-  const m = box("mouth");
-  return {
-    at: { x: cx(m), y: cy(m) },
-    box: byRole.has("mouth_open") ? unionBoxes([m, box("mouth_open")]) : m
-  };
-}
-
 // src/auto-rig/head.ts
 function outerEdge(runs, axisX, side) {
   if (runs.length === 0) return void 0;
@@ -5859,7 +5995,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
     headStart = fm.headStart;
   } else if (spec.role === "hair_front") {
     mesh = columnMesh(b, frontGrid);
-  } else if (lips !== void 0 && isLipRole(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") {
     const cells = MESH_CELLS[spec.role] ?? FEATURE_MESH_CELLS;
@@ -5976,6 +6112,8 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
       extra = [(AMPLITUDE.mouthOpenWidth - 1) * (bw(b) / 2), 0];
       break;
     case "mouth_inner":
+    case "mouth_tongue":
+    case "mouth_teeth":
     case "lip_lower":
     case "lip_upper":
       warps.push(
@@ -5983,6 +6121,7 @@ function buildPart(spec, b, order, frame, byRole, style, frontGrid, lips) {
         mouthForm(mesh, b, lips.frame),
         mouthWiden(mesh, b, lips.frame)
       );
+      if (isLipInsideRole(spec.role)) part.clip = { masks: ["mouth_inner"] };
       break;
     case "blush_L":
     case "blush_R":
@@ -6184,6 +6323,8 @@ export {
   DeletePhysicsRig,
   EditorDocument,
   HEAD_BAND,
+  LIP_INSIDE_ROLES,
+  LIP_ROLES,
   LayerGeometryError,
   SPECK_CORE_FRACTION,
   SetDeformerBindings,
@@ -6205,6 +6346,7 @@ export {
   UV_INSET_PX,
   armGeometry,
   captureBindingEndpoint,
+  columnRuns,
   computeGridOffsets,
   createDefaultMatrixDeformer,
   createDefaultPart,
@@ -6218,7 +6360,11 @@ export {
   generateIkiFromLayerSet,
   headHalfOf,
   interpolateGridOffsets,
+  isLipInsideRole,
   isSpeckCore,
+  mouthFold,
+  mouthOpening,
+  mouthRestShift,
   packAtlas,
   parseLayerRoles,
   partIdsOfRole,