@haiyue/extensions 0.1.0

package/dist/animation/HyaAnimation2DClipAdapter.d.ts

@@ -0,0 +1,16 @@
+import { type AnimationAudioComponent, type AnimationParticle2DComponent, type HyaStateMachineExtension, type ParsedAnimation } from '@haiyue/animation-spec';
+import type { Animation2DClip } from './runtime/mixer/index.js';
+/** Returns the canonical built-in state-machine payload from a parsed HYA document. */
+export declare function getHyaStateMachineExtension(animation: ParsedAnimation): HyaStateMachineExtension;
+/**
+ * Adapts named ranges from one HYA composition into source-independent 2D
+ * clips. The returned clips share no scene objects; one pose is applied to one
+ * Animation2DRuntime hierarchy by the state-machine runtime.
+ */
+export declare function createHyaAnimation2DClips(animation: ParsedAnimation, extension?: HyaStateMachineExtension): readonly Animation2DClip[];
+export interface HyaAnimation2DEffectPayload {
+    readonly targetId: string;
+    readonly slot: number;
+    readonly sourcePath: string;
+    readonly component: Readonly<AnimationParticle2DComponent | AnimationAudioComponent>;
+}

package/dist/animation/Particle2DDescriptorAdapter.d.ts

@@ -0,0 +1,5 @@
+import type { AnimationParticle2DComponent } from '@haiyue/animation-spec';
+import { ParticleEmitter2D, type ParticleEmitter2DOptions } from '@haiyue/engine/components';
+/** Single runtime mapping from screen-y-down HYA data to the engine's y-up emitter. */
+export declare function particle2DDescriptorToEmitterOptions(component: Readonly<AnimationParticle2DComponent>): ParticleEmitter2DOptions;
+export declare function createParticle2DEmitter(component: Readonly<AnimationParticle2DComponent>): ParticleEmitter2D;

package/dist/animation/runtime/mixer/Action.d.ts

@@ -0,0 +1,150 @@
+import type { Animation2DActionOptions, Animation2DActionStatus, Animation2DBinding, Animation2DBindingMask, Animation2DBlendMode, Animation2DClip, Animation2DEffectCue, Animation2DEffectEvent, Animation2DLoopMode, Animation2DMutablePose, Animation2DTrack } from './Types.js';
+import { Animation2DSampler } from './Sampler.js';
+export interface Animation2DActionOwner {
+    readonly time: number;
+    assertActive(): void;
+}
+export interface Animation2DActionTrackRuntime {
+    readonly track: Animation2DTrack;
+    readonly sampler: Animation2DSampler;
+    readonly reference: Float32Array;
+}
+interface RuntimeEffect {
+    readonly cue: Animation2DEffectCue;
+    readonly start: number;
+    readonly end: number;
+    readonly fullSpan: boolean;
+    readonly loopBehavior: 'continue' | 'restart';
+    readonly enterEvent: Animation2DEffectEvent;
+    readonly exitEvent: Animation2DEffectEvent;
+    readonly restartEvent: Animation2DEffectEvent;
+    readonly loopEvent: Animation2DEffectEvent;
+    readonly seekEvent: Animation2DEffectEvent;
+}
+/** @internal Reusable exact state used by controller-owned transactions. */
+export interface Animation2DActionSynchronizedState {
+    status: Animation2DActionStatus;
+    paused: boolean;
+    time: number;
+    rawTime: number;
+    timeScale: number;
+    weight: number;
+    loop: Animation2DLoopMode;
+    repetitions: number;
+    clampWhenFinished: boolean;
+    blendMode: Animation2DBlendMode;
+    mask: Animation2DBindingMask | null;
+    layer: number;
+    effectsStarted: boolean;
+    fadeActive: boolean;
+    fadeStart: number;
+    fadeEnd: number;
+    fadeFrom: number;
+    fadeTo: number;
+    fadeValue: number;
+    readonly effectActive: Uint8Array;
+    readonly pendingEffects: Animation2DEffectEvent[];
+}
+/**
+ * Mutable mixer-owned playback state. Effect lifecycle records and sampler
+ * outputs are allocated at construction and reused on every frame.
+ */
+export declare class Animation2DActionRuntime {
+    readonly id: string;
+    readonly clip: Animation2DClip;
+    readonly order: number;
+    readonly runtimeTracks: readonly Animation2DActionTrackRuntime[];
+    readonly runtimeEffects: readonly RuntimeEffect[];
+    private readonly _owner;
+    private readonly _effectActive;
+    private readonly _pendingEffects;
+    private readonly _pendingEffectOutput;
+    private _valid;
+    private _status;
+    private _paused;
+    private _time;
+    private _rawTime;
+    private _timeScale;
+    private _weight;
+    private _loop;
+    private _repetitions;
+    private _clampWhenFinished;
+    private _blendMode;
+    private _mask;
+    private _layer;
+    private _effectsStarted;
+    private _fadeActive;
+    private _fadeStart;
+    private _fadeEnd;
+    private _fadeFrom;
+    private _fadeTo;
+    private _fadeValue;
+    constructor(owner: Animation2DActionOwner, clip: Animation2DClip, id: string, order: number, options?: Animation2DActionOptions);
+    get duration(): number;
+    get status(): Animation2DActionStatus;
+    get paused(): boolean;
+    set paused(value: boolean);
+    get time(): number;
+    set time(value: number);
+    get timeScale(): number;
+    set timeScale(value: number);
+    get weight(): number;
+    set weight(value: number);
+    get layer(): number;
+    set layer(value: number);
+    get loop(): Animation2DLoopMode;
+    set loop(value: Animation2DLoopMode);
+    get repetitions(): number;
+    set repetitions(value: number);
+    get clampWhenFinished(): boolean;
+    set clampWhenFinished(value: boolean);
+    get blendMode(): Animation2DBlendMode;
+    set blendMode(value: Animation2DBlendMode);
+    get mask(): Animation2DBindingMask | null;
+    set mask(value: Animation2DBindingMask | null);
+    get effectiveWeight(): number;
+    play(): this;
+    pause(): this;
+    stop(): this;
+    reset(): this;
+    seek(timeSeconds: number): this;
+    /**
+     * Advances a controller-owned absolute playhead without classifying the
+     * move as a seek. Crossed side-effect boundaries are queued exactly once.
+     */
+    synchronizeTime(timeSeconds: number): this;
+    reverse(): this;
+    fadeTo(targetWeight: number, durationSeconds: number): this;
+    fadeIn(durationSeconds: number): this;
+    fadeOut(durationSeconds: number): this;
+    crossFadeFrom(source: Animation2DActionRuntime, durationSeconds: number): this;
+    crossFadeTo(destination: Animation2DActionRuntime, durationSeconds: number): this;
+    acceptsBinding(binding: Animation2DBinding): boolean;
+    flushPendingEffects(out: Animation2DMutablePose): void;
+    advance(mixerDelta: number, out: Animation2DMutablePose): void;
+    /** @internal Allocates one checkpoint that can be reused for every update. */
+    createSynchronizedState(): Animation2DActionSynchronizedState;
+    /** @internal Captures playhead, fade, and effect-cursor state without sampling. */
+    captureSynchronizedState(state: Animation2DActionSynchronizedState): void;
+    /** @internal Restores an exact controller transaction checkpoint. */
+    restoreSynchronizedState(state: Animation2DActionSynchronizedState): void;
+    invalidate(): void;
+    private _setSampleTime;
+    private _emitInitialEffects;
+    private _emitEffectCrossings;
+    private _emitOnceEffectCrossings;
+    private _emitRepeatEffectCrossings;
+    private _emitPingPongEffectCrossings;
+    private _emitLoopEffect;
+    private _syncEffectActivity;
+    private _queueActiveExits;
+    private _scheduleFade;
+    private _fadeFactor;
+    private _finishFade;
+    private _assertSibling;
+    private _clampSynchronizedTime;
+    private _terminalDirection;
+    private _resetSamplerCursors;
+    private _assertValid;
+}
+export {};

package/dist/animation/runtime/mixer/Mixer.d.ts

@@ -0,0 +1,54 @@
+import type { AnimationStateMachineActionOptions, AnimationStateMachineMixerPort } from '../../../animation-state-machine/runtime/AnimationStateMachineMixerPort.js';
+import { Animation2DActionRuntime, type Animation2DActionOwner } from './Action.js';
+import type { Animation2DActionOptions, Animation2DClip, Animation2DMutablePose, Animation2DPose } from './Types.js';
+/**
+ * Format-independent 2D pose mixer and shared state-machine mixer port.
+ *
+ * Action/track/layer accumulators are retained across frames. Once actions
+ * and their masks/layers have been warmed, update/evaluate allocates no
+ * action- or property-proportional temporary objects.
+ */
+export declare class Animation2DMixerRuntime implements Animation2DActionOwner, AnimationStateMachineMixerPort<Animation2DActionRuntime> {
+    private readonly _clips;
+    private readonly _actions;
+    private readonly _actionsById;
+    private readonly _accumulators;
+    private readonly _accumulatorList;
+    private readonly _stateMachineLayers;
+    private _destroyed;
+    private _time;
+    private _timeScale;
+    private _nextActionId;
+    private _nextActionOrder;
+    private _nextStateMachineLayer;
+    constructor(clips?: readonly Animation2DClip[]);
+    get time(): number;
+    get timeScale(): number;
+    set timeScale(value: number);
+    get actions(): readonly Animation2DActionRuntime[];
+    get liveBindingCount(): number;
+    registerClip(clip: Animation2DClip): this;
+    unregisterClip(clipId: string): boolean;
+    createAction(clip: Animation2DClip, options?: Animation2DActionOptions): Animation2DActionRuntime;
+    createAction(clipId: string, options: AnimationStateMachineActionOptions): Animation2DActionRuntime;
+    getAction(actionId: string): Animation2DActionRuntime | null;
+    removeAction(action: Animation2DActionRuntime | string): boolean;
+    update(deltaSeconds: number, out: Animation2DMutablePose): Animation2DPose;
+    evaluate(out: Animation2DMutablePose): Animation2DPose;
+    setMixerTime(timeSeconds: number, out: Animation2DMutablePose): Animation2DPose;
+    play(action: Animation2DActionRuntime): void;
+    stop(action: Animation2DActionRuntime): void;
+    fade(action: Animation2DActionRuntime, targetWeight: number, durationSeconds: number): void;
+    setWeight(action: Animation2DActionRuntime, weight: number): void;
+    setTime(action: Animation2DActionRuntime, timeSeconds: number): void;
+    setTimeScale(action: Animation2DActionRuntime, timeScale: number): void;
+    destroyAction(action: Animation2DActionRuntime): void;
+    destroy(): void;
+    assertActive(): void;
+    private _advanceActions;
+    private _evaluateInto;
+    private _retainBinding;
+    private _releaseBinding;
+    private _stateMachineLayer;
+    private _assertOwned;
+}

package/dist/animation/runtime/mixer/PoseBuffer.d.ts

@@ -0,0 +1,23 @@
+import type { Animation2DBinding, Animation2DEffectEvent, Animation2DMutablePose, Animation2DPose, Animation2DPoseChannel } from './Types.js';
+/**
+ * Caller-owned frame-transient pose. Channel records, numeric storage, and
+ * effect arrays are reused after warmup.
+ */
+export declare class Animation2DPoseBuffer implements Animation2DMutablePose, Animation2DPose {
+    private readonly _channelPool;
+    private readonly _channels;
+    private readonly _effects;
+    private _sequence;
+    private _mixerTime;
+    private _sealed;
+    get sequence(): number;
+    get mixerTime(): number;
+    get channels(): readonly Animation2DPoseChannel[];
+    get effects(): readonly Animation2DEffectEvent[];
+    reset(mixerTime: number): void;
+    writeNumeric(binding: Animation2DBinding, value: ArrayLike<number>): void;
+    writeDiscrete(binding: Animation2DBinding, value: unknown): void;
+    emit(effect: Animation2DEffectEvent): void;
+    seal(): Animation2DPose;
+    private _channelAt;
+}

package/dist/animation/runtime/mixer/Sampler.d.ts

@@ -0,0 +1,17 @@
+import type { Animation2DBinding, Animation2DTrack } from './Types.js';
+/**
+ * Stateful allocation-free sampler. Rotation values are radians and LINEAR
+ * sampling follows the shortest signed arc in [-PI, PI).
+ */
+export declare class Animation2DSampler {
+    readonly track: Animation2DTrack;
+    readonly output: Float32Array;
+    discreteValue: unknown;
+    private _cursor;
+    constructor(track: Animation2DTrack);
+    sample(timeSeconds: number, out?: Float32Array): Float32Array | unknown;
+    resetCursor(): void;
+    private _findKey;
+}
+export declare function wrapAngle(value: number): number;
+export declare function isNumericBinding(binding: Animation2DBinding): boolean;

package/dist/animation/runtime/mixer/Types.d.ts

@@ -0,0 +1,101 @@
+import type { AnimationStateMachineBindingMask, AnimationStateMachineBlendMode, AnimationStateMachineLoopMode } from '../../../animation-state-machine/AnimationStateMachine.js';
+export type Animation2DBindingStrategy = 'continuous' | 'rotation' | 'discrete' | 'dominant';
+export interface Animation2DBinding {
+    /** Stable mask and pose channel id. */
+    readonly id: string;
+    /** Stable node, slot, component, or graph target id. */
+    readonly targetId: string;
+    /** Examples: transform.position, opacity, text, sprite, composite, mask. */
+    readonly path: string;
+    readonly strategy: Animation2DBindingStrategy;
+    /** Required for continuous and rotation bindings; rotation must use one value. */
+    readonly valueSize?: number;
+    /** Base used when a continuous layer has less than unit weight. */
+    readonly defaultValue?: Readonly<ArrayLike<number>> | unknown;
+}
+export type Animation2DInterpolation = 'step' | 'linear' | 'cubic-bezier';
+export interface Animation2DNumericTrack {
+    readonly id: string;
+    readonly binding: Animation2DBinding;
+    readonly interpolation: Animation2DInterpolation;
+    readonly times: Float32Array;
+    /** Tightly packed key values by binding.valueSize. */
+    readonly values: Float32Array;
+    /** Per-segment x1, y1, x2, y2 tuples for cubic-bezier interpolation. */
+    readonly easings?: Float32Array;
+    /** Relative outgoing/incoming spatial controls for transform.position. */
+    readonly spatialTangents?: Float32Array;
+}
+export interface Animation2DDiscreteTrack {
+    readonly id: string;
+    readonly binding: Animation2DBinding;
+    readonly interpolation: 'step';
+    /** One immutable/reference-stable value per key. */
+    readonly times: Float32Array;
+    readonly values: readonly unknown[];
+}
+export type Animation2DTrack = Animation2DNumericTrack | Animation2DDiscreteTrack;
+export type Animation2DEffectKind = 'audio' | 'particle';
+export type Animation2DEffectLoopBehavior = 'continue' | 'restart';
+export interface Animation2DEffectCue {
+    readonly id: string;
+    readonly kind: Animation2DEffectKind;
+    readonly start: number;
+    /** Defaults to clip duration. The interval is [start, end). */
+    readonly end?: number;
+    /** Audio defaults to continue; particle defaults to restart. */
+    readonly loopBehavior?: Animation2DEffectLoopBehavior;
+    readonly payload?: unknown;
+}
+export interface Animation2DClip {
+    readonly format: 'haiyue-animation2d-clip@1';
+    readonly id: string;
+    readonly name: string;
+    readonly duration: number;
+    readonly tracks: readonly Animation2DTrack[];
+    readonly effects?: readonly Animation2DEffectCue[];
+}
+export type Animation2DEffectLifecycle = 'enter' | 'exit' | 'restart' | 'loop' | 'seek';
+export interface Animation2DEffectEvent {
+    readonly actionId: string;
+    readonly clipId: string;
+    readonly cue: Animation2DEffectCue;
+    readonly lifecycle: Animation2DEffectLifecycle;
+}
+export interface Animation2DPoseChannel {
+    readonly binding: Animation2DBinding;
+    /**
+     * Continuous and rotation channels expose a reused Float32Array. Discrete
+     * and dominant channels expose the winning authored value by reference.
+     */
+    readonly value: Readonly<Float32Array> | unknown;
+}
+export interface Animation2DPose {
+    readonly sequence: number;
+    readonly mixerTime: number;
+    readonly channels: readonly Animation2DPoseChannel[];
+    readonly effects: readonly Animation2DEffectEvent[];
+}
+export interface Animation2DMutablePose {
+    reset(mixerTime: number): void;
+    writeNumeric(binding: Animation2DBinding, value: ArrayLike<number>): void;
+    writeDiscrete(binding: Animation2DBinding, value: unknown): void;
+    emit(effect: Animation2DEffectEvent): void;
+    seal(): Animation2DPose;
+}
+export interface Animation2DActionOptions {
+    readonly id?: string;
+    readonly loop?: AnimationStateMachineLoopMode;
+    readonly repetitions?: number;
+    readonly clampWhenFinished?: boolean;
+    readonly timeScale?: number;
+    readonly weight?: number;
+    /** Ascending layers are applied in order; a higher layer overrides a lower one. */
+    readonly layer?: number;
+    readonly blendMode?: AnimationStateMachineBlendMode;
+    readonly mask?: AnimationStateMachineBindingMask;
+}
+export type Animation2DActionStatus = 'idle' | 'running' | 'paused' | 'finished' | 'stopped';
+export type Animation2DLoopMode = AnimationStateMachineLoopMode;
+export type Animation2DBlendMode = AnimationStateMachineBlendMode;
+export type Animation2DBindingMask = AnimationStateMachineBindingMask;

package/dist/animation/runtime/mixer/index.d.ts

@@ -0,0 +1,6 @@
+export { Animation2DActionRuntime } from './Action.js';
+export type { Animation2DActionOwner, Animation2DActionSynchronizedState, Animation2DActionTrackRuntime, } from './Action.js';
+export { Animation2DMixerRuntime } from './Mixer.js';
+export { Animation2DPoseBuffer } from './PoseBuffer.js';
+export { Animation2DSampler, wrapAngle } from './Sampler.js';
+export type { Animation2DActionOptions, Animation2DActionStatus, Animation2DBinding, Animation2DBindingMask, Animation2DBindingStrategy, Animation2DBlendMode, Animation2DClip, Animation2DDiscreteTrack, Animation2DEffectCue, Animation2DEffectEvent, Animation2DEffectKind, Animation2DEffectLifecycle, Animation2DEffectLoopBehavior, Animation2DInterpolation, Animation2DLoopMode, Animation2DMutablePose, Animation2DNumericTrack, Animation2DPose, Animation2DPoseChannel, Animation2DTrack, } from './Types.js';

package/dist/animation-state-machine/AnimationStateMachine.d.ts

@@ -0,0 +1,111 @@
+export type AnimationStateMachineLoopMode = 'once' | 'repeat' | 'ping-pong';
+export type AnimationStateMachineBlendMode = 'override' | 'additive';
+/**
+ * A state-machine mask addresses logical animation bindings. The concrete 2D
+ * or 3D mixer decides how those stable ids resolve to runtime targets.
+ */
+export interface AnimationStateMachineBindingMask {
+    /** Empty or omitted include means all bindings are eligible. */
+    readonly include?: readonly string[];
+    readonly exclude?: readonly string[];
+}
+export type AnimationStateMachineParameterDefinition = Readonly<{
+    name: string;
+    type: 'float';
+    defaultValue: number;
+}> | Readonly<{
+    name: string;
+    type: 'integer';
+    defaultValue: number;
+}> | Readonly<{
+    name: string;
+    type: 'boolean';
+    defaultValue: boolean;
+}> | Readonly<{
+    name: string;
+    type: 'trigger';
+}>;
+export type AnimationStateMachineTransitionCondition = Readonly<{
+    parameter: string;
+    operator: 'greater' | 'greater-or-equal' | 'less' | 'less-or-equal';
+    value: number;
+}> | Readonly<{
+    parameter: string;
+    operator: 'equal' | 'not-equal';
+    value: number | boolean;
+}> | Readonly<{
+    parameter: string;
+    operator: 'is-true' | 'is-false' | 'triggered';
+}>;
+export interface AnimationStateMachineClipMotion {
+    readonly kind: 'clip';
+    /**
+     * Mixer-owned source id. It may identify a 3D clip, a HYA composition, or
+     * another animation source understood by the selected mixer port.
+     */
+    readonly clipId: string;
+}
+export interface AnimationStateMachineBlend1DChild {
+    readonly threshold: number;
+    readonly motion: AnimationStateMachineMotionDefinition;
+}
+export interface AnimationStateMachineBlend1DMotion {
+    readonly kind: 'blend-1d';
+    readonly parameter: string;
+    readonly children: readonly AnimationStateMachineBlend1DChild[];
+}
+export interface AnimationStateMachineBlend2DChild {
+    readonly position: readonly [number, number];
+    readonly motion: AnimationStateMachineMotionDefinition;
+}
+export interface AnimationStateMachineBlend2DMotion {
+    readonly kind: 'blend-2d';
+    readonly algorithm: 'cartesian' | 'directional';
+    readonly parameterX: string;
+    readonly parameterY: string;
+    readonly children: readonly AnimationStateMachineBlend2DChild[];
+}
+export type AnimationStateMachineMotionDefinition = AnimationStateMachineClipMotion | AnimationStateMachineBlend1DMotion | AnimationStateMachineBlend2DMotion;
+export interface AnimationStateMachineStateDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly motion: AnimationStateMachineMotionDefinition;
+    readonly speed?: number;
+    readonly speedParameter?: string;
+    readonly loop?: AnimationStateMachineLoopMode;
+}
+export type AnimationStateMachineTransitionInterruption = 'none' | 'source' | 'destination' | 'source-then-destination' | 'destination-then-source';
+export interface AnimationStateMachineTransitionDefinition {
+    readonly id: string;
+    /** '*' means any state in the same layer. */
+    readonly from: string | '*';
+    readonly to: string;
+    readonly conditions: readonly AnimationStateMachineTransitionCondition[];
+    readonly duration: number;
+    readonly hasExitTime?: boolean;
+    readonly exitTime?: number;
+    readonly destinationOffset?: number;
+    readonly interruption?: AnimationStateMachineTransitionInterruption;
+}
+export interface AnimationStateMachineLayer {
+    readonly id: string;
+    readonly name: string;
+    readonly initialStateId: string;
+    readonly states: readonly AnimationStateMachineStateDefinition[];
+    /** Declaration order is transition priority. */
+    readonly transitions: readonly AnimationStateMachineTransitionDefinition[];
+    readonly blendMode?: AnimationStateMachineBlendMode;
+    readonly weight?: number;
+    readonly mask?: AnimationStateMachineBindingMask;
+}
+/**
+ * Dimension-neutral serializable state-machine definition. Runtime controller
+ * state and concrete mixer objects are intentionally not stored here.
+ */
+export interface AnimationStateMachineDefinition {
+    readonly format: 'haiyue-animation-state-machine@1';
+    readonly id: string;
+    readonly name: string;
+    readonly parameters: readonly AnimationStateMachineParameterDefinition[];
+    readonly layers: readonly AnimationStateMachineLayer[];
+}

package/dist/animation-state-machine/AnimationStateMachineChannels.d.ts

@@ -0,0 +1,23 @@
+import { HYA_STATE_MACHINE_CHANNEL_REGISTRY, hyaStateMachineChannelCapability, type HyaStateMachineChannelCapability, type HyaStateMachineChannelId, type HyaStateMachineDefinition } from '@haiyue/animation-spec';
+export { HYA_STATE_MACHINE_CHANNEL_REGISTRY, hyaStateMachineChannelCapability, };
+export type { HyaStateMachineChannelCapability, HyaStateMachineChannelId, };
+export type AnimationStateMachineChannelDiagnosticCode = NonNullable<HyaStateMachineChannelCapability['diagnosticCode']> | 'W_STATE_MACHINE_CHANNEL_AUDIO_AUTOPLAY_REJECTED';
+export interface AnimationStateMachineChannelDiagnostic {
+    readonly code: AnimationStateMachineChannelDiagnosticCode;
+    readonly severity: 'warning' | 'error';
+    readonly channelId: HyaStateMachineChannelId;
+    readonly path: string;
+    readonly message: string;
+}
+export declare class AnimationStateMachineChannelError extends Error {
+    readonly diagnostic: AnimationStateMachineChannelDiagnostic;
+    readonly name = "AnimationStateMachineChannelError";
+    constructor(diagnostic: AnimationStateMachineChannelDiagnostic);
+}
+/**
+ * Audio owns one HTMLMediaElement playhead and is intentionally not amplitude
+ * mixed. It is executable only when the graph can never overlap two motions.
+ */
+export declare function audioStateMachineCompatibilityDiagnostic(definition: HyaStateMachineDefinition, path?: string): AnimationStateMachineChannelDiagnostic | null;
+export declare function assertAudioStateMachineCompatible(definition: HyaStateMachineDefinition, path?: string): void;
+export declare function audioAutoplayRejectedDiagnostic(path: string, reason?: unknown): AnimationStateMachineChannelDiagnostic;

package/dist/animation-state-machine/runtime/Animation2DStateMachineMixerAdapter.d.ts

@@ -0,0 +1,51 @@
+import { Animation2DActionRuntime } from '../../animation/runtime/mixer/Action.js';
+import { Animation2DMixerRuntime } from '../../animation/runtime/mixer/Mixer.js';
+import type { AnimationStateMachineActionOptions, AnimationStateMachineMixerPort } from './AnimationStateMachineMixerPort.js';
+export declare class Animation2DStateMachineActionRuntimeHandle {
+    readonly duration: number;
+    readonly clipId: string;
+    readonly action: Animation2DActionRuntime;
+    targetTime: number;
+    playing: boolean;
+    destroyed: boolean;
+    pendingDestroy: boolean;
+    private readonly _checkpoint;
+    private _checkpointTargetTime;
+    private _checkpointPlaying;
+    constructor(clipId: string, action: Animation2DActionRuntime);
+    captureTransactionState(): void;
+    restoreTransactionState(): void;
+}
+/**
+ * Transactional state-machine owner for the existing 2D mixer. It never
+ * samples tracks itself: absolute controller playheads are synchronized into
+ * the mixer actions, and the caller evaluates the ordinary shared pose buffer.
+ */
+export declare class Animation2DStateMachineMixerAdapter implements AnimationStateMachineMixerPort<Animation2DStateMachineActionRuntimeHandle> {
+    readonly mixer: Animation2DMixerRuntime;
+    private readonly _handles;
+    private readonly _transactionHandles;
+    private readonly _transactionCreated;
+    private readonly _transactionPendingDestroy;
+    private _transactionActive;
+    private _destroyed;
+    constructor(mixer: Animation2DMixerRuntime);
+    get liveActionCount(): number;
+    get liveBindingCount(): number;
+    createAction(clipId: string, options: AnimationStateMachineActionOptions): Animation2DStateMachineActionRuntimeHandle;
+    play(handle: Animation2DStateMachineActionRuntimeHandle): void;
+    stop(handle: Animation2DStateMachineActionRuntimeHandle): void;
+    fade(handle: Animation2DStateMachineActionRuntimeHandle, _targetWeight: number, _durationSeconds: number): void;
+    setWeight(handle: Animation2DStateMachineActionRuntimeHandle, weight: number): void;
+    setTime(handle: Animation2DStateMachineActionRuntimeHandle, timeSeconds: number): void;
+    setTimeScale(handle: Animation2DStateMachineActionRuntimeHandle, timeScale: number): void;
+    destroyAction(handle: Animation2DStateMachineActionRuntimeHandle): void;
+    beginControllerTransaction(): void;
+    commitControllerTransaction(): void;
+    rollbackControllerTransaction(): void;
+    destroy(): void;
+    private _destroyHandleNow;
+    private _clearTransaction;
+    private _requireHandle;
+    private _requireActive;
+}

package/dist/animation-state-machine/runtime/AnimationStateMachineBlendTreeWeights.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledAnimation3DBlend1DMotion, CompiledAnimation3DBlend2DMotion } from './AnimationStateMachineCompiler.js';
+/**
+ * Evaluates direct child weights for a compiled 1D blend tree. Values outside
+ * the authored threshold range clamp to the nearest endpoint.
+ */
+export declare function evaluateAnimation3DBlend1DWeights(motion: CompiledAnimation3DBlend1DMotion, value: number, out?: Float64Array): Float64Array;
+/**
+ * Evaluates direct child weights for a compiled 2D blend tree.
+ *
+ * Cartesian trees use a deterministic containing simplex after projecting
+ * outside samples to the convex hull. Directional trees interpolate the two
+ * surrounding authored directions and then interpolate/clamp radially.
+ */
+export declare function evaluateAnimation3DBlend2DWeights(motion: CompiledAnimation3DBlend2DMotion, x: number, y: number, out?: Float64Array): Float64Array;