@haiyue/extensions 0.1.0

package/dist/hya-state-machine.js

@@ -0,0 +1,2934 @@
+import { hyaStateMachineChannelCapability, HYA_STATE_MACHINE_EXTENSION_ID, parseHyaStateMachineExtension, ANIMATION_VECTOR_SHAPE_EXTENSION_ID, parseAnimation } from '@haiyue/animation-spec';
+export { HYA_STATE_MACHINE_CHANNEL_REGISTRY, hyaStateMachineChannelCapability } from '@haiyue/animation-spec';
+import { Component, System } from '@haiyue/engine';
+import { UniqueCheckType, ComponentLifecycleFlags } from '@haiyue/engine/ecs';
+import { r as runAnimationStateMachineControllerUpdateTransaction } from './chunks/AnimationStateMachineController-BIcAh-sT.js';
+import { A as Animation2DRuntime, c as createAnimation2DStateMachineController } from './chunks/Animation2DStateMachine-9IonguNa.js';
+import '@haiyue/engine/geometry';
+import '@haiyue/engine/components';
+
+class Animation2DStateMachineActionRuntimeHandle {
+    duration;
+    clipId;
+    action;
+    targetTime = 0;
+    playing = false;
+    destroyed = false;
+    pendingDestroy = false;
+    _checkpoint;
+    _checkpointTargetTime = 0;
+    _checkpointPlaying = false;
+    constructor(clipId, action) {
+        this.duration = action.duration;
+        this.clipId = clipId;
+        this.action = action;
+        this._checkpoint = action.createSynchronizedState();
+    }
+    captureTransactionState() {
+        this._checkpointTargetTime = this.targetTime;
+        this._checkpointPlaying = this.playing;
+        this.action.captureSynchronizedState(this._checkpoint);
+    }
+    restoreTransactionState() {
+        this.targetTime = this._checkpointTargetTime;
+        this.playing = this._checkpointPlaying;
+        this.pendingDestroy = false;
+        this.action.restoreSynchronizedState(this._checkpoint);
+    }
+}
+/**
+ * Transactional state-machine owner for the existing 2D mixer. It never
+ * samples tracks itself: absolute controller playheads are synchronized into
+ * the mixer actions, and the caller evaluates the ordinary shared pose buffer.
+ */
+class Animation2DStateMachineMixerAdapter {
+    mixer;
+    _handles = new Set();
+    _transactionHandles = [];
+    _transactionCreated = [];
+    _transactionPendingDestroy = [];
+    _transactionActive = false;
+    _destroyed = false;
+    constructor(mixer) {
+        this.mixer = mixer;
+    }
+    get liveActionCount() { return this._handles.size; }
+    get liveBindingCount() { return this.mixer.liveBindingCount; }
+    createAction(clipId, options) {
+        this._requireActive();
+        const handle = new Animation2DStateMachineActionRuntimeHandle(clipId, this.mixer.createAction(clipId, options));
+        this._handles.add(handle);
+        if (this._transactionActive)
+            this._transactionCreated.push(handle);
+        return handle;
+    }
+    play(handle) {
+        this._requireHandle(handle);
+        this.mixer.play(handle.action);
+        handle.playing = true;
+    }
+    stop(handle) {
+        this._requireHandle(handle);
+        this.mixer.stop(handle.action);
+        handle.playing = false;
+    }
+    fade(handle, _targetWeight, _durationSeconds) {
+        this._requireHandle(handle);
+        // The controller is the unique transition clock and applies exact weights.
+    }
+    setWeight(handle, weight) {
+        this._requireHandle(handle);
+        this.mixer.setWeight(handle.action, weight);
+    }
+    setTime(handle, timeSeconds) {
+        this._requireHandle(handle);
+        handle.targetTime = timeSeconds;
+        this.mixer.setTime(handle.action, timeSeconds);
+    }
+    setTimeScale(handle, timeScale) {
+        this._requireHandle(handle);
+        this.mixer.setTimeScale(handle.action, timeScale);
+    }
+    destroyAction(handle) {
+        if (handle.destroyed)
+            return;
+        this._requireHandle(handle);
+        if (this._transactionActive) {
+            if (!handle.pendingDestroy) {
+                handle.pendingDestroy = true;
+                this._transactionPendingDestroy.push(handle);
+            }
+            return;
+        }
+        this._destroyHandleNow(handle);
+    }
+    beginControllerTransaction() {
+        this._requireActive();
+        if (this._transactionActive) {
+            throw new Error('Animation2D state-machine adapter transaction is already active.');
+        }
+        this._transactionActive = true;
+        this._transactionHandles.length = 0;
+        this._transactionCreated.length = 0;
+        this._transactionPendingDestroy.length = 0;
+        for (const handle of this._handles) {
+            handle.captureTransactionState();
+            this._transactionHandles.push(handle);
+        }
+    }
+    commitControllerTransaction() {
+        if (!this._transactionActive) {
+            throw new Error('Animation2D state-machine adapter has no active transaction.');
+        }
+        this._transactionActive = false;
+        for (const handle of this._transactionPendingDestroy)
+            this._destroyHandleNow(handle);
+        this._clearTransaction();
+    }
+    rollbackControllerTransaction() {
+        if (!this._transactionActive)
+            return;
+        this._transactionActive = false;
+        for (let index = this._transactionCreated.length - 1; index >= 0; index--) {
+            this._destroyHandleNow(this._transactionCreated[index]);
+        }
+        for (const handle of this._transactionHandles) {
+            if (!handle.destroyed)
+                handle.restoreTransactionState();
+        }
+        this._clearTransaction();
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this.rollbackControllerTransaction();
+        for (const handle of [...this._handles])
+            this._destroyHandleNow(handle);
+        this._destroyed = true;
+    }
+    _destroyHandleNow(handle) {
+        if (handle.destroyed)
+            return;
+        this.mixer.removeAction(handle.action);
+        handle.playing = false;
+        handle.pendingDestroy = false;
+        handle.destroyed = true;
+        this._handles.delete(handle);
+    }
+    _clearTransaction() {
+        this._transactionHandles.length = 0;
+        this._transactionCreated.length = 0;
+        this._transactionPendingDestroy.length = 0;
+    }
+    _requireHandle(handle) {
+        this._requireActive();
+        if (handle.destroyed || !this._handles.has(handle)) {
+            throw new Error('Animation2D state-machine action belongs to another adapter or was destroyed.');
+        }
+    }
+    _requireActive() {
+        if (this._destroyed)
+            throw new Error('Animation2D state-machine adapter has been destroyed.');
+    }
+}
+
+class AnimationStateMachineChannelError extends Error {
+    diagnostic;
+    name = 'AnimationStateMachineChannelError';
+    constructor(diagnostic) {
+        super(`${diagnostic.message} (${diagnostic.path})`);
+        this.diagnostic = diagnostic;
+    }
+}
+/**
+ * Audio owns one HTMLMediaElement playhead and is intentionally not amplitude
+ * mixed. It is executable only when the graph can never overlap two motions.
+ */
+function audioStateMachineCompatibilityDiagnostic(definition, path = '$.stateMachine') {
+    const capability = hyaStateMachineChannelCapability('audio');
+    if (definition.layers.length !== 1) {
+        return audioRangeDiagnostic(`${path}.layers`, 'Audio requires exactly one state-machine layer.');
+    }
+    const layer = definition.layers[0];
+    if ((layer.weight ?? 1) !== 1 || (layer.blendMode ?? 'override') !== 'override') {
+        return audioRangeDiagnostic(`${path}.layers[0]`, 'Audio requires one full-weight override layer because media amplitude is not pose-mixable.');
+    }
+    for (let stateIndex = 0; stateIndex < layer.states.length; stateIndex++) {
+        if (motionContainsBlendTree(layer.states[stateIndex].motion)) {
+            return audioRangeDiagnostic(`${path}.layers[0].states[${stateIndex}].motion`, 'Audio cannot run inside a Blend Tree because two media playheads would overlap.');
+        }
+    }
+    for (let transitionIndex = 0; transitionIndex < layer.transitions.length; transitionIndex++) {
+        if (layer.transitions[transitionIndex].duration > 0) {
+            return audioRangeDiagnostic(`${path}.layers[0].transitions[${transitionIndex}].duration`, 'Audio transitions must be immediate; non-zero cross-fades are an unmixable media range.');
+        }
+    }
+    if (capability.transition !== 'immediate-only') {
+        throw new Error('The canonical audio channel contract is internally inconsistent.');
+    }
+    return null;
+}
+function assertAudioStateMachineCompatible(definition, path) {
+    const diagnostic = audioStateMachineCompatibilityDiagnostic(definition, path);
+    if (diagnostic)
+        throw new AnimationStateMachineChannelError(diagnostic);
+}
+function audioAutoplayRejectedDiagnostic(path, reason) {
+    const suffix = reason instanceof Error && reason.message
+        ? ` Browser reason: ${reason.message}`
+        : '';
+    return Object.freeze({
+        code: 'W_STATE_MACHINE_CHANNEL_AUDIO_AUTOPLAY_REJECTED',
+        severity: 'warning',
+        channelId: 'audio',
+        path,
+        message: `Audio play() was rejected; the playhead remains paused until a later user-authorized resume.${suffix}`,
+    });
+}
+function audioRangeDiagnostic(path, message) {
+    return Object.freeze({
+        code: 'E_STATE_MACHINE_CHANNEL_AUDIO_UNMIXABLE_RANGE',
+        severity: 'error',
+        channelId: 'audio',
+        path,
+        message,
+    });
+}
+function motionContainsBlendTree(motion) {
+    return motion.kind !== 'clip';
+}
+
+// HYA v2 keeps track times in Float32 while clip ranges remain JSON numbers.
+// At ordinary multi-second timestamps the Float32 ULP is already larger than
+// 1e-7, so boundary comparisons must absorb that representation difference.
+const TIME_EPSILON = 1e-6;
+/** Returns the canonical built-in state-machine payload from a parsed HYA document. */
+function getHyaStateMachineExtension(animation) {
+    const value = animation.extensions[HYA_STATE_MACHINE_EXTENSION_ID];
+    if (value === undefined) {
+        throw new RangeError(`HYA document does not contain the built-in "${HYA_STATE_MACHINE_EXTENSION_ID}" extension.`);
+    }
+    return parseHyaStateMachineExtension(value, animation.duration);
+}
+/**
+ * Adapts named ranges from one HYA composition into source-independent 2D
+ * clips. The returned clips share no scene objects; one pose is applied to one
+ * Animation2DRuntime hierarchy by the state-machine runtime.
+ */
+function createHyaAnimation2DClips(animation, extension = getHyaStateMachineExtension(animation)) {
+    assertChannelCompatibleDocument(animation, extension);
+    const nodesById = new Map(animation.nodes.map(node => [node.id, node]));
+    return Object.freeze(extension.clips.map(range => createClip(animation, range, nodesById)));
+}
+function createClip(animation, range, nodesById) {
+    const runtimeDuration = Math.fround(range.duration);
+    const tracks = [];
+    const effects = [];
+    for (let index = 0; index < animation.tracks.length; index++) {
+        const source = animation.tracks[index];
+        const node = nodesById.get(source.node);
+        tracks.push(sliceNumericTrack(source, node, range, runtimeDuration, index));
+    }
+    for (let index = 0; index < animation.nodes.length; index++) {
+        const node = animation.nodes[index];
+        tracks.push(createVisibilityTrack(node, range, animation.duration, index));
+        appendComponentChannels(node, index, range, runtimeDuration, tracks, effects, animation.duration);
+    }
+    return Object.freeze({
+        format: 'haiyue-animation2d-clip@1',
+        id: range.id,
+        name: range.name ?? range.id,
+        duration: runtimeDuration,
+        tracks: Object.freeze(tracks),
+        ...(effects.length === 0 ? {} : { effects: Object.freeze(effects) }),
+    });
+}
+function appendComponentChannels(node, nodeIndex, range, runtimeDuration, tracks, effects, compositionDuration) {
+    let particleSlot = 0;
+    let audioSlot = 0;
+    const components = node.components ?? [];
+    for (let componentIndex = 0; componentIndex < components.length; componentIndex++) {
+        const component = components[componentIndex];
+        const path = `$.nodes[${nodeIndex}].components[${componentIndex}]`;
+        if (component.type === 'sprite2d') {
+            const sprite = component;
+            if (!sprite.uvRectTrack)
+                continue;
+            tracks.push(sliceStepVectorTrack(sprite.uvRectTrack, range, runtimeDuration, `${range.id}:component:${nodeIndex}:${componentIndex}:sprite-uv`, Object.freeze({
+                id: `${node.id}.components.${componentIndex}.sprite.uv-rect`,
+                targetId: node.id,
+                path: `components.${componentIndex}.sprite.uv-rect`,
+                strategy: 'discrete',
+                defaultValue: Object.freeze([...(sprite.uvRect ?? [0, 0, 1, 1])]),
+            })));
+        }
+        else if (component.type === ANIMATION_VECTOR_SHAPE_EXTENSION_ID) {
+            const vector = component;
+            if (!vector.morph)
+                continue;
+            tracks.push(sliceComponentNumericTrack(vector.morph, range, runtimeDuration, `${range.id}:component:${nodeIndex}:${componentIndex}:vector-morph`, Object.freeze({
+                id: `${node.id}.components.${componentIndex}.vector.morph`,
+                targetId: node.id,
+                path: `components.${componentIndex}.vector.morph`,
+                strategy: 'continuous',
+                valueSize: vector.morph.valueSize,
+                defaultValue: vector.morphRelative
+                    ? new Float32Array(vector.morph.valueSize)
+                    : Object.freeze(Array.from(vector.values)),
+            }), `${path}.morph`));
+        }
+        else if (component.type === 'org.haiyue.vector-path-morph@1') {
+            const morph = component;
+            tracks.push(sliceComponentNumericTrack(morph, range, runtimeDuration, `${range.id}:component:${nodeIndex}:${componentIndex}:path-morph`, Object.freeze({
+                id: `${node.id}.components.${componentIndex}.path.morph`,
+                targetId: node.id,
+                path: `components.${componentIndex}.path.morph`,
+                strategy: 'continuous',
+                valueSize: morph.valueSize,
+                defaultValue: Object.freeze(Array.from(morph.values).slice(0, morph.valueSize)),
+            }), path));
+        }
+        if (component.type === 'particle2d') {
+            appendEffectCue('particle', component, particleSlot++, node, path, range, effects, compositionDuration);
+        }
+        else if (component.type === 'audio') {
+            appendEffectCue('audio', component, audioSlot++, node, path, range, effects, compositionDuration);
+        }
+    }
+}
+function appendEffectCue(kind, component, slot, node, sourcePath, range, effects, compositionDuration) {
+    const nodeStart = node.start ?? 0;
+    const nodeEnd = nodeStart + (node.duration ?? compositionDuration - nodeStart);
+    const start = Math.max(nodeStart, range.start);
+    const end = Math.min(nodeEnd, range.start + range.duration);
+    if (end <= start + TIME_EPSILON)
+        return;
+    const payload = Object.freeze({
+        targetId: node.id,
+        slot,
+        sourcePath,
+        component,
+    });
+    effects.push(Object.freeze({
+        id: `${range.id}:${kind}:${node.id}:${slot}`,
+        kind,
+        start: Math.max(0, Math.fround(start - range.start)),
+        end: Math.min(Math.fround(range.duration), Math.fround(end - range.start)),
+        loopBehavior: kind === 'particle' ? 'restart' : 'continue',
+        payload,
+    }));
+}
+function sliceNumericTrack(source, node, range, runtimeDuration, sourceIndex) {
+    const globalTimes = collectTrackTimes(source, range);
+    const times = new Float32Array(globalTimes.length);
+    const values = new Float32Array(globalTimes.length * source.valueSize);
+    for (let key = 0; key < globalTimes.length; key++) {
+        times[key] = key === 0
+            ? 0
+            : key === globalTimes.length - 1
+                ? runtimeDuration
+                : Math.min(runtimeDuration, Math.max(0, Math.fround(globalTimes[key] - range.start)));
+        sampleTrack(source, globalTimes[key], values, key * source.valueSize);
+    }
+    assertStrictFloatTimes(times, `${range.id}:${source.node}:${source.property}`);
+    const binding = createNumericBinding(source, node);
+    const interpolation = source.times.length < 2 ? 'step' : source.interpolation;
+    const easings = interpolation === 'cubic-bezier'
+        ? sliceEasings(source, globalTimes)
+        : undefined;
+    const spatialTangents = source.spatialTangents
+        ? sliceSpatialTangents(source, globalTimes)
+        : undefined;
+    return Object.freeze({
+        id: `${range.id}:track:${sourceIndex}`,
+        binding,
+        interpolation,
+        times,
+        values,
+        ...(easings ? { easings } : {}),
+        ...(spatialTangents ? { spatialTangents } : {}),
+    });
+}
+function createNumericBinding(track, node) {
+    const transform = node.transform;
+    const path = track.property === 'opacity'
+        ? 'opacity'
+        : `transform.${track.property}`;
+    const defaultValue = track.property === 'position'
+        ? transform?.position ?? [0, 0]
+        : track.property === 'scale'
+            ? transform?.scale ?? [1, 1]
+            : track.property === 'rotation'
+                ? [transform?.rotation ?? 0]
+                : [transform?.opacity ?? 1];
+    return Object.freeze({
+        id: `${node.id}.${path}`,
+        targetId: node.id,
+        path,
+        strategy: track.property === 'rotation' ? 'rotation' : 'continuous',
+        valueSize: track.valueSize,
+        defaultValue: Object.freeze(Array.from(defaultValue)),
+    });
+}
+function sliceComponentNumericTrack(source, range, runtimeDuration, id, binding, debugPath) {
+    const track = vectorTrackAsParsedTrack(source, debugPath);
+    const globalTimes = collectTrackTimes(track, range);
+    const times = new Float32Array(globalTimes.length);
+    const values = new Float32Array(globalTimes.length * source.valueSize);
+    for (let key = 0; key < globalTimes.length; key++) {
+        times[key] = key === 0
+            ? 0
+            : key === globalTimes.length - 1
+                ? runtimeDuration
+                : Math.min(runtimeDuration, Math.max(0, Math.fround(globalTimes[key] - range.start)));
+        sampleTrack(track, globalTimes[key], values, key * source.valueSize);
+    }
+    assertStrictFloatTimes(times, id);
+    const interpolation = source.times.length < 2 ? 'step' : source.interpolation;
+    const easings = interpolation === 'cubic-bezier'
+        ? sliceEasings(track, globalTimes)
+        : undefined;
+    return Object.freeze({
+        id,
+        binding,
+        interpolation,
+        times,
+        values,
+        ...(easings ? { easings } : {}),
+    });
+}
+function sliceStepVectorTrack(source, range, runtimeDuration, id, binding) {
+    const globalTimes = collectVectorTrackTimes(source, range);
+    const times = new Float32Array(globalTimes.length);
+    const values = [];
+    for (let key = 0; key < globalTimes.length; key++) {
+        times[key] = key === 0
+            ? 0
+            : key === globalTimes.length - 1
+                ? runtimeDuration
+                : Math.min(runtimeDuration, Math.max(0, Math.fround(globalTimes[key] - range.start)));
+        const frame = findArraySegment(source.times, globalTimes[key]);
+        const offset = frame * source.valueSize;
+        const sampled = new Float32Array(source.valueSize);
+        for (let component = 0; component < source.valueSize; component++) {
+            sampled[component] = source.values[offset + component] ?? 0;
+        }
+        values.push(sampled);
+    }
+    assertStrictFloatTimes(times, id);
+    return Object.freeze({
+        id,
+        binding,
+        interpolation: 'step',
+        times,
+        values: Object.freeze(values),
+    });
+}
+function collectVectorTrackTimes(track, range) {
+    const end = range.start + range.duration;
+    const result = [range.start];
+    for (let index = 0; index < track.times.length; index++) {
+        const time = track.times[index];
+        if (time > range.start + TIME_EPSILON && time < end - TIME_EPSILON)
+            result.push(time);
+    }
+    result.push(end);
+    return result;
+}
+function vectorTrackAsParsedTrack(source, debugPath) {
+    return {
+        node: debugPath,
+        property: 'opacity',
+        interpolation: source.interpolation,
+        times: source.times instanceof Float32Array ? source.times : Float32Array.from(source.times),
+        values: source.values instanceof Float32Array ? source.values : Float32Array.from(source.values),
+        valueSize: source.valueSize,
+        ...(source.easings === undefined ? {} : {
+            easings: source.easings instanceof Float32Array
+                ? source.easings
+                : Float32Array.from(source.easings),
+        }),
+    };
+}
+function findArraySegment(times, time) {
+    if (times.length <= 1 || time <= times[0])
+        return 0;
+    if (time >= times[times.length - 1])
+        return times.length - 1;
+    let low = 0;
+    let high = times.length - 1;
+    while (low + 1 < high) {
+        const middle = (low + high) >>> 1;
+        if (times[middle] <= time)
+            low = middle;
+        else
+            high = middle;
+    }
+    return low;
+}
+function createVisibilityTrack(node, range, compositionDuration, nodeIndex) {
+    const nodeStart = node.start ?? 0;
+    const nodeEnd = nodeStart + (node.duration ?? compositionDuration - nodeStart);
+    const globalTimes = [range.start];
+    if (nodeStart > range.start + TIME_EPSILON && nodeStart < range.start + range.duration - TIME_EPSILON) {
+        globalTimes.push(nodeStart);
+    }
+    if (nodeEnd > range.start + TIME_EPSILON && nodeEnd < range.start + range.duration - TIME_EPSILON) {
+        globalTimes.push(nodeEnd);
+    }
+    globalTimes.sort((left, right) => left - right);
+    const times = new Float32Array(globalTimes.length);
+    const values = new Array(globalTimes.length);
+    for (let index = 0; index < globalTimes.length; index++) {
+        const globalTime = globalTimes[index];
+        times[index] = Math.fround(globalTime - range.start);
+        values[index] = globalTime >= nodeStart - TIME_EPSILON && globalTime < nodeEnd - TIME_EPSILON;
+    }
+    assertStrictFloatTimes(times, `${range.id}:${node.id}:visibility`);
+    return Object.freeze({
+        id: `${range.id}:visibility:${nodeIndex}`,
+        binding: Object.freeze({
+            id: `${node.id}.visibility`,
+            targetId: node.id,
+            path: 'visibility',
+            strategy: 'discrete',
+            defaultValue: true,
+        }),
+        interpolation: 'step',
+        times,
+        values: Object.freeze(values),
+    });
+}
+function collectTrackTimes(track, range) {
+    const end = range.start + range.duration;
+    const result = [range.start];
+    for (let index = 0; index < track.times.length; index++) {
+        const time = track.times[index];
+        if (time > range.start + TIME_EPSILON && time < end - TIME_EPSILON)
+            result.push(time);
+    }
+    result.push(end);
+    return result;
+}
+function sampleTrack(track, time, output, outputOffset) {
+    const segment = findSegment(track.times, time);
+    const startOffset = segment * track.valueSize;
+    const endOffset = Math.min(segment + 1, track.times.length - 1) * track.valueSize;
+    let progress = 0;
+    if (segment < track.times.length - 1 && track.interpolation !== 'step') {
+        const start = track.times[segment];
+        const end = track.times[segment + 1];
+        const linear = Math.min(1, Math.max(0, (time - start) / Math.max(TIME_EPSILON, end - start)));
+        progress = track.interpolation === 'cubic-bezier'
+            ? cubicBezierYForX(track.easings, segment, linear)
+            : linear;
+    }
+    if (track.spatialTangents && segment < track.times.length - 1) {
+        const tangentOffset = segment * 4;
+        for (let component = 0; component < 2; component++) {
+            const start = track.values[startOffset + component];
+            const end = track.values[endOffset + component];
+            output[outputOffset + component] = spatialCoordinate(progress, start, start + track.spatialTangents[tangentOffset + component], end + track.spatialTangents[tangentOffset + 2 + component], end);
+        }
+        return;
+    }
+    for (let component = 0; component < track.valueSize; component++) {
+        const start = track.values[startOffset + component];
+        output[outputOffset + component] = start
+            + (track.values[endOffset + component] - start) * progress;
+    }
+}
+function sliceSpatialTangents(track, globalTimes) {
+    const result = new Float32Array(Math.max(0, globalTimes.length - 1) * 4);
+    for (let interval = 0; interval < globalTimes.length - 1; interval++) {
+        const startTime = globalTimes[interval];
+        const endTime = globalTimes[interval + 1];
+        const midpoint = (startTime + endTime) * 0.5;
+        const sourceSegment = findSegment(track.times, midpoint);
+        if (sourceSegment >= track.times.length - 1)
+            continue;
+        const sourceStartTime = track.times[sourceSegment];
+        const sourceEndTime = track.times[sourceSegment + 1];
+        if (endTime <= sourceStartTime + TIME_EPSILON || startTime >= sourceEndTime - TIME_EPSILON)
+            continue;
+        const linearStart = clamp01((startTime - sourceStartTime) / (sourceEndTime - sourceStartTime));
+        const linearEnd = clamp01((endTime - sourceStartTime) / (sourceEndTime - sourceStartTime));
+        const progressStart = track.interpolation === 'cubic-bezier'
+            ? cubicBezierYForX(track.easings, sourceSegment, linearStart)
+            : linearStart;
+        const progressEnd = track.interpolation === 'cubic-bezier'
+            ? cubicBezierYForX(track.easings, sourceSegment, linearEnd)
+            : linearEnd;
+        const valueOffset = sourceSegment * 2;
+        const tangentOffset = sourceSegment * 4;
+        const delta = progressEnd - progressStart;
+        for (let component = 0; component < 2; component++) {
+            const start = track.values[valueOffset + component];
+            const end = track.values[valueOffset + 2 + component];
+            const control1 = start + track.spatialTangents[tangentOffset + component];
+            const control2 = end + track.spatialTangents[tangentOffset + 2 + component];
+            const derivativeStart = spatialDerivative(progressStart, start, control1, control2, end);
+            const derivativeEnd = spatialDerivative(progressEnd, start, control1, control2, end);
+            result[interval * 4 + component] = derivativeStart * delta / 3;
+            result[interval * 4 + 2 + component] = -derivativeEnd * delta / 3;
+        }
+    }
+    return result;
+}
+function spatialCoordinate(value, start, first, second, end) {
+    const inverse = 1 - value;
+    return inverse * inverse * inverse * start
+        + 3 * inverse * inverse * value * first
+        + 3 * inverse * value * value * second
+        + value * value * value * end;
+}
+function spatialDerivative(value, start, first, second, end) {
+    const inverse = 1 - value;
+    return 3 * inverse * inverse * (first - start)
+        + 6 * inverse * value * (second - first)
+        + 3 * value * value * (end - second);
+}
+function sliceEasings(track, globalTimes) {
+    const result = new Float32Array(Math.max(0, globalTimes.length - 1) * 4);
+    for (let interval = 0; interval < globalTimes.length - 1; interval++) {
+        const startTime = globalTimes[interval];
+        const endTime = globalTimes[interval + 1];
+        const firstSourceTime = track.times[0];
+        const lastSourceTime = track.times[track.times.length - 1];
+        if (track.times.length < 2
+            || endTime <= firstSourceTime + TIME_EPSILON
+            || startTime >= lastSourceTime - TIME_EPSILON) {
+            result.set([1 / 3, 1 / 3, 2 / 3, 2 / 3], interval * 4);
+            continue;
+        }
+        const sourceSegment = findSegment(track.times, (startTime + endTime) * 0.5);
+        const sourceStart = track.times[sourceSegment];
+        const sourceEnd = track.times[sourceSegment + 1];
+        const duration = sourceEnd - sourceStart;
+        const xStart = Math.min(1, Math.max(0, (startTime - sourceStart) / duration));
+        const xEnd = Math.min(1, Math.max(0, (endTime - sourceStart) / duration));
+        const easingOffset = sourceSegment * 4;
+        const subcurve = sliceCubicBezier(track.easings[easingOffset], track.easings[easingOffset + 1], track.easings[easingOffset + 2], track.easings[easingOffset + 3], xStart, xEnd, track, sourceSegment);
+        result.set(subcurve, interval * 4);
+    }
+    return result;
+}
+function sliceCubicBezier(x1, y1, x2, y2, xStart, xEnd, track, sourceSegment) {
+    if (xStart <= TIME_EPSILON && xEnd >= 1 - TIME_EPSILON)
+        return [x1, y1, x2, y2];
+    const t0 = solveCubicX(xStart, x1, x2);
+    const t1 = solveCubicX(xEnd, x1, x2);
+    const start = cubicPoint(t0, x1, y1, x2, y2);
+    const end = cubicPoint(t1, x1, y1, x2, y2);
+    const delta = t1 - t0;
+    const startDerivative = cubicPointDerivative(t0, x1, y1, x2, y2);
+    const endDerivative = cubicPointDerivative(t1, x1, y1, x2, y2);
+    const control1 = [start[0] + startDerivative[0] * delta / 3, start[1] + startDerivative[1] * delta / 3];
+    const control2 = [end[0] - endDerivative[0] * delta / 3, end[1] - endDerivative[1] * delta / 3];
+    const width = end[0] - start[0];
+    const height = end[1] - start[1];
+    if (Math.abs(height) <= 1e-8) {
+        if (sourceSegmentHasMotion(track, sourceSegment)) {
+            throw new RangeError(`HYA cubic track "${track.node}.${track.property}" cannot be range-sliced at a zero-progress easing interval without losing fidelity.`);
+        }
+        return [1 / 3, 1 / 3, 2 / 3, 2 / 3];
+    }
+    return [
+        clamp01((control1[0] - start[0]) / width),
+        (control1[1] - start[1]) / height,
+        clamp01((control2[0] - start[0]) / width),
+        (control2[1] - start[1]) / height,
+    ];
+}
+function sourceSegmentHasMotion(track, segment) {
+    const start = segment * track.valueSize;
+    const end = (segment + 1) * track.valueSize;
+    for (let component = 0; component < track.valueSize; component++) {
+        if (Math.abs(track.values[start + component] - track.values[end + component]) > 1e-8)
+            return true;
+    }
+    return false;
+}
+function findSegment(times, time) {
+    if (times.length <= 1 || time <= times[0])
+        return 0;
+    if (time >= times[times.length - 1])
+        return times.length - 1;
+    let low = 0;
+    let high = times.length - 1;
+    while (low + 1 < high) {
+        const middle = (low + high) >>> 1;
+        if (times[middle] <= time)
+            low = middle;
+        else
+            high = middle;
+    }
+    return low;
+}
+function cubicBezierYForX(easings, segment, x) {
+    const offset = segment * 4;
+    const x1 = easings[offset];
+    const y1 = easings[offset + 1];
+    const x2 = easings[offset + 2];
+    const y2 = easings[offset + 3];
+    return cubicCoordinate$1(solveCubicX(x, x1, x2), y1, y2);
+}
+function solveCubicX(x, x1, x2) {
+    let parameter = x;
+    for (let iteration = 0; iteration < 6; iteration++) {
+        const estimate = cubicCoordinate$1(parameter, x1, x2) - x;
+        const derivative = cubicDerivative$1(parameter, x1, x2);
+        if (Math.abs(derivative) < 1e-7)
+            break;
+        parameter = clamp01(parameter - estimate / derivative);
+    }
+    let low = 0;
+    let high = 1;
+    for (let iteration = 0; iteration < 18; iteration++) {
+        const estimate = cubicCoordinate$1(parameter, x1, x2);
+        if (Math.abs(estimate - x) < 1e-8)
+            break;
+        if (estimate < x)
+            low = parameter;
+        else
+            high = parameter;
+        parameter = (low + high) * 0.5;
+    }
+    return parameter;
+}
+function cubicPoint(value, x1, y1, x2, y2) {
+    return [cubicCoordinate$1(value, x1, x2), cubicCoordinate$1(value, y1, y2)];
+}
+function cubicPointDerivative(value, x1, y1, x2, y2) {
+    return [cubicDerivative$1(value, x1, x2), cubicDerivative$1(value, y1, y2)];
+}
+function cubicCoordinate$1(value, first, second) {
+    const inverse = 1 - value;
+    return 3 * inverse * inverse * value * first
+        + 3 * inverse * value * value * second
+        + value * value * value;
+}
+function cubicDerivative$1(value, first, second) {
+    const inverse = 1 - value;
+    return 3 * inverse * inverse * first
+        + 6 * inverse * value * (second - first)
+        + 3 * value * value * (1 - second);
+}
+function assertChannelCompatibleDocument(animation, extension) {
+    let hasAudio = false;
+    for (let nodeIndex = 0; nodeIndex < animation.nodes.length; nodeIndex++) {
+        const node = animation.nodes[nodeIndex];
+        const components = node.components ?? [];
+        for (let componentIndex = 0; componentIndex < components.length; componentIndex++) {
+            const component = components[componentIndex];
+            const path = `$.nodes[${nodeIndex}].components[${componentIndex}]`;
+            if (component.type === 'audio')
+                hasAudio = true;
+            const unsupported = unsupportedInlineChannel(component, path);
+            if (unsupported)
+                throw new AnimationStateMachineChannelError(unsupported);
+        }
+        for (let effectIndex = 0; effectIndex < (node.effects?.length ?? 0); effectIndex++) {
+            const effect = node.effects[effectIndex];
+            if (Object.keys(effect).some(key => key.endsWith('Track'))) {
+                throw new AnimationStateMachineChannelError(unsupportedDiagnostic('visual-effect', `$.nodes[${nodeIndex}].effects[${effectIndex}]`, 'Animated visual-effect properties are not yet writable from the shared pose buffer.'));
+            }
+        }
+        const composites = node.composite
+            ? ('layers' in node.composite ? node.composite.layers : [node.composite])
+            : [];
+        for (let compositeIndex = 0; compositeIndex < composites.length; compositeIndex++) {
+            if (composites[compositeIndex].expansionTrack) {
+                throw new AnimationStateMachineChannelError(unsupportedDiagnostic('composite-expansion', `$.nodes[${nodeIndex}].composite.layers[${compositeIndex}].expansionTrack`, 'Animated composite expansion is not yet writable from the shared pose buffer.'));
+            }
+        }
+    }
+    if (hasAudio) {
+        assertAudioStateMachineCompatible(extension.stateMachine, `$.extensions.${HYA_STATE_MACHINE_EXTENSION_ID}.stateMachine`);
+    }
+}
+function unsupportedInlineChannel(component, path) {
+    if (component.type === 'shape2d'
+        || component.type === 'path2d'
+        || component.type === 'sprite2d'
+        || component.type === 'particle2d'
+        || component.type === 'audio'
+        || component.type === 'org.haiyue.vector-stroke@1'
+        || component.type === 'org.haiyue.vector-path-morph@1')
+        return null;
+    if (component.type === ANIMATION_VECTOR_SHAPE_EXTENSION_ID) {
+        const vector = component;
+        if (vectorHasUnsupportedInlineTrack(vector)) {
+            return unsupportedDiagnostic('vector-paint', path, 'Vector paint and modifier tracks are not yet writable from the shared pose buffer; vector morph is supported.');
+        }
+        return null;
+    }
+    if (component.type === 'text2d') {
+        const text = component;
+        const documents = text.documents;
+        const animators = text.animators;
+        if ((documents?.length ?? 0) > 1 || animators?.some(recordHasNestedTrack)) {
+            return unsupportedDiagnostic('text-animator', path, 'Animated text documents and animator tracks are not yet writable from the shared pose buffer.');
+        }
+        return null;
+    }
+    return unsupportedDiagnostic('visual-effect', path, `Component "${component.type}" has no registered state-machine channel strategy.`);
+}
+function vectorHasUnsupportedInlineTrack(vector) {
+    const fill = vector.fill;
+    if (fill) {
+        if (fill.kind === 'solid') {
+            if (fill.colorTrack || fill.opacityTrack)
+                return true;
+        }
+        else if (fill.startTrack || fill.endTrack || fill.stopsTrack || fill.opacityTrack)
+            return true;
+    }
+    const stroke = vector.stroke;
+    if (stroke && (stroke.colorTrack || stroke.opacityTrack || stroke.widthTrack || stroke.dashOffsetTrack
+        || (stroke.gradient && (stroke.gradient.startTrack || stroke.gradient.endTrack
+            || stroke.gradient.stopsTrack || stroke.gradient.opacityTrack))))
+        return true;
+    return vector.modifiers?.some(modifier => modifier.kind === 'round-corners'
+        ? modifier.radiusTrack !== undefined
+        : modifier.startTrack !== undefined || modifier.endTrack !== undefined
+            || modifier.offsetTrack !== undefined) ?? false;
+}
+function recordHasNestedTrack(record) {
+    if (Object.keys(record).some(key => key.endsWith('Track')))
+        return true;
+    return Object.values(record).some(value => value !== null && typeof value === 'object'
+        && !Array.isArray(value)
+        && recordHasNestedTrack(value));
+}
+function unsupportedDiagnostic(channelId, path, message) {
+    return Object.freeze({
+        code: hyaStateMachineChannelCapability(channelId).diagnosticCode,
+        severity: 'error',
+        channelId,
+        path,
+        message,
+    });
+}
+function assertStrictFloatTimes(times, trackId) {
+    for (let index = 1; index < times.length; index++) {
+        if (times[index] <= times[index - 1]) {
+            throw new RangeError(`HYA state-machine clip "${trackId}" has time keys that collapse after Float32 conversion.`);
+        }
+    }
+}
+function clamp01(value) {
+    return Math.min(1, Math.max(0, value));
+}
+
+/**
+ * Plays multiple named animation ranges and a state machine from one HYA
+ * asset. Transitions blend one pose onto one generated scene hierarchy.
+ */
+class Animation2DStateMachineComponent extends Component {
+    static UniqueCheckType = UniqueCheckType.SYMBOL | UniqueCheckType.REPLACE;
+    static UniqueSymbol = Symbol.for('Animation2DStateMachineComponent');
+    static Lifecycle = ComponentLifecycleFlags.EntityRemoveComponent
+        | ComponentLifecycleFlags.EntityRemoveFromWorld;
+    animation;
+    stateMachineExtension;
+    runtimeExtensions;
+    playing;
+    speed;
+    _runtime = null;
+    _needsUpdate = true;
+    _parametersByName;
+    _parameterValues = new Map();
+    constructor(source, options = {}) {
+        super('Animation2DStateMachineComponent');
+        this.animation = isParsed(source) ? source : parseAnimation(source);
+        this.stateMachineExtension = getHyaStateMachineExtension(this.animation);
+        this.runtimeExtensions = options.runtimeExtensions;
+        this.playing = options.autoplay ?? true;
+        this.speed = finiteSpeed(options.speed ?? 1);
+        this._parametersByName = new Map(this.stateMachineExtension.stateMachine.parameters.map(parameter => [parameter.name, parameter]));
+    }
+    get runtimeStats() {
+        return this._runtime?.stats ?? EMPTY_RUNTIME_STATS;
+    }
+    get layerSnapshots() {
+        if (this._runtime)
+            return this._runtime.layerSnapshots;
+        return Object.freeze(this.stateMachineExtension.stateMachine.layers.map(layer => Object.freeze({
+            layerId: layer.id,
+            currentStateId: layer.initialStateId,
+            currentTime: 0,
+            transitionId: null,
+            sourceStateId: null,
+            destinationStateId: null,
+            transitionProgress: 0,
+        })));
+    }
+    get channelDiagnostics() {
+        return this._runtime?.diagnostics ?? EMPTY_CHANNEL_DIAGNOSTICS;
+    }
+    get liveActionCount() { return this._runtime?.liveActionCount ?? 0; }
+    get liveBindingCount() { return this._runtime?.liveBindingCount ?? 0; }
+    get sideEffectOwnerCount() { return this._runtime?.sideEffectOwnerCount ?? 0; }
+    play() {
+        this.playing = true;
+        this._runtime?.setPlaying(true);
+        this._needsUpdate = true;
+        return this;
+    }
+    pause() {
+        this.playing = false;
+        this._runtime?.setPlaying(false);
+        return this;
+    }
+    setSpeed(speed) {
+        this.speed = finiteSpeed(speed);
+        return this;
+    }
+    setFloat(name, value) {
+        if (!Number.isFinite(value))
+            throw new RangeError('Float parameters must be finite.');
+        this._setParameter(name, 'float', value);
+        this._runtime?.controller.setFloat(name, value);
+        return this;
+    }
+    setInteger(name, value) {
+        if (!Number.isSafeInteger(value))
+            throw new RangeError('Integer parameters must be safe integers.');
+        this._setParameter(name, 'integer', value);
+        this._runtime?.controller.setInteger(name, value);
+        return this;
+    }
+    setBoolean(name, value) {
+        if (typeof value !== 'boolean')
+            throw new TypeError('Boolean parameters require a boolean.');
+        this._setParameter(name, 'boolean', value);
+        this._runtime?.controller.setBoolean(name, value);
+        return this;
+    }
+    setTrigger(name) {
+        this._setParameter(name, 'trigger', true);
+        this._runtime?.controller.setTrigger(name);
+        return this;
+    }
+    resetTrigger(name) {
+        this._setParameter(name, 'trigger', false);
+        this._runtime?.controller.resetTrigger(name);
+        return this;
+    }
+    getParameter(name) {
+        const parameter = this._requireParameter(name);
+        if (this._runtime)
+            return this._runtime.controller.getParameter(name);
+        if (this._parameterValues.has(name))
+            return this._parameterValues.get(name);
+        return parameter.type === 'trigger' ? false : parameter.defaultValue;
+    }
+    reset() {
+        this._parameterValues.clear();
+        this._runtime?.reset();
+        this._needsUpdate = this._runtime === null;
+        return this;
+    }
+    onEntityRemoveComponent(_entity, component) {
+        if (component === this)
+            this._disposeRuntime();
+    }
+    onEntityRemoveFromWorld(_entity, _world) {
+        this._disposeRuntime();
+    }
+    clone() {
+        const clone = new Animation2DStateMachineComponent(this.animation, {
+            autoplay: this.playing,
+            speed: this.speed,
+            ...(this.runtimeExtensions ? { runtimeExtensions: this.runtimeExtensions } : {}),
+        });
+        for (const parameter of this.stateMachineExtension.stateMachine.parameters) {
+            clone._parameterValues.set(parameter.name, this.getParameter(parameter.name));
+        }
+        clone.disabled = this.disabled;
+        return clone;
+    }
+    _getParameterValues() {
+        return this._parameterValues;
+    }
+    _disposeRuntime() {
+        if (!this._runtime)
+            return;
+        for (const parameter of this.stateMachineExtension.stateMachine.parameters) {
+            this._parameterValues.set(parameter.name, this._runtime.controller.getParameter(parameter.name));
+        }
+        this._runtime.destroy();
+        this._runtime = null;
+        this._needsUpdate = true;
+    }
+    _setParameter(name, type, value) {
+        const parameter = this._requireParameter(name);
+        if (parameter.type !== type) {
+            throw new TypeError(`State-machine parameter "${name}" is ${parameter.type}, not ${type}.`);
+        }
+        this._parameterValues.set(name, value);
+        this._needsUpdate = true;
+    }
+    _requireParameter(name) {
+        const parameter = this._parametersByName.get(name);
+        if (!parameter)
+            throw new ReferenceError(`Unknown state-machine parameter "${name}".`);
+        return parameter;
+    }
+}
+const EMPTY_RUNTIME_STATS = Object.freeze({
+    nodeCount: 0,
+    visualCount: 0,
+    unsupportedComponentCount: 0,
+    pendingResourceCount: 0,
+    failedResourceCount: 0,
+    textCount: 0,
+    particleCount: 0,
+    audioCount: 0,
+});
+const EMPTY_CHANNEL_DIAGNOSTICS = Object.freeze([]);
+function isParsed(source) {
+    return typeof source === 'object' && source !== null && 'source' in source;
+}
+function finiteSpeed(value) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new RangeError('Animation2D state-machine speed must be finite and non-negative.');
+    }
+    return value;
+}
+
+/** State-machine-only pose writer kept out of the ordinary Animation2D bundle. */
+class Animation2DStateMachineVisualRuntime extends Animation2DRuntime {
+    _particleOwners = new Map();
+    _audioOwners = new Map();
+    _effectPayloads = new Map();
+    _diagnostics = [];
+    _reportedAudioRejections = new Set();
+    constructor(owner, animation, runtimeExtensions, assetManager) {
+        super(owner, animation, runtimeExtensions, assetManager);
+        for (const node of this._nodes) {
+            for (const particle of node.particles) {
+                particle.playing = false;
+                particle.emitting = false;
+                particle.clear();
+            }
+            for (const audio of node.audio)
+                audio.exitStateMachine();
+        }
+    }
+    get diagnostics() {
+        return this._diagnostics;
+    }
+    get sideEffectOwnerCount() {
+        return ownerCount(this._particleOwners) + ownerCount(this._audioOwners);
+    }
+    resetSideEffects() {
+        this._particleOwners.clear();
+        this._audioOwners.clear();
+        this._effectPayloads.clear();
+        for (const node of this._nodes) {
+            for (const particle of node.particles) {
+                particle.playing = false;
+                particle.emitting = false;
+                particle.clear();
+            }
+            for (const audio of node.audio)
+                audio.exitStateMachine();
+        }
+    }
+    applyPose(pose, playing = this._playing, speed = this._speed) {
+        this._playing = playing;
+        this._speed = speed;
+        this._opacityMemo.clear();
+        for (const node of this._nodes) {
+            node.entity.disabled = false;
+            node.transform.setPosition(node.initialX, node.initialY);
+            node.transform.rotation = node.initialRotation;
+            node.transform.setScale(node.initialScaleX, node.initialScaleY);
+            node.opacity = node.initialOpacity;
+        }
+        for (const channel of pose.channels) {
+            const node = this._nodesById.get(channel.binding.targetId);
+            if (!node) {
+                throw new ReferenceError(`Animation2D pose references unknown node "${channel.binding.targetId}".`);
+            }
+            switch (channel.binding.path) {
+                case 'transform.position': {
+                    const value = numericPoseValue(channel.value, channel.binding.id, 2);
+                    node.transform.setPosition(value[0], -value[1]);
+                    break;
+                }
+                case 'transform.rotation': {
+                    const value = numericPoseValue(channel.value, channel.binding.id, 1);
+                    node.transform.rotation = -value[0];
+                    break;
+                }
+                case 'transform.scale': {
+                    const value = numericPoseValue(channel.value, channel.binding.id, 2);
+                    node.transform.setScale(value[0], value[1]);
+                    break;
+                }
+                case 'opacity': {
+                    const value = numericPoseValue(channel.value, channel.binding.id, 1);
+                    node.opacity = clamp(value[0], 0, 1);
+                    break;
+                }
+                case 'visibility':
+                    if (typeof channel.value !== 'boolean') {
+                        throw new TypeError(`Animation2D visibility binding "${channel.binding.id}" requires a boolean.`);
+                    }
+                    node.entity.disabled = !channel.value;
+                    break;
+                default:
+                    if (!this._applyStateMachineVisualChannel(node, channel.binding.path, channel.value)) {
+                        throw new RangeError(`Animation2D state-machine runtime does not support pose binding path "${channel.binding.path}".`);
+                    }
+            }
+        }
+        for (const node of this._nodes)
+            this._applyVisualOpacity(node);
+        for (const [key, owners] of this._audioOwners) {
+            if (owners.length === 0)
+                continue;
+            const target = parseEffectTargetKey(key);
+            const node = this._nodesById.get(target.targetId);
+            this._audioTarget(key)?.updateStateMachineProperties(speed, node ? this._resolveOpacity(node) : 1);
+        }
+        for (const effect of pose.effects)
+            this._applyEffect(effect, playing, speed);
+        this._lastAppliedTime = Number.NaN;
+    }
+    setPlaying(playing) {
+        this._playing = playing;
+        for (const [key, owners] of this._particleOwners) {
+            if (owners.length === 0)
+                continue;
+            const target = this._particleTarget(key);
+            if (target)
+                target.playing = playing;
+        }
+        for (const [key, owners] of this._audioOwners) {
+            if (owners.length === 0)
+                continue;
+            const target = this._audioTarget(key);
+            target?.setStateMachinePlaying(playing, this._speed, reason => this._reportAudioRejection(key, reason));
+        }
+    }
+    destroy() {
+        this.resetSideEffects();
+        super.destroy();
+    }
+    _applyVisualOpacity(node) {
+        const opacity = this._resolveOpacity(node);
+        if (node.deferredVisuals.length > 0 && this._isNodeActive(node)) {
+            for (const deferred of node.deferredVisuals.splice(0))
+                this._materializeCoreVisual(node, deferred);
+        }
+        for (const visual of node.visuals) {
+            const alpha = visual.baseAlpha * opacity;
+            if (Math.abs(alpha - visual.lastAlpha) < 1e-6)
+                continue;
+            visual.color[3] = alpha;
+            visual.component.revision++;
+            visual.lastAlpha = alpha;
+        }
+        for (const extension of node.extensions)
+            extension.setOpacity?.(opacity);
+    }
+    _applyEffect(effect, playing, speed) {
+        const payload = effect.cue.payload;
+        if (!payload || typeof payload.targetId !== 'string' || !Number.isSafeInteger(payload.slot)) {
+            throw new TypeError(`Animation2D effect cue "${effect.cue.id}" has an invalid HYA target payload.`);
+        }
+        const key = effectTargetKey(payload);
+        this._effectPayloads.set(key, payload);
+        const owners = effect.cue.kind === 'particle'
+            ? this._particleOwners
+            : this._audioOwners;
+        const stack = owners.get(key) ?? [];
+        if (!owners.has(key))
+            owners.set(key, stack);
+        if (effect.lifecycle === 'enter') {
+            const existing = stack.indexOf(effect.actionId);
+            if (existing >= 0)
+                stack.splice(existing, 1);
+            stack.push(effect.actionId);
+            if (effect.cue.kind === 'particle') {
+                const particle = this._particleTarget(key);
+                if (particle) {
+                    particle.emitting = true;
+                    particle.restart(true);
+                    particle.playing = playing;
+                }
+            }
+            else {
+                const audio = this._audioTarget(key);
+                const node = this._nodesById.get(payload.targetId);
+                const opacity = node ? this._resolveOpacity(node) : 1;
+                audio?.enterStateMachine(playing, speed, opacity, reason => this._reportAudioRejection(key, reason));
+            }
+            return;
+        }
+        if (effect.lifecycle === 'exit') {
+            const index = stack.indexOf(effect.actionId);
+            const wasDominant = index === stack.length - 1;
+            if (index >= 0)
+                stack.splice(index, 1);
+            if (stack.length === 0) {
+                owners.delete(key);
+                if (effect.cue.kind === 'particle') {
+                    const particle = this._particleTarget(key);
+                    if (particle) {
+                        particle.playing = false;
+                        particle.emitting = false;
+                        particle.clear();
+                    }
+                }
+                else
+                    this._audioTarget(key)?.exitStateMachine();
+            }
+            else if (wasDominant && effect.cue.kind === 'particle') {
+                const particle = this._particleTarget(key);
+                if (particle) {
+                    particle.emitting = true;
+                    particle.restart(true);
+                    particle.playing = playing;
+                }
+            }
+            return;
+        }
+        if (stack[stack.length - 1] !== effect.actionId)
+            return;
+        if (effect.lifecycle === 'loop')
+            return;
+        if (effect.cue.kind === 'particle') {
+            const particle = this._particleTarget(key);
+            if (particle) {
+                particle.emitting = true;
+                particle.restart(true);
+                particle.playing = playing;
+            }
+        }
+        else {
+            const audio = this._audioTarget(key);
+            const node = this._nodesById.get(payload.targetId);
+            const opacity = node ? this._resolveOpacity(node) : 1;
+            audio?.restartStateMachine(playing, speed, opacity, reason => this._reportAudioRejection(key, reason));
+        }
+    }
+    _particleTarget(key) {
+        const target = parseEffectTargetKey(key);
+        return this._nodesById.get(target.targetId)?.particles[target.slot];
+    }
+    _audioTarget(key) {
+        const target = parseEffectTargetKey(key);
+        return this._nodesById.get(target.targetId)?.audio[target.slot];
+    }
+    _reportAudioRejection(key, reason) {
+        if (this._reportedAudioRejections.has(key))
+            return;
+        this._reportedAudioRejections.add(key);
+        const target = parseEffectTargetKey(key);
+        const sourcePath = this._effectPayloads.get(key)?.sourcePath
+            ?? `$.nodes[id=${JSON.stringify(target.targetId)}].components[audio=${target.slot}]`;
+        this._diagnostics.push(audioAutoplayRejectedDiagnostic(sourcePath, reason));
+    }
+}
+function effectTargetKey(payload) {
+    return `${payload.targetId}\u0000${payload.slot}`;
+}
+function parseEffectTargetKey(key) {
+    const separator = key.lastIndexOf('\u0000');
+    return {
+        targetId: key.slice(0, separator),
+        slot: Number(key.slice(separator + 1)),
+    };
+}
+function ownerCount(owners) {
+    let count = 0;
+    for (const stack of owners.values())
+        count += stack.length;
+    return count;
+}
+function numericPoseValue(value, bindingId, size) {
+    if (!(value instanceof Float32Array) || value.length < size) {
+        throw new TypeError(`Animation2D numeric binding "${bindingId}" requires ${size} Float32 values.`);
+    }
+    return value;
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+
+/**
+ * Stateful allocation-free sampler. Rotation values are radians and LINEAR
+ * sampling follows the shortest signed arc in [-PI, PI).
+ */
+class Animation2DSampler {
+    track;
+    output;
+    discreteValue;
+    _cursor = 0;
+    constructor(track) {
+        validateTrack(track);
+        this.track = track;
+        this.output = new Float32Array(isNumericBinding(track.binding)
+            ? track.binding.valueSize
+            : 0);
+    }
+    sample(timeSeconds, out = this.output) {
+        if (!Number.isFinite(timeSeconds)) {
+            throw new RangeError(`Animation2D sample time must be finite; received ${timeSeconds}.`);
+        }
+        const keyIndex = this._findKey(timeSeconds);
+        if (!isNumericBinding(this.track.binding)) {
+            this.discreteValue = this.track.values[keyIndex];
+            return this.discreteValue;
+        }
+        const track = this.track;
+        const size = track.binding.valueSize;
+        if (out.length < size) {
+            throw new RangeError(`Animation2D sampler output requires ${size} values; received ${out.length}.`);
+        }
+        const times = track.times;
+        if (keyIndex >= times.length - 1 || track.interpolation === 'step') {
+            copyNumericKey(track, keyIndex, out);
+            return out;
+        }
+        const startTime = times[keyIndex];
+        const linearAlpha = (timeSeconds - startTime) / (times[keyIndex + 1] - startTime);
+        const alpha = track.interpolation === 'cubic-bezier'
+            ? sampleCubicEasing(track.easings, keyIndex, linearAlpha)
+            : linearAlpha;
+        const startOffset = keyIndex * size;
+        const endOffset = startOffset + size;
+        if (track.binding.strategy === 'rotation') {
+            const start = track.values[startOffset];
+            const delta = wrapAngle(track.values[endOffset] - start);
+            out[0] = wrapAngle(start + delta * alpha);
+            return out;
+        }
+        if (track.spatialTangents) {
+            const tangentOffset = keyIndex * 4;
+            for (let component = 0; component < 2; component++) {
+                const start = track.values[startOffset + component];
+                const end = track.values[endOffset + component];
+                out[component] = cubicSpatialCoordinate(alpha, start, start + track.spatialTangents[tangentOffset + component], end + track.spatialTangents[tangentOffset + 2 + component], end);
+            }
+            return out;
+        }
+        for (let component = 0; component < size; component++) {
+            const start = track.values[startOffset + component];
+            out[component] = start
+                + (track.values[endOffset + component] - start) * alpha;
+        }
+        return out;
+    }
+    resetCursor() {
+        this._cursor = 0;
+    }
+    _findKey(timeSeconds) {
+        const times = this.track.times;
+        const last = times.length - 1;
+        if (last === 0 || timeSeconds <= times[0]) {
+            this._cursor = 0;
+            return 0;
+        }
+        if (timeSeconds >= times[last]) {
+            this._cursor = Math.max(0, last - 1);
+            return last;
+        }
+        let cursor = Math.min(this._cursor, last - 1);
+        if (timeSeconds >= times[cursor] && timeSeconds < times[cursor + 1])
+            return cursor;
+        if (timeSeconds >= times[cursor + 1]) {
+            while (cursor + 1 < last && timeSeconds >= times[cursor + 1])
+                cursor++;
+            this._cursor = cursor;
+            return cursor;
+        }
+        let low = 0;
+        let high = cursor;
+        while (low <= high) {
+            const middle = (low + high) >>> 1;
+            if (timeSeconds < times[middle]) {
+                high = middle - 1;
+            }
+            else if (timeSeconds >= times[middle + 1]) {
+                low = middle + 1;
+            }
+            else {
+                this._cursor = middle;
+                return middle;
+            }
+        }
+        this._cursor = Math.max(0, low);
+        return this._cursor;
+    }
+}
+function wrapAngle(value) {
+    const twoPi = Math.PI * 2;
+    let wrapped = (value + Math.PI) % twoPi;
+    if (wrapped < 0)
+        wrapped += twoPi;
+    return wrapped - Math.PI;
+}
+function isNumericBinding(binding) {
+    return binding.strategy === 'continuous' || binding.strategy === 'rotation';
+}
+function copyNumericKey(track, keyIndex, out) {
+    const size = track.binding.valueSize;
+    const offset = keyIndex * size;
+    for (let component = 0; component < size; component++) {
+        out[component] = track.values[offset + component];
+    }
+    if (track.binding.strategy === 'rotation')
+        out[0] = wrapAngle(out[0]);
+}
+function validateTrack(track) {
+    if (!track.id)
+        throw new RangeError('Animation2D track id must not be empty.');
+    if (!track.binding.id)
+        throw new RangeError('Animation2D binding id must not be empty.');
+    if (track.times.length === 0) {
+        throw new RangeError(`Animation2D track "${track.id}" must contain at least one key.`);
+    }
+    for (let index = 0; index < track.times.length; index++) {
+        const time = track.times[index];
+        if (!Number.isFinite(time) || (index > 0 && time <= track.times[index - 1])) {
+            throw new RangeError(`Animation2D track "${track.id}" times must be finite and strictly increasing.`);
+        }
+    }
+    if (isNumericBinding(track.binding)) {
+        const numericTrack = track;
+        const size = track.binding.valueSize ?? 0;
+        if (!Number.isInteger(size) || size <= 0) {
+            throw new RangeError(`Animation2D numeric binding "${track.binding.id}" requires a positive valueSize.`);
+        }
+        if (track.binding.strategy === 'rotation' && size !== 1) {
+            throw new RangeError(`Animation2D rotation binding "${track.binding.id}" must have valueSize 1.`);
+        }
+        const expected = track.times.length * size;
+        if (!(track.values instanceof Float32Array) || track.values.length !== expected) {
+            throw new RangeError(`Animation2D track "${track.id}" requires ${expected} numeric values.`);
+        }
+        if (numericTrack.interpolation === 'cubic-bezier') {
+            const expectedEasings = Math.max(0, track.times.length - 1) * 4;
+            if (!(numericTrack.easings instanceof Float32Array) || numericTrack.easings.length !== expectedEasings) {
+                throw new RangeError(`Animation2D track "${track.id}" requires ${expectedEasings} cubic easing values.`);
+            }
+            for (let index = 0; index < numericTrack.easings.length; index += 4) {
+                const x1 = numericTrack.easings[index];
+                const x2 = numericTrack.easings[index + 2];
+                if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) {
+                    throw new RangeError(`Animation2D track "${track.id}" cubic easing x controls must be in [0, 1].`);
+                }
+            }
+        }
+        else if (numericTrack.easings !== undefined) {
+            throw new RangeError(`Animation2D track "${track.id}" easings require cubic-bezier interpolation.`);
+        }
+        if (numericTrack.spatialTangents !== undefined) {
+            const expectedTangents = Math.max(0, track.times.length - 1) * 4;
+            if (track.binding.path !== 'transform.position' || size !== 2) {
+                throw new RangeError(`Animation2D track "${track.id}" spatialTangents require transform.position/2.`);
+            }
+            if (numericTrack.interpolation === 'step') {
+                throw new RangeError(`Animation2D track "${track.id}" spatialTangents cannot use step.`);
+            }
+            if (!(numericTrack.spatialTangents instanceof Float32Array)
+                || numericTrack.spatialTangents.length !== expectedTangents) {
+                throw new RangeError(`Animation2D track "${track.id}" requires ${expectedTangents} spatialTangents.`);
+            }
+        }
+        return;
+    }
+    if (track.interpolation !== 'step') {
+        throw new RangeError(`Animation2D ${track.binding.strategy} track "${track.id}" must use step interpolation.`);
+    }
+    if (track.values.length !== track.times.length) {
+        throw new RangeError(`Animation2D track "${track.id}" requires one discrete value per key.`);
+    }
+}
+function sampleCubicEasing(easings, segment, x) {
+    const offset = segment * 4;
+    const x1 = easings[offset];
+    const y1 = easings[offset + 1];
+    const x2 = easings[offset + 2];
+    const y2 = easings[offset + 3];
+    let parameter = x;
+    for (let iteration = 0; iteration < 6; iteration++) {
+        const estimate = cubicCoordinate(parameter, x1, x2) - x;
+        const derivative = cubicDerivative(parameter, x1, x2);
+        if (Math.abs(derivative) < 1e-6)
+            break;
+        parameter = Math.min(1, Math.max(0, parameter - estimate / derivative));
+    }
+    return cubicCoordinate(parameter, y1, y2);
+}
+function cubicCoordinate(value, first, second) {
+    const inverse = 1 - value;
+    return 3 * inverse * inverse * value * first
+        + 3 * inverse * value * value * second
+        + value * value * value;
+}
+function cubicDerivative(value, first, second) {
+    const inverse = 1 - value;
+    return 3 * inverse * inverse * first
+        + 6 * inverse * value * (second - first)
+        + 3 * value * value * (1 - second);
+}
+function cubicSpatialCoordinate(value, start, first, second, end) {
+    const inverse = 1 - value;
+    return inverse * inverse * inverse * start
+        + 3 * inverse * inverse * value * first
+        + 3 * inverse * value * value * second
+        + value * value * value * end;
+}
+
+/**
+ * Mutable mixer-owned playback state. Effect lifecycle records and sampler
+ * outputs are allocated at construction and reused on every frame.
+ */
+class Animation2DActionRuntime {
+    id;
+    clip;
+    order;
+    runtimeTracks;
+    runtimeEffects;
+    _owner;
+    _effectActive;
+    _pendingEffects = [];
+    _pendingEffectOutput = {
+        emit: effect => { this._pendingEffects.push(effect); },
+    };
+    _valid = true;
+    _status = 'idle';
+    _paused = false;
+    _time = 0;
+    _rawTime = 0;
+    _timeScale;
+    _weight;
+    _loop;
+    _repetitions;
+    _clampWhenFinished;
+    _blendMode;
+    _mask;
+    _layer;
+    _effectsStarted = false;
+    _fadeActive = false;
+    _fadeStart = 0;
+    _fadeEnd = 0;
+    _fadeFrom = 1;
+    _fadeTo = 1;
+    _fadeValue = 1;
+    constructor(owner, clip, id, order, options = {}) {
+        validateClip(clip);
+        this._owner = owner;
+        this.clip = clip;
+        this.id = id;
+        this.order = order;
+        this._loop = options.loop ?? 'once';
+        this._repetitions = validateRepetitions(options.repetitions ?? (this._loop === 'once' ? 1 : Infinity));
+        this._clampWhenFinished = options.clampWhenFinished ?? false;
+        this._timeScale = finiteNumber(options.timeScale ?? 1, 'Animation2DAction.timeScale');
+        this._weight = nonNegativeNumber(options.weight ?? 1, 'Animation2DAction.weight');
+        this._fadeValue = this._weight;
+        this._layer = integerNumber(options.layer ?? 0, 'Animation2DAction.layer');
+        this._blendMode = options.blendMode ?? 'override';
+        this._mask = options.mask ?? null;
+        const tracks = [];
+        for (let index = 0; index < clip.tracks.length; index++) {
+            const track = clip.tracks[index];
+            const sampler = new Animation2DSampler(track);
+            const reference = isNumericBinding(track.binding)
+                ? new Float32Array(track.binding.valueSize)
+                : new Float32Array(0);
+            if (reference.length > 0)
+                sampler.sample(0, reference);
+            tracks.push({ track, sampler, reference });
+        }
+        this.runtimeTracks = tracks;
+        const effects = [];
+        const sourceEffects = clip.effects ?? [];
+        for (let index = 0; index < sourceEffects.length; index++) {
+            const cue = sourceEffects[index];
+            const start = cue.start;
+            const end = cue.end ?? clip.duration;
+            validateEffect(cue, start, end, clip.duration);
+            effects.push({
+                cue,
+                start,
+                end,
+                fullSpan: start === 0 && end === clip.duration,
+                loopBehavior: cue.loopBehavior ?? (cue.kind === 'particle' ? 'restart' : 'continue'),
+                enterEvent: effectEvent(id, clip.id, cue, 'enter'),
+                exitEvent: effectEvent(id, clip.id, cue, 'exit'),
+                restartEvent: effectEvent(id, clip.id, cue, 'restart'),
+                loopEvent: effectEvent(id, clip.id, cue, 'loop'),
+                seekEvent: effectEvent(id, clip.id, cue, 'seek'),
+            });
+        }
+        this.runtimeEffects = effects;
+        this._effectActive = new Uint8Array(effects.length);
+    }
+    get duration() { return this.clip.duration; }
+    get status() { return this._status; }
+    get paused() { return this._paused; }
+    set paused(value) {
+        this._assertValid();
+        this._paused = Boolean(value);
+        if (this._paused && this._status === 'running')
+            this._status = 'paused';
+        else if (!this._paused && this._status === 'paused')
+            this._status = 'running';
+    }
+    get time() { return this._time; }
+    set time(value) { this.seek(value); }
+    get timeScale() { return this._timeScale; }
+    set timeScale(value) {
+        this._assertValid();
+        this._timeScale = finiteNumber(value, 'Animation2DAction.timeScale');
+    }
+    get weight() { return this._weight; }
+    set weight(value) {
+        this._assertValid();
+        this._weight = nonNegativeNumber(value, 'Animation2DAction.weight');
+        this._fadeActive = false;
+        this._fadeValue = this._weight;
+    }
+    get layer() { return this._layer; }
+    set layer(value) {
+        this._assertValid();
+        this._layer = integerNumber(value, 'Animation2DAction.layer');
+    }
+    get loop() { return this._loop; }
+    set loop(value) {
+        this._assertValid();
+        if (value !== 'once' && value !== 'repeat' && value !== 'ping-pong') {
+            throw new RangeError(`Unsupported Animation2D loop mode "${String(value)}".`);
+        }
+        this._loop = value;
+        this._setSampleTime(0);
+    }
+    get repetitions() { return this._repetitions; }
+    set repetitions(value) {
+        this._assertValid();
+        this._repetitions = validateRepetitions(value);
+    }
+    get clampWhenFinished() { return this._clampWhenFinished; }
+    set clampWhenFinished(value) {
+        this._assertValid();
+        this._clampWhenFinished = Boolean(value);
+    }
+    get blendMode() { return this._blendMode; }
+    set blendMode(value) {
+        this._assertValid();
+        if (value !== 'override' && value !== 'additive') {
+            throw new RangeError(`Unsupported Animation2D blend mode "${String(value)}".`);
+        }
+        this._blendMode = value;
+    }
+    get mask() { return this._mask; }
+    set mask(value) {
+        this._assertValid();
+        this._mask = value;
+    }
+    get effectiveWeight() {
+        if (!this._valid || this._paused || (this._status !== 'running'
+            && !(this._status === 'finished' && this._clampWhenFinished)))
+            return 0;
+        return this._fadeFactor(this._owner.time);
+    }
+    play() {
+        this._assertValid();
+        if (this._status === 'finished' && !this._clampWhenFinished) {
+            this._rawTime = this._timeScale < 0 ? this.clip.duration : 0;
+            this._setSampleTime(0);
+            this._effectsStarted = false;
+        }
+        this._paused = false;
+        this._status = 'running';
+        return this;
+    }
+    pause() {
+        this.paused = true;
+        return this;
+    }
+    stop() {
+        this._assertValid();
+        this._queueActiveExits();
+        this._paused = false;
+        this._status = 'stopped';
+        this._effectsStarted = false;
+        return this;
+    }
+    reset() {
+        this._assertValid();
+        this._queueActiveExits();
+        this._paused = false;
+        this._status = 'idle';
+        this._rawTime = 0;
+        this._time = 0;
+        this._effectsStarted = false;
+        this._fadeActive = false;
+        this._fadeValue = this._weight;
+        this._resetSamplerCursors();
+        return this;
+    }
+    seek(timeSeconds) {
+        this._assertValid();
+        const next = Math.min(this.clip.duration, Math.max(0, finiteNumber(timeSeconds, 'Animation2DAction.time')));
+        for (let index = 0; index < this.runtimeEffects.length; index++) {
+            const wasActive = this._effectActive[index] !== 0;
+            const active = effectActiveAt(this.runtimeEffects[index], next, this.clip.duration);
+            const effect = this.runtimeEffects[index];
+            if (wasActive && !active)
+                this._pendingEffects.push(effect.exitEvent);
+            this._pendingEffects.push(effect.seekEvent);
+            if (!wasActive && active)
+                this._pendingEffects.push(effect.enterEvent);
+            this._effectActive[index] = active ? 1 : 0;
+        }
+        this._rawTime = next;
+        this._time = next;
+        this._effectsStarted = true;
+        this._resetSamplerCursors();
+        return this;
+    }
+    /**
+     * Advances a controller-owned absolute playhead without classifying the
+     * move as a seek. Crossed side-effect boundaries are queued exactly once.
+     */
+    synchronizeTime(timeSeconds) {
+        this._assertValid();
+        const after = this._clampSynchronizedTime(timeSeconds);
+        const terminalDirection = this._terminalDirection(after);
+        if (!this._effectsStarted) {
+            this._emitInitialEffects(this._pendingEffectOutput);
+            this._effectsStarted = true;
+        }
+        this._emitEffectCrossings(this._rawTime, after, this._pendingEffectOutput, terminalDirection);
+        this._rawTime = after;
+        this._setSampleTime(terminalDirection);
+        this._syncEffectActivity(terminalDirection);
+        this._resetSamplerCursors();
+        return this;
+    }
+    reverse() {
+        this._assertValid();
+        this._timeScale = -Math.max(Number.EPSILON, Math.abs(this._timeScale));
+        return this;
+    }
+    fadeTo(targetWeight, durationSeconds) {
+        this._assertValid();
+        const target = nonNegativeNumber(targetWeight, 'Animation2DAction.fade target');
+        const duration = nonNegativeNumber(durationSeconds, 'Animation2DAction.fade duration');
+        this._scheduleFade(this._fadeFactor(this._owner.time), target, duration);
+        return this;
+    }
+    fadeIn(durationSeconds) {
+        this._assertValid();
+        const duration = nonNegativeNumber(durationSeconds, 'Animation2DAction.fade duration');
+        this._scheduleFade(0, this._weight > 0 ? this._weight : 1, duration);
+        return this;
+    }
+    fadeOut(durationSeconds) {
+        return this.fadeTo(0, durationSeconds);
+    }
+    crossFadeFrom(source, durationSeconds) {
+        this._assertSibling(source);
+        source.play().fadeOut(durationSeconds);
+        this.play().fadeIn(durationSeconds);
+        return this;
+    }
+    crossFadeTo(destination, durationSeconds) {
+        this._assertSibling(destination);
+        destination.crossFadeFrom(this, durationSeconds);
+        return this;
+    }
+    acceptsBinding(binding) {
+        const include = this._mask?.include;
+        if (include && include.length > 0) {
+            let accepted = false;
+            for (let index = 0; index < include.length; index++) {
+                if (include[index] === binding.id) {
+                    accepted = true;
+                    break;
+                }
+            }
+            if (!accepted)
+                return false;
+        }
+        const exclude = this._mask?.exclude;
+        if (exclude) {
+            for (let index = 0; index < exclude.length; index++) {
+                if (exclude[index] === binding.id)
+                    return false;
+            }
+        }
+        return true;
+    }
+    flushPendingEffects(out) {
+        for (let index = 0; index < this._pendingEffects.length; index++) {
+            out.emit(this._pendingEffects[index]);
+        }
+        this._pendingEffects.length = 0;
+    }
+    advance(mixerDelta, out) {
+        if (!this._valid)
+            return;
+        this._finishFade(this._owner.time);
+        this.flushPendingEffects(out);
+        if (this._paused || this._status !== 'running')
+            return;
+        if (!this._effectsStarted) {
+            this._emitInitialEffects(out);
+            this._effectsStarted = true;
+        }
+        const actionDelta = mixerDelta * this._timeScale;
+        if (actionDelta === 0 || this.clip.duration === 0)
+            return;
+        const before = this._rawTime;
+        let after = before + actionDelta;
+        let terminalDirection = 0;
+        const totalDuration = this._loop === 'once'
+            ? this.clip.duration
+            : this._repetitions === Infinity
+                ? Infinity
+                : this.clip.duration * this._repetitions;
+        if (totalDuration !== Infinity) {
+            if (actionDelta > 0 && after >= totalDuration) {
+                after = totalDuration;
+                terminalDirection = 1;
+            }
+            else if (actionDelta < 0 && after <= 0) {
+                after = 0;
+                terminalDirection = -1;
+            }
+        }
+        this._emitEffectCrossings(before, after, out, terminalDirection);
+        this._rawTime = after;
+        this._setSampleTime(terminalDirection);
+        this._syncEffectActivity(terminalDirection);
+        if (terminalDirection !== 0) {
+            this._status = 'finished';
+            if (!this._clampWhenFinished)
+                this._queueActiveExits();
+        }
+    }
+    /** @internal Allocates one checkpoint that can be reused for every update. */
+    createSynchronizedState() {
+        return {
+            status: this._status,
+            paused: this._paused,
+            time: this._time,
+            rawTime: this._rawTime,
+            timeScale: this._timeScale,
+            weight: this._weight,
+            loop: this._loop,
+            repetitions: this._repetitions,
+            clampWhenFinished: this._clampWhenFinished,
+            blendMode: this._blendMode,
+            mask: this._mask,
+            layer: this._layer,
+            effectsStarted: this._effectsStarted,
+            fadeActive: this._fadeActive,
+            fadeStart: this._fadeStart,
+            fadeEnd: this._fadeEnd,
+            fadeFrom: this._fadeFrom,
+            fadeTo: this._fadeTo,
+            fadeValue: this._fadeValue,
+            effectActive: new Uint8Array(this._effectActive.length),
+            pendingEffects: [],
+        };
+    }
+    /** @internal Captures playhead, fade, and effect-cursor state without sampling. */
+    captureSynchronizedState(state) {
+        this._assertValid();
+        if (state.effectActive.length !== this._effectActive.length) {
+            throw new RangeError('Animation2D action checkpoint has an incompatible effect count.');
+        }
+        state.status = this._status;
+        state.paused = this._paused;
+        state.time = this._time;
+        state.rawTime = this._rawTime;
+        state.timeScale = this._timeScale;
+        state.weight = this._weight;
+        state.loop = this._loop;
+        state.repetitions = this._repetitions;
+        state.clampWhenFinished = this._clampWhenFinished;
+        state.blendMode = this._blendMode;
+        state.mask = this._mask;
+        state.layer = this._layer;
+        state.effectsStarted = this._effectsStarted;
+        state.fadeActive = this._fadeActive;
+        state.fadeStart = this._fadeStart;
+        state.fadeEnd = this._fadeEnd;
+        state.fadeFrom = this._fadeFrom;
+        state.fadeTo = this._fadeTo;
+        state.fadeValue = this._fadeValue;
+        state.effectActive.set(this._effectActive);
+        state.pendingEffects.length = 0;
+        for (const effect of this._pendingEffects)
+            state.pendingEffects.push(effect);
+    }
+    /** @internal Restores an exact controller transaction checkpoint. */
+    restoreSynchronizedState(state) {
+        this._assertValid();
+        if (state.effectActive.length !== this._effectActive.length) {
+            throw new RangeError('Animation2D action checkpoint has an incompatible effect count.');
+        }
+        this._status = state.status;
+        this._paused = state.paused;
+        this._time = state.time;
+        this._rawTime = state.rawTime;
+        this._timeScale = state.timeScale;
+        this._weight = state.weight;
+        this._loop = state.loop;
+        this._repetitions = state.repetitions;
+        this._clampWhenFinished = state.clampWhenFinished;
+        this._blendMode = state.blendMode;
+        this._mask = state.mask;
+        this._layer = state.layer;
+        this._effectsStarted = state.effectsStarted;
+        this._fadeActive = state.fadeActive;
+        this._fadeStart = state.fadeStart;
+        this._fadeEnd = state.fadeEnd;
+        this._fadeFrom = state.fadeFrom;
+        this._fadeTo = state.fadeTo;
+        this._fadeValue = state.fadeValue;
+        this._effectActive.set(state.effectActive);
+        this._pendingEffects.length = 0;
+        for (const effect of state.pendingEffects)
+            this._pendingEffects.push(effect);
+        this._resetSamplerCursors();
+    }
+    invalidate() {
+        if (!this._valid)
+            return;
+        this._valid = false;
+        this._status = 'stopped';
+        this._paused = false;
+        this._fadeActive = false;
+        this._pendingEffects.length = 0;
+        this._effectActive.fill(0);
+    }
+    _setSampleTime(terminalDirection) {
+        const duration = this.clip.duration;
+        if (duration === 0) {
+            this._time = 0;
+            return;
+        }
+        if (this._loop === 'once') {
+            this._time = Math.min(duration, Math.max(0, this._rawTime));
+            return;
+        }
+        if (terminalDirection > 0 && this._loop === 'repeat') {
+            this._time = duration;
+            return;
+        }
+        const traversal = Math.floor(this._rawTime / duration);
+        let phase = this._rawTime - traversal * duration;
+        if (phase < 0)
+            phase += duration;
+        if (this._loop === 'repeat') {
+            this._time = phase;
+        }
+        else {
+            this._time = isEven(traversal) ? phase : duration - phase;
+        }
+    }
+    _emitInitialEffects(out) {
+        for (let index = 0; index < this.runtimeEffects.length; index++) {
+            const active = effectActiveAt(this.runtimeEffects[index], this._time, this.clip.duration);
+            this._effectActive[index] = active ? 1 : 0;
+            if (active)
+                out.emit(this.runtimeEffects[index].enterEvent);
+        }
+    }
+    _emitEffectCrossings(before, after, out, terminalDirection = 0) {
+        if (before === after || this.runtimeEffects.length === 0)
+            return;
+        if (this._loop === 'repeat') {
+            this._emitRepeatEffectCrossings(before, after, out, terminalDirection);
+            return;
+        }
+        if (this._loop === 'once') {
+            this._emitOnceEffectCrossings(before, after, out);
+            return;
+        }
+        this._emitPingPongEffectCrossings(before, after, out, terminalDirection);
+    }
+    _emitOnceEffectCrossings(before, after, out) {
+        for (let index = 0; index < this.runtimeEffects.length; index++) {
+            const effect = this.runtimeEffects[index];
+            if (after > before) {
+                if (effect.start > before && effect.start <= after)
+                    out.emit(effect.enterEvent);
+                if (effect.end > before && effect.end <= after)
+                    out.emit(effect.exitEvent);
+            }
+            else {
+                if (effect.end < before && effect.end >= after)
+                    out.emit(effect.enterEvent);
+                if (effect.start < before && effect.start >= after)
+                    out.emit(effect.exitEvent);
+            }
+        }
+    }
+    _emitRepeatEffectCrossings(before, after, out, terminalDirection) {
+        const duration = this.clip.duration;
+        const minimum = Math.min(before, after);
+        const maximum = Math.max(before, after);
+        const firstCycle = Math.floor(minimum / duration) - 1;
+        const lastCycle = Math.floor(maximum / duration) + 1;
+        for (let effectIndex = 0; effectIndex < this.runtimeEffects.length; effectIndex++) {
+            const effect = this.runtimeEffects[effectIndex];
+            if (effect.fullSpan) {
+                if (after > before) {
+                    for (let cycle = firstCycle; cycle <= lastCycle; cycle++) {
+                        const boundary = cycle * duration;
+                        if (boundary > before && boundary <= after) {
+                            if (terminalDirection > 0 && boundary === after)
+                                out.emit(effect.exitEvent);
+                            else
+                                this._emitLoopEffect(effect, out);
+                        }
+                    }
+                }
+                else {
+                    for (let cycle = lastCycle; cycle >= firstCycle; cycle--) {
+                        const boundary = cycle * duration;
+                        if (boundary < before && boundary >= after) {
+                            if (terminalDirection < 0 && boundary === after)
+                                out.emit(effect.exitEvent);
+                            else
+                                this._emitLoopEffect(effect, out);
+                        }
+                    }
+                }
+                continue;
+            }
+            if (after > before) {
+                for (let cycle = firstCycle; cycle <= lastCycle; cycle++) {
+                    const cycleStart = cycle * duration;
+                    const enter = cycleStart + effect.start;
+                    const exit = cycleStart + effect.end;
+                    if (enter > before && enter <= after
+                        && !(terminalDirection > 0 && enter === after))
+                        out.emit(effect.enterEvent);
+                    if (exit > before && exit <= after)
+                        out.emit(effect.exitEvent);
+                }
+            }
+            else {
+                for (let cycle = lastCycle; cycle >= firstCycle; cycle--) {
+                    const cycleStart = cycle * duration;
+                    const enter = cycleStart + effect.end;
+                    const exit = cycleStart + effect.start;
+                    if (enter < before && enter >= after
+                        && !(terminalDirection < 0 && enter === after))
+                        out.emit(effect.enterEvent);
+                    if (exit < before && exit >= after)
+                        out.emit(effect.exitEvent);
+                }
+            }
+        }
+    }
+    _emitPingPongEffectCrossings(before, after, out, terminalDirection) {
+        const duration = this.clip.duration;
+        const minimum = Math.min(before, after);
+        const maximum = Math.max(before, after);
+        const firstTraversal = Math.floor(minimum / duration) - 1;
+        const lastTraversal = Math.floor(maximum / duration) + 1;
+        for (let effectIndex = 0; effectIndex < this.runtimeEffects.length; effectIndex++) {
+            const effect = this.runtimeEffects[effectIndex];
+            if (effect.fullSpan) {
+                if (after > before) {
+                    for (let traversal = firstTraversal; traversal <= lastTraversal; traversal++) {
+                        const boundary = traversal * duration;
+                        if (boundary <= before || boundary > after)
+                            continue;
+                        if (terminalDirection > 0 && boundary === after)
+                            out.emit(effect.exitEvent);
+                        else
+                            this._emitLoopEffect(effect, out);
+                    }
+                }
+                else {
+                    for (let traversal = lastTraversal; traversal >= firstTraversal; traversal--) {
+                        const boundary = traversal * duration;
+                        if (boundary >= before || boundary < after)
+                            continue;
+                        if (terminalDirection < 0 && boundary === after)
+                            out.emit(effect.exitEvent);
+                        else
+                            this._emitLoopEffect(effect, out);
+                    }
+                }
+                continue;
+            }
+            if (after > before) {
+                for (let traversal = firstTraversal; traversal <= lastTraversal; traversal++) {
+                    const traversalStart = traversal * duration;
+                    const forward = isEven(traversal);
+                    const enter = traversalStart + (forward ? effect.start : duration - effect.end);
+                    const exit = traversalStart + (forward ? effect.end : duration - effect.start);
+                    if (enter > before && enter <= after
+                        && !(terminalDirection > 0 && enter === after))
+                        out.emit(effect.enterEvent);
+                    if (exit > before && exit <= after)
+                        out.emit(effect.exitEvent);
+                }
+            }
+            else {
+                for (let traversal = lastTraversal; traversal >= firstTraversal; traversal--) {
+                    const traversalStart = traversal * duration;
+                    const forward = isEven(traversal);
+                    const forwardEnter = traversalStart
+                        + (forward ? effect.start : duration - effect.end);
+                    const forwardExit = traversalStart
+                        + (forward ? effect.end : duration - effect.start);
+                    if (forwardExit < before && forwardExit >= after
+                        && !(terminalDirection < 0 && forwardExit === after))
+                        out.emit(effect.enterEvent);
+                    if (forwardEnter < before && forwardEnter >= after)
+                        out.emit(effect.exitEvent);
+                }
+            }
+        }
+    }
+    _emitLoopEffect(effect, out) {
+        out.emit(effect.loopBehavior === 'restart' ? effect.restartEvent : effect.loopEvent);
+    }
+    _syncEffectActivity(terminalDirection = 0) {
+        for (let index = 0; index < this.runtimeEffects.length; index++) {
+            const effect = this.runtimeEffects[index];
+            const active = effect.fullSpan && this._loop === 'ping-pong'
+                ? terminalDirection === 0
+                : effectActiveAt(effect, this._time, this.clip.duration);
+            this._effectActive[index] = active ? 1 : 0;
+        }
+    }
+    _queueActiveExits() {
+        for (let index = 0; index < this._effectActive.length; index++) {
+            if (this._effectActive[index] === 0)
+                continue;
+            this._pendingEffects.push(this.runtimeEffects[index].exitEvent);
+            this._effectActive[index] = 0;
+        }
+    }
+    _scheduleFade(from, to, duration) {
+        this._fadeFrom = from;
+        this._fadeTo = to;
+        this._fadeStart = this._owner.time;
+        this._fadeEnd = this._fadeStart + duration;
+        if (duration === 0) {
+            this._weight = to;
+            this._fadeValue = to;
+            this._fadeActive = false;
+        }
+        else {
+            this._fadeValue = from;
+            this._fadeActive = true;
+        }
+    }
+    _fadeFactor(time) {
+        if (!this._fadeActive)
+            return this._fadeValue;
+        if (time <= this._fadeStart)
+            return this._fadeFrom;
+        if (time >= this._fadeEnd)
+            return this._fadeTo;
+        const alpha = (time - this._fadeStart) / (this._fadeEnd - this._fadeStart);
+        return this._fadeFrom + (this._fadeTo - this._fadeFrom) * alpha;
+    }
+    _finishFade(time) {
+        if (!this._fadeActive || time < this._fadeEnd)
+            return;
+        this._weight = this._fadeTo;
+        this._fadeValue = this._fadeTo;
+        this._fadeActive = false;
+    }
+    _assertSibling(action) {
+        this._assertValid();
+        if (action._owner !== this._owner || !action._valid) {
+            throw new RangeError('Animation2D cross-fade actions must belong to the same active mixer.');
+        }
+    }
+    _clampSynchronizedTime(timeSeconds) {
+        const next = finiteNumber(timeSeconds, 'Animation2DAction synchronized time');
+        if (this._loop === 'once')
+            return Math.min(this.clip.duration, Math.max(0, next));
+        if (this._repetitions === Infinity)
+            return next;
+        return Math.min(this.clip.duration * this._repetitions, Math.max(0, next));
+    }
+    _terminalDirection(time) {
+        if (this._loop === 'once') {
+            if (time === this.clip.duration && this._rawTime < time)
+                return 1;
+            if (time === 0 && this._rawTime > time)
+                return -1;
+            return 0;
+        }
+        if (this._repetitions === Infinity)
+            return 0;
+        const totalDuration = this.clip.duration * this._repetitions;
+        if (time === totalDuration && this._rawTime < time)
+            return 1;
+        if (time === 0 && this._rawTime > time)
+            return -1;
+        return 0;
+    }
+    _resetSamplerCursors() {
+        for (let index = 0; index < this.runtimeTracks.length; index++) {
+            this.runtimeTracks[index].sampler.resetCursor();
+        }
+    }
+    _assertValid() {
+        this._owner.assertActive();
+        if (!this._valid)
+            throw new Error(`Animation2D action "${this.id}" is no longer valid.`);
+    }
+}
+function effectEvent(actionId, clipId, cue, lifecycle) {
+    return { actionId, clipId, cue, lifecycle };
+}
+function effectActiveAt(effect, time, duration) {
+    if (effect.fullSpan)
+        return time >= 0 && time < duration;
+    return time >= effect.start && time < effect.end;
+}
+function validateClip(clip) {
+    if (clip.format !== 'haiyue-animation2d-clip@1') {
+        throw new RangeError(`Unsupported Animation2D clip format "${String(clip.format)}".`);
+    }
+    if (!clip.id)
+        throw new RangeError('Animation2D clip id must not be empty.');
+    if (!Number.isFinite(clip.duration) || clip.duration < 0) {
+        throw new RangeError(`Animation2D clip duration must be finite and non-negative; received ${clip.duration}.`);
+    }
+    for (let index = 0; index < clip.tracks.length; index++) {
+        const track = clip.tracks[index];
+        const first = track.times[0];
+        const last = track.times[track.times.length - 1];
+        if (first !== undefined && (first < 0 || last > clip.duration)) {
+            throw new RangeError(`Animation2D track "${track.id}" keys must lie within its clip.`);
+        }
+    }
+}
+function validateEffect(cue, start, end, duration) {
+    if (!cue.id)
+        throw new RangeError('Animation2D effect cue id must not be empty.');
+    if (!Number.isFinite(start) || !Number.isFinite(end)
+        || start < 0 || end < start || end > duration) {
+        throw new RangeError(`Animation2D effect "${cue.id}" interval must lie within its clip.`);
+    }
+}
+function validateRepetitions(value) {
+    if (value === Infinity)
+        return value;
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new RangeError(`Animation2D repetitions must be a positive integer or Infinity; received ${value}.`);
+    }
+    return value;
+}
+function finiteNumber(value, property) {
+    if (!Number.isFinite(value))
+        throw new RangeError(`${property} must be finite; received ${value}.`);
+    return value;
+}
+function nonNegativeNumber(value, property) {
+    const result = finiteNumber(value, property);
+    if (result < 0)
+        throw new RangeError(`${property} must be non-negative; received ${value}.`);
+    return result;
+}
+function integerNumber(value, property) {
+    if (!Number.isInteger(value))
+        throw new RangeError(`${property} must be an integer; received ${value}.`);
+    return value;
+}
+function isEven(value) {
+    return Math.abs(value % 2) === 0;
+}
+
+/**
+ * Format-independent 2D pose mixer and shared state-machine mixer port.
+ *
+ * Action/track/layer accumulators are retained across frames. Once actions
+ * and their masks/layers have been warmed, update/evaluate allocates no
+ * action- or property-proportional temporary objects.
+ */
+class Animation2DMixerRuntime {
+    _clips = new Map();
+    _actions = [];
+    _actionsById = new Map();
+    _accumulators = new Map();
+    _accumulatorList = [];
+    _stateMachineLayers = new Map();
+    _destroyed = false;
+    _time = 0;
+    _timeScale = 1;
+    _nextActionId = 1;
+    _nextActionOrder = 0;
+    _nextStateMachineLayer = 0;
+    constructor(clips = []) {
+        for (let index = 0; index < clips.length; index++)
+            this.registerClip(clips[index]);
+    }
+    get time() { return this._time; }
+    get timeScale() { return this._timeScale; }
+    set timeScale(value) {
+        this.assertActive();
+        if (!Number.isFinite(value)) {
+            throw new RangeError(`Animation2D mixer timeScale must be finite; received ${value}.`);
+        }
+        this._timeScale = value;
+    }
+    get actions() { return this._actions; }
+    get liveBindingCount() { return this._accumulators.size; }
+    registerClip(clip) {
+        this.assertActive();
+        const existing = this._clips.get(clip.id);
+        if (existing && existing !== clip) {
+            throw new RangeError(`Animation2D clip id "${clip.id}" is already registered.`);
+        }
+        this._clips.set(clip.id, clip);
+        return this;
+    }
+    unregisterClip(clipId) {
+        this.assertActive();
+        return this._clips.delete(clipId);
+    }
+    createAction(source, options = {}) {
+        this.assertActive();
+        const clip = typeof source === 'string' ? this._clips.get(source) : source;
+        if (!clip)
+            throw new RangeError(`Animation2D clip "${String(source)}" is not registered.`);
+        const stateOptions = isStateMachineOptions(options) ? options : null;
+        const runtimeOptions = stateOptions ? null : options;
+        const layer = stateOptions
+            ? this._stateMachineLayer(stateOptions.layerId)
+            : runtimeOptions.layer ?? 0;
+        const id = runtimeOptions?.id
+            ? runtimeOptions.id
+            : `${clip.id}:${stateOptions?.stateId ?? 'action'}:${this._nextActionId++}`;
+        if (!id)
+            throw new RangeError('Animation2D action id must not be empty.');
+        if (this._actionsById.has(id)) {
+            throw new RangeError(`Animation2D action id "${id}" already exists.`);
+        }
+        const actionOptions = stateOptions
+            ? {
+                id,
+                layer,
+                loop: stateOptions.loop,
+                blendMode: stateOptions.blendMode,
+                ...(stateOptions.mask ? { mask: stateOptions.mask } : {}),
+            }
+            : { ...runtimeOptions, id, layer };
+        const action = new Animation2DActionRuntime(this, clip, id, this._nextActionOrder++, actionOptions);
+        for (let index = 0; index < action.runtimeTracks.length; index++) {
+            this._retainBinding(action.runtimeTracks[index].track.binding, layer);
+        }
+        this._actions.push(action);
+        this._actionsById.set(id, action);
+        return action;
+    }
+    getAction(actionId) {
+        this.assertActive();
+        return this._actionsById.get(actionId) ?? null;
+    }
+    removeAction(action) {
+        this.assertActive();
+        const runtime = typeof action === 'string' ? this._actionsById.get(action) : action;
+        if (!runtime || this._actionsById.get(runtime.id) !== runtime)
+            return false;
+        const index = this._actions.indexOf(runtime);
+        if (index >= 0)
+            this._actions.splice(index, 1);
+        this._actionsById.delete(runtime.id);
+        for (let trackIndex = 0; trackIndex < runtime.runtimeTracks.length; trackIndex++) {
+            this._releaseBinding(runtime.runtimeTracks[trackIndex].track.binding);
+        }
+        runtime.invalidate();
+        return true;
+    }
+    update(deltaSeconds, out) {
+        this.assertActive();
+        if (!Number.isFinite(deltaSeconds)) {
+            throw new RangeError(`Animation2D mixer delta must be finite; received ${deltaSeconds}.`);
+        }
+        const mixerDelta = deltaSeconds * this._timeScale;
+        this._time += mixerDelta;
+        out.reset(this._time);
+        this._advanceActions(mixerDelta, out);
+        this._evaluateInto(out);
+        return out.seal();
+    }
+    evaluate(out) {
+        this.assertActive();
+        out.reset(this._time);
+        for (let index = 0; index < this._actions.length; index++) {
+            this._actions[index].flushPendingEffects(out);
+        }
+        this._evaluateInto(out);
+        return out.seal();
+    }
+    setMixerTime(timeSeconds, out) {
+        this.assertActive();
+        if (!Number.isFinite(timeSeconds)) {
+            throw new RangeError(`Animation2D mixer time must be finite; received ${timeSeconds}.`);
+        }
+        const delta = timeSeconds - this._time;
+        this._time = timeSeconds;
+        out.reset(this._time);
+        this._advanceActions(delta, out);
+        this._evaluateInto(out);
+        return out.seal();
+    }
+    play(action) {
+        this._assertOwned(action);
+        action.play();
+    }
+    stop(action) {
+        this._assertOwned(action);
+        action.stop();
+    }
+    fade(action, targetWeight, durationSeconds) {
+        this._assertOwned(action);
+        action.fadeTo(targetWeight, durationSeconds);
+    }
+    setWeight(action, weight) {
+        this._assertOwned(action);
+        action.weight = weight;
+    }
+    setTime(action, timeSeconds) {
+        this._assertOwned(action);
+        action.synchronizeTime(timeSeconds);
+    }
+    setTimeScale(action, timeScale) {
+        this._assertOwned(action);
+        action.timeScale = timeScale;
+    }
+    destroyAction(action) {
+        this.removeAction(action);
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        for (let index = 0; index < this._actions.length; index++)
+            this._actions[index].invalidate();
+        this._actions.length = 0;
+        this._actionsById.clear();
+        this._accumulators.clear();
+        this._accumulatorList.length = 0;
+        this._clips.clear();
+        this._stateMachineLayers.clear();
+        this._destroyed = true;
+    }
+    assertActive() {
+        if (this._destroyed)
+            throw new Error('Animation2D mixer has been destroyed.');
+    }
+    _advanceActions(mixerDelta, out) {
+        for (let index = 0; index < this._actions.length; index++) {
+            this._actions[index].advance(mixerDelta, out);
+        }
+    }
+    _evaluateInto(out) {
+        for (let index = 0; index < this._accumulatorList.length; index++) {
+            resetAccumulator(this._accumulatorList[index]);
+        }
+        for (let actionIndex = 0; actionIndex < this._actions.length; actionIndex++) {
+            const action = this._actions[actionIndex];
+            const weight = action.effectiveWeight;
+            if (weight <= 0)
+                continue;
+            for (let trackIndex = 0; trackIndex < action.runtimeTracks.length; trackIndex++) {
+                const runtimeTrack = action.runtimeTracks[trackIndex];
+                const binding = runtimeTrack.track.binding;
+                if (!action.acceptsBinding(binding))
+                    continue;
+                const accumulator = this._accumulators.get(binding.id);
+                if (!accumulator)
+                    continue;
+                let layer = accumulator.layersById.get(action.layer);
+                if (!layer) {
+                    layer = createLayerAccumulator(binding, action.layer);
+                    insertLayer(accumulator, layer);
+                }
+                accumulator.active = true;
+                const sampled = runtimeTrack.sampler.sample(action.time);
+                if (isNumericBinding(binding)) {
+                    accumulateNumeric(layer, binding, runtimeTrack, sampled, weight, action.blendMode);
+                }
+                else {
+                    accumulateDominant(layer, sampled, weight, action.order);
+                }
+            }
+        }
+        for (let index = 0; index < this._accumulatorList.length; index++) {
+            const accumulator = this._accumulatorList[index];
+            if (!accumulator.active)
+                continue;
+            if (isNumericBinding(accumulator.binding)) {
+                finalizeNumeric(accumulator);
+                out.writeNumeric(accumulator.binding, accumulator.result);
+            }
+            else {
+                let hasValue = false;
+                let value;
+                for (let layerIndex = 0; layerIndex < accumulator.layers.length; layerIndex++) {
+                    const layer = accumulator.layers[layerIndex];
+                    if (!layer.dominantSet)
+                        continue;
+                    hasValue = true;
+                    value = layer.dominantValue;
+                }
+                if (hasValue)
+                    out.writeDiscrete(accumulator.binding, value);
+            }
+        }
+    }
+    _retainBinding(binding, layer) {
+        const existing = this._accumulators.get(binding.id);
+        if (existing) {
+            if (existing.binding.strategy !== binding.strategy
+                || existing.binding.valueSize !== binding.valueSize) {
+                throw new RangeError(`Animation2D binding id "${binding.id}" has incompatible contracts.`);
+            }
+            existing.references++;
+            if (!existing.layersById.has(layer))
+                insertLayer(existing, createLayerAccumulator(binding, layer));
+            return;
+        }
+        const size = isNumericBinding(binding) ? binding.valueSize : 0;
+        const accumulator = {
+            binding,
+            result: new Float32Array(size),
+            base: new Float32Array(size),
+            layers: [],
+            layersById: new Map(),
+            references: 1,
+            active: false,
+        };
+        writeDefaultBase(binding, accumulator.base);
+        insertLayer(accumulator, createLayerAccumulator(binding, layer));
+        this._accumulators.set(binding.id, accumulator);
+        this._accumulatorList.push(accumulator);
+    }
+    _releaseBinding(binding) {
+        const accumulator = this._accumulators.get(binding.id);
+        if (!accumulator)
+            return;
+        accumulator.references--;
+        if (accumulator.references > 0)
+            return;
+        this._accumulators.delete(binding.id);
+        const index = this._accumulatorList.indexOf(accumulator);
+        if (index >= 0)
+            this._accumulatorList.splice(index, 1);
+    }
+    _stateMachineLayer(layerId) {
+        const existing = this._stateMachineLayers.get(layerId);
+        if (existing !== undefined)
+            return existing;
+        const layer = this._nextStateMachineLayer++;
+        this._stateMachineLayers.set(layerId, layer);
+        return layer;
+    }
+    _assertOwned(action) {
+        this.assertActive();
+        if (this._actionsById.get(action.id) !== action) {
+            throw new RangeError('Animation2D action does not belong to this mixer.');
+        }
+    }
+}
+function resetAccumulator(accumulator) {
+    accumulator.active = false;
+    for (let index = 0; index < accumulator.layers.length; index++) {
+        const layer = accumulator.layers[index];
+        layer.overrideSum.fill(0);
+        layer.additiveSum.fill(0);
+        layer.overrideWeight = 0;
+        layer.rotationAnchor = 0;
+        layer.rotationAnchorSet = false;
+        layer.dominantSet = false;
+        layer.dominantValue = undefined;
+        layer.dominantWeight = -1;
+        layer.dominantOrder = Number.MAX_SAFE_INTEGER;
+    }
+}
+function createLayerAccumulator(binding, layer) {
+    const size = isNumericBinding(binding) ? binding.valueSize : 0;
+    return {
+        layer,
+        overrideSum: new Float32Array(size),
+        additiveSum: new Float32Array(size),
+        overrideWeight: 0,
+        rotationAnchor: 0,
+        rotationAnchorSet: false,
+        dominantSet: false,
+        dominantValue: undefined,
+        dominantWeight: -1,
+        dominantOrder: Number.MAX_SAFE_INTEGER,
+    };
+}
+function insertLayer(accumulator, layer) {
+    let index = accumulator.layers.length;
+    while (index > 0 && accumulator.layers[index - 1].layer > layer.layer)
+        index--;
+    accumulator.layers.splice(index, 0, layer);
+    accumulator.layersById.set(layer.layer, layer);
+}
+function accumulateNumeric(layer, binding, runtimeTrack, sampled, weight, blendMode) {
+    if (blendMode === 'additive') {
+        if (binding.strategy === 'rotation') {
+            layer.additiveSum[0] = layer.additiveSum[0]
+                + wrapAngle(sampled[0] - runtimeTrack.reference[0]) * weight;
+            return;
+        }
+        for (let index = 0; index < sampled.length; index++) {
+            layer.additiveSum[index] = layer.additiveSum[index]
+                + (sampled[index] - runtimeTrack.reference[index]) * weight;
+        }
+        return;
+    }
+    if (binding.strategy === 'rotation') {
+        if (!layer.rotationAnchorSet) {
+            layer.rotationAnchor = sampled[0];
+            layer.rotationAnchorSet = true;
+        }
+        const unwrapped = layer.rotationAnchor + wrapAngle(sampled[0] - layer.rotationAnchor);
+        layer.overrideSum[0] = layer.overrideSum[0] + unwrapped * weight;
+    }
+    else {
+        for (let index = 0; index < sampled.length; index++) {
+            layer.overrideSum[index] = layer.overrideSum[index] + sampled[index] * weight;
+        }
+    }
+    layer.overrideWeight += weight;
+}
+function accumulateDominant(layer, value, weight, order) {
+    if (weight < layer.dominantWeight
+        || (weight === layer.dominantWeight && order >= layer.dominantOrder))
+        return;
+    layer.dominantSet = true;
+    layer.dominantValue = value;
+    layer.dominantWeight = weight;
+    layer.dominantOrder = order;
+}
+function finalizeNumeric(accumulator) {
+    const binding = accumulator.binding;
+    const result = accumulator.result;
+    result.set(accumulator.base);
+    for (let layerIndex = 0; layerIndex < accumulator.layers.length; layerIndex++) {
+        const layer = accumulator.layers[layerIndex];
+        const weight = layer.overrideWeight;
+        if (weight > 0) {
+            if (binding.strategy === 'rotation') {
+                const target = layer.overrideSum[0] / weight;
+                const current = target + wrapAngle(result[0] - target);
+                const alpha = Math.min(1, weight);
+                result[0] = current + (target - current) * alpha;
+            }
+            else if (weight < 1) {
+                const baseWeight = 1 - weight;
+                for (let index = 0; index < result.length; index++) {
+                    result[index] = layer.overrideSum[index] + result[index] * baseWeight;
+                }
+            }
+            else {
+                const inverseWeight = 1 / weight;
+                for (let index = 0; index < result.length; index++) {
+                    result[index] = layer.overrideSum[index] * inverseWeight;
+                }
+            }
+        }
+        for (let index = 0; index < result.length; index++) {
+            result[index] = result[index] + layer.additiveSum[index];
+        }
+        if (binding.strategy === 'rotation')
+            result[0] = wrapAngle(result[0]);
+    }
+}
+function writeDefaultBase(binding, out) {
+    const authored = binding.defaultValue;
+    if (authored && typeof authored === 'object' && 'length' in authored) {
+        const values = authored;
+        for (let index = 0; index < out.length; index++)
+            out[index] = values[index] ?? 0;
+        return;
+    }
+    out.fill(0);
+    if (binding.path === 'transform.scale'
+        || binding.path === 'opacity'
+        || binding.path === 'color')
+        out.fill(1);
+}
+function isStateMachineOptions(options) {
+    return 'layerId' in options && 'stateId' in options;
+}
+
+class ReusablePoseChannel {
+    binding;
+    value;
+    _numeric = new Float32Array(0);
+    constructor(binding) {
+        this.binding = binding;
+    }
+    writeNumeric(binding, source) {
+        const size = numericSize(binding);
+        this.binding = binding;
+        if (this._numeric.length !== size)
+            this._numeric = new Float32Array(size);
+        for (let index = 0; index < size; index++)
+            this._numeric[index] = source[index] ?? 0;
+        this.value = this._numeric;
+    }
+    writeDiscrete(binding, value) {
+        this.binding = binding;
+        this.value = value;
+    }
+}
+/**
+ * Caller-owned frame-transient pose. Channel records, numeric storage, and
+ * effect arrays are reused after warmup.
+ */
+class Animation2DPoseBuffer {
+    _channelPool = [];
+    _channels = [];
+    _effects = [];
+    _sequence = 0;
+    _mixerTime = 0;
+    _sealed = true;
+    get sequence() { return this._sequence; }
+    get mixerTime() { return this._mixerTime; }
+    get channels() { return this._channels; }
+    get effects() { return this._effects; }
+    reset(mixerTime) {
+        if (!Number.isFinite(mixerTime)) {
+            throw new RangeError(`Animation2D pose mixerTime must be finite; received ${mixerTime}.`);
+        }
+        this._mixerTime = mixerTime;
+        this._channels.length = 0;
+        this._effects.length = 0;
+        this._sealed = false;
+    }
+    writeNumeric(binding, value) {
+        const size = numericSize(binding);
+        if (value.length < size) {
+            throw new RangeError(`Animation2D pose channel "${binding.id}" requires ${size} values; received ${value.length}.`);
+        }
+        const channel = this._channelAt(this._channels.length, binding);
+        channel.writeNumeric(binding, value);
+        this._channels.push(channel);
+    }
+    writeDiscrete(binding, value) {
+        const channel = this._channelAt(this._channels.length, binding);
+        channel.writeDiscrete(binding, value);
+        this._channels.push(channel);
+    }
+    emit(effect) {
+        this._effects.push(effect);
+    }
+    seal() {
+        if (!this._sealed) {
+            this._sequence++;
+            this._sealed = true;
+        }
+        return this;
+    }
+    _channelAt(index, binding) {
+        let channel = this._channelPool[index];
+        if (!channel) {
+            channel = new ReusablePoseChannel(binding);
+            this._channelPool.push(channel);
+        }
+        return channel;
+    }
+}
+function numericSize(binding) {
+    const size = binding.valueSize ?? 0;
+    if (!Number.isInteger(size) || size <= 0) {
+        throw new RangeError(`Animation2D numeric binding "${binding.id}" requires a positive valueSize.`);
+    }
+    return size;
+}
+
+class Animation2DStateMachineRuntime {
+    extension;
+    _mixer;
+    _adapter;
+    _pose = new Animation2DPoseBuffer();
+    _visual;
+    _destroyed = false;
+    controller;
+    constructor(owner, animation, extension, parameterValues, runtimeExtensions, assetManager) {
+        this.extension = extension;
+        const clips = createHyaAnimation2DClips(animation, extension);
+        this._mixer = new Animation2DMixerRuntime(clips);
+        this._adapter = new Animation2DStateMachineMixerAdapter(this._mixer);
+        let visual;
+        try {
+            this.controller = createAnimation2DStateMachineController(extension.stateMachine, this._adapter);
+            applyParameterValues(this.controller, extension, parameterValues);
+            this.controller.update(0);
+            visual = new Animation2DStateMachineVisualRuntime(owner, animation, runtimeExtensions, assetManager);
+            this._visual = visual;
+        }
+        catch (error) {
+            visual?.destroy();
+            this.controller?.destroy();
+            this._adapter.destroy();
+            this._mixer.destroy();
+            throw error;
+        }
+    }
+    get stats() { return this._visual.stats; }
+    get diagnostics() { return this._visual.diagnostics; }
+    get liveActionCount() { return this._adapter.liveActionCount; }
+    get liveBindingCount() { return this._adapter.liveBindingCount; }
+    get sideEffectOwnerCount() { return this._visual.sideEffectOwnerCount; }
+    get layerSnapshots() {
+        return this.controller.layerSnapshots;
+    }
+    update(deltaSeconds, playing, speed) {
+        this._requireActive();
+        const pose = runAnimationStateMachineControllerUpdateTransaction(this.controller, playing ? deltaSeconds * speed : 0, () => undefined, () => this._mixer.evaluate(this._pose));
+        this._visual.applyPose(pose, playing, speed);
+    }
+    setPlaying(playing) {
+        this._requireActive();
+        this._visual.setPlaying(playing);
+    }
+    reset() {
+        this._requireActive();
+        this._visual.resetSideEffects();
+        this.controller.reset();
+        const pose = runAnimationStateMachineControllerUpdateTransaction(this.controller, 0, () => undefined, () => this._mixer.evaluate(this._pose));
+        this._visual.applyPose(pose, false, 1);
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this.controller.destroy();
+        this._adapter.destroy();
+        this._mixer.destroy();
+        this._visual.destroy();
+    }
+    _requireActive() {
+        if (this._destroyed)
+            throw new Error('Animation2D state-machine runtime has been destroyed.');
+    }
+}
+function applyParameterValues(controller, extension, values) {
+    for (const parameter of extension.stateMachine.parameters) {
+        if (!values.has(parameter.name))
+            continue;
+        const value = values.get(parameter.name);
+        if (parameter.type === 'float')
+            controller.setFloat(parameter.name, value);
+        else if (parameter.type === 'integer')
+            controller.setInteger(parameter.name, value);
+        else if (parameter.type === 'boolean')
+            controller.setBoolean(parameter.name, value);
+        else if (value)
+            controller.setTrigger(parameter.name);
+    }
+}
+
+class Animation2DStateMachineSystem extends System {
+    _assetManager;
+    constructor(options = {}) {
+        super({ all: [Animation2DStateMachineComponent] });
+        this.name = 'Animation2DStateMachineSystem';
+        if (options.priority !== undefined)
+            this.priority = options.priority;
+        this._assetManager = options.assetManager;
+    }
+    update(world, _time, delta) {
+        if (this.disabled)
+            return this;
+        const entities = this.entitySet.get(world);
+        if (!entities)
+            return this;
+        for (const entity of entities)
+            this._updateEntity(entity, delta);
+        return this;
+    }
+    destroy() {
+        for (const world of this.usedBy) {
+            const entities = this.entitySet.get(world);
+            if (!entities)
+                continue;
+            for (const entity of entities) {
+                entity.getComponent(Animation2DStateMachineComponent)?._disposeRuntime();
+            }
+        }
+        return super.destroy();
+    }
+    _updateEntity(entity, delta) {
+        const component = entity.getComponent(Animation2DStateMachineComponent);
+        if (!component)
+            return;
+        if (component.disabled) {
+            component._disposeRuntime();
+            return;
+        }
+        component._runtime ??= new Animation2DStateMachineRuntime(entity, component.animation, component.stateMachineExtension, component._getParameterValues(), component.runtimeExtensions, this._assetManager);
+        if ((!component.playing || component.speed === 0) && !component._needsUpdate)
+            return;
+        component._runtime.update(Math.max(0, delta) * 0.001, component.playing, component.speed);
+        component._needsUpdate = false;
+    }
+}
+
+export { Animation2DStateMachineComponent, Animation2DStateMachineSystem, AnimationStateMachineChannelError, assertAudioStateMachineCompatible, audioStateMachineCompatibilityDiagnostic, createHyaAnimation2DClips, getHyaStateMachineExtension };
+//# sourceMappingURL=hya-state-machine.js.map