@bitefoundry/retrieviewer 0.0.0-stage → 0.0.2

package/vendor/procedural-animals/src/core/motion/spider.js

@@ -0,0 +1,1810 @@
+// Spider motion engine: eight legs of seven segments, pedipalps, chelicerae with fangs and a hanging
+// abdomen, on uneven ground. Drives the bones of core/rig/spider.js.
+//
+// Locomotion: a phase-offset gait table (alternating tetrapod: L1 R2 L3 R4 against R1 L2 R3 L4, with
+// the metachronal lag inside each tetrapod) blended by speed. Stance claws stay planted where they
+// touched down; swing claws travel on a "ballistic" path (short speed ramps, straight cruise, a
+// rounded apex) whose height clears the terrain sampled along the way, so legs step over bumps.
+// Standing still, legs that end up away from their neutral foothold re-step one tetrapod at a time;
+// turning on the spot runs the gait from the yaw rate. The body height, pitch and roll follow a
+// least-squares plane through the terrain under the eight neutral footholds (springs), and the
+// sternum / abdomen never touch a bump. The abdomen hangs from the pedicel on a spring (lags in turns
+// and speed changes) and breathes (bone scale).
+//
+// Leg solver (body frame, per frame, continuous): the tarsus lies along the leg's azimuth at its
+// bind slope (steeper while the "heel" lifts), which gives the metatarsus-tarsus joint; the coxa
+// yaws part of the way toward it and the trochanter the rest; in the vertical leg plane the
+// metatarsus takes a preferred slope that flattens as the leg stretches, and femur + (patella +
+// tibia, a rigid pair) solve as a two-link chain, knee up, with a soft reach limit. Every bone is
+// written as a rotation from its bind frame: body rotation x yaw about the body's up axis x pitch
+// about the bind leg-plane normal, so the bone roll never flips. Action poses (raised threat legs,
+// held prey, the death curl, the in-air tuck) are blended in the same joint-angle space.
+//
+// Actions: idle (breathing, leg and palp twitches, looking around), jump (a pounce: crouch, hydraulic
+// push-off, front legs raised to grab, landing), sit / lie / sleep (crouch low with the legs drawn
+// in), eat (chelicerae working, palps manipulating, prey held by legs I), drink (mouthparts down),
+// attack (threat pose: front legs raised, fangs out; then a lunge and attackHit), hit (flinch and
+// scuttle back), death (hydraulic leg collapse: the legs curl under the body and it settles on its
+// back or side on whatever ground is there), stand.
+//
+// Lessons from the cheetah engine kept here: continuous solves (no state jumps between frames),
+// soft reach limits, motion from phase not events, springs for secondary motion, zero-dt safety,
+// no allocations in the hot path.
+//
+// ------------------------------------------------------------------------------------------------
+// species.motion schema (all lengths in metres at the reference size; per-variant overrides in
+// `variants: { name: { ...same fields } }`, chosen by params.variant)
+// ------------------------------------------------------------------------------------------------
+// maxSpeed m/s, accel / decel m/s^2, turnRate rad/s, latAccelMax m/s^2 (cornering: wider arcs at speed)
+// gears      { name: speed } named speeds (walk, run, sprint)
+// gaits (req.) [{ name, v, f, D, off: [L1 L2 L3 L4 R1 R2 R3 R4], lift, bob, sway }] sorted by v.
+//            v: speed of the row, f: stride Hz, D: duty factor, off: touchdown phase per leg, lift:
+//            swing height (m), bob: body bounce (m, twice per stride), sway: body yaw sway (rad).
+// stance     { reach: [I, II, III, IV] neutral claw distance from the coxa as a fraction of the
+//            bind pose, height: stance height factor, width: lateral spread factor }
+// feet       { heelLift: tarsus heel lift at push-off (deg) }
+// abdomen    { stiffness: spring rate (1/s), lag: how far it swings in accelerations (rad per
+//            m/s^2 x s), droop: pitch it sags by when relaxed (rad) }
+// breath     { rate Hz, amp: abdomen scale amplitude }
+// chelicerae { fang: 'labidognath' (fangs close sideways: wolf spiders) | 'orthognath' (fangs
+//            strike down: tarantulas), fangOpen: rad, spread: rad, pitch: rad }
+// palps      { twitch 0..1, tap 0..1 }       idle { twitch, raiseFront (rad), look (rad) }
+// look       { yaw, pitch }: how far the body turns / rears toward a look target (rad)
+// actions    { jump: { height, distance, crouch (s) }, attack: { rear (rad), lunge (m),
+//            threat (s) }, sleep: { tuck 0..1 } }
+// ------------------------------------------------------------------------------------------------
+import * as THREE from 'three';
+import { TAU, clamp, lerp, smooth, smin, wrap01, d01, angDiff, Spring, prng, envelope, tv } from './common.js';
+import { LEG_KEYS, legBones, legJoints, palpBones, palpJoints } from '../rig/spider.js';
+
+const DEG = Math.PI / 180;
+// swing shaping (exported for tuning tools)
+export const TUNE = { bf: 1.15, bp: 0.25, bm: 0.2, ramp: 0.22, path: 'joint' };
+const G_ACC = 9.81;
+const PUSH = 0.07; // jump push-off duration (s)
+const COAST = 1 / 50; // constant-velocity moments between push, flight and landing (s)
+const Y_AXIS = Object.freeze(new THREE.Vector3(0, 1, 0));
+const X_AXIS = Object.freeze(new THREE.Vector3(1, 0, 0));
+const Z_AXIS = Object.freeze(new THREE.Vector3(0, 0, 1));
+const ONE = Object.freeze(new THREE.Vector3(1, 1, 1));
+const SET_A = [1, 0, 1, 0, 0, 1, 0, 1]; // tetrapod A: L1 R2 L3 R4
+// action leg poses: bends (deg) of patella, tibia, metatarsus, tarsus relative to the previous segment
+const P_AIR_F = [-40, -25, -30, -20], P_AIR_H = [-15, -12, -10, -8];
+const P_RAISE = [-18, -12, -14, -6], P_HOLD = [-78, -30, -52, -28], P_CURL = [-120, -65, -55, -45], P_TUCK = [-105, -35, -115, -40];
+const STAG = [null, null, null, [0.2, 0.85], [0.1, 0.7], [0, 0.55], [0, 0.45]];
+const softMin = (x, lim, w) => (x < lim - w ? x : lim - w * Math.exp((lim - w - x) / w)); // smooth clamp from above
+const expTo = (x, target, dt, tau) => x + (target - x) * (1 - Math.exp(-dt / tau));
+
+// ------------------------------------------------------------------------------------------------
+// configuration
+function mergeSpec(base, over) {
+  if (!over) return base;
+  const out = { ...base };
+  for (const [k, v] of Object.entries(over)) {
+    if (v && typeof v === 'object' && !Array.isArray(v) && base[k] && typeof base[k] === 'object' && !Array.isArray(base[k])) out[k] = mergeSpec(base[k], v);
+    else out[k] = v;
+  }
+  return out;
+}
+
+function resolveConfig(species, data, skeleton) {
+  const base = species.motion || {};
+  const variant = data.params?.variant;
+  const spec = mergeSpec(base, base.variants && variant ? base.variants[variant] : null);
+  const J = {};
+  for (const [k, v] of Object.entries(data.joints)) J[k] = new THREE.Vector3(v[0], v[1], v[2]);
+  const s = data.params?.size || 1, sq = Math.sqrt(s);
+  const boneIndex = Object.fromEntries(data.bones.map((b, i) => [b.name, i]));
+  const bindQ = skeleton.bind.map((m) => new THREE.Quaternion().setFromRotationMatrix(m));
+  // body root: centre of the coxa bases (sternum level), on the midline
+  const root = new THREE.Vector3();
+  for (const key of LEG_KEYS) root.add(J['coxa' + key[1] + key[0]]);
+  root.multiplyScalar(1 / 8); root.x = 0;
+  const loc = (v) => v.clone().sub(root);
+  const cfg = {
+    spec, s, sq, J, root, boneIndex, bindQ,
+    rootH: root.y,
+    maxSpeed: (spec.maxSpeed ?? 0.3) * sq,
+    accel: (spec.accel ?? 2) * sq, decel: (spec.decel ?? 3) * sq,
+    turnRate: (spec.turnRate ?? 4) / sq,
+    latAccelMax: (spec.latAccelMax ?? 0.4) * sq,
+    gears: Object.fromEntries(Object.entries(spec.gears || { walk: 0.05, run: 0.15 }).map(([k, v]) => [k, v * sq])),
+    gaits: (spec.gaits || []).map((g) => ({ lift: 0.003, bob: 0, sway: 0, ...g })),
+    stance: { reach: [0.9, 0.93, 0.93, 0.9], height: 1, width: 1, ...(spec.stance || {}) },
+    heelLift: (spec.feet?.heelLift ?? 12) * DEG,
+    abd: { stiffness: 16, lag: 0.12, droop: 0.05, ...(spec.abdomen || {}) },
+    breath: { rate: 0.5, amp: 0.015, ...(spec.breath || {}) },
+    chel: { fang: 'labidognath', fangOpen: 1.2, spread: 0.3, pitch: 0.45, ...(spec.chelicerae || {}) },
+    palps: { twitch: 1, tap: 0.5, ...(spec.palps || {}) },
+    idle: { twitch: 1, raiseFront: 0.1, look: 0.3, ...(spec.idle || {}) },
+    look: { yaw: 0.45, pitch: 0.3, ...(spec.look || {}) },
+    actions: spec.actions || {},
+  };
+  if (!cfg.gaits.length) throw new Error('procedural-animals spider: species.motion.gaits is required');
+  // ---- legs
+  cfg.legs = LEG_KEYS.map((key, idx) => {
+    const S = key[0], i = +key[1], side = S === 'L' ? 1 : -1;
+    const jn = legJoints(i, S), bn = legBones(i, S);
+    const P = jn.map((n) => loc(J[n]));
+    const len = [], az = [], el = [];
+    for (let k = 0; k < 7; k++) {
+      const d = P[k + 1].clone().sub(P[k]);
+      len.push(d.length());
+      d.normalize();
+      az.push(Math.atan2(d.x * side, d.z));
+      el.push(Math.asin(clamp(d.y, -1, 1)));
+    }
+    const phi0 = az[2];
+    const u0 = new THREE.Vector3(Math.sin(phi0) * side, 0, Math.cos(phi0));
+    const n0 = new THREE.Vector3().crossVectors(u0, Y_AXIS).normalize();
+    // patella + tibia as one rigid link from the knee to the tibia end
+    const pt = P[5].clone().sub(P[3]);
+    const ptH = pt.x * u0.x + pt.z * u0.z;
+    const ept0 = Math.atan2(pt.y, ptH);
+    const L = {
+      key, idx, i, S, side, front: i <= 2,
+      bones: bn.map((b) => cfg.boneIndex[b]), bindQ: bn.map((b) => bindQ[cfg.boneIndex[b]]),
+      P0: P, len, az0: az, el0: el, phi0, u0, n0,
+      Lpt: Math.hypot(ptH, pt.y), dp: el[3] - ept0, dt: el[4] - ept0,
+      total: len.reduce((a, b) => a + b, 0),
+      tipY: J[jn[7]].y, // claw tip height above the ground at bind
+      set: SET_A[idx],
+    };
+    L.reach2 = L.len[2] + L.Lpt;
+    const F0 = P[2], A0 = P[6];
+    L.D0 = Math.hypot((A0.x - F0.x) * u0.x + (A0.z - F0.z) * u0.z, A0.y - F0.y);
+    // neutral foothold (body frame, horizontal): the bind claw pulled toward the coxa
+    const rk = cfg.stance.reach[i - 1] ?? 0.9;
+    L.neutral = new THREE.Vector3(P[0].x + (P[7].x - P[0].x) * rk * cfg.stance.width, 0, P[0].z + (P[7].z - P[0].z) * rk);
+    // workspace: horizontal distance of the claw from the coxa base (too close folds the leg over
+    // itself, too far cannot be reached)
+    L.rN = Math.hypot(L.neutral.x - P[0].x, L.neutral.z - P[0].z);
+    L.rMin = 0.64 * L.rN;
+    L.rMax = Math.min(1.18 * L.rN, 0.95 * (L.total - len[0] - len[1]));
+    L.azN = Math.atan2((L.neutral.x - P[0].x) * side, L.neutral.z - P[0].z);
+    L.azMax = 0.7;
+    return L;
+  });
+  cfg.legLen = cfg.legs.reduce((a, L) => a + L.total, 0) / 8;
+  // least-squares plane through the neutral footholds: rows of (X^T X)^-1 X^T for y = a + b x + c z
+  {
+    const X = cfg.legs.map((L) => [1, L.neutral.x, L.neutral.z]);
+    const A = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+    for (const r of X) for (let a = 0; a < 3; a++) for (let b = 0; b < 3; b++) A[a][b] += r[a] * r[b];
+    const inv = new THREE.Matrix3().set(...A[0], ...A[1], ...A[2]).invert().elements; // column-major
+    const Ai = (a, b) => inv[b * 3 + a];
+    cfg.fitW = [0, 1, 2].map((a) => X.map((r) => Ai(a, 0) * r[0] + Ai(a, 1) * r[1] + Ai(a, 2) * r[2]));
+  }
+  cfg.turnR = cfg.legs.reduce((a, L) => a + Math.hypot(L.neutral.x, L.neutral.z), 0) / 8;
+  // ---- palps
+  cfg.palpDefs = ['L', 'R'].map((S) => {
+    const side = S === 'L' ? 1 : -1, jn = palpJoints(S), bn = palpBones(S);
+    const P = jn.map((n) => loc(J[n]));
+    const len = [], az = [], el = [];
+    for (let k = 0; k < 6; k++) {
+      const d = P[k + 1].clone().sub(P[k]);
+      len.push(d.length()); d.normalize();
+      az.push(Math.atan2(d.x * side, d.z)); el.push(Math.asin(clamp(d.y, -1, 1)));
+    }
+    const phi0 = az[2];
+    const u0 = new THREE.Vector3(Math.sin(phi0) * side, 0, Math.cos(phi0));
+    return { S, side, bones: bn.map((b) => cfg.boneIndex[b]), bindQ: bn.map((b) => bindQ[cfg.boneIndex[b]]), P0: P, len, az0: az, el0: el, phi0, n0: new THREE.Vector3().crossVectors(u0, Y_AXIS).normalize(), tipR: 0.0004 * s };
+  });
+  // ---- chelicerae and fangs
+  cfg.chels = ['L', 'R'].map((S) => {
+    const side = S === 'L' ? 1 : -1;
+    const base = loc(J['cheBase' + S]), tip = loc(J['cheTip' + S]), ft = loc(J['fangTip' + S]);
+    const fangVec = ft.clone().sub(tip);
+    // fang hinge: labidognath fangs swing sideways (about the forward axis), orthognath fangs swing
+    // down and forward (about the lateral axis); the sign is chosen so that opening moves the tip down
+    const axis = cfg.chel.fang === 'orthognath' ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 0, 1);
+    const test = fangVec.clone().applyAxisAngle(axis, 0.2);
+    if (test.y > fangVec.y) axis.negate();
+    return { S, side, base, tip, fangVec, fangAxis: axis, bc: cfg.boneIndex['chelicera' + S], bf: cfg.boneIndex['fang' + S] };
+  });
+  cfg.ax = {};
+  for (const n of ['front', 'ceph', 'pedA', 'pedB', 'abdEnd', 'spinTip']) cfg.ax[n] = loc(J[n]);
+  cfg.bone = {};
+  for (const n of ['prosoma', 'head', 'pedicel', 'abdomen', 'spinnerets']) cfg.bone[n] = cfg.boneIndex[n] ?? -1;
+  // support points for ground contact of the body: extreme vertices of the bind mesh in 26
+  // directions, for the parts rigid with the prosoma and with the abdomen
+  const abdC = cfg.ax.pedB.clone().lerp(cfg.ax.abdEnd, 0.5);
+  cfg.abdC = abdC; cfg.abdL = cfg.ax.pedB.distanceTo(cfg.ax.abdEnd) * 0.5;
+  cfg.abdR = cfg.abdL * 0.62;
+  {
+    const dirs = [];
+    for (let x = -1; x <= 1; x++) for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++) if (x || y || z) dirs.push(new THREE.Vector3(x, y, z).normalize());
+    const grp = data.bones.map((b) => (b.name === 'prosoma' || b.name === 'head' ? 0 : b.name === 'abdomen' || b.name === 'spinnerets' ? 1 : -1));
+    const best = [dirs.map(() => ({ d: -1e9, p: null })), dirs.map(() => ({ d: -1e9, p: null }))];
+    const pos = data.pos, si = data.skinIndex, sw = data.skinWeight;
+    const c0 = [cfg.ax.pedA.clone().lerp(cfg.ax.front, 0.5), abdC];
+    for (let v = 0; v < data.nV; v++) {
+      if (sw[v * 4] < 0.9) continue;
+      const gI = grp[si[v * 4]];
+      if (gI < 0) continue;
+      const x = pos[v * 3] - root.x, y = pos[v * 3 + 1] - root.y, z = pos[v * 3 + 2] - root.z;
+      const c = c0[gI];
+      for (let k = 0; k < dirs.length; k++) {
+        const dd = (x - c.x) * dirs[k].x + (y - c.y) * dirs[k].y + (z - c.z) * dirs[k].z;
+        if (dd > best[gI][k].d) best[gI][k] = { d: dd, p: [x, y, z] };
+      }
+    }
+    cfg.supPro = best[0].filter((b) => b.p).map((b) => new THREE.Vector3(...b.p));
+    cfg.supAbd = best[1].filter((b) => b.p).map((b) => new THREE.Vector3(...b.p).sub(cfg.ax.pedB));
+    // the abdomen's lowest bind point (for resting it on the ground)
+    let lo = null;
+    for (const p of cfg.supAbd) if (!lo || p.y < lo.y) lo = p;
+    cfg.abdLow = lo || new THREE.Vector3(0, -cfg.abdR, -cfg.abdL);
+  }
+  cfg.bodyLen = cfg.ax.front.distanceTo(cfg.ax.spinTip);
+  // ---- death curl, per leg: every joint flexed ventrally so the leg folds under the sternum and no
+  // joint sticks out beyond the carapace top or the body's flanks (a dead spider on its back or side
+  // rests on its body, never propped on its knees). Solved once here in joint space (femur
+  // elevation + four flexions) by coordinate descent.
+  {
+    let yTop = -1e9, yBot = 1e9, halfW = 0;
+    for (const p of cfg.supPro) { yTop = Math.max(yTop, p.y); yBot = Math.min(yBot, p.y); halfW = Math.max(halfW, Math.abs(p.x)); }
+    for (const p of cfg.supAbd) halfW = Math.max(halfW, Math.abs(p.x + cfg.ax.pedB.x));
+    cfg.bodyTop = yTop; cfg.bodyHalfW = halfW;
+    // two curls per leg: 'back' (a loose fist over the sternum: on its back, or the upper legs on its
+    // side) and 'side' (the legs underneath when it lies on its side: folded straight down so no
+    // joint reaches beyond the flank it rests on)
+    const solve = (L, mode) => {
+      const m = 1.6 * L.tipY, s = L.side, side = mode === 'side', up = mode === 'up';
+      const out = [Math.sin(L.phi0) * s, Math.cos(L.phi0)];
+      const tgt = side ? [s * 0.35 * halfW, yBot - 0.15 * L.total, L.P0[0].z * 0.7]
+        : up ? [L.P0[0].x + out[0] * 0.28 * L.total, yBot + L.tipY, L.P0[0].z + out[1] * 0.28 * L.total]
+        : [s * 0.12 * halfW, yBot - 0.1 * L.total, L.P0[0].z * 0.5];
+      const deep = yBot - 0.3 * L.total;
+      const jp = [];
+      const fk = (x) => {
+        // x = [femur, b1, b2, b3, b4, coxa] (rad); leg plane at phi0
+        let px = L.P0[0].x, py = L.P0[0].y, pz = L.P0[0].z;
+        const segs = [[L.az0[0], x[5]], [L.phi0, x[5]]];
+        let e = x[0];
+        segs.push([L.phi0, e]);
+        for (let k = 1; k < 5; k++) { e += x[k]; segs.push([L.phi0, e]); }
+        jp.length = 0;
+        for (let k = 0; k < 7; k++) {
+          const [a, el] = segs[k], ce = Math.cos(el);
+          px += L.len[k] * Math.sin(a) * ce * s; py += L.len[k] * Math.sin(el); pz += L.len[k] * Math.cos(a) * ce;
+          jp.push(px, py, pz);
+        }
+      };
+      const cost = (x) => {
+        fk(x);
+        const n = jp.length;
+        let c = ((jp[n - 3] - tgt[0]) ** 2 + (jp[n - 2] - tgt[1]) ** 2 + (jp[n - 1] - tgt[2]) ** 2) / (L.total * L.total);
+        for (let k = 0; k < 7; k++) {
+          const x_ = jp[k * 3], y_ = jp[k * 3 + 1];
+          const over = up ? Math.max(0, yBot + m - y_) : Math.max(0, y_ - (yTop - m)) + (side ? Math.max(0, Math.abs(x_) - (halfW - m)) : Math.max(0, deep - y_));
+          c += 400 * (over / L.total) ** 2;
+        }
+        // even flexions (a curl, not one sharp fold), within anatomical limits
+        const mean = (x[1] + x[2] + x[3] + x[4]) / 4;
+        for (let k = 1; k < 5; k++) c += 0.02 * (x[k] - mean) ** 2 + 50 * Math.max(0, x[k] + 0.1) ** 2 + 50 * Math.max(0, -x[k] - 2.6) ** 2;
+        c += 50 * Math.max(0, x[0] - (up ? 1.3 : 0.2)) ** 2 + 50 * Math.max(0, -x[0] - 1.6) ** 2 + (side ? 0 : up ? 0.05 * (x[0] - 0.8) ** 2 : 0.05 * (x[0] + 0.8) ** 2);
+        // the coxa and trochanter may swing down (ventrally) in their sockets, not up
+        c += 50 * Math.max(0, x[5] - L.el0[0]) ** 2 + 50 * Math.max(0, -x[5] - 1.4) ** 2 + 0.05 * (x[5] - L.el0[0]) ** 2;
+        return c;
+      };
+      const x = up ? [0.8, -1.6, -0.6, -0.6, -0.4, L.el0[0]] : [-1.0, -1.4, -0.8, -0.8, -0.6, L.el0[0]];
+      let best = cost(x), step = 0.4;
+      for (let it = 0; it < 400 && step > 1e-3; it++) {
+        let improved = false;
+        for (let k = 0; k < 6; k++) for (const d of [step, -step]) {
+          x[k] += d;
+          const c = cost(x);
+          if (c < best) { best = c; improved = true; } else x[k] -= d;
+        }
+        if (!improved) step *= 0.5;
+      }
+      return { F: x[0], C: x[5], B: [x[1], x[2], x[3], x[4]] };
+    };
+    for (const L of cfg.legs) { L.curlBack = solve(L, 'back'); L.curlSide = solve(L, 'side'); L.curlUp = solve(L, 'up'); }
+  }
+  // mouth: between the chelicera tips
+  cfg.mouth = cfg.chels[0].tip.clone().add(cfg.chels[1].tip).multiplyScalar(0.5);
+  return cfg;
+}
+
+// ------------------------------------------------------------------------------------------------
+// swing path profiles (see the header): horizontal progress with short linear speed ramps; vertical
+// hump: constant climb, a rounded apex, constant descent
+function progress(u, a) {
+  const vm = 1 / (1 - a);
+  if (u <= 0) return 0;
+  if (u >= 1) return 1;
+  if (u < a) return (vm * u * u) / (2 * a);
+  if (u > 1 - a) { const r = 1 - u; return 1 - (vm * r * r) / (2 * a); }
+  return vm * (u - a / 2);
+}
+function hump(u) {
+  // vertical speed +c on [0, u1], easing linearly to -c2 over [u1, u2], -c2 on [u2, 1]; c2 makes the
+  // path end at 0; normalised to a peak of 1
+  if (u <= 0 || u >= 1) return 0;
+  const u1 = 0.3, u2 = 0.6, T = u2 - u1;
+  const c2 = (u1 + 0.5 * T) / (0.5 * T + (1 - u2));
+  const peak = u1 + (0.5 * T) / (1 + c2);
+  let y;
+  if (u < u1) y = u;
+  else if (u < u2) { const t = u - u1; y = u1 + t - ((1 + c2) * t * t) / (2 * T); }
+  else y = c2 * (1 - u);
+  return y / peak;
+}
+
+// ------------------------------------------------------------------------------------------------
+// actions
+const POSTURES = new Set(['sit', 'lie', 'sleep', 'death']);
+const ONESHOTS = new Set(['jump', 'attack', 'hit', 'eat', 'drink']);
+export const SPIDER_ACTIONS = ['idle', 'jump', 'sit', 'lie', 'sleep', 'eat', 'drink', 'attack', 'hit', 'death', 'stand'];
+
+function createParams() {
+  return {
+    gaitW: 1, speedScale: 1, crouch: 0, drop: 0, pitch: 0, roll: 0, fwd: 0, side: 0, yaw: 0,
+    legIn: 0, drawIn: 0, tuck: 0, curl2: 0, raise: new Float32Array(8), hold: new Float32Array(8), curl: 0, air: 0, lean: 0,
+    palpRaise: 0, palpReach: 0, palpWork: 0, palpDown: 0, palpFold: 0,
+    chelOpen: 0, chelWork: 0, fangOpen: 0, abdPitch: 0, abdDown: 0, breathRate: 1, breathAmp: 1,
+    flip: 0, reviving: 0, pullIn: 0, flipSide: 1, flipAngle: Math.PI, dead: 0, lookW: 1, look: null, twitch: 1,
+  };
+}
+function resetParams(P) {
+  P.gaitW = 1; P.speedScale = 1; P.crouch = P.drop = P.pitch = P.roll = P.fwd = P.side = P.yaw = 0;
+  P.legIn = 0; P.drawIn = 0; P.tuck = 0; P.curl2 = 0; P.raise.fill(0); P.hold.fill(0); P.curl = P.tuck = P.air = P.lean = 0;
+  P.palpRaise = P.palpReach = P.palpWork = P.palpDown = P.palpFold = 0;
+  P.chelOpen = P.chelWork = P.fangOpen = P.abdPitch = P.abdDown = 0; P.breathRate = 1; P.breathAmp = 1;
+  P.flip = 0; P.reviving = 0; P.pullIn = 0; P.dead = 0; P.lookW = 1; P.look = null; P.twitch = 1;
+}
+const mx = (P, k, v, w) => { P[k] += (v - P[k]) * w; };
+const mxA = (arr, i, v, w) => { arr[i] += (v - arr[i]) * w; };
+
+const POSTURE_DEFS = {
+  // body lowered, abdomen resting on the ground, legs a little drawn in
+  sit: {
+    fadeIn: 0.7, fadeOut: 0.6,
+    apply(P, w) { mx(P, 'gaitW', 0, w); mx(P, 'crouch', 0.5, w); mx(P, 'legIn', 0.25, w); mx(P, 'abdDown', 1, w); mx(P, 'palpDown', 0.4, w); mx(P, 'pitch', 0.14, w); },
+  },
+  // flat on the ground, legs drawn in
+  lie: {
+    fadeIn: 0.9, fadeOut: 0.8,
+    apply(P, w) { mx(P, 'gaitW', 0, w); mx(P, 'crouch', 0.8, w); mx(P, 'legIn', 0.5, w); mx(P, 'abdDown', 1, w); mx(P, 'palpDown', 0.8, w); mx(P, 'breathRate', 0.8, w); },
+  },
+  // lie with the legs pulled in tight, palps folded, slow breathing
+  sleep: {
+    fadeIn: 1.1, fadeOut: 1.0,
+    apply(P, w, inst, e) {
+      POSTURE_DEFS.lie.apply(P, w);
+      const c = smooth(0.4, 2.0, inst.t) * w;
+      const tuck = e.cfg.actions.sleep?.tuck ?? 0.8;
+      mx(P, 'crouch', 0.92, c); mx(P, 'legIn', 0.5 + 0.35 * tuck, c); mx(P, 'palpFold', 1, c);
+      // the claws are drawn in along the ground, the front legs folded against the chelicerae
+      mx(P, 'drawIn', tuck, c); mx(P, 'pullIn', tuck, c);
+      mx(P, 'breathRate', 0.45, c); mx(P, 'breathAmp', 1.3, c); mx(P, 'twitch', 0.1, c); mx(P, 'lookW', 0, c);
+      for (let i = 0; i < 8; i++) if (e.legs[i].def.i === 1) mxA(P.hold, i, 0.3 * tuck, c);
+    },
+  },
+  // hydraulic collapse: the legs curl under the body, it drops, then rolls onto its back or side
+  death: {
+    fadeIn: 0.2, fadeOut: 3.0,
+    apply(P, w, inst) {
+      const t = inst.t;
+      mx(P, 'gaitW', 0, w); mx(P, 'dead', 1, w);
+      // the legs lose pressure: the body sinks and the claws are drawn in, then the legs fold up
+      // (reviving runs the other way round: it rolls back first, then uncurls, then stands up)
+      mx(P, 'drawIn', smooth(0.05, 0.6, t), smooth(0, 0.35, w));
+      // (no dorsal tuck any more: the legs flex ventrally at once, the body hunches on them and tips over)
+      // on its back the legs contract further, ventrally (over the sternum)
+      mx(P, 'curl2', smooth(0.3, 1.3, t), smooth(0.3, 0.8, w));
+      mx(P, 'crouch', smooth(0, 0.35, t), smooth(0, 0.45, w));
+      const f = smooth(1.0, 2.0, t);
+      const settle = t > 2.0 ? Math.exp(-(t - 2.0) * 5) * Math.sin((t - 2.0) * 14) * 0.05 : 0;
+      mx(P, 'flip', clamp(f - settle, 0, 1.05), smooth(0.6, 1, w));
+      P.flipSide = inst.side; P.flipAngle = inst.flipAngle;
+      if (inst.target < 0.5) P.reviving = 1;
+      mx(P, 'palpFold', 1, w); mx(P, 'fangOpen', 0.3, w); mx(P, 'breathAmp', 0, w); mx(P, 'breathRate', 0, w);
+      mx(P, 'twitch', 0, w); mx(P, 'lookW', 0, w); mx(P, 'abdDown', 0, w);
+    },
+  },
+};
+
+const ONESHOT_DEFS = {
+  // pounce: crouch, push off with legs III-IV, fly with the front legs raised to grab, land
+  jump: {
+    start(inst, e) {
+      const cfg = e.cfg, o = cfg.actions.jump || {};
+      inst.tc = (o.crouch ?? 0.22) * cfg.sq;
+      const h = (o.height ?? 0.014) * cfg.s;
+      // apex h above the take-off height, counting the push-off and coast rise (vy (PUSH / 2 + COAST))
+      const k = PUSH / 2 + COAST;
+      inst.vy = G_ACC * (-k + Math.sqrt(k * k + (2 * h) / G_ACC));
+      const T = (2 * inst.vy) / G_ACC + PUSH * 0.5 + 2 * COAST;
+      let dist = (o.distance ?? 0.05) * cfg.s;
+      if (inst.opts.target) { const t = inst.opts.target; dist = clamp(Math.hypot(t.x - e.pos.x, t.z - e.pos.z), 0.3 * dist, dist * 2); }
+      inst.vh = Math.max(e.speed, dist / T);
+      inst.phase = 'crouch'; inst.dur = Infinity;
+    },
+    update(inst, dt, e) {
+      if (inst.phase === 'crouch' && inst.t >= inst.tc) { inst.phase = 'air'; inst.tAir = inst.t; e.takeOff(inst.vy, inst.vh); }
+      if (inst.phase === 'air' && inst.t - inst.tAir > 3) e.touchDown();
+      // pose weights are states with finite rates (the flight of a small spider lasts ~0.1 s)
+      inst.aw = clamp((inst.aw || 0) + (inst.phase === 'air' ? dt / 0.1 : inst.phase === 'land' ? -dt / 0.25 : 0), 0, 1);
+      return inst.phase === 'land' && inst.t - inst.tLand > 0.45;
+    },
+    onLand(inst) { inst.phase = 'land'; inst.tLand = inst.t; },
+    apply(P, w, inst, e) {
+      const aw = (inst.aw || 0) * w;
+      const pre = inst.phase === 'crouch' ? smooth(0, inst.tc, inst.t) : inst.phase === 'air' ? 1 : 1 - smooth(0, 0.3, inst.t - inst.tLand);
+      const land = inst.phase === 'land' ? envelope(inst.t - inst.tLand, 0.45, 0.06, 0.35) : 0;
+      const cr = inst.phase === 'crouch' ? smooth(0, inst.tc, inst.t) : inst.phase === 'air' ? 1 - smooth(0, PUSH + 0.03, inst.t - inst.tAir) : 0;
+      mx(P, 'crouch', 0.55, cr * w); mx(P, 'crouch', 0.4, land * w); mx(P, 'pitch', 0.1, pre * w * (1 - aw));
+      mx(P, 'air', 1, aw);
+      // landing contacts are not gait contacts (the claws settle while the body brakes)
+      if (inst.phase === 'land') mx(P, 'gaitW', 0, (1 - smooth(0.3, 0.45, inst.t - inst.tLand)) * w);
+      mx(P, 'palpRaise', 1, Math.max(smooth(0, 1, aw), 0.5 * pre) * w); mx(P, 'fangOpen', 1, Math.max(aw, 0.4 * pre) * w); mx(P, 'chelOpen', 0.8, aw);
+      for (let i = 0; i < 8; i++) {
+        const li = e.legs[i].def.i;
+        // front legs lift already in the crouch and reach up and forward to grab; after landing they
+        // come down onto the prey
+        if (li === 1) { mxA(P.raise, i, 1, Math.max(aw, 0.35 * pre) * w); mxA(P.hold, i, 0.6, land * (1 - aw) * w); }
+        else if (li === 2) mxA(P.raise, i, 0.6, aw);
+      }
+    },
+  },
+  // threat display (front legs raised, fangs out, body reared), then a lunge with a fang strike
+  attack: {
+    start(inst, e) {
+      const o = e.cfg.actions.attack || {};
+      inst.threat = (o.threat ?? 0.7) * (inst.opts.duration ? inst.opts.duration / 1.7 : 1);
+      inst.dur = inst.threat + 1.0;
+      inst.hit = false;
+      if (inst.opts.target && !e.input.follow) {
+        const t = inst.opts.target;
+        const want = Math.atan2(t.x - e.pos.x, t.z - e.pos.z);
+        if (Math.abs(angDiff(e.heading, want)) > 0.2) e._turnTo = want;
+      }
+    },
+    update(inst, dt, e) {
+      const tl = inst.t - inst.threat;
+      if (!inst.hit && tl >= 0.16) {
+        inst.hit = true;
+        const cfg = e.cfg;
+        const p = e.localToWorld(cfg.mouth.x, cfg.mouth.y - 0.002 * cfg.s, cfg.mouth.z + 0.003 * cfg.s, new THREE.Vector3());
+        e.emit('attackHit', { position: p, direction: e.forward(e.heading, new THREE.Vector3()), style: 'bite' });
+      }
+      return inst.t >= inst.dur;
+    },
+    apply(P, w, inst, e) {
+      const o = e.cfg.actions.attack || {}, cfg = e.cfg;
+      const t = inst.t, T = inst.threat, tl = t - T;
+      const rear = smooth(0, Math.min(0.35, T), t) * (1 - smooth(0.05, 0.2, tl) * 0.8) * (1 - smooth(0.45, 0.95, tl));
+      const lunge = smooth(0, 0.14, tl) * (1 - smooth(0.4, 0.9, tl));
+      const still = 1 - 0.75 * smooth(0, 0.3 * cfg.maxSpeed, e.speed); // on the run it rears less
+      mx(P, 'pitch', ((o.rear ?? 0.32) * rear - 0.12 * lunge) * still, w);
+      mx(P, 'crouch', 0.15 * rear + 0.25 * lunge, w);
+      // the lunge is a body thrust over planted claws (smaller on the run: the gait carries it)
+      mx(P, 'fwd', (o.lunge ?? 0.012) * cfg.s * lunge * (1 - smooth(0, 0.3 * cfg.maxSpeed, e.speed)), w);
+      mx(P, 'fangOpen', smooth(0.1, 0.4, t) * (1 - smooth(0.3, 0.6, tl) * 0.7) * (1 - smooth(0.7, 0.95, tl)), w);
+      mx(P, 'chelOpen', 0.8 * rear + 0.3 * lunge, w);
+      mx(P, 'palpRaise', 0.9 * rear, w);
+      mx(P, 'abdPitch', -0.15 * rear, w);
+      const strike = lunge * (1 - smooth(0.2, 0.5, tl));
+      for (let i = 0; i < 8; i++) {
+        const li = e.legs[i].def.i;
+        if (li === 1) { mxA(P.raise, i, rear, w); mxA(P.hold, i, strike, w); }
+        else if (li === 2) mxA(P.raise, i, (o.raise2 ?? 0.45) * rear, w);
+      }
+    },
+  },
+  // flinch, then scuttle back
+  hit: {
+    start(inst, e) {
+      const cfg = e.cfg;
+      inst.dur = 0.9;
+      const d = inst.opts.direction;
+      const dir = tv();
+      if (d && d.lengthSq() > 1e-8) dir.set(d.x, 0, d.z).normalize(); else e.forward(e.heading, dir).negate();
+      // scuttle away from the blow, mostly backwards
+      const back = e.forward(e.heading, tv()).negate();
+      dir.lerp(back, 0.5).normalize();
+      e.push.addScaledVector(dir, 5.5 * cfg.bodyLen / Math.max(0.5, cfg.sq));
+    },
+    update(inst) { return inst.t >= inst.dur; },
+    apply(P, w, inst, e) {
+      const t = inst.t;
+      const fl = envelope(t, 0.9, 0.05, 0.55);
+      const jerk = smooth(0, 0.12, t) * (1 - smooth(0.15, 0.45, t));
+      mx(P, 'crouch', 0.3 * fl, w); mx(P, 'pitch', 0.18 * jerk, w); mx(P, 'fwd', -0.06 * e.cfg.bodyLen * jerk, w);
+      mx(P, 'palpRaise', 0.6 * fl, w); mx(P, 'abdPitch', 0.12 * jerk, w);
+      for (let i = 0; i < 8; i++) if (e.legs[i].def.i === 1) mxA(P.raise, i, 0.45 * jerk, w);
+    },
+  },
+  // prey held under the chelicerae by legs I and the palps; chelicerae working
+  eat: {
+    start(inst) { inst.dur = inst.opts.duration ?? (inst.opts.loop ? Infinity : 4); },
+    update(inst) { return inst.t >= inst.dur; },
+    apply(P, w, inst, e) {
+      const a = smooth(0, 0.5, inst.t) * w;
+      mx(P, 'crouch', 0.3, a); mx(P, 'pitch', -0.06, a);
+      mx(P, 'palpWork', 1, a); mx(P, 'chelWork', 1, a); mx(P, 'fangOpen', 0.35, a); mx(P, 'palpReach', 0.3, a);
+      for (let i = 0; i < 8; i++) if (e.legs[i].def.i === 1) mxA(P.hold, i, 0.7, a);
+    },
+  },
+  // mouthparts down to the ground / water
+  drink: {
+    start(inst) { inst.dur = inst.opts.duration ?? (inst.opts.loop ? Infinity : 3); },
+    update(inst) { return inst.t >= inst.dur; },
+    apply(P, w, inst) {
+      const a = smooth(0, 0.6, inst.t) * w;
+      mx(P, 'crouch', 0.35, a); mx(P, 'pitch', -0.2, a); mx(P, 'palpRaise', -0.2, a); mx(P, 'palpReach', 0.5, a);
+      mx(P, 'chelWork', 0.25, a); mx(P, 'chelOpen', 0.2, a); mx(P, 'abdPitch', 0.05, a);
+    },
+  },
+};
+
+class SpiderActions {
+  constructor(engine) {
+    this.e = engine;
+    this.names = SPIDER_ACTIONS.slice();
+    this.postures = [];
+    this.oneshots = [];
+    this.posture = 'stand';
+    this.standReq = null;
+    this.idle = { w: 0, lookT: 1, look: new THREE.Vector3(), hasLook: false, twitchT: 2, palpT: 1 };
+  }
+  holdsStill() { for (const p of this.postures) if (p.target > 0 || p.w > 0.02) return true; return false; }
+  // automatic stand-up (asked to move): never revives a dead spider
+  requestStand() { if (!this.standReq && !this.dead()) this.play('stand'); }
+  // arbitration: a new one-shot interrupts the running
+  // ones (fade out, 'interrupted'); a jump in the air is committed (only a hit layers over it); a
+  // posture ends the one-shots (except a hit); stop() ends everything but death and never cuts a
+  // jump in the air; dead: only hit is taken. Promises resolve 'done' | 'interrupted' | 'stopped' |
+  // 'refused'.
+  committed(a) { return !a.stopping && a.name === 'jump' && this.e.air.active; }
+  end(a, reason) { if (a.stopping) return; a.stopping = true; a.reason = reason; }
+  current() {
+    for (const a of this.oneshots) if (!a.stopping) return a.name;
+    for (const p of this.postures) if (p.target > 0) return p.name;
+    return this.standReq ? 'stand' : null;
+  }
+  clear() { for (const a of [...this.postures, ...this.oneshots]) { a.resolve?.('stopped'); a.resolveIn?.('stopped'); } this.postures.length = 0; this.oneshots.length = 0; }
+  dead() { for (const p of this.postures) if (p.name === 'death' && p.target > 0) return true; return false; }
+
+  play(name, opts = {}) {
+    const e = this.e;
+    if (name === 'idle') name = 'stand';
+    if (name === 'stand') {
+      if (!this.postures.length) return Promise.resolve('done');
+      for (const p of this.postures) if (p.target > 0) { p.target = 0; p.resolveIn?.('interrupted'); }
+      e.emit('actionStart', { name: 'stand' });
+      if (this.standReq) return this.standReq.promise;
+      let resolve;
+      const promise = new Promise((r) => { resolve = r; });
+      this.standReq = { promise, resolve };
+      return promise;
+    }
+    if (POSTURES.has(name)) {
+      const cur = this.postures.find((p) => p.target > 0);
+      if (cur && cur.name === 'death' && name !== 'death') return Promise.resolve('refused');
+      if (cur && cur.name === name) return cur.promiseIn;
+      if (name !== 'death' && this.oneshots.some((a) => this.committed(a))) return Promise.resolve('refused');
+      for (const p of this.postures) if (p.target > 0) { p.target = 0; p.resolveIn?.('interrupted'); }
+      if (this.standReq) { this.standReq.resolve('interrupted'); this.standReq = null; }
+      for (const a of this.oneshots) if (a.name !== 'hit' && !this.committed(a)) this.end(a, 'interrupted');
+      const def = POSTURE_DEFS[name];
+      let side = opts.side ?? (e.rand() < 0.5 ? -1 : 1);
+      if (opts.direction && name === 'death') { const d = opts.direction; side = (d.x * Math.cos(e.heading) - d.z * Math.sin(e.heading)) > 0 ? 1 : -1; }
+      const inst = { name, t: 0, w: 0, target: 1, fadeIn: def.fadeIn / (opts.speed || 1), fadeOut: def.fadeOut, side, opts, reached: false };
+      // death: on its back most of the time, sometimes on its side
+      inst.flipAngle = opts.onSide ?? (e.rand() < 0.35) ? Math.PI * 0.52 : Math.PI * (0.9 + 0.08 * e.rand());
+      const prev = this.postures.find((p) => p.name === 'lie');
+      if (prev && name === 'sleep') { inst.w = prev.w; prev.w = 0; this.postures = this.postures.filter((p) => p !== prev); }
+      inst.promiseIn = new Promise((r) => { inst.resolveIn = r; });
+      this.postures.push(inst);
+      e.emit('actionStart', { name });
+      if (name === 'death') e.emit('death', { position: e.pos.clone() });
+      return inst.promiseIn;
+    }
+    if (!ONESHOTS.has(name)) return Promise.reject(new Error(`procedural-animals: unknown action "${name}"`));
+    if (this.dead() && name !== 'hit') return Promise.resolve('refused');
+    if (this.holdsStill() && (name === 'jump' || name === 'attack')) return this.play('stand').then((r) => (r === 'refused' ? r : this.play(name, opts)));
+    // arbitration: a new one-shot interrupts the running ones; in the air only a hit is taken
+    if (e.air.active || this.oneshots.some((a) => this.committed(a))) {
+      if (name !== 'hit') return Promise.resolve('refused');
+      for (const a of this.oneshots) if (a.name === 'hit') this.end(a, 'interrupted');
+    } else for (const a of this.oneshots) this.end(a, 'interrupted');
+    const inst = { name, t: 0, w: 0, dur: 1, stopping: false, opts, fade: name === 'hit' ? 0.06 : 0.15, speed: opts.speed || 1 };
+    ONESHOT_DEFS[name].start(inst, e);
+    inst.promise = new Promise((r) => { inst.resolve = r; });
+    this.oneshots.push(inst);
+    e.emit('actionStart', { name });
+    return inst.promise;
+  }
+
+  stop(name) {
+    for (const a of this.oneshots) if ((!name || a.name === name) && !this.committed(a)) this.end(a, 'stopped');
+    if (!name || POSTURES.has(name)) if (this.postures.some((p) => p.target > 0 && (name ? p.name === name : p.name !== 'death'))) this.play('stand');
+  }
+  onLand() { for (const a of this.oneshots) if (ONESHOT_DEFS[a.name].onLand) ONESHOT_DEFS[a.name].onLand(a, this.e); }
+
+  update(dt) {
+    const e = this.e, P = e.P;
+    resetParams(P);
+    for (const p of this.postures) {
+      p.t += dt;
+      const rate = p.target > p.w ? 1 / p.fadeIn : 1 / p.fadeOut;
+      p.w = clamp(p.w + clamp(p.target - p.w, -rate * dt, rate * dt), 0, 1);
+      if (!p.reached && p.target > 0 && p.w >= 1 && (p.name !== 'death' || p.t > 2.0) && (p.name !== 'sleep' || p.t > 2.0)) { p.reached = true; p.resolveIn('done'); e.emit('actionEnd', { name: p.name }); }
+    }
+    for (let i = this.postures.length - 1; i >= 0; i--) { const p = this.postures[i]; if (!(p.target > 0 || p.w > 0)) this.postures.splice(i, 1); }
+    let active = null;
+    for (const p of this.postures) if (p.target > 0) active = p;
+    this.posture = active ? (active.name === 'death' ? 'dead' : active.name) : this.postures.length ? 'standing-up' : 'stand';
+    if (this.standReq && !this.postures.length) { this.standReq.resolve('done'); this.standReq = null; e.emit('actionEnd', { name: 'stand' }); }
+    // idle
+    const still = e.speed < 0.08 * e.cfg.maxSpeed && !e.input.follow && e.push.lengthSq() < 1e-6 && e.pushV.lengthSq() < 1e-6;
+    let busy = false;
+    for (const a of this.oneshots) if (!a.stopping && a.name !== 'hit') busy = true;
+    const idleT = still && !this.postures.length && !busy ? 1 : 0;
+    const id = this.idle;
+    id.w += clamp(idleT - id.w, -dt * 2, dt * 0.8);
+    this.applyIdle(P, id.w, dt);
+    for (const p of this.postures) { const w = p.w * p.w * (3 - 2 * p.w); POSTURE_DEFS[p.name].apply(P, w, p, e); }
+    const wantsToMove = e.wantSpeed > 0.02 * e.cfg.maxSpeed || !!e.input.follow;
+    for (const a of this.oneshots) {
+      if (wantsToMove && (a.name === 'eat' || a.name === 'drink')) this.end(a, 'interrupted');
+      a.t += dt * a.speed;
+      if (!a.stopping && ONESHOT_DEFS[a.name].update(a, dt * a.speed, e)) this.end(a, 'done');
+      const fadeOut = a.name === 'jump' && a.reason === 'done' ? 0.05 : a.name === 'attack' ? 0.25 : a.fade;
+      if (a.stopping) a.w = Math.max(0, a.w - dt / fadeOut); else a.w = Math.min(1, a.w + dt / a.fade);
+      const w = a.w * a.w * (3 - 2 * a.w);
+      if (w > 0) ONESHOT_DEFS[a.name].apply(P, w, a, e);
+    }
+    for (let i = this.oneshots.length - 1; i >= 0; i--) {
+      const a = this.oneshots[i];
+      if (a.stopping && a.w <= 0) { this.oneshots.splice(i, 1); a.resolve(a.reason || 'done'); e.emit('actionEnd', { name: a.name, reason: a.reason || 'done' }); }
+    }
+    if (e.air.active) { let air = false; for (const a of this.oneshots) if (a.name === 'jump') air = true; if (!air) e.touchDown(); }
+  }
+
+  applyIdle(P, w, dt) {
+    const e = this.e, id = this.idle, cfg = e.cfg;
+    if (w <= 0.001) { id.hasLook = false; return; }
+    // sit-and-wait: front legs a little raised now and then
+    const rf = cfg.idle.raiseFront * (0.5 + 0.5 * Math.sin(e.time * 0.21 + 1.3));
+    for (let i = 0; i < 8; i++) if (e.legs[i].def.i === 1) mxA(P.raise, i, rf, w);
+    // leg twitch: one leg lifts a touch and sets down again
+    id.twitchT -= dt;
+    if (id.twitchT <= 0 && w > 0.9) {
+      id.twitchT = (2.5 + e.rand() * 5) / Math.max(0.05, cfg.idle.twitch);
+      e.twitchLeg(Math.floor(e.rand() * 8));
+    }
+    // look around
+    if (!e.input.look) {
+      id.lookT -= dt;
+      if (id.lookT <= 0) {
+        id.lookT = 1.5 + e.rand() * 3;
+        if (e.rand() < 0.35) id.hasLook = false;
+        else {
+          const a = e.heading + (e.rand() - 0.5) * 2 * cfg.idle.look;
+          const d = 10 * cfg.bodyLen;
+          const px = e.pos.x + Math.sin(a) * d, pz = e.pos.z + Math.cos(a) * d;
+          id.look.set(px, e.terrainH(px, pz) + (e.rand() * 3) * cfg.bodyLen, pz);
+          id.hasLook = true;
+        }
+      }
+      if (id.hasLook) { P.look = id.look; P.lookW = w; }
+    }
+  }
+}
+
+// ------------------------------------------------------------------------------------------------
+export function createSpiderMotion(ctx) { return new SpiderMotion(ctx); }
+
+export class SpiderMotion {
+  constructor({ species, data, skeleton, ground, water, position, heading = 0, emit }) {
+    this.species = species;
+    this.sk = skeleton;
+    this.cfg = resolveConfig(species, data, skeleton);
+    const cfg = this.cfg;
+    this.ground = ground || (() => 0);
+    this.water = water || null;
+    this.emit = emit || (() => {});
+    this.rand = prng((data.seed || 1) * 7919 + 29);
+    this.input = { speed: 0, heading, climb: 0, look: null, follow: null, target: null, targetSpeed: cfg.gears.run || 0.1, crouch: 0, gait: null };
+    this.pos = new THREE.Vector3();
+    this.velocity = new THREE.Vector3();
+    this.heading = heading; this.speed = 0; this.yawRate = 0; this.phase = 0; this.time = 0; this.lod = 0; this.frame = 0;
+    this.wantSpeed = 0; this.wantHeading = heading;
+    this.push = new THREE.Vector3(); this.pushV = new THREE.Vector3();
+    this.moveDir = new THREE.Vector3(0, 0, 1);
+    this.air = { active: false, t: 0, vy: 0, vh: 0, y0: 0, T: 0, dir: new THREE.Vector3() };
+    this.state = {
+      position: this.pos, heading, speed: 0, velocity: this.velocity, gait: 'stand', grounded: true,
+      action: null, posture: 'stand', eyelid: 0, lookTarget: null,
+      stats: { gait: 'stand', freq: 0, duty: 1 },
+      legs: LEG_KEYS.map((key) => ({ key, stance: true, contact: new THREE.Vector3() })),
+    };
+    this.headPose = { position: new THREE.Vector3(), quaternion: new THREE.Quaternion() };
+    this.debug = { targets: Array.from({ length: 8 }, () => new THREE.Vector3()) };
+    this.gaits = [...new Set(cfg.gaits.map((g) => g.name))];
+    this.gears = cfg.gears;
+    this.gait = { name: 'walk', f: 1, D: 0.7, lift: 0.003, bob: 0, sway: 0, off: new Float64Array(8) };
+    // springs
+    this.hS = new Spring(0); this.pitchS = new Spring(0); this.rollS = new Spring(0);
+    this.lookYawS = new Spring(0); this.lookPitchS = new Spring(0);
+    this.abdPitchS = new Spring(0); this.abdYawS = new Spring(0);
+    this.supportS = new Spring(0); this.speedS = new Spring(0);
+    this.breath = 0; this._lift = 0; this.brakeA = 0;
+    this.lastVel = new THREE.Vector3(); this.accelV = new THREE.Vector3();
+    // legs
+    this.legs = cfg.legs.map((L) => ({
+      def: L, state: 'stance', mode: 'gait',
+      plant: new THREE.Vector3(), lift: new THREE.Vector3(), land: new THREE.Vector3(), landBase: new THREE.Vector3(), tip: new THREE.Vector3(),
+      swingT: 0, swingDur: 0.1, liftH: 0.002, hMax: 0, stanceTime: 0, prevPhase: 0, windowUsed: false, heel: 0,
+      az: new Float64Array(7), el: new Float64Array(7), jp: Array.from({ length: 8 }, () => new THREE.Vector3()),
+      airFrom: new THREE.Vector3(), airRoot: new THREE.Vector3(), airT: 1, carry0: 0, swingInit: false, liftAz: new Float64Array(7), liftEl: new Float64Array(7), rawAz: new Float64Array(7), rawEl: new Float64Array(7), ikEl: new Float64Array(7), ikAz: new Float64Array(7),
+    }));
+    this.palpState = cfg.palpDefs.map(() => ({ twitch: new Float64Array(6), tgt: new Float64Array(6), twT: 0.5, az: new Float64Array(6), el: new Float64Array(6), jp: Array.from({ length: 7 }, () => new THREE.Vector3()) }));
+    // frames (preallocated)
+    this.qB = new THREE.Quaternion(); this.qBinv = new THREE.Quaternion(); this.upB = new THREE.Vector3(0, 1, 0); this.root = new THREE.Vector3();
+    this.qAbd = new THREE.Quaternion(); this.qPed = new THREE.Quaternion();
+    this._e = new THREE.Euler(); this._q = new THREE.Quaternion(); this._q2 = new THREE.Quaternion(); this._q3 = new THREE.Quaternion();
+    this._qc1 = new THREE.Quaternion(); this._qc2 = new THREE.Quaternion(); this._qc3 = new THREE.Quaternion();
+    this._scale = new THREE.Vector3(1, 1, 1); this._v = new THREE.Vector3(); this._w = new THREE.Vector3();
+    this.lookTarget = new THREE.Vector3();
+    this.P = createParams();
+    this.actionsLayer = new SpiderActions(this);
+    this.actions = this.actionsLayer.names;
+    this.attachmentPoints = this._attachments(data);
+    this.reset(position || new THREE.Vector3(), heading);
+  }
+
+  _attachments(data) {
+    const cfg = this.cfg, J = cfg.J;
+    const at = (bone, p) => {
+      const i = data.bones.findIndex((b) => b.name === bone);
+      if (i < 0) return null;
+      const inv = this.sk.inverses ? this.sk.inverses[i] : this.sk.bind[i].clone().invert();
+      return { bone, local: new THREE.Matrix4().makeTranslation(p.x, p.y, p.z).premultiply(inv) };
+    };
+    const mouth = cfg.mouth.clone().add(cfg.root);
+    let headP = J.ceph.clone().lerp(J.front, 0.6);
+    if (data.eyes?.length) { headP = new THREE.Vector3(); for (const e of data.eyes) headP.add(new THREE.Vector3(...e.c)); headP.multiplyScalar(1 / data.eyes.length); }
+    this._eyeLocal = headP.clone().sub(cfg.root);
+    const back = cfg.abdC.clone().add(cfg.root); back.y += cfg.abdR * 0.9;
+    const out = { mouth: at('head', mouth), head: at('head', headP), back: at('abdomen', back) };
+    for (const k of Object.keys(out)) if (!out[k]) delete out[k];
+    return out;
+  }
+
+  // ----------------------------------------------------------------- frames
+  forward(h, out) { return out.set(Math.sin(h), 0, Math.cos(h)); }
+  left(h, out) { return out.set(Math.cos(h), 0, -Math.sin(h)); }
+  terrainH(x, z) { const h = this.ground(x, z); return Number.isFinite(h) ? h : 0; }
+  localToWorld(x, y, z, out) { return out.set(x, y, z).applyQuaternion(this.qB).add(this.root); }
+  // heading frame (no pitch / roll) about the ground point p
+  headingToWorld(lx, lz, h, px, pz, out) {
+    const sh = Math.sin(h), ch = Math.cos(h);
+    return out.set(px + ch * lx + sh * lz, 0, pz - sh * lx + ch * lz);
+  }
+
+  reset(p, heading = this.heading) {
+    this.pos.set(p.x, this.terrainH(p.x, p.z), p.z);
+    this.heading = heading; this.input.heading = heading; this.wantHeading = heading;
+    this.speed = 0; this.yawRate = 0; this.velocity.set(0, 0, 0); this.lastVel.set(0, 0, 0);
+    this.gaitAt(0);
+    for (const leg of this.legs) {
+      this.neutral(leg, 0, 0, 0, leg.plant);
+      leg.state = 'stance'; leg.stanceTime = 1;
+    }
+    this.hS.reset(this.cfg.rootH); this.pitchS.reset(0); this.rollS.reset(0);
+    this._fitTerrain();
+    this.hS.reset(this._fit.h + this.cfg.rootH * this.cfg.stance.height);
+    this.pitchS.reset(this._fit.pitch); this.rollS.reset(this._fit.roll);
+  }
+
+  // ----------------------------------------------------------------- gait table
+  gaitAt(vn) {
+    const T = this.cfg.gaits, g = this.gait;
+    let i = 0;
+    while (i < T.length - 2 && vn > T[i + 1].v) i++;
+    const a = T[i], b = T[Math.min(i + 1, T.length - 1)];
+    const t = a === b ? 0 : smooth(0, 1, (vn - a.v) / (b.v - a.v));
+    g.name = t < 0.5 ? a.name : b.name;
+    g.f = lerp(a.f, b.f, t); g.D = lerp(a.D, b.D, t);
+    g.lift = lerp(a.lift, b.lift, t); g.bob = lerp(a.bob, b.bob, t); g.sway = lerp(a.sway, b.sway, t);
+    for (let j = 0; j < 8; j++) g.off[j] = wrap01(a.off[j] + d01(a.off[j], b.off[j]) * t);
+    if (vn > b.v) g.f = b.f * Math.min(1.3, vn / Math.max(b.v, 1e-6));
+    const cfg = this.cfg;
+    g.f /= cfg.sq;
+    g.lift *= cfg.s; g.bob *= cfg.s;
+    return g;
+  }
+
+  // neutral claw position (world, on the terrain + tip height) tAhead seconds from now, plus a lead
+  // along the velocity (half a stance sweep) and the yaw of the turn
+  neutral(leg, tAhead, lead, yawLead, out) {
+    const L = leg.def, P = this.P;
+    const hp = this.heading + clamp(this.yawRate * tAhead + yawLead, -0.45, 0.45);
+    const bx = this.pos.x + this.velocity.x * tAhead, bz = this.pos.z + this.velocity.z * tAhead;
+    const k = 1 - 0.22 * P.legIn * (L.i === 1 || L.i === 4 ? 1.2 : 1);
+    this.headingToWorld(L.neutral.x * k, L.neutral.z * k, hp, bx, bz, out);
+    if (lead) { const vl = Math.hypot(this.velocity.x, this.velocity.z); if (vl > 1e-6) { out.x += (this.velocity.x / vl) * lead; out.z += (this.velocity.z / vl) * lead; } }
+    out.y = this.terrainH(out.x, out.z) + L.tipY;
+    return out;
+  }
+
+  // ----------------------------------------------------------------- public API
+  play(name, opts) { return this.actionsLayer.play(name, opts || {}); }
+  stop(name) { this.actionsLayer.stop(name); }
+  setLod(level) { this.lod = clamp(level | 0, 0, 2); return this; }
+  dispose() { this.actionsLayer.clear(); }
+
+  update(dt) {
+    if (!(dt > 1e-4) || !Number.isFinite(dt)) dt = 1e-4;
+    this.frame++;
+    // LOD 2 (crowds): the whole rig runs at half rate (a spider in a crowd is a few pixels tall)
+    if (this.lod === 2 && !this.input.follow) {
+      this._lodDt = (this._lodDt || 0) + dt;
+      if ((this.frame & 1) === 1 && this._lodDt < 1 / 24) return;
+      dt = this._lodDt; this._lodDt = 0;
+    }
+    dt = Math.min(dt, 1 / 20);
+    this.drive(dt);
+    this.actionsLayer.update(dt);
+    const sub = dt > 1 / 70 && this.lod === 0 ? 2 : 1;
+    for (let i = 0; i < sub; i++) this.step(dt / sub);
+    this.pose(dt);
+    this.publish();
+  }
+
+  // steering input -> wanted speed / heading
+  drive(dt) {
+    const inp = this.input, cfg = this.cfg;
+    this.wantSpeed = clamp(inp.speed || 0, 0, cfg.maxSpeed);
+    this.wantHeading = inp.heading ?? this.heading;
+    if (inp.target && !inp.follow) {
+      const dx = inp.target.x - this.pos.x, dz = inp.target.z - this.pos.z;
+      const d = Math.hypot(dx, dz);
+      const stopR = 0.4 * cfg.bodyLen + 0.05 * this.speed;
+      if (d < stopR) { inp.target = null; inp.speed = 0; this.wantSpeed = 0; this.emit('arrive', {}); }
+      else {
+        const want = Math.atan2(dx, dz);
+        inp.heading = want; this.wantHeading = want;
+        const ang = Math.abs(angDiff(this.heading, want));
+        const brake = Math.sqrt(Math.max(0, 2 * cfg.decel * 0.7 * (d - stopR)));
+        this.wantSpeed = Math.min(inp.targetSpeed || cfg.gears.run, cfg.maxSpeed, brake + 0.01 * cfg.sq, ang > 1.0 ? cfg.gears.walk || 0.05 : 1e9);
+      }
+    }
+    if (this.actionsLayer.holdsStill()) {
+      if (this.wantSpeed > 0.02 * cfg.maxSpeed && !inp.follow) this.actionsLayer.requestStand();
+      this.wantSpeed = 0; this.wantHeading = this.heading; this._turnTo = undefined;
+    } else if (!inp.follow && this.wantSpeed < 0.02 * cfg.maxSpeed) {
+      // turn on the spot toward a look target outside the body's twist range (or an attack target)
+      const lt = inp.look;
+      if (lt) {
+        const want = Math.atan2(lt.x - this.pos.x, lt.z - this.pos.z);
+        const off = angDiff(this.heading, want);
+        if (Math.abs(off) > cfg.look.yaw * 1.1) this._turnTo = want;
+        else if (this._turnTo !== undefined && Math.abs(angDiff(this.heading, this._turnTo)) < 0.15) this._turnTo = undefined;
+      } else if (this._turnTo !== undefined && Math.abs(angDiff(this.heading, this._turnTo)) < 0.08) this._turnTo = undefined;
+      if (this._turnTo !== undefined) { this.wantHeading = this._turnTo; inp.heading = this._turnTo; }
+    }
+  }
+
+  // ----------------------------------------------------------------- simulation step
+  step(dt) {
+    this.time += dt;
+    this.landT = (this.landT ?? 9) + dt;
+    const cfg = this.cfg, inp = this.input, P = this.P, air = this.air;
+    const F = this.forward(this.heading, tv());
+    if (inp.follow && !air.active) {
+      const fv = inp.follow.velocity;
+      const vx = fv ? fv.x : 0, vz = fv ? fv.z : 0;
+      const sp = Math.hypot(vx, vz);
+      this.speed = Math.max(0, this.speedS.step(sp, 12, dt));
+      let hT = inp.follow.heading;
+      if (hT === null || hT === undefined) hT = sp > 0.1 * cfg.maxSpeed ? Math.atan2(vx, vz) : this.heading;
+      const wMax = cfg.turnRate * 1.5;
+      const wT = clamp(angDiff(this.heading, hT) * 6, -wMax, wMax);
+      this.yawRate += clamp(wT - this.yawRate, -40 * dt, 40 * dt);
+      this.heading += this.yawRate * dt;
+      this.pos.x = inp.follow.position.x; this.pos.z = inp.follow.position.z;
+      this.velocity.set(vx, 0, vz);
+    } else {
+      let vT = this.wantSpeed * P.speedScale * P.gaitW;
+      if (air.active) vT = this.speed;
+      const acc = vT > this.speed ? cfg.accel : this.landT < COAST ? 0 : this.landT < 0.2 ? Math.max(cfg.decel, this.landV / 0.1) : cfg.decel;
+      this.speed += clamp(vT - this.speed, -acc * dt, acc * dt);
+      if (air.active) this.speed = lerp(air.v0, air.vh, Math.min(1, air.t / PUSH));
+      const vn = this.speed / cfg.maxSpeed;
+      const wMax = air.active ? 0 : Math.min(cfg.turnRate * lerp(0.7, 1, smooth(0, 0.5, vn)), cfg.latAccelMax / Math.max(this.speed, 1e-3)) * (P.gaitW > 0.5 ? 1 : 0);
+      const wT = clamp(angDiff(this.heading, this.wantHeading) * 5, -wMax, wMax);
+      this.yawRate += clamp(wT - this.yawRate, -30 * dt, 30 * dt);
+      this.heading += this.yawRate * dt;
+      this.forward(this.heading, F);
+      this.velocity.copy(air.active ? air.dir : F).multiplyScalar(this.speed);
+      if (this.push.lengthSq() > 1e-12 || this.pushV.lengthSq() > 1e-12) {
+        // a shove: the velocity it adds rises over a few frames and decays (no velocity step)
+        this.pushV.lerp(this.push, 1 - Math.exp(-dt / 0.05));
+        this.velocity.add(this.pushV);
+        this.push.multiplyScalar(Math.exp(-dt * 7));
+        if (this.push.lengthSq() < 1e-10) this.push.set(0, 0, 0);
+        if (this.pushV.lengthSq() < 1e-10 && this.push.lengthSq() === 0) this.pushV.set(0, 0, 0);
+      }
+      this.pos.x += this.velocity.x * dt; this.pos.z += this.velocity.z * dt;
+    }
+    if (this.heading > Math.PI * 64 || this.heading < -Math.PI * 64) this.heading = angDiff(0, this.heading);
+    this.pos.y = this.terrainH(this.pos.x, this.pos.z);
+    this.accelV.copy(this.velocity).sub(this.lastVel).divideScalar(dt);
+    this.lastVel.copy(this.velocity);
+
+    // jump flight
+    if (air.active) {
+      air.t += dt;
+      // push-off: the legs extend over PUSH seconds (body accelerating, claws still planted), then
+      // the flight is ballistic
+      // (the vertical acceleration never flips sign from one frame to the next: push, a coast
+      // frame, free fall, and at touchdown another coast frame before the legs brake the fall)
+      const t = air.t, Tp = PUSH, Tc = PUSH + COAST;
+      if (t < Tp) this.airY = air.y0 + (air.vy * t * t) / (2 * Tp);
+      else if (t < Tc) this.airY = air.y0 + air.vy * Tp * 0.5 + air.vy * (t - Tp);
+      else { const u = t - Tc; this.airY = air.y0 + air.vy * (Tp * 0.5 + COAST) + air.vy * u - 0.5 * G_ACC * u * u; }
+      if (!air.legsOff && t >= Tp * 0.0) {
+        air.legsOff = true;
+        for (const leg of this.legs) if (leg.state === 'stance') { leg.carry0 = 0; leg.state = 'air'; this.fkTip(leg, leg.rawAz, leg.rawEl, leg.airFrom); leg.airRoot.copy(this.root); leg.airT = 0; leg.liftAz.set(leg.rawAz); leg.liftEl.set(leg.rawEl); }
+      }
+      // the legs reach the ground well before the body comes down: it is braked on them
+      const yLand = this.pos.y + air.h0 + 4.2 * cfg.rootH;
+      if (air.t > PUSH + COAST + 0.02 && air.vy - G_ACC * (air.t - PUSH - COAST) < 0 && this.airY <= yLand) this.touchDown();
+    }
+
+    // gait
+    const vPlanar = Math.hypot(this.velocity.x, this.velocity.z);
+    const vEff = Math.max(vPlanar, Math.abs(this.yawRate) * cfg.turnR * 0.8);
+    const g = this.gaitAt(vEff / cfg.sq);
+    const moving = vEff > 0.012 * cfg.maxSpeed && P.gaitW > 0.5 && !air.active;
+    if (moving) this.phase = wrap01(this.phase + g.f * dt);
+    const st = this.state.stats;
+    st.gait = moving ? g.name : 'stand'; st.freq = moving ? g.f : 0; st.duty = g.D;
+    this._moving = moving;
+    let swinging = 0, swingSet = -1;
+    for (const leg of this.legs) if (leg.state === 'swing') { swinging++; swingSet = leg.def.set; }
+    const tStance = g.D / g.f;
+    for (let li = 0; li < 8; li++) {
+      const leg = this.legs[li], L = leg.def;
+      const p = wrap01(this.phase - g.off[li]);
+      if (p < leg.prevPhase - 0.5) leg.windowUsed = false;
+      if (air.active) {
+        leg.prevPhase = p;
+        continue;
+      }
+      if (leg.state === 'stance') {
+        leg.stanceTime += dt;
+        if (moving) {
+          // lift-off: at the end of the stance window, or early if the claw trails too far
+          const nb = this.neutral(leg, 0, 0, 0, tv());
+          const fx = leg.plant.x - nb.x, fz = leg.plant.z - nb.z;
+          const trail = -(fx * this.velocity.x + fz * this.velocity.z) / Math.max(vPlanar, 1e-6);
+          const off = Math.hypot(fx, fz);
+          const rr = this.coxaDist(leg, leg.plant);
+          const caz = Math.abs(this.coxaAz(leg, leg.plant));
+          // early lift-off when the claw drifts out of comfortable range (after a minimum stance), at
+          // once when it is about to leave the reachable workspace
+          const soft = (vPlanar > 1e-4 && trail > 0.32 * L.total) || off > 0.42 * L.total || rr < L.rMin * 0.92 || rr > L.rMax || caz > L.azMax * 1.15;
+          const hard = rr < L.rMin * 0.8 || rr > L.rMax * 1.06 || caz > L.azMax * 1.4;
+          const drag = (leg.reachErr || 0) > 0.004 * L.total; // the claw can no longer be held: step at once
+          // (while shoved, early lifts are capped at four legs so it scrambles on a tetrapod)
+          // (just after a landing the claws are wherever they came down: they re-step one tetrapod at a
+          // time instead of all together)
+          const settle = this.landT < 0.8 && !((swinging === 0 || swingSet === L.set) && swinging < 4);
+          const over = drag || hard || (!settle && soft && leg.stanceTime > 0.4 * tStance && (swinging < 4 || this.pushV.lengthSq() < 1e-8));
+          if (((p >= g.D && leg.stanceTime > 0.3 * tStance) || over) && !leg.windowUsed) {
+            leg.windowUsed = true;
+            const remain = Math.max((1 - p) / g.f, 0.45 * (1 - g.D) / g.f);
+            this.startSwing(leg, remain, g.lift, 'gait');
+            swinging++; swingSet = L.set;
+          }
+        } else if (P.gaitW > 0.5 || P.dead < 0.5) {
+          // standing: re-step feet that are far from their neutral foothold, one tetrapod at a time
+          const nb = this.neutral(leg, 0, 0, 0, tv());
+          const err = Math.hypot(nb.x - leg.plant.x, nb.z - leg.plant.z);
+          const thr = (P.gaitW > 0.5 ? 0.075 : 0.05) * L.total;
+          if (err > thr && leg.stanceTime > 0.12 && this.wantSpeed < 0.02 * cfg.maxSpeed && P.curl < 0.05 && P.dead < 0.02 && P.drawIn < 0.02 && P.raise[li] + P.hold[li] < 0.05 && (swinging === 0 || swingSet === L.set) && swinging < 4) {
+            this.startSwing(leg, (0.12 + 0.5 * err / L.total) * cfg.sq, 0.06 * L.total * (P.gaitW > 0.5 ? 1 : 0.6), 'step');
+            swinging++; swingSet = L.set;
+          }
+        }
+      } else if (leg.state === 'swing') {
+        leg.swingT += dt / leg.swingDur;
+        const remain = Math.max(0, (1 - leg.swingT) * leg.swingDur);
+        if (leg.mode === 'gait' || leg.mode === 'step') {
+          const half = moving ? Math.min(vPlanar * tStance * 0.5, 0.3 * L.total) : 0;
+          const yawLead = moving ? this.yawRate * tStance * 0.5 : 0;
+          // the landing spot is predicted once, at lift-off (a swing lasts a few frames; a target that
+          // moved under a fast claw would make it jerk); the next step corrects any change of course
+          if (!leg.targetSet) {
+            leg.targetSet = true;
+            this.neutral(leg, remain, half, yawLead, leg.landBase);
+          }
+        }
+        // the landing spot stays inside the workspace of where the body will actually be (the clamp
+        // moves continuously with the body, so the claw is never yanked)
+        if (leg.mode !== 'land') {
+          leg.land.copy(leg.landBase);
+          this.clampWorkspace(leg, leg.land, remain);
+          this._swingClear(leg);
+        }
+        if (leg.swingT >= 1) {
+          leg.state = 'stance'; leg.windowUsed = leg.mode === 'gait' ? leg.windowUsed : false;
+          leg.plant.copy(leg.land); leg.stanceTime = 0;
+          if (leg.mode === 'gait') leg.windowUsed = false;
+          if (leg.mode === 'gait' && P.gaitW > 0.5) this.emit('footstep', { foot: L.key, position: leg.plant.clone(), speed: this.speed, strength: clamp(0.15 + this.speed / cfg.maxSpeed * 0.5, 0, 1) });
+        }
+      }
+      leg.prevPhase = p;
+    }
+  }
+
+  // horizontal distance of a world point from the leg's coxa base (current body, heading frame)
+  coxaDist(leg, w) {
+    const L = leg.def, h = this.heading, sh = Math.sin(h), ch = Math.cos(h);
+    const dx = w.x - this.pos.x, dz = w.z - this.pos.z;
+    const lx = dx * ch - dz * sh, lz = dx * sh + dz * ch;
+    return Math.hypot(lx - L.P0[0].x, lz - L.P0[0].z);
+  }
+  // azimuth of a world point about the coxa base relative to the leg's neutral direction
+  coxaAz(leg, w) {
+    const L = leg.def, h = this.heading, sh = Math.sin(h), ch = Math.cos(h);
+    const dx = w.x - this.pos.x, dz = w.z - this.pos.z;
+    const lx = dx * ch - dz * sh - L.P0[0].x, lz = dx * sh + dz * ch - L.P0[0].z;
+    return angDiff(L.azN, Math.atan2(lx * L.side, lz));
+  }
+  // keep a landing target inside the leg's workspace (radially about the coxa base)
+  clampWorkspace(leg, w, tAhead = 0) {
+    // relative to where the body will be at touchdown
+    const L = leg.def, h = this.heading + clamp(this.yawRate * tAhead, -0.45, 0.45), sh = Math.sin(h), ch = Math.cos(h);
+    const px = this.pos.x + this.velocity.x * tAhead, pz = this.pos.z + this.velocity.z * tAhead;
+    const dx = w.x - px, dz = w.z - pz;
+    let lx = dx * ch - dz * sh - L.P0[0].x, lz = dx * sh + dz * ch - L.P0[0].z;
+    const r = Math.hypot(lx, lz) || 1e-9;
+    const rc = clamp(r, L.rMin * 1.04, L.rMax * 0.96);
+    // and within +-L.azMax of the neutral direction
+    const a = Math.atan2(lx * L.side, lz), da = angDiff(L.azN, a);
+    const ac = L.azN + clamp(da, -L.azMax, L.azMax);
+    if (rc === r && ac === L.azN + da) return w;
+    lx = Math.sin(ac) * rc * L.side + L.P0[0].x; lz = Math.cos(ac) * rc + L.P0[0].z;
+    w.x = px + ch * lx + sh * lz; w.z = pz - sh * lx + ch * lz;
+    w.y = this.terrainH(w.x, w.z) + L.tipY;
+    return w;
+  }
+
+  // swing clearance: sample the terrain along the path so the claw steps over bumps
+  _swingClear(leg) {
+    let m = -1e9;
+    for (let k = 1; k <= 3; k++) {
+      const u = k / 4;
+      const x = lerp(leg.lift.x, leg.land.x, u), z = lerp(leg.lift.z, leg.land.z, u);
+      const base = lerp(leg.lift.y, leg.land.y, u);
+      m = Math.max(m, this.terrainH(x, z) + leg.def.tipY - base);
+    }
+    leg.hMax = Math.max(0, m);
+  }
+
+  startSwing(leg, dur, lift, mode) {
+    leg.lift.copy(leg.plant);
+    leg.land.copy(leg.plant); leg.landBase.copy(leg.plant);
+    leg.state = 'swing'; leg.mode = mode;
+    leg.swingT = 0; leg.swingDur = Math.max(0.05, dur);
+    leg.liftH = lift;
+    leg.swingInit = true;
+    leg.targetSet = mode === 'twitch';
+    this._swingClear(leg);
+  }
+
+  // an idle twitch: lift the claw a little and set it down again (almost) in place
+  twitchLeg(i) {
+    const leg = this.legs[i];
+    if (leg.state !== 'stance' || this._moving || this.P.gaitW < 0.5) return;
+    this.startSwing(leg, 0.22 * this.cfg.sq, 0.05 * leg.def.total, 'twitch');
+    const nb = this.neutral(leg, 0, 0, 0, tv());
+    leg.land.lerp(nb, 0.5); leg.land.y = this.terrainH(leg.land.x, leg.land.z) + leg.def.tipY;
+    leg.landBase.copy(leg.land);
+    this._swingClear(leg);
+  }
+
+  takeOff(vy, vh) {
+    const a = this.air, cfg = this.cfg;
+    a.active = true; a.t = 0; a.vy = vy; a.vh = vh; a.v0 = this.speed;
+    this.forward(this.heading, a.dir);
+    a.y0 = this.root.y;
+    a.h0 = this.root.y - this.pos.y;
+    a.T = (2 * vy) / G_ACC;
+    this.airY = a.y0;
+    a.legsOff = false;
+    // legs already in the air (mid-swing) follow the body at once; planted ones push off first
+    for (const leg of this.legs) if (leg.state !== 'stance' || leg.def.i <= 2) { leg.carry0 = leg.state === 'stance' ? 0 : 1; leg.state = 'air'; this.fkTip(leg, leg.rawAz, leg.rawEl, leg.airFrom); leg.airRoot.copy(this.root); leg.airT = 0; leg.liftAz.set(leg.rawAz); leg.liftEl.set(leg.rawEl); }
+    this.state.grounded = false;
+    this.emit('takeoff', {});
+    void cfg;
+  }
+  touchDown() {
+    const a = this.air;
+    if (!a.active) return;
+    a.active = false;
+    this.state.grounded = true;
+    // every claw comes down near its neutral foothold, the legs reaching out from the tuck
+    // (clamped into the workspace around where the body stops: a coast frame, then the brake)
+    const tStop = COAST + Math.min(this.speed / (2 * this.cfg.decel), 0.05);
+    for (const leg of this.legs) {
+      // (the legs reach out to spread footholds as they land: a landing on legs tucked under the
+      // body would leave it standing on stilts)
+      const nb = this.neutral(leg, tStop, 0, 0, tv());
+      leg.plant.set(lerp(leg.tip.x, nb.x, 0.85), 0, lerp(leg.tip.z, nb.z, 0.85));
+      leg.plant.y = this.terrainH(leg.plant.x, leg.plant.z) + leg.def.tipY;
+      this.clampWorkspace(leg, leg.plant, tStop);
+      leg.lift.copy(leg.tip);
+      leg.land.copy(leg.plant);
+      leg.state = 'swing'; leg.mode = 'land'; leg.swingInit = true; leg.swingT = 0; leg.swingDur = 0.13 * this.cfg.sq; leg.liftH = 0; leg.hMax = 0;
+    }
+    this.landV = this.speed;
+    // the body keeps its falling speed into the landing spring (legs absorb the impact)
+    this.hS.x = this.airY; this.hS.v = Math.min(0, a.vy - G_ACC * Math.max(0, a.t - PUSH - COAST));
+    {
+      const v = -this.hS.v, rest = this.pos.y + this.cfg.rootH * 0.78, d = Math.max(1e-4, this.airY - v * COAST - rest);
+      this.brakeA = (v * v) / (2 * d);
+      this.landFrames = 0;
+    }
+    this.actionsLayer.onLand();
+    this.landT = 0;
+    this.emit('land', {});
+  }
+
+  _fitTerrain() {
+    const cfg = this.cfg, W = cfg.fitW, h = this.heading;
+    let a = 0, b = 0, c = 0;
+    const tmp = tv();
+    for (let i = 0; i < 8; i++) {
+      const L = cfg.legs[i];
+      this.headingToWorld(L.neutral.x, L.neutral.z, h, this.pos.x, this.pos.z, tmp);
+      const y = this.terrainH(tmp.x, tmp.z);
+      a += W[0][i] * y; b += W[1][i] * y; c += W[2][i] * y;
+    }
+    this._fit = this._fit || { h: 0, pitch: 0, roll: 0 };
+    this._fit.h = a; this._fit.pitch = Math.atan(c) * 0.85; this._fit.roll = Math.atan(b) * 0.85;
+    return this._fit;
+  }
+
+  // ----------------------------------------------------------------- pose
+  pose(dt) {
+    const cfg = this.cfg, P = this.P, g = this.gait, t = this.time, air = this.air;
+    const fit = this._fitTerrain();
+    const vn = this.speed / cfg.maxSpeed;
+    // look: body twist and rearing toward the look target
+    const look = this.input.look || P.look;
+    let lyT = 0, lpT = 0;
+    if (look && P.lookW > 0.01 && P.dead < 0.5) {
+      const dx = look.x - this.pos.x, dz = look.z - this.pos.z;
+      const rel = angDiff(this.heading, Math.atan2(dx, dz));
+      lyT = clamp(rel, -cfg.look.yaw, cfg.look.yaw) * P.lookW * (1 - smooth(0.2, 0.6, vn) * 0.8);
+      const dy = look.y - (this.pos.y + cfg.rootH * 1.5);
+      lpT = clamp(Math.atan2(dy, Math.hypot(dx, dz) + 1e-6), 0, cfg.look.pitch) * P.lookW * (1 - smooth(0.1, 0.4, vn));
+      this.lookTarget.copy(look); this.state.lookTarget = this.lookTarget;
+    } else this.state.lookTarget = null;
+    const lookYaw = this.lookYawS.step(lyT, 7, dt), lookPitch = this.lookPitchS.step(lpT, 6, dt);
+    // raise the front legs a little when rearing to look up
+    if (lookPitch > 0.01) for (let i = 0; i < 8; i++) if (this.legs[i].def.i === 1) P.raise[i] = Math.max(P.raise[i], 0.8 * lookPitch / cfg.look.pitch);
+    // body height, pitch and roll from the terrain plane, the posture and the gait
+    const moving = this._moving ? smooth(0, 0.15, vn) : 0;
+    const bob = g.bob * moving * Math.cos(TAU * 2 * this.phase);
+    const sway = g.sway * moving * Math.sin(TAU * this.phase);
+    const dropK = 1 - 0.55 * P.crouch;
+    const hT = fit.h + cfg.rootH * cfg.stance.height * dropK - P.drop + bob;
+    // a stiffer spring for a moment after landing (the legs absorb the fall)
+    let h;
+    if (this.brakeA > 0 && this.hS.v < 0) {
+      // landing: a coast frame, then constant braking on the legs down to the stance height
+      // frame 0: the landing height itself; frame 1: coasting; then braking
+      const lf = this.landFrames++;
+      if (lf >= 2) this.hS.v = Math.min(0, this.hS.v + this.brakeA * dt);
+      if (lf >= 1) this.hS.x += this.hS.v * dt;
+      h = this.hS.x;
+    } else { this.brakeA = 0; h = this.hS.step(hT, 18, dt); }
+    if (air.active) { h = this.airY; this.hS.x = h; this.hS.v = 0; }
+    const pitch = this.pitchS.step(fit.pitch * (1 - P.dead) + P.pitch + lookPitch, 14, dt);
+    const roll = this.rollS.step(fit.roll * (1 - P.dead), 14, dt);
+    // body rotation: heading (+ look twist + sway), pitch (nose up), roll, then the death flip about
+    // the long axis
+    this._e.set(-pitch, this.heading + lookYaw + sway + P.yaw, roll + P.roll, 'YXZ');
+    this.qB.setFromEuler(this._e);
+    if (P.flip > 1e-4) this.qB.multiply(this._q.setFromAxisAngle(Z_AXIS, P.flip * P.flipAngle * P.flipSide));
+    // lunge / side offsets in the heading frame
+    const F = this.forward(this.heading, tv()), Lf = this.left(this.heading, tv());
+    this.root.set(this.pos.x, h, this.pos.z).addScaledVector(F, P.fwd).addScaledVector(Lf, P.side);
+    this.qBinv.copy(this.qB).invert();
+    this.upB.set(0, 1, 0).applyQuaternion(this.qBinv); // world up in the body frame
+
+    // abdomen: hangs from the pedicel on a spring; lags in accelerations and turns; rests on the
+    // ground in low postures; breathes
+    const aLocal = this._v.copy(this.accelV).applyQuaternion(this.qBinv);
+    const A = cfg.abd;
+    const pT = -A.droop * (1 - moving) + P.abdPitch - clamp(aLocal.z * A.lag * 0.02, -0.2, 0.2) + clamp(aLocal.y * 0.002, -0.1, 0.1);
+    const yT = clamp(-aLocal.x * A.lag * 0.02, -0.25, 0.25) - this.yawRate * 0.04 * A.lag * 10;
+    let ap = this.abdPitchS.step(pT, A.stiffness, dt);
+    const ay = this.abdYawS.step(clamp(yT, -0.3, 0.3), A.stiffness * 0.8, dt);
+    const tmp = tv();
+    const pb = cfg.ax.pedB, lo = cfg.abdLow;
+    const abdLowAt = (a) => {
+      // world position of the abdomen's lowest bind point for abdomen pitch a (no yaw)
+      const c = Math.cos(a), sn = Math.sin(a);
+      return this.localToWorld(pb.x + lo.x, pb.y + lo.y * c - lo.z * sn, pb.z + lo.y * sn + lo.z * c, tmp);
+    };
+    // (faded out continuously in death, when the body itself lies on the ground)
+    const wAl = 1 - smooth(0.25, 0.6, P.dead);
+    if (wAl > 0) {
+      // keep the abdomen off the ground (or rest it on the ground in low postures)
+      const ap0 = ap;
+      abdLowAt(ap);
+      const gap = tmp.y - this.terrainH(tmp.x, tmp.z) - 0.00025 * cfg.s;
+      const L = Math.hypot(lo.y, lo.z);
+      if (P.abdDown > 0.01 && gap > 0) ap -= P.abdDown * clamp(gap / L, 0, 0.35);
+      if (gap < 0) ap += Math.min(0.6, (-gap / L) * 1.1);
+      // every other extreme point too (rearing, the rear end is the lowest)
+      const c = Math.cos(ap), sn = Math.sin(ap);
+      let fix = 0;
+      for (const p of cfg.supAbd) {
+        if (p === lo || p.z > 0) continue;
+        this.localToWorld(pb.x + p.x, pb.y + p.y * c - p.z * sn, pb.z + p.y * sn + p.z * c, tmp);
+        const g = tmp.y - this.terrainH(tmp.x, tmp.z) - 0.00025 * cfg.s;
+        if (g < 0) fix = Math.max(fix, Math.min(0.6, (-g / Math.max(1e-6, Math.hypot(p.y, p.z))) * 1.1));
+      }
+      ap += fix;
+      ap = ap0 + (ap - ap0) * wAl;
+    }
+    this._e.set(ap, ay, 0, 'YXZ');
+    this.qAbd.setFromEuler(this._e);
+    this.qPed.identity().slerp(this.qAbd, 0.5);
+    // body support: nothing of the body goes into the ground (bumps under the sternum or abdomen,
+    // a dead spider lying on its back or side); a spring keeps it continuous
+    let lift = 0;
+    for (const p of cfg.supPro) {
+      this.localToWorld(p.x, p.y, p.z, tmp);
+      const pen = this.terrainH(tmp.x, tmp.z) + 0.0001 * cfg.s - tmp.y;
+      if (pen > lift) lift = pen;
+    }
+    {
+      const qa = this._q2.copy(this.qB).multiply(this.qAbd);
+      const ped = this._w.subVectors(pb, cfg.ax.pedA).applyQuaternion(this._q.copy(this.qB).multiply(this.qPed));
+      const pA = this.localToWorld(cfg.ax.pedA.x, cfg.ax.pedA.y, cfg.ax.pedA.z, tv()).add(ped);
+      for (const p of cfg.supAbd) {
+        tmp.copy(p).applyQuaternion(qa).add(pA);
+        const pen = this.terrainH(tmp.x, tmp.z) + 0.0001 * cfg.s - tmp.y;
+        if (pen > lift) lift = pen;
+      }
+    }
+    // the leg roots (trochanters, femur bases) are as rigid with the body as the carapace: a deep crouch
+    // or a steep rear must not push them into the ground either
+    for (const leg of this.legs) for (let k = 1; k <= 2; k++) {
+      const q = leg.jp[k];
+      const pen = this.terrainH(q.x, q.z) + 2.2 * leg.def.tipY - (q.y - this._lift);
+      if (pen > lift) lift = pen;
+    }
+    const wLeg = P.dead * Math.max(smooth(0, 0.08, P.flip), P.curl2); // dying, it rests on its curling legs
+    if (wLeg > 1e-3) {
+      // rolling over, a dead spider rests on its curled legs as well (folded tight before it rolls);
+      // the joints were placed last frame including last frame's lift, so compare without it
+      lift = Math.max(lift, this._legSupport(wLeg, this._lift));
+    }
+    const sup = this.supportS.step(lift, 30, dt);
+    // smooth maximum of the spring and the raw depth (never far below the ground, no kinks)
+    this._lift = -smin(-sup, -lift, 0.0003 * cfg.s);
+    this.root.y += this._lift;
+    this.breath += dt * TAU * cfg.breath.rate * P.breathRate;
+    const br = Math.sin(this.breath) * cfg.breath.amp * P.breathAmp;
+
+    this.writeAxial(br);
+    this.solveLegs(dt);
+    if (wLeg > 1e-3) {
+      // the legs of a dying spider move fast (curling, rolling over): the support above used last
+      // frame's joints, so check this frame's too and lift the whole body clear if any went under
+      const extra = this._legSupport(wLeg, 0);
+      if (extra > 1e-6) {
+        this.root.y += extra; this._lift += extra;
+        this.writeAxial(br);
+        this.solveLegs(0);
+      }
+    }
+    this.solvePalps(dt);
+    this.solveChelicerae(dt);
+    // head pose
+    const hb = this.sk.bones[cfg.bone.head];
+    if (hb) {
+      this.localToWorld(this._eyeLocal.x, this._eyeLocal.y, this._eyeLocal.z, this.headPose.position);
+      this.headPose.quaternion.copy(this.qB);
+    }
+  }
+
+  // how far the body must rise so no leg joint is in the ground (joints nearer the knee carry a wider
+  // margin: the knuckles are thick): a soft maximum over the joints, so the support does not jerk as
+  // the lowest joint changes from one leg to another while it rolls
+  _legSupport(w, lifted) {
+    const k = 0.00006 * this.cfg.s;
+    let mx = -Infinity;
+    const pens = this._pens || (this._pens = new Float64Array(48));
+    let n = 0;
+    for (const leg of this.legs) for (let j = 2; j < 8; j++) {
+      const q = leg.jp[j];
+      const p = this.terrainH(q.x, q.z) + (j === 7 ? 1.6 : j === 2 ? 2.2 : 5) * leg.def.tipY - (q.y - lifted);
+      pens[n++] = p; if (p > mx) mx = p;
+    }
+    if (mx < -8 * k) return 0;
+    let sum = 0;
+    for (let i = 0; i < n; i++) sum += Math.exp((pens[i] - mx) / k);
+    // softplus of the soft maximum: 0 when every joint is clear, the depth when one is under
+    const sm = mx + k * Math.log(sum);
+    return w * (sm > 8 * k ? sm : k * Math.log1p(Math.exp(sm / k)));
+  }
+
+  setBone(i, pos, q, scale) {
+    if (i < 0) return;
+    const b = this.sk.bones[i];
+    b.matrixWorld.compose(pos, this._q3.copy(q).multiply(this.cfg.bindQ[i]), scale || ONE);
+  }
+
+  writeAxial(br) {
+    const cfg = this.cfg, ax = cfg.ax, B = cfg.bone;
+    const p = tv();
+    this.localToWorld(ax.pedA.x, ax.pedA.y, ax.pedA.z, p);
+    this.setBone(B.prosoma, p, this.qB);
+    this.localToWorld(ax.ceph.x, ax.ceph.y, ax.ceph.z, p);
+    this.setBone(B.head, p, this.qB);
+    // pedicel and abdomen hang from pedA
+    const qP = this._q2.copy(this.qB).multiply(this.qPed);
+    this.localToWorld(ax.pedA.x, ax.pedA.y, ax.pedA.z, p);
+    this.setBone(B.pedicel, p, qP);
+    const pedVec = tv().subVectors(ax.pedB, ax.pedA).applyQuaternion(qP);
+    const abdHead = tv().copy(p).add(pedVec);
+    const qA = tv(); void qA;
+    const qAw = this._q2.copy(this.qB).multiply(this.qAbd);
+    this._scale.set(1 + br, 1 + br * 0.4, 1 + br);
+    this.setBone(B.abdomen, abdHead, qAw, this._scale);
+    if (B.spinnerets >= 0) {
+      const sv = tv().subVectors(ax.abdEnd, ax.pedB).multiplyScalar(1 + br * 0.4).applyQuaternion(qAw);
+      const sp = tv().copy(abdHead).add(sv);
+      // spinnerets twitch a little
+      this._e.set(0.05 * Math.sin(this.time * 1.7) * this.P.twitch, 0.06 * Math.sin(this.time * 0.9 + 1) * this.P.twitch, 0, 'YXZ');
+      this.setBone(B.spinnerets, sp, this._q.copy(qAw).multiply(this._q3.setFromEuler(this._e)));
+    }
+  }
+
+  // ---------------------------------------------------------------- legs
+  solveLegs(dt) {
+    const P = this.P, cfg = this.cfg, air = this.air;
+    const tipL = tv();
+    for (let li = 0; li < 8; li++) {
+      const leg = this.legs[li], L = leg.def;
+      // world claw target
+      const T = tv();
+      let heel = 0;
+      if (leg.state === 'stance') {
+        this.postureTarget(leg, T.copy(leg.plant));
+        if (this._moving) heel = smooth(0.5, 1.0, leg.stanceTime * this.gait.f / Math.max(this.gait.D, 0.05));
+      } else if (leg.state === 'swing') {
+        // swing in joint space: from the lift-off angles to the angles that reach the (moving) landing
+        // target, with short speed ramps, plus a femur lift that clears the terrain on the way. Each
+        // joint then sweeps a smooth arc instead of folding and unfolding to follow a straight path.
+        const u = clamp(leg.swingT, 0, 1);
+        const s = progress(u, TUNE.ramp);
+        if (leg.swingInit) { leg.liftAz.set(leg.rawAz); leg.liftEl.set(leg.rawEl); leg.liftHeel = leg.heel; leg.swingInit = false; }
+        // the landing pose is solved in the body frame predicted for the moment of touchdown (in the
+        // current frame a claw landing ahead would look further away than it will be)
+        const rem = Math.max(0, (1 - u) * leg.swingDur);
+        const qp = this._q2.setFromAxisAngle(Y_AXIS, clamp(this.yawRate * rem, -0.45, 0.45)).multiply(this.qB).invert();
+        this.postureTarget(leg, tipL.copy(leg.land));
+        tipL.x -= this.root.x + this.velocity.x * rem; tipL.y -= this.root.y; tipL.z -= this.root.z + this.velocity.z * rem;
+        tipL.applyQuaternion(qp);
+        const az = leg.az, el = leg.el;
+        let reach = Math.max(0.3 * L.total, Math.hypot(tipL.x - L.P0[2].x, tipL.z - L.P0[2].z));
+        if (TUNE.path === 'polar') {
+          // claw path in polar coordinates about the coxa base (radius and azimuth interpolate, so a
+          // radial leg neither overshoots nor cuts across), height with the clearance hump
+          const B = L.P0[0], sd = L.side;
+          const lL = tv().copy(leg.lift).sub(this.root).applyQuaternion(this.qBinv);
+          const r0 = Math.hypot(lL.x - B.x, lL.z - B.z), r1 = Math.hypot(tipL.x - B.x, tipL.z - B.z);
+          const a0 = Math.atan2((lL.x - B.x) * sd, lL.z - B.z), a1 = Math.atan2((tipL.x - B.x) * sd, tipL.z - B.z);
+          const r = lerp(r0, r1, s), a = a0 + angDiff(a0, a1) * s;
+          const y = lerp(lL.y, tipL.y, s) + (leg.liftH + leg.hMax) * hump(u);
+          tipL.set(B.x + Math.sin(a) * r * sd, y, B.z + Math.cos(a) * r);
+          this.solveLeg(leg, tipL, leg.liftHeel * (1 - s) * cfg.heelLift);
+        } else {
+          this.solveLeg(leg, tipL, 0);
+          if (TUNE.debug) leg._landEl = Array.from(el);
+          for (let k = 0; k < 7; k++) { az[k] = leg.liftAz[k] + angDiff(leg.liftAz[k], az[k]) * s; el[k] = leg.liftEl[k] + angDiff(leg.liftEl[k], el[k]) * s; }
+          const b = ((leg.liftH + leg.hMax) * hump(u)) / reach;
+          el[2] += b * TUNE.bf; el[3] -= b * TUNE.bp; el[5] -= b * TUNE.bm;
+        }
+        this._unwrapIK(leg, li);
+        leg.rawAz.set(az); leg.rawEl.set(el);
+        T.lerpVectors(leg.lift, leg.land, s);
+        const wPose = this.blendLegPose(leg, li);
+        this.writeLeg(leg);
+        if (wPose > 1e-3 && (P.dead < 0.5 || P.flip < 0.3)) this.groundGuard(leg, (P.dead < 0.5 ? 1 : 1 - smooth(0.02, 0.3, P.flip)) * smooth(0, 0.05, wPose));
+        // a joint-space swing can dip toward the ground between lift-off and touchdown: lift the femur
+        // by just enough to keep the claw and the tarsus base clear (continuous in the depth)
+        {
+          // (faded in and out at the ends of the swing, where the claw is on the ground anyway)
+          const r = smooth(0, 0.05, u) * (1 - smooth(0.95, 1, u));
+          // (the tibia end first: the femur lifts it; then the claw and tarsus: the metatarsus)
+          const q5 = leg.jp[5], p5 = this.terrainH(q5.x, q5.z) + L.tipY * 2 - q5.y;
+          if (p5 > 0 && r > 0) { const de = r * Math.min(0.6, (p5 * 1.2) / (L.len[2] + L.Lpt)); el[2] += de; leg.rawEl[2] += de; this.writeLeg(leg); }
+          let pen = 0;
+          for (let k = 6; k <= 7; k++) { const q = leg.jp[k]; pen = Math.max(pen, this.terrainH(q.x, q.z) + L.tipY * (k === 7 ? 1 : 1.5) - q.y); }
+          if (pen > 0 && r > 0) { const de = r * Math.min(0.8, (pen * 1.3) / (L.len[5] * Math.max(0.3, Math.cos(el[5])))); el[5] += de; leg.rawEl[5] += de; this.writeLeg(leg); }
+        }
+        leg.ikEl.set(leg.el); leg.ikAz.set(leg.az);
+        if (this.debug.targets[li]) this.debug.targets[li].copy(T);
+        continue;
+      } else {
+        // in the air: the claw leaves the ground picking up the body's motion gradually, then settles
+        // on its place relative to the body (the action pose does the rest)
+        const nb = tv().copy(L.P0[7]).applyQuaternion(this.qB).add(this.root);
+        leg.airT = Math.min(1, leg.airT + dt / 0.25);
+        const carry = Math.min(1, leg.carry0 + leg.airT * 2.5);
+        T.copy(leg.airFrom).addScaledVector(tv().subVectors(this.root, leg.airRoot), carry);
+        T.lerp(nb, smooth(0.2, 1, leg.airT));
+      }
+      // the heel eases (a leg that has stood for a while must not snap to a lifted heel)
+      leg.heel += (heel - leg.heel) * (1 - Math.exp(-dt / 0.045));
+      heel = leg.heel;
+      // body frame
+      tipL.copy(T).sub(this.root).applyQuaternion(this.qBinv);
+      this.solveLeg(leg, tipL, heel * cfg.heelLift);
+      if (leg.state === 'air' && leg.airT < 0.6) {
+        // leaving the ground (possibly mid-swing, whose joint-space pose is not the IK one): the
+        // joints ease from their take-off angles into the solved ones
+        const w = smooth(0, 0.6, leg.airT), az = leg.az, el = leg.el;
+        for (let k = 0; k < 7; k++) { az[k] = leg.liftAz[k] + angDiff(leg.liftAz[k], az[k]) * w; el[k] = leg.liftEl[k] + (el[k] - leg.liftEl[k]) * w; }
+      }
+      this._unwrapIK(leg, li);
+      leg.rawAz.set(leg.az); leg.rawEl.set(leg.el);
+      // action poses blended in joint-angle space
+      const wPose = this.blendLegPose(leg, li);
+      this.writeLeg(leg);
+      // a planted claw the leg can no longer reach (body shoved or lunging past it) must step
+      leg.reachErr = leg.state === 'stance' && wPose < 1e-3 ? Math.hypot(leg.tip.x - T.x, leg.tip.z - T.z) : 0;
+      if (wPose > 1e-3 && (P.dead < 0.5 || P.flip < 0.3)) this.groundGuard(leg, (P.dead < 0.5 ? 1 : 1 - smooth(0.02, 0.3, P.flip)) * smooth(0, 0.05, wPose));
+      leg.ikEl.set(leg.el); leg.ikAz.set(leg.az); // the displayed angles: next frame's IK is unwrapped against them
+      if (this.debug.targets[li]) this.debug.targets[li].copy(T);
+    }
+    void air; void P;
+  }
+
+  solveLeg(leg, T, heel) {
+    const L = leg.def, az = leg.az, el = leg.el, s = L.side;
+    const B = L.P0[0];
+    // tarsus along the leg azimuth at its bind slope (steeper while the heel lifts)
+    // azimuths of points very close to the coxa are ill-defined: fall back to the neutral one
+    const rS = L.rMin;
+    const azG = (dx, dz, r0) => {
+      const a = Math.atan2(dx * s, dz), d = Math.hypot(dx, dz);
+      return L.phi0 + angDiff(L.phi0, a) * smooth(0.3 * r0, 0.75 * r0, d);
+    };
+    const phT = azG(T.x - B.x, T.z - B.z, rS);
+    // the tarsus keeps its slope relative to the ground, not the body (a planted tarsus does not roll
+    // on its pad when the body pitches or rolls)
+    const u = this.upB, tilt = Math.asin(clamp(u.x * Math.sin(phT) * s + u.z * Math.cos(phT), -1, 1));
+    const eta = L.el0[6] - heel - clamp(tilt, -0.7, 0.7) * (1 - this.P.dead);
+    const cT = Math.cos(eta);
+    const Ax = T.x - L.len[6] * Math.sin(phT) * cT * s, Ay = T.y - L.len[6] * Math.sin(eta), Az = T.z - L.len[6] * Math.cos(phT) * cT;
+    // coxa yaws part of the way, the trochanter the rest
+    const phA = azG(Ax - B.x, Az - B.z, rS);
+    const dph = angDiff(L.phi0, phA);
+    const phC = L.az0[0] + clamp(0.55 * dph, -0.6, 0.6);
+    const eC = L.el0[0];
+    let x = B.x + L.len[0] * Math.sin(phC) * Math.cos(eC) * s, y = B.y + L.len[0] * Math.sin(eC), z = B.z + L.len[0] * Math.cos(phC) * Math.cos(eC);
+    const phTr = azG(Ax - x, Az - z, rS * 0.7);
+    const eTr = L.el0[1];
+    x += L.len[1] * Math.sin(phTr) * Math.cos(eTr) * s; y += L.len[1] * Math.sin(eTr); z += L.len[1] * Math.cos(phTr) * Math.cos(eTr);
+    // vertical leg plane from the femur base to the metatarsus-tarsus joint
+    const phP = azG(Ax - x, Az - z, rS * 0.6);
+    const ux = Math.sin(phP) * s, uz = Math.cos(phP);
+    const h = (Ax - x) * ux + (Az - z) * uz, v = Ay - y;
+    const Lf = L.len[2], Lpt = L.Lpt, Lm = L.len[5];
+    const d1 = (Lf + Lpt) * 0.97;
+    // metatarsus: preferred slope, flattening as the leg stretches
+    const D = Math.hypot(h, v);
+    let em = L.el0[5] + clamp(1.1 * (D - L.D0) / L.D0, -0.6, 0.9);
+    em = Math.min(em, -0.05);
+    let mh = h - Lm * Math.cos(em), mv = v - Lm * Math.sin(em);
+    let dm = Math.hypot(mh, mv);
+    {
+      // too far for femur + patella/tibia with the preferred slope: turn the metatarsus toward the
+      // femur base (its straightest, longest reach), smoothly with the reach excess
+      const w = smooth(0.84 * d1, 1.0 * d1, dm);
+      if (w > 0) {
+        em = em + angDiff(em, Math.atan2(v, h)) * w;
+        mh = h - Lm * Math.cos(em); mv = v - Lm * Math.sin(em);
+        dm = Math.hypot(mh, mv);
+      }
+    }
+    // two-link femur + (patella, tibia), knee up, soft reach limit
+    const dr = clamp(softMin(dm, d1, 0.04 * d1), Math.abs(Lf - Lpt) * 1.02 + 1e-7, d1);
+    const al = Math.atan2(mv, mh);
+    const cb = clamp((Lf * Lf + dr * dr - Lpt * Lpt) / (2 * Lf * dr), -1, 1);
+    const ef = al + Math.acos(cb);
+    const kh = Lf * Math.cos(ef), kv = Lf * Math.sin(ef);
+    const mhr = mh * dr / Math.max(dm, 1e-9), mvr = mv * dr / Math.max(dm, 1e-9);
+    const ept = Math.atan2(mvr - kv, mhr - kh);
+    az[0] = phC; el[0] = eC;
+    az[1] = phTr; el[1] = eTr;
+    az[2] = az[3] = az[4] = az[5] = phP;
+    el[2] = ef; el[3] = ept + L.dp; el[4] = ept + L.dt; el[5] = em;
+    az[6] = phT; el[6] = eta;
+  }
+
+  // Action poses in joint-angle space. Relative bends (deg) from the femur outward:
+  //   raise (threat / grab): femur up, leg nearly straight, pointing up and forward
+  //   hold (prey, sleep tuck): femur up, knee sharply flexed, tip toward the mouth
+  //   curl (death): femur down, every joint flexed: the leg folds under the body
+  //   air (jump): front legs by raise, the hind legs trailing, all a little flexed
+  blendLegPose(leg, li) {
+    const P = this.P, L = leg.def, az = leg.az, el = leg.el;
+    // the in-air pose takes a leg only once it has left the ground (pushing legs stay planted)
+    const r = P.raise[li], hd = P.hold[li], c = P.curl, a = P.air > 0 ? P.air * (leg.state === 'stance' && this.air.active ? 0 : smooth(0, 0.35, leg.airT)) : 0;
+    if (r + hd + c + a + P.curl2 < 1e-4) return 0;
+    const front = L.i === 1 ? 1 : L.i === 2 ? 0.7 : 0;
+    if (a > 0) this.poseBlend(leg, a * (1 - front * 0.7), L.i >= 3 ? 10 : 30, L.i >= 3 ? P_AIR_H : P_AIR_F, L.i >= 3 ? 8 : -6, false);
+    if (r > 0) this.poseBlend(leg, r, 62 + 8 * front, P_RAISE, -10 * front, false);
+    if (hd > 0) this.poseBlend(leg, hd, 42, P_HOLD, -22 * front - 6, false);
+    // death: every joint flexes ventrally, distal joints first (the hydraulic collapse), and the legs
+    // gather under the sternum (over it once it lies on its back)
+    if (c > 0) this.poseBlend(leg, c, 75, P_TUCK, -10, false);
+    if (P.curl2 > 1e-4) {
+      // upright, the legs half-flex with the knees up (the dying spider sinks, legs drawn in); as the
+      // body rolls over the femurs swing ventrally and every joint flexes fully, so the corpse rests
+      // on its back or side inside the cage of its legs. Once curl2 is 1 no angle depends on the IK.
+      const cu = P.flipAngle < 2 && L.side === -P.flipSide ? L.curlSide : L.curlBack;
+      const down = L.side === -P.flipSide, roll = P.flip * P.flipAngle;
+      // (the legs it rolls onto fold ventrally first, the upper ones as they come off the ground)
+      const w = P.curl2, fl = down ? smooth(0, 0.3 * Math.PI, roll) : smooth(0.3 * Math.PI, 0.6 * Math.PI, roll), cp = L.curlUp;
+      if (P.flip > 1e-4 || (P.reviving && this._lift > 0.4 * this.cfg.rootH)) {
+        // rolled over, the claws' stance targets mean nothing: the IK is replaced by the upright
+        // curl as the base the pose blends from (the IK comes back only once it is upright)
+        const g = Math.max(smooth(0, 0.1, P.flip), P.reviving * smooth(0.4 * this.cfg.rootH, 1.2 * this.cfg.rootH, this._lift));
+        el[0] += (cp.C - el[0]) * g; el[1] += (cp.C - el[1]) * g;
+        let e0 = cp.F;
+        el[2] += (e0 - el[2]) * g;
+        for (let k = 3; k < 7; k++) { e0 += cp.B[k - 3]; el[k] += (e0 - el[k]) * g; }
+        az[0] += (L.az0[0] - az[0]) * g;
+        for (let k = 1; k < 7; k++) az[k] += (L.phi0 - az[k]) * g;
+      }
+      const cT = lerp(cp.C, cu.C, fl);
+      el[0] += (cT - el[0]) * w; el[1] += (cT - el[1]) * w;
+      el[2] += (lerp(cp.F, cu.F, fl) - el[2]) * w;
+      let e = el[2];
+      for (let k = 3; k < 7; k++) { e += lerp(cp.B[k - 3], cu.B[k - 3], fl); el[k] += (e - el[k]) * w; }
+      az[0] += (L.az0[0] - az[0]) * w;
+      for (let k = 1; k < 7; k++) az[k] += (L.phi0 - az[k]) * w;
+    }
+    return Math.min(1, r + hd + c + a + P.curl2);
+  }
+
+  // posture changes of a claw target (world): drawn in toward the coxa along the ground (a collapsing
+  // spider), lifted while the legs curl or uncurl (so the blend never sweeps through the ground),
+  // tucked under the sternum; the same for planted claws and for landing targets
+  postureTarget(leg, T) {
+    const P = this.P, L = leg.def;
+    if (P.drawIn > 1e-3) {
+      // (sleep pulls them in further than death: the living legs keep their pose)
+      const cb = tv().copy(L.P0[0]).applyQuaternion(this.qB).add(this.root);
+      const k = 0.3 * P.drawIn + 0.2 * P.pullIn;
+      T.x += (cb.x - T.x) * k; T.z += (cb.z - T.z) * k;
+      T.y = this.terrainH(T.x, T.z) + L.tipY;
+    }
+    if (P.dead > 1e-3 && P.curl > 1e-3) T.y += 0.28 * L.total * smooth(0, 0.6, P.curl);
+    if (P.tuck > 1e-3) {
+      const B = L.P0[0];
+      T.lerp(this.localToWorld(B.x * 0.35, B.y - 0.25 * L.len[2], B.z * 0.6, tv()), P.tuck);
+    }
+    return T;
+  }
+
+  // The IK's elevations are defined modulo a turn. Pose blends interpolate them linearly toward fixed
+  // targets, so while any pose is blended in they are taken on the turn nearest to what was shown
+  // last frame (a leg released from a pose takes the short way back, never a full spin); with no pose
+  // active they are brought back to (-pi, pi], which changes nothing visible.
+  _unwrapIK(leg, li) {
+    const P = this.P, el = leg.el, az = leg.az, pv = leg.ikEl, pa = leg.ikAz;
+    const posed = P.raise[li] + P.hold[li] + P.curl + P.air + P.curl2 > 1e-5;
+    for (let k = 0; k < 7; k++) {
+      el[k] = posed ? pv[k] + angDiff(pv[k], el[k]) : angDiff(0, el[k]);
+      az[k] = posed ? pa[k] + angDiff(pa[k], az[k]) : angDiff(0, az[k]);
+    }
+  }
+
+  // blend one pose into the solved joint angles: femur elevation (deg) and the bends of the following
+  // joints relative to it; staggered = distal joints move first
+  poseBlend(leg, w, femur, bends, dAz, staggered) {
+    if (w < 1e-4) return;
+    const L = leg.def, az = leg.az, el = leg.el;
+    let e = femur * DEG;
+    el[2] += (e - el[2]) * (staggered ? smooth(0.35, 1, w) : w);
+    for (let k = 3; k < 7; k++) {
+      e += bends[k - 3] * DEG;
+      const wk = staggered ? smooth(STAG[k][0], STAG[k][1], w) : w;
+      el[k] += (e - el[k]) * wk;
+    }
+    const tAz = L.phi0 + dAz * DEG;
+    az[0] += (L.az0[0] - az[0]) * w;
+    for (let k = 1; k < 7; k++) az[k] += (tAz - az[k]) * w;
+  }
+
+  // A posed leg (raised, holding, curled, tucked) must not pass through the ground: rotate the chain
+  // from the femur outward about its base by just enough to lift the deepest joint clear (the
+  // direction that raises that joint, found numerically, so it also works upside down).
+  groundGuard(leg, strength = 1) {
+    const L = leg.def, el = leg.el, jp = leg.jp, m = L.tipY * 1.1, k2 = (0.1 * L.total) ** 2;
+    const pen = this._gpen || (this._gpen = new Float64Array(8)), y0 = this._gy0 || (this._gy0 = new Float64Array(8));
+    for (let it = 0; it < 3; it++) {
+      let any = false;
+      for (let k = 3; k < 8; k++) { const q = jp[k]; pen[k] = Math.max(0, this.terrainH(q.x, q.z) + (k === 7 ? m : 1.8 * m) - q.y); y0[k] = q.y; if (pen[k] > 0) any = true; }
+      if (!any) return;
+      const e = 0.05;
+      for (let k = 2; k < 7; k++) el[k] += e;
+      this.writeLeg(leg);
+      // least-squares step over every joint in the ground (each enters with zero depth: continuous)
+      let num = 0, den = k2;
+      for (let k = 3; k < 8; k++) { const sl = (jp[k].y - y0[k]) / e; num += pen[k] * sl; den += pen[k] > 0 ? sl * sl : 0; }
+      const dd = clamp((1.05 * num) / den, -0.6, 0.6) * strength - e;
+      for (let k = 2; k < 7; k++) el[k] += dd;
+      this.writeLeg(leg);
+    }
+  }
+
+
+
+
+  // claw tip (world) of a leg for joint angles az / el (no bones written)
+  fkTip(leg, az, el, out) {
+    const L = leg.def, s = L.side;
+    let x = L.P0[0].x, y = L.P0[0].y, z = L.P0[0].z;
+    for (let k = 0; k < 7; k++) {
+      const ce = Math.cos(el[k]);
+      x += L.len[k] * Math.sin(az[k]) * ce * s; y += L.len[k] * Math.sin(el[k]); z += L.len[k] * Math.cos(az[k]) * ce;
+    }
+    return this.localToWorld(x, y, z, out);
+  }
+
+  writeLeg(leg) {
+    const L = leg.def, az = leg.az, el = leg.el, s = L.side, jp = leg.jp;
+    const q = this._q, qy = this._q2;
+    const p = tv().copy(L.P0[0]);
+    this.localToWorld(p.x, p.y, p.z, jp[0]);
+    for (let k = 0; k < 7; k++) {
+      // rotation from bind: body x yaw about body up x pitch about the bind leg-plane normal
+      qy.setFromAxisAngle(Y_AXIS, s * angDiff(L.az0[k], az[k]));
+      q.setFromAxisAngle(L.n0, el[k] - L.el0[k]);
+      qy.multiply(q);
+      q.copy(this.qB).multiply(qy);
+      this.setBone(L.bones[k], jp[k], q);
+      const ce = Math.cos(el[k]);
+      p.x += L.len[k] * Math.sin(az[k]) * ce * s; p.y += L.len[k] * Math.sin(el[k]); p.z += L.len[k] * Math.cos(az[k]) * ce;
+      this.localToWorld(p.x, p.y, p.z, jp[k + 1]);
+    }
+    leg.tip.copy(jp[7]);
+  }
+
+  // ---------------------------------------------------------------- palps
+  solvePalps(dt) {
+    const cfg = this.cfg, P = this.P, t = this.time;
+    // (eased: the gait can switch on and off for a frame, e.g. at a landing)
+    this._palpMove = expTo(this._palpMove || 0, this._moving ? 1 : 0, dt, 0.12);
+    const moving = this._palpMove;
+    for (let k = 0; k < 2; k++) {
+      const D = cfg.palpDefs[k], S = this.palpState[k], az = S.az, el = S.el, s = D.side;
+      // idle twitches: random small targets, eased
+      S.twT -= dt;
+      if (S.twT <= 0) {
+        S.twT = 0.4 + this.rand() * 2.2;
+        const amp = 0.25 * cfg.palps.twitch * P.twitch * (1 - moving * 0.6);
+        for (let j = 0; j < 6; j++) S.tgt[j] = (this.rand() - 0.5) * amp;
+      }
+      const kT = 1 - Math.exp(-dt / 0.07), kD = 1 - Math.exp(-dt / 0.6);
+      const work = P.palpWork * Math.sin(t * TAU * 2.2 + k * Math.PI);
+      const gaitSwing = moving * cfg.palps.tap * 0.25 * Math.sin(TAU * (this.phase + k * 0.5));
+      for (let j = 0; j < 6; j++) {
+        S.twitch[j] += (S.tgt[j] - S.twitch[j]) * kT;
+        S.tgt[j] -= S.tgt[j] * kD;
+        az[j] = D.az0[j] - s * 0; el[j] = D.el0[j];
+      }
+      const raise = P.palpRaise, reach = P.palpReach, down = P.palpDown, fold = P.palpFold;
+      const ftw = S.twitch[2] + S.twitch[3];
+      el[2] += 0.85 * raise + 0.2 * reach - 0.35 * down + 0.3 * work + gaitSwing + ftw * 0.6 + 0.5 * fold;
+      el[3] += -0.3 * raise - 0.4 * down - 0.2 * work - 0.9 * fold + S.twitch[4] * 0.5;
+      el[4] += -0.2 * raise + 0.35 * reach - 0.25 * work - 0.7 * fold;
+      el[5] += -0.4 * raise + 0.45 * reach + 0.35 * work - 0.4 * fold + S.twitch[5] * 0.5;
+      for (let j = 1; j < 6; j++) az[j] += (-0.12 * raise - 0.05 * work + 0.1 * S.twitch[1]) ;
+      this.writePalp(D, S);
+      // keep the palp tip above the ground: lift the femur (continuous in the penetration depth)
+      const tip = S.jp[6];
+      let pen = this._palpPen(D, S);
+      for (let it = 0; it < 3 && pen > 0; it++) {
+        // lift the palp femur (and flatten the tarsus) until the tip clears
+        const reachL = D.len[2] + D.len[3] + D.len[4] + D.len[5];
+        el[2] += Math.min(0.9, Math.asin(Math.min(1, pen / reachL)) * 1.4);
+        el[5] += Math.min(0.6, pen / D.len[5]);
+        this.writePalp(D, S);
+        pen = this._palpPen(D, S);
+      }
+    }
+  }
+  // deepest ground penetration of the palp tip and of the patella, tibia and tarsus (ends and middles)
+  _palpPen(D, S) {
+    const tip = S.jp[6];
+    let m = this.terrainH(tip.x, tip.z) + D.tipR - tip.y;
+    for (let j = 3; j <= 5; j++) {
+      const q = S.jp[j], q2 = S.jp[j + 1];
+      m = Math.max(m, this.terrainH(q.x, q.z) + D.tipR * 2.4 - q.y);
+      const mx_ = (q.x + q2.x) * 0.5, my = (q.y + q2.y) * 0.5, mz = (q.z + q2.z) * 0.5;
+      m = Math.max(m, this.terrainH(mx_, mz) + D.tipR * 2.2 - my);
+    }
+    return m;
+  }
+  writePalp(D, S) {
+    const az = S.az, el = S.el, s = D.side, jp = S.jp;
+    const q = this._q, qy = this._q2;
+    const p = tv().copy(D.P0[0]);
+    this.localToWorld(p.x, p.y, p.z, jp[0]);
+    for (let k = 0; k < 6; k++) {
+      qy.setFromAxisAngle(Y_AXIS, s * angDiff(D.az0[k], az[k]));
+      q.setFromAxisAngle(D.n0, el[k] - D.el0[k]);
+      qy.multiply(q);
+      q.copy(this.qB).multiply(qy);
+      this.setBone(D.bones[k], jp[k], q);
+      const ce = Math.cos(el[k]);
+      p.x += D.len[k] * Math.sin(az[k]) * ce * s; p.y += D.len[k] * Math.sin(el[k]); p.z += D.len[k] * Math.cos(az[k]) * ce;
+      this.localToWorld(p.x, p.y, p.z, jp[k + 1]);
+    }
+  }
+
+  // ---------------------------------------------------------------- chelicerae and fangs
+  solveChelicerae() {
+    const cfg = this.cfg, P = this.P, C = cfg.chel, t = this.time;
+    const q = this._qc1, qw = this._qc2, qf = this._qc3;
+    for (let k = 0; k < 2; k++) {
+      const ch = cfg.chels[k], s = ch.side;
+      const work = P.chelWork * Math.sin(t * TAU * 2.6 + k * Math.PI);
+      const pitch = C.pitch * (0.35 * P.chelOpen + 0.25 * work) - 0.1 * P.dead;
+      const spread = C.spread * (P.chelOpen + 0.3 * Math.max(0, work)) * s;
+      // chelicera: pitch about the lateral axis (tips forward), spread about the forward axis
+      q.setFromAxisAngle(X_AXIS, -pitch).premultiply(qf.setFromAxisAngle(Z_AXIS, spread));
+      qw.copy(this.qB).multiply(q);
+      const base = this.localToWorld(ch.base.x, ch.base.y, ch.base.z, tv());
+      this.setBone(ch.bc, base, qw);
+      // fang: unfolds about its hinge
+      const tipLocal = tv().subVectors(ch.tip, ch.base).applyQuaternion(q).add(ch.base);
+      const tipW = this.localToWorld(tipLocal.x, tipLocal.y, tipLocal.z, tv());
+      const open = clamp(P.fangOpen + 0.15 * Math.max(0, work) * P.chelWork, 0, 1.1) * C.fangOpen;
+      qw.multiply(qf.setFromAxisAngle(ch.fangAxis, open));
+      this.setBone(ch.bf, tipW, qw);
+    }
+  }
+
+  // ----------------------------------------------------------------- state
+  publish() {
+    const st = this.state, P = this.P;
+    st.heading = this.heading;
+    st.speed = Math.hypot(this.velocity.x, this.velocity.z);
+    st.gait = this.air.active ? 'jump' : st.stats.gait;
+    st.grounded = !this.air.active;
+    st.eyelid = 0;
+    st.action = this.actionsLayer.current();
+    st.posture = this.actionsLayer.posture;
+    for (let i = 0; i < 8; i++) {
+      const leg = this.legs[i], o = st.legs[i];
+      o.stance = leg.state === 'stance' && !this.air.active && P.gaitW > 0.5 && P.raise[i] + P.hold[i] + P.curl + P.curl2 + P.air + P.drawIn + P.tuck + P.dead < 0.004;
+      if (leg.state === 'stance') o.contact.copy(leg.plant); else o.contact.copy(leg.tip);
+      o.contact.y -= leg.def.tipY;
+    }
+  }
+}