@lovelace_lol/embody 0.0.8 → 0.0.9

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

@@ -45,6 +45,7 @@ export declare class DPthreeCameraController {
     private markerStateListeners;
     private domElement;
     private renderer;
+    private readonly playbackTimer;
     private renderFrame;
     private resizeRenderer;
     private onRenderError;

package/dist/three/authoring.d.ts

@@ -0,0 +1,95 @@
+import type { AnimationClip, Mesh, Object3D } from 'three';
+import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import type { Region } from './annotations/types';
+import type * as Types from './authoringTypes';
+export * from './authoringTypes';
+export { resolveBoneNames, fuzzyNameMatch } from './annotations/adapter';
+export { DEFAULT_AXIS_TO_CHANNEL, DEFAULT_BONE_MAX_DEGREES, JOINT_CONTROL_SECTION, VISEME_KEYS, HAIR_COLOR_PRESETS, DEFAULT_HAIR_COLOR_APPEARANCE, HUMANOID_SKELETON_TEMPLATES, CC4_HUMANOID_SKELETON_TEMPLATE, } from '@lovelace_lol/embody/wasm';
+export declare const getPreset: (id: Types.PresetType) => Types.Profile;
+export declare const extendCharacterConfigWithPreset: <T extends Types.ProfileRuntimeConfig>(config: T) => T;
+export declare const extractProfileOverrides: (config: Types.ProfileRuntimeConfig) => Partial<Types.Profile>;
+export declare const mergeCharacterRegionsByName: (base?: Region[], override?: Region[]) => Region[];
+export declare const getMeshNamesForAUProfile: (profile: Types.Profile, auId: number) => string[];
+export declare const getHumanoidSpecification: () => Types.HumanoidSpecification;
+export declare const setAUMorphTargets: (profile: Types.Profile, auId: number, side: "left" | "right" | "center", targets: Types.MorphTargetRef[]) => Types.Profile;
+export declare const setHumanoidRoleBinding: (profile: Types.Profile, role: Types.VRMHumanoidRole, boneName: string | null) => Types.Profile;
+export declare const resolveHumanoidCharacterization: (profile: Types.Profile) => Types.HumanoidCharacterizationResolution;
+export declare const hasLeftRightMorphs: (profile: Types.Profile, auId: number) => boolean;
+export declare const isMixedAU: (profile: Types.Profile, auId: number) => boolean;
+export declare const resolveVisemeProfile: (profile: Partial<Types.Profile>) => Types.ResolvedVisemeProfile;
+export declare const isMaxDegreesOnlyAxisBindingUpdate: (update: Types.BoneAxisBindingUpdate) => boolean;
+export declare const findNodeKeyForBone: (boneName: string, profile: Types.Profile | null) => string | null;
+export declare const ensureBoneNodeKey: (profile: Types.Profile, boneName: string) => {
+    nodeKey: string;
+    boneNodes: Record<string, string>;
+};
+export declare const ensureBilateralBoneNodeKeys: (profile: Types.Profile, leftBoneName: string, rightBoneName: string) => Types.Profile;
+export declare const resolveBoneNameForNodeKey: (profile: Types.Profile, nodeKey: string) => string | null;
+export declare const stripConfiguredBoneAffixes: (profile: Pick<Types.Profile, "bonePrefix" | "boneSuffix"> | null | undefined, boneName: string) => string;
+export declare const inferChiralBoneNamePair: (boneNames: string[], selectedBoneName: string) => Types.ChiralBoneNamePair | null;
+export declare const formatAxisLabel: (axis: Types.BoneAxisKey) => string;
+export declare const formatAxisDirectionLabel: (axis: Types.BoneAxisKey, direction: Types.BoneAxisDirection) => string;
+export declare const getAxisFromChannel: (channel?: string) => Types.BoneAxisKey | null;
+export declare const getBoneAxisBindingState: (profile: Types.Profile, boneName: string, axis: Types.BoneAxisKey) => Types.BoneAxisBindingState | null;
+export declare const resolveBoneAxisChannel: (profile: Types.Profile, boneName: string, axis: Types.BoneAxisKey) => Types.RotationChannel;
+export declare const getBilateralAxisBindingState: (profile: Types.Profile, boneName: string, axis: Types.BoneAxisKey) => Types.BilateralAxisBindingState | null;
+export declare const getAUBoneBindingState: (profile: Types.Profile, auId: number) => Types.AUBoneBindingState;
+export declare const inferEyeControlScope: (profile: Pick<Types.Profile, "auToBones">, binding: Pick<Types.BoneAxisBindingState, "nodeKey" | "negativeAuId" | "positiveAuId">) => Types.BoneControlScope | null;
+export declare const inferEyeControlFamily: (binding: Pick<Types.BoneAxisBindingState, "nodeKey" | "axis">) => Types.BoneControlFamily | null;
+export declare const applyBoneAxisBindingUpdate: (profile: Types.Profile, boneName: string, axis: Types.BoneAxisKey, update: Types.BoneAxisBindingUpdate) => Types.Profile;
+export declare const applyBilateralAxisBindingUpdate: (profile: Types.Profile, boneName: string, axis: Types.BoneAxisKey, scope: Types.BilateralBoneAxisScope, update: Types.BoneAxisBindingUpdate) => Types.Profile;
+export declare const applyAUBoneBindingUpdate: (profile: Types.Profile, auId: number, update: {
+    boneName: string | null;
+    axis: Types.BoneAxisKey;
+    direction: Types.BoneAxisDirection;
+    maxDegrees: number | null;
+}) => Types.Profile;
+export declare const createBoneAxisAu: (profile: Types.Profile, boneName: string, axis: Types.BoneAxisKey, direction: Types.BoneAxisDirection, options?: {
+    name?: string;
+}) => Types.CreatedBoneAxisAu;
+export declare const createBilateralBoneAxisAu: (profile: Types.Profile, boneName: string, axis: Types.BoneAxisKey, scope: Types.BilateralBoneAxisScope, direction: Types.BoneAxisDirection, options?: {
+    name?: string;
+}) => Types.CreatedBoneAxisAu;
+export declare const buildBoneAuOptions: (profile: Types.Profile) => Array<{
+    value: string;
+    label: string;
+    detail?: string;
+}>;
+export declare const isJointControlAuInfo: (info?: Pick<Types.AUInfo, "facePart"> | null) => boolean;
+export declare const classifyAuAsJointControl: (profile: Types.Profile, auId: number, options?: {
+    boneName?: string | null;
+    nodeKey?: string | null;
+}) => Types.Profile;
+export declare const resolveContinuumDisplayLabel: (profile: Pick<Types.Profile, "continuumPairs" | "continuumLabels" | "auInfo" | "boneNodes" | "bonePrefix" | "boneSuffix">, negativeAuId: number, positiveAuId: number) => string;
+export declare function getBodyControls(profile: Types.Profile, model?: Object3D): Types.BodyControlDescriptor[];
+export declare function extractModelData(model: Object3D, meshes?: Mesh[], animations?: AnimationClip[]): Types.ModelData;
+export declare function analyzeModel(options: {
+    source: {
+        type: 'gltf';
+        gltf: GLTF;
+    } | {
+        type: 'runtime';
+        model: Object3D;
+        meshes?: Mesh[];
+        animations?: AnimationClip[];
+    };
+    preset?: Types.Profile;
+    suggestCorrections?: boolean;
+}): Promise<Types.ModelAnalysisReport>;
+export declare function validateMappings(meshes: unknown[], skeleton: unknown, profile: Types.Profile, options?: Record<string, unknown>): Types.ValidationResult;
+export declare function validateHumanoidCharacterization(model: Object3D, profile: Types.Profile): Types.HumanoidCharacterizationResolution;
+export declare function normalizeHairColorAppearance(value: Types.HairColorAppearance | string, fallback?: Types.HairColorAppearance): Types.HairColorAppearance;
+export declare const getHumanoidSkeletonTemplate: (id: string) => Types.HumanoidSkeletonTemplate | null;
+export declare function getHumanoidSkeletonTemplateBoneNames(template?: Types.HumanoidSkeletonTemplate): string[];
+export declare function createValidationSkeletonFromHumanoidTemplate(template?: Types.HumanoidSkeletonTemplate): {
+    bones: Array<{
+        name: string;
+    }>;
+};
+export declare function computeHumanoidSkeletonTemplateRestBounds(template: Types.HumanoidSkeletonTemplate): Types.HumanoidSkeletonTemplateBounds;
+export declare function extractHumanoidSkeletonTemplateFromModel(model: Object3D, options: {
+    id: string;
+    sourceCharacterId: string;
+    sourceAsset?: string;
+    sourceSkinName?: string;
+}): Types.HumanoidSkeletonTemplate;

package/dist/three/authoringTypes.d.ts

@@ -0,0 +1,576 @@
+import type { Region, MarkerStyle, MarkerGroup, LineConfig, MarkerStyleOverrides } from './annotations/types';
+export interface AuthoringVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface AuthoringQuaternion extends AuthoringVector3 {
+    w: number;
+}
+export type PresetType = 'cc4' | 'fish' | string;
+export type BoneAxisKey = 'pitch' | 'yaw' | 'roll';
+export type BoneAxisDirection = 'negative' | 'positive';
+export type BoneAxisDirectionScale = -1 | 1;
+export type RotationChannel = 'rx' | 'ry' | 'rz';
+export type BilateralBoneAxisScope = 'shared' | 'left' | 'right';
+export type BoneControlFamily = 'Horizontal Gaze' | 'Vertical Gaze';
+export type BoneControlScope = 'Both Eyes' | 'Left Eye Only' | 'Right Eye Only';
+export type HumanoidSkeletonTemplateVec3 = readonly [number, number, number];
+export type HumanoidSkeletonTemplateBounds = readonly [number, number, number, number, number, number];
+export type MorphTargetRef = string | number;
+export type MeshCategory = 'body' | 'eye' | 'eyeOcclusion' | 'tearLine' | 'teeth' | 'tongue' | 'hair' | 'eyebrow' | 'cornea' | 'eyelash';
+export type BlendingMode = 'Normal' | 'Additive' | 'Subtractive' | 'Multiply' | 'None';
+export interface MorphTargetsBySide {
+    left: MorphTargetRef[];
+    right: MorphTargetRef[];
+    center: MorphTargetRef[];
+}
+export interface BoneBinding {
+    node: string;
+    channel: 'rx' | 'ry' | 'rz' | 'tx' | 'ty' | 'tz';
+    scale: BoneAxisDirectionScale;
+    maxDegrees?: number;
+    maxUnits?: number;
+    side?: 'left' | 'right';
+}
+export interface AUInfo {
+    id: string;
+    name: string;
+    muscularBasis?: string;
+    links?: string[];
+    faceArea?: 'Upper' | 'Lower' | 'Body';
+    facePart?: string;
+}
+export interface RotationAxis {
+    aus: number[];
+    axis: RotationChannel;
+    negative?: number | number[];
+    positive?: number | number[];
+}
+export interface CompositeRotation {
+    node: string;
+    pitch: RotationAxis | null;
+    yaw: RotationAxis | null;
+    roll: RotationAxis | null;
+}
+export interface VisemeSlotFeatures {
+    jawOpen?: number;
+    lipClosed?: number;
+    lipRound?: number;
+    lipSpread?: number;
+    tongueTip?: number;
+    fricative?: number;
+    nasal?: number;
+}
+export interface VisemeSlot {
+    id: string;
+    label: string;
+    order?: number;
+    providerIds?: Record<string, Array<string | number>>;
+    phonemes?: string[];
+    matchers?: string[];
+    features?: VisemeSlotFeatures;
+    defaultJawAmount?: number;
+}
+export type VisemeTongueTarget = Record<string, number>;
+export interface VisemeBindingTarget {
+    morph: MorphTargetRef;
+    weight?: number;
+}
+export interface VisemeBinding {
+    targets?: VisemeBindingTarget[];
+    morph?: MorphTargetRef;
+    jawAmount?: number;
+    note?: string;
+    sharedWith?: string[];
+}
+export interface ResolvedVisemeSlot extends Omit<VisemeSlot, 'label'> {
+    label?: string;
+    [extension: string]: unknown;
+}
+/** Model-independent authored resolution. Array indices equal Embody runtime slot indices. */
+export interface ResolvedVisemeProfile {
+    routingMode: 'explicit' | 'legacy';
+    /** Stock canonical sound index to runtime slot index, including reordered stock profiles. */
+    canonicalSlotIndices?: number[];
+    visemeSlots: ResolvedVisemeSlot[];
+    visemeBindingTargets: Array<Array<Required<VisemeBindingTarget>>>;
+    visemeJawAmounts: number[];
+    visemeTongueTargets: VisemeTongueTarget[];
+    visemeMeshNames: string[];
+    visemeMeshCategory: string;
+}
+export interface MappingEditorSection {
+    id: string;
+    label: string;
+    kind: 'au' | 'viseme' | 'lipSync' | 'hair' | 'unmapped' | 'custom';
+    order: number;
+    meshCategory?: string;
+    facePart?: string;
+}
+export interface MeshMaterialSettings {
+    renderOrder?: number;
+    transparent?: boolean;
+    opacity?: number;
+    depthWrite?: boolean;
+    depthTest?: boolean;
+    blending?: BlendingMode;
+}
+export interface MeshInfo {
+    name?: string;
+    visible?: boolean;
+    category: MeshCategory;
+    morphCount: number;
+    material?: MeshMaterialSettings;
+}
+export type HairMorphAxis = 'yaw' | 'pitch' | 'roll';
+export interface HairMorphTargetMapping {
+    key: string;
+    axis: HairMorphAxis;
+}
+export interface HairMorphTargetValueMapping {
+    value: number;
+    axis: HairMorphAxis;
+}
+export interface HairPhysicsProfileConfig {
+    enabled?: boolean;
+    stiffness?: number;
+    damping?: number;
+    inertia?: number;
+    gravity?: number;
+    responseScale?: number;
+    idleSwayAmount?: number;
+    idleSwaySpeed?: number;
+    windStrength?: number;
+    windDirectionX?: number;
+    windDirectionZ?: number;
+    windTurbulence?: number;
+    windFrequency?: number;
+    idleClipDuration?: number;
+    impulseClipDuration?: number;
+    direction?: {
+        yawSign?: 1 | -1;
+        pitchSign?: 1 | -1;
+    };
+    morphTargets?: {
+        swayLeft?: HairMorphTargetMapping | null;
+        swayRight?: HairMorphTargetMapping | null;
+        swayFront?: HairMorphTargetMapping | null;
+        fluffRight?: HairMorphTargetMapping | null;
+        fluffBottom?: HairMorphTargetMapping | null;
+        headUp?: Record<string, HairMorphTargetValueMapping | null> | null;
+        headDown?: Record<string, HairMorphTargetValueMapping | null> | null;
+    } | null;
+}
+export type VRMHumanoidRole = 'hips' | 'spine' | 'chest' | 'upperChest' | 'neck' | 'head' | 'leftEye' | 'rightEye' | 'jaw' | 'leftShoulder' | 'leftUpperArm' | 'leftLowerArm' | 'leftHand' | 'rightShoulder' | 'rightUpperArm' | 'rightLowerArm' | 'rightHand' | 'leftUpperLeg' | 'leftLowerLeg' | 'leftFoot' | 'leftToes' | 'rightUpperLeg' | 'rightLowerLeg' | 'rightFoot' | 'rightToes' | 'leftThumbMetacarpal' | 'leftThumbProximal' | 'leftThumbDistal' | 'rightThumbMetacarpal' | 'rightThumbProximal' | 'rightThumbDistal' | 'leftIndexProximal' | 'leftIndexIntermediate' | 'leftIndexDistal' | 'rightIndexProximal' | 'rightIndexIntermediate' | 'rightIndexDistal' | 'leftMiddleProximal' | 'leftMiddleIntermediate' | 'leftMiddleDistal' | 'rightMiddleProximal' | 'rightMiddleIntermediate' | 'rightMiddleDistal' | 'leftRingProximal' | 'leftRingIntermediate' | 'leftRingDistal' | 'rightRingProximal' | 'rightRingIntermediate' | 'rightRingDistal' | 'leftLittleProximal' | 'leftLittleIntermediate' | 'leftLittleDistal' | 'rightLittleProximal' | 'rightLittleIntermediate' | 'rightLittleDistal';
+/** A standard bone role; motion axes/ranges belong to the authored rig profile. */
+export interface HumanoidBoneDefinition {
+    role: VRMHumanoidRole;
+    label: string;
+    section: 'Torso' | 'Head' | 'Arms' | 'Hands' | 'Legs' | 'Feet';
+    parent: VRMHumanoidRole | null;
+    required: boolean;
+    /** This optional parent must be mapped when the child is mapped. */
+    requiresParent: boolean;
+}
+export interface HumanoidSpecification {
+    standard: 'VRMC_vrm-1.0';
+    bones: HumanoidBoneDefinition[];
+}
+export interface HumanoidRoleBinding {
+    nodeKey: string;
+    /** Literal model bone selected by the role editor, before preset prefix lookup. */
+    exactBoneName?: string;
+    source?: string;
+    confidence?: number;
+}
+export interface HumanoidCharacterization {
+    schemaVersion: 1;
+    standard: 'VRMC_vrm-1.0';
+    status: 'verified-vrm' | 'characterized' | 'incomplete';
+    /** Explicitly edited role catalogs are authoritative across preset upgrades. */
+    authored?: boolean;
+    roles: Partial<Record<VRMHumanoidRole, HumanoidRoleBinding>>;
+}
+export interface HumanoidCharacterizationResolution {
+    schemaVersion: number | null;
+    standard: string | null;
+    status: string | null;
+    roles: Record<string, {
+        nodeKey: string;
+        boneName: string;
+        source: string | null;
+        confidence: number | null;
+    }>;
+    missingRequiredRoles: string[];
+    errors: string[];
+    warnings: string[];
+    valid: boolean;
+}
+/** Semantic body actions reuse the AU bone/morph evaluator. VRM names identify targets. */
+export interface BodyControlDefinition {
+    label: string;
+    section: string;
+    auId: number;
+    negativeAuId?: number | null;
+    bilateral: boolean;
+    roles: VRMHumanoidRole[];
+    order?: number;
+}
+export interface BodyControlDescriptor {
+    id: string;
+    label: string;
+    section: string;
+    auId: number;
+    negativeAuId: number | null;
+    auIds: number[];
+    bilateral: boolean;
+    roles: VRMHumanoidRole[];
+    order: number;
+    boneBindings: Array<BoneBinding & {
+        auId: number;
+        boneName: string;
+    }>;
+    morphBindings: MorphTargetsBySide;
+    meshNames: string[];
+    hasBones: boolean;
+    hasMorphs: boolean;
+    isMixed: boolean;
+    available: boolean;
+    diagnostics: string[];
+}
+/** Pose values are normalized authored action amounts, never world Euler angles. */
+export interface SemanticPoseChannel {
+    intensity: number;
+    /** -1 = character's left, 0 = both, +1 = character's right. */
+    balance?: number;
+    /** Morph contribution only; bone activation remains intensity. Defaults to profile. */
+    morphStrength?: number;
+}
+export interface SemanticPose {
+    version: 1;
+    controls: Array<{
+        controlId: string;
+        positive?: SemanticPoseChannel;
+        negative?: SemanticPoseChannel;
+    }>;
+}
+export interface SemanticPoseDirection {
+    auId: number;
+    label: string;
+    available: boolean;
+    availableSides?: Array<'left' | 'right' | 'center'>;
+    hasBones: boolean;
+    hasMorphs: boolean;
+    morphStrength: number;
+}
+export interface SemanticPoseControl {
+    id: string;
+    label: string;
+    section: string;
+    roles: string[];
+    bilateral: boolean;
+    boneNames: string[];
+    morphNames: string[];
+    positive: SemanticPoseDirection;
+    negative?: SemanticPoseDirection;
+}
+export interface SemanticAnimation {
+    version: 1;
+    durationSeconds: number;
+    tracks: Array<{
+        controlId: string;
+        direction: 'positive' | 'negative';
+        balance?: number;
+        morphStrength?: number;
+        keyframes: Array<{
+            time: number;
+            intensity: number;
+        }>;
+    }>;
+}
+export interface SemanticAnimationOptions extends Record<string, unknown> {
+    faceCurves?: Record<string, Array<{
+        time: number;
+        intensity: number;
+        inherit?: boolean;
+    }>>;
+}
+export interface Profile {
+    name?: string;
+    animalType?: string;
+    emoji?: string;
+    auToMorphs: Record<number, MorphTargetsBySide>;
+    auToBones: Record<number, BoneBinding[]>;
+    boneNodes: Record<string, string>;
+    bonePrefix?: string;
+    boneSuffix?: string;
+    morphPrefix?: string;
+    morphSuffix?: string;
+    suffixPattern?: string;
+    leftMorphSuffixes?: string[];
+    rightMorphSuffixes?: string[];
+    morphToMesh: Record<string, string[]>;
+    auFacePartToMeshCategory?: Record<string, string>;
+    mappingSections?: MappingEditorSection[];
+    visemeKeys: MorphTargetRef[];
+    visemeSystemId?: string;
+    visemeSlots?: VisemeSlot[];
+    visemeBindings?: Record<string, VisemeBinding>;
+    visemeMeshCategory?: string;
+    visemeJawAmounts?: number[];
+    /** Per-viseme tongue AU targets in canonical slot order. */
+    visemeTongueTargets?: VisemeTongueTarget[];
+    auMixDefaults?: Record<number, number>;
+    auInfo?: Record<string, AUInfo>;
+    eyeMeshNodes?: {
+        LEFT: string;
+        RIGHT: string;
+    };
+    compositeRotations?: CompositeRotation[];
+    meshes?: Record<string, MeshInfo>;
+    continuumPairs?: Record<number, {
+        pairId: number;
+        isNegative: boolean;
+        axis: BoneAxisKey;
+        node: string;
+    }>;
+    continuumLabels?: Record<string, string>;
+    annotationRegions?: Region[];
+    disabledRegions?: string[];
+    hairPhysics?: HairPhysicsProfileConfig;
+    humanoidCharacterization?: HumanoidCharacterization;
+    /** Authored overrides may patch individual fields; null removes a preset control. */
+    bodyControls?: Record<string, Partial<BodyControlDefinition> | null>;
+}
+export interface ProfileRuntimeConfig extends Partial<Profile> {
+    profilePresetId?: PresetType;
+    presetId?: PresetType;
+    baseProfileId?: PresetType;
+    auPresetType?: PresetType;
+    profile?: Partial<Profile>;
+    defaultRegion?: string;
+    regions?: Region[];
+    markerStyle?: MarkerStyle;
+    playIntroOnLoad?: boolean;
+    modelOffset?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    modelRotation?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    modelScale?: number;
+    modelGroundClearance?: number;
+    deletedBakedAnimationClips?: string[];
+    markerGroups?: MarkerGroup[];
+    lineDefaults?: LineConfig;
+    markerDefaults?: Partial<MarkerStyleOverrides>;
+}
+export interface CharacterProfile extends ProfileRuntimeConfig {
+    characterId?: string;
+    characterName?: string;
+    modelPath?: string;
+}
+export type CharacterConfig = CharacterProfile & {
+    characterId: string;
+    characterName: string;
+    modelPath: string;
+    regions: Region[];
+};
+export interface HairColorAppearance {
+    name: string;
+    baseColor: string;
+    emissive: string;
+    emissiveIntensity: number;
+}
+export interface HairAppearanceState {
+    hairColor: HairColorAppearance;
+    eyebrowColor: HairColorAppearance;
+    showOutline: boolean;
+    outlineColor: string;
+    outlineOpacity: number;
+}
+export interface HairPhysicsRuntimeConfig {
+    enabled: boolean;
+    [key: string]: any;
+}
+export type HairPhysicsRuntimeConfigUpdate = Partial<HairPhysicsRuntimeConfig>;
+export interface TransitionHandle {
+    promise: Promise<void>;
+    pause(): void;
+    resume(): void;
+    cancel(): void;
+}
+export interface BoneAxisBindingUpdate {
+    channel?: RotationChannel;
+    positiveAuId?: number | null;
+    negativeAuId?: number | null;
+    positiveMaxDegrees?: number | null;
+    negativeMaxDegrees?: number | null;
+    positiveScale?: BoneAxisDirectionScale | null;
+    negativeScale?: BoneAxisDirectionScale | null;
+    positiveLeftScale?: BoneAxisDirectionScale | null;
+    positiveRightScale?: BoneAxisDirectionScale | null;
+    negativeLeftScale?: BoneAxisDirectionScale | null;
+    negativeRightScale?: BoneAxisDirectionScale | null;
+}
+export interface BoneAxisBindingState {
+    axis: BoneAxisKey;
+    channel: RotationChannel;
+    nodeKey: string;
+    positiveAuId: number | null;
+    negativeAuId: number | null;
+    positiveMaxDegrees: number | null;
+    negativeMaxDegrees: number | null;
+    positiveScale: BoneAxisDirectionScale | null;
+    negativeScale: BoneAxisDirectionScale | null;
+}
+export interface AUBoneBindingState {
+    auId: number;
+    boneName: string | null;
+    nodeKey: string | null;
+    axis: BoneAxisKey;
+    direction: BoneAxisDirection;
+    channel: RotationChannel | null;
+    maxDegrees: number | null;
+    oppositeAuId: number | null;
+    oppositeMaxDegrees: number | null;
+    hasBinding: boolean;
+    hasMultipleBindings: boolean;
+}
+export interface BilateralAxisDirectionScaleState {
+    left: BoneAxisDirectionScale | null;
+    right: BoneAxisDirectionScale | null;
+}
+export interface BilateralAxisScopeBindingState {
+    scope: BilateralBoneAxisScope;
+    label: string;
+    negativeAuId: number | null;
+    positiveAuId: number | null;
+    negativeMaxDegrees: number | null;
+    positiveMaxDegrees: number | null;
+    negativeScale: BilateralAxisDirectionScaleState;
+    positiveScale: BilateralAxisDirectionScaleState;
+}
+export interface BilateralAxisBindingState {
+    axis: BoneAxisKey;
+    familyLabel: string;
+    leftBoneName: string;
+    leftNodeKey: string;
+    rightBoneName: string;
+    rightNodeKey: string;
+    selectedSide: 'left' | 'right';
+    shared: BilateralAxisScopeBindingState;
+    left: BilateralAxisScopeBindingState;
+    right: BilateralAxisScopeBindingState;
+}
+export interface ChiralBoneNamePair {
+    leftBoneName: string;
+    rightBoneName: string;
+    selectedSide: 'left' | 'right';
+    familyLabel: string;
+}
+export interface CreatedBoneAxisAu {
+    auId: number;
+    profile: Profile;
+}
+export interface BoneInfo {
+    name: string;
+    parent: string | null;
+    children: string[];
+    worldPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    depth: number;
+}
+export interface TrackInfo {
+    name: string;
+    targetName: string;
+    property: string;
+    type: string;
+    keyframeCount: number;
+    valueRange?: {
+        min: number[];
+        max: number[];
+    };
+}
+export interface AnimationInfo {
+    name: string;
+    duration: number;
+    tracks: TrackInfo[];
+    animatedBones: string[];
+    animatedMorphs: string[];
+}
+export interface ModelData {
+    bones: BoneInfo[];
+    morphs: Array<{
+        name: string;
+        meshName: string;
+        index: number;
+    }>;
+    meshes: Array<{
+        name: string;
+        hasMorphTargets: boolean;
+        morphCount: number;
+    }>;
+    animations: AnimationInfo[];
+    boneNames: string[];
+    morphNames: string[];
+    meshNames: string[];
+}
+export interface MappingCorrection {
+    type: 'bone' | 'morph' | 'viseme' | 'mesh';
+    source: string;
+    target: string;
+    confidence: number;
+    reason: string;
+    applied: boolean;
+    auId?: number;
+    key?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    score: number;
+    missingMorphs: string[];
+    missingBones: string[];
+    foundMorphs: string[];
+    foundBones: string[];
+    unmappedMorphs: string[];
+    unmappedBones: string[];
+    missingMeshes: string[];
+    foundMeshes: string[];
+    unmappedMeshes: string[];
+    warnings: string[];
+    suggestedConfig?: Profile;
+    corrections?: MappingCorrection[];
+    unresolved?: MappingCorrection[];
+}
+export interface ModelAnalysisReport {
+    model: ModelData;
+    validation?: ValidationResult;
+    animations: {
+        count: number;
+        hasIdleCandidate: boolean;
+        clips: unknown[];
+    };
+    overallScore: number;
+    summary: string;
+}
+export interface HumanoidSkeletonTemplateBone {
+    readonly name: string;
+    readonly parent: string | null;
+    readonly translation: HumanoidSkeletonTemplateVec3;
+}
+export interface HumanoidSkeletonTemplate {
+    readonly id: string;
+    readonly sourceCharacterId: string;
+    readonly sourceAsset: string;
+    readonly sourceSkinName: string;
+    readonly bones: readonly HumanoidSkeletonTemplateBone[];
+}