@heyramzi/ui 2.11.0 → 2.11.2

package/dist/agents/vendor/engine.js

@@ -1,632 +1,731 @@
 export const STATES = [
-    "default",
-    "working",
-    "sleeping"
+	"default",
+	"working",
+	"sleeping"
 ];
-const HOP_T = 0.68;
+/* the working state's hop: its period, and the height of the spinning one */
+const HOP_T = .68;
 const HOP_SPIN_H = 26;
-const FLIP_PRE = 0.2;
-const FLIP_POST = 0.66;
+/* a flip is that spinning hop on its own: a crouch before it (the squash
+that, in the working state, the previous landing leaves), the hop, and
+the landing's recovery after — measured in hop periods */
+const FLIP_PRE = .2;
+const FLIP_POST = .66;
 export const JUMP_DEFAULTS = {
-    height: HOP_SPIN_H,
-    time: HOP_T,
-    stretch: 1,
-    squash: 1.15,
-    squashTime: 0.37,
-    squashEase: "pulse",
-    groundTime: 0.11,
-    groundEase: "pulse",
-    riseTime: 0.33,
-    riseEase: "pulse",
-    clickSquashTime: 0.24,
-    spin: 1,
-    lean: 6,
-    every: 8,
-    land: 0
+	height: HOP_SPIN_H,
+	time: HOP_T,
+	stretch: 1,
+	squash: 1.15,
+	squashTime: .37,
+	squashEase: "pulse",
+	groundTime: .11,
+	groundEase: "pulse",
+	riseTime: .33,
+	riseEase: "pulse",
+	clickSquashTime: .24,
+	spin: 1,
+	lean: 6,
+	every: 8,
+	land: 0
 };
-const flipPre = (j, poked)=>poked ? j.clickSquashTime : FLIP_PRE * j.time;
-const flipDuration = (j, poked)=>flipPre(j, poked) + j.time + SQUASH_PEAK[j.squashEase] * (poked ? j.clickSquashTime : j.squashTime) + Math.max(0, j.groundTime) + j.riseTime + Math.max(0, j.land) + 0.05;
+/* a click's jump crouches for its squash time before take-off and lands
+with a squash of the same length; an idle jump's crouch is the working
+hop's short one */
+const flipPre = (j, poked) => poked ? j.clickSquashTime : FLIP_PRE * j.time;
+const flipDuration = (j, poked) => flipPre(j, poked) + j.time + SQUASH_PEAK[j.squashEase] * (poked ? j.clickSquashTime : j.squashTime) + Math.max(0, j.groundTime) + j.riseTime + Math.max(0, j.land) + .05;
+/* where in its time each easing reaches the deepest squash */
 const SQUASH_PEAK = {
-    sharp: 0,
-    pulse: 2 / 7,
-    soft: 0.5,
-    bouncy: 0.144
+	sharp: 0,
+	pulse: 2 / 7,
+	soft: .5,
+	bouncy: .144
 };
-const risePulse = (v, ease)=>{
-    if (v <= 0) return 1;
-    if (v >= 1) return 0;
-    switch(ease){
-        case "sharp":
-            return (1 - v) * (1 - v);
-        case "soft":
-            return 0.5 + 0.5 * Math.cos(Math.PI * v);
-        case "bouncy":
-            return Math.exp(-3.2 * v) * Math.cos(5.4 * v) - v * v * v * 0.026;
-        default:
-            {
-                const k = 4.2 * v;
-                return (1 + k) * Math.exp(-k) - v * v * v * 0.078;
-            }
-    }
+/* the rise: how the body comes back from its deepest squash to its own
+shape, 1 → 0 over the rise time. `sharp` lets go at once and eases in
+to rest, `pulse` leaves quickly with a long settle, `soft` eases out of
+the squash and into rest, `bouncy` passes rest into a slight stretch
+and settles back. */
+const risePulse = (v, ease) => {
+	if (v <= 0) return 1;
+	if (v >= 1) return 0;
+	switch (ease) {
+		case "sharp": return (1 - v) * (1 - v);
+		case "soft": return .5 + .5 * Math.cos(Math.PI * v);
+		case "bouncy": return Math.exp(-3.2 * v) * Math.cos(5.4 * v) - v * v * v * .026;
+		default: {
+			const k = 4.2 * v;
+			return (1 + k) * Math.exp(-k) - v * v * v * .078;
+		}
+	}
 };
-const groundShape = (v, ease)=>1 + 0.25 * squashPulse(v, ease);
-const squashPulse = (u, ease)=>{
-    if (u <= 0 || u >= 1) return 0;
-    let x;
-    switch(ease){
-        case "sharp":
-            x = (1 - u) * (1 - u);
-            break;
-        case "soft":
-            x = Math.sin(Math.PI * u) ** 2;
-            break;
-        case "bouncy":
-            x = Math.exp(-3.15 * u) * Math.sin(8.43 * u) / 0.596;
-            break;
-        default:
-            {
-                const k = 7 * u;
-                x = k * k * Math.exp(2 - k) / 4;
-            }
-    }
-    const tail = u > 0.85 ? 1 - (u - 0.85) / 0.15 : 1;
-    return x * tail * tail * (3 - 2 * tail);
+/* the weight settling through the hold, as a gain on the deepest squash:
+the same four curves as the landing squash, pressing up to a quarter
+deeper and back to the held depth, so the hold's ends never step */
+const groundShape = (v, ease) => 1 + .25 * squashPulse(v, ease);
+/* the landing squash over its time, 0–1 → its depth, 0–1 at the peak:
+sharp is all there at contact and eases off; pulse presses quickly and
+recovers without a wobble (a critically damped spring under a short
+push); soft eases in and out; bouncy overshoots into a stretch and
+settles. Each is faded out over the last part so it ends at nothing. */
+const squashPulse = (u, ease) => {
+	if (u <= 0 || u >= 1) return 0;
+	let x;
+	switch (ease) {
+		case "sharp":
+			x = (1 - u) * (1 - u);
+			break;
+		case "soft":
+			x = Math.sin(Math.PI * u) ** 2;
+			break;
+		case "bouncy":
+			x = Math.exp(-3.15 * u) * Math.sin(8.43 * u) / .596;
+			break;
+		default: {
+			const k = 7 * u;
+			x = k * k * Math.exp(2 - k) / 4;
+		}
+	}
+	const tail = u > .85 ? 1 - (u - .85) / .15 : 1;
+	return x * tail * tail * (3 - 2 * tail);
 };
-const hopSquash = (a)=>Math.exp(-Math.pow(Math.min(Math.abs(a), Math.abs(a - 1)) / 0.11, 2));
+/* the hop's shaping: squash on the ground, stretch at the top */
+const hopSquash = (a) => Math.exp(-Math.pow(Math.min(Math.abs(a), Math.abs(a - 1)) / .11, 2));
 const DEG = Math.PI / 180;
 const TAU = Math.PI * 2;
+/* how long a state change takes: dozing off is slow, waking a little
+quicker, the rest brisk */
+/* How long a switch takes. Settling down takes longer than getting to
+work: coming back to idle the body has to let go of the hops, so it
+eases out over more than a second. */
 const SWITCH_TO = {
-    default: 1.2,
-    working: 0.7,
-    sleeping: 1.4
+	default: 1.2,
+	working: .7,
+	sleeping: 1.4
 };
 const SWITCH_FROM_SLEEP = 1;
+/* Deterministic per-instance randomness (mulberry32). */
 function rng(seed) {
-    let a = seed * 0x9e3779b1 >>> 0 || 1;
-    return ()=>{
-        a = a + 0x6d2b79f5 >>> 0;
-        let t = a;
-        t = Math.imul(t ^ t >>> 15, t | 1);
-        t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-        return ((t ^ t >>> 14) >>> 0) / 4294967296;
-    };
+	let a = seed * 2654435761 >>> 0 || 1;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = a;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
 }
+/** Exponential approach: `rate` per second, frame-rate independent. */
 function approach(cur, target, rate, dt) {
-    return cur + (target - cur) * (1 - Math.exp(-rate * dt));
+	return cur + (target - cur) * (1 - Math.exp(-rate * dt));
 }
-const easeInOut = (p)=>p < 0.5 ? 4 * p * p * p : 1 - Math.pow(-2 * p + 2, 3) / 2;
-const easeSine = (p)=>0.5 - 0.5 * Math.cos(Math.PI * p);
+const easeInOut = (p) => p < .5 ? 4 * p * p * p : 1 - Math.pow(-2 * p + 2, 3) / 2;
+/* gentler at both ends than the cubic: for drifting off and waking */
+const easeSine = (p) => .5 - .5 * Math.cos(Math.PI * p);
+/* A value that drifts: picks a new target inside its range every hold,
+and eases toward it. Ranges change with the state; the value never
+jumps. */
 class Wander {
-    rand;
-    amp;
-    holdMin;
-    holdMax;
-    rate;
-    spring;
-    value = 0;
-    vel = 0;
-    target = 0;
-    next = 0;
-    constructor(rand, amp, holdMin, holdMax, rate, spring = false){
-        this.rand = rand;
-        this.amp = amp;
-        this.holdMin = holdMin;
-        this.holdMax = holdMax;
-        this.rate = rate;
-        this.spring = spring;
-    }
-    update(t, dt) {
-        if (t >= this.next) {
-            this.target = (this.rand() * 2 - 1) * this.amp;
-            this.next = t + this.holdMin + this.rand() * (this.holdMax - this.holdMin);
-        }
-        if (this.spring) {
-            const w = this.rate * 1.6, z = 0.9;
-            this.vel += (w * w * (this.target - this.value) - 2 * z * w * this.vel) * dt;
-            this.value += this.vel * dt;
-        } else this.value = approach(this.value, this.target, this.rate, dt);
-    }
-    aim(v) {
-        this.target = v;
-        this.next = Infinity;
-    }
-    set(amp, holdMin, holdMax, rate) {
-        this.amp = amp;
-        this.holdMin = holdMin;
-        this.holdMax = holdMax;
-        this.rate = rate;
-        this.next = 0;
-    }
+	rand;
+	amp;
+	holdMin;
+	holdMax;
+	rate;
+	spring;
+	value = 0;
+	vel = 0;
+	target = 0;
+	next = 0;
+	/* A channel that picks a new target now and then and moves to it. The
+	head channels move as a lightly damped spring — the turn starts and
+	ends softly, the way a head does — while the eyes dart with an
+	exponential approach, the way eyes do. */
+	constructor(rand, amp, holdMin, holdMax, rate, spring = false) {
+		this.rand = rand;
+		this.amp = amp;
+		this.holdMin = holdMin;
+		this.holdMax = holdMax;
+		this.rate = rate;
+		this.spring = spring;
+	}
+	update(t, dt) {
+		if (t >= this.next) {
+			this.target = (this.rand() * 2 - 1) * this.amp;
+			this.next = t + this.holdMin + this.rand() * (this.holdMax - this.holdMin);
+		}
+		if (this.spring) {
+			const w = this.rate * 1.6, z = .9;
+			this.vel += (w * w * (this.target - this.value) - 2 * z * w * this.vel) * dt;
+			this.value += this.vel * dt;
+		} else this.value = approach(this.value, this.target, this.rate, dt);
+	}
+	/** aim at a value and stay there: the rig picks the next one */
+	aim(v) {
+		this.target = v;
+		this.next = Infinity;
+	}
+	set(amp, holdMin, holdMax, rate) {
+		this.amp = amp;
+		this.holdMin = holdMin;
+		this.holdMax = holdMax;
+		this.rate = rate;
+		this.next = 0;
+	}
 }
+/* A one-shot event: progress 0 → 1 over its duration, then idle at -1. */
 class Event {
-    duration;
-    p = -1;
-    constructor(duration){
-        this.duration = duration;
-    }
-    fire() {
-        this.p = 0;
-    }
-    get active() {
-        return this.p >= 0;
-    }
-    update(dt) {
-        if (this.p < 0) return;
-        this.p += dt / this.duration;
-        if (this.p >= 1) this.p = -1;
-    }
+	duration;
+	p = -1;
+	constructor(duration) {
+		this.duration = duration;
+	}
+	fire() {
+		this.p = 0;
+	}
+	get active() {
+		return this.p >= 0;
+	}
+	update(dt) {
+		if (this.p < 0) return;
+		this.p += dt / this.duration;
+		if (this.p >= 1) this.p = -1;
+	}
 }
+/* The idle gaze: how far the head swings, and how long it stays. The
+sideways reach is the big one — a look to a corner reads as a turn of
+the head, with the rise and a slight tilt going along. */
 const GAZE_YAW = 35 * DEG;
 const GAZE_PITCH = 14 * DEG;
 const GAZE_ROLL = 3.2 * DEG;
 const GAZE_HOLD_MIN = 2.6;
 const GAZE_HOLD_MAX = 4.4;
 const REST = {
-    default: {
-        pitch: 0,
-        roll: 0,
-        y: 0,
-        lookX: 0,
-        lookY: 0
-    },
-    working: {
-        pitch: 5 * DEG,
-        roll: 0,
-        y: 0,
-        lookX: 0,
-        lookY: 0
-    },
-    sleeping: {
-        pitch: -16 * DEG,
-        roll: 6 * DEG,
-        y: 3,
-        lookX: 0,
-        lookY: 1
-    }
+	default: {
+		pitch: 0,
+		roll: 0,
+		y: 0,
+		lookX: 0,
+		lookY: 0
+	},
+	working: {
+		pitch: 5 * DEG,
+		roll: 0,
+		y: 0,
+		lookX: 0,
+		lookY: 0
+	},
+	sleeping: {
+		pitch: -16 * DEG,
+		roll: 6 * DEG,
+		y: 3,
+		lookX: 0,
+		lookY: 1
+	}
 };
 export class Sim {
-    pose = {
-        yaw: 0,
-        pitch: 0,
-        roll: 0,
-        x: 0,
-        y: 0,
-        sx: 1,
-        sy: 1,
-        eyeOpen: 1,
-        blinkL: 0,
-        blinkR: 0,
-        lookX: 0,
-        lookY: 0,
-        breath: 0,
-        laugh: 0,
-        whirl: 0,
-        whirlAngle: 0,
-        w: [
-            1,
-            0,
-            0
-        ]
-    };
-    state = "default";
-    rand;
-    t = 0;
-    wFrom = [
-        1,
-        0,
-        0
-    ];
-    tr = 1;
-    trDuration = 1.2;
-    yawW;
-    pitchW;
-    rollW;
-    lookXW;
-    lookYW;
-    blink = new Event(0.17);
-    blinkAt;
-    blinkAgain = false;
-    dart = new Event(0.12);
-    dartAt;
-    dartX = 0;
-    dartY = 0;
-    flip = new Event(flipDuration(JUMP_DEFAULTS, false));
-    flipPoked = false;
-    jump = {
-        ...JUMP_DEFAULTS
-    };
-    flipAt;
-    flipSide = 1;
-    nod = new Event(1.7);
-    nodAt;
-    hopPhase = 0;
-    hopCount = 0;
-    hopGain = 0;
-    laughEv = new Event(0.8);
-    laughAt;
-    prevYaw = 0;
-    jelly = 0;
-    jellyV = 0;
-    gazeLead = 0;
-    gazeDir = [
-        0,
-        0
-    ];
-    gazeAt = 0;
-    turnK = 1;
-    breathPhase = 0;
-    ptrX = 0;
-    ptrY = 0;
-    ptrS = 0;
-    ptrTargetX = 0;
-    ptrTargetY = 0;
-    ptrTargetS = 0;
-    baseYaw = 0;
-    constructor(seed, state = "default"){
-        this.rand = rng(Math.floor(seed * 1e6) + 1);
-        const r = this.rand;
-        this.yawW = new Wander(r, 36 * DEG, 1.1, 2.6, 3, true);
-        this.pitchW = new Wander(r, 10 * DEG, 1.1, 2.6, 2.6, true);
-        this.rollW = new Wander(r, 5 * DEG, 1.6, 3.2, 2, true);
-        this.lookXW = new Wander(r, 3.6, 0.5, 2, 14);
-        this.lookYW = new Wander(r, 2.4, 0.5, 2, 14);
-        this.t = r() * 10;
-        this.hopPhase = r();
-        this.breathPhase = r();
-        this.blinkAt = this.t + 1 + r() * 3;
-        this.flipAt = this.nextFlip(this.t, 1);
-        this.nodAt = this.t + 3 + r() * 4;
-        this.dartAt = this.t + 1 + r() * 2;
-        this.laughAt = this.t + 0.6 + r() * 1.5;
-        this.setState(state, true);
-    }
-    setState(next, immediate = false) {
-        if (next === this.state && !immediate) return;
-        const from = this.state;
-        this.state = next;
-        const w = this.pose.w;
-        if (immediate) {
-            for(let i = 0; i < 3; i++)w[i] = STATES[i] === next ? 1 : 0;
-            this.tr = 1;
-        } else {
-            this.wFrom = [
-                w[0],
-                w[1],
-                w[2]
-            ];
-            this.tr = 0;
-            this.trDuration = from === "sleeping" ? SWITCH_FROM_SLEEP : SWITCH_TO[next];
-        }
-        switch(next){
-            case "default":
-                this.yawW.set(GAZE_YAW, 2.6, 5.4, 2);
-                this.pitchW.set(GAZE_PITCH, 2.8, 5.8, 1.8);
-                this.rollW.set(GAZE_ROLL, 3.4, 6.6, 1.5);
-                this.gazeAt = 0;
-                this.gazeDir = [
-                    0,
-                    0
-                ];
-                this.lookXW.set(3.6, 0.6, 2.2, 13);
-                this.lookYW.set(2.4, 0.6, 2.2, 13);
-                this.flipAt = this.nextFlip(this.t, 0.6);
-                break;
-            case "working":
-                this.yawW.set(16 * DEG, 0.9, 1.8, 4);
-                this.pitchW.set(3 * DEG, 1.2, 2.4, 3);
-                this.rollW.set(0, 1, 2, 3);
-                this.lookXW.set(2, 0.5, 1.2, 12);
-                this.lookYW.set(1, 0.5, 1.2, 12);
-                this.hopPhase = 0;
-                this.hopCount = 0;
-                this.laughAt = this.t + 0.5 + this.rand() * 1.2;
-                break;
-            case "sleeping":
-                this.yawW.set(7 * DEG, 3, 6, 0.7);
-                this.pitchW.set(3 * DEG, 3, 6, 0.7);
-                this.rollW.set(2 * DEG, 3, 6, 0.6);
-                this.lookXW.set(0, 2, 4, 2);
-                this.lookYW.set(0, 2, 4, 2);
-                this.nodAt = this.t + 2.5 + this.rand() * 4;
-                break;
-        }
-    }
-    setPointer(x, y, strength) {
-        this.ptrTargetX = Math.max(-1.2, Math.min(1.2, x));
-        this.ptrTargetY = Math.max(-1.2, Math.min(1.2, y));
-        this.ptrTargetS = Math.max(0, Math.min(1, strength));
-    }
-    poke() {
-        if (this.flip.active && this.flip.p < 0.6) return;
-        this.flipPoked = true;
-        this.flip.duration = flipDuration(this.jump, true);
-        this.flipSide = this.rand() < 0.5 ? -1 : 1;
-        this.flip.fire();
-        this.flipAt = this.nextFlip(this.t, 1.1);
-    }
-    setTurn(k) {
-        const next = Math.max(0, k);
-        if (next === this.turnK) return;
-        this.turnK = next;
-        if (this.state === "default") this.gazeAt = 0;
-    }
-    setJump(j) {
-        const every = this.jump.every;
-        Object.assign(this.jump, j);
-        if (j.every !== undefined && j.every !== every) this.flipAt = this.nextFlip(this.t, 1);
-    }
-    nextGaze() {
-        const r = this.rand;
-        const [px, py] = this.gazeDir;
-        if (px !== 0 || py !== 0) {
-            const p = r();
-            if (p < 0.66) return [
-                -px,
-                -py
-            ];
-            if (p < 0.85) return [
-                -px,
-                py
-            ];
-            return [
-                0,
-                0
-            ];
-        }
-        const corners = [
-            [
-                1,
-                -1
-            ],
-            [
-                -1,
-                1
-            ],
-            [
-                -1,
-                -1
-            ],
-            [
-                1,
-                1
-            ]
-        ];
-        return corners[Math.floor(r() * corners.length)];
-    }
-    nextFlip(t, k) {
-        const every = this.jump.every;
-        return every > 0 ? t + every * k * (0.625 + this.rand() * 0.75) : Infinity;
-    }
-    update(dt) {
-        dt = Math.min(dt, 0.05);
-        this.t += dt;
-        const t = this.t;
-        const p = this.pose;
-        const w = p.w;
-        if (this.tr < 1) {
-            this.tr = Math.min(1, this.tr + dt / this.trDuration);
-            const e = easeSine(this.tr);
-            for(let i = 0; i < 3; i++){
-                const target = STATES[i] === this.state ? 1 : 0;
-                w[i] = this.wFrom[i] + (target - this.wFrom[i]) * e;
-            }
-        }
-        const [wd, ww, ws] = w;
-        const rest = {
-            pitch: 0,
-            roll: 0,
-            y: 0,
-            lookX: 0,
-            lookY: 0
-        };
-        for(let i = 0; i < 3; i++){
-            const r = REST[STATES[i]];
-            rest.pitch += r.pitch * w[i];
-            rest.roll += r.roll * w[i];
-            rest.y += r.y * w[i];
-            rest.lookX += r.lookX * w[i];
-            rest.lookY += r.lookY * w[i];
-        }
-        if (this.state === "default" && t >= this.gazeAt) {
-            const [gx, gy] = this.nextGaze();
-            this.gazeDir = [
-                gx,
-                gy
-            ];
-            const reach = 0.84 + this.rand() * 0.16;
-            this.yawW.aim(gx * GAZE_YAW * reach * this.turnK);
-            this.pitchW.aim(gy * GAZE_PITCH * reach);
-            this.rollW.aim(gx * GAZE_ROLL * reach * this.turnK);
-            this.gazeAt = t + GAZE_HOLD_MIN + this.rand() * (GAZE_HOLD_MAX - GAZE_HOLD_MIN);
-        }
-        this.yawW.update(t, dt);
-        this.pitchW.update(t, dt);
-        this.rollW.update(t, dt);
-        this.lookXW.update(t, dt);
-        this.lookYW.update(t, dt);
-        this.ptrS = approach(this.ptrS, this.ptrTargetS, 8, dt);
-        this.ptrX = approach(this.ptrX, this.ptrTargetX, 14, dt);
-        this.ptrY = approach(this.ptrY, this.ptrTargetY, 14, dt);
-        const ps = this.ptrS;
-        const quiet = 1 - 0.75 * ps;
-        this.baseYaw = approach(this.baseYaw, this.yawW.value * quiet + 22 * DEG * this.ptrX * ps, 5, dt);
-        const basePitch = rest.pitch + this.pitchW.value * quiet - 12 * DEG * this.ptrY * ps;
-        const baseRoll = rest.roll + this.rollW.value * quiet;
-        const baseY = rest.y;
-        const baseLookX = rest.lookX + this.lookXW.value * quiet + 4.5 * this.ptrX * ps;
-        const baseLookY = rest.lookY + this.lookYW.value * quiet + 3 * this.ptrY * ps;
-        let spin = 0, hopY = 0, sx = 1, sy = 1, pitchAdd = 0, rollAdd = 0, blinkClose = 0, lookXAdd = 0, lookYAdd = 0, laugh = 0;
-        let whirl = 0, whirlAngle = 0;
-        const smooth = (a, b, v)=>{
-            const x = Math.min(1, Math.max(0, (v - a) / (b - a)));
-            return x * x * (3 - 2 * x);
-        };
-        const envelope = (q)=>smooth(0.1, 0.26, q) * (1 - smooth(0.66, 0.9, q));
-        const ringAngle = (q)=>TAU * (1.5 * q + 0.9 * easeInOut(q));
-        if (t >= this.blinkAt && !this.blink.active && wd + ww > 0.5) {
-            this.blink.fire();
-            this.blinkAgain = !this.blinkAgain && this.rand() < 0.22;
-            this.blinkAt = t + (this.blinkAgain ? 0.28 : 2.2 + this.rand() * 2.6);
-        }
-        this.blink.update(dt);
-        if (this.blink.active) blinkClose = Math.sin(Math.PI * this.blink.p);
-        if (t >= this.dartAt && !this.dart.active && wd + ww > 0.5) {
-            this.dart.fire();
-            this.dartX = (this.rand() * 2 - 1) * 4;
-            this.dartY = (this.rand() * 2 - 1) * 2;
-            this.dart.duration = 0.25 + this.rand() * 0.45;
-            this.dartAt = t + 1.2 + this.rand() * 2.6;
-        }
-        this.dart.update(dt);
-        if (this.dart.active) {
-            const q = this.dart.p;
-            const hold = q < 0.15 ? q / 0.15 : q > 0.8 ? (1 - q) / 0.2 : 1;
-            lookXAdd += this.dartX * hold * (wd + ww);
-            lookYAdd += this.dartY * hold * (wd + ww);
-        }
-        if (this.state === "default" && t >= this.flipAt && !this.flip.active) {
-            this.flipPoked = false;
-            this.flip.duration = flipDuration(this.jump, false);
-            this.flipSide = this.rand() < 0.5 ? -1 : 1;
-            this.flip.fire();
-            this.flipAt = this.nextFlip(t, 1);
-        }
-        this.flip.update(dt);
-        if (this.flip.active) {
-            const J = this.jump;
-            const preS = flipPre(J, this.flipPoked);
-            const a = (this.flip.p * this.flip.duration - preS) / J.time;
-            const q = Math.min(1, Math.max(0, a));
-            const arc = Math.sin(Math.PI * q);
-            spin += TAU * J.spin * easeInOut(q);
-            hopY -= J.height * arc;
-            const tl = (a - 1) * J.time - J.land;
-            const squashTime = this.flipPoked ? J.clickSquashTime : J.squashTime;
-            const crouch = (u)=>this.flipPoked ? u * u * (3 - 2 * u) : hopSquash(u - 1);
-            const hold = Math.max(0, J.groundTime);
-            const peakT = SQUASH_PEAK[J.squashEase] * squashTime;
-            const rise = tl - peakT - hold;
-            const depth = tl <= peakT ? squashPulse(tl / squashTime, J.squashEase) : rise <= 0 ? groundShape((tl - peakT) / hold, J.groundEase) : risePulse(rise / J.riseTime, J.riseEase);
-            const land = (a < 0 ? crouch(Math.max(0, 1 + a * J.time / preS)) : tl > 0 ? depth : a < 0.2 ? hopSquash(a) : 0) * J.squash;
-            sx += 0.16 * land - 0.06 * arc * J.stretch;
-            sy += -0.18 * land + 0.09 * arc * J.stretch;
-            rollAdd += this.flipSide * J.lean * DEG * arc;
-            if (J.spin > 0) {
-                laugh = Math.max(laugh, arc);
-                whirl = Math.max(whirl, envelope(q));
-                whirlAngle = ringAngle(q);
-            }
-        }
-        const J = this.jump;
-        const exitHold = Math.max(0, J.groundTime);
-        const exitFor = exitHold + J.riseTime;
-        if (this.state === "working") this.hopGain = ww;
-        if (this.hopGain > 0.02 && (this.state === "working" || this.hopPhase > 0)) {
-            this.hopPhase += dt / HOP_T;
-            if (this.hopPhase >= 1) {
-                if (this.state === "working") {
-                    this.hopPhase -= 1;
-                    this.hopCount += 1;
-                } else if ((this.hopPhase - 1) * HOP_T >= exitFor) {
-                    this.hopPhase = 0;
-                    this.hopGain = 0;
-                }
-            }
-            const g = this.hopGain;
-            const q = Math.min(1, this.hopPhase);
-            const arc = Math.sin(Math.PI * q);
-            const spinning = this.hopCount % 3 === 2;
-            const h = spinning ? HOP_SPIN_H : 18;
-            hopY -= h * arc * g;
-            const exitT = this.state !== "working" && this.hopPhase > 1 ? (this.hopPhase - 1) * HOP_T : -1;
-            const land = exitT < 0 ? hopSquash(this.hopPhase) : exitT < exitHold ? groundShape(exitT / exitHold, J.groundEase) : risePulse((exitT - exitHold) / J.riseTime, J.riseEase);
-            sx += (0.16 * land - 0.06 * arc) * g;
-            sy += (-0.18 * land + 0.09 * arc) * g;
-            if (spinning) {
-                spin += TAU * easeInOut(q) * g;
-                laugh = Math.max(laugh, arc * g);
-                if (envelope(q) * g > whirl) {
-                    whirl = envelope(q) * g;
-                    whirlAngle = ringAngle(q);
-                }
-            }
-            rollAdd += (this.hopCount % 2 === 0 ? 1 : -1) * 6 * DEG * arc * g;
-        }
-        if (this.state === "working" && t >= this.laughAt && !this.laughEv.active) {
-            this.laughEv.fire();
-            this.laughEv.duration = 0.6 + this.rand() * 0.5;
-            this.laughAt = t + 1.6 + this.rand() * 2.2;
-        }
-        this.laughEv.update(dt);
-        if (this.laughEv.active) {
-            const q = this.laughEv.p;
-            laugh = Math.max(laugh, q < 0.18 ? q / 0.18 : q > 0.78 ? (1 - q) / 0.22 : 1);
-        }
-        if (this.state === "sleeping" && t >= this.nodAt && !this.nod.active) {
-            this.nod.fire();
-            this.nodAt = t + 4 + this.rand() * 4;
-        }
-        this.nod.update(dt);
-        if (this.nod.active) {
-            const q = this.nod.p;
-            const dip = q < 0.72 ? easeInOut(q / 0.72) : 1 - easeInOut((q - 0.72) / 0.28);
-            pitchAdd -= 13 * DEG * dip * ws;
-        }
-        this.breathPhase += dt / (3.6 + 1.2 * ws);
-        const breath = Math.sin(this.breathPhase * TAU);
-        p.breath = breath;
-        sx += breath * (0.008 + 0.014 * ws);
-        sy += breath * (0.012 + 0.02 * ws);
-        const bob = Math.sin(t * TAU / 3.4) * 2 * (1 - ws);
-        p.yaw = this.baseYaw + spin;
-        let dyaw = this.baseYaw - this.prevYaw;
-        dyaw = ((dyaw + Math.PI) % TAU + TAU) % TAU - Math.PI;
-        this.prevYaw = this.baseYaw;
-        const rate = dt > 0 ? Math.abs(dyaw) / dt : 0;
-        const leadTarget = dt > 0 ? Math.max(-2.2, Math.min(2.2, dyaw / dt * 2.4)) : 0;
-        this.gazeLead = approach(this.gazeLead, leadTarget, 9, dt);
-        const jellyTarget = Math.min(0.22, 0.055 * rate);
-        const omega = 16, zeta = 0.45;
-        this.jellyV += (omega * omega * (jellyTarget - this.jelly) - 2 * zeta * omega * this.jellyV) * dt;
-        this.jelly += this.jellyV * dt;
-        const jelly = Math.max(-0.08, Math.min(0.28, this.jelly)) * 0.6;
-        sx *= 1 + jelly;
-        sy *= 1 - 0.55 * jelly;
-        p.pitch = basePitch + pitchAdd;
-        p.roll = baseRoll + rollAdd;
-        p.x = 0;
-        p.y = baseY + hopY + bob;
-        p.sx = sx;
-        p.sy = sy;
-        p.eyeOpen = 1;
-        p.laugh = approach(p.laugh, laugh, 30, dt);
-        p.blinkL = blinkClose;
-        p.blinkR = blinkClose;
-        p.lookX = baseLookX + lookXAdd + this.gazeLead;
-        p.lookY = baseLookY + lookYAdd;
-        p.whirl = whirl;
-        p.whirlAngle = whirlAngle;
-    }
+	pose = {
+		yaw: 0,
+		pitch: 0,
+		roll: 0,
+		x: 0,
+		y: 0,
+		sx: 1,
+		sy: 1,
+		eyeOpen: 1,
+		blinkL: 0,
+		blinkR: 0,
+		lookX: 0,
+		lookY: 0,
+		breath: 0,
+		laugh: 0,
+		whirl: 0,
+		whirlAngle: 0,
+		w: [
+			1,
+			0,
+			0
+		]
+	};
+	state = "default";
+	rand;
+	t = 0;
+	/* a state change: the weights it started from and its progress */
+	wFrom = [
+		1,
+		0,
+		0
+	];
+	tr = 1;
+	trDuration = 1.2;
+	yawW;
+	pitchW;
+	rollW;
+	lookXW;
+	lookYW;
+	blink = new Event(.17);
+	blinkAt;
+	blinkAgain = false;
+	/* −1 left eye only, 1 right eye only, 0 both */
+	dart = new Event(.12);
+	dartAt;
+	dartX = 0;
+	dartY = 0;
+	flip = new Event(flipDuration(JUMP_DEFAULTS, false));
+	flipPoked = false;
+	jump = { ...JUMP_DEFAULTS };
+	flipAt;
+	flipSide = 1;
+	nod = new Event(1.7);
+	nodAt;
+	hopPhase = 0;
+	hopCount = 0;
+	/** the hops' gain: the working weight while in the state, then held so
+	a hop under way finishes whole when the state is left */
+	hopGain = 0;
+	laughEv = new Event(.8);
+	laughAt;
+	/* the jelly: a damped spring driven by how fast the head turns, so a
+	sweep stretches the body and it wobbles back */
+	prevYaw = 0;
+	jelly = 0;
+	jellyV = 0;
+	/** how far the eyes run ahead of a head turn */
+	gazeLead = 0;
+	/** the idle gaze: where the head is looking, and when it moves on */
+	gazeDir = [0, 0];
+	gazeAt = 0;
+	/** how far it turns to the side, 1 as the gaze has it */
+	turnK = 1;
+	/** the breathing cycle's phase, in turns */
+	breathPhase = 0;
+	/* the pointer, as an offset from the head in head-widths, and how much
+	to follow it — both smoothed */
+	ptrX = 0;
+	ptrY = 0;
+	ptrS = 0;
+	ptrTargetX = 0;
+	ptrTargetY = 0;
+	ptrTargetS = 0;
+	/* the smoothed yaw the head is turning to on its own */
+	baseYaw = 0;
+	constructor(seed, state = "default") {
+		this.rand = rng(Math.floor(seed * 1e6) + 1);
+		const r = this.rand;
+		this.yawW = new Wander(r, 36 * DEG, 1.1, 2.6, 3, true);
+		this.pitchW = new Wander(r, 10 * DEG, 1.1, 2.6, 2.6, true);
+		this.rollW = new Wander(r, 5 * DEG, 1.6, 3.2, 2, true);
+		this.lookXW = new Wander(r, 3.6, .5, 2, 14);
+		this.lookYW = new Wander(r, 2.4, .5, 2, 14);
+		/* every instance starts somewhere else in its loops */
+		this.t = r() * 10;
+		this.hopPhase = r();
+		this.breathPhase = r();
+		/* event timers count from that start, so nothing fires on the first tick */
+		this.blinkAt = this.t + 1 + r() * 3;
+		this.flipAt = this.nextFlip(this.t, 1);
+		this.nodAt = this.t + 3 + r() * 4;
+		this.dartAt = this.t + 1 + r() * 2;
+		this.laughAt = this.t + .6 + r() * 1.5;
+		this.setState(state, true);
+	}
+	setState(next, immediate = false) {
+		if (next === this.state && !immediate) return;
+		const from = this.state;
+		this.state = next;
+		const w = this.pose.w;
+		if (immediate) {
+			for (let i = 0; i < 3; i++) w[i] = STATES[i] === next ? 1 : 0;
+			this.tr = 1;
+		} else {
+			this.wFrom = [
+				w[0],
+				w[1],
+				w[2]
+			];
+			this.tr = 0;
+			this.trDuration = from === "sleeping" ? SWITCH_FROM_SLEEP : SWITCH_TO[next];
+		}
+		switch (next) {
+			case "default":
+				/* the head takes its time: it holds a place, then swings to the
+				next over about a second — no short quick jabs. The gaze picks
+				where, so these carry the motion and their amplitude is unused. */
+				this.yawW.set(GAZE_YAW, 2.6, 5.4, 2);
+				this.pitchW.set(GAZE_PITCH, 2.8, 5.8, 1.8);
+				this.rollW.set(GAZE_ROLL, 3.4, 6.6, 1.5);
+				this.gazeAt = 0;
+				this.gazeDir = [0, 0];
+				/* the eyes keep their quickness: they dart, the head follows */
+				this.lookXW.set(3.6, .6, 2.2, 13);
+				this.lookYW.set(2.4, .6, 2.2, 13);
+				this.flipAt = this.nextFlip(this.t, .6);
+				break;
+			case "working":
+				this.yawW.set(16 * DEG, .9, 1.8, 4);
+				this.pitchW.set(3 * DEG, 1.2, 2.4, 3);
+				this.rollW.set(0, 1, 2, 3);
+				this.lookXW.set(2, .5, 1.2, 12);
+				this.lookYW.set(1, .5, 1.2, 12);
+				this.hopPhase = 0;
+				this.hopCount = 0;
+				this.laughAt = this.t + .5 + this.rand() * 1.2;
+				break;
+			case "sleeping":
+				this.yawW.set(7 * DEG, 3, 6, .7);
+				this.pitchW.set(3 * DEG, 3, 6, .7);
+				this.rollW.set(2 * DEG, 3, 6, .6);
+				this.lookXW.set(0, 2, 4, 2);
+				this.lookYW.set(0, 2, 4, 2);
+				this.nodAt = this.t + 2.5 + this.rand() * 4;
+				break;
+		}
+	}
+	/** Where the pointer is, relative to the head (−1 … 1 across a head
+	width), and how strongly to follow it (0 lets go). */
+	setPointer(x, y, strength) {
+		this.ptrTargetX = Math.max(-1.2, Math.min(1.2, x));
+		this.ptrTargetY = Math.max(-1.2, Math.min(1.2, y));
+		this.ptrTargetS = Math.max(0, Math.min(1, strength));
+	}
+	/** A hop and a full turn, right now, whatever the state. */
+	poke() {
+		if (this.flip.active && this.flip.p < .6) return;
+		this.flipPoked = true;
+		this.flip.duration = flipDuration(this.jump, true);
+		this.flipSide = this.rand() < .5 ? -1 : 1;
+		this.flip.fire();
+		this.flipAt = this.nextFlip(this.t, 1.1);
+	}
+	/** How far the head turns to the side while idle: 1 as the gaze has
+	it, 0 keeps it facing forward. */
+	setTurn(k) {
+		const next = Math.max(0, k);
+		if (next === this.turnK) return;
+		this.turnK = next;
+		/* take the new reach at once rather than at the next place */
+		if (this.state === "default") this.gazeAt = 0;
+	}
+	/** The jump's numbers; any subset. */
+	setJump(j) {
+		const every = this.jump.every;
+		Object.assign(this.jump, j);
+		/* a new interval takes effect at once, so `every: 0` stops the next
+		jump that was already due and a first value starts the clock */
+		if (j.every !== undefined && j.every !== every) this.flipAt = this.nextFlip(this.t, 1);
+	}
+	/* Where the head looks next. From a corner it mostly swings straight
+	across to the opposite one — top right, stay, bottom left — now and
+	then only sideways, or back to the middle for a beat. */
+	nextGaze() {
+		const r = this.rand;
+		const [px, py] = this.gazeDir;
+		if (px !== 0 || py !== 0) {
+			const p = r();
+			if (p < .66) return [-px, -py];
+			if (p < .85) return [-px, py];
+			return [0, 0];
+		}
+		const corners = [
+			[1, -1],
+			[-1, 1],
+			[-1, -1],
+			[1, 1]
+		];
+		return corners[Math.floor(r() * corners.length)];
+	}
+	/** when the next idle jump is due: `every` seconds, give or take 40 % */
+	nextFlip(t, k) {
+		const every = this.jump.every;
+		return every > 0 ? t + every * k * (.625 + this.rand() * .75) : Infinity;
+	}
+	/** Advance by `dt` seconds (already scaled by the speed). */
+	update(dt) {
+		dt = Math.min(dt, .05);
+		this.t += dt;
+		const t = this.t;
+		const p = this.pose;
+		const w = p.w;
+		/* the state change eases from the weights it started with to the new
+		state's on an S-curve: soft start, soft finish, no creeping tail */
+		if (this.tr < 1) {
+			this.tr = Math.min(1, this.tr + dt / this.trDuration);
+			/* a sine ease: no kick at either end of a switch */
+			const e = easeSine(this.tr);
+			for (let i = 0; i < 3; i++) {
+				const target = STATES[i] === this.state ? 1 : 0;
+				w[i] = this.wFrom[i] + (target - this.wFrom[i]) * e;
+			}
+		}
+		const [wd, ww, ws] = w;
+		/* rest targets, blended */
+		const rest = {
+			pitch: 0,
+			roll: 0,
+			y: 0,
+			lookX: 0,
+			lookY: 0
+		};
+		for (let i = 0; i < 3; i++) {
+			const r = REST[STATES[i]];
+			rest.pitch += r.pitch * w[i];
+			rest.roll += r.roll * w[i];
+			rest.y += r.y * w[i];
+			rest.lookX += r.lookX * w[i];
+			rest.lookY += r.lookY * w[i];
+		}
+		/* the idle gaze: a place to look, a while to stay, then the swing to
+		the next — the wanderers carry it on their own springs */
+		if (this.state === "default" && t >= this.gazeAt) {
+			const [gx, gy] = this.nextGaze();
+			this.gazeDir = [gx, gy];
+			const reach = .84 + this.rand() * .16;
+			this.yawW.aim(gx * GAZE_YAW * reach * this.turnK);
+			this.pitchW.aim(gy * GAZE_PITCH * reach);
+			/* the tilt goes with the turn, so it follows it */
+			this.rollW.aim(gx * GAZE_ROLL * reach * this.turnK);
+			this.gazeAt = t + GAZE_HOLD_MIN + this.rand() * (GAZE_HOLD_MAX - GAZE_HOLD_MIN);
+		}
+		/* wander */
+		this.yawW.update(t, dt);
+		this.pitchW.update(t, dt);
+		this.rollW.update(t, dt);
+		this.lookXW.update(t, dt);
+		this.lookYW.update(t, dt);
+		/* following the pointer: the eyes lead, the head turns after them,
+		and the wander quietens while it lasts */
+		this.ptrS = approach(this.ptrS, this.ptrTargetS, 8, dt);
+		this.ptrX = approach(this.ptrX, this.ptrTargetX, 14, dt);
+		this.ptrY = approach(this.ptrY, this.ptrTargetY, 14, dt);
+		const ps = this.ptrS;
+		const quiet = 1 - .75 * ps;
+		/* the base pose: the blended rest plus the smoothed wander and the
+		pointer's pull — every term is already continuous */
+		this.baseYaw = approach(this.baseYaw, this.yawW.value * quiet + 22 * DEG * this.ptrX * ps, 5, dt);
+		const basePitch = rest.pitch + this.pitchW.value * quiet - 12 * DEG * this.ptrY * ps;
+		const baseRoll = rest.roll + this.rollW.value * quiet;
+		const baseY = rest.y;
+		const baseLookX = rest.lookX + this.lookXW.value * quiet + 4.5 * this.ptrX * ps;
+		const baseLookY = rest.lookY + this.lookYW.value * quiet + 3 * this.ptrY * ps;
+		/* ── events ── */
+		let spin = 0, hopY = 0, sx = 1, sy = 1, pitchAdd = 0, rollAdd = 0, blinkClose = 0, lookXAdd = 0, lookYAdd = 0, laugh = 0;
+		let whirl = 0, whirlAngle = 0;
+		/* the whirl: not there until the turn is visibly under way, gone
+		before the landing */
+		const smooth = (a, b, v) => {
+			const x = Math.min(1, Math.max(0, (v - a) / (b - a)));
+			return x * x * (3 - 2 * x);
+		};
+		const envelope = (q) => smooth(.1, .26, q) * (1 - smooth(.66, .9, q));
+		/* the ring's own travel: fast and steady from the first frame, with a
+		little of the body's own easing on top, so it is moving the moment
+		it shows */
+		const ringAngle = (q) => TAU * (1.5 * q + .9 * easeInOut(q));
+		/* blinks: idle and working blink; a double blink now and then */
+		if (t >= this.blinkAt && !this.blink.active && wd + ww > .5) {
+			this.blink.fire();
+			this.blinkAgain = !this.blinkAgain && this.rand() < .22;
+			this.blinkAt = t + (this.blinkAgain ? .28 : 2.2 + this.rand() * 2.6);
+		}
+		this.blink.update(dt);
+		if (this.blink.active) blinkClose = Math.sin(Math.PI * this.blink.p);
+		/* eye darts: a quick glance to the side and back, between the slower
+		looks — the eyes have a life of their own */
+		if (t >= this.dartAt && !this.dart.active && wd + ww > .5) {
+			this.dart.fire();
+			this.dartX = (this.rand() * 2 - 1) * 4;
+			this.dartY = (this.rand() * 2 - 1) * 2;
+			this.dart.duration = .25 + this.rand() * .45;
+			this.dartAt = t + 1.2 + this.rand() * 2.6;
+		}
+		this.dart.update(dt);
+		if (this.dart.active) {
+			const q = this.dart.p;
+			/* snap out, hold, snap back */
+			const hold = q < .15 ? q / .15 : q > .8 ? (1 - q) / .2 : 1;
+			lookXAdd += this.dartX * hold * (wd + ww);
+			lookYAdd += this.dartY * hold * (wd + ww);
+		}
+		/* idle: a full turn now and then, with a jump */
+		if (this.state === "default" && t >= this.flipAt && !this.flip.active) {
+			this.flipPoked = false;
+			this.flip.duration = flipDuration(this.jump, false);
+			this.flipSide = this.rand() < .5 ? -1 : 1;
+			this.flip.fire();
+			this.flipAt = this.nextFlip(t, 1);
+		}
+		this.flip.update(dt);
+		if (this.flip.active) {
+			const J = this.jump;
+			/* the hop's own phase: below 0 the crouch, above 1 the recovery */
+			const preS = flipPre(J, this.flipPoked);
+			const a = (this.flip.p * this.flip.duration - preS) / J.time;
+			const q = Math.min(1, Math.max(0, a));
+			const arc = Math.sin(Math.PI * q);
+			/* whole turns, eased in and out, no overshoot to snap back from */
+			spin += TAU * J.spin * easeInOut(q);
+			hopY -= J.height * arc;
+			/* the crouch before take-off; then the landing squash from `land`
+			seconds round the moment of contact — before it, the body braces
+			for the ground; after it, it gives late */
+			const tl = (a - 1) * J.time - J.land;
+			const squashTime = this.flipPoked ? J.clickSquashTime : J.squashTime;
+			/* the crouch: a click's builds over its squash time, an idle jump's
+			is the hop's short bump; then the hop, then the landing squash */
+			const crouch = (u) => this.flipPoked ? u * u * (3 - 2 * u) : hopSquash(u - 1);
+			/* the landing in three parts: the press down to the deepest squash
+			in the squash easing's own shape, the hold on the ground, then
+			the rise back to the body's shape — each with its own time and
+			easing, and all three meeting at the same depth, so nothing steps */
+			const hold = Math.max(0, J.groundTime);
+			const peakT = SQUASH_PEAK[J.squashEase] * squashTime;
+			const rise = tl - peakT - hold;
+			const depth = tl <= peakT ? squashPulse(tl / squashTime, J.squashEase) : rise <= 0 ? groundShape((tl - peakT) / hold, J.groundEase) : risePulse(rise / J.riseTime, J.riseEase);
+			const land = (a < 0 ? crouch(Math.max(0, 1 + a * J.time / preS)) : tl > 0 ? depth : a < .2 ? hopSquash(a) : 0) * J.squash;
+			sx += .16 * land - .06 * arc * J.stretch;
+			sy += -.18 * land + .09 * arc * J.stretch;
+			/* lean into it; eyes shut for a turn */
+			rollAdd += this.flipSide * J.lean * DEG * arc;
+			if (J.spin > 0) {
+				laugh = Math.max(laugh, arc);
+				whirl = Math.max(whirl, envelope(q));
+				whirlAngle = ringAngle(q);
+			}
+		}
+		/* working: hops all the time; every third one spins. Leaving the
+		state, the hop under way keeps the strength it had — it flies its
+		whole arc, finishes its turn and lands — and that last landing is
+		not the rhythm's quick bump but a jump's proper one: the hold on
+		the ground and the rise back, from the depth the hop reached. */
+		const J = this.jump;
+		const exitHold = Math.max(0, J.groundTime);
+		const exitFor = exitHold + J.riseTime;
+		if (this.state === "working") this.hopGain = ww;
+		if (this.hopGain > .02 && (this.state === "working" || this.hopPhase > 0)) {
+			this.hopPhase += dt / HOP_T;
+			if (this.hopPhase >= 1) {
+				if (this.state === "working") {
+					this.hopPhase -= 1;
+					this.hopCount += 1;
+				} else if ((this.hopPhase - 1) * HOP_T >= exitFor) {
+					/* the last hop has landed and settled */
+					this.hopPhase = 0;
+					this.hopGain = 0;
+				}
+			}
+			const g = this.hopGain;
+			/* past 1 the body is down and only the landing is still playing */
+			const q = Math.min(1, this.hopPhase);
+			const arc = Math.sin(Math.PI * q);
+			const spinning = this.hopCount % 3 === 2;
+			const h = spinning ? HOP_SPIN_H : 18;
+			hopY -= h * arc * g;
+			/* squash on landing, stretch at the top */
+			const exitT = this.state !== "working" && this.hopPhase > 1 ? (this.hopPhase - 1) * HOP_T : -1;
+			const land = exitT < 0 ? hopSquash(this.hopPhase) : exitT < exitHold ? groundShape(exitT / exitHold, J.groundEase) : risePulse((exitT - exitHold) / J.riseTime, J.riseEase);
+			sx += (.16 * land - .06 * arc) * g;
+			sy += (-.18 * land + .09 * arc) * g;
+			if (spinning) {
+				spin += TAU * easeInOut(q) * g;
+				/* eyes shut for the spin */
+				laugh = Math.max(laugh, arc * g);
+				if (envelope(q) * g > whirl) {
+					whirl = envelope(q) * g;
+					whirlAngle = ringAngle(q);
+				}
+			}
+			/* lean into each hop, alternating sides */
+			rollAdd += (this.hopCount % 2 === 0 ? 1 : -1) * 6 * DEG * arc * g;
+		}
+		/* working: now and then a laugh shuts the eyes into arcs, then they
+		open again */
+		if (this.state === "working" && t >= this.laughAt && !this.laughEv.active) {
+			this.laughEv.fire();
+			this.laughEv.duration = .6 + this.rand() * .5;
+			this.laughAt = t + 1.6 + this.rand() * 2.2;
+		}
+		this.laughEv.update(dt);
+		if (this.laughEv.active) {
+			const q = this.laughEv.p;
+			/* quick shut, hold, quick open */
+			laugh = Math.max(laugh, q < .18 ? q / .18 : q > .78 ? (1 - q) / .22 : 1);
+		}
+		/* sleeping: the head drops, then jerks back up */
+		if (this.state === "sleeping" && t >= this.nodAt && !this.nod.active) {
+			this.nod.fire();
+			this.nodAt = t + 4 + this.rand() * 4;
+		}
+		this.nod.update(dt);
+		if (this.nod.active) {
+			const q = this.nod.p;
+			/* slow slide down, quick recovery */
+			const dip = q < .72 ? easeInOut(q / .72) : 1 - easeInOut((q - .72) / .28);
+			pitchAdd -= 13 * DEG * dip * ws;
+		}
+		/* breathing, always, deeper and slower asleep. The phase is integrated
+		so the period can change with the state without the cycle jumping */
+		this.breathPhase += dt / (3.6 + 1.2 * ws);
+		const breath = Math.sin(this.breathPhase * TAU);
+		p.breath = breath;
+		sx += breath * (.008 + .014 * ws);
+		sy += breath * (.012 + .02 * ws);
+		const bob = Math.sin(t * TAU / 3.4) * 2 * (1 - ws);
+		/* ── compose ── */
+		p.yaw = this.baseYaw + spin;
+		/* the jelly: the faster the head turns, the more the body stretches
+		along the turn, on a spring that overshoots and settles. A flip's
+		spin is left out: that is a jump, and the landing spring handles it. */
+		let dyaw = this.baseYaw - this.prevYaw;
+		dyaw = ((dyaw + Math.PI) % TAU + TAU) % TAU - Math.PI;
+		this.prevYaw = this.baseYaw;
+		const rate = dt > 0 ? Math.abs(dyaw) / dt : 0;
+		/* the eyes lead a head turn, the way a gaze shift goes: they run
+		ahead of it and come back as the head settles */
+		const leadTarget = dt > 0 ? Math.max(-2.2, Math.min(2.2, dyaw / dt * 2.4)) : 0;
+		this.gazeLead = approach(this.gazeLead, leadTarget, 9, dt);
+		const jellyTarget = Math.min(.22, .055 * rate);
+		const omega = 16, zeta = .45;
+		this.jellyV += (omega * omega * (jellyTarget - this.jelly) - 2 * zeta * omega * this.jellyV) * dt;
+		this.jelly += this.jellyV * dt;
+		const jelly = Math.max(-.08, Math.min(.28, this.jelly)) * .6;
+		sx *= 1 + jelly;
+		sy *= 1 - .55 * jelly;
+		p.pitch = basePitch + pitchAdd;
+		p.roll = baseRoll + rollAdd;
+		p.x = 0;
+		p.y = baseY + hopY + bob;
+		p.sx = sx;
+		p.sy = sy;
+		/* the lids: the sleeping state closes them through its own weight in
+		the renderer, so here the eyes stay open apart from blinks */
+		p.eyeOpen = 1;
+		p.laugh = approach(p.laugh, laugh, 30, dt);
+		p.blinkL = blinkClose;
+		p.blinkR = blinkClose;
+		p.lookX = baseLookX + lookXAdd + this.gazeLead;
+		p.lookY = baseLookY + lookYAdd;
+		p.whirl = whirl;
+		p.whirlAngle = whirlAngle;
+	}
 }
+/** The still pose of a state, for reduced motion and the first paint. */
 export function restPose(state) {
-    const r = REST[state];
-    return {
-        yaw: 0,
-        pitch: r.pitch,
-        roll: r.roll,
-        x: 0,
-        y: r.y,
-        sx: 1,
-        sy: 1,
-        eyeOpen: 1,
-        blinkL: 0,
-        blinkR: 0,
-        lookX: r.lookX,
-        lookY: r.lookY,
-        breath: 0,
-        laugh: 0,
-        whirl: 0,
-        whirlAngle: 0,
-        w: STATES.map((s)=>s === state ? 1 : 0)
-    };
+	const r = REST[state];
+	return {
+		yaw: 0,
+		pitch: r.pitch,
+		roll: r.roll,
+		x: 0,
+		y: r.y,
+		sx: 1,
+		sy: 1,
+		eyeOpen: 1,
+		blinkL: 0,
+		blinkR: 0,
+		lookX: r.lookX,
+		lookY: r.lookY,
+		breath: 0,
+		laugh: 0,
+		whirl: 0,
+		whirlAngle: 0,
+		w: STATES.map((s) => s === state ? 1 : 0)
+	};
 }