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

package/docs/introduction.mdx

@@ -0,0 +1,121 @@
+---
+title: "Vincentt XR SDK Docs"
+description: "Author XR scenes with scene objects, typed components, runtime renderers, and inspector panels."
+sidebarTitle: "Introduction"
+icon: "book-open"
+---
+
+The Vincentt XR SDK now supports a scene-object authoring model.
+Instead of treating every renderable as a one-off React component, the SDK can
+describe scene content as stable objects with attached components.
+
+## Current focus
+
+The current docs cover the scene-object API added for:
+
+- Screen Image objects
+- Screen Text objects
+- Screen Shape objects, including gradient and glass fills
+- Screen-space coordinate conversion and smoothing utilities
+- FaceInfo effect-logic data
+- Face binding presets and custom anchors
+- Face, hand, gesture, body, and segmentation trackers
+- Face meshes, warp, retouch, head binding, and occlusion
+- Texture-source playback, capture/recording, and audio
+- 3D Object runtime APIs
+- Render-group ordering
+- Runtime object rendering
+- Hierarchy and object inspector panels
+- reusable debug-ui scene editor primitives
+- Harness client integration
+
+## Mental model
+
+A scene object is the user-facing item in a hierarchy. It has an ID, name,
+enabled state, owning render group, and ordered component IDs.
+
+A component owns one piece of behavior or rendering state:
+
+- `Transform`
+- `ScreenTransform`
+- `ScreenImage`
+- `ScreenText`
+- `ScreenShape`
+- `TrackingAnchor`
+- `MeshRenderer`
+- `Light`
+- `LookAt`
+- `PinToMesh`
+- `Material`
+- `Texture`
+
+Use the API Reference pages for definitions and examples:
+
+- Runtime 3D: `Transform3D`, `MeshRenderer`, `VideoBackground`, `LightObject`,
+  `LookAt`, `PinToMesh`, and `SceneObjectRenderer`
+- Material Render State: `depthTest`, `depthWrite`, `colorMask`, culling,
+  blending, and polygon offset
+- Behavior Components: `LookAt` and `PinToMesh` target resolution, offsets, and
+  defaults
+- Scene Object Store: serialized object/component types, default factories, and
+  immutable update helpers
+- Debug UI Scene Editor: `XRSceneEditorProvider`, `XRSceneViewport`,
+  `SceneHierarchyPanel`, `SceneInspectorPanel`, `ViewportToolbar`, and settings
+  panels
+
+## Basic composition
+
+```ts
+import {
+  createDefaultComponent,
+  createRenderPlan,
+  createSceneObject,
+  migrateToRenderGroups,
+} from "@vincentt-xr/sdk/scene-object";
+
+const object = createSceneObject({ name: "Cube", renderGroupId: "general" });
+const transform = createDefaultComponent("Transform", object.id);
+const meshRenderer = createDefaultComponent("MeshRenderer", object.id);
+
+object.componentIds = [transform.id, meshRenderer.id];
+```
+
+Render the object through the runtime bridge:
+
+```tsx
+import { SceneObjectRenderer } from "@vincentt-xr/sdk";
+
+const scene = migrateToRenderGroups(store);
+const [entry] = createRenderPlan(scene);
+
+<SceneObjectRenderer
+  objectId={entry.objectId}
+  store={scene}
+  renderOrder={entry.renderOrder}
+  renderLayer={entry.renderLayer}
+/>;
+```
+
+Open these source-backed docs at `/docs`. The verified in-repo editor is
+`/layer-panel-test`, and `test001` is the canonical external Harness client.
+
+## Current example routes
+
+Source of truth: `example/src/navigation/routes.tsx`. This list is a readable
+summary only.
+
+- `/unified-architecture`: current debug-ui composition for a unified
+  face-tracking scene.
+- `/testing-hook`: multi-face face-mesh sanity example using reusable
+  scene-object/debug-ui APIs.
+- `/body`: visible body-tracking anchors using `BodyTracker` and
+  `TrackingAnchor`.
+- `/debugger`: minimal debugger overlay example for metrics and runtime
+  inspection.
+- `/viewport-editor`: reusable 3D scene editor fixture.
+- `/face-retouch-legacy`: legacy face-retouch shader controls with debug-ui
+  settings.
+
+Example-app assets are organized by purpose: reusable media in
+`example/src/assets/media`, GLB files in `example/src/assets/models`, and
+domain-owned effect assets in folders such as `example/src/assets/face-effects`.

package/docs/scene-objects/overview.mdx

@@ -0,0 +1,127 @@
+---
+title: "Scene Object Overview"
+description: "The shared object/component model used by Screen Image, Screen Text, and 3D Object authoring."
+sidebarTitle: "Overview"
+icon: "layers"
+---
+
+The scene-object model separates identity from behavior.
+
+Import scene-object types, factories, selectors, and store operations from
+`@vincentt-xr/sdk/scene-object`. Runtime renderers remain in
+`@vincentt-xr/sdk`.
+
+Internal source layout: serialized scene-object helpers stay in
+`lib/scene-object/`; render helpers live in `lib/render/`; screen settings live
+in `lib/screen-image/` and `lib/screen-text/`. Public imports stay unchanged.
+
+## SceneObject
+
+`SceneObject` is the stable object users see in the editor hierarchy.
+
+```ts
+type SceneObject = {
+  id: SceneObjectId;
+  name: string;
+  enabled: boolean;
+  parentObjectId?: SceneObjectId | null;
+  childObjectIds?: SceneObjectId[];
+  renderGroupId?: string;
+  componentIds: SceneComponentId[];
+};
+```
+
+The object does not directly know how to render. Its ordered `componentIds`
+determine which systems apply to it.
+
+`parentObjectId` and `childObjectIds` model nested hierarchy. Child transforms
+are evaluated in parent space, so a child can keep its own local transform while
+parent movement affects the full subtree. Parenting does not rewrite the child
+Transform; existing child values become local-to-parent values. Use
+`setSceneObjectParent` instead of manually editing both fields. Editor surfaces
+that should avoid visual jumps can use
+`setSceneObjectParentPreserveWorldTransform`.
+
+World preservation is exact for transforms representable by the component.
+Rotation combined with non-uniform scale in an ancestor introduces matrix shear;
+because `Transform` and `ScreenTransform` do not expose shear, reparenting that
+case is approximate.
+
+## SceneComponent
+
+`SceneComponent` stores one typed component instance.
+
+```ts
+type SceneComponent<TType extends SceneComponentType = SceneComponentType> = {
+  id: SceneComponentId;
+  objectId: SceneObjectId;
+  type: TType;
+  enabled: boolean;
+  settings: ComponentRegistry[TType];
+};
+```
+
+## ComponentRegistry
+
+The registry maps component names to settings. This keeps the inspector,
+serialization layer, and runtime renderer type-aware.
+
+```ts
+type ComponentRegistry = {
+  Transform: Transform3DSettings;
+  ScreenTransform: ScreenTransform2DSettings;
+  ScreenImage: ScreenImageSettings;
+  ScreenText: ScreenTextSettings;
+  ScreenShape: ScreenShapeSettings;
+  TrackingAnchor: TrackingAnchorSettings;
+  MeshRenderer: MeshRendererSettings;
+  Material: MaterialSettings;
+  Texture: TextureSettings;
+  Light: LightSettings;
+  LookAt: LookAtSettings;
+  PinToMesh: PinToMeshSettings;
+};
+```
+
+Current 3D scene objects use `Transform` + `MeshRenderer`, optionally with
+`LookAt` and/or `PinToMesh` behavior components. Light objects use `Transform` +
+`Light`. Screen-space objects use `ScreenTransform` with `ScreenImage`,
+`ScreenText`, or `ScreenShape`. Add `TrackingAnchor` to a 2D or 3D object for
+face binding. Null/container objects use only `Transform` for 3D or only
+`ScreenTransform` for 2D.
+
+## Store shape
+
+```ts
+type SceneObjectStore = {
+  objects: Record<SceneObjectId, SceneObject>;
+  components: Record<SceneComponentId, SceneComponent>;
+};
+```
+
+Apps can extend the store with UI state:
+
+```ts
+type EditorStore = SceneObjectStore & {
+  selectedObjectId: SceneObjectId;
+};
+```
+
+Store helper functions preserve extra app-owned fields.
+
+Parent only within one transform domain: `Transform` children belong under 3D
+parents and `ScreenTransform` children under 2D parents. Mixed 2D/3D parenting
+is rejected. `setSceneObjectParentPreserveWorldTransform` supports both domains.
+
+Grouped editors extend the store with materialized groups:
+
+```ts
+type RenderGroupSceneObjectStore = SceneObjectStore & {
+  renderGroups: Record<RenderGroupId, RenderGroup>;
+  renderGroupOrder: RenderGroupId[];
+};
+```
+
+Use `migrateToRenderGroups(store, legacyObjectOrder?)` to construct this state.
+Only groups backed by compatible scene objects are materialized. Group order is
+derived state, not a hardcoded list.

package/docs/scene-objects/render-groups.mdx

@@ -0,0 +1,77 @@
+---
+title: "Render Groups"
+description: "Materialize compatible scene groups and control cross-domain composition."
+sidebarTitle: "Render Groups"
+icon: "layer-group"
+---
+
+Render groups are user-facing composition units. They are not Three.js camera
+layers and are not a fixed list.
+
+Import all render-group types, policies, migration, compatibility checks, reorder
+helpers, and `createRenderPlan` from `@vincentt-xr/sdk/scene-object`.
+
+Internal source layout: render-group helpers live under `lib/render/`
+(`renderGroups.ts`, `renderPasses.ts`, `layerStack.ts`). Public imports stay
+`@vincentt-xr/sdk/scene-object` or `@vincentt-xr/sdk`.
+
+## State
+
+```ts
+type RenderGroup = {
+  id: RenderGroupId;
+  name: string;
+  domain: RenderGroupDomain;
+  enabled: boolean;
+  objectIds: SceneObjectId[];
+};
+```
+
+`renderGroupOrder` controls order between groups. A group's `objectIds` controls
+order inside that group. The first group renders first; the last group renders
+last and composites in front.
+
+## Supported domains
+
+| Domain             | Required composition                               | Status    |
+| ------------------ | -------------------------------------------------- | --------- |
+| General / 3D Scene | `Transform` + `MeshRenderer`                       | Supported |
+| 2D Foreground      | `ScreenTransform` + `ScreenText` or `ScreenImage`  | Supported |
+| Background         | editor camera-texture plane or external background | Partial   |
+| AR Tracking        | Tracking scene-object components                   | Reserved  |
+| Post Effects       | Post-processing scene object                       | Reserved  |
+
+Reserved and empty groups are not materialized or shown in the Hierarchy.
+
+## Structural helpers
+
+- `reorderRenderGroup` changes `renderGroupOrder`.
+- `reorderObjectWithinGroup` changes one group's `objectIds`.
+- `validateGroupCompatibility` checks a cross-group move without mutation.
+- `moveObjectToGroup` updates group membership and `object.renderGroupId` only
+  when compatibility passes.
+- `createRenderPlan` assigns each enabled object a sorting band and internal
+  camera layer. It omits groups beyond `MAX_RENDER_GROUP_PASSES` rather than
+  throwing or reusing a camera layer.
+
+Unknown IDs and incompatible moves are safe no-ops.
+
+## Internal camera layers
+
+Camera layers are visibility masks used by sequential render passes. Their
+numeric values do not define visual order. Layer 0 is shared by lights,
+infrastructure, and editor controls. Managed groups use layers 1–30.
+Import `MAX_RENDER_GROUP_PASSES` from `@vincentt-xr/sdk` when guarding group
+creation in an authoring client.
+
+`VideoBackground` is a flat external camera-background component, not a managed
+scene object. The reusable `XRSceneViewport` owns a separate editor-only
+camera-texture plane when the camera feed should behave as depth-writing 3D
+geometry. `EXTERNAL_BACKGROUND_RENDER_LAYER` (31) remains temporary
+infrastructure for legacy external background composition.
+
+## Grouping flat stores
+
+`migrateToRenderGroups` validates explicit `renderGroupId` values, infers missing
+or incompatible assignments from object components, and derives the initial group
+order from the first object occurrence.

package/docs/scene-objects/runtime-rendering.mdx

@@ -0,0 +1,75 @@
+---
+title: "Runtime Rendering"
+description: "Render scene objects from component data with SceneObjectRenderer."
+sidebarTitle: "Runtime Rendering"
+icon: "play"
+---
+
+`SceneObjectRenderer` converts scene-object data into runtime React Three Fiber
+objects.
+
+## Props
+
+```ts
+type SceneObjectRendererProps = {
+  objectId: SceneObjectId;
+  store: SceneObjectStore;
+  editorMode?: boolean;
+  renderOrder?: number;
+  renderLayer?: number;
+  onComponentChange?: (component: SceneComponent) => void;
+  fallback?: (message: string) => ReactNode;
+};
+```
+
+## Supported combinations
+
+| Object type          | Components                                                     | Runtime result                                                    |
+| -------------------- | -------------------------------------------------------------- | ----------------------------------------------------------------- |
+| 3D Null              | `Transform`                                                    | invisible 3D transform container                                  |
+| 3D Object            | `Transform` + `MeshRenderer`                                   | transformed primitive or asset mesh                               |
+| 3D Object + behavior | `Transform` + `MeshRenderer` + optional `LookAt` / `PinToMesh` | mesh with behavior components resolved by scene-object target IDs |
+| Light                | `Transform` + `Light`                                          | ambient, directional, point, or spot light                        |
+| 2D Null              | `ScreenTransform`                                              | invisible screen-space transform container                        |
+| Screen Image         | `ScreenTransform` + `ScreenImage`                              | screen-space image                                                |
+| Screen Text          | `ScreenTransform` + `ScreenText`                               | screen-space text                                                 |
+| Screen Shape         | `ScreenTransform` + `ScreenShape`                              | vector shape with solid, gradient, or glass fill                  |
+| Face-bound object    | `Transform` or `ScreenTransform` + `TrackingAnchor`            | content attached to a face preset or custom face-local point      |
+
+## Render an object
+
+```tsx
+import { getRenderGroupLayer, SceneObjectRenderer, SequentialRenderPasses } from "@vincentt-xr/sdk";
+import { createRenderPlan } from "@vincentt-xr/sdk/scene-object";
+
+const plan = createRenderPlan(scene);
+const passLayers = Array.from(new Set(plan.map((entry) => entry.renderLayer)));
+
+<SequentialRenderPasses layers={passLayers} />;
+{
+  plan.map((entry) => (
+    <SceneObjectRenderer
+      key={entry.objectId}
+      objectId={entry.objectId}
+      store={scene}
+      renderOrder={entry.renderOrder}
+      renderLayer={entry.renderLayer}
+      editorMode={entry.objectId === scene.selectedObjectId}
+      onComponentChange={replaceComponent}
+    />
+  ));
+}
+```
+
+When `editorMode` is enabled, runtime transform controls can write changed
+component settings back through `onComponentChange`.
+
+For 3D objects, `SceneObjectRenderer` registers each rendered object ID with the
+runtime object registry. `LookAt` and `PinToMesh` then resolve
+`targetObjectId` values against that registry, so serialized scene data can point
+to other scene objects without hardcoded React refs.
+
+`SequentialRenderPasses` must be mounted inside `XRScene`. It renders groups from
+first to last, preserves color, and clears depth before later groups. The last
+group therefore composites in front. `captureFrame()` uses the same registered
+grouped renderer.

package/docs/texture-api-consumer.md

@@ -0,0 +1,58 @@
+# Texture API: client usage
+
+Use `ScreenImage` for the rendered object. Keep the resolver/controller outside
+the component and bind diagnostics or inspector controls to the same state.
+
+```tsx
+import { ScreenImage, ScreenSpaceUI } from "@vincentt-xr/sdk";
+import {
+  createTextureSourceResolver,
+  disposeResolvedTextureSource,
+  type ResolvedTextureSource,
+} from "@vincentt-xr/sdk/low-level";
+
+const resolver = createTextureSourceResolver(providers);
+
+function MediaImage({ source, transform }) {
+  const [resolved, setResolved] = useState<ResolvedTextureSource>();
+  useEffect(() => {
+    const controller = new AbortController();
+    let active: ResolvedTextureSource | undefined;
+    void resolver(source, controller.signal).then((next) => {
+      active = next;
+      setResolved(next);
+    });
+    return () => {
+      controller.abort();
+      disposeResolvedTextureSource(active);
+    };
+  }, [source]);
+
+  return (
+    <ScreenSpaceUI>
+      <ScreenImage
+        source={resolved ? { kind: "texture", texture: resolved.texture } : { kind: "default" }}
+        transform={transform}
+        materialType="unlit"
+        onScreenTransformChange={/* write the live scene-object state */}
+      />
+    </ScreenSpaceUI>
+  );
+}
+```
+
+Rules: abort stale loads; dispose only owned results; preserve transform/material
+settings during source changes; capability-gate playback controls; and expose
+loading, error, retry, paused, ended, and cleanup state to the caller.
+
+Media event compatibility:
+
+```ts
+const unsubscribe = resolved.controller?.on("PlayEnd", ({ snapshot }) => {
+  console.log(snapshot.frame, snapshot.time);
+});
+// unsubscribe on source replacement/unmount
+```
+
+Supported events: `KeyFrameInSecond`, `Pause`, `PlayBegin`, `PlayEnd`, `Resume`,
+and `Stop`.

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@vincentt-xr/sdk",
-  "version": "2.0.0-alpha.0",
+  "version": "2.0.0-alpha.2",
   "description": "XR SDK by Vincentt",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rangoon-x/vincentt-xr-sdk.git"
+  },
   "license": "UNLICENSED",
   "keywords": [
     "Vincentt",
@@ -13,7 +17,17 @@
   "sideEffects": false,
   "files": [
     "/dist",
-    "GROUNDING.md"
+    "GROUNDING.md",
+    "docs/api",
+    "docs/examples",
+    "docs/guides",
+    "docs/inspector",
+    "docs/scene-objects",
+    "docs/docs.json",
+    "docs/introduction.mdx",
+    "docs/MIGRATION_GUIDE.md",
+    "docs/SDK_DOCUMENTATION.md",
+    "docs/texture-api-consumer.md"
   ],
   "main": "./dist/main.cjs",
   "module": "./dist/main.js",
@@ -39,16 +53,37 @@
       "import": "./dist/low-level.js",
       "require": "./dist/low-level.cjs"
     },
+    "./scene-object": {
+      "types": "./dist/entries/scene-object.d.ts",
+      "import": "./dist/scene-object.js",
+      "require": "./dist/scene-object.cjs"
+    },
     "./internal": {
       "types": "./dist/entries/internal.d.ts",
       "import": "./dist/internal.js",
       "require": "./dist/internal.cjs"
+    },
+    "./debug-ui": {
+      "types": "./dist/debug-ui/index.d.ts",
+      "import": "./dist/debug-ui.js",
+      "require": "./dist/debug-ui.cjs"
+    },
+    "./debug-ui/media-source": {
+      "types": "./dist/debug-ui/media-source/index.d.ts",
+      "import": "./dist/debug-ui/media-source.js",
+      "require": "./dist/debug-ui/media-source.cjs"
+    },
+    "./debug-ui/default-setting": {
+      "types": "./dist/debug-ui/default-setting/index.d.ts",
+      "import": "./dist/debug-ui/default-setting.js",
+      "require": "./dist/debug-ui/default-setting.cjs"
     }
   },
   "peerDependencies": {
     "@mediapipe/tasks-vision": "^0.10.18",
     "@react-three/drei": "9.105.6",
     "@react-three/fiber": "8.18.0",
+    "onnxruntime-web": "^1.27.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "three": "0.173.0"
@@ -56,9 +91,14 @@
   "peerDependenciesMeta": {
     "@mediapipe/tasks-vision": {
       "optional": false
+    },
+    "onnxruntime-web": {
+      "optional": true
     }
   },
   "devDependencies": {
+    "@eslint/js": "^9.14.0",
+    "@mdx-js/rollup": "^3.1.1",
     "@types/node": "^22.9.0",
     "@types/react": "^18.3.12",
     "@types/react-dom": "^18.3.1",
@@ -69,8 +109,6 @@
     "commit-and-tag-version": "^12.5.0",
     "cz-conventional-changelog": "^3.3.0",
     "eslint": "^9.14.0",
-    "eslint-config-airbnb": "^19.0.4",
-    "eslint-config-airbnb-typescript": "^18.0.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
     "eslint-plugin-react": "^7.37.2",
@@ -78,9 +116,14 @@
     "eslint-plugin-react-refresh": "^0.4.14",
     "husky": "^9.1.6",
     "lint-staged": "^15.2.10",
+    "omggif": "^1.0.10",
+    "onnxruntime-web": "^1.27.0",
     "prettier": "3.3.3",
     "qrcode-terminal": "^0.12.0",
     "react-router-dom": "^6.28.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-mdx-frontmatter": "^5.2.0",
     "typescript": "^5.6.3",
     "vite": "^5.4.11",
     "vite-plugin-dts": "^4.3.0",
@@ -95,17 +138,22 @@
       "path": "./node_modules/cz-conventional-changelog"
     }
   },
+  "dependencies": {
+    "lucide-react": "^1.14.0"
+  },
   "scripts": {
     "dev": "vite --config example/vite.config.ts --mode dev",
     "preview:tunnel": "node example/scripts/preview.mjs",
     "preview:local": "node example/scripts/preview.mjs --local",
     "build": "vite build",
     "build:watch": "vite build --watch",
-    "format:check": "prettier --check .",
-    "format": "prettier --write 'src/**/*.{js,jsx,ts,tsx}' 'lib/**/*.{js,jsx,ts,tsx}'",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
+    "typecheck:example": "tsc --noEmit -p example/tsconfig.json",
+    "format:check": "prettier --check 'lib/**/*.{ts,tsx}' 'example/**/*.{ts,tsx}' '*.{json,md,mjs,ts}' '.github/**/*.{md,yml}' 'docs/**/*.{md,mdx,json}'",
+    "format": "prettier --write 'lib/**/*.{js,jsx,ts,tsx}' 'example/**/*.{js,jsx,ts,tsx}'",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint:check": "eslint src --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
+    "lint:check": "eslint lib --max-warnings 0",
     "example:build": "vite build --config example/vite.config.ts",
     "example:preview": "vite preview --config example/vite.config.ts --outDir dist-example",
     "release": "commit-and-tag-version"

package/dist/components/FaceRetouch/retouchRegions.d.ts

@@ -1,23 +0,0 @@
-import { FaceLandmark2D, FaceRetouchRegion } from '../../types/face';
-export declare const DEFAULT_FEATURE_GROUPS: number[][];
-export declare const DEFAULT_FEATURE_POINT_INDICES: number[];
-export type CreateFaceRetouchRegionsOptions = {
-    faceOvalIndices?: number[];
-    featureGroups?: number[][];
-    featurePointIndices?: number[];
-    faceBoundsExpansion?: number;
-    featureBoundsExpansion?: number;
-    minRegionRadius?: number;
-    faceRegionStrength?: number;
-    featureRegionStrength?: number;
-    featurePointRegionStrength?: number;
-    featurePointRadiusRatio?: number;
-};
-/**
- * Compute elliptical retouch regions from MediaPipe face landmarks.
- *
- * The defaults match the V2 face-retouch demo. Override `featureGroups`
- * or `featurePointIndices` to retouch a different anatomy (or a different
- * landmark model).
- */
-export declare const createFaceRetouchRegions: (landmarks: FaceLandmark2D[] | undefined, options?: CreateFaceRetouchRegionsOptions) => FaceRetouchRegion[];

package/dist/components/FaceRetouch/useFaceRetouchRegions.d.ts

@@ -1,12 +0,0 @@
-import { FaceRetouchRegion } from '../../types/face';
-import { XRModelNodeFaceTracking } from '../../types/nodes';
-import { CreateFaceRetouchRegionsOptions } from './retouchRegions';
-/**
- * Continuously recompute face-retouch regions from the active face's
- * landmarks. Returns a stable array reference when the regions haven't
- * meaningfully changed (4-decimal precision).
- *
- * Pass `options` to retouch a different anatomy or landmark model — see
- * `createFaceRetouchRegions`.
- */
-export declare const useFaceRetouchRegions: (faceNode: XRModelNodeFaceTracking | null, options?: CreateFaceRetouchRegionsOptions) => FaceRetouchRegion[];