@lovelace_lol/embody 0.0.7 → 0.0.9

package/dist/engines/three/Embody.d.ts

@@ -1,372 +0,0 @@
-/**
- * Embody - Three.js Implementation
- *
- * Default implementation of the Embody runtime interface for Three.js.
- * Controls 3D character facial animation using Action Units (AUs),
- * morph targets, visemes, and bone transformations.
- */
-import type { Mesh, Object3D, AnimationClip } from 'three';
-import type { EmbodyRuntime, ReadyPayload, EmbodyConfig } from '../../interfaces/EmbodyRuntime';
-import type { MeshInfo, Profile } from '../../mappings/types';
-import type { TransitionHandle, AnimationPlayOptions, AnimationClipInfo, AnimationState, AnimationActionHandle, CurvesMap, ClipOptions, ClipHandle, Snippet, SnippetChannel, TypedSnippet, CompositeRotation, AnimationBlendMode, MorphTargetDelta, AddMorphTargetOptions } from '../../core/types';
-import { ThreeModelInspector } from './ThreeModelInspector';
-import { type ThreeFrameApplierBindings, type ThreeMaterialConfig, type ThreeResolvedMaterialConfig } from './ThreeFrameApplier';
-import { HairPhysicsController, type HairPhysicsConfig, type HairPhysicsConfigUpdate } from './hair/HairPhysicsController';
-export declare class Embody implements EmbodyRuntime {
-    onSnippetEnd?: (name: string) => void;
-    /**
-     * Create an engine with Rust-owned preset/profile resolution.
-     *
-     * Prefer this factory whenever a profile patch must be merged onto a preset.
-     * The sync constructor accepts either a presetType with no patch, or an
-     * already-resolved profile.
-     */
-    static create(config?: EmbodyConfig, animation?: {
-        tick(dtSeconds: number): void;
-        addTransition(key: string, from: number, to: number, durationMs: number, apply: (value: number) => void, easing?: (t: number) => number): TransitionHandle;
-        clearTransitions(): void;
-        getActiveTransitionCount(): number;
-    }): Promise<Embody>;
-    private config;
-    private animation;
-    private compositeRotations;
-    private auToCompositeMap;
-    private auValues;
-    private auBalances;
-    private rigReady;
-    private missingBoneWarnings;
-    private rotations;
-    private pendingCompositeNodes;
-    private isPaused;
-    private translations;
-    private faceMesh;
-    private resolvedFaceMeshes;
-    private meshes;
-    private model;
-    private meshByName;
-    private morphKeyCache;
-    private morphIndexCache;
-    private resolvedAUMorphTargets;
-    private resolvedVisemeTargets;
-    private bones;
-    private mixWeights;
-    private visemeValues;
-    private visemeJawScales;
-    private static readonly VISEME_JAW_AMOUNTS;
-    private animationController;
-    private hairPhysics;
-    private modelInspector;
-    private frameApplier;
-    private modelDescriptor;
-    private wasmRuntimeCore;
-    private framePathReady;
-    private clock;
-    private animationFrameId;
-    private isRunning;
-    constructor(config?: EmbodyConfig, animation?: {
-        tick(dtSeconds: number): void;
-        addTransition(key: string, from: number, to: number, durationMs: number, apply: (value: number) => void, easing?: (t: number) => number): TransitionHandle;
-        clearTransitions(): void;
-        getActiveTransitionCount(): number;
-    });
-    onReady(payload: ReadyPayload): void;
-    private bindHostNeutralRuntime;
-    private attachWasmCore;
-    private syncRuntimeCoreState;
-    /**
-     * Re-inspect the current model and push a fresh ModelDescriptor into the
-     * runtime cores and frame applier. Needed whenever host-side morph targets
-     * or meshes change after onReady (e.g. addMorphTarget).
-     */
-    private refreshHostNeutralModelDescriptor;
-    private applyLiveFrameDelta;
-    private rebuildMorphTargetsCache;
-    private resolveFaceMeshes;
-    update(deltaSeconds: number): void;
-    /** Start the internal animation loop using Three.js Clock */
-    start(): void;
-    /** Stop the internal animation loop */
-    stop(): void;
-    dispose(): void;
-    setAU(id: number | string, v: number, balance?: number): void;
-    transitionAU(id: number | string, to: number, durationMs?: number, balance?: number): TransitionHandle;
-    getAU(id: number): number;
-    getCompositeRotations(): CompositeRotation[];
-    /**
-     * Set a continuum AU pair immediately (no animation).
-     *
-     * Sign convention:
-     * - Negative value (-1 to 0): activates negAU (e.g., head left, eyes left)
-     * - Positive value (0 to +1): activates posAU (e.g., head right, eyes right)
-     *
-     * @param negAU - AU ID for negative direction (e.g., 61 for eyes left)
-     * @param posAU - AU ID for positive direction (e.g., 62 for eyes right)
-     * @param continuumValue - Value from -1 (full negative) to +1 (full positive)
-     * @param balance - Optional L/R balance for bilateral morphs
-     */
-    setContinuum(negAU: number, posAU: number, continuumValue: number, balance?: number): void;
-    /**
-     * Smoothly transition a continuum AU pair (e.g., eyes left/right, head up/down).
-     * Takes a continuum value from -1 to +1 and internally manages both AU values.
-     *
-     * @param negAU - AU ID for negative direction (e.g., 61 for eyes left)
-     * @param posAU - AU ID for positive direction (e.g., 62 for eyes right)
-     * @param continuumValue - Target value from -1 (full negative) to +1 (full positive)
-     * @param durationMs - Transition duration in milliseconds
-     * @param balance - Optional L/R balance for bilateral morphs
-     */
-    transitionContinuum(negAU: number, posAU: number, continuumValue: number, durationMs?: number, balance?: number): TransitionHandle;
-    addMorphTarget(target: MorphTargetDelta, options?: AddMorphTargetOptions): number;
-    addMorphTargets(targets: MorphTargetDelta[], options?: AddMorphTargetOptions): Record<string, number>;
-    ensureMorphInfluence(meshName: string, morphName: string): number;
-    refreshMorphTargets(_meshNames?: string[]): void;
-    /**
-     * Set a morph target value.
-     *
-     * Fast paths (in order of speed):
-     * 1. Pass pre-resolved { infl, idx } array directly - zero lookups
-     * 2. String key with cache hit - one Map lookup
-     * 3. String key cache miss - dictionary lookup, then cached for next time
-     */
-    setMorph(key: string, v: number, meshNames?: string[]): void;
-    setMorph(key: string, v: number, targets: {
-        infl: number[];
-        idx: number;
-    }[]): void;
-    setMorphInfluence(index: number, v: number, meshNames?: string[]): void;
-    /**
-     * Resolve morph key to direct targets for ultra-fast repeated access.
-     * Use this when you need to set the same morph many times (e.g., in animation loops).
-     */
-    private resolveMorphTargetIndex;
-    resolveMorphTargets(key: string, meshNames?: string[]): {
-        infl: number[];
-        idx: number;
-    }[];
-    resolveMorphTargetsByIndex(index: number, meshNames?: string[]): {
-        infl: number[];
-        idx: number;
-    }[];
-    transitionMorph(key: string, to: number, durationMs?: number, meshNames?: string[]): TransitionHandle;
-    transitionMorphInfluence(index: number, to: number, durationMs?: number, meshNames?: string[]): TransitionHandle;
-    setViseme(visemeIndex: number, value: number, jawScale?: number): void;
-    transitionViseme(visemeIndex: number, to: number, durationMs?: number, jawScale?: number): TransitionHandle;
-    setVisemeById(slotId: string, value: number, jawScale?: number): void;
-    transitionVisemeById(slotId: string, to: number, durationMs?: number, jawScale?: number): TransitionHandle;
-    setAUMixWeight(id: number, weight: number): void;
-    getAUMixWeight(id: number): number;
-    /**
-     * Check if an AU has bilateral bone bindings (left + right side hints).
-     * Used to determine if a balance slider should be shown for bone-only bilateral AUs.
-     */
-    hasLeftRightBones(auId: number): boolean;
-    pause(): void;
-    resume(): void;
-    getPaused(): boolean;
-    clearTransitions(): void;
-    getActiveTransitionCount(): number;
-    resetToNeutral(): void;
-    private reinitializeRuntimeStateFromCurrentControls;
-    private reapplyProceduralStateAfterBakedUpdate;
-    getMeshList(): MeshInfo[];
-    /** Get all morph targets grouped by mesh name */
-    getMorphTargets(): Record<string, string[]>;
-    /** Get morph target indices mapped to labels for each mesh */
-    getMorphTargetIndices(): Record<string, {
-        index: number;
-        name: string;
-    }[]>;
-    /** Get all resolved bone names and their current transforms */
-    getBones(): Record<string, {
-        position: [number, number, number];
-        rotation: [number, number, number];
-    }>;
-    setMeshVisible(meshName: string, visible: boolean): void;
-    /**
-     * Highlight a mesh with an emissive glow effect
-     * @param meshName - Name of the mesh to highlight (null to clear all highlights)
-     * @param color - Highlight color (default: cyan 0x00ffff)
-     * @param intensity - Emissive intensity (default: 0.5)
-     */
-    highlightMesh(meshName: string | null, color?: number, intensity?: number): void;
-    /** Get material config for a mesh */
-    getMeshMaterialConfig(meshName: string): ThreeResolvedMaterialConfig | null;
-    /** Set material config for a mesh */
-    setMeshMaterialConfig(meshName: string, config: ThreeMaterialConfig): void;
-    private applyHairPhysicsProfileConfig;
-    setProfile(profile: Profile): void;
-    getProfile(): Profile;
-    /**
-     * Get the mesh names that should receive morph influences for a given AU.
-     * Routing is driven by `auFacePartToMeshCategory` in profile config.
-     */
-    getMeshNamesForAU(auId: number): string[];
-    getMeshNamesForViseme(): string[];
-    registerHairObjects(objects: Object3D[]): Array<{
-        name: string;
-        isMesh: boolean;
-        isEyebrow: boolean;
-    }>;
-    getRegisteredHairObjects(): Mesh[];
-    setHairPhysicsEnabled(enabled: boolean): void;
-    isHairPhysicsEnabled(): boolean;
-    setHairPhysicsConfig(config: HairPhysicsConfigUpdate): void;
-    getHairPhysicsConfig(): HairPhysicsConfig;
-    validateHairMorphTargets(): string[];
-    /** Get head rotation values for hair physics (range -1 to 1) */
-    getHeadRotation(): {
-        yaw: number;
-        pitch: number;
-        roll: number;
-    };
-    updateHairPhysics(dt: number): void;
-    getHairMorphTargets(meshName?: string): string[];
-    setMorphOnMeshes(meshNames: string[], morphKey: string, value: number): void;
-    applyHairStateToObject(objectName: string, state: {
-        color?: {
-            baseColor: string;
-            emissive: string;
-            emissiveIntensity: number;
-        };
-        outline?: {
-            show: boolean;
-            color: string;
-            opacity: number;
-        };
-        visible?: boolean;
-        scale?: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        position?: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        isEyebrow?: boolean;
-    }): void;
-    getHairAppearance(): import("../..").HairAppearanceState;
-    setHairColor(color: Parameters<HairPhysicsController['setHairColor']>[0]): void;
-    setEyebrowColor(color: Parameters<HairPhysicsController['setEyebrowColor']>[0]): void;
-    setHairBaseColor(baseColor: string): void;
-    setEyebrowBaseColor(baseColor: string): void;
-    setHairGlow(emissive: string, intensity: number): void;
-    setEyebrowGlow(emissive: string, intensity: number): void;
-    setHairOutline(outline: {
-        show: boolean;
-        color?: string;
-        opacity?: number;
-    }): void;
-    private computeSideValues;
-    private getAUMorphsBySide;
-    private applyMorphTargets;
-    private applyVisemeRuntimeState;
-    private getJawBoneNodeKey;
-    private getHeadBoneNodeKey;
-    private getActiveVisemeJawAmount;
-    private getMorphValue;
-    private getMorphValueForMeshes;
-    private getMorphValueByIndex;
-    private getMorphValueByIndexForMeshes;
-    private validateMorphTargetDelta;
-    private applyMorphTargetDelta;
-    private requireNamedMesh;
-    private getMeshMorphDictionary;
-    private assertMorphAttributeDataLength;
-    private assertCompatibleMorphTargetMode;
-    private setMorphAttributeAtIndex;
-    private setZeroMorphAttributeAtIndex;
-    private addRuntimeMorphMesh;
-    private getMorphKeyCacheKey;
-    private getMorphIndexCacheKey;
-    private syncVisemeRuntimeState;
-    private getVisemeJawAmount;
-    private collectResolvedExpressionMorphTargets;
-    private resetMorphTargetHandles;
-    private isMixedAU;
-    private getEffectiveBoneAUValue;
-    private getCompositeAxisValueForNode;
-    private getCompositeAxisBindingForNode;
-    private initBoneRotations;
-    /** Update rotation state - just stores -1 to 1 value like stable version */
-    private updateBoneRotation;
-    private updateBoneTranslation;
-    private transitionBoneRotation;
-    private transitionBoneTranslation;
-    private flushPendingComposites;
-    /**
-     * Apply composite rotation using quaternion composition like stable version.
-     * Looks up maxDegrees and channel from BONE_AU_TO_BINDINGS.
-     */
-    private applyCompositeRotation;
-    private resolveBones;
-    private combineHandles;
-    /**
-     * Apply render order and material settings from CC4_MESHES to all meshes.
-     * This ensures proper layering (e.g., hair renders on top of eyebrows).
-     * Also auto-registers hair and eyebrow meshes for hair physics.
-     */
-    private applyMeshMaterialSettings;
-    loadAnimationClips(clips: unknown[]): void;
-    getAnimationClips(): AnimationClipInfo[];
-    removeAnimationClip(clipName: string): boolean;
-    playAnimation(clipName: string, options?: AnimationPlayOptions): AnimationActionHandle | null;
-    stopAnimation(clipName: string): void;
-    stopAllAnimations(): void;
-    pauseAnimation(clipName: string): void;
-    resumeAnimation(clipName: string): void;
-    pauseAllAnimations(): void;
-    resumeAllAnimations(): void;
-    setAnimationSpeed(clipName: string, speed: number): void;
-    setAnimationIntensity(clipName: string, intensity: number): void;
-    setAnimationLoopMode(clipName: string, loopMode: 'repeat' | 'once' | 'pingpong'): void;
-    setAnimationRepeatCount(clipName: string, repeatCount?: number): void;
-    setAnimationReverse(clipName: string, reverse: boolean): void;
-    setAnimationBlendMode(clipName: string, blendMode: AnimationBlendMode): void;
-    seekAnimation(clipName: string, time: number): void;
-    setAnimationTimeScale(timeScale: number): void;
-    getAnimationState(clipName: string): AnimationState | null;
-    getPlayingAnimations(): AnimationState[];
-    crossfadeTo(clipName: string, duration?: number, options?: AnimationPlayOptions): AnimationActionHandle | null;
-    snippetToClip(clipName: string, curves: CurvesMap, options?: ClipOptions): AnimationClip | null;
-    playClip(clip: AnimationClip, options?: ClipOptions): ClipHandle | null;
-    playSnippet(snippet: Snippet | {
-        name: string;
-        curves: CurvesMap;
-    } | TypedSnippet | {
-        name: string;
-        channels: SnippetChannel[];
-    }, options?: ClipOptions): ClipHandle | null;
-    playTypedSnippet(snippet: TypedSnippet | {
-        name: string;
-        channels: SnippetChannel[];
-    }, options?: ClipOptions): ClipHandle | null;
-    buildClip(clipName: string, curves: CurvesMap, options?: ClipOptions): ClipHandle | null;
-    buildTypedClip(clipName: string, channels: SnippetChannel[], options?: ClipOptions): ClipHandle | null;
-    typedSnippetToClip(clipName: string, channels: SnippetChannel[], options?: ClipOptions): AnimationClip | null;
-    cleanupSnippet(name: string): void;
-    updateClipParams(name: string, params: {
-        weight?: number;
-        rate?: number;
-        loop?: boolean;
-        loopMode?: 'once' | 'repeat' | 'pingpong';
-        repeatCount?: number;
-        reverse?: boolean;
-        actionId?: string;
-    }): boolean;
-    /**
-     * Check if curves can be played through buildClip.
-     * Returns false if curves contain data that cannot be converted to mixer tracks.
-     */
-    supportsClipCurves(curves: Record<string, Array<{
-        time: number;
-        intensity: number;
-        inherit?: boolean;
-    }>>): boolean;
-}
-/**
- * Helper function to collect meshes with morph targets from a scene.
- */
-export declare function collectMorphMeshes(root: Object3D): Mesh[];
-export declare function buildFrameApplierBindings(inspection: ReturnType<ThreeModelInspector['inspectModel']>): ThreeFrameApplierBindings;

package/dist/engines/three/ThreeAnimationRuntime.d.ts

@@ -1,203 +0,0 @@
-/**
- * ThreeAnimationRuntime - Lerp-based animation driver
- *
- * Internal driver for time-based interpolation with easing functions.
- */
-import { AnimationClip, Quaternion } from 'three';
-import type { Mesh, Object3D } from 'three';
-import type { TransitionHandle, AnimationPlayOptions, AnimationClipInfo, AnimationState, AnimationActionHandle, CurvesMap, ClipOptions, ClipHandle, Snippet, CompositeRotation, AnimationBlendMode, SnippetChannel, TypedSnippet, EmbodyAnimationRuntimeFactory } from '../../core/types';
-import type { Profile } from '../../mappings/types';
-import type { ResolvedBones } from './types';
-declare const easeInOutQuad: (t: number) => number;
-declare const easeInOutCubic: (t: number) => number;
-export { easeInOutQuad, easeInOutCubic };
-export declare class ThreeAnimationRuntime {
-    private transitions;
-    /**
-     * Tick all active transitions by dt seconds.
-     * Applies eased interpolation and removes completed transitions.
-     * Respects individual transition pause state.
-     */
-    tick(dtSeconds: number): void;
-    /**
-     * Add or replace a transition for the given key.
-     * If a transition with the same key exists, it is cancelled and replaced.
-     * @returns TransitionHandle with { promise, pause, resume, cancel }
-     */
-    addTransition(key: string, from: number, to: number, durationMs: number, apply: (value: number) => void, easing?: (t: number) => number): TransitionHandle;
-    /** Clear all running transitions. */
-    clearTransitions(): void;
-    /** Get count of active transitions. */
-    getActiveTransitionCount(): number;
-}
-export interface ThreeAnimationSystemHost {
-    getModel: () => Object3D | null;
-    getMeshes: () => Mesh[];
-    getMeshByName: (name: string) => Mesh | undefined;
-    getMeshNamesForAU?: (auId: number) => string[];
-    getMeshNamesForViseme?: () => string[];
-    getCurrentAUValue?: (auId: number) => number;
-    getCurrentVisemeValue?: (visemeIndex: number) => number;
-    getCurrentMorphValue?: (morphKey: string, meshNames?: string[]) => number;
-    getCurrentMorphIndexValue?: (morphIndex: number, meshNames?: string[]) => number;
-    getCurrentBoneQuaternion?: (nodeKey: string) => Quaternion | null;
-    getCurrentBonePositionValue?: (nodeKey: string, axis: 'x' | 'y' | 'z') => number | null;
-    getBones: () => ResolvedBones;
-    getConfig: () => Profile;
-    getCompositeRotations: () => CompositeRotation[];
-    computeSideValues: (base: number, balance?: number) => {
-        left: number;
-        right: number;
-    };
-    getAUMixWeight: (auId: number) => number;
-    isMixedAU: (auId: number) => boolean;
-    reapplyProceduralState?: () => void;
-}
-/** @deprecated Use ThreeAnimationSystemHost. */
-export type AnimationControllerHost = ThreeAnimationSystemHost;
-/** @deprecated Use ThreeAnimationSystemHost. */
-export type BakedAnimationHost = ThreeAnimationSystemHost;
-export type ThreeAnimationSystemOptions = {
-    animationRuntimeFactory?: EmbodyAnimationRuntimeFactory;
-};
-type ClipParamsUpdate = {
-    weight?: number;
-    rate?: number;
-    loop?: boolean;
-    loopMode?: 'once' | 'repeat' | 'pingpong';
-    repeatCount?: number;
-    reverse?: boolean;
-    actionId?: string;
-};
-export declare class ThreeAnimationSystem {
-    private host;
-    private animationMixer;
-    private clipAnimationMixer;
-    private mixerFinishedListenerAttached;
-    private clipMixerFinishedListenerAttached;
-    private animationClips;
-    private bakedSourceClips;
-    private bakedMixerActions;
-    private bakedAdditiveMixerClips;
-    private bakedActionGroups;
-    private bakedMixerClipToSource;
-    private animationActions;
-    private animationFinishedCallbacks;
-    private clipActions;
-    private clipHandles;
-    private rendererClipHandles;
-    private clipSources;
-    private playbackState;
-    private actionIds;
-    private actionIdToClip;
-    private clipMonitors;
-    private dynamicClipSources;
-    private cljsAnimationRuntime;
-    constructor(host: ThreeAnimationSystemHost, options?: ThreeAnimationSystemOptions);
-    private shouldDebugClipLogs;
-    private debugClipLog;
-    private createRuntimeConnector;
-    getRuntimeSnapshot(): Record<string, unknown> | null;
-    private getActionId;
-    private setActionId;
-    private clearActionId;
-    private uncacheClip;
-    private uncacheAction;
-    private releaseBakedMixerAction;
-    private clearBakedAdditiveMixerClip;
-    private clearAllBakedAdditiveMixerClips;
-    private resolveTrackTarget;
-    private getMorphTrackBaseValue;
-    private canCreateFirstFrameReferenceTrack;
-    private createFirstFrameReferenceTrack;
-    private createAdditiveReferenceTrack;
-    private createAdditiveMixerClip;
-    private getOrCreateBakedAdditiveMixerClip;
-    private setClipEventMetadata;
-    private getClipEventMetadata;
-    private curvesHaveInheritedStart;
-    private channelsHaveInheritedStart;
-    private rebuildDynamicClip;
-    private resolveInheritedClipForPlayback;
-    private getKeyframeIndex;
-    private emitClipEvent;
-    private emitKeyframesForRange;
-    private resetClipMonitor;
-    private syncClipMonitorTime;
-    private cleanupClipMonitor;
-    private advanceClipMonitor;
-    private normalizePlaybackOptions;
-    private applyPlaybackState;
-    private setPlaybackState;
-    private getPlaybackStateSnapshot;
-    private mergePlaybackOptions;
-    private isBakedSourceClip;
-    private getBakedSourceClip;
-    private getBakedChannelInfo;
-    private getBakedAggregateBlendMode;
-    private applyPlaybackStateToBakedAction;
-    private resolveStartTime;
-    private getOrCreateBakedMixerAction;
-    private getRepresentativeBakedAction;
-    private createBakedActionGroup;
-    private getMeshNamesForAU;
-    private getMeshNamesForViseme;
-    private hasActiveAdditivePlayback;
-    update(dtSeconds: number): void;
-    dispose(): void;
-    loadAnimationClips(clips: unknown[]): void;
-    getAnimationClips(): AnimationClipInfo[];
-    removeAnimationClip(clipName: string): boolean;
-    playAnimation(clipName: string, options?: AnimationPlayOptions): AnimationActionHandle | null;
-    stopAnimation(clipName: string): void;
-    stopAllAnimations(): void;
-    pauseAnimation(clipName: string): void;
-    resumeAnimation(clipName: string): void;
-    pauseAllAnimations(): void;
-    resumeAllAnimations(): void;
-    setAnimationSpeed(clipName: string, speed: number): void;
-    setAnimationIntensity(clipName: string, intensity: number): void;
-    setAnimationLoopMode(clipName: string, loopMode: 'repeat' | 'once' | 'pingpong'): void;
-    setAnimationRepeatCount(clipName: string, repeatCount?: number): void;
-    setAnimationReverse(clipName: string, reverse: boolean): void;
-    setAnimationBlendMode(clipName: string, blendMode: AnimationBlendMode): void;
-    seekAnimation(clipName: string, time: number): void;
-    setAnimationTimeScale(timeScale: number): void;
-    getAnimationState(clipName: string): AnimationState | null;
-    getPlayingAnimations(): AnimationState[];
-    crossfadeTo(clipName: string, duration?: number, options?: AnimationPlayOptions): AnimationActionHandle | null;
-    snippetToClip(clipName: string, curves: CurvesMap, options?: ClipOptions): AnimationClip | null;
-    typedSnippetToClip(clipName: string, channels: SnippetChannel[], options?: ClipOptions): AnimationClip | null;
-    private playClipDirect;
-    playClip(clip: AnimationClip, options?: ClipOptions): ClipHandle | null;
-    playSnippet(snippet: Snippet | {
-        name: string;
-        curves: CurvesMap;
-    } | TypedSnippet | {
-        name: string;
-        channels: SnippetChannel[];
-    }, options?: ClipOptions): ClipHandle | null;
-    playTypedSnippet(snippet: TypedSnippet | {
-        name: string;
-        channels: SnippetChannel[];
-    }, options?: ClipOptions): ClipHandle | null;
-    buildClip(clipName: string, curves: CurvesMap, options?: ClipOptions): ClipHandle | null;
-    private buildClipDirect;
-    buildTypedClip(clipName: string, channels: SnippetChannel[], options?: ClipOptions): ClipHandle | null;
-    cleanupSnippet(name: string): void;
-    private cleanupSnippetDirect;
-    updateClipParams(name: string, params: ClipParamsUpdate): boolean;
-    private updateClipParamsDirect;
-    private addMorphTracks;
-    private addMorphIndexTracks;
-    private sampleFinalKeyframeValue;
-    private ensureMixer;
-    private ensureClipMixer;
-    private handleMixerFinished;
-    private createAnimationHandle;
-    private createBakedAnimationHandle;
-}
-/** @deprecated Use ThreeAnimationSystem. */
-export { ThreeAnimationSystem as AnimationController };
-/** @deprecated Use ThreeAnimationSystem. */
-export { ThreeAnimationSystem as BakedAnimationController };

package/dist/engines/three/ThreeClipAdapter.d.ts

@@ -1,24 +0,0 @@
-import { AnimationClip } from 'three';
-import type { Object3D } from 'three';
-import type { BoneId, ClipIR, MeshId, MorphTargetId } from '../../core/contracts';
-export interface ThreeClipMeshBinding {
-    readonly trackName: string;
-}
-export interface ThreeClipMorphTargetBinding {
-    readonly meshId: MeshId;
-    readonly index: number;
-}
-export interface ThreeClipAdapterBindings {
-    readonly meshes?: ReadonlyMap<MeshId, Object3D | ThreeClipMeshBinding>;
-    readonly morphTargets?: ReadonlyMap<MorphTargetId, ThreeClipMorphTargetBinding>;
-    readonly bones?: ReadonlyMap<BoneId, Object3D | string>;
-}
-export declare class ThreeClipAdapter {
-    private meshes;
-    private morphTargets;
-    private bones;
-    constructor(bindings?: ThreeClipAdapterBindings);
-    setBindings(bindings: ThreeClipAdapterBindings): void;
-    toAnimationClip(clip: ClipIR): AnimationClip;
-    private toKeyframeTrack;
-}

package/dist/engines/three/ThreeFrameApplier.d.ts

@@ -1,68 +0,0 @@
-import type { Mesh, Object3D } from 'three';
-import type { BoneId, FrameDelta, HostFrameApplier, MeshId, MorphTargetId, Transform } from '../../core/contracts';
-export interface ThreeMorphTargetBinding {
-    readonly meshId: MeshId;
-    readonly mesh: Mesh;
-    readonly index: number;
-}
-export interface ThreeFrameApplierBindings {
-    readonly meshes?: ReadonlyMap<MeshId, Mesh>;
-    readonly morphTargets?: ReadonlyMap<MorphTargetId, ThreeMorphTargetBinding>;
-    readonly bones?: ReadonlyMap<BoneId, Object3D>;
-}
-export interface ThreeMaterialConfig {
-    renderOrder?: number;
-    transparent?: boolean;
-    opacity?: number;
-    depthWrite?: boolean;
-    depthTest?: boolean;
-    blending?: keyof typeof THREE_BLENDING_MODES;
-}
-export interface ThreeResolvedMaterialConfig {
-    renderOrder: number;
-    transparent: boolean;
-    opacity: number;
-    depthWrite: boolean;
-    depthTest: boolean;
-    blending: keyof typeof THREE_BLENDING_MODES;
-}
-export interface ThreeMeshMaterialConfig {
-    readonly material?: ThreeMaterialConfig;
-}
-export declare const THREE_BLENDING_MODES: {
-    readonly Normal: 1;
-    readonly Additive: 2;
-    readonly Subtractive: 3;
-    readonly Multiply: 4;
-    readonly None: 0;
-};
-export declare class ThreeFrameApplier implements HostFrameApplier<Object3D> {
-    private meshes;
-    private morphTargets;
-    private bones;
-    private originalEmissive;
-    constructor(bindings?: ThreeFrameApplierBindings);
-    setBindings(bindings: ThreeFrameApplierBindings): void;
-    applyFrameDelta(model: Object3D, frame: FrameDelta): void;
-    applyPackedMorphFrameDelta(values: ArrayLike<number>, stride?: number): void;
-    /** Rows: `[boneId, px, py, pz, qx, qy, qz, qw, flags]`; flags bit0=position, bit1=rotation. */
-    applyPackedBoneFrameDelta(values: ArrayLike<number>, stride?: number): void;
-    applyObjectTransform(target: Object3D, transform: Transform, mode?: 'absolute' | 'additive'): void;
-    applyMorphTargets(targets: readonly {
-        infl: number[];
-        idx: number;
-    }[], value: number): void;
-    resetMorphTargets(targets: readonly {
-        infl: number[];
-        idx: number;
-    }[]): void;
-    setMeshVisible(root: Object3D, meshName: string, visible: boolean): void;
-    highlightMesh(root: Object3D, meshName: string | null, color?: number, intensity?: number): void;
-    getMeshMaterialConfig(root: Object3D, meshName: string): ThreeResolvedMaterialConfig | null;
-    setMeshMaterialConfig(root: Object3D, meshName: string, config: ThreeMaterialConfig): void;
-    applyMeshMaterialConfigs(root: Object3D, configs: Readonly<Record<string, ThreeMeshMaterialConfig>>): void;
-    private applyMeshMaterialConfig;
-    private setMorphTarget;
-    private applyTransform;
-    private visitNamedMesh;
-}