@haiyue/extensions 0.1.0

package/dist/animation3d/hya/HyaAnimation3DTypes.d.ts

@@ -0,0 +1,170 @@
+import type { Scene } from '@haiyue/engine';
+import type { ParticleEmitter3DOptions } from '@haiyue/engine/components';
+import type { PbrMaterial } from '@haiyue/engine/material';
+import type { LoadedGltfModel, LoadGltfOptions } from '../../gltf/GltfLoaderContract';
+import type { Animation3DActionOptions } from '../Animation3DAction';
+import type { Animation3DBinding } from '../Animation3DBinding';
+import type { Animation3DEvent } from '../Animation3DClip';
+import type { Animation3DStateMachineDefinition } from '../Animation3DStateMachine';
+export interface HyaAnimation3DResource {
+    readonly id: string;
+    readonly type: 'image' | 'audio' | 'binary';
+    readonly uri: string;
+    readonly mimeType?: string;
+    readonly integrity?: string;
+}
+export interface HyaAnimation3DMaterialDescriptor {
+    readonly id: string;
+    readonly name: string;
+    readonly baseColorFactor: readonly [number, number, number, number];
+    readonly metallicFactor: number;
+    readonly roughnessFactor: number;
+    readonly emissiveFactor: readonly [number, number, number];
+    readonly alphaMode: 'opaque' | 'mask' | 'blend';
+    readonly alphaCutoff?: number;
+    readonly doubleSided: boolean;
+    readonly baseColorTexture?: string;
+    readonly normalTexture?: string;
+    readonly metallicRoughnessTexture?: string;
+    readonly emissiveTexture?: string;
+}
+export interface HyaAnimation3DTransformDescriptor {
+    readonly translation: readonly [number, number, number];
+    readonly rotation: readonly [number, number, number, number];
+    readonly scale: readonly [number, number, number];
+}
+export type HyaAnimation3DCameraProjection = Readonly<{
+    kind: 'perspective';
+    fovYRadians: number;
+    near: number;
+    far: number;
+}> | Readonly<{
+    kind: 'orthographic';
+    orthoHeight: number;
+    near: number;
+    far: number;
+}>;
+export type HyaAnimation3DComponentDescriptor = Readonly<{
+    id: string;
+    kind: 'camera3d';
+    projection: HyaAnimation3DCameraProjection;
+}> | Readonly<{
+    id: string;
+    kind: 'primitive3d';
+    primitive: 'box' | 'sphere' | 'plane' | 'cylinder' | 'cone';
+    materialId: string;
+}> | Readonly<{
+    id: string;
+    kind: 'model3d';
+    resource: string;
+    materialOverrides?: readonly Readonly<{
+        slot: string;
+        materialId: string;
+    }>[];
+}> | Readonly<{
+    id: string;
+    kind: 'particle3d';
+    descriptor: ParticleEmitter3DOptions & Readonly<{
+        textureResource?: string;
+    }>;
+}>;
+export interface HyaAnimation3DNodeDescriptor {
+    readonly id: string;
+    readonly name: string;
+    readonly parent?: string;
+    readonly start?: number;
+    readonly duration?: number;
+    readonly transform: HyaAnimation3DTransformDescriptor;
+    readonly components: readonly HyaAnimation3DComponentDescriptor[];
+}
+export interface HyaAnimation3DClipDescriptor {
+    readonly format: 'haiyue-animation3d-clip@1';
+    readonly id: string;
+    readonly name: string;
+    readonly duration: number;
+    readonly tracks: readonly Readonly<{
+        id: string;
+        binding: Animation3DBinding;
+        interpolation: 'step' | 'linear' | 'cubic-spline';
+        times: ArrayLike<number>;
+        values: ArrayLike<number>;
+    }>[];
+    readonly events: readonly Animation3DEvent[];
+}
+/** Runtime port implemented by the validated animation-spec payload. */
+export interface HyaAnimation3DPayload {
+    readonly format: 'haiyue-animation-3d@1';
+    readonly mode: 'native-3d';
+    readonly viewport: Readonly<{
+        width: number;
+        height: number;
+    }>;
+    readonly materials: readonly HyaAnimation3DMaterialDescriptor[];
+    readonly nodes: readonly HyaAnimation3DNodeDescriptor[];
+    readonly clips: readonly HyaAnimation3DClipDescriptor[];
+    readonly stateMachine?: Animation3DStateMachineDefinition | null;
+}
+export interface HyaAnimation3DRuntimeOptions {
+    readonly scene: Scene;
+    /** Payload returned by animation-spec native3d validation. */
+    readonly payload: HyaAnimation3DPayload;
+    readonly resources: readonly HyaAnimation3DResource[];
+    readonly signal?: AbortSignal;
+    readonly useAuthoredCamera?: boolean;
+    readonly addPreviewLights?: boolean;
+    readonly loadModel?: (uri: string, options: LoadGltfOptions) => Promise<LoadedGltfModel>;
+    readonly disposeModel?: (model: LoadedGltfModel) => void;
+    readonly resolveTexture?: (resource: HyaAnimation3DResource, material: PbrMaterial | null) => ParticleEmitter3DOptions['textureSource'] | null;
+}
+export interface HyaAnimation3DPlayOptions extends Animation3DActionOptions {
+    readonly fadeFrom?: HyaAnimation3DActionGroup;
+    readonly fadeDuration?: number;
+    readonly warp?: boolean;
+}
+export interface HyaAnimation3DActionGroup {
+    readonly id: string;
+    readonly clipId: string;
+    readonly actionCount: number;
+    readonly playing: boolean;
+    play(): this;
+    stop(): this;
+    reset(): this;
+}
+export interface HyaAnimation3DRuntimeDiagnostics {
+    readonly state: 'active' | 'destroyed';
+    readonly entityCount: number;
+    readonly materialCount: number;
+    readonly modelCount: number;
+    readonly actionGroupCount: number;
+    readonly ownerResidualCount: number;
+}
+export interface HyaAnimation3DStateMachineLayerSnapshot {
+    readonly layerId: string;
+    readonly currentStateId: string;
+    readonly currentTime: number;
+    readonly transitionId: string | null;
+    readonly sourceStateId: string | null;
+    readonly destinationStateId: string | null;
+    readonly transitionProgress: number;
+}
+/** Stable parameter/query port for the runtime's unique state-machine clock. */
+export interface HyaAnimation3DStateMachineController {
+    readonly status: 'active' | 'destroyed';
+    readonly layerSnapshots: readonly HyaAnimation3DStateMachineLayerSnapshot[];
+    getLayerSnapshot(layerId: string): HyaAnimation3DStateMachineLayerSnapshot;
+    setFloat(name: string, value: number): this;
+    setInteger(name: string, value: number): this;
+    setBoolean(name: string, value: boolean): this;
+    setTrigger(name: string): this;
+    resetTrigger(name: string): this;
+    getParameter(name: string): number | boolean;
+}
+/** Stable lifecycle and diagnostic view of the HYA state-machine owner. */
+export interface HyaAnimation3DStateMachineRuntimeControl {
+    readonly controller: HyaAnimation3DStateMachineController;
+    readonly time: number;
+    readonly liveActionCount: number;
+    readonly liveBindingCount: number;
+    readonly sideEffectOwnerCount: number;
+    reset(): void;
+}

package/dist/animation3d/hya/index.d.ts

@@ -0,0 +1,4 @@
+export { HyaAnimation3DRuntime, createHyaAnimation3DRuntime } from './HyaAnimation3DRuntime';
+export { HyaAnimation3DStateMachineRuntime, } from './HyaAnimation3DStateMachineRuntime';
+export type { HyaAnimation3DParticleCue, HyaAnimation3DStateMachinePartition, HyaAnimation3DStateMachineRuntimeOptions, } from './HyaAnimation3DStateMachineRuntime';
+export type * from './HyaAnimation3DTypes';

package/dist/animation3d/index.d.ts

@@ -0,0 +1,14 @@
+export type { Animation3DBinding, Animation3DBindingMask, Animation3DBindingResolver, Animation3DBindingTarget, Animation3DFixedValueSize, Animation3DFixedValueType, Animation3DMorphWeightsBinding, Animation3DPropertyBinding, Animation3DResolvedBinding, Animation3DRotationBinding, Animation3DScaleBinding, Animation3DTranslationBinding, Animation3DValueType, } from './Animation3DBinding.js';
+export type { Animation3DInterpolation, Animation3DTrack, Animation3DTrackFor, } from './Animation3DTrack.js';
+export type { Animation3DClip, Animation3DEvent, } from './Animation3DClip.js';
+export type { Animation3DMutablePose, Animation3DPose, Animation3DPoseChannel, Animation3DPoseEvent, } from './Animation3DPose.js';
+export { Animation3DPoseApplier } from './Animation3DPose.js';
+export { Animation3DPoseBuffer } from './Animation3DPoseBuffer.js';
+export type { Animation3DAction, Animation3DActionOptions, Animation3DActionStatus, Animation3DBlendMode, Animation3DLoopMode, } from './Animation3DAction.js';
+export { Animation3DMixer } from './Animation3DMixer.js';
+export type { Animation3DMixerState } from './Animation3DMixer.js';
+export { Animation3DError } from './Animation3DError.js';
+export type { Animation3DErrorCode, Animation3DErrorDetails, } from './Animation3DError.js';
+export type { Animation3DBlend1DChild, Animation3DBlend1DMotion, Animation3DBlend2DChild, Animation3DBlend2DMotion, Animation3DClipMotion, Animation3DMotionDefinition, Animation3DParameterDefinition, Animation3DStateDefinition, Animation3DStateMachineDefinition, Animation3DStateMachineLayer, Animation3DTransitionCondition, Animation3DTransitionDefinition, Animation3DTransitionInterruption, } from './Animation3DStateMachine.js';
+export { Animation3DStateMachineController, Animation3DStateMachineValidationError, compileAnimation3DStateMachineDefinition, validateAnimation3DStateMachineDefinition, } from './Animation3DStateMachineRuntime.js';
+export type { Animation3DCompiledStateMachine, Animation3DStateMachineClipResolver, Animation3DStateMachineControllerOptions, Animation3DStateMachineControllerStatus, Animation3DStateMachineLayerSnapshot, Animation3DStateMachineValidationCode, Animation3DStateMachineValidationIssue, } from './Animation3DStateMachineRuntime.js';

package/dist/animation3d/runtime/integration/Animation3DStateMachineMixerAdapter.d.ts

@@ -0,0 +1,81 @@
+import type { Animation3DClip } from '../../Animation3DClip.js';
+import type { Animation3DMutablePose } from '../../Animation3DPose.js';
+import type { AnimationStateMachineActionOptions, AnimationStateMachineMixerPort } from '../../../animation-state-machine/runtime/AnimationStateMachineMixerPort.js';
+import { Animation3DActionRuntime } from '../mixer/Action.js';
+import { Animation3DMixerRuntime } from '../mixer/Mixer.js';
+/**
+ * Resolves the serializable clip ids stored in state-machine definitions.
+ * Returned clips remain resolver/caller-owned.
+ */
+export interface Animation3DStateMachineClipResolver {
+    resolve(clipId: string): Animation3DClip | null;
+}
+export declare class Animation3DStateMachineActionRuntimeHandle {
+    readonly duration: number;
+    readonly clipId: string;
+    readonly layerId: string;
+    readonly stateId: string;
+    readonly action: Animation3DActionRuntime;
+    targetTime: number;
+    appliedTime: number;
+    playing: boolean;
+    destroyed: boolean;
+    pendingDestroy: boolean;
+    private readonly _actionCheckpoint;
+    private _checkpointTargetTime;
+    private _checkpointAppliedTime;
+    private _checkpointPlaying;
+    constructor(clipId: string, options: AnimationStateMachineActionOptions, action: Animation3DActionRuntime);
+    captureTransactionState(): void;
+    restoreTransactionState(): void;
+}
+/**
+ * Adapts the dimension-neutral state-machine port to the real 3D mixer.
+ *
+ * The controller owns every action playhead. The adapter applies its absolute
+ * times to actions while a synchronized mixer frame is open; it never calls
+ * mixer.update(), so the mixer clock cannot advance the same actions again.
+ */
+export declare class Animation3DStateMachineMixerAdapter implements AnimationStateMachineMixerPort<Animation3DStateMachineActionRuntimeHandle> {
+    readonly mixer: Animation3DMixerRuntime;
+    readonly clipResolver: Animation3DStateMachineClipResolver;
+    private readonly _handles;
+    private readonly _transactionHandles;
+    private readonly _transactionCreated;
+    private readonly _transactionPendingDestroy;
+    private readonly _actionIdPrefix;
+    private _nextActionId;
+    private _transactionNextActionId;
+    private _frameOut;
+    private _controllerTransactionActive;
+    private _destroyed;
+    constructor(mixer: Animation3DMixerRuntime, clipResolver: Animation3DStateMachineClipResolver);
+    get liveActionCount(): number;
+    createAction(clipId: string, options: AnimationStateMachineActionOptions): Animation3DStateMachineActionRuntimeHandle;
+    play(action: Animation3DStateMachineActionRuntimeHandle): void;
+    stop(action: Animation3DStateMachineActionRuntimeHandle): void;
+    fade(action: Animation3DStateMachineActionRuntimeHandle, _targetWeight: number, _durationSeconds: number): void;
+    setWeight(action: Animation3DStateMachineActionRuntimeHandle, weight: number): void;
+    setTime(action: Animation3DStateMachineActionRuntimeHandle, timeSeconds: number): void;
+    setTimeScale(action: Animation3DStateMachineActionRuntimeHandle, timeScale: number): void;
+    destroyAction(action: Animation3DStateMachineActionRuntimeHandle): void;
+    /** @internal Called by the shared controller transaction boundary. */
+    beginControllerTransaction(): void;
+    /** @internal Makes deferred action destruction observable atomically. */
+    commitControllerTransaction(): void;
+    /** @internal Removes new actions and restores exact event/playhead state. */
+    rollbackControllerTransaction(): void;
+    beginFrame(out: Animation3DMutablePose): void;
+    endFrame(out: Animation3DMutablePose): void;
+    cancelFrame(out: Animation3DMutablePose): void;
+    /**
+     * Releases adapter-created actions only. The mixer, clips, and clip resolver
+     * are externally owned and are never destroyed by this adapter.
+     */
+    destroy(): void;
+    private _applyTime;
+    private _destroyHandleNow;
+    private _clearControllerTransaction;
+    private _requireActive;
+    private _requireHandle;
+}

package/dist/animation3d/runtime/integration/Animation3DStateMachineMixerIntegration.d.ts

@@ -0,0 +1,39 @@
+import type { Animation3DMutablePose, Animation3DPose } from '../../Animation3DPose.js';
+import { Animation3DStateMachineController, type Animation3DStateMachineControllerOptions } from '../state-machine/Animation3DStateMachineController.js';
+import type { CompiledAnimation3DStateMachine } from '../state-machine/Animation3DStateMachineCompiler.js';
+import { Animation3DMixerRuntime } from '../mixer/Mixer.js';
+import { Animation3DStateMachineMixerAdapter, type Animation3DStateMachineActionRuntimeHandle, type Animation3DStateMachineClipResolver } from './Animation3DStateMachineMixerAdapter.js';
+export type Animation3DStateMachineMixerIntegrationState = 'active' | 'destroyed';
+/**
+ * Closed-loop runtime for a compiled state machine and the real 3D mixer.
+ *
+ * The state-machine controller is the unique playback-clock owner. A frame
+ * advances the controller once, synchronizes absolute action playheads, then
+ * asks the mixer to evaluate without advancing any action time.
+ */
+export declare class Animation3DStateMachineMixerIntegration {
+    readonly mixer: Animation3DMixerRuntime;
+    readonly adapter: Animation3DStateMachineMixerAdapter;
+    readonly controller: Animation3DStateMachineController<Animation3DStateMachineActionRuntimeHandle>;
+    private _state;
+    private _time;
+    private _transactionOut;
+    private readonly _beginControllerUpdate;
+    private readonly _completeControllerUpdate;
+    constructor(compiled: CompiledAnimation3DStateMachine, mixer: Animation3DMixerRuntime, clipResolver: Animation3DStateMachineClipResolver, controllerOptions?: Animation3DStateMachineControllerOptions);
+    get state(): Animation3DStateMachineMixerIntegrationState;
+    get time(): number;
+    update(deltaSeconds: number, out: Animation3DMutablePose): Animation3DPose;
+    /**
+     * Re-evaluates the current controller-owned time without advancing it.
+     */
+    evaluate(out: Animation3DMutablePose): Animation3DPose;
+    reset(out: Animation3DMutablePose): Animation3DPose;
+    /**
+     * Stops and removes every controller action. External mixer/clip resources
+     * remain caller-owned. Repeated calls are safe.
+     */
+    destroy(): void;
+    private _requireActive;
+    private _requireTransactionOut;
+}

package/dist/animation3d/runtime/integration/index.d.ts

@@ -0,0 +1,2 @@
+export { Animation3DStateMachineActionRuntimeHandle, Animation3DStateMachineMixerAdapter, type Animation3DStateMachineClipResolver, } from './Animation3DStateMachineMixerAdapter.js';
+export { Animation3DStateMachineMixerIntegration, type Animation3DStateMachineMixerIntegrationState, } from './Animation3DStateMachineMixerIntegration.js';

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

@@ -0,0 +1,150 @@
+import type { Animation3DBinding, Animation3DBindingMask } from '../../Animation3DBinding.js';
+import type { Animation3DAction, Animation3DActionOptions, Animation3DActionStatus, Animation3DBlendMode, Animation3DLoopMode } from '../../Animation3DAction.js';
+import type { Animation3DClip } from '../../Animation3DClip.js';
+import type { Animation3DMutablePose } from '../../Animation3DPose.js';
+import type { Animation3DTrack } from '../../Animation3DTrack.js';
+import { Animation3DTrackSampler } from './TrackSampler.js';
+export interface Animation3DActionOwner {
+    readonly time: number;
+    assertActive(): void;
+}
+export interface Animation3DActionTrackRuntime {
+    readonly track: Animation3DTrack;
+    readonly sampler: Animation3DTrackSampler;
+    readonly reference: Float32Array;
+}
+/** @internal Reusable exact state used by controller-owned frame transactions. */
+export interface Animation3DActionSynchronizedState {
+    status: Animation3DActionStatus;
+    enabled: boolean;
+    paused: boolean;
+    time: number;
+    rawTime: number;
+    timeScale: number;
+    weight: number;
+    loop: Animation3DLoopMode;
+    repetitions: number;
+    clampWhenFinished: boolean;
+    blendMode: Animation3DBlendMode;
+    mask: Animation3DBindingMask | null;
+    startTime: number | null;
+    eventsStarted: boolean;
+    fadeActive: boolean;
+    fadeStart: number;
+    fadeEnd: number;
+    fadeFrom: number;
+    fadeTo: number;
+    fadeValue: number;
+    warpActive: boolean;
+    warpStart: number;
+    warpEnd: number;
+    warpFrom: number;
+    warpTo: number;
+    warpValue: number;
+}
+/**
+ * Mutable mixer-owned playback state for one immutable clip.
+ */
+export declare class Animation3DActionRuntime implements Animation3DAction {
+    readonly id: string;
+    readonly clip: Animation3DClip;
+    readonly runtimeTracks: readonly Animation3DActionTrackRuntime[];
+    private readonly _owner;
+    private readonly _runtimeEvents;
+    private _valid;
+    private _status;
+    private _enabled;
+    private _paused;
+    private _time;
+    private _rawTime;
+    private _timeScale;
+    private _weight;
+    private _loop;
+    private _repetitions;
+    private _clampWhenFinished;
+    private _blendMode;
+    private _mask;
+    private _startTime;
+    private _eventsStarted;
+    private _fadeActive;
+    private _fadeStart;
+    private _fadeEnd;
+    private _fadeFrom;
+    private _fadeTo;
+    private _fadeValue;
+    private _warpActive;
+    private _warpStart;
+    private _warpEnd;
+    private _warpFrom;
+    private _warpTo;
+    private _warpValue;
+    constructor(owner: Animation3DActionOwner, clip: Animation3DClip, id: string, options?: Animation3DActionOptions);
+    get status(): Animation3DActionStatus;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    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 loop(): Animation3DLoopMode;
+    set loop(value: Animation3DLoopMode);
+    get repetitions(): number;
+    set repetitions(value: number);
+    get clampWhenFinished(): boolean;
+    set clampWhenFinished(value: boolean);
+    get blendMode(): Animation3DBlendMode;
+    set blendMode(value: Animation3DBlendMode);
+    get mask(): Animation3DBindingMask | null;
+    set mask(value: Animation3DBindingMask | null);
+    get effectiveTimeScale(): number;
+    get effectiveWeight(): number;
+    play(): this;
+    stop(): this;
+    reset(): this;
+    startAt(mixerTimeSeconds: number): this;
+    fadeIn(durationSeconds: number): this;
+    fadeOut(durationSeconds: number): this;
+    crossFadeFrom(source: Animation3DAction, durationSeconds: number, warp?: boolean): this;
+    crossFadeTo(destination: Animation3DAction, durationSeconds: number, warp?: boolean): this;
+    stopFading(): this;
+    acceptsBinding(binding: Animation3DBinding): boolean;
+    canContribute(): boolean;
+    /** @internal Allocated once by an integration handle and reused every frame. */
+    createSynchronizedState(): Animation3DActionSynchronizedState;
+    /** @internal Captures every field changed by controller synchronization. */
+    captureSynchronizedState(out: Animation3DActionSynchronizedState): void;
+    /** @internal Restores event cursors as well as the sampled playhead. */
+    restoreSynchronizedState(state: Animation3DActionSynchronizedState): void;
+    /**
+     * Sets an unwrapped controller-owned playhead without emitting events.
+     * Integration adapters use this for initial destination offsets before play.
+     */
+    seekSynchronizedTime(timeSeconds: number): void;
+    /**
+     * Moves to an absolute controller-owned playhead and emits every crossed
+     * clip event exactly once. This does not advance the mixer clock.
+     */
+    synchronizeTime(timeSeconds: number, out: Animation3DMutablePose): void;
+    advance(mixerDelta: number, previousMixerTime: number, currentMixerTime: number, out: Animation3DMutablePose): void;
+    invalidate(): void;
+    private _clampSynchronizedTime;
+    private _setSampleTime;
+    private _emitCrossedEvents;
+    private _emitStartingEvents;
+    private _emitOnceEvents;
+    private _emitRepeatEvents;
+    private _emitPingPongEvents;
+    private _emitPingPongTraversal;
+    private _scheduleFade;
+    private _scheduleWarp;
+    private _fadeFactor;
+    private _warpFactor;
+    private _finishTransitions;
+    private _requireSibling;
+    private _resetSamplerCursors;
+    private _assertValid;
+}

package/dist/animation3d/runtime/mixer/Animation3DMixerRuntimeStore.d.ts

@@ -0,0 +1,6 @@
+import type { Animation3DMixer } from '../../Animation3DMixer.js';
+import type { Animation3DMixerRuntime } from './Mixer.js';
+/** @internal Connects the public facade to controller-only runtime operations. */
+export declare function registerAnimation3DMixerRuntime(mixer: Animation3DMixer, runtime: Animation3DMixerRuntime): void;
+/** @internal Used only by the state-machine facade integration. */
+export declare function animation3DMixerRuntime(mixer: Animation3DMixer): Animation3DMixerRuntime;

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

@@ -0,0 +1,59 @@
+import type { Animation3DBindingResolver } from '../../Animation3DBinding.js';
+import type { Animation3DAction, Animation3DActionOptions } from '../../Animation3DAction.js';
+import type { Animation3DClip } from '../../Animation3DClip.js';
+import type { Animation3DMixerState } from '../../Animation3DMixer.js';
+import type { Animation3DMutablePose, Animation3DPose } from '../../Animation3DPose.js';
+import { type Animation3DActionOwner } from './Action.js';
+/**
+ * Contract-compatible Animation3D mixer runtime.
+ *
+ * Clips remain caller-owned immutable values. The mixer caches only samplers,
+ * blend accumulators, and resolver results; it never retains AssetHandles.
+ */
+export declare class Animation3DMixerRuntime implements Animation3DActionOwner {
+    readonly resolver: Animation3DBindingResolver;
+    private readonly _actions;
+    private readonly _actionsById;
+    private readonly _accumulators;
+    private readonly _accumulatorList;
+    private readonly _resolvedBindings;
+    private _resolverRevision;
+    private _state;
+    private _time;
+    private _timeScale;
+    private _nextActionId;
+    private _synchronizedFrameOut;
+    private _synchronizedPreviousTime;
+    constructor(resolver: Animation3DBindingResolver);
+    get state(): Animation3DMixerState;
+    get actions(): readonly Animation3DAction[];
+    get liveBindingCount(): number;
+    get time(): number;
+    get timeScale(): number;
+    set timeScale(value: number);
+    createAction(clip: Animation3DClip, options?: Animation3DActionOptions): Animation3DAction;
+    getAction(actionId: string): Animation3DAction | null;
+    removeAction(action: Animation3DAction | string): boolean;
+    stopAllActions(): this;
+    update(deltaSeconds: number, out: Animation3DMutablePose): Animation3DPose;
+    evaluate(out: Animation3DMutablePose): Animation3DPose;
+    setTime(timeSeconds: number, out: Animation3DMutablePose): Animation3DPose;
+    /**
+     * Opens an externally-clocked evaluation frame. Ordinary update/evaluate/
+     * setTime calls are rejected until the synchronized frame is closed.
+     */
+    beginSynchronizedFrame(timeSeconds: number, out: Animation3DMutablePose): void;
+    endSynchronizedFrame(out: Animation3DMutablePose): Animation3DPose;
+    cancelSynchronizedFrame(out: Animation3DMutablePose): void;
+    /** @internal Restores a completed frame when a sibling mixer in one controller transaction fails. */
+    rollbackCompletedSynchronizedFrame(timeSeconds: number): void;
+    destroy(): void;
+    assertActive(): void;
+    private _requireIndependentClock;
+    private _advanceActions;
+    private _evaluateInto;
+    private _retainBinding;
+    private _releaseBinding;
+    private _invalidateResolvedBindingsIfNeeded;
+    private _readBase;
+}

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

@@ -0,0 +1 @@
+export { Animation3DPoseBuffer } from '../../Animation3DPoseBuffer.js';

package/dist/animation3d/runtime/mixer/TrackSampler.d.ts

@@ -0,0 +1,24 @@
+import type { Animation3DTrack } from '../../Animation3DTrack.js';
+/**
+ * Stateful, allocation-free sampler for one immutable track.
+ *
+ * The sampler owns one reusable output buffer and a key cursor optimized for
+ * coherent playback. Callers may provide another destination when needed.
+ */
+export declare class Animation3DTrackSampler {
+    readonly track: Animation3DTrack;
+    readonly valueSize: number;
+    readonly output: Float32Array;
+    private _cursor;
+    constructor(track: Animation3DTrack);
+    sample(timeSeconds: number, out?: Float32Array): Float32Array;
+    resetCursor(): void;
+    private _findInterval;
+    private _copyKeyValue;
+    private _sampleLinear;
+    private _sampleQuaternionLinear;
+    private _sampleCubic;
+}
+/** @internal Shared by clip admission and direct sampler construction. */
+export declare function validateAnimation3DTrack(track: Animation3DTrack, clipDuration?: number): void;
+export declare function normalizeQuaternion(value: Float32Array): void;

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

@@ -0,0 +1,4 @@
+export { Animation3DActionRuntime, type Animation3DActionOwner, type Animation3DActionTrackRuntime, } from './Action.js';
+export { Animation3DMixerRuntime } from './Mixer.js';
+export { Animation3DPoseBuffer } from './PoseBuffer.js';
+export { Animation3DTrackSampler } from './TrackSampler.js';

package/dist/animation3d/runtime/state-machine/Animation3DBlendTreeWeights.d.ts

@@ -0,0 +1 @@
+export { evaluateAnimation3DBlend1DWeights, evaluateAnimation3DBlend2DWeights, } from '../../../animation-state-machine/runtime/AnimationStateMachineBlendTreeWeights.js';

package/dist/animation3d/runtime/state-machine/Animation3DStateMachineCompiler.d.ts

@@ -0,0 +1 @@
+export * from '../../../animation-state-machine/runtime/AnimationStateMachineCompiler.js';

package/dist/animation3d/runtime/state-machine/Animation3DStateMachineController.d.ts

@@ -0,0 +1 @@
+export * from '../../../animation-state-machine/runtime/AnimationStateMachineController.js';

package/dist/animation3d/runtime/state-machine/Animation3DStateMachineMixerPort.d.ts

@@ -0,0 +1 @@
+export * from '../../../animation-state-machine/runtime/AnimationStateMachineMixerPort.js';

package/dist/animation3d/runtime/state-machine/index.d.ts

@@ -0,0 +1,6 @@
+export { evaluateAnimation3DBlend1DWeights, evaluateAnimation3DBlend2DWeights, } from './Animation3DBlendTreeWeights.js';
+export { Animation3DStateMachineValidationError, compileAnimation3DStateMachine, compileAnimation3DStateMachineDefinition, validateAnimation3DStateMachineDefinition, } from './Animation3DStateMachineCompiler.js';
+export type { Animation3DStateMachineValidationCode, Animation3DStateMachineValidationIssue, CompiledAnimation3DBlend1DChild, CompiledAnimation3DBlend1DMotion, CompiledAnimation3DBlend2DChild, CompiledAnimation3DBlend2DMotion, CompiledAnimation3DClipMotion, CompiledAnimation3DCondition, CompiledAnimation3DConditionOperator, CompiledAnimation3DLayer, CompiledAnimation3DMotion, CompiledAnimation3DParameter, CompiledAnimation3DParameterType, CompiledAnimation3DState, CompiledAnimation3DStateMachine, CompiledAnimation3DTransition, } from './Animation3DStateMachineCompiler.js';
+export { Animation3DStateMachineController, createAnimation3DStateMachineController, } from './Animation3DStateMachineController.js';
+export type { Animation3DStateMachineControllerOptions, Animation3DStateMachineControllerStatus, Animation3DStateMachineLayerSnapshot, } from './Animation3DStateMachineController.js';
+export type { AnimationStateMachineActionHandle, AnimationStateMachineActionOptions, AnimationStateMachineMixerPort, Animation3DStateMachineActionHandle, Animation3DStateMachineActionOptions, Animation3DStateMachineMixerPort, } from './Animation3DStateMachineMixerPort.js';

package/dist/animation3d.d.ts

@@ -0,0 +1,5 @@
+/** Stable, source-independent 3D animation runtime. */
+export * from './animation3d/index.js';
+/** Stable HYA adapter for the source-independent 3D runtime. */
+export { HyaAnimation3DRuntime, createHyaAnimation3DRuntime } from './animation3d/hya/HyaAnimation3DRuntime.js';
+export type * from './animation3d/hya/HyaAnimation3DTypes.js';