@vincentt-xr/sdk 2.0.0-alpha.0 → 2.0.0-alpha.10

package/dist/types/holistic.d.ts

@@ -0,0 +1,121 @@
+import { NormalizedLandmark } from '@mediapipe/tasks-vision';
+import { TrackerPoint } from './common';
+/** Which hands the holistic tracker publishes. Holistic is single-person: at most one left and one right hand. */
+export type HolisticHandsOption = "both" | "left" | "right" | "none";
+export type HolisticHandSide = "left" | "right";
+export type HolisticTrackingStatus = "loading" | "ready" | "error";
+/**
+ * Inference backend. `"auto"` (default) starts on the GPU and falls back to
+ * the CPU the first time the graph fails to run there: MediaPipe's holistic
+ * face-blendshape stage has no WebGL implementation, so with
+ * `outputFaceBlendshapes` the GPU path fails on the first frame.
+ */
+export type HolisticDelegate = "auto" | "GPU" | "CPU";
+/** The backend actually running inference. */
+export type HolisticActiveDelegate = "GPU" | "CPU";
+/**
+ * Options the first acquirer passes to `XRModel.HOLISTIC_TRACKER`. The
+ * model-creation options (`modelUrl`, confidences, `outputFaceBlendshapes`)
+ * are fixed for the model's lifetime; the runtime subset
+ * (`HolisticRuntimeOptions`) can be changed live through `node.setOptions`.
+ */
+export type HolisticModelOptions = HolisticRuntimeOptions & {
+    /**
+     * Override the `.task` asset. Pre-release default: MediaPipe's published
+     * holistic landmarker on `storage.googleapis.com`, integrity-verified; the
+     * SDK CDN copy is not published yet and will become the default when it is.
+     * Set this to a self-hosted copy to drop the third-party dependency; a custom
+     * URL is fetched best-effort.
+     */
+    modelUrl?: string;
+    /** Face detector confidence, 0..1. MediaPipe default 0.5. */
+    minFaceDetectionConfidence?: number;
+    /** Face presence confidence for the landmark stage, 0..1. MediaPipe default 0.5. */
+    minFacePresenceConfidence?: number;
+    /** Pose detector confidence, 0..1. MediaPipe default 0.5. */
+    minPoseDetectionConfidence?: number;
+    /** Pose presence confidence for the landmark stage, 0..1. MediaPipe default 0.5. */
+    minPosePresenceConfidence?: number;
+    /** Hand landmark confidence, 0..1. MediaPipe default 0.5. */
+    minHandLandmarksConfidence?: number;
+    /** Emit the 52 face blendshape scores. Default `true`. */
+    outputFaceBlendshapes?: boolean;
+    /** Inference backend policy. Default `"auto"`. */
+    delegate?: HolisticDelegate;
+    /** Inference cap (fps). Read by the session at run time; overrides `perf.targetFps`. */
+    targetFps?: number;
+};
+/** Options that can change while the model is running (last writer wins). */
+export type HolisticRuntimeOptions = {
+    /** Hands to publish. Default `"both"`. */
+    hands?: HolisticHandsOption;
+    /**
+     * Longest side (px) of the frame handed to MediaPipe. The feed is
+     * downscaled to this before inference; outputs are normalized so consumers
+     * never see it. Default 768.
+     */
+    analysisMaxDimension?: number;
+    /** Keep a lost face / hand / pose for this long (ms) before dropping it. Default 250. */
+    holdMs?: number;
+    /** While held, extrapolate along the last velocity for up to this long (ms). Default 0. */
+    predictMs?: number;
+};
+/** Live face stream: landmarks in MediaPipe image space, like `FaceTracker`'s `detectionResults`. */
+export type HolisticFaceResult = {
+    /** 478 landmarks, normalized 0..1, top-left origin, Y down; `z` is tracker-relative depth. */
+    landmarks: NormalizedLandmark[];
+    /** Blendshape name → score (0..1). Empty when `outputFaceBlendshapes` is false. */
+    blendshapes: Record<string, number>;
+    /** 1 while detected; decays linearly to 0 over `holdMs` while held. */
+    confidence: number;
+    /** True when the stream is being replayed from memory after a dropout. */
+    held: boolean;
+};
+/** Live hand stream in SDK tracker coordinates, like `HandTracker`'s `coordinates`. */
+export type HolisticHandResult = {
+    /**
+     * The person's anatomical side on every source. Holistic labels follow the
+     * image, so the SDK swaps them on the mirrored webcam feed; this matches
+     * what `HandTracker` reports on the same feed.
+     */
+    handedness: HolisticHandSide;
+    /** 21 joints, center origin, X right, Y up, Z toward the viewer. */
+    landmarks: TrackerPoint[];
+    /** 21 joints in MediaPipe's metric world space (metres, wrist-relative, Y down). Not converted. */
+    worldLandmarks: TrackerPoint[];
+    /** 1 while detected; decays linearly to 0 over `holdMs` while held. */
+    confidence: number;
+    held: boolean;
+};
+/**
+ * Live pose stream in SDK tracker coordinates, like `BodyTracker`'s
+ * `getLandmarks2D()`. Unlike `BodyTracker`, left/right indices are the
+ * person's anatomical sides on every source (swapped on the mirrored webcam
+ * feed), so they agree with `leftHand` / `rightHand`.
+ */
+export type HolisticPoseResult = {
+    /** 33 landmarks, center origin, X right, Y up, Z toward the viewer. */
+    landmarks: TrackerPoint[];
+    /** 33 landmarks in MediaPipe's metric world space (metres, hip-relative, Y down). Not converted. */
+    worldLandmarks: TrackerPoint[];
+    /** Per-landmark visibility from MediaPipe (0..1), aligned with `landmarks`. */
+    visibility: number[];
+    /** Mean landmark visibility while detected; decays linearly to 0 over `holdMs` while held. */
+    confidence: number;
+    held: boolean;
+};
+/**
+ * The unified holistic result. One object per model instance, mutated in
+ * place every frame; read it inside `useFrame` and treat it as read-only.
+ * A stream is `null` when it is neither detected nor held.
+ */
+export type HolisticResult = {
+    /** Bumped on every publish; `0` until the first inference. */
+    version: number;
+    /** `performance.now()` of the last publish. */
+    timestampMs: number;
+    face: HolisticFaceResult | null;
+    leftHand: HolisticHandResult | null;
+    rightHand: HolisticHandResult | null;
+    pose: HolisticPoseResult | null;
+};

package/dist/types/index.d.ts

@@ -1,9 +1,9 @@
-export * from './client';
 export * from './nodes';
 export * from './session';
 export * from './body';
 export * from './face';
 export * from './headBinding';
+export * from './holistic';
 export * from './model';
 export * from './segmentation';
 export * from './common';

package/dist/types/model.d.ts

@@ -1,4 +1,4 @@
-import { XRMediaSourceKind } from './compositor';
+import { XRSessionSourceKind } from './compositor';
 /**
  * Session-level performance config, set via `<XRProvider perf={...}>`. Trades
  * tracking fidelity for lower GPU/CPU load and heat. Every field is optional;
@@ -29,12 +29,30 @@ export type XRPerfConfig = {
      * the tight native-selfie framing users expect; set `1` for the widest FOV.
      */
     cameraZoom?: number;
+    /**
+     * Multiplier (0.25..1) on every tracker's analysis resolution. Lower =
+     * cheaper inference, coarser landmarks. The adaptive-quality controller
+     * drives it per tier; set it directly only with `quality={false}`.
+     */
+    analysisScale?: number;
+};
+/**
+ * Session lifecycle behaviour, set via `<XRProvider lifecycle={...}>`.
+ */
+export type XRLifecycleConfig = {
+    /**
+     * Pause the whole session (blit loop, every model, the video element) while
+     * the tab is hidden and resume it when it returns. Off by default: a hidden
+     * tab already throttles RAF, and some flows (recording, picture-in-picture)
+     * must keep running. Turn it on for battery-sensitive single-page apps.
+     */
+    pauseWhenHidden?: boolean;
 };
 export type RunModelParams = {
     sourceCanvas: OffscreenCanvas | HTMLCanvasElement;
     renderWidth: number;
     renderHeight: number;
-    getSource?: () => "webcam" | XRMediaSourceKind | undefined;
+    getSource?: () => XRSessionSourceKind | undefined;
     /**
      * Cap the model's inference rate to this many frames per second. The model's
      * RAF loop still runs at display rate, but the (expensive) MediaPipe detect
@@ -43,4 +61,6 @@ export type RunModelParams = {
      * smoothness. See `session.perf.targetFps` and the per-tracker `targetFps`.
      */
     targetFps?: number;
+    /** Multiplier on the model's analysis resolution (0.25..1); default 1. */
+    analysisScale?: number;
 };

package/dist/types/nodes.d.ts

@@ -1,14 +1,24 @@
-import { FaceLandmarkerResult } from '@mediapipe/tasks-vision';
-import { Texture } from 'three';
-import { Coordinate } from './common';
+import { FaceLandmarkerResult, HolisticLandmarkerResult } from '@mediapipe/tasks-vision';
+import { Texture, Camera } from 'three';
+import { TrackerPoint } from './common';
 import { Face, FaceRawTrackingData } from './face';
 import { GestureData } from './gesture-tracking';
-import { HandData } from './hand-tracking';
-import { SegmentationData } from './segmentation';
+import { HandData, Handedness } from './hand-tracking';
+import { TrackedBody } from '../body/bodyIdentity';
+import { BodyPose } from '../body/bodyPose';
+import { HandPose, HandPoses } from '../hand/handPose';
+import { HolisticActiveDelegate, HolisticResult, HolisticRuntimeOptions, HolisticTrackingStatus } from './holistic';
+import { SemanticMask } from '../segmentation2d/types';
+import { SegmentationData, SemanticSegmentationStatus } from './segmentation';
 export type XRModelNodeSegmentation = {
     backgroundSegmentationMask?: Texture;
     getMaskCanvas: () => HTMLCanvasElement | null;
     getRawSegmentationData: () => SegmentationData | null;
+    /**
+     * `performance.now()` of the frame the current mask was made from (0 before
+     * the first), without reading the mask back. Optional for custom nodes.
+     */
+    getMaskTimestampMs?: () => number;
     /**
      * Supply a high-resolution input source (raw <video>/<img>) so segmentation
      * runs on native-resolution, uncropped frames instead of the small display-fit
@@ -16,12 +26,72 @@ export type XRModelNodeSegmentation = {
      */
     setInputSource: (source: CanvasImageSource | null | undefined) => void;
 };
+/** Live state of `XRModel.SEMANTIC_SEGMENTATION`; functions read the model's current values. */
+export type XRModelNodeSemanticSegmentation = {
+    /** Stable mask object in feed space, mutated in place; `version` 0 until the first inference. */
+    getMask: () => SemanticMask;
+    getStatus: () => SemanticSegmentationStatus;
+    getError: () => Error | null;
+};
+/**
+ * Live state of `XRModel.HOLISTIC_TRACKER`. One node object per model
+ * instance; every function reads the current value.
+ */
+export type XRModelNodeHolisticTracking = {
+    /** Unified, dropout-bridged result. Stable object mutated in place; `version` 0 until the first inference. */
+    getResult: () => HolisticResult;
+    /** The last raw MediaPipe result, unbridged and unconverted. */
+    getRawResult: () => HolisticLandmarkerResult | undefined;
+    getStatus: () => HolisticTrackingStatus;
+    getError: () => Error | null;
+    /** The backend running inference; `"CPU"` after an automatic fallback. */
+    getDelegate: () => HolisticActiveDelegate;
+    /** Change the runtime-tunable options without re-initializing the model. */
+    setOptions: (options: HolisticRuntimeOptions) => void;
+};
 export type XRModelNodeBodyTracking = {
-    getLandmarks2D: (bodyIndex?: number) => Coordinate[] | undefined;
+    getLandmarks2D: (bodyIndex?: number) => TrackerPoint[] | undefined;
+    /**
+     * Per-landmark visibility (0..1, MediaPipe's estimate that the point is in
+     * frame and not occluded), in landmark order. Optional for custom nodes.
+     */
+    getVisibility?: (bodyIndex?: number) => number[] | undefined;
+    /**
+     * The body's 3D pose (metric world joints plus the image ones and
+     * visibility), sided as the person's own left / right on every feed — unlike
+     * `getLandmarks2D`, which keeps MediaPipe's image sides. `null` = no body at
+     * that index. Optional for custom nodes.
+     */
+    getBodyPose?: (bodyIndex?: number) => BodyPose | null;
+    /**
+     * Every tracked body with a stable `id` (spatial identity: it stays with the
+     * person through result-order changes and dropouts under 250 ms), by id.
+     * Optional for custom nodes.
+     */
+    getBodies?: () => readonly TrackedBody[];
+    /** The pose of the body with this `id`, or `null` when it is not tracked. */
+    getBodyPoseById?: (id: number) => BodyPose | null;
+    /**
+     * Ask the shared model to look for `count` bodies (capped at
+     * `XR_MAX_SUBJECTS.body.max`); it looks for the most any live request asks.
+     * Returns the release. Optional for custom nodes.
+     */
+    requestBodies?: (owner: string, count: number) => () => void;
+    /** How many bodies the model looks for now. */
+    readonly numBodies?: number;
 };
 export type XRModelNodeHandTracking = {
+    hands?: HandData[];
+    /**
+     * Both hands by anatomical side, with stable identity through label flips
+     * and short dropouts (`assignHandPoses`). `null` = that hand is not tracked.
+     */
+    poses?: HandPoses;
+    /** `poses[hand]`. */
+    getHandPose?: (hand: Handedness) => HandPose | null;
     coordinates?: HandData["coordinates"];
     gesture?: HandData["gesture"];
+    handedness?: HandData["handedness"];
 };
 export type XRModelNodeGestureTracking = {
     coordinates?: GestureData["coordinates"];
@@ -29,7 +99,14 @@ export type XRModelNodeGestureTracking = {
 };
 export type XRModelNodeFaceTracking = {
     detectionResults?: FaceLandmarkerResult;
+    /**
+     * How many faces the shared face model was started with (`numFaces` of the
+     * first consumer to start it; default 1). Read-only: the model reports at
+     * most this many faces until it is started again. Optional for custom nodes.
+     */
+    readonly numFaces?: number;
     getDetectionResults: () => FaceLandmarkerResult | undefined;
     getFace: (faceIndex?: number) => Face | undefined;
     getRawFaceTrackingData: (faceIndex?: number) => FaceRawTrackingData | undefined;
+    setCamera: (camera: Camera, faceIndex?: number) => void;
 };

package/dist/types/segmentation.d.ts

@@ -18,6 +18,11 @@ export type SegmentationData = {
     maskData: Uint8Array | null;
     width: number;
     height: number;
+    /**
+     * `performance.now()` when the frame this mask comes from was segmented
+     * (the clock hand poses use): pair it with tracking from the same moment.
+     */
+    timestampMs?: number;
 };
 export type SegmentationQuality = "low" | "medium" | "high";
 export type SegmentationModelOptions = {
@@ -29,3 +34,24 @@ export type SegmentationModelOptions = {
      */
     quality?: SegmentationQuality;
 };
+/**
+ * Category-segmentation presets served by `XRModel.SEMANTIC_SEGMENTATION`.
+ * `hair` runs MediaPipe's Hair Segmenter (`bg` / `hair`); `multiclass` runs
+ * the Selfie Multiclass model (`bg`, `hair`, `body_skin`, `face_skin`,
+ * `clothes`, `others`); `nails` runs the SDK's fingernail segmenter (`bg` /
+ * `nail`, a 1.9 M-parameter U-Net, best with the short edge near 128 px).
+ * One preset per session: the first acquirer decides.
+ */
+export declare const SEMANTIC_SEGMENTATION_PRESETS: readonly ["hair", "multiclass", "nails"];
+export type SemanticSegmentationPreset = (typeof SEMANTIC_SEGMENTATION_PRESETS)[number];
+export type SemanticSegmentationModelOptions = {
+    preset?: SemanticSegmentationPreset;
+    /**
+     * Override the model asset URL. Defaults to the SDK CDN path for the
+     * preset, which is integrity-verified; a custom URL is fetched best-effort.
+     */
+    modelUrl?: string;
+    /** Process-canvas scale relative to the feed: low 0.5, medium 0.75, high 1. Default medium. */
+    quality?: SegmentationQuality;
+};
+export type SemanticSegmentationStatus = "loading" | "ready" | "error";

package/dist/types/session.d.ts

@@ -1,8 +1,9 @@
 import { XRMediaSource, XRModel } from '../constants';
-import { XRMediaSourceKind } from './compositor';
+import { XRCameraFacing, XRCameraRequest, XRMediaSourceKind } from './compositor';
 import { BodyModelOptions } from './body';
 import { FaceModelOptions } from './face';
-import { SegmentationModelOptions } from './segmentation';
+import { HolisticModelOptions } from './holistic';
+import { SegmentationModelOptions, SemanticSegmentationModelOptions } from './segmentation';
 export declare enum SessionStatus {
     ACTIVE = "ACTIVE",
     DISABLED = "DISABLED"
@@ -18,6 +19,19 @@ export type Session = {
 type SetMediaSourceWebcamParams = {
     source: XRMediaSource.WEBCAM;
     sourceKind?: "webcam";
+    /**
+     * Which camera to open: `user` (front, default) or `environment` (rear).
+     * Binding again with a different facing swaps the camera mid-session.
+     */
+    facingMode?: XRCameraFacing;
+    /** A specific camera from `enumerateDevices()`; beats `facingMode` when set. */
+    deviceId?: string;
+    /**
+     * Mirror override. Default: the front camera is mirrored (`sourceKind`
+     * `"webcam"`), the rear camera is drawn straight (`sourceKind`
+     * `"rear-camera"`). Set explicitly for a camera whose facing is unknown.
+     */
+    mirrored?: boolean;
 };
 type SetMediaSourceStreamParams = {
     source: XRMediaSource.STREAM;
@@ -44,9 +58,15 @@ export type RegisterXRPipelineParams = Array<{
 } | {
     model: XRModel.FACE_TRACKER;
     options?: FaceModelOptions;
+} | {
+    model: XRModel.HOLISTIC_TRACKER;
+    options?: HolisticModelOptions;
 } | {
     model: XRModel.BACKGROUND_SEGMENTATION;
     options?: SegmentationModelOptions;
+} | {
+    model: XRModel.SEMANTIC_SEGMENTATION;
+    options?: SemanticSegmentationModelOptions;
 }>;
 /**
  * Public XR session surface. Returned by `useXRContext().session` and used
@@ -62,7 +82,10 @@ export type RegisterXRPipelineParams = Array<{
  * Lifecycle:
  *
  *     idle ──setMediaSource──> media-bound ──start──> running ──stop──> stopped
- *                                   ↑                                       │
+ *                                   ↑                 │    ↑                │
+ *                                   │           pause │    │ resume          │
+ *                                   │                 ▼    │                │
+ *                                   │               paused ─┘               │
  *                                   └────────────reset──────────────────────┘
  */
 export type XRSession = {
@@ -83,6 +106,21 @@ export type XRSession = {
      * `stop()` + clear the model registry. Returns the session to `idle`.
      */
     reset: () => Promise<void>;
+    /**
+     * Suspend a `running` session without releasing the camera: the feed loop
+     * stops, every model pauses, the video element pauses. No-op in any other
+     * state. `resume()` (or `start()`) continues with no rebind.
+     */
+    pause: () => void;
+    /** Continue a `paused` session. No-op in any other state. */
+    resume: () => Promise<void>;
+    /**
+     * Open another camera (`facingMode` / `deviceId`, optional `mirrored`
+     * override) and keep going: models, lifecycle and scene stay; a
+     * `media-bound` / `stopped` session is started. Resolves to the facing the
+     * session ended up with (a single-camera device answers with what it has).
+     */
+    switchCamera: (request?: XRCameraRequest) => Promise<XRCameraFacing>;
     /**
      * @deprecated Prefer `useXRModel(modelName, options)`. Kept as an
      * additive shim for backwards compatibility — multiple calls are
@@ -95,8 +133,16 @@ export type XRSession = {
      * dataURL. Use from a gesture or state callback (e.g. on capture trigger)
      * to grab the visible frame as a photo. Returns the dataURL string.
      *
-     * Throws `XRError` if called before `<XRScene>` has mounted.
+     * Throws `XRError` if no active `<XRScene>` or `<XRMediaSurface>` capture
+     * target has mounted.
      */
     captureFrame: () => string;
+    /**
+     * Captures the same active XRScene or XRMediaSurface composition as a
+     * MediaStream for use with `useMediaRecorder`.
+     */
+    captureStream: (fps?: number) => MediaStream;
+    /** Current tracker-input frame. Read-only; reused and repainted by the session. */
+    getInputFrame: () => OffscreenCanvas | HTMLCanvasElement | null;
 };
 export {};

package/dist/types/tracking.d.ts

@@ -9,7 +9,13 @@
  * The lists below are the v1 enumeration. New entries can be added
  * non-breakingly as additional landmarks/joints become supported.
  */
-export type FaceTarget = "face.forehead" | "face.noseTip" | "face.chin" | "face.leftEyeOuter" | "face.rightEyeOuter" | "face.leftCheek" | "face.rightCheek" | "face.mouthCenter";
+export type FaceTarget = "face.custom" | "face.center" | "face.forehead" | "face.noseTip" | "face.chin" | "face.leftEyeOuter" | "face.rightEyeOuter" | "face.leftCheek" | "face.rightCheek" | "face.mouthCenter" | "face.leftEye" | "face.rightEye" | "face.leftEarlobe" | "face.rightEarlobe";
+/** Face-local point: X/Y are clamped to [-1, 1], origin is face center, and +Z points toward camera. */
+export type FaceCustomAnchorPoint = {
+    x: number;
+    y: number;
+    z: number;
+};
 export type HandTarget = "hand.wrist" | "hand.thumbTip" | "hand.indexTip" | "hand.middleTip" | "hand.ringTip" | "hand.pinkyTip" | "hand.indexBase" | "hand.middleBase" | "hand.ringBase" | "hand.pinkyBase";
 export type BodyTarget = "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";
 /**
@@ -20,7 +26,7 @@ export type TrackingTarget = FaceTarget | HandTarget | BodyTarget;
  * Tracker type identifier exposed via tracker context.
  */
 export type TrackerType = "face" | "hand" | "body";
-export declare const FACE_TARGETS: readonly ["face.forehead", "face.noseTip", "face.chin", "face.leftEyeOuter", "face.rightEyeOuter", "face.leftCheek", "face.rightCheek", "face.mouthCenter"];
+export declare const FACE_TARGETS: readonly ["face.center", "face.forehead", "face.noseTip", "face.chin", "face.leftEyeOuter", "face.rightEyeOuter", "face.leftCheek", "face.rightCheek", "face.mouthCenter", "face.leftEye", "face.rightEye", "face.leftEarlobe", "face.rightEarlobe", "face.custom"];
 export declare const HAND_TARGETS: readonly ["hand.wrist", "hand.thumbTip", "hand.indexTip", "hand.middleTip", "hand.ringTip", "hand.pinkyTip", "hand.indexBase", "hand.middleBase", "hand.ringBase", "hand.pinkyBase"];
 export declare const BODY_TARGETS: readonly ["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"];
 /**

package/dist/types/util-types.d.ts

@@ -1 +1 @@
-export type Class<T> = new (...args: any[]) => T;
+export type Class<T> = new (...args: never[]) => T;

package/dist/useBodies-BYzJpQ4L.js

@@ -0,0 +1,75 @@
+import { useFrame as S } from "@react-three/fiber";
+import { useState as g, useRef as f, useCallback as M, useId as h, useEffect as j } from "react";
+import { f as p, g as C, h as E, X as m, j as I } from "./index-CKRN-xJp.js";
+import { u as v } from "./landmarks-DtCAFV_m.js";
+const X = (t, o) => {
+  var r;
+  for (let n = 0; n < m.body.max; n += 1)
+    if (((r = t == null ? void 0 : t.getBodyPose) == null ? void 0 : r.call(t, n)) === o) return n;
+  return null;
+}, _ = ({ bodyId: t, subject: o, numBodies: r }) => r ?? (t !== void 0 || o ? 2 : 1), T = (t, { bodyIndex: o = 0, bodyId: r, subject: n }, u = p) => {
+  var d, a;
+  const s = ((d = t == null ? void 0 : t.getBodies) == null ? void 0 : d.call(t)) ?? [], i = (e) => e ? { ...e, index: e.held ? null : X(t, e.pose) } : null;
+  if (r !== void 0)
+    return { body: i(s.find((e) => e.id === r)), memory: u };
+  if (n) {
+    const e = C(E(s), n, u);
+    return {
+      body: e.index === null ? null : i(s[e.index]),
+      memory: e.memory
+    };
+  }
+  const c = ((a = t == null ? void 0 : t.getBodyPose) == null ? void 0 : a.call(t, o)) ?? null;
+  if (!c) return { body: null, memory: u };
+  const l = s.find((e) => e.pose === c);
+  return { body: { pose: c, id: (l == null ? void 0 : l.id) ?? null, held: !1, index: o }, memory: u };
+}, R = (t, o = !0, r) => {
+  const n = h(), { ready: u, node: s } = v(
+    I.BODY_TRACKER,
+    r,
+    o
+  ), i = Math.min(
+    m.body.max,
+    Math.max(1, Number.isFinite(t) ? Math.round(t) : 1)
+  );
+  return j(() => {
+    var c;
+    return (c = s == null ? void 0 : s.requestBodies) == null ? void 0 : c.call(s, n, i);
+  }, [s, n, i]), { ready: u, node: s };
+}, Y = ({
+  numBodies: t = m.body.max,
+  active: o = !0
+} = {}) => {
+  const { node: r } = R(t, o), [n, u] = g([]), s = f("");
+  return S(() => {
+    var l;
+    const i = (((l = r == null ? void 0 : r.getBodies) == null ? void 0 : l.call(r)) ?? []).map((d) => d.id), c = i.join(",");
+    c !== s.current && (s.current = c, u(i));
+  }), n;
+}, w = ({
+  active: t = !0,
+  acquireOptions: o,
+  ...r
+} = {}) => {
+  const { ready: n, node: u } = R(_(r), t, o), s = f(r);
+  s.current = r;
+  const i = f(p), c = f(null), l = M(() => {
+    var x, B;
+    const a = s.current, e = (x = u == null ? void 0 : u.getBodies) == null ? void 0 : x.call(u), b = JSON.stringify([a.bodyId, a.subject, a.bodyIndex]);
+    if (e && ((B = c.current) == null ? void 0 : B.bodies) === e && c.current.key === b)
+      return c.current.body;
+    const y = T(u, a, i.current);
+    return i.current = y.memory, c.current = e ? { bodies: e, key: b, body: y.body } : null, y.body;
+  }, [u]), d = M(() => {
+    var y;
+    const { bodyId: a, subject: e, bodyIndex: b = 0 } = s.current;
+    return a !== void 0 || e ? ((y = l()) == null ? void 0 : y.index) ?? null : b;
+  }, [l]);
+  return { ready: n, node: u, read: l, index: d };
+};
+export {
+  Y as a,
+  _ as b,
+  T as r,
+  w as u
+};

package/dist/useBodies-Cxpmx6Bb.cjs

@@ -0,0 +1 @@
+"use strict";const C=require("@react-three/fiber"),y=require("react"),b=require("./index-Sho4F4it.cjs"),E=require("./landmarks-BEjJXcnE.cjs"),_=(e,o)=>{var t;for(let c=0;c<b.XR_MAX_SUBJECTS.body.max;c+=1)if(((t=e==null?void 0:e.getBodyPose)==null?void 0:t.call(e,c))===o)return c;return null},R=({bodyId:e,subject:o,numBodies:t})=>t??(e!==void 0||o?2:1),S=(e,{bodyIndex:o=0,bodyId:t,subject:c},u=b.EMPTY_SUBJECT_MEMORY)=>{var a,d;const s=((a=e==null?void 0:e.getBodies)==null?void 0:a.call(e))??[],i=r=>r?{...r,index:r.held?null:_(e,r.pose)}:null;if(t!==void 0)return{body:i(s.find(r=>r.id===t)),memory:u};if(c){const r=b.selectSubject(b.bodyCandidates(s),c,u);return{body:r.index===null?null:i(s[r.index]),memory:r.memory}}const n=((d=e==null?void 0:e.getBodyPose)==null?void 0:d.call(e,o))??null;if(!n)return{body:null,memory:u};const l=s.find(r=>r.pose===n);return{body:{pose:n,id:(l==null?void 0:l.id)??null,held:!1,index:o},memory:u}},m=(e,o=!0,t)=>{const c=y.useId(),{ready:u,node:s}=E.useXRModel(b.XRModel.BODY_TRACKER,t,o),i=Math.min(b.XR_MAX_SUBJECTS.body.max,Math.max(1,Number.isFinite(e)?Math.round(e):1));return y.useEffect(()=>{var n;return(n=s==null?void 0:s.requestBodies)==null?void 0:n.call(s,c,i)},[s,c,i]),{ready:u,node:s}},j=({numBodies:e=b.XR_MAX_SUBJECTS.body.max,active:o=!0}={})=>{const{node:t}=m(e,o),[c,u]=y.useState([]),s=y.useRef("");return C.useFrame(()=>{var l;const i=(((l=t==null?void 0:t.getBodies)==null?void 0:l.call(t))??[]).map(a=>a.id),n=i.join(",");n!==s.current&&(s.current=n,u(i))}),c},T=({active:e=!0,acquireOptions:o,...t}={})=>{const{ready:c,node:u}=m(R(t),e,o),s=y.useRef(t);s.current=t;const i=y.useRef(b.EMPTY_SUBJECT_MEMORY),n=y.useRef(null),l=y.useCallback(()=>{var x,M;const d=s.current,r=(x=u==null?void 0:u.getBodies)==null?void 0:x.call(u),B=JSON.stringify([d.bodyId,d.subject,d.bodyIndex]);if(r&&((M=n.current)==null?void 0:M.bodies)===r&&n.current.key===B)return n.current.body;const f=S(u,d,i.current);return i.current=f.memory,n.current=r?{bodies:r,key:B,body:f.body}:null,f.body},[u]),a=y.useCallback(()=>{var f;const{bodyId:d,subject:r,bodyIndex:B=0}=s.current;return d!==void 0||r?((f=l())==null?void 0:f.index)??null:B},[l]);return{ready:c,node:u,read:l,index:a}};exports.bodySubjectCount=R;exports.resolveBody=S;exports.useBodyIds=j;exports.useBodySubject=T;

package/dist/useFaceInfo-BzEUj2OI.js

@@ -0,0 +1,75 @@
+import { useMemo as x, useEffect as h, useCallback as p, useRef as R } from "react";
+import { X as E, j as C, f as N, g as _ } from "./index-CKRN-xJp.js";
+import { useThree as b } from "@react-three/fiber";
+import { g as y } from "./getFaceInfo-BafgGT27.js";
+import { u as T } from "./useFaceResultReader-Cc4Qrutf.js";
+import { u as S } from "./landmarks-DtCAFV_m.js";
+const X = ({
+  active: i = !0,
+  holdMs: l = 250,
+  numFaces: r = 1,
+  targetFps: s,
+  throttleMs: o = 16
+} = {}) => {
+  const { camera: t } = b(), u = Number.isFinite(r) ? Math.min(E.face.max, Math.max(1, Math.round(r))) : 1, m = s !== void 0 && Number.isFinite(s) && s > 0 ? s : void 0, e = x(
+    () => ({
+      numFaces: u,
+      ...m ? { targetFps: m } : {}
+    }),
+    [u, m]
+  ), { node: n, ready: c } = S(
+    C.FACE_TRACKER,
+    e,
+    i
+  );
+  h(() => {
+    if (n)
+      for (let a = 0; a < e.numFaces; a += 1)
+        n.setCamera(t, a);
+  }, [e.numFaces, t, n]);
+  const d = p(
+    (a) => {
+      if (!n) return [];
+      const F = [];
+      for (let f = 0; f < a.faceLandmarks.length; f += 1) {
+        const M = y(n, a, f);
+        M && F.push(M);
+      }
+      return F;
+    },
+    [n]
+  );
+  return T({
+    enabled: i && c,
+    holdMs: Number.isFinite(l) ? Math.max(0, l) : 250,
+    node: n,
+    prepare: d,
+    throttleMs: Number.isFinite(o) ? Math.max(0, o) : 16
+  });
+}, A = 4, J = ({
+  faceIndex: i = 0,
+  numFaces: l,
+  subject: r,
+  ...s
+} = {}) => {
+  const o = Number.isFinite(i) ? Math.max(0, Math.round(i)) : 0, t = X({
+    ...s,
+    numFaces: Math.max(l ?? (r ? A : o + 1), o + 1)
+  }), u = R(N), m = JSON.stringify(r ?? null), e = x(() => {
+    if (!r) return null;
+    const n = t.map((c, d) => ({
+      index: d,
+      center: { x: c.bounds.centerX, y: c.bounds.centerY },
+      size: c.bounds.width
+    }));
+    return _(n, r, u.current);
+  }, [t, m]);
+  return h(() => {
+    e && (u.current = e.memory);
+  }, [e]), r ? e && e.index !== null ? t[e.index] ?? null : null : t[o] ?? null;
+};
+export {
+  A as D,
+  J as a,
+  X as u
+};

package/dist/useFaceInfo-DlLRAVNw.cjs

@@ -0,0 +1 @@
+"use strict";const i=require("react"),f=require("./index-Sho4F4it.cjs"),_=require("@react-three/fiber"),C=require("./getFaceInfo-BzlwHMjX.cjs"),N=require("./useFaceResultReader-D3jOQNKz.cjs"),b=require("./landmarks-BEjJXcnE.cjs"),h=({active:c=!0,holdMs:d=250,numFaces:r=1,targetFps:t,throttleMs:u=16}={})=>{const{camera:s}=_.useThree(),a=Number.isFinite(r)?Math.min(f.XR_MAX_SUBJECTS.face.max,Math.max(1,Math.round(r))):1,l=t!==void 0&&Number.isFinite(t)&&t>0?t:void 0,e=i.useMemo(()=>({numFaces:a,...l?{targetFps:l}:{}}),[a,l]),{node:n,ready:m}=b.useXRModel(f.XRModel.FACE_TRACKER,e,c);i.useEffect(()=>{if(n)for(let o=0;o<e.numFaces;o+=1)n.setCamera(s,o)},[e.numFaces,s,n]);const F=i.useCallback(o=>{if(!n)return[];const x=[];for(let M=0;M<o.faceLandmarks.length;M+=1){const R=C.getFaceInfoFromResults(n,o,M);R&&x.push(R)}return x},[n]);return N.useFaceResultReader({enabled:c&&m,holdMs:Number.isFinite(d)?Math.max(0,d):250,node:n,prepare:F,throttleMs:Number.isFinite(u)?Math.max(0,u):16})},E=4,T=({faceIndex:c=0,numFaces:d,subject:r,...t}={})=>{const u=Number.isFinite(c)?Math.max(0,Math.round(c)):0,s=h({...t,numFaces:Math.max(d??(r?E:u+1),u+1)}),a=i.useRef(f.EMPTY_SUBJECT_MEMORY),l=JSON.stringify(r??null),e=i.useMemo(()=>{if(!r)return null;const n=s.map((m,F)=>({index:F,center:{x:m.bounds.centerX,y:m.bounds.centerY},size:m.bounds.width}));return f.selectSubject(n,r,a.current)},[s,l]);return i.useEffect(()=>{e&&(a.current=e.memory)},[e]),r?e&&e.index!==null?s[e.index]??null:null:s[u]??null};exports.DEFAULT_POLICY_NUM_FACES=E;exports.useFaceInfo=T;exports.useFaceInfos=h;