@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/src/kinds/head-face.ts

@@ -0,0 +1,242 @@
+// The skull edit list, primary → secondary forms (the ZBrush order): cranium, face plate, cheek
+// bones, muzzle, mandible + chin, neck; then sockets, brow ridge, lids, nose, lips and the mouth
+// line. Head units, mirrored across Y. The jaw cut (head-split.ts) later divides this one field
+// into the `head` and `jaw` parts, so their surfaces meet without a seam.
+
+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). */
+export function primaryEdits(l: HeadLayout): SculptEdit[] {
+  const [cx, , cz] = l.cranium.at;
+  const [rx, ry, rz] = l.cranium.r;
+  return [
+    { shape: 'ellipsoid', at: [cx, 0, cz], size: [rx, ry, rz] },
+    {
+      shape: 'ellipsoid',
+      at: [l.faceX - 0.19, 0, l.eye[2] - 0.03],
+      size: [0.2, ry * 0.86, 0.24],
+      blend: 0.08,
+    },
+  ];
+}
+
+/** `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 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.075 * p.cheeks.size, 0.07 * p.cheeks.size, 0.055 * p.cheeks.size],
+      rotate: [0, 0, 25],
+      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.
+    {
+      shape: 'ellipsoid',
+      at: [l.faceX - 0.13 + p.jaw.muzzle * 0.6, 0, l.noseZ + 0.01],
+      size: [0.15, 0.2 * p.cheeks.width, 0.13],
+      blend: 0.08,
+    },
+    {
+      shape: 'ellipsoid',
+      at: [l.mouthX - 0.13, 0, l.mouthZ + 0.02],
+      size: [0.14, Math.max(mw * 1.15, 0.13), 0.12 + p.jaw.drop * 0.2],
+      blend: 0.07,
+    },
+    // Mandible: a U of bone — body from the jaw angles to the chin, ramus up to the hinge.
+    {
+      shape: 'roundBox',
+      at: [(ax + chin[0]) / 2 + 0.01, 0, (az + chin[2]) / 2 + 0.03],
+      size: [chin[0] - ax + 0.04, ay * 1.75, 0.16 + p.jaw.drop * 0.5],
+      round: 0.07,
+      rotate: [0, Math.atan2(az - chin[2], chin[0] - ax) * (180 / Math.PI) * 0.6, 0],
+      blend: 0.08,
+    },
+    {
+      shape: 'capsule',
+      at: [hx - 0.04, ay * 0.85, hz],
+      to: [ax, ay, az],
+      size: 0.055,
+      blend: 0.07,
+    },
+    { shape: 'sphere', at: [ax + 0.02, ay * 0.95, az], size: 0.065, blend: 0.07 },
+    {
+      shape: 'roundBox',
+      at: 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,
+    },
+    {
+      shape: 'capsule',
+      at: [cx + 0.02, 0, ez - 0.22],
+      to: [cx - 0.05, 0, l.base + 0.45],
+      size: p.neck.radius,
+      blend: 0.1,
+    },
+    // Sternocleidomastoid: the cords from behind the ear to the throat.
+    {
+      shape: 'capsule',
+      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 },
+  ];
+  // Lids: a shell over the eyeball, kept above (upper) / below (lower) a plane through the eye
+  // centre tilted to the lid angle, so the lid edge crosses the cornea exactly at that angle.
+  const lid = (deg: number, upper: boolean): SculptEdit => {
+    const t = (deg * Math.PI) / 180;
+    const n: Vec3 = upper ? [-Math.sin(t), 0, Math.cos(t)] : [Math.sin(t), 0, Math.cos(t)];
+    const k = upper ? 1 : -1;
+    return {
+      group: [
+        { shape: 'sphere', at: l.eye, size: r * (upper ? 1.14 : 1.1) },
+        {
+          shape: 'roundBox',
+          at: [ex + n[0] * k, ey, ez + n[2] * k],
+          size: [4, 4, 2],
+          rotate: [0, upper ? -deg : deg, 0],
+          op: 'intersect',
+        },
+      ],
+      blend: r * 0.22,
+    };
+  };
+  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.3 + 0.01,
+  ];
+  e.push(
+    {
+      shape: 'cone',
+      at: noseRoot,
+      size: [rootR, tipR * 0.85, Math.hypot(...noseDir)],
+      rotate: alongZ(noseDir),
+      blend: 0.045,
+    },
+    {
+      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: [wingX, p.nose.width, l.noseZ + 0.02],
+      size: [0.045 * wing, 0.035 * wing, 0.032 * wing],
+      blend: 0.025,
+    },
+    {
+      shape: 'ellipsoid',
+      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.008,
+      color: c.mouth,
+    },
+  );
+  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({
+    shape: 'ellipsoid',
+    at: [tipX - p.nose.tip * 1.5 - 0.035, p.nose.width + 0.05, l.noseZ - 0.035],
+    size: [0.08, 0.006, 0.006],
+    rotate: alongX(fold),
+    op: 'subtract',
+    blend: 0.03,
+    color: c.shade,
+  });
+  // 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 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-geom.ts

@@ -0,0 +1,31 @@
+// Small geometry helpers for head edit lists: the `rotate` that points an edit's local X (or Z) along
+// a direction, and point/vector helpers.
+
+import type { Vec3 } from '../core/index.ts';
+
+const DEG = 180 / Math.PI;
+
+/** `rotate` (deg, X→Y→Z) taking local +X onto `d`, then rolling `roll` deg about it. */
+export function alongX(d: Vec3, roll = 0): Vec3 {
+  const yaw = Math.atan2(d[1], d[0]);
+  const pitch = -Math.atan2(d[2], Math.hypot(d[0], d[1]));
+  return [roll, pitch * DEG, yaw * DEG];
+}
+
+/** `rotate` taking local +Z (a cone's axis) onto `d`. */
+export function alongZ(d: Vec3): Vec3 {
+  const len = Math.hypot(d[0], d[1], d[2]) || 1;
+  const tilt = Math.acos(Math.max(-1, Math.min(1, d[2] / len)));
+  return [0, tilt * DEG, Math.atan2(d[1], d[0]) * DEG];
+}
+
+export const unit = (d: Vec3): Vec3 => {
+  const l = Math.hypot(d[0], d[1], d[2]) || 1;
+  return [d[0] / l, d[1] / l, d[2] / l];
+};
+
+export const along = (a: Vec3, d: Vec3, t: number): Vec3 => [
+  a[0] + d[0] * t,
+  a[1] + d[1] * t,
+  a[2] + d[2] * t,
+];

package/src/kinds/head-hair.ts

@@ -0,0 +1,193 @@
+// Scalp hair as edit lists, part of the skull field: a top-knot, mohawk ridge, chunky swept locks
+// over a cap clipped at the hairline, wiry tufts, braids. Beards and eyebrows: head-beard.ts.
+// Head units, mirrored across Y unless an edit opts out.
+
+import type { Vec3 } from '../core/index.ts';
+import type { SculptEdit } from '../primitives/index.ts';
+import { alongZ } from './head-geom.ts';
+import type { HeadLayout } from './head-layout.ts';
+import type { HeadParams } from './head-params.ts';
+
+const RAD = Math.PI / 180;
+
+export function hairEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
+  const h = p.colors.hair;
+  const [cx, , cz] = l.cranium.at;
+  const [rx, ry, rz] = l.cranium.r;
+  const top = l.crown;
+  switch (p.hair) {
+    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 [
+        {
+          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.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;
+        return {
+          shape: 'ellipsoid',
+          at: [cx + Math.sin(a) * rx * 0.95, 0, cz + Math.cos(a) * rz * 0.97],
+          size: [0.06, 0.035, 0.09],
+          rotate: [0, (a * 180) / Math.PI - 15, 0],
+          color: h,
+          blend: 0.03,
+        };
+      });
+    case 'swept': {
+      // Cap clipped to a rounded hairline (face and ears carved out), then big tapered locks
+      // sweeping back from the hairline — thick roots proud, tips sunk — in two shades.
+      const C: Vec3 = [cx - 0.04, 0, cz + 0.04];
+      const R: Vec3 = [rx + 0.035, ry + 0.04, rz + 0.02];
+      const on = (az: number, el: number, lift = 0): Vec3 => [
+        C[0] + (R[0] + lift) * Math.cos(el * RAD) * Math.cos(az * RAD),
+        C[1] + (R[1] + lift) * Math.cos(el * RAD) * Math.sin(az * RAD),
+        C[2] + (R[2] + lift) * Math.sin(el * RAD),
+      ];
+      const light: Vec3 = [h[0] * 1.45, h[1] * 1.45, h[2] * 1.45];
+      // A lock hugs the cap: two tapering cones root → mid → tip, mid on the surface.
+      const cone = (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]]),
+      });
+      const lock = (az: number, el: number, len: number, r: number, i: number): SculptEdit => {
+        const a = on(az, el, -0.005);
+        const m = on(az + len * 0.3, el - len * 0.45, -0.012);
+        const b = on(az + len * 0.6, el - len, -0.045);
+        return {
+          group: [cone(a, m, r, r * 0.75), cone(m, b, r * 0.75, r * 0.15)],
+          color: i % 2 ? h : light,
+          blend: 0.035,
+          ...(az === 0 ? { mirror: false } : {}),
+        };
+      };
+      return [
+        {
+          group: [
+            { shape: 'ellipsoid', at: C, size: R },
+            {
+              shape: 'ellipsoid',
+              at: [l.faceX + 0.12, 0, l.eye[2] - 0.08],
+              size: [0.34, ry * 0.92, 0.36],
+              op: 'subtract',
+              blend: 0.03,
+            },
+            {
+              shape: 'ellipsoid',
+              at: [cx + 0.02, ry, l.eye[2] - 0.08],
+              size: [0.13, 0.25, 0.16],
+              op: 'subtract',
+              blend: 0.03,
+            },
+          ],
+          color: h,
+          blend: 0.012,
+        },
+        lock(0, 44, 50, 0.07, 1),
+        lock(22, 46, 50, 0.07, 0),
+        lock(45, 40, 45, 0.068, 1),
+        lock(70, 34, 40, 0.06, 0),
+        lock(95, 30, 35, 0.055, 1),
+        lock(120, 30, 30, 0.05, 0),
+      ];
+    }
+    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.012,
+          mirror: az !== 10 && az !== -25 && az !== -120,
+        });
+      }
+      return out;
+    }
+    case 'braids':
+      return [
+        { ...capOf(l, h) },
+        {
+          shape: 'capsule',
+          at: [cx - 0.2, ry * 0.7, cz - 0.1],
+          to: [cx - 0.1, ry * 0.8, cz - 0.6],
+          size: 0.035,
+          color: h,
+          blend: 0.02,
+        },
+      ];
+    default:
+      return [];
+  }
+}
+
+const capOf = (l: HeadLayout, h: Vec3): SculptEdit => ({
+  shape: 'ellipsoid',
+  at: [l.cranium.at[0] - 0.07, 0, l.cranium.at[2] + 0.09],
+  size: [l.cranium.r[0] + 0.02, l.cranium.r[1] + 0.025, l.cranium.r[2]],
+  color: h,
+  blend: 0.02,
+});