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

package/dist/components/Makeup/types.d.ts

@@ -0,0 +1,110 @@
+import { LipEffectSettings } from '../LipEffect/settings';
+import { MakeupFaceRegion, MakeupFinish, MakeupRegion, MakeupSide } from './constants';
+import { MakeupShadeSetting } from './shades';
+import { MakeupShape } from './shapes';
+/**
+ * Fields every makeup region shares (lips use `LipEffectSettings`). Flat and
+ * serializable: a settings object can live in a store, a URL or a panel.
+ */
+export type MakeupRegionSettings<R extends MakeupFaceRegion> = {
+    /** `false` draws nothing and costs nothing. Looks use it for unused regions. */
+    enabled: boolean;
+    /**
+     * Placement preset from `MAKEUP_SHAPES[region]`; it sets the geometry
+     * fields and `coverage`. `"custom"` applies no preset: the placement is the
+     * region's default shape's (contour `soft`, blush `apples`, highlighter
+     * `cheekbones`, eyeshadow `lid`, eyeliner `classic`, brows `natural`) with
+     * the fields as given.
+     */
+    shape: MakeupShape<R> | "custom";
+    /**
+     * A named colour from `MAKEUP_SHADES[region]` (sets `color`), `"auto"`
+     * where supported (from the person's own colouring; `color` is the
+     * fallback until it is measured) or `"custom"` (`color` as given).
+     */
+    shade: MakeupShadeSetting<R>;
+    /** CSS colour. An explicit colour that differs from the shade wins and the shade becomes `"custom"`. */
+    color: string;
+    /** Linear amount, 0..1: 0.8 renders 80 %. */
+    opacity: number;
+    /** 0 = sheer (filters the person's own colour, never lightens), 1 = opaque (covers the skin). */
+    coverage: number;
+    /** How the product reflects light. Choosing a finish sets `shine` and the sparkle fields. */
+    finish: MakeupFinish;
+    /** Strength of the finish highlight, 0..1. */
+    shine: number;
+    /** Flake colour for `shimmer` / `glitter`; `""` derives it from the shade. */
+    sparkleColor: string;
+    /** Flake density, 0..1 (`shimmer` and `glitter` only). */
+    sparkleDensity: number;
+    /** Flake size in millimetres, 0.1..1.5. */
+    sparkleSize: number;
+    /** Edge feather, 0..1. */
+    softness: number;
+    /** The person's own side(s) to paint, on every feed. */
+    side: MakeupSide;
+};
+export type BlushSettings = MakeupRegionSettings<"blush"> & {
+    /** Scale of the placement, 0.5..1.5. */
+    size: number;
+    /** −1..1: 0 sits on the cheek, positive lifts toward the temple, negative drops toward the apples. */
+    lift: number;
+};
+export type ContourSettings = MakeupRegionSettings<"contour"> & {
+    /** Scale of the placement, 0.5..1.5. */
+    size: number;
+};
+export type HighlighterSettings = MakeupRegionSettings<"highlighter"> & {
+    /** Scale of the placement, 0.5..1.5. */
+    size: number;
+};
+export type EyeshadowSettings = MakeupRegionSettings<"eyeshadow"> & {
+    /** How far the lid colour reaches, 0..1: lash line (0) to brow (1). */
+    height: number;
+    /** Strength of the crease band, 0..1. */
+    crease: number;
+    /** Crease colour by name; `creaseColor` wins when it differs. */
+    creaseShade: MakeupShadeSetting<"eyeshadow">;
+    creaseColor: string;
+    /** Shadow along the lower lash line, 0..1. */
+    lower: number;
+    /** Inner-corner highlight, 0..1. */
+    inner: number;
+    /** Inner-corner colour by name; `innerColor` wins when it differs. */
+    innerShade: MakeupShadeSetting<"eyeshadow">;
+    innerColor: string;
+};
+export type EyelinerSettings = MakeupRegionSettings<"eyeliner"> & {
+    /** Line width at its thickest, in millimetres, 0.2..4. */
+    thickness: number;
+    /** Wing length past the outer corner, in millimetres, 0..15. */
+    wing: number;
+    /** Wing angle in degrees, 0..45, upward in the person's frame. */
+    wingAngle: number;
+    /** Lower lash line, 0..1 (fades while blinking). */
+    lower: number;
+    /** Softens and widens the line, 0..1. */
+    smudge: number;
+};
+export type BrowsSettings = MakeupRegionSettings<"brows"> & {
+    /** 0..1; 0.5 follows the person's own brow, higher is thicker and darker. */
+    boldness: number;
+    /** 0 tints only the real hairs, 1 fills a full powder shape. */
+    fill: number;
+    /** Procedural hair strokes, 0..1. */
+    strokes: number;
+};
+/** Settings per region: `MakeupSettings["blush"]` is `BlushSettings`, lips are `LipEffectSettings`. */
+export type MakeupSettings = {
+    lips: LipEffectSettings;
+    contour: ContourSettings;
+    blush: BlushSettings;
+    highlighter: HighlighterSettings;
+    eyeshadow: EyeshadowSettings;
+    eyeliner: EyelinerSettings;
+    brows: BrowsSettings;
+};
+/** Partial settings per region, as looks and overrides carry them. */
+export type MakeupSettingsInput = {
+    [R in MakeupRegion]?: Partial<MakeupSettings[R]>;
+};

package/dist/components/Makeup/useMakeupSkinTone.d.ts

@@ -0,0 +1,40 @@
+import { FaceSkinQuality } from '../../face-atlas/probe/constants';
+import { MakeupSkinTone } from './skinTone';
+export type UseMakeupSkinToneOptions = {
+    /** Which tracked face. Default: the nearest `FaceRig` / `FaceTracker`'s face, else 0. */
+    faceIndex?: number;
+    /** Faces to start the face model with when this starts it (no `FaceTracker` above). */
+    numFaces?: number;
+    /**
+     * Milliseconds between reads of the probe, at least
+     * `MAKEUP_SKIN_TONE.minReadbackMs` (200). Default 500 (two reads a second).
+     */
+    intervalMs?: number;
+    /** Shades recommended per region. Default 3. */
+    count?: number;
+    /** The skin probe's quality (`useFaceSkin`). Default `"auto"`. */
+    quality?: FaceSkinQuality;
+    /** `false` stops reading and releases the probe. Default true. */
+    enabled?: boolean;
+};
+/**
+ * The person's skin tone for shade-finder UIs: skin depth (`fair` … `rich`),
+ * undertone (`cool`, `neutral`, `warm`), the measured skin, lip and brow
+ * colours, and the curated palette shades nearest what each region would
+ * paint on them (`MakeupSkinTone`). `null` until the face's skin probe has
+ * settled.
+ *
+ * It reads the shared skin probe of the face (the one makeup uses; it starts
+ * one if none runs) back from the GPU without stalling it, at most every
+ * `intervalMs` (default 500 ms), and re-renders only when the readout
+ * changes. Works alone (it starts the face model when no `FaceTracker` is
+ * above). The camera's white balance moves the undertone and its exposure
+ * the depth: it describes the image, not the person, so offer it as a
+ * suggestion, never a label.
+ *
+ * ```tsx
+ * const tone = useMakeupSkinTone();
+ * <Blush shade={tone?.recommendations.blush[0] ?? "rose"} />
+ * ```
+ */
+export declare const useMakeupSkinTone: (options?: UseMakeupSkinToneOptions) => MakeupSkinTone | null;

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

@@ -0,0 +1,59 @@
+import { Blending, DepthModes, Side } from 'three';
+export type MeshRendererMesh = "cube" | "sphere" | "plane";
+export type MeshRendererMaterialType = "standard" | "basic";
+export type MeshRendererShadowMode = "off" | "cast" | "receive" | "castReceive";
+export type MeshRendererDepthFunction = "never" | "less" | "equal" | "lessEqual" | "greater" | "notEqual" | "greaterEqual" | "always";
+export type MeshRendererCullMode = "back" | "front" | "off";
+export type MeshRendererBlendMode = "normal" | "additive" | "subtractive" | "multiply" | "none";
+export type MeshRendererRenderState = {
+    depthTest: boolean;
+    depthWrite: boolean;
+    depthFunc: MeshRendererDepthFunction;
+    colorWrite: boolean;
+    colorMask: {
+        r: boolean;
+        g: boolean;
+        b: boolean;
+        a: boolean;
+    };
+    cullMode: MeshRendererCullMode;
+    blendMode: MeshRendererBlendMode;
+    polygonOffset: {
+        enabled: boolean;
+        factor: number;
+        units: number;
+    };
+};
+export type MeshRendererSettings = {
+    enabled: boolean;
+    mesh: MeshRendererMesh;
+    /** Optional GLTF/GLB asset URL. When set, renders the imported asset instead of a primitive. */
+    assetUrl?: string;
+    assetNodeName?: string;
+    assetAnimation?: ("all" & {}) | (string & {});
+    material: {
+        type: MeshRendererMaterialType;
+        color: string;
+        opacity: number;
+        wireframe: boolean;
+        roughness: number;
+        metalness: number;
+        renderState?: Partial<Omit<MeshRendererRenderState, "colorMask" | "polygonOffset"> & {
+            colorMask: Partial<MeshRendererRenderState["colorMask"]>;
+            polygonOffset: Partial<MeshRendererRenderState["polygonOffset"]>;
+        }>;
+    };
+    shadowMode: MeshRendererShadowMode;
+    visible: boolean;
+};
+export type MeshRendererProps = {
+    value: MeshRendererSettings;
+    renderOrder?: number;
+};
+export declare const DEFAULT_MESH_RENDERER: MeshRendererSettings;
+export declare const DEFAULT_MESH_RENDERER_RENDER_STATE: MeshRendererRenderState;
+export declare const normalizeMeshRendererRenderState: (renderState?: MeshRendererSettings["material"]["renderState"]) => MeshRendererRenderState;
+export declare const getThreeDepthFunction: (depthFunc: MeshRendererDepthFunction) => DepthModes;
+export declare const getThreeSide: (cullMode: MeshRendererCullMode) => Side;
+export declare const getThreeBlending: (blendMode: MeshRendererBlendMode) => Blending;
+export declare const MeshRenderer: ({ renderOrder, value }: MeshRendererProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/Necklace/Necklace.d.ts

@@ -0,0 +1,44 @@
+import { ReactNode } from 'react';
+import { SpringSwingOptions } from '../../spring/swing';
+import { CanonicalOffset } from '../HeadOccluder/useLandmarkPoseFit';
+import { CanonicalTorsoFitOptions } from '../ShoulderOccluder/useCanonicalTorsoFit';
+import type * as THREE from "three";
+/** Nodes whose name contains one of these swing (`*_pendant`, `*_charm`). */
+export declare const NECKLACE_SWING_NODES: readonly string[];
+/** A pendant lies on the chest: it swings less far than an earring. */
+export declare const NECKLACE_SWING_DEFAULTS: Readonly<SpringSwingOptions>;
+export type NecklaceProps = Omit<CanonicalTorsoFitOptions, "offset"> & {
+    /**
+     * The necklace, authored in the torso frame: centimetres, origin between
+     * the shoulder joints, +X screen right, +Y up, +Z toward the camera, the
+     * chain on the neck base and upper chest. A pendant is a child node named
+     * `…pendant…` (or `…charm…`) with its origin on its bail. Cloned, so pass a
+     * loaded GLB's scene (or one of its nodes) as it is.
+     */
+    model?: THREE.Object3D | null;
+    /** JSX in the same frame (it does not swing). */
+    children?: ReactNode;
+    /**
+     * The pendants swing on a spring about their bail as the body moves, then
+     * settle: `true` (default) for the gentle default, `SpringSwingOptions`, or
+     * `false` (rigid). They hang along the torso's own down.
+     */
+    swing?: boolean | SpringSwingOptions;
+    /** Name parts of the nodes that swing. Default `NECKLACE_SWING_NODES`. */
+    swingNodes?: readonly string[];
+    /** Hide the chain behind the neck and shoulders (a `ShoulderOccluder`). Default true. */
+    occluder?: boolean;
+    /** The occluder's mesh (`ShoulderOccluder` `url`); default the SDK's CDN copy. */
+    occluderUrl?: string;
+    /** Nudge on top of the fit, in torso centimetres. */
+    offset?: CanonicalOffset;
+};
+/**
+ * A necklace on a tracked body: the chain sits on the neck base and upper
+ * chest (the canonical torso fit), its pendants swing, and the shoulder
+ * occluder hides the chain behind the neck. Inside a `BodyTracker` it uses
+ * that body; anywhere else it tracks the body itself (`bodyIndex`). Hidden
+ * while the body is lost. Under a `HeadOccluder` (a `HeadBinding`) the chin
+ * hides the chain behind it too.
+ */
+export declare const Necklace: ({ model, children, swing, swingNodes, occluder, occluderUrl, offset, bodyIndex, ...fit }: NecklaceProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { NECKLACE_SWING_DEFAULTS, NECKLACE_SWING_NODES, Necklace, type NecklaceProps, } from './Necklace';

package/dist/components/ParticleEmitter/ParticleEmitter.d.ts

@@ -0,0 +1,69 @@
+import { Euler, Vector3 } from '@react-three/fiber';
+import { ReactNode } from 'react';
+import { ParticleEmitterTarget } from '../../particles/eyes';
+import { ParticlePreset } from '../../particles/presets';
+import { ParticleSettings } from '../../particles/settings';
+import { ParticleSystem } from '../../particles/system';
+import type * as THREE from "three";
+export type ParticleEmitterProps = Partial<ParticleSettings> & {
+    /** A built-in look the other settings go on top of (`PARTICLE_PRESETS`). */
+    preset?: ParticlePreset;
+    /**
+     * Emit from the person's own left eye, right eye, or both (two emitters),
+     * straight out of the face. `position`, `rotation` and `scale` then apply
+     * about the eye, in the head's centimetres. Inside a `FaceTracker` it
+     * follows that tracker's face; anywhere else it tracks the face itself.
+     */
+    target?: ParticleEmitterTarget;
+    /** With `target`: the face (default: the enclosing `FaceTracker`'s, else 0). */
+    faceIndex?: number;
+    /** With `target` and no enclosing `FaceTracker`: faces the face model tracks when this starts it. */
+    numFaces?: number;
+    /** New particles keep coming. False stops emitting; the particles already out live on. Default true. */
+    emitting?: boolean;
+    /** The particles' render order (they draw in the transparent pass). Default 0. */
+    renderOrder?: number;
+    /** The emitter's place in its parent (its +Z is forward). */
+    position?: Vector3;
+    rotation?: Euler;
+    scale?: Vector3;
+    /** Called with each emitter's `ParticleSystem` when it is made, and with null when it goes. */
+    onSystem?: (system: ParticleSystem | null) => void;
+    children?: ReactNode;
+};
+/**
+ * Emits particles from where it is: put it anywhere in the scene, inside a
+ * tracker to follow a face or a hand, or give it a `target` (the eyes).
+ * Particles are drawn in world space and keep their own path once out; they
+ * live on when the emitter stops or its tracker hides (it emits only while
+ * shown). Settings are props (any subset of `ParticleSettings`, over a
+ * `preset`), in the emitter's units: inside a head frame (and with
+ * `target`), centimetres. The ref is the emitter's group (with two eyes, the
+ * person's left one).
+ */
+export declare const ParticleEmitter: import('react').ForwardRefExoticComponent<Partial<ParticleSettings> & {
+    /** A built-in look the other settings go on top of (`PARTICLE_PRESETS`). */
+    preset?: ParticlePreset;
+    /**
+     * Emit from the person's own left eye, right eye, or both (two emitters),
+     * straight out of the face. `position`, `rotation` and `scale` then apply
+     * about the eye, in the head's centimetres. Inside a `FaceTracker` it
+     * follows that tracker's face; anywhere else it tracks the face itself.
+     */
+    target?: ParticleEmitterTarget;
+    /** With `target`: the face (default: the enclosing `FaceTracker`'s, else 0). */
+    faceIndex?: number;
+    /** With `target` and no enclosing `FaceTracker`: faces the face model tracks when this starts it. */
+    numFaces?: number;
+    /** New particles keep coming. False stops emitting; the particles already out live on. Default true. */
+    emitting?: boolean;
+    /** The particles' render order (they draw in the transparent pass). Default 0. */
+    renderOrder?: number;
+    /** The emitter's place in its parent (its +Z is forward). */
+    position?: Vector3;
+    rotation?: Euler;
+    scale?: Vector3;
+    /** Called with each emitter's `ParticleSystem` when it is made, and with null when it goes. */
+    onSystem?: (system: ParticleSystem | null) => void;
+    children?: ReactNode;
+} & import('react').RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;

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

@@ -0,0 +1 @@
+export { ParticleEmitter, type ParticleEmitterProps } from './ParticleEmitter';

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

@@ -0,0 +1,46 @@
+import { BodySubjectOptions } from '../../body/bodySubject';
+import { ScreenImageProps } from '../ScreenImage/types';
+import { PersonCutoutFallback, PersonCutoutStatus } from './personCutout';
+export type { PersonCutoutFallback, PersonCutoutStatus } from './personCutout';
+export { FULL_SCREEN_ANCHORS, resolvePersonCutoutStatus, shouldDrawFallback } from './personCutout';
+export { usePersonMaskTexture } from './personMask';
+export type { PersonMaskTextureResult } from './personMask';
+export type PersonCutoutProps = Omit<ScreenImageProps, "source" | "src" | "maskTexture" | "maskChannel" | "maskInvert"> & {
+    /** Edge softening as a 3×3 blur radius in mask texels. Default 4; 0 = hard edge. */
+    maskFeather?: number;
+    /**
+     * Shrink the kept silhouette into the feathered edge (0..1 of the feather
+     * width) so background fringe from the segmenter is trimmed. Default 0.7.
+     */
+    maskErode?: number;
+    /** Show the background only (cut the person out) instead of the person only. */
+    invert?: boolean;
+    /**
+     * What to draw while the segmentation model is loading or has failed:
+     * the unmasked camera (default, the experience degrades to a plain feed)
+     * or nothing.
+     */
+    fallback?: PersonCutoutFallback;
+    /** Keep the segmentation model running. Default true. */
+    active?: boolean;
+    onStatusChange?: (status: PersonCutoutStatus, error: Error | null) => void;
+    /**
+     * Cut out only the person with this stable id (`useBodyIds()`): the person
+     * mask split by the nearest skeleton (`useBodyMaskTexture`). Without
+     * `bodyId` or `subject`, everyone.
+     */
+    bodyId?: BodySubjectOptions["bodyId"];
+    /** Cut out only the person a policy picks (`largest`, `leftmost`, `sticky` …). */
+    subject?: BodySubjectOptions["subject"];
+    /** Bodies to track to tell people apart (1–2). Default 2 when a person is picked. */
+    numBodies?: BodySubjectOptions["numBodies"];
+};
+/**
+ * The live camera, masked to the person, as a full-screen `ScreenImage`.
+ * Place any `ScreenImage` (image, video, GIF) or shader surface behind it
+ * with a lower `renderOrder` for background replacement. The camera texture is
+ * already cover-cropped and webcam-mirrored by the session, and the mask is in
+ * that same space, so no coordinate work is needed. With `bodyId` or
+ * `subject`, only that person (the others go with the background).
+ */
+export declare const PersonCutout: ({ bodyId, subject, numBodies, ...props }: PersonCutoutProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/PersonCutout/personCutout.d.ts

@@ -0,0 +1,16 @@
+import { ScreenAnchorEdges } from '../ScreenSpaceUI';
+/** Anchors that stretch a screen element over the whole viewport. */
+export declare const FULL_SCREEN_ANCHORS: ScreenAnchorEdges;
+export type PersonCutoutStatus = "loading" | "ready" | "error";
+/**
+ * Status of a person cut-out from the segmentation model's lifecycle and
+ * whether its mask texture exists yet.
+ */
+export declare const resolvePersonCutoutStatus: ({ ready, error, hasMask, }: {
+    ready: boolean;
+    error: Error | null;
+    hasMask: boolean;
+}) => PersonCutoutStatus;
+export type PersonCutoutFallback = "camera" | "hidden";
+/** Whether the camera layer should draw while the mask is not available. */
+export declare const shouldDrawFallback: (status: PersonCutoutStatus, fallback: PersonCutoutFallback) => boolean;

package/dist/components/PersonCutout/personMask.d.ts

@@ -0,0 +1,19 @@
+import { PersonCutoutStatus } from './personCutout';
+import type * as THREE from "three";
+export type PersonMaskTextureResult = {
+    /**
+     * The portrait segmentation mask in feed space. The signal is in RGB:
+     * white (255) on the person, black (0) on the background, alpha 255
+     * everywhere (measured; three's `alphaMap` reads green, which is how
+     * `VideoBackground` consumes it).
+     */
+    texture: THREE.Texture | null;
+    status: PersonCutoutStatus;
+    error: Error | null;
+};
+/**
+ * The portrait segmentation mask as a texture, with the model's lifecycle.
+ * Acquires the segmentation model itself. The mask lives in feed space, like
+ * the camera texture; read its green channel: 255 on the person, 0 elsewhere.
+ */
+export declare const usePersonMaskTexture: (active?: boolean) => PersonMaskTextureResult;

package/dist/components/PersonCutout/useBodyMaskTexture.d.ts

@@ -0,0 +1,35 @@
+import { BodyMaskSplitOptions } from '../../body/bodyMask';
+import { BodySubjectOptions } from '../../body/bodySubject';
+import { PersonCutoutStatus } from './personCutout';
+import * as THREE from "three";
+export type BodyMaskTextureOptions = BodySubjectOptions & Partial<BodyMaskSplitOptions> & {
+    /** `false` pauses the person mask and the body model. Default `true`. */
+    active?: boolean;
+    /**
+     * The mask's size as a share of the person mask's (feed render size).
+     * Default 0.5: the split's line is soft anyway, and the cost scales with it.
+     */
+    resolution?: number;
+};
+export type BodyMaskTextureResult = {
+    /**
+     * The person's mask in feed space, the same convention as
+     * `usePersonMaskTexture`: white on this person, black elsewhere (read the
+     * green channel). `null` until the person mask exists.
+     */
+    texture: THREE.Texture | null;
+    /** The id of the person it shows (`null` while nobody is followed). */
+    id: number | null;
+    status: PersonCutoutStatus;
+    error: Error | null;
+};
+/**
+ * One person's mask: the portrait person mask (everyone, `usePersonMaskTexture`)
+ * split by the nearest skeleton, on the GPU, for the body picked by `bodyId`,
+ * `subject` or `bodyIndex` (`BodySubjectOptions`). The mask is split by where
+ * the people were when it was made (the closest body detection in time).
+ * Starts the segmentation and body models itself; asks for 2 bodies unless
+ * `numBodies` says otherwise, since telling people apart needs them all
+ * tracked. Use inside `XRScene`.
+ */
+export declare const useBodyMaskTexture: ({ active, resolution, nobody, feather, numBodies, ...subject }?: BodyMaskTextureOptions) => BodyMaskTextureResult;

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

@@ -1,13 +1,7 @@
 import { PerspectiveCameraProps } from '@react-three/fiber';
 /**
- * @deprecated Use @react-three/drei's PerspectiveCamera directly for the new unified architecture.
- * This component is kept for backwards compatibility with old examples.
- *
- * For new projects, use:
- * ```tsx
- * import { PerspectiveCamera } from '@react-three/drei';
- * <PerspectiveCamera makeDefault position={[0, 0, 5]} fov={45} />
- * ```
+ * @deprecated Import PerspectiveCamera directly from @react-three/drei.
+ * Retained for backwards compatibility with existing SDK consumers.
  */
 export declare const PerspectiveCamera: (props: PerspectiveCameraProps & {
     makeDefault?: boolean;

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

@@ -0,0 +1,47 @@
+import { Object3D, Vector3 } from 'three';
+export type PinToMeshOrientation = "none" | "position" | "positionAndDirection";
+export type PinToMeshVector3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type PinToMeshSettings = {
+    enabled: boolean;
+    targetObjectId: string | null;
+    orientation: PinToMeshOrientation;
+    uv: {
+        x: number;
+        y: number;
+    };
+    vertexNormal: boolean;
+    offsetSpace: "local" | "world";
+    offsetPosition: PinToMeshVector3;
+    offsetRotation: PinToMeshVector3;
+};
+export declare const DEFAULT_PIN_TO_MESH: PinToMeshSettings;
+export type PinToMeshProps = {
+    target: Object3D | null;
+    settings: PinToMeshSettings;
+    children: React.ReactNode;
+};
+/** Resolve a UV coordinate to the first matching mesh triangle in world space. */
+export declare const resolvePinSurface: (target: Object3D, uv: {
+    x: number;
+    y: number;
+}, useVertexNormal?: boolean) => {
+    position: Vector3;
+    normal: Vector3;
+};
+export type ApplyPinToMeshOptions = {
+    source: Object3D;
+    surface: {
+        position: Vector3;
+        normal: Vector3;
+    };
+    settings: Pick<PinToMeshSettings, "offsetPosition" | "offsetRotation" | "offsetSpace" | "orientation">;
+};
+export declare const resetPinnedObject: (source: Object3D) => void;
+export declare const applyPinToMeshTransform: ({ settings, source, surface }: ApplyPinToMeshOptions) => void;
+export declare const PinToMesh: ({ target, settings, children }: PinToMeshProps) => import('react').ReactElement<{
+    ref: import('react').RefObject<Object3D<import('three').Object3DEventMap>>;
+}, string | import('react').JSXElementConstructor<any>>;

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

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from 'react';
+export type RenderGroupLayerProps = PropsWithChildren & {
+    layer?: number;
+};
+/** Assigns every renderable descendant to one camera layer. */
+export declare const RenderGroupLayer: ({ children, layer }: RenderGroupLayerProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { FaceMeshMaterialOverride } from '../FaceMesh';
+import { SceneComponent, SceneComponentId, SceneObjectId, SceneObjectStore } from '../../scene-object';
+export type SceneObjectRendererProps = {
+    objectId: SceneObjectId;
+    store: SceneObjectStore;
+    editorMode?: boolean;
+    /** Stable renderer sorting value, normally supplied by createRenderPlan(). */
+    renderOrder?: number;
+    /** Camera layer used by SequentialRenderPasses for guaranteed group composition. */
+    renderLayer?: number;
+    onComponentChange?: (component: SceneComponent) => void;
+    fallback?: (message: string) => ReactNode;
+    /** Internal: descendants already share an ancestor ScreenSpaceUI plane. */
+    insideScreenSpaceUI?: boolean;
+    /**
+     * Runtime-only material overrides keyed by FaceMeshRenderer component ID.
+     * These are deliberately separate from SceneObjectStore so Three.js
+     * materials and shader factories never enter serialized scene data.
+     */
+    faceMeshMaterialOverrides?: Readonly<Partial<Record<SceneComponentId, FaceMeshMaterialOverride>>>;
+};
+export declare const SceneObjectRenderer: ({ editorMode, faceMeshMaterialOverrides, fallback, insideScreenSpaceUI, objectId, onComponentChange, renderLayer, renderOrder, store, }: SceneObjectRendererProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/Screen2D/ScreenTransformFrame.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { ScreenTransformGuideLayer } from '../ScreenSpaceUI';
+import { ScreenTransform2DSettings } from '../../screen2d';
+export type ScreenTransformFrameProps = {
+    transform: ScreenTransform2DSettings;
+    guideLayer: ScreenTransformGuideLayer;
+    guideColor: string;
+    onChange?: (next: ScreenTransform2DSettings) => void;
+    children: ReactNode;
+};
+export declare function ScreenTransformFrame({ transform, guideLayer, guideColor, onChange, children, }: ScreenTransformFrameProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Screen2D/ScreenTransformHelpers.d.ts

@@ -0,0 +1,19 @@
+import { ResolvedScreenTransform2D, ScreenTransform2DSettings } from '../../screen2d';
+export declare const snapHalfPixel: (value: number) => number;
+export declare const clamp01: (value: number) => number;
+export declare function resolveScreenTransformDesignScale(viewportSize: {
+    width: number;
+    height: number;
+}): number;
+export declare function resolveScreenTransformUnitScale({ resolved, transform, }: {
+    resolved: ResolvedScreenTransform2D;
+    transform: ScreenTransform2DSettings;
+}): number;
+export declare function resolveScreenTransformControlScale({ parent, resolved, transform, }: {
+    parent: {
+        width: number;
+        height: number;
+    };
+    resolved: ResolvedScreenTransform2D;
+    transform: ScreenTransform2DSettings;
+}): [number, number, number];

package/dist/components/Screen2D/ScreenTransformInteraction.d.ts

@@ -0,0 +1,18 @@
+import { ScreenTransformControlHandle } from '../ScreenSpaceUI/ScreenTransformGuide';
+import { ScreenTransform2DSettings } from '../../screen2d';
+export type ScreenTransformDragState = {
+    handle: ScreenTransformControlHandle;
+    startX: number;
+    startY: number;
+    startPointerDesign: {
+        x: number;
+        y: number;
+    };
+    startTransform: ScreenTransform2DSettings;
+};
+export declare function applyScreenTransformDrag({ drag, clientX, clientY, designScale, }: {
+    drag: ScreenTransformDragState;
+    clientX: number;
+    clientY: number;
+    designScale: number;
+}): ScreenTransform2DSettings;

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

@@ -0,0 +1,5 @@
+export { ScreenTransformFrame } from './ScreenTransformFrame';
+export type { ScreenTransformFrameProps } from './ScreenTransformFrame';
+export { applyScreenTransformDrag } from './ScreenTransformInteraction';
+export type { ScreenTransformDragState } from './ScreenTransformInteraction';
+export { clamp01, resolveScreenTransformControlScale, resolveScreenTransformDesignScale, resolveScreenTransformUnitScale, snapHalfPixel, } from './ScreenTransformHelpers';

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

@@ -0,0 +1,3 @@
+import { ScreenGlassSettings } from './types';
+export declare const DEFAULT_SCREEN_GLASS: ScreenGlassSettings;
+export declare const normalizeScreenGlass: (value?: Partial<ScreenGlassSettings>) => ScreenGlassSettings;

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

@@ -0,0 +1,5 @@
+import { DEFAULT_SCREEN_GLASS, normalizeScreenGlass } from './defaults';
+import { ScreenGlassMaterialProps } from './types';
+export type { ScreenGlassMaterialProps, ScreenGlassSettings } from './types';
+export { DEFAULT_SCREEN_GLASS, normalizeScreenGlass };
+export declare const ScreenGlassMaterial: ({ opacity, value }: ScreenGlassMaterialProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ScreenGlass/shaders.d.ts

@@ -0,0 +1,2 @@
+export declare const screenGlassVertexShader = "\n  varying vec2 vPosition;\n  void main() {\n    vPosition = position.xy;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n  }\n";
+export declare const screenGlassFragmentShader = "\n  uniform vec3 tint;\n  uniform float opacity;\n  uniform float frost;\n  uniform float highlight;\n  varying vec2 vPosition;\n\n  void main() {\n    float grain = fract(sin(dot(vPosition * 997.0, vec2(12.9898, 78.233))) * 43758.5453);\n    float sheen = smoothstep(0.15, 0.85, 1.0 - (vPosition.x + vPosition.y + 1.0) * 0.5);\n    vec3 frosted = mix(tint, vec3(1.0), frost * (0.18 + grain * 0.08));\n    vec3 color = mix(frosted, vec3(1.0), sheen * highlight * 0.32);\n    gl_FragColor = vec4(color, opacity);\n  }\n";

package/dist/components/ScreenGlass/types.d.ts

@@ -0,0 +1,10 @@
+export type ScreenGlassSettings = {
+    tint: string;
+    opacity: number;
+    frost: number;
+    highlight: number;
+};
+export type ScreenGlassMaterialProps = {
+    value: ScreenGlassSettings;
+    opacity?: number;
+};

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

@@ -0,0 +1,5 @@
+import { ScreenGradientSettings, ScreenGradientStop } from './types';
+export declare const MAX_SCREEN_GRADIENT_STOPS = 8;
+export declare const DEFAULT_SCREEN_GRADIENT: ScreenGradientSettings;
+export declare const normalizeScreenGradientStops: (stops: ScreenGradientStop[]) => ScreenGradientStop[];
+export declare const normalizeScreenGradient: (value?: Partial<ScreenGradientSettings>) => ScreenGradientSettings;