@nakednous/host 0.0.3 → 0.0.5

package/dist/index.js

@@ -1,3288 +1,4 @@
-/**
- * @file Core constants — zero dependencies.
- * @module tree/constants
- * @license AGPL-3.0-only
- */
-
-// Coordinate spaces
-const WORLD  = 'WORLD';
-const EYE    = 'EYE';
-const NDC    = 'NDC';
-const SCREEN = 'SCREEN';
-const MATRIX = 'MATRIX';
-
-// Integrator frame source (helm `from` only): the construct's own current pose
-// — body-relative; not a general mapDirection space.
-const SELF   = 'SELF';
-
-// NDC Z convention (only difference between backends)
-const WEBGL  = -1;   // z ∈ [−1, 1]
-
-// Handle constraint kinds
-const SPHERE = 0;
-const PLANE  = 1;
-const AXIS   = 2;
-const DIAL   = 3;
-
-// Handle report modes
-const POINT     = 0;
-const DIRECTION = 1;
-
-/** Normalise quaternion in-place. @returns {number[]} out */
-const qNormalize = (out) => {
-  const l = Math.sqrt(out[0]*out[0]+out[1]*out[1]+out[2]*out[2]+out[3]*out[3]) || 1;
-  out[0]/=l; out[1]/=l; out[2]/=l; out[3]/=l; return out;
-};
-
-/** Hamilton product out = a * b. Alias-safe: out may be a or b. @returns {number[]} out */
-const qMul = (out, a, b) => {
-  const ax=a[0],ay=a[1],az=a[2],aw=a[3], bx=b[0],by=b[1],bz=b[2],bw=b[3];
-  out[0]=aw*bx+ax*bw+ay*bz-az*by;
-  out[1]=aw*by-ax*bz+ay*bw+az*bx;
-  out[2]=aw*bz+ax*by-ay*bx+az*bw;
-  out[3]=aw*bw-ax*bx-ay*by-az*bz;
-  return out;
-};
-
-// =========================================================================
-// Interpolation
-// =========================================================================
-
-/** Spherical linear interpolation. @returns {number[]} out */
-const qSlerp = (out, a, b, t) => {
-  let bx=b[0],by=b[1],bz=b[2],bw=b[3];
-  let d = a[0]*bx+a[1]*by+a[2]*bz+a[3]*bw;
-  if (d < 0) { bx=-bx; by=-by; bz=-bz; bw=-bw; d=-d; }
-  let f0, f1;
-  if (1-d > 1e-10) {
-    const th=Math.acos(d), st=Math.sin(th);
-    f0=Math.sin((1-t)*th)/st; f1=Math.sin(t*th)/st;
-  } else {
-    f0=1-t; f1=t;
-  }
-  out[0]=a[0]*f0+bx*f1; out[1]=a[1]*f0+by*f1;
-  out[2]=a[2]*f0+bz*f1; out[3]=a[3]*f0+bw*f1;
-  return qNormalize(out);
-};
-
-/**
- * Normalised linear interpolation (nlerp).
- * Cheaper than slerp; slightly non-constant angular velocity.
- * Handles antipodal quats by flipping b when dot < 0.
- * @returns {number[]} out
- */
-const qNlerp = (out, a, b, t) => {
-  let bx=b[0],by=b[1],bz=b[2],bw=b[3];
-  if (a[0]*bx+a[1]*by+a[2]*bz+a[3]*bw < 0) { bx=-bx; by=-by; bz=-bz; bw=-bw; }
-  out[0]=a[0]+t*(bx-a[0]); out[1]=a[1]+t*(by-a[1]);
-  out[2]=a[2]+t*(bz-a[2]); out[3]=a[3]+t*(bw-a[3]);
-  return qNormalize(out);
-};
-
-/**
- * Build a quaternion from axis-angle.
- * @param {number[]} out
- * @param {number} ax @param {number} ay @param {number} az  Axis (need not be unit).
- * @param {number} angle  Radians.
- * @returns {number[]} out
- */
-const qFromAxisAngle = (out, ax, ay, az, angle) => {
-  const half = angle * 0.5;
-  const s    = Math.sin(half);
-  const len  = Math.sqrt(ax*ax + ay*ay + az*az) || 1;
-  out[0] = s * ax / len; out[1] = s * ay / len; out[2] = s * az / len;
-  out[3] = Math.cos(half);
-  return out;
-};
-
-/**
- * Build a quaternion from a look direction (−Z forward) and optional up (default +Y).
- * `dir` need not be unit. Right = dir × up, up re-orthogonalised as right × dir;
- * when `dir` is parallel to `up` the up hint is re-seeded from the world axis
- * least aligned with `dir` (the same seed qFromUnitVectors uses), so every
- * direction yields a proper rotation.
- * @param {number[]} out
- * @param {number[]} dir  Forward direction [x,y,z].
- * @param {number[]} [up] Up vector [x,y,z].
- * @returns {number[]} out
- */
-const qFromLookDir = (out, dir, up) => {
-  let fx=dir[0],fy=dir[1],fz=dir[2];
-  const fl=Math.sqrt(fx*fx+fy*fy+fz*fz)||1;
-  fx/=fl; fy/=fl; fz/=fl;
-  let ux=up?up[0]:0, uy=up?up[1]:1, uz=up?up[2]:0;
-  let rx=fy*uz-fz*uy, ry=fz*ux-fx*uz, rz=fx*uy-fy*ux;          // right = dir × up
-  let rl=Math.sqrt(rx*rx+ry*ry+rz*rz);
-  if (rl < 1e-8) {                                              // dir ∥ up: re-seed up
-    const ax=Math.abs(fx), ay=Math.abs(fy), az=Math.abs(fz);
-    ux=0; uy=0; uz=0;
-    if (ax <= ay && ax <= az) ux=1; else if (ay <= az) uy=1; else uz=1;
-    rx=fy*uz-fz*uy; ry=fz*ux-fx*uz; rz=fx*uy-fy*ux;
-    rl=Math.sqrt(rx*rx+ry*ry+rz*rz)||1;
-  }
-  rx/=rl; ry/=rl; rz/=rl;
-  ux=ry*fz-rz*fy; uy=rz*fx-rx*fz; uz=rx*fy-ry*fx;              // up = right × dir
-  return qFromRotMat3x3(out, rx,ux,-fx, ry,uy,-fy, rz,uz,-fz);   // columns: right, up, back
-};
-
-/**
- * Build a quaternion from a 3×3 rotation matrix (9 row-major scalars).
- * @returns {number[]} out (normalised)
- */
-const qFromRotMat3x3 = (out, m00,m01,m02, m10,m11,m12, m20,m21,m22) => {
-  const tr = m00+m11+m22;
-  if (tr > 0) {
-    const s=0.5/Math.sqrt(tr+1);
-    out[3]=0.25/s; out[0]=(m21-m12)*s; out[1]=(m02-m20)*s; out[2]=(m10-m01)*s;
-  } else if (m00>m11 && m00>m22) {
-    const s=2*Math.sqrt(1+m00-m11-m22);
-    out[3]=(m21-m12)/s; out[0]=0.25*s; out[1]=(m01+m10)/s; out[2]=(m02+m20)/s;
-  } else if (m11>m22) {
-    const s=2*Math.sqrt(1+m11-m00-m22);
-    out[3]=(m02-m20)/s; out[0]=(m01+m10)/s; out[1]=0.25*s; out[2]=(m12+m21)/s;
-  } else {
-    const s=2*Math.sqrt(1+m22-m00-m11);
-    out[3]=(m10-m01)/s; out[0]=(m02+m20)/s; out[1]=(m12+m21)/s; out[2]=0.25*s;
-  }
-  return qNormalize(out);
-};
-
-/**
- * Write a quaternion into the rotation block of a column-major mat4.
- * Translation and perspective rows/cols are set to identity values.
- * @param {Float32Array|number[]} out  16-element array.
- * @param {number[]} q  [x,y,z,w].
- * @returns {Float32Array|number[]} out
- */
-const qToMat4 = (out, q) => {
-  const x=q[0],y=q[1],z=q[2],w=q[3];
-  const x2=x+x,y2=y+y,z2=z+z;
-  const xx=x*x2,xy=x*y2,xz=x*z2,yy=y*y2,yz=y*z2,zz=z*z2,wx=w*x2,wy=w*y2,wz=w*z2;
-  out[0]=1-(yy+zz); out[1]=xy+wz;     out[2]=xz-wy;     out[3]=0;
-  out[4]=xy-wz;     out[5]=1-(xx+zz); out[6]=yz+wx;     out[7]=0;
-  out[8]=xz+wy;     out[9]=yz-wx;     out[10]=1-(xx+yy); out[11]=0;
-  out[12]=0;        out[13]=0;        out[14]=0;          out[15]=1;
-  return out;
-};
-
-// Lookat basis scratch — right (0–2), up (3–5), back (6–8): unit, world space.
-const _lb = new Float64Array(9);
-
-/**
- * Orthonormal lookat basis into `_lb`: back = eye − center, right = up × back,
- * up = back × right. When the view direction is parallel to the up hint the
- * hint is re-seeded from the world axis least aligned with it — the seed
- * qFromUnitVectors and qFromLookDir use — so the basis is always a rotation.
- */
-function _lookBasis(ex,ey,ez, cx,cy,cz, ux,uy,uz) {
-  let zx=ex-cx, zy=ey-cy, zz=ez-cz;
-  const zl=Math.sqrt(zx*zx+zy*zy+zz*zz)||1;
-  zx/=zl; zy/=zl; zz/=zl;
-  let xx=uy*zz-uz*zy, xy=uz*zx-ux*zz, xz=ux*zy-uy*zx;
-  let xl=Math.sqrt(xx*xx+xy*xy+xz*xz);
-  if (xl < 1e-8) {                                              // view ∥ up: re-seed up
-    const ax=Math.abs(zx), ay=Math.abs(zy), az=Math.abs(zz);
-    ux=0; uy=0; uz=0;
-    if (ax <= ay && ax <= az) ux=1; else if (ay <= az) uy=1; else uz=1;
-    xx=uy*zz-uz*zy; xy=uz*zx-ux*zz; xz=ux*zy-uy*zx;
-    xl=Math.sqrt(xx*xx+xy*xy+xz*xz)||1;
-  }
-  xx/=xl; xy/=xl; xz/=xl;
-  _lb[0]=xx; _lb[1]=xy; _lb[2]=xz;
-  _lb[3]=zy*xz-zz*xy; _lb[4]=zz*xx-zx*xz; _lb[5]=zx*xy-zy*xx;
-  _lb[6]=zx; _lb[7]=zy; _lb[8]=zz;
-}
-
-/**
- * View matrix (world→eye) from lookat parameters.
- * Camera looks along −Z in eye space; right = normalize(up × (−Z)).
- * Cheaper than building the eye matrix and inverting.
- *
- * @param {Float32Array|number[]} out  16-element destination.
- * @param {number} ex,ey,ez   Eye (camera) position.
- * @param {number} cx,cy,cz   Look-at target.
- * @param {number} ux,uy,uz   World up hint (need not be unit; re-seeded when
- *                            parallel to the view direction).
- */
-function mat4View(out, ex,ey,ez, cx,cy,cz, ux,uy,uz) {
-  _lookBasis(ex,ey,ez, cx,cy,cz, ux,uy,uz);
-  const xx=_lb[0],xy=_lb[1],xz=_lb[2], yx=_lb[3],yy=_lb[4],yz=_lb[5], zx=_lb[6],zy=_lb[7],zz=_lb[8];
-  out[0]=xx;              out[1]=yx;              out[2]=zx;              out[3]=0;
-  out[4]=xy;              out[5]=yy;              out[6]=zy;              out[7]=0;
-  out[8]=xz;              out[9]=yz;              out[10]=zz;             out[11]=0;
-  out[12]=-(xx*ex+xy*ey+xz*ez);
-  out[13]=-(yx*ex+yy*ey+yz*ez);
-  out[14]=-(zx*ex+zy*ey+zz*ez);
-  out[15]=1;
-  return out;
-}
-
-/**
- * Eye matrix (eye→world) from lookat parameters.
- * Transpose of the rotation block + direct translation column.
- * Same parameters as mat4View.
- *
- * @param {Float32Array|number[]} out  16-element destination.
- * @param {number} ex,ey,ez   Eye position.
- * @param {number} cx,cy,cz   Look-at target.
- * @param {number} ux,uy,uz   World up hint (need not be unit; re-seeded when
- *                            parallel to the view direction).
- */
-function mat4Eye(out, ex,ey,ez, cx,cy,cz, ux,uy,uz) {
-  _lookBasis(ex,ey,ez, cx,cy,cz, ux,uy,uz);
-  const xx=_lb[0],xy=_lb[1],xz=_lb[2], yx=_lb[3],yy=_lb[4],yz=_lb[5], zx=_lb[6],zy=_lb[7],zz=_lb[8];
-  out[0]=xx;  out[1]=xy;  out[2]=xz;  out[3]=0;
-  out[4]=yx;  out[5]=yy;  out[6]=yz;  out[7]=0;
-  out[8]=zx;  out[9]=zy;  out[10]=zz; out[11]=0;
-  out[12]=ex; out[13]=ey; out[14]=ez; out[15]=1;
-  return out;
-}
-
-// =========================================================================
-// Projection construction
-// =========================================================================
-
-/**
- * Orthographic projection matrix.
- *
- * @param {Float32Array|number[]} out  16-element destination.
- * @param {number} left,right,bottom,top  Frustum extents.
- * @param {number} near,far              Clip plane distances (positive).
- * @param {number} ndcZMin               −1 (WEBGL) or 0 (WEBGPU).
- * @param {number} [ndcYSign=1]          +1 = NDC y-up (default); −1 = NDC y-down (native Vulkan).
- */
-function mat4Ortho(out, left, right, bottom, top, near, far, ndcZMin, ndcYSign=1) {
-  const rl=1/(right-left), tb=1/(top-bottom), fn=1/(far-near);
-  out[0]=2*rl;              out[1]=0;                       out[2]=0;               out[3]=0;
-  out[4]=0;                 out[5]=ndcYSign*2*tb;           out[6]=0;               out[7]=0;
-  out[8]=0;                 out[9]=0;                       out[10]=(ndcZMin-1)*fn; out[11]=0;
-  out[12]=-(right+left)*rl; out[13]=ndcYSign*(-(top+bottom)*tb);
-  out[14]=(ndcZMin*far-near)*fn;
-  out[15]=1;
-  return out;
-}
-
-/**
- * Perspective projection matrix (general / off-centre frustum).
- * Symmetric case: left=-right, bottom=-top — derive from fov+aspect in user space:
- *   top = near * Math.tan(fov / 2);  right = top * aspect
- *   mat4Persp(out, -right, right, -top, top, near, far, ndcZMin)
- *
- * @param {Float32Array|number[]} out  16-element destination.
- * @param {number} left,right,bottom,top  Near-plane extents (signed, y-up: top>0, bottom<0).
- * @param {number} near,far              Clip plane distances (positive).
- * @param {number} ndcZMin               −1 (WEBGL) or 0 (WEBGPU).
- * @param {number} [ndcYSign=1]          +1 = NDC y-up (default); −1 = NDC y-down (native Vulkan).
- */
-function mat4Persp(out, left, right, bottom, top, near, far, ndcZMin, ndcYSign=1) {
-  const rl=1/(right-left), tb=1/(top-bottom);
-  out[0]=2*near*rl;        out[1]=0;                          out[2]=0;  out[3]=0;
-  out[4]=0;                out[5]=ndcYSign*2*near*tb;         out[6]=0;  out[7]=0;
-  out[8]=(right+left)*rl;  out[9]=ndcYSign*(top+bottom)*tb;
-  out[10]=(ndcZMin*near-far)/(far-near);
-  out[11]=-1;
-  out[12]=0; out[13]=0;
-  out[14]=(ndcZMin-1)*far*near/(far-near);
-  out[15]=0;
-  return out;
-}
-
-/**
- * @file Matrix arithmetic, space-transform dispatch, and projection queries.
- * @module tree/query
- * @license AGPL-3.0-only
- *
- * The operative layer — receives matrices and extracts information.
- * Contrast with form.js which constructs matrices from specs.
- *
- *   form.js  — specs  → matrix
- *   query.js — matrix → information
- *
- * Storage: column-major Float32Array / ArrayLike<number>.
- * Multiply: mat4Mul(out, A, B) = A · B  (standard math order).
- * Pipeline: clip = P · V · M · v
- *
- * ── NDC Z convention ──────────────────────────────────────────────────────
- * Passed as `ndcZMin` to every space-transform function:
- *   WEBGL  = −1   z ∈ [−1,  1]
- *   WEBGPU =  0   z ∈ [ 0,  1]
- *
- * ── NDC Y convention ──────────────────────────────────────────────────────
- * Standard (OpenGL / WebGL / WebGPU browser / Three.js / p5v2):
- *   NDC y-up  — y = +1 at top, y = −1 at bottom.
- * Native Vulkan: NDC y-down — projections constructed with ndcYSign = −1
- * (see form.js).  Query functions are convention-agnostic: they work on
- * whatever matrices are passed in.
- *
- * ── Viewport convention ───────────────────────────────────────────────────
- * vp = [x, y, w, h] — w and h are SIGNED.
- *
- * The sign of h encodes the relationship between NDC y and screen y:
- *   h < 0 (e.g. −canvasH): screen y-DOWN  (DOM / p5 mouseX·mouseY / Vulkan surface)
- *                            NDC y=+1 → screen y=0  (top)
- *                            NDC y=−1 → screen y=H  (bottom)
- *   h > 0 (e.g. +canvasH): screen y-UP   (OpenGL desktop / WebGL gl_FragCoord)
- *                            NDC y=−1 → screen y=0  (bottom)
- *                            NDC y=+1 → screen y=H  (top)
- *
- * Pass [0, canvasH, canvasW, −canvasH] for p5/DOM coordinates.
- * Pass [0, 0, canvasW, canvasH] for WebGL gl_FragCoord / OpenGL bottom-left.
- * All helpers use vp[2]/vp[3] signed — no Math.abs — so both conventions
- * work automatically without any branching.
- *
- * All functions follow the out-first, zero-allocation contract.
- * Returns null on degeneracy (singular matrix, etc.).
- */
-
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Mat4 arithmetic
-// ═══════════════════════════════════════════════════════════════════════════
-
-/** out = A · B  (column-major) */
-function mat4Mul(out, A, B) {
-  const a0=A[0],a1=A[1],a2=A[2],a3=A[3],
-        a4=A[4],a5=A[5],a6=A[6],a7=A[7],
-        a8=A[8],a9=A[9],a10=A[10],a11=A[11],
-        a12=A[12],a13=A[13],a14=A[14],a15=A[15];
-  let b0=B[0],b1=B[1],b2=B[2],b3=B[3];
-  out[0]=a0*b0+a4*b1+a8*b2+a12*b3;
-  out[1]=a1*b0+a5*b1+a9*b2+a13*b3;
-  out[2]=a2*b0+a6*b1+a10*b2+a14*b3;
-  out[3]=a3*b0+a7*b1+a11*b2+a15*b3;
-  b0=B[4];b1=B[5];b2=B[6];b3=B[7];
-  out[4]=a0*b0+a4*b1+a8*b2+a12*b3;
-  out[5]=a1*b0+a5*b1+a9*b2+a13*b3;
-  out[6]=a2*b0+a6*b1+a10*b2+a14*b3;
-  out[7]=a3*b0+a7*b1+a11*b2+a15*b3;
-  b0=B[8];b1=B[9];b2=B[10];b3=B[11];
-  out[8]=a0*b0+a4*b1+a8*b2+a12*b3;
-  out[9]=a1*b0+a5*b1+a9*b2+a13*b3;
-  out[10]=a2*b0+a6*b1+a10*b2+a14*b3;
-  out[11]=a3*b0+a7*b1+a11*b2+a15*b3;
-  b0=B[12];b1=B[13];b2=B[14];b3=B[15];
-  out[12]=a0*b0+a4*b1+a8*b2+a12*b3;
-  out[13]=a1*b0+a5*b1+a9*b2+a13*b3;
-  out[14]=a2*b0+a6*b1+a10*b2+a14*b3;
-  out[15]=a3*b0+a7*b1+a11*b2+a15*b3;
-  return out;
-}
-
-/** out = inverse(src). Returns null if singular (|det| < 1e-12). */
-function mat4Invert(out, src) {
-  const s0=src[0],s1=src[1],s2=src[2],s3=src[3],
-        s4=src[4],s5=src[5],s6=src[6],s7=src[7],
-        s8=src[8],s9=src[9],s10=src[10],s11=src[11],
-        s12=src[12],s13=src[13],s14=src[14],s15=src[15];
-  const b0=s0*s5-s1*s4, b1=s0*s6-s2*s4, b2=s0*s7-s3*s4,
-        b3=s1*s6-s2*s5, b4=s1*s7-s3*s5, b5=s2*s7-s3*s6,
-        b6=s8*s13-s9*s12, b7=s8*s14-s10*s12, b8=s8*s15-s11*s12,
-        b9=s9*s14-s10*s13, b10=s9*s15-s11*s13, b11=s10*s15-s11*s14;
-  let det=b0*b11-b1*b10+b2*b9+b3*b8-b4*b7+b5*b6;
-  if (Math.abs(det) < 1e-12) return null;
-  det = 1/det;
-  out[0]=(s5*b11-s6*b10+s7*b9)*det;
-  out[1]=(s2*b10-s1*b11-s3*b9)*det;
-  out[2]=(s13*b5-s14*b4+s15*b3)*det;
-  out[3]=(s10*b4-s9*b5-s11*b3)*det;
-  out[4]=(s6*b8-s4*b11-s7*b7)*det;
-  out[5]=(s0*b11-s2*b8+s3*b7)*det;
-  out[6]=(s14*b2-s12*b5-s15*b1)*det;
-  out[7]=(s8*b5-s10*b2+s11*b1)*det;
-  out[8]=(s4*b10-s5*b8+s7*b6)*det;
-  out[9]=(s1*b8-s0*b10-s3*b6)*det;
-  out[10]=(s12*b4-s13*b2+s15*b0)*det;
-  out[11]=(s9*b2-s8*b4-s11*b0)*det;
-  out[12]=(s5*b7-s4*b9-s6*b6)*det;
-  out[13]=(s0*b9-s1*b7+s2*b6)*det;
-  out[14]=(s13*b1-s12*b3-s14*b0)*det;
-  out[15]=(s8*b3-s9*b1+s10*b0)*det;
-  return out;
-}
-
-/** out = mat4 * [x,y,z,1], perspective-divides, writes xyz. */
-function mat4MulPoint(out, m, x, y, z) {
-  const rx=m[0]*x+m[4]*y+m[8]*z+m[12], ry=m[1]*x+m[5]*y+m[9]*z+m[13],
-        rz=m[2]*x+m[6]*y+m[10]*z+m[14], rw=m[3]*x+m[7]*y+m[11]*z+m[15];
-  if (rw!==0&&rw!==1) { out[0]=rx/rw; out[1]=ry/rw; out[2]=rz/rw; }
-  else                 { out[0]=rx;    out[1]=ry;    out[2]=rz;    }
-  return out;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Projection queries
-// ═══════════════════════════════════════════════════════════════════════════
-
-/** @returns {boolean} true if orthographic. */
-function projIsOrtho(p) { return p[15] !== 0; }
-
-/**
- * Near plane distance.
- * @param {ArrayLike<number>} p       Projection mat4.
- * @param {number}            ndcZMin WEBGL (−1) or WEBGPU (0).
- */
-function projNear(p, ndcZMin) {
-  return p[15]===0 ? p[14]/(p[10]+ndcZMin) : (p[14]-ndcZMin)/p[10];
-}
-
-/**
- * Top extent of the near plane in camera space (y_max, positive for standard y-up camera).
- * Sign-normalized: returns the larger of the two y boundaries regardless of whether
- * the projection was built with ndcYSign = +1 or −1.
- */
-function projTop(p, ndcZMin) {
-  return p[15]===1
-    ? ( Math.sign(p[5]) - p[13]) / p[5]                    // ortho
-    : projNear(p,ndcZMin)*(Math.sign(p[5])+p[9])/p[5];     // perspective
-}
-
-/**
- * Bottom extent of the near plane in camera space (y_min, negative for standard y-up camera).
- */
-function projBottom(p, ndcZMin) {
-  return p[15]===1
-    ? (-Math.sign(p[5]) - p[13]) / p[5]                    // ortho
-    : projNear(p,ndcZMin)*(p[9]-Math.sign(p[5]))/p[5];     // perspective
-}
-
-/** Vertical field of view in radians (perspective only). */
-function projFov (p) { return Math.abs(2*Math.atan(1/p[5])); }
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Space transforms — mapLocation / mapDirection
-// ═══════════════════════════════════════════════════════════════════════════
-//
-// Flat dispatch: every from→to pair is a self-contained leaf with only stack
-// locals — no reentrancy, no shared state between calls.
-//
-// Matrices bag `m`:
-//   mat4Proj    Float32Array(16)  projection  (eye → clip)
-//   mat4View    Float32Array(16)  view        (world → eye)
-//   mat4Eye?    Float32Array(16)  eye         (eye → world); caller fills before passing
-//   mat4PV?     Float32Array(16)  P · V;      caller fills or _ensurePV allocates once
-//   mat4PVInv?  Float32Array(16)  inv(P · V); caller fills
-//   fromFrame?  Float32Array(16)  MATRIX source frame
-//   toFrameInv? Float32Array(16)  inv(MATRIX dest frame)
-//
-// Viewport `vp` = [x, y, w, h]:
-//   Use SIGNED h to encode screen-y direction (see module header).
-//   Core formula: screen = (ndc*0.5+0.5)*vp[k] + vp[k-2]  (k=2 for x, k=3 for y)
-//   Inverse:      ndc    = ((screen-vp[k-2])/vp[k])*2 - 1
-//   Negative vp[3] flips NDC y-up to screen y-down automatically.
-//
-
-// ── Location helpers ─────────────────────────────────────────────────────
-
-function _worldToScreen(out, px, py, pz, pv, vp, ndcZMin) {
-  const x=pv[0]*px+pv[4]*py+pv[8]*pz+pv[12], y=pv[1]*px+pv[5]*py+pv[9]*pz+pv[13],
-        z=pv[2]*px+pv[6]*py+pv[10]*pz+pv[14], w=pv[3]*px+pv[7]*py+pv[11]*pz+pv[15];
-  const xi=(w!==0&&w!==1)?1/w:1;
-  out[0]=(x*xi*0.5+0.5)*vp[2]+vp[0];
-  out[1]=(y*xi*0.5+0.5)*vp[3]+vp[1];
-  out[2]=(z*xi-ndcZMin)/(1-ndcZMin);
-  return out;
-}
-
-function _screenToWorld(out, sx, sy, sz, ipv, vp, ndcZMin) {
-  return mat4MulPoint(out, ipv,
-    ((sx-vp[0])/vp[2])*2-1,
-    ((sy-vp[1])/vp[3])*2-1,
-    sz*(1-ndcZMin)+ndcZMin);
-}
-
-function _worldToNDC(out, px, py, pz, pv) {
-  const x=pv[0]*px+pv[4]*py+pv[8]*pz+pv[12], y=pv[1]*px+pv[5]*py+pv[9]*pz+pv[13],
-        z=pv[2]*px+pv[6]*py+pv[10]*pz+pv[14], w=pv[3]*px+pv[7]*py+pv[11]*pz+pv[15];
-  const xi=(w!==0&&w!==1)?1/w:1;
-  out[0]=x*xi; out[1]=y*xi; out[2]=z*xi;
-  return out;
-}
-
-function _ensurePV(m) {
-  if (m.mat4PV) return m.mat4PV;
-  m.mat4PV = new Float32Array(16);
-  mat4Mul(m.mat4PV, m.mat4Proj, m.mat4View);
-  return m.mat4PV;
-}
-
-/**
- * Map a point between named coordinate spaces.
- *
- * @param {number[]} out     3-element destination — written and returned.
- * @param {number}   px,py,pz Input point.
- * @param {string}   from    Source space (WORLD, EYE, SCREEN, NDC, MATRIX).
- * @param {string}   to      Destination space.
- * @param {object}   m       Matrices bag — see module header.
- * @param {number[]} vp      Viewport [x, y, w, h]; sign of h encodes screen-y direction.
- * @param {number}   ndcZMin WEBGL (−1) or WEBGPU (0).
- * @returns {number[]} out
- */
-function mapLocation(out, px, py, pz, from, to, m, vp, ndcZMin) {
-  if (to===SCREEN) return _worldToScreen(out,px,py,pz,_ensurePV(m),vp,ndcZMin);
-
-  if (to===NDC)   return _worldToNDC(out,px,py,pz,_ensurePV(m));
-
-  if (to===EYE) return mat4MulPoint(out,m.mat4View,px,py,pz);
-  if (to===MATRIX) return mat4MulPoint(out,m.toFrameInv,px,py,pz);
-
-  out[0]=px; out[1]=py; out[2]=pz;
-  return out;
-}
-
-// ── Direction helpers ────────────────────────────────────────────────────
-//
-// Directions use only the linear 3×3 block — no translation, no w-divide.
-// The signed vp[2]/vp[3] carries the y-convention automatically.
-//
-
-function _applyDir(out, m, dx, dy, dz) {
-  out[0]=m[0]*dx+m[4]*dy+m[8]*dz;
-  out[1]=m[1]*dx+m[5]*dy+m[9]*dz;
-  out[2]=m[2]*dx+m[6]*dy+m[10]*dz;
-  return out;
-}
-
-function _worldToScreenDir(out, dx, dy, dz, proj, view, vpW, vpH, ndcZMin) {
-  const vx=view[0]*dx+view[4]*dy+view[8]*dz,
-        vy=view[1]*dx+view[5]*dy+view[9]*dz,
-        vz=view[2]*dx+view[6]*dy+view[10]*dz;
-  // vpH is signed — negative flips y component automatically.
-  out[0]=(proj[0]*vx+proj[4]*vy+proj[8]*vz)*vpW*0.5;
-  out[1]=(proj[1]*vx+proj[5]*vy+proj[9]*vz)*vpH*0.5;
-  out[2]=(proj[2]*vx+proj[6]*vy+proj[10]*vz)*(1-ndcZMin)*0.5;
-  return out;
-}
-
-function _screenToWorldDir(out, dx, dy, dz, proj, eye, vpW, vpH, ndcZMin) {
-  // Inverse of _worldToScreenDir: undo the viewport scale, then the projection's
-  // upper-triangular 3×3 block (p[8], p[9] carry an off-centre frustum), then
-  // rotate eye→world. Signed vpW/vpH cancel the y-flip.
-  const cz = dz/((1-ndcZMin)*0.5)/proj[10];
-  const cy = (dy/(vpH*0.5) - proj[9]*cz)/proj[5];
-  const cx = (dx/(vpW*0.5) - proj[8]*cz)/proj[0];
-  return _applyDir(out, eye, cx, cy, cz);
-}
-
-function _screenToNDCDir(out, dx, dy, dz, vpW, vpH, ndcZMin) {
-  out[0]=dx/(vpW*0.5); out[1]=dy/(vpH*0.5); out[2]=dz/((1-ndcZMin)*0.5);
-  return out;
-}
-
-function _ndcToScreenDir(out, dx, dy, dz, vpW, vpH, ndcZMin) {
-  out[0]=dx*vpW*0.5; out[1]=dy*vpH*0.5; out[2]=dz*(1-ndcZMin)*0.5;
-  return out;
-}
-
-/**
- * Map a direction between named coordinate spaces.
- * Same bag and viewport contract as mapLocation.
- *
- * @param {number[]} out     3-element destination.
- * @param {number}   dx,dy,dz Input direction.
- * @param {string}   from    Source space.
- * @param {string}   to      Destination space.
- * @param {object}   m       Matrices bag — see module header.
- * @param {number[]} vp      Viewport [x, y, w, h]; sign of h encodes screen-y direction.
- * @param {number}   ndcZMin WEBGL (−1) or WEBGPU (0).
- * @returns {number[]} out
- */
-function mapDirection(out, dx, dy, dz, from, to, m, vp, ndcZMin) {
-  const vpW=vp[2], vpH=vp[3];  // signed — carry y-convention through all helpers
-
-  if (from===EYE   && to===WORLD)  return _applyDir(out,m.mat4Eye, dx,dy,dz);
-  if (from===WORLD && to===EYE)    return _applyDir(out,m.mat4View,dx,dy,dz);
-
-  if (from===WORLD  && to===SCREEN) return _worldToScreenDir(out,dx,dy,dz,m.mat4Proj,m.mat4View,vpW,vpH,ndcZMin);
-  if (from===SCREEN && to===WORLD)  return _screenToWorldDir(out,dx,dy,dz,m.mat4Proj,m.mat4Eye, vpW,vpH,ndcZMin);
-
-  if (from===SCREEN && to===NDC)    return _screenToNDCDir(out,dx,dy,dz,vpW,vpH,ndcZMin);
-  if (from===NDC    && to===SCREEN) return _ndcToScreenDir(out,dx,dy,dz,vpW,vpH,ndcZMin);
-
-  if (from===WORLD && to===NDC) {
-    _worldToScreenDir(out,dx,dy,dz,m.mat4Proj,m.mat4View,vpW,vpH,ndcZMin);
-    return _screenToNDCDir(out,out[0],out[1],out[2],vpW,vpH,ndcZMin);
-  }
-  if (from===NDC && to===WORLD) {
-    _ndcToScreenDir(out,dx,dy,dz,vpW,vpH,ndcZMin);
-    return _screenToWorldDir(out,out[0],out[1],out[2],m.mat4Proj,m.mat4Eye,vpW,vpH,ndcZMin);
-  }
-
-  if (from===EYE && to===SCREEN) {
-    _applyDir(out,m.mat4Eye,dx,dy,dz);
-    return _worldToScreenDir(out,out[0],out[1],out[2],m.mat4Proj,m.mat4View,vpW,vpH,ndcZMin);
-  }
-  if (from===SCREEN && to===EYE) {
-    _screenToWorldDir(out,dx,dy,dz,m.mat4Proj,m.mat4Eye,vpW,vpH,ndcZMin);
-    return _applyDir(out,m.mat4View,out[0],out[1],out[2]);
-  }
-
-  if (from===EYE && to===NDC) {
-    _applyDir(out,m.mat4Eye,dx,dy,dz);
-    _worldToScreenDir(out,out[0],out[1],out[2],m.mat4Proj,m.mat4View,vpW,vpH,ndcZMin);
-    return _screenToNDCDir(out,out[0],out[1],out[2],vpW,vpH,ndcZMin);
-  }
-  if (from===NDC && to===EYE) {
-    _ndcToScreenDir(out,dx,dy,dz,vpW,vpH,ndcZMin);
-    _screenToWorldDir(out,out[0],out[1],out[2],m.mat4Proj,m.mat4Eye,vpW,vpH,ndcZMin);
-    return _applyDir(out,m.mat4View,out[0],out[1],out[2]);
-  }
-
-  if (from===MATRIX && to===WORLD)  return _applyDir(out,m.fromFrame, dx,dy,dz);
-  if (from===WORLD  && to===MATRIX) return _applyDir(out,m.toFrameInv,dx,dy,dz);
-
-  if (from===MATRIX && to===EYE) {
-    _applyDir(out,m.fromFrame,dx,dy,dz);
-    return _applyDir(out,m.mat4View,out[0],out[1],out[2]);
-  }
-  if (from===EYE && to===MATRIX) {
-    _applyDir(out,m.mat4Eye,dx,dy,dz);
-    return _applyDir(out,m.toFrameInv,out[0],out[1],out[2]);
-  }
-
-  if (from===MATRIX && to===SCREEN) {
-    _applyDir(out,m.fromFrame,dx,dy,dz);
-    return _worldToScreenDir(out,out[0],out[1],out[2],m.mat4Proj,m.mat4View,vpW,vpH,ndcZMin);
-  }
-  if (from===SCREEN && to===MATRIX) {
-    _screenToWorldDir(out,dx,dy,dz,m.mat4Proj,m.mat4Eye,vpW,vpH,ndcZMin);
-    return _applyDir(out,m.toFrameInv,out[0],out[1],out[2]);
-  }
-
-  if (from===MATRIX && to===NDC) {
-    _applyDir(out,m.fromFrame,dx,dy,dz);
-    _worldToScreenDir(out,out[0],out[1],out[2],m.mat4Proj,m.mat4View,vpW,vpH,ndcZMin);
-    return _screenToNDCDir(out,out[0],out[1],out[2],vpW,vpH,ndcZMin);
-  }
-  if (from===NDC && to===MATRIX) {
-    _ndcToScreenDir(out,dx,dy,dz,vpW,vpH,ndcZMin);
-    _screenToWorldDir(out,out[0],out[1],out[2],m.mat4Proj,m.mat4Eye,vpW,vpH,ndcZMin);
-    return _applyDir(out,m.toFrameInv,out[0],out[1],out[2]);
-  }
-
-  if (from===MATRIX && to===MATRIX) {
-    _applyDir(out,m.fromFrame,dx,dy,dz);
-    return _applyDir(out,m.toFrameInv,out[0],out[1],out[2]);
-  }
-
-  out[0]=dx; out[1]=dy; out[2]=dz;
-  return out;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Rays and pointer hits
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Screen point → world ray: origin on the near plane (screen depth 0), unit
- * direction toward the far plane (depth 1). Same bag and viewport contract as
- * mapLocation; `m.mat4PVInv` must be filled by the caller.
- *
- * @param {number[]} outO    3-element origin.
- * @param {number[]} outD    3-element unit direction.
- * @param {number}   sx,sy   Screen point.
- * @param {object}   m       Matrices bag — see module header.
- * @param {number[]} vp      Viewport [x, y, w, h]; sign of h encodes screen-y direction.
- * @param {number}   ndcZMin WEBGL (−1) or WEBGPU (0).
- * @returns {number[]|null} outD, or null when the bag carries no mat4PVInv
- *                          (singular P·V) or the ray has no length.
- */
-function unproject(outO, outD, sx, sy, m, vp, ndcZMin) {
-  const ipv = m.mat4PVInv;
-  if (!ipv) return null;
-  _screenToWorld(outO, sx, sy, 0, ipv, vp, ndcZMin);
-  _screenToWorld(outD, sx, sy, 1, ipv, vp, ndcZMin);
-  const dx=outD[0]-outO[0], dy=outD[1]-outO[1], dz=outD[2]-outO[2];
-  const l=Math.sqrt(dx*dx+dy*dy+dz*dz);
-  if (!(l > 0)) return null;
-  outD[0]=dx/l; outD[1]=dy/l; outD[2]=dz/l;
-  return outD;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// pixelRatio
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * World-units-per-pixel at a given eye-space Z depth.
- * @param {ArrayLike<number>} proj    Projection mat4.
- * @param {number}            vpH     Viewport height in pixels (positive).
- * @param {number}            eyeZ    Eye-space Z — negative means in front of camera.
- * @param {number}            ndcZMin WEBGL (−1) or WEBGPU (0).
- */
-function pixelRatio(proj, vpH, eyeZ, ndcZMin) {
-  return projIsOrtho(proj)
-    ? Math.abs(projTop(proj,ndcZMin)-projBottom(proj,ndcZMin)) / vpH
-    : 2*Math.abs(eyeZ)*Math.tan(projFov(proj)/2) / vpH;
-}
-
-/**
- * @file Spline math and keyframe animation state machines.
- * @module tree/track
- * @license AGPL-3.0-only
- *
- * Quaternion algebra is provided by quat.js; projection matrix construction
- * by form.js. Spline helpers (hermiteVec3, lerpVec3) and TRS↔mat4 conversions
- * (transformToMat4, mat4ToTransform) live here because they are tightly
- * coupled to the PoseTrack keyframe shape.
- *
- * Zero dependencies on p5, DOM, WebGL, or WebGPU.
- *
- * ── Exports ──────────────────────────────────────────────────────────────
- *  Quaternion helpers   (re-exported from quat.js)
- *    qSet qCopy qDot qNormalize qNegate qMul qConjugate qRotateVec3
- *    qSlerp qNlerp qFromUnitVectors qFromAxisAngle qFromLookDir
- *    qFromRotMat3x3 qFromMat4 qToMat4 qToAxisAngle
- *  Spline / vector helpers
- *    hermiteVec3  lerpVec3
- *  Transform / mat4 helpers
- *    transformToMat4  mat4ToTransform
- *  Tracks
- *    PoseTrack    — { pos, rot, scl } TRS keyframes
- *    CameraTrack  — { eye, center, up, fov?, halfHeight?, near, far }
- *                   lookat keyframes
- *
- * ── Public path access (all zero-alloc, no cursor side effects) ──────────
- *  PoseTrack
- *    samplePos        (out)  |  (out, seg, t)              vec3
- *    mat4Model        (out)  |  (out, seg, t)              mat4  — TRS model
- *    tangents         (outIn, outOut, index)               vec3 × 2 at keyframe
- *    eval             (out?)                               TRS object at cursor
- *
- *  CameraTrack
- *    sampleEye        (out)  |  (out, seg, t)              vec3
- *    sampleCenter     (out)  |  (out, seg, t)              vec3
- *    mat4Eye          (out)  |  (out, seg, t)              mat4  — lookat frame
- *    eyeTangents      (outIn, outOut, index)               vec3 × 2 at keyframe
- *    centerTangents   (outIn, outOut, index)               vec3 × 2 at keyframe
- *    eval             (out?)                               { eye, center, up,
- *                                                            fov, halfHeight,
- *                                                            near, far }
- *
- *  Two arities for the continuous family:
- *    (out)          cursor form — reads track.seg / track.f. Useful when the
- *                   track's own transport is driving the animation.
- *    (out, seg, t)  explicit form — continuous (seg, t) coordinate, no cursor
- *                   side effects. seg ∈ [0, segments−1] integer, t ∈ [0, 1]
- *                   local to that segment. As a convenience, seg === segments
- *                   is accepted and rewritten to (segments−1, 1) — so the
- *                   idiom sampleX(out, i, 0) uniformly addresses keyframe i
- *                   for every i ∈ [0, keyframes.length−1].
- *
- *  All honour the track's interpolation mode (hermite / linear / step) and
- *  the same stored-tangent → centripetal-CR fallback chain that eval() uses.
- *
- *  `tangents` / `eyeTangents` / `centerTangents` are keyframe-indexed — a
- *  keyframe's incoming tangent belongs to the previous segment, outgoing to
- *  the next. At boundary keyframes the missing side mirrors the present one
- *  so drawing arrows at endpoints always yields a visible vector.
- *
- *  Projection matrices are deliberately not exposed as a track method. Each
- *  CameraTrack keyframe stores `fov` (perspective) or `halfHeight` (ortho)
- *  directly on track.keyframes[i] — callers wanting a projection build one
- *  with the free mat4Persp / mat4Ortho constructors. Animated fov in
- *  sketches flows through the bridge's camera-binding via eval().fov and
- *  eval().halfHeight (the bridge calls cam.perspective() / cam.ortho() each
- *  frame).
- *
- * ── Class hierarchy ──────────────────────────────────────────────────────
- *  Track (unexported, never instantiated directly)
- *    └── PoseTrack   (exported)
- *    └── CameraTrack (exported)
- *
- * ── Hook architecture ────────────────────────────────────────────────────
- *  Lib-space hooks (underscore prefix — host layer / UI layer):
- *    _onActivate / _onDeactivate  — fire on playing false→true / true→false.
- *    _onPlay / _onEnd / _onStop   — mirror the user-space hooks.
- *
- *  User-space hooks:
- *    onPlay : fires in play()  on false→true transition.
- *    onEnd  : fires in tick()  at natural boundary (once mode only).
- *    onStop : fires in stop() / reset().
- *
- *  Firing order:
- *    play()  → onPlay → _onPlay → _onActivate
- *    tick()  → onEnd  → _onEnd  → _onDeactivate
- *    stop()  → onStop → _onStop → _onDeactivate
- *    reset() → onStop → _onStop → _onDeactivate
- *
- * ── Loop modes ───────────────────────────────────────────────────────────
- *  loop:false, bounce:false  — play once, stop at end (fires onEnd)
- *  loop:true,  bounce:false  — repeat, wrap back to start
- *  loop:true,  bounce:true   — bounce forever at boundaries
- *  loop:false, bounce:true   — bounce once: flip at far boundary, stop at origin
- *
- * ── Playback semantics (rate + _dir) ─────────────────────────────────────
- *  rate > 0   forward       rate < 0   backward       rate === 0 frozen
- *
- *  play() is the sole setter of playing = true.
- *  stop() is the sole setter of playing = false.
- *  Assigning rate never starts or stops playback.
- *
- *  _dir (internal, ±1) tracks the current bounce travel direction.
- *  tick() advances by rate * _dir and flips _dir at boundaries.
- *  _dir is reset to 1 only in reset().
- *
- * ── One-keyframe behaviour ───────────────────────────────────────────────
- *  play() with exactly one keyframe snaps eval() to that keyframe without
- *  setting playing = true and without firing hooks.
- */
-
-
-// =========================================================================
-// S2  Spline / vector helpers
-// =========================================================================
-
-function _dist3(a, b) {
-  const dx=a[0]-b[0], dy=a[1]-b[1], dz=a[2]-b[2];
-  return Math.sqrt(dx*dx+dy*dy+dz*dz);
-}
-
-/**
- * Cubic Hermite interpolation between p0 and p1 with explicit tangents.
- * @param {number[]} out  3-element result.
- * @param {number[]} p0   Segment start.
- * @param {number[]} m0   Outgoing tangent at p0.
- * @param {number[]} p1   Segment end.
- * @param {number[]} m1   Incoming tangent at p1.
- * @param {number}   t    Blend [0, 1].
- * @returns {number[]} out
- */
-const hermiteVec3 = (out, p0, m0, p1, m1, t) => {
-  const t2=t*t, t3=t2*t;
-  const h00=2*t3-3*t2+1, h10=t3-2*t2+t, h01=-2*t3+3*t2, h11=t3-t2;
-  out[0]=h00*p0[0]+h10*m0[0]+h01*p1[0]+h11*m1[0];
-  out[1]=h00*p0[1]+h10*m0[1]+h01*p1[1]+h11*m1[1];
-  out[2]=h00*p0[2]+h10*m0[2]+h01*p1[2]+h11*m1[2];
-  return out;
-};
-
-// Centripetal CR outgoing tangent at p1 for segment p1→p2.
-// Signature: (out, p0, p1, p2). Returns tangent AT p1 (the middle point).
-const _crTanOut = (out, p0, p1, p2) => {
-  const dt0=Math.pow(_dist3(p0,p1),0.5)||1, dt1=Math.pow(_dist3(p1,p2),0.5)||1;
-  for (let i=0;i<3;i++) out[i]=((p1[i]-p0[i])/dt0-(p2[i]-p0[i])/(dt0+dt1)+(p2[i]-p1[i])/dt1)*dt1;
-  return out;
-};
-
-// Centripetal CR incoming tangent at p2 for segment p1→p2.
-// Signature: (out, p1, p2, p3). Returns tangent AT p2 (the middle point).
-const _crTanIn = (out, p1, p2, p3) => {
-  const dt1=Math.pow(_dist3(p1,p2),0.5)||1, dt2=Math.pow(_dist3(p2,p3),0.5)||1;
-  for (let i=0;i<3;i++) out[i]=((p2[i]-p1[i])/dt1-(p3[i]-p1[i])/(dt1+dt2)+(p3[i]-p2[i])/dt2)*dt1;
-  return out;
-};
-
-// Module-level scratch — shared across track instances (non-reentrant hot path).
-const _m0=[0,0,0], _m1=[0,0,0];
-const _trsScratch = { pos:[0,0,0], rot:[0,0,0,1], scl:[1,1,1] };
-const _eyeScratch = { eye:[0,0,0], center:[0,0,0], up:[0,1,0] };
-
-/**
- * Linear interpolation between two vec3s.
- */
-const lerpVec3 = (out, a, b, t) => {
-  out[0]=a[0]+t*(b[0]-a[0]);
-  out[1]=a[1]+t*(b[1]-a[1]);
-  out[2]=a[2]+t*(b[2]-a[2]);
-  return out;
-};
-
-// =========================================================================
-// S2b  Path samplers — shared core
-// =========================================================================
-
-/** @private — sample interpolated vec3 path at (seg, t) into out. */
-function _samplePathCore(out, kfs, interp, field, tanInName, tanOutName, seg, t) {
-  const n = kfs.length;
-  if (n === 0) { out[0]=0; out[1]=0; out[2]=0; return out; }
-  if (n === 1) {
-    const p = kfs[0][field];
-    out[0]=p[0]; out[1]=p[1]; out[2]=p[2];
-    return out;
-  }
-  const nSeg = n - 1;
-  seg = seg | 0;
-  if (seg >= nSeg) { seg = nSeg - 1; t = 1; }
-  else if (seg < 0) { seg = 0; t = 0; }
-  t   = _clamp01(t);
-  const k0 = kfs[seg];
-  const k1 = kfs[seg + 1];
-
-  if (interp === 'step') {
-    const p = k0[field];
-    out[0]=p[0]; out[1]=p[1]; out[2]=p[2];
-    return out;
-  }
-  if (interp === 'linear') {
-    return lerpVec3(out, k0[field], k1[field], t);
-  }
-
-  const p0 = seg > 0      ? kfs[seg - 1][field] : k0[field];
-  const p3 = seg + 2 < n  ? kfs[seg + 2][field] : k1[field];
-  const m0 = k0[tanOutName] != null ? k0[tanOutName]
-           : k0[tanInName]  != null ? k0[tanInName]
-           : _crTanOut(_m0, p0, k0[field], k1[field]);
-  const m1 = k1[tanInName]  != null ? k1[tanInName]
-           : k1[tanOutName] != null ? k1[tanOutName]
-           : _crTanIn(_m1, k0[field], k1[field], p3);
-  return hermiteVec3(out, k0[field], m0, k1[field], m1, t);
-}
-
-/** @private — write effective in/out tangents at keyframe i. */
-function _sampleTangentsCore(outIn, outOut, kfs, field, tanInName, tanOutName, i) {
-  const n = kfs.length;
-  if (n === 0) {
-    outIn[0]=outIn[1]=outIn[2]=0; outOut[0]=outOut[1]=outOut[2]=0;
-    return;
-  }
-  i = _clampS(i | 0, 0, n - 1);
-  const ki = kfs[i];
-  const hasTI = ki[tanInName]  != null;
-  const hasTO = ki[tanOutName] != null;
-
-  if (hasTO) {
-    outOut[0]=ki[tanOutName][0]; outOut[1]=ki[tanOutName][1]; outOut[2]=ki[tanOutName][2];
-  } else if (hasTI) {
-    outOut[0]=ki[tanInName][0];  outOut[1]=ki[tanInName][1];  outOut[2]=ki[tanInName][2];
-  } else if (i < n - 1) {
-    const k1 = kfs[i + 1];
-    const p0 = i > 0 ? kfs[i - 1][field] : ki[field];
-    _crTanOut(outOut, p0, ki[field], k1[field]);
-  } else {
-    outOut[0]=0; outOut[1]=0; outOut[2]=0;
-  }
-
-  if (hasTI) {
-    outIn[0]=ki[tanInName][0];  outIn[1]=ki[tanInName][1];  outIn[2]=ki[tanInName][2];
-  } else if (hasTO) {
-    outIn[0]=ki[tanOutName][0]; outIn[1]=ki[tanOutName][1]; outIn[2]=ki[tanOutName][2];
-  } else if (i > 0) {
-    const k0 = kfs[i - 1];
-    const p3 = i + 1 < n ? kfs[i + 1][field] : ki[field];
-    _crTanIn(outIn, k0[field], ki[field], p3);
-  } else {
-    outIn[0]=outOut[0]; outIn[1]=outOut[1]; outIn[2]=outOut[2];
-  }
-
-  if (i === n - 1 && !hasTO && !hasTI) {
-    outOut[0]=outIn[0]; outOut[1]=outIn[1]; outOut[2]=outIn[2];
-  }
-}
-
-// =========================================================================
-// S3  Transform <-> Mat4
-// =========================================================================
-
-/**
- * Write a TRS transform into a column-major mat4.
- */
-const transformToMat4 = (out, xform) => {
-  qToMat4(out, xform.rot);
-  const sx=xform.scl[0], sy=xform.scl[1], sz=xform.scl[2];
-  out[0]*=sx; out[1]*=sx; out[2]*=sx;
-  out[4]*=sy; out[5]*=sy; out[6]*=sy;
-  out[8]*=sz; out[9]*=sz; out[10]*=sz;
-  out[12]=xform.pos[0]; out[13]=xform.pos[1]; out[14]=xform.pos[2];
-  return out;
-};
-
-/**
- * Decompose a column-major mat4 into a TRS transform.
- */
-const mat4ToTransform = (out, m) => {
-  out.pos[0]=m[12]; out.pos[1]=m[13]; out.pos[2]=m[14];
-  const sx=Math.sqrt(m[0]*m[0]+m[1]*m[1]+m[2]*m[2]);
-  const sy=Math.sqrt(m[4]*m[4]+m[5]*m[5]+m[6]*m[6]);
-  const sz=Math.sqrt(m[8]*m[8]+m[9]*m[9]+m[10]*m[10]);
-  out.scl[0]=sx; out.scl[1]=sy; out.scl[2]=sz;
-  qFromRotMat3x3(out.rot,
-    m[0]/sx,m[4]/sy,m[8]/sz,
-    m[1]/sx,m[5]/sy,m[9]/sz,
-    m[2]/sx,m[6]/sy,m[10]/sz);
-  return out;
-};
-
-// =========================================================================
-// S4a  Spec parser — PoseTrack
-// =========================================================================
-
-const _isNum$1   = (x) => typeof x === 'number' && Number.isFinite(x);
-const _clamp01 = (x) => x < 0 ? 0 : (x > 1 ? 1 : x);
-const _clampS  = (x, lo, hi) => x < lo ? lo : (x > hi ? hi : x);
-
-function _parseVec3(v) {
-  if (!v) return null;
-  if (ArrayBuffer.isView(v) && v.length >= 3) return [v[0], v[1], v[2]];
-  if (Array.isArray(v) && v.length >= 3 && v.every(n => typeof n === 'number')) return [v[0], v[1], v[2]];
-  if (typeof v === 'object' && 'x' in v) return [v.x || 0, v.y || 0, v.z || 0];
-  return null;
-}
-
-const _EULER_AXES   = { X:[1,0,0], Y:[0,1,0], Z:[0,0,1] };
-const _EULER_ORDERS = new Set(['XYZ','XZY','YXZ','YZX','ZXY','ZYX']);
-
-/**
- * Parse any rotation representation into a unit quaternion [x,y,z,w].
- *
- * Accepted forms:
- *   [x,y,z,w]                        — raw quaternion array
- *   { axis:[x,y,z], angle }          — axis-angle (angle in radians)
- *   { dir:[x,y,z], up?:[x,y,z] }     — forward direction (−Z) with optional up
- *   { mat4Eye: mat4 }                — rotation block of an eye matrix
- *   { mat3: mat3 }                   — column-major 3×3 rotation matrix
- *   { euler:[rx,ry,rz], order? }     — intrinsic Euler (default order: YXZ)
- *   { from:[x,y,z], to:[x,y,z] }     — shortest-arc rotation between two vectors
- *
- * @param {*} v
- * @returns {number[]|null}  [x,y,z,w] or null if unparseable.
- */
-function _parseQuat(v) {
-  if (!v) return null;
-
-  // [x,y,z,w] — normalised like every other form
-  if (Array.isArray(v) && v.length === 4) return qNormalize([v[0],v[1],v[2],v[3]]);
-  if (ArrayBuffer.isView(v) && v.length >= 4) return qNormalize([v[0],v[1],v[2],v[3]]);
-
-  if (typeof v !== 'object') return null;
-
-  // { axis, angle }
-  if (v.axis != null && v.angle != null) {
-    const ax = Array.isArray(v.axis) ? v.axis : [v.axis.x||0, v.axis.y||0, v.axis.z||0];
-    return qFromAxisAngle([0,0,0,1], ax[0],ax[1],ax[2], v.angle);
-  }
-
-  // { dir, up? }
-  if (v.dir != null) {
-    const d = Array.isArray(v.dir) ? v.dir : [v.dir.x||0, v.dir.y||0, v.dir.z||0];
-    const u = v.up ? (Array.isArray(v.up) ? v.up : [v.up.x||0, v.up.y||0, v.up.z||0]) : null;
-    return qFromLookDir([0,0,0,1], d, u);
-  }
-
-  // { mat4Eye }
-  if (v.mat4Eye != null) {
-    const m = (ArrayBuffer.isView(v.mat4Eye) || Array.isArray(v.mat4Eye))
-      ? v.mat4Eye : (v.mat4Eye.mat4 ?? null);
-    if (!m || m.length < 16) return null;
-    return qFromRotMat3x3([0,0,0,1], m[0],m[4],m[8], m[1],m[5],m[9], m[2],m[6],m[10]);
-  }
-
-  // { mat3 }
-  if (v.mat3 != null) {
-    const m = (ArrayBuffer.isView(v.mat3) || Array.isArray(v.mat3)) ? v.mat3 : null;
-    if (!m || m.length < 9) return null;
-    return qFromRotMat3x3([0,0,0,1], m[0],m[3],m[6], m[1],m[4],m[7], m[2],m[5],m[8]);
-  }
-
-  // { euler, order? }
-  if (v.euler != null) {
-    const e = v.euler;
-    if (!Array.isArray(e) || e.length < 3) return null;
-    const order = (v.order && _EULER_ORDERS.has(v.order)) ? v.order : 'YXZ';
-    const q = [0,0,0,1], s = [0,0,0,1];
-    for (let i = 0; i < 3; i++) {
-      const ax = _EULER_AXES[order[i]];
-      qMul(q, q, qFromAxisAngle(s, ax[0],ax[1],ax[2], e[i]));
-    }
-    return q;
-  }
-
-  // { from, to }
-  if (v.from != null && v.to != null) {
-    const f = Array.isArray(v.from) ? v.from : [v.from.x||0, v.from.y||0, v.from.z||0];
-    const t = Array.isArray(v.to)   ? v.to   : [v.to.x||0,   v.to.y||0,   v.to.z||0];
-    const fl = Math.sqrt(f[0]*f[0]+f[1]*f[1]+f[2]*f[2]) || 1;
-    const tl = Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]) || 1;
-    const fx=f[0]/fl, fy=f[1]/fl, fz=f[2]/fl;
-    const tx=t[0]/tl, ty=t[1]/tl, tz=t[2]/tl;
-    const dot = fx*tx + fy*ty + fz*tz;
-    if (dot >= 1 - 1e-8) return [0,0,0,1];
-    if (dot <= -1 + 1e-8) {
-      let px=0, py=fz, pz=-fy;
-      let pl = Math.sqrt(px*px+py*py+pz*pz);
-      if (pl < 1e-8) { px=fy; py=-fx; pz=0; pl = Math.sqrt(px*px+py*py+pz*pz); }
-      if (pl < 1e-8) return [0,0,0,1];
-      return qFromAxisAngle([0,0,0,1], px/pl,py/pl,pz/pl, Math.PI);
-    }
-    let ax=fy*tz-fz*ty, ay=fz*tx-fx*tz, az=fx*ty-fy*tx;
-    const al = Math.sqrt(ax*ax+ay*ay+az*az) || 1;
-    return qFromAxisAngle([0,0,0,1], ax/al,ay/al,az/al,
-      Math.acos(Math.max(-1, Math.min(1, dot))));
-  }
-
-  return null;
-}
-
-/**
- * Parse a PoseTrack keyframe spec into internal form.
- *
- * Accepted forms:
- *   { mat4Model }
- *     Decompose a column-major mat4 into TRS via mat4ToTransform.
- *     Float32Array(16), plain Array, or { mat4 } wrapper.
- *
- *   { pos?, rot?, scl?, tanIn?, tanOut? }
- *     Explicit TRS. pos and scl are vec3; rot accepts any form from _parseQuat.
- *     All fields are optional — missing pos/scl default to [0,0,0] / [1,1,1],
- *     missing rot defaults to identity.
- *     tanIn/tanOut are optional vec3 tangents for Hermite interpolation.
- *
- * @param {Object} spec
- * @returns {{ pos:number[], rot:number[], scl:number[],
- *             tanIn:number[]|null, tanOut:number[]|null } | null}
- */
-function _parseSpec(spec) {
-  if (!spec || typeof spec !== 'object') return null;
-
-  // { mat4Model } — full TRS decomposition from model matrix
-  if (spec.mat4Model != null) {
-    const m = (ArrayBuffer.isView(spec.mat4Model) || Array.isArray(spec.mat4Model))
-      ? spec.mat4Model : (spec.mat4Model.mat4 ?? null);
-    if (!m || m.length < 16) return null;
-    const kf = mat4ToTransform({ pos:[0,0,0], rot:[0,0,0,1], scl:[1,1,1] }, m);
-    kf.tanIn = null; kf.tanOut = null;
-    return kf;
-  }
-
-  // { pos?, rot?, scl?, tanIn?, tanOut? } — explicit TRS
-  const pos    = _parseVec3(spec.pos)    || [0,0,0];
-  const rot    = _parseQuat(spec.rot)    || [0,0,0,1];
-  const scl    = _parseVec3(spec.scl)    || [1,1,1];
-  const tanIn  = _parseVec3(spec.tanIn)  || null;
-  const tanOut = _parseVec3(spec.tanOut) || null;
-  return { pos, rot, scl, tanIn, tanOut };
-}
-
-function _sameTransform(a, b) {
-  for (let i=0;i<3;i++) if (a.pos[i]!==b.pos[i]||a.scl[i]!==b.scl[i]) return false;
-  for (let i=0;i<4;i++) if (a.rot[i]!==b.rot[i]) return false;
-  return true;
-}
-
-// =========================================================================
-// S4b  Spec parser — CameraTrack
-// =========================================================================
-
-// Lens defaults used when a spec omits near/far. Match the three.js /
-// Bevy conventions and are safe for typical p5 v2 scene scales.
-const _DEFAULT_NEAR = 0.1;
-const _DEFAULT_FAR  = 1000;
-
-/**
- * Parse a CameraTrack keyframe spec into internal form.
- *
- * Required: eye (vec3). Everything else is optional.
- *   center       defaults to [0, 0, 0]
- *   up           defaults to [0, 1, 0] and is normalised
- *   fov          vertical fov (radians), perspective only — null if absent
- *   halfHeight   world-unit half-height of ortho frustum — null if absent
- *   near         near clip distance (positive) — defaults to 0.1
- *   far          far  clip distance (positive) — defaults to 1000
- *   eyeTanIn/Out       optional Hermite tangents for the eye path
- *   centerTanIn/Out    optional Hermite tangents for the center path
- *
- * fov and halfHeight are mutually exclusive (perspective xor ortho) and
- * therefore left nullable; eval() lerps each only when both adjacent
- * keyframes carry a non-null value, passing null through otherwise.
- *
- * near and far are always meaningful regardless of projection type, so
- * they receive real defaults and are linearly interpolated unconditionally.
- *
- * @param {Object} spec
- * @returns {Object|null}  Parsed keyframe or null if eye is missing/malformed.
- */
-function _parseCameraSpec(spec) {
-  if (!spec || typeof spec !== 'object') return null;
-  const eye = _parseVec3(spec.eye);
-  if (!eye) return null;
-  const center = _parseVec3(spec.center) || [0,0,0];
-  const upRaw  = spec.up ? _parseVec3(spec.up) : null;
-  const up     = upRaw || [0,1,0];
-  const ul     = Math.sqrt(up[0]*up[0]+up[1]*up[1]+up[2]*up[2]) || 1;
-  return {
-    eye, center,
-    up: [up[0]/ul, up[1]/ul, up[2]/ul],
-    fov:          typeof spec.fov        === 'number' ? spec.fov        : null,
-    halfHeight:   typeof spec.halfHeight === 'number' ? spec.halfHeight : null,
-    near:         typeof spec.near       === 'number' ? spec.near       : _DEFAULT_NEAR,
-    far:          typeof spec.far        === 'number' ? spec.far        : _DEFAULT_FAR,
-    eyeTanIn:     _parseVec3(spec.eyeTanIn)    || null,
-    eyeTanOut:    _parseVec3(spec.eyeTanOut)   || null,
-    centerTanIn:  _parseVec3(spec.centerTanIn) || null,
-    centerTanOut: _parseVec3(spec.centerTanOut)|| null,
-  };
-}
-
-function _sameCameraKeyframe(a, b) {
-  for (let i=0;i<3;i++) {
-    if (a.eye[i]!==b.eye[i]) return false;
-    if (a.center[i]!==b.center[i]) return false;
-    if (a.up[i]!==b.up[i]) return false;
-  }
-  if (a.fov !== b.fov) return false;
-  if (a.halfHeight !== b.halfHeight) return false;
-  if (a.near !== b.near) return false;
-  if (a.far  !== b.far)  return false;
-  return true;
-}
-
-// =========================================================================
-// S5  Track — unexported base class (transport machinery only)
-// =========================================================================
-
-class Track {
-  constructor() {
-    /** @type {Array} Keyframe array — shape depends on subclass. */
-    this.keyframes = [];
-    /** Whether playback is currently active. @type {boolean} */
-    this.playing   = false;
-    /** Loop at boundaries. @type {boolean} */
-    this.loop      = false;
-    /** Ping-pong bounce at boundaries (independent of loop). @type {boolean} */
-    this.bounce    = false;
-    /** Frames per segment (≥1). @type {number} */
-    this.duration  = 30;
-    /** Current segment index. @type {number} */
-    this.seg       = 0;
-    /** Frame offset within current segment (can be fractional). @type {number} */
-    this.f         = 0;
-
-    // Playback rate (signed: negative = reverse; 0 = frozen).
-    this._rate = 1;
-    // Current bounce travel direction (±1). Reset to 1 only on reset().
-    this._dir  = 1;
-    // Whether a bounce-once has already flipped direction.
-    this._bounced = false;
-
-    /** User hook: fires on play() false→true transition. @type {Function|null} */
-    this.onPlay = null;
-    /** User hook: fires on natural boundary in once mode. @type {Function|null} */
-    this.onEnd  = null;
-    /** User hook: fires on stop() / reset() / end-of-bounce-once. @type {Function|null} */
-    this.onStop = null;
-
-    // Lib-space hooks (underscore prefix — host layer / UI layer only).
-    this._onActivate = null; this._onDeactivate = null;
-    this._onPlay     = null; this._onEnd         = null; this._onStop = null;
-  }
-
-  /** Playback rate. Signed: negative reverses, 0 freezes. Assigning never starts or stops playback. @type {number} */
-  get rate()  { return this._rate; }
-  set rate(v) { this._rate = (_isNum$1(v)) ? v : 1; }
-
-  /** Number of interpolatable segments (keyframes.length − 1, min 0). @type {number} */
-  get segments() { return Math.max(0, this.keyframes.length - 1); }
-
-  /**
-   * @private — resolve cursor (seg, f) into continuous (seg, t).
-   * Shared backing of every cursor-form sampler / matrix method.
-   */
-  _cursorSegT() {
-    const nSeg = this.segments;
-    const dur  = Math.max(1, this.duration | 0);
-    const seg  = nSeg > 0 ? _clampS(this.seg, 0, nSeg - 1) : 0;
-    const t    = _clamp01(this.f / dur);
-    return [seg, t];
-  }
-
-  /**
-   * Start or update playback. Sole setter of `playing = true`.
-   *
-   * Fires `onPlay → _onPlay → _onActivate` only on a false→true transition.
-   * Zero keyframes: no-op. Exactly one keyframe: snaps eval() to it but does
-   * not set `playing` and fires no hooks.
-   *
-   * @param {number|{duration?:number,loop?:boolean,bounce?:boolean,
-   *                 rate?:number,onPlay?:Function,onEnd?:Function,
-   *                 onStop?:Function}} [rateOrOpts]
-   *        A bare number is taken as `rate`; an object configures multiple
-   *        fields in one call.
-   * @returns {Track} this
-   */
-  play(rateOrOpts) {
-    if (this.keyframes.length === 0) return this;
-    if (this.keyframes.length === 1) { this.seg = 0; this.f = 0; return this; }
-
-    if (typeof rateOrOpts === 'number' && Number.isFinite(rateOrOpts)) {
-      this._rate = rateOrOpts;
-    } else if (rateOrOpts && typeof rateOrOpts === 'object') {
-      const o = rateOrOpts;
-      if (_isNum$1(o.duration))             this.duration = Math.max(1, o.duration | 0);
-      if ('loop'   in o) this.loop   = !!o.loop;
-      if ('bounce' in o) this.bounce = !!o.bounce;
-      if (typeof o.onPlay === 'function') this.onPlay = o.onPlay;
-      if (typeof o.onEnd  === 'function') this.onEnd  = o.onEnd;
-      if (typeof o.onStop === 'function') this.onStop = o.onStop;
-      if (_isNum$1(o.rate))                 this._rate  = o.rate;
-    }
-
-    const nSeg = this.segments, dur = Math.max(1, this.duration | 0);
-    if (this.seg < 0)     this.seg = 0;
-    if (this.seg >= nSeg) this.seg = nSeg - 1;
-    if (this.f   < 0)     this.f   = 0;
-    if (this.f   > dur)   this.f   = dur;
-
-    const wasPlaying = this.playing;
-    this.playing = true;
-    if (!wasPlaying) {
-      this._bounced = false;
-      if (typeof this.onPlay === 'function') { try { this.onPlay(this); } catch (_) {} }
-      this._onPlay?.();
-      this._onActivate?.();
-    }
-    return this;
-  }
-
-  /**
-   * Stop playback. Sole setter of `playing = false`. Fires
-   * `onStop → _onStop → _onDeactivate` on a true→false transition.
-   *
-   * @param {boolean} [rewind]  If true, seek to the origin end after stopping
-   *                            (0 when playing forward, 1 when playing backward).
-   * @returns {Track} this
-   */
-  stop(rewind) {
-    const wasPlaying = this.playing;
-    this.playing = false;
-    if (wasPlaying) {
-      this._bounced = false;
-      if (typeof this.onStop === 'function') { try { this.onStop(this); } catch (_) {} }
-      this._onStop?.();
-      this._onDeactivate?.();
-      if (rewind && this.keyframes.length > 1) this.seek(this._rate * this._dir < 0 ? 1 : 0);
-    }
-    return this;
-  }
-
-  /**
-   * Clear all keyframes and stop. Fires stop-side hooks if it was playing.
-   * Unlike stop(), this also resets `_dir` to +1.
-   * @returns {Track} this
-   */
-  reset() {
-    const wasPlaying = this.playing;
-    this.playing = false;
-    if (wasPlaying) {
-      if (typeof this.onStop === 'function') { try { this.onStop(this); } catch (_) {} }
-      this._onStop?.();
-      this._onDeactivate?.();
-    }
-    this.keyframes.length = 0;
-    this.seg = 0; this.f = 0; this._dir = 1; this._bounced = false;
-    return this;
-  }
-
-  /**
-   * Remove the keyframe at `index`. Adjusts the cursor if the removal shrinks
-   * the track below the current segment.
-   * @param {number} index
-   * @returns {boolean}  true if removed; false if index was invalid.
-   */
-  remove(index) {
-    if (!_isNum$1(index)) return false;
-    const i = index | 0;
-    if (i < 0 || i >= this.keyframes.length) return false;
-    this.keyframes.splice(i, 1);
-    const nSeg = this.segments;
-    if (nSeg === 0) { this.seg = 0; this.f = 0; }
-    else if (this.seg >= nSeg) { this.seg = nSeg - 1; }
-    return true;
-  }
-
-  /**
-   * Move the cursor.
-   *   seek(t)            Scrub to normalised position t ∈ [0, 1] across the
-   *                      whole track.
-   *   seek(t, segIndex)  Position within a specific segment — t is local to
-   *                      that segment.
-   * Does not affect `playing`.
-   *
-   * @param {number} t
-   * @param {number} [segIndex]
-   * @returns {Track} this
-   */
-  seek(t, segIndex) {
-    const nSeg = this.segments;
-    if (nSeg === 0) { this.seg = 0; this.f = 0; return this; }
-    const dur = Math.max(1, this.duration | 0);
-    if (_isNum$1(segIndex)) {
-      this.seg = _clampS(segIndex | 0, 0, nSeg - 1);
-      this.f   = _clamp01(t) * dur;
-    } else {
-      this._setCursorFromScalar(_clamp01(t) * nSeg * dur);
-    }
-    return this;
-  }
-
-  /**
-   * Normalised cursor position across the whole track.
-   * @returns {number}  ∈ [0, 1]; 0 when there are no segments.
-   */
-  time() {
-    const nSeg = this.segments;
-    if (nSeg === 0) return 0;
-    const dur = Math.max(1, this.duration | 0);
-    return _clamp01((this.seg * dur + this.f) / (nSeg * dur));
-  }
-
-  /**
-   * Snapshot of transport state. Allocates a new object per call — intended
-   * for UI / debugging, not hot loops.
-   * @returns {{keyframes:number, segments:number, seg:number, f:number,
-   *            playing:boolean, loop:boolean, bounce:boolean, rate:number,
-   *            duration:number, time:number}}
-   */
-  info() {
-    return {
-      keyframes: this.keyframes.length,
-      segments:  this.segments,
-      seg:       this.seg,
-      f:         this.f,
-      playing:   this.playing,
-      loop:      this.loop,
-      bounce:    this.bounce,
-      rate:      this._rate,
-      duration:  this.duration,
-      time:      this.segments > 0 ? this.time() : 0
-    };
-  }
-
-  /**
-   * Advance the cursor by `rate * _dir` in frames. Handles loop / bounce /
-   * once modes per the table in the module header. Fires `onEnd → _onEnd →
-   * _onDeactivate` at a natural boundary in once mode.
-   *
-   * Intended to be called once per animation frame by the bridge / UI layer.
-   * rate === 0 freezes the cursor but keeps `playing` unchanged.
-   *
-   * @returns {boolean}  Current `playing` state after advancing.
-   */
-  tick() {
-    if (!this.playing) return false;
-    const nSeg = this.segments;
-    if (nSeg === 0) { this.playing = false; this._onDeactivate?.(); return false; }
-    if (this._rate === 0) return true;
-
-    const dur   = Math.max(1, this.duration | 0);
-    const total = nSeg * dur;
-    const s     = _clampS(this.seg * dur + this.f, 0, total);
-    const next  = s + this._rate * this._dir;
-
-    if (this.loop && this.bounce) {
-      let pos = next, flips = 0;
-      while (pos < 0 || pos > total) {
-        if (pos < 0) { pos = -pos; flips++; }
-        else         { pos = 2 * total - pos; flips++; }
-      }
-      if (flips & 1) this._dir = -this._dir;
-      this._setCursorFromScalar(pos);
-      return true;
-    }
-
-    if (!this.loop && this.bounce) {
-      if (next >= total) {
-        this._setCursorFromScalar(Math.min(total, 2 * total - next));
-        this._dir = -this._dir;
-        this._bounced = true;
-        return true;
-      }
-      if (next <= 0) {
-        this._setCursorFromScalar(0);
-        this.playing = false;
-        this._dir = 1; this._bounced = false;
-        if (typeof this.onEnd === 'function') { try { this.onEnd(this); } catch (_) {} }
-        this._onEnd?.();
-        this._onDeactivate?.();
-        return false;
-      }
-      this._setCursorFromScalar(next);
-      return true;
-    }
-
-    if (this.loop) {
-      this._setCursorFromScalar(((next % total) + total) % total);
-      return true;
-    }
-
-    if (next <= 0) {
-      this._setCursorFromScalar(0);
-      this.playing = false;
-      if (typeof this.onEnd === 'function') { try { this.onEnd(this); } catch (_) {} }
-      this._onEnd?.();
-      this._onDeactivate?.();
-      return false;
-    }
-    if (next >= total) {
-      this._setCursorFromScalar(total);
-      this.playing = false;
-      if (typeof this.onEnd === 'function') { try { this.onEnd(this); } catch (_) {} }
-      this._onEnd?.();
-      this._onDeactivate?.();
-      return false;
-    }
-
-    this._setCursorFromScalar(next);
-    return true;
-  }
-
-  /** @private */
-  _setCursorFromScalar(s) {
-    const dur  = Math.max(1, this.duration | 0);
-    const nSeg = this.segments;
-    this.seg = Math.floor(s / dur);
-    this.f   = s - this.seg * dur;
-    if (this.seg >= nSeg) { this.seg = nSeg - 1; this.f = dur; }
-    if (this.seg < 0)     { this.seg = 0;         this.f = 0;   }
-  }
-}
-
-// =========================================================================
-// S6  PoseTrack
-// =========================================================================
-
-/**
- * Renderer-agnostic TRS keyframe track.
- *
- * Keyframe shape: { pos:[x,y,z], rot:[x,y,z,w], scl:[x,y,z],
- *                   tanIn?:[x,y,z], tanOut?:[x,y,z] }
- *
- * tanIn  — incoming position tangent at this keyframe (Hermite mode).
- * tanOut — outgoing position tangent at this keyframe (Hermite mode).
- * When only one is supplied, the other mirrors it at sample time.
- * When neither is supplied, centripetal Catmull-Rom tangents are auto-computed.
- */
-class PoseTrack extends Track {
-  constructor() {
-    super();
-    /**
-     * Position interpolation mode.
-     * - 'hermite' — cubic Hermite; auto-computes centripetal Catmull-Rom
-     *               tangents when none are stored (default)
-     * - 'linear'  — lerp
-     * - 'step'    — snap to k0; useful for discrete state changes
-     * @type {'hermite'|'linear'|'step'}
-     */
-    this.posInterp = 'hermite';
-    /**
-     * Rotation interpolation mode.
-     * - 'slerp'  — constant angular velocity (default)
-     * - 'nlerp'  — normalised lerp; cheaper, slightly non-constant speed
-     * - 'step'   — snap to k0 quaternion
-     * @type {'slerp'|'nlerp'|'step'}
-     */
-    this.rotInterp = 'slerp';
-  }
-
-  /**
-   * Append one or more keyframes. Adjacent duplicates are skipped by default.
-   * Accepts any spec form understood by _parseSpec, or an array of them.
-   * @param {Object|Object[]} spec
-   * @param {{ deduplicate?: boolean }} [opts]
-   */
-  add(spec, opts) {
-    if (Array.isArray(spec)) { for (const s of spec) this.add(s, opts); return; }
-    const kf = _parseSpec(spec);
-    if (!kf) return;
-    const dedup = !opts || opts.deduplicate !== false;
-    if (dedup && this.keyframes.length > 0) {
-      if (_sameTransform(this.keyframes[this.keyframes.length - 1], kf)) return;
-    }
-    this.keyframes.push(kf);
-  }
-
-  /**
-   * Replace the keyframe at `index`, or append at the end if `index` equals
-   * the current keyframe count.
-   * @param {number} index
-   * @param {Object} spec  Any spec form understood by _parseSpec.
-   * @returns {boolean}  true on success; false for invalid index or spec.
-   */
-  set(index, spec) {
-    if (!_isNum$1(index)) return false;
-    const i = index | 0, kf = _parseSpec(spec);
-    if (!kf || i < 0 || i > this.keyframes.length) return false;
-    if (i === this.keyframes.length) this.keyframes.push(kf);
-    else this.keyframes[i] = kf;
-    return true;
-  }
-
-  /**
-   * Sample the position path. Zero-alloc, no cursor side effects. Honours
-   * posInterp and the stored-tangent → auto-CR fallback chain.
-   *
-   * Two signatures:
-   *   samplePos(out)              cursor form — reads current seg/f
-   *   samplePos(out, seg, t)      explicit (seg, t), continuous on the path
-   *
-   * @param {number[]} out  3-element result buffer.
-   * @param {number} [seg]  Segment index in [0, segments−1]. Omit for cursor.
-   * @param {number} [t]    Local parameter in [0, 1]. Omit for cursor.
-   * @returns {number[]} out
-   */
-  samplePos(out, seg, t) {
-    if (arguments.length < 3) [seg, t] = this._cursorSegT();
-    return _samplePathCore(out, this.keyframes, this.posInterp, 'pos', 'tanIn', 'tanOut', seg, t);
-  }
-
-  /**
-   * Write the TRS pose as a column-major model mat4. Zero-alloc, no cursor
-   * side effects.
-   *
-   * Two signatures:
-   *   mat4Model(out)              cursor form — reads current seg/f
-   *   mat4Model(out, seg, t)      explicit (seg, t), continuous on the path
-   *
-   * Replaces the previous toMatrix() method.
-   *
-   * @param {Float32Array|number[]} out  16-element result buffer.
-   * @param {number} [seg]  Segment index in [0, segments−1]. Omit for cursor.
-   * @param {number} [t]    Local parameter in [0, 1]. Omit for cursor.
-   * @returns {Float32Array|number[]} out
-   */
-  mat4Model(out, seg, t) {
-    if (arguments.length < 3) [seg, t] = this._cursorSegT();
-    this._sampleTRS(_trsScratch, seg, t);
-    return transformToMat4(out, _trsScratch);
-  }
-
-  /**
-   * Effective incoming / outgoing position tangents at keyframe `index`.
-   * Stored tanIn/tanOut take precedence; each mirrors the other when only
-   * one is stored; else centripetal Catmull-Rom tangents are auto-computed
-   * from neighbours. Boundary keyframes mirror across the missing side.
-   *
-   * @param {number[]} outIn   3-element result — incoming tangent.
-   * @param {number[]} outOut  3-element result — outgoing tangent.
-   * @param {number} index     Keyframe index.
-   * @returns {PoseTrack} this
-   */
-  tangents(outIn, outOut, index) {
-    _sampleTangentsCore(outIn, outOut, this.keyframes, 'pos', 'tanIn', 'tanOut', index);
-    return this;
-  }
-
-  /** @private — write interpolated TRS at (seg, t). */
-  _sampleTRS(out, seg, t) {
-    const n = this.keyframes.length;
-    if (n === 0) return out;
-    if (n === 1) {
-      const k = this.keyframes[0];
-      out.pos[0]=k.pos[0]; out.pos[1]=k.pos[1]; out.pos[2]=k.pos[2];
-      out.rot[0]=k.rot[0]; out.rot[1]=k.rot[1]; out.rot[2]=k.rot[2]; out.rot[3]=k.rot[3];
-      out.scl[0]=k.scl[0]; out.scl[1]=k.scl[1]; out.scl[2]=k.scl[2];
-      return out;
-    }
-    const nSeg = n - 1;
-    seg = seg | 0;
-    if (seg >= nSeg) { seg = nSeg - 1; t = 1; }
-    else if (seg < 0) { seg = 0; t = 0; }
-    t   = _clamp01(t);
-    const k0 = this.keyframes[seg];
-    const k1 = this.keyframes[seg + 1];
-
-    _samplePathCore(out.pos, this.keyframes, this.posInterp, 'pos', 'tanIn', 'tanOut', seg, t);
-
-    if (this.rotInterp === 'step') {
-      out.rot[0]=k0.rot[0]; out.rot[1]=k0.rot[1]; out.rot[2]=k0.rot[2]; out.rot[3]=k0.rot[3];
-    } else if (this.rotInterp === 'nlerp') {
-      qNlerp(out.rot, k0.rot, k1.rot, t);
-    } else {
-      qSlerp(out.rot, k0.rot, k1.rot, t);
-    }
-
-    lerpVec3(out.scl, k0.scl, k1.scl, t);
-    return out;
-  }
-
-  /**
-   * Evaluate interpolated TRS pose at current cursor.
-   * @param {{ pos:number[], rot:number[], scl:number[] }} [out]
-   * @returns {{ pos:number[], rot:number[], scl:number[] }} out
-   */
-  eval(out) {
-    out = out || { pos:[0,0,0], rot:[0,0,0,1], scl:[1,1,1] };
-    const n = this.keyframes.length;
-    if (n === 0) return out;
-    if (n === 1) return this._sampleTRS(out, 0, 0);
-    const [seg, t] = this._cursorSegT();
-    return this._sampleTRS(out, seg, t);
-  }
-}
-
-// =========================================================================
-// S7  CameraTrack
-// =========================================================================
-
-/**
- * Lookat camera keyframe track.
- *
- * Keyframe shape: { eye:[x,y,z], center:[x,y,z], up:[x,y,z],
- *                   fov?:number, halfHeight?:number,
- *                   near:number, far:number,
- *                   eyeTanIn?:[x,y,z], eyeTanOut?:[x,y,z],
- *                   centerTanIn?:[x,y,z], centerTanOut?:[x,y,z] }
- *
- * fov        — vertical fov (radians) for perspective cameras; null for ortho.
- * halfHeight — world-unit half-height of ortho frustum; null for perspective.
- * Both are optional and nullable because exactly one is meaningful per
- * keyframe (perspective xor ortho). eval() lerps each only when both
- * adjacent keyframes carry a non-null value for that field; mixed or
- * missing entries pass `null` through.
- *
- * near, far — clip plane distances (positive, world units). Always real
- * numbers. Defaults: near = 0.1, far = 1000 (three.js / Bevy convention).
- * Linearly interpolated between keyframes without null-passthrough.
- *
- * eyeTanIn/Out and centerTanIn/Out are optional vec3 tangents for Hermite
- * interpolation of the eye and center paths respectively. When absent,
- * centripetal Catmull-Rom tangents are auto-computed at sample time.
- *
- * Missing fields default to: center → [0,0,0], up → [0,1,0],
- * near → 0.1, far → 1000.
- *
- * For matrix-based capture of a camera-like pose use
- * PoseTrack.add({ mat4Model: mat4Eye }) for full TRS fidelity including roll,
- * or a lookat spec here for camera-style interpolation.
- */
-class CameraTrack extends Track {
-  constructor() {
-    super();
-    /**
-     * Eye-path interpolation mode.
-     * @type {'hermite'|'linear'|'step'}
-     */
-    this.eyeInterp = 'hermite';
-    /**
-     * Center-path interpolation mode.
-     * @type {'hermite'|'linear'|'step'}
-     */
-    this.centerInterp = 'linear';
-  }
-
-  /**
-   * Append one or more camera keyframes. Adjacent duplicates are skipped by
-   * default.
-   * @param {Object|Object[]} spec
-   * @param {{ deduplicate?: boolean }} [opts]
-   */
-  add(spec, opts) {
-    if (Array.isArray(spec)) { for (const s of spec) this.add(s, opts); return; }
-    const kf = _parseCameraSpec(spec);
-    if (!kf) return;
-    const dedup = !opts || opts.deduplicate !== false;
-    if (dedup && this.keyframes.length > 0) {
-      if (_sameCameraKeyframe(this.keyframes[this.keyframes.length - 1], kf)) return;
-    }
-    this.keyframes.push(kf);
-  }
-
-  /**
-   * Replace the camera keyframe at `index`, or append at the end if `index`
-   * equals the current keyframe count.
-   * @param {number} index
-   * @param {Object} spec
-   * @returns {boolean}
-   */
-  set(index, spec) {
-    if (!_isNum$1(index)) return false;
-    const i = index | 0, kf = _parseCameraSpec(spec);
-    if (!kf || i < 0 || i > this.keyframes.length) return false;
-    if (i === this.keyframes.length) this.keyframes.push(kf);
-    else this.keyframes[i] = kf;
-    return true;
-  }
-
-  /**
-   * Sample the eye path. Zero-alloc, no cursor side effects.
-   *
-   * Two signatures:
-   *   sampleEye(out)              cursor form — reads current seg/f
-   *   sampleEye(out, seg, t)      explicit (seg, t), continuous on the path
-   *
-   * @param {number[]} out
-   * @param {number} [seg]
-   * @param {number} [t]
-   * @returns {number[]} out
-   */
-  sampleEye(out, seg, t) {
-    if (arguments.length < 3) [seg, t] = this._cursorSegT();
-    return _samplePathCore(out, this.keyframes, this.eyeInterp, 'eye', 'eyeTanIn', 'eyeTanOut', seg, t);
-  }
-
-  /**
-   * Sample the center path. Zero-alloc, no cursor side effects.
-   *
-   * Two signatures:
-   *   sampleCenter(out)              cursor form — reads current seg/f
-   *   sampleCenter(out, seg, t)      explicit (seg, t)
-   *
-   * @param {number[]} out
-   * @param {number} [seg]
-   * @param {number} [t]
-   * @returns {number[]} out
-   */
-  sampleCenter(out, seg, t) {
-    if (arguments.length < 3) [seg, t] = this._cursorSegT();
-    return _samplePathCore(out, this.keyframes, this.centerInterp, 'center', 'centerTanIn', 'centerTanOut', seg, t);
-  }
-
-  /**
-   * Write the interpolated lookat eye matrix as a column-major mat4
-   * (eye→world rigid frame). Zero-alloc, no cursor side effects.
-   *
-   * Two signatures:
-   *   mat4Eye(out)              cursor form — reads current seg/f
-   *   mat4Eye(out, seg, t)      explicit (seg, t), continuous on the path
-   *
-   * @param {Float32Array|number[]} out  16-element result buffer.
-   * @param {number} [seg]
-   * @param {number} [t]
-   * @returns {Float32Array|number[]} out
-   */
-  mat4Eye(out, seg, t) {
-    if (arguments.length < 3) [seg, t] = this._cursorSegT();
-    this._sampleEyePose(_eyeScratch, seg, t);
-    const e = _eyeScratch;
-    return mat4Eye(out,
-      e.eye[0], e.eye[1], e.eye[2],
-      e.center[0], e.center[1], e.center[2],
-      e.up[0], e.up[1], e.up[2]);
-  }
-
-  /**
-   * Effective in/out eye tangents at keyframe `index`.
-   */
-  eyeTangents(outIn, outOut, index) {
-    _sampleTangentsCore(outIn, outOut, this.keyframes, 'eye', 'eyeTanIn', 'eyeTanOut', index);
-    return this;
-  }
-
-  /**
-   * Effective in/out center tangents at keyframe `index`.
-   */
-  centerTangents(outIn, outOut, index) {
-    _sampleTangentsCore(outIn, outOut, this.keyframes, 'center', 'centerTanIn', 'centerTanOut', index);
-    return this;
-  }
-
-  /** @private — write interpolated { eye, center, up } at (seg, t). */
-  _sampleEyePose(out, seg, t) {
-    const n = this.keyframes.length;
-    if (n === 0) return out;
-    if (n === 1) {
-      const k = this.keyframes[0];
-      out.eye[0]=k.eye[0];       out.eye[1]=k.eye[1];       out.eye[2]=k.eye[2];
-      out.center[0]=k.center[0]; out.center[1]=k.center[1]; out.center[2]=k.center[2];
-      out.up[0]=k.up[0];         out.up[1]=k.up[1];         out.up[2]=k.up[2];
-      return out;
-    }
-    const nSeg = n - 1;
-    seg = seg | 0;
-    if (seg >= nSeg) { seg = nSeg - 1; t = 1; }
-    else if (seg < 0) { seg = 0; t = 0; }
-    t   = _clamp01(t);
-    const k0 = this.keyframes[seg];
-    const k1 = this.keyframes[seg + 1];
-
-    _samplePathCore(out.eye,    this.keyframes, this.eyeInterp,    'eye',    'eyeTanIn',    'eyeTanOut',    seg, t);
-    _samplePathCore(out.center, this.keyframes, this.centerInterp, 'center', 'centerTanIn', 'centerTanOut', seg, t);
-
-    lerpVec3(out.up, k0.up, k1.up, t);
-    const ul = Math.sqrt(out.up[0]*out.up[0]+out.up[1]*out.up[1]+out.up[2]*out.up[2]) || 1;
-    out.up[0]/=ul; out.up[1]/=ul; out.up[2]/=ul;
-    return out;
-  }
-
-  /**
-   * Evaluate interpolated camera pose at current cursor.
-   *
-   * `fov` / `halfHeight` are lerped only when both adjacent keyframes carry
-   * a non-null value; mixed entries pass `null` through so the bridge can
-   * leave the projection unchanged.
-   *
-   * `near` / `far` are always real numbers and are linearly interpolated
-   * unconditionally.
-   *
-   * @param {{ eye:number[], center:number[], up:number[],
-   *           fov:number|null, halfHeight:number|null,
-   *           near:number, far:number }} [out]
-   * @returns {{ eye:number[], center:number[], up:number[],
-   *             fov:number|null, halfHeight:number|null,
-   *             near:number, far:number }} out
-   */
-  eval(out) {
-    out = out || { eye:[0,0,0], center:[0,0,0], up:[0,1,0],
-                   fov:null, halfHeight:null,
-                   near:_DEFAULT_NEAR, far:_DEFAULT_FAR };
-    const n = this.keyframes.length;
-    if (n === 0) return out;
-    if (n === 1) {
-      const k = this.keyframes[0];
-      this._sampleEyePose(out, 0, 0);
-      out.fov = k.fov; out.halfHeight = k.halfHeight;
-      out.near = k.near; out.far = k.far;
-      return out;
-    }
-    const [seg, t] = this._cursorSegT();
-    const k0 = this.keyframes[seg];
-    const k1 = this.keyframes[seg + 1];
-
-    this._sampleEyePose(out, seg, t);
-
-    out.fov = (k0.fov != null && k1.fov != null)
-      ? k0.fov + t * (k1.fov - k0.fov) : (k0.fov ?? k1.fov ?? null);
-    out.halfHeight = (k0.halfHeight != null && k1.halfHeight != null)
-      ? k0.halfHeight + t * (k1.halfHeight - k0.halfHeight)
-      : (k0.halfHeight ?? k1.halfHeight ?? null);
-
-    // near / far carry real defaults on every keyframe — always lerp.
-    out.near = k0.near + t * (k1.near - k0.near);
-    out.far  = k0.far  + t * (k1.far  - k0.far);
-
-    return out;
-  }
-}
-
-/**
- * @file Constraint solver, canonical handle state, and ray-primitive
- *       intersections for interactive manipulators.
- * @module tree/handle
- * @license AGPL-3.0-only
- *
- * The numeric brain of the manipulator handle. Renderer- and frame-agnostic:
- * inputs are plain numbers in ONE working space chosen by the caller (the
- * bridge), and the solver never learns world vs eye — it solves in whatever
- * space the ray and geometry are expressed in. The bridge converts the pointer
- * ray into the working frame before calling solve(), and converts the value
- * back out via mapLocation / mapDirection.
- *
- * Zero dependencies on p5, DOM, WebGL, or WebGPU. Out-first throughout; no
- * allocation in solve() / value(). Vectors are passed as flat scalars (matching
- * form.js), state is held as plain number[] (matching track.js keyframes).
- *
- * ── Storage convention ─────────────────────────────────────────────────────
- * The core distinguishes two value shapes deliberately:
- *   mat4   — 16-element ArrayLike, typically Float32Array, because matrices
- *            cross the GL boundary (contiguous f32 is what the renderer wants).
- *   vec3 / quat — plain number[] (f64), because they are authoring/state values
- *            and because the frozen basis-vector constants (i, j, k, ORIGIN)
- *            cannot be expressed as frozen typed arrays. Handle state follows
- *            the vec3 rule.
- *
- * ── Constraint kinds ───────────────────────────────────────────────────────
- *   SPHERE  2-DOF heading on a sphere of radius r about an anchor.
- *           Canonical state is a UNIT DIRECTION (renormalised every solve) —
- *           no stored Euler angles, so no gimbal degeneracy at the poles.
- *           az/el are derived on request via azEl().
- *   PLANE   2-DOF point on a fixed plane (anchor + unit normal).
- *   AXIS    1-DOF point on a line (anchor + unit dir), scalar t clamped to extent.
- *   DIAL    1-DOF angle on a circle of radius r in the plane (anchor, axis).
- *           Canonical state is an ACCUMULATED angle θ (multi-turn winding is
- *           preserved: each solve applies the smaller signed arc, so θ counts
- *           full turns — essential for bind targets like "rotate this 720°").
- *           θ=0 sits at the reference direction `zero` (derived from the axis
- *           when not supplied); θ grows right-handed about the axis. Near
- *           edge-on view (the ray almost parallel to the dial plane, where a
- *           plane hit races to infinity — the classic rotate-gizmo failure)
- *           the solve falls back to the TANGENT LINE of the circle at the
- *           current angle, converting linear drag to dθ: bounded, monotone,
- *           and still pure ray geometry.
- *
- *   VIEW (the camera-facing free-translate constraint) is NOT a core kind: the
- *   bridge implements it with PLANE, feeding a fresh camera-derived normal and
- *   anchor each frame. The core stays oblivious to the camera.
- *
- * ── Report modes ───────────────────────────────────────────────────────────
- *   DIRECTION  value() writes the unit direction: SPHERE → the heading;
- *              DIAL → the radial unit at θ.
- *   POINT      value() writes a position: SPHERE → anchor + dir·radius;
- *              DIAL → the point on the circle; PLANE / AXIS → the constrained
- *              point.
- *
- * ── State ownership & portability ──────────────────────────────────────────
- * Each Constraint owns its own state; there is no module-level scratch. solve()
- * writes into instance fields, never shared globals. This keeps the type a
- * plain-data state machine: it ports 1:1 to a Rust enum + impl that is
- * `Send + Sync` for free, with `&mut self` on solve() making concurrent
- * mutation a compile error. The binding closure deliberately lives in the
- * bridge, not here — a stored callback would forfeit that guarantee.
- *
- * ── Extension contract ─────────────────────────────────────────────────────
- * A constraint is any object exposing: `kind` (integer discriminant),
- * `solve(ox,oy,oz, dx,dy,dz)`, `value(out, report)`, `seed(x,y,z)`, and
- * optionally `scalar()` / `azEl(out2)` / `aim(ax,ay,az[, zx,zy,zz])` — the
- * basis re-aim seam the bridge's deferred `from` frame drives — and
- * `proxy(ox,oy,oz, dx,dy,dz, radius)`, the analytic pick: the ray parameter
- * at which a ray in the working space meets the grab proxy of `radius`
- * working units, or Infinity (a kind without one gets a sphere at its
- * POINT). The handle controller drives any conforming constraint
- * (lifecycle, frame conversion, bind, hooks, pick); a new kind — 6-DOF, or
- * app-specific — implements this contract here (portable, draw-free) plus a
- * bridge-side locus draw, rather than forking the controller. The classes
- * below are the reference implementation. See handle-design.md §9–§10.
- *
- * ── Conventions ────────────────────────────────────────────────────────────
- * Ray direction `d` is assumed unit (the bridge normalises). Plane / axis
- * normals and directions are normalised at construction. The angular utilities
- * use a right-handed convention: az about +Y, el measured from the XZ plane.
- * solve() does NOT depend on this convention — it stores the hit direction
- * directly; az/el are a readout/authoring convenience only. DIAL's θ is
- * right-handed about its own axis, measured from `zero`.
- */
-
-
-const EPS = 1e-6;
-const TWO_PI$1 = Math.PI * 2;
-
-// Edge-on threshold for DIAL: below this |d·n| the plane hit is ill-conditioned
-// (dθ per pixel diverges) and the solve switches to the tangent-line fallback.
-// ≈ 4.6° of incidence. Tune empirically (handle-experiments/e2).
-const DIAL_EDGE = 0.08;
-
-// =========================================================================
-// H1  Small private helpers
-// =========================================================================
-
-const _isNum = (x) => typeof x === 'number' && Number.isFinite(x);
-const _clamp$1 = (x, lo, hi) => x < lo ? lo : (x > hi ? hi : x);
-const _num   = (x, d) => _isNum(x) ? x : d;
-
-/** Wrap an angle to (−π, π]. */
-const _wrapPi = (a) => a - TWO_PI$1 * Math.round(a / TWO_PI$1);
-
-/** Parse a vec3 from array / typed array / {x,y,z}. Returns a fresh [x,y,z] or null. */
-function _vec3$1(v) {
-  if (!v) return null;
-  if (ArrayBuffer.isView(v) && v.length >= 3) return [v[0], v[1], v[2]];
-  if (Array.isArray(v) && v.length >= 3) return [v[0], v[1], v[2]];
-  if (typeof v === 'object' && 'x' in v) return [v.x || 0, v.y || 0, v.z || 0];
-  return null;
-}
-
-/** Normalise a vec3 in place; zero-length falls back to the given default axis. */
-function _unit$1(v, dx, dy, dz) {
-  const l = Math.sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
-  if (l < EPS) { v[0]=dx; v[1]=dy; v[2]=dz; return v; }
-  v[0]/=l; v[1]/=l; v[2]/=l;
-  return v;
-}
-
-/**
- * Orthonormal in-plane basis for a unit normal n, written into ub, vb. Seeds
- * from the world axis least aligned with n so the first cross can't degenerate.
- * (Same derivation the p5 bridge uses for its plane quad — duplicated here
- * because the core cannot depend on the bridge.)
- */
-function _basis$1(n, ub, vb) {
-  const ax = Math.abs(n[0]), ay = Math.abs(n[1]), az = Math.abs(n[2]);
-  let rx = 0, ry = 0, rz = 0;
-  if (ax <= ay && ax <= az) rx = 1; else if (ay <= az) ry = 1; else rz = 1;
-  ub[0] = ry*n[2] - rz*n[1]; ub[1] = rz*n[0] - rx*n[2]; ub[2] = rx*n[1] - ry*n[0];
-  _unit$1(ub, 1, 0, 0);
-  vb[0] = n[1]*ub[2] - n[2]*ub[1]; vb[1] = n[2]*ub[0] - n[0]*ub[2]; vb[2] = n[0]*ub[1] - n[1]*ub[0];
-}
-
-// =========================================================================
-// H2  Ray-primitive intersections (pure, out-first, scalar params)
-// =========================================================================
-
-/**
- * Nearest ray–sphere intersection. The ray direction is assumed unit, so the
- * quadratic's leading coefficient is 1. On a miss, writes the closest-approach
- * point projected onto the sphere (so the handle tracks the limb gracefully
- * rather than snapping away).
- *
- * @param {number[]} out  3-element destination (hit point).
- * @param {number} ox,oy,oz  Ray origin.
- * @param {number} dx,dy,dz  Ray direction (unit).
- * @param {number} cx,cy,cz  Sphere centre.
- * @param {number} r         Sphere radius.
- * @returns {number} Ray parameter t at the written hit.
- */
-function raySphere(out, ox,oy,oz, dx,dy,dz, cx,cy,cz, r) {
-  const lx=ox-cx, ly=oy-cy, lz=oz-cz;
-  const b  = lx*dx + ly*dy + lz*dz;
-  const cc = lx*lx + ly*ly + lz*lz - r*r;
-  const disc = b*b - cc;
-  let t;
-  if (disc >= 0) {
-    const s = Math.sqrt(disc);
-    t = -b - s;
-    if (t < 0) t = -b + s;              // origin inside the sphere: take far root
-    out[0]=ox+t*dx; out[1]=oy+t*dy; out[2]=oz+t*dz;
-  } else {
-    t = -b;                             // closest approach along the ray
-    let hx=ox+t*dx-cx, hy=oy+t*dy-cy, hz=oz+t*dz-cz;
-    const hl = Math.sqrt(hx*hx + hy*hy + hz*hz) || 1;
-    const k = r/hl;
-    out[0]=cx+hx*k; out[1]=cy+hy*k; out[2]=cz+hz*k;
-  }
-  return t;
-}
-
-/**
- * Ray–plane intersection. A near-parallel ray (|d·n| < EPS) returns Infinity
- * and leaves `out` untouched — the caller keeps the previous value.
- *
- * @param {number[]} out  3-element destination (hit point).
- * @param {number} ox,oy,oz  Ray origin.
- * @param {number} dx,dy,dz  Ray direction (unit).
- * @param {number} px,py,pz  A point on the plane.
- * @param {number} nx,ny,nz  Plane normal (unit).
- * @returns {number} Ray parameter t, or Infinity if parallel.
- */
-function rayPlane(out, ox,oy,oz, dx,dy,dz, px,py,pz, nx,ny,nz) {
-  const den = dx*nx + dy*ny + dz*nz;
-  if (den < EPS && den > -EPS) return Infinity;
-  const t = ((px-ox)*nx + (py-oy)*ny + (pz-oz)*nz) / den;
-  out[0]=ox+t*dx; out[1]=oy+t*dy; out[2]=oz+t*dz;
-  return t;
-}
-
-/**
- * Closest point on the infinite line (p, u) to the ray (o, d). Both `d` and
- * `u` are assumed unit. For a ray parallel to the line, projects the ray
- * origin onto the line.
- *
- * @param {number[]} out  3-element destination (closest point on the line).
- * @param {number} ox,oy,oz  Ray origin.
- * @param {number} dx,dy,dz  Ray direction (unit).
- * @param {number} px,py,pz  A point on the line.
- * @param {number} ux,uy,uz  Line direction (unit).
- * @returns {number} Signed parameter s along u at the written point (unclamped).
- */
-function rayClosestPointOnAxis(out, ox,oy,oz, dx,dy,dz, px,py,pz, ux,uy,uz) {
-  const wx=ox-px, wy=oy-py, wz=oz-pz;
-  const b  = dx*ux + dy*uy + dz*uz;     // d·u
-  const dd = dx*wx + dy*wy + dz*wz;     // d·w
-  const e  = ux*wx + uy*wy + uz*wz;     // u·w
-  const den = 1 - b*b;                  // (d·d)(u·u) − (d·u)² with d,u unit
-  const s = (den > EPS) ? (e - b*dd) / den : e;
-  out[0]=px+s*ux; out[1]=py+s*uy; out[2]=pz+s*uz;
-  return s;
-}
-
-// =========================================================================
-// H2b Ray-primitive hit tests (pure, no out: the nearest t, or Infinity)
-// =========================================================================
-//
-// Beside the solve primitives above, which always write a point, these are
-// TESTS: they write nothing and return the ray parameter of the nearest hit
-// with t ≥ 0, or Infinity on a miss. A ray whose origin lies inside the
-// primitive hits at its exit, so a press from inside a proxy still grabs.
-// The ray direction is assumed unit.
-
-/**
- * Ray–sphere hit test.
- * @param {number} ox,oy,oz  Ray origin.
- * @param {number} dx,dy,dz  Ray direction (unit).
- * @param {number} cx,cy,cz  Sphere centre.
- * @param {number} r         Sphere radius.
- * @returns {number} The nearest t ≥ 0, or Infinity.
- */
-function rayHitSphere(ox,oy,oz, dx,dy,dz, cx,cy,cz, r) {
-  const lx=ox-cx, ly=oy-cy, lz=oz-cz;
-  const b  = lx*dx + ly*dy + lz*dz;
-  const cc = lx*lx + ly*ly + lz*lz - r*r;
-  const disc = b*b - cc;
-  if (disc < 0) return Infinity;
-  const s = Math.sqrt(disc);
-  let t = -b - s;
-  if (t < 0) t = -b + s;                // origin inside: the exit
-  return t < 0 ? Infinity : t;          // both roots behind the origin
-}
-
-// One end cap of a capsule: the sphere at (cx,cy,cz), a root accepted only
-// where the hit's axial coordinate h = wu + t·du lies beyond the segment on
-// that cap's side (h ≤ 0 at A, h ≥ L at B), so the point is on the capsule's
-// surface and not inside its cylinder.
-function _capHit(ox,oy,oz, dx,dy,dz, cx,cy,cz, r, wu, du, lim, endB) {
-  const lx=ox-cx, ly=oy-cy, lz=oz-cz;
-  const b  = lx*dx + ly*dy + lz*dz;
-  const cc = lx*lx + ly*ly + lz*lz - r*r;
-  const disc = b*b - cc;
-  if (disc < 0) return Infinity;
-  const s = Math.sqrt(disc);
-  let t = -b - s, h = wu + t*du;
-  if (t < 0 || (endB ? h < lim : h > lim)) { t = -b + s; h = wu + t*du; }
-  return (t >= 0 && (endB ? h >= lim : h <= lim)) ? t : Infinity;
-}
-
-/**
- * Ray–capsule hit test: the segment A→B swept by radius r. The cylinder wall
- * counts within the segment's extent, each end sphere beyond it; the nearest
- * of the three wins. A zero-length segment is the sphere at A.
- * @param {number} ox,oy,oz  Ray origin.
- * @param {number} dx,dy,dz  Ray direction (unit).
- * @param {number} ax,ay,az  Segment start.
- * @param {number} bx,by,bz  Segment end.
- * @param {number} r         Capsule radius.
- * @returns {number} The nearest t ≥ 0, or Infinity.
- */
-function rayHitCapsule(ox,oy,oz, dx,dy,dz, ax,ay,az, bx,by,bz, r) {
-  let ux=bx-ax, uy=by-ay, uz=bz-az;
-  const L = Math.sqrt(ux*ux + uy*uy + uz*uz);
-  if (L < EPS) return rayHitSphere(ox,oy,oz, dx,dy,dz, ax,ay,az, r);
-  ux/=L; uy/=L; uz/=L;
-  const wx=ox-ax, wy=oy-ay, wz=oz-az;
-  const du = dx*ux + dy*uy + dz*uz;     // d·u
-  const wu = wx*ux + wy*uy + wz*uz;     // w·u
-  let best = Infinity;
-  // Cylinder wall: the quadratic in the components perpendicular to u.
-  const a = 1 - du*du;
-  if (a > EPS) {
-    const b = (dx*wx + dy*wy + dz*wz) - du*wu;
-    const c = (wx*wx + wy*wy + wz*wz) - wu*wu - r*r;
-    const disc = b*b - a*c;
-    if (disc >= 0) {
-      const s = Math.sqrt(disc);
-      let t = (-b - s)/a, h = wu + t*du;
-      if (t < 0 || h < 0 || h > L) { t = (-b + s)/a; h = wu + t*du; }
-      if (t >= 0 && h >= 0 && h <= L) best = t;
-    }
-  }
-  const ta = _capHit(ox,oy,oz, dx,dy,dz, ax,ay,az, r, wu, du, 0, false);
-  if (ta < best) best = ta;
-  const tb = _capHit(ox,oy,oz, dx,dy,dz, bx,by,bz, r, wu, du, L, true);
-  if (tb < best) best = tb;
-  return best;
-}
-
-// Ring scratch — the plane normal and its in-plane basis. Function-local
-// working values, never state: rayHitRing runs to completion.
-const _rn = [0, 0, 1], _r0 = [1, 0, 0], _r1 = [0, 1, 0];
-
-/**
- * Ray–ring hit test: the circle of radius R about c in the plane
- * perpendicular to u, swept by tube radius r — the analytic torus proxy as a
- * capsule chain, the circle polygonised into `detail` segments and each
- * tested with rayHitCapsule. The chain has volume in every direction, so it
- * never degenerates edge-on; the chordal error is R · (1 − cos(π / detail)).
- * @param {number} ox,oy,oz  Ray origin.
- * @param {number} dx,dy,dz  Ray direction (unit).
- * @param {number} cx,cy,cz  Ring centre.
- * @param {number} ux,uy,uz  Ring plane normal (normalised here).
- * @param {number} R         Ring radius.
- * @param {number} r         Tube radius.
- * @param {number} [detail=32]  Chain segments (at least 3).
- * @returns {number} The nearest t ≥ 0, or Infinity.
- */
-function rayHitRing(ox,oy,oz, dx,dy,dz, cx,cy,cz, ux,uy,uz, R, r, detail = 32) {
-  const n = _isNum(detail) && detail >= 3 ? Math.floor(detail) : 32;
-  _rn[0]=ux; _rn[1]=uy; _rn[2]=uz;
-  _unit$1(_rn, 0, 0, 1);
-  _basis$1(_rn, _r0, _r1);
-  const step = TWO_PI$1 / n;
-  let best = Infinity;
-  let ax = cx + R*_r0[0], ay = cy + R*_r0[1], az = cz + R*_r0[2];   // vertex at angle 0
-  for (let i = 1; i <= n; i++) {
-    const th = i === n ? 0 : i*step;                                 // close the chain exactly
-    const cs = Math.cos(th)*R, sn = Math.sin(th)*R;
-    const bx = cx + cs*_r0[0] + sn*_r1[0];
-    const by = cy + cs*_r0[1] + sn*_r1[1];
-    const bz = cz + cs*_r0[2] + sn*_r1[2];
-    const t = rayHitCapsule(ox,oy,oz, dx,dy,dz, ax,ay,az, bx,by,bz, r);
-    if (t < best) best = t;
-    ax = bx; ay = by; az = bz;
-  }
-  return best;
-}
-
-// =========================================================================
-// H3  Angular utilities (readout / authoring convenience)
-// =========================================================================
-
-/**
- * Unit direction from azimuth/elevation (right-handed: az about +Y, el from XZ).
- * @param {number[]} out  3-element destination.
- * @param {number} az  Azimuth (radians).
- * @param {number} el  Elevation (radians).
- * @returns {number[]} out
- */
-function dirFromAzEl(out, az, el) {
-  const ce = Math.cos(el);
-  out[0]=ce*Math.cos(az); out[1]=Math.sin(el); out[2]=ce*Math.sin(az);
-  return out;
-}
-
-/**
- * Azimuth/elevation from a unit direction. Inverse of dirFromAzEl.
- * @param {number[]} out2  2-element destination [az, el] (radians).
- * @param {number} dx,dy,dz  Unit direction.
- * @returns {number[]} out2
- */
-function azElFromDir(out2, dx, dy, dz) {
-  out2[0] = Math.atan2(dz, dx);                 // az
-  out2[1] = Math.asin(_clamp$1(dy, -1, 1));       // el
-  return out2;
-}
-
-// =========================================================================
-// H4  Constraint — tagged state machine (one class, kind discriminant)
-// =========================================================================
-
-/**
- * A draggable constraint: maps a ray to a constrained value and holds the
- * canonical state between drags. One class with a `kind` discriminant (never
- * per-constraint subclasses) so it maps cleanly to a Rust enum.
- *
- * Construction options (all optional unless noted):
- *   SPHERE — { radius = 1, report = DIRECTION, anchor = [0,0,0] }
- *   PLANE  — { anchor = [0,0,0], normal = [0,1,0] }
- *   AXIS   — { anchor = [0,0,0], axis = [1,0,0], extent = [-1, 1] }
- *   DIAL   — { anchor = [0,0,0], axis = [0,1,0], radius = 1, zero?,
- *              extent = [-∞, ∞] }
- *            `axis` is the dial-plane normal (θ is right-handed about it);
- *            `zero` is the in-plane reference direction for θ=0 (projected
- *            onto the plane and normalised; derived from the axis when
- *            absent); `extent` clamps θ in radians — unbounded by default,
- *            so the dial winds multiple turns.
- *
- * @param {number} kind  SPHERE | PLANE | AXIS | DIAL.
- * @param {Object} [opts]
- */
-class Constraint {
-  constructor(kind, opts = {}) {
-    /** Constraint kind discriminant. @type {number} */
-    this.kind = kind;
-
-    /** Constraint origin (sphere centre / plane point / axis anchor / dial centre). @type {number[]} */
-    this.anchor = _vec3$1(opts.anchor) || [0, 0, 0];
-    /** Canonical unit direction — SPHERE. @type {number[]} */
-    this.dir = [0, 0, 1];
-    /** Constrained point — PLANE / AXIS / DIAL (and SPHERE scratch). @type {number[]} */
-    this.pt = [this.anchor[0], this.anchor[1], this.anchor[2]];
-    /** Plane normal (unit) — PLANE. @type {number[]} */
-    this.n = _unit$1(_vec3$1(opts.normal) || [0, 1, 0], 0, 1, 0);
-    /** Axis / dial-plane normal (unit) — AXIS / DIAL. @type {number[]} */
-    this.u = kind === DIAL
-      ? _unit$1(_vec3$1(opts.axis) || [0, 1, 0], 0, 1, 0)
-      : _unit$1(_vec3$1(opts.axis) || [1, 0, 0], 1, 0, 0);
-    /** Current scalar parameter — AXIS: t along the line; DIAL: accumulated θ. @type {number} */
-    this.s = 0;
-
-    // DIAL in-plane basis: r0 (the θ=0 reference) and r1 = u × r0, so the
-    // point at θ is anchor + radius·(cosθ·r0 + sinθ·r1) — right-handed about u.
-    /** θ=0 reference direction (unit, in-plane) — DIAL. @type {number[]} */
-    this.r0 = [1, 0, 0];
-    /** In-plane binormal u × r0 (unit) — DIAL. @type {number[]} */
-    this.r1 = [0, 0, 1];
-    if (kind === DIAL) {
-      const z = _vec3$1(opts.zero);
-      this._dialBasis(z ? z[0] : NaN, z ? z[1] : NaN, z ? z[2] : NaN);
-    }
-
-    // Extent: AXIS clamps t (default [-1, 1]); DIAL clamps θ in radians
-    // (default unbounded, so the dial winds freely).
-    const ext = Array.isArray(opts.extent) ? opts.extent : null;
-    const dial = kind === DIAL;
-    /** Minimum scalar parameter. @type {number} */
-    this.min = ext && _isNum(ext[0]) ? ext[0] : (dial ? -Infinity : -1);
-    /** Maximum scalar parameter. @type {number} */
-    this.max = ext && _isNum(ext[1]) ? ext[1] : (dial ?  Infinity :  1);
-
-    // Sphere / dial radius (private backing — see radius getter/setter).
-    this._radius = _num(opts.radius, 1);
-
-    /**
-     * Default report mode. SPHERE defaults to DIRECTION; PLANE / AXIS / DIAL
-     * report a POINT.
-     * @type {number}
-     */
-    this.report = (opts.report === POINT || opts.report === DIRECTION)
-      ? opts.report
-      : (kind === SPHERE ? DIRECTION : POINT);
-
-    if (kind === DIAL) this._dialPoint();
-  }
-
-  /** Sphere / dial radius. @type {number} */
-  get radius()  { return this._radius; }
-  set radius(r) { this._radius = _isNum(r) ? r : this._radius; if (this.kind === DIAL) this._dialPoint(); }
-
-  // Recompute the DIAL point from θ (anchor + ρ(cosθ·r0 + sinθ·r1)).
-  _dialPoint() {
-    const c = Math.cos(this.s) * this._radius, sn = Math.sin(this.s) * this._radius;
-    this.pt[0] = this.anchor[0] + c*this.r0[0] + sn*this.r1[0];
-    this.pt[1] = this.anchor[1] + c*this.r0[1] + sn*this.r1[1];
-    this.pt[2] = this.anchor[2] + c*this.r0[2] + sn*this.r1[2];
-  }
-
-  // Build the DIAL in-plane basis (r0, r1) from the current axis u and an
-  // optional θ=0 reference (zx,zy,zz): the reference is projected onto the
-  // dial plane and normalised; absent (NaN) or degenerate, r0 derives from u
-  // via the least-aligned-axis seed. r1 = u × r0, right-handed about u.
-  _dialBasis(zx, zy, zz) {
-    if (_isNum(zx) && _isNum(zy) && _isNum(zz)) {
-      const d = zx*this.u[0] + zy*this.u[1] + zz*this.u[2];
-      this.r0[0] = zx - d*this.u[0];
-      this.r0[1] = zy - d*this.u[1];
-      this.r0[2] = zz - d*this.u[2];
-      const l = Math.sqrt(this.r0[0]**2 + this.r0[1]**2 + this.r0[2]**2);
-      if (l < EPS) _basis$1(this.u, this.r0, this.r1);
-      else { this.r0[0]/=l; this.r0[1]/=l; this.r0[2]/=l; }
-    } else {
-      _basis$1(this.u, this.r0, this.r1);
-    }
-    // r1 = u × r0 (recomputed even when _basis ran — same result, one rule).
-    this.r1[0] = this.u[1]*this.r0[2] - this.u[2]*this.r0[1];
-    this.r1[1] = this.u[2]*this.r0[0] - this.u[0]*this.r0[2];
-    this.r1[2] = this.u[0]*this.r0[1] - this.u[1]*this.r0[0];
-  }
-
-  /**
-   * Update the canonical state from a ray in the working space. The ray
-   * direction is assumed unit. Chainable.
-   *
-   * @param {number} ox,oy,oz  Ray origin.
-   * @param {number} dx,dy,dz  Ray direction (unit).
-   * @returns {Constraint} this
-   */
-  solve(ox, oy, oz, dx, dy, dz) {
-    if (this.kind === SPHERE) {
-      // Hit the sphere into pt, then derive the unit heading from the anchor.
-      raySphere(this.pt, ox,oy,oz, dx,dy,dz,
-                this.anchor[0], this.anchor[1], this.anchor[2], this._radius);
-      this.dir[0] = this.pt[0] - this.anchor[0];
-      this.dir[1] = this.pt[1] - this.anchor[1];
-      this.dir[2] = this.pt[2] - this.anchor[2];
-      _unit$1(this.dir, this.dir[0], this.dir[1], this.dir[2]);
-    } else if (this.kind === PLANE) {
-      // Parallel ray returns Infinity and leaves pt unchanged (keep last).
-      rayPlane(this.pt, ox,oy,oz, dx,dy,dz,
-               this.anchor[0], this.anchor[1], this.anchor[2],
-               this.n[0], this.n[1], this.n[2]);
-    } else if (this.kind === AXIS) {
-      let s = rayClosestPointOnAxis(this.pt, ox,oy,oz, dx,dy,dz,
-                                    this.anchor[0], this.anchor[1], this.anchor[2],
-                                    this.u[0], this.u[1], this.u[2]);
-      s = _clamp$1(s, this.min, this.max);
-      this.s = s;
-      this.pt[0] = this.anchor[0] + s*this.u[0];   // clamped point
-      this.pt[1] = this.anchor[1] + s*this.u[1];
-      this.pt[2] = this.anchor[2] + s*this.u[2];
-    } else if (this.kind === DIAL) {
-      this._solveDial(ox, oy, oz, dx, dy, dz);
-    }
-    return this;
-  }
-
-  // DIAL solve. Face-on: hit the dial plane, derive the raw angle of the hit
-  // about the anchor, and accumulate the smaller signed arc into θ (winding
-  // preserved). Edge-on (|d·u| < DIAL_EDGE): the plane hit diverges, so solve
-  // the ray against the TANGENT LINE of the circle at the current θ instead —
-  // the signed tangent parameter over the radius is dθ, bounded and monotone.
-  _solveDial(ox, oy, oz, dx, dy, dz) {
-    const u = this.u, r0 = this.r0, r1 = this.r1, a = this.anchor;
-    const den = dx*u[0] + dy*u[1] + dz*u[2];
-    let dth;
-    if (den >= DIAL_EDGE || den <= -DIAL_EDGE) {
-      // Well-conditioned: plane hit → raw angle → smaller signed arc.
-      const t = rayPlane(this.pt, ox,oy,oz, dx,dy,dz,
-                         a[0], a[1], a[2], u[0], u[1], u[2]);
-      if (t === Infinity) return;                  // keep last (paranoia; den guards)
-      const vx = this.pt[0]-a[0], vy = this.pt[1]-a[1], vz = this.pt[2]-a[2];
-      const raw = Math.atan2(vx*r1[0] + vy*r1[1] + vz*r1[2],
-                             vx*r0[0] + vy*r0[1] + vz*r0[2]);
-      dth = _wrapPi(raw - _wrapPi(this.s));
-    } else {
-      // Edge-on fallback: tangent at the current point, w = −sinθ·r0 + cosθ·r1.
-      const cs = Math.cos(this.s), sn = Math.sin(this.s);
-      const wx = -sn*r0[0] + cs*r1[0];
-      const wy = -sn*r0[1] + cs*r1[1];
-      const wz = -sn*r0[2] + cs*r1[2];
-      this._dialPoint();                           // tangent anchored at the current point
-      const sl = rayClosestPointOnAxis(this.pt, ox,oy,oz, dx,dy,dz,
-                                       this.pt[0], this.pt[1], this.pt[2],
-                                       wx, wy, wz);
-      dth = sl / (this._radius || 1);
-    }
-    this.s = _clamp$1(this.s + dth, this.min, this.max);
-    this._dialPoint();
-  }
-
-  /**
-   * Write the current value into `out`. `report` overrides the default for
-   * this call (e.g. read a SPHERE's point even when its default is DIRECTION).
-   * SPHERE+POINT and DIAL+POINT are derived from the angle/heading and the
-   * live radius, so they stay correct after a radius change without
-   * re-solving. DIAL+DIRECTION writes the radial unit at θ.
-   *
-   * @param {number[]} out  3-element destination.
-   * @param {number} [report]  POINT | DIRECTION override.
-   * @returns {number[]} out
-   */
-  value(out, report) {
-    const r = (report === POINT || report === DIRECTION) ? report : this.report;
-    if (this.kind === SPHERE) {
-      if (r === DIRECTION) {
-        out[0]=this.dir[0]; out[1]=this.dir[1]; out[2]=this.dir[2];
-      } else {
-        out[0]=this.anchor[0]+this.dir[0]*this._radius;
-        out[1]=this.anchor[1]+this.dir[1]*this._radius;
-        out[2]=this.anchor[2]+this.dir[2]*this._radius;
-      }
-    } else if (this.kind === DIAL) {
-      const cs = Math.cos(this.s), sn = Math.sin(this.s);
-      if (r === DIRECTION) {
-        out[0]=cs*this.r0[0]+sn*this.r1[0];
-        out[1]=cs*this.r0[1]+sn*this.r1[1];
-        out[2]=cs*this.r0[2]+sn*this.r1[2];
-      } else {
-        out[0]=this.anchor[0]+(cs*this.r0[0]+sn*this.r1[0])*this._radius;
-        out[1]=this.anchor[1]+(cs*this.r0[1]+sn*this.r1[1])*this._radius;
-        out[2]=this.anchor[2]+(cs*this.r0[2]+sn*this.r1[2])*this._radius;
-      }
-    } else {
-      out[0]=this.pt[0]; out[1]=this.pt[1]; out[2]=this.pt[2];
-    }
-    return out;
-  }
-
-  /**
-   * Current scalar parameter: AXIS → signed t along the line; DIAL →
-   * accumulated angle θ in radians (multi-turn).
-   * @returns {number} The parameter, or NaN for non-scalar constraints.
-   */
-  scalar() {
-    return (this.kind === AXIS || this.kind === DIAL) ? this.s : NaN;
-  }
-
-  /**
-   * Derive [az, el] from the current SPHERE direction (SPHERE only).
-   * @param {number[]} out2  2-element destination [az, el].
-   * @returns {number[]} out2
-   */
-  azEl(out2) {
-    return azElFromDir(out2, this.dir[0], this.dir[1], this.dir[2]);
-  }
-
-  /**
-   * Seed the canonical state from a value (used by the bridge on bind() so the
-   * handle starts at the bound target's value). Chainable.
-   *   SPHERE — sets the unit direction (a point value recovers its heading).
-   *   PLANE  — projects the value onto the plane.
-   *   AXIS   — projects the value onto the line, clamped to extent.
-   *   DIAL   — projects the value onto the dial plane, derives the wrapped
-   *            angle, and picks the WINDING NEAREST the current θ (so an
-   *            external sync doesn't unwind accumulated turns), clamped.
-   *
-   * @param {number} x,y,z  Seed value.
-   * @returns {Constraint} this
-   */
-  seed(x, y, z) {
-    if (this.kind === SPHERE) {
-      const vx=x-this.anchor[0], vy=y-this.anchor[1], vz=z-this.anchor[2];
-      const l = Math.sqrt(vx*vx + vy*vy + vz*vz);
-      if (l >= EPS) { this.dir[0]=vx/l; this.dir[1]=vy/l; this.dir[2]=vz/l; }
-    } else if (this.kind === PLANE) {
-      const wx=x-this.anchor[0], wy=y-this.anchor[1], wz=z-this.anchor[2];
-      const d = wx*this.n[0] + wy*this.n[1] + wz*this.n[2];
-      this.pt[0]=x-d*this.n[0]; this.pt[1]=y-d*this.n[1]; this.pt[2]=z-d*this.n[2];
-    } else if (this.kind === AXIS) {
-      const wx=x-this.anchor[0], wy=y-this.anchor[1], wz=z-this.anchor[2];
-      const s = _clamp$1(wx*this.u[0] + wy*this.u[1] + wz*this.u[2], this.min, this.max);
-      this.s = s;
-      this.pt[0]=this.anchor[0]+s*this.u[0];
-      this.pt[1]=this.anchor[1]+s*this.u[1];
-      this.pt[2]=this.anchor[2]+s*this.u[2];
-    } else if (this.kind === DIAL) {
-      const wx=x-this.anchor[0], wy=y-this.anchor[1], wz=z-this.anchor[2];
-      const px = wx*this.r0[0] + wy*this.r0[1] + wz*this.r0[2];
-      const py = wx*this.r1[0] + wy*this.r1[1] + wz*this.r1[2];
-      if (px*px + py*py >= EPS*EPS) {
-        const a = Math.atan2(py, px);
-        // Nearest winding to the current θ preserves accumulated turns.
-        this.s = _clamp$1(a + TWO_PI$1 * Math.round((this.s - a) / TWO_PI$1),
-                        this.min, this.max);
-      }
-      this._dialPoint();
-    }
-    return this;
-  }
-
-  /**
-   * Re-aim the constraint basis in the working space — the deferred-frame
-   * seam (the p5.tree bridge's `from` opt resolves its symbolic basis through
-   * mapDirection and calls this). Per kind:
-   *   PLANE  — new normal; the point is re-projected onto the new plane.
-   *   AXIS   — new direction; the scalar t is preserved, the point recomputed.
-   *   DIAL   — new plane normal + optional θ=0 reference; θ is preserved, the
-   *            in-plane basis rebuilt (reference re-derived when omitted),
-   *            the point recomputed.
-   *   SPHERE — no basis; no-op.
-   * Inputs are normalised; a zero-length axis keeps the previous one.
-   * Chainable.
-   *
-   * @param {number} ax,ay,az  New normal (PLANE) / direction (AXIS) / dial-plane normal (DIAL).
-   * @param {number} [zx,zy,zz]  DIAL only — θ=0 reference (re-derived when omitted).
-   * @returns {Constraint} this
-   */
-  aim(ax, ay, az, zx, zy, zz) {
-    if (this.kind === PLANE) {
-      const px = this.n[0], py = this.n[1], pz = this.n[2];
-      this.n[0] = ax; this.n[1] = ay; this.n[2] = az;
-      _unit$1(this.n, px, py, pz);
-      this.seed(this.pt[0], this.pt[1], this.pt[2]);
-    } else if (this.kind === AXIS) {
-      const px = this.u[0], py = this.u[1], pz = this.u[2];
-      this.u[0] = ax; this.u[1] = ay; this.u[2] = az;
-      _unit$1(this.u, px, py, pz);
-      this.pt[0] = this.anchor[0] + this.s*this.u[0];
-      this.pt[1] = this.anchor[1] + this.s*this.u[1];
-      this.pt[2] = this.anchor[2] + this.s*this.u[2];
-    } else if (this.kind === DIAL) {
-      const px = this.u[0], py = this.u[1], pz = this.u[2];
-      this.u[0] = ax; this.u[1] = ay; this.u[2] = az;
-      _unit$1(this.u, px, py, pz);
-      this._dialBasis(zx, zy, zz);
-      this._dialPoint();
-    }
-    return this;
-  }
-
-  /**
-   * The analytic pick proxy: the ray parameter t at which a ray in the
-   * working space meets the grab proxy, or Infinity. `radius` is the grab
-   * size in working-space units — a constant pixel size the caller converted
-   * through pixelRatio at the proxy's depth. SPHERE / PLANE / AXIS: a sphere
-   * of `radius` at the reported POINT. DIAL: the ring at the anchor with
-   * tube radius `radius` (rayHitRing), so a grab lands anywhere on the ring.
-   *
-   * @param {number} ox,oy,oz  Ray origin.
-   * @param {number} dx,dy,dz  Ray direction (unit).
-   * @param {number} radius    Grab radius, working units.
-   * @returns {number} The nearest t ≥ 0, or Infinity.
-   */
-  proxy(ox, oy, oz, dx, dy, dz, radius) {
-    const a = this.anchor;
-    if (this.kind === DIAL) {
-      return rayHitRing(ox,oy,oz, dx,dy,dz, a[0], a[1], a[2],
-                        this.u[0], this.u[1], this.u[2], this._radius, radius);
-    }
-    let px, py, pz;
-    if (this.kind === SPHERE) {
-      px = a[0] + this.dir[0]*this._radius;
-      py = a[1] + this.dir[1]*this._radius;
-      pz = a[2] + this.dir[2]*this._radius;
-    } else {
-      px = this.pt[0]; py = this.pt[1]; pz = this.pt[2];
-    }
-    return rayHitSphere(ox,oy,oz, dx,dy,dz, px,py,pz, radius);
-  }
-}
-
-/**
- * Convenience factory mirroring the constructor. Handy for headless tests and
- * for the bridge, which otherwise calls `new Constraint(...)` directly.
- * @param {number} kind  SPHERE | PLANE | AXIS | DIAL.
- * @param {Object} [opts]
- * @returns {Constraint}
- */
-function createConstraint(kind, opts) {
-  return new Constraint(kind, opts);
-}
-
-/**
- * @file Source-agnostic 6-DOF pose helm — integrates a live rate stream into a
- *       { pos, rot } pose. Renderer- and transport-agnostic. Zero dependencies.
- * @module tree/helm
- * @license AGPL-3.0-only
- *
- * A helm is the rate-stream sibling of the Track family: where a Track produces
- * a pose from keyframes over time, a helm produces a pose from a live 6-DOF
- * delta stream (a SpaceNavigator, a tracked hand, an agent policy). It is NOT a
- * handle — a handle reports a `vec3` solved from a pointer ray; a helm reports a
- * pose (position + orientation).
- *
- * Family placement (peer of PoseTrack, NOT a Track subclass — no timeline):
- *   feed(translation, rotation)  push the latest raw device rate (input, as Track.add)
- *   step(out, dt, basis)         integrate the rate by dt into the pose (BRIDGE-DRIVEN,
- *                                as Track.tick) — writes the new pose into out
- *   eval(out)                    read the current { pos, rot } (zero-alloc, as Track.eval)
- *   home(pose?)                  re-home the integrated pose (NOT reset — no keyframes to clear)
- *
- * Value layer (opt-in, §10): a per-helm `fullScale` keeps the read-outs honest
- * across input scales; an opt-in `filter` (oneEuro) conditions the fed rates
- * before the deadzone inside step; `poseDelta` differences two absolute poses
- * into a feedable rate. With `filter` null and the default `fullScale`, the
- * clean rate-native path is unchanged.
- *
- * Quaternion algebra is provided by quat.js. Out-first throughout; no allocation
- * in feed/step/eval. Storage convention (matches the rest of the core): vec3 and
- * quat state are plain number[] (f64) — the same shape as track.js keyframes and
- * the frozen basis-vector constants.
- *
- * ── Frame discipline (`from` / `basis`) ──────────────────────────────────────
- * The space the rates are interpreted in is named by `from` (WORLD | EYE | mat4),
- * a declaration the BRIDGE reads — the core never learns about a camera. The
- * resolved orientation arrives per-step as `basis`: an eye→world mat4 (or null
- * for WORLD ≡ the identity basis). Both the linear and angular rates are rotated
- * through that basis, then the quaternion is composed world-frame. This is the
- * single code path that covers both manipulation conventions:
- *
- *   - camera body-fly  — basis is the driven camera's own eye matrix (which this
- *                        helm produced last frame ⇒ equals the integrated `q`,
- *                        zero staleness); rotating a body delta through `q` then
- *                        world-composing is algebraically a body-frame compose.
- *   - screen-relative  — basis is the *viewing* camera's eye matrix (an external
- *                        frame); a push moves the target relative to the screen.
- *
- * Per-channel `from` ({ translation, rotation }) is a deferred, non-breaking
- * extension (one basis suffices today — pose-helm-design.md §8.3).
- */
-
-
-// =========================================================================
-// Module-level scratch — shared across helm instances (non-reentrant; step
-// is synchronous and called at most once per helm per frame).
-// =========================================================================
-
-const _dq = [0, 0, 0, 1];
-
-// Scratch for the optional input filter (helm.filter). The fed rates are packed
-// into one 6-vector, conditioned, and unpacked to lin/ang triples before the
-// deadzone — so a single filter carries one state per helm. Shared across
-// instances (step is synchronous, at most once per helm per frame).
-const _f6raw = [0, 0, 0, 0, 0, 0];
-const _f6out = [0, 0, 0, 0, 0, 0];
-const _fLin  = [0, 0, 0];
-const _fAng  = [0, 0, 0];
-
-/**
- * Default full-deflection input magnitude — the fed rate a read-out shows as
- * full (the SpaceNavigator's saturated lane). Private to core: a transport on a
- * different raw scale sets helm.fullScale and never reads this, so there is no
- * public HELM_FULL export. Display-only; integration uses profile.sens directly.
- */
-const HELM_FULL_SCALE = 500;
-
-// Deadzone gate — |v| > dz keeps v, else 0. Module-level so step allocates no
-// closure. Strictly-greater matches the e7 reference (rest reads exact 0).
-const _dz = (v, dz) => (v > dz || v < -dz) ? v : 0;
-
-/**
- * Build the canonical default profile. SpaceNavigator-tuned lane permutation
- * and the eye-frame manipulation feel found in the e7 experiments; it is the
- * per-app / per-device mapping layer and is meant to be overwritten wholesale
- * (`helm.profile = { … }`) for a different transport.
- *
- *   sign  — per-app direction (camera-fly vs object-grab invert; flip live).
- *   sens  — per-axis sensitivity (tame roll without touching the rest).
- *   lane  — input-channel permutation: which fed channel drives this DOF.
- *           T* lanes index the translation triple; R* lanes the rotation triple.
- */
-function _defaultProfile() {
-  return {
-    Tx: { sign:  1, sens: 0.30,   lane: 0 },
-    Ty: { sign:  1, sens: 0.30,   lane: 2 },
-    Tz: { sign: -1, sens: 0.30,   lane: 1 },
-    Rp: { sign: -1, sens: 0.0025, lane: 0 },
-    Ry: { sign: -1, sens: 0.0025, lane: 2 },
-    Rr: { sign:  1, sens: 0.0018, lane: 1 },
-  };
-}
-
-// =========================================================================
-// PoseHelm
-// =========================================================================
-
-/**
- * Source-agnostic 6-DOF pose producer. Holds a profile + the integrated pose;
- * no timeline (no keyframes, no play/seek/loop).
- */
-class PoseHelm {
-  constructor() {
-    /**
-     * DOF mapping table. Six channels, each `{ sign, sens, lane }`.
-     * Public and mutable — set wholesale to re-map a device or app.
-     * @type {{ Tx:Object, Ty:Object, Tz:Object, Rp:Object, Ry:Object, Rr:Object }}
-     */
-    this.profile = _defaultProfile();
-
-    /**
-     * Rest-drift floor. A fed rate with |value| ≤ deadzone reads as 0. Devices
-     * that rest at exact 0 need only a small floor. @type {number}
-     */
-    this.deadzone = 8;
-
-    /**
-     * Full-deflection input magnitude for the read-outs (gizmo overlay + panel
-     * meters): a fed rate of |fullScale| reads as a full bar / arrow. Set by a
-     * transport whose saturated rate differs from the default (a gamepad stick
-     * that saturates at 1 sets fullScale = 1). Display-only — integration uses
-     * profile.sens directly, so this never affects flight. @type {number}
-     */
-    this.fullScale = HELM_FULL_SCALE;
-
-    /**
-     * Optional input conditioner applied to the fed rates BEFORE the deadzone,
-     * inside step — a oneEuro filter, or any f(out, raw, dt) carrying function
-     * with a reset(). null (the default) is the clean rate-native path: the
-     * filter branch is skipped, so a clean device pays nothing. Set for noisy /
-     * absolute sources; home() resets it. @type {?Function}
-     */
-    this.filter = null;
-
-    /**
-     * The space fed rates are interpreted in: a space constant (WORLD | EYE) or
-     * a mat4 frame. Declarative only — the bridge reads this to resolve the
-     * per-step `basis`; the core stays camera-agnostic. @type {string|ArrayLike<number>}
-     */
-    this.from = 'EYE';
-
-    // Latest fed raw rates (refreshed by feed; persist until the next feed —
-    // the transport is responsible for feeding 0 when motion should stop).
-    this._lin = [0, 0, 0];
-    this._ang = [0, 0, 0];
-
-    // Integrated pose — the source of truth.
-    this._pos = [0, 0, 0];
-    this._q   = [0, 0, 0, 1];
-  }
-
-  /**
-   * Push the latest raw 6-DOF device rate. Either argument may be omitted to
-   * leave that half unchanged (devices report the two halves on separate
-   * frames). The value persists until the next feed. Raw device units — the
-   * profile's `sens` does the scaling, so the same feed() suits any transport.
-   *
-   * @param {ArrayLike<number>} [translation]  [tx, ty, tz] raw lane rates.
-   * @param {ArrayLike<number>} [rotation]     [rx, ry, rz] raw lane rates.
-   * @returns {PoseHelm} this
-   */
-  feed(translation, rotation) {
-    if (translation) {
-      this._lin[0] = translation[0] || 0;
-      this._lin[1] = translation[1] || 0;
-      this._lin[2] = translation[2] || 0;
-    }
-    if (rotation) {
-      this._ang[0] = rotation[0] || 0;
-      this._ang[1] = rotation[1] || 0;
-      this._ang[2] = rotation[2] || 0;
-    }
-    return this;
-  }
-
-  /**
-   * Integrate the latest fed rate by `dt` seconds into the pose, then write the
-   * pose into `out`. Bridge-driven (the player calls it each frame; a sketch
-   * never does, as it never calls track.tick()).
-   *
-   * `basis` is the resolved `from` frame: an eye→world column-major mat4
-   * (16-element ArrayLike), or null/omitted for WORLD (the identity basis). Its
-   * columns supply the right/up/back axes; forward is −col2. Both the linear and
-   * angular rates are rotated through it, then `q` is composed world-frame.
-   *
-   * Zero-allocation. `out` is `{ pos:number[3], rot:number[4] }`; omit it for a
-   * fresh object.
-   *
-   * @param {{ pos:number[], rot:number[] }} [out]
-   * @param {number} dt       Elapsed time in seconds.
-   * @param {ArrayLike<number>} [basis]  Eye→world mat4, or null for WORLD.
-   * @returns {{ pos:number[], rot:number[] }} out
-   */
-  step(out, dt, basis) {
-    const p = this.profile, dz = this.deadzone;
-    let lin = this._lin, ang = this._ang;
-
-    // Value layer — condition the fed rates BEFORE the deadzone (the filter
-    // narrows the jitter band; the deadzone then gates the residual to exact
-    // zero). The filter carries state, so it is ticked exactly once per step;
-    // activity() reads the raw fed rate and is left unfiltered (the read-out
-    // shows device input, normalized by fullScale). Skipped when filter is null.
-    const filter = this.filter;
-    if (filter) {
-      _f6raw[0] = lin[0]; _f6raw[1] = lin[1]; _f6raw[2] = lin[2];
-      _f6raw[3] = ang[0]; _f6raw[4] = ang[1]; _f6raw[5] = ang[2];
-      filter(_f6out, _f6raw, dt);
-      _fLin[0] = _f6out[0]; _fLin[1] = _f6out[1]; _fLin[2] = _f6out[2];
-      _fAng[0] = _f6out[3]; _fAng[1] = _f6out[4]; _fAng[2] = _f6out[5];
-      lin = _fLin; ang = _fAng;
-    }
-
-    // Basis axes (right / up / forward). No basis ⇒ the identity eye matrix:
-    // right +X, up +Y, forward −Z. Forward is −col2 (an eye→world matrix stores
-    // the camera's BACK in col2), and the identity's col2 is +Z, so forward is
-    // −Z — making step(out, dt, null) identical to step(out, dt, IDENTITY_MAT4),
-    // as the `from` contract ("null ≡ the identity basis") promises.
-    let rX = 1, rY = 0, rZ =  0;
-    let uX = 0, uY = 1, uZ =  0;
-    let fX = 0, fY = 0, fZ = -1;
-    if (basis) {
-      rX =  basis[0]; rY =  basis[1]; rZ =  basis[2];
-      uX =  basis[4]; uY =  basis[5]; uZ =  basis[6];
-      fX = -basis[8]; fY = -basis[9]; fZ = -basis[10];
-    }
-
-    // Angular: three rates → one delta quat, rotated into world, world-composed.
-    const wx = _dz(ang[p.Rp.lane], dz) * p.Rp.sign * p.Rp.sens;
-    const wy = _dz(ang[p.Ry.lane], dz) * p.Ry.sign * p.Ry.sens;
-    const wz = _dz(ang[p.Rr.lane], dz) * p.Rr.sign * p.Rr.sens;
-    const w  = Math.sqrt(wx * wx + wy * wy + wz * wz);
-    if (w > 0) {
-      // Axis in world = basis · (wx,wy,wz); its length is w (basis orthonormal),
-      // so the rotation angle is w·dt. qFromAxisAngle renormalizes the axis.
-      const ax = wx * rX + wy * uX + wz * fX;
-      const ay = wx * rY + wy * uY + wz * fY;
-      const az = wx * rZ + wy * uZ + wz * fZ;
-      qFromAxisAngle(_dq, ax, ay, az, w * dt);
-      qMul(this._q, _dq, this._q);        // delta already in world → world-frame compose
-      qNormalize(this._q);
-    }
-
-    // Linear: three rates rotated into world, integrated by dt.
-    const tx = _dz(lin[p.Tx.lane], dz) * p.Tx.sign * p.Tx.sens;
-    const ty = _dz(lin[p.Ty.lane], dz) * p.Ty.sign * p.Ty.sens;
-    const tz = _dz(lin[p.Tz.lane], dz) * p.Tz.sign * p.Tz.sens;
-    this._pos[0] += (tx * rX + ty * uX + tz * fX) * dt;
-    this._pos[1] += (tx * rY + ty * uY + tz * fY) * dt;
-    this._pos[2] += (tx * rZ + ty * uZ + tz * fZ) * dt;
-
-    return this.eval(out);
-  }
-
-  /**
-   * Read the current pose into `out` (zero-alloc). The shared output contract
-   * that feeds applyPose — mirrors Track.eval.
-   *
-   * @param {{ pos:number[], rot:number[] }} [out]
-   * @returns {{ pos:number[], rot:number[] }} out
-   */
-  eval(out) {
-    out = out || { pos: [0, 0, 0], rot: [0, 0, 0, 1] };
-    out.pos[0] = this._pos[0]; out.pos[1] = this._pos[1]; out.pos[2] = this._pos[2];
-    out.rot[0] = this._q[0];   out.rot[1] = this._q[1];
-    out.rot[2] = this._q[2];   out.rot[3] = this._q[3];
-    return out;
-  }
-
-  /**
-   * Write the six effective channel rates (post deadzone·sign·sens) into `out6`,
-   * in channel order [Tx, Ty, Tz, Rp, Ry, Rr]. The gizmo reads this to light the
-   * DOFs being driven; readouts can show signed magnitudes. Zero-alloc.
-   *
-   * @param {number[]} out6  6-element destination.
-   * @returns {number[]} out6
-   */
-  activity(out6) {
-    const p = this.profile, dz = this.deadzone, lin = this._lin, ang = this._ang;
-    out6[0] = _dz(lin[p.Tx.lane], dz) * p.Tx.sign * p.Tx.sens;
-    out6[1] = _dz(lin[p.Ty.lane], dz) * p.Ty.sign * p.Ty.sens;
-    out6[2] = _dz(lin[p.Tz.lane], dz) * p.Tz.sign * p.Tz.sens;
-    out6[3] = _dz(ang[p.Rp.lane], dz) * p.Rp.sign * p.Rp.sens;
-    out6[4] = _dz(ang[p.Ry.lane], dz) * p.Ry.sign * p.Ry.sens;
-    out6[5] = _dz(ang[p.Rr.lane], dz) * p.Rr.sign * p.Rr.sens;
-    return out6;
-  }
-
-  /**
-   * Re-home the integrated pose. Sets position + orientation to `pose` (or the
-   * identity pose when omitted) and clears any pending rate so the helm rests at
-   * a clean, known state. NOT a reset — there are no keyframes to clear.
-   *
-   * @param {{ pos?:ArrayLike<number>, rot?:ArrayLike<number> }} [pose]
-   * @returns {PoseHelm} this
-   */
-  home(pose) {
-    if (pose && pose.pos) {
-      this._pos[0] = pose.pos[0]; this._pos[1] = pose.pos[1]; this._pos[2] = pose.pos[2];
-    } else {
-      this._pos[0] = 0; this._pos[1] = 0; this._pos[2] = 0;
-    }
-    if (pose && pose.rot) {
-      this._q[0] = pose.rot[0]; this._q[1] = pose.rot[1];
-      this._q[2] = pose.rot[2]; this._q[3] = pose.rot[3];
-    } else {
-      this._q[0] = 0; this._q[1] = 0; this._q[2] = 0; this._q[3] = 1;
-    }
-    this._lin[0] = this._lin[1] = this._lin[2] = 0;
-    this._ang[0] = this._ang[1] = this._ang[2] = 0;
-    if (this.filter) this.filter.reset();   // drop filter state at the discontinuity
-    return this;
-  }
-}
-
-/**
- * @file Camera state ↔ matrices: builders, decomposers, and in-place edits.
- * @module tree/camera
- * @license AGPL-3.0-only
- *
- * The camera is plain data — the CameraTrack keyframe shape:
- *
- *   cam = {
- *     eye:        [x, y, z],       // position
- *     center:     [x, y, z],       // lookat target; |center − eye| is the gaze distance
- *     up:         [x, y, z],       // up hint, need not be unit
- *     fov:        number | null,   // vertical field of view, radians — perspective
- *     halfHeight: number | null,   // world-unit half-height at the near plane — orthographic
- *     near:       number,          // > 0
- *     far:        number,          // > near
- *   }
- *
- * Exactly one of fov / halfHeight is meaningful; fov wins when both are set.
- * With both null the lens is "unchanged": cameraProj and cameraPlanes return
- * null and leave their output untouched, so a track that evaluates null into
- * the state keeps the last projection installed. A track writes the state
- * directly — `track.eval(cam)` — and a pose drives it through cameraFromPose.
- *
- * The state carries no aspect ratio — the viewport owns it — so one state is
- * portable between targets of different sizes; every builder that needs it
- * takes it as an argument.
- *
- * Vectors are plain number[] (f64, authoring state); matrices are written into
- * whatever 16-element buffer the caller passes. createCamera is the one
- * allocating call; everything else is out-first (or in-place) and zero-alloc.
- *
- * Every function that needs the camera frame derives it through mat4Eye, so
- * planes and edits agree with cameraEye / cameraView exactly — including the
- * up re-seed when the view direction is parallel to the up hint.
- */
-
-
-const _E$1 = new Float64Array(16);   // eye→world frame scratch: right 0–2, up 4–6, back 8–10
-const _d = [0, 0, 0];              // view-direction scratch
-
-/** Eye→world frame of `cam` into `_E`. */
-function _frame(cam) {
-  const e = cam.eye, c = cam.center, u = cam.up;
-  mat4Eye(_E$1, e[0],e[1],e[2], c[0],c[1],c[2], u[0],u[1],u[2]);
-}
-
-/** Gaze distance |center − eye|, or 1 when the state is degenerate. */
-function _gaze(cam) {
-  const dx = cam.center[0]-cam.eye[0], dy = cam.center[1]-cam.eye[1], dz = cam.center[2]-cam.eye[2];
-  const d = Math.sqrt(dx*dx+dy*dy+dz*dz);
-  return d > 0 ? d : 1;
-}
-
-function _vec3(v, x, y, z) { return v != null ? [v[0], v[1], v[2]] : [x, y, z]; }
-
-// =========================================================================
-// State
-// =========================================================================
-
-/**
- * Allocate a camera state — the one allocating call, setup-time.
- * Defaults: eye [0, 0, 500], center [0, 0, 0], up [0, 1, 0], fov π/3,
- * halfHeight null, near 0.1, far 1000. Passing halfHeight without fov yields
- * an orthographic state (fov null).
- *
- * @param {{ eye?:number[], center?:number[], up?:number[], fov?:number|null,
- *           halfHeight?:number|null, near?:number, far?:number }} [opts]
- * @returns {{ eye:number[], center:number[], up:number[], fov:number|null,
- *             halfHeight:number|null, near:number, far:number }}
- */
-function createCamera(opts) {
-  const o = {};
-  const ortho = o.halfHeight != null && o.fov === undefined;
-  return {
-    eye:        _vec3(o.eye,    0, 0, 500),
-    center:     _vec3(o.center, 0, 0, 0),
-    up:         _vec3(o.up,     0, 1, 0),
-    fov:        o.fov        !== undefined ? o.fov        : (ortho ? null : Math.PI / 3),
-    halfHeight: o.halfHeight !== undefined ? o.halfHeight : null,
-    near:       typeof o.near === 'number' ? o.near : 0.1,
-    far:        typeof o.far  === 'number' ? o.far  : 1000,
-  };
-}
-
-/**
- * Copy one camera state into another (an orbit's home, a track's capture).
- * @param {object} out  Destination state.
- * @param {object} cam  Source state.
- * @returns {object} out
- */
-function cameraCopy(out, cam) {
-  out.eye[0]=cam.eye[0];       out.eye[1]=cam.eye[1];       out.eye[2]=cam.eye[2];
-  out.center[0]=cam.center[0]; out.center[1]=cam.center[1]; out.center[2]=cam.center[2];
-  out.up[0]=cam.up[0];         out.up[1]=cam.up[1];         out.up[2]=cam.up[2];
-  out.fov = cam.fov; out.halfHeight = cam.halfHeight;
-  out.near = cam.near; out.far = cam.far;
-  return out;
-}
-
-// =========================================================================
-// Builders — state → matrices
-// =========================================================================
-
-/**
- * View matrix (world→eye) from the state's lookat.
- * @param {Float32Array|number[]} out  16-element destination.
- * @param {object} cam
- * @returns {Float32Array|number[]} out
- */
-function cameraView(out, cam) {
-  const e = cam.eye, c = cam.center, u = cam.up;
-  return mat4View(out, e[0],e[1],e[2], c[0],c[1],c[2], u[0],u[1],u[2]);
-}
-
-/**
- * Eye matrix (eye→world) from the state's lookat.
- * @param {Float32Array|number[]} out  16-element destination.
- * @param {object} cam
- * @returns {Float32Array|number[]} out
- */
-function cameraEye(out, cam) {
-  const e = cam.eye, c = cam.center, u = cam.up;
-  return mat4Eye(out, e[0],e[1],e[2], c[0],c[1],c[2], u[0],u[1],u[2]);
-}
-
-/**
- * Projection matrix from the state's lens: mat4Persp from fov, or mat4Ortho
- * from halfHeight, with symmetric extents (top = near · tan(fov / 2) or
- * halfHeight; right = top · aspect).
- *
- * @param {Float32Array|number[]} out  16-element destination.
- * @param {object} cam
- * @param {number} aspect        Viewport width / height.
- * @param {number} ndcZMin       WEBGL (−1) or WEBGPU (0).
- * @param {number} [ndcYSign=1]  +1 NDC y-up; −1 NDC y-down.
- * @returns {Float32Array|number[]|null} out, or null (out untouched) when
- *          both fov and halfHeight are null.
- */
-function cameraProj(out, cam, aspect, ndcZMin, ndcYSign = 1) {
-  const near = cam.near, far = cam.far;
-  if (cam.fov != null) {
-    const top = near * Math.tan(cam.fov / 2), right = top * aspect;
-    return mat4Persp(out, -right, right, -top, top, near, far, ndcZMin, ndcYSign);
-  }
-  if (cam.halfHeight != null) {
-    const top = cam.halfHeight, right = top * aspect;
-    return mat4Ortho(out, -right, right, -top, top, near, far, ndcZMin, ndcYSign);
-  }
-  return null;
-}
-
-/**
- * Drive the lookat from a TRS pose: eye ← pos, up and forward from the
- * rotation's columns 1 and −2, center ← eye + forward · d with d the current
- * gaze distance (1 when degenerate). The lens is untouched; `scl` is ignored.
- *
- * @param {object} cam                            State written in place.
- * @param {{ pos:number[], rot:number[] }} pose   rot is a unit quaternion [x,y,z,w].
- * @returns {object} cam
- */
-function cameraFromPose(cam, pose) {
-  const d = _gaze(cam);
-  const q = pose.rot, x=q[0], y=q[1], z=q[2], w=q[3];
-  const x2=x+x, y2=y+y, z2=z+z;
-  const xx=x*x2, xy=x*y2, xz=x*z2, yy=y*y2, yz=y*z2, zz=z*z2, wx=w*x2, wy=w*y2, wz=w*z2;
-  const ux=xy-wz, uy=1-(xx+zz), uz=yz+wx;        // column 1 of qToMat4(rot): up
-  const bx=xz+wy, by=yz-wx, bz=1-(xx+yy);        // column 2: back
-  cam.eye[0]=pose.pos[0]; cam.eye[1]=pose.pos[1]; cam.eye[2]=pose.pos[2];
-  cam.up[0]=ux; cam.up[1]=uy; cam.up[2]=uz;
-  cam.center[0]=cam.eye[0]-bx*d; cam.center[1]=cam.eye[1]-by*d; cam.center[2]=cam.eye[2]-bz*d;
-  return cam;
-}
-
-/**
- * The lookat as a TRS pose: pos ← eye, rot ← qFromLookDir(center − eye, up) —
- * the rotation of cameraEye, so a helm seeded from it continues the frame.
- *
- * @param {{ pos:number[], rot:number[] }} pose  Written in place.
- * @param {object} cam
- * @returns {{ pos:number[], rot:number[] }} pose
- */
-function cameraToPose(pose, cam) {
-  pose.pos[0]=cam.eye[0]; pose.pos[1]=cam.eye[1]; pose.pos[2]=cam.eye[2];
-  _d[0]=cam.center[0]-cam.eye[0]; _d[1]=cam.center[1]-cam.eye[1]; _d[2]=cam.center[2]-cam.eye[2];
-  qFromLookDir(pose.rot, _d, cam.up);
-  return pose;
-}
-
-// =========================================================================
-// Edits — in place, chainable, zero-alloc
-// =========================================================================
-
-/**
- * Orbit the eye about the center: `dAz` rotates it about the up hint
- * (right-handed); `dEl` raises its elevation above the plane through the
- * center perpendicular to the hint, clamped to ±opts.maxEl so the view
- * direction never reaches the hint (the pole guard). `up` is left as the hint
- * it was, so an orbit never rolls. A state already at the pole is pulled
- * inside the guard by its first non-zero edit; (0, 0) is a no-op.
- *
- * @param {object} cam
- * @param {number} dAz  Azimuth delta, radians.
- * @param {number} dEl  Elevation delta, radians.
- * @param {{ maxEl?:number }} [opts]  Elevation limit; default π/2 − 1e-3.
- * @returns {object} cam
- */
-function cameraOrbit(cam, dAz, dEl, opts) {
-  if (dAz === 0 && dEl === 0) return cam;
-  const maxEl = Math.PI / 2 - 1e-3;
-  const e = cam.eye, c = cam.center;
-  let ux=cam.up[0], uy=cam.up[1], uz=cam.up[2];
-  const ul = Math.sqrt(ux*ux+uy*uy+uz*uz) || 1;
-  ux/=ul; uy/=ul; uz/=ul;
-  const dx=e[0]-c[0], dy=e[1]-c[1], dz=e[2]-c[2];
-  const r = Math.sqrt(dx*dx+dy*dy+dz*dz);
-  _frame(cam);
-  const px=_E$1[4], py=_E$1[5], pz=_E$1[6];            // the eye's up
-  const bx=_E$1[8], by=_E$1[9], bz=_E$1[10];           // back: center → eye, unit
-  // elevation: raise by θ within the (back, up) plane, clamped
-  const el  = Math.asin(Math.max(-1, Math.min(1, bx*ux+by*uy+bz*uz)));
-  const th  = Math.max(-maxEl, Math.min(maxEl, el + dEl)) - el;
-  const ct = Math.cos(th), st = Math.sin(th);
-  const ox = r*(bx*ct+px*st), oy = r*(by*ct+py*st), oz = r*(bz*ct+pz*st);
-  // azimuth: rotate about the hint (Rodrigues)
-  const ca = Math.cos(dAz), sa = Math.sin(dAz), k = (ux*ox+uy*oy+uz*oz)*(1-ca);
-  e[0] = c[0] + ox*ca + (uy*oz-uz*oy)*sa + ux*k;
-  e[1] = c[1] + oy*ca + (uz*ox-ux*oz)*sa + uy*k;
-  e[2] = c[2] + oz*ca + (ux*oy-uy*ox)*sa + uz*k;
-  return cam;
-}
-
-/**
- * Dolly: scale the gaze distance by `factor` — the eye moves along the view
- * direction under perspective; under orthographic (fov null, halfHeight set)
- * halfHeight is scaled instead, since moving the eye changes nothing on
- * screen. opts.min / opts.max clamp the scaled quantity. An edit that would
- * make it non-positive is a no-op.
- *
- * @param {object} cam
- * @param {number} factor
- * @param {{ min?:number, max?:number }} [opts]
- * @returns {object} cam
- */
-function cameraDolly(cam, factor, opts) {
-  const min = opts && typeof opts.min === 'number' ? opts.min : 0;
-  const max = opts && typeof opts.max === 'number' ? opts.max : Infinity;
-  if (cam.fov == null && cam.halfHeight != null) {
-    const h = Math.max(min, Math.min(max, cam.halfHeight * factor));
-    if (h > 0) cam.halfHeight = h;
-    return cam;
-  }
-  const e = cam.eye, c = cam.center;
-  const dx=e[0]-c[0], dy=e[1]-c[1], dz=e[2]-c[2];
-  const r = Math.sqrt(dx*dx+dy*dy+dz*dz);
-  if (r === 0) return cam;
-  const r1 = Math.max(min, Math.min(max, r * factor));
-  if (!(r1 > 0)) return cam;
-  const s = r1 / r;
-  e[0]=c[0]+dx*s; e[1]=c[1]+dy*s; e[2]=c[2]+dz*s;
-  return cam;
-}
-
-/**
- * Pan: translate eye and center by `dx` along the eye's right and `dy` along
- * its up, world units. The caller converts pixels through pixelRatio at the
- * center's depth so a pan tracks the pointer.
- *
- * @param {object} cam
- * @param {number} dx
- * @param {number} dy
- * @returns {object} cam
- */
-function cameraPan(cam, dx, dy) {
-  _frame(cam);
-  const tx=_E$1[0]*dx+_E$1[4]*dy, ty=_E$1[1]*dx+_E$1[5]*dy, tz=_E$1[2]*dx+_E$1[6]*dy;
-  const e = cam.eye, c = cam.center;
-  e[0]+=tx; e[1]+=ty; e[2]+=tz;
-  c[0]+=tx; c[1]+=ty; c[2]+=tz;
-  return cam;
-}
+import { WEBGL, cameraView, cameraProj, mat4Mul, mat4Invert, PLANE, createConstraint, WORLD, AXIS, DIAL, POINT, mapDirection, pixelRatio, rayHitSphere, unproject, SPHERE, dirFromAzEl, DIRECTION, mapLocation, MATRIX, PoseHelm, cameraToPose, EYE, SELF, qToMat4, cameraEye, cameraFromPose, CameraTrack, PoseTrack, qFromAxisAngle, SCREEN, cameraCopy, createCamera, coastAlive, coastStep, cameraOrbit, cameraPan, cameraDolly } from '@nakednous/tree';
 
 /**
  * @file The view bag — the matrices every pick, solve, label and orbit reads.
@@ -3685,7 +401,7 @@ function createPlayers() {
   return players;
 }
 
-const _now$1 = () => (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
+const _now$2 = () => (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
 
 /**
  * Create a frame loop. `onFrame(dt)` runs once per animation frame with the
@@ -3701,7 +417,7 @@ function createLoop(opts) {
   const o = opts || {};
   const raf = o.raf || ((cb) => requestAnimationFrame(cb));
   const caf = o.caf || ((id) => cancelAnimationFrame(id));
-  const now = o.now || _now$1;
+  const now = o.now || _now$2;
   const clamp = (o.clampMs ?? 50) / 1000;
   let handle = null, last = 0;
   const loop = {
@@ -5132,10 +1848,88 @@ function createGamepad(host, opts) {
 }
 
 /**
- * @file Media sources — images, video and Canvas2D rasters for a bridge's textures.
+ * @file OBJ text → the arrays shape a bridge's buffer upload takes.
+ * @module host/obj
+ * @license AGPL-3.0-only
+ *
+ * Positions, texture coordinates and normals. Faces are fan-triangulated — a
+ * quad as 0 1 2 · 2 3 0 — and each distinct position / uv / normal triple
+ * becomes one vertex, in order of first use. Indices are 1-based, or negative
+ * counting back from the last declared element. Groups, objects, smoothing and
+ * materials are ignored.
+ */
+
+
+const _index = (s, count) => {
+  const i = parseInt(s, 10);
+  return i < 0 ? count + i : i - 1;
+};
+
+/**
+ * Parse OBJ text into `{ position, normal?, texcoord?, indices }`; normal and
+ * texcoord only when some face vertex names one.
+ * @param {string} text
+ * @returns {{ position:{numComponents:number,data:Float32Array},
+ *             normal?:{numComponents:number,data:Float32Array},
+ *             texcoord?:{numComponents:number,data:Float32Array},
+ *             indices:{numComponents:number,data:Uint32Array} }}
+ */
+function parseObj(text) {
+  const v = [], vt = [], vn = [];
+  const position = [], texcoord = [], normal = [], indices = [];
+  const seen = new Map();
+  let uvs = false, normals = false;
+
+  const vertex = (token) => {
+    const [ps, ts, ns] = token.split('/');
+    const p = _index(ps, v.length / 3);
+    const t = ts ? _index(ts, vt.length / 2) : -1;
+    const n = ns ? _index(ns, vn.length / 3) : -1;
+    const key = p + '/' + t + '/' + n;
+    let id = seen.get(key);
+    if (id !== undefined) return id;
+    position.push(v[3 * p], v[3 * p + 1], v[3 * p + 2]);
+    if (t >= 0) { texcoord.push(vt[2 * t], vt[2 * t + 1]); uvs = true; } else texcoord.push(0, 0);
+    if (n >= 0) { normal.push(vn[3 * n], vn[3 * n + 1], vn[3 * n + 2]); normals = true; } else normal.push(0, 0, 0);
+    id = position.length / 3 - 1;
+    seen.set(key, id);
+    return id;
+  };
+
+  for (const raw of text.split('\n')) {
+    const line = raw.trim();
+    if (!line || line[0] === '#') continue;
+    const parts = line.split(/\s+/);
+    switch (parts[0]) {
+      case 'v':  v.push(+parts[1], +parts[2], +parts[3]); break;
+      case 'vt': vt.push(+parts[1], +(parts[2] ?? 0)); break;
+      case 'vn': vn.push(+parts[1], +parts[2], +parts[3]); break;
+      case 'f': {
+        const ids = parts.slice(1).map(vertex);
+        if (ids.length === 4) indices.push(ids[0], ids[1], ids[2], ids[2], ids[3], ids[0]);
+        else for (let i = 1; i + 1 < ids.length; i++) indices.push(ids[0], ids[i], ids[i + 1]);
+        break;
+      }
+    }
+  }
+
+  const out = {
+    position: { numComponents: 3, data: new Float32Array(position) },
+    indices: { numComponents: 3, data: new Uint32Array(indices) },
+  };
+  if (normals) out.normal = { numComponents: 3, data: new Float32Array(normal) };
+  if (uvs) out.texcoord = { numComponents: 2, data: new Float32Array(texcoord) };
+  return out;
+}
+
+/**
+ * @file Media sources — images, video and Canvas2D rasters for a bridge's textures, OBJ models for its buffers.
  * @module host/media
  * @license AGPL-3.0-only
  *
+ * A model arrives as arrays for a bridge's buffer upload: loadModel fetches an
+ * OBJ file and parses it (host/obj).
+ *
  * What a texture upload reads from: an ImageBitmap fetched from a URL, a
  * hidden <video> element from a file or the user's camera, a bitmap drawn
  * through a 2D context (the text path — glyph strips, billboard tags,
@@ -5161,6 +1955,28 @@ async function loadImage(url, opts) {
   return o.bitmap ? createImageBitmap(blob, o.bitmap) : createImageBitmap(blob);
 }
 
+/**
+ * Fetch an OBJ model into the arrays shape: position and indices, plus normal
+ * and texcoord when the file carries them. twgl's createBufferInfoFromArrays
+ * takes the result as it is.
+ *
+ * Faces are triangulated and each distinct position / uv / normal triple
+ * becomes one vertex. Materials are ignored.
+ *
+ * @param {string} url
+ * @param {{ fetch?:object }} [opts]  fetch: the fetch init (credentials, mode, …).
+ * @returns {Promise<{ position:{numComponents:number,data:Float32Array},
+ *                     normal?:{numComponents:number,data:Float32Array},
+ *                     texcoord?:{numComponents:number,data:Float32Array},
+ *                     indices:{numComponents:number,data:Uint32Array} }>}
+ */
+async function loadModel(url, opts) {
+  const o = opts || {};
+  const res = await fetch(url, o.fetch);
+  if (!res.ok) throw new Error('[host] model: ' + url + ' → ' + res.status);
+  return parseObj(await res.text());
+}
+
 /**
  * A hidden, muted, inline <video> element from a file or the user's camera.
  * `ready` resolves once metadata arrived (width / height known); a camera
@@ -5469,9 +2285,14 @@ function createLabels(host, opts) {
  * Two-pointer motion is computed from the pointers' own coordinates, never
  * from a browser's pinch synthesis, so it reads the same on every platform;
  * the canvas gets touch-action: none while the orbit lives so the browser
- * does not scroll or zoom the page instead. No damping, no inertia: direct
- * manipulation wants exactness, and a sketch that wants smoothing lerps the
- * camera it owns.
+ * does not scroll or zoom the page instead. `damping`, seconds, makes the
+ * camera trail the gesture through a first-order lag: each step of a drag —
+ * orbit, pan and dolly lanes — and each wheel notch is an impulse the camera
+ * drains with that time constant through tree's coast, so it follows the
+ * finger about `damping` behind and, after a release, travels the rest of
+ * what the finger did and no more, a flick easing out. A fresh touch drops
+ * what is still draining, so do home() and enabled = false. The default is
+ * 0.2 s; 0 makes the orbit exact.
  *
  * Screen y runs down; which world direction that is depends on the
  * projection installed in the view bag: a y-up projection (GL's, tree's
@@ -5482,19 +2303,23 @@ function createLabels(host, opts) {
 
 
 const _clamp = { min: 0, max: Infinity };
+const _now$1 = () => (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
+const EPS = 1e-4;        // a rate below this in every lane ends the drain
+const DT_MAX = 0.1;      // seconds, the measured frame's clamp
 
 /**
  * Create an orbit on a camera state.
  *
  * @param {object} host
  * @param {object} cam  The camera state written.
- * @param {{ rotate?:number, pan?:number, zoom?:number, wheel?:number,
+ * @param {{ rotate?:number, pan?:number, zoom?:number, wheel?:number, damping?:number,
  *           minDistance?:number, maxDistance?:number, enabled?:boolean }} [opts]
  *        rotate: radians per pixel (default 0.005). pan / zoom / wheel:
  *        scalars on the two-pointer pan, the pinch and the wheel dolly
- *        (default 1). minDistance / maxDistance: gaze-distance clamps.
- * @returns {object} The orbit: { cam, enabled, rotate, pan, zoom, wheel,
- *          minDistance, maxDistance, update(), home(), dispose() }.
+ *        (default 1). damping: the lag's time constant in seconds (default
+ *        0.2; 0 exact). minDistance / maxDistance: gaze-distance clamps.
+ * @returns {object} The orbit: { cam, enabled, rotate, pan, zoom, wheel, damping,
+ *          minDistance, maxDistance, update(dt), home(), dispose() }.
  */
 function createOrbit(host, cam, opts) {
   const o = opts || {};
@@ -5502,6 +2327,16 @@ function createOrbit(host, cam, opts) {
   const home = cameraCopy(createCamera(), cam);
   const tracked = new Map();   // pointer id → { x, y } as last consumed
   let wheelAcc = 0;
+  const rate = [0, 0, 0, 0, 0];           // what is still draining: dAz, dEl, panX, panY, log dolly — per second
+  const step = [0, 0, 0, 0, 0];           // one frame of it
+  let lastNow = 0, wasPressed = false;
+
+  const cancel = () => { for (let i = 0; i < 5; i++) rate[i] = 0; };
+  const apply = (s) => {
+    if (s[0] !== 0 || s[1] !== 0) cameraOrbit(cam, s[0], s[1]);
+    if (s[2] !== 0 || s[3] !== 0) cameraPan(cam, s[2], s[3]);
+    if (s[4] !== 0) dolly(Math.exp(s[4]));
+  };
 
   const onWheel = (e) => {
     if (typeof e.preventDefault === 'function') e.preventDefault();
@@ -5539,34 +2374,47 @@ function createOrbit(host, cam, opts) {
     zoom: o.zoom ?? 1,
     /** Scalar on the wheel dolly. */
     wheel: o.wheel ?? 1,
+    /** The lag's time constant, seconds; 0 makes the orbit exact. */
+    damping: o.damping ?? 0.2,
     /** Gaze-distance clamps for every dolly. */
     minDistance: o.minDistance ?? 0,
     maxDistance: o.maxDistance ?? Infinity,
 
     /**
-     * Consume this frame's unclaimed pointer motion and wheel into cam.
+     * Consume this frame's unclaimed pointer motion and wheel into cam —
+     * through the lag when damping is on.
+     * @param {number} [dt]  The frame in seconds; measured since the last update when omitted.
      * @returns {boolean} Whether the camera moved.
      */
-    update() {
-      if (!orbit.enabled) { tracked.clear(); wheelAcc = 0; return false; }
+    update(dt) {
+      const now = _now$1();
+      if (typeof dt !== 'number') dt = lastNow ? Math.min((now - lastNow) / 1000, DT_MAX) : 0;
+      lastNow = now;
+      if (!orbit.enabled) { tracked.clear(); wheelAcc = 0; cancel(); wasPressed = false; return false; }
       const src = host.pointer;
       let a = null, b = null;
       for (const p of src.pointers.values()) {
-        if (p.owner !== null || p.up || p.cancel) { tracked.delete(p.id); continue; }
+        // a hovering mouse has an entry without a press; only pressed, unclaimed, live pointers drive
+        if (!p.down || p.owner !== null || p.up || p.cancel) { tracked.delete(p.id); continue; }
         if (a === null || p.id < a.id) { b = a; a = p; }
         else if (b === null || p.id < b.id) b = p;
       }
       for (const id of tracked.keys()) {
         if ((a === null || id !== a.id) && (b === null || id !== b.id)) tracked.delete(id);
       }
+      const tau = orbit.damping > 0 ? orbit.damping : 0;
+      const pressed = a !== null;
+      if (pressed && !wasPressed) cancel();         // a fresh touch catches the scene: what was still draining is dropped
+      wasPressed = pressed;
       let moved = false;
+      let az = 0, el = 0, px = 0, py = 0, ld = 0;   // this frame's step
       const view = host.view;
       const ys = view.mat4Proj[5] < 0 ? -1 : 1;   // screen-down is the eye's −up under a y-up projection, +up under p5's flip
       if (a !== null && b === null) {
         const t = tracked.get(a.id);
         if (t) {
           const dx = a.x - t.x, dy = a.y - t.y;
-          if (dx !== 0 || dy !== 0) { cameraOrbit(cam, -dx * orbit.rotate, ys * dy * orbit.rotate); moved = true; }
+          if (dx !== 0 || dy !== 0) { az = -dx * orbit.rotate; el = ys * dy * orbit.rotate; }
         }
         track(a);
       } else if (a !== null && b !== null) {
@@ -5575,30 +2423,37 @@ function createOrbit(host, cam, opts) {
           const dmx = (a.x + b.x - ta.x - tb.x) / 2, dmy = (a.y + b.y - ta.y - tb.y) / 2;
           if (dmx !== 0 || dmy !== 0) {
             const ratio = pixelRatio(view.mat4Proj, -view.vp[3] || 1, -distance(), view.ndcZMin);
-            cameraPan(cam, -dmx * ratio * orbit.pan, ys * dmy * ratio * orbit.pan);
-            moved = true;
+            px = -dmx * ratio * orbit.pan; py = ys * dmy * ratio * orbit.pan;
           }
           const d0 = Math.hypot(ta.x - tb.x, ta.y - tb.y), d1 = Math.hypot(a.x - b.x, a.y - b.y);
-          if (d0 > 0 && d1 > 0 && d0 !== d1) { dolly(Math.pow(d0 / d1, orbit.zoom)); moved = true; }
+          if (d0 > 0 && d1 > 0 && d0 !== d1) ld = orbit.zoom * Math.log(d0 / d1);
         }
         track(a); track(b);
       }
+      // the step: exact, or — with damping — an impulse the drain below spreads over time
+      if (az !== 0 || el !== 0 || px !== 0 || py !== 0 || ld !== 0) {
+        if (tau > 0) { rate[0] += az / tau; rate[1] += el / tau; rate[2] += px / tau; rate[3] += py / tau; rate[4] += ld / tau; }
+        else { step[0] = az; step[1] = el; step[2] = px; step[3] = py; step[4] = ld; apply(step); moved = true; }
+      }
       if (wheelAcc !== 0) {
-        dolly(Math.exp(wheelAcc * 0.001 * orbit.wheel));
+        const w = wheelAcc * 0.001 * orbit.wheel;
         wheelAcc = 0;
-        moved = true;
+        if (tau > 0) rate[4] += w / tau;
+        else { dolly(Math.exp(w)); moved = true; }
       }
+      if (tau > 0 && coastAlive(rate, EPS)) { apply(coastStep(step, rate, dt, tau)); moved = true; }
       return moved;
     },
 
-    /** Restore the pose captured at creation. */
-    home() { cameraCopy(cam, home); return orbit; },
+    /** Restore the pose captured at creation; whatever was draining is dropped. */
+    home() { cameraCopy(cam, home); cancel(); return orbit; },
 
     /** Remove the wheel listener, restore touch-action, unregister from the host. */
     dispose() {
       canvas.removeEventListener('wheel', onWheel);
       if (canvas.style) canvas.style.touchAction = touchAction;
       tracked.clear();
+      cancel();
       host.unregister(orbit);
       return orbit;
     },
@@ -5623,7 +2478,7 @@ function createOrbit(host, cam, opts) {
  *   host.cameraHelm(cam, opts) · host.poseHelm(opts)
  *   host.poseTrack(opts) · host.cameraTrack(cam, opts)
  *   host.hid(opts) · host.gamepad(opts)
- *   host.image(url) · host.video(opts) · host.raster(draw, w, h)
+ *   host.image(url) · host.video(opts) · host.raster(draw, w, h) · host.model(url)
  *   host.labels        // the DOM label layer, created on first access
  *   host.orbit(cam, opts)
  *   host.tick(dt)      // external-loop mode
@@ -5718,6 +2573,8 @@ function createHost(canvas, opts) {
     video(opts) { return host.register(createVideo(opts)); },
     /** Draw through a 2D context into a texture source — see host/media. */
     raster(draw, w, h, opts) { return raster(draw, w, h, opts); },
+    /** Fetch an OBJ model into the arrays shape — see host/media. */
+    model(url, opts) { return loadModel(url, opts); },
     /**
      * The label layer — see host/labels. Created on first access, so a
      * canvas that never labels never gets a layer nor a repositioned parent.
@@ -5773,5 +2630,5 @@ function createHost(canvas, opts) {
   return host;
 }
 
-export { GAMEPAD_MAP, HID_FILTERS, Handle, PointerRouter, TrackHandles, VIEW, cameraHelm, cameraTrack, createGamepad, createHid, createHost, createLabels, createLoop, createOrbit, createPlayers, createPointer, createVideo, createView, decodeSpaceNavigator, helmBasis, isConstraint, loadImage, measureCanvas, observeCanvas, poseHelm, poseTrack, raster, validConstraint };
+export { GAMEPAD_MAP, HID_FILTERS, Handle, PointerRouter, TrackHandles, VIEW, cameraHelm, cameraTrack, createGamepad, createHid, createHost, createLabels, createLoop, createOrbit, createPlayers, createPointer, createVideo, createView, decodeSpaceNavigator, helmBasis, isConstraint, loadImage, loadModel, measureCanvas, observeCanvas, poseHelm, poseTrack, raster, validConstraint };
 //# sourceMappingURL=index.js.map