diff --git a/docs/en/animation/animator.mdx b/docs/en/animation/animator.mdx
index d4cf4f3d8d..a253d0cd98 100644
--- a/docs/en/animation/animator.mdx
+++ b/docs/en/animation/animator.mdx
@@ -113,11 +113,20 @@ animator.speed = 0;
 animator.speed = 1;
 ```
 
-If you only want to pause a specific `AnimatorState` , you can do so by setting its speed to 0.
+If you only want to pause a specific `AnimatorState` on this Animator instance, set the per-instance speed to 0.
 
 ```typescript
 const state = animator.findAnimatorState("xxx");
+if (!state) {
+  // State not found in any layer
+  return;
+}
+
+// Pause only this Animator instance's playback of the state.
 state.speed = 0;
+
+// To resume later, write any non-zero value:
+// state.speed = 1;
 ```
 
 ### Transition to Specified Animation State
@@ -130,26 +139,34 @@ animator.crossFade("OtherStateName", 0.3);
 
 ### Get Current Playing Animation State
 
-You can use the [getCurrentAnimatorState](/apis/core/#Animator-getCurrentAnimatorState) method to get the currently playing `AnimatorState` . The parameter is the index `layerIndex` of the `AnimatorControllerLayer` where the `AnimatorState` is located. For details, see the [API documentation](/apis/core/#Animator-getCurrentAnimatorState). After obtaining it, you can set the properties of the `AnimatorState` , such as changing the default loop playback to play once.
+[getCurrentAnimatorState](/apis/core/#Animator-getCurrentAnimatorState) returns the playing `AnimatorStateInstance` on a given layer, or `null` when the layer is missing or nothing is playing.
 
 ```typescript
-const currentState = animator.getCurrentAnimatorState(0);
-// Play once
-currentState.wrapMode = WrapMode.Once;
-// Loop playback
-currentState.wrapMode = WrapMode.Loop;
+const current = animator.getCurrentAnimatorState(0);
+if (current) {
+  current.speed = 0.5;
+}
 ```
 
 ### Get Animation State
 
-You can use the [findAnimatorState](/apis/core/#Animator-findAnimatorState) method to get the specified `AnimatorState` . After obtaining it, you can set the properties of the  `AnimatorState` , such as changing the default loop playback to play once.
+[findAnimatorState](/apis/core/#Animator-findAnimatorState) returns the per-Animator `AnimatorStateInstance` (`AnimatorStateInstance | null`). Writes only affect this Animator; the shared `AnimatorState` on the controller is untouched. Same pattern as `Renderer.getInstanceMaterial`.
+
+- `speed`, `wrapMode` are per-instance overrideable; unwritten reads return the shared default.
+- `name`, `clip`, `clipStartTime`, `clipEndTime` read through to the shared asset.
+
+To mutate the shared asset (broadcasts to every Animator), go through the controller path:
 
 ```typescript
 const state = animator.findAnimatorState("xxx");
-// Play once
+if (!state) return;
+
+// Per-instance overrides.
+state.speed = 0.5;
 state.wrapMode = WrapMode.Once;
-// Loop playback
-state.wrapMode = WrapMode.Loop;
+
+// Broadcast to every Animator using this controller.
+animator.animatorController.layers[0].stateMachine.findStateByName("xxx").clip = otherClip;
 ```
 
 ### Animation Culling
diff --git a/docs/zh/animation/animator.mdx b/docs/zh/animation/animator.mdx
index 0f95eb4550..5246416625 100644
--- a/docs/zh/animation/animator.mdx
+++ b/docs/zh/animation/animator.mdx
@@ -117,11 +117,20 @@ animator.speed = 1;
 ```
 
 
-如果你只想针对某一个 `动画状态` 进行暂停，可以通过将它的速度设置为 0 来实现。
+如果你只想针对当前 `Animator` 上的某个 `动画状态` 进行暂停，将它的 per-instance 速度设为 0 即可。
 
 ```typescript
 const state = animator.findAnimatorState("xxx");
+if (!state) {
+  // 任何一个动画层都没有该状态
+  return;
+}
+
+// 仅暂停当前 Animator 实例的该状态播放。
 state.speed = 0;
+
+// 想要恢复时写回任意非零速度即可:
+// state.speed = 1;
 ```
 
 ### 过渡指定动画状态
@@ -135,26 +144,34 @@ animator.crossFade("OtherStateName", 0.3);
 
 ### 获取当前在播放的动画状态
 
-你可以使用 [getCurrentAnimatorState](/apis/core/#Animator-getCurrentAnimatorState)  方法来获取当前正在播放的 `动画状态`。参数为 `动画状态` 所在 `动画层` 的序号`layerIndex`, 详见[API 文档](/apis/core/#Animator-getCurrentAnimatorState)。获取之后可以设置 `动画状态` 的属性，比如将默认的循环播放改为一次。
+[getCurrentAnimatorState](/apis/core/#Animator-getCurrentAnimatorState) 返回指定层当前播放的 `AnimatorStateInstance`，层不存在或未在播放时返回 `null`。
 
 ```typescript
-const currentState = animator.getCurrentAnimatorState(0);
-// 播放一次
-currentState.wrapMode = WrapMode.Once;
-// 循环播放
-currentState.wrapMode = WrapMode.Loop;
+const current = animator.getCurrentAnimatorState(0);
+if (current) {
+  current.speed = 0.5;
+}
 ```
 
 ### 获取动画状态
 
-你可以使用 [findAnimatorState](/apis/core/#Animator-findAnimatorState)  方法来获取指定名称的 `动画状态` 。获取之后可以设置动画状态的属性，比如将默认的循环播放改为一次。
+[findAnimatorState](/apis/core/#Animator-findAnimatorState) 返回当前 `Animator` 独有的 `AnimatorStateInstance`（`AnimatorStateInstance | null`）。对它的写入只影响当前 Animator，共享 `AnimatorState` 资产不受影响。模式与 `Renderer.getInstanceMaterial` 一致。
+
+- `speed`、`wrapMode` 可逐实例覆盖；未写入前透传到共享默认值。
+- `name` / `clip` / `clipStartTime` / `clipEndTime` 从共享资产转发。
+
+要修改共享资产（广播到所有使用该控制器的 Animator），通过控制器路径访问：
 
 ```typescript
 const state = animator.findAnimatorState("xxx");
-// 播放一次
+if (!state) return;
+
+// 只影响当前 Animator
+state.speed = 0.5;
 state.wrapMode = WrapMode.Once;
-// 循环播放
-state.wrapMode = WrapMode.Loop;
+
+// 广播到所有使用该控制器的 Animator
+animator.animatorController.layers[0].stateMachine.findStateByName("xxx").clip = otherClip;
 ```
 
 ### 动画裁剪
diff --git a/e2e/case/animator-additive.ts b/e2e/case/animator-additive.ts
index b30f2bf983..462f8f4f51 100644
--- a/e2e/case/animator-additive.ts
+++ b/e2e/case/animator-additive.ts
@@ -56,7 +56,11 @@ WebGLEngine.create({ canvas: "canvas" }).then((engine) => {
       const additivePoseNames = animations.filter((clip) => clip.name.includes("pose")).map((clip) => clip.name);
 
       additivePoseNames.forEach((name) => {
-        const clip = animator.findAnimatorState(name).clip;
+        const state = animator.findAnimatorState(name);
+        if (!state) {
+          throw new Error(`Animator state not found: ${name}`);
+        }
+        const clip = state.clip;
         const newState = animatorStateMachine.addState(name);
         newState.clipStartTime = 1;
         newState.clip = clip;
diff --git a/e2e/case/animator-event.ts b/e2e/case/animator-event.ts
index 430b260dc2..eb83a74734 100644
--- a/e2e/case/animator-event.ts
+++ b/e2e/case/animator-event.ts
@@ -53,6 +53,9 @@ WebGLEngine.create({ canvas: "canvas" }).then((engine) => {
       const animator = defaultSceneRoot.getComponent(Animator);
 
       const state = animator.findAnimatorState("walk");
+      if (!state) {
+        throw new Error("Animator state not found: walk");
+      }
       const clip = state.clip;
 
       const event0 = new AnimationEvent();
diff --git a/e2e/case/animator-play-backwards.ts b/e2e/case/animator-play-backwards.ts
index 526d21b9ca..936a370048 100644
--- a/e2e/case/animator-play-backwards.ts
+++ b/e2e/case/animator-play-backwards.ts
@@ -33,7 +33,11 @@ WebGLEngine.create({ canvas: "canvas" }).then((engine) => {
       const { defaultSceneRoot } = gltfResource;
       rootEntity.addChild(defaultSceneRoot);
       const animator = defaultSceneRoot.getComponent(Animator);
-      animator.findAnimatorState("walk").speed = -1;
+      const walkState = animator.findAnimatorState("walk");
+      if (!walkState) {
+        throw new Error("Animator state not found: walk");
+      }
+      walkState.speed = -1;
       animator.play("walk");
       updateForE2E(engine);
 
diff --git a/e2e/case/animator-stateMachine.ts b/e2e/case/animator-stateMachine.ts
index 08fb9e6d39..4f449d8487 100644
--- a/e2e/case/animator-stateMachine.ts
+++ b/e2e/case/animator-stateMachine.ts
@@ -54,9 +54,12 @@ WebGLEngine.create({ canvas: "canvas" }).then((engine) => {
       const animator = defaultSceneRoot.getComponent(Animator)!;
       animator.animatorController.addParameter("playerSpeed", 1);
       const stateMachine = animator.animatorController.layers[0].stateMachine;
-      const idleState = animator.findAnimatorState("idle");
-      const walkState = animator.findAnimatorState("walk");
-      const runState = animator.findAnimatorState("run");
+      const idleState = stateMachine.findStateByName("idle");
+      const walkState = stateMachine.findStateByName("walk");
+      const runState = stateMachine.findStateByName("run");
+      if (!idleState || !walkState || !runState) {
+        throw new Error("Required animator states not found: idle/walk/run");
+      }
       let idleToWalkTime = 0;
       let walkToRunTime = 0;
       let runToWalkTime = 0;
@@ -70,7 +73,9 @@ WebGLEngine.create({ canvas: "canvas" }).then((engine) => {
       idleState.addTransition(toWalkTransition);
       idleToWalkTime =
         //@ts-ignore
-        toWalkTransition.exitTime * idleState._getDuration() + toWalkTransition.duration * walkState._getDuration();
+        toWalkTransition.exitTime * idleState._getDuration() +
+        //@ts-ignore
+        toWalkTransition.duration * walkState._getDuration();
 
       const exitTransition = idleState.addExitTransition();
       exitTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
@@ -97,16 +102,16 @@ WebGLEngine.create({ canvas: "canvas" }).then((engine) => {
         toIdleTransition.duration * idleState._getDuration();
 
       // to run state
-      const RunToWalkTransition = new AnimatorStateTransition();
-      RunToWalkTransition.destinationState = walkState;
-      RunToWalkTransition.duration = 0.3;
-      RunToWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Less, 0.5);
-      runState.addTransition(RunToWalkTransition);
+      const runToWalkTransition = new AnimatorStateTransition();
+      runToWalkTransition.destinationState = walkState;
+      runToWalkTransition.duration = 0.3;
+      runToWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Less, 0.5);
+      runState.addTransition(runToWalkTransition);
       runToWalkTime =
         //@ts-ignore
-        (RunToWalkTransition.exitTime - toRunTransition.duration) * runState._getDuration() +
+        (runToWalkTransition.exitTime - toRunTransition.duration) * runState._getDuration() +
         //@ts-ignore
-        RunToWalkTransition.duration * walkState._getDuration();
+        runToWalkTransition.duration * walkState._getDuration();
 
       stateMachine.addEntryStateTransition(idleState);
 
diff --git a/e2e/case/animator-stateMachineScript.ts b/e2e/case/animator-stateMachineScript.ts
index 76e5247b3a..5f6d8d9f26 100644
--- a/e2e/case/animator-stateMachineScript.ts
+++ b/e2e/case/animator-stateMachineScript.ts
@@ -55,9 +55,12 @@ WebGLEngine.create({ canvas: "canvas" }).then((engine) => {
       rootEntity.addChild(defaultSceneRoot);
 
       const animator = defaultSceneRoot.getComponent(Animator);
-      const state = animator.findAnimatorState("walk");
+      const walkState = animator.animatorController.layers[0].stateMachine.findStateByName("walk");
+      if (!walkState) {
+        throw new Error("Animator state not found: walk");
+      }
 
-      state.addStateMachineScript(
+      walkState.addStateMachineScript(
         class extends StateMachineScript {
           onStateEnter(animator: Animator, animatorState: AnimatorState, layerIndex: number): void {
             textRenderer.text = "0";
diff --git a/e2e/case/gltf-blendshape.ts b/e2e/case/gltf-blendshape.ts
index 85f3c72b72..5d4c1bde89 100644
--- a/e2e/case/gltf-blendshape.ts
+++ b/e2e/case/gltf-blendshape.ts
@@ -45,13 +45,14 @@ WebGLEngine.create({ canvas: "canvas" }).then((engine) => {
       rootEntity.addChild(defaultSceneRoot);
       const animator = defaultSceneRoot.getComponent(Animator)!;
 
-      animator.play("Right");
-      const state = animator.getCurrentAnimatorState(0);
+      // clipStartTime/clipEndTime are on the shared AnimatorState asset, not the per-Animator instance view.
+      const state = animator.animatorController.layers[0].stateMachine.findStateByName("Right");
       state.clipStartTime = 1;
       state.clipEndTime = 1;
+      animator.play("Right");
 
       updateForE2E(engine);
 
       initScreenshot(engine, camera);
     });
-});
\ No newline at end of file
+});
diff --git a/packages/core/src/Entity.ts b/packages/core/src/Entity.ts
index 9470d05817..063fbe1c1c 100644
--- a/packages/core/src/Entity.ts
+++ b/packages/core/src/Entity.ts
@@ -105,6 +105,8 @@ export class Entity extends EngineObject {
   /** @internal */
   _scripts: DisorderedArray<Script> = new DisorderedArray<Script>();
   /** @internal */
+  _scriptsVersion = 0;
+  /** @internal */
   _children: Entity[] = [];
   /** @internal */
   _scene: Scene;
@@ -341,7 +343,7 @@ export class Entity extends EngineObject {
    * @deprecated Please use `children` property instead.
    * Find child entity by index.
    * @param index - The index of the child entity
-   * @returns	The component which be found
+   * @returns The entity that was found
    */
   getChild(index: number): Entity {
     return this._children[index];
@@ -349,8 +351,8 @@ export class Entity extends EngineObject {
 
   /**
    * Find entity by name.
-   * @param name - The name of the entity which want to be found
-   * @returns The component which be found
+   * @param name - The name of the entity to find
+   * @returns The entity that was found
    */
   findByName(name: string): Entity {
     if (name === this.name) {
@@ -369,14 +371,13 @@ export class Entity extends EngineObject {
   /**
    * Find the entity by path.
    * @param path - The path of the entity eg: /entity
-   * @returns The component which be found
+   * @returns The entity that was found
    */
   findByPath(path: string): Entity {
     const splits = path.split("/").filter(Boolean);
     if (!splits.length) {
       return this;
     }
-
     return Entity._findChildByName(this, 0, splits, 0);
   }
 
@@ -538,6 +539,7 @@ export class Entity extends EngineObject {
   _addScript(script: Script) {
     script._entityScriptsIndex = this._scripts.length;
     this._scripts.add(script);
+    this._scriptsVersion++;
   }
 
   /**
@@ -547,6 +549,7 @@ export class Entity extends EngineObject {
     const replaced = this._scripts.deleteByIndex(script._entityScriptsIndex);
     replaced && (replaced._entityScriptsIndex = script._entityScriptsIndex);
     script._entityScriptsIndex = -1;
+    this._scriptsVersion++;
   }
 
   /**
diff --git a/packages/core/src/UpdateFlagManager.ts b/packages/core/src/UpdateFlagManager.ts
index 82dda34349..0e1e98ec90 100644
--- a/packages/core/src/UpdateFlagManager.ts
+++ b/packages/core/src/UpdateFlagManager.ts
@@ -5,7 +5,9 @@ import { Utils } from "./Utils";
  * @internal
  */
 export class UpdateFlagManager {
-  /** @internal */
+  /** Monotonic counter bumped on every `dispatch`; consumers can snapshot it for lazy pull-style cache invalidation. */
+  version = 0;
+
   _updateFlags: UpdateFlag[] = [];
 
   private _listeners: ((type?: number, param?: Object) => void)[] = [];
@@ -62,6 +64,8 @@ export class UpdateFlagManager {
    * @param param - Event param
    */
   dispatch(type?: number, param?: Object): void {
+    this.version++;
+
     const updateFlags = this._updateFlags;
     for (let i = updateFlags.length - 1; i >= 0; i--) {
       updateFlags[i].dispatch(type, param);
diff --git a/packages/core/src/animation/Animator.ts b/packages/core/src/animation/Animator.ts
index 180c2d1356..5e66ed0aff 100644
--- a/packages/core/src/animation/Animator.ts
+++ b/packages/core/src/animation/Animator.ts
@@ -6,11 +6,11 @@ import { Renderer } from "../Renderer";
 import { Script } from "../Script";
 import { Logger } from "../base/Logger";
 import { assignmentClone, ignoreClone } from "../clone/CloneManager";
-import { ClearableObjectPool } from "../utils/ClearableObjectPool";
 import { AnimatorController } from "./AnimatorController";
 import { AnimatorControllerLayer } from "./AnimatorControllerLayer";
 import { AnimatorControllerParameter, AnimatorControllerParameterValue } from "./AnimatorControllerParameter";
 import { AnimatorState } from "./AnimatorState";
+import { AnimatorStateInstance } from "./AnimatorStateInstance";
 import { AnimatorStateTransition } from "./AnimatorStateTransition";
 import { AnimatorStateTransitionCollection } from "./AnimatorStateTransitionCollection";
 import { KeyframeValueType } from "./Keyframe";
@@ -55,8 +55,6 @@ export class Animator extends Component {
   @ignoreClone
   private _curveOwnerPool: Record<number, Record<string, AnimationCurveOwner<KeyframeValueType>>> = Object.create(null);
   @ignoreClone
-  private _animationEventHandlerPool = new ClearableObjectPool(AnimationEventHandler);
-  @ignoreClone
   private _parametersValueMap = <Record<string, AnimatorControllerParameterValue>>Object.create(null);
 
   @ignoreClone
@@ -115,9 +113,7 @@ export class Animator extends Component {
    * @param normalizedTimeOffset - The normalized time offset (between 0 and 1, default 0) to start the state's animation from
    */
   play(stateName: string, layerIndex: number = -1, normalizedTimeOffset: number = 0): void {
-    if (this._controllerUpdateFlag?.flag) {
-      this._reset();
-    }
+    this._resetIfControllerUpdated();
 
     const stateInfo = this._getAnimatorStateInfo(stateName, layerIndex);
     const { state } = stateInfo;
@@ -192,9 +188,7 @@ export class Animator extends Component {
       return;
     }
 
-    if (this._controllerUpdateFlag?.flag) {
-      this._reset();
-    }
+    this._resetIfControllerUpdated();
 
     this._updateMark++;
 
@@ -206,20 +200,29 @@ export class Animator extends Component {
   }
 
   /**
-   * Get the playing state from the target layerIndex.
+   * Get the state instance currently playing on the target layer.
    * @param layerIndex - The layer index
+   * @returns The state instance, or null if nothing is playing
+   * @remarks The returned instance is tied to the current controller's layer data. After a controller structure change (layers added or removed), the instance is invalidated; re-call this method to get a fresh one.
    */
-  getCurrentAnimatorState(layerIndex: number): AnimatorState {
-    return this._animatorLayersData[layerIndex]?.srcPlayData?.state;
+  getCurrentAnimatorState(layerIndex: number): AnimatorStateInstance | null {
+    this._resetIfControllerUpdated();
+    return this._animatorLayersData[layerIndex]?.srcPlayData?.instance ?? null;
   }
 
   /**
-   * Get the state by name.
+   * Get the state instance for a named state on this Animator.
+   * Overrides on the returned instance only affect this Animator.
    * @param stateName - The state name
-   * @param layerIndex - The layer index(default -1). If layer is -1, find the first state with the given state name
+   * @param layerIndex - The layer index (default -1, searches all layers)
+   * @returns The state instance, or null if no state matches
+   * @remarks The returned instance is tied to the current controller's layer data. After a controller structure change (layers added or removed), the instance is invalidated; re-call this method to get a fresh one.
    */
-  findAnimatorState(stateName: string, layerIndex: number = -1): AnimatorState {
-    return this._getAnimatorStateInfo(stateName, layerIndex).state;
+  findAnimatorState(stateName: string, layerIndex: number = -1): AnimatorStateInstance | null {
+    this._resetIfControllerUpdated();
+    const { state, layerIndex: foundLayer } = this._getAnimatorStateInfo(stateName, layerIndex);
+    if (!state) return null;
+    return this._getAnimatorLayerData(foundLayer).getOrCreateInstance(state);
   }
 
   /**
@@ -324,13 +327,18 @@ export class Animator extends Component {
     this._animatorLayersData.length = 0;
     this._curveOwnerPool = Object.create(null);
     this._parametersValueMap = Object.create(null);
-    this._animationEventHandlerPool.clear();
 
     if (this._controllerUpdateFlag) {
       this._controllerUpdateFlag.flag = false;
     }
   }
 
+  private _resetIfControllerUpdated(): void {
+    if (this._controllerUpdateFlag?.flag) {
+      this._reset();
+    }
+  }
+
   /**
    * @internal
    */
@@ -358,11 +366,12 @@ export class Animator extends Component {
     normalizedTimeOffset: number,
     isFixedDuration: boolean
   ): void {
-    if (this._controllerUpdateFlag?.flag) {
-      this._reset();
-    }
+    this._resetIfControllerUpdated();
 
     const { state, layerIndex: playLayerIndex } = this._getAnimatorStateInfo(stateName, layerIndex);
+    if (!state) {
+      return;
+    }
     const { manuallyTransition } = this._getAnimatorLayerData(playLayerIndex);
     manuallyTransition.duration = duration;
 
@@ -388,8 +397,10 @@ export class Animator extends Component {
             break;
           }
         }
-      } else {
+      } else if (layerIndex >= 0 && layerIndex < layers.length) {
         state = layers[layerIndex].stateMachine.findStateByName(stateName);
+      } else {
+        layerIndex = -1;
       }
     }
     stateInfo.layerIndex = layerIndex;
@@ -398,19 +409,18 @@ export class Animator extends Component {
   }
 
   private _getAnimatorStateData(
-    stateName: string,
     animatorState: AnimatorState,
     animatorLayerData: AnimatorLayerData,
     layerIndex: number
   ): AnimatorStateData {
     const { animatorStateDataMap } = animatorLayerData;
-    let animatorStateData = animatorStateDataMap[stateName];
+    let animatorStateData = animatorStateDataMap.get(animatorState);
     if (!animatorStateData) {
-      animatorStateData = new AnimatorStateData();
-      animatorStateDataMap[stateName] = animatorStateData;
+      animatorStateData = new AnimatorStateData(animatorState);
+      animatorStateDataMap.set(animatorState, animatorStateData);
       this._saveAnimatorStateData(animatorState, animatorStateData, animatorLayerData, layerIndex);
-      this._saveAnimatorEventHandlers(animatorState, animatorStateData);
     }
+    this._ensureEventHandlers(animatorState, animatorStateData);
     return animatorStateData;
   }
 
@@ -467,34 +477,40 @@ export class Animator extends Component {
     }
   }
 
-  private _saveAnimatorEventHandlers(state: AnimatorState, animatorStateData: AnimatorStateData): void {
-    const eventHandlerPool = this._animationEventHandlerPool;
+  private _ensureEventHandlers(state: AnimatorState, animatorStateData: AnimatorStateData): void {
+    // state._updateFlagManager dispatches on both clip-swap and clip-events-mutation,
+    // so its version covers every input that affects eventHandlers binding
+    const stateVersion = state._updateFlagManager.version;
+    const scriptsVersion = this._entity._scriptsVersion;
+    if (
+      animatorStateData.eventsBuiltVersion === stateVersion &&
+      animatorStateData.eventsBuiltScriptsVersion === scriptsVersion
+    ) {
+      return;
+    }
+
     const scripts = [];
+    this._entity.getComponents(Script, scripts);
+    const scriptCount = scripts.length;
+    const { events } = state.clip;
     const { eventHandlers } = animatorStateData;
+    eventHandlers.length = 0;
+    for (let i = 0, n = events.length; i < n; i++) {
+      const event = events[i];
+      const eventHandler = new AnimationEventHandler();
+      const funcName = event.functionName;
+      const { handlers } = eventHandler;
 
-    const clipChangedListener = () => {
-      this._entity.getComponents(Script, scripts);
-      const scriptCount = scripts.length;
-      const { events } = state.clip;
-      eventHandlers.length = 0;
-      for (let i = 0, n = events.length; i < n; i++) {
-        const event = events[i];
-        const eventHandler = eventHandlerPool.get();
-        const funcName = event.functionName;
-        const { handlers } = eventHandler;
-
-        eventHandler.event = event;
-        handlers.length = 0;
-        for (let j = scriptCount - 1; j >= 0; j--) {
-          const script = scripts[j];
-          const handler = <Function>script[funcName]?.bind(script);
-          handler && handlers.push(handler);
-        }
-        eventHandlers.push(eventHandler);
+      eventHandler.event = event;
+      for (let j = scriptCount - 1; j >= 0; j--) {
+        const script = scripts[j];
+        const handler = <Function>script[funcName]?.bind(script);
+        handler && handlers.push(handler);
       }
-    };
-    clipChangedListener();
-    state._updateFlagManager.addListener(clipChangedListener);
+      eventHandlers.push(eventHandler);
+    }
+    animatorStateData.eventsBuiltVersion = stateVersion;
+    animatorStateData.eventsBuiltScriptsVersion = scriptsVersion;
   }
 
   private _clearCrossData(animatorLayerData: AnimatorLayerData): void {
@@ -521,8 +537,8 @@ export class Animator extends Component {
   }
 
   private _prepareStandbyCrossFading(animatorLayerData: AnimatorLayerData): void {
-    // Standby have two sub state, one is never play, one is finished, never play srcPlayData.state is null
-    animatorLayerData.srcPlayData.state && this._prepareSrcCrossData(animatorLayerData, true);
+    // Standby have two sub state, one is never play (srcPlayData is null), one is finished (srcPlayData is non-null)
+    animatorLayerData.srcPlayData && this._prepareSrcCrossData(animatorLayerData, true);
     // Add dest cross curve data
     this._prepareDestCrossData(animatorLayerData, true);
   }
@@ -614,9 +630,9 @@ export class Animator extends Component {
     aniUpdate: boolean
   ): void {
     const { srcPlayData } = layerData;
-    const { state } = srcPlayData;
+    const state = srcPlayData.instance._state;
 
-    const playSpeed = state.speed * this.speed;
+    const playSpeed = srcPlayData.instance.speed * this.speed;
     const playDeltaTime = playSpeed * deltaTime;
 
     srcPlayData.updateOrientation(playDeltaTime);
@@ -699,8 +715,9 @@ export class Animator extends Component {
     );
 
     if (transition) {
-      // Remove speed factor, use actual cost time
-      const remainDeltaTime = deltaTime - playCostTime / playSpeed;
+      // Remove speed factor, use actual cost time. Per-instance speed=0 means the source
+      // state is paused, so it consumes no time — pass deltaTime through to the destination.
+      const remainDeltaTime = playSpeed === 0 ? deltaTime : deltaTime - playCostTime / playSpeed;
       remainDeltaTime > 0 && this._updateState(layerData, remainDeltaTime, aniUpdate);
     }
   }
@@ -711,7 +728,7 @@ export class Animator extends Component {
     additive: boolean,
     aniUpdate: boolean
   ): void {
-    const curveBindings = playData.state.clip._curveBindings;
+    const curveBindings = playData.instance.clip._curveBindings;
     const finished = playData.playState === AnimatorStatePlayState.Finished;
 
     if (aniUpdate || finished) {
@@ -745,20 +762,20 @@ export class Animator extends Component {
   ) {
     const { srcPlayData, destPlayData, layerIndex } = layerData;
     const { speed } = this;
-    const { state: srcState } = srcPlayData;
-    const { state: destState } = destPlayData;
+    const srcState = srcPlayData.instance._state;
+    const destState = destPlayData.instance._state;
     const transitionDuration = layerData.crossFadeTransition._getFixedDuration();
 
     if (this._tryCrossFadeInterrupt(layerData, transitionDuration, destState, deltaTime, aniUpdate)) {
       return;
     }
 
-    const srcPlaySpeed = srcState.speed * speed;
-    const dstPlaySpeed = destState.speed * speed;
+    const srcPlaySpeed = srcPlayData.instance.speed * speed;
+    const dstPlaySpeed = destPlayData.instance.speed * speed;
     const dstPlayDeltaTime = dstPlaySpeed * deltaTime;
 
-    srcPlayData && srcPlayData.updateOrientation(srcPlaySpeed * deltaTime);
-    destPlayData && destPlayData.updateOrientation(dstPlayDeltaTime);
+    srcPlayData.updateOrientation(srcPlaySpeed * deltaTime);
+    destPlayData.updateOrientation(dstPlayDeltaTime);
 
     const { clipTime: lastSrcClipTime, playState: lastSrcPlayState } = srcPlayData;
     const { clipTime: lastDestClipTime, playState: lastDstPlayState } = destPlayData;
@@ -836,8 +853,8 @@ export class Animator extends Component {
     aniUpdate: boolean
   ) {
     const { crossLayerOwnerCollection } = layerData;
-    const { _curveBindings: srcCurves } = srcPlayData.state.clip;
-    const { state: destState } = destPlayData;
+    const { _curveBindings: srcCurves } = srcPlayData.instance.clip;
+    const destState = destPlayData.instance._state;
     const { _curveBindings: destCurves } = destState.clip;
 
     const finished = destPlayData.playState === AnimatorStatePlayState.Finished;
@@ -876,14 +893,14 @@ export class Animator extends Component {
     aniUpdate: boolean
   ) {
     const { destPlayData } = layerData;
-    const { state } = destPlayData;
+    const state = destPlayData.instance._state;
     const transitionDuration = layerData.crossFadeTransition._getFixedDuration();
 
     if (this._tryCrossFadeInterrupt(layerData, transitionDuration, state, deltaTime, aniUpdate)) {
       return;
     }
 
-    const playSpeed = state.speed * this.speed;
+    const playSpeed = destPlayData.instance.speed * this.speed;
     const playDeltaTime = playSpeed * deltaTime;
 
     destPlayData.updateOrientation(playDeltaTime);
@@ -950,7 +967,7 @@ export class Animator extends Component {
     aniUpdate: boolean
   ) {
     const { crossLayerOwnerCollection } = layerData;
-    const { state } = destPlayData;
+    const state = destPlayData.instance._state;
     const { _curveBindings: curveBindings } = state.clip;
 
     const { clipTime: destClipTime, playState } = destPlayData;
@@ -988,8 +1005,8 @@ export class Animator extends Component {
     aniUpdate: boolean
   ): void {
     const playData = layerData.srcPlayData;
-    const { state } = playData;
-    const actualSpeed = state.speed * this.speed;
+    const state = playData.instance._state;
+    const actualSpeed = playData.instance.speed * this.speed;
     const actualDeltaTime = actualSpeed * deltaTime;
 
     playData.updateOrientation(actualDeltaTime);
@@ -1030,7 +1047,7 @@ export class Animator extends Component {
     }
 
     const { curveLayerOwner } = playData.stateData;
-    const { _curveBindings: curveBindings } = playData.state.clip;
+    const { _curveBindings: curveBindings } = playData.instance.clip;
 
     for (let i = curveBindings.length - 1; i >= 0; i--) {
       const layerOwner = curveLayerOwner[i];
@@ -1051,14 +1068,13 @@ export class Animator extends Component {
     } else {
       layerData.layerState = LayerState.Playing;
     }
-    layerData.switchPlayData();
-    layerData.crossFadeTransition = null;
+    layerData.completeCrossFade();
   }
 
   private _preparePlayOwner(layerData: AnimatorLayerData, playState: AnimatorState): void {
     if (layerData.layerState === LayerState.Playing) {
       const srcPlayData = layerData.srcPlayData;
-      if (srcPlayData.state !== playState) {
+      if (srcPlayData.instance._state !== playState) {
         const { curveLayerOwner } = srcPlayData.stateData;
         for (let i = curveLayerOwner.length - 1; i >= 0; i--) {
           curveLayerOwner[i]?.curveOwner.revertDefaultValue();
@@ -1082,7 +1098,7 @@ export class Animator extends Component {
     deltaTime: number,
     aniUpdate: boolean
   ): AnimatorStateTransition {
-    const { state } = playData;
+    const state = playData.instance._state;
     const clipDuration = state.clip.length;
     let targetTransition: AnimatorStateTransition = null;
     const startTime = state.clipStartTime * clipDuration;
@@ -1299,19 +1315,23 @@ export class Animator extends Component {
   }
 
   private _preparePlay(state: AnimatorState, layerIndex: number, normalizedTimeOffset: number = 0): boolean {
-    const name = state.name;
     if (!state.clip) {
-      Logger.warn(`The state named ${name} has no AnimationClip data.`);
+      Logger.warn(`The state named ${state.name} has no AnimationClip data.`);
       return false;
     }
 
     const animatorLayerData = this._getAnimatorLayerData(layerIndex);
-    const animatorStateData = this._getAnimatorStateData(name, state, animatorLayerData, layerIndex);
+    const animatorStateData = this._getAnimatorStateData(state, animatorLayerData, layerIndex);
 
     this._preparePlayOwner(animatorLayerData, state);
 
     animatorLayerData.layerState = LayerState.Playing;
-    animatorLayerData.srcPlayData.reset(state, animatorStateData, state._getClipActualEndTime() * normalizedTimeOffset);
+    const playData = animatorLayerData.getOrCreateInstance(state)._playData;
+    playData.reset(animatorStateData, state._getClipActualEndTime() * normalizedTimeOffset);
+    animatorLayerData.srcPlayData = playData;
+    // Drop any dangling cross-fade slot from a previously-interrupted crossFade
+    // so a later crossFade(B) isn't wrongly no-op'd by the active-dest guard.
+    animatorLayerData.clearCrossFadeSlot();
     animatorLayerData.resetCurrentCheckIndex();
 
     return true;
@@ -1411,13 +1431,21 @@ export class Animator extends Component {
     }
 
     const animatorLayerData = this._getAnimatorLayerData(layerIndex);
-    const animatorStateData = this._getAnimatorStateData(crossState.name, crossState, animatorLayerData, layerIndex);
 
-    animatorLayerData.destPlayData.reset(
-      crossState,
-      animatorStateData,
-      transition.offset * crossState._getClipActualEndTime()
-    );
+    // Self/active-dest cross-fade is a no-op: each state has one persistent
+    // instance per layer, so a second concurrent fade has nowhere to live.
+    if (
+      animatorLayerData.srcPlayData?.instance._state === crossState ||
+      animatorLayerData.destPlayData?.instance._state === crossState
+    ) {
+      return false;
+    }
+
+    const animatorStateData = this._getAnimatorStateData(crossState, animatorLayerData, layerIndex);
+
+    const destPlayData = animatorLayerData.getOrCreateInstance(crossState)._playData;
+    destPlayData.reset(animatorStateData, transition.offset * crossState._getClipActualEndTime());
+    animatorLayerData.destPlayData = destPlayData;
     animatorLayerData.resetCurrentCheckIndex();
 
     switch (animatorLayerData.layerState) {
@@ -1452,7 +1480,8 @@ export class Animator extends Component {
     lastClipTime: number,
     deltaTime: number
   ): void {
-    const { state, isForward, clipTime } = playData;
+    const { isForward, clipTime } = playData;
+    const state = playData.instance._state;
     const startTime = state._getClipActualStartTime();
     const endTime = state._getClipActualEndTime();
 
@@ -1564,6 +1593,10 @@ export class Animator extends Component {
     lastPlayState: AnimatorStatePlayState,
     deltaTime: number
   ) {
+    // Re-check whether the clip events/scripts changed since the last build —
+    // play()/crossFade() entry points already ensure on enter, but addEvent()
+    // or addComponent(Script) after play() must also flow through.
+    this._ensureEventHandlers(state, playData.stateData);
     const { eventHandlers } = playData.stateData;
     eventHandlers.length && this._fireAnimationEvents(playData, eventHandlers, lastClipTime, deltaTime);
 
diff --git a/packages/core/src/animation/AnimatorStateInstance.ts b/packages/core/src/animation/AnimatorStateInstance.ts
new file mode 100644
index 0000000000..c966184c6a
--- /dev/null
+++ b/packages/core/src/animation/AnimatorStateInstance.ts
@@ -0,0 +1,84 @@
+import { AnimationClip } from "./AnimationClip";
+import { AnimatorState } from "./AnimatorState";
+import { AnimatorStatePlayData } from "./internal/AnimatorStatePlayData";
+import { WrapMode } from "./enums/WrapMode";
+
+/**
+ * Per-Animator view of an `AnimatorState`.
+ *
+ * The state asset is shared across every Animator that references the same controller;
+ * this view is created lazily per (Animator, state) pair and lets a single Animator
+ * override playback fields (e.g. speed, wrapMode) without affecting other Animators
+ * sharing the same controller. Unset fields fall through to the underlying state asset.
+ */
+export class AnimatorStateInstance {
+  /** @internal */
+  readonly _state: AnimatorState;
+  /** @internal */
+  readonly _playData: AnimatorStatePlayData;
+
+  private _speed: number | undefined;
+  private _wrapMode: WrapMode | undefined;
+
+  /**
+   * Name of the underlying state.
+   */
+  get name(): string {
+    return this._state.name;
+  }
+
+  /**
+   * Animation clip of the underlying state.
+   */
+  get clip(): AnimationClip {
+    return this._state.clip;
+  }
+
+  /**
+   * Normalized clip start time of the underlying state.
+   */
+  get clipStartTime(): number {
+    return this._state.clipStartTime;
+  }
+
+  /**
+   * Normalized clip end time of the underlying state.
+   */
+  get clipEndTime(): number {
+    return this._state.clipEndTime;
+  }
+
+  /**
+   * Playback speed for this Animator.
+   *
+   * Reading returns the per-instance override if set, otherwise the underlying state's speed.
+   * Writing sets the override on this instance only; other Animators sharing the controller are unaffected.
+   */
+  get speed(): number {
+    return this._speed ?? this._state.speed;
+  }
+
+  set speed(value: number) {
+    this._speed = value;
+  }
+
+  /**
+   * Wrap mode for this Animator.
+   *
+   * Reading returns the per-instance override if set, otherwise the underlying state's wrapMode.
+   * Writing sets the override on this instance only; other Animators sharing the controller are unaffected.
+   */
+  get wrapMode(): WrapMode {
+    return this._wrapMode ?? this._state.wrapMode;
+  }
+
+  set wrapMode(value: WrapMode) {
+    this._wrapMode = value;
+  }
+
+  /** @internal */
+  constructor(state: AnimatorState) {
+    this._state = state;
+    this._playData = new AnimatorStatePlayData(this);
+  }
+}
diff --git a/packages/core/src/animation/AnimatorStateMachine.ts b/packages/core/src/animation/AnimatorStateMachine.ts
index 7a2914280a..3200aab5df 100644
--- a/packages/core/src/animation/AnimatorStateMachine.ts
+++ b/packages/core/src/animation/AnimatorStateMachine.ts
@@ -17,9 +17,9 @@ export class AnimatorStateMachine {
 
   /**
    * The state will be played automatically.
-   * @remarks When the Animator's AnimatorController changed or the Animator's onEnable be triggered.
+   * @remarks When the Animator's AnimatorController changed or the Animator's onEnable be triggered. Cleared to `null` if the state is removed via `removeState`.
    */
-  defaultState: AnimatorState;
+  defaultState: AnimatorState | null = null;
 
   /** @internal */
   _entryTransitionCollection = new AnimatorStateTransitionCollection();
@@ -68,8 +68,11 @@ export class AnimatorStateMachine {
     const index = this.states.indexOf(state);
     if (index > -1) {
       this.states.splice(index, 1);
+      delete this._statesMap[name];
+      if (this.defaultState === state) {
+        this.defaultState = null;
+      }
     }
-    delete this._statesMap[name];
   }
 
   /**
diff --git a/packages/core/src/animation/index.ts b/packages/core/src/animation/index.ts
index b829ffde54..1bbffce883 100644
--- a/packages/core/src/animation/index.ts
+++ b/packages/core/src/animation/index.ts
@@ -11,6 +11,7 @@ export { Animator } from "./Animator";
 export { AnimatorController } from "./AnimatorController";
 export { AnimatorControllerLayer } from "./AnimatorControllerLayer";
 export { AnimatorState } from "./AnimatorState";
+export { AnimatorStateInstance } from "./AnimatorStateInstance";
 export { AnimatorStateMachine } from "./AnimatorStateMachine";
 export { AnimatorStateTransition } from "./AnimatorStateTransition";
 export { AnimatorConditionMode } from "./enums/AnimatorConditionMode";
diff --git a/packages/core/src/animation/internal/AnimatorLayerData.ts b/packages/core/src/animation/internal/AnimatorLayerData.ts
index a7bd04f1a5..a3b2677c0b 100644
--- a/packages/core/src/animation/internal/AnimatorLayerData.ts
+++ b/packages/core/src/animation/internal/AnimatorLayerData.ts
@@ -1,9 +1,11 @@
 import { AnimatorControllerLayer } from "../AnimatorControllerLayer";
+import { AnimatorState } from "../AnimatorState";
+import { AnimatorStateInstance } from "../AnimatorStateInstance";
 import { AnimatorStateTransition } from "../AnimatorStateTransition";
 import { LayerState } from "../enums/LayerState";
 import { AnimationCurveLayerOwner } from "./AnimationCurveLayerOwner";
 import { AnimatorStateData } from "./AnimatorStateData";
-import { AnimatorStatePlayData } from "./AnimatorStatePlayData";
+import type { AnimatorStatePlayData } from "./AnimatorStatePlayData";
 
 /**
  * @internal
@@ -12,20 +14,35 @@ export class AnimatorLayerData {
   layerIndex: number;
   layer: AnimatorControllerLayer;
   curveOwnerPool: Record<number, Record<string, AnimationCurveLayerOwner>> = Object.create(null);
-  animatorStateDataMap: Record<string, AnimatorStateData> = {};
-  srcPlayData: AnimatorStatePlayData = new AnimatorStatePlayData();
-  destPlayData: AnimatorStatePlayData = new AnimatorStatePlayData();
+  animatorStateDataMap: WeakMap<AnimatorState, AnimatorStateData> = new WeakMap();
+  instanceMap: WeakMap<AnimatorState, AnimatorStateInstance> = new WeakMap();
+  srcPlayData: AnimatorStatePlayData | null = null;
+  destPlayData: AnimatorStatePlayData | null = null;
   layerState: LayerState = LayerState.Standby;
   crossCurveMark: number = 0;
   manuallyTransition: AnimatorStateTransition = new AnimatorStateTransition();
   crossFadeTransition: AnimatorStateTransition;
   crossLayerOwnerCollection: AnimationCurveLayerOwner[] = [];
 
-  switchPlayData(): void {
-    const srcPlayData = this.destPlayData;
-    const switchTemp = this.srcPlayData;
-    this.srcPlayData = srcPlayData;
-    this.destPlayData = switchTemp;
+  getOrCreateInstance(state: AnimatorState): AnimatorStateInstance {
+    const map = this.instanceMap;
+    let instance = map.get(state);
+    if (!instance) {
+      instance = new AnimatorStateInstance(state);
+      map.set(state, instance);
+    }
+    return instance;
+  }
+
+  completeCrossFade(): void {
+    this.srcPlayData = this.destPlayData;
+    this.destPlayData = null;
+    this.crossFadeTransition = null;
+  }
+
+  clearCrossFadeSlot(): void {
+    this.destPlayData = null;
+    this.crossFadeTransition = null;
   }
 
   resetCurrentCheckIndex(): void {
diff --git a/packages/core/src/animation/internal/AnimatorStateData.ts b/packages/core/src/animation/internal/AnimatorStateData.ts
index 146c0bb52f..08d455ac38 100644
--- a/packages/core/src/animation/internal/AnimatorStateData.ts
+++ b/packages/core/src/animation/internal/AnimatorStateData.ts
@@ -1,3 +1,4 @@
+import { AnimatorState } from "../AnimatorState";
 import { AnimationCurveLayerOwner } from "./AnimationCurveLayerOwner";
 import { AnimationEventHandler } from "./AnimationEventHandler";
 
@@ -7,4 +8,8 @@ import { AnimationEventHandler } from "./AnimationEventHandler";
 export class AnimatorStateData {
   curveLayerOwner: AnimationCurveLayerOwner[] = [];
   eventHandlers: AnimationEventHandler[] = [];
+  eventsBuiltVersion = -1;
+  eventsBuiltScriptsVersion = -1;
+
+  constructor(readonly state: AnimatorState) {}
 }
diff --git a/packages/core/src/animation/internal/AnimatorStatePlayData.ts b/packages/core/src/animation/internal/AnimatorStatePlayData.ts
index 7d10fc2324..a4f2c80142 100644
--- a/packages/core/src/animation/internal/AnimatorStatePlayData.ts
+++ b/packages/core/src/animation/internal/AnimatorStatePlayData.ts
@@ -1,4 +1,4 @@
-import { AnimatorState } from "../AnimatorState";
+import { AnimatorStateInstance } from "../AnimatorStateInstance";
 import { AnimatorStatePlayState } from "../enums/AnimatorStatePlayState";
 import { WrapMode } from "../enums/WrapMode";
 import { AnimatorStateData } from "./AnimatorStateData";
@@ -7,27 +7,30 @@ import { AnimatorStateData } from "./AnimatorStateData";
  * @internal
  */
 export class AnimatorStatePlayData {
-  state: AnimatorState;
   stateData: AnimatorStateData;
-  playedTime: number;
-  playState: AnimatorStatePlayState;
-  clipTime: number;
-  currentEventIndex: number;
-  isForward = true;
-  offsetFrameTime: number;
 
-  private _changedOrientation = false;
+  playedTime: number = 0;
+  playState: AnimatorStatePlayState = AnimatorStatePlayState.UnStarted;
+  clipTime: number = 0;
+  currentEventIndex: number = 0;
+  isForward: boolean = true;
+  offsetFrameTime: number = 0;
 
-  reset(state: AnimatorState, stateData: AnimatorStateData, offsetFrameTime: number): void {
-    this.state = state;
-    this.playedTime = 0;
-    this.offsetFrameTime = offsetFrameTime;
+  private _changedOrientation: boolean = false;
+
+  constructor(public readonly instance: AnimatorStateInstance) {}
+
+  reset(stateData: AnimatorStateData, offsetFrameTime: number): void {
+    const state = this.instance._state;
     this.stateData = stateData;
+    this.offsetFrameTime = offsetFrameTime;
+    this.playedTime = 0;
     this.playState = AnimatorStatePlayState.UnStarted;
     this.clipTime = state.clipStartTime * state.clip.length;
     this.currentEventIndex = 0;
     this.isForward = true;
-    this.state._transitionCollection.needResetCurrentCheckIndex = true;
+    this._changedOrientation = false;
+    state._transitionCollection.needResetCurrentCheckIndex = true;
   }
 
   updateOrientation(deltaTime: number): void {
@@ -43,11 +46,12 @@ export class AnimatorStatePlayData {
 
   update(deltaTime: number): void {
     this.playedTime += deltaTime;
-    const state = this.state;
+    const instance = this.instance;
+    const state = instance._state;
     let time = this.playedTime + this.offsetFrameTime;
     const duration = state._getDuration();
     this.playState = AnimatorStatePlayState.Playing;
-    if (state.wrapMode === WrapMode.Loop) {
+    if (instance.wrapMode === WrapMode.Loop) {
       time = duration ? time % duration : 0;
     } else {
       if (Math.abs(time) >= duration) {
@@ -65,8 +69,9 @@ export class AnimatorStatePlayData {
     }
   }
 
-  private _correctTime() {
-    const { state } = this;
+  private _correctTime(): void {
+    const state = this.instance._state;
+    // Reverse playback at clipTime=0 would step into negatives; jump to clipEnd.
     if (this.clipTime === 0) {
       this.clipTime = state.clipEndTime * state.clip.length;
     }
diff --git a/packages/loader/src/gltf/parser/GLTFParserContext.ts b/packages/loader/src/gltf/parser/GLTFParserContext.ts
index 83f9f65124..b549da5ca2 100644
--- a/packages/loader/src/gltf/parser/GLTFParserContext.ts
+++ b/packages/loader/src/gltf/parser/GLTFParserContext.ts
@@ -116,13 +116,13 @@ export class GLTFParserContext {
 
       return AssetPromise.all([
         this.get<void>(GLTFParserType.Validator),
+        this.get<Entity>(GLTFParserType.Scene),
         this.get<Texture2D>(GLTFParserType.Texture),
         this.get<Material>(GLTFParserType.Material),
         this.get<ModelMesh[]>(GLTFParserType.Mesh),
         this.get<Skin>(GLTFParserType.Skin),
         this.get<AnimationClip>(GLTFParserType.Animation),
-        this.get<AnimatorController>(GLTFParserType.AnimatorController),
-        this.get<Entity>(GLTFParserType.Scene)
+        this.get<AnimatorController>(GLTFParserType.AnimatorController)
       ]).then(() => {
         const glTFResource = this.glTFResource;
         const animatorController = glTFResource.animatorController;
diff --git a/packages/loader/src/gltf/parser/GLTFSkinParser.ts b/packages/loader/src/gltf/parser/GLTFSkinParser.ts
index 7c1580e4ca..e8959b4b70 100644
--- a/packages/loader/src/gltf/parser/GLTFSkinParser.ts
+++ b/packages/loader/src/gltf/parser/GLTFSkinParser.ts
@@ -34,17 +34,20 @@ export class GLTFSkinParser extends GLTFParser {
       }
       skin.bones = bones;
 
-      // Get skeleton
+      // Get skeleton — when `skin.skeleton` is absent, resolve via joints' LCA
+      // LCA falls back to the GLTF_ROOT wrapper only when joints span multiple top-level scene nodes
       if (skeleton !== undefined) {
         const rootBone = entities[skeleton];
+        if (!rootBone) {
+          throw `Skin skeleton index ${skeleton} is out of range.`;
+        }
         skin.rootBone = rootBone;
       } else {
         const rootBone = this._findSkeletonRootBone(joints, entities);
-        if (rootBone) {
-          skin.rootBone = rootBone;
-        } else {
+        if (!rootBone) {
           throw "Failed to find skeleton root bone.";
         }
+        skin.rootBone = rootBone;
       }
 
       return skin;
@@ -53,7 +56,11 @@ export class GLTFSkinParser extends GLTFParser {
     return AssetPromise.resolve(skinPromise);
   }
 
-  private _findSkeletonRootBone(joints: number[], entities: Entity[]): Entity {
+  /**
+   * Resolve the skeleton rootBone as the lowest common ancestor of the joints' parent chains.
+   * Returns null when joints share no common ancestor.
+   */
+  private _findSkeletonRootBone(joints: number[], entities: Entity[]): Entity | null {
     const paths = <Record<number, Entity[]>>{};
     for (const index of joints) {
       const path = new Array<Entity>();
@@ -65,7 +72,7 @@ export class GLTFSkinParser extends GLTFParser {
       paths[index] = path;
     }
 
-    let rootNode = <Entity>null;
+    let rootNode: Entity | null = null;
     for (let i = 0; ; i++) {
       let path = paths[joints[0]];
       if (i >= path.length) {
diff --git a/tests/src/core/Animator.test.ts b/tests/src/core/Animator.test.ts
index 044312c943..9544a7591e 100644
--- a/tests/src/core/Animator.test.ts
+++ b/tests/src/core/Animator.test.ts
@@ -20,7 +20,7 @@ import {
 } from "@galacean/engine-core";
 import "@galacean/engine-loader";
 import type { GLTFResource } from "@galacean/engine-loader";
-import { Quaternion } from "@galacean/engine-math";
+import { Quaternion, Vector3 } from "@galacean/engine-math";
 import { WebGLEngine } from "@galacean/engine";
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
 import { glbResource } from "./model/fox";
@@ -70,16 +70,18 @@ describe("Animator test", function () {
     stateMachine.clearAnyStateTransitions();
     stateMachine.clearEntryStateTransitions();
 
-    // 清理各状态的 transitions 并恢复默认属性
+    // 清理各状态的 transitions 并恢复默认属性 (mutate shared AnimatorState)
     const stateNames = ["Survey", "Walk", "Run"];
     for (const name of stateNames) {
-      const state = animator.findAnimatorState(name);
-      if (state) {
-        state.clearTransitions();
-        state.speed = 1;
-        state.clipStartTime = 0;
-        state.clipEndTime = 1;
-        state.wrapMode = WrapMode.Loop;
+      const view = animator.findAnimatorState(name);
+      if (view) {
+        const def = (view as any)._state;
+        def.clearTransitions();
+        def.speed = 1;
+        def.clipStartTime = 0;
+        def.clipEndTime = 1;
+        def.wrapMode = WrapMode.Loop;
+        def.clip?.clearEvents();
       }
     }
   });
@@ -196,9 +198,9 @@ describe("Animator test", function () {
   it("find animator state", () => {
     const stateName = "Survey";
     const expectedStateName = "Run";
-    const layerIndex = animator["_tempAnimatorStateInfo"].layerIndex;
 
     animator.play(stateName);
+    const layerIndex = animator["_tempAnimatorStateInfo"].layerIndex;
     const currentAnimatorState = animator.getCurrentAnimatorState(layerIndex);
     let animatorState = animator.findAnimatorState(stateName, layerIndex);
     expect(animatorState).to.eq(currentAnimatorState);
@@ -206,7 +208,7 @@ describe("Animator test", function () {
     animator.play(expectedStateName);
     animatorState = animator.findAnimatorState(expectedStateName, layerIndex);
     expect(animatorState).not.to.eq(currentAnimatorState);
-    expect(animatorState.name).to.eq(expectedStateName);
+    expect(animatorState?.name).to.eq(expectedStateName);
   });
 
   it("animation getCurrentAnimatorState", () => {
@@ -250,25 +252,25 @@ describe("Animator test", function () {
     // @ts-ignore
     const layerData = animator._getAnimatorLayerData(0);
     const srcPlayData = layerData.srcPlayData;
-    expect(srcPlayData.state.name).to.eq("Run");
+    expect(srcPlayData.instance.name).to.eq("Run");
     expect(srcPlayData.playedTime).to.eq(0.3);
     // @ts-ignore
-    expect(srcPlayData.clipTime).to.eq(0.3 + 0.1 * runState._getDuration());
+    expect(srcPlayData.clipTime).to.eq(0.3 + 0.1 * (runState as any)._state._getDuration());
   });
 
   it("animation cross fade by transition", () => {
     const walkState = animator.findAnimatorState("Walk");
     const runState = animator.findAnimatorState("Run");
     const transition = new AnimatorStateTransition();
-    transition.destinationState = runState;
+    transition.destinationState = (runState as any)._state;
     transition.duration = 1;
     transition.exitTime = 1;
-    walkState.addTransition(transition);
+    (walkState as any)._state.addTransition(transition);
 
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update(walkState.clip.length - 0.1);
+    animator.update((walkState as any)._state.clip.length - 0.1);
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
@@ -311,7 +313,7 @@ describe("Animator test", function () {
     additiveLayer.mask = mask;
     additiveLayer.blendingMode = AnimatorLayerBlendingMode.Additive;
     animatorController.addLayer(additiveLayer);
-    const clip = animator.findAnimatorState("Run").clip;
+    const clip = (animator.findAnimatorState("Run") as any)._state.clip;
     const newState = animatorStateMachine.addState("Run");
     newState.clipStartTime = 1;
     newState.clip = clip;
@@ -350,7 +352,7 @@ describe("Animator test", function () {
     animator.play("Walk");
 
     class TestScript extends Script {
-      event0(): void { }
+      event0(): void {}
     }
 
     const testScript = animator.entity.addComponent(TestScript);
@@ -366,17 +368,77 @@ describe("Animator test", function () {
     expect(testScriptSpy).toHaveBeenCalledTimes(1);
   });
 
+  it("eventHandlers rebuild when Script is added after play (no clip event mutation)", () => {
+    const event = new AnimationEvent();
+    event.functionName = "event0";
+    event.time = 0;
+    const state = animator.findAnimatorState("Walk")!;
+    state.clip.addEvent(event); // event exists before play
+
+    animator.play("Walk"); // script not yet attached; first build sees zero scripts
+
+    class TestScript extends Script {
+      event0(): void {}
+    }
+    const script = animator.entity.addComponent(TestScript); // does NOT bump clip _version
+    const spy = vi.spyOn(script, "event0");
+
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it("eventHandlers rebuild when state.clip is swapped (state version covers clip swap)", () => {
+    const walkState = animator.animatorController.layers[0].stateMachine.findStateByName("Walk");
+    const runState = animator.animatorController.layers[0].stateMachine.findStateByName("Run");
+    const originalClip = walkState.clip;
+
+    // Old clip: add an event matching event0
+    const oldEvent = new AnimationEvent();
+    oldEvent.functionName = "event0";
+    oldEvent.time = 0;
+    originalClip.addEvent(oldEvent);
+
+    class TestScript extends Script {
+      event0(): void {}
+    }
+    const script = animator.entity.addComponent(TestScript);
+    const spy0 = vi.spyOn(script, "event0");
+
+    animator.play("Walk");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+    expect(spy0).toHaveBeenCalledTimes(1);
+
+    // Swap to a different real clip (Run's) that has no event0; even if the new clip's
+    // _version happens to match the prior snapshot, the swap itself must invalidate the
+    // cached eventHandlers via state._updateFlagManager dispatch
+    walkState.clip = runState.clip;
+
+    spy0.mockClear();
+    animator.play("Walk");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+    expect(spy0).toHaveBeenCalledTimes(0); // swapped clip has no event0
+
+    // restore for other tests
+    walkState.clip = originalClip;
+  });
+
   it("stateMachine", () => {
     animator.animatorController.addParameter("playerSpeed", 1);
     const stateMachine = animator.animatorController.layers[0].stateMachine;
     const idleState = animator.findAnimatorState("Survey");
     const idleSpeed = 2;
     idleState.speed = idleSpeed;
-    idleState.clearTransitions();
+    (idleState as any)._state.clearTransitions();
     const walkState = animator.findAnimatorState("Walk");
-    walkState.clearTransitions();
+    (walkState as any)._state.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    runState.clearTransitions();
+    (runState as any)._state.clearTransitions();
     let idleToWalkTime = 0;
     let walkToRunTime = 0;
     let runToWalkTime = 0;
@@ -384,68 +446,68 @@ describe("Animator test", function () {
 
     // handle idle state
     const toWalkTransition = new AnimatorStateTransition();
-    toWalkTransition.destinationState = walkState;
+    toWalkTransition.destinationState = (walkState as any)._state;
     toWalkTransition.duration = 0.2;
     toWalkTransition.exitTime = 0.9;
     toWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Greater, 0);
-    idleState.addTransition(toWalkTransition);
+    (idleState as any)._state.addTransition(toWalkTransition);
     idleToWalkTime =
       //@ts-ignore
-      (toWalkTransition.exitTime * idleState._getDuration()) / idleSpeed +
+      (toWalkTransition.exitTime * (idleState as any)._state._getDuration()) / idleSpeed +
       //@ts-ignore
-      toWalkTransition.duration * walkState._getDuration();
+      toWalkTransition.duration * (walkState as any)._state._getDuration();
 
-    const exitTransition = idleState.addExitTransition();
+    const exitTransition = (idleState as any)._state.addExitTransition();
     exitTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
     // to walk state
     const toRunTransition = new AnimatorStateTransition();
-    toRunTransition.destinationState = runState;
+    toRunTransition.destinationState = (runState as any)._state;
     toRunTransition.duration = 0.3;
     toRunTransition.exitTime = 0.9;
     toRunTransition.addCondition("playerSpeed", AnimatorConditionMode.Greater, 0.5);
-    walkState.addTransition(toRunTransition);
+    (walkState as any)._state.addTransition(toRunTransition);
     walkToRunTime =
       //@ts-ignore
-      (toRunTransition.exitTime - toWalkTransition.duration) * walkState._getDuration() +
+      (toRunTransition.exitTime - toWalkTransition.duration) * (walkState as any)._state._getDuration() +
       //@ts-ignore
-      toRunTransition.duration * runState._getDuration();
+      toRunTransition.duration * (runState as any)._state._getDuration();
     const toIdleTransition = new AnimatorStateTransition();
-    toIdleTransition.destinationState = idleState;
+    toIdleTransition.destinationState = (idleState as any)._state;
     toIdleTransition.duration = 0.3;
     toIdleTransition.exitTime = 0.9;
     toIdleTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
-    walkState.addTransition(toIdleTransition);
+    (walkState as any)._state.addTransition(toIdleTransition);
     walkToIdleTime =
       //@ts-ignore
-      (toIdleTransition.exitTime - toRunTransition.duration) * walkState._getDuration() +
+      (toIdleTransition.exitTime - toRunTransition.duration) * (walkState as any)._state._getDuration() +
       //@ts-ignore
-      (toIdleTransition.duration * idleState._getDuration()) / idleSpeed;
+      (toIdleTransition.duration * (idleState as any)._state._getDuration()) / idleSpeed;
 
     // to run state
     const runToWalkTransition = new AnimatorStateTransition();
-    runToWalkTransition.destinationState = walkState;
+    runToWalkTransition.destinationState = (walkState as any)._state;
     runToWalkTransition.duration = 0.3;
     runToWalkTransition.exitTime = 0.9;
     runToWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Less, 0.5);
-    runState.addTransition(runToWalkTransition);
+    (runState as any)._state.addTransition(runToWalkTransition);
     runToWalkTime =
       //@ts-ignore
-      (runToWalkTransition.exitTime - toRunTransition.duration) * runState._getDuration() +
+      (runToWalkTransition.exitTime - toRunTransition.duration) * (runState as any)._state._getDuration() +
       //@ts-ignore
-      runToWalkTransition.duration * walkState._getDuration();
+      runToWalkTransition.duration * (walkState as any)._state._getDuration();
 
-    stateMachine.addEntryStateTransition(idleState);
+    stateMachine.addEntryStateTransition((idleState as any)._state);
 
-    const anyTransition = stateMachine.addAnyStateTransition(idleState);
+    const anyTransition = stateMachine.addAnyStateTransition((idleState as any)._state);
     anyTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
     anyTransition.duration = 0.3;
     anyTransition.hasExitTime = true;
     anyTransition.exitTime = 0.7;
     let anyToIdleTime =
       // @ts-ignore
-      (anyTransition.exitTime - toIdleTransition.duration) * walkState._getDuration() +
+      (anyTransition.exitTime - toIdleTransition.duration) * (walkState as any)._state._getDuration() +
       // @ts-ignore
-      (anyTransition.duration * idleState._getDuration()) / idleSpeed;
+      (anyTransition.duration * (idleState as any)._state._getDuration()) / idleSpeed;
 
     // @ts-ignore
     animator.engine.time._frameCount++;
@@ -497,11 +559,11 @@ describe("Animator test", function () {
     const idleState = animator.findAnimatorState("Survey");
     const idleSpeed = 2;
     idleState.speed = idleSpeed;
-    idleState.clearTransitions();
+    (idleState as any)._state.clearTransitions();
     const walkState = animator.findAnimatorState("Walk");
-    walkState.clearTransitions();
+    (walkState as any)._state.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    runState.clearTransitions();
+    (runState as any)._state.clearTransitions();
     let idleToWalkTime = 0;
     let walkToRunTime = 0;
     let runToWalkTime = 0;
@@ -509,68 +571,68 @@ describe("Animator test", function () {
 
     // handle idle state
     const toWalkTransition = new AnimatorStateTransition();
-    toWalkTransition.destinationState = walkState;
+    toWalkTransition.destinationState = (walkState as any)._state;
     toWalkTransition.duration = 0.2;
     toWalkTransition.exitTime = 0.1;
     toWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Greater, 0);
-    idleState.addTransition(toWalkTransition);
+    (idleState as any)._state.addTransition(toWalkTransition);
     idleToWalkTime =
       //@ts-ignore
-      ((1 - toWalkTransition.exitTime) * idleState._getDuration()) / idleSpeed +
+      ((1 - toWalkTransition.exitTime) * (idleState as any)._state._getDuration()) / idleSpeed +
       //@ts-ignore
-      toWalkTransition.duration * walkState._getDuration();
+      toWalkTransition.duration * (walkState as any)._state._getDuration();
 
-    const exitTransition = idleState.addExitTransition();
+    const exitTransition = (idleState as any)._state.addExitTransition();
     exitTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
     // to walk state
     const toRunTransition = new AnimatorStateTransition();
-    toRunTransition.destinationState = runState;
+    toRunTransition.destinationState = (runState as any)._state;
     toRunTransition.duration = 0.3;
     toRunTransition.exitTime = 0.1;
     toRunTransition.addCondition("playerSpeed", AnimatorConditionMode.Greater, 0.5);
-    walkState.addTransition(toRunTransition);
+    (walkState as any)._state.addTransition(toRunTransition);
     walkToRunTime =
       //@ts-ignore
-      (1 - toRunTransition.exitTime - toWalkTransition.duration) * walkState._getDuration() +
+      (1 - toRunTransition.exitTime - toWalkTransition.duration) * (walkState as any)._state._getDuration() +
       //@ts-ignore
-      toRunTransition.duration * runState._getDuration();
+      toRunTransition.duration * (runState as any)._state._getDuration();
     const toIdleTransition = new AnimatorStateTransition();
-    toIdleTransition.destinationState = idleState;
+    toIdleTransition.destinationState = (idleState as any)._state;
     toIdleTransition.duration = 0.3;
     toIdleTransition.exitTime = 0.1;
     toIdleTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
-    walkState.addTransition(toIdleTransition);
+    (walkState as any)._state.addTransition(toIdleTransition);
     walkToIdleTime =
       //@ts-ignore
-      (1 - toIdleTransition.exitTime - toRunTransition.duration) * walkState._getDuration() +
+      (1 - toIdleTransition.exitTime - toRunTransition.duration) * (walkState as any)._state._getDuration() +
       //@ts-ignore
-      (toIdleTransition.duration * idleState._getDuration()) / idleSpeed;
+      (toIdleTransition.duration * (idleState as any)._state._getDuration()) / idleSpeed;
 
     // to run state
     const runToWalkTransition = new AnimatorStateTransition();
-    runToWalkTransition.destinationState = walkState;
+    runToWalkTransition.destinationState = (walkState as any)._state;
     runToWalkTransition.duration = 0.3;
     runToWalkTransition.exitTime = 0.1;
     runToWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Less, 0.5);
-    runState.addTransition(runToWalkTransition);
+    (runState as any)._state.addTransition(runToWalkTransition);
     runToWalkTime =
       //@ts-ignore
-      (1 - runToWalkTransition.exitTime - toRunTransition.duration) * runState._getDuration() +
+      (1 - runToWalkTransition.exitTime - toRunTransition.duration) * (runState as any)._state._getDuration() +
       //@ts-ignore
-      runToWalkTransition.duration * walkState._getDuration();
+      runToWalkTransition.duration * (walkState as any)._state._getDuration();
 
-    stateMachine.addEntryStateTransition(idleState);
+    stateMachine.addEntryStateTransition((idleState as any)._state);
 
-    const anyTransition = stateMachine.addAnyStateTransition(idleState);
+    const anyTransition = stateMachine.addAnyStateTransition((idleState as any)._state);
     anyTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
     anyTransition.duration = 0.3;
     anyTransition.hasExitTime = true;
     anyTransition.exitTime = 0.3;
     let anyToIdleTime =
       // @ts-ignore
-      (1 - anyTransition.exitTime - toIdleTransition.duration) * walkState._getDuration() +
+      (1 - anyTransition.exitTime - toIdleTransition.duration) * (walkState as any)._state._getDuration() +
       // @ts-ignore
-      (anyTransition.duration * idleState._getDuration()) / idleSpeed;
+      (anyTransition.duration * (idleState as any)._state._getDuration()) / idleSpeed;
 
     // @ts-ignore
     animator.engine.time._frameCount++;
@@ -614,10 +676,10 @@ describe("Animator test", function () {
 
   it("transitionOffset", () => {
     const walkState = animator.findAnimatorState("Walk");
-    walkState.clearTransitions();
+    (walkState as any)._state.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    runState.clearTransitions();
-    const toRunTransition = walkState.addTransition(runState);
+    (runState as any)._state.clearTransitions();
+    const toRunTransition = (walkState as any)._state.addTransition((runState as any)._state);
     toRunTransition.exitTime = 0;
     toRunTransition.duration = 1;
     toRunTransition.offset = 0.5;
@@ -627,7 +689,7 @@ describe("Animator test", function () {
     animator.update(0.01);
 
     const destPlayData = animator["_animatorLayersData"][0].destPlayData;
-    const destState = destPlayData.state;
+    const destState = (destPlayData.instance as any)._state;
     const transitionDuration = toRunTransition.duration * destState._getDuration();
     const crossWeight = animator["_animatorLayersData"][0].destPlayData.playedTime / transitionDuration;
     expect(crossWeight).to.lessThan(0.01);
@@ -636,21 +698,21 @@ describe("Animator test", function () {
   it("clipStartTime crossFade", () => {
     const walkState = animator.findAnimatorState("Walk");
     walkState.wrapMode = WrapMode.Once;
-    walkState.clipStartTime = 0.8;
-    walkState.clearTransitions();
+    (walkState as any)._state.clipStartTime = 0.8;
+    (walkState as any)._state.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    runState.clearTransitions();
-    const toRunTransition = walkState.addTransition(runState);
+    (runState as any)._state.clearTransitions();
+    const toRunTransition = (walkState as any)._state.addTransition((runState as any)._state);
     toRunTransition.exitTime = 0.5;
     toRunTransition.duration = 1;
-    runState.clipStartTime = 0.5;
+    (runState as any)._state.clipStartTime = 0.5;
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
 
     const destPlayData = animator["_animatorLayersData"][0].destPlayData;
-    expect(destPlayData.state?.name).to.eq("Run");
+    expect(destPlayData.instance?.name).to.eq("Run");
   });
 
   it("transition to exit but no entry", () => {
@@ -658,8 +720,8 @@ describe("Animator test", function () {
 
     const walkState = animator.findAnimatorState("Walk");
     walkState.wrapMode = WrapMode.Once;
-    walkState.clearTransitions();
-    walkState.addExitTransition();
+    (walkState as any)._state.clearTransitions();
+    (walkState as any)._state.addExitTransition();
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
@@ -792,8 +854,8 @@ describe("Animator test", function () {
     animator.animatorController = animatorController;
 
     class TestScript extends StateMachineScript {
-      onStateEnter(animator) { }
-      onStateExit(animator) { }
+      onStateEnter(animator) {}
+      onStateExit(animator) {}
     }
 
     const testScript = state1.addStateMachineScript(TestScript);
@@ -826,15 +888,15 @@ describe("Animator test", function () {
     stateMachine.clearAnyStateTransitions();
     const walkState = animator.findAnimatorState("Run");
     // For test clipStartTime is not 0 and transition duration is 0
-    walkState.clipStartTime = 0.5;
-    walkState.addStateMachineScript(
+    (walkState as any)._state.clipStartTime = 0.5;
+    (walkState as any)._state.addStateMachineScript(
       class extends StateMachineScript {
         onStateEnter(animator) {
           animator.setParameterValue("playRun", 0);
         }
       }
     );
-    const transition = stateMachine.addAnyStateTransition(animator.findAnimatorState("Run"));
+    const transition = stateMachine.addAnyStateTransition((animator.findAnimatorState("Run") as any)._state);
     transition.addCondition("playRun", AnimatorConditionMode.Equals, 1);
     // For test clipStartTime is not 0 and transition duration is 0
     transition.duration = 0;
@@ -845,9 +907,9 @@ describe("Animator test", function () {
     animator.engine.time._frameCount++;
     animator.update(0.5);
 
-    expect(layerData.srcPlayData.state.name).to.eq("Run");
+    expect(layerData.srcPlayData.instance.name).to.eq("Run");
     expect(layerData.srcPlayData.playedTime).to.eq(0.5);
-    expect(layerData.srcPlayData.clipTime).to.eq(walkState.clip.length * 0.5 + 0.5);
+    expect(layerData.srcPlayData.clipTime).to.eq((walkState as any)._state.clip.length * 0.5 + 0.5);
   });
 
   it("hasExitTime", () => {
@@ -860,13 +922,13 @@ describe("Animator test", function () {
     stateMachine.clearAnyStateTransitions();
     const idleState = animator.findAnimatorState("Survey");
     idleState.speed = 1;
-    idleState.clearTransitions();
+    (idleState as any)._state.clearTransitions();
     const walkState = animator.findAnimatorState("Walk");
-    walkState.clipStartTime = 0;
-    walkState.clearTransitions();
+    (walkState as any)._state.clipStartTime = 0;
+    (walkState as any)._state.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    runState.clearTransitions();
-    const walkToRunTransition = walkState.addTransition(runState);
+    (runState as any)._state.clearTransitions();
+    const walkToRunTransition = (walkState as any)._state.addTransition((runState as any)._state);
     walkToRunTransition.hasExitTime = true;
     walkToRunTransition.exitTime = 0.5;
     walkToRunTransition.duration = 0;
@@ -874,10 +936,10 @@ describe("Animator test", function () {
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update(walkState.clip.length * 0.5);
-    expect(layerData.destPlayData.state.name).to.eq("Run");
+    animator.update((walkState as any)._state.clip.length * 0.5);
+    expect(layerData.destPlayData.instance.name).to.eq("Run");
     expect(layerData.destPlayData.playedTime).to.eq(0);
-    const anyToIdleTransition = stateMachine.addAnyStateTransition(idleState);
+    const anyToIdleTransition = stateMachine.addAnyStateTransition((idleState as any)._state);
     anyToIdleTransition.hasExitTime = false;
     anyToIdleTransition.duration = 0.2;
     anyToIdleTransition.addCondition("triggerIdle", AnimatorConditionMode.If, true);
@@ -885,13 +947,13 @@ describe("Animator test", function () {
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
-    expect(layerData.srcPlayData.state.name).to.eq("Run");
+    expect(layerData.srcPlayData.instance.name).to.eq("Run");
     expect(layerData.srcPlayData.playedTime).to.eq(0.1);
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update(idleState.clip.length * 0.2 - 0.1);
-    expect(layerData.srcPlayData.state.name).to.eq("Survey");
-    expect(layerData.srcPlayData.clipTime).to.eq(idleState.clip.length * 0.2);
+    animator.update((idleState as any)._state.clip.length * 0.2 - 0.1);
+    expect(layerData.srcPlayData.instance.name).to.eq("Survey");
+    expect(layerData.srcPlayData.clipTime).to.eq((idleState as any)._state.clip.length * 0.2);
   });
 
   it("setTriggerParameter", () => {
@@ -904,16 +966,16 @@ describe("Animator test", function () {
     stateMachine.clearEntryStateTransitions();
     stateMachine.clearAnyStateTransitions();
     const walkState = animator.findAnimatorState("Walk");
-    walkState.clearTransitions();
+    (walkState as any)._state.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    runState.clipStartTime = 0;
-    runState.clearTransitions();
-    const walkToRunTransition = walkState.addTransition(runState);
+    (runState as any)._state.clipStartTime = 0;
+    (runState as any)._state.clearTransitions();
+    const walkToRunTransition = (walkState as any)._state.addTransition((runState as any)._state);
     walkToRunTransition.hasExitTime = false;
     walkToRunTransition.duration = 0.1;
     walkToRunTransition.addCondition("triggerRun", AnimatorConditionMode.If, true);
 
-    const runToWalkTransition = runState.addTransition(walkState);
+    const runToWalkTransition = (runState as any)._state.addTransition((walkState as any)._state);
     runToWalkTransition.hasExitTime = true;
     runToWalkTransition.exitTime = 0.7;
     runToWalkTransition.duration = 0.3;
@@ -925,28 +987,28 @@ describe("Animator test", function () {
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
-    expect(layerData.srcPlayData.state.name).to.eq("Walk");
+    expect(layerData.srcPlayData.instance.name).to.eq("Walk");
     expect(layerData.srcPlayData.playedTime).to.eq(0.1);
-    expect(layerData.destPlayData.state.name).to.eq("Run");
+    expect(layerData.destPlayData.instance.name).to.eq("Run");
     expect(layerData.destPlayData.playedTime).to.eq(0.1);
     expect(animator.getParameterValue("triggerRun")).to.eq(false);
     expect(animator.getParameterValue("triggerWalk")).to.eq(true);
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update(runState.clip.length * 0.1 - 0.1);
-    expect(layerData.srcPlayData.state.name).to.eq("Run");
-    expect(layerData.srcPlayData.playedTime).to.eq(runState.clip.length * 0.1);
+    animator.update((runState as any)._state.clip.length * 0.1 - 0.1);
+    expect(layerData.srcPlayData.instance.name).to.eq("Run");
+    expect(layerData.srcPlayData.playedTime).to.eq((runState as any)._state.clip.length * 0.1);
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update(runState.clip.length * 0.6);
-    expect(layerData.destPlayData.state.name).to.eq("Walk");
+    animator.update((runState as any)._state.clip.length * 0.6);
+    expect(layerData.destPlayData.instance.name).to.eq("Walk");
     expect(layerData.destPlayData.playedTime).to.eq(0);
     expect(animator.getParameterValue("triggerWalk")).to.eq(false);
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update(walkState.clip.length * 0.3);
-    expect(layerData.srcPlayData.state.name).to.eq("Walk");
-    expect(layerData.srcPlayData.playedTime).to.eq(walkState.clip.length * 0.3);
+    animator.update((walkState as any)._state.clip.length * 0.3);
+    expect(layerData.srcPlayData.instance.name).to.eq("Walk");
+    expect(layerData.srcPlayData.playedTime).to.eq((walkState as any)._state.clip.length * 0.3);
   });
 
   it("fixedDuration", () => {
@@ -956,11 +1018,11 @@ describe("Animator test", function () {
     // @ts-ignore
     const layerData = animator._getAnimatorLayerData(0);
     const walkState = animator.findAnimatorState("Walk");
-    walkState.clearTransitions();
+    (walkState as any)._state.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    runState.clipStartTime = runState.clipEndTime = 0;
-    runState.clearTransitions();
-    const walkToRunTransition = walkState.addTransition(runState);
+    (runState as any)._state.clipStartTime = (runState as any)._state.clipEndTime = 0;
+    (runState as any)._state.clearTransitions();
+    const walkToRunTransition = (walkState as any)._state.addTransition((runState as any)._state);
     walkToRunTransition.hasExitTime = false;
     walkToRunTransition.isFixedDuration = true;
     walkToRunTransition.duration = 0.1;
@@ -970,7 +1032,7 @@ describe("Animator test", function () {
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
-    expect(layerData.srcPlayData.state.name).to.eq("Run");
+    expect(layerData.srcPlayData.instance.name).to.eq("Run");
     expect(layerData.srcPlayData.playedTime).to.eq(0.1);
     expect(layerData.srcPlayData.clipTime).to.eq(0);
   });
@@ -1033,19 +1095,61 @@ describe("Animator test", function () {
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.6);
-    expect(animatorLayerData[0]?.srcPlayData.state.name).to.eq("state1");
+    expect(animatorLayerData[0]?.srcPlayData.instance.name).to.eq("state1");
 
     transition2.mute = false;
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.3);
-    expect(animatorLayerData[0]?.srcPlayData.state.name).to.eq("state2");
+    expect(animatorLayerData[0]?.srcPlayData.instance.name).to.eq("state2");
   });
 
   it("Clone", () => {
     expect(animator.entity.clone().getComponent(Animator).animatorController).to.eq(animator.animatorController);
   });
 
+  it("samples self-name-prefixed curve paths on wrapped roots", () => {
+    const wrappedRoot = new Entity(engine, "GLTF_ROOT");
+    const hips = new Entity(engine, "mixamorig:Hips");
+    const spine = new Entity(engine, "mixamorig:Spine");
+    hips.parent = wrappedRoot;
+    spine.parent = hips;
+
+    const clip = new AnimationClip("idle");
+    const hipsCurve = new AnimationFloatCurve();
+    const spineCurve = new AnimationFloatCurve();
+    const hipsStart = new Keyframe<number>();
+    const hipsEnd = new Keyframe<number>();
+    hipsStart.time = 0;
+    hipsStart.value = 0;
+    hipsEnd.time = 0.1;
+    hipsEnd.value = 1;
+    hipsCurve.addKey(hipsStart);
+    hipsCurve.addKey(hipsEnd);
+
+    const spineStart = new Keyframe<number>();
+    const spineEnd = new Keyframe<number>();
+    spineStart.time = 0;
+    spineStart.value = 0;
+    spineEnd.time = 0.1;
+    spineEnd.value = 1;
+    spineCurve.addKey(spineStart);
+    spineCurve.addKey(spineEnd);
+
+    clip.addCurveBinding("mixamorig:Hips", Transform, "position.x", hipsCurve);
+    clip.addCurveBinding("mixamorig:Hips/mixamorig:Spine", Transform, "position.y", spineCurve);
+
+    expect(wrappedRoot.findByPath("mixamorig:Hips")).to.eq(hips);
+    expect(wrappedRoot.findByPath("mixamorig:Hips/mixamorig:Spine")).to.eq(spine);
+
+    // @ts-ignore
+    clip._sampleAnimation(wrappedRoot, 0.1);
+
+    expect(wrappedRoot.transform.position.x).to.eq(0);
+    expect(hips.transform.position.x).to.eq(1);
+    expect(spine.transform.position.y).to.eq(1);
+  });
+
   it("anyState transition interrupts crossFade", () => {
     const { animatorController } = animator;
     animatorController.addParameter("interrupt", false);
@@ -1053,7 +1157,7 @@ describe("Animator test", function () {
     const idleState = animator.findAnimatorState("Survey");
 
     // AnyState -> Idle (can interrupt)
-    const anyToIdle = stateMachine.addAnyStateTransition(idleState);
+    const anyToIdle = stateMachine.addAnyStateTransition((idleState as any)._state);
     anyToIdle.hasExitTime = false;
     anyToIdle.duration = 0.2;
     anyToIdle.addCondition("interrupt", AnimatorConditionMode.If, true);
@@ -1070,7 +1174,7 @@ describe("Animator test", function () {
     const layerData = animator._getAnimatorLayerData(0);
 
     expect(layerData.layerState).to.eq(LayerState.CrossFading);
-    expect(layerData.destPlayData.state.name).to.eq("Run");
+    expect(layerData.destPlayData.instance.name).to.eq("Run");
 
     // Trigger interrupt during crossFade
     animator.setParameterValue("interrupt", true);
@@ -1079,7 +1183,7 @@ describe("Animator test", function () {
     animator.update(0.1);
 
     // Should have interrupted to Idle
-    expect(layerData.destPlayData.state.name).to.eq("Survey");
+    expect(layerData.destPlayData.instance.name).to.eq("Survey");
   });
 
   it("noExitTime transition scan should ignore exitTime transitions", () => {
@@ -1091,12 +1195,12 @@ describe("Animator test", function () {
     const runState = animator.findAnimatorState("Run");
     const idleState = animator.findAnimatorState("Survey");
 
-    walkState.clipStartTime = 0;
-    walkState.clipEndTime = 1;
-    walkState.clearTransitions();
+    (walkState as any)._state.clipStartTime = 0;
+    (walkState as any)._state.clipEndTime = 1;
+    (walkState as any)._state.clearTransitions();
 
     // A noExitTime transition that fails (ensures noExitTimeCount > 0).
-    const noExitFailTransition = walkState.addTransition(idleState);
+    const noExitFailTransition = (walkState as any)._state.addTransition((idleState as any)._state);
     noExitFailTransition.hasExitTime = false;
     noExitFailTransition.duration = 0;
     noExitFailTransition.addCondition("never", AnimatorConditionMode.If, true);
@@ -1105,26 +1209,26 @@ describe("Animator test", function () {
     const exitTimeTransition = new AnimatorStateTransition();
     exitTimeTransition.exitTime = 0.5;
     exitTimeTransition.duration = 0;
-    exitTimeTransition.destinationState = runState;
+    exitTimeTransition.destinationState = (runState as any)._state;
     exitTimeTransition.addCondition("goRun", AnimatorConditionMode.If, true);
-    walkState.addTransition(exitTimeTransition);
+    (walkState as any)._state.addTransition(exitTimeTransition);
 
     // @ts-ignore
     const layerData = animator._getAnimatorLayerData(0);
     animator.play("Walk");
 
     // Update before exitTime, should still be in Walk and not start transitioning to Run.
-    const preExitDeltaTime = walkState.clip.length * 0.25;
+    const preExitDeltaTime = (walkState as any)._state.clip.length * 0.25;
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(preExitDeltaTime);
-    expect(layerData.srcPlayData.state.name).to.eq("Walk");
-    expect(layerData.destPlayData.state).to.be.undefined;
+    expect(layerData.srcPlayData.instance.name).to.eq("Walk");
+    expect(layerData.destPlayData).to.be.null;
 
     // Update past exitTime, should transition to Run.
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update(walkState.clip.length * 0.5);
+    animator.update((walkState as any)._state.clip.length * 0.5);
     expect(animator.getCurrentAnimatorState(0).name).to.eq("Run");
   });
 
@@ -1136,7 +1240,7 @@ describe("Animator test", function () {
     const walkState = animator.findAnimatorState("Walk");
 
     // AnyState -> Idle (can interrupt)
-    const anyToIdle = stateMachine.addAnyStateTransition(idleState);
+    const anyToIdle = stateMachine.addAnyStateTransition((idleState as any)._state);
     anyToIdle.hasExitTime = false;
     anyToIdle.duration = 0.2;
     anyToIdle.addCondition("interrupt", AnimatorConditionMode.If, true);
@@ -1146,7 +1250,7 @@ describe("Animator test", function () {
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update(walkState.clip.length + 0.1);
+    animator.update((walkState as any)._state.clip.length + 0.1);
 
     // @ts-ignore
     const layerData = animator._getAnimatorLayerData(0);
@@ -1160,7 +1264,7 @@ describe("Animator test", function () {
     animator.update(0.1);
 
     expect(layerData.layerState).to.eq(LayerState.FixedCrossFading);
-    expect(layerData.destPlayData.state.name).to.eq("Run");
+    expect(layerData.destPlayData.instance.name).to.eq("Run");
 
     // Trigger interrupt during FixedCrossFading
     animator.setParameterValue("interrupt", true);
@@ -1169,7 +1273,7 @@ describe("Animator test", function () {
     animator.update(0.1);
 
     // Should have interrupted to Idle
-    expect(layerData.destPlayData.state.name).to.eq("Survey");
+    expect(layerData.destPlayData.instance.name).to.eq("Survey");
   });
 
   it("anyState interrupt should skip transition to same destination state", () => {
@@ -1179,7 +1283,7 @@ describe("Animator test", function () {
     const runState = animator.findAnimatorState("Run");
 
     // AnyState -> Run (always true, noExitTime)
-    const anyToRun = stateMachine.addAnyStateTransition(runState);
+    const anyToRun = stateMachine.addAnyStateTransition((runState as any)._state);
     anyToRun.hasExitTime = false;
     anyToRun.duration = 0.2;
     anyToRun.addCondition("alwaysTrue", AnimatorConditionMode.If, true);
@@ -1196,7 +1300,7 @@ describe("Animator test", function () {
 
     // Should be in CrossFading state, dest = Run
     expect(layerData.layerState).to.eq(LayerState.CrossFading);
-    expect(layerData.destPlayData.state.name).to.eq("Run");
+    expect(layerData.destPlayData.instance.name).to.eq("Run");
 
     // Update again - anyState -> Run should be skipped because dest is already Run
     // @ts-ignore
@@ -1205,7 +1309,7 @@ describe("Animator test", function () {
 
     // Should still be CrossFading to Run (not interrupted/reset)
     expect(layerData.layerState).to.eq(LayerState.CrossFading);
-    expect(layerData.destPlayData.state.name).to.eq("Run");
+    expect(layerData.destPlayData.instance.name).to.eq("Run");
   });
 
   it("zero-duration crossFade should not be interrupted by anyState transition", () => {
@@ -1215,7 +1319,7 @@ describe("Animator test", function () {
     const idleState = animator.findAnimatorState("Survey");
 
     // AnyState -> Idle (always true, noExitTime)
-    const anyToIdle = stateMachine.addAnyStateTransition(idleState);
+    const anyToIdle = stateMachine.addAnyStateTransition((idleState as any)._state);
     anyToIdle.hasExitTime = false;
     anyToIdle.duration = 0.2;
     anyToIdle.addCondition("interrupt", AnimatorConditionMode.If, true);
@@ -1231,26 +1335,26 @@ describe("Animator test", function () {
     const layerData = animator._getAnimatorLayerData(0);
 
     // Zero-duration crossFade completes instantly, should be Playing Run (not interrupted to Survey)
-    expect(layerData.srcPlayData.state.name).to.eq("Run");
+    expect(layerData.srcPlayData.instance.name).to.eq("Run");
   });
 
   it("toggle hasExitTime should maintain correct noExitTimeCount", () => {
     const walkState = animator.findAnimatorState("Walk");
     const runState = animator.findAnimatorState("Run");
     const idleState = animator.findAnimatorState("Survey");
-    walkState.clearTransitions();
+    (walkState as any)._state.clearTransitions();
 
     // Add a noExitTime transition
-    const t1 = walkState.addTransition(runState);
+    const t1 = (walkState as any)._state.addTransition((runState as any)._state);
     t1.hasExitTime = false;
 
     // Add a hasExitTime transition
-    const t2 = walkState.addTransition(idleState);
+    const t2 = (walkState as any)._state.addTransition((idleState as any)._state);
     t2.hasExitTime = true;
     t2.exitTime = 0.5;
 
     // @ts-ignore
-    const collection = walkState._transitionCollection;
+    const collection = (walkState as any)._state._transitionCollection;
     expect(collection.noExitTimeCount).to.eq(1);
     expect(collection.count).to.eq(2);
 
@@ -1269,4 +1373,446 @@ describe("Animator test", function () {
     expect(collection.get(0)).to.eq(t2);
     expect(collection.get(1)).to.eq(t1);
   });
+
+  it("findAnimatorState lazy-creates handle for unplayed state", () => {
+    // Clone yields a fresh animator with no PlayData populated
+    const cloneEntity = animator.entity.clone();
+    const cloneAnimator = cloneEntity.getComponent(Animator);
+
+    const survey = cloneAnimator.findAnimatorState("Survey");
+    expect(survey).to.not.eq(null);
+    expect(survey.name).to.eq("Survey");
+    expect(survey.speed).to.eq((survey as any)._state.speed); // live-bound default
+
+    // Same handle returned on subsequent calls (verifies caching)
+    expect(cloneAnimator.findAnimatorState("Survey")).to.eq(survey);
+  });
+
+  it("per-instance speed set before play applies on first play", () => {
+    const handle = animator.findAnimatorState("Survey");
+    handle.speed = 0.5;
+    animator.play("Survey");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.001);
+
+    // Same handle observed via getCurrentAnimatorState
+    expect(animator.getCurrentAnimatorState(0)).to.eq(handle);
+    expect(handle.speed).to.eq(0.5);
+  });
+
+  it("per-instance speed survives crossFade out and back", () => {
+    animator.findAnimatorState("Survey").speed = 0.5;
+    animator.play("Survey");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.001);
+
+    // crossFade out (fixed 0.05s duration)
+    animator.crossFadeInFixedDuration("Walk", 0.05, 0, 0);
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1); // complete crossfade
+    // crossFade back
+    animator.crossFadeInFixedDuration("Survey", 0.05, 0, 0);
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+
+    // @ts-ignore
+    const srcPlayData = animator._animatorLayersData[0].srcPlayData;
+    expect(srcPlayData.instance.name).to.eq("Survey"); // ensure crossfade actually completed back to Survey
+    expect(animator.findAnimatorState("Survey").speed).to.eq(0.5);
+    expect(srcPlayData.instance.speed).to.eq(0.5);
+  });
+
+  it("per-instance speed is per-Animator (clone isolation)", () => {
+    const cloneEntity = animator.entity.clone();
+    const cloneAnimator = cloneEntity.getComponent(Animator);
+    expect(cloneAnimator.animatorController).to.eq(animator.animatorController);
+
+    animator.findAnimatorState("Survey").speed = 0.5;
+
+    expect(animator.findAnimatorState("Survey").speed).to.eq(0.5);
+    expect(cloneAnimator.findAnimatorState("Survey").speed).to.eq(1); // shared default
+    // shared asset not mutated
+    const sharedSurvey = animator.animatorController.layers[0].stateMachine.findStateByName("Survey");
+    expect(sharedSurvey.speed).to.eq(1);
+  });
+
+  it("crossFade phase honors per-instance speed for time progression", () => {
+    // Set high per-instance speed on src state
+    animator.findAnimatorState("Survey").speed = 4;
+    animator.play("Survey");
+    // @ts-ignore — Animator.update short-circuits to dt=0 if _playFrameCount===frameCount
+    animator.engine.time._frameCount++;
+    animator.update(0.001);
+
+    // @ts-ignore
+    const layerData = animator._animatorLayersData[0];
+    const srcPlayedBefore = layerData.srcPlayData.playedTime;
+
+    // Start crossFade — during crossFade, src should still advance per per-instance speed=4
+    animator.crossFade("Walk", 0.5, 0, 0);
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.05); // 50ms of crossfade
+
+    const srcPlayedAfter = layerData.srcPlayData.playedTime;
+    const advanced = srcPlayedAfter - srcPlayedBefore;
+    // With per-instance speed=4 and dt=0.05, expect ~0.2 (4 * 0.05). With shared state.speed=1 it'd be ~0.05.
+    expect(advanced).to.be.closeTo(0.2, 0.05);
+  });
+
+  it("findAnimatorState rebuilds handle when state identity changes (remove/re-add same name)", () => {
+    const sm = animator.animatorController.layers[0].stateMachine;
+    const oldSurvey = animator.findAnimatorState("Survey");
+    expect(oldSurvey).not.to.eq(null);
+    const oldStateRef = (oldSurvey as any)._state;
+    const originalIndex = sm.states.indexOf(oldStateRef);
+
+    // Simulate dynamic controller mutation: remove and re-add same-name state
+    sm.removeState(oldStateRef);
+    const newStateRef = sm.addState("Survey");
+    expect(newStateRef).not.to.eq(oldStateRef);
+
+    const newHandle = animator.findAnimatorState("Survey");
+    expect(newHandle).not.to.eq(null);
+    expect((newHandle as any)._state).to.eq(newStateRef);
+    expect(newHandle).not.to.eq(oldSurvey);
+
+    // Restore original Survey state so subsequent tests still see the
+    // clip-bound state. Drop the barebones replacement and reinsert the
+    // original at its previous index in the states list/map.
+    sm.removeState(newStateRef);
+    sm.states.splice(originalIndex, 0, oldStateRef);
+    // @ts-ignore — _statesMap is private but rebuild requires direct access
+    sm._statesMap["Survey"] = oldStateRef;
+    // Reset cached layer data so the next findAnimatorState rebuilds against
+    // the restored state.
+    // @ts-ignore
+    animator._reset();
+  });
+
+  it("rebuilds curve owners and event handlers when state identity changes via remove/re-add", () => {
+    const localEntity = new Entity(engine);
+    const localAnimator = localEntity.addComponent(Animator);
+    const controller = new AnimatorController(engine);
+    const layer = new AnimatorControllerLayer("layer");
+    controller.addLayer(layer);
+
+    // Old state binds rotation.x: 0 → 90 over 1s
+    const oldState = layer.stateMachine.addState("X");
+    const oldClip = new AnimationClip("oldClip");
+    const rotationCurve = new AnimationFloatCurve();
+    const rk1 = new Keyframe<number>();
+    rk1.time = 0;
+    rk1.value = 0;
+    const rk2 = new Keyframe<number>();
+    rk2.time = 1;
+    rk2.value = 90;
+    rotationCurve.addKey(rk1);
+    rotationCurve.addKey(rk2);
+    oldClip.addCurveBinding("", Transform, "rotation.x", rotationCurve);
+    oldState.clip = oldClip;
+    oldState.wrapMode = WrapMode.Loop;
+
+    localAnimator.animatorController = controller;
+    localAnimator.play("X");
+    // @ts-ignore
+    localAnimator.engine.time._frameCount++;
+    localAnimator.update(0.5);
+
+    // First play populates stateData cache keyed by name "X" pointing at oldState's owners.
+    expect(localEntity.transform.rotation.x).to.be.closeTo(45, 1);
+
+    // Remove + re-add same-name state with a clip targeting a *different* property.
+    layer.stateMachine.removeState(oldState);
+    const newState = layer.stateMachine.addState("X");
+    const newClip = new AnimationClip("newClip");
+    const positionCurve = new AnimationFloatCurve();
+    const pk1 = new Keyframe<number>();
+    pk1.time = 0;
+    pk1.value = 0;
+    const pk2 = new Keyframe<number>();
+    pk2.time = 1;
+    pk2.value = 5;
+    positionCurve.addKey(pk1);
+    positionCurve.addKey(pk2);
+    newClip.addCurveBinding("", Transform, "position.x", positionCurve);
+    newState.clip = newClip;
+    newState.wrapMode = WrapMode.Loop;
+
+    // Reset transform so any stale binding shows up as a wrong-property mutation.
+    localEntity.transform.position = new Vector3(0, 0, 0);
+    localEntity.transform.rotation = new Vector3(0, 0, 0);
+
+    // @ts-ignore — internal layer data, verify cached state BEFORE second play to confirm stale.
+    const layerDataBeforeSecondPlay = localAnimator._animatorLayersData[0];
+    const stateDataBefore = layerDataBeforeSecondPlay.animatorStateDataMap.get(oldState);
+    expect(stateDataBefore, "stateData should exist after first play").to.not.eq(undefined);
+    expect(stateDataBefore.state, "first-play stateData.state must be oldState").to.eq(oldState);
+
+    localAnimator.play("X");
+
+    // @ts-ignore — internal layer data
+    const layerData = localAnimator._animatorLayersData[0];
+    const stateData = layerData.animatorStateDataMap.get(newState);
+    // stateData must rebuild against newState identity, not stay aliased to oldState.
+    expect(stateData.state, "second-play stateData.state must be newState").to.eq(newState);
+    // The cached curveLayerOwner must point at position.x owner now, not the stale rotation.x owner.
+    const firstOwnerProp = (stateData.curveLayerOwner[0] as any)?.curveOwner?.property;
+    expect(firstOwnerProp).to.eq("position.x");
+
+    // @ts-ignore
+    localAnimator.engine.time._frameCount++;
+    localAnimator.update(0.5);
+
+    // After rebuild: position.x ≈ 2.5, rotation.x stays at 0.
+    // Without rebuild (stale stateData): curveLayerOwner[0] still points at rotation.x owner,
+    // so position curve value would be applied to rotation.x and position.x would never change.
+    expect(localEntity.transform.position.x).to.be.closeTo(2.5, 0.5);
+    expect(localEntity.transform.rotation.x).to.eq(0);
+
+    localEntity.destroy();
+  });
+
+  it("findAnimatorState resets stale layer data after controller mutation", () => {
+    // Ensure layerData[0] is populated
+    const handle1 = animator.findAnimatorState("Survey");
+    expect(handle1).not.to.eq(null);
+
+    // Mutate the controller — this dispatches the update flag
+    const controller = animator.animatorController;
+    const dummyLayer = new AnimatorControllerLayer("__dummy__");
+    controller.addLayer(dummyLayer);
+
+    // findAnimatorState should reset stale layerData and rebuild
+    const handle2 = animator.findAnimatorState("Survey");
+    expect(handle2).not.to.eq(null);
+    expect(handle2).not.to.eq(handle1); // fresh handle after reset
+
+    // Cleanup
+    controller.removeLayer(controller.layers.indexOf(dummyLayer));
+  });
+
+  it("eventHandlers rebuild lazily when state.clip events change", () => {
+    const survey = animator.findAnimatorState("Survey");
+    expect(survey).not.to.eq(null);
+    const surveyState = (survey as any)._state;
+    animator.play("Survey");
+
+    // @ts-ignore — internal layerData / stateData
+    const layerData = animator._animatorLayersData[0];
+    const stateData = layerData.animatorStateDataMap.get(surveyState);
+    expect(stateData, "stateData should exist after play").to.not.eq(undefined);
+
+    const versionBefore = stateData.eventsBuiltVersion;
+    expect(versionBefore).to.be.greaterThanOrEqual(0);
+
+    // Dispatching the clip flag bumps clip's version → next access invalidates eventsBuiltVersion.
+    surveyState.clip._updateFlagManager.dispatch();
+
+    // Next play / state-data access triggers _ensureEventHandlersUpToDate and rebuilds.
+    animator.play("Survey");
+    // @ts-ignore
+    const layerDataAfter = animator._animatorLayersData[0];
+    const stateDataAfter = layerDataAfter.animatorStateDataMap.get(surveyState);
+    expect(stateDataAfter.eventsBuiltVersion).to.be.greaterThan(versionBefore);
+  });
+
+  it("crossFade to current state is no-op (avoids src/dest PlayData alias)", () => {
+    animator.play("Walk");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+
+    // @ts-ignore
+    const layerData = animator._animatorLayersData[0];
+    const srcBefore = layerData.srcPlayData;
+    const playedBefore = srcBefore.playedTime;
+
+    // crossFade to the same state — should be ignored
+    animator.crossFade("Walk", 0.3, 0, 0);
+
+    expect(layerData.srcPlayData).to.eq(srcBefore);
+    expect(layerData.srcPlayData.playedTime).to.eq(playedBefore);
+    expect(layerData.destPlayData).to.eq(null);
+  });
+
+  it("crossFade to currently-fading dest state is no-op", () => {
+    animator.play("Walk");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+
+    animator.crossFade("Run", 0.5, 0, 0);
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.05);
+
+    // @ts-ignore
+    const layerData = animator._animatorLayersData[0];
+    const destBefore = layerData.destPlayData;
+    const destPlayedBefore = destBefore.playedTime;
+
+    // crossFade to the in-flight dest state — should be ignored
+    animator.crossFade("Run", 0.3, 0, 0);
+
+    expect(layerData.destPlayData).to.eq(destBefore);
+    expect(layerData.destPlayData.playedTime).to.eq(destPlayedBefore);
+  });
+
+  it("state-machine self-transition is also a no-op (alias-guard policy)", () => {
+    const walk = animator.findAnimatorState("Walk");
+    (walk as any)._state.clearTransitions();
+    animator.animatorController.addParameter("restart", false);
+
+    const selfTransition = (walk as any)._state.addTransition((walk as any)._state);
+    selfTransition.hasExitTime = false;
+    selfTransition.duration = 0.1;
+    selfTransition.addCondition("restart", AnimatorConditionMode.If, true);
+
+    animator.play("Walk");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.05);
+
+    // @ts-ignore
+    const layerData = animator._animatorLayersData[0];
+    const srcBefore = layerData.srcPlayData;
+    const playedBefore = srcBefore.playedTime;
+
+    // Trigger the self-transition
+    animator.setParameterValue("restart", true);
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.05);
+
+    // Self-transition is intentionally a no-op (one persistent PlayData per state).
+    // src should keep advancing as if no transition happened, dest stays null.
+    expect(layerData.srcPlayData).to.eq(srcBefore);
+    expect(layerData.srcPlayData.instance.name).to.eq("Walk");
+    expect(layerData.srcPlayData.playedTime).to.be.greaterThan(playedBefore);
+    expect(layerData.destPlayData).to.eq(null);
+  });
+
+  it("play during crossFade clears stale destPlayData", () => {
+    animator.play("Walk");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+
+    animator.crossFade("Run", 0.5, 0, 0);
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.05);
+
+    // Interrupt the in-flight crossFade with a play()
+    animator.play("Survey");
+
+    // @ts-ignore
+    const layerData = animator._animatorLayersData[0];
+    expect(layerData.destPlayData).to.eq(null);
+    expect(layerData.crossFadeTransition).to.eq(null);
+
+    // A subsequent crossFade to the previously-fading state should now succeed —
+    // the stale dest slot must not block it via the alias guard.
+    animator.crossFade("Run", 0.3, 0, 0);
+    expect(layerData.destPlayData?.instance.name).to.eq("Run");
+  });
+
+  it("crossFade to nonexistent state is a safe no-op", () => {
+    animator.play("Walk");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+
+    const before = animator.getCurrentAnimatorState(0);
+    animator.crossFade("MissingState", 0.3, 0, 0);
+    const after = animator.getCurrentAnimatorState(0);
+
+    expect(after).to.eq(before);
+    // @ts-ignore — verify no junk layerData was written at array index -1.
+    expect(animator._animatorLayersData[-1]).to.eq(undefined);
+  });
+
+  it("findAnimatorState with out-of-range layerIndex returns null", () => {
+    expect(animator.findAnimatorState("Survey", 99)).to.eq(null);
+    expect(animator.findAnimatorState("Survey", -2)).to.eq(null);
+  });
+
+  it("play / crossFade with out-of-range layerIndex are safe no-ops", () => {
+    animator.play("Survey");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.001);
+
+    const stateBefore = animator.getCurrentAnimatorState(0);
+
+    expect(() => animator.play("Walk", 99)).not.to.throw();
+    expect(() => animator.crossFade("Run", 0.3, 99, 0)).not.to.throw();
+
+    expect(animator.getCurrentAnimatorState(0)).to.eq(stateBefore);
+    // @ts-ignore — verify no junk layerData created at index -1 / 99
+    expect(animator._animatorLayersData[-1]).to.eq(undefined);
+    // @ts-ignore
+    expect(animator._animatorLayersData[99]).to.eq(undefined);
+  });
+
+  it("transition out of a state with per-instance speed 0 does not produce NaN", () => {
+    const survey = animator.findAnimatorState("Survey");
+    survey.speed = 0; // pause this state per-instance
+    animator.play("Survey");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+
+    // crossFade out — destination state should still progress despite src speed=0
+    animator.crossFade("Walk", 0.3, 0, 0);
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+
+    // @ts-ignore
+    const layerData = animator._animatorLayersData[0];
+    expect(Number.isNaN(layerData.srcPlayData.playedTime)).to.eq(false);
+    expect(Number.isNaN(layerData.destPlayData?.playedTime ?? 0)).to.eq(false);
+    // Walk dest should have progressed
+    expect(layerData.destPlayData?.playedTime).to.be.greaterThan(0);
+  });
+
+  it("no-exit transition out of speed=0 source preserves remaining deltaTime and avoids NaN", () => {
+    const survey = animator.findAnimatorState("Survey");
+    const walk = animator.findAnimatorState("Walk");
+    (survey as any)._state.clearTransitions();
+    (walk as any)._state.clearTransitions();
+    animator.animatorController.addParameter("goWalk", false);
+
+    survey.speed = 0; // pause source per-instance
+
+    const transition = (survey as any)._state.addTransition((walk as any)._state);
+    transition.hasExitTime = false;
+    transition.duration = 0.3;
+    transition.addCondition("goWalk", AnimatorConditionMode.If, true);
+
+    animator.play("Survey");
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.05);
+
+    animator.setParameterValue("goWalk", true);
+    // @ts-ignore
+    animator.engine.time._frameCount++;
+    animator.update(0.1);
+
+    // @ts-ignore
+    const layerData = animator._animatorLayersData[0];
+    expect(Number.isNaN(layerData.srcPlayData.playedTime)).to.eq(false);
+    expect(Number.isNaN(layerData.destPlayData?.playedTime ?? 0)).to.eq(false);
+    expect(layerData.destPlayData?.instance.name).to.eq("Walk");
+    // dest should have advanced from the remaining deltaTime that was
+    // preserved by the playSpeed===0 guard
+    expect(layerData.destPlayData?.playedTime).to.be.greaterThan(0);
+  });
 });
diff --git a/tests/src/core/Entity.test.ts b/tests/src/core/Entity.test.ts
index 0a428f4b60..ac4795890e 100644
--- a/tests/src/core/Entity.test.ts
+++ b/tests/src/core/Entity.test.ts
@@ -871,4 +871,4 @@ describe("Entity", async () => {
       expect(order).toEqual(["C", "B", "A"]);
     });
   });
-});
\ No newline at end of file
+});
diff --git a/tests/src/loader/GLTFLoader.test.ts b/tests/src/loader/GLTFLoader.test.ts
index 6ad52fc919..6f3eaf0b17 100644
--- a/tests/src/loader/GLTFLoader.test.ts
+++ b/tests/src/loader/GLTFLoader.test.ts
@@ -39,6 +39,117 @@ beforeAll(async function () {
   @registerGLTFParser(GLTFParserType.Schema)
   class GLTFCustomJSONParser extends GLTFParser {
     parse(context: GLTFParserContext) {
+      if (context.glTFResource.url.endsWith("testSkinRoot.gltf")) {
+        context.buffers = [new ArrayBuffer(192)];
+        return Promise.resolve({
+          asset: {
+            version: "2.0"
+          },
+          scene: 0,
+          scenes: [
+            {
+              nodes: [0, 1]
+            }
+          ],
+          nodes: [
+            {
+              name: "Character_Man"
+            },
+            {
+              name: "mixamorig:Hips",
+              children: [2]
+            },
+            {
+              name: "mixamorig:Spine"
+            }
+          ],
+          skins: [
+            {
+              inverseBindMatrices: 0,
+              // Joints span both top-level scene roots: Character_Man (0) and Hips (1)/Spine (2).
+              joints: [0, 1, 2]
+            }
+          ],
+          accessors: [
+            {
+              bufferView: 0,
+              byteOffset: 0,
+              componentType: 5126,
+              count: 3,
+              type: "MAT4"
+            }
+          ],
+          bufferViews: [
+            {
+              buffer: 0,
+              byteOffset: 0,
+              byteLength: 192
+            }
+          ],
+          buffers: [
+            {
+              byteLength: 192
+            }
+          ]
+        });
+      }
+
+      if (context.glTFResource.url.endsWith("testSingleSkeleton.gltf")) {
+        context.buffers = [new ArrayBuffer(128)];
+        return Promise.resolve({
+          asset: {
+            version: "2.0"
+          },
+          scene: 0,
+          scenes: [
+            {
+              // Two top-level roots: a character skeleton and an unrelated sibling (e.g., a light).
+              nodes: [0, 2]
+            }
+          ],
+          nodes: [
+            {
+              name: "Character_Root",
+              children: [1]
+            },
+            {
+              name: "mixamorig:Hips"
+            },
+            {
+              name: "Light"
+            }
+          ],
+          skins: [
+            {
+              inverseBindMatrices: 0,
+              // All joints converge to a single top-level root (Character_Root).
+              joints: [0, 1]
+            }
+          ],
+          accessors: [
+            {
+              bufferView: 0,
+              byteOffset: 0,
+              componentType: 5126,
+              count: 2,
+              type: "MAT4"
+            }
+          ],
+          bufferViews: [
+            {
+              buffer: 0,
+              byteOffset: 0,
+              byteLength: 128
+            }
+          ],
+          buffers: [
+            {
+              byteLength: 128
+            }
+          ]
+        });
+      }
+
       const glTF = <any>{
         buffers: [
           {
@@ -481,6 +592,17 @@ describe("glTF Loader test", function () {
     expect(renderer).to.exist;
     expect(renderer.blendShapeWeights).to.deep.include([1, 1]);
   });
+
+  it("single-root animation root channel should bind to the root node path", async () => {
+    const glTFResource: GLTFResource = await engine.resourceManager.load({
+      type: AssetType.GLTF,
+      url: "mock/path/testA.gltf"
+    });
+
+    const clip = glTFResource.animations?.[0];
+    expect(clip).to.exist;
+    expect(clip.curveBindings[0].relativePath).to.equal("entity1");
+  });
 });
 
 describe("glTF instance test", function () {
@@ -530,6 +652,33 @@ describe("glTF scene root structure", function () {
     expect(defaultSceneRoot.children.length).to.equal(1);
     expect(defaultSceneRoot.children[0].name).to.equal("entity1");
   });
+
+  it("Multi-root skins without skeleton should use the scene wrapper as rootBone", async () => {
+    const glTFResource: GLTFResource = await engine.resourceManager.load({
+      type: AssetType.GLTF,
+      url: "mock/path/testSkinRoot.gltf"
+    });
+    const { defaultSceneRoot, skins } = glTFResource;
+
+    expect(defaultSceneRoot.name).to.equal("GLTF_ROOT");
+    expect(defaultSceneRoot.children.length).to.equal(2);
+    expect(skins[0].rootBone).to.equal(defaultSceneRoot);
+  });
+
+  it("Multi-root scenes whose joints converge to a single top-level root should not use the scene wrapper", async () => {
+    const glTFResource: GLTFResource = await engine.resourceManager.load({
+      type: AssetType.GLTF,
+      url: "mock/path/testSingleSkeleton.gltf"
+    });
+    const { defaultSceneRoot, skins } = glTFResource;
+
+    expect(defaultSceneRoot.name).to.equal("GLTF_ROOT");
+    // Scene has two top-level roots, but all joints converge to "Character_Root".
+    expect(defaultSceneRoot.children.length).to.equal(2);
+    expect(skins[0].rootBone).to.not.equal(defaultSceneRoot);
+    // rootBone should be inside the Character_Root subtree (LCA = Character_Root).
+    expect(skins[0].rootBone.name).to.equal("Character_Root");
+  });
 });
 
 describe("glTF instance test", function () {