@lovelace_lol/embody 0.0.13 → 0.0.14

package/dist/three/annotations/DOMControls.d.ts

@@ -1,5 +1,5 @@
 /**
- * Self-contained DOM controls for DPthreeCameraController
+ * Self-contained DOM controls for ThreeAnnotationController
  * No React dependencies - vanilla DOM manipulation
  */
 export interface DOMControlRegion {
@@ -27,6 +27,10 @@ export declare function isRuntimeAnnotationRegionName(name: string): boolean;
 export declare function filterCameraViewRegions<T extends {
     name: string;
 }>(regions: T[]): T[];
+/**
+ * Format region name for display
+ * Converts snake_case to Title Case
+ */
 export declare function buildRegionDisplayOptions(regions: DOMControlRegion[]): Array<{
     name: string;
     label: string;

package/dist/three/annotations/HtmlAnnotationMarkers.d.ts

@@ -0,0 +1,5 @@
+import { ThreeAnnotationMarkers, type AnnotationMarkersConfig } from './ThreeAnnotationMarkers';
+/** HTML rendering of the same Rust annotation state and layout. */
+export declare class HtmlAnnotationMarkers extends ThreeAnnotationMarkers {
+    constructor(options: AnnotationMarkersConfig);
+}

package/dist/three/annotations/OverlayAnnotationMarkers.d.ts

@@ -0,0 +1 @@
+export { HtmlAnnotationMarkers as OverlayAnnotationMarkers } from './HtmlAnnotationMarkers';

package/dist/three/annotations/ThreeAnnotationController.d.ts

@@ -0,0 +1,145 @@
+import * as THREE from 'three';
+import { ThreeAnnotationControls } from './ThreeAnnotationControls';
+import type { ThreeAnnotationControllerConfig, CharacterConfig, AnnotationAnchoredRegion, CameraState, MarkerStyle, MarkerStyleOverrides, LineConfig, ExpandedRegionState, RuntimeAnnotationOptions, RuntimeAnnotationRegionSummary, RegionChangeCallback } from './types';
+export interface MarkerStateSnapshot {
+    visible: boolean;
+    style: MarkerStyle;
+}
+/** Native resource owner for one Rust AnnotationRuntime. Await create() or initialize Wasm before construction. */
+export declare class ThreeAnnotationController {
+    readonly camera: THREE.PerspectiveCamera;
+    readonly scene: THREE.Scene;
+    readonly controls: ThreeAnnotationControls;
+    private readonly runtime;
+    private readonly markerRenderer;
+    private readonly resolveCharacterConfig;
+    private readonly selectRegion?;
+    private domElement;
+    private readonly manageCamera;
+    private observer;
+    private hostConfig;
+    private configSnapshot;
+    private configSnapshotRevision;
+    private configSnapshotHost;
+    private state;
+    private domControls;
+    private disposed;
+    private fallbackFrame;
+    private readonly flights;
+    private readonly markerStateListeners;
+    private readonly regionListeners;
+    private renderer;
+    private readonly playbackTimer;
+    private renderFrame;
+    private resizeRenderer;
+    private onRenderError;
+    private renderingSuspended;
+    private unbindRendering;
+    private renderingFailure;
+    private framePending;
+    private frameCompletion;
+    private modelPreparation;
+    private renderFailed;
+    private resizeObserver;
+    private boundResizeHandler;
+    static create(config: ThreeAnnotationControllerConfig): Promise<ThreeAnnotationController>;
+    constructor(config: ThreeAnnotationControllerConfig, nativeOptions?: {
+        captureInput?: boolean;
+        manageCamera?: boolean;
+        markerDefaults?: unknown;
+    });
+    private readState;
+    private call;
+    private sync;
+    private applyCameraState;
+    private isCurrent;
+    private requestFrame;
+    private settleFlights;
+    private waitForFlight;
+    private select;
+    private pick;
+    setModel(model: THREE.Object3D): void;
+    /** Drop native and Rust model observations before the host releases its model under a rendering lease. */
+    clearModel(): void;
+    getModel(): THREE.Object3D | null;
+    loadRegions(config: CharacterConfig): Promise<void>;
+    private configure;
+    prepareRegionsForReveal(config: CharacterConfig): void;
+    prepareRegionsAndMarkersForReveal(config: CharacterConfig, beforeReveal?: () => Promise<boolean>): Promise<void>;
+    private startConfiguredCamera;
+    loadMarkersForCurrentRegions(sliceSurfaceQueries?: boolean): Promise<void>;
+    private rebuild;
+    focusRegion(name: string, duration?: number): Promise<void>;
+    focusBones(bones: string[], duration?: number): Promise<void>;
+    focusMeshes(meshes: string[], duration?: number): Promise<void>;
+    focusFullBody(duration?: number): Promise<void>;
+    focusObjects(objects: THREE.Object3D[], duration?: number): Promise<void>;
+    private focus;
+    playIntroAnimation(orbitDuration?: number, zoomDuration?: number): Promise<void>;
+    animateToCameraState(state: CameraState, duration?: number): Promise<void>;
+    getCameraState(): CameraState;
+    setCameraState(state: CameraState): void;
+    getRegionNames(): string[];
+    getCurrentRegion(): string | null;
+    getCharacterConfig(): CharacterConfig | null;
+    getAnnotationRegions(): AnnotationAnchoredRegion[];
+    getAnnotationRegion(name: string): AnnotationAnchoredRegion | undefined;
+    setCurrentRegion(name: string | null): void;
+    getMarkersVisible(): boolean;
+    setMarkersVisible(visible: boolean): void;
+    getMarkerStyle(): MarkerStyle;
+    setMarkerStyle(style: MarkerStyle): void;
+    clearMarkers(): void;
+    subscribeMarkerState(listener: (state: MarkerStateSnapshot) => void): () => void;
+    onRegionChange(listener: RegionChangeCallback): () => void;
+    soloMarker(name: string | null): void;
+    getSoloedMarker(): string | null;
+    expandRegion(name: string, duration?: number): void;
+    setRegionExpansion(name: string, expanded: boolean, animation?: 'outward' | 'staggered', duration?: number): void;
+    collapseRegion(name: string, duration?: number): void;
+    toggleRegion(name: string, animation?: 'outward' | 'staggered', duration?: number): void;
+    private expandCommand;
+    getExpandedRegions(): ExpandedRegionState[];
+    setRegionLineStyle(name: string, line: Partial<LineConfig>): void;
+    setRegionStyle(name: string, style: Partial<MarkerStyleOverrides>): void;
+    updateRegionMeshes(name: string, meshes: string[]): void;
+    repositionMarker(name: string, position: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    getMarkerPosition(name: string): {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+    updateAnnotationRegion(name: string, update: Partial<AnnotationAnchoredRegion>): void;
+    removeAnnotationRegion(name: string): void;
+    showRuntimeBoneAnnotation(boneName: string, options?: RuntimeAnnotationOptions): RuntimeAnnotationRegionSummary;
+    showRuntimeAUAnnotations(auId: string | number, profile?: unknown, options?: RuntimeAnnotationOptions, morphTargetsByMesh?: unknown): RuntimeAnnotationRegionSummary[];
+    clearRuntimeAnnotations(): string[];
+    setDOMControlsVisible(visible: boolean): void;
+    updateDOMControls(): void;
+    update(): void;
+    dispose(): void;
+    private startRenderLoop;
+    private handleRenderError;
+    /**
+     * Stop the render loop
+     */
+    private stopRenderLoop;
+    private setupResizeHandling;
+    /**
+     * Clean up resize handling
+     */
+    private cleanupResizeHandling;
+    /**
+     * Prepare the currently visible material variants before first reveal.
+     * Borrows model/renderer; callers retain them until this promise settles,
+     * including after cancellation or controller disposal.
+     */
+    prepareModelForRender(model: THREE.Object3D, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    private cancelModelPreparation;
+}

package/dist/three/annotations/ThreeAnnotationControls.d.ts

@@ -0,0 +1,42 @@
+import * as THREE from 'three';
+import type { NativeAnnotationRuntime } from './runtime';
+/** Native event capture and pose observation. Rust integrates every gesture. */
+export declare class ThreeAnnotationControls extends THREE.EventDispatcher<{
+    change: {};
+    start: {};
+    end: {};
+}> {
+    domElement: HTMLElement;
+    private readonly runtime;
+    private readonly advance;
+    private readonly captureInput;
+    readonly target: THREE.Vector3;
+    private disposed;
+    private previousTouchAction;
+    private connected;
+    constructor(domElement: HTMLElement, runtime: NativeAnnotationRuntime, advance: () => void, captureInput?: boolean);
+    connect(element: HTMLElement): void;
+    disconnect(): void;
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    get enableDamping(): boolean;
+    set enableDamping(enableDamping: boolean);
+    get dampingFactor(): number;
+    set dampingFactor(dampingFactor: number);
+    get minDistance(): number;
+    set minDistance(minDistance: number);
+    get maxDistance(): number;
+    set maxDistance(maxDistance: number);
+    private read;
+    private settings;
+    update(): void;
+    notifyChange(): void;
+    private send;
+    private readonly down;
+    private readonly move;
+    private readonly up;
+    private readonly cancel;
+    private readonly wheel;
+    private readonly contextMenu;
+    dispose(): void;
+}

package/dist/three/annotations/ThreeAnnotationMarkers.d.ts

@@ -0,0 +1,42 @@
+import * as THREE from 'three';
+import { ThreeAnnotationController } from './ThreeAnnotationController';
+import type { AnnotationAnchoredRegion, CharacterConfig, MarkerStyle, MarkerStyleOverrides, LineConfig, ExpandAnimation } from './types';
+export interface AnnotationMarkersConfig {
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    domElement: HTMLElement;
+    onSelect: (name: string) => void;
+    config?: Partial<MarkerStyleOverrides> & {
+        lineLength?: number;
+        labelScale?: number;
+    };
+}
+/** Marker-only native view of the same Rust runtime used by the controller. */
+export declare class ThreeAnnotationMarkers {
+    private readonly options;
+    private readonly style;
+    protected readonly controller: ThreeAnnotationController;
+    constructor(options: AnnotationMarkersConfig, style?: MarkerStyle);
+    setModel(model: THREE.Object3D): void;
+    loadRegions(config: CharacterConfig, options?: {
+        sliceSurfaceQueries?: boolean;
+    }): Promise<void>;
+    setCurrentRegion(name: string | null): void;
+    updateRegion(name: string, update: Partial<AnnotationAnchoredRegion>): void;
+    removeRegion(name: string): void;
+    updateRegionMeshes(name: string, meshes: string[]): void;
+    repositionMarker(name: string, position: THREE.Vector3): void;
+    getMarkerPosition(name: string): THREE.Vector3 | null;
+    updateLineStyle(name: string, line: Partial<LineConfig>): void;
+    updateMarkerStyle(name: string, style: Partial<MarkerStyleOverrides>): void;
+    setSoloMarker(name: string | null): void;
+    getSoloedMarker(): string | null;
+    expandRegion(name: string, animation?: ExpandAnimation, duration?: number): void;
+    collapseRegion(name: string, duration?: number): void;
+    toggleRegion(name: string, animation?: ExpandAnimation, duration?: number): void;
+    getExpandedRegions(): import("./types").ExpandedRegionState[];
+    update(): void;
+    setVisible(visible: boolean): void;
+    clear(): void;
+    dispose(): void;
+}

package/dist/three/annotations/ThreeAnnotationRenderer.d.ts

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+import type { AnnotationSnapshot, NativeAnnotationRuntime } from './runtime';
+/** Applies Rust frame records to native objects. No annotation state machine. */
+export declare class ThreeAnnotationRenderer {
+    private readonly runtime;
+    private readonly scene;
+    private readonly camera;
+    private domElement;
+    private readonly onPick;
+    private readonly onHover;
+    private readonly group;
+    private readonly objects;
+    private readonly overlay;
+    private readonly raycaster;
+    private readonly pointer;
+    private readonly viewProjection;
+    private overlayParent;
+    private releaseParentPosition;
+    private readonly overlayResizeObserver;
+    private style;
+    private revision;
+    private meshes;
+    setMeshes(meshes: THREE.Mesh[]): void;
+    constructor(runtime: NativeAnnotationRuntime, scene: THREE.Scene, camera: THREE.PerspectiveCamera, domElement: HTMLElement, onPick: (ids: number[]) => void, onHover: (id: number | null) => void);
+    private attachOverlay;
+    private layoutOverlay;
+    setDomElement(element: HTMLElement): void;
+    sync(snapshot: AnnotationSnapshot): void;
+    private create;
+    update(now: number): void;
+    private readonly click;
+    private remove;
+    clear(): void;
+    dispose(): void;
+}

package/dist/three/annotations/{DPthree.d.ts → ThreeAnnotations.d.ts}

@@ -1,10 +1,10 @@
 import * as THREE from 'three';
-import { DPthreeCameraController } from './DPthreeCameraController';
-import type { CharacterConfig, DPthreeCameraControllerConfig, MarkerStyle, LineConfig, MarkerStyleOverrides, ExpandAnimation, ExpandedRegionState } from './types';
+import { ThreeAnnotationController } from './ThreeAnnotationController';
+import type { CharacterConfig, ThreeAnnotationControllerConfig, MarkerStyle, LineConfig, MarkerStyleOverrides, ExpandAnimation, ExpandedRegionState } from './types';
 /**
- * DPthree Configuration
+ * ThreeAnnotations Configuration
  */
-export interface DPthreeConfig {
+export interface ThreeAnnotationsConfig {
     /** Three.js scene */
     scene: THREE.Scene;
     /** Three.js camera */
@@ -18,35 +18,35 @@ export interface DPthreeConfig {
     /** Callback when a region is selected */
     onRegionSelect?: (name: string) => void;
     /** Camera controller options */
-    cameraOptions?: Partial<DPthreeCameraControllerConfig>;
+    cameraOptions?: Partial<ThreeAnnotationControllerConfig>;
 }
 /**
- * DPthree - Camera & Marker System for Three.js
+ * ThreeAnnotations - Camera & Marker System for Three.js
  *
  * Factory class that creates and manages camera controller and markers.
  *
  * @example
  * ```typescript
- * const dp = new DPthree({
+ * const annotations = await ThreeAnnotations.create({
  *   scene,
  *   camera,
  *   domElement: canvas,
  *   markerStyle: '3d',
  * });
  *
- * dp.setModel(model);
- * await dp.loadCharacter(config);
- * dp.focus('head');
+ * annotations.setModel(model);
+ * await annotations.loadCharacter(config);
+ * annotations.focus('head');
  *
  * // In render loop
- * dp.update();
+ * annotations.update();
  * ```
  */
-export declare class DPthree {
+export declare class ThreeAnnotations {
     private readonly cameraController;
-    private markerStyle;
     private model;
-    constructor(options: DPthreeConfig);
+    static create(options: ThreeAnnotationsConfig): Promise<ThreeAnnotations>;
+    constructor(options: ThreeAnnotationsConfig);
     setModel(model: THREE.Object3D): this;
     loadCharacter(config: CharacterConfig): Promise<this>;
     focus(regionName: string, duration?: number): Promise<void>;
@@ -57,7 +57,7 @@ export declare class DPthree {
     setControlsVisible(visible: boolean): this;
     getCameraState(): import("./types").CameraState;
     setCameraState(position: [number, number, number], target: [number, number, number], _animate?: boolean): this;
-    get controller(): DPthreeCameraController;
+    get controller(): ThreeAnnotationController;
     update(): void;
     expandRegion(name: string, duration?: number): this;
     collapseRegion(name: string, duration?: number): this;
@@ -75,17 +75,8 @@ export declare class DPthree {
      * @returns Validation result with found/missing bones and morphs
      */
     validateCharacter(expectedBones?: Record<string, string>, expectedMorphs?: string[]): CharacterValidationResult;
-    /**
-     * Get all bone names in the loaded model
-     */
     getBoneNames(): string[];
-    /**
-     * Get all morph target names in the loaded model
-     */
     getMorphNames(): string[];
-    /**
-     * Get all mesh names in the loaded model
-     */
     getMeshNames(): string[];
 }
 export interface ValidationItem {
@@ -107,7 +98,7 @@ export interface CharacterValidationResult {
     };
     summary: string;
 }
-export { DPthreeCameraController as CameraController } from './DPthreeCameraController';
-export { DPthree3DMarkers as Markers3D } from './DPthree3DMarkers';
-export { DPthreeHTMLMarkers as MarkersHTML } from './DPthreeHTMLMarkers';
+export { ThreeAnnotationController as CameraController } from './ThreeAnnotationController';
+export { ThreeAnnotationMarkers as Markers3D } from './ThreeAnnotationMarkers';
+export { HtmlAnnotationMarkers as MarkersHTML } from './HtmlAnnotationMarkers';
 export { CameraDOMControls as Controls } from './DOMControls';

package/dist/three/annotations/adapter.d.ts

@@ -134,7 +134,7 @@ export declare function getSemanticHorizontalSignForSide(side: 'left' | 'right',
 export declare function getSemanticHorizontalSign(name: string, laterality: AnnotationLaterality): 1 | -1 | null;
 export declare function resolveRegionCameraAngle(region: Region, laterality: AnnotationLaterality): number | undefined;
 export declare function resolveRegionVisibilityCameraAngle(region: Region, laterality: AnnotationLaterality): number | undefined;
-export declare function toWorldDirection(model: Object3D | null, local: Vector3): Vector3;
+export declare function toWorldDirection(model: Object3D | null, direction: Vector3): Vector3;
 export declare function getWorldDirectionForCameraAngle(model: Object3D | null, angle: number): Vector3;
 export declare function getModelLocalOrbitAngle(model: Object3D | null, center: Vector3, position: Vector3): number;
 export declare function passesMarkerCameraAngleGate(o: {
@@ -142,15 +142,9 @@ export declare function passesMarkerCameraAngleGate(o: {
     currentCameraAngle?: number;
     rangeDegrees?: number;
 }): boolean;
-/** Reduce scene objects to a world-space annotation anchor; numeric camera math stays in Rust. */
 export declare function resolveFaceCenter(model: Object3D, region: Region, profile?: BoneResolutionProfile | null): {
     center: Vector3;
-    method: string;
-    debugInfo: string[];
-    headBonePosition?: undefined;
-} | {
-    center: Vector3;
-    headBonePosition: Vector3 | undefined;
+    headBonePosition?: Vector3;
     method: string;
     debugInfo: string[];
 };

package/dist/three/annotations/annotationAnchorModel.d.ts

@@ -7,10 +7,6 @@ export interface ResolvedMarkerAnchorRegion {
     projection: MarkerAnchorProjectionMode;
     useLegacyRegionSemantics: boolean;
 }
-/**
- * Convert explicit marker-anchor intent into the legacy region target fields
- * that the current marker renderers understand.
- */
 export declare function resolveMarkerAnchorRegion(region: Region): ResolvedMarkerAnchorRegion;
 export declare function shouldUseFaceCenterForMarkerAnchor(resolved: ResolvedMarkerAnchorRegion): boolean;
 export declare function shouldProjectMarkerAnchorToSurface(resolved: ResolvedMarkerAnchorRegion, legacyDefault: boolean): boolean;

package/dist/three/annotations/index.d.ts

@@ -1,10 +1,11 @@
-export { DPthree, CameraController, Markers3D, MarkersHTML, Controls } from './DPthree';
-export type { DPthreeConfig, CharacterValidationResult, ValidationCategory, ValidationItem } from './DPthree';
-export { DPthreeCameraController } from './DPthreeCameraController';
-export type { MarkerStateSnapshot } from './DPthreeCameraController';
-export { DPthree3DMarkers } from './DPthree3DMarkers';
-export { DPthreeHTMLMarkers } from './DPthreeHTMLMarkers';
-export { DPthreeMarkers } from './DPthreeMarkers';
+export { ThreeAnnotations, CameraController, Markers3D, MarkersHTML, Controls } from './ThreeAnnotations';
+export type { ThreeAnnotationsConfig, CharacterValidationResult, ValidationCategory, ValidationItem } from './ThreeAnnotations';
+export { ThreeAnnotationController } from './ThreeAnnotationController';
+export type { ThreeAnnotationControls } from './ThreeAnnotationControls';
+export type { MarkerStateSnapshot } from './ThreeAnnotationController';
+export { ThreeAnnotationMarkers } from './ThreeAnnotationMarkers';
+export { HtmlAnnotationMarkers } from './HtmlAnnotationMarkers';
+export { OverlayAnnotationMarkers } from './OverlayAnnotationMarkers';
 export { CameraDOMControls, RUNTIME_ANNOTATION_REGION_PREFIX, filterCameraViewRegions, isRuntimeAnnotationRegionName, buildRegionDisplayOptions } from './DOMControls';
 export type { DOMControlRegion, DOMControlsConfig } from './DOMControls';
 export { resolveMarkerAnchorRegion, shouldProjectMarkerAnchorToSurface, shouldUseFaceCenterForMarkerAnchor } from './annotationAnchorModel';
@@ -17,4 +18,4 @@ export type { RuntimeAnnotationPreviewLifecycleOptions } from './runtimeAnnotati
 export { inferRuntimeAnnotationPreviewSide, pickContinuumAnnotationAuId } from './runtimeAnnotationPreviewSide';
 export { boneResolutionProfile } from './boneResolutionProfile';
 export { resolveAnnotationCharacterConfig, RustAnnotationCameraCore, createRustAnnotationCameraCore, getDefaultAnnotationLaterality, getSemanticHorizontalSignForSide, getSemanticHorizontalSign, resolveRegionCameraAngle, resolveRegionVisibilityCameraAngle, toWorldDirection, getWorldDirectionForCameraAngle, getModelLocalOrbitAngle, passesMarkerCameraAngleGate, resolveFaceCenter, detectAnnotationLaterality, } from './adapter';
-export type { AnnotationCharacterConfig, AnnotationAnchorPoint, AnnotationMarkerAnchor, AnnotationMarkerAnchorType, AnnotationFocusTarget, AnnotationAnchoredRegion, RuntimeAnnotationMetadata, RuntimeAnnotationOptions, RuntimeAnnotationRegionSummary, RuntimeAnnotationSide, RuntimeAnnotationTargetType, CameraState, FocusPosition, DPthreeCameraControllerConfig, RegionChangeCallback, CharacterChangeCallback, DPthreeRegion, DPthreeCharacterConfig, DPthreeRegistry, DPthreeRegionChangeCallback, DPthreeCharacterChangeCallback, LineStyle, LineCurve, NamedDirection, LineConfig, MarkerStyleOverrides, ExpandAnimation, ExpandedRegionState, FallbackConfig, MarkerGroup, Region, MarkerStyle, BoneResolutionProfile, AnnotationLaterality, } from './types';
+export type { AnnotationCharacterConfig, AnnotationAnchorPoint, AnnotationMarkerAnchor, AnnotationMarkerAnchorType, AnnotationFocusTarget, AnnotationAnchoredRegion, RuntimeAnnotationMetadata, RuntimeAnnotationOptions, RuntimeAnnotationRegionSummary, RuntimeAnnotationSide, RuntimeAnnotationTargetType, CameraState, FocusPosition, ThreeAnnotationControllerConfig, RegionChangeCallback, CharacterChangeCallback, AnnotationRegion, AnnotationRegistry, AnnotationRegionChangeCallback, AnnotationCharacterChangeCallback, LineStyle, LineCurve, NamedDirection, LineConfig, MarkerStyleOverrides, ExpandAnimation, ExpandedRegionState, FallbackConfig, MarkerGroup, Region, MarkerStyle, BoneResolutionProfile, AnnotationLaterality, } from './types';

package/dist/three/annotations/lifecycleBridge.d.ts

@@ -0,0 +1,26 @@
+export type LifecycleEffect = {
+    kind: 'visibility' | 'style' | 'previewStart' | 'previewEnd';
+    visible?: boolean;
+    style?: '3d' | 'html';
+};
+/** Clock/queue transport only. All deadline and effect decisions belong to Rust. */
+export declare class AnnotationLifecycleBridge {
+    private readonly mode;
+    private readonly duration;
+    private readonly apply;
+    private readiness;
+    private initializing;
+    private core;
+    private timer;
+    private pending;
+    private initialized;
+    private commandRevision;
+    constructor(mode: 'preview' | 'visibility', duration: number, apply: (effects: LifecycleEffect[]) => void);
+    /** The current attempt; dispatching after a failed attempt can start a retry. */
+    get ready(): Promise<void>;
+    private initialize;
+    private drainPending;
+    dispatch(operation: string, options?: unknown): void;
+    private execute;
+    isActive(): boolean;
+}

package/dist/three/annotations/markerVisibilityLifecycle.d.ts

@@ -1,4 +1,4 @@
-import type { DPthreeCameraController } from './DPthreeCameraController';
+import type { ThreeAnnotationController } from './ThreeAnnotationController';
 import type { MarkerStyle } from './types';
 export declare const DEFAULT_MARKER_AUTO_HIDE_MS = 5000;
 export type MarkerLifecycleRevealOptions = {
@@ -10,12 +10,13 @@ export type MarkerLifecycleRevealSource = {
     markerStyle?: MarkerStyle;
     playIntroOnLoad?: boolean;
 };
-type MarkerLifecycleController = Pick<DPthreeCameraController, 'setMarkersVisible' | 'setMarkerStyle'>;
+type Controller = Pick<ThreeAnnotationController, 'setMarkersVisible' | 'setMarkerStyle'>;
 export declare function createMarkerLifecycleRevealOptions(config: MarkerLifecycleRevealSource | null | undefined): MarkerLifecycleRevealOptions;
-export declare function createMarkerVisibilityLifecycle(getController: () => MarkerLifecycleController | null, defaultDurationMs?: number): {
-    setManualVisibility(visible: boolean): void;
-    prepareForCharacterLoad(): void;
-    showForCharacterLoad(options?: MarkerLifecycleRevealOptions): void;
-    dispose(): void;
+export declare function createMarkerVisibilityLifecycle(getController: () => Controller | null, defaultDurationMs?: number): {
+    readonly ready: Promise<void>;
+    setManualVisibility: (visible: boolean) => void;
+    prepareForCharacterLoad: () => void;
+    showForCharacterLoad: (options?: MarkerLifecycleRevealOptions) => void;
+    dispose: () => void;
 };
 export {};

package/dist/three/annotations/modelObservation.d.ts

@@ -0,0 +1,44 @@
+import * as THREE from 'three';
+import type { NativeAnnotationRuntime } from './runtime';
+type Bounds = {
+    min: number[];
+    max: number[];
+};
+export interface AnnotationModelObservation {
+    bounds: Bounds;
+    quaternion: number[];
+    inverse: number[];
+    objects: {
+        id: number;
+        name: string;
+        kind: string;
+        parent: number | null;
+        position: number[];
+        bounds: Bounds | null;
+        matrix: number[];
+        inverse: number[];
+        morphNames: string[];
+    }[];
+}
+export declare function readAttribute(attribute: THREE.BufferAttribute | THREE.InterleavedBufferAttribute): Float32Array;
+/** Stable native handle table. No region matching or anchor policy lives here. */
+export declare class AnnotationModelObserver {
+    readonly model: THREE.Object3D;
+    readonly objects: Map<number, THREE.Object3D<THREE.Object3DEventMap>>;
+    readonly meshes: THREE.Mesh[];
+    private readonly ids;
+    constructor(model: THREE.Object3D);
+    id(object: THREE.Object3D): number | undefined;
+    capture(): AnnotationModelObservation;
+    observe(runtime: NativeAnnotationRuntime): void;
+    transforms(runtime: NativeAnnotationRuntime): Float32Array;
+    morphAnchors(runtime: NativeAnnotationRuntime): Record<string, {
+        x: number;
+        y: number;
+        z: number;
+    }>;
+    /** Rust selects influenced vertices; Three evaluates the current native pose. */
+    observeFocus(runtime: NativeAnnotationRuntime, request: unknown): void;
+}
+export declare function observeAnnotationModel(model: THREE.Object3D): AnnotationModelObservation;
+export {};

package/dist/three/annotations/runtime.d.ts

@@ -0,0 +1,46 @@
+import { requireInitializedEmbodyCore } from '@lovelace_lol/embody/wasm';
+import type { AnnotationAnchoredRegion, AnnotationCharacterConfig, CameraState, ExpandedRegionState, MarkerStyle, MarkerStyleOverrides, LineConfig } from './types';
+export declare function annotationQuery<T>(operation: string, payload: unknown): T;
+export type NativeAnnotationRuntime = InstanceType<ReturnType<typeof requireInitializedEmbodyCore>['AnnotationRuntime']>;
+export interface MarkerDescriptor {
+    id: number;
+    name: string;
+    label: string;
+    title: string;
+    htmlText: string;
+    style: Required<Omit<MarkerStyleOverrides, 'line'>> & {
+        line: Required<LineConfig>;
+    };
+    radius: number;
+    arrowLength: number;
+    arrowRadius: number;
+}
+export interface AnnotationSnapshot {
+    generation: number;
+    revision: number;
+    descriptorRevision: number;
+    configRevision: number;
+    disposed: boolean;
+    loaded: boolean;
+    visible: boolean;
+    style: MarkerStyle;
+    currentRegion: string | null;
+    solo: string | null;
+    regions: AnnotationAnchoredRegion[];
+    config: AnnotationCharacterConfig;
+    descriptors: MarkerDescriptor[];
+    camera: CameraState;
+    expanded: ExpandedRegionState[];
+}
+export interface SurfaceQuery {
+    id: number;
+    generation: number;
+    phase: number;
+    origin: [number, number, number];
+    direction: [number, number, number];
+    far: number;
+}
+/** Only annotation contract data crosses Wasm; host resources/metadata stay borrowed. */
+export declare function annotationConfigInput(config: AnnotationCharacterConfig): Record<string, unknown>;
+/** Profile transport selects contract fields without traversing host metadata. */
+export declare function annotationProfileInput(profile: unknown): unknown;

package/dist/three/annotations/runtimeAnnotationPreview.d.ts

@@ -5,9 +5,9 @@ export interface RuntimeAnnotationPreviewLifecycleOptions {
     onPreviewStart?: () => void;
     onPreviewEnd?: () => void;
 }
-/** Framework-independent annotation preview lifetime; hosts supply input events. */
 export declare function createRuntimeAnnotationPreviewLifecycle(options: RuntimeAnnotationPreviewLifecycleOptions): {
-    start(forceRefresh?: boolean): void;
+    readonly ready: Promise<void>;
+    start: (forceRefresh?: boolean) => void;
     end: () => void;
     scheduleEnd: () => void;
     isActive: () => boolean;

package/dist/three/annotations/runtimeAnnotationPreviewSide.d.ts

@@ -3,8 +3,4 @@ export declare function inferRuntimeAnnotationPreviewSide(auId: number, profile:
     auToMorphs?: unknown;
     auToBones?: unknown;
 } | null | undefined): RuntimeAnnotationSide | undefined;
-/**
- * Pick which continuum AU to annotate. While a drag gesture is sticky, keep
- * the original side so crossing 0 does not rebuild runtime markers mid-drag.
- */
 export declare function pickContinuumAnnotationAuId(value: number, negId: number, posId: number, stickyId: number | null): number;

package/dist/three/annotations/runtimeAnnotationSidePreview.d.ts

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import type { AnnotationAnchoredRegion, RuntimeAnnotationSide } from './types';
 export declare function getRuntimeAnnotationSide(region: AnnotationAnchoredRegion): RuntimeAnnotationSide | null;
-export declare function getRuntimeAUMorphAnchorPoint(region: AnnotationAnchoredRegion, mesh: THREE.Mesh): THREE.Vector3 | null;
 export declare function getRuntimeAUMeshSideOffset(region: AnnotationAnchoredRegion, sideSign: number, modelSize: THREE.Vector3): THREE.Vector3 | null;
+/** Reads native attributes; both candidate selection and anchor reduction run in Rust. */
+export declare function getRuntimeAUMorphAnchorPoint(region: AnnotationAnchoredRegion, mesh: THREE.Mesh): THREE.Vector3 | null;