@haiyue/extensions 0.1.0

package/dist/chunks/GltfAnimation3DAdapter-Cu3rQQsW.js

@@ -0,0 +1,2240 @@
+import { Component } from '@haiyue/engine';
+import { createAbortError } from '@haiyue/engine/experimental/async';
+import { c as composeTrsMatrix, b as applyMorphWeights, u as updateSkinnedPrimitive } from './GltfAnimationRuntime-CRHsLycN.js';
+
+/**
+ * Stable domain error for the Animation3D facade.
+ *
+ * Callers should branch on `code`; messages remain diagnostic and may gain
+ * additional context without changing the error contract.
+ */
+class Animation3DError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'Animation3DError';
+        this.code = code;
+        this.details = Object.freeze({ ...details });
+    }
+}
+
+class ReusablePoseChannel {
+    binding;
+    value;
+    constructor(binding) {
+        this.binding = binding;
+        this.value = new Float32Array(binding.valueSize);
+    }
+    write(binding, source) {
+        this.binding = binding;
+        if (this.value.length !== binding.valueSize) {
+            this.value = new Float32Array(binding.valueSize);
+        }
+        for (let index = 0; index < binding.valueSize; index++) {
+            this.value[index] = source[index] ?? 0;
+        }
+    }
+}
+/**
+ * Reusable caller-owned mixer output.
+ *
+ * Channel records and value arrays are pooled after first use. seal() returns
+ * this object as the read-only pose view rather than allocating a snapshot.
+ */
+class Animation3DPoseBuffer {
+    _channelPool = [];
+    _channels = [];
+    _events = [];
+    _sequence = 0;
+    _mixerTime = 0;
+    _sealed = true;
+    get sequence() { return this._sequence; }
+    get mixerTime() { return this._mixerTime; }
+    get channels() { return this._channels; }
+    get events() { return this._events; }
+    reset(mixerTime) {
+        if (!Number.isFinite(mixerTime)) {
+            throw new RangeError(`Animation3D pose mixerTime must be finite; received ${mixerTime}.`);
+        }
+        this._mixerTime = mixerTime;
+        this._channels.length = 0;
+        this._events.length = 0;
+        this._sealed = false;
+    }
+    write(binding, value) {
+        if (value.length < binding.valueSize) {
+            throw new RangeError(`Animation3D pose channel "${binding.id}" requires ${binding.valueSize} values; received ${value.length}.`);
+        }
+        const index = this._channels.length;
+        let channel = this._channelPool[index];
+        if (!channel) {
+            channel = new ReusablePoseChannel(binding);
+            this._channelPool.push(channel);
+        }
+        channel.write(binding, value);
+        this._channels.push(channel);
+    }
+    emit(event) {
+        this._events.push(event);
+    }
+    seal() {
+        if (!this._sealed) {
+            this._sequence++;
+            this._sealed = true;
+        }
+        return this;
+    }
+}
+
+const SLERP_LINEAR_THRESHOLD = 0.9995;
+/**
+ * Stateful, allocation-free sampler for one immutable track.
+ *
+ * The sampler owns one reusable output buffer and a key cursor optimized for
+ * coherent playback. Callers may provide another destination when needed.
+ */
+class Animation3DTrackSampler {
+    track;
+    valueSize;
+    output;
+    _cursor = 0;
+    constructor(track) {
+        validateAnimation3DTrack(track);
+        this.track = track;
+        this.valueSize = track.binding.valueSize;
+        this.output = new Float32Array(this.valueSize);
+    }
+    sample(timeSeconds, out = this.output) {
+        if (!Number.isFinite(timeSeconds)) {
+            throw new RangeError(`Animation3D track sample time must be finite; received ${timeSeconds}.`);
+        }
+        if (out.length < this.valueSize) {
+            throw new RangeError(`Animation3D track output requires ${this.valueSize} values; received ${out.length}.`);
+        }
+        const times = this.track.times;
+        const keyCount = times.length;
+        if (keyCount === 1 || timeSeconds <= times[0]) {
+            this._copyKeyValue(0, out);
+            this._cursor = 0;
+            return out;
+        }
+        const lastIndex = keyCount - 1;
+        if (timeSeconds >= times[lastIndex]) {
+            this._copyKeyValue(lastIndex, out);
+            this._cursor = Math.max(0, lastIndex - 1);
+            return out;
+        }
+        const keyIndex = this._findInterval(timeSeconds);
+        if (this.track.interpolation === 'step') {
+            this._copyKeyValue(keyIndex, out);
+            return out;
+        }
+        const startTime = times[keyIndex];
+        const endTime = times[keyIndex + 1];
+        const alpha = (timeSeconds - startTime) / (endTime - startTime);
+        if (this.track.interpolation === 'cubic-spline') {
+            this._sampleCubic(keyIndex, endTime - startTime, alpha, out);
+        }
+        else if (this.track.binding.valueType === 'quaternion') {
+            this._sampleQuaternionLinear(keyIndex, alpha, out);
+        }
+        else {
+            this._sampleLinear(keyIndex, alpha, out);
+        }
+        return out;
+    }
+    resetCursor() {
+        this._cursor = 0;
+    }
+    _findInterval(timeSeconds) {
+        const times = this.track.times;
+        let cursor = Math.min(this._cursor, times.length - 2);
+        if (timeSeconds >= times[cursor] && timeSeconds < times[cursor + 1]) {
+            return cursor;
+        }
+        if (timeSeconds >= times[cursor + 1]) {
+            while (cursor + 2 < times.length && 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;
+    }
+    _copyKeyValue(keyIndex, out) {
+        const size = this.valueSize;
+        const values = this.track.values;
+        const offset = this.track.interpolation === 'cubic-spline'
+            ? keyIndex * size * 3 + size
+            : keyIndex * size;
+        for (let component = 0; component < size; component++) {
+            out[component] = values[offset + component];
+        }
+        if (this.track.binding.valueType === 'quaternion')
+            normalizeQuaternion$1(out);
+    }
+    _sampleLinear(keyIndex, alpha, out) {
+        const size = this.valueSize;
+        const values = this.track.values;
+        const startOffset = keyIndex * size;
+        const endOffset = startOffset + size;
+        for (let component = 0; component < size; component++) {
+            const start = values[startOffset + component];
+            out[component] = start + (values[endOffset + component] - start) * alpha;
+        }
+    }
+    _sampleQuaternionLinear(keyIndex, alpha, out) {
+        const values = this.track.values;
+        const startOffset = keyIndex * 4;
+        const endOffset = startOffset + 4;
+        const ax = values[startOffset];
+        const ay = values[startOffset + 1];
+        const az = values[startOffset + 2];
+        const aw = values[startOffset + 3];
+        let bx = values[endOffset];
+        let by = values[endOffset + 1];
+        let bz = values[endOffset + 2];
+        let bw = values[endOffset + 3];
+        let dot = ax * bx + ay * by + az * bz + aw * bw;
+        if (dot < 0) {
+            dot = -dot;
+            bx = -bx;
+            by = -by;
+            bz = -bz;
+            bw = -bw;
+        }
+        dot = Math.min(1, Math.max(-1, dot));
+        if (dot > SLERP_LINEAR_THRESHOLD) {
+            out[0] = ax + (bx - ax) * alpha;
+            out[1] = ay + (by - ay) * alpha;
+            out[2] = az + (bz - az) * alpha;
+            out[3] = aw + (bw - aw) * alpha;
+            normalizeQuaternion$1(out);
+            return;
+        }
+        const theta = Math.acos(dot);
+        const sinTheta = Math.sin(theta);
+        const startWeight = Math.sin((1 - alpha) * theta) / sinTheta;
+        const endWeight = Math.sin(alpha * theta) / sinTheta;
+        out[0] = ax * startWeight + bx * endWeight;
+        out[1] = ay * startWeight + by * endWeight;
+        out[2] = az * startWeight + bz * endWeight;
+        out[3] = aw * startWeight + bw * endWeight;
+        normalizeQuaternion$1(out);
+    }
+    _sampleCubic(keyIndex, keyDuration, alpha, out) {
+        const size = this.valueSize;
+        const values = this.track.values;
+        const startGroup = keyIndex * size * 3;
+        const endGroup = startGroup + size * 3;
+        const startValue = startGroup + size;
+        const startOutTangent = startGroup + size * 2;
+        const endInTangent = endGroup;
+        const endValue = endGroup + size;
+        const alpha2 = alpha * alpha;
+        const alpha3 = alpha2 * alpha;
+        const h00 = 2 * alpha3 - 3 * alpha2 + 1;
+        const h10 = alpha3 - 2 * alpha2 + alpha;
+        const h01 = -2 * alpha3 + 3 * alpha2;
+        const h11 = alpha3 - alpha2;
+        for (let component = 0; component < size; component++) {
+            out[component] = h00 * values[startValue + component]
+                + h10 * keyDuration * values[startOutTangent + component]
+                + h01 * values[endValue + component]
+                + h11 * keyDuration * values[endInTangent + component];
+        }
+        if (this.track.binding.valueType === 'quaternion')
+            normalizeQuaternion$1(out);
+    }
+}
+/** @internal Shared by clip admission and direct sampler construction. */
+function validateAnimation3DTrack(track, clipDuration = Infinity) {
+    const trackId = typeof track?.id === 'string' ? track.id : '';
+    const fail = (message) => {
+        throw new Animation3DError('invalid-track', message, { trackId });
+    };
+    if (!track || typeof track !== 'object') {
+        fail('Animation3D track must be an object.');
+    }
+    if (trackId.trim().length === 0) {
+        fail('Animation3D track id must not be empty.');
+    }
+    if (!track.binding || typeof track.binding !== 'object') {
+        fail(`Animation3D track "${trackId}" requires a binding.`);
+    }
+    if (typeof track.binding.id !== 'string' || track.binding.id.trim().length === 0) {
+        fail(`Animation3D track "${trackId}" binding id must not be empty.`);
+    }
+    validateBindingTarget(track, fail);
+    const size = track.binding.valueSize;
+    if (!Number.isInteger(size) || size <= 0) {
+        fail(`Animation3D binding valueSize must be a positive integer; received ${size}.`);
+    }
+    const fixedSize = fixedBindingValueSize(track.binding.valueType);
+    if (fixedSize !== null && Number.isNaN(fixedSize)) {
+        fail(`Animation3D track "${trackId}" has an unsupported binding value type.`);
+    }
+    if (fixedSize !== null && size !== fixedSize) {
+        fail(`Animation3D ${track.binding.valueType} binding requires ${fixedSize} values; received ${size}.`);
+    }
+    if (track.binding.valueType === 'weights' && !Number.isSafeInteger(size)) {
+        fail(`Animation3D weights binding valueSize must be a positive safe integer; received ${size}.`);
+    }
+    validateBindingPath(track, size, fail);
+    if (track.interpolation !== 'step'
+        && track.interpolation !== 'linear'
+        && track.interpolation !== 'cubic-spline') {
+        fail(`Animation3D track "${trackId}" has an unsupported interpolation.`);
+    }
+    if (!(track.times instanceof Float32Array)) {
+        fail(`Animation3D track "${trackId}" times must be a Float32Array.`);
+    }
+    if (!(track.values instanceof Float32Array)) {
+        fail(`Animation3D track "${trackId}" values must be a Float32Array.`);
+    }
+    if (track.times.length === 0) {
+        fail(`Animation3D track "${trackId}" must contain at least one key.`);
+    }
+    for (let index = 0; index < track.times.length; index++) {
+        const time = track.times[index];
+        if (!Number.isFinite(time) || time < 0 || time > clipDuration
+            || (index > 0 && time <= track.times[index - 1])) {
+            fail(`Animation3D track "${trackId}" key times must be finite, non-negative, `
+                + 'strictly increasing, and within the clip duration.');
+        }
+    }
+    const stride = track.interpolation === 'cubic-spline' ? size * 3 : size;
+    const expectedValues = track.times.length * stride;
+    if (track.values.length !== expectedValues) {
+        fail(`Animation3D track "${trackId}" requires ${expectedValues} values; received ${track.values.length}.`);
+    }
+    for (let index = 0; index < track.values.length; index++) {
+        if (!Number.isFinite(track.values[index])) {
+            fail(`Animation3D track "${trackId}" values must be finite.`);
+        }
+    }
+    if (track.binding.valueType === 'quaternion') {
+        const groupStride = track.interpolation === 'cubic-spline' ? size * 3 : size;
+        const valueOffset = track.interpolation === 'cubic-spline' ? size : 0;
+        for (let keyIndex = 0; keyIndex < track.times.length; keyIndex++) {
+            const offset = keyIndex * groupStride + valueOffset;
+            const length = Math.hypot(track.values[offset], track.values[offset + 1], track.values[offset + 2], track.values[offset + 3]);
+            if (length <= Number.EPSILON) {
+                fail(`Animation3D track "${trackId}" contains a zero-length quaternion key.`);
+            }
+        }
+    }
+}
+function validateBindingTarget(track, fail) {
+    const { target } = track.binding;
+    if (!target || typeof target !== 'object') {
+        fail(`Animation3D track "${track.id}" binding requires a target.`);
+    }
+    if (target.kind === 'node-id') {
+        if (typeof target.nodeId !== 'string' || target.nodeId.trim().length === 0) {
+            fail(`Animation3D track "${track.id}" node-id target must not be empty.`);
+        }
+        return;
+    }
+    if (target.kind === 'node-path') {
+        if (!Array.isArray(target.segments)
+            || target.segments.some(segment => typeof segment !== 'string')) {
+            fail(`Animation3D track "${track.id}" node-path target must contain string segments.`);
+        }
+        return;
+    }
+    if (target.kind === 'slot') {
+        if (typeof target.slot !== 'string' || target.slot.trim().length === 0) {
+            fail(`Animation3D track "${track.id}" slot target must not be empty.`);
+        }
+        return;
+    }
+    fail(`Animation3D track "${track.id}" has an unsupported binding target.`);
+}
+function validateBindingPath(track, size, fail) {
+    const { binding } = track;
+    if (binding.path === 'transform.translation') {
+        if (binding.valueType !== 'vec3' || size !== 3) {
+            fail('Animation3D translation tracks require a vec3 binding.');
+        }
+        return;
+    }
+    if (binding.path === 'transform.rotation') {
+        if (binding.valueType !== 'quaternion' || size !== 4) {
+            fail('Animation3D rotation tracks require a quaternion binding.');
+        }
+        return;
+    }
+    if (binding.path === 'transform.scale') {
+        if (binding.valueType !== 'vec3' || size !== 3) {
+            fail('Animation3D scale tracks require a vec3 binding.');
+        }
+        return;
+    }
+    if (binding.path === 'morph.weights') {
+        if (binding.valueType !== 'weights') {
+            fail('Animation3D morph tracks require a weights binding.');
+        }
+        return;
+    }
+    if (binding.path === 'property') {
+        if (String(binding.valueType) === 'weights'
+            || typeof binding.component !== 'string'
+            || binding.component.trim().length === 0
+            || typeof binding.property !== 'string'
+            || binding.property.trim().length === 0) {
+            fail('Animation3D property tracks require component, property, and a fixed value type.');
+        }
+        return;
+    }
+    fail(`Animation3D track "${track.id}" has an unsupported binding path.`);
+}
+function fixedBindingValueSize(valueType) {
+    if (valueType === 'scalar')
+        return 1;
+    if (valueType === 'vec2')
+        return 2;
+    if (valueType === 'vec3')
+        return 3;
+    if (valueType === 'vec4' || valueType === 'quaternion')
+        return 4;
+    if (valueType === 'weights')
+        return null;
+    return Number.NaN;
+}
+function normalizeQuaternion$1(value) {
+    const x = value[0];
+    const y = value[1];
+    const z = value[2];
+    const w = value[3];
+    const length = Math.hypot(x, y, z, w);
+    if (length <= Number.EPSILON) {
+        value[0] = 0;
+        value[1] = 0;
+        value[2] = 0;
+        value[3] = 1;
+        return;
+    }
+    const inverseLength = 1 / length;
+    value[0] = x * inverseLength;
+    value[1] = y * inverseLength;
+    value[2] = z * inverseLength;
+    value[3] = w * inverseLength;
+}
+
+/**
+ * Mutable mixer-owned playback state for one immutable clip.
+ */
+class Animation3DActionRuntime {
+    id;
+    clip;
+    runtimeTracks;
+    _owner;
+    _runtimeEvents;
+    _valid = true;
+    _status = 'idle';
+    _enabled = true;
+    _paused = false;
+    _time = 0;
+    _rawTime = 0;
+    _timeScale;
+    _weight;
+    _loop;
+    _repetitions;
+    _clampWhenFinished;
+    _blendMode;
+    _mask;
+    _startTime = null;
+    _eventsStarted = false;
+    _fadeActive = false;
+    _fadeStart = 0;
+    _fadeEnd = 0;
+    _fadeFrom = 1;
+    _fadeTo = 1;
+    _fadeValue = 1;
+    _warpActive = false;
+    _warpStart = 0;
+    _warpEnd = 0;
+    _warpFrom = 1;
+    _warpTo = 1;
+    _warpValue = 1;
+    constructor(owner, clip, id, options = {}) {
+        validateClip(clip);
+        this._owner = owner;
+        this.clip = clip;
+        this.id = id;
+        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, 'Animation3DAction.timeScale');
+        this._weight = nonNegativeNumber(options.weight ?? 1, 'Animation3DAction.weight');
+        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 Animation3DTrackSampler(track);
+            const reference = new Float32Array(track.binding.valueSize);
+            sampler.sample(0, reference);
+            tracks.push({ track, sampler, reference });
+        }
+        this.runtimeTracks = tracks;
+        const sortedEvents = [...clip.events].sort((a, b) => a.time - b.time);
+        const runtimeEvents = [];
+        for (let index = 0; index < sortedEvents.length; index++) {
+            const event = sortedEvents[index];
+            runtimeEvents.push({
+                event,
+                poseEvent: { actionId: id, clipId: clip.id, event },
+            });
+        }
+        this._runtimeEvents = runtimeEvents;
+    }
+    get status() { return this._status; }
+    get enabled() { return this._enabled; }
+    set enabled(value) {
+        this._assertValid();
+        this._enabled = Boolean(value);
+    }
+    get paused() { return this._paused; }
+    set paused(value) {
+        this._assertValid();
+        const next = Boolean(value);
+        if (this._paused === next)
+            return;
+        this._paused = next;
+        if (next && (this._status === 'running' || this._status === 'scheduled')) {
+            this._status = 'paused';
+        }
+        else if (!next && this._status === 'paused') {
+            this._status = this._startTime !== null && this._owner.time < this._startTime
+                ? 'scheduled'
+                : 'running';
+        }
+    }
+    get time() { return this._time; }
+    set time(value) {
+        this._assertValid();
+        const duration = this.clip.duration;
+        const next = Math.min(duration, Math.max(0, finiteNumber(value, 'Animation3DAction.time')));
+        this._rawTime = next;
+        this._time = next;
+        this._eventsStarted = false;
+        this._resetSamplerCursors();
+    }
+    get timeScale() { return this._timeScale; }
+    set timeScale(value) {
+        this._assertValid();
+        this._timeScale = finiteNumber(value, 'Animation3DAction.timeScale');
+    }
+    get weight() { return this._weight; }
+    set weight(value) {
+        this._assertValid();
+        this._weight = nonNegativeNumber(value, 'Animation3DAction.weight');
+    }
+    get loop() { return this._loop; }
+    set loop(value) {
+        this._assertValid();
+        if (value !== 'once' && value !== 'repeat' && value !== 'ping-pong') {
+            throw new RangeError(`Unsupported Animation3D 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 Animation3D blend mode "${String(value)}".`);
+        }
+        this._blendMode = value;
+    }
+    get mask() { return this._mask; }
+    set mask(value) {
+        this._assertValid();
+        this._mask = value;
+    }
+    get effectiveTimeScale() {
+        if (!this._valid || this._paused || this._status !== 'running')
+            return 0;
+        return this._timeScale * this._warpFactor(this._owner.time);
+    }
+    get effectiveWeight() {
+        if (!this._valid || !this._enabled || this._status === 'idle'
+            || this._status === 'scheduled' || this._status === 'stopped'
+            || (this._status === 'finished' && !this._clampWhenFinished))
+            return 0;
+        return this._weight * this._fadeFactor(this._owner.time);
+    }
+    play() {
+        this._assertValid();
+        this._enabled = true;
+        this._paused = false;
+        this._status = this._startTime !== null && this._owner.time < this._startTime
+            ? 'scheduled'
+            : 'running';
+        return this;
+    }
+    stop() {
+        this._assertValid();
+        this._enabled = false;
+        this._paused = false;
+        this._status = 'stopped';
+        this._startTime = null;
+        this._fadeActive = false;
+        this._warpActive = false;
+        return this;
+    }
+    reset() {
+        this._assertValid();
+        this._enabled = true;
+        this._paused = false;
+        this._status = 'idle';
+        this._time = 0;
+        this._rawTime = 0;
+        this._startTime = null;
+        this._eventsStarted = false;
+        this._fadeActive = false;
+        this._fadeValue = 1;
+        this._warpActive = false;
+        this._warpValue = 1;
+        this._resetSamplerCursors();
+        return this;
+    }
+    startAt(mixerTimeSeconds) {
+        this._assertValid();
+        this._startTime = finiteNumber(mixerTimeSeconds, 'Animation3DAction.startAt');
+        if (this._status === 'running' || this._status === 'scheduled') {
+            this._status = this._owner.time < this._startTime ? 'scheduled' : 'running';
+        }
+        return this;
+    }
+    fadeIn(durationSeconds) {
+        this._assertValid();
+        const duration = nonNegativeNumber(durationSeconds, 'Animation3DAction.fadeIn');
+        this._fadeValue = 0;
+        this._scheduleFade(0, 1, duration);
+        return this;
+    }
+    fadeOut(durationSeconds) {
+        this._assertValid();
+        const duration = nonNegativeNumber(durationSeconds, 'Animation3DAction.fadeOut');
+        this._scheduleFade(this._fadeFactor(this._owner.time), 0, duration);
+        return this;
+    }
+    crossFadeFrom(source, durationSeconds, warp = false) {
+        this._assertValid();
+        const sourceRuntime = this._requireSibling(source);
+        const duration = nonNegativeNumber(durationSeconds, 'Animation3DAction.crossFadeFrom');
+        sourceRuntime.play().fadeOut(duration);
+        this.play().fadeIn(duration);
+        if (warp && sourceRuntime.clip.duration > 0 && this.clip.duration > 0) {
+            sourceRuntime._scheduleWarp(1, sourceRuntime.clip.duration / this.clip.duration, duration);
+            this._scheduleWarp(this.clip.duration / sourceRuntime.clip.duration, 1, duration);
+        }
+        return this;
+    }
+    crossFadeTo(destination, durationSeconds, warp = false) {
+        this._assertValid();
+        const destinationRuntime = this._requireSibling(destination);
+        destinationRuntime.crossFadeFrom(this, durationSeconds, warp);
+        return this;
+    }
+    stopFading() {
+        this._assertValid();
+        if (this._fadeActive)
+            this._fadeValue = this._fadeFactor(this._owner.time);
+        this._fadeActive = false;
+        return this;
+    }
+    acceptsBinding(binding) {
+        const include = this._mask?.include;
+        if (include && include.length > 0) {
+            let found = false;
+            for (let index = 0; index < include.length; index++) {
+                if (include[index] === binding.id) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+                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;
+    }
+    canContribute() {
+        return this.effectiveWeight > 0;
+    }
+    /** @internal Allocated once by an integration handle and reused every frame. */
+    createSynchronizedState() {
+        const state = {};
+        this.captureSynchronizedState(state);
+        return state;
+    }
+    /** @internal Captures every field changed by controller synchronization. */
+    captureSynchronizedState(out) {
+        this._assertValid();
+        out.status = this._status;
+        out.enabled = this._enabled;
+        out.paused = this._paused;
+        out.time = this._time;
+        out.rawTime = this._rawTime;
+        out.timeScale = this._timeScale;
+        out.weight = this._weight;
+        out.loop = this._loop;
+        out.repetitions = this._repetitions;
+        out.clampWhenFinished = this._clampWhenFinished;
+        out.blendMode = this._blendMode;
+        out.mask = this._mask;
+        out.startTime = this._startTime;
+        out.eventsStarted = this._eventsStarted;
+        out.fadeActive = this._fadeActive;
+        out.fadeStart = this._fadeStart;
+        out.fadeEnd = this._fadeEnd;
+        out.fadeFrom = this._fadeFrom;
+        out.fadeTo = this._fadeTo;
+        out.fadeValue = this._fadeValue;
+        out.warpActive = this._warpActive;
+        out.warpStart = this._warpStart;
+        out.warpEnd = this._warpEnd;
+        out.warpFrom = this._warpFrom;
+        out.warpTo = this._warpTo;
+        out.warpValue = this._warpValue;
+    }
+    /** @internal Restores event cursors as well as the sampled playhead. */
+    restoreSynchronizedState(state) {
+        this._assertValid();
+        this._status = state.status;
+        this._enabled = state.enabled;
+        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._startTime = state.startTime;
+        this._eventsStarted = state.eventsStarted;
+        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._warpActive = state.warpActive;
+        this._warpStart = state.warpStart;
+        this._warpEnd = state.warpEnd;
+        this._warpFrom = state.warpFrom;
+        this._warpTo = state.warpTo;
+        this._warpValue = state.warpValue;
+        this._resetSamplerCursors();
+    }
+    /**
+     * Sets an unwrapped controller-owned playhead without emitting events.
+     * Integration adapters use this for initial destination offsets before play.
+     */
+    seekSynchronizedTime(timeSeconds) {
+        this._assertValid();
+        this._rawTime = this._clampSynchronizedTime(timeSeconds);
+        this._setSampleTime(0);
+        this._eventsStarted = false;
+        this._resetSamplerCursors();
+    }
+    /**
+     * Moves to an absolute controller-owned playhead and emits every crossed
+     * clip event exactly once. This does not advance the mixer clock.
+     */
+    synchronizeTime(timeSeconds, out) {
+        this._assertValid();
+        const after = this._clampSynchronizedTime(timeSeconds);
+        const before = this._rawTime;
+        const direction = after === before ? this._timeScale : after - before;
+        if (!this._eventsStarted) {
+            this._emitStartingEvents(direction, out);
+            this._eventsStarted = true;
+        }
+        this._emitCrossedEvents(before, after, out);
+        this._rawTime = after;
+        this._setSampleTime(0);
+    }
+    advance(mixerDelta, previousMixerTime, currentMixerTime, out) {
+        if (!this._valid)
+            return;
+        this._finishTransitions(currentMixerTime);
+        if (!this._enabled || this._paused)
+            return;
+        let activeMixerDelta = mixerDelta;
+        if (this._status === 'scheduled') {
+            const startTime = this._startTime;
+            if (startTime === null) {
+                this._status = 'running';
+            }
+            else if (mixerDelta >= 0) {
+                if (currentMixerTime < startTime)
+                    return;
+                activeMixerDelta = currentMixerTime - Math.max(previousMixerTime, startTime);
+                this._status = 'running';
+                this._startTime = null;
+            }
+            else {
+                if (currentMixerTime > startTime)
+                    return;
+                activeMixerDelta = currentMixerTime - Math.min(previousMixerTime, startTime);
+                this._status = 'running';
+                this._startTime = null;
+            }
+        }
+        if (this._status !== 'running')
+            return;
+        const actionDelta = activeMixerDelta * this._timeScale * this._warpFactor(currentMixerTime);
+        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 (after >= totalDuration && actionDelta > 0) {
+                after = totalDuration;
+                terminalDirection = 1;
+            }
+            else if (after <= 0 && actionDelta < 0) {
+                after = 0;
+                terminalDirection = -1;
+            }
+        }
+        if (!this._eventsStarted) {
+            this._emitStartingEvents(actionDelta, out);
+            this._eventsStarted = true;
+        }
+        this._emitCrossedEvents(before, after, out);
+        this._rawTime = after;
+        this._setSampleTime(terminalDirection);
+        if (terminalDirection !== 0) {
+            this._status = 'finished';
+            if (!this._clampWhenFinished)
+                this._enabled = false;
+        }
+    }
+    invalidate() {
+        if (!this._valid)
+            return;
+        this._valid = false;
+        this._enabled = false;
+        this._paused = false;
+        this._status = 'stopped';
+        this._startTime = null;
+        this._fadeActive = false;
+        this._warpActive = false;
+    }
+    _clampSynchronizedTime(timeSeconds) {
+        const next = finiteNumber(timeSeconds, 'Animation3DAction 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));
+    }
+    _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;
+            return;
+        }
+        this._time = isEven(traversal) ? phase : duration - phase;
+    }
+    _emitCrossedEvents(before, after, out) {
+        if (before === after || this._runtimeEvents.length === 0)
+            return;
+        if (this._loop === 'once') {
+            this._emitOnceEvents(before, after, out);
+        }
+        else if (this._loop === 'repeat') {
+            this._emitRepeatEvents(before, after, out);
+        }
+        else {
+            this._emitPingPongEvents(before, after, out);
+        }
+    }
+    _emitStartingEvents(direction, out) {
+        if (direction >= 0) {
+            for (let index = 0; index < this._runtimeEvents.length; index++) {
+                const runtimeEvent = this._runtimeEvents[index];
+                if (runtimeEvent.event.time === this._time)
+                    out.emit(runtimeEvent.poseEvent);
+            }
+        }
+        else {
+            for (let index = this._runtimeEvents.length - 1; index >= 0; index--) {
+                const runtimeEvent = this._runtimeEvents[index];
+                if (runtimeEvent.event.time === this._time)
+                    out.emit(runtimeEvent.poseEvent);
+            }
+        }
+    }
+    _emitOnceEvents(before, after, out) {
+        if (after > before) {
+            for (let index = 0; index < this._runtimeEvents.length; index++) {
+                const runtimeEvent = this._runtimeEvents[index];
+                if (runtimeEvent.event.time > before && runtimeEvent.event.time <= after) {
+                    out.emit(runtimeEvent.poseEvent);
+                }
+            }
+        }
+        else {
+            for (let index = this._runtimeEvents.length - 1; index >= 0; index--) {
+                const runtimeEvent = this._runtimeEvents[index];
+                if (runtimeEvent.event.time < before && runtimeEvent.event.time >= after) {
+                    out.emit(runtimeEvent.poseEvent);
+                }
+            }
+        }
+    }
+    _emitRepeatEvents(before, after, out) {
+        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;
+        if (after > before) {
+            for (let cycle = firstCycle; cycle <= lastCycle; cycle++) {
+                const cycleStart = cycle * duration;
+                for (let index = 0; index < this._runtimeEvents.length; index++) {
+                    const runtimeEvent = this._runtimeEvents[index];
+                    const occurrence = cycleStart + runtimeEvent.event.time;
+                    if (occurrence > before && occurrence <= after)
+                        out.emit(runtimeEvent.poseEvent);
+                }
+            }
+        }
+        else {
+            for (let cycle = lastCycle; cycle >= firstCycle; cycle--) {
+                const cycleStart = cycle * duration;
+                for (let index = this._runtimeEvents.length - 1; index >= 0; index--) {
+                    const runtimeEvent = this._runtimeEvents[index];
+                    const occurrence = cycleStart + runtimeEvent.event.time;
+                    if (occurrence < before && occurrence >= after)
+                        out.emit(runtimeEvent.poseEvent);
+                }
+            }
+        }
+    }
+    _emitPingPongEvents(before, after, out) {
+        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;
+        if (after > before) {
+            for (let traversal = firstTraversal; traversal <= lastTraversal; traversal++) {
+                if (isEven(traversal)) {
+                    this._emitPingPongTraversal(traversal, before, after, true, true, out);
+                }
+                else {
+                    this._emitPingPongTraversal(traversal, before, after, false, true, out);
+                }
+            }
+        }
+        else {
+            for (let traversal = lastTraversal; traversal >= firstTraversal; traversal--) {
+                if (isEven(traversal)) {
+                    this._emitPingPongTraversal(traversal, before, after, false, false, out);
+                }
+                else {
+                    this._emitPingPongTraversal(traversal, before, after, true, false, out);
+                }
+            }
+        }
+    }
+    _emitPingPongTraversal(traversal, before, after, ascendingEvents, forwardRaw, out) {
+        const duration = this.clip.duration;
+        const even = isEven(traversal);
+        let index = ascendingEvents ? 0 : this._runtimeEvents.length - 1;
+        const end = ascendingEvents ? this._runtimeEvents.length : -1;
+        const step = ascendingEvents ? 1 : -1;
+        for (; index !== end; index += step) {
+            const runtimeEvent = this._runtimeEvents[index];
+            const eventTime = runtimeEvent.event.time;
+            if ((even && eventTime === 0) || (!even && eventTime === duration))
+                continue;
+            const occurrence = traversal * duration + (even ? eventTime : duration - eventTime);
+            const crossed = forwardRaw
+                ? occurrence > before && occurrence <= after
+                : occurrence < before && occurrence >= after;
+            if (crossed)
+                out.emit(runtimeEvent.poseEvent);
+        }
+    }
+    _scheduleFade(from, to, duration) {
+        this._fadeFrom = from;
+        this._fadeTo = to;
+        this._fadeStart = this._owner.time;
+        this._fadeEnd = this._fadeStart + duration;
+        if (duration === 0) {
+            this._fadeValue = to;
+            this._fadeActive = false;
+        }
+        else {
+            this._fadeValue = from;
+            this._fadeActive = true;
+        }
+    }
+    _scheduleWarp(from, to, duration) {
+        this._warpFrom = from;
+        this._warpTo = to;
+        this._warpStart = this._owner.time;
+        this._warpEnd = this._warpStart + duration;
+        if (duration === 0) {
+            this._warpValue = to;
+            this._warpActive = false;
+        }
+        else {
+            this._warpValue = from;
+            this._warpActive = 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;
+    }
+    _warpFactor(time) {
+        if (!this._warpActive)
+            return this._warpValue;
+        if (time <= this._warpStart)
+            return this._warpFrom;
+        if (time >= this._warpEnd)
+            return this._warpTo;
+        const alpha = (time - this._warpStart) / (this._warpEnd - this._warpStart);
+        return this._warpFrom + (this._warpTo - this._warpFrom) * alpha;
+    }
+    _finishTransitions(time) {
+        if (this._fadeActive && time >= this._fadeEnd) {
+            this._fadeValue = this._fadeTo;
+            this._fadeActive = false;
+        }
+        if (this._warpActive && time >= this._warpEnd) {
+            this._warpValue = this._warpTo;
+            this._warpActive = false;
+        }
+    }
+    _requireSibling(action) {
+        if (!(action instanceof Animation3DActionRuntime) || action._owner !== this._owner) {
+            throw new RangeError('Animation3D cross-fade actions must belong to the same mixer.');
+        }
+        action._assertValid();
+        return action;
+    }
+    _resetSamplerCursors() {
+        for (let index = 0; index < this.runtimeTracks.length; index++) {
+            this.runtimeTracks[index].sampler.resetCursor();
+        }
+    }
+    _assertValid() {
+        this._owner.assertActive();
+        if (!this._valid) {
+            throw new Animation3DError('invalid-action', `Animation3D action "${this.id}" is no longer valid.`, { actionId: this.id });
+        }
+    }
+}
+function validateClip(clip) {
+    const clipId = typeof clip?.id === 'string' ? clip.id : '';
+    const fail = (message) => {
+        throw new Animation3DError('invalid-clip', message, { clipId });
+    };
+    if (!clip || typeof clip !== 'object') {
+        fail('Animation3D clip must be an object.');
+    }
+    if (clip.format !== 'haiyue-animation3d-clip@1') {
+        fail(`Unsupported Animation3D clip format "${String(clip.format)}".`);
+    }
+    if (clipId.trim().length === 0) {
+        fail('Animation3D clip id must not be empty.');
+    }
+    if (typeof clip.name !== 'string') {
+        fail(`Animation3D clip "${clipId}" name must be a string.`);
+    }
+    if (!Number.isFinite(clip.duration) || clip.duration < 0) {
+        fail(`Animation3D clip duration must be finite and non-negative; received ${clip.duration}.`);
+    }
+    if (!Array.isArray(clip.tracks)) {
+        fail(`Animation3D clip "${clipId}" tracks must be an array.`);
+    }
+    if (!Array.isArray(clip.events)) {
+        fail(`Animation3D clip "${clipId}" events must be an array.`);
+    }
+    const trackIds = new Set();
+    for (let index = 0; index < clip.tracks.length; index++) {
+        const track = clip.tracks[index];
+        validateAnimation3DTrack(track, clip.duration);
+        if (trackIds.has(track.id)) {
+            fail(`Animation3D clip "${clipId}" contains duplicate track id "${track.id}".`);
+        }
+        trackIds.add(track.id);
+    }
+    const eventIds = new Set();
+    for (let index = 0; index < clip.events.length; index++) {
+        const event = clip.events[index];
+        if (!event || typeof event.id !== 'string' || event.id.trim().length === 0) {
+            fail(`Animation3D clip "${clipId}" event ids must not be empty.`);
+        }
+        if (eventIds.has(event.id)) {
+            fail(`Animation3D clip "${clipId}" contains duplicate event id "${event.id}".`);
+        }
+        eventIds.add(event.id);
+        if (typeof event.name !== 'string') {
+            fail(`Animation3D event "${event.id}" name must be a string.`);
+        }
+        if (!Number.isFinite(event.time) || event.time < 0 || event.time > clip.duration) {
+            fail(`Animation3D event "${event.id}" must lie within its clip duration.`);
+        }
+    }
+}
+function validateRepetitions(value) {
+    if (value === Infinity)
+        return value;
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new RangeError(`Animation3DAction.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 isEven(value) {
+    return Math.abs(value % 2) === 0;
+}
+
+/**
+ * Contract-compatible Animation3D mixer runtime.
+ *
+ * Clips remain caller-owned immutable values. The mixer caches only samplers,
+ * blend accumulators, and resolver results; it never retains AssetHandles.
+ */
+class Animation3DMixerRuntime {
+    resolver;
+    _actions = [];
+    _actionsById = new Map();
+    _accumulators = new Map();
+    _accumulatorList = [];
+    _resolvedBindings = new Map();
+    _resolverRevision = Number.NaN;
+    _state = 'active';
+    _time = 0;
+    _timeScale = 1;
+    _nextActionId = 1;
+    _synchronizedFrameOut = null;
+    _synchronizedPreviousTime = 0;
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    get state() { return this._state; }
+    get actions() { return this._actions; }
+    get liveBindingCount() { return this._accumulators.size; }
+    get time() { return this._time; }
+    get timeScale() { return this._timeScale; }
+    set timeScale(value) {
+        this.assertActive();
+        if (!Number.isFinite(value)) {
+            throw new RangeError(`Animation3DMixer.timeScale must be finite; received ${value}.`);
+        }
+        this._timeScale = value;
+    }
+    createAction(clip, options = {}) {
+        this.assertActive();
+        const clipId = typeof clip?.id === 'string' ? clip.id : '';
+        const id = options.id ?? `${clipId}:${this._nextActionId++}`;
+        if (!id) {
+            throw new Animation3DError('invalid-action', 'Animation3D action id must not be empty.', { clipId });
+        }
+        if (this._actionsById.has(id)) {
+            throw new Animation3DError('duplicate-action-id', `Animation3D action id "${id}" already exists in this mixer.`, { actionId: id });
+        }
+        const action = new Animation3DActionRuntime(this, clip, id, options);
+        for (let index = 0; index < action.runtimeTracks.length; index++) {
+            this._retainBinding(action.runtimeTracks[index].track.binding);
+        }
+        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 instanceof Animation3DActionRuntime
+                ? action
+                : undefined;
+        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;
+    }
+    stopAllActions() {
+        this.assertActive();
+        for (let index = 0; index < this._actions.length; index++)
+            this._actions[index].stop();
+        return this;
+    }
+    update(deltaSeconds, out) {
+        this.assertActive();
+        this._requireIndependentClock();
+        if (!Number.isFinite(deltaSeconds)) {
+            throw new RangeError(`Animation3DMixer delta must be finite; received ${deltaSeconds}.`);
+        }
+        const previousTime = this._time;
+        const mixerDelta = deltaSeconds * this._timeScale;
+        this._time += mixerDelta;
+        out.reset(this._time);
+        this._advanceActions(mixerDelta, previousTime, this._time, out);
+        this._evaluateInto(out);
+        return out.seal();
+    }
+    evaluate(out) {
+        this.assertActive();
+        this._requireIndependentClock();
+        out.reset(this._time);
+        this._evaluateInto(out);
+        return out.seal();
+    }
+    setTime(timeSeconds, out) {
+        this.assertActive();
+        this._requireIndependentClock();
+        if (!Number.isFinite(timeSeconds)) {
+            throw new RangeError(`Animation3DMixer time must be finite; received ${timeSeconds}.`);
+        }
+        const previousTime = this._time;
+        const mixerDelta = timeSeconds - previousTime;
+        this._time = timeSeconds;
+        out.reset(this._time);
+        this._advanceActions(mixerDelta, previousTime, this._time, out);
+        this._evaluateInto(out);
+        return out.seal();
+    }
+    /**
+     * Opens an externally-clocked evaluation frame. Ordinary update/evaluate/
+     * setTime calls are rejected until the synchronized frame is closed.
+     */
+    beginSynchronizedFrame(timeSeconds, out) {
+        this.assertActive();
+        if (this._synchronizedFrameOut) {
+            throw new Error('Animation3D mixer already has an active synchronized frame.');
+        }
+        if (!Number.isFinite(timeSeconds)) {
+            throw new RangeError(`Animation3D synchronized frame time must be finite; received ${timeSeconds}.`);
+        }
+        this._synchronizedPreviousTime = this._time;
+        this._time = timeSeconds;
+        this._synchronizedFrameOut = out;
+        out.reset(timeSeconds);
+    }
+    endSynchronizedFrame(out) {
+        this.assertActive();
+        if (this._synchronizedFrameOut !== out) {
+            throw new Error('Animation3D synchronized frame output does not match the active frame.');
+        }
+        try {
+            this._evaluateInto(out);
+            const pose = out.seal();
+            this._synchronizedFrameOut = null;
+            this._synchronizedPreviousTime = this._time;
+            return pose;
+        }
+        catch (error) {
+            this._time = this._synchronizedPreviousTime;
+            this._synchronizedFrameOut = null;
+            throw error;
+        }
+    }
+    cancelSynchronizedFrame(out) {
+        if (this._synchronizedFrameOut !== out)
+            return;
+        this._time = this._synchronizedPreviousTime;
+        this._synchronizedFrameOut = null;
+    }
+    /** @internal Restores a completed frame when a sibling mixer in one controller transaction fails. */
+    rollbackCompletedSynchronizedFrame(timeSeconds) {
+        this.assertActive();
+        if (this._synchronizedFrameOut) {
+            throw new Error('Animation3D mixer cannot roll back a completed frame while another frame is active.');
+        }
+        if (!Number.isFinite(timeSeconds)) {
+            throw new RangeError(`Animation3D rollback time must be finite; received ${timeSeconds}.`);
+        }
+        this._time = timeSeconds;
+        this._synchronizedPreviousTime = timeSeconds;
+    }
+    destroy() {
+        if (this._state === 'destroyed')
+            return;
+        for (let index = 0; index < this._actions.length; index++)
+            this._actions[index].invalidate();
+        this._actions.length = 0;
+        this._actionsById.clear();
+        this._accumulatorList.length = 0;
+        this._accumulators.clear();
+        this._resolvedBindings.clear();
+        this._synchronizedFrameOut = null;
+        this._synchronizedPreviousTime = 0;
+        this._state = 'destroyed';
+    }
+    assertActive() {
+        if (this._state !== 'active') {
+            throw new Animation3DError('mixer-destroyed', 'Animation3D mixer has been destroyed.');
+        }
+    }
+    _requireIndependentClock() {
+        if (this._synchronizedFrameOut) {
+            throw new Error('Animation3D mixer clock cannot advance during a controller-owned synchronized frame.');
+        }
+    }
+    _advanceActions(mixerDelta, previousTime, currentTime, out) {
+        for (let index = 0; index < this._actions.length; index++) {
+            this._actions[index].advance(mixerDelta, previousTime, currentTime, out);
+        }
+    }
+    _evaluateInto(out) {
+        this._invalidateResolvedBindingsIfNeeded();
+        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;
+            const tracks = action.runtimeTracks;
+            for (let trackIndex = 0; trackIndex < tracks.length; trackIndex++) {
+                const runtimeTrack = tracks[trackIndex];
+                const binding = runtimeTrack.track.binding;
+                if (!action.acceptsBinding(binding))
+                    continue;
+                const accumulator = this._accumulators.get(binding.id);
+                if (!accumulator)
+                    continue;
+                const sampled = runtimeTrack.sampler.sample(action.time);
+                accumulator.active = true;
+                if (action.blendMode === 'additive') {
+                    accumulateAdditive(accumulator, runtimeTrack, sampled, weight);
+                }
+                else {
+                    accumulateOverride(accumulator, sampled, weight);
+                }
+            }
+        }
+        for (let index = 0; index < this._accumulatorList.length; index++) {
+            const accumulator = this._accumulatorList[index];
+            if (!accumulator.active)
+                continue;
+            this._readBase(accumulator);
+            finalizeAccumulator(accumulator);
+            out.write(accumulator.binding, accumulator.result);
+        }
+    }
+    _retainBinding(binding) {
+        const existing = this._accumulators.get(binding.id);
+        if (existing) {
+            if (existing.binding.valueSize !== binding.valueSize
+                || existing.binding.valueType !== binding.valueType) {
+                throw new RangeError(`Animation3D binding id "${binding.id}" has incompatible value contracts.`);
+            }
+            existing.references++;
+            return;
+        }
+        const size = binding.valueSize;
+        const accumulator = {
+            binding,
+            base: new Float32Array(size),
+            result: new Float32Array(size),
+            overrideSum: new Float32Array(size),
+            additiveSum: new Float32Array(size),
+            quaternionAnchor: new Float32Array(4),
+            additiveQuaternion: new Float32Array([0, 0, 0, 1]),
+            references: 1,
+            active: false,
+            overrideWeight: 0,
+            quaternionAnchorSet: false,
+            additiveQuaternionUsed: false,
+        };
+        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);
+        this._resolvedBindings.delete(binding.id);
+        const index = this._accumulatorList.indexOf(accumulator);
+        if (index >= 0)
+            this._accumulatorList.splice(index, 1);
+    }
+    _invalidateResolvedBindingsIfNeeded() {
+        if (this._resolverRevision === this.resolver.revision)
+            return;
+        this._resolverRevision = this.resolver.revision;
+        this._resolvedBindings.clear();
+    }
+    _readBase(accumulator) {
+        const id = accumulator.binding.id;
+        let resolved = this._resolvedBindings.get(id);
+        if (resolved === undefined && !this._resolvedBindings.has(id)) {
+            resolved = this.resolver.resolve(accumulator.binding);
+            this._resolvedBindings.set(id, resolved);
+        }
+        if (resolved) {
+            resolved.read(accumulator.base);
+            return;
+        }
+        throw new Animation3DError('resolver-miss', `Animation3D binding resolver could not resolve "${id}".`, { resolver: 'binding', bindingId: id });
+    }
+}
+function resetAccumulator(accumulator) {
+    accumulator.active = false;
+    accumulator.overrideWeight = 0;
+    accumulator.quaternionAnchorSet = false;
+    accumulator.additiveQuaternionUsed = false;
+    accumulator.overrideSum.fill(0);
+    accumulator.additiveSum.fill(0);
+    accumulator.additiveQuaternion[0] = 0;
+    accumulator.additiveQuaternion[1] = 0;
+    accumulator.additiveQuaternion[2] = 0;
+    accumulator.additiveQuaternion[3] = 1;
+}
+function accumulateOverride(accumulator, sampled, weight) {
+    if (accumulator.binding.valueType !== 'quaternion') {
+        for (let index = 0; index < sampled.length; index++) {
+            accumulator.overrideSum[index] = accumulator.overrideSum[index] + sampled[index] * weight;
+        }
+        accumulator.overrideWeight += weight;
+        return;
+    }
+    let sign = 1;
+    if (!accumulator.quaternionAnchorSet) {
+        accumulator.quaternionAnchor.set(sampled);
+        accumulator.quaternionAnchorSet = true;
+    }
+    else {
+        const dot = accumulator.quaternionAnchor[0] * sampled[0]
+            + accumulator.quaternionAnchor[1] * sampled[1]
+            + accumulator.quaternionAnchor[2] * sampled[2]
+            + accumulator.quaternionAnchor[3] * sampled[3];
+        if (dot < 0)
+            sign = -1;
+    }
+    for (let index = 0; index < 4; index++) {
+        accumulator.overrideSum[index] = accumulator.overrideSum[index]
+            + sampled[index] * weight * sign;
+    }
+    accumulator.overrideWeight += weight;
+}
+function accumulateAdditive(accumulator, runtimeTrack, sampled, weight) {
+    if (accumulator.binding.valueType === 'quaternion') {
+        accumulateAdditiveQuaternion(accumulator.additiveQuaternion, sampled, runtimeTrack.reference, weight);
+        accumulator.additiveQuaternionUsed = true;
+        return;
+    }
+    for (let index = 0; index < sampled.length; index++) {
+        accumulator.additiveSum[index] = accumulator.additiveSum[index]
+            + (sampled[index] - runtimeTrack.reference[index]) * weight;
+    }
+}
+function finalizeAccumulator(accumulator) {
+    const size = accumulator.binding.valueSize;
+    const overrideWeight = accumulator.overrideWeight;
+    if (accumulator.binding.valueType !== 'quaternion') {
+        if (overrideWeight > 0) {
+            if (overrideWeight < 1) {
+                const baseWeight = 1 - overrideWeight;
+                for (let index = 0; index < size; index++) {
+                    accumulator.result[index] = accumulator.overrideSum[index]
+                        + accumulator.base[index] * baseWeight;
+                }
+            }
+            else {
+                const inverseWeight = 1 / overrideWeight;
+                for (let index = 0; index < size; index++) {
+                    accumulator.result[index] = accumulator.overrideSum[index] * inverseWeight;
+                }
+            }
+        }
+        else {
+            accumulator.result.set(accumulator.base);
+        }
+        for (let index = 0; index < size; index++) {
+            accumulator.result[index] = accumulator.result[index] + accumulator.additiveSum[index];
+        }
+        return;
+    }
+    if (overrideWeight > 0) {
+        accumulator.result.set(accumulator.overrideSum);
+        if (overrideWeight < 1) {
+            let sign = 1;
+            const anchorDot = accumulator.quaternionAnchor[0] * accumulator.base[0]
+                + accumulator.quaternionAnchor[1] * accumulator.base[1]
+                + accumulator.quaternionAnchor[2] * accumulator.base[2]
+                + accumulator.quaternionAnchor[3] * accumulator.base[3];
+            if (anchorDot < 0)
+                sign = -1;
+            const baseWeight = 1 - overrideWeight;
+            for (let index = 0; index < 4; index++) {
+                accumulator.result[index] = accumulator.result[index]
+                    + accumulator.base[index] * baseWeight * sign;
+            }
+        }
+        normalizeQuaternion$1(accumulator.result);
+    }
+    else {
+        accumulator.result.set(accumulator.base);
+        normalizeQuaternion$1(accumulator.result);
+    }
+    if (accumulator.additiveQuaternionUsed) {
+        multiplyQuaternionInPlace(accumulator.result, accumulator.additiveQuaternion);
+        normalizeQuaternion$1(accumulator.result);
+    }
+}
+function accumulateAdditiveQuaternion(accumulated, sampled, reference, weight) {
+    const rx = reference[0];
+    const ry = reference[1];
+    const rz = reference[2];
+    const rw = reference[3];
+    const inverseLengthSquared = 1 / Math.max(Number.EPSILON, rx * rx + ry * ry + rz * rz + rw * rw);
+    const ix = -rx * inverseLengthSquared;
+    const iy = -ry * inverseLengthSquared;
+    const iz = -rz * inverseLengthSquared;
+    const iw = rw * inverseLengthSquared;
+    const sx = sampled[0];
+    const sy = sampled[1];
+    const sz = sampled[2];
+    const sw = sampled[3];
+    let dx = iw * sx + ix * sw + iy * sz - iz * sy;
+    let dy = iw * sy - ix * sz + iy * sw + iz * sx;
+    let dz = iw * sz + ix * sy - iy * sx + iz * sw;
+    let dw = iw * sw - ix * sx - iy * sy - iz * sz;
+    if (dw < 0) {
+        dx = -dx;
+        dy = -dy;
+        dz = -dz;
+        dw = -dw;
+    }
+    dw = Math.min(1, Math.max(-1, dw));
+    let wx;
+    let wy;
+    let wz;
+    let ww;
+    if (dw > 0.9995) {
+        wx = dx * weight;
+        wy = dy * weight;
+        wz = dz * weight;
+        ww = 1 + (dw - 1) * weight;
+        const inverseLength = 1 / Math.max(Number.EPSILON, Math.hypot(wx, wy, wz, ww));
+        wx *= inverseLength;
+        wy *= inverseLength;
+        wz *= inverseLength;
+        ww *= inverseLength;
+    }
+    else {
+        const theta = Math.acos(dw);
+        const scale = Math.sin(theta * weight) / Math.sin(theta);
+        wx = dx * scale;
+        wy = dy * scale;
+        wz = dz * scale;
+        ww = Math.cos(theta * weight);
+    }
+    const ax = accumulated[0];
+    const ay = accumulated[1];
+    const az = accumulated[2];
+    const aw = accumulated[3];
+    accumulated[0] = aw * wx + ax * ww + ay * wz - az * wy;
+    accumulated[1] = aw * wy - ax * wz + ay * ww + az * wx;
+    accumulated[2] = aw * wz + ax * wy - ay * wx + az * ww;
+    accumulated[3] = aw * ww - ax * wx - ay * wy - az * wz;
+    normalizeQuaternion$1(accumulated);
+}
+function multiplyQuaternionInPlace(target, right) {
+    const ax = target[0];
+    const ay = target[1];
+    const az = target[2];
+    const aw = target[3];
+    const bx = right[0];
+    const by = right[1];
+    const bz = right[2];
+    const bw = right[3];
+    target[0] = aw * bx + ax * bw + ay * bz - az * by;
+    target[1] = aw * by - ax * bz + ay * bw + az * bx;
+    target[2] = aw * bz + ax * by - ay * bx + az * bw;
+    target[3] = aw * bw - ax * bx - ay * by - az * bz;
+}
+
+const MIXER_RUNTIMES = new WeakMap();
+/** @internal Connects the public facade to controller-only runtime operations. */
+function registerAnimation3DMixerRuntime(mixer, runtime) {
+    MIXER_RUNTIMES.set(mixer, runtime);
+}
+/** @internal Used only by the state-machine facade integration. */
+function animation3DMixerRuntime(mixer) {
+    const runtime = MIXER_RUNTIMES.get(mixer);
+    if (!runtime) {
+        throw new TypeError('Expected an Animation3DMixer facade instance.');
+    }
+    return runtime;
+}
+
+/**
+ * Public mixer facade. Controller-only clock/transaction hooks remain on the
+ * internal runtime and are intentionally absent from this surface.
+ */
+class Animation3DMixer {
+    #runtime;
+    constructor(resolver) {
+        this.#runtime = new Animation3DMixerRuntime(resolver);
+        registerAnimation3DMixerRuntime(this, this.#runtime);
+    }
+    get state() { return this.#runtime.state; }
+    get resolver() { return this.#runtime.resolver; }
+    get actions() { return this.#runtime.actions; }
+    get time() { return this.#runtime.time; }
+    get timeScale() { return this.#runtime.timeScale; }
+    set timeScale(value) { this.#runtime.timeScale = value; }
+    createAction(clip, options) {
+        return this.#runtime.createAction(clip, options);
+    }
+    getAction(actionId) {
+        return this.#runtime.getAction(actionId);
+    }
+    removeAction(action) {
+        return this.#runtime.removeAction(action);
+    }
+    stopAllActions() {
+        this.#runtime.stopAllActions();
+        return this;
+    }
+    update(deltaSeconds, out) {
+        return this.#runtime.update(deltaSeconds, out);
+    }
+    evaluate(out) {
+        return this.#runtime.evaluate(out);
+    }
+    setTime(timeSeconds, out) {
+        return this.#runtime.setTime(timeSeconds, out);
+    }
+    destroy() {
+        this.#runtime.destroy();
+    }
+}
+
+class GltfAnimation3DResolvedEndpoint {
+    binding;
+    state;
+    path;
+    _onDirectWrite;
+    constructor(binding, state, path, onDirectWrite) {
+        this.binding = binding;
+        this.state = state;
+        this.path = path;
+        this._onDirectWrite = onDirectWrite;
+    }
+    read(out) {
+        copyValues(this.baseValue(), out, this.binding.valueSize);
+    }
+    write(value) {
+        this.writeCurrent(value);
+        commitTargetState(this.state, this.path.startsWith('transform.'), this.path === 'morph.weights');
+        this._onDirectWrite();
+    }
+    resetCurrentFromBase() {
+        this.state.translation.set(this.state.baseTranslation);
+        this.state.rotation.set(this.state.baseRotation);
+        this.state.scale.set(this.state.baseScale);
+        this.state.weights.set(this.state.baseWeights);
+    }
+    writeCurrent(value) {
+        switch (this.path) {
+            case 'transform.translation':
+                copyValues(value, this.state.translation, 3);
+                this.state.touchedTransform = true;
+                break;
+            case 'transform.rotation':
+                copyValues(value, this.state.rotation, 4);
+                normalizeQuaternion(this.state.rotation);
+                this.state.touchedTransform = true;
+                break;
+            case 'transform.scale':
+                copyValues(value, this.state.scale, 3);
+                this.state.touchedTransform = true;
+                break;
+            case 'morph.weights':
+                copyValues(value, this.state.weights, this.binding.valueSize);
+                this.state.touchedWeights = true;
+                break;
+        }
+    }
+    baseValue() {
+        switch (this.path) {
+            case 'transform.translation': return this.state.baseTranslation;
+            case 'transform.rotation': return this.state.baseRotation;
+            case 'transform.scale': return this.state.baseScale;
+            case 'morph.weights': return this.state.baseWeights;
+        }
+    }
+}
+/**
+ * Resolves source-independent Animation3D bindings to one loaded glTF model.
+ * Base reads remain the authored glTF pose so partial fades do not accumulate
+ * the previously applied frame back into the next mix.
+ */
+class GltfAnimation3DBindingResolver {
+    _endpoints;
+    _revision = 0;
+    _destroyed = false;
+    constructor(endpoints) {
+        this._endpoints = endpoints;
+    }
+    get revision() { return this._revision; }
+    get bindingCount() { return this._endpoints.size; }
+    get destroyed() { return this._destroyed; }
+    resolve(binding) {
+        if (this._destroyed)
+            return null;
+        const endpoint = this._endpoints.get(binding.id);
+        if (!endpoint
+            || endpoint.binding.path !== binding.path
+            || endpoint.binding.valueType !== binding.valueType
+            || endpoint.binding.valueSize !== binding.valueSize) {
+            return null;
+        }
+        return endpoint;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._endpoints.clear();
+        this._revision++;
+    }
+}
+/**
+ * Applies a transient Animation3D pose to glTF Transform3D, skinning and morph
+ * resources. Target scratch and active lists are retained and reused.
+ */
+class GltfAnimation3DPoseApplier {
+    _targetStates;
+    _endpoints;
+    _skinnedPrimitives;
+    _activeTargets = [];
+    _previousTargets = [];
+    _generation = 0;
+    _destroyed = false;
+    constructor(context) {
+        this._targetStates = context.targetStates;
+        this._endpoints = context.endpoints;
+        this._skinnedPrimitives = context.skinnedPrimitives;
+    }
+    get targetCount() { return this._targetStates.size; }
+    get destroyed() { return this._destroyed; }
+    apply(pose) {
+        this.assertActive();
+        const generation = ++this._generation;
+        this._activeTargets.length = 0;
+        for (const channel of pose.channels) {
+            const endpoint = this._endpoints.get(channel.binding.id);
+            if (!endpoint)
+                continue;
+            const state = endpoint.state;
+            if (state.seenGeneration !== generation) {
+                state.seenGeneration = generation;
+                state.touchedTransform = false;
+                state.touchedWeights = false;
+                endpoint.resetCurrentFromBase();
+                this._activeTargets.push(state);
+            }
+            endpoint.writeCurrent(channel.value);
+        }
+        let changed = false;
+        for (const state of this._previousTargets) {
+            if (state.seenGeneration === generation)
+                continue;
+            state.translation.set(state.baseTranslation);
+            state.rotation.set(state.baseRotation);
+            state.scale.set(state.baseScale);
+            state.weights.set(state.baseWeights);
+            commitTargetState(state, state.appliedTransform, state.appliedWeights);
+            changed ||= state.appliedTransform || state.appliedWeights;
+            state.appliedTransform = false;
+            state.appliedWeights = false;
+        }
+        for (const state of this._activeTargets) {
+            const restoreTransform = state.appliedTransform && !state.touchedTransform;
+            const restoreWeights = state.appliedWeights && !state.touchedWeights;
+            commitTargetState(state, state.touchedTransform || restoreTransform, state.touchedWeights || restoreWeights);
+            changed ||= state.touchedTransform || state.touchedWeights || restoreTransform || restoreWeights;
+            state.appliedTransform = state.touchedTransform;
+            state.appliedWeights = state.touchedWeights;
+        }
+        this._previousTargets.length = 0;
+        this._previousTargets.push(...this._activeTargets);
+        if (changed)
+            updateSkinnedPrimitives(this._skinnedPrimitives);
+    }
+    destroy(restoreBasePose = true) {
+        if (this._destroyed)
+            return;
+        if (restoreBasePose) {
+            let changed = false;
+            for (const state of this._previousTargets) {
+                state.translation.set(state.baseTranslation);
+                state.rotation.set(state.baseRotation);
+                state.scale.set(state.baseScale);
+                state.weights.set(state.baseWeights);
+                commitTargetState(state, state.appliedTransform, state.appliedWeights);
+                changed ||= state.appliedTransform || state.appliedWeights;
+            }
+            if (changed)
+                updateSkinnedPrimitives(this._skinnedPrimitives);
+        }
+        this._destroyed = true;
+        this._activeTargets.length = 0;
+        this._previousTargets.length = 0;
+        this._targetStates.clear();
+        this._endpoints.clear();
+    }
+    assertActive() {
+        if (this._destroyed)
+            throw new Error('glTF Animation3D pose applier has been destroyed.');
+    }
+}
+class GltfAnimation3DRuntimeOwnerComponent extends Component {
+    _runtime = null;
+    constructor() {
+        super('GltfAnimation3DRuntimeOwner');
+    }
+    attach(runtime) {
+        this._runtime = runtime;
+    }
+    release(runtime) {
+        if (this._runtime === runtime)
+            this._runtime = null;
+    }
+    clone() {
+        return new GltfAnimation3DRuntimeOwnerComponent();
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        const runtime = this._runtime;
+        this._runtime = null;
+        runtime?.destroy();
+        super.destroy();
+    }
+}
+/**
+ * Model-scoped owner combining the existing Animation3D mixer with glTF
+ * binding and pose adapters. It does not own or dispose the LoadedGltfModel.
+ */
+class GltfAnimation3DRuntime {
+    mixer;
+    pose = new Animation3DPoseBuffer();
+    _clips;
+    _owner;
+    _resolver;
+    _poseApplier;
+    _root;
+    _state = 'active';
+    _signal;
+    _abortListener;
+    constructor(model, options = {}) {
+        if (options.signal?.aborted)
+            throw createAbortError('glTF Animation3D runtime creation aborted.', options.signal.reason);
+        const context = createAdapterContext(model);
+        this._clips = createClips(model.animationClips, context, options.clipIdPrefix);
+        this._resolver = new GltfAnimation3DBindingResolver(context.endpoints);
+        this._poseApplier = new GltfAnimation3DPoseApplier(context);
+        this.mixer = new Animation3DMixer(this._resolver);
+        this._root = model.root;
+        this._owner = new GltfAnimation3DRuntimeOwnerComponent();
+        this._owner.attach(this);
+        model.root.addComponent(this._owner);
+        this._signal = options.signal ?? null;
+        this._abortListener = this._signal
+            ? () => this.destroy()
+            : null;
+        if (this._signal && this._abortListener) {
+            this._signal.addEventListener('abort', this._abortListener, { once: true });
+        }
+    }
+    get state() { return this._state; }
+    get root() { return this._root; }
+    get clips() { return this._clips; }
+    /** Diagnostic count without exposing the model-specific resolver handle. */
+    get bindingCount() { return this._resolver.bindingCount; }
+    /** Diagnostic count without exposing the model-specific pose-applier handle. */
+    get targetCount() { return this._poseApplier.targetCount; }
+    update(deltaSeconds) {
+        this.assertActive();
+        const pose = this.mixer.update(deltaSeconds, this.pose);
+        this._poseApplier.apply(pose);
+        return pose;
+    }
+    evaluate() {
+        this.assertActive();
+        const pose = this.mixer.evaluate(this.pose);
+        this._poseApplier.apply(pose);
+        return pose;
+    }
+    /** @internal Applies a pose produced by a shared multi-mixer state-machine transaction. */
+    applySynchronizedPose(pose) {
+        this.assertActive();
+        this._poseApplier.apply(pose);
+    }
+    setTime(timeSeconds) {
+        this.assertActive();
+        const pose = this.mixer.setTime(timeSeconds, this.pose);
+        this._poseApplier.apply(pose);
+        return pose;
+    }
+    destroy() {
+        if (this._state === 'destroyed')
+            return;
+        this._state = 'destroyed';
+        if (this._signal && this._abortListener) {
+            this._signal.removeEventListener('abort', this._abortListener);
+        }
+        const root = this._root;
+        this._root = null;
+        this._owner.release(this);
+        this.mixer.destroy();
+        this._poseApplier.destroy(root ? !root.destroyed : false);
+        this._resolver.destroy();
+        this._clips.length = 0;
+    }
+    assertActive() {
+        if (this._state !== 'active' || this._root?.destroyed) {
+            this.destroy();
+            throw new Error('glTF Animation3D runtime has been destroyed.');
+        }
+    }
+}
+function createGltfAnimation3DRuntime(model, options = {}) {
+    return new GltfAnimation3DRuntime(model, options);
+}
+/** Converts loaded legacy glTF clips without exposing glTF sampler structures. */
+function createGltfAnimation3DClips(model, clipIdPrefix) {
+    const context = createAdapterContext(model);
+    return createClips(model.animationClips, context, clipIdPrefix);
+}
+function createAdapterContext(model) {
+    const targetSizes = new Map();
+    const skinnedPrimitives = new Set();
+    for (const clip of model.animationClips) {
+        for (const channel of clip.channels) {
+            const previousSize = targetSizes.get(channel.target) ?? channel.target.weights.length;
+            targetSizes.set(channel.target, Math.max(previousSize, channel.path === 'weights' ? channel.valueSize : 0));
+        }
+        for (const primitive of clip.skinnedPrimitives)
+            skinnedPrimitives.add(primitive);
+    }
+    const targetStates = new Map();
+    for (const [target, weightSize] of targetSizes) {
+        const nodePath = createStableNodePath(model.root, target.entity);
+        const baseWeights = new Float32Array(Math.max(weightSize, target.weights.length));
+        copyValues(target.weights, baseWeights, baseWeights.length);
+        const baseRotation = new Float32Array(target.rotation);
+        normalizeQuaternion(baseRotation);
+        targetStates.set(target, {
+            target,
+            nodePath,
+            nodeKey: nodePath.join('/'),
+            baseTranslation: new Float32Array(target.translation),
+            baseRotation,
+            baseScale: new Float32Array(target.scale),
+            baseWeights,
+            translation: new Float32Array(target.translation),
+            rotation: new Float32Array(baseRotation),
+            scale: new Float32Array(target.scale),
+            weights: new Float32Array(baseWeights),
+            matrix: new Float32Array(16),
+            seenGeneration: 0,
+            touchedTransform: false,
+            touchedWeights: false,
+            appliedTransform: false,
+            appliedWeights: false,
+        });
+    }
+    const endpoints = new Map();
+    const context = {
+        targetStates,
+        endpoints,
+        skinnedPrimitives: [...skinnedPrimitives],
+    };
+    const updateSkinning = () => updateSkinnedPrimitives(context.skinnedPrimitives);
+    for (const clip of model.animationClips) {
+        for (const channel of clip.channels) {
+            const state = requiredTargetState(context, channel.target);
+            const binding = createBinding(state, channel.path, channel.valueSize);
+            if (!endpoints.has(binding.id)) {
+                endpoints.set(binding.id, new GltfAnimation3DResolvedEndpoint(binding, state, bindingPath(channel.path), updateSkinning));
+            }
+        }
+    }
+    return context;
+}
+function createClips(clips, context, clipIdPrefix = 'gltf-animation') {
+    return clips.map((clip, clipIndex) => {
+        const id = `${clipIdPrefix}:${clipIndex}`;
+        const tracks = clip.channels.map((channel, channelIndex) => {
+            const state = requiredTargetState(context, channel.target);
+            const binding = context.endpoints.get(bindingId(state, bindingPath(channel.path)))?.binding;
+            if (!binding)
+                throw new Error(`Missing glTF Animation3D binding for ${channel.path}.`);
+            const times = copyFiniteValues(channel.input, `${id}.tracks[${channelIndex}].times`);
+            validateTimes(times, clip.duration, `${id}.tracks[${channelIndex}].times`);
+            const interpolation = mapInterpolation(channel.interpolation);
+            const values = copyFiniteValues(channel.output, `${id}.tracks[${channelIndex}].values`);
+            validateTrackValues(times, values, binding.valueSize, interpolation, `${id}.tracks[${channelIndex}]`);
+            return {
+                id: `${id}:track:${channelIndex}`,
+                binding,
+                interpolation,
+                times,
+                values,
+            };
+        });
+        return {
+            format: 'haiyue-animation3d-clip@1',
+            id,
+            name: clip.name,
+            duration: clip.duration,
+            tracks,
+            events: [],
+        };
+    });
+}
+function createBinding(state, path, valueSize) {
+    const target = Object.freeze({
+        kind: 'node-path',
+        segments: state.nodePath,
+    });
+    switch (path) {
+        case 'translation':
+            return {
+                id: bindingId(state, 'transform.translation'),
+                target,
+                path: 'transform.translation',
+                valueType: 'vec3',
+                valueSize: 3,
+            };
+        case 'rotation':
+            return {
+                id: bindingId(state, 'transform.rotation'),
+                target,
+                path: 'transform.rotation',
+                valueType: 'quaternion',
+                valueSize: 4,
+            };
+        case 'scale':
+            return {
+                id: bindingId(state, 'transform.scale'),
+                target,
+                path: 'transform.scale',
+                valueType: 'vec3',
+                valueSize: 3,
+            };
+        case 'weights':
+            if (!Number.isInteger(valueSize) || valueSize <= 0) {
+                throw new RangeError(`glTF morph binding requires a positive valueSize; received ${valueSize}.`);
+            }
+            return {
+                id: bindingId(state, 'morph.weights'),
+                target,
+                path: 'morph.weights',
+                valueType: 'weights',
+                valueSize,
+            };
+    }
+}
+function bindingPath(path) {
+    switch (path) {
+        case 'translation': return 'transform.translation';
+        case 'rotation': return 'transform.rotation';
+        case 'scale': return 'transform.scale';
+        case 'weights': return 'morph.weights';
+    }
+}
+function bindingId(state, path) {
+    return `gltf:${state.nodeKey}:${path}`;
+}
+function mapInterpolation(interpolation) {
+    switch (interpolation) {
+        case 'STEP': return 'step';
+        case 'CUBICSPLINE': return 'cubic-spline';
+        case 'LINEAR': return 'linear';
+    }
+}
+function requiredTargetState(context, target) {
+    const state = context.targetStates.get(target);
+    if (!state)
+        throw new Error(`glTF animation target "${target.entity.name}" is not registered.`);
+    return state;
+}
+function createStableNodePath(root, target) {
+    const reversed = [];
+    let current = target;
+    while (current && current !== root) {
+        const parent = current.parent;
+        if (!parent) {
+            throw new Error(`glTF animation target "${target.name}" is outside the loaded model root.`);
+        }
+        const siblingIndex = parent.children.indexOf(current);
+        reversed.push(`${encodeURIComponent(current.name)}[${siblingIndex}]`);
+        current = parent;
+    }
+    if (current !== root) {
+        throw new Error(`glTF animation target "${target.name}" is outside the loaded model root.`);
+    }
+    reversed.reverse();
+    return Object.freeze(reversed);
+}
+function copyFiniteValues(source, path) {
+    const out = new Float32Array(source.length);
+    for (let index = 0; index < source.length; index++) {
+        const value = source[index];
+        if (!Number.isFinite(value))
+            throw new RangeError(`${path}[${index}] must be finite.`);
+        out[index] = value;
+    }
+    return out;
+}
+function validateTimes(times, duration, path) {
+    if (times.length === 0)
+        throw new RangeError(`${path} must contain at least one key.`);
+    for (let index = 0; index < times.length; index++) {
+        const value = times[index];
+        if ((index > 0 && value <= times[index - 1]) || value < 0 || value > duration) {
+            throw new RangeError(`${path} must be strictly increasing and within clip duration.`);
+        }
+    }
+}
+function validateTrackValues(times, values, valueSize, interpolation, path) {
+    const stride = interpolation === 'cubic-spline' ? valueSize * 3 : valueSize;
+    const expected = times.length * stride;
+    if (values.length !== expected) {
+        throw new RangeError(`${path}.values requires ${expected} values; received ${values.length}.`);
+    }
+}
+function commitTargetState(state, transformChanged, weightsChanged) {
+    if (transformChanged) {
+        state.target.transform.localMatrix = composeTrsMatrix(state.translation, state.rotation, state.scale, state.matrix);
+    }
+    if (weightsChanged)
+        applyMorphWeights(state.target, state.weights);
+}
+function updateSkinnedPrimitives(primitives) {
+    for (const primitive of primitives)
+        updateSkinnedPrimitive(primitive);
+}
+function copyValues(source, target, count) {
+    for (let index = 0; index < count; index++)
+        target[index] = source[index] ?? 0;
+}
+function normalizeQuaternion(value) {
+    const x = value[0] ?? 0;
+    const y = value[1] ?? 0;
+    const z = value[2] ?? 0;
+    const w = value[3] ?? 1;
+    const length = Math.hypot(x, y, z, w);
+    if (length <= Number.EPSILON) {
+        value.set([0, 0, 0, 1]);
+        return;
+    }
+    value[0] = x / length;
+    value[1] = y / length;
+    value[2] = z / length;
+    value[3] = w / length;
+}
+
+export { Animation3DError as A, GltfAnimation3DRuntime as G, createGltfAnimation3DRuntime as a, animation3DMixerRuntime as b, createGltfAnimation3DClips as c, Animation3DPoseBuffer as d, Animation3DMixer as e };
+//# sourceMappingURL=GltfAnimation3DAdapter-Cu3rQQsW.js.map