@vincentt-xr/sdk 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/settings-BJ7FMBsO.js

@@ -0,0 +1,111 @@
+import { D as t } from "./detector-K8aej4MB.js";
+const i = {
+  enabled: !0,
+  bothHands: !0,
+  countEnabled: !0,
+  minCountConfidence: 0.35,
+  showBones: !0,
+  showJoints: !0,
+  showBoundingBox: !0,
+  showLabels: !1,
+  visualScale: 1,
+  opacity: 0.9,
+  jointRadius: 3,
+  lineWidth: 1.5,
+  labelScale: 1,
+  smoothing: 0.35
+}, r = [
+  [0, 1],
+  [1, 2],
+  [2, 3],
+  [3, 4],
+  [0, 5],
+  [5, 6],
+  [6, 7],
+  [7, 8],
+  [0, 9],
+  [9, 10],
+  [10, 11],
+  [11, 12],
+  [0, 13],
+  [13, 14],
+  [14, 15],
+  [15, 16],
+  [0, 17],
+  [17, 18],
+  [18, 19],
+  [19, 20]
+], a = [
+  "both",
+  "left",
+  "right",
+  "none"
+], n = {
+  hands: "both",
+  targetFps: 24,
+  analysisMaxDimension: 768,
+  holdMs: 250,
+  predictMs: 0,
+  outputFaceBlendshapes: !0
+}, p = [
+  {
+    key: "hands",
+    label: "Hands",
+    type: "select",
+    options: a.map((e) => ({ label: e, value: e }))
+  },
+  {
+    key: "targetFps",
+    label: "Target FPS (0 = uncapped)",
+    type: "number",
+    min: 0,
+    max: 60,
+    step: 1
+  },
+  {
+    key: "analysisMaxDimension",
+    label: "Analysis max px",
+    type: "number",
+    min: 256,
+    max: 1280,
+    step: 64
+  },
+  { key: "holdMs", label: "Hold (ms)", type: "number", min: 0, max: 1e3, step: 10 },
+  { key: "predictMs", label: "Predict (ms)", type: "number", min: 0, max: 300, step: 10 },
+  { key: "outputFaceBlendshapes", label: "Face blendshapes (re-inits)", type: "boolean" }
+], m = (e) => ({ ...n, ...e }), c = (e, s) => ({ ...e, ...s }), d = (e) => ({
+  hands: e.hands,
+  targetFps: e.targetFps > 0 ? e.targetFps : void 0,
+  analysisMaxDimension: e.analysisMaxDimension,
+  holdMs: e.holdMs,
+  predictMs: e.predictMs,
+  outputFaceBlendshapes: e.outputFaceBlendshapes
+}), o = { ...t }, b = [
+  { key: "enterThreshold", label: "Enter threshold", type: "number", min: 0, max: 1, step: 0.01 },
+  { key: "exitThreshold", label: "Exit threshold", type: "number", min: 0, max: 1, step: 0.01 },
+  { key: "holdMs", label: "Hold before begin (ms)", type: "number", min: 0, max: 1e3, step: 10 },
+  {
+    key: "cooldownMs",
+    label: "Cooldown after end (ms)",
+    type: "number",
+    min: 0,
+    max: 3e3,
+    step: 50
+  },
+  { key: "minConfidence", label: "Min confidence", type: "number", min: 0, max: 1, step: 0.05 },
+  { key: "lostGraceMs", label: "Loss grace (ms)", type: "number", min: 0, max: 1e3, step: 10 }
+], h = (e, s = o) => ({ ...s, ...e }), T = (e, s) => ({ ...e, ...s });
+export {
+  n as D,
+  b as G,
+  r as H,
+  a,
+  p as b,
+  o as c,
+  T as d,
+  h as e,
+  i as f,
+  c as p,
+  m as r,
+  d as t
+};

package/dist/settings-C63FMBlF.cjs

@@ -0,0 +1 @@
+"use strict";const o=require("./detector-ijypGtse.cjs"),l={enabled:!0,bothHands:!0,countEnabled:!0,minCountConfidence:.35,showBones:!0,showJoints:!0,showBoundingBox:!0,showLabels:!1,visualScale:1,opacity:.9,jointRadius:3,lineWidth:1.5,labelScale:1,smoothing:.35},i=[[0,1],[1,2],[2,3],[3,4],[0,5],[5,6],[6,7],[7,8],[0,9],[9,10],[10,11],[11,12],[0,13],[13,14],[14,15],[15,16],[0,17],[17,18],[18,19],[19,20]],s=["both","left","right","none"],n={hands:"both",targetFps:24,analysisMaxDimension:768,holdMs:250,predictMs:0,outputFaceBlendshapes:!0},r=[{key:"hands",label:"Hands",type:"select",options:s.map(e=>({label:e,value:e}))},{key:"targetFps",label:"Target FPS (0 = uncapped)",type:"number",min:0,max:60,step:1},{key:"analysisMaxDimension",label:"Analysis max px",type:"number",min:256,max:1280,step:64},{key:"holdMs",label:"Hold (ms)",type:"number",min:0,max:1e3,step:10},{key:"predictMs",label:"Predict (ms)",type:"number",min:0,max:300,step:10},{key:"outputFaceBlendshapes",label:"Face blendshapes (re-inits)",type:"boolean"}],T=e=>({...n,...e}),S=(e,t)=>({...e,...t}),c=e=>({hands:e.hands,targetFps:e.targetFps>0?e.targetFps:void 0,analysisMaxDimension:e.analysisMaxDimension,holdMs:e.holdMs,predictMs:e.predictMs,outputFaceBlendshapes:e.outputFaceBlendshapes}),a={...o.DEFAULT_GESTURE_DETECTOR_OPTIONS},p=[{key:"enterThreshold",label:"Enter threshold",type:"number",min:0,max:1,step:.01},{key:"exitThreshold",label:"Exit threshold",type:"number",min:0,max:1,step:.01},{key:"holdMs",label:"Hold before begin (ms)",type:"number",min:0,max:1e3,step:10},{key:"cooldownMs",label:"Cooldown after end (ms)",type:"number",min:0,max:3e3,step:50},{key:"minConfidence",label:"Min confidence",type:"number",min:0,max:1,step:.05},{key:"lostGraceMs",label:"Loss grace (ms)",type:"number",min:0,max:1e3,step:10}],m=(e,t=a)=>({...t,...e}),E=(e,t)=>({...e,...t});exports.DEFAULT_GESTURE_SETTINGS=a;exports.DEFAULT_HAND_JOINTS_2D_SETTINGS=l;exports.DEFAULT_HOLISTIC_TRACKER_SETTINGS=n;exports.GESTURE_SETTINGS_FIELDS=p;exports.HAND_JOINTS_2D_BONES=i;exports.HOLISTIC_HANDS_OPTIONS=s;exports.HOLISTIC_TRACKER_SETTINGS_FIELDS=r;exports.patchGestureSettings=E;exports.patchHolisticTrackerSettings=S;exports.resolveGestureSettings=m;exports.resolveHolisticTrackerSettings=T;exports.toHolisticTrackerProps=c;

package/dist/similarityFit-BFqHND2e.cjs

@@ -0,0 +1 @@
+"use strict";const A=require("three");function B(o){const e=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(o){for(const s in o)if(s!=="default"){const S=Object.getOwnPropertyDescriptor(o,s);Object.defineProperty(e,s,S.get?S:{enumerable:!0,get:()=>o[s]})}}return e.default=o,Object.freeze(e)}const H=B(A),w=new H.Vector3,k=new H.Vector3,U=new H.Matrix3,C=new H.Matrix4,_=new H.Vector3,G=(o,e)=>{const s=o.slice();e[0]=1,e[1]=0,e[2]=0,e[3]=0,e[4]=1,e[5]=0,e[6]=0,e[7]=0,e[8]=1;for(let S=0;S<12&&!(s[1]*s[1]+s[2]*s[2]+s[5]*s[5]<1e-24);S+=1)for(const[l,f]of[[0,1],[0,2],[1,2]]){const D=s[l*3+f];if(Math.abs(D)<1e-18)continue;const V=s[l*3+l],y=(s[f*3+f]-V)/(2*D),j=Math.sign(y||1)/(Math.abs(y)+Math.sqrt(y*y+1)),h=1/Math.sqrt(j*j+1),x=j*h;for(let t=0;t<3;t+=1){const n=s[t*3+l],a=s[t*3+f];s[t*3+l]=h*n-x*a,s[t*3+f]=x*n+h*a}for(let t=0;t<3;t+=1){const n=s[l*3+t],a=s[f*3+t];s[l*3+t]=h*n-x*a,s[f*3+t]=x*n+h*a}for(let t=0;t<3;t+=1){const n=e[t*3+l],a=e[t*3+f];e[t*3+l]=h*n-x*a,e[t*3+f]=x*n+h*a}}return[s[0],s[4],s[8]]},N=o=>o[0]*(o[4]*o[8]-o[5]*o[7])-o[1]*(o[3]*o[8]-o[5]*o[6])+o[2]*(o[3]*o[7]-o[4]*o[6]),r=[0,0,0,0,0,0,0,0,0],v=[0,0,0,0,0,0,0,0,0],F=[0,0,0,0,0,0,0,0,0],m=[0,0,0,0,0,0,0,0,0],E=[0,0,0,0,0,0,0,0,0],u=[0,0,0,0,0,0,0,0,0],I=(o,e,s={scale:1,quaternion:new H.Quaternion,translation:new H.Vector3,rms:0},S=!0)=>{const z=Math.floor(Math.min(o.length,e.length)/3);if(z<3)throw new Error("solveSimilarity: at least 3 points are required");w.set(0,0,0),k.set(0,0,0);for(let t=0;t<z;t+=1)w.x+=o[t*3],w.y+=o[t*3+1],w.z+=o[t*3+2],k.x+=e[t*3],k.y+=e[t*3+1],k.z+=e[t*3+2];w.divideScalar(z),k.divideScalar(z),r.fill(0);let l=0;for(let t=0;t<z;t+=1){const n=o[t*3]-w.x,a=o[t*3+1]-w.y,p=o[t*3+2]-w.z,b=e[t*3]-k.x,d=e[t*3+1]-k.y,q=e[t*3+2]-k.z;l+=n*n+a*a+p*p,r[0]+=n*b,r[1]+=n*d,r[2]+=n*q,r[3]+=a*b,r[4]+=a*d,r[5]+=a*q,r[6]+=p*b,r[7]+=p*d,r[8]+=p*q}for(let t=0;t<3;t+=1)for(let n=0;n<3;n+=1)v[t*3+n]=r[t]*r[n]+r[3+t]*r[3+n]+r[6+t]*r[6+n];const f=G(v,F),D=[0,1,2].sort((t,n)=>f[n]-f[t]),V=[0,0,0],c=[];for(let t=0;t<3;t+=1){const n=D[t],a=F[n],p=F[3+n],b=F[6+n];m[t]=a,m[3+t]=p,m[6+t]=b;let d=r[0]*a+r[1]*p+r[2]*b,q=r[3]*a+r[4]*p+r[5]*b,O=r[6]*a+r[7]*p+r[8]*b;if(V[t]=Math.sqrt(Math.max(f[n],0)),t===2){const i=c[0][1]*c[1][2]-c[0][2]*c[1][1],M=c[0][2]*c[1][0]-c[0][0]*c[1][2],R=c[0][0]*c[1][1]-c[0][1]*c[1][0],T=d*i+q*M+O*R,g=Math.hypot(d,q,O)>1e-9*Math.max(V[0],1e-300)?T<0?-1:1:N(m)<0?-1:1;c.push([g*i,g*M,g*R]);continue}for(const i of c){const M=d*i[0]+q*i[1]+O*i[2];d-=M*i[0],q-=M*i[1],O-=M*i[2]}const Q=Math.hypot(d,q,O);if(Q>1e-12)c.push([d/Q,q/Q,O/Q]);else if(t===0)c.push([1,0,0]);else{const i=Math.abs(c[0][0])<.9?[1,0,0]:[0,1,0],M=i[0]*c[0][0]+i[1]*c[0][1]+i[2]*c[0][2],R=i[0]-M*c[0][0],T=i[1]-M*c[0][1],P=i[2]-M*c[0][2],g=Math.hypot(R,T,P);c.push([R/g,T/g,P/g])}}for(let t=0;t<3;t+=1)E[t]=c[t][0],E[3+t]=c[t][1],E[6+t]=c[t][2];const y=[1,1,N(m)*N(E)<0?-1:1];for(let t=0;t<3;t+=1)for(let n=0;n<3;n+=1)u[t*3+n]=m[t*3]*y[0]*E[n*3]+m[t*3+1]*y[1]*E[n*3+1]+m[t*3+2]*y[2]*E[n*3+2];U.set(u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7],u[8]),s.quaternion.setFromRotationMatrix(C.setFromMatrix3(U));const j=V[0]*y[0]+V[1]*y[1]+V[2]*y[2],h=S&&l>0?j/l:1;s.scale=h,s.translation.copy(w).applyQuaternion(s.quaternion).multiplyScalar(-h).add(k);let x=0;for(let t=0;t<z;t+=1){_.set(o[t*3],o[t*3+1],o[t*3+2]).applyQuaternion(s.quaternion).multiplyScalar(h).add(s.translation);const n=_.x-e[t*3],a=_.y-e[t*3+1],p=_.z-e[t*3+2];x+=n*n+a*a+p*p}return s.rms=Math.sqrt(x/z),s};exports.solveSimilarity=I;

package/dist/similarityFit-Bbz-R8AY.js

@@ -0,0 +1,91 @@
+import * as H from "three";
+const k = new H.Vector3(), z = new H.Vector3(), G = new H.Matrix3(), J = new H.Matrix4(), j = new H.Vector3(), K = (s, a) => {
+  const o = s.slice();
+  a[0] = 1, a[1] = 0, a[2] = 0, a[3] = 0, a[4] = 1, a[5] = 0, a[6] = 0, a[7] = 0, a[8] = 1;
+  for (let g = 0; g < 12 && !(o[1] * o[1] + o[2] * o[2] + o[5] * o[5] < 1e-24); g += 1)
+    for (const [l, f] of [
+      [0, 1],
+      [0, 2],
+      [1, 2]
+    ]) {
+      const D = o[l * 3 + f];
+      if (Math.abs(D) < 1e-18) continue;
+      const V = o[l * 3 + l], h = (o[f * 3 + f] - V) / (2 * D), R = Math.sign(h || 1) / (Math.abs(h) + Math.sqrt(h * h + 1)), y = 1 / Math.sqrt(R * R + 1), w = R * y;
+      for (let t = 0; t < 3; t += 1) {
+        const n = o[t * 3 + l], r = o[t * 3 + f];
+        o[t * 3 + l] = y * n - w * r, o[t * 3 + f] = w * n + y * r;
+      }
+      for (let t = 0; t < 3; t += 1) {
+        const n = o[l * 3 + t], r = o[f * 3 + t];
+        o[l * 3 + t] = y * n - w * r, o[f * 3 + t] = w * n + y * r;
+      }
+      for (let t = 0; t < 3; t += 1) {
+        const n = a[t * 3 + l], r = a[t * 3 + f];
+        a[t * 3 + l] = y * n - w * r, a[t * 3 + f] = w * n + y * r;
+      }
+    }
+  return [o[0], o[4], o[8]];
+}, C = (s) => s[0] * (s[4] * s[8] - s[5] * s[7]) - s[1] * (s[3] * s[8] - s[5] * s[6]) + s[2] * (s[3] * s[7] - s[4] * s[6]), e = [0, 0, 0, 0, 0, 0, 0, 0, 0], I = [0, 0, 0, 0, 0, 0, 0, 0, 0], A = [0, 0, 0, 0, 0, 0, 0, 0, 0], S = [0, 0, 0, 0, 0, 0, 0, 0, 0], E = [0, 0, 0, 0, 0, 0, 0, 0, 0], x = [0, 0, 0, 0, 0, 0, 0, 0, 0], L = (s, a, o = {
+  scale: 1,
+  quaternion: new H.Quaternion(),
+  translation: new H.Vector3(),
+  rms: 0
+}, g = !0) => {
+  const m = Math.floor(Math.min(s.length, a.length) / 3);
+  if (m < 3) throw new Error("solveSimilarity: at least 3 points are required");
+  k.set(0, 0, 0), z.set(0, 0, 0);
+  for (let t = 0; t < m; t += 1)
+    k.x += s[t * 3], k.y += s[t * 3 + 1], k.z += s[t * 3 + 2], z.x += a[t * 3], z.y += a[t * 3 + 1], z.z += a[t * 3 + 2];
+  k.divideScalar(m), z.divideScalar(m), e.fill(0);
+  let l = 0;
+  for (let t = 0; t < m; t += 1) {
+    const n = s[t * 3] - k.x, r = s[t * 3 + 1] - k.y, p = s[t * 3 + 2] - k.z, u = a[t * 3] - z.x, q = a[t * 3 + 1] - z.y, M = a[t * 3 + 2] - z.z;
+    l += n * n + r * r + p * p, e[0] += n * u, e[1] += n * q, e[2] += n * M, e[3] += r * u, e[4] += r * q, e[5] += r * M, e[6] += p * u, e[7] += p * q, e[8] += p * M;
+  }
+  for (let t = 0; t < 3; t += 1)
+    for (let n = 0; n < 3; n += 1)
+      I[t * 3 + n] = e[t] * e[n] + e[3 + t] * e[3 + n] + e[6 + t] * e[6 + n];
+  const f = K(I, A), D = [0, 1, 2].sort((t, n) => f[n] - f[t]), V = [0, 0, 0], c = [];
+  for (let t = 0; t < 3; t += 1) {
+    const n = D[t], r = A[n], p = A[3 + n], u = A[6 + n];
+    S[t] = r, S[3 + t] = p, S[6 + t] = u;
+    let q = e[0] * r + e[1] * p + e[2] * u, M = e[3] * r + e[4] * p + e[5] * u, Q = e[6] * r + e[7] * p + e[8] * u;
+    if (V[t] = Math.sqrt(Math.max(f[n], 0)), t === 2) {
+      const i = c[0][1] * c[1][2] - c[0][2] * c[1][1], d = c[0][2] * c[1][0] - c[0][0] * c[1][2], F = c[0][0] * c[1][1] - c[0][1] * c[1][0], U = q * i + M * d + Q * F, b = Math.hypot(q, M, Q) > 1e-9 * Math.max(V[0], 1e-300) ? U < 0 ? -1 : 1 : C(S) < 0 ? -1 : 1;
+      c.push([b * i, b * d, b * F]);
+      continue;
+    }
+    for (const i of c) {
+      const d = q * i[0] + M * i[1] + Q * i[2];
+      q -= d * i[0], M -= d * i[1], Q -= d * i[2];
+    }
+    const T = Math.hypot(q, M, Q);
+    if (T > 1e-12)
+      c.push([q / T, M / T, Q / T]);
+    else if (t === 0)
+      c.push([1, 0, 0]);
+    else {
+      const i = Math.abs(c[0][0]) < 0.9 ? [1, 0, 0] : [0, 1, 0], d = i[0] * c[0][0] + i[1] * c[0][1] + i[2] * c[0][2], F = i[0] - d * c[0][0], U = i[1] - d * c[0][1], B = i[2] - d * c[0][2], b = Math.hypot(F, U, B);
+      c.push([F / b, U / b, B / b]);
+    }
+  }
+  for (let t = 0; t < 3; t += 1)
+    E[t] = c[t][0], E[3 + t] = c[t][1], E[6 + t] = c[t][2];
+  const h = [1, 1, C(S) * C(E) < 0 ? -1 : 1];
+  for (let t = 0; t < 3; t += 1)
+    for (let n = 0; n < 3; n += 1)
+      x[t * 3 + n] = S[t * 3] * h[0] * E[n * 3] + S[t * 3 + 1] * h[1] * E[n * 3 + 1] + S[t * 3 + 2] * h[2] * E[n * 3 + 2];
+  G.set(x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8]), o.quaternion.setFromRotationMatrix(J.setFromMatrix3(G));
+  const R = V[0] * h[0] + V[1] * h[1] + V[2] * h[2], y = g && l > 0 ? R / l : 1;
+  o.scale = y, o.translation.copy(k).applyQuaternion(o.quaternion).multiplyScalar(-y).add(z);
+  let w = 0;
+  for (let t = 0; t < m; t += 1) {
+    j.set(s[t * 3], s[t * 3 + 1], s[t * 3 + 2]).applyQuaternion(o.quaternion).multiplyScalar(y).add(o.translation);
+    const n = j.x - a[t * 3], r = j.y - a[t * 3 + 1], p = j.z - a[t * 3 + 2];
+    w += n * n + r * r + p * p;
+  }
+  return o.rms = Math.sqrt(w / m), o;
+};
+export {
+  L as s
+};

package/dist/spring/index.d.ts

@@ -0,0 +1,2 @@
+export { SPRING_DEFAULTS, SPRING_MAX_FRAME, SPRING_MAX_JUMP, SPRING_MAX_SUBSTEP, SPRING_SETTINGS_RANGES, SpringChain, SpringJoint, resolveSpringSettings, type SpringSettings, } from './spring';
+export { SPRING_SWING_LENGTH, SpringSwingDriver, insertSwingPivots, type SpringSwingOptions, type SwingPivot, } from './swing';

package/dist/spring/spring.d.ts

@@ -0,0 +1,69 @@
+import * as THREE from "three";
+/**
+ * Spring bones (pure): a mass that hangs from a pivot along a rest direction
+ * and swings when the pivot moves or turns, then settles. A `SpringChain`
+ * hangs masses one below another (a lock of hair, a tassel); jewellery uses
+ * one joint. Everything is in world space; the rest direction comes from the
+ * thing it hangs from (the head's or torso's own down), so it swings only
+ * from motion.
+ *
+ * Each mass is pulled toward its rest point (`pivot + rest × length`) by a
+ * spring of `frequency` and `damping` relative to how that point moves, then
+ * kept at `length` from its pivot and within `maxAngle` of rest. Frames are
+ * split into steps of at most `SPRING_MAX_SUBSTEP`, so the swing is the same
+ * at any frame rate.
+ */
+export type SpringSettings = {
+    /** Swings per second when let go (Hz): lower is slower and floppier. */
+    frequency: number;
+    /** 0..1: how fast a swing dies down (0: never; 1: no overshoot). */
+    damping: number;
+    /** The largest swing from rest, degrees. */
+    maxAngle: number;
+};
+/** Gentle, like real jewellery: swings with turns and nods, settles within about a second. */
+export declare const SPRING_DEFAULTS: Readonly<SpringSettings>;
+export declare const SPRING_SETTINGS_RANGES: {
+    readonly frequency: readonly [0.2, 10];
+    readonly damping: readonly [0, 1];
+    readonly maxAngle: readonly [1, 175];
+};
+/** Any partial settings → complete and clamped (non-finite values fall back to the defaults). */
+export declare const resolveSpringSettings: (input?: Partial<SpringSettings>) => SpringSettings;
+/** The longest physics step (s): longer frames are split. */
+export declare const SPRING_MAX_SUBSTEP: number;
+/** A frame longer than this (s), or a jump of the rest point by more than `SPRING_MAX_JUMP` lengths, snaps to rest. */
+export declare const SPRING_MAX_FRAME = 0.25;
+export declare const SPRING_MAX_JUMP = 20;
+/** One mass on a pivot. Call `step` once a frame; `reset` (or the first step) starts it at rest. */
+export declare class SpringJoint {
+    /** The mass, world space. */
+    readonly position: THREE.Vector3;
+    readonly velocity: THREE.Vector3;
+    private ready;
+    private readonly lastPivot;
+    private readonly lastRest;
+    private lastLength;
+    private readonly lastTarget;
+    /** Starts at rest below `pivot` (`rest` a unit direction, `length` in world units). */
+    reset(pivot: THREE.Vector3, rest: THREE.Vector3, length: number): void;
+    /**
+     * Moves the mass on by `dt` seconds, the pivot having gone from its last
+     * pose to `pivot` / `rest` / `length` (world). Writes the unit direction
+     * from the pivot to the mass into `out` and returns it.
+     */
+    step(pivot: THREE.Vector3, rest: THREE.Vector3, length: number, dt: number, settings: SpringSettings, out?: THREE.Vector3): THREE.Vector3;
+}
+/**
+ * Masses hung one below another: joint 0 from the root pivot, each next
+ * joint from the mass before it. `rests` and `lengths` per joint (world).
+ */
+export declare class SpringChain {
+    readonly joints: SpringJoint[];
+    private readonly pivot;
+    constructor(count: number);
+    /** Steps every joint; writes each joint's unit direction into `out` (one per joint). */
+    step(root: THREE.Vector3, rests: readonly THREE.Vector3[], lengths: readonly number[], dt: number, settings: SpringSettings, out: THREE.Vector3[]): THREE.Vector3[];
+    /** Every joint at rest, hanging from `root`. */
+    reset(root: THREE.Vector3, rests: readonly THREE.Vector3[], lengths: readonly number[]): void;
+}

package/dist/spring/swing.d.ts

@@ -0,0 +1,54 @@
+import { SpringSettings } from './spring';
+import * as THREE from "three";
+/**
+ * A swing on a scene object (no React): `inner` (a child of `outer`) turns
+ * about `outer`'s origin so whatever is in it hangs along `outer`'s own −Y
+ * and swings as `outer` moves and turns. Call `update` after the world
+ * matrices are up to date (the scene's before-render hook), so the swing
+ * follows the pose the object is drawn at.
+ */
+export type SpringSwingOptions = Partial<SpringSettings> & {
+    /** How far below the pivot the weight sits, in the pivot's own units (cm in a head or torso frame). */
+    length?: number;
+};
+/** The default weight distance (cm): a short drop earring or a pendant. */
+export declare const SPRING_SWING_LENGTH = 1.5;
+export declare class SpringSwingDriver {
+    readonly outer: THREE.Object3D;
+    readonly inner: THREE.Object3D;
+    private settings;
+    private length;
+    private readonly joint;
+    private lastTime;
+    private readonly pivot;
+    private readonly rest;
+    private readonly direction;
+    private readonly linear;
+    constructor(outer: THREE.Object3D, inner: THREE.Object3D, options?: SpringSwingOptions);
+    setOptions({ length, ...settings }: SpringSwingOptions): void;
+    /**
+     * One frame at `time` (s): steps the swing from `outer`'s current world
+     * pose and turns `inner`. While `outer` (or a parent) is hidden it rests
+     * and starts again at rest when shown. A second call at the same time
+     * changes nothing.
+     */
+    update(time: number): void;
+    /** Back to rest; the next update starts again from there. */
+    reset(): void;
+    private toRest;
+}
+/** A swing pivot inserted above a node: rotate `inner`, its contents swing about `outer`'s origin. */
+export type SwingPivot = {
+    node: THREE.Object3D;
+    outer: THREE.Group;
+    inner: THREE.Group;
+};
+/**
+ * Finds the nodes under `root` whose name contains one of `names`
+ * (case-insensitive; a matching node's own descendants are left alone) and
+ * puts a pivot above each, at the node's origin: an `outer` group in the
+ * node's place and an `inner` group holding the node. Turning `inner` swings
+ * the node about its origin (a pendant's bail). Changes `root` in place:
+ * call it on your own clone.
+ */
+export declare const insertSwingPivots: (root: THREE.Object3D, names: readonly string[]) => SwingPivot[];

package/dist/subjects/index.d.ts

@@ -0,0 +1,2 @@
+export type { XRSubjectAssociation, XRSubjectCandidate, XRSubjectMemory, XRSubjectPolicy, XRSubjectSelection, XRSubjectSelectionResult, } from './types';
+export { DEFAULT_SUBJECT_POLICY, EMPTY_SUBJECT_MEMORY, XR_MAX_SUBJECTS, associateSubjects, faceCandidates, jointCandidates, selectSubject, } from './select';

package/dist/subjects/select.d.ts

@@ -0,0 +1,62 @@
+import { TrackerPoint } from '../types/common';
+import { XRSubjectAssociation, XRSubjectCandidate, XRSubjectMemory, XRSubjectPolicy, XRSubjectSelectionResult } from './types';
+export declare const DEFAULT_SUBJECT_POLICY: XRSubjectPolicy;
+/**
+ * Maximum subjects each tracker can report, and whether the count is a
+ * request option. Face: `numFaces` (1 default, raise per consumer; the first
+ * acquirer wins). Hand: 2 (fixed). Gesture: 1. Body: 1. Holistic: 1 (single
+ * person by design). Segmentation has no subjects.
+ */
+export declare const XR_MAX_SUBJECTS: Readonly<{
+    face: {
+        max: number;
+        default: number;
+        option: "numFaces";
+    };
+    hand: {
+        max: number;
+        default: number;
+        option: null;
+    };
+    gesture: {
+        max: number;
+        default: number;
+        option: null;
+    };
+    body: {
+        max: number;
+        default: number;
+        option: null;
+    };
+    holistic: {
+        max: number;
+        default: number;
+        option: null;
+    };
+}>;
+export declare const EMPTY_SUBJECT_MEMORY: XRSubjectMemory;
+/**
+ * Pick one subject. Pure: feed `result.memory` back on the next frame for
+ * `sticky`. `null` index means nothing to select (the consumer should treat
+ * it as a dropout and apply its own hold).
+ */
+export declare const selectSubject: (candidates: XRSubjectCandidate[], policy?: XRSubjectPolicy, memory?: XRSubjectMemory) => XRSubjectSelectionResult;
+type Landmark = {
+    x: number;
+    y: number;
+};
+/** Candidates from face-mesh landmark arrays (feed space): centre and width of the bounds. */
+export declare const faceCandidates: (faces: ReadonlyArray<ReadonlyArray<Landmark>>) => XRSubjectCandidate[];
+/** Candidates from tracker-space joint lists (hands, bodies): centre and span, converted to feed space. */
+export declare const jointCandidates: (subjects: ReadonlyArray<{
+    coordinates?: ReadonlyArray<TrackerPoint>;
+    label?: string;
+}>) => XRSubjectCandidate[];
+/**
+ * Greedy nearest-centre matching between two trackers' subjects (face ↔
+ * body, hand ↔ body). Each subject is used once; pairs farther than
+ * `maxDistance` (feed units) are not associated. This is the SDK's whole
+ * association contract: spatial proximity in the same frame, no identity.
+ */
+export declare const associateSubjects: (primary: XRSubjectCandidate[], secondary: XRSubjectCandidate[], maxDistance?: number) => XRSubjectAssociation[];
+export {};

package/dist/subjects/types.d.ts

@@ -0,0 +1,55 @@
+import { FeedPoint } from '../coordinates/spaces';
+/**
+ * How one subject is picked from a tracker's result array.
+ *
+ * - `index`: the result-array position (`policy.index`, default 0). The
+ *   SDK's historical behaviour; the position is NOT a persistent identity.
+ * - `largest`: the biggest subject (closest to the camera).
+ * - `nearest-center`: the subject closest to the feed centre.
+ * - `leftmost` / `rightmost`: by feed x (viewer's left / right as shown in the preview).
+ * - `sticky`: the subject nearest to the previously selected one (within
+ *   `stickyRadius`), falling back to `fallback` when none is close enough.
+ *   This is the SDK's only re-identification: spatial continuity, nothing
+ *   learned about the person.
+ */
+export type XRSubjectSelection = "index" | "largest" | "nearest-center" | "leftmost" | "rightmost" | "sticky";
+export type XRSubjectPolicy = {
+    selection: XRSubjectSelection;
+    /** Result-array position for `index`. Default 0. */
+    index?: number;
+    /** Max feed distance (0..1 units) a `sticky` subject may move between frames. Default 0.2. */
+    stickyRadius?: number;
+    /** What `sticky` picks when nothing is within the radius (default `largest`). */
+    fallback?: Exclude<XRSubjectSelection, "sticky">;
+};
+/** A subject reduced to what selection needs: its feed-space centre and size. */
+export type XRSubjectCandidate = {
+    /** Result-array position. */
+    index: number;
+    /** Feed space (0..1, top-left origin). */
+    center: FeedPoint;
+    /** Width in feed units (bounds width for faces, span for hands / bodies). */
+    size: number;
+    /** Extra identity hint the selection may use (e.g. handedness). */
+    label?: string;
+};
+export type XRSubjectSelectionResult = {
+    /** Selected result-array position, or `null` when there is no candidate. */
+    index: number | null;
+    /** Which rule decided. */
+    reason: XRSubjectSelection | "none" | "sticky-fallback";
+    /** Carry to the next call for `sticky`. */
+    memory: XRSubjectMemory;
+};
+/** Where the selected subject was last seen (for `sticky`). */
+export type XRSubjectMemory = {
+    center: FeedPoint | null;
+    label?: string;
+};
+/** A pair of subjects matched across two trackers (face ↔ body, hand ↔ body…). */
+export type XRSubjectAssociation = {
+    primaryIndex: number;
+    secondaryIndex: number;
+    /** Feed-space distance between the matched centres. */
+    distance: number;
+};

package/dist/tracking-config/apply.d.ts

@@ -0,0 +1,57 @@
+import { XRProviderProps } from '../components/XRProvider';
+import { XRModel } from '../constants';
+import { XRCameraRequest } from '../types/compositor';
+import { XRTrackerKind, XRTrackingConfig } from './types';
+/** `perf`, `lifecycle` and `quality` for `<XRProvider>`. */
+export declare const toProviderProps: (config: XRTrackingConfig) => Pick<XRProviderProps, "perf" | "lifecycle" | "quality">;
+/** The webcam request for `setMediaSource` / `switchCamera`. */
+export declare const toCameraRequest: (config: XRTrackingConfig) => XRCameraRequest;
+type TrackerProps = {
+    face: {
+        numFaces: number;
+        targetFps?: number;
+        holdMs: number;
+        predictMs: number;
+        active: boolean;
+    };
+    hand: {
+        targetFps?: number;
+        active: boolean;
+    };
+    gesture: {
+        targetFps?: number;
+        active: boolean;
+    };
+    /** `<BodyTracker>` has no fps prop; its cap comes from `toModelOptions` / `perf.targetFps`. */
+    body: {
+        active: boolean;
+    };
+    holistic: {
+        targetFps?: number;
+        hands: XRTrackingConfig["trackers"]["holistic"]["hands"];
+        holdMs: number;
+        predictMs: number;
+        analysisMaxDimension: number;
+        outputFaceBlendshapes: boolean;
+        delegate: XRTrackingConfig["trackers"]["holistic"]["delegate"];
+        modelUrl?: string;
+        active: boolean;
+    };
+    segmentation: {
+        quality: XRTrackingConfig["trackers"]["segmentation"]["quality"];
+        active: boolean;
+    };
+    semanticSegmentation: {
+        preset: XRTrackingConfig["trackers"]["semanticSegmentation"]["preset"];
+        quality: XRTrackingConfig["trackers"]["semanticSegmentation"]["quality"];
+        modelUrl?: string;
+        active: boolean;
+    };
+};
+/** Props for one tracker component / hook from the config (`active` mirrors `enabled`). */
+export declare const toTrackerProps: <K extends XRTrackerKind>(config: XRTrackingConfig, kind: K) => TrackerProps[K];
+/** Acquire options for `useXRModel` / `registry.acquire` per model. */
+export declare const toModelOptions: (config: XRTrackingConfig, model: XRModel) => Record<string, unknown>;
+/** The models the config enables, for capability probes and preloading. */
+export declare const enabledModels: (config: XRTrackingConfig) => XRModel[];
+export {};

package/dist/tracking-config/index.d.ts

@@ -0,0 +1,7 @@
+export type { XRTrackerKind, XRTrackingConfig, XRTrackingConfigInput, XRTrackingConfigParseResult, } from './types';
+export { DEFAULT_TRACKING_CONFIG, TRACKER_KINDS, TRACKING_CONFIG_VERSION, mergeTrackingConfig, parseTrackingConfig, resolveTrackingConfig, serializeTrackingConfig, } from './resolve';
+export { enabledModels, toCameraRequest, toModelOptions, toProviderProps, toTrackerProps, } from './apply';
+export { TRACKING_CONFIG_STORAGE_KEY, clearTrackingConfig, loadTrackingConfig, saveTrackingConfig, } from './storage';
+export type { TrackingConfigStorage } from './storage';
+export { useXRTrackingConfig } from './useXRTrackingConfig';
+export type { UseXRTrackingConfigOptions, UseXRTrackingConfigResult } from './useXRTrackingConfig';

package/dist/tracking-config/resolve.d.ts

@@ -0,0 +1,25 @@
+import { XRTrackerKind, XRTrackingConfig, XRTrackingConfigInput, XRTrackingConfigParseResult } from './types';
+export declare const TRACKING_CONFIG_VERSION: 1;
+export declare const DEFAULT_TRACKING_CONFIG: XRTrackingConfig;
+/**
+ * Validate a partial config over `base` (the defaults unless given). Every
+ * leaf is type-checked and clamped; invalid values keep the base value and
+ * add a warning. Returns a new object; never throws.
+ */
+export declare const resolveTrackingConfig: (input?: XRTrackingConfigInput, base?: XRTrackingConfig, warnings?: string[]) => XRTrackingConfig;
+/** Apply a patch over a resolved config (stamps `updatedAt`). */
+export declare const mergeTrackingConfig: (current: XRTrackingConfig, patch: XRTrackingConfigInput, now?: number) => XRTrackingConfig;
+/**
+ * Serialize for storage or transport. The config holds no runtime values by
+ * construction; this strips anything a caller may have attached and emits
+ * stable key order.
+ */
+export declare const serializeTrackingConfig: (config: XRTrackingConfig) => string;
+/**
+ * Parse a stored document of any version. Unknown or older versions are
+ * migrated field-by-field onto the current defaults (fields that still
+ * exist keep their values; the rest default) with `migrated: true`;
+ * corrupt input yields the defaults with a warning. Never throws.
+ */
+export declare const parseTrackingConfig: (raw: string | unknown) => XRTrackingConfigParseResult;
+export declare const TRACKER_KINDS: XRTrackerKind[];

package/dist/tracking-config/storage.d.ts

@@ -0,0 +1,8 @@
+import { XRTrackingConfig, XRTrackingConfigParseResult } from './types';
+export declare const TRACKING_CONFIG_STORAGE_KEY = "vincentt.xr.tracking-config";
+export type TrackingConfigStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+/** Read and migrate a stored config; `null` when nothing is stored or storage is unavailable. */
+export declare const loadTrackingConfig: (key?: string, storage?: TrackingConfigStorage | null) => XRTrackingConfigParseResult | null;
+/** Persist (serialized, runtime-free). Returns `false` when storage is unavailable or full. */
+export declare const saveTrackingConfig: (config: XRTrackingConfig, key?: string, storage?: TrackingConfigStorage | null) => boolean;
+export declare const clearTrackingConfig: (key?: string, storage?: TrackingConfigStorage | null) => void;