@bitefoundry/retrieviewer 0.0.0-stage → 0.0.2

package/vendor/procedural-animals/src/species/dog/motion.js

@@ -0,0 +1,118 @@
+// Dog motion data for the quadruped engine (schema: src/core/motion/quadruped.js).
+// Numbers are for the reference individual (a 30 kg shepherd type, params.size = 1, withers 0.60 m,
+// hip 0.55 m); the engine scales them by dynamic similarity for retrievers (~0.93), terriers (~0.47)
+// and pups: speeds x sqrt(size), stride frequencies / sqrt(size) (terrier ~x1.46, as measured).
+//
+// Gaits (Maes et al. 2008, Blaszczyk & Dobrzecka 2001, Hildebrand 1968,
+// Heglund & Taylor 1988): lateral-sequence walk (0.5-1.4 m/s, 1.0-1.6 Hz, duty 0.75-0.6, limb phase
+// ~0.25); trot, the dog's steady gait (1.3-3.5 m/s, 1.8-2.6 Hz, duty 0.5-0.35, hind of each diagonal
+// ~3 % first), the shepherd's ground-covering flying trot with suspension at its top; the canter is a
+// transverse (right-lead) gallop (3-6 m/s, 2.3-2.8 Hz, duty 0.3-0.4), the rotary gallop (LH-RH-RF-LF,
+// 2.8-3.9 Hz, duty 0.2-0.3, strong spinal flexion-extension: gathered and extended flights) above
+// ~6 m/s. Trot -> gallop 1.53 M^0.24 = 3.5 m/s for 30 kg (Heglund & Taylor 1988).
+import { dogHooks } from './behaviour.js';
+
+const G = (name, v, f, D, off, o) => ({ name, v, f, D, off, ...o });
+const GAITS = [
+    G('walk', 0.0, 0.95, 0.72, [0.25, 0.75, 0.0, 0.5], { liftF: 0.05, liftH: 0.042, bobF: 0.005, bobH: 0.005, flex: 0.0, lat: 0.05, fold: 1.0, heel: 35, tail: 0, drop: 0.0, width: 0.95 }),
+    G('walk', 1.25, 1.35, 0.62, [0.25, 0.75, 0.0, 0.5], { liftF: 0.062, liftH: 0.05, bobF: 0.008, bobH: 0.008, flex: 0.0, lat: 0.05, fold: 1.2, heel: 42, tail: 0.12, drop: 0.0, width: 0.82 }),
+    G('trot', 1.75, 1.95, 0.47, [0.53, 0.03, 0.0, 0.5], { liftF: 0.082, liftH: 0.07, bobF: 0.015, bobH: 0.015, flex: 0.02, lat: 0.015, fold: 1.45, heel: 50, tail: 0.3, drop: 0.005, width: 0.62 }),
+    G('trot', 3.3, 2.35, 0.38, [0.53, 0.03, 0.0, 0.5], { liftF: 0.1, liftH: 0.085, bobF: 0.02, bobH: 0.02, flex: 0.03, lat: 0.01, fold: 1.6, heel: 58, tail: 0.4, drop: 0.01, width: 0.55 }),
+    G('canter', 4.2, 2.5, 0.35, [0.3, 0.45, 0.0, 0.3], { liftF: 0.13, liftH: 0.115, bobF: 0.018, bobH: 0.028, flex: 0.2, lat: 0, fold: 1.8, heel: 62, tail: 0.6, drop: 0.016, width: 0.8 }),
+    G('gallop', 7, 2.9, 0.27, [0.52, 0.42, 0.0, 0.1], { liftF: 0.16, liftH: 0.15, bobF: 0.025, bobH: 0.036, flex: 0.34, lat: 0, fold: 1.9, heel: 68, tail: 0.8, drop: 0.025, width: 1 }),
+    G('gallop', 13, 3.5, 0.21, [0.52, 0.42, 0.0, 0.1], { liftF: 0.19, liftH: 0.18, bobF: 0.025, bobH: 0.04, flex: 0.44, lat: 0, fold: 2.0, heel: 72, tail: 0.9, drop: 0.04, width: 1 }),
+];
+
+export const motion = {
+  hooks: dogHooks,
+  maxSpeed: 13,
+  accel: [5.5, 9],
+  decel: 10,
+  turnRate: 2.8,
+  latAccelMax: 11,
+  gears: { walk: 1.0, trot: 2.4, canter: 4.4, gallop: 9 },
+  gallopBlend: [3.8, 7],
+  gaits: GAITS,
+  feet: {
+    front: { type: 'digitigrade', curl: 55 },
+    hind: { type: 'digitigrade', curl: 65 },
+  },
+  stance: { width: 1, gallopWidth: 0.6, sprawl: 0, crouch: 0, scuff: [11, 18, 0] },
+  // torso cross-sections (bind, reference size): centre height, half height, half width (incl. coat)
+  body: {
+    // (measured on the bind mesh at the shoulder / hip, + coat; the pelvis includes the thighs a lying
+    // dog rests on)
+    chest: { y: 0.41, hh: 0.1, hw: 0.112 },
+    pelvis: { y: 0.41, hh: 0.15, hw: 0.118 },
+    back: 0.055,
+  },
+  head: {
+    // [speed, raise (m), reach (m), pitch (rad, + = nose down)]: head carried up standing and walking (standing: raised
+    // 7 cm, not 9.5 cm and pulled back 4.5: that bunched the throat skin under the jaw into a fold),
+    // lowered toward the back line in the shepherd's ground-covering trot, stretched in the gallop
+    carriage: [[0, 0.07, -0.02, -0.04], [1.0, 0.03, -0.01, 0.1], [2.4, -0.065, 0.045, 0.3], [4.4, -0.06, 0.05, 0.25], [9, -0.06, 0.07, 0.18]],
+    stab: [[0, 0], [0.9, 0.22], [1.8, 0.3], [4.5, 0.34], [9, 0.6]],
+    neckBend: 55, neckPivot: 0.6, yaw: 1.25, pitchUp: 0.65, pitchDown: 0.75,
+  },
+  tail: {
+    // [speed, pitch per segment from horizontal (deg), base -> tip]: the shepherd's saber tail hangs
+    // at rest (tip near the hock), rises toward level in the trot (never above the back), streams
+    // back at the gallop
+    carriage: [
+      [0.0, [-45, -64, -72, -76, -77, -75, -70, -62]],
+      [1.0, [-38, -54, -62, -65, -65, -62, -56, -48]],
+      [2.4, [-20, -28, -32, -33, -32, -29, -24, -18]],
+      [4.4, [-12, -16, -17, -16, -14, -11, -8, -5]],
+      [9, [-6, -8, -8, -7, -6, -4, -2, 0]],
+    ],
+    stiffness: 0.9, sway: 7, flick: 0, wag: 0, swish: 0, curl: 0,
+    balance: 0.4,
+    radius: [0.055, 0.04],
+  },
+  ears: { rest: [0, 0], mobility: 1, speedFlatten: 0.6, twitch: 1, prick: 0.45 },
+  breath: { rate: 0.3, amp: 0.012, pant: true, pantRate: 3.6, pantAmp: 0.045, heatSpeed: 3.2 },
+  actions: {
+    attack: { style: 'bite-lunge', paws: false }, // (forefeet planted: the head and neck drive the bite)
+    eat: { style: 'tear', dropF: 0.3, dropH: 0.1, ahead: 0.9, pitch: 1.0 },
+    drink: { dropF: 0.32, dropH: 0.1, ahead: 0.9, pitch: 1.0 },
+    jump: { height: 0.9, distance: 2.8 },
+    sit: { dropH: 1.0 },
+    lie: {},
+    sleep: { style: 'curl' },
+  },
+  // per variant (merged one level deep over the above)
+  variants: {
+    retriever: {
+      // level, gently curved otter tail, wagging freely; drop ears swing (behaviour.js pose)
+      tail: {
+        carriage: [
+          [0.0, [-28, -40, -46, -50, -52, -52, -50, -46]],
+          [1.0, [-18, -26, -30, -32, -33, -32, -30, -26]],
+          [2.4, [-10, -14, -16, -17, -17, -16, -14, -12]],
+          [4.4, [-6, -8, -9, -9, -8, -7, -5, -3]],
+          [9, [-4, -5, -5, -4, -3, -2, -1, 0]],
+        ],
+        stiffness: 1.0, sway: 9, balance: 0.35, radius: [0.04, 0.018],
+      },
+      ears: { rest: [0, 0], mobility: 0.25, speedFlatten: 0.25, twitch: 0.3, prick: 0.05 },
+      body: { chest: { y: 0.385, hh: 0.112, hw: 0.128 }, pelvis: { y: 0.41, hh: 0.16, hw: 0.13 }, back: 0.05 },
+      head: { carriage: [[0, 0.09, -0.045, -0.03], [1.0, 0.04, -0.01, 0.07], [2.4, -0.04, 0.04, 0.22], [4.4, -0.045, 0.05, 0.2], [9, -0.05, 0.07, 0.15]] },
+    },
+    terrier: {
+      // erect tail, carried up (60-90 deg); lowers toward level only at the gallop
+      tail: {
+        carriage: [
+          [0.0, [55, 64, 70, 72, 72, 70, 66, 60]],
+          [1.0, [52, 60, 65, 66, 65, 62, 58, 52]],
+          [2.4, [42, 48, 50, 50, 48, 45, 40, 35]],
+          [4.4, [25, 28, 28, 26, 24, 21, 18, 15]],
+          [9, [8, 8, 7, 5, 3, 2, 1, 0]],
+        ],
+        stiffness: 1.3, sway: 5, balance: 0.3, radius: [0.026, 0.014],
+      },
+      ears: { rest: [0, 0], mobility: 0.55, speedFlatten: 0.35, twitch: 0.8, prick: 0.15 },
+      body: { chest: { y: 0.41, hh: 0.105, hw: 0.108 }, pelvis: { y: 0.41, hh: 0.15, hw: 0.11 }, back: 0.05 },
+      head: { carriage: [[0, 0.085, -0.04, -0.04], [1.0, 0.04, -0.01, 0.05], [2.4, -0.02, 0.03, 0.15], [4.4, -0.03, 0.05, 0.15], [9, -0.04, 0.07, 0.12]] },
+    },
+  },
+};

package/vendor/procedural-animals/src/species/dog/regions.js

@@ -0,0 +1,61 @@
+// Meshing plan: body at 4.2 mm (0.7 % of the withers height), head at 2.1 mm (overlapping across the
+// upper neck and cross-faded), eyelid patches at ~1 mm, the lower jaw and the tongue as their own
+// rigid surfaces so the mouth can open and the tongue slide out. The tongue is dropped at the low and
+// crowd tiers (it is hidden in the closed mouth and too thin for their cells).
+import { HEAD_O } from './rig.js';
+import { eyeOf } from './sculpt.js';
+import { eyeFrameOf } from '../../core/sdf/eyeSocket.js';
+import { norm, smoothstep } from '../../core/math/vec.js';
+
+// the neck cut, fixed in reference space: a plane just behind the skull, tilted forward so the throat
+// stays with the neck and the whole jaw with the head (the dog carries its neck steeply)
+export const NECK_CUT = { c: [HEAD_O[0], HEAD_O[1] - 0.005, HEAD_O[2] - 0.085], d: norm([0, 0.45, 1]), band: 0.011 };
+export const neckS = (x, y, z) => (x - NECK_CUT.c[0]) * NECK_CUT.d[0] + (y - NECK_CUT.c[1]) * NECK_CUT.d[1] + (z - NECK_CUT.c[2]) * NECK_CUT.d[2];
+
+export const eyeCentres = (params) => [1, -1].map((s) => eyeFrameOf(eyeOf(params), HEAD_O, s).c);
+const PATCH = { R: 0.019, B: 0.0036, h: 0.001 };
+function eyePatchWeight(centres, R, B, x, y, z) {
+  let dmin = 1e9;
+  for (const c of centres) dmin = Math.min(dmin, Math.hypot(x - c[0], y - c[1], z - c[2]));
+  return 1 - smoothstep(R - B, R + B, dmin);
+}
+
+export function dogRegions(rig, params, Q) {
+  const B = NECK_CUT.band, r = Q.res;
+  // Each surface is clipped past the band's midline by at least two of its own cells: the mesher keeps
+  // whole cells, so a clipped surface's open edge lies up to ~2 cells inside the clip plane. With the
+  // clip at the band edge (11 mm) the coarse body (13 mm cells at low, 18 mm at crowd) ended on the
+  // visible side of the midline and left a row of open cells round the throat and the nape.
+  const hB = 0.00435 * r, hH = 0.00218 * r;
+  const cB = Math.max(B, 2 * hB), cH = Math.max(B, 2 * hH);
+  const ek = params.eyeK || 1;
+  const PR = PATCH.R * ek, PB = PATCH.B * ek;
+  const centres = eyeCentres(params);
+  const patches = Q.eyePatches ? centres.map((c) => ({ c, R: PR, B: PB, h: PATCH.h * Math.max(1, r) })) : [];
+  const J = rig.J;
+  const zN = J.nose[2] + 0.03;
+  const hw = params.headW || 1;
+  const tb = J.tongueBase, tt = J.tongueTip;
+  const jobs = [
+    [{ name: 'body', part: 'body', bmin: [-0.17, -0.03, -0.72], bmax: [0.17, 0.86, 0.56], h: hB, F: 4, clip: (x, y, z) => neckS(x, y, z) < cB }],
+    [
+      { name: 'head', part: 'body', bmin: [-0.14, 0.5, 0.33], bmax: [0.14, 0.88, zN], h: hH, F: 6, clip: (x, y, z) => neckS(x, y, z) > -cH, patches },
+      { name: 'jaw', part: 'jaw', bmin: [-0.06 * hw, 0.54, 0.44], bmax: [0.06 * hw, 0.66, zN], h: 0.0021 * r, F: 6, rigidBone: 'jaw' },
+    ],
+  ];
+  // the tongue (hero, high, medium)
+  if (r < 2.5) jobs[1].push({ name: 'tongue', part: 'tongue', bmin: [-0.03 * hw, Math.min(tb[1], tt[1]) - 0.02, tb[2] - 0.04], bmax: [0.03 * hw, Math.max(tb[1], tt[1]) + 0.02, tt[2] + 0.03], h: 0.0021 * r, F: 4, rigidBone: 'tongue' });
+  return {
+    jobs,
+    fade(x, y, z, name, patch) {
+      const sN = neckS(x, y, z);
+      if (name === 'body') return 1 - smoothstep(-B, B, sN);
+      if (name === 'head') {
+        let f = smoothstep(-B, B, sN);
+        if (patches.length) { const ew = eyePatchWeight(centres, PR, PB, x, y, z); f *= patch ? ew : 1 - ew; }
+        return f;
+      }
+      return 1;
+    },
+  };
+}

package/vendor/procedural-animals/src/species/dog/rig.js

@@ -0,0 +1,129 @@
+// Domestic dog skeleton in bind pose (metres). Forward = +Z, up = +Y, the animal's left = +X.
+//
+// Reference individual: a medium shepherd-type dog between the sexes, withers height 0.60 m
+// (German shepherd M 0.60-0.65 / F 0.55-0.60, FCI 166), body (point of shoulder -> buttock)
+// ~1.15 x withers height, head 0.25 m (~40 % of the withers height).
+// Limb segments (Fischer & Lilje 2011, Miller's Anatomy; shepherd ratios to SH):
+// scapula 0.25, humerus 0.29, radius 0.30, metacarpus 0.11, femur 0.31, tibia 0.32, metatarsus 0.12.
+//
+// Every variant is modelled at this reference scale and brought to its own size by params.size
+// (retriever ~0.93, terrier ~0.47): the variant changes the skeleton here (topline, hind angulation,
+// tail set and length, ears) and the sculpt; broader or shorter-legged builds and head size are
+// proportion warps (index.js). The head is modelled level in its own frame (HEAD_O); its carriage
+// comes from the motion data.
+import { buildRig } from '../../core/rig/rig.js';
+import { quadrupedBones, quadrupedLimbs, tailChain } from '../../core/rig/quadruped.js';
+
+export const TAIL_SEGS = 8;
+export const HEAD_O = [0, 0.622, 0.562]; // head-local origin (mid cranium, between eyes and ears)
+export const HS = 1.0; // head-local scale (landmarks below are for a 0.25 m skull)
+export const SH = 0.6; // reference withers height
+export const MUZZLE_Z0 = 0.04; // head-local z where the muzzle starts (muzzle length variation acts ahead of it)
+
+// head-local -> reference space, with per-individual muzzle length and head width factors
+export const hlOf = (m = 1, w = 1) => (v) => [HEAD_O[0] + v[0] * w * HS, HEAD_O[1] + v[1] * HS, HEAD_O[2] + HS * (v[2] > MUZZLE_Z0 ? MUZZLE_Z0 + (v[2] - MUZZLE_Z0) * m : v[2])];
+
+// ear bone (base -> tip, head-local) by ear type:
+//  prick  (shepherd): tall erect triangle, slightly outward and back
+//  drop   (retriever): pendant flap hanging from the fold at the top of the skull down the cheek
+//  button (terrier, shepherd pups): rises a little, the flap folds forward over the ear opening
+export const EAR = {
+  prick: { base: [0.04, 0.045, -0.037], dir: [0.034, 0.116, -0.012] },
+  drop: { base: [0.05, 0.036, -0.026], dir: [0.026, -0.08, 0.034] },
+  button: { base: [0.043, 0.047, -0.036], dir: [0.028, -0.004, 0.04] },
+};
+
+// per-variant skeleton changes (reference scale): axial heights and hind limb
+const BODY = {
+  // sloping topline, long well-angulated hind legs (hock well behind the croup), low-set tail
+  shepherd: {
+    lumbarMid: [0, 0.505, -0.1], lumbosacral: [0, 0.488, -0.205], tailBase: [0, 0.468, -0.285],
+    hip: [0.056, 0.41, -0.24], knee: [0.07, 0.245, -0.165], hock: [0.055, 0.105, -0.318], mtp: [0.052, 0.03, -0.305], htoe: [0.052, 0.012, -0.267],
+    tail: { ang: [-20, -32, -40, -45, -47, -47, -45, -41], len: 0.39 },
+  },
+  // level topline, moderate angulation, thick otter tail set on level with the back
+  retriever: {
+    lumbarMid: [0, 0.512, -0.095], lumbosacral: [0, 0.505, -0.195], tailBase: [0, 0.498, -0.27],
+    hip: [0.058, 0.425, -0.23], knee: [0.072, 0.252, -0.158], hock: [0.056, 0.105, -0.295], mtp: [0.053, 0.03, -0.283], htoe: [0.053, 0.012, -0.245],
+    tail: { ang: [-10, -16, -20, -23, -25, -26, -26, -25], len: 0.36 },
+  },
+  // square, level, straight hind legs, tail set high and carried erect
+  terrier: {
+    lumbarMid: [0, 0.515, -0.09], lumbosacral: [0, 0.51, -0.185], tailBase: [0, 0.505, -0.255],
+    hip: [0.056, 0.43, -0.215], knee: [0.068, 0.26, -0.145], hock: [0.054, 0.108, -0.268], mtp: [0.051, 0.03, -0.258], htoe: [0.051, 0.012, -0.22],
+    tail: { ang: [38, 52, 62, 68, 70, 70, 68, 64], len: 0.3 },
+    // (a little more bend in the standing foreleg: reach to spare for the quick steps of a small dog)
+    scapTop: [0.034, 0.53, 0.255], shoulder: [0.06, 0.398, 0.333], elbow: [0.054, 0.264, 0.232],
+  },
+};
+
+export function dogJoints(params = {}) {
+  const V = BODY[params.variant] || BODY.shepherd;
+  const hl = hlOf(params.muzzle || 1, params.headW || 1);
+  const earK = params.ear || 1;
+  const E = EAR[params.earType || 'prick'];
+  const ear = hl(E.base);
+  const J = {
+    nose: hl([0, -0.014, 0.158]),
+    occiput: hl([0, 0.02, -0.095]),
+    neckMid: [0, 0.556, 0.405],
+    neckBase: [0, 0.5, 0.33],
+    chestMid: [0, 0.51, 0.17],
+    thoraxRear: [0, 0.514, 0.02],
+    lumbarMid: V.lumbarMid,
+    lumbosacral: V.lumbosacral,
+    tailBase: V.tailBase,
+    scapTopL: V.scapTop || [0.034, 0.54, 0.255],
+    shoulderL: V.shoulder || [0.06, 0.41, 0.335],
+    elbowL: V.elbow || [0.054, 0.27, 0.238],
+    wristL: [0.047, 0.1, 0.247],
+    mcpL: [0.046, 0.029, 0.259],
+    ftoeL: [0.046, 0.012, 0.299],
+    hipL: V.hip,
+    kneeL: V.knee,
+    hockL: V.hock,
+    mtpL: V.mtp,
+    htoeL: V.htoe,
+    jawHinge: hl([0, -0.034, -0.03]),
+    jawTip: hl([0, -0.06, 0.13]),
+    // tongue (rigid, rides on the jaw): lies in the floor of the mouth, slides out to pant and lap
+    tongueBase: hl([0, -0.046, 0.02]),
+    tongueTip: hl([0, -0.05, 0.118]),
+    earBaseL: ear,
+    earTipL: [ear[0] + E.dir[0] * earK * HS * (params.headW || 1), ear[1] + E.dir[1] * earK * HS, ear[2] + E.dir[2] * earK * HS],
+  };
+  const tk = (params.tail || 1) * V.tail.len;
+  // segment lengths taper toward the tip (sum = tk)
+  const w = [1.14, 1.09, 1.04, 0.99, 0.95, 0.91, 0.86, 0.82], ws = w.reduce((a, b) => a + b, 0);
+  tailChain(J, 'tailBase', V.tail.ang, w.map((x) => (x / ws) * tk));
+  return J;
+}
+
+export function dogRig(params = {}) {
+  const J = dogJoints(params);
+  return buildRig({
+    joints: J,
+    unit: SH / 0.76,
+    headOrigin: HEAD_O,
+    bones: quadrupedBones({ tailSegs: TAIL_SEGS, ears: true, jaw: true, extra: [['tongue', 'tongueBase', 'tongueTip', 'jaw', { region: 'jaw', group: 'jaw' }]] }),
+    axial: {
+      points: ['nose', 'occiput', 'neckMid', 'neckBase', 'chestMid', 'thoraxRear', 'lumbarMid', 'lumbosacral', 'tailBase', ...Array.from({ length: TAIL_SEGS }, (_, i) => 'tail' + (i + 1))],
+      bones: ['head', 'neck2', 'neck1', 'chest', 'spine3', 'spine2', 'spine1', 'pelvis', ...Array.from({ length: TAIL_SEGS }, (_, i) => 'tail' + i)],
+      // the skull's influence reaches back into the nape; wider on the throat side (3rd value)
+      blend: { 1: [-0.09, 0.18, 3] },
+      // (core weights.js `cascade`: the skull's throat lever reaches past the mid-neck joint, where the default cut its
+      // share off: carried high, the head bunched the throat skin into a fold along that line, and the ruff's shells
+      // drew it as a crisp line round the throat. Faded out over the next segment instead)
+      cascade: { 1: 0.25 },
+      // a hanging tail (shepherd) lies behind the thighs: body skin blends into it only at its base
+      bodyTail: params.variant === 'terrier' ? 1 : 0,
+    },
+    limbs: quadrupedLimbs({
+      front: { tCore: 0.55, aCore: 0.04, aBody: -0.07, midX: 0.0 },
+      hind: { tCore: 0.52, aCore: 0.022, aBody: -0.045, midX: 0.008 },
+    }),
+    // (soft drop / button ears hinge over a wider fold)
+    appendages: ['L', 'R'].map((S) => ({ group: 'ear' + S, bone: 'ear' + S, blend: params.earType === 'prick' || !params.earType ? [-0.003, 0.006] : [-0.006, 0.01] })),
+    webTags: ['flankfold', 'thighfront', 'scapmuscle'],
+  });
+}

package/vendor/procedural-animals/src/species/dog/sculpt.js

@@ -0,0 +1,246 @@
+// The domestic dog, sculpted as a signed distance field.
+// Every primitive is attached to a bone (skinning) and a group (axial / limb / ear / jaw / tongue).
+// The torso is placed relative to the axial joints so the variants' toplines (the shepherd's slope,
+// the level retriever and terrier) carry the body with them. The head is modelled in head-local
+// coordinates (HEAD_O) and shaped per individual by params: stop, skull width, muzzle length and
+// depth, flews (the retriever's pendulous upper lips), cheek fur; ears by type (prick, drop,
+// button); tail by type (the shepherd's bushy saber, the retriever's thick otter tail, the
+// terrier's short erect tail).
+import { HEAD_O, TAIL_SEGS, HS, hlOf } from './rig.js';
+import { add, sub, mul, lerp, norm, cross } from '../../core/math/vec.js';
+import { eyeFrameOf } from '../../core/sdf/eyeSocket.js';
+
+// Eye geometry shared by the sculpt (lids + aperture) and the eyeball shader (head-local, left eye).
+// Axial eyeball ~21.5 mm (r 10.8 mm) for a 30 kg dog (Miller & Murphy 1995); almond fissure
+// ~20 x 10 mm set a little obliquely (shepherd); rounder and more forward-facing in retrievers and
+// terriers (params.eyeRound); eyes ~62 mm apart. Small dogs and pups have relatively larger eyes
+// (params.eyeK).
+export const EYE_BASE = { c: [0.033, 0.022, 0.038], r: 0.0108, back: 0.0023, yaw: 0.2, pitch: 0.04, lid: 0.0014, R: 0.0131, d: 0.0081, off: -0.0006, tilt: (12 * Math.PI) / 180, irisZ: 0.0066, irisR: 0.0089 };
+export const eyeOf = (params = {}) => {
+  const k = params.eyeK || 1, rd = params.eyeRound || 0;
+  const R = EYE_BASE.R * k, d = EYE_BASE.d * k * (1 - 0.3 * rd);
+  return {
+    ...EYE_BASE,
+    c: [EYE_BASE.c[0] * (params.headW || 1) * HS, (EYE_BASE.c[1] + 0.002 * (k - 1)) * HS, EYE_BASE.c[2] * HS],
+    r: EYE_BASE.r * k, back: EYE_BASE.back * k, lid: EYE_BASE.lid * k, R, d, irisZ: EYE_BASE.irisZ * k, irisR: EYE_BASE.irisR * k,
+    yaw: EYE_BASE.yaw - 0.05 * rd, tilt: EYE_BASE.tilt * (1 - 0.6 * rd),
+  };
+};
+
+const X = [1, 0, 0];
+
+export function sculptDog(m, rig, params = {}) {
+  const J = rig.J;
+  const EYE = eyeOf(params);
+  const mz = params.muzzle || 1, hw = params.headW || 1, juv = params.juv || 0;
+  const stop = params.stop ?? 0.5, flews = params.flews || 0, mzD = params.muzzleDepth || 1;
+  const ruff = params.ruff ?? 0.5, neckK = params.neckK || 1, chestK = params.chestK || 1;
+  const hl = hlOf(mz, hw);
+  // short muzzles (pups, terrier) shorten the muzzle pads with the muzzle, so they never swallow the nose
+  const mzS = Math.min(1, mz);
+  const hr = (r) => [r[0] * hw * HS, r[1] * HS, r[2] * HS];
+  const eyeFrame = (s) => eyeFrameOf(EYE, HEAD_O, s);
+  const ellY = (o) => {
+    const y = norm(o.ydir);
+    const lat = o.lateral || X;
+    const z = norm(cross(lat, y));
+    return m.ell({ ...o, axis: z, up: y, r: [o.r[0], o.r[1], o.r[2]] });
+  };
+  const cm = J.chestMid, tr = J.thoraxRear, lm = J.lumbarMid, ls = J.lumbosacral, nb = J.neckBase, nm = J.neckMid;
+  const P = (x, y, z) => [x, y, z];
+
+  // ---------------------------------------------------------------- TORSO
+  // deep chest reaching the elbow, prominent forechest, firm back, belly tucked up behind the ribs
+  const ribY = (cm[1] + tr[1]) / 2;
+  m.ell({ tag: 'ribcage', bone: 'spine3', c: P(0, ribY - 0.077, lerp(cm, tr, 0.4)[2]), r: [0.077 * chestK, 0.128 * chestK, 0.165], axis: norm([0, 0.1, -1]), k: 0 });
+  m.ell({ tag: 'brisket', bone: 'chest', c: P(0, cm[1] - 0.148, cm[2] + 0.07), r: [0.048 * chestK, 0.062, 0.085], axis: norm([0, -0.35, 1]), k: 0.05 });
+  m.ell({ tag: 'pectoral', bone: 'chest', c: P(0, nb[1] - 0.095, nb[2] + 0.008), r: [0.056 * chestK, 0.066, 0.052], k: 0.045 });
+  m.ell({ tag: 'withers', bone: 'chest', c: P(0, J.scapTopL[1] + 0.012, J.scapTopL[2] - 0.045), r: [0.044, 0.046, 0.105], axis: norm([0, -0.1, 1]), k: 0.05 });
+  m.ell({ tag: 'back', bone: 'spine3', c: P(0, tr[1] + 0.036, tr[2] + 0.01), r: [0.055, 0.042, 0.13], k: 0.05 });
+  m.ell({ tag: 'abdomen', bone: 'spine2', c: P(0, lm[1] - 0.048 + 0.012 * (params.tuck || 0), lm[2] + 0.035), r: [0.06 * chestK, 0.06 - 0.008 * (params.tuck || 0), 0.13], axis: norm([0, 0.34 * Math.max(0, params.tuck ?? 1), -1]), k: 0.055 });
+  const lo = lerp(lm, ls, 0.4);
+  m.ell({ tag: 'loin', bone: 'spine1', c: P(0, lo[1] + 0.022, lo[2]), r: [0.05, 0.041, 0.115], k: 0.045 });
+  m.ell({ tag: 'flank', bone: 'spine1', c: P(0, ls[1] - 0.05 - 0.01 * Math.max(0, -(params.tuck || 0)), ls[2] + 0.02), r: [0.053 * chestK, 0.053 + 0.012 * Math.max(0, -(params.tuck || 0)), 0.075], k: 0.045 });
+  m.ell({ tag: 'pelvis', bone: 'pelvis', c: P(0, ls[1] - 0.02, ls[2] - 0.058), r: [0.058, 0.07, 0.09], k: 0.05 });
+  m.ell({ tag: 'croup', bone: 'pelvis', c: P(0, ls[1] + 0.02, ls[2] - 0.048), r: [0.046, 0.034, 0.085], axis: norm([0, (J.tailBase[1] - ls[1]) * 3, -0.25]), k: 0.035 });
+  for (const s of [1, -1]) {
+    m.ell({ tag: 'rump', bone: 'pelvis', c: P(0.035 * s, ls[1] - 0.052, ls[2] - 0.118), r: [0.036, 0.058, 0.042], k: 0.035 });
+  }
+  // shepherd: the thicker coat over the shoulders and neck (sculpted coat volume)
+  if (ruff > 0.3) m.ell({ tag: 'cape', bone: 'chest', c: P(0, J.scapTopL[1] + 0.005, J.scapTopL[2] + 0.04), r: [0.06 * (0.7 + 0.3 * ruff), 0.055, 0.1], axis: norm([0, 0.25, 1]), k: 0.06 });
+
+  // ---------------------------------------------------------------- NECK
+  const occ = J.occiput;
+  const nTop = lerp(nm, occ, 0.55);
+  m.cone({ tag: 'neck', bone: 'neck1', a: P(0, nb[1] - 0.02, nb[2] - 0.03), b: nm, ra: 0.072 * neckK, rb: 0.058 * neckK, k: 0.05 });
+  m.cone({ tag: 'neck', bone: 'neck2', a: nm, b: P(0, nTop[1], nTop[2]), ra: 0.056 * neckK, rb: 0.049 * neckK, k: 0.04 });
+  // crest: the top line runs in one convex arc from the occiput to the withers
+  const cr = lerp(nm, occ, 0.3);
+  m.ell({ tag: 'nape', bone: 'neck1', c: P(0, cr[1] + 0.046, cr[2] - 0.025), r: [0.042 * neckK, 0.034, 0.1], axis: norm([0, 0.55, 1]), k: 0.045 });
+  // throat: a straight line from under the jaw to the forechest (no dewlap)
+  const hl0 = hlOf(mz, hw);
+  m.cone({ tag: 'throat', bone: 'neck1', a: hl0([0, -0.05, -0.03]), b: P(0, nb[1] - 0.085, nb[2] + 0.035), ra: 0.034 * neckK, rb: 0.05 * neckK, k: 0.05 });
+  // ruff (shepherd): the longer hair of the neck sides
+  const rf = 0.7 + 0.3 * ruff;
+  if (ruff > 0.3) m.ell({ tag: 'ruff', bone: 'neck1', c: P(0, nm[1] - 0.03, nm[2] - 0.035), r: [0.058 * rf * neckK, 0.052 * rf, 0.07], axis: norm([0, 0.6, 1]), k: 0.05 });
+
+  // ---------------------------------------------------------------- HEAD (head-local coords, see HEAD_O)
+  // landmarks (adult ~0.25 m occiput -> nose): nose tip (0, -0.014, 0.158), eyes (+-0.033, 0.022, 0.038),
+  // stop ~z 0.045 (deeper with params.stop), chin (0, -0.062, 0.125), skull top 0.064, occiput -0.095
+  const H = { bone: 'head' };
+  const dome = 0.004 * juv + 0.003 * (params.dome || 0);
+  m.ell({ ...H, tag: 'cranium', c: hl([0, 0.016 + dome, -0.034]), r: hr([0.05 + 0.004 * juv, 0.048 + 0.008 * juv + 0.003 * (params.dome || 0), 0.064]), k: 0.035 });
+  m.ell({ ...H, tag: 'forehead', c: hl([0, 0.027 + 0.011 * stop + dome, 0.008 + 0.008 * stop]), r: hr([0.034, 0.03, 0.042]), axis: norm([0, -0.35 + 0.35 * stop, 1]), k: 0.026 });
+  m.ell({ ...H, tag: 'crest', c: hl([0, 0.05, -0.055]), r: hr([0.016, 0.013, 0.048]), k: 0.03 });
+  for (const s of [1, -1]) {
+    m.ell({ ...H, tag: 'brow', c: hl([0.028 * s, 0.037 + 0.006 * stop, 0.034]), r: hr([0.016, 0.008 + 0.002 * stop, 0.014]), k: 0.012 });
+    m.ell({ ...H, tag: 'zygomatic', c: hl([0.05 * s, 0.002, -0.006]), r: hr([0.015 * (params.zyg ?? 1), 0.02, 0.042]), axis: norm([-0.3 * s, 0, 1]), k: 0.024 });
+    m.ell({ ...H, tag: 'cheek', c: hl([0.034 * s, -0.022, -0.006]), r: hr([0.021, 0.027, 0.04]), k: 0.03 });
+    // maxilla: carries the cheek forward into the side of the muzzle under the eye (a wedge from above,
+    // no crease or pit between the cheek and the muzzle)
+    m.ell({ ...H, tag: 'maxilla', c: hl([0.029 * s, -0.02, 0.046]), r: hr([0.021, 0.025, 0.038]), k: 0.03 });
+    if (ruff > 0.2) m.ell({ ...H, tag: 'cheekruff', c: hl([0.046 * s, -0.026, -0.046]), r: hr([0.014 * ruff, 0.036, 0.04]), axis: norm([0.3 * s, 0, 1]), k: 0.03 });
+    m.ell({ ...H, tag: 'mastoid', c: hl([0.034 * s, -0.02, -0.062]), r: hr([0.023, 0.03, 0.03]), k: 0.03 });
+    // upper lip; the retriever's flews hang lower and fuller behind the canines
+    m.ell({ ...H, tag: 'lip', c: hl([0.025 * s, -0.045 - 0.006 * flews, 0.078]), r: hr([0.015 + 0.002 * flews, 0.013 + 0.005 * flews, 0.058]), axis: norm([-0.2 * s, -0.06, 1]), k: 0.016 });
+    m.ell({ ...H, tag: 'whisker', c: hl([0.021 * s, -0.027 - 0.003 * flews, 0.121]), r: hr([0.015 + 0.002 * flews, 0.015 * mzD, 0.026 * mzS]), k: 0.016 });
+  }
+  // muzzle: straight nasal bridge (shepherd) to a broad, deeper muzzle (retriever)
+  m.cone({ ...H, tag: 'nasal', a: hl([0, 0.033 - 0.004 * stop - 0.023 * hw, 0.055]), b: hl([0, 0.007 - 0.016 * hw, 0.1505 - 0.0145 / mz]), ra: 0.023 * hw, rb: 0.016 * hw, k: 0.016 });
+  m.ell({ ...H, tag: 'muzzle', c: hl([0, -0.02, 0.084]), r: hr([0.033, 0.027 * mzD, 0.064 * mzS]), axis: norm([0, -0.1, 1]), k: 0.02 });
+  m.ell({ ...H, tag: 'nose', c: hl([0, -0.006, 0.1505]), r: hr([0.02, 0.0135, 0.0095]), axis: norm([0, 0.4, 1]), k: 0.008 });
+  m.ell({ ...H, tag: 'philtrum', c: hl([0, -0.031, 0.146]), r: hr([0.01, 0.012, 0.008]), k: 0.01 });
+  for (const s of [1, -1]) {
+    const ef = eyeFrame(s);
+    const at = (u, v, w) => add(add(add(ef.c, mul(ef.x, u)), mul(ef.y, v)), mul(ef.z, w));
+    ellY({ ...H, tag: 'orbit', c: at(-0.002 * s, -0.0005, 0.018), ydir: ef.y, lateral: ef.x, r: [0.017 * EYE.r / 0.0108, 0.012 * EYE.r / 0.0108, 0.0085], k: 0.008, carve: true });
+    m.sphere({ ...H, tag: 'eyelid', c: ef.c, rad: EYE.r + EYE.lid, k: 0.005 });
+    m.lens({ ...H, tag: 'eyesocket', c: add(ef.c, mul(ef.y, EYE.off)), x: ef.x, y: ef.y, z: ef.z, R: EYE.R, d: EYE.d, zMin: -0.002, zMax: 0.024, k: 0.0021, carve: true });
+    m.sphere({ ...H, tag: 'nostril', c: hl([0.0078 * s, -0.009, 0.16]), rad: 0.0035, k: 0.002, carve: true });
+    // upper canine, hidden behind the lip; shows when the mouth opens (snarl, pant)
+    m.cone({ ...H, tag: 'canine', a: hl([0.014 * s, -0.043, 0.118]), b: hl([0.013 * s, -0.057 - 0.004 * flews, 0.115]), ra: 0.0038, rb: 0.0011, k: 0.002 });
+  }
+
+  // ---------------------------------------------------------------- JAW (separate surface so the mouth can open)
+  const JW = { bone: 'jaw', group: 'jaw', part: 'jaw' };
+  m.cone({ ...JW, tag: 'mandible', a: hl([0, -0.05, -0.015]), b: hl([0, -0.058, 0.11]), ra: 0.016, rb: 0.0085, k: 0 });
+  for (const s of [1, -1]) {
+    m.cone({ ...JW, tag: 'mandible', a: hl([0.03 * s * hw, -0.044, -0.03]), b: hl([0.0065 * s, -0.056, 0.108]), ra: 0.012, rb: 0.007, k: 0.02 });
+    m.cone({ ...JW, tag: 'lowercanine', a: hl([0.0105 * s, -0.05, 0.112]), b: hl([0.0115 * s, -0.038, 0.109]), ra: 0.0032, rb: 0.001, k: 0.001 });
+  }
+  m.ell({ ...JW, tag: 'chin', c: hl([0, -0.06, 0.104]), r: hr([0.0105, 0.0085, 0.012]), k: 0.015 });
+
+  // ---------------------------------------------------------------- TONGUE (rigid, slides out)
+  // a long flat tongue in the floor of the mouth, just under the jaw's top surface when retracted
+  const TG = { bone: 'tongue', group: 'jaw', part: 'tongue' };
+  const tb = J.tongueBase, tt = J.tongueTip;
+  const tdir = norm(sub(tt, tb)), tl = Math.hypot(...sub(tt, tb));
+  ellY({ ...TG, tag: 'tongue', c: lerp(tb, tt, 0.45), ydir: tdir, lateral: X, r: [0.018 * hw, tl * 0.56, 0.0055], k: 0 });
+  ellY({ ...TG, tag: 'tongue', c: lerp(tb, tt, 0.86), ydir: tdir, lateral: X, r: [0.019 * hw, tl * 0.2, 0.0045], k: 0.01 });
+
+  // ---------------------------------------------------------------- EARS
+  const earType = params.earType || 'prick';
+  for (const S of ['L', 'R']) {
+    const s = S === 'L' ? 1 : -1;
+    const base = J['earBase' + S], tip = J['earTip' + S];
+    const dir = norm(sub(tip, base));
+    const L = Math.hypot(...sub(tip, base));
+    const ear = { bone: 'ear' + S, group: 'ear' + S, thin: true };
+    const at = (t) => lerp(base, tip, t);
+    if (earType === 'prick') {
+      // erect, broad at the base, pointed, the opening facing forward and a little out
+      const facing = norm([0.5 * s, 0.05, 1]);
+      const lat = norm(cross(dir, facing));
+      const k = L / 0.125;
+      ellY({ ...ear, tag: 'ear', c: at(0.22), ydir: dir, lateral: lat, r: [0.031 * k, 0.042 * k, 0.0085], k: 0.012 });
+      ellY({ ...ear, tag: 'ear', c: at(0.55), ydir: dir, lateral: lat, r: [0.02 * k, 0.042 * k, 0.006], k: 0.012 });
+      ellY({ ...ear, tag: 'ear', c: at(0.85), ydir: dir, lateral: lat, r: [0.0085 * k, 0.026 * k, 0.0042], k: 0.01 });
+      // the cup: a deep hollow on the front of the pinna, open toward the skull at its base
+      ellY({ ...ear, tag: 'earinner', c: add(at(0.34), mul(facing, 0.0075)), ydir: dir, lateral: lat, r: [0.022 * k, 0.044 * k, 0.0075], k: 0.004, carve: true });
+      ellY({ ...ear, tag: 'earinner', c: add(at(0.67), mul(facing, 0.0055)), ydir: dir, lateral: lat, r: [0.011 * k, 0.03 * k, 0.0048], k: 0.003, carve: true });
+    } else if (earType === 'drop') {
+      // pendant flap: thin, broadest just below the fold, rounded tip, lying against the cheek
+      const fwd = norm(cross(X.map((v) => v * s), dir).map((v) => -v));
+      const k = L / 0.09;
+      ellY({ ...ear, tag: 'ear', c: at(0.12), ydir: dir, lateral: fwd, r: [0.022 * k, 0.02 * k, 0.008], k: 0.012 });
+      ellY({ ...ear, tag: 'ear', c: at(0.45), ydir: dir, lateral: fwd, r: [0.033 * k, 0.04 * k, 0.0055], k: 0.012 });
+      ellY({ ...ear, tag: 'ear', c: at(0.8), ydir: dir, lateral: fwd, r: [0.026 * k, 0.026 * k, 0.005], k: 0.012 });
+    } else {
+      // button: a short upright root, then the flap folded forward and down over the opening
+      const k = L / 0.05;
+      ellY({ ...ear, tag: 'ear', c: add(base, [0.004 * s, 0.006, 0]), ydir: [0, 1, 0], lateral: [0, 0, 1], r: [0.019 * k, 0.013 * k, 0.008], k: 0.01 });
+      // the flap lies tangent to the skull: its plane faces out and up
+      const n = norm([0.8 * s, 0.6, 0.1]);
+      const bend = norm(add(dir, [0, -0.6, 0]));
+      ellY({ ...ear, tag: 'ear', c: at(0.5), ydir: dir, lateral: norm(cross(n, dir)), r: [0.022 * k, 0.026 * k, 0.005], k: 0.01 });
+      ellY({ ...ear, tag: 'ear', c: add(at(0.88), mul(bend, 0.008 * k)), ydir: bend, lateral: norm(cross(n, bend)), r: [0.017 * k, 0.014 * k, 0.0045], k: 0.01 });
+    }
+  }
+
+  // ---------------------------------------------------------------- LEGS
+  const legK = params.boneK || 1; // bone / paw substance (retriever heavier, terrier finer)
+  for (const S of ['L', 'R']) {
+    const s = S === 'L' ? 1 : -1;
+    const lat = [s, 0, 0];
+    const sx = (v) => [v[0] * s, v[1], v[2]];
+    const g = 'F' + S;
+    const Sc = J['scapTop' + S], Sh = J['shoulder' + S], E = J['elbow' + S], W = J['wrist' + S], M = J['mcp' + S], T = J['ftoe' + S];
+    ellY({ tag: 'scapmuscle', bone: 'scapula' + S, group: g, c: add(lerp(Sc, Sh, 0.5), sx([0.007, 0, 0])), ydir: sub(Sh, Sc), lateral: lat, r: [0.022, 0.085, 0.05], k: 0.05, bias: 0.003 });
+    m.cone({ tag: 'upperarm', bone: 'humerus' + S, group: g, a: Sh, b: E, ra: 0.034, rb: 0.025, k: 0.05 });
+    ellY({ tag: 'triceps', bone: 'humerus' + S, group: g, c: add(lerp(Sh, E, 0.55), [0, 0, -0.025]), ydir: sub(E, Sh), lateral: lat, r: [0.026, 0.063, 0.031], k: 0.042 });
+    m.sphere({ tag: 'olecranon', bone: 'radius' + S, group: g, c: add(E, [0, 0.006, -0.02]), rad: 0.015, k: 0.018 });
+    m.cone({ tag: 'forearm', bone: 'radius' + S, group: g, a: E, b: W, ra: 0.025 * legK, rb: 0.0155 * legK, k: 0.022 });
+    ellY({ tag: 'forearmmuscle', bone: 'radius' + S, group: g, c: add(lerp(E, W, 0.25), sx([0.0025, 0, 0.003])), ydir: sub(W, E), lateral: lat, r: [0.023 * legK, 0.056, 0.027 * legK], k: 0.026 });
+    ellY({ tag: 'feather', bone: 'radius' + S, group: g, c: add(lerp(E, W, 0.45), [0, 0, -0.014]), ydir: sub(W, E), lateral: lat, r: [0.012, 0.05, 0.014 * (0.6 + 0.6 * ruff)], k: 0.018 });
+    m.sphere({ tag: 'wrist', bone: 'metacarpus' + S, group: g, c: add(W, [0, 0, -0.0025]), rad: 0.016 * legK, k: 0.01 });
+    m.sphere({ tag: 'carpalpad', bone: 'metacarpus' + S, group: g, c: add(W, [0, -0.007, -0.016]), rad: 0.0075, k: 0.009 });
+    m.cone({ tag: 'pastern', bone: 'metacarpus' + S, group: g, a: W, b: M, ra: 0.0155 * legK, rb: 0.0155 * legK, k: 0.01 });
+    m.sphere({ tag: 'dewclaw', bone: 'metacarpus' + S, group: g, c: add(lerp(W, M, 0.3), sx([-0.0135, 0, 0.002])), rad: 0.005, k: 0.004 });
+    const dp = norm(sub(T, M));
+    const pk = params.pawK || 1;
+    ellY({ tag: 'paw', bone: 'fpaw' + S, group: g, c: add(add(M, mul(dp, 0.018)), [0, -0.005, 0]), ydir: dp, lateral: lat, r: [0.025 * pk, 0.033 * pk, 0.016], k: 0.012 });
+    m.sphere({ tag: 'pad', bone: 'fpaw' + S, group: g, c: add(M, [0, -0.016, 0.01]), rad: 0.011 * pk, k: 0.009 });
+    const toeX = [-0.0175, -0.006, 0.006, 0.0175].map((x) => x * pk), toeZ = [-0.009, 0, 0, -0.009].map((z) => z * pk);
+    for (let i = 0; i < 4; i++) m.sphere({ tag: 'toe', bone: 'fpaw' + S, group: g, c: [T[0] + toeX[i] * s, 0.0102 * pk, T[2] - 0.0075 * pk + toeZ[i]], rad: 0.0096 * pk, k: 0.006 });
+    for (let i = 0; i < 4; i++) m.cone({ tag: 'claw', bone: 'fpaw' + S, group: g, a: [T[0] + toeX[i] * s * 0.95, 0.0092 * pk, T[2] + toeZ[i]], b: [T[0] + toeX[i] * s * 0.95, 0.0035, T[2] + 0.009 * pk + toeZ[i]], ra: 0.0027, rb: 0.001, k: 0.002 });
+
+    const h = 'H' + S;
+    const Hp = J['hip' + S], K = J['knee' + S], Hk = J['hock' + S], Mt = J['mtp' + S], Tt = J['htoe' + S];
+    const hip = (d) => add(Hp, sx(d));
+    ellY({ tag: 'thigh', bone: 'femur' + S, group: h, c: add(lerp(Hp, K, 0.4), sx([0.003, 0, -0.024])), ydir: sub(K, Hp), lateral: lat, r: [0.035, 0.118, 0.078], k: 0.045, bias: 0.003 });
+    m.cone({ tag: 'thighfront', bone: 'femur' + S, group: h, a: hip([-0.024, 0.044, 0.084]), b: add(K, sx([-0.003, 0.045, 0.0])), ra: 0.031, rb: 0.02, k: 0.05 });
+    m.cone({ tag: 'hamstring', bone: 'femur' + S, group: h, a: hip([-0.02, 0.044, -0.084]), b: add(lerp(K, Hk, 0.28), [0, 0, -0.025]), ra: 0.037, rb: 0.023, k: 0.035 });
+    ellY({ tag: 'breeches', bone: 'femur' + S, group: h, c: add(lerp(Hp, K, 0.62), sx([0.005, -0.008, -0.068])), ydir: sub(K, Hp), lateral: lat, r: [0.024, 0.064, 0.018 + 0.012 * ruff], k: 0.03 });
+    ellY({ tag: 'flankfold', bone: 'femur' + S, group: h, c: hip([-0.016, -0.052, 0.1]), ydir: [-0.03, 0.16, 0.1], lateral: lat, r: [0.017, 0.066, 0.033], k: 0.05 });
+    m.sphere({ tag: 'stifle', bone: 'tibia' + S, group: h, c: add(K, sx([0.002, 0.007, 0.005])), rad: 0.014, k: 0.035 });
+    m.cone({ tag: 'shin', bone: 'tibia' + S, group: h, a: add(lerp(K, Hk, 0.06), sx([0.0, 0.0, 0.003])), b: Hk, ra: 0.019 * legK, rb: 0.014 * legK, k: 0.025 });
+    ellY({ tag: 'calf', bone: 'tibia' + S, group: h, c: add(lerp(K, Hk, 0.3), sx([0.002, 0.008, -0.022])), ydir: sub(Hk, K), lateral: lat, r: [0.021, 0.058, 0.025], k: 0.03 });
+    m.cone({ tag: 'achilles', bone: 'tibia' + S, group: h, a: add(lerp(K, Hk, 0.5), [0, 0.008, -0.028]), b: add(Hk, [0, 0.01, -0.024]), ra: 0.01, rb: 0.009, k: 0.013 });
+    m.sphere({ tag: 'calcaneus', bone: 'metatarsus' + S, group: h, c: add(Hk, [0, 0.01, -0.02]), rad: 0.0125, k: 0.01 });
+    m.sphere({ tag: 'hock', bone: 'metatarsus' + S, group: h, c: Hk, rad: 0.0165 * legK, k: 0.01 });
+    m.cone({ tag: 'metatarsus', bone: 'metatarsus' + S, group: h, a: Hk, b: Mt, ra: 0.015 * legK, rb: 0.014 * legK, k: 0.01 });
+    const dh = norm(sub(Tt, Mt));
+    ellY({ tag: 'paw', bone: 'hpaw' + S, group: h, c: add(add(Mt, mul(dh, 0.016)), [0, -0.005, 0]), ydir: dh, lateral: lat, r: [0.022 * pk, 0.03 * pk, 0.015], k: 0.012 });
+    m.sphere({ tag: 'pad', bone: 'hpaw' + S, group: h, c: add(Mt, [0, -0.018, 0.008]), rad: 0.01 * pk, k: 0.009 });
+    for (let i = 0; i < 4; i++) m.sphere({ tag: 'toe', bone: 'hpaw' + S, group: h, c: [Tt[0] + toeX[i] * 0.92 * s, 0.0096 * pk, Tt[2] - 0.0075 * pk + toeZ[i]], rad: 0.0088 * pk, k: 0.006 });
+    for (let i = 0; i < 4; i++) m.cone({ tag: 'claw', bone: 'hpaw' + S, group: h, a: [Tt[0] + toeX[i] * 0.88 * s, 0.0085 * pk, Tt[2] + toeZ[i]], b: [Tt[0] + toeX[i] * 0.88 * s, 0.0035, Tt[2] + 0.0085 * pk + toeZ[i]], ra: 0.0025, rb: 0.0009, k: 0.002 });
+  }
+
+  // ---------------------------------------------------------------- TAIL
+  const tailType = params.tailType || 'brush';
+  const tb2 = params.tailBrush ?? 1;
+  const tailR = tailType === 'otter'
+    // thick at the root, tapering evenly to a rounded tip ("otter tail", FCI 122)
+    ? (t) => tb2 * (0.034 - 0.022 * Math.pow(t, 1.1))
+    : tailType === 'thin'
+      ? (t) => tb2 * (0.019 - 0.008 * t)
+      // bushy saber: thickest at a third of its length
+      : (t) => tb2 * (t < 0.12 ? 0.024 + 0.004 * (t / 0.12) : t < 0.45 ? 0.028 + 0.004 * ((t - 0.12) / 0.33) : 0.032 - 0.016 * Math.pow((t - 0.45) / 0.55, 1.6));
+  const rootR = tailType === 'thin' ? 0.024 : 0.03;
+  m.cone({ tag: 'tailroot', bone: 'tail0', a: lerp(J.tailBase, ls, 0.3), b: J.tail1, ra: rootR, rb: tailR(0.1), k: 0.035 });
+  for (let i = 0; i < TAIL_SEGS; i++) {
+    m.cone({ tag: 'tail', bone: 'tail' + i, a: J['tail' + i], b: J['tail' + (i + 1)], ra: tailR(i / TAIL_SEGS), rb: tailR((i + 1) / TAIL_SEGS), k: tailType === 'brush' ? 0.012 : 0.022, thin: i >= TAIL_SEGS - 1 });
+  }
+
+  return m;
+}