@developerz.ai/ts23d 0.1.0 → 0.2.0

package/src/kinds/head-face.ts

@@ -7,6 +7,7 @@ import type { Vec3 } from '../core/index.ts';
 import type { SculptEdit } from '../primitives/index.ts';
 import { alongX, alongZ, unit } from './head-geom.ts';
 import type { HeadLayout } from './head-layout.ts';
+import { mouthEdits } from './head-mouth.ts';
 import type { HeadParams } from './head-params.ts';
 
 /** Brain case + face plate: the forms the eyes are seated against (head.ts probes them). */
@@ -24,27 +25,40 @@ export function primaryEdits(l: HeadLayout): SculptEdit[] {
   ];
 }
 
-export function skullEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
+/** `cell`: the sculpt cell (head units). Far LODs drop the teeth and floor the nose's radii at
+ *  about 0.6 cells so a long nose survives. */
+export function skullEdits(p: HeadParams, l: HeadLayout, cell = 0): SculptEdit[] {
+  const fine = cell < 0.03;
+  const tipR = Math.max(p.nose.tip, cell * 0.6);
   const c = p.colors;
   const cx = l.cranium.at[0];
   const [ex, ey, ez] = l.eye;
   const r = l.eyeR;
-  const lipT = p.mouth.lips;
   const mw = p.mouth.width;
   const [ax, ay, az] = l.angle;
   const [hx, hz] = l.hinge;
   const chin = l.chin;
   const tipX = l.faceX + 0.06 + p.nose.length * 0.25 + p.nose.bridge + p.jaw.muzzle * 0.5;
   const tipZ = l.noseZ + 0.035 - p.nose.hook;
+  const bIn: Vec3 = [ex + r * 0.75, 0.03, l.browZ - p.brow.scowl];
+  const bOut: Vec3 = [ex + r * 0.05, ey + r * 1.3, l.browZ + p.brow.scowl * 0.5];
   const e: SculptEdit[] = [
     // Primary: brain case, face plate, cheek bones, muzzle, mandible, chin, neck.
     ...primaryEdits(l),
     {
       shape: 'ellipsoid',
       at: [ex - 0.03, (ey + 0.06) * p.cheeks.width, ez - r - 0.065 * p.cheeks.size],
-      size: [0.09 * p.cheeks.size, 0.08 * p.cheeks.size, 0.065 * p.cheeks.size],
+      size: [0.075 * p.cheeks.size, 0.07 * p.cheeks.size, 0.055 * p.cheeks.size],
       rotate: [0, 0, 25],
-      blend: 0.09,
+      blend: 0.08,
+    },
+    // Zygomatic arch: the cheekbone ridge running back from under the eye towards the ear.
+    {
+      shape: 'capsule',
+      at: [ex - r * 0.2, (ey + 0.05) * p.cheeks.width, ez - r - 0.03],
+      to: [cx + 0.06, l.cranium.r[1] * 0.92, ez - 0.07],
+      size: 0.028 * p.cheeks.size,
+      blend: 0.05,
     },
     // Maxilla: fills the midface between cheekbones, nose and muzzle.
     {
@@ -77,9 +91,10 @@ export function skullEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
     },
     { shape: 'sphere', at: [ax + 0.02, ay * 0.95, az], size: 0.065, blend: 0.07 },
     {
-      shape: 'ellipsoid',
+      shape: 'roundBox',
       at: chin,
-      size: [0.065 * p.jaw.chin, 0.09 * p.jaw.chin, 0.07 * p.jaw.chin],
+      size: [0.13 * p.jaw.chin, 0.18 * p.jaw.chin, 0.14 * p.jaw.chin],
+      round: 0.06 * p.jaw.chin,
       blend: 0.06,
     },
     {
@@ -89,13 +104,32 @@ export function skullEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
       size: p.neck.radius,
       blend: 0.1,
     },
-    // Secondary: sockets, brow, lids.
+    // Sternocleidomastoid: the cords from behind the ear to the throat.
     {
       shape: 'capsule',
-      at: [ex + r * 0.75, 0.025, l.browZ - p.brow.scowl],
-      to: [ex + r * 0.1, ey + r * 1.25, l.browZ + p.brow.scowl * 0.5],
-      size: p.brow.ridge,
-      blend: 0.06,
+      at: [cx - 0.03, l.cranium.r[1] * 0.68, ez - 0.28],
+      to: [cx + p.neck.radius * 0.6, 0.05, l.base + 0.74],
+      size: p.neck.radius * 0.26,
+      blend: 0.05,
+    },
+    // Secondary: brow shelf (a flattened bar along the brow line, lowered inside by the scowl)
+    // with the glabella knot between the eyes, then the sockets and lids.
+    {
+      shape: 'ellipsoid',
+      at: [(bIn[0] + bOut[0]) / 2, (bIn[1] + bOut[1]) / 2, (bIn[2] + bOut[2]) / 2],
+      size: [
+        Math.hypot(bOut[0] - bIn[0], bOut[1] - bIn[1], bOut[2] - bIn[2]) / 2 + p.brow.ridge * 0.6,
+        p.brow.ridge * 1.25,
+        p.brow.ridge * 0.85,
+      ],
+      rotate: alongX([bOut[0] - bIn[0], bOut[1] - bIn[1], bOut[2] - bIn[2]]),
+      blend: 0.05,
+    },
+    {
+      shape: 'sphere',
+      at: [bIn[0] - 0.01, 0, bIn[2] - p.brow.ridge * 0.15],
+      size: p.brow.ridge * 1.05,
+      blend: 0.05,
     },
     { shape: 'sphere', at: l.eye, size: r * 1.12, op: 'subtract', blend: r * 0.5, color: c.shade },
   ];
@@ -121,66 +155,61 @@ export function skullEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
   };
   e.push(lid(p.eyes.lid, true), lid(p.eyes.lowerLid, false));
   // Nose: bridge (humped by `hook`), tip, wings, nostrils.
+  const long = p.nose.bridge > 0.06 ? 0.65 : 1;
+  const wing = Math.min(1.4, Math.max(0.55, p.nose.width / 0.065)) * long;
+  const rootR = Math.max(0.02 + p.nose.width * 0.6, cell * 0.65);
+  // Nostril wings sit at the nose base, however far a long nose reaches past them.
+  const wingX = Math.min(tipX - p.nose.tip * 1.2, l.faceX + 0.1 + p.jaw.muzzle * 0.5);
   const noseRoot: Vec3 = [ex + r * 0.4, 0, ez - r * 0.4];
   const noseDir: Vec3 = [tipX - noseRoot[0], 0, tipZ + 0.01 - noseRoot[2]];
   const midNose: Vec3 = [
     (ex + r * 0.6 + tipX) / 2,
     0,
-    (ez - 0.02 + tipZ) / 2 + p.nose.hook * 0.6 + 0.01,
+    (ez - 0.02 + tipZ) / 2 + p.nose.hook * 0.3 + 0.01,
   ];
   e.push(
     {
       shape: 'cone',
       at: noseRoot,
-      size: [0.02 + p.nose.width * 0.6, p.nose.tip * 0.8, Math.hypot(...noseDir)],
+      size: [rootR, tipR * 0.85, Math.hypot(...noseDir)],
       rotate: alongZ(noseDir),
-      blend: 0.04,
+      blend: 0.045,
     },
-    { shape: 'sphere', at: midNose, size: 0.02 + p.nose.width * 0.2, blend: 0.04 },
-    { shape: 'sphere', at: [tipX, 0, tipZ], size: p.nose.tip, blend: 0.03 },
     {
-      shape: 'ellipsoid',
-      at: [tipX - p.nose.tip * 1.2, p.nose.width, l.noseZ + 0.02],
-      size: [0.045, 0.035, 0.032],
-      blend: 0.025,
+      shape: 'sphere',
+      at: midNose,
+      size: ((rootR + tipR) / 2) * 0.85 + Math.max(0, p.nose.hook) * 0.12,
+      blend: 0.05,
     },
+    { shape: 'sphere', at: [tipX, 0, tipZ], size: tipR, blend: 0.035 },
+    // A strong hook draws the tip out into a drooping point (one form, not a ball on a stick).
+    ...(p.nose.hook > 0.04
+      ? [
+          {
+            shape: 'cone',
+            at: [tipX, 0, tipZ],
+            size: [tipR * 0.9, 0.01, p.nose.tip + p.nose.hook * 1.2],
+            rotate: alongZ([0.6, 0, -1]),
+            blend: 0.03,
+          } satisfies SculptEdit,
+        ]
+      : []),
     {
       shape: 'ellipsoid',
-      at: [tipX - p.nose.tip * 0.6, p.nose.width * 0.55, l.noseZ + 0.005],
-      size: [0.022, 0.014, 0.012],
-      op: 'subtract',
-      blend: 0.008,
-      color: c.mouth,
-    },
-  );
-  // Lips and the mouth line (a grin opens it and lifts the corners).
-  const g = p.mouth.grin;
-  e.push(
-    {
-      shape: 'ellipsoid',
-      at: [l.mouthX - 0.01, 0, l.mouthZ + lipT * 0.7],
-      size: [0.032, mw, lipT],
-      color: c.lips,
-      blend: 0.03,
+      at: [wingX, p.nose.width, l.noseZ + 0.02],
+      size: [0.045 * wing, 0.035 * wing, 0.032 * wing],
+      blend: 0.025,
     },
     {
       shape: 'ellipsoid',
-      at: [l.mouthX - 0.015 + p.jaw.underbite * 0.7, 0, l.mouthZ - lipT * 0.8],
-      size: [0.034, mw * 0.85, lipT * 1.1],
-      color: c.lips,
-      blend: 0.03,
-    },
-    {
-      shape: 'capsule',
-      at: [l.mouthX + 0.05, 0, l.mouthZ],
-      to: [l.mouthX - 0.03 - 0.02 * g, mw * 0.98, l.mouthZ + 0.012 + g * 0.05],
-      size: 0.006 + g * 0.022,
+      at: [Math.min(tipX - p.nose.tip * 0.6, wingX + 0.035), p.nose.width * 0.55, l.noseZ + 0.005],
+      size: [0.022 * wing, 0.014 * wing, 0.012 * wing],
       op: 'subtract',
-      blend: 0.012,
+      blend: 0.008,
       color: c.mouth,
     },
   );
-  if (g > 0.15) e.push(...teethRows(p, l));
+  e.push(...mouthEdits(p, l, fine));
   // Nasolabial fold from the nose wing towards the mouth corner.
   const fold = unit([-0.02, mw - p.nose.width, l.mouthZ - l.noseZ]);
   e.push({
@@ -192,31 +221,22 @@ export function skullEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
     blend: 0.03,
     color: c.shade,
   });
-  return e;
-}
-
-/** Upper and lower teeth, visible in a grin: rounded blocks along the dental arch. */
-function teethRows(p: HeadParams, l: HeadLayout): SculptEdit[] {
-  const out: SculptEdit[] = [];
-  const mw = p.mouth.width * 0.8;
-  for (let i = 0; i < 4; i++) {
-    const a = ((i + 0.5) / 4) * 0.9;
-    const y = Math.sin(a) * mw;
-    const x = l.mouthX - 0.025 - (1 - Math.cos(a)) * mw * 0.9;
-    const z = l.mouthZ + 0.004 + p.mouth.grin * 0.03 * (i / 4);
-    for (const [dz, h] of [
-      [0.016, 0.02],
-      [-0.016, 0.018],
-    ] as const)
-      out.push({
-        shape: 'roundBox',
-        at: [x, y, z + dz * (1 + p.mouth.grin)],
-        size: [0.02, 0.028, h * (1 + p.mouth.grin * 0.6)],
-        round: 0.006,
-        rotate: [0, 0, (a * 180) / Math.PI],
-        color: p.colors.teeth,
-        blend: 0.003,
-      });
+  // Forehead creases, painted (a groove that thin is below the sculpt cell): thin discs through
+  // the brow, fading where the forehead turns away.
+  const [, , cz] = l.cranium.at;
+  const [crx, , crz] = l.cranium.r;
+  for (let i = 0; i < (p.wrinkles ?? 0); i++) {
+    const z = l.browZ + 0.07 + i * 0.05;
+    const x = cx + crx * Math.sqrt(Math.max(0, 1 - ((z - cz) / crz) ** 2)) + 0.005;
+    e.push({
+      shape: 'ellipsoid',
+      at: [x, 0.06, z - 0.008],
+      size: [0.05, 0.08 - i * 0.012, 0.005],
+      rotate: [-14, -12, 0],
+      op: 'paint',
+      blend: 0.01,
+      color: c.shade,
+    });
   }
-  return out;
+  return e;
 }

package/src/kinds/head-garb.ts

@@ -0,0 +1,181 @@
+// The scrawny tinker's garb (bust style `vest`), layered like real clothing over the bony torso:
+// a shirt shell with a V-neck (clavicles and sternal notch show through), a leather vest shell open
+// down the front, a strap across the chest with a buckle, a scarf wound round the neck and knotted
+// off-centre with hanging tails, and a cowl (a hood worn down) bunched on the back of the neck.
+// Each layer is the torso grown a little (torsoForms) and trimmed by the same bust cut.
+
+import type { Vec3 } from '../core/index.ts';
+import type { SculptEdit } from '../primitives/index.ts';
+import { alongZ, unit } from './head-geom.ts';
+import type { HeadParams } from './head-params.ts';
+import { type BustFrame, bustCut, torsoForms } from './head-torso.ts';
+
+const shade = (c: Vec3, k: number): Vec3 => [c[0] * k, c[1] * k, c[2] * k];
+
+export function vest(p: HeadParams, f: BustFrame): SculptEdit[] {
+  const c = p.colors;
+  const { cx, s, b, nz, n } = f;
+  const scarf = c.scarf ?? c.cloth;
+  const hood = c.cape ?? shade(c.cloth, 0.8);
+  const out: SculptEdit[] = [
+    // Shirt: V-neck down to the sternum.
+    {
+      group: [
+        { group: torsoForms(f, 0.032) },
+        {
+          shape: 'ellipsoid',
+          at: [cx + 0.32, 0, nz + 0.01],
+          size: [0.2, 0.07, 0.11],
+          op: 'subtract',
+          blend: 0.01,
+        },
+        bustCut(f),
+      ],
+      color: c.cloth,
+      blend: 0.006,
+    },
+    // Vest: open down the front, the opening widening to the hem.
+    {
+      group: [
+        { group: torsoForms(f, 0.065) },
+        {
+          shape: 'roundBox',
+          at: [cx + 0.4, 0, b + 0.3],
+          size: [0.5, 0.3, 1],
+          rotate: [0, -8, 0],
+          round: 0.08,
+          op: 'subtract',
+          blend: 0.02,
+        },
+        // Arm holes: the vest stops short of the shoulder tip, so the shirt shows there.
+        {
+          shape: 'sphere',
+          at: [cx - 0.03, s * 0.98, b + 0.42],
+          size: 0.17,
+          op: 'subtract',
+          blend: 0.02,
+        },
+        bustCut(f),
+      ],
+      color: c.leather,
+      blend: 0.006,
+    },
+    // Strap from the right shoulder across to the left hip, with a buckle.
+    {
+      group: [
+        { group: torsoForms(f, 0.088) },
+        {
+          shape: 'roundBox',
+          at: [cx, 0, b + 0.38],
+          size: [4, 4, 0.08],
+          rotate: [-48, 0, 0],
+          op: 'intersect',
+        },
+        bustCut(f),
+      ],
+      color: shade(c.leather, 0.65),
+      blend: 0.004,
+      mirror: false,
+    },
+    {
+      group: [
+        { group: torsoForms(f, 0.105) },
+        {
+          shape: 'roundBox',
+          at: [cx + 0.3, -0.06, b + 0.32],
+          size: [0.3, 0.1, 0.1],
+          rotate: [-48, 0, 0],
+          op: 'intersect',
+        },
+        {
+          shape: 'roundBox',
+          at: [cx + 0.4, -0.06, b + 0.32],
+          size: [0.16, 0.05, 0.05],
+          rotate: [-48, 0, 0],
+          op: 'subtract',
+        },
+      ],
+      color: c.metal,
+      blend: 0.003,
+      mirror: false,
+    },
+    // Hood worn down: a rolled rim round the neck, the bag of it lying on the upper back with
+    // its dark mouth open upward, and a pointed tail hanging down the spine.
+    {
+      group: [
+        {
+          shape: 'torus',
+          at: [cx - 0.1, 0, nz + 0.03],
+          size: [n + 0.12, 0.06],
+          rotate: [0, -28, 0],
+        },
+        {
+          shape: 'roundBox',
+          at: [cx - 1.04, 0, nz],
+          size: [2, 4, 4],
+          op: 'intersect',
+          blend: 0.04,
+        },
+      ],
+      color: hood,
+      blend: 0.03,
+    },
+    {
+      group: [
+        { shape: 'ellipsoid', at: [cx - 0.33, 0, nz - 0.04], size: [0.13, s * 0.5, 0.25] },
+        {
+          shape: 'cone',
+          at: [cx - 0.36, 0, nz - 0.12],
+          size: [0.1, 0.015, 0.34],
+          rotate: alongZ(unit([-0.35, 0, -1])),
+          blend: 0.05,
+        },
+        {
+          shape: 'ellipsoid',
+          at: [cx - 0.3, 0, nz + 0.12],
+          size: [0.08, s * 0.36, 0.1],
+          op: 'subtract',
+          blend: 0.02,
+          color: shade(hood, 0.35),
+        },
+      ],
+      color: hood,
+      blend: 0.04,
+      mirror: false,
+    },
+    // Scarf: a wrap round the neck root, a knot off-centre and two tails.
+    {
+      shape: 'torus',
+      at: [cx - 0.04, 0, nz + 0.17],
+      size: [n + 0.05, 0.065],
+      rotate: [0, -12, 0],
+      color: scarf,
+      blend: 0.02,
+    },
+  ];
+  const knot: Vec3 = [cx + n * 0.8, n + 0.04, nz + 0.13];
+  out.push({
+    shape: 'ellipsoid',
+    at: knot,
+    size: [0.05, 0.06, 0.05],
+    color: shade(scarf, 0.85),
+    blend: 0.02,
+    mirror: false,
+  });
+  for (const [dy, len, tw] of [
+    [0.3, 0.2, 0.045],
+    [0.6, 0.16, 0.04],
+  ] as const) {
+    const dir = unit([0.3, dy, -1]);
+    out.push({
+      shape: 'cone',
+      at: [knot[0] + 0.01, knot[1] + dy * 0.04, knot[2] - 0.02],
+      size: [tw, tw * 0.7, len],
+      rotate: alongZ(dir),
+      color: dy > 0.5 ? scarf : shade(scarf, 0.8),
+      blend: 0.015,
+      mirror: false,
+    });
+  }
+  return out;
+}

package/src/kinds/head-hair.ts

@@ -16,31 +16,42 @@ export function hairEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
   const [rx, ry, rz] = l.cranium.r;
   const top = l.crown;
   switch (p.hair) {
-    case 'topknot':
+    case 'topknot': {
+      // A warrior's knot: hair gathered at the back of the crown, bound by two iron rings, rising
+      // and then falling back in a thick tapering tail to the nape.
+      const root: Vec3 = [cx - 0.14, 0, top - 0.03];
+      const rise: Vec3 = [cx - 0.2, 0, top + 0.13];
+      const fall: Vec3 = [cx - 0.38, 0, top + 0.02];
+      const tip: Vec3 = [cx - rx - 0.08, 0, cz - 0.12];
+      const seg = (a: Vec3, b: Vec3, r0: number, r1: number): SculptEdit => ({
+        shape: 'cone',
+        at: a,
+        size: [r0, r1, Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2])],
+        rotate: alongZ([b[0] - a[0], b[1] - a[1], b[2] - a[2]]),
+        blend: 0.03,
+      });
+      const ring = (at: Vec3, deg: number): SculptEdit => ({
+        shape: 'torus',
+        at,
+        size: [0.07, 0.018],
+        rotate: [0, deg, 0],
+        color: p.colors.metal,
+        blend: 0.004,
+      });
       return [
-        { shape: 'ellipsoid', at: [cx - 0.12, 0, top - 0.02], size: [0.11, 0.08, 0.07], color: h },
-        {
-          shape: 'sphere',
-          at: [cx - 0.16, 0, top + 0.07],
-          size: 0.075,
-          color: h,
-          blend: 0.03,
-        },
         {
-          shape: 'capsule',
-          at: [cx - 0.2, 0, top + 0.08],
-          to: [cx - 0.42, 0, top - 0.25],
-          size: 0.04,
+          group: [
+            seg(root, rise, 0.085, 0.075),
+            seg(rise, fall, 0.08, 0.07),
+            seg(fall, tip, 0.07, 0.015),
+          ],
           color: h,
-          blend: 0.04,
-        },
-        {
-          shape: 'torus',
-          at: [cx - 0.17, 0, top + 0.02],
-          size: [0.06, 0.018],
-          color: p.colors.metal,
+          blend: 0.02,
         },
+        ring([root[0] - 0.02, 0, root[2] + 0.06], -15),
+        ring([root[0] - 0.04, 0, root[2] + 0.11], -25),
       ];
+    }
     case 'mohawk':
       return Array.from({ length: 6 }, (_, i): SculptEdit => {
         const a = (-20 + i * 26) * RAD;
@@ -112,20 +123,50 @@ export function hairEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
         lock(120, 30, 30, 0.05, 0),
       ];
     }
-    case 'tufts':
-      return Array.from({ length: 5 }, (_, i): SculptEdit => {
-        const a = (i / 4 - 0.5) * 1.6;
-        const base: Vec3 = [cx - 0.1 + Math.cos(a) * 0.05, Math.sin(a) * 0.12, top - 0.04];
-        return {
-          shape: 'cone',
-          at: base,
-          size: [0.025, 0.004, 0.12 + (i % 2) * 0.05],
-          rotate: alongZ([-0.6, Math.sin(a) * 0.8, 1]),
+    case 'tufts': {
+      // Wispy strands: a few thin, curling wisps on the crown and over the ears, each a root cone
+      // and a finer tip cone bent back — straggly, not a brush.
+      const out: SculptEdit[] = [];
+      const spots: ReadonlyArray<readonly [number, number, number]> = [
+        [10, 78, 0.26],
+        [-25, 70, 0.22],
+        [40, 62, 0.22],
+        [150, 55, 0.2],
+        [115, 30, 0.2],
+        [100, 16, 0.18],
+        [-120, 40, 0.18],
+      ];
+      for (const [az, el, len] of spots) {
+        const a = az * RAD;
+        const e = el * RAD;
+        const n: Vec3 = [Math.cos(e) * Math.cos(a), Math.cos(e) * Math.sin(a), Math.sin(e)];
+        const root: Vec3 = [cx - 0.04 + rx * 0.97 * n[0], ry * 0.97 * n[1], cz + rz * 0.97 * n[2]];
+        const d1: Vec3 = [n[0] - 0.6, n[1] * 1.3, n[2] * 0.6 + 0.25];
+        const l1 = Math.hypot(...d1);
+        const mid: Vec3 = [
+          root[0] + (d1[0] / l1) * len * 0.55,
+          root[1] + (d1[1] / l1) * len * 0.55,
+          root[2] + (d1[2] / l1) * len * 0.55,
+        ];
+        const d2: Vec3 = [d1[0] - 0.5, d1[1] * 1.6, -0.9];
+        out.push({
+          group: [
+            { shape: 'cone', at: root, size: [0.026, 0.014, len * 0.58], rotate: alongZ(d1) },
+            {
+              shape: 'cone',
+              at: mid,
+              size: [0.015, 0.004, len * 0.6],
+              rotate: alongZ(d2),
+              blend: 0.008,
+            },
+          ],
           color: h,
-          blend: 0.01,
-          mirror: false,
-        };
-      });
+          blend: 0.012,
+          mirror: az !== 10 && az !== -25 && az !== -120,
+        });
+      }
+      return out;
+    }
     case 'braids':
       return [
         { ...capOf(l, h) },

package/src/kinds/head-mesh.ts

@@ -8,6 +8,12 @@ import { type Field, type SculptEdit, sculptField, sd, sdf } from '../primitives
 import type { HeadLayout } from './head-layout.ts';
 import type { HeadParams } from './head-params.ts';
 import { creaseNormals, sharpenRim } from './head-rim.ts';
+import { toned } from './head-tone.ts';
+
+/** Cavity probe of the painted tone, head units: about one fold. */
+const REACH = 0.05;
+/** Default plinth colour (dark slate). */
+export const PLINTH: Vec3 = [0.16, 0.15, 0.15];
 
 /** The jaw region (head units): an ellipsoid around chin and lower lip, cut flat at the mouth
  *  line. Its skin seam runs along the lips, down the marionette lines and under the chin — creases
@@ -17,7 +23,7 @@ export function jawRegion(
   l: HeadLayout,
 ): { field: Field; centre: Vec3; radii: Vec3 } {
   const chin = l.chin;
-  const reach = Math.max(p.mouth.width * 1.25, (p.tusks?.spread ?? 0) + p.mouth.width * 0.5);
+  const reach = Math.max(p.mouth.width * 1.08, (p.tusks?.spread ?? 0) + p.mouth.width * 0.5);
   const centre: Vec3 = [l.mouthX - 0.15, 0, l.mouthZ];
   const radii: Vec3 = [Math.max(0.27, l.mouthX - chin[0] + 0.2), reach, l.mouthZ - chin[2] + 0.1];
   const e = sd.ellipsoid(centre, radii);
@@ -56,6 +62,8 @@ export interface HeadEditSet {
   readonly ears: readonly SculptEdit[];
   readonly tusks: readonly SculptEdit[];
   readonly bust: readonly SculptEdit[];
+  /** The bust-cut region (≈ 0 on the cut faces), painted as bare plinth material. */
+  readonly bustCut?: Field;
 }
 
 /** `head` and `jaw` meshes in head units at cell size `res` (units). Each is ONE sculpt (skull +
@@ -72,7 +80,7 @@ export function headAndJaw(
   // The jaw reaches a little past the cut and sits a hair proud of the skin, so it laps over the
   // head like a lip: no gap opens along the seam where meshing leaves the two rims a cell apart.
   const lap = res * 0.75;
-  const proud = res * 0.15;
+  const proud = res * 0.03;
   const ears: SculptEdit[] = set.ears.length > 0 ? [{ group: set.ears, blend: 0.02 }] : [];
   const tusks: SculptEdit[] = set.tusks.length > 0 ? [{ group: set.tusks, blend: 0.01 }] : [];
   const h = sculptField(
@@ -87,6 +95,18 @@ export function headAndJaw(
   const mouth = p.colors.mouth;
   // Only the skin-only skull is needed near the cut (paint + rim snapping): evaluated lazily.
   const skull = sculptField(set.skull, opts).field;
+  // The painted tone reads the uncut surface (skin + ears, skin + tusks): the cut faces' normals
+  // would light the jaw rim up as a pale outline.
+  const extra = (e: readonly SculptEdit[]): Field =>
+    e.length > 0
+      ? (
+          (f: Field): Field =>
+          (q) =>
+            Math.min(skull(q), f(q))
+        )(sculptField(e, opts).field)
+      : skull;
+  const headTone = extra(set.ears);
+  const jawTone = extra(set.tusks);
   const deep = -Math.max(res * 4, 0.03);
   const paint =
     (colorAt: (q: Vec3) => Vec3) =>
@@ -102,14 +122,14 @@ export function headAndJaw(
     field: h.field,
     bounds: h.bounds,
     resolution: res,
-    color: paint(h.colorAt),
+    color: toned(headTone, paint(h.colorAt), { reach: REACH }),
     symmetry: 'y',
   });
   const jaw = sdf({
     field: jField,
     bounds: unionBounds(jb, tb),
     resolution: res,
-    color: paint(jRaw.colorAt),
+    color: toned(jawTone, paint(jRaw.colorAt), { reach: REACH }),
     symmetry: 'y',
   });
   // Coarse cells: snapping folds triangles over, and nobody sees a seam at that distance.
@@ -122,13 +142,31 @@ export function headAndJaw(
   };
 }
 
+/** A surface point lies on a cut face: on the cut boundary, facing out of the cut region. */
+function onCut(cut: Field, q: Vec3, n: Vec3, res: number): boolean {
+  if (Math.abs(cut(q)) > res * 0.8) return false;
+  const e = res * 0.5;
+  const g: Vec3 = [
+    cut([q[0] + e, q[1], q[2]]) - cut([q[0] - e, q[1], q[2]]),
+    cut([q[0], q[1] + e, q[2]]) - cut([q[0], q[1] - e, q[2]]),
+    cut([q[0], q[1], q[2] + e]) - cut([q[0], q[1], q[2] - e]),
+  ];
+  const l = Math.hypot(g[0], g[1], g[2]) || 1;
+  return (g[0] * n[0] + g[1] * n[1] + g[2] * n[2]) / l > 0.85;
+}
+
 export function bustMesh(p: HeadParams, set: HeadEditSet, res: number): Mesh {
   const s = sculptField(set.bust, { color: p.colors.skin, mirror: 'y' });
+  const tone = toned(s.field, s.colorAt, { reach: REACH * 1.4 });
+  const cut = set.bustCut;
+  const base = p.colors.plinth ?? PLINTH;
+  const face: Vec3 = [base[0] * 1.3, base[1] * 1.3, base[2] * 1.3];
   return sdf({
     field: s.field,
     bounds: s.bounds,
     resolution: res,
-    color: (q) => s.colorAt(q),
+    // Cut faces read as the bare material of a sculpted bust, not as sliced layers.
+    color: cut ? (q, n) => (onCut(cut, q, n, res) ? face : tone(q)) : tone,
     symmetry: 'y',
   });
 }