@lovelace_lol/embody 0.0.1

package/dist/core/WasmRuntimeCore.d.ts

@@ -0,0 +1,55 @@
+import type { BoneFrameDelta, FrameDelta, ModelDescriptor, MorphTargetFrameDelta } from './contracts';
+import type { Profile } from '../mappings/types';
+import type { EmbodyCoreWasmModule } from '../wasmTypes';
+export declare const AU_MORPH_BINDING_STRIDE = 5;
+export declare const VISEME_MORPH_BINDING_STRIDE = 4;
+export type MorphBindingSide = 0 | 1 | 2;
+export interface WasmRuntimeCoreOptions {
+    readonly profile: Profile;
+    readonly model: ModelDescriptor;
+    readonly wasm: EmbodyCoreWasmModule;
+}
+/**
+ * TypeScript facade over the Rust Wasm RuntimeCore for live morph FrameDelta
+ * evaluation. Bones/composites remain on TsRuntimeCore until a later slice.
+ */
+export declare class WasmRuntimeCore {
+    private readonly wasm;
+    private readonly core;
+    private profile;
+    private model;
+    constructor(options: WasmRuntimeCoreOptions);
+    setProfile(profile: Profile): void;
+    setModelDescriptor(model: ModelDescriptor): void;
+    setAU(id: number, value: number, balance?: number): void;
+    getAU(id: number): number;
+    setAUMixWeight(id: number, weight: number): void;
+    setViseme(visemeIndex: number, value: number, jawScale?: number): void;
+    clear(): void;
+    evaluatePackedMorphFrameDelta(): Float32Array;
+    evaluatePackedBoneFrameDelta(): Float32Array;
+    evaluateMorphFrameDelta(deltaSeconds?: number): FrameDelta;
+    evaluateFrameDelta(deltaSeconds?: number): FrameDelta;
+    private reloadBindings;
+}
+export declare function compileMorphBindings(profile: Profile, model: ModelDescriptor): {
+    auBindings: Float32Array;
+    visemeBindings: Float32Array;
+    mixedAus: Uint32Array;
+};
+export interface CompiledBoneBindings {
+    restTransforms: Float32Array;
+    compositeAxes: Float32Array;
+    translations: Float32Array;
+    jawBinding: Float32Array;
+    visemeJawAmounts: Float32Array;
+}
+/**
+ * Compile profile bone mappings into the packed tables the Rust RuntimeCore
+ * consumes: rest transforms, composite rotation axes (in yaw/pitch/roll
+ * application order), AU translations, and the auto viseme jaw binding.
+ * Mirrors the mapping resolution in TsRuntimeCore.collectBoneWrites.
+ */
+export declare function compileBoneBindings(profile: Profile, model: ModelDescriptor): CompiledBoneBindings;
+export declare function unpackBoneFrameDelta(values: ArrayLike<number>): BoneFrameDelta[];
+export declare function unpackMorphFrameDelta(values: ArrayLike<number>): MorphTargetFrameDelta[];

package/dist/core/compositeAxis.d.ts

@@ -0,0 +1,4 @@
+import type { AUSelector, BoneBinding, RotationAxis } from './types';
+export declare function toAUList(value?: AUSelector): number[];
+export declare function getCompositeAxisValue(axisConfig: RotationAxis | null | undefined, getValue: (auId: number) => number): number;
+export declare function getCompositeAxisBinding(nodeKey: string, axisConfig: RotationAxis | null | undefined, direction: number, getValue: (auId: number) => number, auToBones: Record<number, BoneBinding[]>): BoneBinding | null;

package/dist/core/contracts/abi.d.ts

@@ -0,0 +1,70 @@
+import type { NumericArray } from './primitives';
+export declare const EMBODY_CORE_ABI_VERSION = 1;
+export declare const PACKED_MORPH_FRAME_DELTA_STRIDE = 4;
+export declare const PACKED_MORPH_FRAME_DELTA_FIELDS: readonly ["meshId", "morphTargetId", "value", "mode"];
+export declare const PACKED_BONE_FRAME_DELTA_STRIDE = 9;
+export declare const PACKED_BONE_FRAME_DELTA_FIELDS: readonly ["boneId", "positionX", "positionY", "positionZ", "rotationX", "rotationY", "rotationZ", "rotationW", "flags"];
+/** Packed bone FrameDelta flags: bit 0 = has position, bit 1 = has rotation. */
+export declare const PACKED_BONE_FLAG_HAS_POSITION = 1;
+export declare const PACKED_BONE_FLAG_HAS_ROTATION = 2;
+export declare const HAIR_CONFIG_STRIDE = 11;
+export declare const HAIR_STATE_STRIDE = 4;
+export declare const HAIR_HEAD_STATE_STRIDE = 5;
+export declare const HAIR_MORPH_OUTPUT_STRIDE = 6;
+export declare const TEMPLATE_SKELETON_FIT_TRANSFORM_STRIDE = 4;
+export declare const MESH_PROPORTIONS_STRIDE = 16;
+export declare const TEMPLATE_SKELETON_FIT_SOLUTION_STRIDE = 10;
+export declare const ANNOTATION_CAMERA_FRAMING_STRIDE = 7;
+export declare const CAMERA_FLIGHT_SAMPLE_STRIDE = 7;
+export declare const MARKER_VISIBILITY_FACTORS_STRIDE = 3;
+export declare const MARKER_ENDPOINT_STRIDE = 3;
+export declare const HAIR_CONFIG_FIELDS: readonly ["mass", "stiffness", "damping", "gravity", "headInfluence", "windEnabled", "windStrength", "windDirectionX", "windDirectionZ", "windTurbulence", "windFrequency"];
+export declare const HAIR_STATE_FIELDS: readonly ["x", "z", "vx", "vz"];
+export declare const HAIR_HEAD_STATE_FIELDS: readonly ["yaw", "pitch", "roll", "yawVelocity", "pitchVelocity"];
+export declare const HAIR_MORPH_OUTPUT_FIELDS: readonly ["L_Hair_Left", "L_Hair_Right", "L_Hair_Front", "R_Hair_Left", "R_Hair_Right", "R_Hair_Front"];
+export declare const TEMPLATE_SKELETON_FIT_TRANSFORM_FIELDS: readonly ["scale", "translationX", "translationY", "translationZ"];
+export declare const MESH_PROPORTIONS_FIELDS: readonly ["minX", "minY", "minZ", "maxX", "maxY", "maxZ", "centerX", "centerY", "centerZ", "spanX", "spanY", "spanZ", "verticalHeight", "crossAxisWideSpan", "crossAxisNarrowSpan", "humanoidLikelihood"];
+export declare const TEMPLATE_SKELETON_FIT_SOLUTION_FIELDS: readonly ["scale", "translationX", "translationY", "translationZ", "confidence", "meshHeight", "templateHeight", "meshCrossAxisWideSpan", "templateCrossAxisWideSpan", "status"];
+export declare const ANNOTATION_CAMERA_FRAMING_FIELDS: readonly ["positionX", "positionY", "positionZ", "targetX", "targetY", "targetZ", "distance"];
+export declare const CAMERA_FLIGHT_SAMPLE_FIELDS: readonly ["positionX", "positionY", "positionZ", "targetX", "targetY", "targetZ", "done"];
+export declare const MARKER_VISIBILITY_FACTORS_FIELDS: readonly ["itemOpacityFactor", "labelScaleFactor", "lineOpacityFactor"];
+export declare const MARKER_ENDPOINT_FIELDS: readonly ["x", "y", "z"];
+export type PackedMorphFrameDeltaField = (typeof PACKED_MORPH_FRAME_DELTA_FIELDS)[number];
+export type HairConfigField = (typeof HAIR_CONFIG_FIELDS)[number];
+export type HairStateField = (typeof HAIR_STATE_FIELDS)[number];
+export type HairHeadStateField = (typeof HAIR_HEAD_STATE_FIELDS)[number];
+export type HairMorphOutputField = (typeof HAIR_MORPH_OUTPUT_FIELDS)[number];
+export type TemplateSkeletonFitTransformField = (typeof TEMPLATE_SKELETON_FIT_TRANSFORM_FIELDS)[number];
+export type MeshProportionsField = (typeof MESH_PROPORTIONS_FIELDS)[number];
+export type TemplateSkeletonFitSolutionField = (typeof TEMPLATE_SKELETON_FIT_SOLUTION_FIELDS)[number];
+export interface PackedMorphFrameDelta {
+    readonly abiVersion: typeof EMBODY_CORE_ABI_VERSION;
+    readonly stride: typeof PACKED_MORPH_FRAME_DELTA_STRIDE;
+    readonly fields: typeof PACKED_MORPH_FRAME_DELTA_FIELDS;
+    readonly values: NumericArray;
+}
+export interface PackedHairPhysicsState {
+    readonly stride: typeof HAIR_STATE_STRIDE;
+    readonly fields: typeof HAIR_STATE_FIELDS;
+    readonly values: NumericArray;
+}
+export interface PackedHairMorphOutput {
+    readonly stride: typeof HAIR_MORPH_OUTPUT_STRIDE;
+    readonly fields: typeof HAIR_MORPH_OUTPUT_FIELDS;
+    readonly values: NumericArray;
+}
+export interface PackedTemplateSkeletonFitTransform {
+    readonly stride: typeof TEMPLATE_SKELETON_FIT_TRANSFORM_STRIDE;
+    readonly fields: typeof TEMPLATE_SKELETON_FIT_TRANSFORM_FIELDS;
+    readonly values: NumericArray;
+}
+export interface PackedMeshProportions {
+    readonly stride: typeof MESH_PROPORTIONS_STRIDE;
+    readonly fields: typeof MESH_PROPORTIONS_FIELDS;
+    readonly values: NumericArray;
+}
+export interface PackedTemplateSkeletonFitSolution {
+    readonly stride: typeof TEMPLATE_SKELETON_FIT_SOLUTION_STRIDE;
+    readonly fields: typeof TEMPLATE_SKELETON_FIT_SOLUTION_FIELDS;
+    readonly values: NumericArray;
+}

package/dist/core/contracts/clip.d.ts

@@ -0,0 +1,44 @@
+import type { BoneId, ChannelId, MeshId, MorphTargetId, TrackId } from './ids';
+import type { NumericArray } from './primitives';
+export type ClipChannelKind = 'face' | 'body' | 'scene' | 'custom';
+export type ClipTrackValueType = 'scalar' | 'vec3' | 'quat';
+export type ClipInterpolation = 'step' | 'linear' | 'cubic';
+export type ClipTrackTargetKind = 'morphTarget' | 'boneTransform' | 'meshVisibility';
+export type ClipTrackTransformProperty = 'position' | 'rotation' | 'scale';
+export interface ClipChannelIR {
+    readonly id: ChannelId;
+    readonly kind: ClipChannelKind;
+    readonly name?: string;
+}
+export interface MorphTargetTrackTarget {
+    readonly kind: 'morphTarget';
+    readonly meshId: MeshId;
+    readonly morphTargetId: MorphTargetId;
+}
+export interface BoneTransformTrackTarget {
+    readonly kind: 'boneTransform';
+    readonly boneId: BoneId;
+    readonly property: ClipTrackTransformProperty;
+}
+export interface MeshVisibilityTrackTarget {
+    readonly kind: 'meshVisibility';
+    readonly meshId: MeshId;
+}
+export type ClipTrackTarget = MorphTargetTrackTarget | BoneTransformTrackTarget | MeshVisibilityTrackTarget;
+export interface ClipTrackIR {
+    readonly id: TrackId;
+    readonly channelId: ChannelId;
+    readonly target: ClipTrackTarget;
+    readonly valueType: ClipTrackValueType;
+    readonly times: NumericArray;
+    readonly values: NumericArray;
+    readonly interpolation?: ClipInterpolation;
+}
+export interface ClipIR {
+    readonly id?: string;
+    readonly name: string;
+    readonly durationSeconds: number;
+    readonly channels: readonly ClipChannelIR[];
+    readonly tracks: readonly ClipTrackIR[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}

package/dist/core/contracts/frame.d.ts

@@ -0,0 +1,27 @@
+import type { BoneId, MeshId, MorphTargetId } from './ids';
+import type { Transform } from './primitives';
+export type FrameValueMode = 'absolute' | 'additive';
+export type TransformSpace = 'local' | 'model';
+export interface MorphTargetFrameDelta {
+    readonly meshId: MeshId;
+    readonly morphTargetId: MorphTargetId;
+    readonly value: number;
+    readonly mode?: FrameValueMode;
+}
+export interface BoneFrameDelta {
+    readonly boneId: BoneId;
+    readonly transform: Transform;
+    readonly mode?: FrameValueMode;
+    readonly space?: TransformSpace;
+}
+export interface MeshFrameDelta {
+    readonly meshId: MeshId;
+    readonly visible?: boolean;
+}
+export interface FrameDelta {
+    readonly timeSeconds?: number;
+    readonly deltaSeconds?: number;
+    readonly morphTargets?: readonly MorphTargetFrameDelta[];
+    readonly bones?: readonly BoneFrameDelta[];
+    readonly meshes?: readonly MeshFrameDelta[];
+}

package/dist/core/contracts/host.d.ts

@@ -0,0 +1,28 @@
+import type { ClipIR } from './clip';
+import type { FrameDelta } from './frame';
+import type { ModelDescriptor } from './model';
+export interface HostModelInspector<HostModel = unknown> {
+    describeModel(model: HostModel): ModelDescriptor;
+}
+export interface HostFrameApplier<HostModel = unknown> {
+    applyFrameDelta(model: HostModel, frame: FrameDelta): void;
+}
+export interface HostAnimationHandle {
+    readonly id?: string;
+    stop(): void;
+    pause?(): void;
+    resume?(): void;
+    setWeight?(weight: number): void;
+    setPlaybackRate?(playbackRate: number): void;
+}
+export interface HostAnimationPlayOptions {
+    readonly weight?: number;
+    readonly playbackRate?: number;
+    readonly loop?: boolean;
+    readonly startTimeSeconds?: number;
+}
+export interface HostAnimationSystem<HostModel = unknown, HostClip = unknown, AnimationHandle extends HostAnimationHandle = HostAnimationHandle> extends HostModelInspector<HostModel>, HostFrameApplier<HostModel> {
+    createClip(model: HostModel, clip: ClipIR): HostClip;
+    playClip(model: HostModel, clip: HostClip, options?: HostAnimationPlayOptions): AnimationHandle | null;
+    update?(model: HostModel, deltaSeconds: number): void;
+}

package/dist/core/contracts/ids.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Stable numeric identifiers used by host-neutral model, frame, and clip
+ * contracts. Adapters assign these ids while inspecting a host model and keep
+ * them stable for the lifetime of that descriptor.
+ */
+type StableNumericId<Tag extends string> = number & {
+    readonly __embodyStableId: Tag;
+};
+export type MeshId = StableNumericId<'mesh'>;
+export type MorphTargetId = StableNumericId<'morphTarget'>;
+export type BoneId = StableNumericId<'bone'>;
+export type TrackId = StableNumericId<'track'>;
+export type ChannelId = StableNumericId<'channel'>;
+export type HostTargetId = MeshId | MorphTargetId | BoneId;
+export {};

package/dist/core/contracts/index.d.ts

@@ -0,0 +1,10 @@
+export type { HairConfigField, HairHeadStateField, HairMorphOutputField, HairStateField, PackedHairMorphOutput, PackedHairPhysicsState, PackedMeshProportions, PackedMorphFrameDelta, PackedMorphFrameDeltaField, PackedTemplateSkeletonFitSolution, PackedTemplateSkeletonFitTransform, TemplateSkeletonFitTransformField, MeshProportionsField, TemplateSkeletonFitSolutionField, } from './abi';
+export { ANNOTATION_CAMERA_FRAMING_FIELDS, ANNOTATION_CAMERA_FRAMING_STRIDE, CAMERA_FLIGHT_SAMPLE_FIELDS, CAMERA_FLIGHT_SAMPLE_STRIDE, EMBODY_CORE_ABI_VERSION, HAIR_CONFIG_FIELDS, HAIR_CONFIG_STRIDE, HAIR_HEAD_STATE_FIELDS, HAIR_HEAD_STATE_STRIDE, HAIR_MORPH_OUTPUT_FIELDS, HAIR_MORPH_OUTPUT_STRIDE, HAIR_STATE_FIELDS, HAIR_STATE_STRIDE, MARKER_VISIBILITY_FACTORS_FIELDS, MARKER_VISIBILITY_FACTORS_STRIDE, MARKER_ENDPOINT_FIELDS, MARKER_ENDPOINT_STRIDE, MESH_PROPORTIONS_FIELDS, MESH_PROPORTIONS_STRIDE, PACKED_MORPH_FRAME_DELTA_FIELDS, PACKED_MORPH_FRAME_DELTA_STRIDE, PACKED_BONE_FRAME_DELTA_FIELDS, PACKED_BONE_FRAME_DELTA_STRIDE, PACKED_BONE_FLAG_HAS_POSITION, PACKED_BONE_FLAG_HAS_ROTATION, TEMPLATE_SKELETON_FIT_SOLUTION_FIELDS, TEMPLATE_SKELETON_FIT_SOLUTION_STRIDE, TEMPLATE_SKELETON_FIT_TRANSFORM_FIELDS, TEMPLATE_SKELETON_FIT_TRANSFORM_STRIDE, } from './abi';
+export type { BoneId, ChannelId, HostTargetId, MeshId, MorphTargetId, TrackId, } from './ids';
+export type { NumericArray, Quat, Transform, Vec3, } from './primitives';
+export { TEMPLATE_SKELETON_FIT_METADATA_KIND, TEMPLATE_SKELETON_FIT_METADATA_VERSION, TEMPLATE_SKELETON_FIT_STATUSES, TEMPLATE_SKELETON_FIT_VERTICAL_ANCHORS, TEMPLATE_SKELETON_FIT_VERTICAL_AXES, composeTemplateSkeletonFitTransform, isTemplateSkeletonFitStatus, validateTemplateSkeletonFitMetadata, } from './skeletonFit';
+export type { TemplateSkeletonFitManualAdjustment, TemplateSkeletonFitMetadata, TemplateSkeletonFitMetrics, TemplateSkeletonFitStatus, TemplateSkeletonFitTransform, TemplateSkeletonFitValidationResult, TemplateSkeletonFitVerticalAnchor, TemplateSkeletonFitVerticalAxis, } from './skeletonFit';
+export type { BoneDescriptor, MeshDescriptor, ModelDescriptor, MorphTargetDescriptor, } from './model';
+export type { BoneFrameDelta, FrameDelta, FrameValueMode, MeshFrameDelta, MorphTargetFrameDelta, TransformSpace, } from './frame';
+export type { BoneTransformTrackTarget, ClipChannelIR, ClipChannelKind, ClipIR, ClipInterpolation, ClipTrackIR, ClipTrackTarget, ClipTrackTargetKind, ClipTrackTransformProperty, ClipTrackValueType, MeshVisibilityTrackTarget, MorphTargetTrackTarget, } from './clip';
+export type { HostAnimationHandle, HostAnimationPlayOptions, HostAnimationSystem, HostFrameApplier, HostModelInspector, } from './host';

package/dist/core/contracts/model.d.ts

@@ -0,0 +1,31 @@
+import type { BoneId, MeshId, MorphTargetId } from './ids';
+import type { Transform } from './primitives';
+export interface MorphTargetDescriptor {
+    readonly id: MorphTargetId;
+    readonly meshId: MeshId;
+    readonly name: string;
+    /** Host-local morph slot/index, recorded as data and not used as identity. */
+    readonly hostIndex?: number;
+}
+export interface MeshDescriptor {
+    readonly id: MeshId;
+    readonly name: string;
+    readonly parentBoneId?: BoneId;
+    readonly morphTargetIds: readonly MorphTargetId[];
+    readonly visible?: boolean;
+}
+export interface BoneDescriptor {
+    readonly id: BoneId;
+    readonly name: string;
+    readonly parentId?: BoneId;
+    readonly childIds: readonly BoneId[];
+    readonly restTransform?: Transform;
+}
+export interface ModelDescriptor {
+    readonly id?: string;
+    readonly name?: string;
+    readonly meshes: readonly MeshDescriptor[];
+    readonly morphTargets: readonly MorphTargetDescriptor[];
+    readonly bones: readonly BoneDescriptor[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}

package/dist/core/contracts/primitives.d.ts

@@ -0,0 +1,17 @@
+export type NumericArray = readonly number[] | Float32Array;
+export interface Vec3 {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+export interface Quat {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
+}
+export interface Transform {
+    readonly position?: Vec3;
+    readonly rotation?: Quat;
+    readonly scale?: Vec3;
+}

package/dist/core/contracts/skeletonFit.d.ts

@@ -0,0 +1,41 @@
+import type { Vec3 } from './primitives';
+export declare const TEMPLATE_SKELETON_FIT_METADATA_KIND = "template-skeleton-fit";
+export declare const TEMPLATE_SKELETON_FIT_METADATA_VERSION = 1;
+export declare const TEMPLATE_SKELETON_FIT_STATUSES: readonly ["unfitted", "estimated", "manual-adjusted", "invalid"];
+export declare const TEMPLATE_SKELETON_FIT_VERTICAL_AXES: readonly ["x", "y", "z"];
+export declare const TEMPLATE_SKELETON_FIT_VERTICAL_ANCHORS: readonly ["min", "center", "max"];
+export type TemplateSkeletonFitStatus = (typeof TEMPLATE_SKELETON_FIT_STATUSES)[number];
+export type TemplateSkeletonFitVerticalAxis = (typeof TEMPLATE_SKELETON_FIT_VERTICAL_AXES)[number];
+export type TemplateSkeletonFitVerticalAnchor = (typeof TEMPLATE_SKELETON_FIT_VERTICAL_ANCHORS)[number];
+export interface TemplateSkeletonFitTransform {
+    readonly scale: number;
+    readonly translation: Vec3;
+}
+export interface TemplateSkeletonFitMetrics extends TemplateSkeletonFitTransform {
+    readonly confidence: number;
+    readonly meshHeight: number;
+    readonly templateHeight: number;
+    readonly crossAxisSpans: Vec3;
+    readonly status: TemplateSkeletonFitStatus;
+}
+export interface TemplateSkeletonFitManualAdjustment {
+    readonly scale?: number;
+    readonly translation?: Vec3;
+}
+export interface TemplateSkeletonFitMetadata {
+    readonly kind: typeof TEMPLATE_SKELETON_FIT_METADATA_KIND;
+    readonly version: typeof TEMPLATE_SKELETON_FIT_METADATA_VERSION;
+    readonly templateId: string;
+    readonly sourceCharacterId: string;
+    readonly verticalAxis: TemplateSkeletonFitVerticalAxis;
+    readonly verticalAnchor: TemplateSkeletonFitVerticalAnchor;
+    readonly fit: TemplateSkeletonFitMetrics;
+    readonly manualAdjustment?: TemplateSkeletonFitManualAdjustment;
+}
+export interface TemplateSkeletonFitValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly string[];
+}
+export declare function isTemplateSkeletonFitStatus(value: unknown): value is TemplateSkeletonFitStatus;
+export declare function composeTemplateSkeletonFitTransform(fit: TemplateSkeletonFitTransform, manualAdjustment?: TemplateSkeletonFitManualAdjustment): TemplateSkeletonFitTransform;
+export declare function validateTemplateSkeletonFitMetadata(metadata: unknown): TemplateSkeletonFitValidationResult;

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+export type { BoneDescriptor, BoneFrameDelta, BoneId, BoneTransformTrackTarget, ChannelId, ClipChannelIR, ClipChannelKind, ClipIR, ClipInterpolation, ClipTrackIR, ClipTrackTarget, ClipTrackTargetKind, ClipTrackTransformProperty, ClipTrackValueType, FrameDelta, FrameValueMode, HostAnimationHandle, HostAnimationPlayOptions, HostAnimationSystem, HostFrameApplier, HostModelInspector, HostTargetId, MeshDescriptor, MeshFrameDelta, MeshId, MeshVisibilityTrackTarget, ModelDescriptor, MorphTargetDescriptor, MorphTargetFrameDelta, MorphTargetId, MorphTargetTrackTarget, NumericArray, PackedMeshProportions, PackedTemplateSkeletonFitSolution, Quat, MeshProportionsField, TemplateSkeletonFitSolutionField, TemplateSkeletonFitManualAdjustment, TemplateSkeletonFitMetadata, TemplateSkeletonFitMetrics, TemplateSkeletonFitStatus, TemplateSkeletonFitTransform, TemplateSkeletonFitTransformField, TemplateSkeletonFitValidationResult, TemplateSkeletonFitVerticalAnchor, TemplateSkeletonFitVerticalAxis, TrackId, Transform, TransformSpace, Vec3, } from './contracts';
+export { TEMPLATE_SKELETON_FIT_METADATA_KIND, TEMPLATE_SKELETON_FIT_METADATA_VERSION, MESH_PROPORTIONS_FIELDS, MESH_PROPORTIONS_STRIDE, TEMPLATE_SKELETON_FIT_STATUSES, TEMPLATE_SKELETON_FIT_SOLUTION_FIELDS, TEMPLATE_SKELETON_FIT_SOLUTION_STRIDE, TEMPLATE_SKELETON_FIT_TRANSFORM_FIELDS, TEMPLATE_SKELETON_FIT_TRANSFORM_STRIDE, TEMPLATE_SKELETON_FIT_VERTICAL_ANCHORS, TEMPLATE_SKELETON_FIT_VERTICAL_AXES, composeTemplateSkeletonFitTransform, isTemplateSkeletonFitStatus, validateTemplateSkeletonFitMetadata, } from './contracts';
+export { TsClipCompiler, numericArrayToNumbers, } from './TsClipCompiler';
+export { TsRuntimeCore } from './TsRuntimeCore';
+export { AU_MORPH_BINDING_STRIDE, VISEME_MORPH_BINDING_STRIDE, WasmRuntimeCore, compileMorphBindings, compileBoneBindings, unpackMorphFrameDelta, unpackBoneFrameDelta, } from './WasmRuntimeCore';
+export type { CompiledBoneBindings, MorphBindingSide, WasmRuntimeCoreOptions, } from './WasmRuntimeCore';
+export type { TsClipCompilerInput, TsClipCompilerKeyframe, TsClipCompilerTrackInput, TsClipCurveTarget, TsClipCurvesInput, } from './TsClipCompiler';
+export type { TsRuntimeCoreOptions } from './TsRuntimeCore';