@rig-c/parts 1.27.0 → 1.28.0

package/docs/AUTHORING.md

@@ -2637,6 +2637,7 @@ See-through with another seed.
 | <a id="CONFIG_CLOTH_PARTS_UNIQUE"></a>`CONFIG_CLOTH_PARTS_UNIQUE` | a `cloth` recipe sets both `part` and `parts`, or its part list names the same part more than once (issue #437) | set at most one of `part` or `parts`, and list each part once in root-to-tip order |
 | <a id="CONFIG_CLOTH_SPRING_STABLE"></a>`CONFIG_CLOTH_SPRING_STABLE` | a `cloth` recipe's strength — declared, or the default 100 / 100 / 50 — whose spring is unstable at a damping the recipe runs at (`damping`, `alternate_damping`, or rig-c's 0.85 when `damping` is left out): k = strength·massInverse·step² at or past 2(1 + damping^(60·step)), step 1/60 and mass 1 (rig-c's defaults; the recipe sets neither). The detail gives k and the bound | a lower strength, or a higher damping |
 | <a id="CONFIG_TURN_BONE_FREE"></a>`CONFIG_TURN_BONE_FREE` | the config has `turn` and `bones` declares a bone named `turn`, the control the rig stage adds | rename that bone |
+| <a id="CONFIG_TURN_DEFORM_RANGE"></a>`CONFIG_TURN_DEFORM_RANGE` | an entry in `turn.deform` lies outside its allowed `[min, max]` interval in `FACE_DEFORM_RANGES` (`src/turn.ts`, issue #436); the detail gives the value found, the interval required and the default fraction | put that `turn.deform.<key>` inside the stated range, or remove it to take the Set B ×2.5 default |
 | <a id="CONFIG_PROPOSED_RIG_SCALE"></a>`CONFIG_PROPOSED_RIG_SCALE` | `proposed_rig_scale` (the `scale_rig_per_source` `propose` drafted the rig sections at, issue #354) differs from `assemble.rig_scale`: the coordinates in `bones`, `meshes`, `limbs` and `motion` are in that rig canvas's pixels and do not scale when `assemble.rig_scale` changes | re-run `assemble` and `propose` at the new `assemble.rig_scale`, or restore `assemble.rig_scale` to `proposed_rig_scale` |
 
 ### inputs

package/docs/STABILITY.md

@@ -160,8 +160,9 @@ part name, `[i]` an entry of a list):
 - **motion.blink** — required: `t`, `eyes`, `squash`; optional: `brows`, `brow_drop`, `still`
 - **motion.blink.still.<part>** — required: `row`, `bone`
 - **motion.animations_from**, the file it names — required: `spec`, `animations`
-- **turn** — required: `pivot`, `depths`
+- **turn** — required: `pivot`, `depths`; optional: `deform`
 - **turn.depths.<part>** — a See-through depth
+- **turn.deform.<key>** — a per-degree fraction or coupling share (FACE_DEFORM_FRACTIONS, issue #436)
 - **scene** — no field (`{}`; a record or an annotation only)
 - **proposal.json**, the file propose writes — `bones`, `meshes`, `regions`, `limbs` under `--keypoints` where an arm or a leg is drafted from its joints (issue #349), `stops` when supplied, `motion` under the rules above, `turn` with `--full`/`--head`, `proposed_rig_scale` (issue #354), and `notes`
 <!-- /stable:config -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/parts",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "description": "AI-authored 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through rig-c before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {

package/src/check.ts

@@ -1045,6 +1045,21 @@ export interface LoopPhysics {
   in: 'rig.json' | 'motion.json';
 }
 
+/**
+ * A throwaway copy of `rig` whose accompanying `motion` replaces `animations`
+ * with a synthetic set (`still`, `blink_shut`, `stress ...`, `sweep ...`) omits
+ * any `slider` constraint whose target animation is not in that set.
+ */
+function withoutSliders(rig: Record<string, unknown>, animations: Record<string, unknown>): Record<string, unknown> {
+  if (!Array.isArray(rig.constraints)) return rig;
+  const kept = rig.constraints.filter((c) => !(isRecord(c) && c.type === 'slider' && typeof c.animation === 'string' && !(c.animation in animations)));
+  if (kept.length === rig.constraints.length) return rig;
+  const out: Record<string, unknown> = { ...rig };
+  if (kept.length > 0) out.constraints = kept;
+  else delete out.constraints;
+  return out;
+}
+
 /**
  * The rig spec and motion spec with every physics constraint left out, and
  * the constraints it left out; null when there is none, so a rig without one
@@ -3331,8 +3346,9 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
         mkdirSync(stressDir, { recursive: true });
         const base = stripped === null ? inp.rig : stripped.rig;
         const images = typeof inp.rig.images === 'string' ? resolve(inp.rigDir, inp.rig.images) : inp.rig.images;
-        writeFileSync(join(stressDir, 'rig.json'), JSON.stringify({ ...base, images }));
-        writeFileSync(join(stressDir, 'motion.json'), JSON.stringify({ ...(stripped === null ? inp.motion : stripped.motion), animations: stressAnimations(plan) }));
+        const stressAnims = stressAnimations(plan);
+        writeFileSync(join(stressDir, 'rig.json'), JSON.stringify({ ...withoutSliders(base, stressAnims), images }));
+        writeFileSync(join(stressDir, 'motion.json'), JSON.stringify({ ...(stripped === null ? inp.motion : stripped.motion), animations: stressAnims }));
         const sb = rigc(['build', '--rig', join(stressDir, 'rig.json'), '--motion', join(stressDir, 'motion.json'), '--out', join(stressDir, 'build'), '--profile', 'spine']);
         if (sb.status !== 0) refuseIfAny(rigcFailed(`build (${STRESS_LINE}'s turned copy)`, sb, buildGateLines(sb.out)));
         const sr = rigc(['render', '--candidate', join(stressDir, 'build'), '--fps', String(IDLE_FPS), '--max', String(FOLD_RENDER_MAX), '--geometry', '--out', join(stressDir, 'render')]);
@@ -3380,7 +3396,8 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
       const sets = new Map<string, { under: FrameSet; bare: FrameSet }>();
       if (copy.slots.length > 0) {
         for (const [file, image] of copy.images) writePng(join(imagesDir, file), image);
-        writeFileSync(join(sweepDir, 'rig.json'), JSON.stringify({ ...copy.rig, images: imagesDir }));
+        const sweepAnims = isRecord(copy.motion.animations) ? copy.motion.animations : {};
+        writeFileSync(join(sweepDir, 'rig.json'), JSON.stringify({ ...withoutSliders(copy.rig, sweepAnims), images: imagesDir }));
         writeFileSync(join(sweepDir, 'motion.json'), JSON.stringify(copy.motion));
         const sb = rigc(['build', '--rig', join(sweepDir, 'rig.json'), '--motion', join(sweepDir, 'motion.json'), '--out', join(sweepDir, 'build'), '--profile', 'spine']);
         if (sb.status !== 0) refuseIfAny(rigcFailed(`build (${SWEEP_LINE}'s bent copy)`, sb, buildGateLines(sb.out)));
@@ -3423,7 +3440,6 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     try {
       mkdirSync(stillDir, { recursive: true });
       const images = typeof inp.rig.images === 'string' ? resolve(inp.rigDir, inp.rig.images) : inp.rig.images;
-      writeFileSync(join(stillDir, 'rig.json'), JSON.stringify({ ...inp.rig, images }));
       const eyes = full === null ? [] : partsTagged(full.parts, EYE_TAGS);
       const slotBone = new Map((Array.isArray(inp.rig.slots) ? inp.rig.slots : []).filter(isRecord).map((sl) => [String(sl.name), String(sl.bone)]));
       const shut = full === null ? [] : blinkTracks(inp.motion, eyeBones(inp.rig, eyes.map((p) => slotBone.get(p.name) ?? '')));
@@ -3437,6 +3453,8 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
           tracks: shut.map((b) => ({ ...b.target, property: 'scaley', keys: [{ t: 0, v: [b.closed] }, { t: STILL_DURATION, v: [b.closed] }] })),
         };
       }
+      const stillRig = { ...withoutSliders(inp.rig, animations), images };
+      writeFileSync(join(stillDir, 'rig.json'), JSON.stringify(stillRig));
       writeFileSync(join(stillDir, 'motion.json'), JSON.stringify({ ...inp.motion, animations }));
       const sb = rigc(['build', '--rig', join(stillDir, 'rig.json'), '--motion', join(stillDir, 'motion.json'), '--out', join(stillDir, 'build'), '--profile', 'spine']);
       if (sb.status !== 0) refuseIfAny(rigcFailed('build (the setup-pose still)', sb, buildGateLines(sb.out)));
@@ -3460,7 +3478,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
       }
       if (inp.source !== null) {
         // The same pose with every slot tinted black, built with the same animations so rigc fits the same grid.
-        writeFileSync(join(stillDir, BLACK_RIG), JSON.stringify(blackRig({ ...inp.rig, images })));
+        writeFileSync(join(stillDir, BLACK_RIG), JSON.stringify(blackRig(stillRig)));
         const kb = rigc(['build', '--rig', join(stillDir, BLACK_RIG), '--motion', join(stillDir, 'motion.json'), '--out', join(stillDir, 'black_build'), '--profile', 'spine']);
         if (kb.status !== 0) refuseIfAny(rigcFailed('build (the setup-pose still, every slot tinted black)', kb, buildGateLines(kb.out)));
         const kr = rigc(['render', '--candidate', join(stillDir, 'black_build'), '--animation', 'still', '--fps', String(STILL_FPS), '--max', String(maxSide), '--out', join(stillDir, 'black')]);

package/src/config.ts

@@ -93,7 +93,7 @@ import { GRID, MAX_SIDE } from './contour.ts';
 import { type Problem, refuseIfAny } from './errors.ts';
 import { isSkeletonName, KEYPOINT_NAMES, type KeypointName, type PosePoints, SKELETON_NAMES, type SkeletonName } from './skeleton.ts';
 import { acceptedTagNames, AUTHOR_LABEL_RULE, AUTHOR_PREFIX, readLayerTag } from './tags.ts';
-import { TURN_BONE, type TurnSpec, turnNearest } from './turn.ts';
+import { FACE_DEFORM_FRACTIONS, FACE_DEFORM_RANGES, type FaceDeformKey, TURN_BONE, type TurnSpec, turnNearest } from './turn.ts';
 import { FLOOR_FORMS, type FloorForm, type MeshInfluences } from './weights.ts';
 
 export type Point = [number, number];
@@ -2975,7 +2975,7 @@ function checkScene(c: Check, v: Json): void {
 
 function checkTurn(c: Check, v: Json, attached: Set<string>, bones: Set<string>): void {
   const at = 'config.turn';
-  const o = c.object(at, v, ['pivot', 'depths'], []);
+  const o = c.object(at, v, ['pivot', 'depths'], ['deform']);
   if (o === null) return;
   const pivot = 'pivot' in o && c.number(`${at}.pivot`, o.pivot) ? (o.pivot as number) : null;
   const depths: Record<string, number> = {};
@@ -2996,6 +2996,35 @@ function checkTurn(c: Check, v: Json, attached: Set<string>, bones: Set<string>)
       }
     }
   }
+  if ('deform' in o) {
+    const df = o.deform;
+    if (!isPlainObject(df)) {
+      c.fail('CONFIG_FIELD_TYPE', `${at}.deform`, `is ${show(df)}; an object of face deform key -> per-degree fraction is required`);
+    } else {
+      const known = Object.keys(FACE_DEFORM_FRACTIONS);
+      for (const [key, val] of Object.entries(df)) {
+        if (isRecordKey(key)) continue;
+        if (key === 'note' || key.endsWith('_note')) {
+          if (typeof val !== 'string') c.fail('CONFIG_FIELD_TYPE', `${at}.deform.${key}`, `is ${show(val)}; an annotation is a string`);
+          continue;
+        }
+        if (!Object.hasOwn(FACE_DEFORM_FRACTIONS, key)) {
+          c.fail('CONFIG_KEY_KNOWN', `${at}.deform.${key}`, `is not a known face deform fraction; expected one of ${known.join(', ')} — ${DOORS}`);
+          continue;
+        }
+        if (c.number(`${at}.deform.${key}`, val)) {
+          const [lo, hi] = FACE_DEFORM_RANGES[key as FaceDeformKey];
+          if (val < lo || val > hi) {
+            c.fail(
+              'CONFIG_TURN_DEFORM_RANGE',
+              `${at}.deform.${key}`,
+              `is ${val}; a per-degree fraction in [${lo}, ${hi}] is required (default ${FACE_DEFORM_FRACTIONS[key as FaceDeformKey]})`,
+            );
+          }
+        }
+      }
+    }
+  }
   if (pivot !== null && depthsOk) {
     const nearest = turnNearest(depths);
     if (nearest !== null && !(pivot > nearest.depth)) {

package/src/coords.ts

@@ -22,5 +22,5 @@
  * `flattenRig` goes back through `toWorld`. No rotation matrix is written out
  * by hand in this package.
  */
-export { computeExactFrameTransforms, computeWorldTransforms, cropToSpineY, normaliseDegrees, toBoneLocal, toWorld } from 'rig-c/src/transform.ts';
+export { computeExactFrameTransforms, computeWorldTransforms, cropToSpineY, normaliseDegrees, toBoneLocal, toBoneLocalVector, toWorld } from 'rig-c/src/transform.ts';
 export type { BoneTransform } from 'rig-c/src/transform.ts';

package/src/motion.ts

@@ -145,16 +145,26 @@ export interface MotionSpec {
   animations: { idle: { duration: number; loop: true; note: string; tracks: MotionTrack[] } };
 }
 
+const FACE_DEFORM_HOOK = new WeakMap<MotionSpec, (merged: MotionSpec & { animations: Record<string, unknown> }) => void>();
+
+/** Attach a face-surface-deform hook to `motion` so {@link withAnimations} applies it when `turn`/`tilt` slider animations are merged (issue #436). */
+export function bindFaceSurfaceDeform(motion: MotionSpec, hook: (merged: MotionSpec & { animations: Record<string, unknown> }) => void): void {
+  FACE_DEFORM_HOOK.set(motion, hook);
+}
+
 /**
  * The motion `motion.json` holds: the idle, and after it every animation the
- * file `config.motion.animations_from` names, as read (issue #183) — nothing
- * added, nothing re-keyed, nothing judged; each is rigc's to accept at the
- * gate. With none, `motion` itself, so a config that names no file writes the
- * bytes it wrote before the field existed.
+ * file `config.motion.animations_from` names, as read (issue #183) — plus, when
+ * those animations hold `turn` or `tilt` slider `derive` keys, the Set B ×2.5
+ * face surface deform (issue #436). With none, `motion` itself, so a config
+ * that names no file writes the bytes it wrote before the field existed.
  */
 export function withAnimations(motion: MotionSpec, extra: Readonly<Record<string, unknown>> | null): MotionSpec | Record<string, unknown> {
   if (extra === null) return motion;
-  return { ...motion, animations: { ...motion.animations, ...extra } };
+  const merged = { ...motion, animations: { ...motion.animations, ...extra } };
+  const hook = FACE_DEFORM_HOOK.get(motion);
+  if (hook !== undefined) hook(merged);
+  return merged;
 }
 
 /** One sine channel over an idle of `duration` seconds. */

package/src/rig.ts

@@ -165,13 +165,13 @@ import {
 import { type ContourChainRibs, type ContourReport, contourMesh, type ContourRegion, type ContourRib } from './contour.ts';
 import { type LocalInfluence, localInfluences } from './localweights.ts';
 import { artCoverage, ART_ALPHA, latticeMesh, latticeStray, ONE_LOOP_PASSES } from './mesh.ts';
-import { BLINK, blinkHoldMisses, blinkSpan, CONTROL_SUFFIX, controlledBones, IDLE_FPS, idleMotion, type MotionSpec, moveKeysToControls } from './motion.ts';
+import { bindFaceSurfaceDeform, BLINK, blinkHoldMisses, blinkSpan, CONTROL_SUFFIX, controlledBones, IDLE_FPS, idleMotion, type MotionSpec, moveKeysToControls } from './motion.ts';
 import { PAINTING_RUN, type PartsFile, readFrom, tagOf } from './parts.ts';
 import { EYE_GROUP_TAGS } from './propose.ts';
 import { alphaAbove, crop, pad, type Raster } from './raster/index.ts';
 import { pyRound } from './round.ts';
 import { boneHeat, type HeatDust, heatInfluences, HEAT_LIMITS, heatRow, type HeatRow, latticeSilhouette, tracedSilhouette } from './heat.ts';
-import { TURN_BONE, type TurnSpec, turnConstraintName, turnFractions, turnTwin } from './turn.ts';
+import { applyFaceSurfaceDeform, TURN_BONE, type TurnSpec, turnConstraintName, turnFractions, turnTwin } from './turn.ts';
 import { DISTANCE_EXPONENT, type FloorForm, type Influence, influences, type InfluenceLimits, type MeshInfluences, meshLimits, type Segment } from './weights.ts';
 
 /** Transparent pixels added round every part image — the reference's `PAD`. */
@@ -1996,6 +1996,17 @@ export function buildRig(
   // issue #239: the face's line, written only when the face bones were turned to one, so no other rig moves.
   const axes = [faceAxis.axis, faceAxis.tipAxis].flatMap((x) => (x === null ? [] : [x]));
   if (axes.length > 0) rig.invariants = { ...rig.invariants, axes };
+  const faceImg = outImages.find(([k]) => k === 'face.png')?.[1];
+  const facePart = parts.parts.find((p) => p.name === 'face');
+  bindFaceSurfaceDeform(motion, (merged) => {
+    applyFaceSurfaceDeform(rig, merged, {
+      imageWidth: faceImg?.width,
+      imageHeight: faceImg?.height,
+      opaqueWidth: facePart?.w,
+      opaqueHeight: facePart?.h,
+      overrides: cfg.turn?.deform,
+    });
+  });
   return { rig, motion, meshReport, images: outImages, controls, meshKeyed, idleKeys, loopPasses, autoMotion, faceAxis, turn: turned?.rows ?? null };
 }
 

package/src/turn.ts

@@ -28,6 +28,7 @@
  * that the depth maps do not carry relief inside a layer, so a part moves as
  * one piece. Pure: no file, no clock.
  */
+import { computeWorldTransforms, toBoneLocalVector, toWorld, type BoneTransform } from './coords.ts';
 import { pyRound } from './round.ts';
 
 /**
@@ -67,10 +68,108 @@ export const TURN_BONE = 'turn';
 /** The places a pivot and a fraction are written to. */
 export const TURN_PLACES = 6;
 
-/** `config.turn`: the pivot depth and each carried part's See-through `depth_median`. */
+/**
+ * The Set B ×2.5 face surface deformation table (issue #436): per-degree
+ * fractions of the face plate's opaque width `W` and height `H` (and the
+ * dimensionless coupling shares of the hair, ear and topknot parts that sample
+ * the same head field), with the sheet's measurements on a `106×128` plate at
+ * `+15°` beside each entry.
+ */
+export const FACE_DEFORM_FRACTIONS = {
+  /** Mid-face vertical shift per degree of pitch (`H/deg`; `-9.02 px` at `+15°` on `H = 128`). */
+  tilt_mid_y: -0.0047,
+  /** Lower-face chin vertical squash per degree of pitch (`H/deg`; `+5.04 px` squash, chin tip `-3.98 px` at `+15°` on `H = 128`). */
+  tilt_chin_squash_y: 0.002625,
+  /** Forehead/crown extra drop per degree of pitch (`H/deg`; crown `-11.28 px` at `+15°` on `H = 128`). */
+  tilt_crown_drop_y: -0.001175,
+  /** Forehead/jaw perspective horizontal taper per degree of pitch (`W/deg`; `±4.77 px` at `+15°` on `W = 106`). */
+  tilt_taper_x: 0.003,
+  /** Mid-face and chin horizontal shift per degree of yaw (`W/deg`; `-9.54 px` at `+15°` on `W = 106`). */
+  turn_mid_x: -0.006,
+  /** Far (leading) cheek inward compression per degree of yaw (`W/deg`; far cheek `+3.75 px` inward at `+15°` on `W = 106`). */
+  turn_lead_compress_x: 0.00835,
+  /** Near (trailing) cheek shift beyond mid-face per degree of yaw (`W/deg`; near cheek `-10.50 px` at `+15°` on `W = 106`, total narrowing `-14.25 px` = `-13.4% W`). */
+  turn_trail_shift_x: -0.0006,
+  /** Cheek-arch vertical lift/drop per degree of yaw (`H/deg`; `±1.20 px` at `+15°` on `H = 128`). */
+  turn_cheek_arch_y: 0.000625,
+  /** Forehead bang base vertical travel per degree of pitch (`H/deg`; `-3.00 px` at `+15°` on `H = 128`). */
+  tilt_bang_base_y: -0.0015625,
+  /** Share of the pitch vertical surface field carried by `hair_front` (`0.95×` of `dySurf`). */
+  tilt_hair_front_y: 0.95,
+  /** Share of the pitch vertical surface field carried by lower `hair_back` (`0.85×` of `dySurf`). */
+  tilt_hair_back_lower_y: 0.85,
+  /** Share of the pitch vertical surface field carried by upper `hair_back` (`0.45×` of `dySurf`). */
+  tilt_hair_back_bun_y: 0.45,
+  /** Share of the pitch horizontal taper carried at the top of `hair_back` (`0.60×` of `dxSurf`). */
+  tilt_hair_back_bun_x: 0.6,
+  /** Share of the pitch vertical surface field carried by `ears` (`0.55×` of `dySurf`, `-4.31 px` at `+15°`). */
+  tilt_ear_y: 0.55,
+  /** Share of the crown pitch vertical field carried by `topknot` (`0.50×` of crown `dySurf`, `-5.64 px` at `+15°`). */
+  tilt_topknot_y: 0.5,
+  /** Forehead bang forward parallax per degree of yaw (`W/deg`; `-3.50 px` at `+15°` on `W = 106`). */
+  turn_bang_parallax_x: -(3.5 / 15) / 106,
+  /** Share of the cheek yaw horizontal field carried by lower `hair_back` (`0.90×` of `dxCheek`). */
+  turn_hair_back_cheek_x: 0.9,
+  /** Rear bun counter-parallax per degree of yaw (`W/deg`; `+8.00 px` at `+15°` on `W = 106`). */
+  turn_bun_counter_x: 8.0 / 15 / 106,
+  /** Rear hairpin counter-parallax per degree of yaw (`W/deg`; `+6.00 px` at `+15°` on `W = 106`). */
+  turn_hairpin_counter_x: 6.0 / 15 / 106,
+  /** Share of the cheek-edge yaw horizontal field carried by `ear_r` and `ear_l` (`0.85×` of `dxCheekEdge`, `-8.92 px` / `+3.14 px` at `+15°`). */
+  turn_ear_x: 0.85,
+} as const;
+
+export type FaceDeformKey = keyof typeof FACE_DEFORM_FRACTIONS;
+export type FaceDeformFractions = Record<FaceDeformKey, number>;
+
+/**
+ * Allowed `[min, max]` range for each key of {@link FACE_DEFORM_FRACTIONS}; an
+ * override in `config.turn.deform` outside its stated interval is refused by
+ * name (`CONFIG_TURN_DEFORM_RANGE`).
+ */
+export const FACE_DEFORM_RANGES: Readonly<Record<FaceDeformKey, readonly [number, number]>> = {
+  tilt_mid_y: [-0.02, 0],
+  tilt_chin_squash_y: [0, 0.015],
+  tilt_crown_drop_y: [-0.01, 0],
+  tilt_taper_x: [0, 0.015],
+  turn_mid_x: [-0.02, 0],
+  turn_lead_compress_x: [0, 0.025],
+  turn_trail_shift_x: [-0.01, 0.01],
+  turn_cheek_arch_y: [0, 0.01],
+  tilt_bang_base_y: [-0.01, 0],
+  tilt_hair_front_y: [0, 1.5],
+  tilt_hair_back_lower_y: [0, 1.5],
+  tilt_hair_back_bun_y: [0, 1.5],
+  tilt_hair_back_bun_x: [0, 1.5],
+  tilt_ear_y: [0, 1.5],
+  tilt_topknot_y: [0, 1.5],
+  turn_bang_parallax_x: [-0.015, 0],
+  turn_hair_back_cheek_x: [0, 1.5],
+  turn_bun_counter_x: [0, 0.02],
+  turn_hairpin_counter_x: [0, 0.02],
+  turn_ear_x: [0, 1.5],
+};
+
+/** Uneven 5×5 grid columns and rows for the `face` plate mesh (issue #436). */
+export const FACE_DEFORM_GRID_US: readonly number[] = [0, 0.18, 0.5, 0.82, 1];
+export const FACE_DEFORM_GRID_VS: readonly number[] = [0, 0.22, 0.5, 0.78, 1];
+
+/** Resolve {@link FACE_DEFORM_FRACTIONS} with optional recipe overrides. */
+export function resolveFaceDeformFractions(overrides?: Readonly<Partial<FaceDeformFractions>> | null): FaceDeformFractions {
+  const out: FaceDeformFractions = { ...FACE_DEFORM_FRACTIONS };
+  if (overrides !== undefined && overrides !== null) {
+    for (const k of Object.keys(FACE_DEFORM_FRACTIONS) as FaceDeformKey[]) {
+      const v = overrides[k];
+      if (typeof v === 'number') out[k] = v;
+    }
+  }
+  return out;
+}
+
+/** `config.turn`: the pivot depth, each carried part's See-through `depth_median`, and optional face surface deform overrides. */
 export interface TurnSpec {
   pivot: number;
   depths: Record<string, number>;
+  deform?: Partial<FaceDeformFractions>;
 }
 
 /** One carried part: its depth and the fraction of the control's offset it travels. */
@@ -128,3 +227,568 @@ export function turnTwin(part: string, bone: string): string {
 export function turnConstraintName(part: string): string {
   return `${TURN_BONE}_${part}`;
 }
+
+const FACE_DEFORM_MULT = 2.5;
+const unmult = (v: number): number => pyRound(v / FACE_DEFORM_MULT, 8);
+
+/**
+ * Evaluate the pitch (`tilt`) surface deformation field `(dx, dy)` in `head`
+ * space at `(hx, hy)` for `deg` degrees of pitch.
+ */
+export function evalPitchFaceSurface(
+  hx: number,
+  hy: number,
+  deg: number,
+  W: number,
+  H: number,
+  X0: number,
+  Y0: number,
+  f: Readonly<FaceDeformFractions> = FACE_DEFORM_FRACTIONS,
+): [number, number] {
+  if (deg === 0) return [0, 0];
+  const ux = Math.max(-1.35, Math.min(1.35, (hx - X0) / (W / 2)));
+  const uy = Math.max(-1.35, Math.min(1.35, (hy - Y0) / (H / 2)));
+  const uChin = Math.min(1.2, Math.max(0, -uy));
+  const uCrown = Math.min(1.2, Math.max(0, uy));
+  const fracYPerDeg = unmult(f.tilt_mid_y) + unmult(f.tilt_chin_squash_y) * Math.pow(uChin, 1.25) + unmult(f.tilt_crown_drop_y) * Math.pow(uCrown, 1.25);
+  const fracXPerDeg = unmult(f.tilt_taper_x) * ux * Math.max(-1.1, Math.min(1.1, uy));
+  return [FACE_DEFORM_MULT * deg * W * fracXPerDeg, FACE_DEFORM_MULT * deg * H * fracYPerDeg];
+}
+
+/**
+ * Evaluate the yaw (`turn`) surface deformation field `(dx, dy)` in `head`
+ * space at `(hx, hy)` for `deg` degrees of yaw.
+ */
+export function evalYawFaceSurface(
+  hx: number,
+  hy: number,
+  deg: number,
+  W: number,
+  H: number,
+  X0: number,
+  Y0: number,
+  f: Readonly<FaceDeformFractions> = FACE_DEFORM_FRACTIONS,
+): [number, number] {
+  if (deg === 0) return [0, 0];
+  const s = Math.sign(deg);
+  const ux = Math.max(-1.35, Math.min(1.35, (hx - X0) / (W / 2)));
+  const uy = Math.max(-1.35, Math.min(1.35, (hy - Y0) / (H / 2)));
+  const uLead = Math.min(1.2, Math.max(0, -s * ux));
+  const uTrail = Math.min(1.2, Math.max(0, s * ux));
+  const fracXPerDeg = unmult(f.turn_mid_x) + unmult(f.turn_lead_compress_x) * Math.pow(uLead, 1.2) + unmult(f.turn_trail_shift_x) * Math.pow(uTrail, 1.2);
+  const fracYPerDeg = unmult(f.turn_cheek_arch_y) * (-s * ux) * Math.max(0, 1 - Math.abs(uy));
+  return [FACE_DEFORM_MULT * deg * W * fracXPerDeg, FACE_DEFORM_MULT * deg * H * fracYPerDeg];
+}
+
+export interface FaceSurfaceDeformOptions {
+  /** Padded `face.png` width in rig px (defaults to the mesh width or 114). */
+  imageWidth?: number;
+  /** Padded `face.png` height in rig px (defaults to the mesh height or 136). */
+  imageHeight?: number;
+  /** Opaque face plate width `W` in rig px (defaults to `imageWidth - 8`). */
+  opaqueWidth?: number;
+  /** Opaque face plate height `H` in rig px (defaults to `imageHeight - 8`). */
+  opaqueHeight?: number;
+  /** Recipe overrides for {@link FACE_DEFORM_FRACTIONS}. */
+  overrides?: Readonly<Partial<FaceDeformFractions>> | null;
+}
+
+interface DeformWeight {
+  bone: string;
+  x: number;
+  y: number;
+  weight: number;
+}
+
+interface DeformMeshAttachment {
+  type: 'mesh';
+  image: string;
+  width: number;
+  height: number;
+  uvs: number[];
+  triangles: number[];
+  hull: number;
+  weights: DeformWeight[][];
+}
+
+interface DeformRegionAttachment {
+  image: string;
+  x: number;
+  y: number;
+  rotation?: number;
+}
+
+interface DeriveSpec {
+  kind: 'yaw' | 'pitch';
+  degrees: number;
+  about?: number;
+  depth?: number | Readonly<Record<string, number>>;
+  carried?: number | Readonly<Record<string, number>>;
+}
+
+interface SliderKey {
+  t: number;
+  v?: number[];
+  derive?: DeriveSpec;
+}
+
+interface SliderTrack {
+  bone?: string;
+  group?: string;
+  property: string;
+  keys: SliderKey[];
+}
+
+interface DeformTimelineEntry {
+  slot: string;
+  attachment: string;
+  keys: Array<{ t: number; vertices?: number[] }>;
+}
+
+interface SliderAnimation {
+  duration: number;
+  tracks: SliderTrack[];
+  deform?: DeformTimelineEntry[];
+}
+
+function buildFaceGrid(width: number, height: number): { points: Array<[number, number]>; uvs: number[]; triangles: number[]; hull: number } {
+  const us = FACE_DEFORM_GRID_US;
+  const vs = FACE_DEFORM_GRID_VS;
+  const cols = us.length - 1;
+  const rows = vs.length - 1;
+  const ring: Array<[number, number]> = [];
+  for (let c = 0; c <= cols; c++) ring.push([c, 0]);
+  for (let r = 1; r <= rows; r++) ring.push([cols, r]);
+  for (let c = cols - 1; c >= 0; c--) ring.push([c, rows]);
+  for (let r = rows - 1; r >= 1; r--) ring.push([0, r]);
+  const interior: Array<[number, number]> = [];
+  for (let r = 1; r < rows; r++) for (let c = 1; c < cols; c++) interior.push([c, r]);
+  const all = [...ring, ...interior];
+  const idx = new Map<string, number>();
+  all.forEach(([c, r], i) => idx.set(`${c},${r}`, i));
+  const points: Array<[number, number]> = [];
+  const uvs: number[] = [];
+  for (const [c, r] of all) {
+    const u = us[c];
+    const v = vs[r];
+    points.push([u * width, v * height]);
+    uvs.push(pyRound(u, 6), pyRound(v, 6));
+  }
+  const triangles: number[] = [];
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const tl = idx.get(`${c},${r}`) as number;
+      const tr = idx.get(`${c + 1},${r}`) as number;
+      const bl = idx.get(`${c},${r + 1}`) as number;
+      const br = idx.get(`${c + 1},${r + 1}`) as number;
+      triangles.push(tl, bl, br, tl, br, tr);
+    }
+  }
+  return { points, uvs, triangles, hull: ring.length };
+}
+
+/**
+ * Promote the `face` region on `head` to a 5×5 grid mesh and populate the
+ * `tilt` and `turn` slider animations with the Set B ×2.5 face and hair mesh
+ * deform timelines and ear/topknot tracks (issue #436). When `motion` holds
+ * neither `tilt` nor `turn` with slider `derive` keys, neither `rig` nor
+ * `motion` is touched.
+ */
+export function applyFaceSurfaceDeform(
+  rig: {
+    bones: Array<{ name: string; parent?: string; x: number; y: number; rotation?: number; length?: number; inherit?: string }>;
+    skins: { default: Record<string, Record<string, DeformMeshAttachment | DeformRegionAttachment>> };
+    invariants?: Record<string, unknown>;
+  },
+  motion: {
+    groups?: Record<string, string[]>;
+    animations: Record<string, unknown>;
+  },
+  options?: FaceSurfaceDeformOptions | Readonly<Partial<FaceDeformFractions>> | null,
+): void {
+  const rawTilt = motion.animations.tilt as SliderAnimation | undefined;
+  const rawTurn = motion.animations.turn as SliderAnimation | undefined;
+  if (rawTilt === undefined && rawTurn === undefined) return;
+  const hasDerive =
+    (rawTilt?.tracks?.some((tr) => tr.keys?.some((k) => k.derive !== undefined)) ?? false) ||
+    (rawTurn?.tracks?.some((tr) => tr.keys?.some((k) => k.derive !== undefined)) ?? false);
+  if (!hasDerive) return;
+  const tiltAnim = rawTilt === undefined ? undefined : structuredClone(rawTilt);
+  const turnAnim = rawTurn === undefined ? undefined : structuredClone(rawTurn);
+  if (tiltAnim !== undefined) motion.animations.tilt = tiltAnim;
+  if (turnAnim !== undefined) motion.animations.turn = turnAnim;
+
+  const isOpts =
+    options !== undefined &&
+    options !== null &&
+    ('imageWidth' in options || 'imageHeight' in options || 'opaqueWidth' in options || 'opaqueHeight' in options || 'overrides' in options);
+  const opts: FaceSurfaceDeformOptions = isOpts ? (options as FaceSurfaceDeformOptions) : { overrides: options as Readonly<Partial<FaceDeformFractions>> | null | undefined };
+  const f = resolveFaceDeformFractions(opts.overrides);
+
+  const faceSlot = rig.skins.default.face;
+  if (faceSlot === undefined || faceSlot.face === undefined) return;
+  const faceAtt = faceSlot.face;
+
+  let faceW = opts.imageWidth ?? 114;
+  let faceH = opts.imageHeight ?? 136;
+  let faceRegX = -1;
+  let faceRegY = 49;
+
+  if (!('type' in faceAtt)) {
+    faceRegX = faceAtt.x;
+    faceRegY = faceAtt.y;
+    const grid = buildFaceGrid(faceW, faceH);
+    const faceWeights: DeformWeight[][] = grid.points.map(([px, py]) => [
+      {
+        bone: 'head',
+        x: pyRound(faceRegX - faceW / 2 + px, 6),
+        y: pyRound(faceRegY + faceH / 2 - py, 6),
+        weight: 1,
+      },
+    ]);
+    faceSlot.face = {
+      type: 'mesh',
+      image: faceAtt.image,
+      width: faceW,
+      height: faceH,
+      uvs: grid.uvs,
+      triangles: grid.triangles,
+      hull: grid.hull,
+      weights: faceWeights,
+    };
+    if (rig.invariants !== undefined) {
+      if (typeof rig.invariants.meshSlots === 'number') rig.invariants.meshSlots += 1;
+      if (typeof rig.invariants.meshTriangles === 'number') rig.invariants.meshTriangles += grid.triangles.length / 3;
+    }
+  } else {
+    faceW = faceAtt.width;
+    faceH = faceAtt.height;
+    let sumX = 0;
+    let sumY = 0;
+    for (const w of faceAtt.weights) {
+      sumX += w[0]?.x ?? 0;
+      sumY += w[0]?.y ?? 0;
+    }
+    if (faceAtt.weights.length > 0) {
+      faceRegX = Math.round(sumX / faceAtt.weights.length);
+      faceRegY = Math.round(sumY / faceAtt.weights.length);
+    }
+  }
+
+  const W = opts.opaqueWidth ?? faceW - 8;
+  const H = opts.opaqueHeight ?? faceH - 8;
+  const X0 = faceRegX;
+  const Y0 = faceRegY - 1;
+
+  const boneOrder = new Map<string, number>(rig.bones.map((b, i) => [b.name, i]));
+  for (const slotName of ['hair_front', 'hair_back']) {
+    const slotObj = rig.skins.default[slotName];
+    const att = slotObj?.[slotName];
+    if (att !== undefined && 'type' in att) {
+      for (const infls of att.weights) {
+        infls.sort((a, b) => (boneOrder.get(a.bone) ?? 0) - (boneOrder.get(b.bone) ?? 0));
+      }
+    }
+  }
+
+  const tf = computeWorldTransforms(rig.bones);
+  const headTf = tf.get('head') as BoneTransform | undefined;
+  if (headTf === undefined) return;
+
+  interface VertexSetup {
+    hx: number;
+    hy: number;
+    boneWeights: Record<string, number>;
+    infls: DeformWeight[];
+  }
+
+  const getMeshSetup = (att: DeformMeshAttachment): VertexSetup[] =>
+    att.weights.map((infls) => {
+      let wx = 0;
+      let wy = 0;
+      const boneWeights: Record<string, number> = {};
+      for (const inf of infls) {
+        const m = tf.get(inf.bone) as BoneTransform;
+        const [x, y] = toWorld(m, inf.x, inf.y);
+        wx += x * inf.weight;
+        wy += y * inf.weight;
+        boneWeights[inf.bone] = (boneWeights[inf.bone] ?? 0) + inf.weight;
+      }
+      return { hx: wx - headTf.worldX, hy: wy - headTf.worldY, boneWeights, infls };
+    });
+
+  const expandToDeform = (verts: readonly VertexSetup[], evalVertex: (v: VertexSetup) => [number, number]): number[] => {
+    const out: number[] = [];
+    for (const v of verts) {
+      const [dx, dy] = evalVertex(v);
+      for (const inf of v.infls) {
+        const m = tf.get(inf.bone) as BoneTransform;
+        const [bx, by] = toBoneLocalVector(m, dx, dy);
+        out.push(pyRound(bx, 4), pyRound(by, 4));
+      }
+    }
+    return out;
+  };
+
+  const boneMap = new Map(rig.bones.map((b) => [b.name, b]));
+  const evalDeriveKey = (boneName: string, k: SliderKey): number => {
+    if (Array.isArray(k.v)) return k.v[0] ?? 0;
+    const d = k.derive;
+    if (d === undefined) return 0;
+    const b = boneMap.get(boneName);
+    const coord = d.kind === 'yaw' ? (b?.x ?? 0) : (b?.y ?? 0);
+    const rad = (d.degrees * Math.PI) / 180;
+    const depth = typeof d.depth === 'number' ? d.depth : (d.depth?.[boneName] ?? 0);
+    const carried = typeof d.carried === 'number' ? d.carried : (d.carried?.[boneName] ?? 0);
+    const val = (coord - (d.about ?? 0)) * (Math.cos(rad) - 1) - (depth - carried) * Math.sin(rad);
+    const r = Math.round(val * 1e6) / 1e6;
+    return r === 0 ? 0 : r;
+  };
+
+  const mapParent: Readonly<Record<string, string>> = {
+    bang_r0: 'bang_r0_ctl',
+    bang_r1: 'bang_r0_ctl',
+    bang_c0: 'bang_c0_ctl',
+    bang_c1: 'bang_c0_ctl',
+    bang_l0: 'bang_l0_ctl',
+    bang_l1: 'bang_l0_ctl',
+    bun: 'bun_ctl',
+  };
+
+  const getBoneDeltaAtTime = (tracks: readonly SliderTrack[], t: number, boneName: string): [number, number] => {
+    const driver = mapParent[boneName] ?? boneName;
+    let dx = 0;
+    let dy = 0;
+    for (const tr of tracks) {
+      const inGroup = tr.group !== undefined && (motion.groups?.[tr.group]?.includes(driver) ?? false);
+      if (tr.bone !== driver && !inGroup) continue;
+      const key = tr.keys.find((k) => Math.abs(k.t - t) < 1e-6);
+      if (key === undefined) continue;
+      const val = evalDeriveKey(driver, key);
+      if (tr.property === 'translatex') dx = val;
+      if (tr.property === 'translatey') dy = val;
+    }
+    return [dx, dy];
+  };
+
+  const getVertexBoneDelta = (v: VertexSetup, tracks: readonly SliderTrack[], t: number): [number, number] => {
+    let bx = 0;
+    let by = 0;
+    for (const [bname, w] of Object.entries(v.boneWeights)) {
+      const [dx, dy] = getBoneDeltaAtTime(tracks, t, bname);
+      bx += dx * w;
+      by += dy * w;
+    }
+    return [bx, by];
+  };
+
+  const faceMesh = faceSlot.face as DeformMeshAttachment;
+  const faceVerts = getMeshSetup(faceMesh);
+  const hairFrontAtt = rig.skins.default.hair_front?.hair_front;
+  const hairBackAtt = rig.skins.default.hair_back?.hair_back;
+  const hairFrontVerts = hairFrontAtt !== undefined && 'type' in hairFrontAtt ? getMeshSetup(hairFrontAtt) : null;
+  const hairBackVerts = hairBackAtt !== undefined && 'type' in hairBackAtt ? getMeshSetup(hairBackAtt) : null;
+
+  const hyCrown = Y0 + (67 / 128) * H;
+  const hyBunSpan = (85 / 128) * H;
+  const hyBangBottom = Y0 - (68 / 128) * H;
+  const hyBangSpan = (130 / 128) * H;
+  const hyTurnBangBottom = Y0 - (28 / 128) * H;
+  const hyTurnBangSpan = (80 / 128) * H;
+  const hyEar = Y0 - (16 / 128) * H;
+  const earRx = boneMap.get('ear_r')?.x ?? -51;
+  const earLx = boneMap.get('ear_l')?.x ?? 47.5;
+
+  if (tiltAnim !== undefined) {
+    const origTiltTracks = tiltAnim.tracks.map((tr) => ({ ...tr, keys: [...tr.keys] }));
+    const tiltKeys: Array<{ t: number; deg: number }> = [
+      { t: 0, deg: -25 },
+      { t: 0.75, deg: -10 },
+      { t: 1.25, deg: 0 },
+      { t: 2.0, deg: 15 },
+      { t: 2.5, deg: 25 },
+    ];
+    const tiltDeform: DeformTimelineEntry[] = [
+      {
+        slot: 'face',
+        attachment: 'face',
+        keys: tiltKeys.map(({ t, deg }) =>
+          deg === 0 ? { t } : { t, vertices: expandToDeform(faceVerts, (v) => evalPitchFaceSurface(v.hx, v.hy, deg, W, H, X0, Y0, f)) },
+        ),
+      },
+    ];
+    if (hairFrontVerts !== null) {
+      tiltDeform.push({
+        slot: 'hair_front',
+        attachment: 'hair_front',
+        keys: tiltKeys.map(({ t, deg }) =>
+          deg === 0
+            ? { t }
+            : {
+                t,
+                vertices: expandToDeform(hairFrontVerts, (v) => {
+                  const [dxSurf, dySurf] = evalPitchFaceSurface(v.hx, v.hy, deg, W, H, X0, Y0, f);
+                  const [bx, by] = getVertexBoneDelta(v, origTiltTracks, t);
+                  const baseBangDy = (deg / 15) * (f.tilt_bang_base_y * 15 * H) * Math.max(0, Math.min(1, (v.hy - hyBangBottom) / hyBangSpan));
+                  return [dxSurf - bx, baseBangDy + dySurf * f.tilt_hair_front_y - by];
+                }),
+              },
+        ),
+      });
+    }
+    if (hairBackVerts !== null) {
+      tiltDeform.push({
+        slot: 'hair_back',
+        attachment: 'hair_back',
+        keys: tiltKeys.map(({ t, deg }) =>
+          deg === 0
+            ? { t }
+            : {
+                t,
+                vertices: expandToDeform(hairBackVerts, (v) => {
+                  const [bx, by] = getVertexBoneDelta(v, origTiltTracks, t);
+                  const [dxSurf, dySurf] = evalPitchFaceSurface(v.hx, Math.min(hyCrown, v.hy), deg, W, H, X0, Y0, f);
+                  const uBun = Math.max(0, Math.min(1, (v.hy - hyCrown) / hyBunSpan));
+                  const targetDy = (1 - uBun) * (dySurf * f.tilt_hair_back_lower_y) + uBun * (dySurf * f.tilt_hair_back_bun_y);
+                  return [dxSurf * (1 - pyRound(1 - f.tilt_hair_back_bun_x, 8) * uBun) - bx, targetDy - by];
+                }),
+              },
+        ),
+      });
+    }
+    for (const tr of tiltAnim.tracks) {
+      if (tr.group === 'ears' && tr.property === 'translatey') {
+        tr.keys = tr.keys.map((k) => {
+          const deg = k.derive?.degrees ?? 0;
+          if (deg === 0) return { t: k.t, v: [0] };
+          const [, dyEar] = evalPitchFaceSurface(0, hyEar, deg, W, H, X0, Y0, f);
+          return { t: k.t, v: [pyRound(dyEar * f.tilt_ear_y, 4)] };
+        });
+      }
+      if (tr.group === 'topknot' && tr.property === 'translatey') {
+        tr.keys = tr.keys.map((k) => {
+          const deg = k.derive?.degrees ?? 0;
+          if (deg === 0) return { t: k.t, v: [0] };
+          const [, dyCrown] = evalPitchFaceSurface(0, hyCrown, deg, W, H, X0, Y0, f);
+          return { t: k.t, v: [pyRound(dyCrown * f.tilt_topknot_y, 4)] };
+        });
+      }
+    }
+    const refTiltKeys = origTiltTracks[0]?.keys ?? [];
+    for (const [earBone, earHx] of [
+      ['ear_r', earRx],
+      ['ear_l', earLx],
+    ] as const) {
+      if (!boneMap.has(earBone)) continue;
+      tiltAnim.tracks.push({
+        bone: earBone,
+        property: 'translatex',
+        keys: refTiltKeys.map((k) => {
+          const deg = k.derive?.degrees ?? 0;
+          if (deg === 0) return { t: k.t, v: [0] };
+          const [dxEar] = evalPitchFaceSurface(earHx, hyEar, deg, W, H, X0, Y0, f);
+          return { t: k.t, v: [pyRound(dxEar, 4)] };
+        }),
+      });
+    }
+    tiltAnim.deform = tiltDeform;
+  }
+
+  if (turnAnim !== undefined) {
+    const origTurnTracks = turnAnim.tracks.map((tr) => ({ ...tr, keys: [...tr.keys] }));
+    const turnKeys: Array<{ t: number; deg: number }> = [
+      { t: 0, deg: -30 },
+      { t: 0.75, deg: -15 },
+      { t: 1.5, deg: 0 },
+      { t: 2.25, deg: 15 },
+      { t: 3.0, deg: 30 },
+    ];
+    const turnDeform: DeformTimelineEntry[] = [
+      {
+        slot: 'face',
+        attachment: 'face',
+        keys: turnKeys.map(({ t, deg }) =>
+          deg === 0 ? { t } : { t, vertices: expandToDeform(faceVerts, (v) => evalYawFaceSurface(v.hx, v.hy, deg, W, H, X0, Y0, f)) },
+        ),
+      },
+    ];
+    if (hairFrontVerts !== null) {
+      turnDeform.push({
+        slot: 'hair_front',
+        attachment: 'hair_front',
+        keys: turnKeys.map(({ t, deg }) =>
+          deg === 0
+            ? { t }
+            : {
+                t,
+                vertices: expandToDeform(hairFrontVerts, (v) => {
+                  const [dxSurf, dySurf] = evalYawFaceSurface(v.hx, v.hy, deg, W, H, X0, Y0, f);
+                  const [bx, by] = getVertexBoneDelta(v, origTurnTracks, t);
+                  const uBang = Math.max(0, Math.min(1, (v.hy - hyTurnBangBottom) / hyTurnBangSpan));
+                  const bangParallaxX = (deg / 15) * pyRound(f.turn_bang_parallax_x * 15 * W, 8) * uBang;
+                  return [bangParallaxX + dxSurf - bx, dySurf - by];
+                }),
+              },
+        ),
+      });
+    }
+    if (hairBackVerts !== null) {
+      turnDeform.push({
+        slot: 'hair_back',
+        attachment: 'hair_back',
+        keys: turnKeys.map(({ t, deg }) =>
+          deg === 0
+            ? { t }
+            : {
+                t,
+                vertices: expandToDeform(hairBackVerts, (v) => {
+                  const [bx, by] = getVertexBoneDelta(v, origTurnTracks, t);
+                  const [dxCheek, dyCheek] = evalYawFaceSurface(v.hx, v.hy, deg, W, H, X0, Y0, f);
+                  const uBun = Math.max(0, Math.min(1, (v.hy - hyCrown) / hyBunSpan));
+                  const bunCounterX = FACE_DEFORM_MULT * (deg / 15) * pyRound((f.turn_bun_counter_x * 15 * W) / FACE_DEFORM_MULT, 8);
+                  const targetDx = (1 - uBun) * (dxCheek * f.turn_hair_back_cheek_x) + uBun * bunCounterX;
+                  return [targetDx - bx, (1 - uBun) * dyCheek - by];
+                }),
+              },
+        ),
+      });
+    }
+    const refTurnKeys = origTurnTracks[0]?.keys ?? [];
+    turnAnim.tracks = turnAnim.tracks.filter(
+      (tr) => !(tr.group === 'ears' && tr.property === 'translatex') && !(tr.group === 'topknot' && tr.property === 'translatex'),
+    );
+    for (const [earBone, earHx] of [
+      ['ear_r', earRx],
+      ['ear_l', earLx],
+    ] as const) {
+      if (!boneMap.has(earBone)) continue;
+      turnAnim.tracks.push({
+        bone: earBone,
+        property: 'translatex',
+        keys: refTurnKeys.map((k) => {
+          const deg = k.derive?.degrees ?? 0;
+          if (deg === 0) return { t: k.t, v: [0] };
+          const [dxCheekEdge] = evalYawFaceSurface(earHx, hyEar, deg, W, H, X0, Y0, f);
+          return { t: k.t, v: [pyRound(dxCheekEdge * f.turn_ear_x, 4)] };
+        }),
+      });
+    }
+    for (const [tkBone, tkFrac] of [
+      ['bun_ctl', f.turn_bun_counter_x],
+      ['hairpin', f.turn_hairpin_counter_x],
+    ] as const) {
+      if (!boneMap.has(tkBone)) continue;
+      turnAnim.tracks.push({
+        bone: tkBone,
+        property: 'translatex',
+        keys: refTurnKeys.map((k) => {
+          const deg = k.derive?.degrees ?? 0;
+          if (deg === 0) return { t: k.t, v: [0] };
+          const tkPx = pyRound((tkFrac * 15 * W) / FACE_DEFORM_MULT, 8);
+          return { t: k.t, v: [pyRound(FACE_DEFORM_MULT * (deg / 15) * tkPx, 4)] };
+        }),
+      });
+    }
+    turnAnim.deform = turnDeform;
+  }
+}