@aura3d/animation 4.7.12 → 5.0.0

package/dist/pose/PoseMixer.js

@@ -1,7 +1,9 @@
-import { sampleClipEvents } from "../AnimationClipEvents.js";
+import { AnimationClip } from "../AnimationClip.js";
+import { AnimationAction } from "../AnimationAction.js";
 import { compileClip, createTrackCursors, sampleTrackInto } from "./CompiledClip.js";
 import { lerpVec3Flat, multiplyQuatFlat, slerpQuatFlat } from "./quatFlat.js";
 import { isClipAdditive } from "./makeClipAdditive.js";
+import { PoseInertializer } from "./PoseInertializer.js";
 export class PoseAction {
     mixer;
     clipName;
@@ -9,18 +11,11 @@ export class PoseAction {
     bindings;
     cursors;
     additive;
+    playback;
     weight = 1;
     timeScale = 1;
-    time = 0;
-    playing = false;
-    paused = false;
     enabled = true;
-    loopMode = "repeat";
-    repetitions = Infinity;
-    clampWhenFinished = false;
     syncGroupName = null;
-    pingPongForward = true;
-    loopCount = -1;
     fade = null;
     warpState = null;
     restoreTimeScale = null;
@@ -40,70 +35,103 @@ export class PoseAction {
         this.bindings = mixer.resolveBindings(clip);
         this.cursors = createTrackCursors(clip);
         const source = mixer.sourceClip(clipName);
+        if (source === undefined)
+            throw new Error(`ANIMATION_CLIP_NOT_FOUND: clip "${clipName}" is not registered.`);
+        this.playback = new AnimationAction(source);
         this.additive = options.additive ?? (source !== undefined && isClipAdditive(source));
-        this.weight = options.weight ?? 1;
-        this.timeScale = options.timeScale ?? 1;
-        if (options.loopMode)
-            this.loopMode = options.loopMode;
-        if (options.repetitions !== undefined)
-            this.repetitions = options.repetitions;
+        this.setEffectiveWeight(options.weight ?? 1);
+        this.setEffectiveTimeScale(options.timeScale ?? 1);
+        this.setLoop(options.loopMode ?? "repeat", options.repetitions ?? Infinity);
         this.clampWhenFinished = options.clampWhenFinished ?? false;
         this.syncGroupName = options.syncGroup ?? null;
     }
+    get time() { return this.playback.time; }
+    set time(value) { this.playback.time = value; }
+    get playing() { return this.playback.playing; }
+    set playing(value) { this.playback.playing = value; }
+    get paused() { return this.playback.paused; }
+    set paused(value) { this.playback.paused = value; }
+    get loopMode() { return this.playback.loopMode; }
+    set loopMode(value) { this.playback.loopMode = value; }
+    get repetitions() { return this.playback.repetitions; }
+    set repetitions(value) { this.playback.repetitions = value; }
+    get clampWhenFinished() { return this.playback.clampWhenFinished; }
+    set clampWhenFinished(value) { this.playback.clampWhenFinished = value; }
+    get lastPlaybackDelta() { return this.playback.lastPlaybackDelta; }
+    /** @internal The core clip, rather than an independently compiled clip, owns playback. */
+    get hasPlaybackDuration() { return this.playback.clip.duration > 0; }
+    /** Maximum markers retained by a single update; excess crossings are reported by the mixer. */
+    get maxEventCatchUp() { return this.playback.maxEventCatchUp; }
+    set maxEventCatchUp(value) { this.playback.maxEventCatchUp = value; }
     play() {
-        this.playing = true;
-        this.paused = false;
-        this.enabled = true;
         this.mixer.activate(this);
+        this.playback.play();
+        this.enabled = true;
         return this;
     }
     stop() {
-        this.playing = false;
-        this.paused = false;
-        this.time = 0;
-        this.loopCount = -1;
-        this.pingPongForward = true;
+        this.playback.stop();
+        this.fade = null;
+        this.warpState = null;
+        this.restoreTimeScale = null;
+        this.effectiveWeight = 0;
+        this.effectiveTimeScale = 0;
         this.mixer.deactivate(this);
         return this;
     }
     pause() {
-        this.paused = true;
+        this.playback.pause();
         return this;
     }
     setEffectiveWeight(weight) {
+        if (!Number.isFinite(weight) || weight < 0)
+            throw new Error("PoseAction weight must be finite and non-negative.");
         this.weight = weight;
         return this;
     }
     setEffectiveTimeScale(timeScale) {
+        if (!Number.isFinite(timeScale))
+            throw new Error("PoseAction timeScale must be finite.");
         this.timeScale = timeScale;
         return this;
     }
     setLoop(mode, repetitions = Infinity) {
-        this.loopMode = mode;
-        this.repetitions = repetitions;
+        this.playback.setLoop(mode, repetitions);
         return this;
     }
     /** three r185 syncWith: copy time + timeScale and stop any warping. */
     syncWith(other) {
-        this.time = other.time;
+        this.playback.synchronizePlayback(other.playback);
         this.timeScale = other.timeScale;
         this.stopWarping();
         return this;
     }
+    /** Align the starting phase and reflection direction without changing this action's rate. */
+    synchronizePhaseWith(other) {
+        this.playback.synchronizePlayback(other.playback, true);
+    }
     fadeIn(duration) {
-        return this.scheduleFade(duration, 0, 1);
+        return this.scheduleFade(duration, 0, this.weight);
     }
     fadeOut(duration) {
-        return this.scheduleFade(duration, 1, 0);
+        return this.scheduleFade(duration, this.currentWeight(this.mixer.time), 0);
     }
     fadeTo(weight, duration) {
-        return this.scheduleFade(duration, this.weight, weight);
+        return this.scheduleFade(duration, this.currentWeight(this.mixer.time), weight);
     }
-    /** three r185 warp: multiplicative timescale interpolant over mixer time (values = start/base → end/base). */
+    /** Linearly change the signed playback rate over unpaused mixer time. */
     warp(startTimeScale, endTimeScale, duration) {
-        const now = this.mixer.time;
-        const base = this.timeScale;
-        this.warpState = { startTime: now, duration, from: startTimeScale / base, to: endTimeScale / base };
+        if (![startTimeScale, endTimeScale, duration].every(Number.isFinite) ||
+            !Number.isFinite(endTimeScale - startTimeScale) || duration < 0) {
+            throw new Error("PoseAction warp rates and duration must be finite and duration non-negative.");
+        }
+        if (duration === 0) {
+            this.warpState = null;
+            this.timeScale = this.restoreTimeScale ?? endTimeScale;
+            this.restoreTimeScale = null;
+            return this;
+        }
+        this.warpState = { duration, elapsed: 0, from: startTimeScale, to: endTimeScale };
         return this;
     }
     stopWarping() {
@@ -130,8 +158,8 @@ export class PoseAction {
             const endStartRatio = fadeOutDuration === 0 ? 1 : fadeInDuration / fadeOutDuration;
             fadeOutAction.restoreTimeScale = fadeOutAction.timeScale;
             this.restoreTimeScale = this.timeScale;
-            fadeOutAction.warp(1.0, startEndRatio, duration);
-            this.warp(endStartRatio, 1.0, duration);
+            fadeOutAction.warp(fadeOutAction.timeScale, fadeOutAction.timeScale * startEndRatio, duration);
+            this.warp(this.timeScale * endStartRatio, this.timeScale, duration);
         }
         return this;
     }
@@ -141,30 +169,248 @@ export class PoseAction {
     get normalizedPhase() {
         return this.clip.duration > 0 ? this.time / this.clip.duration : 0;
     }
+    /** A complete, JSON-safe snapshot; unlike a time/weight diagnostic it can be restored. */
+    snapshot() {
+        return this.serialize();
+    }
+    /**
+     * Capture both the core playback state and the pose-specific envelopes,
+     * synchronization, bindings and layer state. Clip data and executable
+     * callbacks are not copied; their identities must be rebound on restore.
+     */
+    serialize() {
+        this.mixer.assertSnapshotOperation("serialize");
+        assertPoseActionData(this);
+        assertPosePlaybackData(this.playback);
+        const currentWarp = this.warpState;
+        const startTime = currentWarp === null ? 0 : this.mixer.time - currentWarp.elapsed;
+        const warp = currentWarp === null ? null : {
+            startTime,
+            duration: currentWarp.duration,
+            from: currentWarp.from,
+            to: currentWarp.to,
+            ...(this.mixer.time - startTime === currentWarp.elapsed ? {} : { elapsed: currentWarp.elapsed })
+        };
+        const snapshot = {
+            version: 1,
+            clipName: this.clipName,
+            compiledIdentity: poseCompiledIdentity(this.clip),
+            targetIdentity: JSON.stringify(capturePoseSkeleton(this.mixer.skeleton)),
+            mixerTime: this.mixer.time,
+            playback: this.playback.serialize(),
+            bindings: readPoseBindings(this.bindings, this.mixer.skeleton.boneCount, this.clip.tracks.length),
+            cursors: readPoseTypedNumbers(this.cursors, Uint32Array, this.clip.tracks.length, "action cursors"),
+            additive: this.additive,
+            weight: this.weight,
+            timeScale: this.timeScale,
+            enabled: this.enabled,
+            syncGroupName: this.syncGroupName,
+            fade: readPoseEnvelope(this.fade, "fade", true),
+            warp: readPoseWarp(warp),
+            restoreTimeScale: this.restoreTimeScale,
+            effectiveWeight: this.effectiveWeight,
+            effectiveTimeScale: this.effectiveTimeScale,
+            layerMask: this.layerMask === null ? null : readPoseTypedNumbers(this.layerMask, Float32Array, this.mixer.skeleton.boneCount, "action mask"),
+            layerBlendMode: this.layerBlendMode
+        };
+        this.prepareRestore(snapshot, this.mixer.time);
+        rejectPoseNegativeZero(snapshot);
+        return snapshot;
+    }
+    /**
+     * Restore in place without playing, dispatching events or registering the
+     * action. Its existing mixer membership is unchanged. Envelopes are rebased
+     * to the destination mixer's current clock.
+     */
+    restore(snapshot) {
+        return this.restoreAtMixerTime(snapshot, this.mixer.time);
+    }
+    /** @internal Stage a restored action against the clock a mixer will commit. */
+    restoreAtMixerTime(snapshot, targetTime) {
+        this.mixer.assertSnapshotOperation("restore");
+        this.assertRestoreWritable();
+        const state = this.prepareRestore(snapshot, targetTime);
+        const layerMask = state.layerMask === null ? null : new Float32Array(state.layerMask);
+        this.playback.restore(state.playback);
+        this.weight = state.weight;
+        this.timeScale = state.timeScale;
+        this.enabled = state.enabled;
+        this.syncGroupName = state.syncGroupName;
+        this.fade = state.fade;
+        this.warpState = state.warp === null ? null : {
+            duration: state.warp.duration,
+            elapsed: state.warp.elapsed,
+            from: state.warp.from,
+            to: state.warp.to
+        };
+        this.restoreTimeScale = state.restoreTimeScale;
+        this.effectiveWeight = state.effectiveWeight;
+        this.effectiveTimeScale = state.effectiveTimeScale;
+        this.layerMask = layerMask;
+        this.layerBlendMode = state.layerBlendMode;
+        this.cursors.set(state.cursors);
+        return this;
+    }
+    prepareRestore(input, targetTime) {
+        const keys = [
+            "version", "clipName", "compiledIdentity", "targetIdentity", "mixerTime", "playback", "bindings", "cursors",
+            "additive", "weight", "timeScale", "enabled", "syncGroupName", "fade", "warp",
+            "restoreTimeScale", "effectiveWeight", "effectiveTimeScale", "layerMask", "layerBlendMode"
+        ];
+        const record = poseRecord(input, "action snapshot", keys);
+        if (record.version !== 1)
+            throw new Error("PoseAction.restore: unsupported snapshot version.");
+        if (record.clipName !== this.clipName || typeof record.compiledIdentity !== "string" ||
+            record.compiledIdentity !== poseCompiledIdentity(this.clip)) {
+            throw new Error("PoseAction.restore: registered clip or compiled clip identity does not match.");
+        }
+        if (typeof record.targetIdentity !== "string" ||
+            record.targetIdentity !== JSON.stringify(capturePoseSkeleton(this.mixer.skeleton))) {
+            throw new Error("PoseAction.restore: rebound skeleton target does not match.");
+        }
+        const mixerTime = poseNumber(record.mixerTime, "action mixerTime");
+        const nextTime = poseNumber(targetTime, "destination mixerTime");
+        const shift = nextTime - mixerTime;
+        if (!Number.isFinite(shift))
+            throw new Error("PoseAction.restore: mixer clock offset is not finite.");
+        const playbackRecord = poseRecord(record.playback, "core playback", [
+            "clipName", "duration", "time", "weight", "timeScale", "playing", "paused", "loopMode", "state", "active"
+        ], ["clipName", "duration", "time", "weight", "timeScale", "playing", "paused", "loopMode", "state"]);
+        if (playbackRecord.state === undefined)
+            throw new Error("PoseAction.restore: versioned core playback state is required.");
+        // Validation takes place on a temporary action before any live state changes.
+        const playback = new AnimationAction(this.playback.clip).restore(record.playback).serialize();
+        const bindings = readPoseBindings(record.bindings, this.mixer.skeleton.boneCount, this.clip.tracks.length);
+        const currentBindings = readPoseBindings(this.bindings, this.mixer.skeleton.boneCount, this.clip.tracks.length);
+        if (JSON.stringify(bindings) !== JSON.stringify(currentBindings)) {
+            throw new Error("PoseAction.restore: target bindings do not match the rebound skeleton.");
+        }
+        const cursors = readPoseNumberArray(record.cursors, this.clip.tracks.length, "action cursors")
+            .map(value => {
+            if (!Number.isInteger(value) || value < 0 || value > 0xffffffff)
+                throw new Error("PoseAction.restore: invalid track cursor.");
+            return value;
+        });
+        const additive = poseBoolean(record.additive, "action additive");
+        if (additive !== this.additive)
+            throw new Error("PoseAction.restore: additive mode does not match.");
+        const syncGroupName = record.syncGroupName;
+        if (syncGroupName !== null && typeof syncGroupName !== "string")
+            throw new Error("PoseAction.restore: invalid synchronization group.");
+        const fade = rebasePoseEnvelope(readPoseEnvelope(record.fade, "fade", true), shift);
+        const capturedWarp = readPoseWarp(record.warp);
+        let warp = null;
+        if (capturedWarp !== null) {
+            const elapsed = capturedWarp.elapsed ?? Math.max(0, Math.min(capturedWarp.duration, mixerTime - capturedWarp.startTime));
+            if (!Number.isFinite(elapsed))
+                throw new Error("PoseAction.restore: invalid warp elapsed time.");
+            const rebased = rebasePoseEnvelope(capturedWarp, shift);
+            warp = { ...rebased, elapsed };
+        }
+        const restoreTimeScale = record.restoreTimeScale === null ? null : poseNumber(record.restoreTimeScale, "restoreTimeScale");
+        if (restoreTimeScale !== null && warp === null)
+            throw new Error("PoseAction.restore: restoreTimeScale requires a scheduled warp.");
+        const layerBlendMode = record.layerBlendMode;
+        if (layerBlendMode !== null && layerBlendMode !== "override" && layerBlendMode !== "additive") {
+            throw new Error("PoseAction.restore: invalid layer blend mode.");
+        }
+        const layerMask = record.layerMask === null ? null : readPoseFloatArray(record.layerMask, this.mixer.skeleton.boneCount, "action mask");
+        const result = {
+            version: 1, clipName: this.clipName, compiledIdentity: record.compiledIdentity, targetIdentity: record.targetIdentity,
+            mixerTime: nextTime, playback, bindings, cursors, additive,
+            weight: poseNumber(record.weight, "action weight", 0),
+            timeScale: poseNumber(record.timeScale, "action timeScale"),
+            enabled: poseBoolean(record.enabled, "action enabled"),
+            syncGroupName, fade, warp, restoreTimeScale,
+            effectiveWeight: poseNumber(record.effectiveWeight, "action effectiveWeight", 0),
+            effectiveTimeScale: poseNumber(record.effectiveTimeScale, "action effectiveTimeScale"),
+            layerMask, layerBlendMode
+        };
+        rejectPoseNegativeZero(result);
+        return result;
+    }
+    /** @internal Validate writable owned state before a mixer starts its commit. */
+    assertRestoreWritable() {
+        assertPoseActionData(this);
+        assertPosePlaybackData(this.playback);
+        assertPoseWritable(this, [
+            "weight", "timeScale", "enabled", "syncGroupName", "fade", "warpState", "restoreTimeScale",
+            "effectiveWeight", "effectiveTimeScale", "layerMask", "layerBlendMode"
+        ], "action");
+        assertPoseWritable(this.playback, [
+            "time", "weight", "timeScale", "playing", "paused", "loopMode", "repetitions", "clampWhenFinished",
+            "maxEventCatchUp", "pingPongForward", "loopsCompleted", "fadeDuration", "fadeElapsed",
+            "fadeStartWeight", "fadeTargetWeight", "warpState", "lastPlaybackDelta", "signalLoopDelta",
+            "signalFinishedDirection", "signalEventOverflow"
+        ], "core playback");
+        readPoseTypedNumbers(this.cursors, Uint32Array, this.clip.tracks.length, "action cursors");
+    }
+    /** @internal Stop an old handle without invoking overridable mixer callbacks. */
+    retireForRestore() {
+        AnimationAction.prototype.stop.call(this.playback);
+        this.fade = null;
+        this.warpState = null;
+        this.restoreTimeScale = null;
+        this.effectiveWeight = 0;
+        this.effectiveTimeScale = 0;
+    }
+    /** @internal Advance only the part of a frame during which playback was active. */
+    advanceWarp(elapsed) {
+        const warp = this.warpState;
+        if (warp === null)
+            return;
+        // Mirror the core's per-segment accumulation, including rounding at a
+        // rate reversal, rather than recomputing elapsed from the mixer clock.
+        for (const segment of AnimationAction.warpSegments(elapsed, warp)) {
+            if (segment.inWarp)
+                warp.elapsed = Math.min(warp.duration, segment.elapsed + segment.duration);
+        }
+    }
+    /** @internal A warp ending at zero pauses even when a sync leader keeps moving. */
+    warpPauseOffset() {
+        const warp = this.warpState;
+        return warp !== null && (this.restoreTimeScale ?? warp.to) === 0
+            ? Math.max(0, warp.duration - warp.elapsed)
+            : null;
+    }
+    /** @internal Preserve the whole frame's signed travel across warp segments. */
+    setPlaybackDelta(delta) {
+        this.playback.lastPlaybackDelta = delta;
+    }
     scheduleFade(duration, weightNow, weightThen) {
+        if (!Number.isFinite(duration) || duration < 0 || !Number.isFinite(weightThen) || weightThen < 0) {
+            throw new Error("PoseAction fade weight and duration must be finite and non-negative.");
+        }
         const now = this.mixer.time;
         if (duration <= 0) {
             this.fade = null;
             this.weight = weightThen;
+            if (weightThen === 0)
+                this.enabled = false;
             return this;
         }
         this.fade = { startTime: now, duration, from: weightNow, to: weightThen };
         return this;
     }
+    currentWeight(now) {
+        const fade = this.fade;
+        if (fade === null)
+            return this.weight;
+        const t = Math.min(Math.max((now - fade.startTime) / fade.duration, 0), 1);
+        return fade.from + (fade.to - fade.from) * t;
+    }
     /** Effective weight at mixer.time, per r185 `_updateWeight`. */
     updateWeight(now) {
         let weight = 0;
         if (this.enabled) {
-            weight = this.weight;
             const fade = this.fade;
+            weight = this.currentWeight(now);
             if (fade !== null) {
                 const end = fade.startTime + fade.duration;
-                const t = Math.min(Math.max((now - fade.startTime) / fade.duration, 0), 1);
-                const interpolant = fade.from + (fade.to - fade.from) * t;
-                weight *= interpolant;
-                if (now > end) {
+                if (now >= end) {
                     this.fade = null;
-                    if (interpolant === 0)
+                    this.weight = fade.to;
+                    if (weight === 0)
                         this.enabled = false;
                 }
             }
@@ -172,93 +418,125 @@ export class PoseAction {
         this.effectiveWeight = weight;
         return weight;
     }
-    /** Effective timescale at mixer.time, per r185 `_updateTimeScale`. */
-    updateTimeScale(now) {
+    /** Effective instantaneous rate, including a scheduled warp. */
+    updateTimeScale(_now, finishPausedWarp = false) {
         let timeScale = 0;
-        if (!this.paused) {
-            timeScale = this.timeScale;
+        if (!this.paused || finishPausedWarp) {
+            let rate = this.timeScale;
             const warp = this.warpState;
             if (warp !== null) {
-                const end = warp.startTime + warp.duration;
-                const t = Math.min(Math.max((now - warp.startTime) / warp.duration, 0), 1);
-                timeScale *= warp.from + (warp.to - warp.from) * t;
-                if (now > end) {
-                    if (timeScale === 0) {
-                        this.paused = true;
-                    }
-                    else {
-                        if (this.restoreTimeScale !== null)
-                            timeScale = this.restoreTimeScale;
-                        this.timeScale = timeScale;
+                const t = Math.min(warp.elapsed / warp.duration, 1);
+                rate = warp.from + (warp.to - warp.from) * t;
+                if (warp.elapsed >= warp.duration) {
+                    rate = this.restoreTimeScale ?? warp.to;
+                    this.timeScale = rate;
+                    if (rate === 0 && this.playing && !this.paused) {
+                        this.playback.pause();
                     }
                     this.warpState = null;
+                    this.restoreTimeScale = null;
                 }
             }
+            if (!this.paused)
+                timeScale = rate;
         }
         this.effectiveTimeScale = timeScale;
         return timeScale;
     }
-    /** Advance clip time per r185 `_updateTime`; returns {wrapped, finished}. */
-    updateTime(deltaTime) {
-        const duration = this.clip.duration;
-        const previous = this.time;
-        let time = previous + deltaTime;
-        let wrapped = false;
-        let finished = false;
-        if (this.loopMode === "once") {
-            if (this.loopCount === -1)
-                this.loopCount = 0;
-            if (time >= duration) {
-                time = duration;
-                finished = true;
-            }
-            else if (time < 0) {
-                time = 0;
-                finished = true;
-            }
-            if (finished) {
-                if (this.clampWhenFinished)
-                    this.paused = true;
-                else
-                    this.enabled = false;
-                this.time = time;
-                return { wrapped, finished, previous };
-            }
+    /** Integrate each monotonic part of a warp, retaining any direction change. */
+    integratedTimeScaleSegments(from, to) {
+        if (this.paused || to <= from)
+            return [];
+        if (!Number.isFinite(this.timeScale))
+            throw new Error("PoseAction timeScale must be finite.");
+        const warp = this.warpState;
+        if (warp === null)
+            return this.integratedTimeScaleSpans(to - from).map(segment => segment.distance);
+        // Keep this interval-query API relative to the current mixer clock. Actual
+        // playback uses the local elapsed value directly, without subtracting clocks.
+        const start = this.mixer.time - warp.elapsed;
+        const segments = [];
+        const beforeEnd = Math.min(to, start);
+        if (beforeEnd > from) {
+            const distance = (beforeEnd - from) * this.timeScale;
+            if (distance !== 0)
+                segments.push(distance);
         }
-        else {
-            // repeat / pingpong
-            if (this.loopCount === -1) {
-                if (deltaTime >= 0) {
-                    this.loopCount = 0;
-                }
-            }
-            if (duration > 0 && (time >= duration || time < 0)) {
-                const loopDelta = Math.floor(time / duration);
-                time -= duration * loopDelta;
-                this.loopCount += Math.abs(loopDelta);
-                wrapped = true;
-                const pending = this.repetitions - this.loopCount;
-                if (pending <= 0) {
-                    if (this.clampWhenFinished)
-                        this.paused = true;
-                    else
-                        this.enabled = false;
-                    this.time = deltaTime > 0 ? duration : 0;
-                    return { wrapped, finished: true, previous };
-                }
+        const begin = Math.max(from, start);
+        if (to > begin) {
+            const elapsed = Math.max(0, Math.min(warp.duration, begin - start));
+            for (const segment of AnimationAction.warpSegments(to - begin, { ...warp, elapsed })) {
+                const rate = this.restoreTimeScale ?? segment.to;
+                const distance = segment.inWarp ? segment.distance : segment.duration * (rate / 2 + rate / 2);
+                if (distance !== 0)
+                    segments.push(distance);
             }
-            if (this.loopMode === "pingpong") {
-                if ((this.loopCount & 1) === 1)
-                    this.pingPongForward = false;
-                else
-                    this.pingPongForward = true;
-                if (!this.pingPongForward)
-                    time = duration - time;
+        }
+        return segments;
+    }
+    /** @internal Use the same signed, action-local warp integration as core playback. */
+    integratedTimeScaleSpans(delta) {
+        if (this.paused || delta === 0)
+            return [];
+        if (!Number.isFinite(delta))
+            throw new Error("PoseAction update delta must be finite.");
+        if (!Number.isFinite(this.timeScale))
+            throw new Error("PoseAction timeScale must be finite.");
+        const direction = delta < 0 ? -1 : 1;
+        const warp = this.warpState;
+        if (warp === null) {
+            const distance = delta * this.timeScale;
+            if (!Number.isFinite(distance))
+                throw new Error("PoseAction scaled playback span must be finite.");
+            const rate = direction * this.timeScale;
+            return [{ startOffset: 0, duration: Math.abs(delta), from: rate, to: rate, distance }];
+        }
+        let offset = 0;
+        return AnimationAction.warpSegments(delta, warp).map(segment => {
+            const restoredRate = !segment.inWarp ? this.restoreTimeScale : null;
+            const from = direction * (restoredRate ?? segment.from);
+            const to = direction * (restoredRate ?? segment.to);
+            const distance = restoredRate === null
+                ? segment.distance
+                : direction * segment.duration * (restoredRate / 2 + restoredRate / 2);
+            if (!Number.isFinite(distance)) {
+                throw new Error("PoseAction warped playback span must be finite.");
             }
+            const result = { startOffset: offset, duration: segment.duration, from, to, distance };
+            offset += segment.duration;
+            return result;
+        });
+    }
+    /** Advance through the core action so signed playheads and marker boundaries agree. */
+    updateTime(deltaTime) {
+        const previous = this.time;
+        // The caller has already applied both mixer and action rates.
+        const events = this.playback.update(deltaTime);
+        const signals = this.playback.consumePlaybackSignals();
+        if (signals.finishedDirection !== 0 && !this.clampWhenFinished)
+            this.enabled = false;
+        return { wrapped: signals.loopDelta !== 0, finished: signals.finishedDirection !== 0, previous, events, eventOverflow: signals.eventOverflow };
+    }
+}
+/** Stop synchronized travel at the follower's own warp-to-zero boundary. */
+function limitTimeScaleSegments(segments, limit) {
+    const limited = [];
+    for (const segment of segments) {
+        if (segment.startOffset >= limit)
+            break;
+        if (segment.startOffset + segment.duration <= limit) {
+            limited.push(segment);
+            continue;
         }
-        this.time = time;
-        return { wrapped, finished, previous };
+        const duration = limit - segment.startOffset;
+        const to = segment.from + (segment.to - segment.from) * (duration / segment.duration);
+        const distance = duration * (segment.from / 2 + to / 2);
+        if (!Number.isFinite(distance))
+            throw new Error("PoseAction limited playback span must be finite.");
+        limited.push({ ...segment, duration, to, distance });
+        break;
     }
+    return limited;
 }
 /** Drop layer actions that stopped or finished fading out, so replaced clips do not pile up. */
 function pruneFinishedLayerActions(layer) {
@@ -275,12 +553,16 @@ export class PoseMixer {
     skeleton;
     inertializer;
     time = 0;
+    /** Markers omitted by the catch-up bounds in the most recent update. */
+    lastEventOverflow = 0;
     timeScale = 1;
     clips = new Map();
     actions = [];
     layers = [];
     layerByName = new Map();
     eventListeners = new Set();
+    disposed = false;
+    updateDepth = 0;
     latestPose = null;
     previousPose = null;
     inertializerElapsed = Infinity;
@@ -318,19 +600,30 @@ export class PoseMixer {
         this.addTouchedCount = 0;
     }
     setEffectiveTimeScale(timeScale) {
+        this.assertAlive();
+        if (!Number.isFinite(timeScale))
+            throw new Error("PoseMixer timeScale must be finite.");
         this.timeScale = timeScale;
         return this;
     }
     get effectiveTimeScale() {
         return this.timeScale;
     }
+    /** @internal Reject snapshots taken while an update is traversing callbacks. */
+    assertSnapshotOperation(operation) {
+        this.assertAlive();
+        if (this.updateDepth !== 0)
+            throw new Error(`PoseMixer.${operation}: cannot ${operation} during an update.`);
+    }
     /** Register a clip under a name (compiles it for flat sampling). */
     addClip(name, clip) {
+        this.assertAlive();
         this.clips.set(name, { source: clip, compiled: compileClip(clip) });
         return this;
     }
     /** Register a pre-compiled clip (returns undefined if unknown). */
     addCompiledClip(name, compiled, source) {
+        this.assertAlive();
         this.clips.set(name, { source, compiled });
         return this;
     }
@@ -338,6 +631,7 @@ export class PoseMixer {
         return this.clips.get(name)?.source;
     }
     clipAction(name, options = {}) {
+        this.assertAlive();
         const entry = this.clips.get(name);
         if (!entry) {
             throw new Error(`ANIMATION_CLIP_NOT_FOUND: clip "${name}" is not registered. Available: ${[...this.clips.keys()].join(", ")}`);
@@ -357,6 +651,7 @@ export class PoseMixer {
      * to compute covered-bone sets for `restPoseReset: false`).
      */
     activeActions() {
+        this.assertAlive();
         const all = [];
         for (const action of this.actions) {
             if (action.playing && action.enabled)
@@ -379,6 +674,7 @@ export class PoseMixer {
      * name — `""` for the base layer — for `animationState()` snapshots (C-37).
      */
     activeActionEntries() {
+        this.assertAlive();
         const all = [];
         for (const action of this.actions) {
             if (action.playing && action.enabled)
@@ -392,6 +688,266 @@ export class PoseMixer {
         }
         return all;
     }
+    /** Strict, restorable snapshot; the external skeleton must be acknowledged. */
+    snapshot(options = {}) {
+        return this.serialize(options);
+    }
+    /**
+     * Capture mixer-owned state only. The caller must rebind an equivalent
+     * skeleton and matching registered clips; event listeners must be removed and
+     * reattached explicitly. Active inertializer transitions cannot yet be
+     * serialized because their captured velocities are externally owned.
+     */
+    serialize(options = {}) {
+        this.assertSnapshotOperation("serialize");
+        this.assertGraphData();
+        const captureOptions = poseRecord(options, "serialization options", ["externalTarget"], []);
+        if (captureOptions.externalTarget !== "rebind") {
+            throw new Error("PoseMixer.serialize: the external skeleton target requires externalTarget: 'rebind'.");
+        }
+        if (this.eventListeners.size !== 0) {
+            throw new Error("PoseMixer.serialize: event callbacks/listeners cannot be serialized; unsubscribe and reattach them explicitly.");
+        }
+        if (this.inertializer !== null)
+            assertPoseInertializerData(this.inertializer, this.skeleton.boneCount);
+        if (this.inertializer !== null && (this.inertializer.active || this.inertializerElapsed !== Infinity)) {
+            throw new Error("PoseMixer.serialize: active inertializer transitions cannot be serialized.");
+        }
+        const masks = [];
+        const indices = new Map();
+        const seenActions = new Set();
+        const maskIndex = (mask) => {
+            if (mask === null)
+                return null;
+            const existing = indices.get(mask);
+            if (existing !== undefined)
+                return existing;
+            const index = masks.length;
+            masks.push(readPoseTypedNumbers(mask, Float32Array, this.skeleton.boneCount, "layer mask"));
+            indices.set(mask, index);
+            return index;
+        };
+        const captureAction = (action) => {
+            if (seenActions.has(action))
+                throw new Error("PoseMixer.serialize: an action belongs to more than one mixer layer.");
+            if (!(action instanceof PoseAction))
+                throw new Error("PoseMixer.serialize: invalid action.");
+            assertPoseActionData(action);
+            if (action.mixer !== this)
+                throw new Error("PoseMixer.serialize: action belongs to another mixer.");
+            seenActions.add(action);
+            return { action: action.serialize(), mask: maskIndex(action.layerMask) };
+        };
+        const snapshot = {
+            version: 1,
+            time: this.time,
+            timeScale: this.timeScale,
+            lastEventOverflow: this.lastEventOverflow === Infinity ? null : this.lastEventOverflow,
+            lastDt: this.lastDt,
+            target: capturePoseSkeleton(this.skeleton),
+            clips: this.captureClipCatalog(),
+            masks,
+            actions: this.actions.map(captureAction),
+            layers: this.layers.map(layer => ({
+                name: layer.name,
+                blendMode: layer.blendMode,
+                weight: layer.weight,
+                mask: maskIndex(layer.mask),
+                actions: layer.actions.map(captureAction)
+            })),
+            inertializer: this.inertializer === null ? null : {
+                latestPose: this.latestPose === null ? null : capturePoseBuffer(this.latestPose, this.skeleton.boneCount, "latest pose"),
+                previousPose: this.previousPose === null ? null : capturePoseBuffer(this.previousPose, this.skeleton.boneCount, "previous pose"),
+                halfLife: this.inertializerHalfLife
+            }
+        };
+        this.prepareRestore(snapshot);
+        rejectPoseNegativeZero(snapshot);
+        return snapshot;
+    }
+    /**
+     * Atomically rebind to this mixer's skeleton and registered clips. No pose or
+     * callbacks are applied. Existing actions are stopped and replaced; callers
+     * should reacquire action handles via activeActions()/activeActionEntries().
+     * Existing destination listeners remain attached.
+     */
+    restore(snapshot) {
+        this.assertSnapshotOperation("restore");
+        this.assertGraphData();
+        const plan = this.prepareRestore(snapshot);
+        assertPoseWritable(this, [
+            "time", "timeScale", "lastEventOverflow", "lastDt", "latestPose", "previousPose",
+            "inertializerHalfLife", "inertializerElapsed"
+        ], "mixer");
+        assertPoseMutableArray(this.actions, "existing base actions");
+        assertPoseMutableArray(this.layers, "existing layers");
+        if (Object.getPrototypeOf(this.layerByName) !== Map.prototype || Reflect.ownKeys(this.layerByName).length !== 0) {
+            throw new Error("PoseMixer.restore: existing layer index contains unsupported callbacks or properties.");
+        }
+        const previous = new Set(this.actions);
+        for (const layer of this.layers) {
+            const record = poseRecord(layer, "existing layer", ["name", "blendMode", "mask", "weight", "actions"]);
+            for (const action of poseArray(record.actions, "existing layer actions"))
+                previous.add(action);
+        }
+        for (const action of previous) {
+            if (!(action instanceof PoseAction)) {
+                throw new Error("PoseMixer.restore: existing action belongs to another mixer or is invalid.");
+            }
+            assertPoseActionData(action);
+            if (action.mixer !== this)
+                throw new Error("PoseMixer.restore: existing action belongs to another mixer.");
+            action.assertRestoreWritable();
+        }
+        for (const action of previous)
+            PoseAction.prototype.retireForRestore.call(action);
+        this.actions.length = 0;
+        for (const action of plan.actions)
+            this.actions.push(action);
+        this.layers.length = 0;
+        for (const layer of plan.layers)
+            this.layers.push(layer);
+        this.layerByName.clear();
+        for (const layer of plan.layers)
+            this.layerByName.set(layer.name, layer);
+        this.time = plan.time;
+        this.timeScale = plan.timeScale;
+        this.lastEventOverflow = plan.lastEventOverflow;
+        this.lastDt = plan.lastDt;
+        this.latestPose = plan.latestPose;
+        this.previousPose = plan.previousPose;
+        this.inertializerHalfLife = plan.halfLife;
+        this.inertializerElapsed = Infinity;
+        return this;
+    }
+    prepareRestore(input) {
+        const record = poseRecord(input, "mixer snapshot", [
+            "version", "time", "timeScale", "lastEventOverflow", "lastDt", "target", "clips", "masks", "actions", "layers", "inertializer"
+        ]);
+        if (record.version !== 1)
+            throw new Error("PoseMixer.restore: unsupported snapshot version.");
+        const time = poseNumber(record.time, "mixer time");
+        const timeScale = poseNumber(record.timeScale, "mixer timeScale");
+        const lastDt = poseNumber(record.lastDt, "lastDt", 0);
+        const lastEventOverflow = record.lastEventOverflow === null
+            ? Infinity : poseNumber(record.lastEventOverflow, "lastEventOverflow", 0);
+        if (lastEventOverflow !== Infinity && !Number.isInteger(lastEventOverflow)) {
+            throw new Error("PoseMixer.restore: invalid event overflow.");
+        }
+        const target = readPoseSkeleton(record.target, this.skeleton.boneCount);
+        if (JSON.stringify(target) !== JSON.stringify(capturePoseSkeleton(this.skeleton))) {
+            throw new Error("PoseMixer.restore: rebound skeleton target does not match.");
+        }
+        const clips = readPoseClipCatalog(record.clips);
+        if (JSON.stringify(clips) !== JSON.stringify(this.captureClipCatalog())) {
+            throw new Error("PoseMixer.restore: registered source/compiled clip catalog or identity does not match.");
+        }
+        const masks = poseArray(record.masks, "masks").map((mask, index) => new Float32Array(readPoseFloatArray(mask, this.skeleton.boneCount, `mask ${index}`)));
+        const usedMasks = new Set();
+        const maskAt = (value) => {
+            if (value === null)
+                return null;
+            if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value >= masks.length) {
+                throw new Error("PoseMixer.restore: invalid mask reference.");
+            }
+            usedMasks.add(value);
+            return masks[value];
+        };
+        const restoreAction = (inputAction) => {
+            const wrapper = poseRecord(inputAction, "mixer action", ["action", "mask"]);
+            const actionRecord = poseRecord(wrapper.action, "action snapshot", [
+                "version", "clipName", "compiledIdentity", "targetIdentity", "mixerTime", "playback", "bindings", "cursors",
+                "additive", "weight", "timeScale", "enabled", "syncGroupName", "fade", "warp",
+                "restoreTimeScale", "effectiveWeight", "effectiveTimeScale", "layerMask", "layerBlendMode"
+            ]);
+            if (typeof actionRecord.clipName !== "string" || typeof actionRecord.additive !== "boolean") {
+                throw new Error("PoseMixer.restore: invalid action clip or additive mode.");
+            }
+            if (actionRecord.mixerTime !== time)
+                throw new Error("PoseMixer.restore: action and mixer clocks do not match.");
+            const action = this.clipAction(actionRecord.clipName, { additive: actionRecord.additive });
+            action.restoreAtMixerTime(wrapper.action, time);
+            const mask = maskAt(wrapper.mask);
+            if ((mask === null) !== (action.layerMask === null) ||
+                (mask !== null && JSON.stringify([...mask]) !== JSON.stringify([...action.layerMask]))) {
+                throw new Error("PoseMixer.restore: action mask does not match its mask reference.");
+            }
+            action.layerMask = mask;
+            return action;
+        };
+        const actions = poseArray(record.actions, "base actions").map(restoreAction);
+        const names = new Set();
+        const layers = poseArray(record.layers, "layers").map(inputLayer => {
+            const layer = poseRecord(inputLayer, "layer", ["name", "blendMode", "weight", "mask", "actions"]);
+            if (typeof layer.name !== "string" || names.has(layer.name))
+                throw new Error("PoseMixer.restore: invalid or duplicate layer name.");
+            names.add(layer.name);
+            if (layer.blendMode !== "override" && layer.blendMode !== "additive")
+                throw new Error("PoseMixer.restore: invalid layer blend mode.");
+            return {
+                name: layer.name,
+                blendMode: layer.blendMode,
+                weight: poseNumber(layer.weight, "layer weight", 0),
+                mask: maskAt(layer.mask),
+                actions: poseArray(layer.actions, "layer actions").map(restoreAction)
+            };
+        });
+        if (usedMasks.size !== masks.length)
+            throw new Error("PoseMixer.restore: unreferenced mask data.");
+        let latestPose = null;
+        let previousPose = null;
+        let halfLife = 0.15;
+        if ((record.inertializer === null) !== (this.inertializer === null)) {
+            throw new Error("PoseMixer.restore: rebound inertializer configuration does not match.");
+        }
+        if (record.inertializer !== null) {
+            assertPoseInertializerData(this.inertializer, this.skeleton.boneCount);
+            if (this.inertializer.active || this.inertializerElapsed !== Infinity) {
+                throw new Error("PoseMixer.restore: active inertializer transitions cannot be replaced.");
+            }
+            const history = poseRecord(record.inertializer, "inertializer history", ["latestPose", "previousPose", "halfLife"]);
+            latestPose = history.latestPose === null ? null : restorePoseBuffer(history.latestPose, this.skeleton.boneCount, "latest pose");
+            previousPose = history.previousPose === null ? null : restorePoseBuffer(history.previousPose, this.skeleton.boneCount, "previous pose");
+            halfLife = poseNumber(history.halfLife, "inertializer halfLife");
+        }
+        rejectPoseNegativeZero(input);
+        return { time, timeScale, lastEventOverflow, lastDt, actions, layers, latestPose, previousPose, halfLife };
+    }
+    assertGraphData() {
+        poseArray(this.actions, "existing base actions");
+        const layers = poseArray(this.layers, "existing layers");
+        if (Object.getPrototypeOf(this.layerByName) !== Map.prototype || Reflect.ownKeys(this.layerByName).length !== 0 ||
+            this.layerByName.size !== layers.length) {
+            throw new Error("PoseMixer: layer index contains unsupported or inconsistent state.");
+        }
+        for (const input of layers) {
+            const layer = poseRecord(input, "existing layer", ["name", "blendMode", "mask", "weight", "actions"]);
+            if (typeof layer.name !== "string" || this.layerByName.get(layer.name) !== input) {
+                throw new Error("PoseMixer: layer index does not match layer membership.");
+            }
+            poseArray(layer.actions, "existing layer actions");
+        }
+    }
+    captureClipCatalog() {
+        if (Object.getPrototypeOf(this.clips) !== Map.prototype || Reflect.ownKeys(this.clips).length !== 0) {
+            throw new Error("PoseMixer.serialize: clip registry contains unsupported callbacks or properties.");
+        }
+        const clips = [...this.clips].map(([name, input]) => {
+            if (typeof name !== "string")
+                throw new Error("PoseMixer.serialize: invalid registered clip name.");
+            const entry = poseRecord(input, "registered clip", ["source", "compiled"]);
+            const source = entry.source;
+            assertPoseSourceClip(source);
+            const playback = new AnimationAction(source).serialize();
+            return {
+                name,
+                sourceIdentity: playback.state.clipIdentity,
+                compiledIdentity: poseCompiledIdentity(entry.compiled),
+                additive: isClipAdditive(source)
+            };
+        });
+        return readPoseClipCatalog(clips);
+    }
     /**
      * `crossFadeTo(clip, seconds, options)` — mirrors `node.play` semantics:
      * the current active base action fades out over `seconds` (default driven by
@@ -428,7 +984,7 @@ export class PoseMixer {
     activeBaseAction() {
         for (let i = this.actions.length - 1; i >= 0; i -= 1) {
             const action = this.actions[i];
-            if (!action.additive && action.playing)
+            if (!action.additive && action.playing && action.enabled)
                 return action;
         }
         return null;
@@ -487,11 +1043,13 @@ export class PoseMixer {
         }
     }
     onEvent(listener) {
+        this.assertAlive();
         this.eventListeners.add(listener);
         return () => this.eventListeners.delete(listener);
     }
     activate(action) {
-        if (!this.actions.includes(action))
+        this.assertAlive();
+        if (!this.actions.includes(action) && !this.layers.some(layer => layer.actions.includes(action)))
             this.actions.push(action);
     }
     deactivate(action) {
@@ -507,10 +1065,17 @@ export class PoseMixer {
             const parsed = parseTrackTarget(track.target);
             if (parsed === null)
                 continue;
-            const indices = this.skeleton.jointIndicesByName.get(parsed.nodeName);
+            const indices = this.skeleton.jointIndicesByName.get(parsed.nodeName)
+                ?? this.skeleton.jointIndicesByName.get(unescapeNodeName(parsed.nodeName));
             if (!indices || indices.length === 0)
                 continue;
-            bindings.push({ trackIndex: i, boneIndex: indices[0], channel: parsed.channel });
+            const expectedType = parsed.channel === "rotation" ? "quaternion" : "vector3";
+            const expectedStride = parsed.channel === "rotation" ? 4 : 3;
+            if (track.valueType !== expectedType || track.stride !== expectedStride) {
+                throw new Error(`POSE_TRACK_TYPE_MISMATCH: ${track.target} requires ${expectedType} (${expectedStride} components), got ${track.valueType} (${track.stride}).`);
+            }
+            for (const boneIndex of indices)
+                bindings.push({ trackIndex: i, boneIndex, channel: parsed.channel });
         }
         return bindings;
     }
@@ -538,82 +1103,170 @@ export class PoseMixer {
      * times/weights, and emit clip events between old and new action times.
      */
     update(dt) {
-        this.lastDt = dt;
-        this.time += dt;
-        const scaledDt = dt * this.timeScale;
-        const events = [];
-        const allActions = [...this.actions];
-        for (const layer of this.layers)
-            allActions.push(...layer.actions);
-        for (const action of allActions) {
-            if (!action.playing && !action.enabled)
-                continue;
-            const effectiveTimeScale = action.updateTimeScale(this.time);
-            const clipDelta = scaledDt * effectiveTimeScale;
-            const { previous, wrapped } = action.updateTime(clipDelta);
-            const weight = action.updateWeight(this.time);
-            if (!action.enabled && !action.playing)
-                this.deactivate(action);
-            if (!action.enabled)
-                continue;
-            const source = this.clips.get(action.clipName);
-            if (source !== undefined && source.source.events.length > 0 && weight > 0) {
-                const to = action.time;
-                const invocations = sampleClipEvents({ id: action.clipName, duration: source.compiled.duration, events: source.source.events }, {
-                    from: previous,
-                    to,
-                    duration: source.compiled.duration,
-                    loop: wrapped,
-                    direction: to >= previous ? 1 : -1,
-                    playbackTime: this.time
-                });
-                events.push(...invocations);
-            }
-        }
-        // Aura extension: sync groups keep normalized phase aligned to the leader
-        // (first activated member) — three r185 has no phase sync. Only enabled
-        // members take part: a faded-out action stays `playing` (enabled=false, as
-        // in r185) and must not keep leading the group — it would slave the
-        // incoming clip to its own (restored) rate after the crossfade.
-        const groups = new Map();
-        for (const action of allActions) {
-            if (action.syncGroupName === null || !action.playing || !action.enabled)
-                continue;
-            const group = groups.get(action.syncGroupName) ?? [];
-            group.push(action);
-            groups.set(action.syncGroupName, group);
+        this.assertAlive();
+        if (!Number.isFinite(dt) || !Number.isFinite(this.timeScale)) {
+            throw new Error("PoseMixer update delta and timeScale must be finite.");
         }
-        for (const group of groups.values()) {
-            if (group.length < 2)
-                continue;
-            const leader = group[0];
-            const phase = leader.normalizedPhase;
-            for (let i = 1; i < group.length; i += 1) {
-                const member = group[i];
-                member.time = phase * member.clip.duration;
+        this.updateDepth += 1;
+        try {
+            this.lastDt = Math.abs(dt);
+            const scaledDt = dt * this.timeScale;
+            if (!Number.isFinite(scaledDt))
+                throw new Error("PoseMixer scaled delta must be finite.");
+            // Durations use elapsed mixer time even during reverse playback. Fades
+            // continue while an action is paused; its warp and playhead do not.
+            const elapsedDt = Math.abs(scaledDt);
+            this.time += elapsedDt;
+            const events = [];
+            this.lastEventOverflow = 0;
+            const allActions = [...this.actions];
+            for (const layer of this.layers)
+                allActions.push(...layer.actions);
+            // Establish the same phase and reflected direction before advancing. This
+            // lets followers report markers they actually cross, including when a new
+            // action joins a group while its leader is moving backwards.
+            const leaders = new Map();
+            const leaderFor = new Map();
+            for (const action of allActions) {
+                if (action.syncGroupName === null || !action.playing || !action.enabled)
+                    continue;
+                const leader = leaders.get(action.syncGroupName);
+                if (leader === undefined)
+                    leaders.set(action.syncGroupName, action);
+                else {
+                    if (!action.paused)
+                        action.synchronizePhaseWith(leader);
+                    leaderFor.set(action, leader);
+                }
             }
-        }
-        for (const invocation of events) {
-            for (const listener of this.eventListeners)
-                listener(invocation);
-        }
-        if (this.inertializer !== null && this.inertializerElapsed !== Infinity) {
-            this.inertializerElapsed += scaledDt;
-        }
-        // Sweep layers whose actions have all faded out.
-        for (let i = this.layers.length - 1; i >= 0; i -= 1) {
-            const layer = this.layers[i];
-            if (layer.actions.length > 0 && layer.actions.every((a) => !a.enabled || !a.playing)) {
-                for (const action of layer.actions)
-                    action.stop();
-                this.layers.splice(i, 1);
-                this.layerByName.delete(layer.name);
+            const advances = new Map();
+            for (const action of allActions) {
+                if (!action.playing || !action.enabled) {
+                    // Finished fades must not retain an ever-growing list of active actions.
+                    if (action.playing && !action.enabled)
+                        action.stop();
+                    else
+                        action.setPlaybackDelta(0);
+                    continue;
+                }
+                const wasPaused = action.paused;
+                const leader = leaderFor.get(action);
+                const leaderAdvances = leader === undefined ? undefined : advances.get(leader);
+                const pauseOffset = action.warpPauseOffset();
+                let clipSegments = wasPaused || !action.hasPlaybackDuration ? [] : leaderAdvances !== undefined
+                    ? leader.clip.duration > 0
+                        ? leaderAdvances.map(segment => {
+                            const ratio = action.clip.duration / leader.clip.duration;
+                            return {
+                                ...segment, from: segment.from * ratio, to: segment.to * ratio,
+                                distance: segment.distance * ratio
+                            };
+                        })
+                        : []
+                    : action.integratedTimeScaleSpans(scaledDt);
+                if (pauseOffset !== null && pauseOffset < elapsedDt) {
+                    clipSegments = limitTimeScaleSegments(clipSegments, pauseOffset);
+                }
+                const actualAdvances = [];
+                const actionEvents = [];
+                let actionOverflow = 0;
+                let playbackDelta = 0;
+                let finishOffset = null;
+                const catchUpLimit = action.maxEventCatchUp;
+                if (!Number.isSafeInteger(catchUpLimit) || catchUpLimit < 0) {
+                    throw new Error("PoseAction maxEventCatchUp must be a non-negative safe integer.");
+                }
+                const authoredLoopMode = action.loopMode;
+                try {
+                    // A sync group is leader-driven: followers cross the same normalized
+                    // seams and reflections even when their standalone loop mode differs.
+                    if (leader !== undefined)
+                        action.loopMode = leader.loopMode;
+                    for (const segment of clipSegments) {
+                        action.maxEventCatchUp = Math.max(0, catchUpLimit - actionEvents.length);
+                        const result = action.updateTime(segment.distance);
+                        const travelled = action.lastPlaybackDelta;
+                        const finished = !action.playing || action.paused;
+                        const consumed = finished ? AnimationAction.consumedWarpDuration(segment, Math.abs(travelled)) : segment.duration;
+                        const endRate = segment.duration > 0
+                            ? segment.from + (segment.to - segment.from) * (consumed / segment.duration)
+                            : segment.from;
+                        actualAdvances.push({ ...segment, duration: consumed, to: endRate, distance: travelled });
+                        playbackDelta += travelled;
+                        actionOverflow += result.eventOverflow;
+                        for (const event of result.events)
+                            actionEvents.push({ previous: result.previous, event });
+                        if (finished) {
+                            finishOffset = segment.startOffset + consumed;
+                            break;
+                        }
+                    }
+                }
+                finally {
+                    action.maxEventCatchUp = catchUpLimit;
+                    action.loopMode = authoredLoopMode;
+                }
+                action.setPlaybackDelta(playbackDelta);
+                advances.set(action, actualAdvances);
+                if (!wasPaused && action.hasPlaybackDuration) {
+                    action.advanceWarp(Math.min(elapsedDt, finishOffset ?? elapsedDt, pauseOffset ?? elapsedDt));
+                }
+                action.updateTimeScale(this.time, !wasPaused && action.paused);
+                action.updateWeight(this.time);
+                if (!action.enabled) {
+                    if (action.playing)
+                        action.stop();
+                    else
+                        this.deactivate(action);
+                }
+                this.lastEventOverflow += actionOverflow;
+                for (const { previous, event: marker } of actionEvents) {
+                    const { clipName: _clipName, direction, loopCount, ...event } = marker;
+                    events.push({
+                        clipId: action.clipName,
+                        event,
+                        time: event.time,
+                        previousTime: previous,
+                        localTime: event.time,
+                        normalizedTime: action.clip.duration > 0 ? event.time / action.clip.duration : 0,
+                        loopCount,
+                        direction,
+                        playbackTime: this.time
+                    });
+                }
             }
-            else {
-                pruneFinishedLayerActions(layer);
+            // Preserve the established leader-driven phase contract even if actions
+            // have different loop modes; marker traversal above uses each action's mode.
+            for (const [member, leader] of leaderFor) {
+                if (member.playing && member.enabled && !member.paused && leader.playing && leader.enabled) {
+                    member.time = leader.normalizedPhase * member.clip.duration;
+                }
+            }
+            for (const invocation of events) {
+                for (const listener of this.eventListeners)
+                    listener(invocation);
             }
+            if (this.inertializer !== null && this.inertializerElapsed !== Infinity) {
+                this.inertializerElapsed += Math.abs(scaledDt);
+            }
+            // Sweep layers whose actions have all faded out.
+            for (let i = this.layers.length - 1; i >= 0; i -= 1) {
+                const layer = this.layers[i];
+                if (layer.actions.length > 0 && layer.actions.every((a) => !a.enabled || !a.playing)) {
+                    for (const action of layer.actions)
+                        action.stop();
+                    this.layers.splice(i, 1);
+                    this.layerByName.delete(layer.name);
+                }
+                else {
+                    pruneFinishedLayerActions(layer);
+                }
+            }
+            return events;
+        }
+        finally {
+            this.updateDepth -= 1;
         }
-        return events;
     }
     /**
      * Evaluate the final pose into `out` (PoseBuffer with skeleton.boneCount
@@ -621,6 +1274,7 @@ export class PoseMixer {
      * (incremental-weighted, rest fills below Σw=1), then each layer in order.
      */
     evaluate(out) {
+        this.assertAlive();
         const n = this.skeleton.boneCount;
         const rest = this.skeleton.restPose;
         this.previousPose = this.latestPose;
@@ -654,6 +1308,7 @@ export class PoseMixer {
      * `evaluate`, so the two paths stay within the 1e-4 parity bar.
      */
     evaluateSamples(samples, out) {
+        this.assertAlive();
         const rest = this.skeleton.restPose;
         out.positions.set(rest.positions);
         out.rotations.set(rest.rotations);
@@ -685,6 +1340,30 @@ export class PoseMixer {
         this.applyAdditiveAccumulators(out);
         this.resetAccumulators();
     }
+    /** Stop all actions and release clip, binding, and event-listener references. */
+    dispose() {
+        if (this.disposed)
+            return;
+        for (const action of [...this.actions])
+            action.stop();
+        for (const layer of this.layers)
+            for (const action of layer.actions)
+                action.stop();
+        this.actions.length = 0;
+        this.layers.length = 0;
+        this.layerByName.clear();
+        this.clips.clear();
+        this.statelessBindings.clear();
+        this.statelessCursors.clear();
+        this.eventListeners.clear();
+        this.latestPose = null;
+        this.previousPose = null;
+        this.disposed = true;
+    }
+    assertAlive() {
+        if (this.disposed)
+            throw new Error("PoseMixer has been disposed.");
+    }
     applyBase(out) {
         const scratch = this.scratchClip;
         for (const action of this.actions) {
@@ -896,4 +1575,346 @@ function parseTrackTarget(target) {
         return null;
     return { nodeName: target.slice(0, separator), channel };
 }
+function unescapeNodeName(name) {
+    return name.replace(/\\(.)/gu, "$1");
+}
+function poseRecord(value, label, allowed, required = allowed) {
+    if (value === null || typeof value !== "object" || Array.isArray(value) ||
+        (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)) {
+        throw new Error(`PoseMixer.restore: ${label} must be a plain object.`);
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Object.getOwnPropertySymbols(value).length || Object.keys(descriptors).some(key => !allowed.includes(key) || !("value" in descriptors[key]) || !descriptors[key].enumerable)) {
+        throw new Error(`PoseMixer.restore: ${label} contains unsupported fields, accessors or callbacks.`);
+    }
+    if (required.some(key => !Object.prototype.hasOwnProperty.call(descriptors, key))) {
+        throw new Error(`PoseMixer.restore: ${label} is missing required fields.`);
+    }
+    return value;
+}
+function poseArray(value, label) {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || Object.getOwnPropertySymbols(value).length) {
+        throw new Error(`PoseMixer.restore: ${label} must be a plain array.`);
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const keys = Object.keys(descriptors);
+    if (keys.length !== value.length + 1 || keys.some(key => key !== "length" &&
+        (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length))) {
+        throw new Error(`PoseMixer.restore: ${label} contains sparse or unsupported array properties.`);
+    }
+    for (let index = 0; index < value.length; index++) {
+        const descriptor = descriptors[String(index)];
+        if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+            throw new Error(`PoseMixer.restore: ${label} contains sparse entries or accessors.`);
+        }
+    }
+    return value;
+}
+function poseNumber(value, label, minimum = -Infinity) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || Object.is(value, -0)) {
+        throw new Error(`PoseMixer.restore: ${label} must be a finite, JSON-roundtrippable number.`);
+    }
+    return value;
+}
+function poseBoolean(value, label) {
+    if (typeof value !== "boolean")
+        throw new Error(`PoseMixer.restore: ${label} must be boolean.`);
+    return value;
+}
+function readPoseNumberArray(value, length, label) {
+    const values = poseArray(value, label);
+    if (values.length !== length)
+        throw new Error(`PoseMixer.restore: ${label} has the wrong length.`);
+    return values.map((item, index) => poseNumber(item, `${label}[${index}]`));
+}
+function readPoseFloatArray(value, length, label) {
+    return readPoseNumberArray(value, length, label).map(number => {
+        if (Math.fround(number) !== number)
+            throw new Error(`PoseMixer.restore: ${label} must contain exact Float32 values.`);
+        return number;
+    });
+}
+function readPoseTypedNumbers(value, constructor, length, label) {
+    if (!(value instanceof constructor) || Object.getPrototypeOf(value) !== constructor.prototype ||
+        Object.getOwnPropertySymbols(value).length || value.length !== length) {
+        throw new Error(`PoseMixer.serialize: ${label} must be an unmodified ${constructor.name} of the expected length.`);
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Object.keys(descriptors).length !== value.length || Object.keys(descriptors).some(key => !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length ||
+        !("value" in descriptors[key]) || !descriptors[key].enumerable)) {
+        throw new Error(`PoseMixer.serialize: ${label} contains unsupported properties or callbacks.`);
+    }
+    return Array.from(value, (item, index) => poseNumber(item, `${label}[${index}]`));
+}
+function readPoseBindings(value, boneCount, trackCount) {
+    return poseArray(value, "track bindings").map(entry => {
+        const binding = poseRecord(entry, "track binding", ["trackIndex", "boneIndex", "channel"]);
+        const trackIndex = poseNumber(binding.trackIndex, "binding trackIndex", 0);
+        const boneIndex = poseNumber(binding.boneIndex, "binding boneIndex", 0);
+        if (!Number.isSafeInteger(trackIndex) || trackIndex >= trackCount ||
+            !Number.isSafeInteger(boneIndex) || boneIndex >= boneCount ||
+            (binding.channel !== "position" && binding.channel !== "rotation" && binding.channel !== "scale")) {
+            throw new Error("PoseMixer.restore: invalid track binding.");
+        }
+        return { trackIndex, boneIndex, channel: binding.channel };
+    });
+}
+function readPoseEnvelope(value, label, nonnegative) {
+    if (value === null)
+        return null;
+    const record = poseRecord(value, label, ["startTime", "duration", "from", "to"]);
+    const startTime = poseNumber(record.startTime, `${label} startTime`);
+    const duration = poseNumber(record.duration, `${label} duration`, 0);
+    const from = poseNumber(record.from, `${label} from`, nonnegative ? 0 : -Infinity);
+    const to = poseNumber(record.to, `${label} to`, nonnegative ? 0 : -Infinity);
+    if (duration === 0 || !Number.isFinite(startTime + duration) || !Number.isFinite(to - from)) {
+        throw new Error(`PoseMixer.restore: invalid ${label} interval.`);
+    }
+    return { startTime, duration, from, to };
+}
+function readPoseWarp(value) {
+    if (value === null)
+        return null;
+    const record = poseRecord(value, "warp", ["startTime", "duration", "from", "to", "elapsed"], ["startTime", "duration", "from", "to"]);
+    const envelope = readPoseEnvelope({
+        startTime: record.startTime, duration: record.duration, from: record.from, to: record.to
+    }, "warp", false);
+    if (!Object.prototype.hasOwnProperty.call(record, "elapsed"))
+        return envelope;
+    const elapsed = poseNumber(record.elapsed, "warp elapsed", 0);
+    if (elapsed > envelope.duration)
+        throw new Error("PoseMixer.restore: invalid warp elapsed time.");
+    return { ...envelope, elapsed };
+}
+function rebasePoseEnvelope(envelope, offset) {
+    if (envelope === null)
+        return null;
+    const startTime = envelope.startTime + offset;
+    if (!Number.isFinite(startTime) || !Number.isFinite(startTime + envelope.duration)) {
+        throw new Error("PoseAction.restore: rebased envelope is not finite.");
+    }
+    return { ...envelope, startTime };
+}
+function capturePoseBuffer(value, boneCount, label) {
+    const record = poseRecord(value, label, ["boneCount", "positions", "rotations", "scales"]);
+    if (record.boneCount !== boneCount)
+        throw new Error(`PoseMixer.serialize: ${label} has the wrong bone count.`);
+    return {
+        positions: readPoseTypedNumbers(record.positions, Float32Array, boneCount * 3, `${label} positions`),
+        rotations: readPoseTypedNumbers(record.rotations, Float32Array, boneCount * 4, `${label} rotations`),
+        scales: readPoseTypedNumbers(record.scales, Float32Array, boneCount * 3, `${label} scales`)
+    };
+}
+function readPoseBuffer(value, boneCount, label) {
+    const record = poseRecord(value, label, ["positions", "rotations", "scales"]);
+    return {
+        positions: readPoseFloatArray(record.positions, boneCount * 3, `${label} positions`),
+        rotations: readPoseFloatArray(record.rotations, boneCount * 4, `${label} rotations`),
+        scales: readPoseFloatArray(record.scales, boneCount * 3, `${label} scales`)
+    };
+}
+function restorePoseBuffer(value, boneCount, label) {
+    const pose = readPoseBuffer(value, boneCount, label);
+    return {
+        boneCount,
+        positions: new Float32Array(pose.positions),
+        rotations: new Float32Array(pose.rotations),
+        scales: new Float32Array(pose.scales)
+    };
+}
+function readPoseSkeleton(value, boneCount) {
+    const record = poseRecord(value, "skeleton target", ["jointNames", "parentIndices", "missingJointSlots", "nameBindings", "restPose"]);
+    const jointNames = poseArray(record.jointNames, "joint names");
+    const parents = readPoseNumberArray(record.parentIndices, boneCount, "parent indices");
+    const missing = poseArray(record.missingJointSlots, "missing joint slots");
+    if (jointNames.length !== boneCount || jointNames.some(name => typeof name !== "string") ||
+        parents.some(index => !Number.isSafeInteger(index) || index < -1 || index >= boneCount) ||
+        missing.length !== boneCount || missing.some(value => typeof value !== "boolean")) {
+        throw new Error("PoseMixer.restore: invalid skeleton target topology.");
+    }
+    const seenNames = new Set();
+    const nameBindings = poseArray(record.nameBindings, "skeleton name bindings").map(value => {
+        const entry = poseRecord(value, "skeleton name binding", ["name", "indices"]);
+        if (typeof entry.name !== "string" || seenNames.has(entry.name))
+            throw new Error("PoseMixer.restore: invalid skeleton name binding.");
+        seenNames.add(entry.name);
+        const indices = poseArray(entry.indices, "skeleton name indices").map(value => poseNumber(value, "skeleton joint index", 0));
+        if (indices.some(index => !Number.isSafeInteger(index) || index >= boneCount))
+            throw new Error("PoseMixer.restore: invalid skeleton joint index.");
+        return { name: entry.name, indices };
+    });
+    nameBindings.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    return {
+        jointNames: jointNames, parentIndices: parents, missingJointSlots: missing,
+        nameBindings, restPose: readPoseBuffer(record.restPose, boneCount, "rest pose")
+    };
+}
+function capturePoseSkeleton(skeleton) {
+    const boneCount = poseNumber(skeleton.boneCount, "skeleton boneCount", 0);
+    if (!Number.isSafeInteger(boneCount))
+        throw new Error("PoseMixer.serialize: invalid skeleton bone count.");
+    const nodeIndices = readPoseNumberArray(skeleton.jointNodeIndices, boneCount, "skeleton node indices");
+    const missing = poseArray(skeleton.missingNodeIndices, "missing node indices")
+        .map(value => poseNumber(value, "missing node index", 0));
+    if (nodeIndices.some(value => !Number.isSafeInteger(value) || value < 0) ||
+        missing.some(value => !Number.isSafeInteger(value) || !nodeIndices.includes(value))) {
+        throw new Error("PoseMixer.serialize: invalid skeleton node indices.");
+    }
+    const nameMap = skeleton.jointIndicesByName;
+    if (!(nameMap instanceof Map) || Object.getPrototypeOf(nameMap) !== Map.prototype ||
+        Reflect.ownKeys(nameMap).length !== 0) {
+        throw new Error("PoseMixer.serialize: skeleton name bindings must be an unmodified Map.");
+    }
+    const target = {
+        jointNames: skeleton.jointNames,
+        parentIndices: skeleton.parentIndices,
+        missingJointSlots: nodeIndices.map(index => missing.includes(index)),
+        nameBindings: [...nameMap].map(([name, indices]) => ({ name, indices })),
+        restPose: capturePoseBuffer(skeleton.restPose, boneCount, "rest pose")
+    };
+    return readPoseSkeleton(target, boneCount);
+}
+function assertPoseActionData(action) {
+    const allowed = [
+        "mixer", "clipName", "clip", "bindings", "cursors", "additive", "playback", "weight", "timeScale",
+        "enabled", "syncGroupName", "fade", "warpState", "restoreTimeScale", "effectiveWeight",
+        "effectiveTimeScale", "layerMask", "layerBlendMode"
+    ];
+    const descriptors = Object.getOwnPropertyDescriptors(action);
+    if (Object.getPrototypeOf(action) !== PoseAction.prototype || Object.getOwnPropertySymbols(action).length ||
+        Object.keys(descriptors).some(key => !allowed.includes(key) || !("value" in descriptors[key]) || !descriptors[key].enumerable)) {
+        throw new Error("PoseAction.serialize: custom action fields, accessors and callbacks cannot be serialized.");
+    }
+}
+function assertPosePlaybackData(playback) {
+    const allowed = [
+        "clip", "time", "weight", "timeScale", "loopMode", "repetitions", "clampWhenFinished", "playing", "paused",
+        "maxEventCatchUp", "lastPlaybackDelta", "pingPongForward", "loopsCompleted", "signalLoopDelta",
+        "signalFinishedDirection", "signalEventOverflow", "fadeDuration", "fadeElapsed", "fadeStartWeight",
+        "fadeTargetWeight", "warpState"
+    ];
+    const descriptors = Object.getOwnPropertyDescriptors(playback);
+    if (Object.getPrototypeOf(playback) !== AnimationAction.prototype || Object.getOwnPropertySymbols(playback).length ||
+        Object.keys(descriptors).some(key => !allowed.includes(key) || !("value" in descriptors[key]) || !descriptors[key].enumerable)) {
+        throw new Error("PoseAction: custom core playback fields, accessors and callbacks cannot be serialized or restored.");
+    }
+    const warp = descriptors.warpState?.value;
+    if (warp !== null && warp !== undefined)
+        poseRecord(warp, "core playback warp", ["duration", "elapsed", "from", "to"]);
+}
+function assertPoseInertializerData(inertializer, boneCount) {
+    const allowed = ["captured", "positionVelocities", "scaleVelocities", "angularSpeeds", "angularAxes", "boneCount", "halfLife"];
+    const descriptors = Object.getOwnPropertyDescriptors(inertializer);
+    if (Object.getPrototypeOf(inertializer) !== PoseInertializer.prototype || Object.getOwnPropertySymbols(inertializer).length ||
+        Object.keys(descriptors).some(key => !allowed.includes(key) || !("value" in descriptors[key]) || !descriptors[key].enumerable) ||
+        descriptors.boneCount?.value !== boneCount) {
+        throw new Error("PoseMixer: custom inertializers, callbacks or mismatched bone counts cannot be serialized or restored.");
+    }
+}
+function assertPoseWritable(value, keys, label) {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (keys.some(key => !descriptors[key] || !("value" in descriptors[key]) || !descriptors[key].writable)) {
+        throw new Error(`PoseMixer.restore: ${label} contains non-writable state or accessors.`);
+    }
+}
+function assertPoseMutableArray(value, label) {
+    const array = poseArray(value, label);
+    const descriptors = Object.getOwnPropertyDescriptors(array);
+    if (!Object.isExtensible(array) || !Object.getOwnPropertyDescriptor(array, "length")?.writable ||
+        Object.keys(descriptors).some(key => key !== "length" && (!descriptors[key].configurable || !descriptors[key].writable))) {
+        throw new Error(`PoseMixer.restore: ${label} is not mutable.`);
+    }
+}
+function assertPoseSourceClip(value) {
+    if (value === null || typeof value !== "object" || Object.getPrototypeOf(value) !== AnimationClip.prototype) {
+        throw new Error("PoseMixer.serialize: custom source clips cannot be serialized.");
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const keys = ["name", "tracks", "events", "duration"];
+    if (Object.getOwnPropertySymbols(value).length || keys.some(key => !descriptors[key]) ||
+        Object.keys(descriptors).some(key => !keys.includes(key) || !("value" in descriptors[key]) || !descriptors[key].enumerable)) {
+        throw new Error("PoseMixer.serialize: source clip contains unsupported fields, accessors or callbacks.");
+    }
+}
+function readPoseClipCatalog(value) {
+    const names = new Set();
+    const clips = poseArray(value, "registered clips").map(input => {
+        const clip = poseRecord(input, "registered clip identity", ["name", "sourceIdentity", "compiledIdentity", "additive"]);
+        if (typeof clip.name !== "string" || names.has(clip.name) ||
+            typeof clip.sourceIdentity !== "string" || typeof clip.compiledIdentity !== "string") {
+            throw new Error("PoseMixer.restore: invalid or duplicate registered clip identity.");
+        }
+        names.add(clip.name);
+        return {
+            name: clip.name,
+            sourceIdentity: clip.sourceIdentity,
+            compiledIdentity: clip.compiledIdentity,
+            additive: poseBoolean(clip.additive, "registered clip additive mode")
+        };
+    });
+    clips.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    return clips;
+}
+function rejectPoseNegativeZero(value) {
+    if (typeof value === "number" && Object.is(value, -0)) {
+        throw new Error("PoseMixer.serialize: negative zero cannot round-trip through JSON.");
+    }
+    if (value && typeof value === "object") {
+        for (const nested of Object.values(value))
+            rejectPoseNegativeZero(nested);
+    }
+}
+/**
+ * Collision-free identity for the actual compiled samples, not just their
+ * source clip. `addCompiledClip` permits independently supplied flat arrays.
+ */
+function poseCompiledIdentity(clip) {
+    return canonicalPoseData(clip, new Set(), 0);
+}
+function canonicalPoseData(value, ancestors, depth) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return `s${JSON.stringify(value)}`;
+    if (typeof value === "boolean")
+        return value ? "b1" : "b0";
+    if (typeof value === "number" && Number.isFinite(value))
+        return `n${Object.is(value, -0) ? "-0" : JSON.stringify(value)}`;
+    if (typeof value !== "object" || depth > 128)
+        throw new Error("PoseMixer.serialize: compiled clip contains nonserializable data or callbacks.");
+    if (ancestors.has(value))
+        throw new Error("PoseMixer.serialize: compiled clip contains a cycle.");
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            const values = poseArray(value, "compiled clip array");
+            return `a[${values.map(entry => canonicalPoseData(entry, ancestors, depth + 1)).join(",")}]`;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        const typed = prototype === Float32Array.prototype ? "f32" : prototype === Float64Array.prototype ? "f64"
+            : prototype === Uint8Array.prototype ? "u8" : prototype === Uint32Array.prototype ? "u32" : null;
+        if (typed !== null) {
+            const array = value;
+            const descriptors = Object.getOwnPropertyDescriptors(array);
+            if (Object.getOwnPropertySymbols(array).length || Object.keys(descriptors).length !== array.length ||
+                Object.keys(descriptors).some(key => !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= array.length ||
+                    !("value" in descriptors[key]) || !descriptors[key].enumerable)) {
+                throw new Error("PoseMixer.serialize: compiled clip typed array contains unsupported properties.");
+            }
+            return `t${typed}[${Array.from(array, entry => canonicalPoseData(entry, ancestors, depth + 1)).join(",")}]`;
+        }
+        if ((prototype !== Object.prototype && prototype !== null) || Object.getOwnPropertySymbols(value).length) {
+            throw new Error("PoseMixer.serialize: compiled clip contains a nonserializable object.");
+        }
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        const keys = Object.keys(descriptors).sort();
+        if (keys.some(key => !("value" in descriptors[key]) || !descriptors[key].enumerable)) {
+            throw new Error("PoseMixer.serialize: compiled clip contains an accessor or nonserializable property.");
+        }
+        return `o{${keys.map(key => `${JSON.stringify(key)}:${canonicalPoseData(descriptors[key].value, ancestors, depth + 1)}`).join(",")}}`;
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
 //# sourceMappingURL=PoseMixer.js.map