@haiyue/extensions 0.1.0

package/dist/animation3d.js

@@ -0,0 +1,1708 @@
+import { A as Animation3DError, b as animation3DMixerRuntime, d as Animation3DPoseBuffer, e as Animation3DMixer, G as GltfAnimation3DRuntime } from './chunks/GltfAnimation3DAdapter-Cu3rQQsW.js';
+import { A as Animation3DStateMachineController$1, r as runAnimationStateMachineControllerUpdateTransaction, b as compileAnimation3DStateMachineDefinition$1, d as validateAnimation3DStateMachineDefinition$1, c as compileAnimationStateMachineDefinition } from './chunks/AnimationStateMachineController-BIcAh-sT.js';
+import { Entity, Mesh3D, Component, Camera3D } from '@haiyue/engine';
+import { MeshHelper, Transform3D, ParticleEmitter3D } from '@haiyue/engine/components';
+import { createCone3D, createCylinder3D, createPlane3D, createSphere3D, createBox3D } from '@haiyue/engine/geometry';
+import { AmbientLight, DirectionalLight } from '@haiyue/engine/lighting';
+import { PbrMaterial } from '@haiyue/engine/material';
+import { d as disposeGltfModel, a as loadGltfModel } from './chunks/gltfLoader-Dm22jLYB.js';
+import { c as composeTrsMatrix } from './chunks/GltfAnimationRuntime-CRHsLycN.js';
+import '@haiyue/engine/experimental/async';
+import 'wgpu-matrix';
+import '@haiyue/engine/core';
+
+const POSE_APPLIER_STATES = new WeakMap();
+/**
+ * Applies pose channels through a revision-aware binding resolver cache.
+ * Resolver misses fail explicitly and never write to a fallback target.
+ */
+class Animation3DPoseApplier {
+    constructor(resolver) {
+        POSE_APPLIER_STATES.set(this, {
+            resolver,
+            resolverRevision: Number.NaN,
+            resolvedBindings: new Map(),
+        });
+    }
+    apply(pose) {
+        const state = POSE_APPLIER_STATES.get(this);
+        const { resolver } = state;
+        if (state.resolverRevision !== resolver.revision) {
+            state.resolverRevision = resolver.revision;
+            state.resolvedBindings.clear();
+        }
+        for (let index = 0; index < pose.channels.length; index++) {
+            const channel = pose.channels[index];
+            const bindingId = channel.binding.id;
+            let resolved = state.resolvedBindings.get(bindingId);
+            if (resolved === undefined && !state.resolvedBindings.has(bindingId)) {
+                resolved = resolver.resolve(channel.binding);
+                state.resolvedBindings.set(bindingId, resolved);
+            }
+            if (!resolved) {
+                throw new Animation3DError('resolver-miss', `Animation3D binding resolver could not resolve "${bindingId}".`, { resolver: 'binding', bindingId });
+            }
+            resolved.write(channel.value);
+        }
+    }
+}
+
+let nextAdapterId = 1;
+class Animation3DStateMachineActionRuntimeHandle {
+    duration;
+    clipId;
+    layerId;
+    stateId;
+    action;
+    targetTime = 0;
+    appliedTime = 0;
+    playing = false;
+    destroyed = false;
+    pendingDestroy = false;
+    _actionCheckpoint;
+    _checkpointTargetTime = 0;
+    _checkpointAppliedTime = 0;
+    _checkpointPlaying = false;
+    constructor(clipId, options, action) {
+        this.duration = action.clip.duration;
+        this.clipId = clipId;
+        this.layerId = options.layerId;
+        this.stateId = options.stateId;
+        this.action = action;
+        this._actionCheckpoint = action.createSynchronizedState();
+    }
+    captureTransactionState() {
+        this._checkpointTargetTime = this.targetTime;
+        this._checkpointAppliedTime = this.appliedTime;
+        this._checkpointPlaying = this.playing;
+        this.action.captureSynchronizedState(this._actionCheckpoint);
+    }
+    restoreTransactionState() {
+        this.targetTime = this._checkpointTargetTime;
+        this.appliedTime = this._checkpointAppliedTime;
+        this.playing = this._checkpointPlaying;
+        this.pendingDestroy = false;
+        this.action.restoreSynchronizedState(this._actionCheckpoint);
+    }
+}
+/**
+ * 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.
+ */
+class Animation3DStateMachineMixerAdapter {
+    mixer;
+    clipResolver;
+    _handles = new Set();
+    _transactionHandles = [];
+    _transactionCreated = [];
+    _transactionPendingDestroy = [];
+    _actionIdPrefix;
+    _nextActionId = 1;
+    _transactionNextActionId = 1;
+    _frameOut = null;
+    _controllerTransactionActive = false;
+    _destroyed = false;
+    constructor(mixer, clipResolver) {
+        this.mixer = mixer;
+        this.clipResolver = clipResolver;
+        this._actionIdPrefix = `animation3d-state-machine:${nextAdapterId++}`;
+    }
+    get liveActionCount() {
+        return this._handles.size;
+    }
+    createAction(clipId, options) {
+        this._requireActive();
+        const clip = this.clipResolver.resolve(clipId);
+        if (!clip) {
+            throw new Animation3DError('resolver-miss', `Animation3D clip resolver could not resolve "${clipId}".`, { resolver: 'clip', clipId });
+        }
+        const action = this.mixer.createAction(clip, {
+            id: `${this._actionIdPrefix}:${this._nextActionId++}`,
+            loop: options.loop,
+            repetitions: options.loop === 'once' ? 1 : Infinity,
+            clampWhenFinished: true,
+            weight: 0,
+            blendMode: options.blendMode,
+            ...(options.mask ? { mask: options.mask } : {}),
+        });
+        const handle = new Animation3DStateMachineActionRuntimeHandle(clipId, options, action);
+        this._handles.add(handle);
+        if (this._controllerTransactionActive)
+            this._transactionCreated.push(handle);
+        return handle;
+    }
+    play(action) {
+        this._requireHandle(action);
+        action.action.play();
+        action.playing = true;
+    }
+    stop(action) {
+        this._requireHandle(action);
+        action.action.stop();
+        action.playing = false;
+    }
+    fade(action, _targetWeight, _durationSeconds) {
+        this._requireHandle(action);
+        // The controller computes exact source/destination weights for every
+        // transition segment. Scheduling an action-local fade here would multiply
+        // that weight and introduce a second transition clock.
+    }
+    setWeight(action, weight) {
+        this._requireHandle(action);
+        action.action.weight = weight;
+    }
+    setTime(action, timeSeconds) {
+        this._requireHandle(action);
+        action.targetTime = timeSeconds;
+        if (!action.playing) {
+            action.action.seekSynchronizedTime(timeSeconds);
+            action.appliedTime = timeSeconds;
+            return;
+        }
+        if (this._frameOut)
+            this._applyTime(action, this._frameOut);
+    }
+    setTimeScale(action, timeScale) {
+        this._requireHandle(action);
+        action.action.timeScale = timeScale;
+    }
+    destroyAction(action) {
+        if (action.destroyed)
+            return;
+        if (!this._handles.has(action)) {
+            throw new Error('Animation3D state-machine action belongs to another adapter.');
+        }
+        if (this._controllerTransactionActive) {
+            if (action.pendingDestroy)
+                return;
+            action.pendingDestroy = true;
+            this._transactionPendingDestroy.push(action);
+            return;
+        }
+        this._destroyHandleNow(action);
+    }
+    /** @internal Called by the shared controller transaction boundary. */
+    beginControllerTransaction() {
+        this._requireActive();
+        if (this._controllerTransactionActive) {
+            throw new Error('Animation3D state-machine adapter transaction is already active.');
+        }
+        this._controllerTransactionActive = true;
+        this._transactionNextActionId = this._nextActionId;
+        this._transactionHandles.length = 0;
+        this._transactionCreated.length = 0;
+        this._transactionPendingDestroy.length = 0;
+        for (const handle of this._handles) {
+            handle.captureTransactionState();
+            this._transactionHandles.push(handle);
+        }
+    }
+    /** @internal Makes deferred action destruction observable atomically. */
+    commitControllerTransaction() {
+        if (!this._controllerTransactionActive) {
+            throw new Error('Animation3D state-machine adapter has no active transaction.');
+        }
+        this._controllerTransactionActive = false;
+        for (let index = 0; index < this._transactionPendingDestroy.length; index++) {
+            this._destroyHandleNow(this._transactionPendingDestroy[index]);
+        }
+        this._clearControllerTransaction();
+    }
+    /** @internal Removes new actions and restores exact event/playhead state. */
+    rollbackControllerTransaction() {
+        if (!this._controllerTransactionActive)
+            return;
+        this._controllerTransactionActive = false;
+        for (let index = this._transactionCreated.length - 1; index >= 0; index--) {
+            this._destroyHandleNow(this._transactionCreated[index]);
+        }
+        for (let index = 0; index < this._transactionHandles.length; index++) {
+            const handle = this._transactionHandles[index];
+            if (!handle.destroyed)
+                handle.restoreTransactionState();
+        }
+        this._nextActionId = this._transactionNextActionId;
+        this._clearControllerTransaction();
+    }
+    beginFrame(out) {
+        this._requireActive();
+        if (this._frameOut) {
+            throw new Error('Animation3D state-machine adapter already has an active frame.');
+        }
+        this._frameOut = out;
+        for (const handle of this._handles) {
+            if (handle.playing)
+                this._applyTime(handle, out);
+        }
+    }
+    endFrame(out) {
+        if (this._frameOut !== out) {
+            throw new Error('Animation3D state-machine adapter output does not match its active frame.');
+        }
+        this._frameOut = null;
+    }
+    cancelFrame(out) {
+        if (this._frameOut === out)
+            this._frameOut = null;
+    }
+    /**
+     * Releases adapter-created actions only. The mixer, clips, and clip resolver
+     * are externally owned and are never destroyed by this adapter.
+     */
+    destroy() {
+        if (this._destroyed)
+            return;
+        this.rollbackControllerTransaction();
+        this._frameOut = null;
+        for (const handle of this._handles)
+            this._destroyHandleNow(handle);
+        this._destroyed = true;
+    }
+    _applyTime(handle, out) {
+        handle.action.synchronizeTime(handle.targetTime, out);
+        handle.appliedTime = handle.targetTime;
+    }
+    _destroyHandleNow(action) {
+        if (action.destroyed)
+            return;
+        if (action.playing)
+            action.action.stop();
+        this.mixer.removeAction(action.action);
+        action.playing = false;
+        action.pendingDestroy = false;
+        action.destroyed = true;
+        this._handles.delete(action);
+    }
+    _clearControllerTransaction() {
+        for (let index = 0; index < this._transactionPendingDestroy.length; index++) {
+            this._transactionPendingDestroy[index].pendingDestroy = false;
+        }
+        this._transactionHandles.length = 0;
+        this._transactionCreated.length = 0;
+        this._transactionPendingDestroy.length = 0;
+    }
+    _requireActive() {
+        if (this._destroyed) {
+            throw new Error('Animation3D state-machine mixer adapter has been destroyed.');
+        }
+    }
+    _requireHandle(handle) {
+        this._requireActive();
+        if (handle.destroyed || !this._handles.has(handle)) {
+            throw new Error('Animation3D state-machine action is no longer valid.');
+        }
+    }
+}
+
+/**
+ * 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.
+ */
+class Animation3DStateMachineMixerIntegration {
+    mixer;
+    adapter;
+    controller;
+    _state = 'active';
+    _time = 0;
+    _transactionOut = null;
+    _beginControllerUpdate = () => {
+        this.adapter.beginFrame(this._requireTransactionOut());
+    };
+    _completeControllerUpdate = () => {
+        const out = this._requireTransactionOut();
+        this.adapter.endFrame(out);
+        return this.mixer.endSynchronizedFrame(out);
+    };
+    constructor(compiled, mixer, clipResolver, controllerOptions = {}) {
+        this.mixer = mixer;
+        this.adapter = new Animation3DStateMachineMixerAdapter(mixer, clipResolver);
+        try {
+            this.controller = new Animation3DStateMachineController$1(compiled, this.adapter, controllerOptions);
+        }
+        catch (error) {
+            this.adapter.destroy();
+            this._state = 'destroyed';
+            throw error;
+        }
+    }
+    get state() {
+        return this._state;
+    }
+    get time() {
+        return this._time;
+    }
+    update(deltaSeconds, out) {
+        this._requireActive();
+        if (!Number.isFinite(deltaSeconds) || deltaSeconds < 0) {
+            throw new RangeError('Animation3D state-machine deltaSeconds must be finite and non-negative.');
+        }
+        const nextTime = this._time + deltaSeconds;
+        this.mixer.beginSynchronizedFrame(nextTime, out);
+        this._transactionOut = out;
+        try {
+            const pose = runAnimationStateMachineControllerUpdateTransaction(this.controller, deltaSeconds, this._beginControllerUpdate, this._completeControllerUpdate);
+            this._time = nextTime;
+            return pose;
+        }
+        catch (error) {
+            this.adapter.cancelFrame(out);
+            this.mixer.cancelSynchronizedFrame(out);
+            throw error;
+        }
+        finally {
+            this._transactionOut = null;
+        }
+    }
+    /**
+     * Re-evaluates the current controller-owned time without advancing it.
+     */
+    evaluate(out) {
+        this._requireActive();
+        this.mixer.beginSynchronizedFrame(this._time, out);
+        this.adapter.beginControllerTransaction();
+        try {
+            this.adapter.beginFrame(out);
+            this.adapter.endFrame(out);
+            const pose = this.mixer.endSynchronizedFrame(out);
+            this.adapter.commitControllerTransaction();
+            return pose;
+        }
+        catch (error) {
+            this.adapter.cancelFrame(out);
+            this.mixer.cancelSynchronizedFrame(out);
+            this.adapter.rollbackControllerTransaction();
+            throw error;
+        }
+    }
+    reset(out) {
+        this._requireActive();
+        this.controller.reset();
+        this._time = 0;
+        return this.evaluate(out);
+    }
+    /**
+     * Stops and removes every controller action. External mixer/clip resources
+     * remain caller-owned. Repeated calls are safe.
+     */
+    destroy() {
+        if (this._state === 'destroyed')
+            return;
+        this.controller.destroy();
+        this.adapter.destroy();
+        this._state = 'destroyed';
+    }
+    _requireActive() {
+        if (this._state !== 'active') {
+            throw new Error('Animation3D state-machine mixer integration has been destroyed.');
+        }
+    }
+    _requireTransactionOut() {
+        if (!this._transactionOut) {
+            throw new Error('Animation3D state-machine integration has no active transaction output.');
+        }
+        return this._transactionOut;
+    }
+}
+
+class Animation3DStateMachineValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super(`Invalid Animation3D state-machine definition (${issues.length} ${issues.length === 1 ? 'issue' : 'issues'}).`);
+        this.name = 'Animation3DStateMachineValidationError';
+        this.issues = Object.freeze([...issues]);
+    }
+}
+function validateAnimation3DStateMachineDefinition(definition) {
+    return validateAnimation3DStateMachineDefinition$1(definition);
+}
+function compileAnimation3DStateMachineDefinition(definition) {
+    const issues = validateAnimation3DStateMachineDefinition(definition);
+    if (issues.length > 0) {
+        throw new Animation3DStateMachineValidationError(issues);
+    }
+    return compileAnimation3DStateMachineDefinition$1(definition);
+}
+/**
+ * Public closed-loop controller and minimal Mixer integration.
+ *
+ * The internal mixer port, action handles, controller transactions and
+ * compiled nodes never cross this boundary.
+ */
+class Animation3DStateMachineController {
+    mixer;
+    #integration;
+    constructor(compiled, mixer, clipResolver, options = {}) {
+        this.mixer = mixer;
+        this.#integration = new Animation3DStateMachineMixerIntegration(compiled, animation3DMixerRuntime(mixer), clipResolver, options);
+    }
+    get status() {
+        return this.#integration.state;
+    }
+    get time() {
+        return this.#integration.time;
+    }
+    get layerSnapshots() {
+        return this.#integration.controller.layerSnapshots;
+    }
+    getLayerSnapshot(layerId) {
+        return this.#integration.controller.getLayerSnapshot(layerId);
+    }
+    setFloat(name, value) {
+        this.#integration.controller.setFloat(name, value);
+        return this;
+    }
+    setInteger(name, value) {
+        this.#integration.controller.setInteger(name, value);
+        return this;
+    }
+    setBoolean(name, value) {
+        this.#integration.controller.setBoolean(name, value);
+        return this;
+    }
+    setTrigger(name) {
+        this.#integration.controller.setTrigger(name);
+        return this;
+    }
+    resetTrigger(name) {
+        this.#integration.controller.resetTrigger(name);
+        return this;
+    }
+    getParameter(name) {
+        return this.#integration.controller.getParameter(name);
+    }
+    update(deltaSeconds, out) {
+        return this.#integration.update(deltaSeconds, out);
+    }
+    evaluate(out) {
+        return this.#integration.evaluate(out);
+    }
+    reset(out) {
+        return this.#integration.reset(out);
+    }
+    destroy() {
+        this.#integration.destroy();
+    }
+}
+
+const TIME_EPSILON = 1e-9;
+class HyaAnimation3DStateMachineActionHandle {
+    id;
+    clipId;
+    duration;
+    loop;
+    children;
+    activeCueKeys = new Set();
+    targetTime = 0;
+    traversal = 0;
+    playing = false;
+    destroyed = false;
+    pendingDestroy = false;
+    constructor(id, clipId, duration, loop, children) {
+        this.id = id;
+        this.clipId = clipId;
+        this.duration = duration;
+        this.loop = loop;
+        this.children = Object.freeze([...children]);
+    }
+}
+/**
+ * One controller-facing port spanning the scene mixer and every loaded model
+ * mixer. It is the only state-machine clock; child adapters only synchronize
+ * existing mixer actions and participate in the same rollback boundary.
+ */
+class HyaAnimation3DStateMachineMixerPort {
+    partitions;
+    _particleCues;
+    _clips = new Map();
+    _particles = new Map();
+    _owners = new Map();
+    _handles = new Set();
+    _transactionCreated = [];
+    _transactionPendingDestroy = [];
+    _transactionCheckpoints = new Map();
+    _transactionCommands = [];
+    _transactionOwners = new Map();
+    _nextHandleId = 1;
+    _transactionNextHandleId = 1;
+    _transactionActive = false;
+    _destroyed = false;
+    constructor(partitions, clips, _particleCues) {
+        this.partitions = partitions;
+        this._particleCues = _particleCues;
+        for (const clip of clips)
+            this._clips.set(clip.id, clip);
+        for (const cues of _particleCues.values()) {
+            for (const cue of cues)
+                this._particles.set(cue.key, cue.emitter);
+        }
+    }
+    get liveActionCount() { return this._handles.size; }
+    get sideEffectOwnerCount() {
+        let count = 0;
+        for (const owners of this._owners.values())
+            count += owners.length;
+        return count;
+    }
+    createAction(clipId, options) {
+        this._requireActive();
+        const clip = this._clips.get(clipId);
+        if (!clip)
+            throw new RangeError(`Unknown HYA Animation3D state-machine clip "${clipId}".`);
+        const children = [];
+        try {
+            for (const partition of this.partitions) {
+                if (partition.clips.has(clipId)) {
+                    children.push(partition.adapter.createAction(clipId, translateActionOptions(options, partition.bindingIds)));
+                }
+            }
+        }
+        catch (error) {
+            let childIndex = 0;
+            for (const partition of this.partitions) {
+                if (!partition.clips.has(clipId) || childIndex >= children.length)
+                    continue;
+                partition.adapter.destroyAction(children[childIndex++]);
+            }
+            throw error;
+        }
+        const handle = new HyaAnimation3DStateMachineActionHandle(`hya-animation3d-state-machine:${this._nextHandleId++}`, clipId, clip.duration, options.loop, children);
+        this._handles.add(handle);
+        if (this._transactionActive)
+            this._transactionCreated.push(handle);
+        return handle;
+    }
+    play(handle) {
+        this._requireHandle(handle);
+        forEachChild(this.partitions, handle, (adapter, child) => adapter.play(child));
+        if (handle.playing)
+            return;
+        handle.playing = true;
+        this._syncParticleCues(handle, true);
+    }
+    stop(handle) {
+        this._requireHandle(handle);
+        forEachChild(this.partitions, handle, (adapter, child) => adapter.stop(child));
+        if (!handle.playing)
+            return;
+        handle.playing = false;
+        this._releaseAllParticleCues(handle);
+    }
+    fade(handle, targetWeight, durationSeconds) {
+        this._requireHandle(handle);
+        forEachChild(this.partitions, handle, (adapter, child) => adapter.fade(child, targetWeight, durationSeconds));
+    }
+    setWeight(handle, weight) {
+        this._requireHandle(handle);
+        forEachChild(this.partitions, handle, (adapter, child) => adapter.setWeight(child, weight));
+    }
+    setTime(handle, timeSeconds) {
+        this._requireHandle(handle);
+        forEachChild(this.partitions, handle, (adapter, child) => adapter.setTime(child, timeSeconds));
+        const previousTraversal = handle.traversal;
+        const position = playbackPosition(timeSeconds, handle.duration, handle.loop);
+        handle.targetTime = timeSeconds;
+        handle.traversal = position.traversal;
+        if (!handle.playing)
+            return;
+        this._syncParticleCues(handle, false, position.localTime);
+        if (position.traversal !== previousTraversal)
+            this._restartDominantParticleCues(handle);
+    }
+    setTimeScale(handle, timeScale) {
+        this._requireHandle(handle);
+        forEachChild(this.partitions, handle, (adapter, child) => adapter.setTimeScale(child, timeScale));
+    }
+    destroyAction(handle) {
+        if (handle.destroyed)
+            return;
+        this._requireHandle(handle);
+        if (handle.playing) {
+            handle.playing = false;
+            this._releaseAllParticleCues(handle);
+        }
+        forEachChild(this.partitions, handle, (adapter, child) => adapter.destroyAction(child));
+        if (this._transactionActive) {
+            if (!handle.pendingDestroy) {
+                handle.pendingDestroy = true;
+                this._transactionPendingDestroy.push(handle);
+            }
+            return;
+        }
+        this._destroyGroupNow(handle);
+    }
+    beginControllerTransaction() {
+        this._requireActive();
+        if (this._transactionActive)
+            throw new Error('HYA Animation3D state-machine transaction is already active.');
+        this._transactionActive = true;
+        this._transactionCreated.length = 0;
+        this._transactionPendingDestroy.length = 0;
+        this._transactionCheckpoints.clear();
+        this._transactionCommands.length = 0;
+        this._transactionOwners = cloneOwners(this._owners);
+        this._transactionNextHandleId = this._nextHandleId;
+        for (const handle of this._handles) {
+            this._transactionCheckpoints.set(handle, {
+                targetTime: handle.targetTime,
+                traversal: handle.traversal,
+                playing: handle.playing,
+                activeCueKeys: new Set(handle.activeCueKeys),
+            });
+        }
+        const begun = [];
+        try {
+            for (const partition of this.partitions) {
+                partition.adapter.beginControllerTransaction();
+                begun.push(partition.adapter);
+            }
+        }
+        catch (error) {
+            for (let index = begun.length - 1; index >= 0; index--)
+                begun[index].rollbackControllerTransaction();
+            this._transactionActive = false;
+            this._clearTransaction();
+            throw error;
+        }
+    }
+    commitControllerTransaction() {
+        if (!this._transactionActive)
+            throw new Error('HYA Animation3D state-machine has no active transaction.');
+        for (const partition of this.partitions)
+            partition.adapter.commitControllerTransaction();
+        this._transactionActive = false;
+        for (const command of this._transactionCommands)
+            this._applyParticleCommand(command);
+        for (const handle of this._transactionPendingDestroy)
+            this._destroyGroupNow(handle);
+        this._clearTransaction();
+    }
+    rollbackControllerTransaction() {
+        if (!this._transactionActive)
+            return;
+        this._transactionActive = false;
+        for (let index = this.partitions.length - 1; index >= 0; index--) {
+            this.partitions[index].adapter.rollbackControllerTransaction();
+        }
+        for (const handle of this._transactionCreated) {
+            handle.destroyed = true;
+            this._handles.delete(handle);
+        }
+        for (const [handle, checkpoint] of this._transactionCheckpoints) {
+            if (handle.destroyed)
+                continue;
+            handle.targetTime = checkpoint.targetTime;
+            handle.traversal = checkpoint.traversal;
+            handle.playing = checkpoint.playing;
+            handle.pendingDestroy = false;
+            handle.activeCueKeys.clear();
+            for (const key of checkpoint.activeCueKeys)
+                handle.activeCueKeys.add(key);
+        }
+        this._owners.clear();
+        for (const [key, owners] of this._transactionOwners)
+            this._owners.set(key, [...owners]);
+        this._nextHandleId = this._transactionNextHandleId;
+        this._clearTransaction();
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this.rollbackControllerTransaction();
+        for (const handle of [...this._handles]) {
+            if (handle.playing)
+                this.stop(handle);
+            forEachChild(this.partitions, handle, (adapter, child) => adapter.destroyAction(child));
+            this._destroyGroupNow(handle);
+        }
+        for (const partition of this.partitions)
+            partition.adapter.destroy();
+        for (const emitter of this._particles.values())
+            stopParticle(emitter);
+        this._owners.clear();
+        this._destroyed = true;
+    }
+    _syncParticleCues(handle, entering, localTime = playbackPosition(handle.targetTime, handle.duration, handle.loop).localTime) {
+        for (const cue of this._particleCues.get(handle.clipId) ?? []) {
+            const active = particleCueActive(cue, localTime, handle.duration);
+            const owned = handle.activeCueKeys.has(cue.key);
+            if (active && !owned)
+                this._acquireParticleCue(handle, cue);
+            else if (!active && owned)
+                this._releaseParticleCue(handle, cue.key);
+            else if (entering && active && owned)
+                this._recordParticleCommand({ key: cue.key, kind: 'start' });
+        }
+    }
+    _acquireParticleCue(handle, cue) {
+        handle.activeCueKeys.add(cue.key);
+        const owners = this._owners.get(cue.key) ?? [];
+        if (!this._owners.has(cue.key))
+            this._owners.set(cue.key, owners);
+        const existing = owners.indexOf(handle.id);
+        if (existing >= 0)
+            owners.splice(existing, 1);
+        owners.push(handle.id);
+        this._recordParticleCommand({ key: cue.key, kind: 'start' });
+    }
+    _releaseParticleCue(handle, key) {
+        handle.activeCueKeys.delete(key);
+        const owners = this._owners.get(key);
+        if (!owners)
+            return;
+        const index = owners.indexOf(handle.id);
+        const wasDominant = index === owners.length - 1;
+        if (index >= 0)
+            owners.splice(index, 1);
+        if (owners.length === 0) {
+            this._owners.delete(key);
+            this._recordParticleCommand({ key, kind: 'stop' });
+        }
+        else if (wasDominant)
+            this._recordParticleCommand({ key, kind: 'start' });
+    }
+    _releaseAllParticleCues(handle) {
+        for (const key of [...handle.activeCueKeys])
+            this._releaseParticleCue(handle, key);
+    }
+    _restartDominantParticleCues(handle) {
+        for (const key of handle.activeCueKeys) {
+            const owners = this._owners.get(key);
+            if (owners?.[owners.length - 1] === handle.id)
+                this._recordParticleCommand({ key, kind: 'start' });
+        }
+    }
+    _recordParticleCommand(command) {
+        if (this._transactionActive)
+            this._transactionCommands.push(command);
+        else
+            this._applyParticleCommand(command);
+    }
+    _applyParticleCommand(command) {
+        const emitter = this._particles.get(command.key);
+        if (!emitter)
+            return;
+        if (command.kind === 'stop')
+            stopParticle(emitter);
+        else {
+            emitter.emitting = true;
+            emitter.restart(true);
+            emitter.playing = true;
+        }
+    }
+    _destroyGroupNow(handle) {
+        handle.playing = false;
+        handle.pendingDestroy = false;
+        handle.destroyed = true;
+        handle.activeCueKeys.clear();
+        this._handles.delete(handle);
+    }
+    _clearTransaction() {
+        this._transactionCreated.length = 0;
+        this._transactionPendingDestroy.length = 0;
+        this._transactionCheckpoints.clear();
+        this._transactionCommands.length = 0;
+        this._transactionOwners.clear();
+    }
+    _requireHandle(handle) {
+        this._requireActive();
+        if (handle.destroyed || !this._handles.has(handle)) {
+            throw new Error('HYA Animation3D state-machine action is no longer valid.');
+        }
+    }
+    _requireActive() {
+        if (this._destroyed)
+            throw new Error('HYA Animation3D state-machine mixer port has been destroyed.');
+    }
+}
+/** Coordinates native scene, glTF model and Particle3D channels with one controller transaction. */
+class HyaAnimation3DStateMachineRuntime {
+    controller;
+    _partitions;
+    _port;
+    _time = 0;
+    _destroyed = false;
+    constructor(options) {
+        this._partitions = Object.freeze(options.partitions.map(partition => {
+            const resolver = { resolve: (clipId) => partition.clips.get(clipId) ?? null };
+            return {
+                id: partition.id,
+                mixer: partition.mixer,
+                adapter: new Animation3DStateMachineMixerAdapter(partition.mixer, resolver),
+                clips: partition.clips,
+                bindingIds: partition.bindingIds,
+                pose: partition.pose ?? new Animation3DPoseBuffer(),
+                apply: partition.apply,
+                previousTime: 0,
+                frameCompleted: false,
+            };
+        }));
+        this._port = new HyaAnimation3DStateMachineMixerPort(this._partitions, options.clips, options.particleCues ?? new Map());
+        try {
+            this.controller = new Animation3DStateMachineController$1(compileAnimationStateMachineDefinition(options.definition), this._port);
+            this.evaluate();
+        }
+        catch (error) {
+            this.controller?.destroy();
+            this._port.destroy();
+            this._destroyed = true;
+            throw error;
+        }
+    }
+    get time() { return this._time; }
+    get liveActionCount() { return this._port.liveActionCount; }
+    get liveBindingCount() {
+        let count = 0;
+        for (const partition of this._partitions)
+            count += partition.mixer.liveBindingCount;
+        return count;
+    }
+    get sideEffectOwnerCount() { return this._port.sideEffectOwnerCount; }
+    update(deltaSeconds) {
+        this._requireActive();
+        if (!Number.isFinite(deltaSeconds) || deltaSeconds < 0) {
+            throw new RangeError('HYA Animation3D state-machine deltaSeconds must be finite and non-negative.');
+        }
+        this._runFrame(deltaSeconds);
+    }
+    evaluate() {
+        this._requireActive();
+        this._runFrame(0);
+    }
+    reset() {
+        this._requireActive();
+        this.controller.reset();
+        this._time = 0;
+        this.evaluate();
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this.controller.destroy();
+        this._port.destroy();
+        this._destroyed = true;
+    }
+    _runFrame(deltaSeconds) {
+        const nextTime = this._time + deltaSeconds;
+        this._openFrames(nextTime);
+        let poses;
+        try {
+            poses = runAnimationStateMachineControllerUpdateTransaction(this.controller, deltaSeconds, () => {
+                for (const partition of this._partitions)
+                    partition.adapter.beginFrame(partition.pose);
+            }, () => {
+                for (const partition of this._partitions)
+                    partition.adapter.endFrame(partition.pose);
+                const result = [];
+                for (const partition of this._partitions) {
+                    result.push(partition.mixer.endSynchronizedFrame(partition.pose));
+                    partition.frameCompleted = true;
+                }
+                return result;
+            });
+        }
+        catch (error) {
+            this._cancelFrames();
+            throw error;
+        }
+        for (const partition of this._partitions)
+            partition.frameCompleted = false;
+        this._time = nextTime;
+        for (let index = 0; index < this._partitions.length; index++) {
+            this._partitions[index].apply(poses[index]);
+        }
+    }
+    _openFrames(time) {
+        const opened = [];
+        try {
+            for (const partition of this._partitions) {
+                partition.previousTime = partition.mixer.time;
+                partition.frameCompleted = false;
+                partition.mixer.beginSynchronizedFrame(time, partition.pose);
+                opened.push(partition);
+            }
+        }
+        catch (error) {
+            for (let index = opened.length - 1; index >= 0; index--) {
+                opened[index].mixer.cancelSynchronizedFrame(opened[index].pose);
+            }
+            throw error;
+        }
+    }
+    _cancelFrames() {
+        for (const partition of this._partitions)
+            partition.adapter.cancelFrame(partition.pose);
+        for (let index = this._partitions.length - 1; index >= 0; index--) {
+            const partition = this._partitions[index];
+            if (partition.frameCompleted) {
+                partition.mixer.rollbackCompletedSynchronizedFrame(partition.previousTime);
+                partition.frameCompleted = false;
+            }
+            else
+                partition.mixer.cancelSynchronizedFrame(partition.pose);
+        }
+    }
+    _requireActive() {
+        if (this._destroyed)
+            throw new Error('HYA Animation3D state-machine runtime has been destroyed.');
+    }
+}
+function forEachChild(partitions, handle, visit) {
+    let childIndex = 0;
+    for (const partition of partitions) {
+        if (!partition.clips.has(handle.clipId))
+            continue;
+        visit(partition.adapter, handle.children[childIndex++]);
+    }
+}
+function cloneOwners(source) {
+    const result = new Map();
+    for (const [key, owners] of source)
+        result.set(key, [...owners]);
+    return result;
+}
+function translateActionOptions(options, bindingIds) {
+    if (!options.mask || !bindingIds || bindingIds.size === 0)
+        return options;
+    const translate = (ids) => {
+        if (!ids)
+            return undefined;
+        return Object.freeze(ids.map(id => bindingIds.get(id) ?? id));
+    };
+    const include = translate(options.mask.include);
+    const exclude = translate(options.mask.exclude);
+    return {
+        ...options,
+        mask: Object.freeze({
+            ...(include === undefined ? {} : { include }),
+            ...(exclude === undefined ? {} : { exclude }),
+        }),
+    };
+}
+function playbackPosition(time, duration, loop) {
+    if (duration <= TIME_EPSILON || loop === 'once') {
+        return { localTime: Math.min(duration, Math.max(0, time)), traversal: 0 };
+    }
+    const traversal = Math.floor(time / duration);
+    let localTime = time - traversal * duration;
+    if (localTime < 0)
+        localTime += duration;
+    if (loop === 'ping-pong' && Math.abs(traversal % 2) === 1)
+        localTime = duration - localTime;
+    return { localTime, traversal };
+}
+function particleCueActive(cue, time, duration) {
+    const atTerminalEnd = Math.abs(cue.end - duration) <= TIME_EPSILON
+        && Math.abs(time - duration) <= TIME_EPSILON;
+    return time >= cue.start - TIME_EPSILON
+        && (time < cue.end - TIME_EPSILON || atTerminalEnd);
+}
+function stopParticle(emitter) {
+    emitter.playing = false;
+    emitter.emitting = false;
+    emitter.clear();
+}
+
+class HyaAnimation3DResolvedEndpoint {
+    binding;
+    _read;
+    _write;
+    constructor(binding, _read, _write) {
+        this.binding = binding;
+        this._read = _read;
+        this._write = _write;
+    }
+    read(out) { this._read(out); }
+    write(value) { this._write(value); }
+}
+class HyaAnimation3DBindingResolver {
+    _endpoints = new Map();
+    _revision = 0;
+    _destroyed = false;
+    get revision() { return this._revision; }
+    get size() { return this._endpoints.size; }
+    add(endpoint) {
+        if (this._destroyed)
+            throw new Error('HYA Animation3D resolver is destroyed.');
+        this._endpoints.set(endpoint.binding.id, endpoint);
+        this._revision++;
+    }
+    resolve(binding) {
+        if (this._destroyed)
+            return null;
+        const endpoint = this._endpoints.get(binding.id);
+        if (!endpoint || endpoint.binding.path !== binding.path
+            || endpoint.binding.valueType !== binding.valueType
+            || endpoint.binding.valueSize !== binding.valueSize)
+            return null;
+        return endpoint;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._endpoints.clear();
+        this._revision++;
+    }
+}
+class HyaAnimation3DRuntimeOwner extends Component {
+    _runtime = null;
+    constructor() { super('HyaAnimation3DRuntimeOwner'); }
+    attach(runtime) { this._runtime = runtime; }
+    release(runtime) { if (this._runtime === runtime)
+        this._runtime = null; }
+    clone() { return new HyaAnimation3DRuntimeOwner(); }
+    destroy() {
+        if (this.destroyed)
+            return;
+        const runtime = this._runtime;
+        this._runtime = null;
+        runtime?.destroy();
+        super.destroy();
+    }
+}
+class HyaAnimation3DActionGroupImpl {
+    id;
+    clipId;
+    entries;
+    constructor(id, clipId, entries) {
+        this.id = id;
+        this.clipId = clipId;
+        this.entries = entries;
+    }
+    get actionCount() { return this.entries.length; }
+    get playing() {
+        return this.entries.some(entry => entry.owner.state === 'active'
+            && (entry.action.status === 'running' || entry.action.status === 'scheduled'));
+    }
+    play() { for (const entry of this.entries)
+        if (entry.owner.state === 'active')
+            entry.action.play(); return this; }
+    stop() { for (const entry of this.entries)
+        if (entry.owner.state === 'active')
+            entry.action.stop(); return this; }
+    reset() { for (const entry of this.entries)
+        if (entry.owner.state === 'active')
+            entry.action.reset(); return this; }
+}
+/**
+ * Optional native-3D HYA owner. The caller must pass an already validated
+ * animation-spec payload; no ECS/GPU object is allocated by the parser.
+ */
+class HyaAnimation3DRuntime {
+    root = new Entity('HYA Native 3D');
+    mixer;
+    pose = new Animation3DPoseBuffer();
+    _scene;
+    _payload;
+    _clips;
+    _resources;
+    _entities = new Map();
+    _transforms = new Map();
+    _materials = new Map();
+    _cameras = new Map();
+    _models = [];
+    _mainClips = new Map();
+    _modelClips = new Map();
+    _modelBindingIds = new Map();
+    _actionGroups = new Map();
+    _resolver = new HyaAnimation3DBindingResolver();
+    _poseApplier;
+    _owner = new HyaAnimation3DRuntimeOwner();
+    _geometries = new Set();
+    _particles = [];
+    _abortController = new AbortController();
+    _externalSignal;
+    _externalAbortListener;
+    _disposeModel;
+    _state = 'active';
+    _initialized = false;
+    _stateMachine = null;
+    constructor(options) {
+        this._scene = options.scene;
+        this._payload = options.payload;
+        this._clips = Object.freeze(options.payload.clips.map(lowerRuntimeClip));
+        this._resources = new Map(options.resources.map(resource => [resource.id, resource]));
+        this._disposeModel = options.disposeModel ?? disposeGltfModel;
+        this.mixer = new Animation3DMixer(this._resolver);
+        this._poseApplier = new Animation3DPoseApplier(this._resolver);
+        this._owner.attach(this);
+        this.root.addComponent(this._owner);
+        this._externalSignal = options.signal ?? null;
+        this._externalAbortListener = this._externalSignal ? () => this.destroy() : null;
+        this._externalSignal?.addEventListener('abort', this._externalAbortListener, { once: true });
+    }
+    static async create(options) {
+        if (options.signal?.aborted)
+            throw abortError(options.signal.reason);
+        const runtime = new HyaAnimation3DRuntime(options);
+        try {
+            await runtime._initialize(options);
+            return runtime;
+        }
+        catch (error) {
+            runtime.destroy();
+            throw error;
+        }
+    }
+    get state() { return this._state; }
+    get initialized() { return this._initialized; }
+    get clips() { return this._clips; }
+    get authoredCameraIds() { return Object.freeze([...this._cameras.keys()]); }
+    get stateMachine() { return this._stateMachine; }
+    getEntity(nodeId) { return this._entities.get(nodeId) ?? null; }
+    getMaterial(materialId) { return this._materials.get(materialId) ?? null; }
+    getModelAnimationClips(nodeId) {
+        return this._models.find(model => model.nodeId === nodeId)?.runtime.clips ?? Object.freeze([]);
+    }
+    select(nodeIds) {
+        const selected = new Set(nodeIds);
+        for (const [id, entity] of this._entities) {
+            if (selected.has(id))
+                entity.addComponent(new MeshHelper({ mode: 'aabb', color: [0.25, 0.75, 1, 1], lineWidth: 1.5 }));
+            else
+                entity.removeComponent(MeshHelper);
+        }
+    }
+    useAuthoredCamera(nodeId) {
+        this._assertActive();
+        const entity = this._entities.get(nodeId);
+        if (!entity || !this._cameras.has(nodeId))
+            throw new RangeError(`Unknown authored camera node "${nodeId}".`);
+        this._scene.setCamera(entity);
+    }
+    playClip(clipId, options = {}) {
+        this._assertActive();
+        if (this._stateMachine) {
+            throw new Error('Manual HYA Animation3D clip actions are unavailable while the built-in state machine owns the mixers.');
+        }
+        const base = this._clips.find(clip => clip.id === clipId);
+        if (!base)
+            throw new RangeError(`Unknown HYA Animation3D clip "${clipId}".`);
+        const groupId = options.id ?? `${clipId}:action:${this._actionGroups.size}`;
+        if (this._actionGroups.has(groupId))
+            throw new RangeError(`HYA Animation3D action group "${groupId}" already exists.`);
+        const entries = [];
+        const actionOptions = withoutGroupOptions(options);
+        const main = this._mainClips.get(clipId);
+        if (main)
+            entries.push({ owner: this.mixer, action: this.mixer.createAction(main, { ...actionOptions, id: `${groupId}:scene` }) });
+        for (const [model, clip] of this._modelClips.get(clipId) ?? []) {
+            entries.push({ owner: model.runtime.mixer, action: model.runtime.mixer.createAction(clip, { ...actionOptions, id: `${groupId}:${model.componentId}` }) });
+        }
+        const group = new HyaAnimation3DActionGroupImpl(groupId, clipId, entries);
+        if (options.fadeFrom) {
+            const source = options.fadeFrom;
+            const duration = options.fadeDuration ?? 0;
+            for (const entry of entries) {
+                const sourceEntry = source.entries.find(candidate => candidate.owner === entry.owner);
+                if (sourceEntry)
+                    entry.action.crossFadeFrom(sourceEntry.action, duration, options.warp ?? false);
+                else
+                    entry.action.fadeIn(duration).play();
+            }
+        }
+        else
+            group.play();
+        this._actionGroups.set(groupId, group);
+        return group;
+    }
+    removeActionGroup(group) {
+        const id = typeof group === 'string' ? group : group.id;
+        const target = this._actionGroups.get(id);
+        if (!target)
+            return false;
+        for (const entry of target.entries) {
+            if (entry.owner.state !== 'active')
+                continue;
+            entry.action.stop();
+            entry.owner.removeAction(entry.action);
+        }
+        this._actionGroups.delete(id);
+        return true;
+    }
+    update(deltaSeconds) {
+        this._assertActive();
+        if (this._stateMachine) {
+            this._stateMachine.update(deltaSeconds);
+            return;
+        }
+        this._poseApplier.apply(this.mixer.update(deltaSeconds, this.pose));
+        for (const model of this._models)
+            model.runtime.update(deltaSeconds);
+    }
+    setTime(timeSeconds) {
+        this._assertActive();
+        if (this._stateMachine) {
+            throw new Error('HYA Animation3D setTime() is unavailable while the built-in state machine owns the playhead.');
+        }
+        this._poseApplier.apply(this.mixer.setTime(timeSeconds, this.pose));
+        for (const model of this._models)
+            model.runtime.setTime(timeSeconds);
+    }
+    diagnostics() {
+        const residual = this._state === 'destroyed'
+            ? this._entities.size + this._materials.size + this._models.length + this._actionGroups.size + this._resolver.size
+            : 0;
+        return Object.freeze({
+            state: this._state,
+            entityCount: this._entities.size,
+            materialCount: this._materials.size,
+            modelCount: this._models.length,
+            actionGroupCount: this._actionGroups.size,
+            ownerResidualCount: residual,
+        });
+    }
+    destroy() {
+        if (this._state === 'destroyed')
+            return;
+        this._state = 'destroyed';
+        if (this._externalSignal && this._externalAbortListener)
+            this._externalSignal.removeEventListener('abort', this._externalAbortListener);
+        this._stateMachine?.destroy();
+        this._stateMachine = null;
+        for (const id of [...this._actionGroups.keys()])
+            this.removeActionGroup(id);
+        this._abortController.abort('hya-animation3d-runtime-destroyed');
+        this.mixer.destroy();
+        this._resolver.destroy();
+        for (const model of this._models.splice(0)) {
+            model.runtime.destroy();
+            if (!model.model.root.destroyed)
+                this._disposeModel(model.model);
+        }
+        this._owner.release(this);
+        if (!this.root.destroyed)
+            this.root.destroy();
+        this._entities.clear();
+        this._transforms.clear();
+        this._materials.clear();
+        this._cameras.clear();
+        this._mainClips.clear();
+        this._modelClips.clear();
+        this._modelBindingIds.clear();
+        this._particles.length = 0;
+        this._geometries.clear();
+    }
+    async _initialize(options) {
+        this._createMaterials();
+        this._createNodes(options);
+        this._attachHierarchy();
+        this._scene.add(this.root);
+        if (options.addPreviewLights !== false)
+            this._addPreviewLights();
+        await this._loadModels(options);
+        this._buildClipPartitions();
+        this._createStateMachineRuntime();
+        const authoredCamera = this._cameras.keys().next().value;
+        if (options.useAuthoredCamera !== false && authoredCamera)
+            this.useAuthoredCamera(authoredCamera);
+        this._initialized = true;
+    }
+    _createMaterials() {
+        for (const descriptor of this._payload.materials) {
+            this._materials.set(descriptor.id, materialFromDescriptor(descriptor));
+        }
+    }
+    _createNodes(options) {
+        for (const descriptor of this._payload.nodes) {
+            const entity = new Entity(descriptor.name || descriptor.id);
+            const transform = new Transform3D();
+            const state = {
+                transform,
+                translation: new Float32Array(descriptor.transform.translation),
+                rotation: new Float32Array(descriptor.transform.rotation),
+                scale: new Float32Array(descriptor.transform.scale),
+                matrix: new Float32Array(16),
+            };
+            commitTransform(state);
+            entity.addComponent(transform);
+            this._entities.set(descriptor.id, entity);
+            this._transforms.set(descriptor.id, state);
+            for (const component of descriptor.components)
+                this._createComponent(descriptor, entity, component, options);
+        }
+    }
+    _createComponent(node, entity, component, options) {
+        if (component.kind === 'camera3d') {
+            const camera = cameraFromProjection(component.projection, this._payload.viewport.width / this._payload.viewport.height);
+            entity.addComponent(camera);
+            this._cameras.set(node.id, camera);
+            return;
+        }
+        if (component.kind === 'primitive3d') {
+            const geometry = primitiveGeometry(component.primitive);
+            this._geometries.add(geometry);
+            entity.addComponent(new Mesh3D(geometry, required(this._materials, component.materialId, 'material')));
+            return;
+        }
+        if (component.kind === 'particle3d') {
+            const { textureResource, ...descriptor } = component.descriptor;
+            const resource = textureResource ? required(this._resources, textureResource, 'particle texture') : undefined;
+            const textureSource = resource ? options.resolveTexture?.(resource, null) ?? null : null;
+            const emitter = new ParticleEmitter3D({
+                ...descriptor,
+                ...(textureSource ? { textureSource } : {}),
+                ...(this._payload.stateMachine ? { playing: false, emitting: false } : {}),
+            });
+            entity.addComponent(emitter);
+            this._particles.push({
+                key: `${node.id}\u0000${component.id}`,
+                node,
+                componentId: component.id,
+                emitter,
+            });
+        }
+    }
+    _attachHierarchy() {
+        for (const descriptor of this._payload.nodes) {
+            const entity = required(this._entities, descriptor.id, 'node');
+            if (descriptor.parent)
+                required(this._entities, descriptor.parent, 'parent node').addChild(entity);
+            else
+                this.root.addChild(entity);
+        }
+    }
+    async _loadModels(options) {
+        const loader = options.loadModel ?? loadGltfModel;
+        const tasks = [];
+        for (const node of this._payload.nodes) {
+            for (const component of node.components) {
+                if (component.kind !== 'model3d')
+                    continue;
+                tasks.push((async () => {
+                    const resource = required(this._resources, component.resource, 'model resource');
+                    const model = await loader(resource.uri, { signal: this._abortController.signal });
+                    if (this._state !== 'active') {
+                        if (!model.root.destroyed)
+                            this._disposeModel(model);
+                        throw abortError('runtime-destroyed-during-model-load');
+                    }
+                    const entity = required(this._entities, node.id, 'model node');
+                    entity.addChild(model.root);
+                    applyMaterialOverrides(model.root, component.materialOverrides ?? [], this._materials);
+                    const runtime = new GltfAnimation3DRuntime(model, {
+                        signal: this._abortController.signal,
+                        clipIdPrefix: `hya:${component.id}`,
+                    });
+                    this._models.push({ nodeId: node.id, componentId: component.id, model, runtime });
+                })());
+            }
+        }
+        await Promise.all(tasks);
+    }
+    _buildClipPartitions() {
+        for (const clip of this._clips) {
+            const mainTracks = [];
+            const modelTracks = new Map();
+            for (const track of clip.tracks) {
+                const endpoint = this._createSceneEndpoint(track.binding);
+                if (endpoint) {
+                    this._resolver.add(endpoint);
+                    mainTracks.push(track);
+                    continue;
+                }
+                const modelMatch = this._matchModelBinding(track);
+                if (modelMatch) {
+                    let tracks = modelTracks.get(modelMatch.model);
+                    if (!tracks) {
+                        tracks = [];
+                        modelTracks.set(modelMatch.model, tracks);
+                    }
+                    tracks.push({ ...track, binding: modelMatch.binding });
+                    let bindingIds = this._modelBindingIds.get(modelMatch.model);
+                    if (!bindingIds) {
+                        bindingIds = new Map();
+                        this._modelBindingIds.set(modelMatch.model, bindingIds);
+                    }
+                    bindingIds.set(track.binding.id, modelMatch.binding.id);
+                    continue;
+                }
+                throw new RangeError(`HYA Animation3D binding "${track.binding.id}" cannot be resolved.`);
+            }
+            if (mainTracks.length > 0 || this._payload.stateMachine) {
+                this._mainClips.set(clip.id, { ...clip, tracks: Object.freeze(mainTracks) });
+            }
+            const byModel = new Map();
+            for (const [model, tracks] of modelTracks)
+                byModel.set(model, { ...clip, id: `${clip.id}:${model.componentId}`, tracks: Object.freeze(tracks) });
+            this._modelClips.set(clip.id, byModel);
+        }
+    }
+    _createStateMachineRuntime() {
+        const definition = this._payload.stateMachine;
+        if (!definition)
+            return;
+        const partitions = [{
+                id: 'scene',
+                mixer: animation3DMixerRuntime(this.mixer),
+                clips: this._mainClips,
+                pose: this.pose,
+                apply: pose => this._poseApplier.apply(pose),
+            }];
+        for (const model of this._models) {
+            const clips = new Map();
+            for (const [clipId, byModel] of this._modelClips) {
+                const clip = byModel.get(model);
+                if (clip)
+                    clips.set(clipId, clip);
+            }
+            if (clips.size === 0)
+                continue;
+            partitions.push({
+                id: `model:${model.nodeId}:${model.componentId}`,
+                mixer: animation3DMixerRuntime(model.runtime.mixer),
+                clips,
+                ...(this._modelBindingIds.get(model) ? { bindingIds: this._modelBindingIds.get(model) } : {}),
+                pose: model.runtime.pose,
+                apply: pose => model.runtime.applySynchronizedPose(pose),
+            });
+        }
+        const particleCues = new Map();
+        for (const clip of this._clips) {
+            const cues = [];
+            for (const particle of this._particles) {
+                const start = Math.min(clip.duration, Math.max(0, particle.node.start ?? 0));
+                const authoredEnd = particle.node.duration === undefined
+                    ? clip.duration
+                    : (particle.node.start ?? 0) + particle.node.duration;
+                const end = Math.min(clip.duration, Math.max(0, authoredEnd));
+                if (end <= start)
+                    continue;
+                cues.push(Object.freeze({
+                    key: particle.key,
+                    emitter: particle.emitter,
+                    start,
+                    end,
+                }));
+            }
+            particleCues.set(clip.id, Object.freeze(cues));
+        }
+        this._stateMachine = new HyaAnimation3DStateMachineRuntime({
+            definition,
+            clips: this._clips,
+            partitions,
+            particleCues,
+        });
+    }
+    _createSceneEndpoint(binding) {
+        if (binding.path === 'morph.weights')
+            return null;
+        const nodeId = binding.target.kind === 'node-id' ? binding.target.nodeId
+            : binding.target.kind === 'node-path' && binding.target.segments.length === 1 ? binding.target.segments[0]
+                : null;
+        if (binding.path.startsWith('transform.') && nodeId) {
+            const state = this._transforms.get(nodeId);
+            if (!state)
+                return null;
+            const target = binding.path === 'transform.translation' ? state.translation
+                : binding.path === 'transform.rotation' ? state.rotation : state.scale;
+            return endpoint(binding, new Float32Array(target), value => { copy(value, target, binding.valueSize); commitTransform(state); });
+        }
+        if (binding.path !== 'property')
+            return null;
+        if (binding.component === 'material3d' && binding.target.kind === 'slot') {
+            const material = this._materials.get(binding.target.slot);
+            if (!material)
+                return null;
+            return materialEndpoint(binding, material);
+        }
+        if (binding.component === 'camera3d' && nodeId) {
+            const camera = this._cameras.get(nodeId);
+            if (!camera)
+                return null;
+            return cameraEndpoint(binding, camera, this._payload.viewport.width / this._payload.viewport.height);
+        }
+        return null;
+    }
+    _matchModelBinding(track) {
+        const candidates = [];
+        for (const model of this._models) {
+            for (const sourceClip of model.runtime.clips) {
+                for (const sourceTrack of sourceClip.tracks) {
+                    if (sameModelBinding(track.binding, sourceTrack.binding, model.nodeId))
+                        candidates.push({ model, binding: sourceTrack.binding });
+                }
+            }
+        }
+        const exact = candidates.find(candidate => candidate.binding.id === track.binding.id);
+        if (exact)
+            return exact;
+        return candidates.length === 1 ? candidates[0] : null;
+    }
+    _addPreviewLights() {
+        const ambient = new Entity('HYA Preview Ambient');
+        ambient.addComponent(new AmbientLight({ color: [0.72, 0.8, 1], intensity: 0.5 }));
+        this.root.addChild(ambient);
+        const sun = new Entity('HYA Preview Sun');
+        sun.addComponent(new DirectionalLight({ color: [1, 0.94, 0.84], intensity: 2, direction: [-0.4, -1, -0.35], castShadow: false }));
+        this.root.addChild(sun);
+    }
+    _assertActive() {
+        if (this._state !== 'active' || this.root.destroyed) {
+            this.destroy();
+            throw new Error('HYA Animation3D runtime is destroyed.');
+        }
+    }
+}
+async function createHyaAnimation3DRuntime(options) {
+    return await HyaAnimation3DRuntime.create(options);
+}
+function lowerRuntimeClip(value) {
+    return Object.freeze({
+        format: 'haiyue-animation3d-clip@1',
+        id: value.id,
+        name: value.name,
+        duration: value.duration,
+        tracks: Object.freeze(value.tracks.map(track => Object.freeze({
+            id: track.id,
+            binding: track.binding,
+            interpolation: track.interpolation,
+            times: new Float32Array(Array.from(track.times)),
+            values: new Float32Array(Array.from(track.values)),
+        }))),
+        events: Object.freeze([...value.events]),
+    });
+}
+function materialFromDescriptor(value) {
+    return new PbrMaterial({
+        baseColor: value.baseColorFactor,
+        metallic: value.metallicFactor,
+        roughness: Math.max(0.04, value.roughnessFactor),
+        emissiveFactor: value.emissiveFactor,
+        alphaMode: value.alphaMode,
+        alphaCutoff: value.alphaCutoff ?? 0.5,
+        doubleSided: value.doubleSided,
+    });
+}
+function cameraFromProjection(value, aspect) {
+    if (value.kind === 'perspective')
+        return new Camera3D({ type: 'perspective', fov: value.fovYRadians, near: value.near, far: value.far, aspect });
+    const half = value.orthoHeight * 0.5;
+    return new Camera3D({ type: 'orthographic', near: value.near, far: value.far, aspect, left: -half * aspect, right: half * aspect, top: half, bottom: -half });
+}
+function primitiveGeometry(value) {
+    switch (value) {
+        case 'box': return createBox3D();
+        case 'sphere': return createSphere3D();
+        case 'plane': return createPlane3D();
+        case 'cylinder': return createCylinder3D();
+        case 'cone': return createCone3D();
+    }
+}
+function commitTransform(state) {
+    composeTrsMatrix(state.translation, state.rotation, state.scale, state.matrix);
+    state.transform.localMatrix = state.matrix;
+}
+function endpoint(binding, base, write) {
+    return new HyaAnimation3DResolvedEndpoint(binding, out => copy(base, out, binding.valueSize), write);
+}
+function materialEndpoint(binding, material) {
+    const base = new Float32Array(binding.valueSize);
+    if (binding.property === 'baseColorFactor')
+        material.baseColor.writeLinear(base);
+    else {
+        const value = binding.property === 'emissiveFactor' ? material.emissiveFactor
+            : [binding.property === 'metallicFactor' ? material.metallic
+                    : binding.property === 'roughnessFactor' ? material.roughness
+                        : material.alphaCutoff];
+        copy(value, base, binding.valueSize);
+    }
+    const write = (value) => {
+        if (binding.property === 'baseColorFactor')
+            material.baseColor = tuple4(value);
+        else if (binding.property === 'emissiveFactor')
+            material.emissiveFactor = tuple3(value);
+        else if (binding.property === 'metallicFactor')
+            material.metallic = value[0] ?? 0;
+        else if (binding.property === 'roughnessFactor')
+            material.roughness = Math.max(0.04, value[0] ?? 0.04);
+        else if (binding.property === 'alphaCutoff')
+            material.alphaCutoff = value[0] ?? 0.5;
+    };
+    return endpoint(binding, base, write);
+}
+function cameraEndpoint(binding, camera, aspect) {
+    const base = new Float32Array([binding.property === 'fovYRadians' ? camera.fov
+            : binding.property === 'near' ? camera.near
+                : binding.property === 'far' ? camera.far
+                    : camera.orthoTop - camera.orthoBottom]);
+    const write = (value) => {
+        const next = value[0] ?? 0;
+        if (binding.property === 'fovYRadians')
+            camera.fov = next;
+        else if (binding.property === 'near')
+            camera.near = next;
+        else if (binding.property === 'far')
+            camera.far = next;
+        else if (binding.property === 'orthoHeight') {
+            const half = next * 0.5;
+            camera.orthoLeft = -half * aspect;
+            camera.orthoRight = half * aspect;
+            camera.orthoTop = half;
+            camera.orthoBottom = -half;
+        }
+    };
+    return endpoint(binding, base, write);
+}
+function sameModelBinding(candidate, endpoint, modelNodeId) {
+    if (candidate.id === endpoint.id)
+        return candidate.path === endpoint.path && candidate.valueSize === endpoint.valueSize;
+    if (candidate.path !== endpoint.path || candidate.valueSize !== endpoint.valueSize)
+        return false;
+    if (candidate.target.kind === 'node-path' && endpoint.target.kind === 'node-path') {
+        const authored = candidate.target.segments[0] === modelNodeId ? candidate.target.segments.slice(1) : candidate.target.segments;
+        const endpointSegments = endpoint.target.segments;
+        return authored.length <= endpointSegments.length
+            && authored.every((segment, index) => segment === endpointSegments[endpointSegments.length - authored.length + index]);
+    }
+    if (candidate.path === 'morph.weights' && candidate.target.kind === 'slot') {
+        return candidate.target.slot === modelNodeId || candidate.target.slot.startsWith(`${modelNodeId}:`);
+    }
+    return false;
+}
+function applyMaterialOverrides(root, overrides, materials) {
+    if (overrides.length === 0)
+        return;
+    const bySlot = new Map(overrides.map(item => [item.slot, required(materials, item.materialId, 'material override')]));
+    const pending = [root];
+    while (pending.length > 0) {
+        const entity = pending.pop();
+        const mesh = entity.getComponent(Mesh3D);
+        const material = bySlot.get(entity.name);
+        if (mesh && material)
+            mesh.material = material;
+        pending.push(...entity.children);
+    }
+}
+function copy(source, target, count) {
+    for (let index = 0; index < count; index++)
+        target[index] = source[index] ?? 0;
+}
+function tuple3(value) {
+    return [value[0] ?? 0, value[1] ?? 0, value[2] ?? 0];
+}
+function tuple4(value) {
+    return [value[0] ?? 0, value[1] ?? 0, value[2] ?? 0, value[3] ?? 0];
+}
+function withoutGroupOptions(options) {
+    const { fadeFrom: _fadeFrom, fadeDuration: _fadeDuration, warp: _warp, id: _id, ...result } = options;
+    return result;
+}
+function required(map, key, label) {
+    const value = map.get(key);
+    if (!value)
+        throw new RangeError(`Unknown ${label} "${String(key)}".`);
+    return value;
+}
+function abortError(reason) {
+    return new DOMException(reason === undefined ? 'The operation was aborted.' : String(reason), 'AbortError');
+}
+
+export { Animation3DError, Animation3DMixer, Animation3DPoseApplier, Animation3DPoseBuffer, Animation3DStateMachineController, Animation3DStateMachineValidationError, HyaAnimation3DRuntime, compileAnimation3DStateMachineDefinition, createHyaAnimation3DRuntime, validateAnimation3DStateMachineDefinition };
+//# sourceMappingURL=animation3d.js.map