@zephyr3d/editor 0.3.5 → 0.3.7

package/dist/modules/zephyr3d_scene.js

@@ -1,4 +1,4 @@
-import { Disposable, makeObservable, releaseObject, retainObject, Vector4, Vector3, DRef, AABB, Frustum, ClipState, Interpolator, Quaternion, randomUUID, DWeakRef, Matrix4x4, nextPowerOf2, weightedAverage, ObservableVector3, ObservableQuaternion, ASSERT, Ray, Vector2, applyMixins, float2half, Observable, objectKeys, halton23, CubeFace, ObservableVector4, castObservable, radian2degree, degree2radian, uint8ArrayToBase64, base64ToUint8Array, mimeTypeOf, clamp01 as clamp01$1, smoothStep, InterpolatorScalar, applyPatch, guessMimeType, diff, PRNG, splitStringByGraphemes, packFloat3, isPowerOf2, clamp as clamp$1, Matrix3x3, PathUtils, textToBase64, HttpFS, MemoryFS, objectEntries, flushPendingDisposals } from '@zephyr3d/base';
+import { Disposable, makeObservable, releaseObject, retainObject, Vector4, Vector3, DRef, AABB, Frustum, ClipState, Interpolator, Quaternion, randomUUID, DWeakRef, Matrix4x4, nextPowerOf2, Observable, weightedAverage, ObservableVector3, ObservableQuaternion, ASSERT, Ray, Vector2, applyMixins, float2half, objectKeys, halton23, CubeFace, ObservableVector4, castObservable, radian2degree, degree2radian, uint8ArrayToBase64, base64ToUint8Array, mimeTypeOf, clamp01 as clamp01$1, smoothStep, InterpolatorScalar, applyPatch, guessMimeType, diff, PRNG, splitStringByGraphemes, packFloat3, isPowerOf2, clamp as clamp$1, Matrix3x3, PathUtils, textToBase64, HttpFS, MemoryFS, objectEntries, flushPendingDisposals } from '@zephyr3d/base';
 import { PBPrimitiveType, matchVertexBuffer, PBInsideFunctionScope, ProgramBuilder, PBShaderExp, isFloatTextureFormat, getVertexAttributeIndex, VERTEX_ATTRIB_POSITION, VERTEX_ATTRIB_TEXCOORD0, getVertexAttributeFormat, hasDepthChannel, PBStructTypeInfo, PBArrayTypeInfo, PBPrimitiveTypeInfo, getVertexFormatComponentCount, TextureAtlasManager } from '@zephyr3d/device';
 
 /** @internal */ let appInstance;
@@ -2645,6 +2645,8 @@ const debugFrameBuffer = {};
     /** @internal */ _tracks;
     _weight;
     /** @internal */ _skeletons;
+    /** @internal */ _frameRate;
+    /** @internal */ _markers;
     /**
    * Creates an animation instance
    * @param name - Name of the animation
@@ -2659,6 +2661,8 @@ const debugFrameBuffer = {};
         this._weight = 1;
         this._autoPlay = false;
         this._skeletons = new Set();
+        this._frameRate = 30;
+        this._markers = [];
     }
     /**
    * Whether this clip is embedded (owned inline by its container/resource).
@@ -2709,6 +2713,21 @@ const debugFrameBuffer = {};
         this._skeletons = val;
     }
     /**
+   * Default frame rate used to convert frame-based marker references.
+   */ get frameRate() {
+        return this._frameRate;
+    }
+    set frameRate(val) {
+        if (Number.isFinite(val) && val > 0) {
+            this._frameRate = val;
+        }
+    }
+    /**
+   * Timeline markers stored on this clip.
+   */ get markers() {
+        return this._markers;
+    }
+    /**
    * Total time span of the clip in seconds.
    *
    * Automatically extended when adding tracks with longer duration.
@@ -2719,6 +2738,74 @@ const debugFrameBuffer = {};
         this._duration = val;
     }
     /**
+   * Add a serializable marker to this clip.
+   *
+   * @param marker - Marker metadata. If `id` is omitted, `name` is used as the id.
+   * @returns The normalized marker.
+   */ addMarker(marker) {
+        if (!marker?.name) {
+            console.error('Animation marker must have a name');
+            return null;
+        }
+        const normalized = {
+            ...marker,
+            id: marker.id || marker.name
+        };
+        if (this.resolveMarkerTime(normalized) === null) {
+            console.error('Animation marker must have either time or frame');
+            return null;
+        }
+        this._markers.push(normalized);
+        this._markers.sort((a, b)=>(this.resolveMarkerTime(a) ?? 0) - (this.resolveMarkerTime(b) ?? 0));
+        return normalized;
+    }
+    /**
+   * Remove markers matching the marker id or name.
+   */ removeMarker(idOrName) {
+        const oldLength = this._markers.length;
+        this._markers = this._markers.filter((marker)=>marker.id !== idOrName && marker.name !== idOrName);
+        return this._markers.length !== oldLength;
+    }
+    /**
+   * Get the first marker matching the marker id or name.
+   */ getMarker(idOrName) {
+        return this._markers.find((marker)=>marker.id === idOrName || marker.name === idOrName) ?? null;
+    }
+    /**
+   * Resolve a marker to seconds on this clip's timeline.
+   */ resolveMarkerTime(marker) {
+        if (typeof marker.time === 'number' && Number.isFinite(marker.time)) {
+            return marker.time;
+        }
+        if (typeof marker.frame === 'number' && Number.isFinite(marker.frame)) {
+            const fps = marker.fps ?? this._frameRate;
+            return fps > 0 ? marker.frame / fps : null;
+        }
+        return null;
+    }
+    /**
+   * Resolve a time reference to seconds on this clip's timeline.
+   */ resolveTimeRef(ref) {
+        if (ref === null || ref === undefined) {
+            return null;
+        }
+        if (typeof ref === 'number') {
+            return Number.isFinite(ref) ? ref : null;
+        }
+        if ('time' in ref) {
+            return Number.isFinite(ref.time) ? ref.time : null;
+        }
+        if ('frame' in ref) {
+            const fps = ref.fps ?? this._frameRate;
+            return Number.isFinite(ref.frame) && fps > 0 ? ref.frame / fps : null;
+        }
+        if ('marker' in ref) {
+            const marker = this.getMarker(ref.marker);
+            return marker ? this.resolveMarkerTime(marker) : null;
+        }
+        return null;
+    }
+    /**
    * Add a skeleton used by this clip.
    *
    * @param skeletonId - Persistent ID of Skeleton to register for this clip.
@@ -5756,6 +5843,224 @@ function copySkeletonReferences(sourceClip, targetClip) {
     return targetClip;
 }
 
+let nextAnimationPlaybackId = 1;
+/**
+ * Runtime handle for one playback of an AnimationClip.
+ * @public
+ */ class AnimationPlayback extends Observable {
+    /** @internal */ _animationSet;
+    /** @internal */ _clip;
+    /** @internal */ _options;
+    /** @internal */ _id;
+    /** @internal */ _frameWaiters;
+    /** @internal */ _state;
+    /** @internal */ _time;
+    /** @internal */ _weight;
+    /** @internal */ _speedRatio;
+    /** @internal */ _layer;
+    /** @internal */ _priority;
+    /** @internal */ _interruptible;
+    constructor(animationSet, clip, options){
+        super();
+        this._animationSet = animationSet;
+        this._clip = clip;
+        this._options = {
+            ...options ?? {}
+        };
+        this._id = this._options.id ?? `animation-playback-${nextAnimationPlaybackId++}`;
+        this._state = 'scheduled';
+        this._speedRatio = this._options.speedRatio ?? 1;
+        this._weight = this._options.weight ?? clip.weight ?? 1;
+        this._time = this._speedRatio < 0 ? clip.timeDuration : 0;
+        this._layer = this._options.layer ?? 'default';
+        this._priority = this._options.priority ?? 0;
+        this._interruptible = this._options.interruptible ?? true;
+        this._frameWaiters = new Map();
+    }
+    get id() {
+        return this._id;
+    }
+    get animationSet() {
+        return this._animationSet;
+    }
+    get clip() {
+        return this._clip;
+    }
+    get state() {
+        return this._state;
+    }
+    get time() {
+        return this._time;
+    }
+    set time(value) {
+        this.seek(value);
+    }
+    get normalizedTime() {
+        return this._clip.timeDuration > 0 ? this._time / this._clip.timeDuration : 0;
+    }
+    set normalizedTime(value) {
+        this.seek(value * this._clip.timeDuration);
+    }
+    get weight() {
+        return this._weight;
+    }
+    set weight(value) {
+        this._animationSet.setPlaybackWeight(this, value);
+    }
+    get speedRatio() {
+        return this._speedRatio;
+    }
+    set speedRatio(value) {
+        this._animationSet.setPlaybackSpeedRatio(this, value);
+    }
+    get layer() {
+        return this._layer;
+    }
+    get priority() {
+        return this._priority;
+    }
+    get interruptible() {
+        return this._interruptible;
+    }
+    play() {
+        this._animationSet.startPlayback(this);
+        return this;
+    }
+    pause() {
+        this._animationSet.pausePlayback(this);
+        return this;
+    }
+    resume() {
+        this._animationSet.resumePlayback(this);
+        return this;
+    }
+    stop(options) {
+        this._animationSet.stopPlayback(this, options);
+        return this;
+    }
+    seek(time, options) {
+        this._animationSet.seekPlayback(this, time, options);
+        return this;
+    }
+    fadeTo(weight, duration) {
+        this._animationSet.fadePlaybackTo(this, weight, duration);
+        return this;
+    }
+    crossFadeTo(name, options) {
+        const duration = Math.max(options?.duration ?? 0, 0);
+        this.stop({
+            fadeOut: duration,
+            reason: 'interrupted'
+        });
+        return this._animationSet.play(name, {
+            ...options,
+            fadeIn: duration
+        });
+    }
+    waitForComplete() {
+        return new Promise((resolve)=>{
+            this.once('complete', ()=>resolve(this));
+        });
+    }
+    waitForMarker(idOrName) {
+        if (this._state === 'stopped' || this._state === 'completed') {
+            return Promise.resolve(undefined);
+        }
+        return new Promise((resolve)=>{
+            const handler = (event)=>{
+                if (event.marker.id === idOrName || event.marker.name === idOrName) {
+                    this.off('marker', handler);
+                    this.off('stop', stop);
+                    resolve(event);
+                }
+            };
+            const stop = ()=>{
+                this.off('marker', handler);
+                this.off('stop', stop);
+                resolve(undefined);
+            };
+            this.on('marker', handler);
+            this.on('stop', stop);
+        });
+    }
+    waitForFrame(frame) {
+        if (this._state === 'stopped' || this._state === 'completed') {
+            return Promise.resolve(undefined);
+        }
+        return new Promise((resolve)=>{
+            const waiters = this._frameWaiters.get(frame) ?? [];
+            let settled = false;
+            let stop;
+            const wrappedResolve = (event)=>{
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                this.off('stop', stop);
+                resolve(event);
+            };
+            stop = ()=>{
+                const current = this._frameWaiters.get(frame);
+                if (current) {
+                    this._frameWaiters.set(frame, current.filter((item)=>item !== wrappedResolve));
+                }
+                wrappedResolve(undefined);
+            };
+            waiters.push(wrappedResolve);
+            this._frameWaiters.set(frame, waiters);
+            this.on('stop', stop);
+        });
+    }
+    /** @internal */ _getOptions() {
+        return this._options;
+    }
+    /** @internal */ _setState(state) {
+        this._state = state;
+    }
+    /** @internal */ _setTime(time) {
+        this._time = time;
+    }
+    /** @internal */ _setWeight(weight) {
+        this._weight = weight;
+    }
+    /** @internal */ _setSpeedRatio(speedRatio) {
+        this._speedRatio = speedRatio;
+    }
+    /** @internal */ _getWatchedFrames() {
+        return [
+            ...this._frameWaiters.keys()
+        ];
+    }
+    /** @internal */ _emitStart(event) {
+        this.dispatchEvent('start', event);
+    }
+    /** @internal */ _emitLoop(event) {
+        this.dispatchEvent('loop', event);
+    }
+    /** @internal */ _emitMarker(event) {
+        this.dispatchEvent('marker', event);
+    }
+    /** @internal */ _emitFrame(event) {
+        this.dispatchEvent('frame', event);
+        const waiters = this._frameWaiters.get(event.frame);
+        if (waiters) {
+            this._frameWaiters.delete(event.frame);
+            waiters.forEach((resolve)=>resolve(event));
+        }
+    }
+    /** @internal */ _emitComplete(event) {
+        this.dispatchEvent('complete', event);
+    }
+    /** @internal */ _emitStop(event) {
+        this.dispatchEvent('stop', event);
+    }
+    /** @internal */ _emitPause(event) {
+        this.dispatchEvent('pause', event);
+    }
+    /** @internal */ _emitResume(event) {
+        this.dispatchEvent('resume', event);
+    }
+}
 function cloneInterpolator(src) {
     return new Interpolator(src.mode, src.target, src.inputs instanceof Float32Array ? new Float32Array(src.inputs) : [
         ...src.inputs
@@ -6137,26 +6442,26 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         dstClip.addTrack(remap.dstNode, track);
     }
 }
-/**
- * Animation set
- *
- * Manages a collection of named animation clips for a model and orchestrates:
- * - Playback state (time, loops, speed, weights, fade-in/out).
- * - Blending across multiple tracks targeting the same property via weighted averages.
- * - Skeleton usage and application for clips that drive skeletal animation.
- * - Active track registration and cleanup as clips start/stop.
- *
- * Usage:
- * - Create or retrieve `AnimationClip`s by name.
- * - Start playback with `playAnimation(name, options)`.
- * - Advance animation with `update(deltaSeconds)`.
- * - Optionally adjust weight while playing with `setAnimationWeight(name, weight)`.
- *
- * Lifetime:
- * - Disposing the set releases references to the model, clips, and clears active state.
- *
- * @public
- */ class AnimationSet extends Disposable {
+/**
+ * Animation set
+ *
+ * Manages a collection of named animation clips for a model and orchestrates:
+ * - Playback state (time, loops, speed, weights, fade-in/out).
+ * - Blending across multiple tracks targeting the same property via weighted averages.
+ * - Skeleton usage and application for clips that drive skeletal animation.
+ * - Active track registration and cleanup as clips start/stop.
+ *
+ * Usage:
+ * - Create or retrieve `AnimationClip`s by name.
+ * - Start playback with `playAnimation(name, options)`.
+ * - Advance animation with `update(deltaSeconds)`.
+ * - Optionally adjust weight while playing with `setAnimationWeight(name, weight)`.
+ *
+ * Lifetime:
+ * - Disposing the set releases references to the model, clips, and clears active state.
+ *
+ * @public
+ */ class AnimationSet extends makeObservable(Disposable)() {
     /** @internal */ _model;
     /** @internal */ _animations;
     /** @internal */ _skeletons;
@@ -6165,10 +6470,18 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
     /** @internal */ _activeSkinBindings;
     /** @internal */ _activeRigs;
     /** @internal */ _activeAnimations;
-    /**
-   * Create an AnimationSet controlling the provided model.
-   *
-   * @param model - The SceneNode (model root) controlled by this animation set.
+    /**
+   * Callbacks driven by the same logical clock as the animations (see {@link update}).
+   *
+   * Used by higher-level constructs (e.g. timeline runners) that need to advance
+   * wall-clock-independent timers in sync with playback, so they pause/scale with the
+   * game clock instead of running on real time.
+   * @internal
+   */ _timelineTickers;
+    /**
+   * Create an AnimationSet controlling the provided model.
+   *
+   * @param model - The SceneNode (model root) controlled by this animation set.
    */ constructor(model){
         super();
         this._model = model;
@@ -6179,29 +6492,42 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         this._activeAnimations = new Map();
         this._skeletons = [];
         this._rigs = [];
+        this._timelineTickers = new Set();
     }
-    /**
-   * The model (SceneNode) controlled by this animation set.
+    /**
+   * Register a callback advanced by {@link update} using the same delta time as the animations.
+   * @internal
+   */ _registerTimelineTicker(ticker) {
+        this._timelineTickers.add(ticker);
+    }
+    /**
+   * Unregister a callback previously registered with {@link _registerTimelineTicker}.
+   * @internal
+   */ _unregisterTimelineTicker(ticker) {
+        this._timelineTickers.delete(ticker);
+    }
+    /**
+   * The model (SceneNode) controlled by this animation set.
    */ get model() {
         return this._model;
     }
-    /**
-   * Number of animation clips registered in this set.
+    /**
+   * Number of animation clips registered in this set.
    */ get numAnimations() {
         return Object.getOwnPropertyNames(this._animations).length;
     }
-    /**
-   * The skeletons used by animations in this set.
+    /**
+   * The skeletons used by animations in this set.
    */ get skeletons() {
         return this._skeletons;
     }
-    /**
-   * The shared rigs used by animations in this set.
+    /**
+   * The shared rigs used by animations in this set.
    */ get rigs() {
         return this._rigs;
     }
-    /**
-   * Per-skin bindings used by skinned meshes in this set.
+    /**
+   * Per-skin bindings used by skinned meshes in this set.
    */ get skinBindings() {
         return this._skeletons;
     }
@@ -6223,20 +6549,20 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         }
         return rig;
     }
-    /**
-   * Retrieve an animation clip by name.
-   *
-   * @param name - Name of the animation.
-   * @returns The clip if present; otherwise null.
+    /**
+   * Retrieve an animation clip by name.
+   *
+   * @param name - Name of the animation.
+   * @returns The clip if present; otherwise null.
    */ get(name) {
         return this._animations[name] ?? null;
     }
-    /**
-   * Create and register a new animation clip.
-   *
-   * @param name - Unique name for the animation clip.
-   * @param embedded - Whether the clip is embedded/owned (implementation-specific). Default false.
-   * @returns The created clip, or null if the name is empty or not unique.
+    /**
+   * Create and register a new animation clip.
+   *
+   * @param name - Unique name for the animation clip.
+   * @param embedded - Whether the clip is embedded/owned (implementation-specific). Default false.
+   * @returns The created clip, or null if the name is empty or not unique.
    */ createAnimation(name, embedded = false) {
         if (!name || this._animations[name]) {
             console.error('Animation must have unique name');
@@ -6248,12 +6574,12 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             return animation;
         }
     }
-    /**
-   * Delete and dispose an animation clip by name.
-   *
-   * - If the animation is currently playing, it is first stopped (immediately).
-   *
-   * @param name - Name of the animation to remove.
+    /**
+   * Delete and dispose an animation clip by name.
+   *
+   * - If the animation is currently playing, it is first stopped (immediately).
+   *
+   * @param name - Name of the animation to remove.
    */ deleteAnimation(name) {
         const animation = this._animations[name];
         if (animation) {
@@ -6262,50 +6588,119 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             animation.dispose();
         }
     }
-    /**
-   * Get the list of all registered animation names.
-   *
-   * @returns An array of clip names.
+    /**
+   * Get the list of all registered animation names.
+   *
+   * @returns An array of clip names.
    */ getAnimationNames() {
         return Object.keys(this._animations);
     }
-    /**
-   * Advance and apply active animations.
-   *
-   * Responsibilities per call:
-   * - Update time cursor for each active clip (respecting speedRatio and looping).
-   * - Enforce repeat limits and apply fade-out termination if configured.
-   * - For each animated target, blend active tracks (weighted by clip weight × fade-in × fade-out)
-   *   and apply the resulting state to the target.
-   * - Apply shared rig modifiers once, then update skin binding palettes.
-   *
-   * @param deltaInSeconds - Time step in seconds since last update.
+    /**
+   * Advance and apply active animations.
+   *
+   * Responsibilities per call:
+   * - Update time cursor for each active clip (respecting speedRatio and looping).
+   * - Enforce repeat limits and apply fade-out termination if configured.
+   * - For each animated target, blend active tracks (weighted by clip weight × fade-in × fade-out)
+   *   and apply the resulting state to the target.
+   * - Apply shared rig modifiers once, then update skin binding palettes.
+   *
+   * @param deltaInSeconds - Time step in seconds since last update.
    */ update(deltaInSeconds) {
         this._activeAnimations.forEach((v, k)=>{
+            if (!v.started) {
+                v.started = true;
+                const event = this.createPlaybackEvent(v, k);
+                v.playback._emitStart(event);
+                this.dispatchEvent('playbackstart', event);
+            }
+            if (v.paused) {
+                return;
+            }
             if (v.fadeOut > 0 && v.fadeOutStart < 0) {
                 v.fadeOutStart = v.animateTime;
             }
+            if (v.completed) {
+                v.animateTime += Math.abs(deltaInSeconds * v.speedRatio);
+                if (v.fadeOut > 0 && v.animateTime - v.fadeOutStart >= v.fadeOut) {
+                    this.stopAnimation(k.name, {
+                        reason: v.stopReason
+                    });
+                }
+                return;
+            }
             // Update animation time
             if (v.firstFrame) {
                 v.firstFrame = false;
             } else {
+                const previousTime = v.currentTime;
                 const timeAdvance = deltaInSeconds * v.speedRatio;
                 v.currentTime += timeAdvance;
                 v.animateTime += timeAdvance;
+                const direction = timeAdvance >= 0 ? 1 : -1;
                 if (k.timeDuration > 0) {
-                    if (v.currentTime > k.timeDuration) {
-                        v.repeatCounter += Math.max(1, Math.floor(v.currentTime / k.timeDuration));
+                    if (v.rangeEnd !== null && v.speedRatio >= 0 && v.currentTime >= v.rangeEnd) {
+                        v.currentTime = v.rangeEnd;
+                        v.playback._setTime(v.currentTime);
+                        this.completePlayback(k, v);
+                        return;
+                    } else if (v.rangeStart !== null && v.speedRatio < 0 && v.currentTime <= v.rangeStart) {
+                        v.currentTime = v.rangeStart;
+                        v.playback._setTime(v.currentTime);
+                        this.completePlayback(k, v);
+                        return;
+                    } else if (v.currentTime > k.timeDuration) {
+                        const loops = Math.max(1, Math.floor(v.currentTime / k.timeDuration));
+                        if (v.repeat !== 0 && v.repeatCounter + loops >= v.repeat) {
+                            v.repeatCounter += loops;
+                            v.currentTime = k.timeDuration;
+                            v.playback._setTime(v.currentTime);
+                            this.emitCrossedMarkers(v, k, previousTime, v.currentTime, direction);
+                            this.emitCrossedFrames(v, k, previousTime, v.currentTime, direction);
+                            this.completePlayback(k, v);
+                            return;
+                        }
+                        v.repeatCounter += loops;
                         v.currentTime %= k.timeDuration;
+                        const event = this.createPlaybackEvent(v, k);
+                        v.playback._emitLoop(event);
+                        this.dispatchEvent('playbackloop', event);
                     } else if (v.currentTime < 0) {
-                        v.repeatCounter += Math.max(1, Math.ceil(-v.currentTime / k.timeDuration));
+                        const loops = Math.max(1, Math.ceil(-v.currentTime / k.timeDuration));
+                        if (v.repeat !== 0 && v.repeatCounter + loops >= v.repeat) {
+                            v.repeatCounter += loops;
+                            v.currentTime = 0;
+                            v.playback._setTime(v.currentTime);
+                            this.emitCrossedMarkers(v, k, previousTime, v.currentTime, direction);
+                            this.emitCrossedFrames(v, k, previousTime, v.currentTime, direction);
+                            this.completePlayback(k, v);
+                            return;
+                        }
+                        v.repeatCounter += loops;
                         v.currentTime = (v.currentTime % k.timeDuration + k.timeDuration) % k.timeDuration;
+                        const event = this.createPlaybackEvent(v, k);
+                        v.playback._emitLoop(event);
+                        this.dispatchEvent('playbackloop', event);
                     }
                 }
+                v.playback._setTime(v.currentTime);
+                this.emitCrossedMarkers(v, k, previousTime, v.currentTime, direction);
+                this.emitCrossedFrames(v, k, previousTime, v.currentTime, direction);
                 if (v.repeat !== 0 && v.repeatCounter >= v.repeat) {
-                    this.stopAnimation(k.name);
+                    this.completePlayback(k, v);
                 } else if (v.fadeOut > 0) {
                     if (v.animateTime - v.fadeOutStart >= v.fadeOut) {
-                        this.stopAnimation(k.name);
+                        this.stopAnimation(k.name, {
+                            reason: v.stopReason
+                        });
+                    }
+                }
+                if (v.fadeToDuration > 0) {
+                    const t = Math.min(1, (v.animateTime - v.fadeToStart) / v.fadeToDuration);
+                    v.weight = v.fadeFromWeight + (v.fadeTargetWeight - v.fadeFromWeight) * t;
+                    v.playback._setWeight(v.weight);
+                    if (t >= 1) {
+                        v.fadeToDuration = 0;
                     }
                 }
             }
@@ -6345,12 +6740,17 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         this._skeletons.forEach((v)=>{
             v.get()?.apply();
         });
+        // Advance logical-clock timers (e.g. timeline `wait` steps) with the same delta time,
+        // so they stay in sync with playback and pause/scale with the game clock.
+        if (this._timelineTickers.size > 0) {
+            this._timelineTickers.forEach((ticker)=>ticker(deltaInSeconds));
+        }
     }
-    /**
-   * Check whether an animation is currently playing.
-   *
-   * @param name - Optional animation name. If omitted, returns true if any animation is playing.
-   * @returns True if playing; otherwise false.
+    /**
+   * Check whether an animation is currently playing.
+   *
+   * @param name - Optional animation name. If omitted, returns true if any animation is playing.
+   * @returns True if playing; otherwise false.
    */ isPlayingAnimation(name) {
         if (name) {
             const animation = this._animations[name];
@@ -6358,23 +6758,23 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         }
         return this._activeAnimations.size > 0;
     }
-    /**
-   * Get an animation clip by name.
-   *
-   * Alias of `get(name)` returning a nullable type.
-   *
-   * @param name - Name of the animation.
-   * @returns The clip if present; otherwise null.
+    /**
+   * Get an animation clip by name.
+   *
+   * Alias of `get(name)` returning a nullable type.
+   *
+   * @param name - Name of the animation.
+   * @returns The clip if present; otherwise null.
    */ getAnimationClip(name) {
         return this._animations[name] ?? null;
     }
-    /**
-   * Set the runtime blend weight for a currently playing animation.
-   *
-   * Has no effect if the clip is not active.
-   *
-   * @param name - Name of the playing animation.
-   * @param weight - New weight value used during blending.
+    /**
+   * Set the runtime blend weight for a currently playing animation.
+   *
+   * Has no effect if the clip is not active.
+   *
+   * @param name - Name of the playing animation.
+   * @param weight - New weight value used during blending.
    */ setAnimationWeight(name, weight) {
         const ani = this._animations[name];
         if (!ani) {
@@ -6384,42 +6784,104 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         const info = this._activeAnimations.get(ani);
         if (info) {
             info.weight = weight;
+            info.targetWeight = weight;
+            info.playback._setWeight(weight);
         }
     }
-    /**
-   * Start (or update) playback of an animation clip.
-   *
-   * Behavior:
-   * - If the clip is already playing, stops it first.
-   * - Otherwise initializes playback state (repeat counter, speed, weight, initial time).
-   * - Registers clip tracks and skeletons into the active sets for blending and application.
-   *
-   * @param name - Name of the animation to play.
-   * @param options - Playback options (repeat, speedRatio, fadeIn).
-   */ playAnimation(name, options) {
+    /**
+   * Create a playback handle without starting it.
+   */ createPlayback(name, options) {
         const ani = this._animations[name];
         if (!ani) {
             console.error(`Animation ${name} not exists`);
-            return;
+            return null;
         }
-        if (this.isPlayingAnimation(name)) {
-            this.stopAnimation(name);
+        return new AnimationPlayback(this, ani, options);
+    }
+    /**
+   * Start an animation and return its playback handle.
+   */ play(name, options) {
+        const playback = this.createPlayback(name, options);
+        playback?.play();
+        return playback;
+    }
+    /**
+   * Get currently active playbacks.
+   */ getPlaybacks(name) {
+        const playbacks = [];
+        this._activeAnimations.forEach((info, clip)=>{
+            if (!name || clip.name === name) {
+                playbacks.push(info.playback);
+            }
+        });
+        return playbacks;
+    }
+    /**
+   * Get the currently active playback for a clip.
+   */ getPlayback(name) {
+        const clip = this._animations[name];
+        return clip ? this._activeAnimations.get(clip)?.playback ?? null : null;
+    }
+    /**
+   * Start (or update) playback of an animation clip.
+   *
+   * Behavior:
+   * - If the clip is already playing, stops it first.
+   * - Otherwise initializes playback state (repeat counter, speed, weight, initial time).
+   * - Registers clip tracks and skeletons into the active sets for blending and application.
+   *
+   * @param name - Name of the animation to play.
+   * @param options - Playback options (repeat, speedRatio, fadeIn).
+   */ playAnimation(name, options) {
+        this.play(name, options);
+    }
+    /**
+   * Start a previously created playback.
+   * @internal
+   */ startPlayback(playback) {
+        const ani = playback.clip;
+        if (!ani) {
+            return;
         }
+        const options = playback._getOptions();
         const fadeIn = Math.max(options?.fadeIn ?? 0, 0);
         const repeat = options?.repeat ?? 0;
-        const speedRatio = options?.speedRatio ?? 1;
-        const weight = options?.weight ?? ani.weight ?? 1;
+        const speedRatio = playback.speedRatio;
+        const weight = playback.weight;
+        const rangeStart = ani.resolveTimeRef(options?.range?.start);
+        const rangeEnd = ani.resolveTimeRef(options?.range?.end);
+        const syncSource = this.resolvePlaybackSyncSource(options?.sync);
+        const initialTime = this.computePlaybackInitialTime(ani, speedRatio, rangeStart, rangeEnd, options?.sync, syncSource);
+        if (this.isPlayingAnimation(ani.name)) {
+            this.stopAnimation(ani.name, {
+                reason: 'replaced'
+            });
+        }
+        playback._setState('playing');
+        playback._setTime(initialTime);
         this._activeAnimations.set(ani, {
+            playback,
             repeat,
             weight,
+            targetWeight: weight,
             speedRatio,
             fadeIn,
             fadeOut: 0,
             repeatCounter: 0,
-            currentTime: speedRatio < 0 ? ani.timeDuration : 0,
+            currentTime: initialTime,
             animateTime: 0,
             fadeOutStart: 0,
-            firstFrame: true
+            fadeToStart: 0,
+            fadeToDuration: 0,
+            fadeFromWeight: weight,
+            fadeTargetWeight: weight,
+            firstFrame: true,
+            started: false,
+            paused: false,
+            stopReason: 'manual',
+            completed: false,
+            rangeStart,
+            rangeEnd
         });
         ani.tracks?.forEach((v, k)=>{
             let nodeTracks = this._activeTracks.get(k);
@@ -6456,18 +6918,257 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             }
         });
     }
-    /**
-   * Stop playback of an animation clip.
-   *
-   * Behavior:
-   * - If `options.fadeOut > 0`, marks the clip for fade-out; actual removal occurs after fade completes.
-   * - If `fadeOut` is 0 or omitted, immediately:
-   *   - Removes the clip from active animations.
-   *   - Unregisters its tracks from active track maps.
-   *   - Decrements skeleton reference counts; resets and removes skeletons when refcount reaches 0.
-   *
-   * @param name - Name of the animation to stop.
-   * @param options - Optional fade-out configuration.
+    resolvePlaybackSyncSource(sync) {
+        if (!sync?.target) {
+            return null;
+        }
+        const playback = this.resolveActivePlayback(sync.target);
+        if (!playback) {
+            return null;
+        }
+        const info = this._activeAnimations.get(playback.clip);
+        return info?.playback === playback ? {
+            playback,
+            info,
+            clip: playback.clip
+        } : null;
+    }
+    resolveActivePlayback(target) {
+        const named = this.getPlayback(target);
+        if (named) {
+            return named;
+        }
+        for (const info of this._activeAnimations.values()){
+            if (info.playback.id === target) {
+                return info.playback;
+            }
+        }
+        return null;
+    }
+    computePlaybackInitialTime(clip, speedRatio, rangeStart, rangeEnd, sync, syncSource) {
+        const fallback = speedRatio < 0 ? rangeEnd ?? rangeStart ?? clip.timeDuration : rangeStart ?? 0;
+        if (!sync || !syncSource) {
+            return fallback;
+        }
+        const destination = this.getPlaybackEffectiveRange(clip, rangeStart, rangeEnd);
+        if (destination.duration <= 0) {
+            return fallback;
+        }
+        const offset = Number.isFinite(sync.offset) ? sync.offset ?? 0 : 0;
+        const wrap = sync.wrap ?? true;
+        if ((sync.mode ?? 'normalized') === 'time') {
+            return this.constrainPlaybackTime(syncSource.info.currentTime + offset, destination, wrap);
+        }
+        const source = this.getPlaybackEffectiveRange(syncSource.clip, syncSource.info.rangeStart, syncSource.info.rangeEnd);
+        if (source.duration <= 0) {
+            return fallback;
+        }
+        const phase = (syncSource.info.currentTime - source.start) / source.duration + offset;
+        return this.constrainPlaybackTime(destination.start + phase * destination.duration, destination, wrap);
+    }
+    getPlaybackEffectiveRange(clip, rangeStart, rangeEnd) {
+        const start = rangeStart ?? 0;
+        const end = rangeEnd ?? clip.timeDuration;
+        return start <= end ? {
+            start,
+            end,
+            duration: end - start
+        } : {
+            start: end,
+            end: start,
+            duration: start - end
+        };
+    }
+    constrainPlaybackTime(time, range, wrap) {
+        if (!Number.isFinite(time)) {
+            return range.start;
+        }
+        if (!wrap) {
+            return Math.max(range.start, Math.min(range.end, time));
+        }
+        if (time >= range.start && time < range.end) {
+            return time;
+        }
+        const offset = ((time - range.start) % range.duration + range.duration) % range.duration;
+        return range.start + offset;
+    }
+    /**
+   * Stop a playback handle.
+   * @internal
+   */ stopPlayback(playback, options) {
+        if (this._activeAnimations.get(playback.clip)?.playback === playback) {
+            this.stopAnimation(playback.clip.name, options);
+        }
+    }
+    /**
+   * Pause a playback handle.
+   * @internal
+   */ pausePlayback(playback) {
+        const info = this._activeAnimations.get(playback.clip);
+        if (info?.playback === playback && !info.paused) {
+            info.paused = true;
+            playback._setState('paused');
+            const event = this.createPlaybackEvent(info, playback.clip);
+            playback._emitPause(event);
+            this.dispatchEvent('playbackpause', event);
+        }
+    }
+    /**
+   * Resume a playback handle.
+   * @internal
+   */ resumePlayback(playback) {
+        const info = this._activeAnimations.get(playback.clip);
+        if (info?.playback === playback && info.paused) {
+            info.paused = false;
+            playback._setState('playing');
+            const event = this.createPlaybackEvent(info, playback.clip);
+            playback._emitResume(event);
+            this.dispatchEvent('playbackresume', event);
+        }
+    }
+    /**
+   * Seek a playback handle.
+   * @internal
+   */ seekPlayback(playback, time, options) {
+        const clip = playback.clip;
+        const info = this._activeAnimations.get(clip);
+        const duration = clip.timeDuration;
+        const clampedTime = duration > 0 ? Math.max(0, Math.min(duration, time)) : Math.max(0, time);
+        const previousTime = info?.currentTime ?? playback.time;
+        playback._setTime(clampedTime);
+        if (info?.playback === playback) {
+            info.currentTime = clampedTime;
+            if (options?.emitEvents) {
+                const direction = clampedTime >= previousTime ? 1 : -1;
+                this.emitCrossedMarkers(info, clip, previousTime, clampedTime, direction);
+                this.emitCrossedFrames(info, clip, previousTime, clampedTime, direction);
+            }
+            if (options?.apply) {
+                this.update(0);
+            }
+        }
+    }
+    /**
+   * Set playback weight.
+   * @internal
+   */ setPlaybackWeight(playback, weight) {
+        playback._setWeight(weight);
+        const info = this._activeAnimations.get(playback.clip);
+        if (info?.playback === playback) {
+            info.weight = weight;
+            info.targetWeight = weight;
+        }
+    }
+    /**
+   * Set playback speed ratio.
+   * @internal
+   */ setPlaybackSpeedRatio(playback, speedRatio) {
+        playback._setSpeedRatio(speedRatio);
+        const info = this._activeAnimations.get(playback.clip);
+        if (info?.playback === playback) {
+            info.speedRatio = speedRatio;
+        }
+    }
+    /**
+   * Fade playback weight to a target value.
+   * @internal
+   */ fadePlaybackTo(playback, weight, duration) {
+        const info = this._activeAnimations.get(playback.clip);
+        if (info?.playback === playback) {
+            info.fadeFromWeight = info.weight;
+            info.fadeTargetWeight = weight;
+            info.targetWeight = weight;
+            info.fadeToStart = info.animateTime;
+            info.fadeToDuration = Math.max(duration, 0);
+            if (info.fadeToDuration === 0) {
+                info.weight = weight;
+                playback._setWeight(weight);
+            }
+        } else {
+            playback._setWeight(weight);
+        }
+    }
+    createPlaybackEvent(info, clip) {
+        return {
+            playback: info.playback,
+            animationSet: this,
+            clip,
+            time: info.currentTime,
+            normalizedTime: clip.timeDuration > 0 ? info.currentTime / clip.timeDuration : 0
+        };
+    }
+    completePlayback(clip, info) {
+        if (info.completed) {
+            return;
+        }
+        const event = this.createPlaybackEvent(info, clip);
+        const completionFadeOut = Math.max(info.playback._getOptions().completionFadeOut ?? 0, 0);
+        info.playback._setState('completed');
+        info.playback._emitComplete(event);
+        this.dispatchEvent('playbackcomplete', event);
+        if (completionFadeOut > 0) {
+            info.completed = true;
+            info.fadeOut = completionFadeOut;
+            info.fadeOutStart = info.animateTime;
+            info.stopReason = 'completed';
+            return;
+        }
+        this.stopAnimation(clip.name, {
+            reason: 'completed'
+        });
+    }
+    emitCrossedMarkers(info, clip, fromTime, toTime, direction) {
+        for (const marker of this.getCrossedMarkers(clip, fromTime, toTime, direction)){
+            const event = {
+                ...this.createPlaybackEvent(info, clip),
+                marker,
+                direction
+            };
+            info.playback._emitMarker(event);
+            this.dispatchEvent('marker', event);
+        }
+    }
+    emitCrossedFrames(info, clip, fromTime, toTime, direction) {
+        for (const frame of info.playback._getWatchedFrames()){
+            const frameTime = frame / clip.frameRate;
+            const crossed = direction >= 0 ? this.crossedForward(fromTime, toTime, frameTime, clip.timeDuration) : this.crossedBackward(fromTime, toTime, frameTime, clip.timeDuration);
+            if (crossed) {
+                const event = {
+                    ...this.createPlaybackEvent(info, clip),
+                    frame
+                };
+                info.playback._emitFrame(event);
+                this.dispatchEvent('frame', event);
+            }
+        }
+    }
+    getCrossedMarkers(clip, fromTime, toTime, direction) {
+        return clip.markers.filter((marker)=>{
+            const markerTime = clip.resolveMarkerTime(marker);
+            if (markerTime === null) {
+                return false;
+            }
+            return direction >= 0 ? this.crossedForward(fromTime, toTime, markerTime, clip.timeDuration) : this.crossedBackward(fromTime, toTime, markerTime, clip.timeDuration);
+        });
+    }
+    crossedForward(fromTime, toTime, targetTime, duration) {
+        return toTime >= fromTime ? targetTime > fromTime && targetTime <= toTime : duration > 0 && targetTime > fromTime && targetTime <= duration || targetTime <= toTime;
+    }
+    crossedBackward(fromTime, toTime, targetTime, duration) {
+        return toTime <= fromTime ? targetTime < fromTime && targetTime >= toTime : duration > 0 && targetTime < fromTime && targetTime >= 0 || targetTime >= toTime;
+    }
+    /**
+   * Stop playback of an animation clip.
+   *
+   * Behavior:
+   * - If `options.fadeOut > 0`, marks the clip for fade-out; actual removal occurs after fade completes.
+   * - If `fadeOut` is 0 or omitted, immediately:
+   *   - Removes the clip from active animations.
+   *   - Unregisters its tracks from active track maps.
+   *   - Decrements skeleton reference counts; resets and removes skeletons when refcount reaches 0.
+   *
+   * @param name - Name of the animation to stop.
+   * @param options - Optional fade-out configuration.
    */ stopAnimation(name, options) {
         const ani = this._animations[name];
         if (!ani) {
@@ -6477,9 +7178,12 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         const info = this._activeAnimations.get(ani);
         if (info) {
             const fadeOut = Math.max(options?.fadeOut ?? 0, 0);
+            const reason = options?.reason ?? 'manual';
             if (fadeOut !== 0) {
                 info.fadeOut = fadeOut;
                 info.fadeOutStart = -1;
+                info.stopReason = reason;
+                info.playback._setState('stopping');
             } else {
                 this._activeAnimations.delete(ani);
                 this._activeTracks.forEach((v)=>{
@@ -6517,20 +7221,29 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                         }
                     }
                 });
+                const event = {
+                    ...this.createPlaybackEvent(info, ani),
+                    reason
+                };
+                if (reason !== 'completed') {
+                    info.playback._setState('stopped');
+                }
+                info.playback._emitStop(event);
+                this.dispatchEvent('playbackstop', event);
             }
         }
     }
-    /**
-   * Create a skeletal-only masked clip from an existing clip in this set.
-   *
-   * The generated clip is a regular `AnimationClip`: it contains cloned node transform tracks
-   * for the selected rig joints and can be played/blended through the normal animation system.
-   * Non-skeletal tracks are skipped by default.
-   *
-   * @param sourceName - Name of the source clip.
-   * @param targetName - Name of the generated clip.
-   * @param options - Humanoid semantic or joint-name based mask options.
-   * @returns The generated clip, or null on failure.
+    /**
+   * Create a skeletal-only masked clip from an existing clip in this set.
+   *
+   * The generated clip is a regular `AnimationClip`: it contains cloned node transform tracks
+   * for the selected rig joints and can be played/blended through the normal animation system.
+   * Non-skeletal tracks are skipped by default.
+   *
+   * @param sourceName - Name of the source clip.
+   * @param targetName - Name of the generated clip.
+   * @param options - Humanoid semantic or joint-name based mask options.
+   * @returns The generated clip, or null on failure.
    */ createSkeletalMaskedAnimation(sourceName, targetName, options) {
         const sourceClip = this.get(sourceName);
         if (!sourceClip) {
@@ -6737,21 +7450,21 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         }
         return dstClip;
     }
-    /**
-   * Copy an animation clip from another AnimationSet into this one.
-   *
-   * Prerequisites:
-   * - Both sets must reference skeletons with identical joint names and counts.
-   * - The source clip must exist in `sourceSet`.
-   *
-   * @param sourceSet - The AnimationSet to copy from.
-   * @param animationName - Name of the clip to copy.
-   * @param targetName - Name for the new clip in this set. Defaults to `animationName`.
-   * @param excludeJoint - Optional predicate; joints whose name returns true are excluded from
-   *   skeleton structure matching.
-   * @returns The newly created AnimationClip, or null on failure.
-   *
-   * @deprecated Use AnimationSet.copyHumanoidAnimationFrom instead.
+    /**
+   * Copy an animation clip from another AnimationSet into this one.
+   *
+   * Prerequisites:
+   * - Both sets must reference skeletons with identical joint names and counts.
+   * - The source clip must exist in `sourceSet`.
+   *
+   * @param sourceSet - The AnimationSet to copy from.
+   * @param animationName - Name of the clip to copy.
+   * @param targetName - Name for the new clip in this set. Defaults to `animationName`.
+   * @param excludeJoint - Optional predicate; joints whose name returns true are excluded from
+   *   skeleton structure matching.
+   * @returns The newly created AnimationClip, or null on failure.
+   *
+   * @deprecated Use AnimationSet.copyHumanoidAnimationFrom instead.
    */ copyAnimationFrom(sourceSet, animationName, targetName, excludeJoint) {
         const destName = targetName ?? animationName;
         const sourceClip = sourceSet.get(animationName);
@@ -6897,8 +7610,8 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             return ordered;
         }
     }
-    /**
-   * Reset all skeleton modifiers
+    /**
+   * Reset all skeleton modifiers
    */ resetSkeletonModifiers() {
         for (const sk of this._skeletons){
             for (const modifier of sk.get().modifiers){
@@ -6906,12 +7619,12 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             }
         }
     }
-    /**
-   * Dispose the animation set and release owned resources.
-   *
-   * - Disposes the weak reference to the model.
-   * - Disposes all registered animation clips.
-   * - Clears active animations, tracks, and skeleton references.
+    /**
+   * Dispose the animation set and release owned resources.
+   *
+   * - Disposes the weak reference to the model.
+   * - Disposes all registered animation clips.
+   * - Clears active animations, tracks, and skeleton references.
    */ onDispose() {
         super.onDispose();
         for(const k in this._animations){
@@ -13718,9 +14431,13 @@ FEATURE_DISABLE_TAA = MeshMaterial.defineFeature();
                 pb.vec3('worldPos'),
                 pb.vec4('posRange')
             ], function() {
-                this.$l.dist = pb.distance(this.posRange.xyz, this.worldPos);
-                this.$l.falloff = pb.max(0, pb.sub(1, pb.div(this.dist, this.posRange.w)));
-                this.$return(pb.mul(this.falloff, this.falloff));
+                this.$l.d = pb.sub(this.worldPos, this.posRange.xyz);
+                this.$l.dist2 = pb.dot(this.d, this.d);
+                this.$l.lightAtten = pb.div(1, pb.max(this.dist2, 0.0001));
+                this.$l.range2 = pb.mul(this.posRange.w, this.posRange.w);
+                this.$l.f = pb.div(this.dist2, pb.max(this.range2, 0.0001));
+                this.$l.f2 = pb.clamp(pb.sub(1, pb.mul(this.f, this.f)), 0, 1);
+                this.$return(pb.mul(this.lightAtten, pb.mul(this.f2, this.f2)));
             });
             return pb.getGlobalScope()[funcName](worldPos, posRange);
         }
@@ -55763,7 +56480,7 @@ class HeightBoundingGenerator extends RenderMipmap {
                     name: 'FXAAEnabled',
                     type: 'bool',
                     phase: 0,
-                    default: true,
+                    default: false,
                     options: {
                         label: 'Enabled',
                         group: 'PostProcessing/FXAA'
@@ -81681,6 +82398,1474 @@ function dot(ax, ay, bx, by) {
     return ax * bx + ay * by;
 }
 
+/**
+ * Serializable animation timeline definition.
+ * @public
+ */ class AnimationTimeline {
+    /**
+   * Root step sequence executed by runners created from this timeline.
+   */ steps;
+    /**
+   * Event responses declared on this timeline.
+   */ responses;
+    /**
+   * Create a timeline from a definition object or a root step array.
+   *
+   * @param definition - Timeline definition, or a shorthand array used as the root steps.
+   */ constructor(definition){
+        if (Array.isArray(definition)) {
+            this.steps = definition;
+            this.responses = [];
+        } else {
+            this.steps = definition.steps;
+            this.responses = definition.responses ?? [];
+        }
+    }
+    /**
+   * Create a runtime runner for this timeline.
+   *
+   * @param animationSet - Animation set used to create and update playbacks.
+   * @returns A new stopped runner bound to this timeline and animation set.
+   */ createRunner(animationSet) {
+        return new AnimationTimelineRunner(animationSet, this);
+    }
+}
+/**
+ * Runtime interpreter for an AnimationTimeline.
+ *
+ * The interpreter is a synchronous frame-stack state machine advanced by {@link AnimationTimelineRunner.tick}, which is
+ * driven by `AnimationSet.update(dt)` on the same logical clock as the animations. There is no
+ * `async`/`await` in the control flow, so the runtime state can be serialized and replayed.
+ * @public
+ */ class AnimationTimelineRunner extends Observable {
+    /**
+   * Animation set used to start, stop, and query animation playbacks.
+   */ animationSet;
+    /**
+   * Timeline definition interpreted by this runner.
+   */ timeline;
+    _stack;
+    _concurrent;
+    _queued;
+    _pendingEvents;
+    _stopped;
+    _ticking;
+    _lastCompletedPlaybackId;
+    _onTick;
+    /** Tracks playbacks created by this runner so `stop()` can tear them down. */ _ownedPlaybacks;
+    /** Local playback refs that survive after the sequence frame that declared them drains. */ _playbackRefs;
+    /** Ids of playbacks owned by concurrent (keep-active) branches; preserved across main-flow stops. */ _concurrentPlaybackIds;
+    /** Marker/frame crossings observed since the last tick, keyed by playback id. */ _crossedMarkers;
+    _crossedFrames;
+    /**
+   * Create a stopped runner for a timeline.
+   *
+   * @param animationSet - Animation set that owns clips and playbacks referenced by the timeline.
+   * @param timeline - Timeline definition to interpret.
+   */ constructor(animationSet, timeline){
+        super();
+        this.animationSet = animationSet;
+        this.timeline = timeline;
+        this._stack = [];
+        this._concurrent = [];
+        this._queued = [];
+        this._pendingEvents = [];
+        this._stopped = true;
+        this._ticking = false;
+        this._lastCompletedPlaybackId = null;
+        this._onTick = (deltaInSeconds)=>this.tick(deltaInSeconds);
+        this._ownedPlaybacks = new Map();
+        this._playbackRefs = new Map();
+        this._concurrentPlaybackIds = new Set();
+        this._crossedMarkers = new Map();
+        this._crossedFrames = new Map();
+    }
+    /**
+   * Playback currently referenced by the active main-flow scope.
+   *
+   * @returns The current playback, or null when the main flow has no active playback reference.
+   */ get currentPlayback() {
+        const scope = this.activeScope();
+        if (!scope?.currentPlaybackId) {
+            return null;
+        }
+        return this._ownedPlaybacks.get(scope.currentPlaybackId) ?? null;
+    }
+    /**
+   * Whether this runner is stopped.
+   *
+   * @returns True when the runner is stopped; otherwise false.
+   */ get stopped() {
+        return this._stopped;
+    }
+    /**
+   * Playback id for the most recent playback that completed naturally.
+   *
+   * @returns The playback id, or null when no owned playback has completed.
+   */ get lastCompletedPlaybackId() {
+        return this._lastCompletedPlaybackId;
+    }
+    /**
+   * Start or restart the runner from the beginning of the timeline.
+   *
+   * @returns This runner for chaining.
+   */ start() {
+        this._stopped = false;
+        this._stack = [
+            this.makeSeqFrame(this.timeline.steps)
+        ];
+        this._concurrent = [];
+        this._queued.length = 0;
+        this._pendingEvents = [];
+        this._lastCompletedPlaybackId = null;
+        this._playbackRefs.clear();
+        this.animationSet._registerTimelineTicker(this._onTick);
+        // Drain any leading non-blocking steps immediately so e.g. an initial `play` starts now.
+        this.flush();
+        return this;
+    }
+    /**
+   * Stop the runner and all playbacks it owns.
+   *
+   * @param options - Optional stop behavior applied to owned playbacks.
+   * @returns This runner for chaining.
+   */ stop(options) {
+        const wasStopped = this._stopped;
+        this._stopped = true;
+        this._stack = [];
+        this._concurrent = [];
+        this._queued.length = 0;
+        this._pendingEvents = [];
+        this._crossedMarkers.clear();
+        this._crossedFrames.clear();
+        this._lastCompletedPlaybackId = null;
+        const stopOptions = options ?? {
+            reason: 'interrupted'
+        };
+        // Always tear down owned playbacks, even if the control flow already drained: a state whose
+        // script finished may still have a looping clip playing that a transition must stop.
+        this._ownedPlaybacks.forEach((playback)=>{
+            this.detachPlayback(playback);
+            playback.stop(stopOptions);
+        });
+        this._ownedPlaybacks.clear();
+        this._playbackRefs.clear();
+        this._concurrentPlaybackIds.clear();
+        this.animationSet._unregisterTimelineTicker(this._onTick);
+        if (!wasStopped) {
+            this.dispatchEvent('stop', this);
+        }
+        return this;
+    }
+    /**
+   * Append a batch of steps to run after the main stack drains.
+   *
+   * If the runner has already completed, enqueueing steps revives it and registers it for ticking.
+   *
+   * @param steps - Steps to run as the next queued batch.
+   * @returns void
+   */ enqueue(steps) {
+        if (steps.length === 0) {
+            return;
+        }
+        this._queued.push(steps);
+        // Revive a runner that already drained so queued steps are not silently dropped.
+        if (this._stopped) {
+            this._stopped = false;
+            this._stack = [];
+            this.animationSet._registerTimelineTicker(this._onTick);
+        }
+        this.flush();
+    }
+    /**
+   * Run `steps` concurrently with the current control flow (a true parallel branch). Unlike
+   * {@link AnimationTimelineRunner.enqueue}, these do not wait for the main stack to drain.
+   *
+   * @param steps - Steps to run immediately in an independent concurrent branch.
+   * @returns void
+   * @public
+   */ runConcurrent(steps) {
+        if (steps.length === 0) {
+            return;
+        }
+        this._concurrent.push(this.makeSeqFrame(steps, 'concurrent'));
+        if (this._stopped) {
+            this._stopped = false;
+            this.animationSet._registerTimelineTicker(this._onTick);
+        } else {
+            this.ensureTicking();
+        }
+        this.flush();
+    }
+    /**
+   * Dispatch an event to this runner.
+   *
+   * Waiting `waitEvent` frames consume matching events first. If no waiter consumes the event,
+   * the timeline response table is evaluated.
+   *
+   * @param event - Event name to dispatch.
+   * @param payload - Optional payload returned in the result.
+   * @returns The resolved handling result for the event.
+   */ dispatch(event, payload) {
+        // A waiting `waitEvent` frame consumes the event; flush advances past it synchronously.
+        if (this.hasWaiterFor(event)) {
+            this._pendingEvents.push(event);
+            this.flush();
+            return {
+                handled: true,
+                policy: 'consume',
+                event,
+                payload
+            };
+        }
+        const response = this.timeline.responses.find((item)=>item.event === event);
+        if (!response || response.target.ignore) {
+            return {
+                handled: false,
+                policy: response ? 'ignore' : 'none',
+                event,
+                payload
+            };
+        }
+        if (response.target.consume) {
+            return {
+                handled: true,
+                policy: 'consume',
+                event,
+                payload
+            };
+        }
+        if (response.target.targetState !== undefined) {
+            // Only the controller can switch states; bubble up so it can act on its own table.
+            return {
+                handled: false,
+                policy: 'transition',
+                event,
+                payload
+            };
+        }
+        const steps = response.target.steps;
+        if (!steps?.length) {
+            return {
+                handled: false,
+                policy: 'none',
+                event,
+                payload
+            };
+        }
+        if (response.enqueue) {
+            this.enqueue(steps);
+            return {
+                handled: true,
+                policy: 'enqueue',
+                event,
+                payload
+            };
+        }
+        const disposition = response.onActive ?? 'stop';
+        if (disposition === 'keep') {
+            // Run the new steps concurrently with the existing control flow (true parallel branch).
+            this.runConcurrent(steps);
+        } else {
+            const stopOptions = typeof disposition === 'object' ? {
+                ...disposition,
+                reason: 'interrupted'
+            } : undefined;
+            this.stopMainFlow(stopOptions);
+            this._stopped = false;
+            this._stack = [
+                this.makeSeqFrame(steps)
+            ];
+            this.ensureTicking();
+            this.flush();
+        }
+        return {
+            handled: true,
+            policy: 'steps',
+            event,
+            payload
+        };
+    }
+    /**
+   * Run pending non-blocking work synchronously (a zero-delta tick), without advancing any
+   * time-based waits. Lets `start()`/`dispatch()` take effect immediately while keeping all
+   * runtime state in the serializable frame stack.
+   *
+   * @returns This runner for chaining.
+   * @public
+   */ flush() {
+        // Guard against re-entrancy: an `emit` listener firing during a tick may dispatch again.
+        if (!this._ticking) {
+            this.tick(0);
+        }
+        return this;
+    }
+    /**
+   * Advance the timeline by `deltaInSeconds`. Called by `AnimationSet.update`.
+   *
+   * @param deltaInSeconds - Elapsed time in seconds for this tick.
+   * @returns void
+   * @public
+   */ tick(deltaInSeconds) {
+        if (this._stopped && this._queued.length === 0) {
+            return;
+        }
+        this._ticking = true;
+        // Advance the main control-flow stack.
+        if (this._stack.length === 0 && this._queued.length > 0) {
+            const next = this._queued.shift();
+            this._stack = [
+                this.makeSeqFrame(next)
+            ];
+        }
+        if (this._stack.length > 0) {
+            this.tickFrames(this._stack, deltaInSeconds);
+        }
+        // Advance any concurrent (keep-active) branches; drop the ones that finished.
+        if (this._concurrent.length > 0) {
+            this._concurrent = this._concurrent.filter((frame)=>{
+                const stack = [
+                    frame
+                ];
+                this.tickFrames(stack, deltaInSeconds);
+                return stack.length > 0;
+            });
+        }
+        // Consumed this tick.
+        this._pendingEvents = [];
+        this._crossedMarkers.clear();
+        this._crossedFrames.clear();
+        this._ticking = false;
+        // Pull queued batches once the stack drains.
+        while(this._stack.length === 0 && this._queued.length > 0){
+            const next = this._queued.shift();
+            this._stack = [
+                this.makeSeqFrame(next)
+            ];
+            this.tickFrames(this._stack, 0);
+        }
+        if (!this._stopped && this._stack.length === 0 && this._concurrent.length === 0 && this._queued.length === 0) {
+            this._stopped = true;
+            this.animationSet._unregisterTimelineTicker(this._onTick);
+            this.dispatchEvent('complete', this);
+        }
+    }
+    /**
+   * Export the runtime state as plain data.
+   *
+   * @returns A serializable snapshot of the runner state.
+   * @public
+   */ serialize() {
+        return {
+            stack: this._stack.map((frame)=>this.cloneFrame(frame)),
+            concurrent: this._concurrent.map((frame)=>this.cloneFrame(frame)),
+            queued: this._queued.map((steps)=>steps.slice()),
+            concurrentPlaybackIds: [
+                ...this._concurrentPlaybackIds
+            ],
+            playbackRefs: Object.fromEntries(this._playbackRefs),
+            stopped: this._stopped
+        };
+    }
+    /**
+   * Restore runtime state previously produced by {@link AnimationTimelineRunner.serialize}.
+   *
+   * Re-create the relevant active playbacks on the AnimationSet before calling this so that
+   * playback-bound frames (play-wait, waitMarker, waitFrame) can re-attach by id.
+   *
+   * @param animationSet - Animation set containing any live playbacks referenced by the state.
+   * @param timeline - Timeline definition to bind to the restored runner.
+   * @param state - Serialized state previously returned by {@link AnimationTimelineRunner.serialize}.
+   * @returns A runner restored to the supplied runtime state.
+   * @public
+   */ static deserialize(animationSet, timeline, state) {
+        const runner = new AnimationTimelineRunner(animationSet, timeline);
+        runner._stack = state.stack.map((frame)=>runner.cloneFrame(frame));
+        runner._concurrent = state.concurrent.map((frame)=>runner.cloneFrame(frame));
+        state.queued.forEach((steps)=>runner._queued.push(steps.slice()));
+        state.concurrentPlaybackIds?.forEach((id)=>runner._concurrentPlaybackIds.add(id));
+        Object.entries(state.playbackRefs ?? {}).forEach(([ref, id])=>runner._playbackRefs.set(ref, id));
+        runner._stopped = state.stopped;
+        // Re-attach to any live playbacks referenced by the restored frames.
+        runner.reattachPlaybacks(runner._stack);
+        runner._concurrent.forEach((frame)=>runner.reattachPlaybacks([
+                frame
+            ]));
+        // Re-attach drained concurrent playbacks tracked only by id, so they survive future stops.
+        runner._concurrentPlaybackIds.forEach((id)=>{
+            if (!runner._ownedPlaybacks.has(id)) {
+                const playback = runner.findLivePlayback(id);
+                if (playback) {
+                    runner.attachPlayback(playback);
+                }
+            }
+        });
+        runner._playbackRefs.forEach((id)=>{
+            if (!runner._ownedPlaybacks.has(id)) {
+                const playback = runner.findLivePlayback(id);
+                if (playback) {
+                    runner.attachPlayback(playback);
+                }
+            }
+        });
+        if (!runner._stopped) {
+            animationSet._registerTimelineTicker(runner._onTick);
+        }
+        return runner;
+    }
+    // --- internals -------------------------------------------------------------
+    ensureTicking() {
+        if (!this._ticking) {
+            this.animationSet._registerTimelineTicker(this._onTick);
+        }
+    }
+    makeSeqFrame(steps, owner = 'main') {
+        return {
+            kind: 'seq',
+            steps,
+            index: 0,
+            scope: {
+                currentPlaybackId: null,
+                refs: {},
+                owner
+            },
+            child: null
+        };
+    }
+    /** The scope of the innermost active sequence on the main stack (for currentPlayback). */ activeScope() {
+        for(let i = this._stack.length - 1; i >= 0; i--){
+            const scope = this.deepestScope(this._stack[i]);
+            if (scope) {
+                return scope;
+            }
+        }
+        return null;
+    }
+    deepestScope(frame) {
+        if (frame.kind === 'seq') {
+            return frame.child ? this.deepestScope(frame.child) ?? frame.scope : frame.scope;
+        }
+        return null;
+    }
+    /**
+   * Advance a frame stack in place. The top frame runs until it blocks or completes; completed
+   * frames pop and the parent sequence advances. Returns when the stack blocks or empties.
+   */ tickFrames(stack, deltaInSeconds) {
+        this.tickFramesWithLeftover(stack, deltaInSeconds);
+    }
+    /**
+   * Same as {@link AnimationTimelineRunner.tickFrames} but returns the time left unconsumed when the stack drains
+   * completely (so a parent sequence can hand it to its next step).
+   */ tickFramesWithLeftover(stack, deltaInSeconds) {
+        let guard = 0;
+        while(stack.length > 0){
+            if (++guard > 10000) {
+                break;
+            }
+            const frame = stack[stack.length - 1];
+            const result = this.tickFrame(frame, stack, deltaInSeconds);
+            if (result.status === 'block') {
+                return 0;
+            }
+            if (result.status === 'pop') {
+                stack.pop();
+                // Carry any unused time (e.g. a `wait` that overshot its duration this tick) to the next
+                // step so a sequence of waits/actions tracks logical time regardless of frame rate.
+                deltaInSeconds = result.leftover ?? 0;
+                continue;
+            }
+            // 'advanced': the frame pushed a child or moved its cursor; loop again with delta 0 so a
+            // single tick can drain consecutive non-blocking steps.
+            deltaInSeconds = 0;
+        }
+        return deltaInSeconds;
+    }
+    tickFrame(frame, stack, deltaInSeconds) {
+        switch(frame.kind){
+            case 'seq':
+                return this.tickSeq(frame, stack, deltaInSeconds);
+            case 'parallel':
+                return this.tickParallel(frame, deltaInSeconds);
+            case 'wait':
+                frame.remaining -= deltaInSeconds;
+                // On completion, hand back the overshoot (negative remaining) as leftover time.
+                return frame.remaining <= 0 ? {
+                    status: 'pop',
+                    leftover: -frame.remaining
+                } : {
+                    status: 'block'
+                };
+            case 'waitEvent':
+                return this._pendingEvents.includes(frame.event) ? {
+                    status: 'pop'
+                } : {
+                    status: 'block'
+                };
+            case 'waitMarker':
+                return this.tickWaitMarker(frame);
+            case 'waitFrame':
+                return this.tickWaitFrame(frame);
+            case 'playWait':
+                return this.tickPlayWait(frame);
+        }
+    }
+    tickSeq(frame, _stack, deltaInSeconds) {
+        // Drain steps in a loop so unconsumed time (e.g. a `wait` that overshot) flows into the next
+        // step within the same tick instead of being dropped.
+        let guard = 0;
+        for(;;){
+            if (++guard > 10000) {
+                return {
+                    status: 'block'
+                };
+            }
+            if (frame.child) {
+                const childStack = [
+                    frame.child
+                ];
+                const leftover = this.tickFramesWithLeftover(childStack, deltaInSeconds);
+                if (childStack.length > 0) {
+                    return {
+                        status: 'block'
+                    };
+                }
+                frame.child = null;
+                frame.index++;
+                deltaInSeconds = leftover;
+            }
+            if (frame.index >= frame.steps.length) {
+                return {
+                    status: 'pop',
+                    leftover: deltaInSeconds
+                };
+            }
+            const step = frame.steps[frame.index];
+            const blocking = this.beginStep(step, frame);
+            if (blocking) {
+                // Tick the freshly-pushed child immediately with the carried time on the next loop turn.
+                frame.child = blocking;
+                continue;
+            }
+            frame.index++;
+        // A non-blocking step consumes no time; keep the remaining delta for the following step.
+        }
+    }
+    tickParallel(frame, deltaInSeconds) {
+        frame.branches = frame.branches.filter((branch)=>{
+            const branchStack = [
+                branch
+            ];
+            this.tickFrames(branchStack, deltaInSeconds);
+            return branchStack.length > 0;
+        });
+        // Parallel branches may finish at different times; we do not attempt to reconcile a single
+        // leftover across them, so the join simply consumes the whole tick.
+        return frame.branches.length > 0 ? {
+            status: 'block'
+        } : {
+            status: 'pop'
+        };
+    }
+    /**
+   * Execute a non-blocking step immediately and return null, or return a frame to block on.
+   */ beginStep(step, scopeFrame) {
+        const scope = scopeFrame.scope;
+        switch(step.type){
+            case 'sequence':
+                {
+                    const child = this.makeSeqFrame(step.steps);
+                    // Inherit the parent scope so refs/currentPlayback carry into the nested sequence.
+                    child.scope = scope;
+                    return child;
+                }
+            case 'parallel':
+                {
+                    // Each branch gets an isolated scope so currentPlayback/refs don't race (#7), but inherits
+                    // the parent's owner so concurrent branches stay concurrent through nested parallels.
+                    const branches = step.steps.map((child)=>{
+                        const branchScope = {
+                            currentPlaybackId: scope.currentPlaybackId,
+                            refs: {
+                                ...scope.refs
+                            },
+                            owner: scope.owner
+                        };
+                        const seq = this.makeSeqFrame([
+                            child
+                        ]);
+                        seq.scope = branchScope;
+                        return seq;
+                    });
+                    return {
+                        kind: 'parallel',
+                        branches
+                    };
+                }
+            case 'play':
+                {
+                    const playback = this.animationSet.play(step.clip, this.resolvePlayOptions(step.options, scope));
+                    if (!playback) {
+                        return null;
+                    }
+                    this.attachPlayback(playback);
+                    if (scope.owner === 'concurrent') {
+                        // Remember concurrent ownership independently of the frames: a non-blocking keep-active
+                        // play drains out of `_concurrent` immediately, but its playback must still survive a
+                        // later main-flow replacement (#2).
+                        this._concurrentPlaybackIds.add(playback.id);
+                    }
+                    scope.currentPlaybackId = playback.id;
+                    if (step.id) {
+                        scope.refs[step.id] = playback.id;
+                        this._playbackRefs.set(step.id, playback.id);
+                    }
+                    scope.refs[playback.id] = playback.id;
+                    this._playbackRefs.set(playback.id, playback.id);
+                    if (step.wait === 'complete') {
+                        return {
+                            kind: 'playWait',
+                            playbackId: playback.id
+                        };
+                    }
+                    return null;
+                }
+            case 'stop':
+                {
+                    const playback = this.resolvePlayback(step.target, scope);
+                    if (playback) {
+                        playback.stop(step.options);
+                    } else if (!step.target) {
+                        this._ownedPlaybacks.forEach((item)=>item.stop(step.options));
+                    }
+                    return null;
+                }
+            case 'wait':
+                return step.seconds > 0 ? {
+                    kind: 'wait',
+                    remaining: step.seconds
+                } : null;
+            case 'waitEvent':
+                return {
+                    kind: 'waitEvent',
+                    event: step.event
+                };
+            case 'waitMarker':
+                {
+                    const playback = this.resolvePlayback(step.target, scope) ?? this.scopeCurrentPlayback(scope);
+                    if (!playback) {
+                        return null;
+                    }
+                    return {
+                        kind: 'waitMarker',
+                        marker: step.marker,
+                        playbackId: playback.id,
+                        satisfied: false
+                    };
+                }
+            case 'waitFrame':
+                {
+                    const playback = this.resolvePlayback(step.target, scope) ?? this.scopeCurrentPlayback(scope);
+                    if (!playback) {
+                        return null;
+                    }
+                    return {
+                        kind: 'waitFrame',
+                        frame: step.frame,
+                        playbackId: playback.id,
+                        satisfied: false
+                    };
+                }
+            case 'emit':
+                this.dispatchEvent('emit', step.event, step.payload);
+                return null;
+        }
+    }
+    resolvePlayOptions(options, scope) {
+        const target = options?.sync?.target;
+        if (!target) {
+            return options;
+        }
+        const mapped = this.resolvePlaybackRef(target, scope);
+        if (!mapped) {
+            return options;
+        }
+        return {
+            ...options,
+            sync: {
+                ...options.sync,
+                target: mapped
+            }
+        };
+    }
+    resolvePlaybackRef(target, scope) {
+        return scope.refs[target] ?? this._playbackRefs.get(target) ?? null;
+    }
+    tickWaitMarker(frame) {
+        if (frame.satisfied || !frame.playbackId) {
+            return {
+                status: 'pop'
+            };
+        }
+        const playback = this._ownedPlaybacks.get(frame.playbackId);
+        if (!playback || playback.state === 'stopped' || playback.state === 'completed') {
+            return {
+                status: 'pop'
+            };
+        }
+        const crossed = this._crossedMarkers.get(frame.playbackId);
+        if (crossed && crossed.has(frame.marker)) {
+            return {
+                status: 'pop'
+            };
+        }
+        return {
+            status: 'block'
+        };
+    }
+    tickWaitFrame(frame) {
+        if (frame.satisfied || frame.playbackId === null) {
+            return {
+                status: 'pop'
+            };
+        }
+        const playback = this._ownedPlaybacks.get(frame.playbackId);
+        if (!playback || playback.state === 'stopped' || playback.state === 'completed') {
+            return {
+                status: 'pop'
+            };
+        }
+        const crossed = this._crossedFrames.get(frame.playbackId);
+        if (crossed && crossed.has(frame.frame)) {
+            return {
+                status: 'pop'
+            };
+        }
+        return {
+            status: 'block'
+        };
+    }
+    tickPlayWait(frame) {
+        const playback = this._ownedPlaybacks.get(frame.playbackId);
+        if (!playback || playback.state === 'stopped' || playback.state === 'completed') {
+            return {
+                status: 'pop'
+            };
+        }
+        return {
+            status: 'block'
+        };
+    }
+    attachPlayback(playback) {
+        this._ownedPlaybacks.set(playback.id, playback);
+        playback.on('marker', this.onPlaybackMarker);
+        playback.on('frame', this.onPlaybackFrame);
+        playback.on('stop', this.onPlaybackEnd);
+        playback.on('complete', this.onPlaybackComplete);
+    }
+    detachPlayback(playback) {
+        playback.off('marker', this.onPlaybackMarker);
+        playback.off('frame', this.onPlaybackFrame);
+        playback.off('stop', this.onPlaybackEnd);
+        playback.off('complete', this.onPlaybackComplete);
+    }
+    forgetPlayback(playback) {
+        this.detachPlayback(playback);
+        this._ownedPlaybacks.delete(playback.id);
+        this._concurrentPlaybackIds.delete(playback.id);
+        this.forgetPlaybackRefs(playback.id);
+    }
+    /**
+   * Cleanup when an owned playback ends (externally or naturally). Only touches runner-local
+   * bookkeeping, so it is safe to run inside `AnimationSet.update`'s playback loop. Frames blocked
+   * on this playback observe its absence on the next tick and unblock.
+   */ onPlaybackEnd = (event)=>{
+        const playback = this._ownedPlaybacks.get(event.playback.id);
+        if (playback) {
+            this.forgetPlayback(playback);
+        }
+    };
+    onPlaybackComplete = (event)=>{
+        this._lastCompletedPlaybackId = event.playback.id;
+        const playback = this._ownedPlaybacks.get(event.playback.id);
+        if (playback) {
+            this.forgetPlayback(playback);
+        }
+    };
+    onPlaybackMarker = (event)=>{
+        const id = event.playback.id;
+        let set = this._crossedMarkers.get(id);
+        if (!set) {
+            set = new Set();
+            this._crossedMarkers.set(id, set);
+        }
+        if (event.marker.id !== undefined) {
+            set.add(event.marker.id);
+        }
+        set.add(event.marker.name);
+    };
+    onPlaybackFrame = (event)=>{
+        const id = event.playback.id;
+        let set = this._crossedFrames.get(id);
+        if (!set) {
+            set = new Set();
+            this._crossedFrames.set(id, set);
+        }
+        set.add(event.frame);
+    };
+    resolvePlayback(target, scope) {
+        if (!target) {
+            return null;
+        }
+        const mapped = this.resolvePlaybackRef(target, scope);
+        if (mapped) {
+            const owned = this._ownedPlaybacks.get(mapped);
+            if (owned) {
+                return owned;
+            }
+        }
+        return this._ownedPlaybacks.get(target) ?? this.animationSet.getPlayback(target);
+    }
+    forgetPlaybackRefs(playbackId) {
+        [
+            ...this._playbackRefs.entries()
+        ].forEach(([ref, id])=>{
+            if (id === playbackId) {
+                this._playbackRefs.delete(ref);
+            }
+        });
+    }
+    scopeCurrentPlayback(scope) {
+        return scope.currentPlaybackId ? this._ownedPlaybacks.get(scope.currentPlaybackId) ?? null : null;
+    }
+    hasWaiterFor(event) {
+        const inFrame = (frame)=>{
+            switch(frame.kind){
+                case 'waitEvent':
+                    return frame.event === event;
+                case 'seq':
+                    return frame.child ? inFrame(frame.child) : false;
+                case 'parallel':
+                    return frame.branches.some(inFrame);
+                default:
+                    return false;
+            }
+        };
+        return this._stack.some(inFrame) || this._concurrent.some(inFrame);
+    }
+    /** Stop only the main control flow (used when a response replaces it). */ stopMainFlow(options) {
+        const stopOptions = options ?? {
+            reason: 'interrupted'
+        };
+        // Stop every playback owned by the main flow, not just those still referenced by `_stack`:
+        // a sequence that already drained may have left a looping clip playing (e.g. `play idle` with
+        // `repeat: 0`), and replacing the main flow must stop it. Playbacks owned by concurrent
+        // (keep-active) branches are independent parallel tracks and are preserved — tracked by id so
+        // they survive even after their branch frames drained.
+        this._ownedPlaybacks.forEach((playback, id)=>{
+            if (this._concurrentPlaybackIds.has(id)) {
+                return;
+            }
+            this.detachPlayback(playback);
+            playback.stop(stopOptions);
+            this._ownedPlaybacks.delete(id);
+            this.forgetPlaybackRefs(id);
+        });
+        this._stack = [];
+    }
+    collectScopePlaybackIds(frames) {
+        const ids = new Set();
+        const visit = (frame)=>{
+            if (frame.kind === 'seq') {
+                Object.values(frame.scope.refs).forEach((id)=>ids.add(id));
+                if (frame.scope.currentPlaybackId) {
+                    ids.add(frame.scope.currentPlaybackId);
+                }
+                if (frame.child) {
+                    visit(frame.child);
+                }
+            } else if (frame.kind === 'parallel') {
+                frame.branches.forEach(visit);
+            }
+        };
+        frames.forEach(visit);
+        return ids;
+    }
+    cloneFrame(frame) {
+        switch(frame.kind){
+            case 'seq':
+                return {
+                    kind: 'seq',
+                    steps: frame.steps,
+                    index: frame.index,
+                    scope: {
+                        currentPlaybackId: frame.scope.currentPlaybackId,
+                        refs: {
+                            ...frame.scope.refs
+                        },
+                        owner: frame.scope.owner
+                    },
+                    child: frame.child ? this.cloneFrame(frame.child) : null
+                };
+            case 'parallel':
+                return {
+                    kind: 'parallel',
+                    branches: frame.branches.map((b)=>this.cloneFrame(b))
+                };
+            case 'wait':
+                return {
+                    kind: 'wait',
+                    remaining: frame.remaining
+                };
+            case 'waitEvent':
+                return {
+                    kind: 'waitEvent',
+                    event: frame.event
+                };
+            case 'waitMarker':
+                return {
+                    ...frame
+                };
+            case 'waitFrame':
+                return {
+                    ...frame
+                };
+            case 'playWait':
+                return {
+                    ...frame
+                };
+        }
+    }
+    reattachPlaybacks(frames) {
+        const ids = this.collectAllPlaybackIds(frames);
+        ids.forEach((id)=>{
+            if (this._ownedPlaybacks.has(id)) {
+                return;
+            }
+            const playback = this.findLivePlayback(id);
+            if (playback) {
+                this.attachPlayback(playback);
+            }
+        });
+    }
+    collectAllPlaybackIds(frames) {
+        const ids = this.collectScopePlaybackIds(frames);
+        const visit = (frame)=>{
+            if (frame.kind === 'playWait') {
+                ids.add(frame.playbackId);
+            } else if ((frame.kind === 'waitMarker' || frame.kind === 'waitFrame') && frame.playbackId) {
+                ids.add(frame.playbackId);
+            } else if (frame.kind === 'seq' && frame.child) {
+                visit(frame.child);
+            } else if (frame.kind === 'parallel') {
+                frame.branches.forEach(visit);
+            }
+        };
+        frames.forEach(visit);
+        return ids;
+    }
+    findLivePlayback(id) {
+        return this.animationSet.getPlaybacks().find((playback)=>playback.id === id) ?? null;
+    }
+}
+
+/**
+ * Event-driven animation state controller.
+ *
+ * Each state owns one serializable timeline. External gameplay events are dispatched to the
+ * current timeline first, then to the current state's response table, so different states can
+ * respond to the same event differently.
+ * @public
+ */ class AnimationController extends Observable {
+    /**
+   * Animation set used to create playbacks for all state timelines.
+   */ animationSet;
+    _states;
+    _currentState;
+    _runner;
+    _onRunnerComplete;
+    _onRunnerEmit;
+    /**
+   * Create a controller for an animation set.
+   *
+   * @param animationSet - Animation set that owns the clips and active playbacks.
+   */ constructor(animationSet){
+        super();
+        this.animationSet = animationSet;
+        this._states = new Map();
+        this._currentState = null;
+        this._runner = null;
+        this._onRunnerComplete = null;
+        this._onRunnerEmit = null;
+    }
+    /**
+   * Current state name.
+   *
+   * @returns The active state name, or null when the controller is stopped or has not entered a state.
+   */ get currentState() {
+        return this._currentState;
+    }
+    /**
+   * Current timeline runner.
+   *
+   * @returns The active timeline runner, or null when no state is running.
+   */ get runner() {
+        return this._runner;
+    }
+    /**
+   * Register or replace a named state definition.
+   *
+   * @param name - Unique state name.
+   * @param definition - Timeline and event response configuration for the state.
+   * @returns This controller for chaining.
+   */ addState(name, definition) {
+        if (this._states.has(name)) {
+            console.warn(`AnimationController state ${name} already exists; overwriting`);
+        }
+        this._states.set(name, definition);
+        return this;
+    }
+    /**
+   * Test whether a state has been registered.
+   *
+   * @param name - State name to look up.
+   * @returns True if the controller contains a state with the given name; otherwise false.
+   */ hasState(name) {
+        return this._states.has(name);
+    }
+    /**
+   * Enter a registered state.
+   *
+   * If the requested state is already current and `options.force` is not set, this returns the
+   * existing runner without restarting the timeline. When a transition duration is provided, the
+   * previous runner fades out while the entry plays of the new state fade in.
+   *
+   * @param name - State name to enter.
+   * @param options - Optional transition, re-entry, and stop behavior.
+   * @returns The active runner for the entered state, or null if the state does not exist.
+   */ setState(name, options) {
+        const definition = this._states.get(name);
+        if (!definition) {
+            console.error(`AnimationController state ${name} not exists`);
+            return null;
+        }
+        if (!options?.force && this._currentState === name) {
+            return this._runner;
+        }
+        const previousState = this._currentState;
+        const transition = Math.max(options?.transition ?? definition.transition ?? 0, 0);
+        const returnTarget = this.resolveReturnTarget(options?.returnTo, previousState, options?.returnTransition);
+        this.detachRunner();
+        if (transition > 0) {
+            this._runner?.stop({
+                fadeOut: transition,
+                reason: 'interrupted'
+            });
+        } else {
+            this._runner?.stop(options?.stop ?? {
+                reason: 'interrupted'
+            });
+        }
+        const timeline = new AnimationTimeline(prepareTimelineForTransition(definition.timeline, transition, returnTarget?.transition, options?.sync));
+        this._runner = timeline.createRunner(this.animationSet);
+        const runner = this._runner;
+        this.attachRunner(runner, name, returnTarget);
+        // Enter the new state *before* starting the runner: start() flushes synchronously, so any
+        // initial `emit`/`statecomplete` must observe the controller already in `name`. Otherwise a
+        // listener calling dispatch() would route against the previous state.
+        this._currentState = name;
+        this.dispatchEvent('statechange', name, previousState);
+        // The statechange listener may have re-entered (stop() or another setState()), swapping out or
+        // clearing `_runner`. Only start the runner we created if it is still the active one.
+        if (this._runner === runner && this._currentState === name) {
+            runner.start();
+        }
+        // If a reentrant listener superseded us, `_runner` is the now-active runner (or null after a
+        // reentrant stop()); return that rather than a runner we never started.
+        return this._runner;
+    }
+    /**
+   * Dispatch a gameplay event to the active state.
+   *
+   * The active timeline receives the event first. If it does not handle the event, the current
+   * state's response table may consume it, enqueue or run steps, or transition to another state.
+   *
+   * @param event - Event name to dispatch.
+   * @param payload - Optional event payload passed through result notifications.
+   * @returns The resolved handling result for the event.
+   */ dispatch(event, payload) {
+        if (!this._currentState || !this._runner) {
+            return this.emitResult({
+                handled: false,
+                policy: 'none',
+                event,
+                payload
+            });
+        }
+        const timelineResult = this._runner.dispatch(event, payload);
+        if (timelineResult.handled) {
+            return this.emitResult(timelineResult);
+        }
+        const response = this._states.get(this._currentState)?.responses?.find((item)=>item.event === event);
+        if (!response || response.target.ignore) {
+            return this.emitResult({
+                handled: false,
+                policy: response ? 'ignore' : 'none',
+                event,
+                payload
+            });
+        }
+        if (response.target.consume) {
+            return this.emitResult({
+                handled: true,
+                policy: 'consume',
+                event,
+                payload
+            });
+        }
+        if (response.target.targetState !== undefined) {
+            const transition = typeof response.onActive === 'object' ? response.onActive.fadeOut : undefined;
+            const runner = this.setState(response.target.targetState, {
+                transition,
+                returnTo: response.target.returnTo,
+                returnTransition: response.target.returnTransition
+            });
+            // setState returns null when the target state is not registered: a config error must not be
+            // reported as a successfully handled transition.
+            if (!runner) {
+                return this.emitResult({
+                    handled: false,
+                    policy: 'transition',
+                    event,
+                    payload
+                });
+            }
+            return this.emitResult({
+                handled: true,
+                policy: 'transition',
+                event,
+                payload
+            });
+        }
+        const steps = response.target.steps;
+        if (!steps?.length) {
+            return this.emitResult({
+                handled: false,
+                policy: 'none',
+                event,
+                payload
+            });
+        }
+        if (response.enqueue) {
+            this._runner.enqueue(steps);
+            return this.emitResult({
+                handled: true,
+                policy: 'enqueue',
+                event,
+                payload
+            });
+        }
+        const disposition = response.onActive ?? 'stop';
+        if (disposition === 'keep') {
+            this._runner.runConcurrent(steps);
+        } else {
+            const stopOptions = typeof disposition === 'object' ? {
+                ...disposition,
+                reason: 'interrupted'
+            } : undefined;
+            this.detachRunner();
+            this._runner.stop(stopOptions);
+            this._runner = new AnimationTimeline(steps).createRunner(this.animationSet);
+            this.attachRunner(this._runner, this._currentState);
+            this._runner.start();
+        }
+        return this.emitResult({
+            handled: true,
+            policy: 'steps',
+            event,
+            payload
+        });
+    }
+    /**
+   * Stop the active state and clear the current state.
+   *
+   * @param options - Optional stop behavior applied to playbacks owned by the active runner.
+   * @returns void
+   */ stop(options) {
+        const previousState = this._currentState;
+        this.detachRunner();
+        this._runner?.stop(options);
+        this._runner = null;
+        this._currentState = null;
+        if (previousState !== null) {
+            this.dispatchEvent('statechange', null, previousState);
+        }
+    }
+    /**
+   * Stop playback and remove all registered states.
+   *
+   * @returns void
+   */ dispose() {
+        this.stop();
+        this._states.clear();
+    }
+    emitResult(result) {
+        this.dispatchEvent('event', result.event, result.payload, result);
+        return result;
+    }
+    resolveReturnTarget(returnTo, previousState, returnTransition) {
+        if (returnTo === undefined) {
+            return null;
+        }
+        const state = returnTo === true ? previousState : returnTo;
+        if (!state) {
+            return null;
+        }
+        const definition = this._states.get(state);
+        if (!definition) {
+            console.error(`AnimationController return state ${state} not exists`);
+            return null;
+        }
+        return {
+            state,
+            transition: returnTransition ?? definition.transition
+        };
+    }
+    attachRunner(runner, state, returnTarget) {
+        this._onRunnerComplete = ()=>{
+            this.dispatchEvent('statecomplete', state);
+            if (returnTarget && this._runner === runner && this._currentState === state) {
+                const sync = returnTarget.transition && runner.lastCompletedPlaybackId ? {
+                    target: runner.lastCompletedPlaybackId,
+                    mode: 'normalized'
+                } : undefined;
+                this.setState(returnTarget.state, {
+                    transition: returnTarget.transition,
+                    sync
+                });
+            }
+        };
+        this._onRunnerEmit = (event, payload)=>{
+            this.dispatchEvent('emit', event, payload);
+        };
+        runner.on('complete', this._onRunnerComplete);
+        runner.on('emit', this._onRunnerEmit);
+    }
+    detachRunner() {
+        if (this._runner) {
+            if (this._onRunnerComplete) {
+                this._runner.off('complete', this._onRunnerComplete);
+            }
+            if (this._onRunnerEmit) {
+                this._runner.off('emit', this._onRunnerEmit);
+            }
+        }
+        this._onRunnerComplete = null;
+        this._onRunnerEmit = null;
+    }
+}
+function prepareTimelineForTransition(definition, entryTransition, returnTransition, entrySync) {
+    let timeline = definition;
+    if (entrySync) {
+        timeline = withEntrySync(timeline, entrySync);
+    }
+    const completionFadeOut = Math.max(returnTransition ?? 0, 0);
+    if (completionFadeOut > 0) {
+        timeline = withCompletionFadeOut(timeline, completionFadeOut);
+    }
+    return entryTransition > 0 ? withFadeIn(timeline, entryTransition) : timeline;
+}
+/**
+ * Return a copy of the timeline definition whose entry plays use `sync` unless they already
+ * declare a more specific synchronization source.
+ */ function withEntrySync(definition, sync) {
+    const def = Array.isArray(definition) ? {
+        steps: definition
+    } : definition;
+    return {
+        steps: injectEntrySync(def.steps, sync).steps,
+        responses: def.responses
+    };
+}
+function injectEntrySync(steps, sync) {
+    let blocked = false;
+    const out = steps.map((step)=>{
+        if (blocked) {
+            return step;
+        }
+        switch(step.type){
+            case 'play':
+                if (step.wait === 'complete') {
+                    blocked = true;
+                }
+                return {
+                    ...step,
+                    options: {
+                        ...step.options,
+                        sync: step.options?.sync ?? sync
+                    }
+                };
+            case 'sequence':
+                {
+                    const result = injectEntrySync(step.steps, sync);
+                    blocked = result.blocked;
+                    return {
+                        ...step,
+                        steps: result.steps
+                    };
+                }
+            case 'parallel':
+                {
+                    let anyBranchBlocked = false;
+                    const branches = step.steps.map((branch)=>{
+                        const result = injectEntrySync([
+                            branch
+                        ], sync);
+                        anyBranchBlocked = anyBranchBlocked || result.blocked;
+                        return result.steps[0];
+                    });
+                    blocked = anyBranchBlocked;
+                    return {
+                        ...step,
+                        steps: branches
+                    };
+                }
+            case 'wait':
+            case 'waitEvent':
+            case 'waitMarker':
+            case 'waitFrame':
+                blocked = true;
+                return step;
+            default:
+                return step;
+        }
+    });
+    return {
+        steps: out,
+        blocked
+    };
+}
+/**
+ * Return a copy of the timeline definition whose entry plays fade in over `duration`, so a state
+ * transition cross-fades against the previous state's fade-out.
+ *
+ * "Entry plays" are every `play` that starts before the control flow first blocks: plays before a
+ * `wait`/`waitEvent`/`waitMarker`/`waitFrame`, before a blocking `play` (`wait: 'complete'`), and
+ * every branch of a leading `parallel` (all branches start simultaneously). This covers parallel
+ * states whose branches would otherwise snap in at full weight while only the first faded.
+ */ function withFadeIn(definition, duration) {
+    const def = Array.isArray(definition) ? {
+        steps: definition
+    } : definition;
+    return {
+        steps: injectEntryFadeIn(def.steps, duration).steps,
+        responses: def.responses
+    };
+}
+/**
+ * Inject `fadeIn` into every entry play in `steps`. Returns the rewritten steps and whether the
+ * flow blocks before reaching the end (so callers stop injecting into later, non-entry steps).
+ */ function injectEntryFadeIn(steps, duration) {
+    let blocked = false;
+    const out = steps.map((step)=>{
+        if (blocked) {
+            return step;
+        }
+        switch(step.type){
+            case 'play':
+                if (step.wait === 'complete') {
+                    blocked = true;
+                }
+                return {
+                    ...step,
+                    options: {
+                        ...step.options,
+                        fadeIn: duration
+                    }
+                };
+            case 'sequence':
+                {
+                    const result = injectEntryFadeIn(step.steps, duration);
+                    blocked = result.blocked;
+                    return {
+                        ...step,
+                        steps: result.steps
+                    };
+                }
+            case 'parallel':
+                {
+                    // Every branch starts simultaneously, so inject into all of them. The parallel join only
+                    // blocks the steps that follow it if at least one branch blocks; if all branches are
+                    // non-blocking they drain in the same flush, so the following steps are still entry plays.
+                    let anyBranchBlocked = false;
+                    const branches = step.steps.map((branch)=>{
+                        const result = injectEntryFadeIn([
+                            branch
+                        ], duration);
+                        anyBranchBlocked = anyBranchBlocked || result.blocked;
+                        return result.steps[0];
+                    });
+                    blocked = anyBranchBlocked;
+                    return {
+                        ...step,
+                        steps: branches
+                    };
+                }
+            case 'wait':
+            case 'waitEvent':
+            case 'waitMarker':
+            case 'waitFrame':
+                blocked = true;
+                return step;
+            default:
+                return step;
+        }
+    });
+    return {
+        steps: out,
+        blocked
+    };
+}
+/**
+ * Return a copy of the timeline definition whose play steps keep completed playbacks alive long
+ * enough to cross-fade into the automatic return state.
+ */ function withCompletionFadeOut(definition, duration) {
+    const def = Array.isArray(definition) ? {
+        steps: definition
+    } : definition;
+    return {
+        steps: injectCompletionFadeOut(def.steps, duration),
+        responses: def.responses
+    };
+}
+function injectCompletionFadeOut(steps, duration) {
+    return steps.map((step)=>{
+        switch(step.type){
+            case 'play':
+                return {
+                    ...step,
+                    options: {
+                        ...step.options,
+                        completionFadeOut: step.options?.completionFadeOut ?? duration
+                    }
+                };
+            case 'sequence':
+                return {
+                    ...step,
+                    steps: injectCompletionFadeOut(step.steps, duration)
+                };
+            case 'parallel':
+                return {
+                    ...step,
+                    steps: step.steps.map((branch)=>injectCompletionFadeOut([
+                            branch
+                        ], duration)[0])
+                };
+            default:
+                return step;
+        }
+    });
+}
+
 /**
  * Skeleton modifier for IK solvers.
  *
@@ -88373,21 +90558,21 @@ class GPUClothWrapBinding {
     }
 }
 
-/**
- * Named object interface for model loading
- * @public
+/**
+ * Named object interface for model loading
+ * @public
  */ class NamedObject {
     name;
-    /**
-   * Creates an instance of NamedObject
-   * @param name - Name of the object
+    /**
+   * Creates an instance of NamedObject
+   * @param name - Name of the object
    */ constructor(name){
         this.name = name;
     }
 }
-/**
- * Heirarchical node interface for model loading
- * @public
+/**
+ * Heirarchical node interface for model loading
+ * @public
  */ class AssetHierarchyNode extends NamedObject {
     _parent;
     _position;
@@ -88401,10 +90586,10 @@ class GPUClothWrapBinding {
     _weights;
     _children;
     _instances;
-    /**
-   * Creates an instance of AssetHierarchyNode
-   * @param name - Name of the node
-   * @param parent - Parent of the node
+    /**
+   * Creates an instance of AssetHierarchyNode
+   * @param name - Name of the node
+   * @param parent - Parent of the node
    */ constructor(name, model, parent){
         super(name);
         model.nodes.push(this);
@@ -88492,9 +90677,9 @@ class GPUClothWrapBinding {
             child.computeTransforms(this._worldMatrix);
         }
     }
-    /**
-   * Adds a child to this node
-   * @param child - The child node to be added
+    /**
+   * Adds a child to this node
+   * @param child - The child node to be added
    */ addChild(child) {
         if (!child || child.parent) {
             throw new Error('AssetHierarchyNode.addChild(): invalid child node');
@@ -88502,9 +90687,9 @@ class GPUClothWrapBinding {
         this._children.push(child);
         child._parent = this;
     }
-    /**
-   * Removes a child of this node
-   * @param child - The child node to be removed
+    /**
+   * Removes a child of this node
+   * @param child - The child node to be removed
    */ removeChild(child) {
         const index = this._children.indexOf(child);
         if (index < 0) {
@@ -88513,10 +90698,10 @@ class GPUClothWrapBinding {
         this._children[index]._parent = null;
         this._children.splice(index, 1);
     }
-    /**
-   * Attach this node to a skeleton
-   * @param skeleton - The skeleton to which to node will attach
-   * @param index - The joint index
+    /**
+   * Attach this node to a skeleton
+   * @param skeleton - The skeleton to which to node will attach
+   * @param index - The joint index
    */ attachToSkeleton(skeleton) {
         if (!this._attachToSkeleton) {
             this._attachToSkeleton = new Set();
@@ -88524,18 +90709,18 @@ class GPUClothWrapBinding {
         this._attachToSkeleton.add(skeleton);
     }
 }
-/**
- * Skeleton information for model loading
- * @public
+/**
+ * Skeleton information for model loading
+ * @public
  */ class AssetSkeleton extends NamedObject {
     /** The pivot node */ pivot;
     /** Joints of the skeleton */ joints;
     /** Inverse of the binding matrices of the joints */ inverseBindMatrices;
     /** Binding pose matrices of the joints */ bindPose;
     /** Explicit humanoid joint mapping, when supplied by the source asset. */ humanoidJointMapping;
-    /**
-   * Creates an instance of AssetSkeleton
-   * @param name - Name of the skeleton
+    /**
+   * Creates an instance of AssetSkeleton
+   * @param name - Name of the skeleton
    */ constructor(name){
         super(name);
         this.name = name;
@@ -88545,10 +90730,10 @@ class GPUClothWrapBinding {
         this.bindPose = [];
         this.humanoidJointMapping = null;
     }
-    /**
-   * Adds a joint to the skeleton
-   * @param joint - The joint node
-   * @param inverseBindMatrix - Inverse binding matrix of the joint
+    /**
+   * Adds a joint to the skeleton
+   * @param joint - The joint node
+   * @param inverseBindMatrix - Inverse binding matrix of the joint
    */ addJoint(joint, inverseBindMatrix) {
         joint.attachToSkeleton(this);
         this.joints.push(joint);
@@ -88572,22 +90757,22 @@ class GPUClothWrapBinding {
         return root;
     }
 }
-/**
- * Scene for model loading
- * @public
+/**
+ * Scene for model loading
+ * @public
  */ class AssetScene extends NamedObject {
     /** Root nodes of the scene */ rootNodes;
-    /**
-   * Creates an instance of AssetScene
-   * @param name - Name of the scene
+    /**
+   * Creates an instance of AssetScene
+   * @param name - Name of the scene
    */ constructor(name){
         super(name);
         this.rootNodes = [];
     }
 }
-/**
- * Model information that can be shared by multiple model nodes
- * @public
+/**
+ * Model information that can be shared by multiple model nodes
+ * @public
  */ class SharedModel extends Disposable {
     /** @internal */ _nodes;
     /** @internal */ _skeletons;
@@ -88605,8 +90790,8 @@ class GPUClothWrapBinding {
     /** @internal */ _morphTargetGroups;
     /** @internal */ _textureMap;
     /** @internal */ _primitiveMap;
-    /**
-   * Creates an instance of SharedModel
+    /**
+   * Creates an instance of SharedModel
    */ constructor(){
         super();
         this._nodes = [];
@@ -88876,29 +91061,29 @@ class GPUClothWrapBinding {
     getPrimitiveBaseName(info, index, fallback) {
         return info?.name?.trim() || `${fallback}_mesh_${index}`;
     }
-    /**
-   * Adds a model-level morph target group.
-   * @param group - Morph target group to add
+    /**
+   * Adds a model-level morph target group.
+   * @param group - Morph target group to add
    */ addMorphTargetGroup(group) {
         if (group?.name && group.bindings?.length > 0) {
             this._morphTargetGroups.push(group);
         }
     }
-    /**
-   * Removes all model-level morph target groups.
+    /**
+   * Removes all model-level morph target groups.
    */ clearMorphTargetGroups() {
         this._morphTargetGroups = [];
     }
-    /**
-   * Finds a model-level morph target group by name.
-   * @param name - Group name
-   * @returns The matching group, or null if not found
+    /**
+   * Finds a model-level morph target group by name.
+   * @param name - Group name
+   * @returns The matching group, or null if not found
    */ getMorphTargetGroup(name) {
         return this._morphTargetGroups.find((group)=>group.name === name) ?? null;
     }
-    /**
-   * Builds morph target groups by collecting morph target names from every mesh.
-   * @returns Generated morph target groups
+    /**
+   * Builds morph target groups by collecting morph target names from every mesh.
+   * @returns Generated morph target groups
    */ buildMorphTargetGroupsByName() {
         this.clearMorphTargetGroups();
         const groups = new Map();
@@ -88931,15 +91116,15 @@ class GPUClothWrapBinding {
         this._morphTargetGroups = Array.from(groups.values());
         return this._morphTargetGroups;
     }
-    /**
-   * Adds a skeleton to the scene
-   * @param skeleton - The skeleton to be added
+    /**
+   * Adds a skeleton to the scene
+   * @param skeleton - The skeleton to be added
    */ addSkeleton(skeleton) {
         this._skeletons.push(skeleton);
     }
-    /**
-   * Adds an animation to the scene
-   * @param animation - The animation to be added
+    /**
+   * Adds an animation to the scene
+   * @param animation - The animation to be added
    */ addAnimation(animation) {
         this._animations.push(animation);
     }
@@ -91174,32 +93359,32 @@ let outfitInstanceId = 0;
 /* es-module-lexer 1.7.0 */
 var ImportType;!function(A){A[A.Static=1]="Static",A[A.Dynamic=2]="Dynamic",A[A.ImportMeta=3]="ImportMeta",A[A.StaticSourcePhase=4]="StaticSourcePhase",A[A.DynamicSourcePhase=5]="DynamicSourcePhase",A[A.StaticDeferPhase=6]="StaticDeferPhase",A[A.DynamicDeferPhase=7]="DynamicDeferPhase";}(ImportType||(ImportType={}));const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse(E,g="@"){if(!C)return init.then((()=>parse(E)));const I=E.length+1,w=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;w>0&&C.memory.grow(Math.ceil(w/65536));const K=C.sa(I-1);if((A?B:Q)(E,new Uint16Array(C.memory.buffer,K,I)),!C.parse())throw Object.assign(new Error(`Parse error ${g}:${E.slice(0,C.e()).split("\n").length}:${C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const o=[],D=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.it(),g=C.ai(),I=C.id(),w=C.ss(),K=C.se();let D;C.ip()&&(D=k(E.slice(-1===I?A-1:A,-1===I?Q+1:Q))),o.push({n:D,t:B,s:A,e:Q,ss:w,se:K,d:I,a:g});}for(;C.re();){const A=C.es(),Q=C.ee(),B=C.els(),g=C.ele(),I=E.slice(A,Q),w=I[0],K=B<0?undefined:E.slice(B,g),o=K?K[0]:"";D.push({s:A,e:Q,ls:B,le:g,n:'"'===w||"'"===w?k(I):I,ln:'"'===o||"'"===o?k(K):K});}function k(A){try{return (0,eval)(A)}catch(A){}}return [o,D,!!C.f(),!!C.ms()]}function Q(A,Q){const B=A.length;let C=0;for(;C<B;){const B=A.charCodeAt(C);Q[C++]=(255&B)<<8|B>>>8;}}function B(A,Q){const B=A.length;let C=0;for(;C<B;)Q[C]=A.charCodeAt(C++);}let C;const E=()=>{return A="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","undefined"!=typeof Buffer?Buffer.from(A,"base64"):Uint8Array.from(atob(A),(A=>A.charCodeAt(0)));var A;};const init=WebAssembly.compile(E()).then(WebAssembly.instantiate).then((({exports:A})=>{C=A;}));
 
-/**
- * Converts JavaScript source to a data URL tied to a logical module id.
- *
- * @param js - The JavaScript source code to embed.
- * @param id - Logical module identifier (used only for sourceURL tagging).
- * @returns A `data:text/javascript;base64,...` URL with an encoded `#id` suffix.
- * @internal
+/**
+ * Converts JavaScript source to a data URL tied to a logical module id.
+ *
+ * @param js - The JavaScript source code to embed.
+ * @param id - Logical module identifier (used only for sourceURL tagging).
+ * @returns A `data:text/javascript;base64,...` URL with an encoded `#id` suffix.
+ * @internal
  */ function toDataUrl(js, id) {
     const b64 = textToBase64(js);
     return `data:text/javascript;base64,${b64}#${encodeURIComponent(String(id))}`;
 }
-/**
- * Checks whether a specifier is an absolute HTTP(S) URL.
- * @internal
+/**
+ * Checks whether a specifier is an absolute HTTP(S) URL.
+ * @internal
  */ function isAbsoluteUrl(spec) {
     return /^https?:\/\//i.test(spec);
 }
-/**
- * Checks whether a specifier is a special URL (data: or blob:).
- * @internal
+/**
+ * Checks whether a specifier is a special URL (data: or blob:).
+ * @internal
  */ function isSpecialUrl(spec) {
     return /^(data|blob):/i.test(spec);
 }
-/**
- * Checks whether a specifier is a bare module (not starting with ./, ../, /, or #/).
- * @internal
+/**
+ * Checks whether a specifier is a bare module (not starting with ./, ../, /, or #/).
+ * @internal
  */ function isBareModule(spec) {
     return !spec.startsWith('./') && !spec.startsWith('../') && !spec.startsWith('/') && !spec.startsWith('#/');
 }
@@ -91230,32 +93415,32 @@ function hasRawQuery(spec) {
     }
     return query.split('&').some((part)=>part.trim() === 'raw');
 }
-/**
- * Resolves, builds, and serves runtime modules using a VFS.
- *
- * Responsibilities:
- * - Resolve logical module IDs to physical paths or URLs.
- * - In editor mode, bundle local script modules into a single data URL after transpile.
- * - Transpile TypeScript to JavaScript on the fly (requires `window.ts` TypeScript runtime).
- * - Gather static and dynamic import dependencies for tooling.
- *
- * Modes:
- * - Editor mode (`editorMode === true`): local script graphs are bundled to data URLs.
- * - Runtime mode (`editorMode === false`): returns .js URLs directly (with .ts -\> .js mapping).
- *
- * Caching:
- * - Built bundles are memoized in `_built` map keyed by canonical source path.
- *
- * @public
+/**
+ * Resolves, builds, and serves runtime modules using a VFS.
+ *
+ * Responsibilities:
+ * - Resolve logical module IDs to physical paths or URLs.
+ * - In editor mode, bundle local script modules into a single data URL after transpile.
+ * - Transpile TypeScript to JavaScript on the fly (requires `window.ts` TypeScript runtime).
+ * - Gather static and dynamic import dependencies for tooling.
+ *
+ * Modes:
+ * - Editor mode (`editorMode === true`): local script graphs are bundled to data URLs.
+ * - Runtime mode (`editorMode === false`): returns .js/.mjs URLs directly (with .ts -\> .js mapping).
+ *
+ * Caching:
+ * - Built bundles are memoized in `_built` map keyed by canonical source path.
+ *
+ * @public
  */ class ScriptRegistry {
     _vfs;
     _scriptsRoot;
     _built;
     _building;
     _builtDeps;
-    /**
-   * @param vfs - The virtual file system for existence checks, reads, and path ops.
-   * @param scriptsRoot - Root directory for script resolution (used with `#/` specifiers).
+    /**
+   * @param vfs - The virtual file system for existence checks, reads, and path ops.
+   * @param scriptsRoot - Root directory for script resolution (used with `#/` specifiers).
    */ constructor(vfs, scriptsRoot){
         this._vfs = vfs;
         this._scriptsRoot = scriptsRoot;
@@ -91263,10 +93448,10 @@ function hasRawQuery(spec) {
         this._building = new Map();
         this._builtDeps = new Map();
     }
-    /**
-   * The active virtual file system.
-   *
-   * Assigning a new VFS clears the build cache.
+    /**
+   * The active virtual file system.
+   *
+   * Assigning a new VFS clears the build cache.
    */ get VFS() {
         return this._vfs;
     }
@@ -91278,21 +93463,21 @@ function hasRawQuery(spec) {
             this._builtDeps.clear();
         }
     }
-    /**
-   * The root path used by `#/` specifiers.
+    /**
+   * The root path used by `#/` specifiers.
    */ get scriptsRoot() {
         return this._scriptsRoot;
     }
     set scriptsRoot(path) {
         this._scriptsRoot = path;
     }
-    /**
-   * Invalidates cached built module output for one logical module id, or clears the full cache.
-   *
-   * Pass the same logical id shape that callers use with {@link ScriptRegistry.resolveRuntimeUrl},
-   * for example `/assets/scripts/foo.ts`, `/assets/scripts/foo.js`, or `/assets/scripts/foo`.
-   *
-   * @param moduleId - Optional logical module id to invalidate. Omit to clear the entire build cache.
+    /**
+   * Invalidates cached built module output for one logical module id, or clears the full cache.
+   *
+   * Pass the same logical id shape that callers use with {@link ScriptRegistry.resolveRuntimeUrl},
+   * for example `/assets/scripts/foo.ts`, `/assets/scripts/foo.js`, or `/assets/scripts/foo`.
+   *
+   * @param moduleId - Optional logical module id to invalidate. Omit to clear the entire build cache.
    */ invalidate(moduleId) {
         if (!moduleId) {
             this._built.clear();
@@ -91331,22 +93516,22 @@ function hasRawQuery(spec) {
             }
         }
     }
-    /**
-   * Fetches raw source for a logical module id by probing known extensions.
-   *
-   * Search order:
-   * - If `id` already ends with `.ts` or `.js` and is a file -\> return it.
-   * - Else try `.id.ts`, then `.id.js`.
-   *
-   * @param id - Logical module identifier (absolute or logical path-like).
-   * @returns Source code, resolved path, and type (`'js' | 'ts'`), or `undefined` if not found.
+    /**
+   * Fetches raw source for a logical module id by probing known extensions.
+   *
+   * Search order:
+   * - If `id` already ends with `.ts`, `.js`, or `.mjs` and is a file -\> return it.
+   * - Else try `.id.ts`, then `.id.js`, then `.id.mjs`.
+   *
+   * @param id - Logical module identifier (absolute or logical path-like).
+   * @returns Source code, resolved path, and type (`'js' | 'ts'`), or `undefined` if not found.
    */ async fetchSource(id) {
         let type = null;
         let pathWithExt = '';
         if (id.endsWith('.ts')) {
             pathWithExt = id;
             type = 'ts';
-        } else if (id.endsWith('.js')) {
+        } else if (id.endsWith('.js') || id.endsWith('.mjs')) {
             pathWithExt = id;
             type = 'js';
         }
@@ -91365,13 +93550,16 @@ function hasRawQuery(spec) {
             'js'
         ];
         if (!type) {
-            for (const t of types){
+            for (const t of [
+                ...types,
+                'mjs'
+            ]){
                 pathWithExt = `${id}.${t}`;
                 const exists = await this._vfs.exists(pathWithExt);
                 if (exists) {
                     const stats = await this._vfs.stat(pathWithExt);
                     if (stats.isFile) {
-                        type = t;
+                        type = t === 'ts' ? 'ts' : 'js';
                         break;
                     }
                 }
@@ -91388,34 +93576,35 @@ function hasRawQuery(spec) {
             };
         }
     }
-    /**
-   * Resolves a module entry to a URL suitable for dynamic import.
-   *
-   * Behavior:
-   * - In editor mode, builds the module to a data URL.
-   * - Otherwise, returns `.js` URL directly:
-   *   - If `id` ends with `.js`: return as-is.
-   *   - If `id` ends with `.ts`: map to `.js` (assumes pre-built file exists).
-   *   - Else: append `.js`.
-   *
-   * @param entryId - Entry module identifier (logical or path-like).
-   * @returns A URL string that can be used in `import(...)`.
+    /**
+   * Resolves a module entry to a URL suitable for dynamic import.
+   *
+   * Behavior:
+   * - In editor mode, builds the module to a data URL.
+   * - Otherwise, returns `.js` or `.mjs` URL directly:
+   *   - If `id` ends with `.js`: return as-is.
+   *   - If `id` ends with `.mjs`: return as-is.
+   *   - If `id` ends with `.ts`: map to `.js` (assumes pre-built file exists).
+   *   - Else: append `.js`.
+   *
+   * @param entryId - Entry module identifier (logical or path-like).
+   * @returns A URL string that can be used in `import(...)`.
    */ async resolveRuntimeUrl(entryId) {
         const id = await this.resolveLogicalId(entryId);
         if (id.startsWith('/assets/@builtins/')) {
             return await this.build(String(id));
         }
-        return getApp().editorMode !== 'none' ? await this.build(String(id)) : id.endsWith('.js') ? id : id.endsWith('.ts') ? `${id.slice(0, -3)}.js` : `${id}.js`;
-    }
-    /**
-   * Recursively gathers direct static and dynamic import dependencies for a module.
-   *
-   * Only relative specifiers (`./` or `../`) are followed. Absolute, special, and bare
-   * module specifiers are ignored here.
-   *
-   * @param entryId - The starting (possibly relative) specifier from `fromId`.
-   * @param fromId - The logical id of the module containing `entryId`.
-   * @param dependencies - Output map of `resolvedSourcePath -\> file contents`.
+        return getApp().editorMode !== 'none' ? await this.build(String(id)) : id.endsWith('.js') || id.endsWith('.mjs') ? id : id.endsWith('.ts') ? `${id.slice(0, -3)}.js` : `${id}.js`;
+    }
+    /**
+   * Recursively gathers direct static and dynamic import dependencies for a module.
+   *
+   * Only relative specifiers (`./` or `../`) are followed. Absolute, special, and bare
+   * module specifiers are ignored here.
+   *
+   * @param entryId - The starting (possibly relative) specifier from `fromId`.
+   * @param fromId - The logical id of the module containing `entryId`.
+   * @param dependencies - Output map of `resolvedSourcePath -\> file contents`.
    */ async getDependencies(entryId, fromId, dependencies) {
         const reStatic = /\b(?:import|export)\s+[^"']*?from\s+(['"])([^'"]+)\1/g;
         const reDynamic = /\bimport\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
@@ -91443,17 +93632,17 @@ function hasRawQuery(spec) {
         await gather(code, reStatic);
         await gather(code, reDynamic);
     }
-    /**
-   * Builds a logical module id into a bundled data URL (editor mode pipeline).
-   *
-   * Steps:
-   * - Resolve source path (.ts/.js) via {@link ScriptRegistry.resolveSourcePath}.
-   * - Collect reachable local imports without recursively building data URLs.
-   * - Transpile local modules to `System.register`.
-   * - Emit a single `data:` URL with a small module loader and memoize it in `_built`.
-   *
-   * @param id - Logical module id to build.
-   * @returns Data URL string for dynamic import, or empty string if not found.
+    /**
+   * Builds a logical module id into a bundled data URL (editor mode pipeline).
+   *
+   * Steps:
+   * - Resolve source path (.ts/.js) via {@link ScriptRegistry.resolveSourcePath}.
+   * - Collect reachable local imports without recursively building data URLs.
+   * - Transpile local modules to `System.register`.
+   * - Emit a single `data:` URL with a small module loader and memoize it in `_built`.
+   *
+   * @param id - Logical module id to build.
+   * @returns Data URL string for dynamic import, or empty string if not found.
    */ async build(id) {
         const entry = await this.resolveModuleInfo(String(id));
         if (!entry) {
@@ -91548,7 +93737,7 @@ function hasRawQuery(spec) {
         const ts = this.getTypeScriptRuntime();
         const res = ts.transpileModule(code, {
             compilerOptions: {
-                target: ts.ScriptTarget.ES2015,
+                target: ts.ScriptTarget.ES2020,
                 module: ts.ModuleKind.ESNext,
                 experimentalDecorators: true,
                 useDefineForClassFields: false
@@ -91563,19 +93752,20 @@ function hasRawQuery(spec) {
         const res = ts.transpileModule(code, {
             compilerOptions: {
                 allowJs: true,
-                target: ts.ScriptTarget.ES2015,
+                // Keep modern syntax such as async generators, class fields, and private fields intact.
+                target: ts.ScriptTarget.ES2022,
                 module: ts.ModuleKind.System,
                 esModuleInterop: true,
                 experimentalDecorators: true,
-                useDefineForClassFields: false
+                useDefineForClassFields: true
             },
             fileName: logicalId
         });
         return res.outputText || '';
     }
-    /**
-   * Rewrites local ESM specifiers to canonical source paths and records local deps.
-   * External URLs and package imports are left for the native dynamic import path.
+    /**
+   * Rewrites local ESM specifiers to canonical source paths and records local deps.
+   * External URLs and package imports are left for the native dynamic import path.
    */ async rewriteImportsToLogicalIds(code, fromId) {
         await init;
         const [imports] = parse(code);
@@ -91723,21 +93913,21 @@ async function __z3dLoad(spec, parentId = '') {
 }
 `;
     }
-    /**
-   * Resolves a specifier to a logical id suitable for further processing.
-   *
-   * Resolution rules:
-   * - `#/path`: resolved against `scriptsRoot` via VFS join/normalize.
-   * - `./` or `../`: resolved relative to `fromId` directory (requires `fromId`).
-   * - `/absolute`: treated as absolute from root (normalized).
-   * - Bare module in editor mode: if `/deps.lock.json` exists and contains an entry,
-   *   map to the dependency's `entry` path; otherwise return as-is.
-   * - Else (non-editor bare module): return `spec` unchanged (external).
-   *
-   * @param spec - Import specifier string.
-   * @param fromId - Optional base logical id used for relative resolution.
-   * @returns A normalized logical id or an external specifier string.
-   * @throws If a relative import is provided without `fromId`.
+    /**
+   * Resolves a specifier to a logical id suitable for further processing.
+   *
+   * Resolution rules:
+   * - `#/path`: resolved against `scriptsRoot` via VFS join/normalize.
+   * - `./` or `../`: resolved relative to `fromId` directory (requires `fromId`).
+   * - `/absolute`: treated as absolute from root (normalized).
+   * - Bare module in editor mode: if `/deps.lock.json` exists and contains an entry,
+   *   map to the dependency's `entry` path; otherwise return as-is.
+   * - Else (non-editor bare module): return `spec` unchanged (external).
+   *
+   * @param spec - Import specifier string.
+   * @param fromId - Optional base logical id used for relative resolution.
+   * @returns A normalized logical id or an external specifier string.
+   * @throws If a relative import is provided without `fromId`.
    */ async resolveLogicalId(spec, fromId) {
         const { path: baseSpec, suffix } = splitSpecifierQuery(spec);
         if (baseSpec.startsWith('#/')) {
@@ -91767,16 +93957,16 @@ async function __z3dLoad(spec, parentId = '') {
         }
         return spec;
     }
-    /**
-   * Resolves a logical id to a concrete source path and type by probing extensions.
-   *
-   * Rules:
-   * - If `logicalId` ends with `.ts` or `.js`/`.mjs` and is a file, return it.
-   * - Else probe `logicalId.ts`, `logicalId.js`, `logicalId.mjs` in that order.
-   * - Maps `.mjs` to type `'js'`.
-   *
-   * @param logicalId - The normalized logical module id (path-like).
-   * @returns `{ type, path }` or `null` if not found.
+    /**
+   * Resolves a logical id to a concrete source path and type by probing extensions.
+   *
+   * Rules:
+   * - If `logicalId` ends with `.ts` or `.js`/`.mjs` and is a file, return it.
+   * - Else probe `logicalId.ts`, `logicalId.js`, `logicalId.mjs` in that order.
+   * - Maps `.mjs` to type `'js'`.
+   *
+   * @param logicalId - The normalized logical module id (path-like).
+   * @returns `{ type, path }` or `null` if not found.
    */ async resolveSourcePath(logicalId) {
         const { path: normalizedLogicalId } = splitSpecifierQuery(logicalId);
         let type = null;
@@ -93030,5 +95220,5 @@ const DEFAULT_PADDING = 6;
     }
 }
 
-export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, AnimationClip, AnimationSet, AnimationTrack, AnyConditionNode, Application, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, AssetHierarchyNode, AssetManager, AssetScene, AssetSkeleton, AvatarOutfitInstance, AvatarWardrobe, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, BatchGroup, BillboardMatrixNode, BlinnMaterial, Blitter, Bloom, BoundingBox, BoxFilterBlitter, BoxFrameShape, BoxShape, CAMERA_POS_Y, CCDSolver, Camera, CameraNearFarNode, CameraPositionNode, CameraVectorNode, CapsuleShape, CeilNode, ClampNode, Clipmap, ClipmapTerrain, ClipmapTerrainMaterial, ColliderForce, ColorAdjust, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, Compositor, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, ConstraintType, CopyBlitter, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, EPSILON$1 as EPSILON, ESM, ElapsedTimeNode, Engine, EnvConstantAmbient, EnvHemisphericAmbient, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, FABRIKSolver, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, FWidthNode, FXAA, FaceForwardNode, FixedGeometryCacheTrack, FloorNode, FmaNode, Fog, FontAsset, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GPUClothSystem, GaussianBlurBlitter, GenericMathNode, GerstnerWaveGenerator, GraphNode, GrassInstances, GrassLayer, GrassMaterial, GrassQuadtreeNode, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, HistoryResourceManager, HumanoidBodyRig, HumanoidHandRig, IKAngleConstraint, IKChain, IKConstraint, IKModifier, IKSolver, InputManager, InstanceBindGroupAllocator, InstanceIndexNode, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, JointDynamicsModifier, JointDynamicsSystem, JointDynamicsSystemController, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, LightPass, Log2Node, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MSDFText, MSDFTextAtlasManager, MSDFTextSprite, MToonMaterial, MakeVectorNode, Material, MaterialBlueprintIR, MaterialVaryingFlags, MaxNode, Mesh, MeshMaterial, MinNode, MixNode, ModNode, MorphTargetTrack, MultiChainSpringSystem, NamedObject, NodeEulerRotationTrack, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial, PCAGeometryCacheTrack, PCFOPT, PCFPD, PannerNode, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, PixelNormalNode, PixelWorldPositionNode, PlaneShape, PointLight, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, PropertyTrack, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, Radians2DegreesNode, RaycastVisitor, RectLight, ReflectNode, RefractNode, RenderPass, RenderQueue, RenderTarget, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RotateAboutAxisNode, RuntimeScript, SAO, SSS, SaturateNode, Scene, SceneNode, SceneRenderer, ScreenAdapter, ScreenRenderTarget, ScriptAttachment, ScriptRegistry, ScriptingSystem, SelectionNode, ShaderHelper, ShadowMapPass, ShadowMapper, ShadowRegion, Shape, SharedModel, SignNode, SimplexNoise2DNode, SinHNode, SinNode, Skeleton, SkeletonModifier, SkeletonRig, SkinBinding, SkyEnvTextureNode, SkyRenderer, SmoothStepNode, SphereShape, SpotLight, SpringChain, SpringModifier, SpringSystem, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, SubsurfaceProfile, SwizzleNode, TAA, TAA_DEBUG_ALAPH, TAA_DEBUG_CURRENT_COLOR, TAA_DEBUG_EDGE, TAA_DEBUG_HISTORY_COLOR, TAA_DEBUG_MOTION_VECTOR, TAA_DEBUG_NONE, TAA_DEBUG_STRENGTH, TAA_DEBUG_VELOCITY, TanHNode, TanNode, TetrahedronFrameShape, TetrahedronShape, TextSprite, TextureSampleGrad, TextureSampleNode, Tonemap, TorusShape, TransformNode, TwoBoneIKSolver, UnlitMaterial, VSM, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexIndexNode, VertexNormalNode, VertexOutputNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, Water, WaterShaderImpl, WeightedBlendedOIT, aerialPerspective, aerialPerspectiveLut, appInstance, applyAngleLimits, applyMaterialMixins, applyResult, applyRuntimeScriptConfig, atmosphereLUTRendered, buildConstraints, buildMSDFShape, buildSurfaceFaces, checkSurfaceCollision, collisionDetection, collisionDetectionCapsule, collisionDetectionSphere, computeMaxDepth, computeNearestPoints, copyTexture, createAPLutProgram, createCapsuleCollider, createGPUClothWrapBindingData, createGeometryCacheState, createGradientNoiseTexture, createMultiScatteringLutProgram, createPlaneCollider, createProgramFFT2H, createProgramFFT2V, createProgramH0, createProgramHk, createProgramOcean, createProgramPostFFT2, createRandomNoiseTexture, createSkyViewLutProgram, createSphereCollider, createSpringConstraint, createSpringParticle, createTransformAccess, createTransmittanceLutProgram, debugTexture, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, ensureGeometryCacheMeshBinding, extractLocalTwist, fetchNormalizedFloatForDevice, fetchSampler, gammaToLinear, generateMSDF, getAerialPerspectiveLut, getApp, getAtmosphereParamsStruct, getBatchGroupClass, getCameraClass, getDefaultAtmosphereParams, getDefaultTexture2D, getDefaultTexture2DArray, getDefaultTextureCube, getDevice, getDirectionalLightClass, getEngine, getGraphNodeClass, getInput, getMeshClass, getMultiScattering, getMultiScatteringLut, getNodeTypeComponents, getOrthoCameraClass, getParticleNodeClass, getPerspectiveCameraClass, getPointLightClass, getPunctualLightClass, getRectLightClass, getRuntimeScriptProperties, getSceneNodeClass, getSkyView, getSkyViewLut, getSpotLightClass, getTransmittanceLut, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, integralMultiScattering, interleavedGradientNoise, isGPUClothSupported, linearToGamma, mieAbsorption, mieCoefficient, miePhase, mixGeometryCacheBoundingBox, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, multiScatteringLut, noise3D, normalizeRuntimeScriptConfig, normalizeScriptAttachmentConfig, normalizeScriptAttachments, ozoneAbsorption, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, pushInCollisionDetection, pushInFromCapsule, pushInFromCollider, pushInFromSphere, pushoutFromCapsule, pushoutFromCollider, pushoutFromSphere, rayIntersectSphere, rayleighCoefficient, rayleighPhase, renderAPLut, renderAtmosphereLUTs, renderMultiScatteringLut, renderSkyViewLut, renderTransmittanceLut, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, restoreGeometryCacheMeshBinding, scattering, scriptProp, setApp, setSceneMeshAssetBinding, simulate, skyBox, skyViewLut, smoothNoise3D, sortRootPointsByProximity, temporalResolve, transmittance, transmittanceLut, transmittanceLutToUV, transmittanceToSky, tryGetApp, uniformSphereSamples, updateColliderFromNode, uvToTransmittanceLut, uvToViewDir, valueNoise, viewDirToUV, whiteNoise, worleyFBM, worleyNoise };
+export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, AnimationClip, AnimationController, AnimationPlayback, AnimationSet, AnimationTimeline, AnimationTimelineRunner, AnimationTrack, AnyConditionNode, Application, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, AssetHierarchyNode, AssetManager, AssetScene, AssetSkeleton, AvatarOutfitInstance, AvatarWardrobe, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, BatchGroup, BillboardMatrixNode, BlinnMaterial, Blitter, Bloom, BoundingBox, BoxFilterBlitter, BoxFrameShape, BoxShape, CAMERA_POS_Y, CCDSolver, Camera, CameraNearFarNode, CameraPositionNode, CameraVectorNode, CapsuleShape, CeilNode, ClampNode, Clipmap, ClipmapTerrain, ClipmapTerrainMaterial, ColliderForce, ColorAdjust, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, Compositor, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, ConstraintType, CopyBlitter, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, EPSILON$1 as EPSILON, ESM, ElapsedTimeNode, Engine, EnvConstantAmbient, EnvHemisphericAmbient, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, FABRIKSolver, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, FWidthNode, FXAA, FaceForwardNode, FixedGeometryCacheTrack, FloorNode, FmaNode, Fog, FontAsset, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GPUClothSystem, GaussianBlurBlitter, GenericMathNode, GerstnerWaveGenerator, GraphNode, GrassInstances, GrassLayer, GrassMaterial, GrassQuadtreeNode, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, HistoryResourceManager, HumanoidBodyRig, HumanoidHandRig, IKAngleConstraint, IKChain, IKConstraint, IKModifier, IKSolver, InputManager, InstanceBindGroupAllocator, InstanceIndexNode, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, JointDynamicsModifier, JointDynamicsSystem, JointDynamicsSystemController, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, LightPass, Log2Node, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MSDFText, MSDFTextAtlasManager, MSDFTextSprite, MToonMaterial, MakeVectorNode, Material, MaterialBlueprintIR, MaterialVaryingFlags, MaxNode, Mesh, MeshMaterial, MinNode, MixNode, ModNode, MorphTargetTrack, MultiChainSpringSystem, NamedObject, NodeEulerRotationTrack, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial, PCAGeometryCacheTrack, PCFOPT, PCFPD, PannerNode, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, PixelNormalNode, PixelWorldPositionNode, PlaneShape, PointLight, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, PropertyTrack, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, Radians2DegreesNode, RaycastVisitor, RectLight, ReflectNode, RefractNode, RenderPass, RenderQueue, RenderTarget, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RotateAboutAxisNode, RuntimeScript, SAO, SSS, SaturateNode, Scene, SceneNode, SceneRenderer, ScreenAdapter, ScreenRenderTarget, ScriptAttachment, ScriptRegistry, ScriptingSystem, SelectionNode, ShaderHelper, ShadowMapPass, ShadowMapper, ShadowRegion, Shape, SharedModel, SignNode, SimplexNoise2DNode, SinHNode, SinNode, Skeleton, SkeletonModifier, SkeletonRig, SkinBinding, SkyEnvTextureNode, SkyRenderer, SmoothStepNode, SphereShape, SpotLight, SpringChain, SpringModifier, SpringSystem, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, SubsurfaceProfile, SwizzleNode, TAA, TAA_DEBUG_ALAPH, TAA_DEBUG_CURRENT_COLOR, TAA_DEBUG_EDGE, TAA_DEBUG_HISTORY_COLOR, TAA_DEBUG_MOTION_VECTOR, TAA_DEBUG_NONE, TAA_DEBUG_STRENGTH, TAA_DEBUG_VELOCITY, TanHNode, TanNode, TetrahedronFrameShape, TetrahedronShape, TextSprite, TextureSampleGrad, TextureSampleNode, Tonemap, TorusShape, TransformNode, TwoBoneIKSolver, UnlitMaterial, VSM, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexIndexNode, VertexNormalNode, VertexOutputNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, Water, WaterShaderImpl, WeightedBlendedOIT, aerialPerspective, aerialPerspectiveLut, appInstance, applyAngleLimits, applyMaterialMixins, applyResult, applyRuntimeScriptConfig, atmosphereLUTRendered, buildConstraints, buildMSDFShape, buildSurfaceFaces, checkSurfaceCollision, collisionDetection, collisionDetectionCapsule, collisionDetectionSphere, computeMaxDepth, computeNearestPoints, copyTexture, createAPLutProgram, createCapsuleCollider, createGPUClothWrapBindingData, createGeometryCacheState, createGradientNoiseTexture, createMultiScatteringLutProgram, createPlaneCollider, createProgramFFT2H, createProgramFFT2V, createProgramH0, createProgramHk, createProgramOcean, createProgramPostFFT2, createRandomNoiseTexture, createSkyViewLutProgram, createSphereCollider, createSpringConstraint, createSpringParticle, createTransformAccess, createTransmittanceLutProgram, debugTexture, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, ensureGeometryCacheMeshBinding, extractLocalTwist, fetchNormalizedFloatForDevice, fetchSampler, gammaToLinear, generateMSDF, getAerialPerspectiveLut, getApp, getAtmosphereParamsStruct, getBatchGroupClass, getCameraClass, getDefaultAtmosphereParams, getDefaultTexture2D, getDefaultTexture2DArray, getDefaultTextureCube, getDevice, getDirectionalLightClass, getEngine, getGraphNodeClass, getInput, getMeshClass, getMultiScattering, getMultiScatteringLut, getNodeTypeComponents, getOrthoCameraClass, getParticleNodeClass, getPerspectiveCameraClass, getPointLightClass, getPunctualLightClass, getRectLightClass, getRuntimeScriptProperties, getSceneNodeClass, getSkyView, getSkyViewLut, getSpotLightClass, getTransmittanceLut, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, integralMultiScattering, interleavedGradientNoise, isGPUClothSupported, linearToGamma, mieAbsorption, mieCoefficient, miePhase, mixGeometryCacheBoundingBox, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, multiScatteringLut, noise3D, normalizeRuntimeScriptConfig, normalizeScriptAttachmentConfig, normalizeScriptAttachments, ozoneAbsorption, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, pushInCollisionDetection, pushInFromCapsule, pushInFromCollider, pushInFromSphere, pushoutFromCapsule, pushoutFromCollider, pushoutFromSphere, rayIntersectSphere, rayleighCoefficient, rayleighPhase, renderAPLut, renderAtmosphereLUTs, renderMultiScatteringLut, renderSkyViewLut, renderTransmittanceLut, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, restoreGeometryCacheMeshBinding, scattering, scriptProp, setApp, setSceneMeshAssetBinding, simulate, skyBox, skyViewLut, smoothNoise3D, sortRootPointsByProximity, temporalResolve, transmittance, transmittanceLut, transmittanceLutToUV, transmittanceToSky, tryGetApp, uniformSphereSamples, updateColliderFromNode, uvToTransmittanceLut, uvToViewDir, valueNoise, viewDirToUV, whiteNoise, worleyFBM, worleyNoise };
 //# sourceMappingURL=zephyr3d_scene.js.map