@nakednous/host 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,3104 +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 = (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(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(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(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(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(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;
-  }
-}
-const _d = [0, 0, 0];              // view-direction scratch
-
-/** 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;
-}
-
-// =========================================================================
-// 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;
-}
+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, cameraOrbit, cameraPan, cameraDolly } from '@nakednous/tree';
 
 /**
  * @file The view bag — the matrices every pick, solve, label and orbit reads.
@@ -4690,6 +1590,819 @@ class TrackHandles {
   }
 }
 
+/**
+ * @file Device streams — WebHID and Gamepad rate sources that feed a helm.
+ * @module host/stream
+ * @license AGPL-3.0-only
+ *
+ * The measure-by-subscription transports. Each yields lin[3] / ang[3] in raw
+ * device units and, once bind(helm) ran, calls helm.feed(lin, ang) every
+ * tick of the host's players — the helm's profile does all scaling, so a
+ * stream carries no configuration beyond identification and decoding.
+ *
+ *   hid     — WebHID. connect() must run from a user gesture; reports land
+ *             out of band into the stream's buffers and the frame reads the
+ *             latest (last-write-wins). Permissions-Policy gates
+ *             requestDevice to top-level documents: a stream in an iframe
+ *             without allow="hid" reports available === false and never
+ *             prompts.
+ *   gamepad — the Gamepad API, polled once per tick from
+ *             navigator.getGamepads(); an absent axis reads exactly 0.
+ *
+ * Both expose available and connected for a UI to reflect, and bind(helm),
+ * unbind(), dispose().
+ */
+
+
+const _nav = () => (typeof navigator !== 'undefined' ? navigator : null);
+
+/** The 3Dconnexion vendor ids: the SpaceNavigator and its successors. */
+const HID_FILTERS = [{ vendorId: 0x046d }, { vendorId: 0x256f }];
+
+/**
+ * The SpaceNavigator decode: report 1 carries translation, report 2
+ * rotation, each three int16 little-endian lanes; a firmware that packs all
+ * six lanes into one report fills both halves from it.
+ * @param {DataView} report   The report's data (the id byte excluded).
+ * @param {number} reportId
+ * @param {number[]} lin  Translation lanes, written.
+ * @param {number[]} ang  Rotation lanes, written.
+ */
+function decodeSpaceNavigator(report, reportId, lin, ang) {
+  if (report.byteLength >= 12) {
+    for (let i = 0; i < 3; i++) { lin[i] = report.getInt16(2 * i, true); ang[i] = report.getInt16(6 + 2 * i, true); }
+    return;
+  }
+  if (report.byteLength < 6) return;
+  const t = reportId === 1 ? lin : reportId === 2 ? ang : null;
+  if (!t) return;
+  for (let i = 0; i < 3; i++) t[i] = report.getInt16(2 * i, true);
+}
+
+/** Whether WebHID's requestDevice is allowed in this document. */
+function _hidAllowed() {
+  if (typeof document !== 'undefined' && document.featurePolicy && typeof document.featurePolicy.allowsFeature === 'function') {
+    return document.featurePolicy.allowsFeature('hid');
+  }
+  if (typeof window !== 'undefined' && 'top' in window) return window.top === window.self;
+  return true;
+}
+
+function _stream(host, lin, ang) {
+  let helm = null;
+  const s = {
+    /** The latest translation lanes, raw device units. */
+    lin,
+    /** The latest rotation lanes, raw device units. */
+    ang,
+    /** The bound helm, or null. */
+    get helm() { return helm; },
+    /**
+     * Feed a helm every tick. Chainable.
+     * @param {object} target  A PoseHelm (anything with feed(lin, ang)).
+     * @returns {object} this
+     */
+    bind(target) {
+      if (!target || typeof target.feed !== 'function') {
+        console.error('[host] stream: bind() target must have feed(lin, ang). Leaving unbound.');
+        return s;
+      }
+      helm = target;
+      return s;
+    },
+    /** Stop feeding; the helm sees its last rate until it is fed again. */
+    unbind() { helm = null; return s; },
+  };
+  const feed = () => { if (helm) helm.feed(lin, ang); };
+  return { s, feed };
+}
+
+/**
+ * A WebHID rate stream.
+ *
+ * @param {object} host
+ * @param {{ filters?:object[], decode?:function, bind?:object, resume?:boolean,
+ *           hid?:object }} [opts]
+ *        filters: the requestDevice filters (default HID_FILTERS). decode:
+ *        decode(report, reportId, lin, ang) (default decodeSpaceNavigator).
+ *        bind: a helm to bind at once. resume (default true): attach a device
+ *        this origin was already granted, without a prompt. hid: the WebHID
+ *        interface (default navigator.hid) — the seam a test fills.
+ * @returns {object} The stream: { available, connected, device, lin, ang,
+ *          connect(), bind(helm), unbind(), dispose() }.
+ */
+function createHid(host, opts) {
+  const o = opts || {};
+  const hid = o.hid || (_nav() && _nav().hid) || null;
+  const filters = o.filters || HID_FILTERS;
+  const decode = typeof o.decode === 'function' ? o.decode : decodeSpaceNavigator;
+  const lin = [0, 0, 0], ang = [0, 0, 0];
+  const { s, feed } = _stream(host, lin, ang);
+  let device = null;
+
+  const onReport = (e) => decode(e.data, e.reportId, lin, ang);
+  const onDisconnect = (e) => { if (device && e.device === device) detach(); };
+  const matches = (d) => filters.length === 0 || filters.some((f) =>
+    (f.vendorId == null || f.vendorId === d.vendorId) && (f.productId == null || f.productId === d.productId));
+
+  function detach() {
+    if (!device) return;
+    device.removeEventListener('inputreport', onReport);
+    if (device.opened && typeof device.close === 'function') device.close().catch(() => {});
+    device = null;
+    s.connected = false;
+    lin[0] = lin[1] = lin[2] = ang[0] = ang[1] = ang[2] = 0;
+  }
+
+  async function attach(d) {
+    detach();
+    try { if (!d.opened) await d.open(); }
+    catch (e) { console.error('[host] hid: open() failed: ' + e.message + '.'); return false; }
+    device = d;
+    d.addEventListener('inputreport', onReport);
+    s.connected = true;
+    return true;
+  }
+
+  Object.assign(s, {
+    /** Whether WebHID exists and requestDevice is allowed here. */
+    available: !!(hid && typeof hid.requestDevice === 'function') && _hidAllowed(),
+    /** Whether a device is open and reporting. */
+    connected: false,
+
+    /**
+     * Prompt for a device (a user gesture is required) and attach the choice.
+     * @returns {Promise<boolean>} attached
+     */
+    async connect() {
+      if (!s.available) { console.error('[host] hid: WebHID is unavailable here (a top-level Chromium document over https or localhost).'); return false; }
+      let devices;
+      try { devices = await hid.requestDevice({ filters }); }
+      catch (e) { console.error('[host] hid: requestDevice rejected: ' + e.message + '.'); return false; }
+      if (!devices || !devices.length) return false;
+      return attach(devices[0]);
+    },
+
+    /**
+     * Attach a device this origin was already granted, without a prompt.
+     * @returns {Promise<boolean>} attached
+     */
+    async resume() {
+      if (!hid || typeof hid.getDevices !== 'function') return false;
+      let devices;
+      try { devices = await hid.getDevices(); } catch (_) { return false; }
+      const d = (devices || []).find(matches);
+      return d ? attach(d) : false;
+    },
+
+    /** Close the device, remove every listener, unregister from the host. */
+    dispose() {
+      detach();
+      if (hid && typeof hid.removeEventListener === 'function') hid.removeEventListener('disconnect', onDisconnect);
+      host.players.remove(player);
+      host.unregister(s);
+      return s;
+    },
+  });
+
+  /** The open HIDDevice, or null. */
+  Object.defineProperty(s, 'device', { get: () => device, enumerable: true });
+
+  const player = { tick() { feed(); return true; } };
+  host.players.add(player);
+  if (hid && typeof hid.addEventListener === 'function') hid.addEventListener('disconnect', onDisconnect);
+  if (o.bind) s.bind(o.bind);
+  if (s.available && o.resume !== false) s.resume();
+  return host.register(s);
+}
+
+/**
+ * The default gamepad map, the standard layout: left stick → lin[0] / lin[1],
+ * right stick → ang[1] / ang[0], the triggers → lin[2] (right minus left).
+ */
+const GAMEPAD_MAP = { lin: [0, 1, { buttons: [6, 7] }], ang: [3, 2, null] };
+
+function _lane(gp, spec) {
+  if (spec == null) return 0;
+  if (typeof spec === 'number') { const v = gp.axes[spec]; return typeof v === 'number' ? v : 0; }
+  if (spec.buttons) {
+    const n = gp.buttons[spec.buttons[0]], p = gp.buttons[spec.buttons[1]];
+    return (p ? p.value : 0) - (n ? n.value : 0);
+  }
+  if (spec.button) { const b = gp.buttons[spec.button]; return b ? b.value : 0; }
+  return 0;
+}
+
+/**
+ * A Gamepad rate stream, polled once per tick.
+ *
+ * @param {object} host
+ * @param {{ index?:number, map?:object, bind?:object, gamepads?:function }} [opts]
+ *        index: which gamepad (default: the first connected). map: { lin,
+ *        ang }, each three lane specs — an axis index, { buttons: [neg,
+ *        pos] }, { button } or null (default GAMEPAD_MAP). bind: a helm to
+ *        bind at once. gamepads: the poll (default navigator.getGamepads) —
+ *        the seam a test fills.
+ * @returns {object} The stream: { available, connected, index, lin, ang,
+ *          bind(helm), unbind(), dispose() }.
+ */
+function createGamepad(host, opts) {
+  const o = opts || {};
+  const nav = _nav();
+  const poll = o.gamepads || (nav && typeof nav.getGamepads === 'function' ? () => nav.getGamepads() : null);
+  const map = o.map || GAMEPAD_MAP;
+  const lin = [0, 0, 0], ang = [0, 0, 0];
+  const { s, feed } = _stream(host, lin, ang);
+
+  Object.assign(s, {
+    /** Whether the Gamepad API exists. */
+    available: !!poll,
+    /** Whether the last poll found a gamepad. */
+    connected: false,
+    /** The gamepad index polled, or null for the first connected. */
+    index: o.index ?? null,
+    /** Stop polling, unregister from the host. */
+    dispose() { host.players.remove(player); host.unregister(s); return s; },
+  });
+
+  const player = {
+    tick() {
+      let gp = null;
+      if (poll) {
+        const list = poll() || [];
+        if (s.index != null) gp = list[s.index] || null;
+        else for (let i = 0; i < list.length; i++) if (list[i]) { gp = list[i]; break; }
+      }
+      s.connected = !!gp;
+      for (let i = 0; i < 3; i++) {
+        lin[i] = gp ? _lane(gp, map.lin[i]) : 0;
+        ang[i] = gp ? _lane(gp, map.ang[i]) : 0;
+      }
+      feed();
+      return true;
+    },
+  };
+  host.players.add(player);
+  if (o.bind) s.bind(o.bind);
+  return host.register(s);
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var webglObjLoader_min$1 = {exports: {}};
+
+var webglObjLoader_min = webglObjLoader_min$1.exports;
+
+var hasRequiredWebglObjLoader_min;
+
+function requireWebglObjLoader_min () {
+	if (hasRequiredWebglObjLoader_min) return webglObjLoader_min$1.exports;
+	hasRequiredWebglObjLoader_min = 1;
+	(function (module, exports) {
+		!function(e,t){module.exports=t();}("undefined"!=typeof self?self:webglObjLoader_min,(function(){return function(e){var t={};function n(a){if(t[a])return t[a].exports;var s=t[a]={i:a,l:false,exports:{}};return e[a].call(s.exports,s,s.exports,n),s.l=true,s.exports}return n.m=e,n.c=t,n.d=function(e,t,a){n.o(e,t)||Object.defineProperty(e,t,{enumerable:true,get:a});},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:true});},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var a=Object.create(null);if(n.r(a),Object.defineProperty(a,"default",{enumerable:true,value:e}),2&t&&"string"!=typeof e)for(var s in e)n.d(a,s,function(t){return e[t]}.bind(null,s));return a},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="/",n(n.s=0)}({"./src/index.ts":
+		/*!**********************!*\
+		  !*** ./src/index.ts ***!
+		  \**********************/
+		/*! exports provided: OBJ, Attribute, DuplicateAttributeException, Layout, Material, MaterialLibrary, Mesh, TYPES, downloadModels, downloadMeshes, initMeshBuffers, deleteMeshBuffers, version */function(module,__webpack_exports__,__webpack_require__){eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "OBJ", function() { return OBJ; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "version", function() { return version; });\n/* harmony import */ var _mesh__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./mesh */ "./src/mesh.ts");\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Mesh", function() { return _mesh__WEBPACK_IMPORTED_MODULE_0__["default"]; });\n\n/* harmony import */ var _material__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./material */ "./src/material.ts");\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Material", function() { return _material__WEBPACK_IMPORTED_MODULE_1__["Material"]; });\n\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "MaterialLibrary", function() { return _material__WEBPACK_IMPORTED_MODULE_1__["MaterialLibrary"]; });\n\n/* harmony import */ var _layout__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./layout */ "./src/layout.ts");\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Attribute", function() { return _layout__WEBPACK_IMPORTED_MODULE_2__["Attribute"]; });\n\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "DuplicateAttributeException", function() { return _layout__WEBPACK_IMPORTED_MODULE_2__["DuplicateAttributeException"]; });\n\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Layout", function() { return _layout__WEBPACK_IMPORTED_MODULE_2__["Layout"]; });\n\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TYPES", function() { return _layout__WEBPACK_IMPORTED_MODULE_2__["TYPES"]; });\n\n/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./utils */ "./src/utils.ts");\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "downloadModels", function() { return _utils__WEBPACK_IMPORTED_MODULE_3__["downloadModels"]; });\n\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "downloadMeshes", function() { return _utils__WEBPACK_IMPORTED_MODULE_3__["downloadMeshes"]; });\n\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "initMeshBuffers", function() { return _utils__WEBPACK_IMPORTED_MODULE_3__["initMeshBuffers"]; });\n\n/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "deleteMeshBuffers", function() { return _utils__WEBPACK_IMPORTED_MODULE_3__["deleteMeshBuffers"]; });\n\n\n\n\n\nconst version = "2.0.3";\nconst OBJ = {\n    Attribute: _layout__WEBPACK_IMPORTED_MODULE_2__["Attribute"],\n    DuplicateAttributeException: _layout__WEBPACK_IMPORTED_MODULE_2__["DuplicateAttributeException"],\n    Layout: _layout__WEBPACK_IMPORTED_MODULE_2__["Layout"],\n    Material: _material__WEBPACK_IMPORTED_MODULE_1__["Material"],\n    MaterialLibrary: _material__WEBPACK_IMPORTED_MODULE_1__["MaterialLibrary"],\n    Mesh: _mesh__WEBPACK_IMPORTED_MODULE_0__["default"],\n    TYPES: _layout__WEBPACK_IMPORTED_MODULE_2__["TYPES"],\n    downloadModels: _utils__WEBPACK_IMPORTED_MODULE_3__["downloadModels"],\n    downloadMeshes: _utils__WEBPACK_IMPORTED_MODULE_3__["downloadMeshes"],\n    initMeshBuffers: _utils__WEBPACK_IMPORTED_MODULE_3__["initMeshBuffers"],\n    deleteMeshBuffers: _utils__WEBPACK_IMPORTED_MODULE_3__["deleteMeshBuffers"],\n    version,\n};\n/**\n * @namespace\n */\n\n\n\n//# sourceURL=webpack:///./src/index.ts?');},"./src/layout.ts":
+		/*!***********************!*\
+		  !*** ./src/layout.ts ***!
+		  \***********************/
+		/*! exports provided: TYPES, DuplicateAttributeException, Attribute, Layout */function(module,__webpack_exports__,__webpack_require__){eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TYPES", function() { return TYPES; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DuplicateAttributeException", function() { return DuplicateAttributeException; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Attribute", function() { return Attribute; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Layout", function() { return Layout; });\nvar TYPES;\n(function (TYPES) {\n    TYPES["BYTE"] = "BYTE";\n    TYPES["UNSIGNED_BYTE"] = "UNSIGNED_BYTE";\n    TYPES["SHORT"] = "SHORT";\n    TYPES["UNSIGNED_SHORT"] = "UNSIGNED_SHORT";\n    TYPES["FLOAT"] = "FLOAT";\n})(TYPES || (TYPES = {}));\n/**\n * An exception for when two or more of the same attributes are found in the\n * same layout.\n * @private\n */\nclass DuplicateAttributeException extends Error {\n    /**\n     * Create a DuplicateAttributeException\n     * @param {Attribute} attribute - The attribute that was found more than\n     *        once in the {@link Layout}\n     */\n    constructor(attribute) {\n        super(`found duplicate attribute: ${attribute.key}`);\n    }\n}\n/**\n * Represents how a vertex attribute should be packed into an buffer.\n * @private\n */\nclass Attribute {\n    /**\n     * Create an attribute. Do not call this directly, use the predefined\n     * constants.\n     * @param {string} key - The name of this attribute as if it were a key in\n     *        an Object. Use the camel case version of the upper snake case\n     *        const name.\n     * @param {number} size - The number of components per vertex attribute.\n     *        Must be 1, 2, 3, or 4.\n     * @param {string} type - The data type of each component for this\n     *        attribute. Possible values:<br/>\n     *        "BYTE": signed 8-bit integer, with values in [-128, 127]<br/>\n     *        "SHORT": signed 16-bit integer, with values in\n     *            [-32768, 32767]<br/>\n     *        "UNSIGNED_BYTE": unsigned 8-bit integer, with values in\n     *            [0, 255]<br/>\n     *        "UNSIGNED_SHORT": unsigned 16-bit integer, with values in\n     *            [0, 65535]<br/>\n     *        "FLOAT": 32-bit floating point number\n     * @param {boolean} normalized - Whether integer data values should be\n     *        normalized when being casted to a float.<br/>\n     *        If true, signed integers are normalized to [-1, 1].<br/>\n     *        If true, unsigned integers are normalized to [0, 1].<br/>\n     *        For type "FLOAT", this parameter has no effect.\n     */\n    constructor(key, size, type, normalized = false) {\n        this.key = key;\n        this.size = size;\n        this.type = type;\n        this.normalized = normalized;\n        switch (type) {\n            case "BYTE":\n            case "UNSIGNED_BYTE":\n                this.sizeOfType = 1;\n                break;\n            case "SHORT":\n            case "UNSIGNED_SHORT":\n                this.sizeOfType = 2;\n                break;\n            case "FLOAT":\n                this.sizeOfType = 4;\n                break;\n            default:\n                throw new Error(`Unknown gl type: ${type}`);\n        }\n        this.sizeInBytes = this.sizeOfType * size;\n    }\n}\n/**\n * A class to represent the memory layout for a vertex attribute array. Used by\n * {@link Mesh}\'s TBD(...) method to generate a packed array from mesh data.\n * <p>\n * Layout can sort of be thought of as a C-style struct declaration.\n * {@link Mesh}\'s TBD(...) method will use the {@link Layout} instance to\n * pack an array in the given attribute order.\n * <p>\n * Layout also is very helpful when calling a WebGL context\'s\n * <code>vertexAttribPointer</code> method. If you\'ve created a buffer using\n * a Layout instance, then the same Layout instance can be used to determine\n * the size, type, normalized, stride, and offset parameters for\n * <code>vertexAttribPointer</code>.\n * <p>\n * For example:\n * <pre><code>\n *\n * const index = glctx.getAttribLocation(shaderProgram, "pos");\n * glctx.vertexAttribPointer(\n *   layout.position.size,\n *   glctx[layout.position.type],\n *   layout.position.normalized,\n *   layout.position.stride,\n *   layout.position.offset);\n * </code></pre>\n * @see {@link Mesh}\n */\nclass Layout {\n    /**\n     * Create a Layout object. This constructor will throw if any duplicate\n     * attributes are given.\n     * @param {Array} ...attributes - An ordered list of attributes that\n     *        describe the desired memory layout for each vertex attribute.\n     *        <p>\n     *\n     * @see {@link Mesh}\n     */\n    constructor(...attributes) {\n        this.attributes = attributes;\n        this.attributeMap = {};\n        let offset = 0;\n        let maxStrideMultiple = 0;\n        for (const attribute of attributes) {\n            if (this.attributeMap[attribute.key]) {\n                throw new DuplicateAttributeException(attribute);\n            }\n            // Add padding to satisfy WebGL\'s requirement that all\n            // vertexAttribPointer calls have an offset that is a multiple of\n            // the type size.\n            if (offset % attribute.sizeOfType !== 0) {\n                offset += attribute.sizeOfType - (offset % attribute.sizeOfType);\n                console.warn("Layout requires padding before " + attribute.key + " attribute");\n            }\n            this.attributeMap[attribute.key] = {\n                attribute: attribute,\n                size: attribute.size,\n                type: attribute.type,\n                normalized: attribute.normalized,\n                offset: offset,\n            };\n            offset += attribute.sizeInBytes;\n            maxStrideMultiple = Math.max(maxStrideMultiple, attribute.sizeOfType);\n        }\n        // Add padding to the end to satisfy WebGL\'s requirement that all\n        // vertexAttribPointer calls have a stride that is a multiple of the\n        // type size. Because we\'re putting differently sized attributes into\n        // the same buffer, it must be padded to a multiple of the largest\n        // type size.\n        if (offset % maxStrideMultiple !== 0) {\n            offset += maxStrideMultiple - (offset % maxStrideMultiple);\n            console.warn("Layout requires padding at the back");\n        }\n        this.stride = offset;\n        for (const attribute of attributes) {\n            this.attributeMap[attribute.key].stride = this.stride;\n        }\n    }\n}\n// Geometry attributes\n/**\n * Attribute layout to pack a vertex\'s x, y, & z as floats\n *\n * @see {@link Layout}\n */\nLayout.POSITION = new Attribute("position", 3, TYPES.FLOAT);\n/**\n * Attribute layout to pack a vertex\'s normal\'s x, y, & z as floats\n *\n * @see {@link Layout}\n */\nLayout.NORMAL = new Attribute("normal", 3, TYPES.FLOAT);\n/**\n * Attribute layout to pack a vertex\'s normal\'s x, y, & z as floats.\n * <p>\n * This value will be computed on-the-fly based on the texture coordinates.\n * If no texture coordinates are available, the generated value will default to\n * 0, 0, 0.\n *\n * @see {@link Layout}\n */\nLayout.TANGENT = new Attribute("tangent", 3, TYPES.FLOAT);\n/**\n * Attribute layout to pack a vertex\'s normal\'s bitangent x, y, & z as floats.\n * <p>\n * This value will be computed on-the-fly based on the texture coordinates.\n * If no texture coordinates are available, the generated value will default to\n * 0, 0, 0.\n * @see {@link Layout}\n */\nLayout.BITANGENT = new Attribute("bitangent", 3, TYPES.FLOAT);\n/**\n * Attribute layout to pack a vertex\'s texture coordinates\' u & v as floats\n *\n * @see {@link Layout}\n */\nLayout.UV = new Attribute("uv", 2, TYPES.FLOAT);\n// Material attributes\n/**\n * Attribute layout to pack an unsigned short to be interpreted as a the index\n * into a {@link Mesh}\'s materials list.\n * <p>\n * The intention of this value is to send all of the {@link Mesh}\'s materials\n * into multiple shader uniforms and then reference the current one by this\n * vertex attribute.\n * <p>\n * example glsl code:\n *\n * <pre><code>\n *  // this is bound using MATERIAL_INDEX\n *  attribute int materialIndex;\n *\n *  struct Material {\n *    vec3 diffuse;\n *    vec3 specular;\n *    vec3 specularExponent;\n *  };\n *\n *  uniform Material materials[MAX_MATERIALS];\n *\n *  // ...\n *\n *  vec3 diffuse = materials[materialIndex];\n *\n * </code></pre>\n * TODO: More description & test to make sure subscripting by attributes even\n * works for webgl\n *\n * @see {@link Layout}\n */\nLayout.MATERIAL_INDEX = new Attribute("materialIndex", 1, TYPES.SHORT);\nLayout.MATERIAL_ENABLED = new Attribute("materialEnabled", 1, TYPES.UNSIGNED_SHORT);\nLayout.AMBIENT = new Attribute("ambient", 3, TYPES.FLOAT);\nLayout.DIFFUSE = new Attribute("diffuse", 3, TYPES.FLOAT);\nLayout.SPECULAR = new Attribute("specular", 3, TYPES.FLOAT);\nLayout.SPECULAR_EXPONENT = new Attribute("specularExponent", 3, TYPES.FLOAT);\nLayout.EMISSIVE = new Attribute("emissive", 3, TYPES.FLOAT);\nLayout.TRANSMISSION_FILTER = new Attribute("transmissionFilter", 3, TYPES.FLOAT);\nLayout.DISSOLVE = new Attribute("dissolve", 1, TYPES.FLOAT);\nLayout.ILLUMINATION = new Attribute("illumination", 1, TYPES.UNSIGNED_SHORT);\nLayout.REFRACTION_INDEX = new Attribute("refractionIndex", 1, TYPES.FLOAT);\nLayout.SHARPNESS = new Attribute("sharpness", 1, TYPES.FLOAT);\nLayout.MAP_DIFFUSE = new Attribute("mapDiffuse", 1, TYPES.SHORT);\nLayout.MAP_AMBIENT = new Attribute("mapAmbient", 1, TYPES.SHORT);\nLayout.MAP_SPECULAR = new Attribute("mapSpecular", 1, TYPES.SHORT);\nLayout.MAP_SPECULAR_EXPONENT = new Attribute("mapSpecularExponent", 1, TYPES.SHORT);\nLayout.MAP_DISSOLVE = new Attribute("mapDissolve", 1, TYPES.SHORT);\nLayout.ANTI_ALIASING = new Attribute("antiAliasing", 1, TYPES.UNSIGNED_SHORT);\nLayout.MAP_BUMP = new Attribute("mapBump", 1, TYPES.SHORT);\nLayout.MAP_DISPLACEMENT = new Attribute("mapDisplacement", 1, TYPES.SHORT);\nLayout.MAP_DECAL = new Attribute("mapDecal", 1, TYPES.SHORT);\nLayout.MAP_EMISSIVE = new Attribute("mapEmissive", 1, TYPES.SHORT);\n\n\n//# sourceURL=webpack:///./src/layout.ts?');},"./src/material.ts":
+		/*!*************************!*\
+		  !*** ./src/material.ts ***!
+		  \*************************/
+		/*! exports provided: Material, MaterialLibrary */function(module,__webpack_exports__,__webpack_require__){eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Material", function() { return Material; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MaterialLibrary", function() { return MaterialLibrary; });\n/**\n * The Material class.\n */\nclass Material {\n    constructor(name) {\n        this.name = name;\n        /**\n         * Constructor\n         * @param {String} name the unique name of the material\n         */\n        // The values for the following attibutes\n        // are an array of R, G, B normalized values.\n        // Ka - Ambient Reflectivity\n        this.ambient = [0, 0, 0];\n        // Kd - Defuse Reflectivity\n        this.diffuse = [0, 0, 0];\n        // Ks\n        this.specular = [0, 0, 0];\n        // Ke\n        this.emissive = [0, 0, 0];\n        // Tf\n        this.transmissionFilter = [0, 0, 0];\n        // d\n        this.dissolve = 0;\n        // valid range is between 0 and 1000\n        this.specularExponent = 0;\n        // either d or Tr; valid values are normalized\n        this.transparency = 0;\n        // illum - the enum of the illumination model to use\n        this.illumination = 0;\n        // Ni - Set to "normal" (air).\n        this.refractionIndex = 1;\n        // sharpness\n        this.sharpness = 0;\n        // map_Kd\n        this.mapDiffuse = emptyTextureOptions();\n        // map_Ka\n        this.mapAmbient = emptyTextureOptions();\n        // map_Ks\n        this.mapSpecular = emptyTextureOptions();\n        // map_Ns\n        this.mapSpecularExponent = emptyTextureOptions();\n        // map_d\n        this.mapDissolve = emptyTextureOptions();\n        // map_aat\n        this.antiAliasing = false;\n        // map_bump or bump\n        this.mapBump = emptyTextureOptions();\n        // disp\n        this.mapDisplacement = emptyTextureOptions();\n        // decal\n        this.mapDecal = emptyTextureOptions();\n        // map_Ke\n        this.mapEmissive = emptyTextureOptions();\n        // refl - when the reflection type is a cube, there will be multiple refl\n        //        statements for each side of the cube. If it\'s a spherical\n        //        reflection, there should only ever be one.\n        this.mapReflections = [];\n    }\n}\nconst SENTINEL_MATERIAL = new Material("sentinel");\n/**\n * https://en.wikipedia.org/wiki/Wavefront_.obj_file\n * http://paulbourke.net/dataformats/mtl/\n */\nclass MaterialLibrary {\n    constructor(data) {\n        this.data = data;\n        /**\n         * Constructs the Material Parser\n         * @param mtlData the MTL file contents\n         */\n        this.currentMaterial = SENTINEL_MATERIAL;\n        this.materials = {};\n        this.parse();\n    }\n    /* eslint-disable camelcase */\n    /* the function names here disobey camelCase conventions\n     to make parsing/routing easier. see the parse function\n     documentation for more information. */\n    /**\n     * Creates a new Material object and adds to the registry.\n     * @param tokens the tokens associated with the directive\n     */\n    parse_newmtl(tokens) {\n        const name = tokens[0];\n        // console.info(\'Parsing new Material:\', name);\n        this.currentMaterial = new Material(name);\n        this.materials[name] = this.currentMaterial;\n    }\n    /**\n     * See the documenation for parse_Ka below for a better understanding.\n     *\n     * Given a list of possible color tokens, returns an array of R, G, and B\n     * color values.\n     *\n     * @param tokens the tokens associated with the directive\n     * @return {*} a 3 element array containing the R, G, and B values\n     * of the color.\n     */\n    parseColor(tokens) {\n        if (tokens[0] == "spectral") {\n            throw new Error("The MTL parser does not support spectral curve files. You will " +\n                "need to convert the MTL colors to either RGB or CIEXYZ.");\n        }\n        if (tokens[0] == "xyz") {\n            throw new Error("The MTL parser does not currently support XYZ colors. Either convert the " +\n                "XYZ values to RGB or create an issue to add support for XYZ");\n        }\n        // from my understanding of the spec, RGB values at this point\n        // will either be 3 floats or exactly 1 float, so that\'s the check\n        // that i\'m going to perform here\n        if (tokens.length == 3) {\n            const [x, y, z] = tokens;\n            return [parseFloat(x), parseFloat(y), parseFloat(z)];\n        }\n        // Since tokens at this point has a length of 3, we\'re going to assume\n        // it\'s exactly 1, skipping the check for 2.\n        const value = parseFloat(tokens[0]);\n        // in this case, all values are equivalent\n        return [value, value, value];\n    }\n    /**\n     * Parse the ambient reflectivity\n     *\n     * A Ka directive can take one of three forms:\n     *   - Ka r g b\n     *   - Ka spectral file.rfl\n     *   - Ka xyz x y z\n     * These three forms are mutually exclusive in that only one\n     * declaration can exist per material. It is considered a syntax\n     * error otherwise.\n     *\n     * The "Ka" form specifies the ambient reflectivity using RGB values.\n     * The "g" and "b" values are optional. If only the "r" value is\n     * specified, then the "g" and "b" values are assigned the value of\n     * "r". Values are normally in the range 0.0 to 1.0. Values outside\n     * of this range increase or decrease the reflectivity accordingly.\n     *\n     * The "Ka spectral" form specifies the ambient reflectivity using a\n     * spectral curve. "file.rfl" is the name of the ".rfl" file containing\n     * the curve data. "factor" is an optional argument which is a multiplier\n     * for the values in the .rfl file and defaults to 1.0 if not specified.\n     *\n     * The "Ka xyz" form specifies the ambient reflectivity using CIEXYZ values.\n     * "x y z" are the values of the CIEXYZ color space. The "y" and "z" arguments\n     * are optional and take on the value of the "x" component if only "x" is\n     * specified. The "x y z" values are normally in the range of 0.0 to 1.0 and\n     * increase or decrease ambient reflectivity accordingly outside of that\n     * range.\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_Ka(tokens) {\n        this.currentMaterial.ambient = this.parseColor(tokens);\n    }\n    /**\n     * Diffuse Reflectivity\n     *\n     * Similar to the Ka directive. Simply replace "Ka" with "Kd" and the rules\n     * are the same\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_Kd(tokens) {\n        this.currentMaterial.diffuse = this.parseColor(tokens);\n    }\n    /**\n     * Spectral Reflectivity\n     *\n     * Similar to the Ka directive. Simply replace "Ks" with "Kd" and the rules\n     * are the same\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_Ks(tokens) {\n        this.currentMaterial.specular = this.parseColor(tokens);\n    }\n    /**\n     * Emissive\n     *\n     * The amount and color of light emitted by the object.\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_Ke(tokens) {\n        this.currentMaterial.emissive = this.parseColor(tokens);\n    }\n    /**\n     * Transmission Filter\n     *\n     * Any light passing through the object is filtered by the transmission\n     * filter, which only allows specific colors to pass through. For example, Tf\n     * 0 1 0 allows all of the green to pass through and filters out all of the\n     * red and blue.\n     *\n     * Similar to the Ka directive. Simply replace "Ks" with "Tf" and the rules\n     * are the same\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_Tf(tokens) {\n        this.currentMaterial.transmissionFilter = this.parseColor(tokens);\n    }\n    /**\n     * Specifies the dissolve for the current material.\n     *\n     * Statement: d [-halo] `factor`\n     *\n     * Example: "d 0.5"\n     *\n     * The factor is the amount this material dissolves into the background. A\n     * factor of 1.0 is fully opaque. This is the default when a new material is\n     * created. A factor of 0.0 is fully dissolved (completely transparent).\n     *\n     * Unlike a real transparent material, the dissolve does not depend upon\n     * material thickness nor does it have any spectral character. Dissolve works\n     * on all illumination models.\n     *\n     * The dissolve statement allows for an optional "-halo" flag which indicates\n     * that a dissolve is dependent on the surface orientation relative to the\n     * viewer. For example, a sphere with the following dissolve, "d -halo 0.0",\n     * will be fully dissolved at its center and will appear gradually more opaque\n     * toward its edge.\n     *\n     * "factor" is the minimum amount of dissolve applied to the material. The\n     * amount of dissolve will vary between 1.0 (fully opaque) and the specified\n     * "factor". The formula is:\n     *\n     *    dissolve = 1.0 - (N*v)(1.0-factor)\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_d(tokens) {\n        // this ignores the -halo option as I can\'t find any documentation on what\n        // it\'s supposed to be.\n        this.currentMaterial.dissolve = parseFloat(tokens.pop() || "0");\n    }\n    /**\n     * The "illum" statement specifies the illumination model to use in the\n     * material. Illumination models are mathematical equations that represent\n     * various material lighting and shading effects.\n     *\n     * The illumination number can be a number from 0 to 10. The following are\n     * the list of illumination enumerations and their summaries:\n     * 0. Color on and Ambient off\n     * 1. Color on and Ambient on\n     * 2. Highlight on\n     * 3. Reflection on and Ray trace on\n     * 4. Transparency: Glass on, Reflection: Ray trace on\n     * 5. Reflection: Fresnel on and Ray trace on\n     * 6. Transparency: Refraction on, Reflection: Fresnel off and Ray trace on\n     * 7. Transparency: Refraction on, Reflection: Fresnel on and Ray trace on\n     * 8. Reflection on and Ray trace off\n     * 9. Transparency: Glass on, Reflection: Ray trace off\n     * 10. Casts shadows onto invisible surfaces\n     *\n     * Example: "illum 2" to specify the "Highlight on" model\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_illum(tokens) {\n        this.currentMaterial.illumination = parseInt(tokens[0]);\n    }\n    /**\n     * Optical Density (AKA Index of Refraction)\n     *\n     * Statement: Ni `index`\n     *\n     * Example: Ni 1.0\n     *\n     * Specifies the optical density for the surface. `index` is the value\n     * for the optical density. The values can range from 0.001 to 10.  A value of\n     * 1.0 means that light does not bend as it passes through an object.\n     * Increasing the optical_density increases the amount of bending. Glass has\n     * an index of refraction of about 1.5. Values of less than 1.0 produce\n     * bizarre results and are not recommended\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_Ni(tokens) {\n        this.currentMaterial.refractionIndex = parseFloat(tokens[0]);\n    }\n    /**\n     * Specifies the specular exponent for the current material. This defines the\n     * focus of the specular highlight.\n     *\n     * Statement: Ns `exponent`\n     *\n     * Example: "Ns 250"\n     *\n     * `exponent` is the value for the specular exponent. A high exponent results\n     * in a tight, concentrated highlight. Ns Values normally range from 0 to\n     * 1000.\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_Ns(tokens) {\n        this.currentMaterial.specularExponent = parseInt(tokens[0]);\n    }\n    /**\n     * Specifies the sharpness of the reflections from the local reflection map.\n     *\n     * Statement: sharpness `value`\n     *\n     * Example: "sharpness 100"\n     *\n     * If a material does not have a local reflection map defined in its material\n     * defintions, sharpness will apply to the global reflection map defined in\n     * PreView.\n     *\n     * `value` can be a number from 0 to 1000. The default is 60. A high value\n     * results in a clear reflection of objects in the reflection map.\n     *\n     * Tip: sharpness values greater than 100 introduce aliasing effects in\n     * flat surfaces that are viewed at a sharp angle.\n     *\n     * @param tokens the tokens associated with the directive\n     */\n    parse_sharpness(tokens) {\n        this.currentMaterial.sharpness = parseInt(tokens[0]);\n    }\n    /**\n     * Parses the -cc flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -cc flag\n     * @param options the Object of all image options\n     */\n    parse_cc(values, options) {\n        options.colorCorrection = values[0] == "on";\n    }\n    /**\n     * Parses the -blendu flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -blendu flag\n     * @param options the Object of all image options\n     */\n    parse_blendu(values, options) {\n        options.horizontalBlending = values[0] == "on";\n    }\n    /**\n     * Parses the -blendv flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -blendv flag\n     * @param options the Object of all image options\n     */\n    parse_blendv(values, options) {\n        options.verticalBlending = values[0] == "on";\n    }\n    /**\n     * Parses the -boost flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -boost flag\n     * @param options the Object of all image options\n     */\n    parse_boost(values, options) {\n        options.boostMipMapSharpness = parseFloat(values[0]);\n    }\n    /**\n     * Parses the -mm flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -mm flag\n     * @param options the Object of all image options\n     */\n    parse_mm(values, options) {\n        options.modifyTextureMap.brightness = parseFloat(values[0]);\n        options.modifyTextureMap.contrast = parseFloat(values[1]);\n    }\n    /**\n     * Parses and sets the -o, -s, and -t  u, v, and w values\n     *\n     * @param values the values passed to the -o, -s, -t flag\n     * @param {Object} option the Object of either the -o, -s, -t option\n     * @param {Integer} defaultValue the Object of all image options\n     */\n    parse_ost(values, option, defaultValue) {\n        while (values.length < 3) {\n            values.push(defaultValue.toString());\n        }\n        option.u = parseFloat(values[0]);\n        option.v = parseFloat(values[1]);\n        option.w = parseFloat(values[2]);\n    }\n    /**\n     * Parses the -o flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -o flag\n     * @param options the Object of all image options\n     */\n    parse_o(values, options) {\n        this.parse_ost(values, options.offset, 0);\n    }\n    /**\n     * Parses the -s flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -s flag\n     * @param options the Object of all image options\n     */\n    parse_s(values, options) {\n        this.parse_ost(values, options.scale, 1);\n    }\n    /**\n     * Parses the -t flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -t flag\n     * @param options the Object of all image options\n     */\n    parse_t(values, options) {\n        this.parse_ost(values, options.turbulence, 0);\n    }\n    /**\n     * Parses the -texres flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -texres flag\n     * @param options the Object of all image options\n     */\n    parse_texres(values, options) {\n        options.textureResolution = parseFloat(values[0]);\n    }\n    /**\n     * Parses the -clamp flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -clamp flag\n     * @param options the Object of all image options\n     */\n    parse_clamp(values, options) {\n        options.clamp = values[0] == "on";\n    }\n    /**\n     * Parses the -bm flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -bm flag\n     * @param options the Object of all image options\n     */\n    parse_bm(values, options) {\n        options.bumpMultiplier = parseFloat(values[0]);\n    }\n    /**\n     * Parses the -imfchan flag and updates the options object with the values.\n     *\n     * @param values the values passed to the -imfchan flag\n     * @param options the Object of all image options\n     */\n    parse_imfchan(values, options) {\n        options.imfChan = values[0];\n    }\n    /**\n     * This only exists for relection maps and denotes the type of reflection.\n     *\n     * @param values the values passed to the -type flag\n     * @param options the Object of all image options\n     */\n    parse_type(values, options) {\n        options.reflectionType = values[0];\n    }\n    /**\n     * Parses the texture\'s options and returns an options object with the info\n     *\n     * @param tokens all of the option tokens to pass to the texture\n     * @return {Object} a complete object of objects to apply to the texture\n     */\n    parseOptions(tokens) {\n        const options = emptyTextureOptions();\n        let option;\n        let values;\n        const optionsToValues = {};\n        tokens.reverse();\n        while (tokens.length) {\n            // token is guaranteed to exists here, hence the explicit "as"\n            const token = tokens.pop();\n            if (token.startsWith("-")) {\n                option = token.substr(1);\n                optionsToValues[option] = [];\n            }\n            else if (option) {\n                optionsToValues[option].push(token);\n            }\n        }\n        for (option in optionsToValues) {\n            if (!optionsToValues.hasOwnProperty(option)) {\n                continue;\n            }\n            values = optionsToValues[option];\n            const optionMethod = this[`parse_${option}`];\n            if (optionMethod) {\n                optionMethod.bind(this)(values, options);\n            }\n        }\n        return options;\n    }\n    /**\n     * Parses the given texture map line.\n     *\n     * @param tokens all of the tokens representing the texture\n     * @return a complete object of objects to apply to the texture\n     */\n    parseMap(tokens) {\n        // according to wikipedia:\n        // (https://en.wikipedia.org/wiki/Wavefront_.obj_file#Vendor_specific_alterations)\n        // there is at least one vendor that places the filename before the options\n        // rather than after (which is to spec). All options start with a \'-\'\n        // so if the first token doesn\'t start with a \'-\', we\'re going to assume\n        // it\'s the name of the map file.\n        let optionsString;\n        let filename = "";\n        if (!tokens[0].startsWith("-")) {\n            [filename, ...optionsString] = tokens;\n        }\n        else {\n            filename = tokens.pop();\n            optionsString = tokens;\n        }\n        const options = this.parseOptions(optionsString);\n        options.filename = filename.replace(/\\\\/g, "/");\n        return options;\n    }\n    /**\n     * Parses the ambient map.\n     *\n     * @param tokens list of tokens for the map_Ka direcive\n     */\n    parse_map_Ka(tokens) {\n        this.currentMaterial.mapAmbient = this.parseMap(tokens);\n    }\n    /**\n     * Parses the diffuse map.\n     *\n     * @param tokens list of tokens for the map_Kd direcive\n     */\n    parse_map_Kd(tokens) {\n        this.currentMaterial.mapDiffuse = this.parseMap(tokens);\n    }\n    /**\n     * Parses the specular map.\n     *\n     * @param tokens list of tokens for the map_Ks direcive\n     */\n    parse_map_Ks(tokens) {\n        this.currentMaterial.mapSpecular = this.parseMap(tokens);\n    }\n    /**\n     * Parses the emissive map.\n     *\n     * @param tokens list of tokens for the map_Ke direcive\n     */\n    parse_map_Ke(tokens) {\n        this.currentMaterial.mapEmissive = this.parseMap(tokens);\n    }\n    /**\n     * Parses the specular exponent map.\n     *\n     * @param tokens list of tokens for the map_Ns direcive\n     */\n    parse_map_Ns(tokens) {\n        this.currentMaterial.mapSpecularExponent = this.parseMap(tokens);\n    }\n    /**\n     * Parses the dissolve map.\n     *\n     * @param tokens list of tokens for the map_d direcive\n     */\n    parse_map_d(tokens) {\n        this.currentMaterial.mapDissolve = this.parseMap(tokens);\n    }\n    /**\n     * Parses the anti-aliasing option.\n     *\n     * @param tokens list of tokens for the map_aat direcive\n     */\n    parse_map_aat(tokens) {\n        this.currentMaterial.antiAliasing = tokens[0] == "on";\n    }\n    /**\n     * Parses the bump map.\n     *\n     * @param tokens list of tokens for the map_bump direcive\n     */\n    parse_map_bump(tokens) {\n        this.currentMaterial.mapBump = this.parseMap(tokens);\n    }\n    /**\n     * Parses the bump map.\n     *\n     * @param tokens list of tokens for the bump direcive\n     */\n    parse_bump(tokens) {\n        this.parse_map_bump(tokens);\n    }\n    /**\n     * Parses the disp map.\n     *\n     * @param tokens list of tokens for the disp direcive\n     */\n    parse_disp(tokens) {\n        this.currentMaterial.mapDisplacement = this.parseMap(tokens);\n    }\n    /**\n     * Parses the decal map.\n     *\n     * @param tokens list of tokens for the map_decal direcive\n     */\n    parse_decal(tokens) {\n        this.currentMaterial.mapDecal = this.parseMap(tokens);\n    }\n    /**\n     * Parses the refl map.\n     *\n     * @param tokens list of tokens for the refl direcive\n     */\n    parse_refl(tokens) {\n        this.currentMaterial.mapReflections.push(this.parseMap(tokens));\n    }\n    /**\n     * Parses the MTL file.\n     *\n     * Iterates line by line parsing each MTL directive.\n     *\n     * This function expects the first token in the line\n     * to be a valid MTL directive. That token is then used\n     * to try and run a method on this class. parse_[directive]\n     * E.g., the `newmtl` directive would try to call the method\n     * parse_newmtl. Each parsing function takes in the remaining\n     * list of tokens and updates the currentMaterial class with\n     * the attributes provided.\n     */\n    parse() {\n        const lines = this.data.split(/\\r?\\n/);\n        for (let line of lines) {\n            line = line.trim();\n            if (!line || line.startsWith("#")) {\n                continue;\n            }\n            const [directive, ...tokens] = line.split(/\\s/);\n            const parseMethod = this[`parse_${directive}`];\n            if (!parseMethod) {\n                console.warn(`Don\'t know how to parse the directive: "${directive}"`);\n                continue;\n            }\n            // console.log(`Parsing "${directive}" with tokens: ${tokens}`);\n            parseMethod.bind(this)(tokens);\n        }\n        // some cleanup. These don\'t need to be exposed as public data.\n        delete this.data;\n        this.currentMaterial = SENTINEL_MATERIAL;\n    }\n}\nfunction emptyTextureOptions() {\n    return {\n        colorCorrection: false,\n        horizontalBlending: true,\n        verticalBlending: true,\n        boostMipMapSharpness: 0,\n        modifyTextureMap: {\n            brightness: 0,\n            contrast: 1,\n        },\n        offset: { u: 0, v: 0, w: 0 },\n        scale: { u: 1, v: 1, w: 1 },\n        turbulence: { u: 0, v: 0, w: 0 },\n        clamp: false,\n        textureResolution: null,\n        bumpMultiplier: 1,\n        imfChan: null,\n        filename: "",\n    };\n}\n\n\n//# sourceURL=webpack:///./src/material.ts?');},"./src/mesh.ts":
+		/*!*********************!*\
+		  !*** ./src/mesh.ts ***!
+		  \*********************/
+		/*! exports provided: default */function(module,__webpack_exports__,__webpack_require__){eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Mesh; });\n/* harmony import */ var _layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./layout */ "./src/layout.ts");\n\n/**\n * The main Mesh class. The constructor will parse through the OBJ file data\n * and collect the vertex, vertex normal, texture, and face information. This\n * information can then be used later on when creating your VBOs. See\n * OBJ.initMeshBuffers for an example of how to use the newly created Mesh\n */\nclass Mesh {\n    /**\n     * Create a Mesh\n     * @param {String} objectData - a string representation of an OBJ file with\n     *     newlines preserved.\n     * @param {Object} options - a JS object containing valid options. See class\n     *     documentation for options.\n     * @param {bool} options.enableWTextureCoord - Texture coordinates can have\n     *     an optional "w" coordinate after the u and v coordinates. This extra\n     *     value can be used in order to perform fancy transformations on the\n     *     textures themselves. Default is to truncate to only the u an v\n     *     coordinates. Passing true will provide a default value of 0 in the\n     *     event that any or all texture coordinates don\'t provide a w value.\n     *     Always use the textureStride attribute in order to determine the\n     *     stride length of the texture coordinates when rendering the element\n     *     array.\n     * @param {bool} options.calcTangentsAndBitangents - Calculate the tangents\n     *     and bitangents when loading of the OBJ is completed. This adds two new\n     *     attributes to the Mesh instance: `tangents` and `bitangents`.\n     */\n    constructor(objectData, options) {\n        this.name = "";\n        this.indicesPerMaterial = [];\n        this.materialsByIndex = {};\n        this.tangents = [];\n        this.bitangents = [];\n        options = options || {};\n        options.materials = options.materials || {};\n        options.enableWTextureCoord = !!options.enableWTextureCoord;\n        // the list of unique vertex, normal, texture, attributes\n        this.vertexNormals = [];\n        this.textures = [];\n        // the indicies to draw the faces\n        this.indices = [];\n        this.textureStride = options.enableWTextureCoord ? 3 : 2;\n        /*\n        The OBJ file format does a sort of compression when saving a model in a\n        program like Blender. There are at least 3 sections (4 including textures)\n        within the file. Each line in a section begins with the same string:\n          * \'v\': indicates vertex section\n          * \'vn\': indicates vertex normal section\n          * \'f\': indicates the faces section\n          * \'vt\': indicates vertex texture section (if textures were used on the model)\n        Each of the above sections (except for the faces section) is a list/set of\n        unique vertices.\n\n        Each line of the faces section contains a list of\n        (vertex, [texture], normal) groups.\n\n        **Note:** The following documentation will use a capital "V" Vertex to\n        denote the above (vertex, [texture], normal) groups whereas a lowercase\n        "v" vertex is used to denote an X, Y, Z coordinate.\n\n        Some examples:\n            // the texture index is optional, both formats are possible for models\n            // without a texture applied\n            f 1/25 18/46 12/31\n            f 1//25 18//46 12//31\n\n            // A 3 vertex face with texture indices\n            f 16/92/11 14/101/22 1/69/1\n\n            // A 4 vertex face\n            f 16/92/11 40/109/40 38/114/38 14/101/22\n\n        The first two lines are examples of a 3 vertex face without a texture applied.\n        The second is an example of a 3 vertex face with a texture applied.\n        The third is an example of a 4 vertex face. Note: a face can contain N\n        number of vertices.\n\n        Each number that appears in one of the groups is a 1-based index\n        corresponding to an item from the other sections (meaning that indexing\n        starts at one and *not* zero).\n\n        For example:\n            `f 16/92/11` is saying to\n              - take the 16th element from the [v] vertex array\n              - take the 92nd element from the [vt] texture array\n              - take the 11th element from the [vn] normal array\n            and together they make a unique vertex.\n        Using all 3+ unique Vertices from the face line will produce a polygon.\n\n        Now, you could just go through the OBJ file and create a new vertex for\n        each face line and WebGL will draw what appears to be the same model.\n        However, vertices will be overlapped and duplicated all over the place.\n\n        Consider a cube in 3D space centered about the origin and each side is\n        2 units long. The front face (with the positive Z-axis pointing towards\n        you) would have a Top Right vertex (looking orthogonal to its normal)\n        mapped at (1,1,1) The right face would have a Top Left vertex (looking\n        orthogonal to its normal) at (1,1,1) and the top face would have a Bottom\n        Right vertex (looking orthogonal to its normal) at (1,1,1). Each face\n        has a vertex at the same coordinates, however, three distinct vertices\n        will be drawn at the same spot.\n\n        To solve the issue of duplicate Vertices (the `(vertex, [texture], normal)`\n        groups), while iterating through the face lines, when a group is encountered\n        the whole group string (\'16/92/11\') is checked to see if it exists in the\n        packed.hashindices object, and if it doesn\'t, the indices it specifies\n        are used to look up each attribute in the corresponding attribute arrays\n        already created. The values are then copied to the corresponding unpacked\n        array (flattened to play nice with WebGL\'s ELEMENT_ARRAY_BUFFER indexing),\n        the group string is added to the hashindices set and the current unpacked\n        index is used as this hashindices value so that the group of elements can\n        be reused. The unpacked index is incremented. If the group string already\n        exists in the hashindices object, its corresponding value is the index of\n        that group and is appended to the unpacked indices array.\n       */\n        const verts = [];\n        const vertNormals = [];\n        const textures = [];\n        const materialNamesByIndex = [];\n        const materialIndicesByName = {};\n        // keep track of what material we\'ve seen last\n        let currentMaterialIndex = -1;\n        let currentObjectByMaterialIndex = 0;\n        // unpacking stuff\n        const unpacked = {\n            verts: [],\n            norms: [],\n            textures: [],\n            hashindices: {},\n            indices: [[]],\n            materialIndices: [],\n            index: 0,\n        };\n        const VERTEX_RE = /^v\\s/;\n        const NORMAL_RE = /^vn\\s/;\n        const TEXTURE_RE = /^vt\\s/;\n        const FACE_RE = /^f\\s/;\n        const WHITESPACE_RE = /\\s+/;\n        const USE_MATERIAL_RE = /^usemtl/;\n        // array of lines separated by the newline\n        const lines = objectData.split("\\n");\n        for (let line of lines) {\n            line = line.trim();\n            if (!line || line.startsWith("#")) {\n                continue;\n            }\n            const elements = line.split(WHITESPACE_RE);\n            elements.shift();\n            if (VERTEX_RE.test(line)) {\n                // if this is a vertex\n                verts.push(...elements);\n            }\n            else if (NORMAL_RE.test(line)) {\n                // if this is a vertex normal\n                vertNormals.push(...elements);\n            }\n            else if (TEXTURE_RE.test(line)) {\n                let coords = elements;\n                // by default, the loader will only look at the U and V\n                // coordinates of the vt declaration. So, this truncates the\n                // elements to only those 2 values. If W texture coordinate\n                // support is enabled, then the texture coordinate is\n                // expected to have three values in it.\n                if (elements.length > 2 && !options.enableWTextureCoord) {\n                    coords = elements.slice(0, 2);\n                }\n                else if (elements.length === 2 && options.enableWTextureCoord) {\n                    // If for some reason W texture coordinate support is enabled\n                    // and only the U and V coordinates are given, then we supply\n                    // the default value of 0 so that the stride length is correct\n                    // when the textures are unpacked below.\n                    coords.push("0");\n                }\n                textures.push(...coords);\n            }\n            else if (USE_MATERIAL_RE.test(line)) {\n                const materialName = elements[0];\n                // check to see if we\'ve ever seen it before\n                if (!(materialName in materialIndicesByName)) {\n                    // new material we\'ve never seen\n                    materialNamesByIndex.push(materialName);\n                    materialIndicesByName[materialName] = materialNamesByIndex.length - 1;\n                    // push new array into indices\n                    // already contains an array at index zero, don\'t add\n                    if (materialIndicesByName[materialName] > 0) {\n                        unpacked.indices.push([]);\n                    }\n                }\n                // keep track of the current material index\n                currentMaterialIndex = materialIndicesByName[materialName];\n                // update current index array\n                currentObjectByMaterialIndex = currentMaterialIndex;\n            }\n            else if (FACE_RE.test(line)) {\n                // if this is a face\n                /*\n                split this face into an array of Vertex groups\n                for example:\n                   f 16/92/11 14/101/22 1/69/1\n                becomes:\n                  [\'16/92/11\', \'14/101/22\', \'1/69/1\'];\n                */\n                const triangles = triangulate(elements);\n                for (const triangle of triangles) {\n                    for (let j = 0, eleLen = triangle.length; j < eleLen; j++) {\n                        const hash = triangle[j] + "," + currentMaterialIndex;\n                        if (hash in unpacked.hashindices) {\n                            unpacked.indices[currentObjectByMaterialIndex].push(unpacked.hashindices[hash]);\n                        }\n                        else {\n                            /*\n                        Each element of the face line array is a Vertex which has its\n                        attributes delimited by a forward slash. This will separate\n                        each attribute into another array:\n                            \'19/92/11\'\n                        becomes:\n                            Vertex = [\'19\', \'92\', \'11\'];\n                        where\n                            Vertex[0] is the vertex index\n                            Vertex[1] is the texture index\n                            Vertex[2] is the normal index\n                         Think of faces having Vertices which are comprised of the\n                         attributes location (v), texture (vt), and normal (vn).\n                         */\n                            const vertex = triangle[j].split("/");\n                            // it\'s possible for faces to only specify the vertex\n                            // and the normal. In this case, vertex will only have\n                            // a length of 2 and not 3 and the normal will be the\n                            // second item in the list with an index of 1.\n                            const normalIndex = vertex.length - 1;\n                            /*\n                         The verts, textures, and vertNormals arrays each contain a\n                         flattend array of coordinates.\n\n                         Because it gets confusing by referring to Vertex and then\n                         vertex (both are different in my descriptions) I will explain\n                         what\'s going on using the vertexNormals array:\n\n                         vertex[2] will contain the one-based index of the vertexNormals\n                         section (vn). One is subtracted from this index number to play\n                         nice with javascript\'s zero-based array indexing.\n\n                         Because vertexNormal is a flattened array of x, y, z values,\n                         simple pointer arithmetic is used to skip to the start of the\n                         vertexNormal, then the offset is added to get the correct\n                         component: +0 is x, +1 is y, +2 is z.\n\n                         This same process is repeated for verts and textures.\n                         */\n                            // Vertex position\n                            unpacked.verts.push(+verts[(+vertex[0] - 1) * 3 + 0]);\n                            unpacked.verts.push(+verts[(+vertex[0] - 1) * 3 + 1]);\n                            unpacked.verts.push(+verts[(+vertex[0] - 1) * 3 + 2]);\n                            // Vertex textures\n                            if (textures.length) {\n                                const stride = options.enableWTextureCoord ? 3 : 2;\n                                unpacked.textures.push(+textures[(+vertex[1] - 1) * stride + 0]);\n                                unpacked.textures.push(+textures[(+vertex[1] - 1) * stride + 1]);\n                                if (options.enableWTextureCoord) {\n                                    unpacked.textures.push(+textures[(+vertex[1] - 1) * stride + 2]);\n                                }\n                            }\n                            // Vertex normals\n                            unpacked.norms.push(+vertNormals[(+vertex[normalIndex] - 1) * 3 + 0]);\n                            unpacked.norms.push(+vertNormals[(+vertex[normalIndex] - 1) * 3 + 1]);\n                            unpacked.norms.push(+vertNormals[(+vertex[normalIndex] - 1) * 3 + 2]);\n                            // Vertex material indices\n                            unpacked.materialIndices.push(currentMaterialIndex);\n                            // add the newly created Vertex to the list of indices\n                            unpacked.hashindices[hash] = unpacked.index;\n                            unpacked.indices[currentObjectByMaterialIndex].push(unpacked.hashindices[hash]);\n                            // increment the counter\n                            unpacked.index += 1;\n                        }\n                    }\n                }\n            }\n        }\n        this.vertices = unpacked.verts;\n        this.vertexNormals = unpacked.norms;\n        this.textures = unpacked.textures;\n        this.vertexMaterialIndices = unpacked.materialIndices;\n        this.indices = unpacked.indices[currentObjectByMaterialIndex];\n        this.indicesPerMaterial = unpacked.indices;\n        this.materialNames = materialNamesByIndex;\n        this.materialIndices = materialIndicesByName;\n        this.materialsByIndex = {};\n        if (options.calcTangentsAndBitangents) {\n            this.calculateTangentsAndBitangents();\n        }\n    }\n    /**\n     * Calculates the tangents and bitangents of the mesh that forms an orthogonal basis together with the\n     * normal in the direction of the texture coordinates. These are useful for setting up the TBN matrix\n     * when distorting the normals through normal maps.\n     * Method derived from: http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-13-normal-mapping/\n     *\n     * This method requires the normals and texture coordinates to be parsed and set up correctly.\n     * Adds the tangents and bitangents as members of the class instance.\n     */\n    calculateTangentsAndBitangents() {\n        console.assert(!!(this.vertices &&\n            this.vertices.length &&\n            this.vertexNormals &&\n            this.vertexNormals.length &&\n            this.textures &&\n            this.textures.length), "Missing attributes for calculating tangents and bitangents");\n        const unpacked = {\n            tangents: [...new Array(this.vertices.length)].map(_ => 0),\n            bitangents: [...new Array(this.vertices.length)].map(_ => 0),\n        };\n        // Loop through all faces in the whole mesh\n        const indices = this.indices;\n        const vertices = this.vertices;\n        const normals = this.vertexNormals;\n        const uvs = this.textures;\n        for (let i = 0; i < indices.length; i += 3) {\n            const i0 = indices[i + 0];\n            const i1 = indices[i + 1];\n            const i2 = indices[i + 2];\n            const x_v0 = vertices[i0 * 3 + 0];\n            const y_v0 = vertices[i0 * 3 + 1];\n            const z_v0 = vertices[i0 * 3 + 2];\n            const x_uv0 = uvs[i0 * 2 + 0];\n            const y_uv0 = uvs[i0 * 2 + 1];\n            const x_v1 = vertices[i1 * 3 + 0];\n            const y_v1 = vertices[i1 * 3 + 1];\n            const z_v1 = vertices[i1 * 3 + 2];\n            const x_uv1 = uvs[i1 * 2 + 0];\n            const y_uv1 = uvs[i1 * 2 + 1];\n            const x_v2 = vertices[i2 * 3 + 0];\n            const y_v2 = vertices[i2 * 3 + 1];\n            const z_v2 = vertices[i2 * 3 + 2];\n            const x_uv2 = uvs[i2 * 2 + 0];\n            const y_uv2 = uvs[i2 * 2 + 1];\n            const x_deltaPos1 = x_v1 - x_v0;\n            const y_deltaPos1 = y_v1 - y_v0;\n            const z_deltaPos1 = z_v1 - z_v0;\n            const x_deltaPos2 = x_v2 - x_v0;\n            const y_deltaPos2 = y_v2 - y_v0;\n            const z_deltaPos2 = z_v2 - z_v0;\n            const x_uvDeltaPos1 = x_uv1 - x_uv0;\n            const y_uvDeltaPos1 = y_uv1 - y_uv0;\n            const x_uvDeltaPos2 = x_uv2 - x_uv0;\n            const y_uvDeltaPos2 = y_uv2 - y_uv0;\n            const rInv = x_uvDeltaPos1 * y_uvDeltaPos2 - y_uvDeltaPos1 * x_uvDeltaPos2;\n            const r = 1.0 / Math.abs(rInv < 0.0001 ? 1.0 : rInv);\n            // Tangent\n            const x_tangent = (x_deltaPos1 * y_uvDeltaPos2 - x_deltaPos2 * y_uvDeltaPos1) * r;\n            const y_tangent = (y_deltaPos1 * y_uvDeltaPos2 - y_deltaPos2 * y_uvDeltaPos1) * r;\n            const z_tangent = (z_deltaPos1 * y_uvDeltaPos2 - z_deltaPos2 * y_uvDeltaPos1) * r;\n            // Bitangent\n            const x_bitangent = (x_deltaPos2 * x_uvDeltaPos1 - x_deltaPos1 * x_uvDeltaPos2) * r;\n            const y_bitangent = (y_deltaPos2 * x_uvDeltaPos1 - y_deltaPos1 * x_uvDeltaPos2) * r;\n            const z_bitangent = (z_deltaPos2 * x_uvDeltaPos1 - z_deltaPos1 * x_uvDeltaPos2) * r;\n            // Gram-Schmidt orthogonalize\n            //t = glm::normalize(t - n * glm:: dot(n, t));\n            const x_n0 = normals[i0 * 3 + 0];\n            const y_n0 = normals[i0 * 3 + 1];\n            const z_n0 = normals[i0 * 3 + 2];\n            const x_n1 = normals[i1 * 3 + 0];\n            const y_n1 = normals[i1 * 3 + 1];\n            const z_n1 = normals[i1 * 3 + 2];\n            const x_n2 = normals[i2 * 3 + 0];\n            const y_n2 = normals[i2 * 3 + 1];\n            const z_n2 = normals[i2 * 3 + 2];\n            // Tangent\n            const n0_dot_t = x_tangent * x_n0 + y_tangent * y_n0 + z_tangent * z_n0;\n            const n1_dot_t = x_tangent * x_n1 + y_tangent * y_n1 + z_tangent * z_n1;\n            const n2_dot_t = x_tangent * x_n2 + y_tangent * y_n2 + z_tangent * z_n2;\n            const x_resTangent0 = x_tangent - x_n0 * n0_dot_t;\n            const y_resTangent0 = y_tangent - y_n0 * n0_dot_t;\n            const z_resTangent0 = z_tangent - z_n0 * n0_dot_t;\n            const x_resTangent1 = x_tangent - x_n1 * n1_dot_t;\n            const y_resTangent1 = y_tangent - y_n1 * n1_dot_t;\n            const z_resTangent1 = z_tangent - z_n1 * n1_dot_t;\n            const x_resTangent2 = x_tangent - x_n2 * n2_dot_t;\n            const y_resTangent2 = y_tangent - y_n2 * n2_dot_t;\n            const z_resTangent2 = z_tangent - z_n2 * n2_dot_t;\n            const magTangent0 = Math.sqrt(x_resTangent0 * x_resTangent0 + y_resTangent0 * y_resTangent0 + z_resTangent0 * z_resTangent0);\n            const magTangent1 = Math.sqrt(x_resTangent1 * x_resTangent1 + y_resTangent1 * y_resTangent1 + z_resTangent1 * z_resTangent1);\n            const magTangent2 = Math.sqrt(x_resTangent2 * x_resTangent2 + y_resTangent2 * y_resTangent2 + z_resTangent2 * z_resTangent2);\n            // Bitangent\n            const n0_dot_bt = x_bitangent * x_n0 + y_bitangent * y_n0 + z_bitangent * z_n0;\n            const n1_dot_bt = x_bitangent * x_n1 + y_bitangent * y_n1 + z_bitangent * z_n1;\n            const n2_dot_bt = x_bitangent * x_n2 + y_bitangent * y_n2 + z_bitangent * z_n2;\n            const x_resBitangent0 = x_bitangent - x_n0 * n0_dot_bt;\n            const y_resBitangent0 = y_bitangent - y_n0 * n0_dot_bt;\n            const z_resBitangent0 = z_bitangent - z_n0 * n0_dot_bt;\n            const x_resBitangent1 = x_bitangent - x_n1 * n1_dot_bt;\n            const y_resBitangent1 = y_bitangent - y_n1 * n1_dot_bt;\n            const z_resBitangent1 = z_bitangent - z_n1 * n1_dot_bt;\n            const x_resBitangent2 = x_bitangent - x_n2 * n2_dot_bt;\n            const y_resBitangent2 = y_bitangent - y_n2 * n2_dot_bt;\n            const z_resBitangent2 = z_bitangent - z_n2 * n2_dot_bt;\n            const magBitangent0 = Math.sqrt(x_resBitangent0 * x_resBitangent0 +\n                y_resBitangent0 * y_resBitangent0 +\n                z_resBitangent0 * z_resBitangent0);\n            const magBitangent1 = Math.sqrt(x_resBitangent1 * x_resBitangent1 +\n                y_resBitangent1 * y_resBitangent1 +\n                z_resBitangent1 * z_resBitangent1);\n            const magBitangent2 = Math.sqrt(x_resBitangent2 * x_resBitangent2 +\n                y_resBitangent2 * y_resBitangent2 +\n                z_resBitangent2 * z_resBitangent2);\n            unpacked.tangents[i0 * 3 + 0] += x_resTangent0 / magTangent0;\n            unpacked.tangents[i0 * 3 + 1] += y_resTangent0 / magTangent0;\n            unpacked.tangents[i0 * 3 + 2] += z_resTangent0 / magTangent0;\n            unpacked.tangents[i1 * 3 + 0] += x_resTangent1 / magTangent1;\n            unpacked.tangents[i1 * 3 + 1] += y_resTangent1 / magTangent1;\n            unpacked.tangents[i1 * 3 + 2] += z_resTangent1 / magTangent1;\n            unpacked.tangents[i2 * 3 + 0] += x_resTangent2 / magTangent2;\n            unpacked.tangents[i2 * 3 + 1] += y_resTangent2 / magTangent2;\n            unpacked.tangents[i2 * 3 + 2] += z_resTangent2 / magTangent2;\n            unpacked.bitangents[i0 * 3 + 0] += x_resBitangent0 / magBitangent0;\n            unpacked.bitangents[i0 * 3 + 1] += y_resBitangent0 / magBitangent0;\n            unpacked.bitangents[i0 * 3 + 2] += z_resBitangent0 / magBitangent0;\n            unpacked.bitangents[i1 * 3 + 0] += x_resBitangent1 / magBitangent1;\n            unpacked.bitangents[i1 * 3 + 1] += y_resBitangent1 / magBitangent1;\n            unpacked.bitangents[i1 * 3 + 2] += z_resBitangent1 / magBitangent1;\n            unpacked.bitangents[i2 * 3 + 0] += x_resBitangent2 / magBitangent2;\n            unpacked.bitangents[i2 * 3 + 1] += y_resBitangent2 / magBitangent2;\n            unpacked.bitangents[i2 * 3 + 2] += z_resBitangent2 / magBitangent2;\n            // TODO: check handedness\n        }\n        this.tangents = unpacked.tangents;\n        this.bitangents = unpacked.bitangents;\n    }\n    /**\n     * @param layout - A {@link Layout} object that describes the\n     * desired memory layout of the generated buffer\n     * @return The packed array in the ... TODO\n     */\n    makeBufferData(layout) {\n        const numItems = this.vertices.length / 3;\n        const buffer = new ArrayBuffer(layout.stride * numItems);\n        buffer.numItems = numItems;\n        const dataView = new DataView(buffer);\n        for (let i = 0, vertexOffset = 0; i < numItems; i++) {\n            vertexOffset = i * layout.stride;\n            // copy in the vertex data in the order and format given by the\n            // layout param\n            for (const attribute of layout.attributes) {\n                const offset = vertexOffset + layout.attributeMap[attribute.key].offset;\n                switch (attribute.key) {\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].POSITION.key:\n                        dataView.setFloat32(offset, this.vertices[i * 3], true);\n                        dataView.setFloat32(offset + 4, this.vertices[i * 3 + 1], true);\n                        dataView.setFloat32(offset + 8, this.vertices[i * 3 + 2], true);\n                        break;\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].UV.key:\n                        dataView.setFloat32(offset, this.textures[i * 2], true);\n                        dataView.setFloat32(offset + 4, this.textures[i * 2 + 1], true);\n                        break;\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].NORMAL.key:\n                        dataView.setFloat32(offset, this.vertexNormals[i * 3], true);\n                        dataView.setFloat32(offset + 4, this.vertexNormals[i * 3 + 1], true);\n                        dataView.setFloat32(offset + 8, this.vertexNormals[i * 3 + 2], true);\n                        break;\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].MATERIAL_INDEX.key:\n                        dataView.setInt16(offset, this.vertexMaterialIndices[i], true);\n                        break;\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].AMBIENT.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setFloat32(offset, material.ambient[0], true);\n                        dataView.setFloat32(offset + 4, material.ambient[1], true);\n                        dataView.setFloat32(offset + 8, material.ambient[2], true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].DIFFUSE.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setFloat32(offset, material.diffuse[0], true);\n                        dataView.setFloat32(offset + 4, material.diffuse[1], true);\n                        dataView.setFloat32(offset + 8, material.diffuse[2], true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].SPECULAR.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setFloat32(offset, material.specular[0], true);\n                        dataView.setFloat32(offset + 4, material.specular[1], true);\n                        dataView.setFloat32(offset + 8, material.specular[2], true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].SPECULAR_EXPONENT.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setFloat32(offset, material.specularExponent, true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].EMISSIVE.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setFloat32(offset, material.emissive[0], true);\n                        dataView.setFloat32(offset + 4, material.emissive[1], true);\n                        dataView.setFloat32(offset + 8, material.emissive[2], true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].TRANSMISSION_FILTER.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setFloat32(offset, material.transmissionFilter[0], true);\n                        dataView.setFloat32(offset + 4, material.transmissionFilter[1], true);\n                        dataView.setFloat32(offset + 8, material.transmissionFilter[2], true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].DISSOLVE.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setFloat32(offset, material.dissolve, true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].ILLUMINATION.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setInt16(offset, material.illumination, true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].REFRACTION_INDEX.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setFloat32(offset, material.refractionIndex, true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].SHARPNESS.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setFloat32(offset, material.sharpness, true);\n                        break;\n                    }\n                    case _layout__WEBPACK_IMPORTED_MODULE_0__["Layout"].ANTI_ALIASING.key: {\n                        const materialIndex = this.vertexMaterialIndices[i];\n                        const material = this.materialsByIndex[materialIndex];\n                        if (!material) {\n                            console.warn(\'Material "\' +\n                                this.materialNames[materialIndex] +\n                                \'" not found in mesh. Did you forget to call addMaterialLibrary(...)?"\');\n                            break;\n                        }\n                        dataView.setInt16(offset, material.antiAliasing ? 1 : 0, true);\n                        break;\n                    }\n                }\n            }\n        }\n        return buffer;\n    }\n    makeIndexBufferData() {\n        const buffer = new Uint16Array(this.indices);\n        buffer.numItems = this.indices.length;\n        return buffer;\n    }\n    makeIndexBufferDataForMaterials(...materialIndices) {\n        const indices = new Array().concat(...materialIndices.map(mtlIdx => this.indicesPerMaterial[mtlIdx]));\n        const buffer = new Uint16Array(indices);\n        buffer.numItems = indices.length;\n        return buffer;\n    }\n    addMaterialLibrary(mtl) {\n        for (const name in mtl.materials) {\n            if (!(name in this.materialIndices)) {\n                // This material is not referenced by the mesh\n                continue;\n            }\n            const material = mtl.materials[name];\n            // Find the material index for this material\n            const materialIndex = this.materialIndices[material.name];\n            // Put the material into the materialsByIndex object at the right\n            // spot as determined when the obj file was parsed\n            this.materialsByIndex[materialIndex] = material;\n        }\n    }\n}\nfunction* triangulate(elements) {\n    if (elements.length <= 3) {\n        yield elements;\n    }\n    else if (elements.length === 4) {\n        yield [elements[0], elements[1], elements[2]];\n        yield [elements[2], elements[3], elements[0]];\n    }\n    else {\n        for (let i = 1; i < elements.length - 1; i++) {\n            yield [elements[0], elements[i], elements[i + 1]];\n        }\n    }\n}\n\n\n//# sourceURL=webpack:///./src/mesh.ts?');},"./src/utils.ts":
+		/*!**********************!*\
+		  !*** ./src/utils.ts ***!
+		  \**********************/
+		/*! exports provided: downloadModels, downloadMeshes, initMeshBuffers, deleteMeshBuffers */function(module,__webpack_exports__,__webpack_require__){eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "downloadModels", function() { return downloadModels; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "downloadMeshes", function() { return downloadMeshes; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "initMeshBuffers", function() { return initMeshBuffers; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "deleteMeshBuffers", function() { return deleteMeshBuffers; });\n/* harmony import */ var _mesh__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./mesh */ "./src/mesh.ts");\n/* harmony import */ var _material__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./material */ "./src/material.ts");\n\n\nfunction downloadMtlTextures(mtl, root) {\n    const mapAttributes = [\n        "mapDiffuse",\n        "mapAmbient",\n        "mapSpecular",\n        "mapDissolve",\n        "mapBump",\n        "mapDisplacement",\n        "mapDecal",\n        "mapEmissive",\n    ];\n    if (!root.endsWith("/")) {\n        root += "/";\n    }\n    const textures = [];\n    for (const materialName in mtl.materials) {\n        if (!mtl.materials.hasOwnProperty(materialName)) {\n            continue;\n        }\n        const material = mtl.materials[materialName];\n        for (const attr of mapAttributes) {\n            const mapData = material[attr];\n            if (!mapData || !mapData.filename) {\n                continue;\n            }\n            const url = root + mapData.filename;\n            textures.push(fetch(url)\n                .then(response => {\n                if (!response.ok) {\n                    throw new Error();\n                }\n                return response.blob();\n            })\n                .then(function (data) {\n                const image = new Image();\n                image.src = URL.createObjectURL(data);\n                mapData.texture = image;\n                return new Promise(resolve => (image.onload = resolve));\n            })\n                .catch(() => {\n                console.error(`Unable to download texture: ${url}`);\n            }));\n        }\n    }\n    return Promise.all(textures);\n}\nfunction getMtl(modelOptions) {\n    if (!(typeof modelOptions.mtl === "string")) {\n        return modelOptions.obj.replace(/\\.obj$/, ".mtl");\n    }\n    return modelOptions.mtl;\n}\n/**\n * Accepts a list of model request objects and returns a Promise that\n * resolves when all models have been downloaded and parsed.\n *\n * The list of model objects follow this interface:\n * {\n *  obj: \'path/to/model.obj\',\n *  mtl: true | \'path/to/model.mtl\',\n *  downloadMtlTextures: true | false\n *  mtlTextureRoot: \'/models/suzanne/maps\'\n *  name: \'suzanne\'\n * }\n *\n * The `obj` attribute is required and should be the path to the\n * model\'s .obj file relative to the current repo (absolute URLs are\n * suggested).\n *\n * The `mtl` attribute is optional and can either be a boolean or\n * a path to the model\'s .mtl file relative to the current URL. If\n * the value is `true`, then the path and basename given for the `obj`\n * attribute is used replacing the .obj suffix for .mtl\n * E.g.: {obj: \'models/foo.obj\', mtl: true} would search for \'models/foo.mtl\'\n *\n * The `name` attribute is optional and is a human friendly name to be\n * included with the parsed OBJ and MTL files. If not given, the base .obj\n * filename will be used.\n *\n * The `downloadMtlTextures` attribute is a flag for automatically downloading\n * any images found in the MTL file and attaching them to each Material\n * created from that file. For example, if material.mapDiffuse is set (there\n * was data in the MTL file), then material.mapDiffuse.texture will contain\n * the downloaded image. This option defaults to `true`. By default, the MTL\'s\n * URL will be used to determine the location of the images.\n *\n * The `mtlTextureRoot` attribute is optional and should point to the location\n * on the server that this MTL\'s texture files are located. The default is to\n * use the MTL file\'s location.\n *\n * @returns {Promise} the result of downloading the given list of models. The\n * promise will resolve with an object whose keys are the names of the models\n * and the value is its Mesh object. Each Mesh object will automatically\n * have its addMaterialLibrary() method called to set the given MTL data (if given).\n */\nfunction downloadModels(models) {\n    const finished = [];\n    for (const model of models) {\n        if (!model.obj) {\n            throw new Error(\'"obj" attribute of model object not set. The .obj file is required to be set \' +\n                "in order to use downloadModels()");\n        }\n        const options = {\n            indicesPerMaterial: !!model.indicesPerMaterial,\n            calcTangentsAndBitangents: !!model.calcTangentsAndBitangents,\n        };\n        // if the name is not provided, dervive it from the given OBJ\n        let name = model.name;\n        if (!name) {\n            const parts = model.obj.split("/");\n            name = parts[parts.length - 1].replace(".obj", "");\n        }\n        const namePromise = Promise.resolve(name);\n        const meshPromise = fetch(model.obj)\n            .then(response => response.text())\n            .then(data => {\n            return new _mesh__WEBPACK_IMPORTED_MODULE_0__["default"](data, options);\n        });\n        let mtlPromise;\n        // Download MaterialLibrary file?\n        if (model.mtl) {\n            const mtl = getMtl(model);\n            mtlPromise = fetch(mtl)\n                .then(response => response.text())\n                .then((data) => {\n                const material = new _material__WEBPACK_IMPORTED_MODULE_1__["MaterialLibrary"](data);\n                if (model.downloadMtlTextures !== false) {\n                    let root = model.mtlTextureRoot;\n                    if (!root) {\n                        // get the directory of the MTL file as default\n                        root = mtl.substr(0, mtl.lastIndexOf("/"));\n                    }\n                    // downloadMtlTextures returns a Promise that\n                    // is resolved once all of the images it\n                    // contains are downloaded. These are then\n                    // attached to the map data objects\n                    return Promise.all([Promise.resolve(material), downloadMtlTextures(material, root)]);\n                }\n                return Promise.all([Promise.resolve(material), undefined]);\n            })\n                .then((value) => {\n                return value[0];\n            });\n        }\n        const parsed = [namePromise, meshPromise, mtlPromise];\n        finished.push(Promise.all(parsed));\n    }\n    return Promise.all(finished).then(ms => {\n        // the "finished" promise is a list of name, Mesh instance,\n        // and MaterialLibary instance. This unpacks and returns an\n        // object mapping name to Mesh (Mesh points to MTL).\n        const models = {};\n        for (const model of ms) {\n            const [name, mesh, mtl] = model;\n            mesh.name = name;\n            if (mtl) {\n                mesh.addMaterialLibrary(mtl);\n            }\n            models[name] = mesh;\n        }\n        return models;\n    });\n}\n/**\n * Takes in an object of `mesh_name`, `\'/url/to/OBJ/file\'` pairs and a callback\n * function. Each OBJ file will be ajaxed in and automatically converted to\n * an OBJ.Mesh. When all files have successfully downloaded the callback\n * function provided will be called and passed in an object containing\n * the newly created meshes.\n *\n * **Note:** In order to use this function as a way to download meshes, a\n * webserver of some sort must be used.\n *\n * @param {Object} nameAndAttrs an object where the key is the name of the mesh and the value is the url to that mesh\'s OBJ file\n *\n * @param {Function} completionCallback should contain a function that will take one parameter: an object array where the keys will be the unique object name and the value will be a Mesh object\n *\n * @param {Object} meshes In case other meshes are loaded separately or if a previously declared variable is desired to be used, pass in a (possibly empty) json object of the pattern: { \'<mesh_name>\': OBJ.Mesh }\n *\n */\nfunction downloadMeshes(nameAndURLs, completionCallback, meshes) {\n    if (meshes === undefined) {\n        meshes = {};\n    }\n    const completed = [];\n    for (const mesh_name in nameAndURLs) {\n        if (!nameAndURLs.hasOwnProperty(mesh_name)) {\n            continue;\n        }\n        const url = nameAndURLs[mesh_name];\n        completed.push(fetch(url)\n            .then(response => response.text())\n            .then(data => {\n            return [mesh_name, new _mesh__WEBPACK_IMPORTED_MODULE_0__["default"](data)];\n        }));\n    }\n    Promise.all(completed).then(ms => {\n        for (const [name, mesh] of ms) {\n            meshes[name] = mesh;\n        }\n        return completionCallback(meshes);\n    });\n}\nfunction _buildBuffer(gl, type, data, itemSize) {\n    const buffer = gl.createBuffer();\n    const arrayView = type === gl.ARRAY_BUFFER ? Float32Array : Uint16Array;\n    gl.bindBuffer(type, buffer);\n    gl.bufferData(type, new arrayView(data), gl.STATIC_DRAW);\n    buffer.itemSize = itemSize;\n    buffer.numItems = data.length / itemSize;\n    return buffer;\n}\n/**\n * Takes in the WebGL context and a Mesh, then creates and appends the buffers\n * to the mesh object as attributes.\n *\n * @param {WebGLRenderingContext} gl the `canvas.getContext(\'webgl\')` context instance\n * @param {Mesh} mesh a single `OBJ.Mesh` instance\n *\n * The newly created mesh attributes are:\n *\n * Attrbute | Description\n * :--- | ---\n * **normalBuffer**       |contains the model&#39;s Vertex Normals\n * normalBuffer.itemSize  |set to 3 items\n * normalBuffer.numItems  |the total number of vertex normals\n * |\n * **textureBuffer**      |contains the model&#39;s Texture Coordinates\n * textureBuffer.itemSize |set to 2 items\n * textureBuffer.numItems |the number of texture coordinates\n * |\n * **vertexBuffer**       |contains the model&#39;s Vertex Position Coordinates (does not include w)\n * vertexBuffer.itemSize  |set to 3 items\n * vertexBuffer.numItems  |the total number of vertices\n * |\n * **indexBuffer**        |contains the indices of the faces\n * indexBuffer.itemSize   |is set to 1\n * indexBuffer.numItems   |the total number of indices\n *\n * A simple example (a lot of steps are missing, so don\'t copy and paste):\n *\n *     const gl   = canvas.getContext(\'webgl\'),\n *         mesh = OBJ.Mesh(obj_file_data);\n *     // compile the shaders and create a shader program\n *     const shaderProgram = gl.createProgram();\n *     // compilation stuff here\n *     ...\n *     // make sure you have vertex, vertex normal, and texture coordinate\n *     // attributes located in your shaders and attach them to the shader program\n *     shaderProgram.vertexPositionAttribute = gl.getAttribLocation(shaderProgram, "aVertexPosition");\n *     gl.enableVertexAttribArray(shaderProgram.vertexPositionAttribute);\n *\n *     shaderProgram.vertexNormalAttribute = gl.getAttribLocation(shaderProgram, "aVertexNormal");\n *     gl.enableVertexAttribArray(shaderProgram.vertexNormalAttribute);\n *\n *     shaderProgram.textureCoordAttribute = gl.getAttribLocation(shaderProgram, "aTextureCoord");\n *     gl.enableVertexAttribArray(shaderProgram.textureCoordAttribute);\n *\n *     // create and initialize the vertex, vertex normal, and texture coordinate buffers\n *     // and save on to the mesh object\n *     OBJ.initMeshBuffers(gl, mesh);\n *\n *     // now to render the mesh\n *     gl.bindBuffer(gl.ARRAY_BUFFER, mesh.vertexBuffer);\n *     gl.vertexAttribPointer(shaderProgram.vertexPositionAttribute, mesh.vertexBuffer.itemSize, gl.FLOAT, false, 0, 0);\n *     // it\'s possible that the mesh doesn\'t contain\n *     // any texture coordinates (e.g. suzanne.obj in the development branch).\n *     // in this case, the texture vertexAttribArray will need to be disabled\n *     // before the call to drawElements\n *     if(!mesh.textures.length){\n *       gl.disableVertexAttribArray(shaderProgram.textureCoordAttribute);\n *     }\n *     else{\n *       // if the texture vertexAttribArray has been previously\n *       // disabled, then it needs to be re-enabled\n *       gl.enableVertexAttribArray(shaderProgram.textureCoordAttribute);\n *       gl.bindBuffer(gl.ARRAY_BUFFER, mesh.textureBuffer);\n *       gl.vertexAttribPointer(shaderProgram.textureCoordAttribute, mesh.textureBuffer.itemSize, gl.FLOAT, false, 0, 0);\n *     }\n *\n *     gl.bindBuffer(gl.ARRAY_BUFFER, mesh.normalBuffer);\n *     gl.vertexAttribPointer(shaderProgram.vertexNormalAttribute, mesh.normalBuffer.itemSize, gl.FLOAT, false, 0, 0);\n *\n *     gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, model.mesh.indexBuffer);\n *     gl.drawElements(gl.TRIANGLES, model.mesh.indexBuffer.numItems, gl.UNSIGNED_SHORT, 0);\n */\nfunction initMeshBuffers(gl, mesh) {\n    mesh.normalBuffer = _buildBuffer(gl, gl.ARRAY_BUFFER, mesh.vertexNormals, 3);\n    mesh.textureBuffer = _buildBuffer(gl, gl.ARRAY_BUFFER, mesh.textures, mesh.textureStride);\n    mesh.vertexBuffer = _buildBuffer(gl, gl.ARRAY_BUFFER, mesh.vertices, 3);\n    mesh.indexBuffer = _buildBuffer(gl, gl.ELEMENT_ARRAY_BUFFER, mesh.indices, 1);\n    return mesh;\n}\nfunction deleteMeshBuffers(gl, mesh) {\n    gl.deleteBuffer(mesh.normalBuffer);\n    gl.deleteBuffer(mesh.textureBuffer);\n    gl.deleteBuffer(mesh.vertexBuffer);\n    gl.deleteBuffer(mesh.indexBuffer);\n}\n\n\n//# sourceURL=webpack:///./src/utils.ts?');},0:
+		/*!****************************!*\
+		  !*** multi ./src/index.ts ***!
+		  \****************************/
+		/*! no static exports found */function(module,exports,__webpack_require__){eval('module.exports = __webpack_require__(/*! /home/aaron/google_drive/projects/webgl-obj-loader/src/index.ts */"./src/index.ts");\n\n\n//# sourceURL=webpack:///multi_./src/index.ts?');}})})); 
+	} (webglObjLoader_min$1));
+	return webglObjLoader_min$1.exports;
+}
+
+var webglObjLoader_minExports = requireWebglObjLoader_min();
+var OBJ = /*@__PURE__*/getDefaultExportFromCjs(webglObjLoader_minExports);
+
+/**
+ * @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 adapts webgl-obj-loader's mesh, no parser of its own.
+ *
+ * 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,
+ * anything Canvas2D can typeset). No orientation option anywhere: whether
+ * rows flip is the bridge's upload, since it depends on the GPU API's
+ * texture space.
+ */
+
+
+/**
+ * Fetch an image into an ImageBitmap.
+ * @param {string} url
+ * @param {{ fetch?:object, bitmap?:object }} [opts]
+ *        fetch: the fetch init (credentials, mode, …). bitmap: the
+ *        createImageBitmap options (premultiplyAlpha, colorSpaceConversion, …).
+ * @returns {Promise<ImageBitmap>}
+ */
+async function loadImage(url, opts) {
+  const o = opts || {};
+  const res = await fetch(url, o.fetch);
+  if (!res.ok) throw new Error('[host] image: ' + url + ' → ' + res.status);
+  const blob = await res.blob();
+  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.
+ *
+ * Parsing is webgl-obj-loader's: 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);
+  const mesh = new OBJ.Mesh(await res.text());
+  const out = {
+    position: { numComponents: 3, data: new Float32Array(mesh.vertices) },
+    indices: { numComponents: 3, data: new Uint32Array(mesh.indices) },
+  };
+  // a file without normals leaves the loader's normals unset, one per component
+  const n = mesh.vertexNormals;
+  if (n.length && n.every(Number.isFinite)) out.normal = { numComponents: 3, data: new Float32Array(n) };
+  if (mesh.textures.length) out.texcoord = { numComponents: mesh.textureStride, data: new Float32Array(mesh.textures) };
+  return out;
+}
+
+/**
+ * A hidden, muted, inline <video> element from a file or the user's camera.
+ * `ready` resolves once metadata arrived (width / height known); a camera
+ * denial rejects it. Inside an iframe a camera source needs allow="camera"
+ * on the frame.
+ *
+ * @param {{ src?:string, camera?:boolean|object, loop?:boolean, autoplay?:boolean,
+ *           document?:object, media?:object }} opts
+ *        src: a media URL. camera: true or getUserMedia video constraints
+ *        ({ facingMode, width, height }). loop (default true for src).
+ *        autoplay (default true): start() once ready. document / media: the
+ *        Document and MediaDevices to use (defaults: the globals) — the seam
+ *        a test fills.
+ * @returns {{ el:HTMLVideoElement, ready:Promise<object>, width:number, height:number,
+ *             start():Promise<void>, stop():object, dispose():object }}
+ */
+function createVideo(opts) {
+  const o = opts || {};
+  const doc = o.document || (typeof document !== 'undefined' ? document : null);
+  if (!doc) { console.error('[host] video: no document.'); return null; }
+  const el = doc.createElement('video');
+  el.muted = true;
+  el.playsInline = true;
+  el.setAttribute('playsinline', '');
+  el.setAttribute('muted', '');
+  el.style.display = 'none';
+  let stream = null;
+
+  const v = {
+    /** The <video> element — the bridge's upload source, refreshed each frame. */
+    el,
+    /** Intrinsic size, known once `ready` resolved. */
+    width: 0, height: 0,
+    /** Resolves with this source once metadata arrived; rejects on a camera denial or a load error. */
+    ready: null,
+    /** Play; resolves when playback began. */
+    start() { const p = el.play(); return p && typeof p.catch === 'function' ? p.catch((e) => console.error('[host] video: play() failed: ' + e.message + '.')) : Promise.resolve(); },
+    /** Pause. Chainable. */
+    stop() { el.pause(); return v; },
+    /** Stop, release the camera tracks, detach the element. */
+    dispose() {
+      el.pause();
+      if (stream) { for (const t of stream.getTracks()) t.stop(); stream = null; }
+      el.removeAttribute('src');
+      el.srcObject = null;
+      if (typeof el.remove === 'function') el.remove();
+      return v;
+    },
+  };
+
+  v.ready = new Promise((resolve, reject) => {
+    const unlisten = () => { el.removeEventListener('loadedmetadata', onMeta); el.removeEventListener('error', onErr); };
+    const fail = (msg) => { unlisten(); reject(new Error('[host] video: ' + msg)); };
+    const onMeta = () => {
+      v.width = el.videoWidth || 0; v.height = el.videoHeight || 0;
+      unlisten();
+      if (o.autoplay !== false) v.start();
+      resolve(v);
+    };
+    const onErr = () => fail('failed to load ' + (o.src || 'the source') + '.');
+    el.addEventListener('loadedmetadata', onMeta);
+    el.addEventListener('error', onErr);
+    if (o.camera) {
+      const media = o.media || (typeof navigator !== 'undefined' && navigator.mediaDevices) || null;
+      if (!media || typeof media.getUserMedia !== 'function') { fail('getUserMedia is unavailable here.'); return; }
+      media.getUserMedia({ video: o.camera === true ? true : o.camera, audio: false })
+        .then((s) => { stream = s; el.srcObject = s; })
+        .catch((e) => fail('camera denied: ' + e.message + '.'));
+    } else if (o.src) {
+      el.loop = o.loop !== false;
+      el.src = o.src;
+    } else {
+      fail('needs { src } or { camera }.');
+    }
+  });
+  v.ready.catch(() => {});   // an unobserved rejection is the caller's to observe, not a crash
+  return v;
+}
+
+/**
+ * Draw through a 2D context and hand the result back as a texture source: an
+ * ImageBitmap where OffscreenCanvas exists, else the canvas element itself.
+ *
+ * @param {function(CanvasRenderingContext2D, number, number):void} draw
+ * @param {number} w  Pixel width.
+ * @param {number} h  Pixel height.
+ * @param {{ document?:object }} [opts]  The Document for the fallback canvas.
+ * @returns {ImageBitmap|HTMLCanvasElement|null}
+ */
+function raster(draw, w, h, opts) {
+  const o = opts || {};
+  if (typeof OffscreenCanvas !== 'undefined') {
+    const c = new OffscreenCanvas(w, h);
+    draw(c.getContext('2d'), w, h);
+    return c.transferToImageBitmap();
+  }
+  const doc = o.document || (typeof document !== 'undefined' ? document : null);
+  if (!doc) { console.error('[host] raster: no OffscreenCanvas and no document.'); return null; }
+  const c = doc.createElement('canvas');
+  c.width = w; c.height = h;
+  draw(c.getContext('2d'), w, h);
+  return c;
+}
+
+/**
+ * @file The label layer — DOM text over the canvas, anchored in world or screen space.
+ * @module host/labels
+ * @license AGPL-3.0-only
+ *
+ * The replacement for WEBGL text() in HUDs, gizmo labels and formula
+ * readouts, with the browser's own shaping. One absolutely positioned <div>
+ * overlays the canvas as its next sibling, pointer-events: none, sized by
+ * the canvas observer; the host sets the canvas parent to position:
+ * relative when it is static, and says so in the console once.
+ *
+ *   labels.set(id, text, x, y, z, opts)     // a world anchor, projected each tick()
+ *   labels.setScreen(id, text, sx, sy, opts) // canvas px, the HUD form
+ *   labels.remove(id) · labels.clear() · labels.visible
+ *   labels.tick()                            // after the view bag is current
+ *
+ * opts: dx / dy pixel offsets, anchor ('center' default, 'left', 'right'),
+ * class — a CSS class beside the layer's own 'host-label', frame — a
+ * transient label that lives for the frame it was set in: a gizmo re-sets
+ * it every draw and tick() removes it once a frame passes without. A label
+ * whose screen depth leaves [0, 1] or whose anchor leaves the canvas is
+ * hidden, not clamped. Elements are reused by id; tick() writes transforms
+ * only, text when the string changed.
+ */
+
+
+const _p = [0, 0, 0];
+const _ANCHOR = { center: -50, left: 0, right: -100 };
+const _NO_OPTS = {};
+
+/**
+ * Create the label layer of a canvas. The layer is inserted at once; it
+ * needs a parent, so create it after the canvas is in the document.
+ *
+ * @param {object} host  Its canvas, view bag and size are read.
+ * @param {{ document?:object }} [opts]  The Document (default: the global).
+ * @returns {object|null} The layer, or null without a document or a parent.
+ */
+function createLabels(host, opts) {
+  const o = opts || {};
+  const doc = o.document || (typeof document !== 'undefined' ? document : null);
+  const canvas = host.canvas;
+  const parent = canvas && canvas.parentNode;
+  if (!doc || !parent) { console.error('[host] labels: the canvas needs a parent element.'); return null; }
+
+  const el = doc.createElement('div');
+  el.className = 'host-labels';
+  Object.assign(el.style, {
+    position: 'absolute', left: '0px', top: '0px', width: '0px', height: '0px',
+    pointerEvents: 'none', overflow: 'hidden',
+  });
+  const cs = typeof getComputedStyle === 'function' ? getComputedStyle(parent) : null;
+  if (cs && cs.position === 'static') {
+    parent.style.position = 'relative';
+    console.info('[host] labels: set the canvas parent to position: relative for the label layer.');
+  }
+  parent.insertBefore(el, canvas.nextSibling);
+
+  const entries = new Map();   // id → { el, text, x, y, z, dx, dy, ax, screen, cls, sx, sy, shown }
+  let width = 0, height = 0, left = -1, top = -1, visible = true;
+
+  const entry = (id, text, o) => {
+    let e = entries.get(id);
+    if (!e) {
+      const span = doc.createElement('span');
+      Object.assign(span.style, { position: 'absolute', left: '0px', top: '0px', whiteSpace: 'nowrap', willChange: 'transform' });
+      span.style.visibility = 'hidden';
+      el.appendChild(span);
+      e = { el: span, text: null, x: 0, y: 0, z: 0, dx: 0, dy: 0, ax: -50, screen: false, cls: null, sx: NaN, sy: NaN, shown: false, frame: false, fresh: false };
+      entries.set(id, e);
+    }
+    if (e.text !== text) { e.text = text; e.el.textContent = text; }
+    const c = o.class || null;
+    if (e.cls !== c) { e.cls = c; e.el.className = c ? 'host-label ' + c : 'host-label'; }
+    e.ax = _ANCHOR[o.anchor] ?? -50;
+    e.dx = o.dx || 0; e.dy = o.dy || 0;
+    e.frame = !!o.frame; e.fresh = true;
+    return e;
+  };
+  const place = (e, sx, sy) => {
+    if (sx === e.sx && sy === e.sy) return;
+    e.sx = sx; e.sy = sy;
+    e.el.style.transform = 'translate(' + sx + 'px, ' + sy + 'px) translate(' + e.ax + '%, -50%)';
+  };
+  const show = (e, on) => {
+    if (e.shown === on) return;
+    e.shown = on;
+    e.el.style.visibility = on ? '' : 'hidden';
+  };
+
+  const labels = {
+    /** The layer element. */
+    el,
+    /** Whether the layer shows; false hides every label at once. */
+    get visible() { return visible; },
+    set visible(v) { visible = !!v; el.style.display = visible ? '' : 'none'; },
+    /** Live label count. */
+    get size() { return entries.size; },
+
+    /**
+     * Place a label at a world anchor, projected each tick().
+     * @param {string} id
+     * @param {string} text
+     * @param {number} x, y, z  World anchor.
+     * @param {{ dx?:number, dy?:number, anchor?:string, class?:string, frame?:boolean }} [opts]
+     * @returns {object} this
+     */
+    set(id, text, x, y, z, opts) {
+      const e = entry(id, text, opts || _NO_OPTS);
+      e.screen = false; e.x = x; e.y = y; e.z = z;
+      return labels;
+    },
+
+    /**
+     * Place a label in canvas px — the HUD form.
+     * @param {string} id
+     * @param {string} text
+     * @param {number} sx, sy  Canvas px, y down.
+     * @param {{ dx?:number, dy?:number, anchor?:string, class?:string, frame?:boolean }} [opts]
+     * @returns {object} this
+     */
+    setScreen(id, text, sx, sy, opts) {
+      const e = entry(id, text, opts || _NO_OPTS);
+      e.screen = true; e.x = sx; e.y = sy; e.z = 0;
+      return labels;
+    },
+
+    /** Remove a label. */
+    remove(id) {
+      const e = entries.get(id);
+      if (e) { el.removeChild(e.el); entries.delete(id); }
+      return labels;
+    },
+
+    /** Remove every label. */
+    clear() { for (const id of [...entries.keys()]) labels.remove(id); return labels; },
+
+    /**
+     * Project every world label through the view bag and write the
+     * transforms; hide what falls outside the canvas or the depth range.
+     * Call after the view bag is current for the frame.
+     * @returns {object} this
+     */
+    tick() {
+      const ol = canvas.offsetLeft || 0, ot = canvas.offsetTop || 0;
+      if (ol !== left || ot !== top) { left = ol; top = ot; el.style.left = ol + 'px'; el.style.top = ot + 'px'; }
+      const view = host.view;
+      for (const [id, e] of entries) {
+        if (e.frame && !e.fresh) { labels.remove(id); continue; }
+        e.fresh = false;
+        let sx, sy, on;
+        if (e.screen) { sx = e.x; sy = e.y; on = true; }
+        else if (!view || view.stale) { on = false; }
+        else {
+          mapLocation(_p, e.x, e.y, e.z, WORLD, SCREEN, view, view.vp, view.ndcZMin);
+          sx = _p[0]; sy = _p[1];
+          on = _p[2] >= 0 && _p[2] <= 1 && sx >= 0 && sx <= width && sy >= 0 && sy <= height;
+        }
+        if (on) place(e, sx + e.dx, sy + e.dy);
+        show(e, on);
+      }
+      return labels;
+    },
+
+    /**
+     * The observer's write: the layer's size in CSS px.
+     * @param {number} w
+     * @param {number} h
+     * @returns {object} this
+     */
+    resize(w, h) {
+      width = w; height = h;
+      el.style.width = w + 'px'; el.style.height = h + 'px';
+      return labels;
+    },
+
+    /** Remove the layer and its labels. */
+    dispose() {
+      entries.clear();
+      if (el.parentNode) el.parentNode.removeChild(el);
+      host.unregister(labels);
+      return labels;
+    },
+  };
+  labels.resize(host.width || 0, host.height || 0);
+  return host.register(labels);
+}
+
+/**
+ * @file The orbit — the fall-through camera gesture on unclaimed pointers.
+ * @module host/orbit
+ * @license AGPL-3.0-only
+ *
+ * What the handle gate yields to: one pointer orbits the camera state about
+ * its center, two pointers dolly by their distance and pan by their
+ * midpoint, the wheel dollies. update() consumes only unclaimed pointers and
+ * returns true when it moved the camera, so
+ *
+ *   if (!h.update()) orbit.update()
+ *
+ * reads as the gate. It writes cam only; the next setCamera(cam) installs it.
+ * 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.
+ *
+ * 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
+ * default) maps a downward drag to the eye's −up, a y-flipped one (p5's,
+ * mat4Proj[5] < 0) to +up. The orbit reads that sign off the bag each
+ * update, so a drag down always brings the scene down.
+ */
+
+
+const _clamp = { min: 0, max: Infinity };
+
+/**
+ * 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,
+ *           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() }.
+ */
+function createOrbit(host, cam, opts) {
+  const o = opts || {};
+  const canvas = host.canvas;
+  const home = cameraCopy(createCamera(), cam);
+  const tracked = new Map();   // pointer id → { x, y } as last consumed
+  let wheelAcc = 0;
+
+  const onWheel = (e) => {
+    if (typeof e.preventDefault === 'function') e.preventDefault();
+    const unit = e.deltaMode === 1 ? 16 : e.deltaMode === 2 ? (host.height || 1) : 1;
+    wheelAcc += (e.deltaY || 0) * unit;
+  };
+  canvas.addEventListener('wheel', onWheel, { passive: false });
+  const touchAction = canvas.style ? canvas.style.touchAction : undefined;
+  if (canvas.style) canvas.style.touchAction = 'none';
+
+  const track = (p) => {
+    let t = tracked.get(p.id);
+    if (!t) { t = { x: p.x, y: p.y }; tracked.set(p.id, t); }
+    else { t.x = p.x; t.y = p.y; }
+  };
+  const distance = () => {
+    const e = cam.eye, c = cam.center;
+    return Math.hypot(e[0] - c[0], e[1] - c[1], e[2] - c[2]);
+  };
+  const dolly = (factor) => {
+    _clamp.min = orbit.minDistance; _clamp.max = orbit.maxDistance;
+    cameraDolly(cam, factor, _clamp);
+  };
+
+  const orbit = {
+    /** The camera state written. */
+    cam,
+    /** False makes update() a no-op that drops its pointer memory. */
+    enabled: o.enabled !== false,
+    /** Radians per pixel of one-pointer drag. */
+    rotate: o.rotate ?? 0.005,
+    /** Scalar on the two-pointer pan. */
+    pan: o.pan ?? 1,
+    /** Scalar on the pinch dolly's exponent. */
+    zoom: o.zoom ?? 1,
+    /** Scalar on the wheel dolly. */
+    wheel: o.wheel ?? 1,
+    /** 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.
+     * @returns {boolean} Whether the camera moved.
+     */
+    update() {
+      if (!orbit.enabled) { tracked.clear(); wheelAcc = 0; return false; }
+      const src = host.pointer;
+      let a = null, b = null;
+      for (const p of src.pointers.values()) {
+        // 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);
+      }
+      let moved = false;
+      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; }
+        }
+        track(a);
+      } else if (a !== null && b !== null) {
+        const ta = tracked.get(a.id), tb = tracked.get(b.id);
+        if (ta && tb) {
+          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;
+          }
+          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; }
+        }
+        track(a); track(b);
+      }
+      if (wheelAcc !== 0) {
+        dolly(Math.exp(wheelAcc * 0.001 * orbit.wheel));
+        wheelAcc = 0;
+        moved = true;
+      }
+      return moved;
+    },
+
+    /** Restore the pose captured at creation. */
+    home() { cameraCopy(cam, home); 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();
+      host.unregister(orbit);
+      return orbit;
+    },
+  };
+  return host.register(orbit);
+}
+
 /**
  * @file The host context — one per canvas: pointer, view bag, players, loop, observer.
  * @module host
@@ -4706,6 +2419,10 @@ class TrackHandles {
  *   host.handle(opts) · host.router(handles, 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.model(url)
+ *   host.labels        // the DOM label layer, created on first access
+ *   host.orbit(cam, opts)
  *   host.tick(dt)      // external-loop mode
  *   host.dispose()
  *
@@ -4740,7 +2457,7 @@ function createHost(canvas, opts) {
   const o = opts || {};
   const t0 = _now();
   const constructs = new Set();
-  let loop = null, observer = null;
+  let loop = null, observer = null, labels = null;
   const host = {
     canvas,
     width: 0, height: 0, dpr: 1,
@@ -4788,6 +2505,30 @@ function createHost(canvas, opts) {
     poseTrack(opts) { return poseTrack(host, opts); },
     /** A core CameraTrack evaluating into a camera state while it plays — see host/track. */
     cameraTrack(cam, opts) { return cameraTrack(host, cam, opts); },
+    /** A WebHID 6-DOF rate stream — see host/stream. */
+    hid(opts) { return createHid(host, opts); },
+    /** A Gamepad rate stream, polled each tick — see host/stream. */
+    gamepad(opts) { return createGamepad(host, opts); },
+    /** Fetch an image into an ImageBitmap — see host/media. */
+    image(url, opts) { return loadImage(url, opts); },
+    /** A hidden <video> from a file or the camera, disposed with the host — see host/media. */
+    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.
+     */
+    get labels() {
+      if (labels === null) labels = createLabels(host);
+      return labels;
+    },
+    /** Whether the label layer exists, without creating it. */
+    get hasLabels() { return labels !== null; },
+    /** The fall-through camera gesture on unclaimed pointers — see host/orbit. */
+    orbit(cam, opts) { return createOrbit(host, cam, opts); },
 
     /** Register a construct with dispose() so host.dispose() releases it. */
     register(c) { if (c) constructs.add(c); return c; },
@@ -4799,6 +2540,7 @@ function createHost(canvas, opts) {
       if (loop) loop.stop();
       for (const c of [...constructs]) { if (typeof c.dispose === 'function') c.dispose(); }
       constructs.clear();
+      labels = null;
       observer.dispose();
       host.pointer.dispose();
       host.players.clear();
@@ -4811,6 +2553,7 @@ function createHost(canvas, opts) {
   observer = observeCanvas(canvas, (w, h, dpr) => {
     host.width = w; host.height = h; host.dpr = dpr;
     host.view.resize(w, h);
+    if (labels) labels.resize(w, h);
     if (typeof o.onSize === 'function') o.onSize(w, h, dpr);
   });
 
@@ -4829,5 +2572,5 @@ function createHost(canvas, opts) {
   return host;
 }
 
-export { Handle, PointerRouter, TrackHandles, VIEW, cameraHelm, cameraTrack, createHost, createLoop, createPlayers, createPointer, createView, helmBasis, isConstraint, measureCanvas, observeCanvas, poseHelm, poseTrack, 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