@vincentt-xr/sdk 2.0.0-alpha.0

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

@@ -0,0 +1,2 @@
+export declare const FACE_OCCLUDER_SCALE_FACTOR = 0.11;
+export declare const FACE_OCCLUDER_Y_ROTATION_OFFSET_SCALE_FACTOR = 0.004;

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

@@ -0,0 +1,45 @@
+import { NormalizedLandmark } from '@mediapipe/tasks-vision';
+import { XRModelNodeFaceTracking } from '../../types/nodes';
+import { RunModelParams } from '../../types';
+import { PerformanceData } from '../../types/common';
+import { FaceModelOptions } from '../../types/face';
+import { BaseXRModel } from '../Base';
+export declare class FaceTrackingModel extends BaseXRModel {
+    private landmarker;
+    private processingTime;
+    private sourceCanvas;
+    private analysisCanvas;
+    private getSource;
+    private detectionResults;
+    private numFaces;
+    private cameras;
+    private faces;
+    private leftCheekScratch;
+    private rightCheekScratch;
+    private landmarkScratch;
+    private rotMatrixScratch;
+    private rotQuatScratch;
+    private rotEulerScratch;
+    constructor();
+    private landmarkForSource;
+    private extractAndUpdateFaceData;
+    private processFaceTracking;
+    resume(): void;
+    private getFace;
+    private getDetectionResults;
+    private getRawFaceTrackingData;
+    initialize(options?: FaceModelOptions): Promise<void>;
+    run({ sourceCanvas, getSource, targetFps }: RunModelParams): Promise<void>;
+    getModelNode(): XRModelNodeFaceTracking;
+    getPerformanceData(): Promise<PerformanceData>;
+}
+export declare const resolveFaceYawRotation: (yawDegrees: number) => number;
+export declare const resolveFaceAnalysisDimension: (numFaces: number) => 1024 | 512;
+/**
+ * Reference (allocating) source-aware landmark normalization. Non-webcam
+ * sources (image/video) read mirrored from MediaPipe, so x is flipped to
+ * display space. The per-frame extraction path uses an in-place scratch
+ * variant (`landmarkForSource`) to avoid allocating; this pure form exists
+ * for callers/tests that need a plain array transform.
+ */
+export declare const normalizeFaceLandmarksForSource: (landmarks: NormalizedLandmark[], sourceKind?: "webcam" | "image" | "video") => NormalizedLandmark[];

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

@@ -0,0 +1,2 @@
+declare const DEMO_LANDMARKS: number[];
+export default DEMO_LANDMARKS;

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

@@ -0,0 +1,21 @@
+import { XRModelNodeGestureTracking } from '../../types/nodes';
+import { RunModelParams } from '../../types';
+import { PerformanceData } from '../../types/common';
+import { BaseXRModel } from '../Base';
+export declare class GestureTrackingModel extends BaseXRModel {
+    private landmarker;
+    private processingTime;
+    private coordinates;
+    private gesture;
+    private sourceCanvas;
+    private readonly downscaler;
+    constructor();
+    private getGestureData;
+    private processGestureTracking;
+    resume(): void;
+    dispose(): void;
+    initialize(): Promise<void>;
+    run({ sourceCanvas, targetFps }: RunModelParams): Promise<void>;
+    getModelNode(): XRModelNodeGestureTracking;
+    getPerformanceData(): Promise<PerformanceData>;
+}

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

@@ -0,0 +1,21 @@
+import { XRModelNodeHandTracking } from '../../types/nodes';
+import { RunModelParams } from '../../types';
+import { PerformanceData } from '../../types/common';
+import { BaseXRModel } from '../Base';
+export declare class HandTrackingModel extends BaseXRModel {
+    private landmarker;
+    private processingTime;
+    private coordinates;
+    private gesture;
+    private sourceCanvas;
+    private readonly downscaler;
+    constructor();
+    private getHandData;
+    private processHandTracking;
+    resume(): void;
+    dispose(): void;
+    initialize(): Promise<void>;
+    run({ sourceCanvas, targetFps }: RunModelParams): Promise<void>;
+    getModelNode(): XRModelNodeHandTracking;
+    getPerformanceData(): Promise<PerformanceData>;
+}

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

@@ -0,0 +1,75 @@
+import { PerformanceData, RunModelParams, SegmentationModelOptions } from '../../types';
+import { XRModelNodeSegmentation } from '../../types/nodes';
+import { BaseXRModel } from '../Base';
+export declare class BackgroundSegmentationModel extends BaseXRModel {
+    private segmenter;
+    private processingTime;
+    private sourceCanvas;
+    private processCanvas;
+    private filterCanvas;
+    private inputSource;
+    private inputSourceSize;
+    private glCanvas;
+    private drawingUtils;
+    private useGpuMaskPath;
+    private maskImageData;
+    private maskCanvas;
+    private segmentationMaskTexture;
+    private isMaskSetup;
+    private isProcessing;
+    private latestMask;
+    private rawCache;
+    private quality;
+    constructor();
+    private getQualityScaleFactor;
+    /**
+     * Set (or clear) a high-resolution input override. Pass the raw <video>/<img>
+     * (or any CanvasImageSource with intrinsic dimensions) to run segmentation on
+     * native-resolution, uncropped frames instead of the small display-fit session
+     * feed. Pass `undefined` to revert to the shared feed canvas.
+     */
+    setInputSource(source: CanvasImageSource | undefined): void;
+    private readIntrinsicSize;
+    /**
+     * Size the process canvas to the override input's aspect ratio, bounded by
+     * PROCESS_MAX_DIM on the long edge, and keep the GL canvas in sync so the GPU
+     * mask renders at the same resolution. No-op when there is no override, or when
+     * the intrinsic size hasn't changed since the last frame.
+     */
+    private ensureProcessCanvasForInput;
+    private processSegmentation;
+    /**
+     * Blit the GPU-rendered mask (already RGBA-inverted by drawCategoryMask)
+     * straight from the GL canvas into the mask canvas, cover-fitted through the
+     * soft-edge blur. `drawImage(glCanvas)` is a GPU→GPU transfer — no readPixels,
+     * no CPU array, no ImageData, no row flip (the 2D canvas presents the WebGL
+     * canvas right-side-up). This is the zero-readback path.
+     */
+    private blitGlToMask;
+    /**
+     * CPU-fallback inverted-alpha ImageData build (only when the GPU path is off).
+     * The single-channel mask is expanded to RGBA with the person→transparent,
+     * background→opaque convention (green carries the signal for the alphaMap).
+     */
+    private readMaskToImageData;
+    /**
+     * CPU-fallback blit: put the inverted-alpha mask ImageData into maskCanvas
+     * with a soft-edge blur, cover-fitted to the render target. Only used when the
+     * GPU path is off; the GPU path blits the GL canvas directly (blitGlToMask).
+     */
+    private blitImageDataToMask;
+    private stagingCanvas;
+    private getStagingCanvas;
+    resume(): void;
+    dispose(): void;
+    initialize(options?: SegmentationModelOptions): Promise<void>;
+    run({ sourceCanvas, renderWidth, renderHeight, targetFps, }: RunModelParams): Promise<void>;
+    /**
+     * Lazily read the single-channel mask back to a Uint8Array. Only invoked when
+     * a consumer calls getRawSegmentationData(); the default texture path never
+     * touches it, so apps that only use <VideoBackground> pay no extra readback.
+     */
+    private getRawSegmentationData;
+    getModelNode(): XRModelNodeSegmentation;
+    getPerformanceData(): Promise<PerformanceData>;
+}

package/dist/models/index.d.ts

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

package/dist/modules/XRClient/index.d.ts

@@ -0,0 +1,9 @@
+import { XRClientConfig } from '../../types';
+export declare class XRClient {
+    private static instance;
+    private logger;
+    private session?;
+    static initialize(config: XRClientConfig): Promise<XRClient>;
+    private constructor();
+    createSession(): Promise<XRSession>;
+}

package/dist/modules/index.d.ts

@@ -0,0 +1 @@
+export * from './XRClient';

package/dist/selectors-BHO6TnoC.js

@@ -0,0 +1,59 @@
+import { useSyncExternalStore as s, useMemo as a } from "react";
+import { u } from "./index-CYMj26Ej.js";
+const r = () => u().session.store, o = (e) => (t) => e.subscribe(t), p = () => {
+  const e = r();
+  return s(
+    o(e),
+    () => e.getSnapshot().ready,
+    () => !1
+  );
+}, l = () => {
+  const e = r();
+  return s(
+    o(e),
+    () => e.getSnapshot().error,
+    () => {
+    }
+  );
+}, d = () => {
+  const e = r();
+  return s(
+    o(e),
+    () => e.getSnapshot().cameraTexture,
+    () => {
+    }
+  );
+}, h = () => {
+  const e = r(), t = s(
+    o(e),
+    () => e.getSnapshot().renderWidth,
+    () => 0
+  ), n = s(
+    o(e),
+    () => e.getSnapshot().renderHeight,
+    () => 0
+  );
+  return a(() => ({ width: t, height: n }), [t, n]);
+}, S = (e) => {
+  const t = r(), n = s(
+    o(t),
+    () => t.getSnapshot().pipeline.get(e) ?? null,
+    () => null
+  );
+  return a(() => n ? n.getModelNode() : null, [n]);
+}, g = () => {
+  const e = r(), t = s(
+    o(e),
+    () => e.getSnapshot().pipeline,
+    () => e.getSnapshot().pipeline
+  );
+  return a(() => Array.from(t.keys()), [t]);
+};
+export {
+  S as a,
+  p as b,
+  l as c,
+  h as d,
+  g as e,
+  d as u
+};

package/dist/selectors-Bub0o3qy.cjs

@@ -0,0 +1 @@
+"use strict";const s=require("react"),u=require("./index-PtFmD6B8.cjs"),o=()=>u.useXRContext().session.store,n=e=>t=>e.subscribe(t),c=()=>{const e=o();return s.useSyncExternalStore(n(e),()=>e.getSnapshot().ready,()=>!1)},a=()=>{const e=o();return s.useSyncExternalStore(n(e),()=>e.getSnapshot().error,()=>{})},i=()=>{const e=o();return s.useSyncExternalStore(n(e),()=>e.getSnapshot().cameraTexture,()=>{})},S=()=>{const e=o(),t=s.useSyncExternalStore(n(e),()=>e.getSnapshot().renderWidth,()=>0),r=s.useSyncExternalStore(n(e),()=>e.getSnapshot().renderHeight,()=>0);return s.useMemo(()=>({width:t,height:r}),[t,r])},l=e=>{const t=o(),r=s.useSyncExternalStore(n(t),()=>t.getSnapshot().pipeline.get(e)??null,()=>null);return s.useMemo(()=>r?r.getModelNode():null,[r])},p=()=>{const e=o(),t=s.useSyncExternalStore(n(e),()=>e.getSnapshot().pipeline,()=>e.getSnapshot().pipeline);return s.useMemo(()=>Array.from(t.keys()),[t])};exports.useXRCameraTexture=i;exports.useXRError=a;exports.useXRModelNode=l;exports.useXRPipelineSnapshot=p;exports.useXRReady=c;exports.useXRRenderSize=S;

package/dist/services/ApiService.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wrapper class for making API requests.
+ */
+export declare class ApiService {
+    private baseUrl;
+    private apiKey;
+    constructor(params: {
+        baseUrl: string;
+        apiKey: string;
+    });
+    fetch<T = unknown>(url: string, options?: RequestInit): Promise<T>;
+}

package/dist/services/MetricsCollector/CameraFPSTracker.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Camera FPS Tracker
+ * Tracks frames per second from the camera/video processing loop
+ * Updates every 500ms as specified in PRD
+ */
+export declare class CameraFPSTracker {
+    private frameTimestamps;
+    private lastUpdateTime;
+    private currentFPS;
+    private readonly updateInterval;
+    constructor();
+    /**
+     * Track a new frame
+     * Should be called on each camera frame from renderVideo loop
+     */
+    trackFrame(): void;
+    /**
+     * Get current FPS value
+     */
+    getFPS(): number;
+    /**
+     * Reset tracker state
+     */
+    reset(): void;
+}

package/dist/services/MetricsCollector/MemoryTracker.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Memory Tracker
+ * Tracks JavaScript heap memory usage via performance.memory API
+ * Updates every 1 second as specified in PRD
+ * Gracefully handles browsers that don't support performance.memory (non-Chrome)
+ */
+export interface MemoryUsage {
+    used: number;
+    total: number;
+    percentage: number;
+}
+export declare class MemoryTracker {
+    private intervalId;
+    private memoryUsage;
+    private readonly updateInterval;
+    private isSupported;
+    constructor(updateInterval?: number);
+    /**
+     * Check if performance.memory is supported
+     */
+    private checkSupport;
+    /**
+     * Start tracking memory usage
+     */
+    start(): void;
+    /**
+     * Stop tracking memory usage
+     */
+    stop(): void;
+    /**
+     * Update memory measurements
+     */
+    private updateMemory;
+    /**
+     * Get current memory usage
+     * Returns null if performance.memory is not supported
+     */
+    getMemoryUsage(): MemoryUsage | null;
+    /**
+     * Check if memory tracking is supported
+     */
+    isMemorySupported(): boolean;
+}

package/dist/services/MetricsCollector/RenderTimeTracker.d.ts

@@ -0,0 +1,10 @@
+import { RenderTimeCallback } from './types';
+export interface RenderTimeTrackerProps {
+    /** Callback function to receive render time measurements */
+    onUpdate: RenderTimeCallback;
+}
+/**
+ * Hidden component that tracks rendering performance
+ * Place this inside your XRScene to enable render time tracking
+ */
+export declare function RenderTimeTracker({ onUpdate }: RenderTimeTrackerProps): null;

package/dist/services/MetricsCollector/ResolutionTracker.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Resolution Tracker
+ * Tracks the active camera stream resolution from the video element
+ * Updates when video metadata is loaded or dimensions change
+ */
+export declare class ResolutionTracker {
+    private resolution;
+    private videoElement;
+    private metadataListener;
+    /**
+     * Start tracking resolution from a video element
+     */
+    start(videoElement: HTMLVideoElement | null): void;
+    /**
+     * Stop tracking and clean up listeners
+     */
+    stop(): void;
+    /**
+     * Update resolution from video element
+     */
+    private updateResolution;
+    /**
+     * Get current resolution string (e.g., "1280x720")
+     */
+    getResolution(): string;
+}

package/dist/services/MetricsCollector/index.d.ts

@@ -0,0 +1,59 @@
+import { DebuggerMetrics } from '../../types/debugger';
+import { MetricsCollectorOptions } from './types';
+export declare class MetricsCollector {
+    private options;
+    private isRunning;
+    private metrics;
+    private cameraFPSTracker;
+    private memoryTracker;
+    private resolutionTracker;
+    private frameTimes;
+    private lastEffectiveFPSUpdate;
+    constructor(options?: MetricsCollectorOptions);
+    /**
+     * Start collecting metrics
+     * @param videoElement Optional video element for resolution tracking
+     */
+    start(videoElement?: HTMLVideoElement | null): void;
+    /**
+     * Stop collecting metrics and clean up
+     */
+    stop(): void;
+    /**
+     * Setup global hook for camera FPS tracking
+     * This allows useXRSession to call trackFrame() without tight coupling
+     */
+    private setupCameraFPSHook;
+    /**
+     * Cleanup global hook
+     */
+    private cleanupCameraFPSHook;
+    /**
+     * Get current metrics snapshot
+     * Updates metrics from all trackers before returning
+     */
+    getMetrics(): DebuggerMetrics;
+    /**
+     * Update metrics from all trackers
+     */
+    private updateMetricsFromTrackers;
+    /**
+     * Update render time (called from RenderTimeTracker component)
+     */
+    updateRenderTime(renderTime: number): void;
+    /**
+     * Update detection time from models
+     * Aggregates processing time from all active models in the XR pipeline
+     */
+    updateDetectionTime(pipeline?: Partial<Record<string, any>>): Promise<void>;
+    /**
+     * Update effective FPS calculation
+     * (will be implemented in Phase 6)
+     */
+    private updateEffectiveFPS;
+    /**
+     * Check if collector is running
+     */
+    isActive(): boolean;
+}
+export default MetricsCollector;

package/dist/services/MetricsCollector/types.d.ts

@@ -0,0 +1,47 @@
+import { DebuggerMetrics } from '../../types/debugger';
+/**
+ * Memory information from performance.memory API (Chrome-specific)
+ */
+export interface PerformanceMemory {
+    /** Used JavaScript heap size in bytes */
+    usedJSHeapSize: number;
+    /** Total allocated heap size in bytes */
+    totalJSHeapSize: number;
+    /** JavaScript heap size limit in bytes */
+    jsHeapSizeLimit: number;
+}
+/**
+ * Extended Performance interface with memory property
+ */
+export interface PerformanceWithMemory extends Performance {
+    memory?: PerformanceMemory;
+}
+/**
+ * Callback type for render time tracking
+ */
+export type RenderTimeCallback = (renderTime: number) => void;
+/**
+ * Callback type for camera frame tracking
+ */
+export type CameraFrameCallback = () => void;
+/**
+ * Global window interface extension for debugger hooks
+ */
+export interface WindowWithDebuggerHooks extends Window {
+    __xr_debugger_metrics?: {
+        trackCameraFrame: CameraFrameCallback;
+    };
+}
+/**
+ * Options for MetricsCollector initialization
+ */
+export interface MetricsCollectorOptions {
+    /** Whether to enable memory tracking (default: true) */
+    enableMemoryTracking?: boolean;
+    /** Update interval for memory polling in ms (default: 1000) */
+    memoryUpdateInterval?: number;
+}
+/**
+ * Partial metrics for incremental updates
+ */
+export type PartialMetrics = Partial<DebuggerMetrics>;

package/dist/services/MetricsCollector/utils.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Utility functions for metrics collection
+ * Provides efficient data structures and helpers for performance tracking
+ */
+/**
+ * Efficient circular buffer for rolling averages
+ * Uses typed array for better performance
+ */
+export declare class CircularBuffer {
+    private buffer;
+    private index;
+    private filled;
+    private size;
+    constructor(size: number);
+    /**
+     * Add a value to the buffer
+     */
+    add(value: number): void;
+    /**
+     * Get average of all values in buffer
+     */
+    getAverage(): number;
+    /**
+     * Get the most recent value
+     */
+    getLast(): number;
+    /**
+     * Get number of values currently in buffer
+     */
+    getCount(): number;
+    /**
+     * Clear all values from buffer
+     */
+    clear(): void;
+}
+/**
+ * Exponential moving average for smooth value transitions
+ * @param currentValue Current smoothed value
+ * @param newValue New raw value
+ * @param smoothing Smoothing factor (0-1), higher = more smoothing
+ */
+export declare function smoothValue(currentValue: number, newValue: number, smoothing?: number): number;
+/**
+ * Throttle function to limit execution frequency
+ * @param func Function to throttle
+ * @param wait Minimum time between executions in milliseconds
+ */
+export declare function throttle<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Format number to fixed decimal places
+ * @param value Number to format
+ * @param decimals Number of decimal places (default: 1)
+ */
+export declare function formatNumber(value: number, decimals?: number): string;
+/**
+ * Format bytes to megabytes
+ * @param bytes Bytes value
+ */
+export declare function bytesToMB(bytes: number): number;
+/**
+ * Calculate percentage
+ * @param value Numerator
+ * @param total Denominator
+ */
+export declare function percentage(value: number, total: number): number;

package/dist/texture/computeContainScale.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Computes the `[sx, sy, sz]` scale factors that, when multiplied into a
+ * mesh's scale inside a rect of `rectAspect`, produce a mesh whose rendered
+ * aspect equals `textureAspect`. This is the core of `mapFit: "contain"` —
+ * instead of transforming the texture's UV matrix (which produces zoom/crop
+ * under three.js's default wrap mode), the mesh itself is shrunk on one axis
+ * so the texture fills a correctly-shaped plane and the remaining rect area
+ * is genuinely empty.
+ *
+ * Rule:
+ * - `rectAspect > textureAspect` → rect is wider than texture →
+ *   `[textureAspect / rectAspect, 1, 1]` (shrink X, letterbox L/R).
+ * - `rectAspect < textureAspect` → rect is taller than texture →
+ *   `[1, rectAspect / textureAspect, 1]` (shrink Y, letterbox T/B).
+ * - `rectAspect === textureAspect` (within 1e-6) → `[1, 1, 1]` (no-op).
+ *
+ * Pure math — no three.js imports. Safe to call every render.
+ *
+ * @param rectAspect     Aspect (width / height) of the enclosing rect.
+ * @param textureAspect  Aspect (width / height) of the texture.
+ * @returns `[sx, sy, sz]`. `sz` is always `1`; we fit 2D textures to 2D rects.
+ *          Returns `[1, 1, 1]` for non-positive / non-finite inputs so the
+ *          caller doesn't have to pre-guard on asset-load state.
+ */
+export declare function computeContainScale(rectAspect: number, textureAspect: number): [number, number, number];

package/dist/texture/hasFullUnitUVBounds.d.ts

@@ -0,0 +1,37 @@
+import * as THREE from "three";
+/**
+ * Returns `true` if the `uv` attribute of `geometry` covers exactly the full
+ * 0..1 unit square within `tolerance` on each axis.
+ *
+ * Primitive geometries (`PlaneGeometry`, `BoxGeometry`, etc.) always return
+ * `true`. Imported GLTF meshes may return `false` when their UVs have been
+ * baked to a sub-region or use tiling coordinates outside [0, 1].
+ *
+ * This is the fit-eligibility guard used by `mapFit: "contain"` in the
+ * xr-client renderer. The v2 mesh-scale fit mechanism assumes the whole
+ * plane shows the whole texture — only true when UVs cover the unit square.
+ * When this returns `false`, the caller should skip the fit and emit a
+ * warning via `logUVBoundsWarningOnce`.
+ *
+ * @param geometry   The geometry to inspect.
+ * @param tolerance  Epsilon for comparing UV min/max to 0 and 1.
+ *                   Defaults to `0.001`.
+ */
+export declare function hasFullUnitUVBounds(geometry: THREE.BufferGeometry, tolerance?: number): boolean;
+/**
+ * Emits a deduplicated console warning for a mesh whose UV bounds are not
+ * full-unit, so `textureFit` had to fall back to `uvAspect = 1`.
+ *
+ * Only fires once per `meshId` per session (de-duplicated via module-level
+ * Set). Subsequent calls with the same `meshId` are silently ignored.
+ *
+ * @param meshId    A stable identifier for the mesh (e.g. the three.js Object3D `uuid`).
+ * @param meshLabel A human-readable label (e.g. the mesh's `name` or `_label`).
+ *                  Falls back to `meshId` if not provided.
+ */
+export declare function logUVBoundsWarningOnce(meshId: string, meshLabel?: string): void;
+/**
+ * Test helper — resets the deduplicated warning set.
+ * Not intended for production use.
+ */
+export declare function _resetUVBoundsWarnings(): void;

package/dist/texture/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Supported texture fit modes.
+ *
+ * - `"fill"` — three.js default; texture is stretched to fill the mesh's UV
+ *   rectangle. No mesh-scale adjustment is performed.
+ * - `"contain"` — the enclosing mesh's rendered scale is adjusted inside its
+ *   parent rect so the mesh's aspect matches the texture's aspect. The texture
+ *   then fills a correctly-shaped plane naturally; the remainder of the rect
+ *   is genuinely empty (nothing drawn). See `computeContainScale`.
+ *
+ * Implementation note: v2 implements `"contain"` by adjusting the mesh, not
+ * by transforming the texture's UV matrix. v1 tried the latter and produced
+ * zoom/crop under three.js's default `ClampToEdgeWrapping`.
+ */
+export type TextureFit = "fill" | "contain";
+/**
+ * Runtime array of all valid TextureFit values.
+ * Consumed by editor-ui's type picker and the design agent's approved-types validator.
+ */
+export declare const TEXTURE_FITS: readonly TextureFit[];

package/dist/tracking.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const C=require("./useFaceResults-hVUJYSEY.cjs"),b=require("./index-B5J4gzn2.cjs"),E=require("react/jsx-runtime"),S=require("@react-three/fiber"),i=require("react"),z=require("three"),m=require("./index-PtFmD6B8.cjs");function O(e){const r=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e){for(const t in e)if(t!=="default"){const n=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,n.get?n:{enumerable:!0,get:()=>e[t]})}}return r.default=e,Object.freeze(r)}const g=O(z),j={"body.head":0,"body.leftShoulder":11,"body.rightShoulder":12,"body.leftElbow":13,"body.rightElbow":14,"body.leftWrist":15,"body.rightWrist":16,"body.leftHip":23,"body.rightHip":24,"body.leftKnee":25,"body.rightKnee":26,"body.leftAnkle":27,"body.rightAnkle":28},B=({bodyIndex:e=0,active:r=!0,children:t})=>{const n=i.useRef(null),{ready:o,node:d}=b.useXRModel(m.XRModel.BODY_TRACKER,void 0,r),{camera:u}=S.useThree(),l=i.useRef(u);l.current!==u&&(l.current=u);const c=i.useRef(null);S.useFrame(()=>{if(!o||!d||!n.current)return;const p=d;c.current=p;const s=p.getLandmarks2D(e),a=s==null?void 0:s[0];if(!a){n.current.visible=!1;return}const h=x(a,l.current);n.current.visible=!0,n.current.position.copy(h)});const f=i.useCallback(p=>{const s=c.current;if(!s)return null;const a=s.getLandmarks2D(e);if(!a)return null;if(p==="body.neck"){const R=a[11],A=a[12];if(!R||!A)return null;const k={x:(R.x+A.x)/2,y:(R.y+A.y)/2,z:(R.z+A.z)/2};return{position:x(k,l.current)}}const h=j[p];if(h===void 0)return null;const T=a[h];return T?{position:x(T,l.current)}:null},[e]),y=i.useMemo(()=>({type:"body",resolveLandmark:f}),[f]);return E.jsx(b.TrackerContext.Provider,{value:y,children:E.jsx("group",{ref:n,renderOrder:m.RENDER_LAYERS.TRACKED,children:t})})},x=(e,r)=>{const t=new g.Vector3(e.x,e.y,e.z);t.unproject(r);const n=t.sub(r.position).normalize(),o=-r.position.z/n.z;return r.position.clone().add(n.multiplyScalar(o))},H={"hand.wrist":0,"hand.thumbTip":4,"hand.indexTip":8,"hand.middleTip":12,"hand.ringTip":16,"hand.pinkyTip":20,"hand.indexBase":5,"hand.middleBase":9,"hand.ringBase":13,"hand.pinkyBase":17},G=({children:e,targetFps:r,active:t=!0})=>{const n=i.useRef(null),o=i.useMemo(()=>r===void 0?void 0:{targetFps:r},[r]),{ready:d,node:u}=b.useXRModel(m.XRModel.GESTURE_TRACKER,o,t),{camera:l}=S.useThree(),c=i.useRef(l);c.current!==l&&(c.current=l);const f=i.useRef(null);S.useFrame(()=>{var h;if(!d||!u||!n.current)return;f.current=u;const s=(h=u==null?void 0:u.coordinates)==null?void 0:h[0];if(!s){n.current.visible=!1;return}const a=D(s,c.current);n.current.visible=!0,n.current.position.copy(a)});const y=i.useCallback(s=>{var T,R;const a=H[s];if(a===void 0)return null;const h=(R=(T=f.current)==null?void 0:T.coordinates)==null?void 0:R[a];return h?{position:D(h,c.current)}:null},[]),p=i.useMemo(()=>({type:"hand",resolveLandmark:y}),[y]);return E.jsx(b.TrackerContext.Provider,{value:p,children:E.jsx("group",{ref:n,renderOrder:m.RENDER_LAYERS.TRACKED,children:e})})},D=(e,r)=>{const t=new g.Vector3(e.x,e.y,e.z);t.unproject(r);const n=t.sub(r.position).normalize(),o=-r.position.z/n.z;return r.position.clone().add(n.multiplyScalar(o))},K=800,L=200,F=()=>({armed:!1,armStart:null,holdStart:null,fired:!1}),P=(e,{isTrigger:r,gesture:t,now:n,mode:o,debounceMs:d,holdMs:u})=>{if(e.fired)return null;if(o==="hold"){if(r&&t){if(e.holdStart===null&&(e.holdStart=n),n-e.holdStart>=u)return e.fired=!0,t}else e.holdStart=null;return null}return e.armed?r&&t?(e.fired=!0,t):null:(r?e.armStart=null:(e.armStart===null&&(e.armStart=n),n-e.armStart>=d&&(e.armed=!0)),null)};function q({gestures:e,mode:r="arm",debounceMs:t=K,holdMs:n=L,onTrigger:o,enabled:d=!0}){const{ready:u,node:l}=b.useXRModel(m.XRModel.GESTURE_TRACKER),c=i.useRef(o);i.useEffect(()=>{c.current=o},[o]);const f=i.useRef(new Set);i.useEffect(()=>{f.current=new Set(Array.isArray(e)?e:[e])},[e]);const y=i.useRef(F());S.useFrame(()=>{if(!d||!u||!l)return;const p=l.gesture,s=!!(p&&f.current.has(p)),a=P(y.current,{isTrigger:s,gesture:p,now:performance.now(),mode:r,debounceMs:t,holdMs:n});a&&c.current(a)})}const X=e=>(q(e),null),W={"hand.wrist":0,"hand.thumbTip":4,"hand.indexTip":8,"hand.middleTip":12,"hand.ringTip":16,"hand.pinkyTip":20,"hand.indexBase":5,"hand.middleBase":9,"hand.ringBase":13,"hand.pinkyBase":17},V=({children:e,targetFps:r,active:t=!0})=>{const n=i.useRef(null),o=i.useMemo(()=>r===void 0?void 0:{targetFps:r},[r]),{ready:d,node:u}=b.useXRModel(m.XRModel.HAND_TRACKER,o,t),{camera:l}=S.useThree(),c=i.useRef(l);c.current!==l&&(c.current=l);const f=i.useRef(null);S.useFrame(()=>{var T;if(!d||!u||!n.current)return;const s=u;f.current=s;const a=(T=s==null?void 0:s.coordinates)==null?void 0:T[0];if(!a){n.current.visible=!1;return}const h=M(a,c.current);n.current.visible=!0,n.current.position.copy(h)});const y=i.useCallback(s=>{var T,R;const a=W[s];if(a===void 0)return null;const h=(R=(T=f.current)==null?void 0:T.coordinates)==null?void 0:R[a];return h?{position:M(h,c.current)}:null},[]),p=i.useMemo(()=>({type:"hand",resolveLandmark:y}),[y]);return E.jsx(b.TrackerContext.Provider,{value:p,children:E.jsx("group",{ref:n,renderOrder:m.RENDER_LAYERS.TRACKED,children:e})})},M=(e,r)=>{const t=new g.Vector3(e.x,e.y,e.z);t.unproject(r);const n=t.sub(r.position).normalize(),o=-r.position.z/n.z;return r.position.clone().add(n.multiplyScalar(o))},v=["portrait"],Y=({type:e,active:r=!0,children:t})=>(b.useXRModel(m.XRModel.BACKGROUND_SEGMENTATION,{type:e},r),i.useEffect(()=>{v.includes(e)||console.warn(`[Segmentation] unsupported type "${e}"; valid values: ${v.join(", ")}`)},[e]),E.jsx(E.Fragment,{children:t})),$=["face.forehead","face.noseTip","face.chin","face.leftEyeOuter","face.rightEyeOuter","face.leftCheek","face.rightCheek","face.mouthCenter"],U=["hand.wrist","hand.thumbTip","hand.indexTip","hand.middleTip","hand.ringTip","hand.pinkyTip","hand.indexBase","hand.middleBase","hand.ringBase","hand.pinkyBase"],I=["body.head","body.neck","body.leftShoulder","body.rightShoulder","body.leftElbow","body.rightElbow","body.leftWrist","body.rightWrist","body.leftHip","body.rightHip","body.leftKnee","body.rightKnee","body.leftAnkle","body.rightAnkle"],_=e=>e.startsWith("face.")?"face":e.startsWith("hand.")?"hand":e.startsWith("body.")?"body":null,N=(e,r,t)=>r+t*(e-r),w=(e,r)=>1/(1+1/(2*Math.PI*e)/r),J=(e,r,t,n,o,d)=>{if(!e.initialized||t<=0)return e.pos.copy(r),e.prevRaw.copy(r),e.dxHat.set(0,0,0),e.initialized=!0,e;const u=w(d,t),l=["x","y","z"];for(const c of l){const f=(r[c]-e.prevRaw[c])/t,y=N(f,e.dxHat[c],u);e.dxHat[c]=y;const p=n+o*Math.abs(y),s=w(p,t);e.pos[c]=N(r[c],e.pos[c],s),e.prevRaw[c]=r[c]}return e},Q=({target:e,offset:r,smoothing:t=0,children:n})=>{const o=b.useTrackerContext(),d=i.useRef(null),u=i.useRef(!1),l=i.useRef(new g.Vector3),c=i.useRef({pos:new g.Vector3,prevRaw:new g.Vector3,dxHat:new g.Vector3,initialized:!1}),f=_(e),y=o!==null&&f!==null&&o.type!==f,p=o===null,s=p||y||f===null;return i.useEffect(()=>{p?console.warn(`[TrackingAnchor] target "${e}" requires a FaceTracker / HandTracker / BodyTracker ancestor; rendering null.`):y?console.warn(`[TrackingAnchor] target "${e}" namespace does not match parent tracker type "${o==null?void 0:o.type}"; rendering null.`):f===null&&console.warn(`[TrackingAnchor] target "${e}" is not a recognized face/hand/body landmark; rendering null.`)},[e,f,p,y,o==null?void 0:o.type]),S.useFrame((a,h)=>{if(s||!d.current||!o)return;const T=o.resolveLandmark(e);if(!T){d.current.visible=!1,u.current=!1,c.current.initialized=!1;return}d.current.visible=!0;const R=l.current.copy(T.position),A=d.current.parent;if(A){A.updateMatrixWorld();const k=new g.Matrix4().copy(A.matrixWorld).invert();R.applyMatrix4(k)}if(r&&(R.x+=r[0],R.y+=r[1],R.z+=r[2]),t>0){const k=t*.1;J(c.current,R,u.current?h:0,k,.5,1),d.current.position.copy(c.current.pos)}else d.current.position.copy(R);u.current=!0,T.quaternion&&d.current.quaternion.copy(T.quaternion)}),s?null:E.jsx("group",{ref:d,renderOrder:m.RENDER_LAYERS.TRACKED,children:n})};exports.useFaceResults=C.useFaceResults;exports.FaceMesh=b.FaceMesh;exports.FaceTracker=b.FaceTracker;exports.BODY_TARGETS=I;exports.BodyTracker=B;exports.FACE_TARGETS=$;exports.GestureTracker=G;exports.GestureTrigger=X;exports.HAND_TARGETS=U;exports.HandTracker=V;exports.SEGMENTATION_TYPES=v;exports.Segmentation=Y;exports.TrackingAnchor=Q;exports.getTargetNamespace=_;