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

package/dist/measures-9dQPdw96.js

@@ -0,0 +1,154 @@
+var y = Object.defineProperty;
+var S = (t, s, e) => s in t ? y(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
+var f = (t, s, e) => S(t, typeof s != "symbol" ? s + "" : s, e);
+import { useCallback as B } from "react";
+import { p as M, u as v } from "./getFaceInfo-BkZfaQs-.js";
+const F = ({
+  node: t,
+  enabled: s,
+  selectedSource: e,
+  throttleMs: i = 16,
+  holdMs: r = 250,
+  onFrame: l
+}) => {
+  const c = B(
+    (a) => M(a.faceLandmarks ?? []),
+    [e]
+  );
+  return v({ enabled: s, holdMs: r, node: t, onFrame: l, prepare: c, throttleMs: i });
+}, u = (t) => Number.isFinite(t) ? Math.max(0, Math.min(1, t)) : 0, m = (t, s) => Math.hypot(t.x - s.x, t.y - s.y), n = {
+  wrist: 0,
+  thumbTip: 4,
+  indexBase: 5,
+  indexTip: 8,
+  middleBase: 9,
+  middleTip: 12,
+  ringBase: 13,
+  ringTip: 16,
+  pinkyBase: 17,
+  pinkyTip: 20
+}, d = [
+  [n.indexBase, n.indexTip],
+  [n.middleBase, n.middleTip],
+  [n.ringBase, n.ringTip],
+  [n.pinkyBase, n.pinkyTip]
+], h = (t) => t !== void 0 && t.length >= 21, g = (t) => h(t) ? m(t[n.wrist], t[n.middleBase]) : 0, O = (t) => {
+  if (!h(t)) return 0;
+  const s = g(t);
+  if (s <= 0) return 0;
+  const e = m(t[n.thumbTip], t[n.indexTip]) / s;
+  return u(1 - (e - 0.15) / 0.85);
+}, x = (t, s, e) => {
+  const i = t[n.wrist], r = m(t[s], i);
+  if (r <= 0) return 0;
+  const l = m(t[e], i) / r;
+  return u((1.6 - l) / 0.6);
+}, R = (t, s = [0, 0, 0, 0]) => {
+  for (let e = 0; e < d.length; e += 1) {
+    const [i, r] = d[e];
+    s[e] = 1 - x(t, i, r);
+  }
+  return s;
+}, b = (t) => {
+  const s = g(t);
+  if (s <= 0) return 0;
+  const e = m(t[n.thumbTip], t[n.indexBase]) / s;
+  return u((e - 0.45) / 0.5);
+}, p = (t) => {
+  const s = g(t);
+  if (s <= 0) return 0;
+  const e = (t[n.thumbTip].y - t[n.indexBase].y) / s;
+  return Math.max(-1, Math.min(1, e / 0.6));
+}, V = (t, s) => {
+  if (!h(t)) return 0;
+  const e = R(t);
+  let i = 1;
+  for (let r = 0; r < 4; r += 1) {
+    const l = s.fingers[r];
+    l !== null && (i = Math.min(i, l ? e[r] : 1 - e[r]));
+  }
+  if (s.thumb !== void 0 && s.thumb !== null) {
+    const r = b(t);
+    i = Math.min(i, s.thumb ? r : 1 - r);
+  }
+  return i;
+}, N = (t, s) => {
+  if (!h(t)) return 0;
+  const e = V(t, { fingers: [!1, !1, !1, !1] }), i = u(s === "up" ? p(t) : -p(t));
+  return Math.min(e, b(t), i);
+}, k = (t) => {
+  if (!h(t)) return 0;
+  let s = 0;
+  for (const [e, i] of d) s += x(t, e, i);
+  return s / d.length;
+}, z = (t) => h(t) ? 1 - k(t) : 0, q = (t) => h(t) ? u((t[n.wrist].y + 1) / 2) : 0, o = {
+  leftShoulder: 11,
+  rightShoulder: 12,
+  leftElbow: 13,
+  rightElbow: 14,
+  leftWrist: 15,
+  rightWrist: 16,
+  leftHip: 23,
+  rightHip: 24
+}, T = (t) => t !== void 0 && t.length >= 33, w = (t) => m(t[o.leftShoulder], t[o.rightShoulder]), A = (t, s) => {
+  if (!T(t)) return 0;
+  const e = w(t);
+  if (e <= 0) return 0;
+  const i = t[s === "left" ? o.leftWrist : o.rightWrist], r = t[s === "left" ? o.leftShoulder : o.rightShoulder];
+  return u((i.y - r.y) / e);
+}, C = (t) => {
+  if (!T(t)) return 0;
+  const s = w(t);
+  if (s <= 0) return 0;
+  let e = 1;
+  for (const i of ["left", "right"]) {
+    const r = t[i === "left" ? o.leftWrist : o.rightWrist], l = t[i === "left" ? o.leftShoulder : o.rightShoulder], c = u(1 - Math.abs(r.y - l.y) / (s * 0.5)), a = i === "left" ? r.x - l.x : l.x - r.x, E = u(a / s);
+    e = Math.min(e, c, E);
+  }
+  return e;
+};
+class D {
+  constructor(s) {
+    f(this, "reversals", []);
+    f(this, "lastExtremum", null);
+    f(this, "lastValue", null);
+    f(this, "direction", 0);
+    this.options = s;
+  }
+  reset() {
+    this.reversals = [], this.lastExtremum = null, this.lastValue = null, this.direction = 0;
+  }
+  /** Feed one sample; returns the oscillation progress 0..1. */
+  push(s, e) {
+    const { minAmplitude: i, requiredReversals: r, windowMs: l } = this.options;
+    if (this.lastExtremum === null || this.lastValue === null)
+      return this.lastExtremum = s, this.lastValue = s, this.progress(e);
+    const c = s - this.lastValue, a = c > 0 ? 1 : c < 0 ? -1 : 0;
+    for (a !== 0 && (this.direction === 0 ? Math.abs(s - this.lastExtremum) >= i && (this.direction = a) : a !== this.direction ? Math.abs(this.lastValue - this.lastExtremum) >= i && (this.reversals.push(e), this.lastExtremum = this.lastValue, this.direction = a) : this.direction > 0 && s > this.lastExtremum || this.direction < 0 && s < this.lastExtremum), this.lastValue = s; this.reversals.length > 0 && e - this.reversals[0] > l; )
+      this.reversals.shift();
+    return this.progress(e);
+  }
+  progress(s) {
+    const { requiredReversals: e, windowMs: i } = this.options;
+    for (; this.reversals.length > 0 && s - this.reversals[0] > i; )
+      this.reversals.shift();
+    return u(this.reversals.length / e);
+  }
+}
+export {
+  n as H,
+  D as O,
+  o as P,
+  A as a,
+  N as b,
+  V as c,
+  q as d,
+  z as e,
+  k as f,
+  O as g,
+  R as h,
+  b as i,
+  C as m,
+  p as t,
+  F as u
+};

package/dist/measures-KfJzpvod.cjs

@@ -0,0 +1 @@
+"use strict";var P=Object.defineProperty;var R=(t,e,s)=>e in t?P(t,e,{enumerable:!0,configurable:!0,writable:!0,value:s}):t[e]=s;var f=(t,e,s)=>R(t,typeof e!="symbol"?e+"":e,s);const v=require("react"),b=require("./getFaceInfo-ahPxQFGu.cjs"),O=({node:t,enabled:e,selectedSource:s,throttleMs:i=16,holdMs:r=250,onFrame:l})=>{const h=v.useCallback(a=>b.prepareCalibrationFaceResults(a.faceLandmarks??[]),[s]);return b.useFaceResultReader({enabled:e,holdMs:r,node:t,onFrame:l,prepare:h,throttleMs:i})},o=t=>Number.isFinite(t)?Math.max(0,Math.min(1,t)):0,m=(t,e)=>Math.hypot(t.x-e.x,t.y-e.y),n={wrist:0,thumbTip:4,indexBase:5,indexTip:8,middleBase:9,middleTip:12,ringBase:13,ringTip:16,pinkyBase:17,pinkyTip:20},d=[[n.indexBase,n.indexTip],[n.middleBase,n.middleTip],[n.ringBase,n.ringTip],[n.pinkyBase,n.pinkyTip]],c=t=>t!==void 0&&t.length>=21,x=t=>c(t)?m(t[n.wrist],t[n.middleBase]):0,F=t=>{if(!c(t))return 0;const e=x(t);if(e<=0)return 0;const s=m(t[n.thumbTip],t[n.indexTip])/e;return o(1-(s-.15)/.85)},T=(t,e,s)=>{const i=t[n.wrist],r=m(t[e],i);if(r<=0)return 0;const l=m(t[s],i)/r;return o((1.6-l)/.6)},E=(t,e=[0,0,0,0])=>{for(let s=0;s<d.length;s+=1){const[i,r]=d[s];e[s]=1-T(t,i,r)}return e},p=t=>{const e=x(t);if(e<=0)return 0;const s=m(t[n.thumbTip],t[n.indexBase])/e;return o((s-.45)/.5)},g=t=>{const e=x(t);if(e<=0)return 0;const s=(t[n.thumbTip].y-t[n.indexBase].y)/e;return Math.max(-1,Math.min(1,s/.6))},S=(t,e)=>{if(!c(t))return 0;const s=E(t);let i=1;for(let r=0;r<4;r+=1){const l=e.fingers[r];l!==null&&(i=Math.min(i,l?s[r]:1-s[r]))}if(e.thumb!==void 0&&e.thumb!==null){const r=p(t);i=Math.min(i,e.thumb?r:1-r)}return i},H=(t,e)=>{if(!c(t))return 0;const s=S(t,{fingers:[!1,!1,!1,!1]}),i=o(e==="up"?g(t):-g(t));return Math.min(s,p(t),i)},w=t=>{if(!c(t))return 0;let e=0;for(const[s,i]of d)e+=T(t,s,i);return e/d.length},k=t=>c(t)?1-w(t):0,N=t=>c(t)?o((t[n.wrist].y+1)/2):0,u={leftShoulder:11,rightShoulder:12,leftElbow:13,rightElbow:14,leftWrist:15,rightWrist:16,leftHip:23,rightHip:24},y=t=>t!==void 0&&t.length>=33,B=t=>m(t[u.leftShoulder],t[u.rightShoulder]),V=(t,e)=>{if(!y(t))return 0;const s=B(t);if(s<=0)return 0;const i=t[e==="left"?u.leftWrist:u.rightWrist],r=t[e==="left"?u.leftShoulder:u.rightShoulder];return o((i.y-r.y)/s)},W=t=>{if(!y(t))return 0;const e=B(t);if(e<=0)return 0;let s=1;for(const i of["left","right"]){const r=t[i==="left"?u.leftWrist:u.rightWrist],l=t[i==="left"?u.leftShoulder:u.rightShoulder],h=o(1-Math.abs(r.y-l.y)/(e*.5)),a=i==="left"?r.x-l.x:l.x-r.x,M=o(a/e);s=Math.min(s,h,M)}return s};class I{constructor(e){f(this,"reversals",[]);f(this,"lastExtremum",null);f(this,"lastValue",null);f(this,"direction",0);this.options=e}reset(){this.reversals=[],this.lastExtremum=null,this.lastValue=null,this.direction=0}push(e,s){const{minAmplitude:i,requiredReversals:r,windowMs:l}=this.options;if(this.lastExtremum===null||this.lastValue===null)return this.lastExtremum=e,this.lastValue=e,this.progress(s);const h=e-this.lastValue,a=h>0?1:h<0?-1:0;for(a!==0&&(this.direction===0?Math.abs(e-this.lastExtremum)>=i&&(this.direction=a):a!==this.direction?Math.abs(this.lastValue-this.lastExtremum)>=i&&(this.reversals.push(s),this.lastExtremum=this.lastValue,this.direction=a):this.direction>0&&e>this.lastExtremum||this.direction<0&&e<this.lastExtremum),this.lastValue=e;this.reversals.length>0&&s-this.reversals[0]>l;)this.reversals.shift();return this.progress(s)}progress(e){const{requiredReversals:s,windowMs:i}=this.options;for(;this.reversals.length>0&&e-this.reversals[0]>i;)this.reversals.shift();return o(this.reversals.length/s)}}exports.HAND_JOINTS=n;exports.OscillationTracker=I;exports.POSE_JOINTS=u;exports.fingerExtensions=E;exports.measureArmRaise=V;exports.measureFingerPattern=S;exports.measureGrab=w;exports.measureHandHeight=N;exports.measureOpenPalm=k;exports.measurePinch=F;exports.measureTPose=W;exports.measureThumb=H;exports.thumbDirection=g;exports.thumbExtension=p;exports.useFaceResults=O;

package/dist/models/Base/index.d.ts

@@ -1,11 +1,60 @@
 import { RunModelParams } from '../../types';
 import { PerformanceData } from '../../types/common';
+/**
+ * Per-model health read by `useXRDiagnostics`. Every field is a current value
+ * (not an event); `null` means "not measured yet" or "not applicable".
+ */
+export type XRModelDiagnostics = {
+    /** Duration of the last inference in milliseconds. */
+    inferenceMs: number | null;
+    /** Inferences per second over the last ~1 s window. */
+    inferenceFps: number;
+    /** Total inferences since `run()`. */
+    inferences: number;
+    /**
+     * RAF ticks the model saw but did not analyse (throttled by `targetFps`, or
+     * skipped while busy). A high value next to a low `inferenceFps` means the
+     * cap is doing its job; a high value with no cap means the device is slow.
+     */
+    skippedFrames: number;
+    /** Subjects detected in the last inference (faces, hands, bodies; `null` when not applicable). */
+    detections: number | null;
+    /** Detector confidence of the primary subject, 0..1 (`null` when the model reports none). */
+    confidence: number | null;
+    /** `error` when the last inference threw; models without inline status report `"ready"`. */
+    status: "ready" | "error";
+    error: Error | null;
+    paused: boolean;
+    disposed: boolean;
+};
 export declare class BaseXRModel {
     protected disposed: boolean;
     protected paused: boolean;
     protected rafId: number | null;
+    private statInferenceMs;
+    private statInferences;
+    private statWindowStart;
+    private statWindowCount;
+    private statFps;
+    private statSkipped;
+    private statDetections;
+    private statConfidence;
+    private statStatus;
+    private statError;
+    /** Record one completed inference that started at `startMs` (`performance.now()`). */
+    protected recordInference(startMs: number, endMs?: number): number;
+    /** Record what the last inference found (subjects and the primary confidence). */
+    protected recordDetections(count: number | null, confidence?: number | null): void;
+    /** Record an inference failure (or clear it with `null`). */
+    protected recordInferenceError(error: Error | null): void;
+    /** Current health snapshot. Allocates a small object; sample it at UI rate, not per frame. */
+    getDiagnostics(): XRModelDiagnostics;
     protected targetFrameIntervalMs: number;
     protected lastInferenceMs: number;
+    /** Analysis-resolution multiplier (0.25..1) from the quality tier; subclasses read it where they downscale. */
+    protected analysisScale: number;
+    /** Clamp and store the analysis scale; subclasses with a downscaler forward it. */
+    protected setAnalysisScale(scale: number | undefined): void;
     /** Set the per-frame inference cap. fps <= 0 (or undefined) → uncapped. */
     protected setTargetFps(fps: number | undefined): void;
     /**

package/dist/models/Body/index.d.ts

@@ -16,7 +16,7 @@ export declare class BodyTrackingModel extends BaseXRModel {
     dispose(): void;
     private getLandmarks2D;
     initialize(options?: BodyModelOptions): Promise<void>;
-    run({ sourceCanvas, targetFps }: RunModelParams): Promise<void>;
+    run({ sourceCanvas, targetFps, analysisScale }: RunModelParams): Promise<void>;
     getModelNode(): XRModelNodeBodyTracking;
     getPerformanceData(): Promise<PerformanceData>;
 }

package/dist/models/Face/index.d.ts

@@ -30,7 +30,7 @@ export declare class FaceTrackingModel extends BaseXRModel {
     private getDetectionResults;
     private getRawFaceTrackingData;
     initialize(options?: FaceModelOptions): Promise<void>;
-    run({ sourceCanvas, getSource, targetFps }: RunModelParams): Promise<void>;
+    run({ sourceCanvas, getSource, targetFps, analysisScale, }: RunModelParams): Promise<void>;
     getModelNode(): XRModelNodeFaceTracking;
     getPerformanceData(): Promise<PerformanceData>;
 }

package/dist/models/Hand/GestureTracking.d.ts

@@ -15,7 +15,7 @@ export declare class GestureTrackingModel extends BaseXRModel {
     resume(): void;
     dispose(): void;
     initialize(): Promise<void>;
-    run({ sourceCanvas, targetFps }: RunModelParams): Promise<void>;
+    run({ sourceCanvas, targetFps, analysisScale }: RunModelParams): Promise<void>;
     getModelNode(): XRModelNodeGestureTracking;
     getPerformanceData(): Promise<PerformanceData>;
 }

package/dist/models/Hand/HandTracking.d.ts

@@ -17,7 +17,7 @@ export declare class HandTrackingModel extends BaseXRModel {
     resume(): void;
     dispose(): void;
     initialize(): Promise<void>;
-    run({ sourceCanvas, targetFps }: RunModelParams): Promise<void>;
+    run({ sourceCanvas, targetFps, analysisScale }: RunModelParams): Promise<void>;
     getModelNode(): XRModelNodeHandTracking;
     getPerformanceData(): Promise<PerformanceData>;
 }

package/dist/models/Holistic/index.d.ts

@@ -0,0 +1,49 @@
+import { RunModelParams } from '../../types';
+import { PerformanceData } from '../../types/common';
+import { HolisticModelOptions } from '../../types/holistic';
+import { XRModelNodeHolisticTracking } from '../../types/nodes';
+import { BaseXRModel } from '../Base';
+export declare class HolisticTrackingModel extends BaseXRModel {
+    private landmarker;
+    private status;
+    private error;
+    private processingTime;
+    private sourceCanvas;
+    private getSource;
+    private downscaler;
+    private raw;
+    private delegatePolicy;
+    private delegate;
+    /** Kept so the graph can be rebuilt on another delegate without refetching. */
+    private vision;
+    private modelBuffer;
+    private graphOptions;
+    private rebuilding;
+    private fallbackAttempted;
+    private readonly result;
+    private readonly builder;
+    private readonly node;
+    constructor();
+    private setRuntimeOptions;
+    initialize(options?: HolisticModelOptions): Promise<void>;
+    private createLandmarker;
+    /**
+     * The GPU graph can fail on its first run (the face-blendshape stage has no
+     * WebGL kernel for one of its ops). Rebuild on the CPU once, keep the RAF
+     * loop alive meanwhile, and run one detection right away so static sources
+     * (which pulse models once) still get a result.
+     */
+    private fallbackToCpu;
+    /** One detect + publish outside the loop (used after a delegate rebuild). */
+    private detectOnce;
+    private detect;
+    /** The session mirrors only the webcam feed (an unknown kind is treated as webcam). */
+    private isMirrored;
+    run({ sourceCanvas, getSource, targetFps, analysisScale, }: RunModelParams): Promise<void>;
+    private process;
+    resume(): void;
+    dispose(): void;
+    getModelNode(): XRModelNodeHolisticTracking;
+    getPerformanceData(): Promise<PerformanceData>;
+}
+export { DEFAULT_HOLISTIC_ANALYSIS_MAX_DIMENSION, DEFAULT_HOLISTIC_HOLD_MS, DEFAULT_HOLISTIC_MODEL_URL, DEFAULT_HOLISTIC_PREDICT_MS, HolisticResultBuilder, createHolisticResult, resolveHolisticRuntimeOptions, } from './result';

package/dist/models/Holistic/result.d.ts

@@ -0,0 +1,68 @@
+import { HolisticLandmarkerResult } from '@mediapipe/tasks-vision';
+import { TrackerPoint } from '../../types/common';
+import { HolisticResult, HolisticRuntimeOptions } from '../../types/holistic';
+/** MediaPipe's published holistic landmarker; the SDK CDN copy is not published yet. */
+export declare const DEFAULT_HOLISTIC_MODEL_URL = "https://storage.googleapis.com/mediapipe-models/holistic_landmarker/holistic_landmarker/float16/latest/holistic_landmarker.task";
+export declare const DEFAULT_HOLISTIC_HOLD_MS = 250;
+export declare const DEFAULT_HOLISTIC_PREDICT_MS = 0;
+/**
+ * Pose needs a full-body subject at distance resolved well enough to detect,
+ * so the cap matches `BodyTrackingModel` (768) rather than Hand/Face (512).
+ */
+export declare const DEFAULT_HOLISTIC_ANALYSIS_MAX_DIMENSION = 768;
+export declare const resolveHolisticRuntimeOptions: (options?: HolisticRuntimeOptions) => Required<HolisticRuntimeOptions>;
+export declare const createHolisticResult: () => HolisticResult;
+type Point3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+/**
+ * MediaPipe Pose index with left and right swapped: 0 (nose) stays, then the
+ * 16 left/right pairs (eyes 1–3/4–6, ears 7/8, mouth 9/10, shoulders 11/12,
+ * elbows 13/14, wrists 15/16, pinkies 17/18, indexes 19/20, thumbs 21/22,
+ * hips 23/24, knees 25/26, ankles 27/28, heels 29/30, foot indexes 31/32).
+ */
+export declare const MIRRORED_POSE_INDEX: readonly number[];
+/**
+ * Converts raw MediaPipe holistic results into the SDK's unified
+ * `HolisticResult`, bridging dropouts per stream with `FaceTrackMemory` (the
+ * SDK's single hold/predict mechanism). Output arrays and objects are reused
+ * frame-over-frame; the published result is mutated in place.
+ */
+export declare class HolisticResultBuilder {
+    private options;
+    private readonly faceMemory;
+    private readonly leftHandMemory;
+    private readonly rightHandMemory;
+    private readonly poseMemory;
+    private readonly face;
+    private readonly leftHand;
+    private readonly rightHand;
+    private readonly poseScratch;
+    private readonly poseWorldScratch;
+    private readonly pose;
+    constructor(options?: HolisticRuntimeOptions);
+    getOptions(): Required<HolisticRuntimeOptions>;
+    setOptions(options?: HolisticRuntimeOptions): void;
+    reset(): void;
+    private memories;
+    /**
+     * Publish `raw` (or a miss when `undefined`) into `result` at `nowMs`.
+     *
+     * `mirrored` says the analysed frame is a mirror of the person (the
+     * session's webcam feed). Pose left/right follow the image, and holistic
+     * assigns hands from the pose, so on a mirrored frame MediaPipe's "left"
+     * is the person's right. Swap both the hands and the pose's left/right
+     * landmarks so the whole result is anatomical and self-consistent
+     * (`leftHand` and pose wrist 15 are the same physical hand), matching the
+     * convention `HandTracker` reports on that feed.
+     */
+    update(raw: HolisticLandmarkerResult | undefined, nowMs: number, result: HolisticResult, mirrored?: boolean): HolisticResult;
+    private updateFace;
+    private updateHand;
+    private updatePose;
+}
+/** Convenience for tests and custom consumers: a single-stream TrackerPoint copy. */
+export declare const toTrackerPoints: (landmarks: ReadonlyArray<Point3>) => TrackerPoint[];
+export {};

package/dist/models/SemanticSegmentation/index.d.ts

@@ -0,0 +1,31 @@
+import { PerformanceData, RunModelParams } from '../../types';
+import { XRModelNodeSemanticSegmentation } from '../../types/nodes';
+import { SemanticSegmentationModelOptions } from '../../types/segmentation';
+import { BaseXRModel } from '../Base';
+/**
+ * Generic MediaPipe category segmenter publishing a `SemanticMask` in feed
+ * space. The first acquirer picks the preset (hair or multiclass) and the
+ * model asset; the mask object is stable and mutated in place, with `version`
+ * bumped on every inference.
+ */
+export declare class SemanticSegmentationModel extends BaseXRModel {
+    private segmenter;
+    private preset;
+    private quality;
+    private status;
+    private error;
+    private processingTime;
+    private sourceCanvas;
+    private processCanvas;
+    private isProcessing;
+    private readonly mask;
+    private readonly node;
+    constructor();
+    initialize(options?: SemanticSegmentationModelOptions): Promise<void>;
+    run({ sourceCanvas, targetFps }: RunModelParams): Promise<void>;
+    private process;
+    resume(): void;
+    getModelNode(): XRModelNodeSemanticSegmentation;
+    getPerformanceData(): Promise<PerformanceData>;
+    dispose(): void;
+}

package/dist/models/SemanticSegmentation/presets.d.ts

@@ -0,0 +1,28 @@
+import { SemanticSegmentationPreset } from '../../types/segmentation';
+export type SemanticSegmentationPresetSpec = {
+    /** Class labels in model index order; index 0 is `bg`. */
+    labels: readonly string[];
+    /**
+     * Model asset path on the SDK CDN. Its hash is already pinned in the
+     * integrity manifest; once the file is uploaded there, point `defaultUrl`
+     * at it.
+     */
+    assetPath: string;
+    /**
+     * Where the model loads from by default: MediaPipe's published file, whose
+     * bytes are pinned in the integrity manifest, so the default is verified
+     * (a republished file fails loudly with an SRI mismatch rather than
+     * silently changing behaviour).
+     */
+    defaultUrl: string;
+    /**
+     * How a category-mask byte maps to a class index. The hair and multiclass
+     * segmenters emit the class index itself (measured: hair reads 0 / 1). The
+     * SDK's portrait selfie segmenter is the odd one out and emits 255 for
+     * background / 0 for person; `usePersonMask` handles that separately.
+     */
+    decode: (value: number) => number;
+};
+export declare const SEMANTIC_SEGMENTATION_PRESET_SPECS: Record<SemanticSegmentationPreset, SemanticSegmentationPresetSpec>;
+/** Decode a MediaPipe category mask into class indices, resizing `out` when needed. */
+export declare const decodeCategoryMask: (raw: Uint8Array, decode: (value: number) => number, out: Uint8Array) => Uint8Array;

package/dist/models/index.d.ts

@@ -1,5 +1,7 @@
 export { BodyTrackingModel } from './Body';
 export { FaceTrackingModel } from './Face';
 export { GestureTrackingModel } from './Hand/GestureTracking';
+export { HolisticTrackingModel } from './Holistic';
 export { HandTrackingModel } from './Hand/HandTracking';
 export { BackgroundSegmentationModel } from './Segmentation';
+export { SemanticSegmentationModel } from './SemanticSegmentation';

package/dist/product/ProductDimensions.d.ts

@@ -0,0 +1,16 @@
+import { CSSProperties } from 'react';
+import { DimensionLine, ProductDimensions as Dimensions } from './details';
+export type ProductDimensionsProps = {
+    dimensions: Dimensions | null;
+    unit?: "metric" | "imperial";
+    /** Which axes to label. Default all three. */
+    axes?: Array<DimensionLine["axis"]>;
+    style?: CSSProperties;
+};
+export declare const DIMENSION_SLOT_PREFIX = "hotspot-__dim-";
+/**
+ * True-size labels on the model's bounding box (width / height / depth),
+ * anchored as hotspots so they track the model. Child of `<ProductViewer>`.
+ * Pair with `scale="fixed"` so AR shows the same size.
+ */
+export declare const ProductDimensions: ({ dimensions, unit, axes, style, }: ProductDimensionsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/product/ProductHotspot.d.ts

@@ -0,0 +1,16 @@
+import { CSSProperties, ReactNode } from 'react';
+import { ProductHotspotData } from './details';
+export type ProductHotspotProps = {
+    hotspot: ProductHotspotData;
+    /** Custom content; default a dot with the label. */
+    children?: ReactNode;
+    onClick?: (hotspot: ProductHotspotData) => void;
+    style?: CSSProperties;
+    className?: string;
+};
+/**
+ * A surface-anchored callout. Must be a child of `<ProductViewer>`: model-viewer
+ * slots it as `hotspot-{id}` and keeps it over `position` as the camera
+ * orbits, fading it when the surface faces away.
+ */
+export declare const ProductHotspot: ({ hotspot, children, onClick, style, className, }: ProductHotspotProps) => import("react/jsx-runtime").JSX.Element;

package/dist/product/ProductViewer.d.ts

@@ -0,0 +1,9 @@
+import { ProductViewerElement, ProductViewerProps } from './types';
+/**
+ * Surface-placement product viewer: a typed React wrapper over Google's
+ * `<model-viewer>`, loaded lazily. Renders the GLB with camera controls and
+ * hands off to WebXR, Scene Viewer or Quick Look from a user gesture. This
+ * is not the SDK's camera session; see `useProductAr` for the camera
+ * handoff when both exist on one page.
+ */
+export declare const ProductViewer: import('react').ForwardRefExoticComponent<ProductViewerProps & import('react').RefAttributes<ProductViewerElement | null>>;

package/dist/product/details.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Pure helpers for product details: variants, hotspots and dimensions.
+ * model-viewer expresses positions as "x y z" strings in model metres; the
+ * SDK keeps them as numeric tuples so they are serializable and testable.
+ */
+export type Vec3 = [number, number, number];
+/** A surface-anchored annotation, serializable authoring data. */
+export type ProductHotspotData = {
+    /** Unique within the product; becomes `slot="hotspot-{id}"`. */
+    id: string;
+    /** Model-space position in metres. */
+    position: Vec3;
+    /** Surface normal at the position (unit vector). */
+    normal: Vec3;
+    /** Short label shown in the callout. */
+    label?: string;
+    /** Longer text, free-form. */
+    description?: string;
+};
+export type ProductDimensions = {
+    /** Size along x / y / z in metres. */
+    size: Vec3;
+    center: Vec3;
+};
+export declare const formatVec3: (v: Vec3, digits?: number) => string;
+export declare const parseVec3: (text: string) => Vec3 | null;
+/** `data-position` / `data-normal` attribute pair for a hotspot. */
+export declare const hotspotAttributes: (hotspot: ProductHotspotData) => {
+    slot: string;
+    "data-position": string;
+    "data-normal": string;
+};
+/** A stable id from a label (or a counter when the label is empty / taken). */
+export declare const nextHotspotId: (existing: ReadonlyArray<ProductHotspotData>, label?: string) => string;
+/** Validate a hotspot list from storage / import; invalid entries are dropped. */
+export declare const parseHotspots: (raw: unknown) => ProductHotspotData[];
+export declare const serializeHotspots: (hotspots: ReadonlyArray<ProductHotspotData>) => string;
+/** Human size string: metres under 1 m become centimetres. */
+export declare const formatLength: (metres: number, unit?: "metric" | "imperial") => string;
+export type DimensionLine = {
+    axis: "x" | "y" | "z";
+    /** Hotspot anchors at both ends and the label midpoint (model metres). */
+    start: Vec3;
+    end: Vec3;
+    mid: Vec3;
+    length: number;
+};
+/**
+ * Three edge lines of the bounding box (width along x at the front-bottom
+ * edge, height along y at the front-left edge, depth along z at the
+ * bottom-left edge), each anchored as hotspots so they track the model.
+ */
+export declare const dimensionLines: ({ size, center }: ProductDimensions) => DimensionLine[];

package/dist/product/index.d.ts

@@ -0,0 +1,14 @@
+export { ProductViewer } from './ProductViewer';
+export { useProductAr, releaseSessionForAr, supportedProductArModes } from './useProductAr';
+export type { UseProductArOptions, UseProductArResult } from './useProductAr';
+export { isModelViewerDefined, loadModelViewer } from './loadModelViewer';
+export { DEFAULT_PRODUCT_AR_MODES } from './types';
+export { dimensionLines, formatLength, formatVec3, hotspotAttributes, nextHotspotId, parseHotspots, parseVec3, serializeHotspots, } from './details';
+export type { DimensionLine, ProductDimensions as ProductDimensionsData, ProductHotspotData, Vec3, } from './details';
+export { useDimensionLines, useProductDimensions, useProductHotspots, useProductVariants, } from './useProductDetails';
+export type { ProductDetailsElement, UseProductHotspotsOptions, UseProductHotspotsResult, } from './useProductDetails';
+export { ProductHotspot } from './ProductHotspot';
+export type { ProductHotspotProps } from './ProductHotspot';
+export { ProductDimensions } from './ProductDimensions';
+export type { ProductDimensionsProps } from './ProductDimensions';
+export type { ProductArMode, ProductArState, ProductArStatus, ProductViewerElement, ProductViewerPlacement, ProductViewerProps, ProductViewerScale, } from './types';

package/dist/product/loadModelViewer.d.ts

@@ -0,0 +1,4 @@
+export declare const isModelViewerDefined: () => boolean;
+export declare const loadModelViewer: () => Promise<void>;
+/** Test seam. */
+export declare const _resetModelViewerLoader: () => void;

package/dist/product/types.d.ts

@@ -0,0 +1,71 @@
+import { XRFallbackReason } from '../capabilities/types';
+/** The native path a device takes for surface placement. */
+export type ProductArMode = "webxr" | "scene-viewer" | "quick-look";
+/** Preference order shared by `<ProductViewer arModes>` and `useProductAr({ modes })`. */
+export declare const DEFAULT_PRODUCT_AR_MODES: readonly ProductArMode[];
+/**
+ * model-viewer's `ar-status` values, plus the SDK's `unavailable` when no
+ * mode is supported on the device.
+ */
+export type ProductArStatus = "unavailable" | "not-presenting" | "session-started" | "object-placed" | "failed";
+export type ProductViewerPlacement = "floor" | "wall";
+export type ProductViewerScale = "auto" | "fixed";
+export type ProductViewerProps = {
+    /** glTF / GLB URL (the model every platform renders). */
+    src: string;
+    /** USDZ URL for iOS Quick Look. Without it iOS falls back to model-viewer's own USDZ export (slower, lower fidelity). */
+    iosSrc?: string;
+    /** Accessible description. */
+    alt?: string;
+    /** Poster image shown until the model loads. */
+    poster?: string;
+    /** Native paths to offer, in preference order. Default `["webxr", "scene-viewer", "quick-look"]`. */
+    arModes?: ProductArMode[];
+    /** Enable the AR button / `activateAR()`. Default `true`. */
+    ar?: boolean;
+    /** Where the object lands. Default `floor`. */
+    placement?: ProductViewerPlacement;
+    /** `fixed` keeps real-world size (no pinch-to-resize). Default `auto`. */
+    scale?: ProductViewerScale;
+    cameraControls?: boolean;
+    autoRotate?: boolean;
+    /** `auto` | `eager` | `lazy`; default `auto`. */
+    loading?: "auto" | "eager" | "lazy";
+    /** Environment image URL or `neutral`. */
+    environmentImage?: string;
+    shadowIntensity?: number;
+    exposure?: number;
+    /** Extra attributes passed straight to `<model-viewer>` (anything not wrapped). */
+    attributes?: Record<string, string | number | boolean>;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+    onLoad?: () => void;
+    onError?: (error: Error) => void;
+    /** Fires on every `ar-status` change. */
+    onArStatus?: (status: ProductArStatus) => void;
+    /** The custom element, once model-viewer is loaded and mounted. */
+    onReady?: (element: ProductViewerElement) => void;
+};
+/** The subset of `ModelViewerElement` the SDK relies on (typed loosely so the peer stays optional). */
+export type ProductViewerElement = HTMLElement & {
+    src: string;
+    canActivateAR: boolean;
+    activateAR: () => Promise<void>;
+    loaded: boolean;
+    modelIsVisible: boolean;
+    addEventListener: HTMLElement["addEventListener"];
+    removeEventListener: HTMLElement["removeEventListener"];
+};
+export type ProductArState = {
+    status: ProductArStatus;
+    /** Modes the device supports (from the capability check), in the viewer's preference order. */
+    supportedModes: ProductArMode[];
+    /** `canActivateAR` from the element once it is ready. */
+    canActivate: boolean;
+    /** Why AR is unavailable, when it is. */
+    reason: XRFallbackReason | null;
+    /** True while the viewer library is still loading. */
+    loading: boolean;
+    error: Error | null;
+};