@vincentt-xr/sdk 2.0.0-alpha.0

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

@@ -0,0 +1,44 @@
+import { ReactNode } from 'react';
+import { SegmentationType } from '../../types/segmentation';
+type SegmentationProps = {
+    /** Which segmentation pipeline to enable. v1 supports `"portrait"`. */
+    type: SegmentationType;
+    /**
+     * When `false`, the segmentation pipeline is still acquired (for instant
+     * re-enable) but the mask is not exposed to consumers like VideoBackground.
+     * Children always render — Segmentation is an effect provider, not a
+     * visual container.
+     */
+    visible?: boolean;
+    /**
+     * Whether the segmentation pipeline should run. `false` pauses the shared
+     * model's per-frame inference (and its expensive GPU→CPU readback) while
+     * keeping it mounted and initialized, so gating it off costs nothing yet
+     * flipping back to `true` resumes instantly — no unmount, no registry
+     * re-acquire race. Distinct from `visible`, which only gates mask exposure
+     * while inference keeps running. When several consumers share the model, it
+     * runs while any is active. Defaults to `true`.
+     */
+    active?: boolean;
+    /**
+     * Children are rendered as-is via a fragment. Segmentation has no
+     * geometry or transform of its own — it only registers the pipeline —
+     * so nesting children here is equivalent to placing them as siblings.
+     * This allows scene trees where a VideoBackground is grouped under its
+     * Segmentation provider to still render correctly.
+     */
+    children?: ReactNode;
+};
+/**
+ * Declarative scene-level component that enables a segmentation
+ * pipeline. Renders no visible geometry — its only effect is to
+ * declare a refcount on the BACKGROUND_SEGMENTATION model for as long
+ * as it is mounted via `useXRModel`. Multiple `<Segmentation>` instances
+ * (or a `<Segmentation>` plus a `<VideoBackground segmentation="…">`)
+ * share one underlying model instance.
+ *
+ * `<VideoBackground segmentation="…">` consumes the resulting mask by
+ * subscribing to the same model node via `useXRModelNode`.
+ */
+export declare const Segmentation: ({ type, active, children }: SegmentationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SpriteAnimation/index.d.ts

@@ -0,0 +1,52 @@
+import { ScreenAnchorEdges } from '../ScreenSpaceUI/ScreenTransform';
+/**
+ * The UV offset for frame `idx` of a `cols`x`rows` atlas. Frames read
+ * left-to-right, top-to-bottom. three UVs are bottom-left origin but atlas rows
+ * read top-down, so the row is flipped: the FIRST frame (row 0) sits at the TOP
+ * of the sheet, which is the HIGHEST v-offset. Pair with `repeat = (1/cols,
+ * 1/rows)`. Exported for the unit test that guards the row-flip.
+ */
+export declare const spriteCellUV: (idx: number, cols: number, rows: number) => {
+    x: number;
+    y: number;
+};
+/**
+ * One transparent WebP sprite-sheet atlas describing an animation: `cols`x`rows`
+ * cells, the first `frames` read left-to-right, top-to-bottom, played at `fps`.
+ *
+ * This is the platform's animated-transparent-overlay primitive. It is a single
+ * static GPU texture with a per-frame UV offset, so there is no video decode:
+ * it works in every native and in-app browser, has no autoplay policy, and costs
+ * ~zero decode/heat. Prefer it over transparent video, which has no universal
+ * codec (HEVC-alpha is iOS-only; VP8/VP9-alpha WebM renders blank on iOS Safari)
+ * and overheats the device when decoded alongside face tracking. Pair opaque
+ * H.264 video only for full-frame backgrounds.
+ */
+export type SpriteSheet = {
+    /** URL of the transparent WebP atlas (real 8-bit alpha; export with cwebp, not
+     *  ffmpeg's libwebp which drops alpha). */
+    url: string;
+    cols: number;
+    rows: number;
+    /** Frames to play (may be fewer than cols*rows if the last cells are blank). */
+    frames: number;
+    fps: number;
+};
+export type SpriteAnimationProps = {
+    sheet: SpriteSheet;
+    /** Where to place the overlay. Defaults to full-screen. */
+    anchors?: ScreenAnchorEdges;
+    /** Frame width/height. When set, the sheet is contain-fit into the anchor rect
+     *  (no stretch); omit for a plane that fills the rect exactly. */
+    contentAspect?: number;
+    renderOrder?: number;
+    name?: string;
+};
+/**
+ * Plays a sprite-sheet animation as a screen-space overlay (a frame border, a
+ * gesture-instruction graphic, an animated sticker). Transparent, animated,
+ * GPU-cheap, and identical in every browser. Defaults to full-screen; pass
+ * `anchors` to place it and `contentAspect` (frame width/height) to contain-fit
+ * without stretching. Must live inside a `<ScreenSpaceUI>`.
+ */
+export declare const SpriteAnimation: ({ sheet, anchors, contentAspect, renderOrder, name, }: SpriteAnimationProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/TextLabel/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * `<TextLabel>` — a text label drawn into a CanvasTexture and rendered as
+ * a single mesh. First-class scene-tree primitive so lifecycle scripts
+ * don't have to hand-paint canvas textures for every quiz question,
+ * progress indicator, or floating answer.
+ *
+ * Sizes itself 1×1 in world units; use `scale` on the JSX node or a
+ * parent `<ScreenTransform>` / `<TrackingAnchor>` to place it.
+ *
+ * Word-wraps automatically inside the panel's width; when there are too
+ * many lines for the chosen font size, the font shrinks one step before
+ * the text is allowed to clip.
+ */
+export type TextLabelProps = {
+    /** The text to render. Required. */
+    text: string;
+    /** Text color. Default `#ffffff`. */
+    color?: string;
+    /** Font weight. Default `bold`. */
+    fontWeight?: "normal" | "bold" | number;
+    /** Font family. Default `Arial, sans-serif`. */
+    fontFamily?: string;
+    /**
+     * Font size in canvas px at the default 512px resolution. Roughly maps
+     * to "10pt" → 28, "12pt" → 36, "16pt" → 48, etc. Default 48.
+     */
+    fontSize?: number;
+    /** Panel background color. Use `'transparent'` for text-only. Default `rgba(20,40,110,0.88)`. */
+    bgColor?: string;
+    /** Optional border color. Omit for no border. */
+    borderColor?: string;
+    /** Border thickness. Default 0. */
+    borderWidth?: number;
+    /** Corner radius. Use 0 for square. Default 24. */
+    borderRadius?: number;
+    /** Inner padding in canvas px. Default 32. */
+    padding?: number;
+    /**
+     * Aspect ratio (width / height). The mesh itself is always 1×1; this
+     * controls how the texture canvas is shaped so wrapping and corner
+     * radius read correctly when the label isn't square. Default 2.5
+     * (roughly banner-shaped).
+     */
+    aspect?: number;
+    /** Canvas resolution (height in px). Default 512. */
+    resolution?: number;
+    /** Material opacity multiplier. Default 1. */
+    opacity?: number;
+    /** Optional `name` for runtime `getObjectByName` lookups. */
+    name?: string;
+    /** Ignore depth — appropriate for overlay UI. Default true. */
+    overlay?: boolean;
+    /** Local position offset, forwarded to the underlying mesh. */
+    position?: [number, number, number];
+    /** Local rotation (Euler radians), forwarded to the underlying mesh. */
+    rotation?: [number, number, number];
+    /** Local scale, forwarded to the underlying mesh. */
+    scale?: [number, number, number] | number;
+    /** Mesh visibility, forwarded so descendants inherit correctly. */
+    visible?: boolean;
+};
+export declare function TextLabel(props: TextLabelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/TrackingAnchor/index.d.ts

@@ -0,0 +1,74 @@
+import { PropsWithChildren } from 'react';
+import { TrackingTarget } from '../../types/tracking';
+import * as THREE from "three";
+/**
+ * Frame-rate-independent lerp factor for a given smoothing rate and frame
+ * delta: `alpha = 1 - e^(-smoothing*dt)`. Same rate produces the same visual
+ * smoothing whether the render loop ticks at 30 or 120fps (a fixed per-frame
+ * alpha would smooth twice as fast at double the frame rate). `smoothing <= 0`
+ * returns 1 (snap). Exported for the unit test.
+ */
+export declare const smoothingAlpha: (smoothing: number, dt: number) => number;
+/**
+ * One Euro Filter — the standard adaptive low-pass for smoothing noisy,
+ * low-rate interactive tracking (it's what MediaPipe's own hand/face demos use).
+ *
+ * Why not velocity extrapolation: inference is throttled (~24fps) but rendering
+ * runs at 60-120fps, so the raw sample holds then jumps. Extrapolating forward
+ * on the per-sample velocity *overshoots* — the estimate is noisy, so the anchor
+ * coasts past the target and the next sample yanks it back, a visible sawtooth
+ * wobble. This filter takes the opposite approach: it never predicts ahead (so
+ * it cannot overshoot); instead it varies its own smoothing by speed. When the
+ * landmark moves slowly the cutoff is low → heavy smoothing kills jitter; when
+ * it moves fast the cutoff rises → light smoothing kills lag. That adaptivity is
+ * what a fixed lerp can't do — a fixed lerp must trade jitter against lag, and at
+ * 24fps→60fps neither setting is good.
+ *
+ * `minCutoff` sets the floor smoothing (lower = smoother at rest, more lag);
+ * `beta` sets how much speed loosens it (higher = less lag when moving, but more
+ * jitter passes). `dcutoff` smooths the internal speed estimate. These map from
+ * the single `smoothing` prop below. Operates per-axis on a Vec3.
+ */
+export type OneEuroState = {
+    /** Filtered position (the value to render). */
+    pos: THREE.Vector3;
+    /** Previous raw sample, for the derivative. */
+    prevRaw: THREE.Vector3;
+    /** Filtered derivative (units/sec), per axis. */
+    dxHat: THREE.Vector3;
+    initialized: boolean;
+};
+/**
+ * One frame of the One Euro Filter, pure so it can be unit-tested without a
+ * scene. Mutates and returns `state`. `dt` is the render frame delta (seconds).
+ * `minCutoff`/`beta`/`dcutoff` are the filter params (see type doc). Filters
+ * each axis independently. On the first sample it seeds without smoothing.
+ */
+export declare const stepOneEuro: (state: OneEuroState, sample: THREE.Vector3, dt: number, minCutoff: number, beta: number, dcutoff: number) => OneEuroState;
+type TrackingAnchorProps = PropsWithChildren & {
+    /**
+     * Landmark/joint to attach to. The namespace prefix (`face.`, `hand.`,
+     * `body.`) MUST match the type of the nearest ancestor tracker —
+     * mismatched anchors render `null` and emit a console warning.
+     */
+    target: TrackingTarget;
+    /** Optional offset applied in the tracker's local frame after resolution. */
+    offset?: [number, number, number];
+    /**
+     * Position-smoothing amount. Inference is throttled (the `perf` API caps it at
+     * 24fps by default) while rendering runs at 60-120fps, so a raw anchor holds
+     * then jumps on each new sample — visible stepping under head/hand movement. A
+     * plain lerp only hides it at rest; under motion it still steps. With
+     * `smoothing > 0` the anchor runs a **One Euro filter** (the standard adaptive
+     * low-pass for interactive tracking): it smooths hard when the landmark moves
+     * slowly (kills jitter) and loosens as it speeds up (kills lag), and never
+     * extrapolates so it can't overshoot. Higher `smoothing` is snappier (less
+     * lag, slightly more jitter); lower is smoother; ~12-20 is a good range. It
+     * snaps (resets the filter) on first placement and on re-acquire after the
+     * face/hand was lost, so it never slides in from a stale position. `0`
+     * (default) keeps the raw snap-every-frame behavior. Rotation is not smoothed.
+     */
+    smoothing?: number;
+};
+export declare const TrackingAnchor: ({ target, offset, smoothing, children, }: TrackingAnchorProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/VideoBackground/index.d.ts

@@ -0,0 +1,38 @@
+import { Texture } from 'three';
+import { SegmentationType } from '../../types/segmentation';
+export type VideoBackgroundProps = {
+    /**
+     * Optional segmentation mask texture.
+     * When provided, the person area becomes transparent (alpha=0)
+     * and the background area remains opaque (alpha=255).
+     *
+     * Prefer the higher-level `segmentation` prop, which auto-resolves
+     * the mask from a `<Segmentation>` component mounted in the scene.
+     * `segmentationMask` is retained for advanced/imperative use.
+     */
+    segmentationMask?: Texture;
+    /**
+     * Declarative segmentation type to consume. When set, `VideoBackground`
+     * automatically resolves the matching mask texture from the xr-sdk
+     * runtime — there must be a `<Segmentation type="…">` component of the
+     * same type mounted somewhere in the scene tree.
+     */
+    segmentation?: SegmentationType;
+    /**
+     * When true, inverts the segmentation mask so the person area is
+     * replaced by the custom background color while the real-world
+     * background remains visible from the camera feed.
+     */
+    invert?: boolean;
+    /**
+     * Optional custom background texture or color.
+     * Shows through the transparent person area when segmentation is enabled.
+     */
+    customBackground?: Texture | string;
+    /**
+     * Render order for the video background layer.
+     * Default: `RENDER_LAYERS.BACKGROUND` (`-1000`).
+     */
+    renderOrder?: number;
+};
+export declare const VideoBackground: ({ segmentationMask, segmentation, invert, customBackground, renderOrder, }: VideoBackgroundProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/XRCompositor/index.d.ts

@@ -0,0 +1,5 @@
+import { CSSProperties, PropsWithChildren } from 'react';
+export declare const XRCompositor: ({ background, children, style, }: PropsWithChildren<{
+    background?: CSSProperties["background"];
+    style?: CSSProperties;
+}>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/XRDebugView/index.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from 'react';
+export declare const XRDebugView: ({ children, defaultCollapsed, title, width, }: PropsWithChildren<{
+    defaultCollapsed?: boolean;
+    title: string;
+    width?: number;
+}>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/XRLayer/index.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from 'react';
+import { XRLayerConfig } from '../../types/compositor';
+export declare const XRLayer: ({ children, config, style, }: PropsWithChildren<{
+    config: XRLayerConfig;
+    style?: React.CSSProperties;
+}>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/XRMediaSurface/index.d.ts

@@ -0,0 +1,27 @@
+import { RefObject } from 'react';
+import { XRLayerConfig, XRMediaLayout, XRMediaSourceKind } from '../../types/compositor';
+export declare const XRMediaSurface: ({ canvasRef, imageRef, layer, layout, mirrored, sourceKind, videoRef, }: {
+    canvasRef: RefObject<HTMLCanvasElement>;
+    imageRef: RefObject<HTMLImageElement>;
+    layer: XRLayerConfig;
+    layout: XRMediaLayout | null;
+    mirrored: boolean;
+    sourceKind: XRMediaSourceKind;
+    videoRef: RefObject<HTMLVideoElement>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const XRTrackingOverlay: ({ canvasRef, controlInsetTop, debugVisible, fps, imageRef, layer, layout, mirrored, sourceKind, videoRef, viewportSize, }: {
+    canvasRef: RefObject<HTMLCanvasElement>;
+    controlInsetTop?: number;
+    debugVisible: boolean;
+    fps?: number;
+    imageRef: RefObject<HTMLImageElement>;
+    layer: XRLayerConfig;
+    layout: XRMediaLayout | null;
+    mirrored: boolean;
+    sourceKind: XRMediaSourceKind;
+    videoRef: RefObject<HTMLVideoElement>;
+    viewportSize: {
+        width: number;
+        height: number;
+    };
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/XRProvider/index.d.ts

@@ -0,0 +1,13 @@
+import { PropsWithChildren } from 'react';
+import { SessionFacade } from '../../hooks/useXRSession';
+import { XRPerfConfig } from '../../types';
+export type XRContextType = {
+    session: SessionFacade;
+};
+export declare const useXRContext: () => XRContextType;
+export type XRProviderProps = PropsWithChildren<{
+    /** Performance config: cap ML inference fps and camera resolution to reduce
+     *  GPU/CPU load and heat. See {@link XRPerfConfig}. */
+    perf?: XRPerfConfig;
+}>;
+export declare const XRProvider: ({ children, perf }: XRProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/XRScene/defaults.d.ts

@@ -0,0 +1,4 @@
+export declare const DefaultLoadingComponent: () => import("react/jsx-runtime").JSX.Element;
+export declare const DefaultErrorComponent: (props: {
+    error: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/XRScene/index.d.ts

@@ -0,0 +1,15 @@
+import { CanvasProps } from '@react-three/fiber';
+import { default as React, PropsWithChildren } from 'react';
+type XRSceneProps = PropsWithChildren & {
+    style?: React.CSSProperties;
+    canvasProps?: CanvasProps & React.RefAttributes<HTMLCanvasElement>;
+    loadingComponent?: React.ReactNode;
+    loadingTransitionDuration?: number;
+    errorComponent?: React.ReactNode;
+    renderTargetSize?: {
+        width: number;
+        height: number;
+    };
+};
+export declare const XRScene: ({ style, canvasProps, children, loadingComponent, loadingTransitionDuration, errorComponent, renderTargetSize, }: XRSceneProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/XRViewport/index.d.ts

@@ -0,0 +1,101 @@
+import { CSSProperties, ReactNode } from 'react';
+import { CalibrationMediaSourceKind } from '../../hooks/useCalibrationFaceTracker';
+import { XRMediaLayout } from '../../types/compositor';
+import { FaceTrackingResult } from '../../types/face';
+import { XRModelNodeFaceTracking } from '../../types/nodes';
+export type XRViewportMode = "dom" | "r3f" | "hybrid";
+export type XRViewportSourceKind = "webcam" | "image" | "video";
+export type XRViewportFitMode = "auto" | "cover" | "contain";
+export type XRViewportMediaStrategy = "internal" | "external";
+export type XRViewportMediaAssetOption = {
+    id: string;
+    label: string;
+    src: string;
+};
+export type XRViewportSourceConfig = {
+    kind: "webcam";
+} | {
+    kind: "image";
+    assetId?: string;
+} | {
+    kind: "video";
+    assetId?: string;
+};
+export type XRViewportSize = {
+    width: number;
+    height: number;
+};
+export type XRViewportRenderState = {
+    activeDelegate: "GPU" | "CPU" | null;
+    faces: FaceTrackingResult[];
+    imageOptions: XRViewportMediaAssetOption[];
+    layout: XRMediaLayout | null;
+    mediaError: string | null;
+    mediaFitMode: Exclude<XRViewportFitMode, "auto">;
+    mediaLabel: string;
+    mediaStatus: "idle" | "requesting" | "ready" | "error";
+    mirrored: boolean;
+    selectedImageId: string;
+    selectedSource: XRViewportSourceKind;
+    selectedVideoId: string;
+    setMirrored: (value: boolean) => void;
+    setSelectedImageId: (value: string) => void;
+    setSelectedSource: (value: XRViewportSourceKind) => void;
+    setSelectedVideoId: (value: string) => void;
+    setShowMediaControls: (value: boolean) => void;
+    showMediaControls: boolean;
+    trackerError: string | null;
+    trackerStatus: "idle" | "initializing" | "ready" | "error";
+    videoOptions: XRViewportMediaAssetOption[];
+    viewportSize: XRViewportSize;
+    mediaSize: XRViewportSize;
+};
+type XRViewportProps = {
+    children?: ReactNode | ((state: XRViewportRenderState) => ReactNode);
+    fitMode?: XRViewportFitMode;
+    imageOptions?: XRViewportMediaAssetOption[];
+    initialImageId?: string;
+    initialMirrored?: boolean;
+    initialSource?: XRViewportSourceKind;
+    initialVideoId?: string;
+    mediaStrategy?: XRViewportMediaStrategy;
+    mediaDock?: "top-left" | "bottom-left";
+    mode?: XRViewportMode;
+    showMediaControlsByDefault?: boolean;
+    source?: XRViewportSourceConfig;
+    style?: CSSProperties;
+    videoOptions?: XRViewportMediaAssetOption[];
+};
+type XRViewportSlotProps = {
+    children?: ReactNode | ((state: XRViewportRenderState) => ReactNode);
+};
+type XRViewportComponent = ((props: XRViewportProps) => JSX.Element) & {
+    Scene: (props: XRViewportSlotProps) => JSX.Element;
+    Overlay: (props: XRViewportSlotProps) => JSX.Element;
+};
+export declare const resolveViewportFitMode: (fitMode: XRViewportFitMode, selectedSource: XRViewportSourceKind) => Exclude<XRViewportFitMode, "auto">;
+export declare const resolveViewportSourceSelection: ({ imageOptions, initialImageId, initialSource, initialVideoId, source, videoOptions, }: {
+    imageOptions: XRViewportMediaAssetOption[];
+    initialImageId?: string;
+    initialSource?: XRViewportSourceKind;
+    initialVideoId?: string;
+    source?: XRViewportSourceConfig;
+    videoOptions: XRViewportMediaAssetOption[];
+}) => {
+    selectedSource: XRViewportSourceKind;
+    selectedImageId: string;
+    selectedVideoId: string;
+};
+export declare const computeViewportLayout: (source: XRViewportSize, destination: XRViewportSize, fitMode: Exclude<XRViewportFitMode, "auto">) => XRMediaLayout | null;
+export declare const resolveViewportSlots: (mode: XRViewportMode, children: ReactNode) => {
+    sceneContent: ReactNode;
+    overlayContent: ReactNode;
+};
+export declare const resolveViewportSlotContent: (content: ReactNode | ((state: XRViewportRenderState) => ReactNode), state: XRViewportRenderState) => ReactNode;
+export declare const resolveViewportExternalFaces: ({ detectionResults, selectedSource, }: {
+    detectionResults: ReturnType<XRModelNodeFaceTracking["getDetectionResults"]> | null | undefined;
+    selectedSource: CalibrationMediaSourceKind;
+}) => FaceTrackingResult[];
+export declare const useXRViewportState: () => XRViewportRenderState | null;
+export declare const XRViewport: XRViewportComponent;
+export {};

package/dist/components/index.d.ts

@@ -0,0 +1,26 @@
+export * from './AspectRatioContainer';
+export * from './BodyTracker';
+export * from './FaceTracker';
+export * from './FaceMesh';
+export * from './FaceRetouch';
+export * from './GestureTracker';
+export * from './GestureTrigger';
+export * from './HandTracker';
+export * from './HeadBinding';
+export * from './HeadBindingOccluder';
+export * from './HeadOccluder';
+export * from './Panel';
+export * from './PerspectiveCamera';
+export * from './ScreenSpaceUI';
+export * from './Segmentation';
+export * from './SpriteAnimation';
+export * from './TextLabel';
+export * from './TrackingAnchor';
+export * from './VideoBackground';
+export * from './XRProvider';
+export * from './XRCompositor';
+export * from './XRDebugView';
+export * from './XRLayer';
+export * from './XRMediaSurface';
+export * from './XRViewport';
+export * from './XRScene';

package/dist/config/index.d.ts

@@ -0,0 +1,8 @@
+export declare const libConfig: {
+    apiBaseUrl: string;
+    assetStorageEndpoint: string;
+    sdkAssetsBaseUrl: string;
+    loggerPrefix: string;
+    sessionCheckInterval: number;
+};
+export type LibConfig = typeof libConfig;

package/dist/constants/index.d.ts

@@ -0,0 +1,25 @@
+export declare enum XRMediaSource {
+    WEBCAM = "webcam",
+    STREAM = "stream",
+    CANVAS = "canvas"
+}
+export declare enum XRModel {
+    HAND_TRACKER = "vincentt.xr.hand-tracker",
+    GESTURE_TRACKER = "vincentt.xr.gesture-tracker",
+    FACE_TRACKER = "vincentt.xr.face-tracker",
+    BODY_TRACKER = "vincentt.xr.body-tracker",
+    BACKGROUND_SEGMENTATION = "vincentt.xr.background-segmentation"
+}
+export declare enum XRComponentEnum {
+    CAMERA = "vincentt.component.camera",
+    FACE_GEOMETRY = "vincentt.component.face-geometry"
+}
+export declare const SDKEvents: {
+    session: {
+        started: string;
+        stopped: string;
+        readiness: string;
+        startProgress: string;
+        error: string;
+    };
+};

package/dist/constants/renderLayers.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Fixed render-layer convention for AR scenes.
+ *
+ * The AR element model defines four conceptual layers stacked from back
+ * to front. Each container component sets `renderOrder` (and the
+ * appropriate `material-depthTest`) on its descendants so the design
+ * agent and creators do not need to think about Z order.
+ *
+ * Within a single layer, sibling order in the scene tree determines
+ * draw order — later siblings draw on top of earlier siblings.
+ *
+ * Children may override the container default by passing an explicit
+ * `renderOrder` prop, which takes precedence via R3F prop merging.
+ */
+export declare const RENDER_LAYERS: {
+    /** Camera background and segmentation mask. `depthTest` disabled. */
+    readonly BACKGROUND: -1000;
+    /** Free world-space content. `depthTest` enabled. */
+    readonly WORLD: 0;
+    /** Descendants of `FaceTracker` / `HandTracker` / `BodyTracker`. `depthTest` enabled. */
+    readonly TRACKED: 100;
+    /** Descendants of `ScreenSpaceUI`. `depthTest` disabled. */
+    readonly SCREEN_UI: 1000;
+};
+export type RenderLayer = (typeof RENDER_LAYERS)[keyof typeof RENDER_LAYERS];

package/dist/entries/all.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Aggregate of every domain — NOT a package export.
+ *
+ * This exists only so the internal example playground can keep resolving a
+ * flat `@vincentt-xr/sdk` alias without editing its demo files. It is
+ * never listed in `package.json` `exports`; real apps import from the split
+ * subpaths (`.`, `/tracking`, `/face-effects`, `/low-level`). `/internal` is
+ * included here because the playground demos the debugger — which is exactly
+ * why this aggregate is example-only and never shipped.
+ */
+export * from './core';
+export * from './tracking';
+export * from './face-effects';
+export * from './low-level';
+export * from './internal';

package/dist/entries/core.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `@vincentt-xr/sdk` (core) — the always-there surface.
+ *
+ * Session root, scene, screen-space layout, and content primitives — the
+ * frame every AR app has, with no tracker and no effect. Task-specific
+ * surface lives behind subpaths: `/tracking`, `/face-effects`, `/low-level`.
+ */
+export { XRProvider, XRScene, ScreenSpaceUI, ScreenTransform, useScreenRectAspect, TextLabel, Panel, VideoBackground, AspectRatioContainer, SpriteAnimation, } from '../components';
+export type { PanelProps } from '../components/Panel';
+export type { TextLabelProps } from '../components/TextLabel';
+export type { ScreenTransformProps } from '../components/ScreenSpaceUI';
+export type { SpriteSheet, SpriteAnimationProps } from '../components/SpriteAnimation';
+export { computeContainScale } from '../texture/computeContainScale';
+export { useMediaRecorder } from '../hooks/useMediaRecorder';
+export type { UseMediaRecorderOptions } from '../hooks/useMediaRecorder';
+export { dataURLtoFile } from '../utils/dataURL';
+export { AudioEngine, audio, prefetchMusic, registerSound, startMusic, stopMusic, playOneShot, setMuted, toggleMuted, isMuted, onMuteChange, useMuted, } from '../audio';
+export type { AudioEngineOptions } from '../audio';
+export { XRMediaSource, XRModel } from '../constants';
+export type { XRSession } from '../types';
+export type { XRPerfConfig } from '../types/model';

package/dist/entries/face-effects.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@vincentt-xr/sdk/face-effects` — face-filter power-user surface.
+ *
+ * FaceMesh material configuration, landmark-driven retouch, the canonical
+ * face mesh, and the head-binding solver + occluders. The bare
+ * `<FaceMesh appearance={{ map }} />` is in `/tracking`; this is its deep
+ * configuration.
+ */
+export { blendModeIndices, DEFAULT_APPEARANCE, DEFAULT_MASKING, materialTypeOptions, shaderPresetOptions, sideOptions, textureMapOptions, alphaMapOptions, blendModeOptions, supportsTexturePanel, supportsBlendMode, } from '../components/FaceMesh';
+export type { FaceMeshMaterialType, FaceMeshShaderPreset, FaceMeshTextureMap, FaceMeshAlphaMap, FaceMeshMaskTextureSource, FaceMeshSide, FaceMeshBlendMode, FaceMeshAppearance, FaceMeshMasking, } from '../components/FaceMesh';
+export { CanonicalFaceMeshRenderer, useCanonicalFaceMesh, parseCanonicalFaceModel, } from '../components';
+export type { CanonicalFaceMeshRendererProps, ParsedCanonicalMesh } from '../components/FaceMesh';
+export { FaceRetouchBackground, drawFaceRetouchMask, drawMouthRetouchMask, FACE_MASK_SIZE, FACE_OVAL, LEFT_EYE, RIGHT_EYE, OUTER_LIPS, INNER_MOUTH, LEFT_EYEBROW, RIGHT_EYEBROW, createFaceRetouchRegions, DEFAULT_FEATURE_GROUPS, DEFAULT_FEATURE_POINT_INDICES, useFaceRetouchMask, useFaceRetouchRegions, } from '../components/FaceRetouch';
+export type { FaceRetouchBackgroundProps, CreateFaceRetouchRegionsOptions, } from '../components/FaceRetouch';
+export { HeadBinding, HeadBindingOccluder, HeadOccluder, HEAD_OCCLUDER_DEFAULT_OPACITY, HEAD_OCCLUDER_DEFAULT_POSITION, HEAD_OCCLUDER_DEFAULT_SCALE, } from '../components';
+export type { HeadBindingOccluderOptions, HeadBindingProps } from '../components';
+export { computeAdaptiveVerticalFit, computeHeadBindingCubePose, computeHeadBindingDebugMetrics, computeHeadBindingShape, computeUniversalHeadDepthOffset, computeUniversalOccluderScale, computeUniversalPitchOffsetY, computeUniversalYawOffsetX, solveHeadBinding, } from '../utils/headBinding';
+export type { HeadBindingAdaptiveValues, HeadBindingCubeModel, HeadBindingCubePose, HeadBindingDebugMetrics, HeadBindingSolveResult, HeadBindingShape, } from '../types/headBinding';
+export type { FaceLandmark2D, BoundingBox, FaceRawTrackingData, FaceRetouchRegion, FaceBounds, FaceTrackingResult, } from '../types/face';

package/dist/entries/internal.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@vincentt-xr/sdk/internal` — not for app authors.
+ *
+ * Debugger plumbing, private helpers, calibration-debug utilities, and
+ * low-level compositor/render types. Present for the SDK's own tooling and
+ * the editor; app code should not import from here.
+ */
+export { XRDebugView } from '../components';
+export { DebuggerProvider } from '../components/Debugger/DebuggerProvider';
+export { DebuggerOverlay } from '../components/Debugger';
+export { useDebugger } from '../hooks/useDebugger';
+export type { DebuggerMetrics, DebuggerConfig } from '../types/debugger';
+export { logUVBoundsWarningOnce, _resetUVBoundsWarnings } from '../texture/hasFullUnitUVBounds';
+export { readCalibrationDebugEvents, recordCalibrationDebugEvent } from '../utils/calibrationDebug';
+export { RENDER_LAYERS } from '../constants/renderLayers';
+export type { RenderLayer } from '../constants/renderLayers';