@bitefoundry/retrieviewer 0.0.0-stage → 0.0.2

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

@@ -0,0 +1,1594 @@
+// Snake motion engine: path-following lateral undulation over uneven terrain, a curvature-space pose
+// layer for everything that leaves the path (raised forebody, strike S-coil, flinch, writhing), a
+// scripted-path coil, head / jaw / tongue / fang / rattle control, and the snake action set.
+//
+// Locomotion. A virtual leader (the occiput, joint v0) moves along a serpentine path: a centre point
+// C travels at the commanded speed and heading, and the leader swings about it,
+//   leader = C + left(heading) * A * sin(phi),   phi += 2 pi dx / lambda
+// with amplitude A and wavelength lambda from the gait table (springs in the travelled distance, so
+// the path is C1 whatever the speed does; A starts from 0 when a snake sets off, so the new path
+// leaves exactly along its neck). The leader lays a trail on the terrain (a ring buffer of ground
+// points parameterised by arc length); every spine joint sits on the trail at its arc distance behind
+// the leader (non-uniform Catmull-Rom interpolation), lifted along the ground normal by its axis
+// height. So the body follows the head's path exactly (no lateral slip), hugs the ground and cannot
+// float or sink. Turns are rate limited (min radius, and so the leader never moves backwards).
+// state.position is C (the smooth centre of the wave, the point games follow / steer).
+//
+// Pose layer. Actions write, per joint, a lift above the ground, a yaw offset per segment and a roll.
+// The body is then re-integrated segment by segment from the head in the horizontal plane (exact
+// segment lengths: a lifted segment gets shorter horizontally) and translated so that the joints the
+// actions leave alone stay exactly on the trail (weighted fit). Heights always come from the terrain:
+// y = ground + axis height (+ lift), so lifted parts never go below it. A coil is not a pose but a
+// scripted path: the leader crawls an inward Archimedean spiral (curvature integrated along arc
+// length) and the body follows it into a flat coil. When a posture that changed the body shape ends
+// ('stand'), the current shape is baked into the trail, so the snake crawls off along its own body.
+// Self-contact: a part of the body that crosses over another rides on top of it (anterior over
+// posterior), with a smooth ramp along the chain.
+//
+// Lessons kept from the cheetah: continuous solves (nothing jumps between frames; weights and poses
+// are smooth functions of time), motion from phase (the wave is a function of travelled distance),
+// springs for secondary motion (head, jaw), zero-dt safety, no allocations in hot paths.
+//
+// Bones (core/rig/snake.js): head (v0 -> nose), jaw, tongue, tongueTip, fang, spine0..spineN-1
+// (v0 -> vN). Joint vi's bind height is its axis height above the belly.
+//
+// ------------------------------------------------------------------------------------------------
+// species.motion schema (reference size; lengths x total length TL where marked)
+// ------------------------------------------------------------------------------------------------
+// maxSpeed m/s, accel m/s^2, decel m/s^2, turnRate rad/s, minTurnRadius (x TL)
+// gears   { name: speed }  named speeds (crawl, slither, dash ...)
+// gaits   [{ name, v, wave (x TL), amp (x TL), headLift (m), stab (0..1 head yaw stabilisation) }]
+//         sorted by v; rows are blended by speed
+// body    { neck: x TL (part raised to look around), forebody: x TL (part used by strikes) }
+// tongue  { rate: flicks per s at idle, length: extension (x head length), flicks: [min, max] tip
+//         oscillations per flick, freq: tip oscillation Hz }
+// breath  { rate Hz, roll rad }
+// actions { strike: { reach (x TL), speed (m/s), gape (deg), coilHeight (x TL), rise (x TL) },
+//           coil: { pitch (ring spacing / body width), speed (m/s) }, sit: { raise (x TL) },
+//           eat: { swallow (s) }, drink: { pumps } }
+// variants { <params.variant>: { speedK, ampK, strike: {...}, rattle: bool } }  per-variant overrides
+// ------------------------------------------------------------------------------------------------
+// Contract extras: state.contacts = [{ key: 'v<i>', contact, position }] (ground contact of every
+// spine joint; contact = lying on the ground), motion.chain (spine bone indices, head -> tail),
+// state.stats.freq (undulation frequency), state.posture, events attackHit / actionStart /
+// actionEnd / death / arrive. Actions: idle, stand, sit (alert coil, head raised), lie (stretch out),
+// sleep (resting coil), coil, strike = attack, jump (a forward lunge), eat (strike + swallow), drink,
+// hit (flinch and whip away), death (writhe, go limp, roll half belly-up).
+import * as THREE from 'three';
+import { TAU, clamp, lerp, smooth, angDiff, Spring, prng, writeFrame } from './common.js';
+
+const DEFAULTS = {
+  maxSpeed: 0.8, accel: 0.9, decel: 1.6, turnRate: 2.2, minTurnRadius: 0.1,
+  body: { neck: 0.12, forebody: 0.3 },
+  tongue: { rate: 0.6, length: 0.6, flicks: [3, 6], freq: 7.5 },
+  breath: { rate: 0.28, roll: 0.03 },
+};
+const STRIKE = { reach: 0.33, speed: 2.8, gape: 75, coilHeight: 0.07, rise: 0.12 };
+const POSTURES = ['sit', 'lie', 'sleep', 'death', 'coil'];
+const COILED = { sit: 1, sleep: 1, coil: 1 };
+
+const _m1 = new THREE.Matrix4(), _m2 = new THREE.Matrix4(), _m3 = new THREE.Matrix4();
+const _q = new THREE.Quaternion(), _q2 = new THREE.Quaternion();
+const _v = new THREE.Vector3(), _v2 = new THREE.Vector3(), _v3 = new THREE.Vector3(), _v4 = new THREE.Vector3();
+const h2 = (a, b) => Math.sqrt(a * a + b * b);
+const h3 = (a, b, c) => Math.sqrt(a * a + b * b + c * c);
+const _X = new THREE.Vector3(1, 0, 0), _Y = new THREE.Vector3(0, 1, 0), _Z = new THREE.Vector3(0, 0, 1);
+
+// ------------------------------------------------------------------------------------------------
+// Trail: ground points by arc length (ring buffer), newest point = the leader
+// ------------------------------------------------------------------------------------------------
+class Trail {
+  constructor(cap) {
+    this.cap = cap;
+    this.x = new Float64Array(cap); this.y = new Float64Array(cap); this.z = new Float64Array(cap); this.s = new Float64Array(cap);
+    this.o = 0; this.n = 0; this.ver = 0; this.hit = 0;
+  }
+  clear() { this.o = 0; this.n = 0; this.ver++; }
+  // linear storage: logical k lives at o + k; when the end is reached the newest half moves to the front
+  idx(k) { return this.o + k; }
+  push(x, y, z, s) {
+    this.ver++;
+    if (this.o + this.n === this.cap) {
+      const keep = this.n >> 1, from = this.o + this.n - keep;
+      this.x.copyWithin(0, from, from + keep); this.y.copyWithin(0, from, from + keep);
+      this.z.copyWithin(0, from, from + keep); this.s.copyWithin(0, from, from + keep);
+      this.o = 0; this.n = keep;
+    }
+    const i = this.o + this.n;
+    this.x[i] = x; this.y[i] = y; this.z[i] = z; this.s[i] = s;
+    this.n++;
+  }
+  get lastS() { return this.s[this.o + this.n - 1]; }
+  // leader moved: update the provisional newest point, commit it once it is `spacing` from the one before
+  lead(x, y, z, spacing) {
+    const a = this.o + this.n - 1, b = a - 1;
+    const ax = x - this.x[a], ay = y - this.y[a], az = z - this.z[a];
+    if (ax * ax + ay * ay + az * az < 1e-18) return;
+    const bx = x - this.x[b], by = y - this.y[b], bz = z - this.z[b];
+    const db = Math.sqrt(bx * bx + by * by + bz * bz);
+    if (db >= spacing) this.push(x, y, z, this.s[a] + Math.sqrt(ax * ax + ay * ay + az * az));
+    else { this.x[a] = x; this.y[a] = y; this.z[a] = z; this.s[a] = this.s[b] + db; this.ver++; }
+  }
+  // position at arc s (Hermite with finite-difference tangents: C1 for any spacing); beyond the
+  // oldest point the trail is extended straight. `hint`: a nearby logical segment (walk from it).
+  sample(s, out, hint = -1) {
+    const n = this.n, o = this.o, X = this.x, Y = this.y, Z = this.z, S = this.s;
+    this.hit = 0;
+    if (s <= S[o]) {
+      const i0 = o, i1 = o + 1, k = (s - S[i0]) / (S[i1] - S[i0] || 1e-9);
+      out[0] = X[i0] + (X[i1] - X[i0]) * k; out[1] = Y[i0] + (Y[i1] - Y[i0]) * k; out[2] = Z[i0] + (Z[i1] - Z[i0]) * k;
+      return out;
+    }
+    const iN = o + n - 1;
+    if (s >= S[iN]) { out[0] = X[iN]; out[1] = Y[iN]; out[2] = Z[iN]; this.hit = n - 2; return out; }
+    let lo;
+    if (hint >= 0 && hint < n - 1) {
+      lo = hint;
+      while (lo > 0 && S[o + lo] > s) lo--;
+      while (lo < n - 2 && S[o + lo + 1] <= s) lo++;
+    } else {
+      lo = 0; let hi = n - 1;
+      while (hi - lo > 1) { const md = (lo + hi) >> 1; if (S[o + md] <= s) lo = md; else hi = md; }
+    }
+    this.hit = lo;
+    const a = o + lo, b = a + 1;
+    const h = S[b] - S[a] || 1e-9, u = (s - S[a]) / h;
+    // tangents per unit arc at a and b from their neighbours
+    const a0 = lo > 0 ? a - 1 : a, b1 = lo + 2 < n ? b + 1 : b;
+    const da = S[b] - S[a0] || 1e-9, db = S[b1] - S[a] || 1e-9;
+    const u2 = u * u, u3 = u2 * u;
+    const h00 = 2 * u3 - 3 * u2 + 1, h10 = ((u3 - 2 * u2 + u) * h) / da, h01 = -2 * u3 + 3 * u2, h11 = ((u3 - u2) * h) / db;
+    out[0] = h00 * X[a] + h10 * (X[b] - X[a0]) + h01 * X[b] + h11 * (X[b1] - X[a]);
+    out[1] = h00 * Y[a] + h10 * (Y[b] - Y[a0]) + h01 * Y[b] + h11 * (Y[b1] - Y[a]);
+    out[2] = h00 * Z[a] + h10 * (Z[b] - Z[a0]) + h01 * Z[b] + h11 * (Z[b1] - Z[a]);
+    return out;
+  }
+}
+const S3 = new Float64Array(3);
+
+// ------------------------------------------------------------------------------------------------
+export function createSnakeMotion(ctx) { return new SnakeMotion(ctx); }
+
+export class SnakeMotion {
+  constructor({ species, data, skeleton, ground, water, position, heading = 0, emit }) {
+    this.species = species;
+    this.sk = skeleton;
+    this.ground = ground || (() => 0);
+    this.water = water || null;
+    this.emit = emit || (() => {});
+    this.rand = prng((data.seed || 1) * 7919 + 29);
+    this.seed = data.seed || 1;
+    const params = data.params || {};
+    const spec = species.motion || {};
+    const vk = (spec.variants && spec.variants[params.variant]) || {};
+    this.viper = params.variant === 'rattlesnake';
+    // ---- skeleton
+    const J = {};
+    for (const [k, v] of Object.entries(data.joints)) J[k] = new THREE.Vector3(v[0], v[1], v[2]);
+    this.J = J;
+    let N = 0;
+    while (J['v' + (N + 1)]) N++;
+    this.N = N;
+    const bi = {};
+    data.bones.forEach((b, i) => { bi[b.name] = i; });
+    this.bi = bi;
+    this.spine = Array.from({ length: N }, (_, i) => skeleton.bones[bi['spine' + i]]);
+    this.chain = Array.from({ length: N }, (_, i) => bi['spine' + i]);
+    this.bHead = skeleton.bones[bi.head]; this.bJaw = skeleton.bones[bi.jaw];
+    this.bTongue = skeleton.bones[bi.tongue]; this.bTip = skeleton.bones[bi.tongueTip]; this.bFang = skeleton.bones[bi.fang];
+    const bind = (n) => skeleton.bind[bi[n]];
+    this.bindHead = bind('head'); this.bindJaw = bind('jaw'); this.bindTongue = bind('tongue'); this.bindTip = bind('tongueTip'); this.bindFang = bind('fang');
+    // ---- dimensions
+    const s = params.size || 1;
+    this.s = s;
+    this.sq = Math.sqrt(s);
+    this.len = new Float64Array(N); this.sig = new Float64Array(N + 1); this.r = new Float64Array(N + 1); this.hw = new Float64Array(N + 1);
+    const flat = spec.flat || (params.variant === 'rattlesnake' ? 0.64 : 0.74);
+    for (let i = 0; i < N; i++) { this.len[i] = J['v' + i].distanceTo(J['v' + (i + 1)]); this.sig[i + 1] = this.sig[i] + this.len[i]; }
+    for (let i = 0; i <= N; i++) { this.r[i] = J['v' + i].y; this.hw[i] = this.r[i] / flat; }
+    this.bodyLen = this.sig[N];
+    // support of each body cross-section toward the ground as a function of roll, measured on the
+    // bind mesh (vertices skinned mostly to the bone that starts at the joint): the body can lie on its
+    // side or back on any terrain without sinking in or floating
+    {
+      const NA = (this.supN = 48), tab = (this.supTab = new Float32Array((N + 1) * NA)), idx = new Int16Array(data.bones.length).fill(-1);
+      for (let i = 0; i < N; i++) idx[bi['spine' + i]] = i;
+      for (let v = 0; v < data.nV; v++) {
+        if (data.skinWeight[v * 4] < 0.4) continue;
+        const i = idx[data.skinIndex[v * 4]];
+        if (i < 0) continue;
+        const z = data.pos[v * 3 + 2];
+        // only the body's own section (not a rattle or other rigid ornament beyond the joints)
+        if (z > J['v' + i].z + 0.3 * this.len[i] || z < J['v' + (i + 1)].z - 0.3 * this.len[i]) continue;
+        const x = data.pos[v * 3], y = data.pos[v * 3 + 1] - J['v' + i].y;
+        for (let k = 0; k < NA; k++) {
+          const ro = -Math.PI + (TAU * k) / NA;
+          const d = -(x * Math.sin(ro) + y * Math.cos(ro));
+          if (d > tab[i * NA + k]) tab[i * NA + k] = d;
+        }
+      }
+      for (let k = 0; k < NA; k++) tab[N * NA + k] = tab[(N - 1) * NA + k];
+      // sections with no data (none expected): the analytic loaf
+      for (let i = 0; i <= N; i++) if (tab[i * NA + (NA >> 1)] <= 0) for (let k = 0; k < NA; k++) tab[i * NA + k] = J['v' + i].y;
+    }
+    this.headLen = J.nose.distanceTo(J.v0);
+    this.TL = this.bodyLen + this.headLen;
+    let hwMax = 0; for (let i = 0; i <= N; i++) hwMax = Math.max(hwMax, this.hw[i]);
+    this.hwMax = hwMax;
+    this.restCurl = spec.restCurl ?? 1;
+    // ---- config
+    const m = (a, b) => ({ ...a, ...(b || {}) });
+    const speedK = (vk.speedK ?? 1) * this.sq;
+    this.cfg = {
+      maxSpeed: vk.maxSpeed !== undefined ? vk.maxSpeed * this.sq : (spec.maxSpeed ?? DEFAULTS.maxSpeed) * speedK,
+      accel: (spec.accel ?? DEFAULTS.accel) * this.sq, decel: (spec.decel ?? DEFAULTS.decel) * this.sq,
+      turnRate: (spec.turnRate ?? DEFAULTS.turnRate) / this.sq,
+      minR: (spec.minTurnRadius ?? DEFAULTS.minTurnRadius) * this.TL,
+      body: m(DEFAULTS.body, spec.body), tongue: m(m(DEFAULTS.tongue, spec.tongue), vk.tongue), breath: m(DEFAULTS.breath, spec.breath),
+      actions: spec.actions || {},
+      strike: m(m(STRIKE, spec.actions?.strike), vk.strike),
+      rattle: !!vk.rattle,
+      ampK: vk.ampK ?? 1,
+    };
+    // a variant may bring its own gait table / gears (reference speeds, not scaled by speedK)
+    const G = vk.gaits || (spec.gaits && spec.gaits.length ? spec.gaits : [{ name: 'slither', v: 0, wave: 0.42, amp: 0.07, headLift: 0.008, stab: 0.6 }]);
+    const gK = vk.gaits ? this.sq : speedK, aK = vk.gaits ? 1 : this.cfg.ampK;
+    this.gaitRows = G.map((g) => [g.v * gK, g.wave, g.amp * aK, g.headLift * s, g.stab ?? 0.6]);
+    this.gaitNames = G.map((g) => g.name);
+    this.gaits = [...new Set(this.gaitNames)];
+    this.gears = vk.gears ? Object.fromEntries(Object.entries(vk.gears).map(([k, v]) => [k, v * this.sq])) : spec.gears ? Object.fromEntries(Object.entries(spec.gears).map(([k, v]) => [k, v * speedK])) : { slither: 0.25 * speedK };
+    this.cfg.tailCarry = (vk.tailCarry ?? 0) * s;
+    this._row = [0, 0, 0, 0];
+    // ---- bind-space head landmarks (for ground clearance and attachments)
+    this.v0b = J.v0.clone();
+    this.noseB = J.nose.clone();
+    this.chinB = J.jawTip.clone(); this.chinB.y = 0.0005 * s;
+    this.hingeB = J.jawHinge.clone();
+    // outer corner of the lower jaw (bind), for ground clearance when the head rolls
+    this.jawCorner = new THREE.Vector3(0, 0.0005 * s, J.jawHinge.z);
+    this.jawMid = new THREE.Vector3(0, 0.0005 * s, lerp(J.jawHinge.z, J.jawTip.z, 0.55));
+    { const jb = bi.jaw; let mx = 0; for (let v = 0; v < data.nV; v++) if (data.skinIndex[v * 4] === jb && data.skinWeight[v * 4] > 0.5 && Math.abs(data.pos[v * 3]) > mx) { mx = Math.abs(data.pos[v * 3]); this.jawCorner.z = data.pos[v * 3 + 2]; } this.jawCorner.x = mx; this.jawMid.x = 0.5 * mx; }
+    this.tongueBaseB = J.tongueBase.clone(); this.tongueForkB = J.tongueFork.clone();
+    this.tongueDirB = J.tongueFork.clone().sub(J.tongueBase).normalize();
+    this.fangBaseB = J.fangBase.clone();
+    this.tipLen = J.tongueTip.distanceTo(J.tongueFork);
+    // ---- public contract
+    this.input = { speed: 0, heading, climb: 0, look: null, follow: null, target: null, targetSpeed: 0.3, crouch: 0, gait: null };
+    this.pos = new THREE.Vector3();
+    this.velocity = new THREE.Vector3();
+    this.heading = heading;
+    this.speed = 0;
+    this.yawRate = 0;
+    this.time = 0;
+    this.lod = 0;
+    this.frame = 0; this._acc = 0; this._posed = false;
+    this.lookTarget = 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: [],
+      contacts: Array.from({ length: N + 1 }, (_, i) => ({ key: 'v' + i, contact: true, position: new THREE.Vector3() })),
+    };
+    this.headPose = { position: new THREE.Vector3(), quaternion: new THREE.Quaternion() };
+    this.debug = { targets: Array.from({ length: 6 }, () => new THREE.Vector3()) };
+    this.actions = ['idle', 'stand', 'sit', 'lie', 'sleep', 'coil', 'eat', 'drink', 'attack', 'strike', 'jump', 'hit', 'death'];
+    // ---- locomotion state
+    this.trail = new Trail(2048);
+    this.C = new THREE.Vector3();
+    this.leader = new THREE.Vector3();
+    this.x = 0; this.phi = 0;
+    this.A = new Spring(0); this.lam = new Spring(0.42 * this.TL);
+    this.reseed = true;
+    this.script = null; // scripted leader path (coil)
+    this.follow = { init: false, p: new THREE.Vector3() };
+    this.pursuit = { on: false, psi: 0, dx: 0, dz: 0, follow: false };
+    // ---- per-joint arrays
+    const F = (n) => new Float64Array(n);
+    this.gx = F(N + 1); this.gy = F(N + 1); this.gz = F(N + 1); // base ground points (trail)
+    this.nx = F(N + 1); this.ny = F(N + 1); this.nz = F(N + 1); // ground normals
+    this.px = F(N + 1); this.py = F(N + 1); this.pz = F(N + 1); // final axis points
+    this.hx = F(N + 1); this.hz = F(N + 1);
+    this.byaw = F(N); this.byawU = F(N); this.blh = F(N); this.bch = F(N); this.bsin = F(N); // base segment yaw, horizontal length, chord, elevation sine
+    this.lift = F(N + 1); this.dyaw = F(N); this.roll = F(N + 1); this.affect = F(N + 1); this.stack = F(N + 1); this.stackTmp = F(N + 1);
+    this.grid = { head: new Int16Array(256), next: new Int16Array(N + 1) };
+    this.lat = Array.from({ length: N }, () => new THREE.Vector3());
+    this.contact = new Uint8Array(N + 1);
+    // ---- head & secondary springs
+    this.hYaw = new Spring(0); this.hPitch = new Spring(0); this.hRoll = new Spring(0);
+    this.gape = new Spring(0); this.fang = new Spring(0);
+    this.tongue = { t: 0, dur: 0, next: 1 + this.rand() * 2, osc: 4, ext: new Spring(0), tipS: new Spring(0), pitchS: new Spring(0), pitch: 0, tip: 0, extD: 0 };
+    this.qHead = new THREE.Quaternion();
+    this.Tm = new THREE.Matrix4(); // head-rigid transform: bind space -> world
+    this._headInit = false;
+    // ---- actions
+    this.P = makePose(N);
+    this.layer = new SnakeActions(this);
+    this.attachmentPoints = this._attachments(data);
+    this.reset(position || new THREE.Vector3(), heading);
+  }
+
+  _attachments(data) {
+    const J = this.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) };
+    };
+    let headP = J.v0.clone().lerp(J.nose, 0.55);
+    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); }
+    const mid = this.N >> 1;
+    const back = J['v' + mid].clone(); back.y += this.hw[mid];
+    const out = { mouth: at('head', J.nose.clone().lerp(J.jawTip, 0.5)), head: at('head', headP), back: at('spine' + mid, back) };
+    for (const k of Object.keys(out)) if (!out[k]) delete out[k];
+    return out;
+  }
+
+  // ----------------------------------------------------------------- terrain
+  terrainH(x, z) { const h = this.ground(x, z); return Number.isFinite(h) ? h : 0; }
+  terrainN(x, z, out) {
+    const e = 0.05 * this.s, h0 = this.terrainH(x, z);
+    out[0] = h0 - this.terrainH(x + e, z); out[1] = e; out[2] = h0 - this.terrainH(x, z + e);
+    const l = h3(out[0], out[1], out[2]);
+    out[0] /= l; out[1] /= l; out[2] /= l;
+    return out;
+  }
+
+  /** Lay the body straight behind p along `heading` (bind layout). */
+  reset(p, heading = this.heading) {
+    const N = this.N, tr = this.trail;
+    tr.clear();
+    // rest in a loose S behind the head (curvature integrated backwards along the body)
+    const extra = 0.25 * this.TL;
+    const total = this.bodyLen + extra;
+    const step = 0.01 * this.s;
+    const nPts = Math.ceil(total / step) + 1;
+    const X = new Float64Array(nPts), Z = new Float64Array(nPts);
+    let x = p.x, z = p.z, psi = heading;
+    const rr = prng(Math.imul(this.seed || 1, 2654435761) ^ 0x5bd1e995), ph = rr() * TAU;
+    const lam = (0.42 + 0.16 * rr()) * this.TL, amp = (0.3 + 0.45 * rr()) * this.restCurl;
+    for (let k = 0; k < nPts; k++) {
+      X[k] = x; Z[k] = z;
+      const d = k * step;
+      const a = heading + amp * (Math.sin((TAU * d) / lam + ph) - Math.sin(ph)) * smooth(0.02 * this.TL, 0.15 * this.TL, d) * (1 - smooth(this.bodyLen, total, d));
+      psi = a;
+      x -= Math.sin(psi) * step; z -= Math.cos(psi) * step;
+    }
+    let s = 0, lx = 0, ly = 0, lz = 0;
+    for (let k = nPts - 1; k >= 0; k--) {
+      const y = this.terrainH(X[k], Z[k]);
+      if (k < nPts - 1) s += h3(X[k] - lx, y - ly, Z[k] - lz);
+      tr.push(X[k], y, Z[k], s);
+      lx = X[k]; ly = y; lz = Z[k];
+    }
+    this.heading = heading; this.input.heading = heading;
+    this.speed = 0; this.yawRate = 0; this.velocity.set(0, 0, 0);
+    this.C.set(p.x, this.terrainH(p.x, p.z), p.z);
+    this.leader.copy(this.C);
+    this.pos.copy(this.C);
+    this.x = 0; this.phi = 0; this.A.reset(0); this.lam.reset(0.42 * this.TL);
+    this.reseed = true;
+    this.script = null;
+    this._headInit = false;
+    this.follow.init = false;
+    this.pursuit.on = false;
+  }
+
+  // ----------------------------------------------------------------- public API
+  play(name, opts) { return this.layer.play(name, opts || {}); }
+  stop(name) { this.layer.stop(name); }
+  setLod(level) { this.lod = clamp(level | 0, 0, 2); return this; }
+  dispose() { this.layer.clear(); }
+
+  update(dt) {
+    if (!(dt > 1e-4) || !Number.isFinite(dt)) dt = 1e-4;
+    dt = Math.min(dt, 1 / 20);
+    this.time += dt;
+    this.drive(dt);
+    this.locomote(dt);
+    // crowd LOD: the pose is solved at half rate (the simulation still runs every frame)
+    this.frame = (this.frame + 1) | 0;
+    if (this.lod < 2 || (this.frame & 1) === 0 || !this._posed) {
+      this.basePose();
+      this.layer.update(dt + this._acc);
+      this.solveBody();
+      this.solveHead(this._acc + dt);
+      this._acc = 0;
+      this._posed = true;
+    } else { this._acc += dt; }
+    this.publish();
+  }
+
+  // ----------------------------------------------------------------- steering
+  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 = h2(dx, dz);
+      const stopR = 0.08 * this.TL + 0.1 * 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 brake = Math.sqrt(Math.max(0, 2 * cfg.decel * 0.7 * (d - stopR)));
+        this.wantSpeed = Math.min(inp.targetSpeed || 0.3, cfg.maxSpeed, brake + 0.03);
+      }
+    }
+    if (this.layer.holdsStill()) {
+      if ((this.wantSpeed > 0.01 || inp.follow) && !this.layer.dead()) this.layer.requestStand();
+      this.wantSpeed = 0;
+    }
+  }
+
+  gaitAt(v) {
+    const R = this.gaitRows;
+    let i = 0;
+    while (i < R.length - 2 && v > R[i + 1][0]) i++;
+    const a = R[i], b = R[Math.min(i + 1, R.length - 1)];
+    const t = a === b ? 0 : smooth(0, 1, (v - a[0]) / (b[0] - a[0]));
+    const o = this._row;
+    for (let k = 0; k < 4; k++) o[k] = lerp(a[k + 1], b[k + 1], t);
+    this.gaitName = t < 0.5 ? this.gaitNames[i] : this.gaitNames[Math.min(i + 1, R.length - 1)];
+    return o;
+  }
+
+  // ----------------------------------------------------------------- locomotion
+  locomote(dt) {
+    const inp = this.input, cfg = this.cfg, P = this.P;
+    const tr = this.trail;
+    const spacing = 0.005 * this.s;
+    if (this.script) { this.runScript(dt, spacing); return; }
+    const following = !!inp.follow && !this.layer.holdsStill();
+    let v, dx;
+    if (following) {
+      const f = inp.follow, fv = f.velocity;
+      const vx = fv ? fv.x : 0, vz = fv ? fv.z : 0;
+      const sp = h2(vx, vz);
+      const fp = this.follow.p;
+      if (!this.follow.init) { fp.set(f.position.x, 0, f.position.z); this.follow.init = true; this.reseed = false; this.A.reset(0); }
+      // alpha-beta filter: the given velocity carries it, the position pulls gently (physics jitter)
+      const ox = fp.x, oz = fp.z;
+      fp.x += vx * dt; fp.z += vz * dt;
+      const k = 1 - Math.exp(-dt / 0.06);
+      fp.x += (f.position.x - fp.x) * k; fp.z += (f.position.z - fp.z) * k;
+      v = sp;
+      let hT = f.heading ?? (sp > 0.02 * this.sq ? Math.atan2(vx, vz) : this.heading);
+      this.turn(hT, v, dt);
+      const Fx = Math.sin(this.heading), Fz = Math.cos(this.heading);
+      dx = Math.max(0, (fp.x - ox) * Fx + (fp.z - oz) * Fz);
+      this.C.x = fp.x; this.C.z = fp.z;
+      this.speed = v;
+      this.velocity.set(vx, 0, vz);
+    } else {
+      this.follow.init = false;
+      const vT = this.wantSpeed * P.speedScale;
+      const acc = vT > this.speed ? cfg.accel : cfg.decel;
+      this.speed += clamp(vT - this.speed, -acc * dt, acc * dt);
+      if (this.speed < 1e-4 && vT <= 0) this.speed = 0;
+      v = this.speed;
+      if (v > 0 && this.reseed) this.startMoving();
+      this.turn(this.wantHeading, v, dt);
+      dx = v * dt;
+      const Fx = Math.sin(this.heading), Fz = Math.cos(this.heading);
+      this.C.x += Fx * dx; this.C.z += Fz * dx;
+      this.velocity.set(Fx * v, 0, Fz * v);
+    }
+    this.C.y = this.terrainH(this.C.x, this.C.z);
+    this.pos.copy(this.C);
+    const row = this.gaitAt(v / this.sq);
+    this.gait = row;
+    if (dx > 0 || following) {
+      const lamT = row[0] * this.TL, ampT = row[1] * this.TL;
+      if (dx > 0) {
+        const wd = TAU / Math.max(0.05, this.lam.x);
+        this.A.step(ampT, 1.6 * wd, dx);
+        this.lam.step(lamT, 1.6 * wd, dx);
+        this.phi += (TAU * dx) / this.lam.x;
+        this.x += dx;
+      }
+      const y = this.A.x * Math.sin(this.phi);
+      const Lx = Math.cos(this.heading), Lz = -Math.sin(this.heading);
+      const Dx = this.C.x + Lx * y, Dz = this.C.z + Lz * y;
+      // The head tracks its ideal place D on the wave with a curvature-bounded steering law (heading
+      // relaxes toward the ideal path's tangent over a short distance, plus lateral and along-track
+      // corrections), so the laid path is smooth and never tighter than the body can bend, whatever
+      // the input does (sharp turns, a misaligned follow start, physics jitter).
+      const pu = this.pursuit;
+      if (!pu.on) { pu.on = true; pu.psi = this.neckYaw(); pu.k = 0; pu.dx = Dx; pu.dz = Dz; }
+      const tdx = Dx - pu.dx, tdz = Dz - pu.dz;
+      pu.dx = Dx; pu.dz = Dz;
+      const dD = h2(tdx, tdz);
+      const psiD = dD > 1e-7 ? Math.atan2(tdx, tdz) : pu.psi;
+      const ex = Dx - this.leader.x, ez = Dz - this.leader.z;
+      const Fx = Math.sin(pu.psi), Fz = Math.cos(pu.psi);
+      const lat = ex * Fz - ez * Fx, along = ex * Fx + ez * Fz;
+      const TL = this.TL;
+      const psiT = psiD + clamp(lat / (0.05 * TL), -0.7, 0.7);
+      const ds = Math.max(0, dD * clamp(Math.cos(angDiff(pu.psi, psiD)), 0.25, 1) + clamp(along, -0.03 * TL, 0.06 * TL) * 0.12);
+      const kMax = 1 / (0.036 * TL), kRate = kMax / (0.035 * TL);
+      const nSub = Math.max(1, Math.ceil(ds / (0.004 * this.s)));
+      let lx = this.leader.x, lz = this.leader.z;
+      for (let k = 0; k < nSub; k++) {
+        const h = ds / nSub;
+        // curvature command with a smooth saturation, and a bounded rate of change along the path
+        const kc = kMax * Math.tanh(angDiff(pu.psi, psiT) / (0.03 * TL * kMax));
+        pu.k += clamp(kc - pu.k, -kRate * h, kRate * h);
+        pu.psi += pu.k * h;
+        lx += Math.sin(pu.psi) * h; lz += Math.cos(pu.psi) * h;
+      }
+      this.leader.set(lx, this.terrainH(lx, lz), lz);
+      if (!following && pu.follow) { pu.follow = false; }
+      pu.follow = following;
+      tr.lead(this.leader.x, this.leader.y, this.leader.z, spacing);
+    }
+    this.freq = v > 1e-3 ? v / this.lam.x : 0;
+  }
+
+  // limited yaw rate: never tighter than the minimum radius, and slow enough that the leader keeps
+  // moving forward along its path (the wave offset swings with the heading)
+  turn(hT, v, dt) {
+    const cfg = this.cfg;
+    const wMax = Math.min(cfg.turnRate, v / cfg.minR, (0.35 * v) / Math.max(1e-3, Math.abs(this.A.x)));
+    const wT = clamp(angDiff(this.heading, hT) * 2.2, -wMax, wMax);
+    this.yawRate += clamp(wT - this.yawRate, -4 * dt, 4 * dt);
+    this.yawRate = clamp(this.yawRate, -wMax, wMax);
+    this.heading += this.yawRate * dt;
+  }
+
+  neckYaw() {
+    const tr = this.trail, sl = tr.lastS;
+    tr.sample(sl, S3); const ax = S3[0], az = S3[2];
+    tr.sample(sl - 0.04 * this.TL, S3);
+    return Math.atan2(ax - S3[0], az - S3[2]);
+  }
+
+  // a new path leaves exactly along the neck: centre on the leader, heading along the neck, no wave yet
+  startMoving() {
+    const tr = this.trail, sl = tr.lastS;
+    tr.sample(sl, S3); const ax = S3[0], ay = S3[1], az = S3[2];
+    tr.sample(sl - 0.04 * this.TL, S3);
+    this.heading = Math.atan2(ax - S3[0], az - S3[2]);
+    this.yawRate = 0;
+    this.C.set(ax, ay, az);
+    this.leader.set(ax, ay, az);
+    this.A.reset(0);
+    this.phi = 0;
+    this.reseed = false;
+    this.pursuit.on = false;
+  }
+
+  // scripted leader path (coil): curvature integrated along arc length
+  startScript(sc) {
+    const tr = this.trail, sl = tr.lastS;
+    tr.sample(sl, S3); const ax = S3[0], az = S3[2];
+    tr.sample(sl - 0.03 * this.TL, S3); const bx = S3[0], bz = S3[2];
+    tr.sample(sl - 0.06 * this.TL, S3); const cx = S3[0], cz = S3[2];
+    const y1 = Math.atan2(ax - bx, az - bz), y0 = Math.atan2(bx - cx, bz - cz);
+    sc.psi = y1;
+    sc.k0 = clamp(angDiff(y0, y1) / (0.03 * this.TL), -30, 30);
+    sc.u = 0;
+    sc.x = ax; sc.z = az;
+    this.script = sc;
+    this.speed = 0; this.yawRate = 0;
+  }
+
+  runScript(dt, spacing) {
+    const sc = this.script;
+    const rem = sc.total - sc.u;
+    const v = sc.speed * (0.25 + 0.75 * smooth(0, 0.05 * this.TL, sc.u)) * Math.max(0.12, smooth(0, 0.08 * this.TL, rem));
+    const du = Math.min(rem, v * dt);
+    const n = Math.max(1, Math.ceil(du / (0.004 * this.s)));
+    for (let k = 0; k < n; k++) {
+      const h = du / n;
+      const kap = lerp(sc.k0, sc.kappa(sc.u + h * 0.5), smooth(0, 0.07 * this.TL, sc.u));
+      sc.psi += kap * h;
+      sc.x += Math.sin(sc.psi) * h; sc.z += Math.cos(sc.psi) * h;
+      sc.u += h;
+    }
+    this.leader.set(sc.x, this.terrainH(sc.x, sc.z), sc.z);
+    // the head leads: the reported position follows it while the snake coils up
+    this.C.copy(this.leader); this.pos.copy(this.C);
+    this.trail.lead(this.leader.x, this.leader.y, this.leader.z, spacing);
+    this.velocity.set(0, 0, 0);
+    this.freq = 0;
+    if (sc.u >= sc.total - 1e-6) { this.script = null; sc.done = true; this.reseed = true; this.pursuit.on = false; }
+  }
+
+  // ----------------------------------------------------------------- base pose: joints on the trail
+  basePose() {
+    const N = this.N, tr = this.trail, sl = tr.lastS, lod = this.lod;
+    // nothing moved (the trail is unchanged and the terrain is static): the base pose stands
+    if (tr.ver === this._baseVer && lod === this._baseLod) return;
+    this._baseVer = tr.ver; this._baseLod = lod;
+    let hint = tr.n - 2;
+    const gx = this.gx, gy = this.gy, gz = this.gz, sig = this.sig;
+    // crowd LOD: every other joint from the trail, the ones between at the chord midpoint
+    const stepI = lod >= 2 ? 2 : 1;
+    for (let i = 0; i <= N; i += stepI) {
+      tr.sample(sl - sig[i], S3, hint);
+      hint = tr.hit;
+      gx[i] = S3[0]; gz[i] = S3[2];
+      gy[i] = this.terrainH(S3[0], S3[2]);
+      if (lod >= 2) { this.nx[i] = 0; this.ny[i] = 1; this.nz[i] = 0; }
+      else { this.terrainN(S3[0], S3[2], S3); this.nx[i] = S3[0]; this.ny[i] = S3[1]; this.nz[i] = S3[2]; }
+      if (stepI === 2 && i === N - 1) i--; // make sure the tail tip is sampled
+    }
+    if (stepI === 2) {
+      for (let i = 1; i < N; i += 2) {
+        if (i + 1 > N) break;
+        const t = (sig[i] - sig[i - 1]) / (sig[i + 1] - sig[i - 1]);
+        gx[i] = gx[i - 1] + (gx[i + 1] - gx[i - 1]) * t; gz[i] = gz[i - 1] + (gz[i + 1] - gz[i - 1]) * t;
+        gy[i] = this.terrainH(gx[i], gz[i]);
+        this.nx[i] = 0; this.ny[i] = 1; this.nz[i] = 0;
+      }
+    }
+    for (let i = 0; i < N; i++) {
+      const dx = this.gx[i] - this.gx[i + 1], dz = this.gz[i] - this.gz[i + 1], dy = this.gy[i] - this.gy[i + 1];
+      const lh = h2(dx, dz);
+      this.byaw[i] = lh > 1e-9 ? Math.atan2(dx, dz) : i > 0 ? this.byaw[i - 1] : this.heading;
+      this.blh[i] = lh;
+      const c = h2(lh, dy);
+      this.bch[i] = c;
+      this.bsin[i] = c > 1e-9 ? dy / c : 0;
+      // yaw unwrapped along the chain (a coiled body turns through more than pi)
+      this.byawU[i] = i === 0 ? this.byaw[0] : this.byawU[i - 1] + angDiff(this.byaw[i - 1], this.byaw[i]);
+    }
+  }
+
+  // ----------------------------------------------------------------- pose integration and frames
+  solveBody() {
+    const N = this.N, P = this.P;
+    const lift = P.lift, dyaw = P.dyaw, roll = P.roll;
+    let any = false;
+    for (let i = 0; i < N; i++) if (Math.abs(dyaw[i]) > 1e-7) { any = true; break; }
+    if (!any) for (let i = 0; i <= N; i++) if (lift[i] > 1e-7) { any = true; break; }
+    const hx = this.hx, hz = this.hz;
+    if (any) {
+      hx[0] = this.gx[0]; hz[0] = this.gz[0];
+      for (let i = 0; i < N; i++) {
+        const c = this.bch[i];
+        const sn = clamp(this.bsin[i] + (lift[i] - lift[i + 1]) / Math.max(c, 1e-9), -0.995, 0.995);
+        const lh = c * Math.sqrt(1 - sn * sn);
+        const yw = this.byaw[i] + dyaw[i];
+        hx[i + 1] = hx[i] - Math.sin(yw) * lh;
+        hz[i + 1] = hz[i] - Math.cos(yw) * lh;
+      }
+      // keep the joints the actions leave alone where they were
+      let sw = 0, tx = 0, tz = 0;
+      for (let i = 0; i <= N; i++) {
+        const w = Math.max(1e-3, 1 - clamp(this.affect[i], 0, 1));
+        sw += w; tx += w * (this.gx[i] - hx[i]); tz += w * (this.gz[i] - hz[i]);
+      }
+      tx /= sw; tz /= sw;
+      for (let i = 0; i <= N; i++) { hx[i] += tx; hz[i] += tz; }
+    } else {
+      for (let i = 0; i <= N; i++) { hx[i] = this.gx[i]; hz[i] = this.gz[i]; }
+    }
+    // heights from the terrain, axis offset along the ground normal (grows toward the half width
+    // when the body is rolled onto its back)
+    const lod = this.lod;
+    for (let i = 0; i <= N; i++) {
+      const x = hx[i], z = hz[i];
+      let gy, nx, ny, nz;
+      if (any) {
+        gy = this.terrainH(x, z);
+        if (lod >= 2) { nx = 0; ny = 1; nz = 0; } else { this.terrainN(x, z, S3); nx = S3[0]; ny = S3[1]; nz = S3[2]; }
+      } else { gy = this.gy[i]; nx = this.nx[i]; ny = this.ny[i]; nz = this.nz[i]; }
+      const ro = roll[i];
+      // support of the cross-section toward the ground when rolled: flat belly (axis height r) when
+      // upright, the half width on its side, the round back (~half width) when belly-up
+      const rr = ro === 0 ? this.r[i] : this.support(i, ro);
+      this.px[i] = x + nx * rr; this.pz[i] = z + nz * rr;
+      this.py[i] = gy + ny * rr + lift[i];
+      this.stack[i] = 0;
+    }
+    if (lod < 2 && P.stackW > 0) this.selfContact();
+    for (let i = 0; i <= N; i++) this.py[i] += this.stack[i];
+    // on the ground: this joint and its neighbours are not lifted (a joint next to a raised one is
+    // the start of the rise)
+    const tol = 0.0015 * this.s;
+    for (let i = 0; i <= N; i++) {
+      const a = lift[i] + this.stack[i], b = i > 0 ? lift[i - 1] + this.stack[i - 1] : 0, c = i < N ? lift[i + 1] + this.stack[i + 1] : 0;
+      this.contact[i] = a < tol && b < tol && c < tol && !(this.affect[i] > 0.05 && lift[i] > 1e-5) ? 1 : 0;
+    }
+    // frames: lateral axis from the ground normal (belly down), transported where a segment stands
+    // up steeply, then rolled
+    const up = S3;
+    let plx = 0, ply = 0, plz = 0, havePrev = false;
+    for (let i = N - 1; i >= 0; i--) {
+      const fx = this.px[i] - this.px[i + 1], fy = this.py[i] - this.py[i + 1], fz = this.pz[i] - this.pz[i + 1];
+      const fl = h3(fx, fy, fz) || 1;
+      const ux = fx / fl, uy = fy / fl, uz = fz / fl;
+      const gnx = (this.nx[i] + this.nx[i + 1]) * 0.5, gny = (this.ny[i] + this.ny[i + 1]) * 0.5, gnz = (this.nz[i] + this.nz[i + 1]) * 0.5;
+      // left = up x forward
+      let lx = gny * uz - gnz * uy, ly = gnz * ux - gnx * uz, lz = gnx * uy - gny * ux;
+      let ll = h3(lx, ly, lz);
+      if (havePrev) {
+        const d = plx * ux + ply * uy + plz * uz;
+        let tx = plx - ux * d, ty = ply - uy * d, tz = plz - uz * d;
+        const tl = h3(tx, ty, tz) || 1;
+        tx /= tl; ty /= tl; tz /= tl;
+        const w = smooth(0.25, 0.6, ll);
+        if (ll > 1e-9) { lx /= ll; ly /= ll; lz /= ll; }
+        lx = lerp(tx, lx, w); ly = lerp(ty, ly, w); lz = lerp(tz, lz, w);
+        ll = h3(lx, ly, lz);
+      }
+      if (ll < 1e-9) { lx = Math.cos(this.heading); ly = 0; lz = -Math.sin(this.heading); ll = 1; }
+      lx /= ll; ly /= ll; lz /= ll;
+      plx = lx; ply = ly; plz = lz; havePrev = true;
+      // roll about the bone (forward axis)
+      const ro = (roll[i] + roll[i + 1]) * 0.5;
+      const L = this.lat[i];
+      if (Math.abs(ro) > 1e-6) {
+        const c = Math.cos(ro), s = Math.sin(ro);
+        // rotate lat about u by ro (Rodrigues; lat is perpendicular to u)
+        const cxv = uy * lz - uz * ly, cyv = uz * lx - ux * lz, czv = ux * ly - uy * lx;
+        L.set(lx * c + cxv * s, ly * c + cyv * s, lz * c + czv * s);
+      } else L.set(lx, ly, lz);
+    }
+    for (let i = 0; i < N; i++) {
+      _v.set(this.px[i], this.py[i], this.pz[i]);
+      _v2.set(this.px[i + 1] - this.px[i], this.py[i + 1] - this.py[i], this.pz[i + 1] - this.pz[i]);
+      writeFrame(this.spine[i].matrixWorld, _v, _v2, this.lat[i]);
+    }
+    void up;
+  }
+
+  // cross-section support toward the ground for roll ro (table, linear in angle)
+  support(i, ro) {
+    const NA = this.supN;
+    let a = ((ro + Math.PI) / TAU) * NA;
+    a -= Math.floor(a / NA) * NA;
+    const k0 = Math.floor(a), k1 = (k0 + 1) % NA, t = a - k0;
+    const T = this.supTab, o = i * NA;
+    return T[o + k0] + (T[o + k1] - T[o + k0]) * t;
+  }
+
+  // a part of the body lying across another rides on top of it (anterior over posterior)
+  selfContact() {
+    const N = this.N, px = this.px, pz = this.pz, py = this.py, st = this.stack, hw = this.hw, sig = this.sig;
+    // spatial hash of the joints already processed (posterior ones), cell >= the widest contact
+    const G = this.grid, cs = 2 * this.hwMax, inv = 1 / cs;
+    G.head.fill(-1);
+    let anyHit = false;
+    const gap = 0.02 * this.TL;
+    for (let i = N; i >= 0; i--) {
+      let need = 0;
+      const cx = Math.floor(px[i] * inv), cz = Math.floor(pz[i] * inv);
+      for (let ox = -1; ox <= 1; ox++) for (let oz = -1; oz <= 1; oz++) {
+        for (let j = G.head[((cx + ox) * 73856093 ^ (cz + oz) * 19349663) & 255]; j >= 0; j = G.next[j]) {
+          if (sig[j] - sig[i] < 2.5 * (hw[i] + hw[j]) + gap) continue;
+          const D = (hw[i] + hw[j]) * 0.92;
+          const dx = px[i] - px[j], dz = pz[i] - pz[j];
+          const d2 = dx * dx + dz * dz;
+          if (d2 >= D * D) continue;
+          const q = 1 - d2 / (D * D);
+          const h = (py[j] + st[j] + (this.r[i] + hw[j]) * q * (2 - q) - py[i]) * 1.3;
+          if (h > need) need = h;
+        }
+      }
+      st[i] = need;
+      if (need > 0) anyHit = true;
+      const k = (cx * 73856093 ^ cz * 19349663) & 255;
+      G.next[i] = G.head[k]; G.head[k] = i;
+    }
+    if (!anyHit) return;
+    // ramps along the chain so the climbing part forms an arch, not a step: max-plus dilation, then
+    // a light smoothing (the requirement was padded for it)
+    const slope = 0.2;
+    for (let i = 1; i <= N; i++) st[i] = Math.max(st[i], st[i - 1] - slope * this.len[i - 1]);
+    for (let i = N - 1; i >= 0; i--) st[i] = Math.max(st[i], st[i + 1] - slope * this.len[i]);
+    const tmp = this.stackTmp;
+    for (let it = 0; it < 3; it++) {
+      for (let i = 0; i <= N; i++) tmp[i] = 0.25 * st[Math.max(0, i - 1)] + 0.5 * st[i] + 0.25 * st[Math.min(N, i + 1)];
+      for (let i = 0; i <= N; i++) st[i] = tmp[i];
+    }
+    const k = this.P.stackW;
+    for (let i = 0; i <= N; i++) st[i] *= k;
+  }
+
+  // ----------------------------------------------------------------- head, jaw, tongue, fangs
+  solveHead(dt) {
+    const P = this.P, inp = this.input;
+    const px = this.px, py = this.py, pz = this.pz;
+    const s = this.s;
+    // neck direction (segment 0) and base head orientation
+    const fx = px[0] - px[1], fy = py[0] - py[1], fz = pz[0] - pz[1];
+    const fh = h2(fx, fz);
+    const segYaw = fh > 1e-9 ? Math.atan2(fx, fz) : this.heading;
+    const segEl = Math.atan2(fy, Math.max(fh, 1e-9));
+    const moving = smooth(0.005, 0.05, this.speed / this.sq) * (this.script ? 0 : 1);
+    const stab = (this.gait ? this.gait[3] : 0.6) * moving * P.stabW;
+    let yawT = segYaw + clamp(angDiff(segYaw, this.heading), -0.8, 0.8) * stab;
+    // look target: turn the head the rest of the way
+    const look = inp.look || P.look;
+    if (look && P.lookW > 0.01) {
+      const want = Math.atan2(look.x - px[0], look.z - pz[0]);
+      yawT += clamp(angDiff(yawT, want), -0.7, 0.7) * P.lookW;
+      this.lookTarget.copy(look);
+      this.state.lookTarget = this.lookTarget;
+    } else this.state.lookTarget = null;
+    yawT += P.headYaw;
+    // elevation: level with the ground under the head when lying, level in space when raised
+    const cyaw = Math.cos(yawT), syaw = Math.sin(yawT);
+    const g0 = this.terrainH(px[0], pz[0]);
+    const gN = this.terrainH(px[0] + syaw * this.headLen, pz[0] + cyaw * this.headLen);
+    const groundEl = Math.atan2(gN - g0, this.headLen);
+    const raised = smooth(0.003 * s, 0.02 * s, py[0] - g0 - this.r[0]);
+    let elT = lerp(groundEl, lerp(segEl, 0, 0.75), raised) + P.headPitch;
+    if (look && P.lookW > 0.01) {
+      const dy = look.y - (py[0] + 0.3 * this.headLen), dd = h2(look.x - px[0], look.z - pz[0]);
+      elT += clamp(Math.atan2(dy, dd) * 0.6, -0.4, 0.5) * P.lookW * raised;
+    }
+    if (!this._headInit) { this.hYaw.reset(0); this.hPitch.reset(elT); this.hRoll.reset(0); this._headInit = true; }
+    // yaw spring works on the offset from the neck direction (no wrap-around)
+    const yawOff = this.hYaw.step(angDiff(segYaw, yawT), P.headOmega, dt);
+    const yaw = segYaw + yawOff;
+    let el = this.hPitch.step(elT, P.headOmega, dt);
+    const rollT = (P.roll[0] + P.roll[1]) * 0.5 + P.headRoll;
+    const rl = this.hRoll.step(rollT, P.headOmega, dt);
+    // head rotation (bind space faces +Z)
+    const q = this.qHead;
+    q.setFromAxisAngle(_Y, yaw);
+    _q.setFromAxisAngle(_X, -el); q.multiply(_q);
+    _q.setFromAxisAngle(_Z, rl); q.multiply(_q);
+    const ga = this.gape.step(P.gape, P.gapeOmega, dt);
+    // snout and chin (with the jaw's gape) never enter the ground: pitch up about v0 just enough
+    for (let k = 0; k < 4; k++) {
+      const b = k === 0 ? this.noseB : k === 1 ? this.chinB : this.jawMid;
+      _v.copy(b);
+      if (k === 3) _v.x = -_v.x;
+      if (k >= 1) { rotAbout(_m1, this.hingeB, _X, ga); _v.applyMatrix4(_m1); }
+      _v.sub(this.v0b).applyQuaternion(q);
+      const wy = py[0] + _v.y, floor = this.terrainH(px[0] + _v.x, pz[0] + _v.z) + (k === 0 ? 0.001 * s : 0.0003 * s);
+      if (wy < floor) {
+        const hl = h2(_v.x, _v.z) || 1e-6;
+        const add = Math.atan2(floor - wy, hl);
+        el += add;
+        q.setFromAxisAngle(_Y, yaw); _q.setFromAxisAngle(_X, -el); q.multiply(_q); _q.setFromAxisAngle(_Z, rl); q.multiply(_q);
+      }
+    }
+    if (el > this.hPitch.x) { this.hPitch.x = el; this.hPitch.v = Math.max(0, this.hPitch.v); }
+    // a rolled head (limp, dead) must not push the corners of its open jaw into the ground
+    let rr = rl;
+    for (let it = 0; it < 5 && Math.abs(rr) > 1e-3; it++) {
+      let pen = false;
+      for (let k = 0; k < 2 && !pen; k++) {
+        _v.copy(this.jawCorner).setX(k ? -this.jawCorner.x : this.jawCorner.x);
+        rotAbout(_m1, this.hingeB, _X, ga); _v.applyMatrix4(_m1);
+        _v.sub(this.v0b).applyQuaternion(q);
+        if (py[0] + _v.y < this.terrainH(px[0] + _v.x, pz[0] + _v.z)) pen = true;
+      }
+      if (!pen) break;
+      rr *= 0.6;
+      q.setFromAxisAngle(_Y, yaw); _q.setFromAxisAngle(_X, -el); q.multiply(_q); _q.setFromAxisAngle(_Z, rr); q.multiply(_q);
+    }
+    // head-rigid transform T = translate(v0 world) * R * translate(-v0 bind)
+    const T = this.Tm;
+    T.makeRotationFromQuaternion(q);
+    _v.copy(this.v0b).applyQuaternion(q);
+    T.setPosition(px[0] - _v.x, py[0] - _v.y, pz[0] - _v.z);
+    this.bHead.matrixWorld.multiplyMatrices(T, this.bindHead);
+    this.headPose.position.set(px[0], py[0], pz[0]);
+    this.headPose.quaternion.copy(q);
+    // jaw: gape about the quadrate hinge (bind X axis)
+    rotAbout(_m1, this.hingeB, _X, ga);
+    _m2.multiplyMatrices(T, _m1);
+    this.bJaw.matrixWorld.multiplyMatrices(_m2, this.bindJaw);
+    // fangs swing forward from the palate as the mouth opens (vipers)
+    const fe = this.fang.step(this.viper ? smooth(0.35, 0.9, ga / Math.max(0.3, this.cfg.strike.gape * Math.PI / 180)) * 1.75 + P.fang : 0, 18, dt);
+    rotAbout(_m1, this.fangBaseB, _X, -fe);
+    _m3.multiplyMatrices(T, _m1);
+    this.bFang.matrixWorld.multiplyMatrices(_m3, this.bindFang);
+    // tongue: slides out of its sheath (with the jaw), dips, the fork tips oscillate
+    this.solveTongue(dt, ga);
+    const tg = this.tongue;
+    _m3.makeTranslation(this.tongueDirB.x * tg.extD, this.tongueDirB.y * tg.extD, this.tongueDirB.z * tg.extD);
+    rotAbout(_m1, this.tongueBaseB, _X, tg.pitch);
+    _m3.multiply(_m1);
+    _m2.multiply(_m3); // T * jaw * tongue
+    this.bTongue.matrixWorld.multiplyMatrices(_m2, this.bindTongue);
+    rotAbout(_m1, this.tongueForkB, _X, tg.tip);
+    _m2.multiply(_m1);
+    this.bTip.matrixWorld.multiplyMatrices(_m2, this.bindTip);
+    // the flicking tips may brush the ground but never go through it: lift the whole tongue
+    const e = this.bTip.matrixWorld.elements, Lt = this.tipLen;
+    const tx = e[12] + e[4] * Lt, ty = e[13] + e[5] * Lt, tz = e[14] + e[6] * Lt;
+    const lo = Math.min(ty, e[13]) - this.terrainH(tx, tz) - 0.0008 * this.s;
+    // the lift is kept (it only relaxes slowly), so the tongue never snaps back into the ground
+    const need = lo < 0 && tg.extD > 1e-5 ? -lo : 0;
+    tg.lift = Math.max(need, (tg.lift || 0) * Math.exp(-dt * 6));
+    if (tg.lift > 0) {
+      this.bTongue.matrixWorld.elements[13] += tg.lift;
+      e[13] += tg.lift;
+    }
+  }
+
+  solveTongue(dt, gape) {
+    const tg = this.tongue, P = this.P, cfg = this.cfg.tongue;
+    const allow = P.tongue * (gape < 0.25 ? 1 : 0);
+    tg.next -= dt * (0.4 + 0.6 * P.tongueRate);
+    if (tg.dur <= 0 && tg.next <= 0 && allow > 0.5) {
+      tg.dur = 0.35 + this.rand() * 0.45;
+      tg.t = 0;
+      tg.osc = cfg.flicks[0] + this.rand() * (cfg.flicks[1] - cfg.flicks[0]);
+      tg.next = (1 / Math.max(0.05, cfg.rate)) * (0.5 + this.rand());
+    }
+    let ext = 0, tip = 0, pitch = 0;
+    const amp = cfg.amp ?? 1; // a longer tongue whips its tips farther for the same angle
+    if (tg.dur > 0) {
+      tg.t += dt;
+      const t = tg.t, d = tg.dur;
+      ext = smooth(0, 0.09, t) * (1 - smooth(d - 0.09, d, t));
+      // tips oscillate at the species' flick frequency, ramped in and out over the flick
+      const env = Math.sin(clamp((t - 0.05) / (d - 0.1), 0, 1) * Math.PI);
+      const osc = Math.sin(TAU * cfg.freq * Math.max(0, t - 0.05)) * env;
+      tip = 0.45 * amp * osc * ext;
+      pitch = (0.16 + 0.18 * amp * osc) * ext;
+      if (t >= d) tg.dur = 0;
+      if (allow < 0.5 && t < d - 0.09) tg.t = Math.max(t, d - 0.09); // cut short: retract now
+    }
+    ext = Math.max(ext, P.tongueOut);
+    // springs keep the tongue's own motion smooth whatever starts or cuts a flick
+    const w = 55;
+    tg.ext.step(ext, w, dt);
+    tg.tipS.step(tip, w, dt);
+    tg.pitchS.step(pitch + 0.25 * P.tongueOut + 0.08 * (amp < 1 ? 1 : 0) * ext, w, dt);
+    const e = clamp(tg.ext.x, 0, 1);
+    tg.extD = e * cfg.length * this.headLen;
+    tg.tip = tg.tipS.x;
+    tg.pitch = tg.pitchS.x;
+  }
+
+  // ----------------------------------------------------------------- state
+  publish() {
+    const st = this.state, N = this.N;
+    st.heading = this.heading;
+    st.speed = this.speed;
+    const moving = this.speed > 0.004 * this.sq || this.script;
+    st.gait = moving ? (this.script ? 'slither' : this.gaitName) : 'stand';
+    st.stats.gait = st.gait; st.stats.freq = this.freq || 0; st.stats.duty = 1;
+    st.action = this.layer.current();
+    st.posture = this.layer.posture;
+    for (let i = 0; i <= N; i++) {
+      const c = st.contacts[i];
+      c.contact = !!this.contact[i];
+      c.position.set(this.hx[i], this.terrainH(this.hx[i], this.hz[i]), this.hz[i]);
+    }
+    const dbg = this.debug.targets;
+    dbg[0].copy(this.leader); dbg[1].copy(this.C);
+  }
+}
+
+// rotation by angle a about an axis through point c (bind space) -> out
+function rotAbout(out, c, axis, a) {
+  _q2.setFromAxisAngle(axis, a);
+  out.makeRotationFromQuaternion(_q2);
+  _v4.copy(c).applyQuaternion(_q2);
+  out.setPosition(c.x - _v4.x, c.y - _v4.y, c.z - _v4.z);
+  return out;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Pose parameters (filled by the action layer every frame)
+// ------------------------------------------------------------------------------------------------
+function makePose(N) {
+  return {
+    lift: new Float64Array(N + 1), dyaw: new Float64Array(N), roll: new Float64Array(N + 1),
+    speedScale: 1, headYaw: 0, headPitch: 0, headRoll: 0, headOmega: 9, stabW: 1,
+    gape: 0, gapeOmega: 14, fang: 0, tongue: 1, tongueRate: 1, tongueOut: 0,
+    look: null, lookW: 1, stackW: 1,
+  };
+}
+function resetPose(P, affect) {
+  P.lift.fill(0); P.dyaw.fill(0); P.roll.fill(0); affect.fill(0);
+  P.speedScale = 1; P.headYaw = 0; P.headPitch = 0; P.headRoll = 0; P.headOmega = 9; P.stabW = 1;
+  P.gape = 0; P.gapeOmega = 14; P.fang = 0; P.tongue = 1; P.tongueRate = 1; P.tongueOut = 0;
+  P.look = null; P.lookW = 1; P.stackW = 1;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Actions
+// ------------------------------------------------------------------------------------------------
+// Postures (sit, lie, sleep, coil, death) hold until 'stand' or a move request. Coil-family postures
+// (coil = resting coil, sleep = coil + stillness, sit = alert coil with the forebody raised in an S)
+// crawl into a spiral first. One-shots (strike / attack, jump, eat, drink, hit) blend over whatever
+// runs and end by themselves. play() returns a Promise (postures: resolved once in the pose).
+class SnakeActions {
+  constructor(e) {
+    this.e = e;
+    this.postures = []; // { name, t, w, target, shapeW, reached, resolveIn, side, ... }
+    this.oneshots = [];
+    this.posture = 'stand';
+    this.standReq = null;
+    this.idle = { w: 0, t: 0, lookT: 2, look: new THREE.Vector3(), has: false, raise: 0, raiseT: 3, raiseS: new Spring(0), yawS: new Spring(0), bend: 0 };
+    this.lookS = { raise: new Spring(0), bend: new Spring(0), w: new Spring(0) };
+    this.coiled = false;
+    this._t = new THREE.Vector3();
+  }
+  holdsStill() {
+    if (this.postures.length) return true;
+    for (let i = 0; i < this.oneshots.length; i++) { const a = this.oneshots[i]; if (a.still && !a.stopping) return true; }
+    return false;
+  }
+  dead() { for (let i = 0; i < this.postures.length; i++) { const p = this.postures[i]; if (p.name === 'death' && p.target > 0) return true; } return false; }
+  // automatic stand-up (asked to move): never revives a dead snake
+  requestStand() { if (!this.standReq && !this.dead()) this.play('stand'); }
+  // arbitration: a new one-shot interrupts the running
+  // ones (fade out, the promise resolves 'interrupted'); a posture ends them (except a hit); stop()
+  // ends everything but death; dead: only hit is taken. Promises resolve 'done' | 'interrupted' |
+  // 'stopped' | 'refused'.
+  end(a, reason) { if (a.stopping) return; a.stopping = true; a.reason = reason; }
+  current() {
+    for (let i = 0; i < this.oneshots.length; i++) if (!this.oneshots[i].stopping) return this.oneshots[i].name;
+    for (let i = 0; i < this.postures.length; i++) if (this.postures[i].target > 0) return this.postures[i].name;
+    return this.standReq ? 'stand' : null;
+  }
+  clear() {
+    for (const a of [...this.postures, ...this.oneshots]) { a.resolveIn?.('stopped'); a.resolve?.('stopped'); }
+    this.postures.length = 0; this.oneshots.length = 0;
+    if (this.standReq) { this.standReq.resolve('stopped'); this.standReq = null; }
+  }
+
+  play(name, opts = {}) {
+    const e = this.e;
+    if (name === 'idle') name = 'stand';
+    if (name === 'attack') name = 'strike';
+    if (name === 'stand') {
+      if (!this.postures.some((p) => p.target > 0) && !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.includes(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;
+      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.end(a, 'interrupted');
+      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, side, opts, reached: false, baked: false, phase0: e.rand() * TAU };
+      inst.promiseIn = new Promise((r) => { inst.resolveIn = r; });
+      if (COILED[name]) {
+        // already lying in a coil (the body winds through more than ~300 degrees): stay put
+        const wound = Math.abs(e.byawU[0] - e.byawU[e.N - 1]) > 1.7 * Math.PI;
+        if (!this.coiled && !wound) this.startCoil(inst);
+        else { inst.coilDone = true; this.coiled = true; }
+      }
+      this.postures.push(inst);
+      e.emit('actionStart', { name });
+      if (name === 'death') e.emit('death', { position: e.pos.clone() });
+      return inst.promiseIn;
+    }
+    const def = ONESHOTS[name];
+    if (!def) return Promise.reject(new Error(`procedural-animals: unknown action "${name}"`));
+    if (this.dead() && name !== 'hit') return Promise.resolve('refused');
+    if (this.postures.some((p) => p.target > 0) && (name === 'jump' || name === 'strike') && !this.postures.some((p) => p.name === 'sit' && p.target > 0)) {
+      return this.play('stand').then((r) => (r === 'refused' ? r : this.play(name, opts)));
+    }
+    // a new one-shot interrupts the running ones (they fade out, their promises resolve)
+    for (const a of this.oneshots) this.end(a, 'interrupted');
+    const inst = { name, t: 0, w: 0, dur: 1, stopping: false, opts, fade: 0.15, still: false, side: e.rand() < 0.5 ? -1 : 1 };
+    def.start(inst, this);
+    inst.promise = new Promise((r) => { inst.resolve = r; });
+    this.oneshots.push(inst);
+    e.emit('actionStart', { name });
+    return inst.promise;
+  }
+
+  stop(name) {
+    if (name === 'attack') name = 'strike';
+    for (const a of this.oneshots) if (!name || a.name === name) this.end(a, 'stopped');
+    if (!name || POSTURES.includes(name)) if (this.postures.some((p) => p.target > 0 && (name ? p.name === name : p.name !== 'death'))) this.play('stand');
+  }
+
+  startCoil(inst) {
+    const e = this.e, tune = e.cfg.actions.coil || {};
+    // a real resting coil is not a machined spiral: the ring spacing is a little tighter than the body
+    // (inner turns ride up onto the outer ones), the curvature wanders (seeded), the centre is small
+    // and the whole body, tail tip included, ends up in the coil
+    const pitch = 2 * e.hwMax * (tune.pitch ?? 0.88);
+    const rin = Math.max(0.022 * e.TL, 1.8 * e.hw[0] + 0.008 * e.s);
+    const total = e.bodyLen * 1.08;
+    const dir = inst.side;
+    const f1 = 0.16 * e.TL * (0.8 + 0.4 * e.rand()), f2 = 0.07 * e.TL * (0.8 + 0.4 * e.rand()), p1 = e.rand() * TAU, p2 = e.rand() * TAU;
+    const sc = {
+      total, speed: (tune.speed ?? 0.34) * e.sq,
+      kappa: (u) => (dir * (1 + 0.13 * Math.sin((TAU * u) / f1 + p1) + 0.06 * Math.sin((TAU * u) / f2 + p2))) / Math.sqrt(rin * rin + (pitch * Math.max(0, total - u)) / Math.PI),
+      done: false,
+    };
+    e.startScript(sc);
+    inst.script = sc;
+    this.coiled = true;
+  }
+
+  update(dt) {
+    const e = this.e, P = e.P, N = e.N;
+    resetPose(P, e.affect);
+    // ---- postures
+    for (const p of this.postures) {
+      p.t += dt;
+      const coilWait = p.script && !p.script.done;
+      if (p.target > 0) p.w = Math.min(1, p.w + dt / (p.name === 'death' ? 0.2 : 0.8));
+      else p.w = Math.max(0, p.w - dt / (p.name === 'death' ? 1.0 : 0.7));
+      if (!p.reached && p.target > 0 && p.w >= 1 && !coilWait && p.t > (p.name === 'death' ? 1.8 : p.name === 'lie' ? 1.6 : 0.6)) {
+        p.reached = true; p.resolveIn('done'); e.emit('actionEnd', { name: p.name });
+      }
+      // leaving the posture: once lifts and rolls are gone, bake the body shape into the trail
+      if (p.target === 0 && p.w <= 0 && !p.baked) {
+        if (p.script && !p.script.done) { e.script = null; e.reseed = true; }
+        p.baked = true;
+        p.bakeNow = true;
+      }
+    }
+    // any posture that changed the shape (death, lie) is baked when it ends
+    let bake = false;
+    for (let i = 0; i < this.postures.length; i++) { const p = this.postures[i]; if (p.bakeNow && (p.name === 'death' || p.name === 'lie')) bake = true; }
+    if (bake) this.coiled = false; // the body shape changed (death, lie)
+    compact(this.postures, notBaked);
+    if (bake) this.bake();
+    let active = null;
+    for (let i = 0; i < this.postures.length; i++) if (this.postures[i].target > 0) { active = this.postures[i]; break; }
+    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' }); }
+    if (!active && e.speed > 0.01) this.coiled = false;
+
+    // ---- idle and look-at
+    const still = e.speed < 0.01 * e.sq && !e.input.follow && !e.script;
+    let busy = false;
+    for (let i = 0; i < this.oneshots.length; i++) if (!this.oneshots[i].stopping) busy = true;
+    const idleT = still && !this.postures.length && !busy ? 1 : 0;
+    const id = this.idle;
+    id.w += clamp(idleT - id.w, -dt * 1.5, dt * 0.6);
+    this.applyIdle(dt, id.w);
+    this.applyLook(dt);
+    // rattlesnakes carry the rattle just off the ground while they travel
+    if (e.cfg.tailCarry > 0) {
+      this.carry = (this.carry || 0) + (smooth(0.003, 0.03, e.speed / e.sq) * (this.postures.length ? 0 : 1) - (this.carry || 0)) * (1 - Math.exp(-dt * 3));
+      if (this.carry > 1e-3) {
+        const Lt = 0.07 * e.TL;
+        for (let i = e.N; i >= 0 && e.bodyLen - e.sig[i] < Lt; i--) {
+          const q = 1 - (e.bodyLen - e.sig[i]) / Lt;
+          P.lift[i] += this.carry * e.cfg.tailCarry * q * q;
+          e.affect[i] += this.carry * q;
+        }
+      }
+    }
+    // ---- postures
+    for (const p of this.postures) {
+      const w = p.w * p.w * (3 - 2 * p.w);
+      if (w <= 0) continue;
+      POSES[p.name](P, w, p, this, dt);
+    }
+    // ---- one-shots
+    const wantsToMove = e.wantSpeed > 0.01 || !!e.input.follow;
+    for (const a of this.oneshots) {
+      if (wantsToMove && (a.name === 'eat' || a.name === 'drink')) this.end(a, 'interrupted');
+      a.t += dt;
+      const def = ONESHOTS[a.name];
+      if (!a.stopping && def.update(a, dt, this)) this.end(a, 'done');
+      if (a.stopping) a.w = Math.max(0, a.w - dt / a.fade);
+      else a.w = Math.min(1, a.w + dt / a.fade);
+      const w = a.w * a.w * (3 - 2 * a.w);
+      if (w > 0) def.apply(P, w, a, this);
+    }
+    for (const a of this.oneshots) if (a.stopping && a.w <= 0) { a.resolve(a.reason || 'done'); e.emit('actionEnd', { name: a.name, reason: a.reason || 'done' }); }
+    compact(this.oneshots, stillRunning);
+    // the neck never kinks: cap the per-segment yaw change of the posed body
+    void N;
+  }
+
+  // the current body shape becomes the trail (the snake then crawls off along its own body)
+  bake() {
+    const e = this.e, N = e.N, tr = e.trail;
+    // current ground points, tail -> head, parameterised by the rest arc lengths
+    const sl = tr.lastS;
+    const tail = tr.lastS - e.sig[N];
+    // keep the trail behind the tail: extend straight from the posed tail
+    const tx = e.hx[N] - e.hx[N - 1], tz = e.hz[N] - e.hz[N - 1], tl = h2(tx, tz) || 1;
+    tr.clear();
+    const ext = 0.2 * e.TL;
+    for (let k = 4; k >= 1; k--) {
+      const d = (ext * k) / 4, x = e.hx[N] + (tx / tl) * d, z = e.hz[N] + (tz / tl) * d;
+      tr.push(x, e.terrainH(x, z), z, tail - d);
+    }
+    for (let i = N; i >= 0; i--) tr.push(e.hx[i], e.terrainH(e.hx[i], e.hz[i]), e.hz[i], sl - e.sig[i]);
+    e.reseed = true;
+    e.leader.set(e.hx[0], e.terrainH(e.hx[0], e.hz[0]), e.hz[0]);
+    e.C.copy(e.leader); e.pos.copy(e.C);
+  }
+
+  applyIdle(dt, w) {
+    const e = this.e, P = e.P, id = this.idle, t = e.time, s = e.s;
+    if (w <= 0.001) { id.has = false; id.raiseS.step(0, 3, dt); id.yawS.step(0, 3, dt); return; }
+    id.t += dt;
+    // gentle head sway and breathing (a slow roll of the trunk)
+    P.headYaw += w * (0.05 * Math.sin(t * 0.7) + 0.03 * Math.sin(t * 1.9 + 1));
+    P.headPitch += w * 0.03 * Math.sin(t * 0.43 + 2);
+    const br = e.cfg.breath;
+    const b = Math.sin(t * TAU * br.rate) * br.roll * w;
+    for (let i = 0; i <= e.N; i++) { const q = e.sig[i] / e.bodyLen; P.roll[i] += b * smooth(0.1, 0.3, q) * (1 - smooth(0.6, 0.85, q)); }
+    // now and then: raise the head and look about
+    id.raiseT -= dt;
+    if (id.raiseT <= 0) {
+      id.raiseT = 2.5 + e.rand() * 4;
+      id.raise = e.rand() < 0.45 ? 0.02 + e.rand() * 0.035 : 0;
+      id.bend = (e.rand() - 0.5) * 1.1;
+    }
+    const rz = id.raiseS.step(id.raise * w, 1.6, dt), bd = id.yawS.step(id.bend * (id.raise > 0 ? 1 : 0.3) * w, 1.4, dt);
+    if (!e.input.look) this.raiseNeck(P, rz * e.TL, bd, e.cfg.body.neck * e.TL * 1.4, 1);
+    void s;
+  }
+
+  // raise the forebody to height h (m) over arc length Ln, and bend the neck by yaw b (rad)
+  raiseNeck(P, h, b, Ln, w) {
+    const e = this.e, N = e.N;
+    Ln = Math.max(Ln, 2.3 * Math.abs(h));
+    for (let i = 0; i <= N; i++) {
+      const sg = e.sig[i];
+      if (sg > Ln) break;
+      const q = sg / Ln; // 0 head .. 1 base of the raised part
+      // the neck rises straight up to the head and flattens into the ground at its base
+      const f = Math.pow(1 - q, 1.7);
+      P.lift[i] += w * h * f;
+      if (i < N) {
+        const qm = (sg + e.len[i] * 0.5) / Ln;
+        P.dyaw[i] += w * b * (1 - smooth(0, 1, qm));
+      }
+      e.affect[i] += w * f;
+    }
+  }
+
+  applyLook(dt) {
+    const e = this.e, P = e.P, L = this.lookS;
+    const look = e.input.look;
+    let posed = false;
+    for (let i = 0; i < this.postures.length; i++) { const p = this.postures[i]; if (p.target > 0 && (p.name === 'death' || p.name === 'sleep')) posed = true; }
+    for (let i = 0; i < this.oneshots.length; i++) { const a = this.oneshots[i]; if (!a.stopping && (a.name === 'strike' || a.name === 'eat' || a.name === 'jump')) posed = true; }
+    let raise = 0, bend = 0, wT = 0;
+    if (look && !posed) {
+      wT = 1;
+      const hx = e.hx[0], hz = e.hz[0];
+      const to = Math.atan2(look.x - hx, look.z - hz);
+      bend = clamp(angDiff(e.byaw[0], to), -1.5, 1.5) * (e.speed > 0.02 ? 0.3 : 1);
+      const d = h2(look.x - hx, look.z - hz);
+      const dy = look.y - e.terrainH(hx, hz);
+      raise = clamp(0.03 * e.TL + Math.max(0, dy) * 0.25 + 0.04 * e.TL * smooth(3, 0.5, d / e.TL), 0.02 * e.TL, 0.14 * e.TL) * (e.speed > 0.02 ? 0.3 : 1);
+    }
+    const w = L.w.step(wT, 3, dt);
+    const r = L.raise.step(raise, 2.5, dt), b = L.bend.step(bend, 2.5, dt);
+    if (w > 0.001) this.raiseNeck(P, r, b, e.cfg.body.neck * e.TL * (1.2 + Math.abs(b) * 0.6), w);
+  }
+}
+
+// ---------------------------------------------------------------- forebody shapes (strike family)
+// S-coil in the horizontal plane, raised at the front; extension e (0..1) straightens it toward the
+// target. Writes yaw offsets and lifts with weight w.
+function strikeShape(P, a, L, w, e, beta, hS, aimYaw, aimLift, curl) {
+  const E = L.e, N = E.N;
+  const Ls = a.Ls, ia = a.ia;
+  const baseA = E.byawU[Math.min(N - 1, ia)];
+  for (let i = 0; i < N && E.sig[i] <= Ls; i++) {
+    const q = (E.sig[i] + E.len[i] * 0.5) / Ls; // 0 head .. 1 anchor
+    const envS = Math.sin(Math.PI * Math.min(1, q * 1.05));
+    // S-coil yaw about the aim direction (two bends), aim ramp near the anchor
+    const aimRamp = 1 - smooth(0.55, 1, q);
+    const ySx = aimYaw * aimRamp + beta * Math.sin(TAU * q * curl) * envS;
+    const yE = aimYaw * (1 - smooth(0.55, 1, q));
+    const yaw = baseA + lerp(ySx, yE, e);
+    // hand over to the body's own curvature toward the anchor (no curvature step there)
+    P.dyaw[i] += w * (yaw - E.byawU[i]) * (1 - smooth(0.5, 1, q));
+  }
+  for (let i = 0; i <= N && E.sig[i] <= Ls; i++) {
+    const q = E.sig[i] / Ls;
+    const lS = hS * Math.pow(1 - smooth(0, 1, q), 1.2);
+    const lE = aimLift * (1 - smooth(0.05, 1, q));
+    P.lift[i] += w * lerp(lS, lE, e);
+    E.affect[i] += w * (1 - smooth(0.85, 1, q));
+  }
+}
+
+function setupStrike(a, L, target, reachK) {
+  const E = L.e, N = E.N;
+  const t = target || L._t.set(E.hx[0] + Math.sin(E.byaw[0]) * 0.3 * E.TL, E.terrainH(E.hx[0], E.hz[0]) + 0.02 * E.TL, E.hz[0] + Math.cos(E.byaw[0]) * 0.3 * E.TL);
+  a.target = new THREE.Vector3().copy(t);
+  const maxL = reachK * E.TL;
+  // forebody length: enough to reach the target from the anchor, within limits
+  let Ls = maxL;
+  for (let it = 0; it < 3; it++) {
+    let ia = 0; while (ia < N && E.sig[ia] < Ls) ia++;
+    const d = h2(a.target.x - E.hx[ia], a.target.z - E.hz[ia]);
+    Ls = clamp(d * 1.04, 0.14 * E.TL, maxL);
+  }
+  let ia = 0; while (ia < N && E.sig[ia] < Ls) ia++;
+  a.Ls = E.sig[ia]; a.ia = ia;
+  const ax = E.hx[ia], az = E.hz[ia];
+  const to = Math.atan2(a.target.x - ax, a.target.z - az);
+  a.aimYaw = clamp(angDiff(E.byaw[Math.min(N - 1, ia)], to), -1.2, 1.2);
+  const dh = h2(a.target.x - ax, a.target.z - az);
+  const gy = E.terrainH(a.target.x, a.target.z);
+  a.aimLift = clamp(a.target.y - gy - E.r[0], 0, 0.6 * a.Ls) * smooth(0, 1, a.Ls / Math.max(dh, 1e-3));
+}
+
+const ONESHOTS = {
+  // S-coil, strike at the target with the jaw wide open (attackHit), retract, relax
+  strike: {
+    start(a, L) {
+      const E = L.e, st = E.cfg.strike;
+      setupStrike(a, L, a.opts.target, st.reach);
+      a.still = true;
+      a.T = { cock: 0.5, hold: 0.62, hit: 0.62 + clamp(a.Ls / (st.speed * E.sq * 0.9), 0.14, 0.22) };
+      a.T.stay = a.T.hit + 0.14; a.T.back = a.T.stay + 0.32; a.T.end = a.T.back + 0.6;
+      a.dur = a.T.end;
+      a.fade = 0.2;
+      a.hitDone = false;
+    },
+    update(a, dt, L) {
+      const E = L.e, T = a.T;
+      if (!a.hitDone && a.t >= T.hit) {
+        a.hitDone = true;
+        _v.set(0, 0, 0);
+        const m = E.attachmentPoints.mouth;
+        const pos = new THREE.Vector3();
+        if (m) pos.setFromMatrixPosition(_m1.multiplyMatrices(E.bHead.matrixWorld, m.local)); else pos.set(E.px[0], E.py[0], E.pz[0]);
+        const dir = new THREE.Vector3(0, 0, 1).applyQuaternion(E.qHead);
+        E.emit('attackHit', { position: pos, direction: dir, style: 'strike', target: a.target.clone() });
+      }
+      return a.t >= a.dur;
+    },
+    apply(P, w, a, L) {
+      const E = L.e, T = a.T, t = a.t, st = E.cfg.strike;
+      const cock = smooth(0, T.cock, t) * (1 - smooth(T.back, T.end, t));
+      const ext = smootherstep(T.hold, T.hit, t) * (1 - smootherstep(T.stay, T.back, t));
+      const hS = st.coilHeight * E.TL;
+      strikeShape(P, a, L, w * cock, ext, 1.25, hS, a.aimYaw, a.aimLift, 1);
+      P.speedScale *= 1 - w;
+      const openT = smooth(0.45, 0.85, ext);
+      P.gape += w * openT * st.gape * Math.PI / 180;
+      P.gapeOmega = Math.max(P.gapeOmega, 40);
+      P.headPitch += w * (0.12 * cock * (1 - ext) + 0.25 * openT);
+      P.headOmega = Math.max(P.headOmega, lerp(9, 40, w * ext));
+      P.stabW *= 1 - w;
+      P.tongue *= 1 - w * cock;
+      P.lookW *= 1 - w;
+      P.stackW *= 1 - w;
+    },
+  },
+  // a forward lunge (snakes do not jump): a flat, closed-mouth strike straight ahead
+  jump: {
+    start(a, L) {
+      const E = L.e;
+      const h = E.byaw[0];
+      a.opts.target = new THREE.Vector3(E.hx[0] + Math.sin(h) * 0.22 * E.TL, E.terrainH(E.hx[0], E.hz[0]) + 0.03 * E.TL, E.hz[0] + Math.cos(h) * 0.22 * E.TL);
+      setupStrike(a, L, a.opts.target, 0.26);
+      a.still = true;
+      a.T = { cock: 0.4, hold: 0.45, hit: 0.7, stay: 0.8, back: 1.15, end: 1.6 };
+      a.dur = a.T.end; a.fade = 0.2;
+    },
+    update(a) { return a.t >= a.dur; },
+    apply(P, w, a, L) {
+      const E = L.e, T = a.T, t = a.t;
+      const cock = smooth(0, T.cock, t) * (1 - smooth(T.back, T.end, t));
+      const ext = smootherstep(T.hold, T.hit, t) * (1 - smootherstep(T.stay, T.back, t));
+      strikeShape(P, a, L, w * cock, ext, 0.5, 0.03 * E.TL, a.aimYaw, a.aimLift, 1);
+      P.speedScale *= 1 - w;
+      P.headPitch += w * 0.05 * cock;
+      P.headOmega = Math.max(P.headOmega, lerp(9, 30, w * ext));
+      P.stabW *= 1 - w; P.lookW *= 1 - w; P.tongue *= 1 - w * cock; P.stackW *= 1 - w;
+    },
+  },
+  // strike at prey on the ground ahead, then swallow: jaws walk left and right, the neck works
+  eat: {
+    start(a, L) {
+      const E = L.e, h = E.byaw[0];
+      a.opts.target = a.opts.target || new THREE.Vector3(E.hx[0] + Math.sin(h) * 0.12 * E.TL, 0, E.hz[0] + Math.cos(h) * 0.12 * E.TL);
+      a.opts.target.y = E.terrainH(a.opts.target.x, a.opts.target.z) + 0.005 * E.s;
+      setupStrike(a, L, a.opts.target, 0.22);
+      a.still = true;
+      const sw = E.cfg.actions.eat?.swallow ?? 3.2;
+      a.T = { cock: 0.35, hold: 0.4, hit: 0.62, stay: 0.9, back: 1.3, swallow: 1.3 + sw, yawn: 1.3 + sw + 0.7 };
+      a.dur = a.T.yawn + 0.3; a.fade = 0.25;
+    },
+    update(a) { return a.t >= a.dur; },
+    apply(P, w, a, L) {
+      const E = L.e, T = a.T, t = a.t;
+      const cock = smooth(0, T.cock, t) * (1 - smooth(T.stay, T.back, t));
+      const ext = smootherstep(T.hold, T.hit, t) * (1 - smootherstep(T.stay, T.back, t));
+      strikeShape(P, a, L, w * cock, ext, 0.3, 0.025 * E.TL, a.aimYaw, 0, 1);
+      P.gape += w * smooth(0.3, 0.8, ext) * 0.7;
+      P.gapeOmega = Math.max(P.gapeOmega, 25);
+      // swallowing: alternate jaw walks, a pulse down the neck
+      const sw = smooth(T.back - 0.2, T.back + 0.3, t) * (1 - smooth(T.swallow - 0.3, T.swallow, t));
+      const ph = (t - T.back) * TAU * 0.7;
+      P.headYaw += w * sw * 0.14 * Math.sin(ph);
+      P.headRoll += w * sw * 0.1 * Math.sin(ph);
+      P.gape += w * sw * (0.25 + 0.15 * Math.sin(ph * 2));
+      P.headPitch += w * sw * 0.06 * Math.sin(ph + 1);
+      const pulse = ((t - T.back) * 0.12 * E.TL) % (0.2 * E.TL);
+      for (let i = 0; i <= E.N && E.sig[i] < 0.25 * E.TL; i++) {
+        const d = (E.sig[i] - pulse) / (0.03 * E.TL);
+        P.lift[i] += w * sw * 0.004 * E.s * Math.exp(-d * d);
+      }
+      // yawn to reset the jaws
+      const yw = smooth(T.swallow, T.swallow + 0.3, t) * (1 - smooth(T.yawn - 0.3, T.yawn, t));
+      P.gape += w * yw * 1.1;
+      P.headPitch += w * yw * 0.25;
+      P.speedScale *= 1 - w; P.stabW *= 1 - w; P.lookW *= 1 - w; P.tongue *= 1 - w; void yw;
+    },
+  },
+  // head down, snout to the ground / water surface, buccal pumping
+  drink: {
+    start(a, L) { a.still = true; a.dur = 1.0 + (L.e.cfg.actions.drink?.pumps ?? 4) * 0.8; a.fade = 0.4; },
+    update(a) { return a.t >= a.dur; },
+    apply(P, w, a, L) {
+      const t = a.t;
+      const down = smooth(0, 0.6, t);
+      P.headPitch -= w * down * 0.35;
+      const pump = Math.max(0, Math.sin((t - 0.6) * TAU * 1.25)) * smooth(0.6, 0.9, t);
+      P.gape += w * down * (0.03 + 0.06 * pump);
+      P.gapeOmega = Math.max(P.gapeOmega, 20);
+      P.tongue *= 1 - w * down;
+      P.speedScale *= 1 - w; P.lookW *= 1 - w; P.stabW *= 1 - w;
+    },
+  },
+  // flinch into a curve away from the blow, head withdrawn, tail whipping, then settle back
+  hit: {
+    start(a, L) {
+      const E = L.e;
+      const d = a.opts.direction;
+      if (d) a.side = d.x * Math.cos(E.heading) - d.z * Math.sin(E.heading) > 0 ? 1 : -1;
+      a.dur = 1.4; a.fade = 0.2;
+    },
+    update(a) { return a.t >= a.dur; },
+    apply(P, w, a, L) {
+      const E = L.e, t = a.t, N = E.N;
+      const k = smootherstep(0, 0.3, t) * (1 - smootherstep(0.45, 1.35, t));
+      const ov = 0;
+      for (let i = 0; i < N; i++) {
+        const q = (E.sig[i] + E.len[i] * 0.5) / E.bodyLen;
+        // C-bend: forebody swings with the blow, the tail whips the other way
+        const prof = 1.0 * (1 - smooth(0, 0.45, q)) - 0.55 * smooth(0.55, 1, q);
+        P.dyaw[i] += w * a.side * (k * 0.75 + 0.2 * ov) * prof;
+      }
+      for (let i = 0; i <= N; i++) E.affect[i] += w * k;
+      L.raiseNeck(P, 0.035 * E.TL * k, -a.side * 0.3 * k, 0.12 * E.TL, w);
+      P.headYaw += w * a.side * 0.35 * k;
+      P.gape += w * k * (E.viper ? 0.45 : 0.2);
+      P.speedScale *= 1 - w * k;
+      P.lookW *= 1 - w * k;
+      P.stackW *= 1 - w * k;
+      if (E.cfg.rattle) rattle(P, E, w * smooth(0, 0.3, t), t);
+    },
+  },
+};
+
+const notBaked = (p) => !p.baked;
+const stillRunning = (a) => !(a.stopping && a.w <= 0);
+function compact(arr, keep) {
+  let j = 0;
+  for (let i = 0; i < arr.length; i++) if (keep(arr[i])) arr[j++] = arr[i];
+  arr.length = j;
+}
+
+function smootherstep(a, b, x) {
+  const t = clamp((x - a) / (b - a), 0, 1);
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+
+// tail tip raised and buzzing (rattlesnake)
+function rattle(P, E, w, t) {
+  if (w <= 0) return;
+  const N = E.N, Lt = 0.11 * E.TL;
+  const buzz = Math.sin(t * TAU * 27);
+  for (let i = N; i >= 0 && E.bodyLen - E.sig[i] < Lt; i--) {
+    const q = 1 - (E.bodyLen - E.sig[i]) / Lt; // 0 .. 1 at the tip
+    P.lift[i] += w * 0.036 * E.TL * q * q;
+    E.affect[i] += w * q;
+    if (i < N) P.dyaw[i] += w * 0.03 * buzz * smooth(0.5, 1, q);
+  }
+}
+
+// ---------------------------------------------------------------- posture poses
+const POSES = {
+  coil(P, w, p, L) {
+    const E = L.e;
+    P.speedScale *= 1 - w;
+    P.tongueRate *= 1 - 0.4 * w;
+    // once coiled, the neck swings out over the inner ring and the head rests on top of the coils
+    const done = p.coilDone || (p.script && p.script.done);
+    if (done) {
+      if (p.restT === undefined) p.restT = p.t;
+      const k = w * smooth(0, 1.2, p.t - p.restT);
+      L.raiseNeck(P, 1.5 * E.hwMax * k, -p.side * 0.75 * k, 0.14 * E.TL, 1);
+      P.headPitch += k * 0.06;
+    }
+  },
+  sleep(P, w, p, L) {
+    POSES.coil(P, w, p, L);
+    const c = w * smooth(0.5, 2.5, p.t);
+    P.tongue *= 1 - c; P.lookW *= 1 - c; P.stabW *= 1 - c;
+    P.headPitch += c * 0.04;
+    P.headOmega = Math.min(P.headOmega, 4);
+  },
+  // alert / defensive coil: the forebody rises in an S facing the look target (rattlesnakes rattle)
+  sit(P, w, p, L) {
+    const E = L.e;
+    POSES.coil(P, w, p, L);
+    const up = w * (p.script ? smooth(0.6, 1, p.script.u / p.script.total) : 1);
+    if (up <= 0) return;
+    if (!p.S) p.S = { Ls: 0, ia: 0, aimYaw: 0, aimLift: 0 };
+    const S = p.S;
+    const Lf = (E.cfg.actions.sit?.raise ?? 0.1) * E.TL * 2.6;
+    let ia = 0; while (ia < E.N && E.sig[ia] < Lf) ia++;
+    S.Ls = E.sig[ia]; S.ia = ia; S.aimYaw = 0; S.aimLift = 0;
+    const look = E.input.look;
+    if (look) S.aimYaw = clamp(angDiff(E.byaw[Math.min(E.N - 1, ia)], Math.atan2(look.x - E.hx[ia], look.z - E.hz[ia])), -1.2, 1.2) * 0.6;
+    strikeShape(P, S, L, up, 0, 0.9, (E.cfg.actions.sit?.raise ?? 0.1) * E.TL, S.aimYaw, 0, 1);
+    P.stackW *= 1 - up;
+    P.tongueRate += up * 1.5;
+    if (E.cfg.rattle) rattle(P, E, up * smooth(0.5, 1.5, p.t), E.time);
+  },
+  // stretched out: the wave relaxes toward the body's mean line, head down
+  lie(P, w, p, L) {
+    const E = L.e, N = E.N;
+    P.speedScale *= 1 - w;
+    const k = w * smooth(0, 1.4, p.t) * 0.8;
+    const win = 0.18 * E.TL;
+    // mean line: yaw averaged over a window along the body (unwrapped relative to the local yaw)
+    for (let i = 0; i < N; i++) {
+      let sum = 0, n = 0;
+      for (let j = 0; j < N; j++) {
+        if (Math.abs(E.sig[j] - E.sig[i]) > win) continue;
+        sum += angDiff(E.byaw[i], E.byaw[j]); n++;
+      }
+      P.dyaw[i] += k * (sum / Math.max(1, n));
+      E.affect[i] += k;
+    }
+    E.affect[N] += k;
+    P.headPitch -= w * 0.02;
+    P.tongueRate *= 1 - 0.5 * w;
+  },
+  // writhe, go limp and roll half onto the back; stays down until 'stand'
+  death(P, w, p, L) {
+    const E = L.e, N = E.N, t = p.t;
+    P.speedScale = 0;
+    const writhe = 0.55 * smooth(0, 0.12, t) * Math.exp(-t / 0.55);
+    const slack = 0.32 * smooth(0.2, 1.4, t);
+    const rollK = smooth(0.35, 1.3, t);
+    const lam = 0.36 * E.TL;
+    for (let i = 0; i < N; i++) {
+      const sg = E.sig[i] + E.len[i] * 0.5;
+      const q = sg / E.bodyLen;
+      const env = smooth(0, 0.08, q) * (1 - 0.75 * smooth(0.78, 1, q));
+      const wv = writhe * Math.sin(TAU * (sg / lam - 1.7 * t) + p.phase0) + slack * Math.sin(TAU * sg / (0.55 * E.TL) + p.phase0 * 1.7) * 0.8;
+      P.dyaw[i] += w * wv * env;
+    }
+    for (let i = 0; i <= N; i++) {
+      const q = E.sig[i] / E.bodyLen;
+      E.affect[i] += w;
+      // only parts turn belly-up: neck upright, mid-body over ~160 deg, a second partial twist behind
+      const c1 = 0.4 + 0.1 * Math.sin(p.phase0), c2 = 0.76 + 0.06 * Math.cos(p.phase0 * 1.3);
+      const prof = 2.8 * Math.exp(-(((q - c1) / 0.15) ** 2)) + 1.05 * Math.exp(-(((q - c2) / 0.09) ** 2));
+      P.roll[i] += w * p.side * rollK * prof;
+    }
+    P.gape += w * 0.2 * smooth(0.4, 1.2, t);
+    P.gapeOmega = 6;
+    P.tongueOut += w * 0.45 * smooth(0.8, 1.6, t);
+    P.tongue = 0;
+    P.headRoll += w * p.side * 0.6 * rollK;
+    P.headOmega = lerp(P.headOmega, 5, w);
+    P.lookW = 0; P.stabW = 0; P.stackW *= 1 - w;
+  },
+};