From 618d4dda67475d5cd323946e87cfaec9b5ede4b6 Mon Sep 17 00:00:00 2001
From: luzhuang <wz84888@antgroup.com>
Date: Mon, 25 May 2026 20:24:20 +0800
Subject: [PATCH 01/10] fix(loader, animation, physics): cherry-pick fixes from
 fix/shaderlab
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Loader:
- componentRef 解析支持 clone entity 子树查找
- always create GLTF_ROOT container for consistent animation paths
- normalize gltf wrapper and skin roots
- include skinned mesh nodes in skin root LCA
- compute skinned bounds from non-joint rootBone
- add audio extension to AudioLoader supported types
- recognize .m4a/.aac/.flac extensions for audioClip loader
- apply scene physics settings
- cover stripped entity child attachment

Animation:
- normalize single-root clip binding paths
- add per-instance speed to AnimatorStatePlayData
- use per-instance speed during cross fade
- update animator
- expose clip sampling and gate animation events

Physics:
- resolve clone-bypass and runtime native handle desync bugs
- add DynamicCollider.applyForceAtPosition
- remove redundant wakeUp in addForce/addTorque
- repair 8 pre-existing test failures (Lite material + PhysX scene queries)
- kinematic transform sync via setKinematicTarget
- correct collision contact normal orientation
- support kinematic transform teleport sync
- teleport collider on re-enable instead of sweeping
- support PhysX tolerance scale
- raycast 和 sweep 跳过 initial overlap

Clone:
- prefab 克隆时自动 deep clone 同类型 Object 属性

Audio:
- restore pending playback correctly
- restore sources after background interruption
- recover audio after foreground resume
---
 .husky/_/husky.sh                             |    1 +
 packages/core/src/Entity.ts                   |   93 +-
 packages/core/src/animation/AnimationClip.ts  |    9 +
 packages/core/src/animation/Animator.ts       |  244 ++--
 .../src/animation/AnimatorStateInstance.ts    |   76 --
 .../src/animation/AnimatorStateMachine.ts     |    9 +-
 packages/core/src/animation/index.ts          |    2 +-
 .../internal/AnimationEventHandler.ts         |    6 +-
 .../animation/internal/AnimatorLayerData.ts   |   35 +-
 .../animation/internal/AnimatorStateData.ts   |    5 -
 .../internal/AnimatorStatePlayData.ts         |   81 +-
 packages/core/src/audio/AudioManager.ts       |  227 +++-
 packages/core/src/audio/AudioSource.ts        |  137 +-
 packages/core/src/clone/CloneManager.ts       |  126 +-
 .../core/src/physics/CharacterController.ts   |    6 +-
 packages/core/src/physics/Collider.ts         |   59 +-
 packages/core/src/physics/Collision.ts        |    3 +-
 packages/core/src/physics/DynamicCollider.ts  |   90 +-
 packages/core/src/physics/PhysicsMaterial.ts  |   25 +-
 packages/core/src/physics/index.ts            |    7 +-
 .../core/src/physics/shape/ColliderShape.ts   |   20 +-
 .../src/physics/shape/MeshColliderShape.ts    |   61 +-
 packages/design/src/physics/IPhysics.ts       |   10 +
 packages/loader/package.json                  |    2 +-
 packages/loader/src/AudioLoader.ts            |    2 +-
 packages/loader/src/HDRDecoder.ts             |  232 ++--
 packages/loader/src/MaterialLoader.ts         |   22 +-
 packages/loader/src/PrefabLoader.ts           |    4 +-
 packages/loader/src/SceneLoader.ts            |  290 ++--
 packages/loader/src/ShaderChunkLoader.ts      |   51 +
 packages/loader/src/ShaderLoader.ts           |   30 +-
 packages/loader/src/SpriteAtlasLoader.ts      |    4 +-
 packages/loader/src/SpriteLoader.ts           |    4 +-
 packages/loader/src/Texture2DLoader.ts        |  148 +++
 packages/loader/src/TextureCubeLoader.ts      |   78 ++
 packages/loader/src/TextureLoader.ts          |  192 ---
 packages/loader/src/gltf/GLTFUtils.ts         |    2 -
 .../gltf/extensions/GLTFExtensionSchema.ts    |    5 +-
 .../loader/src/gltf/parser/GLTFSceneParser.ts |   47 +-
 .../src/gltf/parser/GLTFSkinParser.test.ts    |   44 +
 .../loader/src/gltf/parser/GLTFSkinParser.ts  |   53 +-
 .../src/gltf/parser/GLTFTextureParser.ts      |    2 +-
 packages/loader/src/index.ts                  |    8 +-
 packages/loader/src/prefab/PrefabParser.ts    |   28 +-
 packages/loader/src/prefab/PrefabResource.ts  |    2 +-
 .../loader/src/resource-deserialize/index.ts  |    5 +-
 .../resources/mesh/IModelMesh.d.ts            |    2 +-
 .../resources/parser/HierarchyParser.ts       |  530 ++++----
 .../resources/parser/ParserContext.ts         |   40 +-
 .../resources/parser/ReflectionParser.ts      |  370 +++---
 .../resources/scene/SceneParser.ts            |   96 +-
 .../resources/schema/BasicSchema.ts           |  122 ++
 .../resources/schema/MaterialSchema.ts        |  111 ++
 .../resources}/schema/ProjectSchema.ts        |    0
 .../resources/schema/SceneSchema.ts           |   90 ++
 .../resources}/schema/index.ts                |    5 +-
 .../resources/texture2D/Texture2DDecoder.ts   |   59 -
 .../resources/texture2D/TextureDecoder.ts     |   77 ++
 .../textureCube/TextureCubeDecoder.ts         |   64 -
 packages/loader/src/schema/BasicSchema.ts     |   24 -
 packages/loader/src/schema/CommonSchema.ts    |   38 -
 packages/loader/src/schema/HierarchySchema.ts |   85 --
 packages/loader/src/schema/MaterialSchema.ts  |   26 -
 packages/loader/src/schema/PrefabSchema.ts    |    5 -
 packages/loader/src/schema/SceneSchema.ts     |   68 -
 packages/loader/src/schema/refs.ts            |    9 -
 packages/physics-lite/package.json            |    2 +-
 .../physics-lite/src/LitePhysicsMaterial.ts   |   24 +-
 packages/physics-physx/package.json           |    2 +-
 .../physics-physx/src/PhysXDynamicCollider.ts |  102 +-
 packages/physics-physx/src/PhysXPhysics.ts    |   67 +-
 .../src/shape/PhysXColliderShape.ts           |    1 +
 tests/src/core/Animator.test.ts               |  947 +++++---------
 tests/src/core/audio/AudioSource.test.ts      |    2 +-
 .../audio/AudioSourcePendingPlayback.test.ts  |  358 +++++
 tests/src/core/particle/Burst.test.ts         |  187 ---
 .../LimitVelocityOverLifetime.test.ts         |    2 +-
 .../core/particle/ParticleBoundingBox.test.ts |   69 +-
 .../core/particle/ParticleRenderer.test.ts    |    2 +-
 .../particle/ParticleShapeTransform.test.ts   |  270 ----
 .../core/particle/ParticleStopResume.test.ts  |  142 ++
 .../ParticleTextureSheetAnimation.test.ts     |   86 +-
 .../core/particle/RateOverDistance.test.ts    |  100 --
 .../core/particle/RateOverTimeReplay.test.ts  |  145 --
 .../core/physics/CharacterController.test.ts  |    2 +-
 tests/src/core/physics/Collider.test.ts       |    2 +-
 tests/src/core/physics/ColliderShape.test.ts  |    2 +-
 tests/src/core/physics/Collision.test.ts      |  262 +++-
 .../src/core/physics/DynamicCollider.test.ts  |  341 ++++-
 tests/src/core/physics/HingeJoint.test.ts     |    2 +-
 tests/src/core/physics/Joint.test.ts          |    2 +-
 .../core/physics/MeshColliderShape.test.ts    |   84 +-
 .../src/core/physics/PhysicsMaterial.test.ts  |   52 +-
 tests/src/core/physics/PhysicsScene.test.ts   |  304 +----
 tests/src/core/physics/SpringJoint.test.ts    |    2 +-
 tests/src/loader/GLTFLoader.test.ts           |   99 +-
 tests/src/loader/KTX2Loader.test.ts           |    2 +-
 tests/src/loader/PrefabResource.test.ts       |  813 ++----------
 tests/src/loader/RawAssetLoader.test.ts       |    2 +-
 tests/src/loader/RenderTargetLoader.test.ts   |   20 +-
 tests/src/loader/SceneFormatV2.test.ts        | 1164 -----------------
 tests/src/loader/SceneParser.test.ts          |    6 +
 tests/src/loader/ScenePhysics.test.ts         |   50 +
 tests/src/loader/StrippedEntity.test.ts       |  277 ++++
 104 files changed, 4884 insertions(+), 5520 deletions(-)
 create mode 120000 .husky/_/husky.sh
 delete mode 100644 packages/core/src/animation/AnimatorStateInstance.ts
 create mode 100644 packages/loader/src/ShaderChunkLoader.ts
 create mode 100644 packages/loader/src/Texture2DLoader.ts
 create mode 100644 packages/loader/src/TextureCubeLoader.ts
 delete mode 100644 packages/loader/src/TextureLoader.ts
 create mode 100644 packages/loader/src/gltf/parser/GLTFSkinParser.test.ts
 create mode 100644 packages/loader/src/resource-deserialize/resources/schema/BasicSchema.ts
 create mode 100644 packages/loader/src/resource-deserialize/resources/schema/MaterialSchema.ts
 rename packages/loader/src/{ => resource-deserialize/resources}/schema/ProjectSchema.ts (100%)
 create mode 100644 packages/loader/src/resource-deserialize/resources/schema/SceneSchema.ts
 rename packages/loader/src/{ => resource-deserialize/resources}/schema/index.ts (56%)
 delete mode 100644 packages/loader/src/resource-deserialize/resources/texture2D/Texture2DDecoder.ts
 create mode 100644 packages/loader/src/resource-deserialize/resources/texture2D/TextureDecoder.ts
 delete mode 100644 packages/loader/src/resource-deserialize/resources/textureCube/TextureCubeDecoder.ts
 delete mode 100644 packages/loader/src/schema/BasicSchema.ts
 delete mode 100644 packages/loader/src/schema/CommonSchema.ts
 delete mode 100644 packages/loader/src/schema/HierarchySchema.ts
 delete mode 100644 packages/loader/src/schema/MaterialSchema.ts
 delete mode 100644 packages/loader/src/schema/PrefabSchema.ts
 delete mode 100644 packages/loader/src/schema/SceneSchema.ts
 delete mode 100644 packages/loader/src/schema/refs.ts
 create mode 100644 tests/src/core/audio/AudioSourcePendingPlayback.test.ts
 delete mode 100644 tests/src/core/particle/Burst.test.ts
 delete mode 100644 tests/src/core/particle/ParticleShapeTransform.test.ts
 create mode 100644 tests/src/core/particle/ParticleStopResume.test.ts
 delete mode 100644 tests/src/core/particle/RateOverTimeReplay.test.ts
 delete mode 100644 tests/src/loader/SceneFormatV2.test.ts
 create mode 100644 tests/src/loader/SceneParser.test.ts
 create mode 100644 tests/src/loader/ScenePhysics.test.ts
 create mode 100644 tests/src/loader/StrippedEntity.test.ts

diff --git a/.husky/_/husky.sh b/.husky/_/husky.sh
new file mode 120000
index 0000000000..7ca6a94c02
--- /dev/null
+++ b/.husky/_/husky.sh
@@ -0,0 +1 @@
+/Users/wz/Documents/website/engine/.husky/_/husky.sh
\ No newline at end of file
diff --git a/packages/core/src/Entity.ts b/packages/core/src/Entity.ts
index 063fbe1c1c..5b0c929ac1 100644
--- a/packages/core/src/Entity.ts
+++ b/packages/core/src/Entity.ts
@@ -9,7 +9,7 @@ import { Script } from "./Script";
 import { Transform } from "./Transform";
 import { UpdateFlagManager } from "./UpdateFlagManager";
 import { ReferResource } from "./asset/ReferResource";
-import { EngineObject } from "./base";
+import { EngineObject, Logger } from "./base";
 import { CloneUtils } from "./clone/CloneUtils";
 import { ComponentCloner } from "./clone/ComponentCloner";
 import { ActiveChangeFlag } from "./enums/ActiveChangeFlag";
@@ -105,8 +105,6 @@ export class Entity extends EngineObject {
   /** @internal */
   _scripts: DisorderedArray<Script> = new DisorderedArray<Script>();
   /** @internal */
-  _scriptsVersion = 0;
-  /** @internal */
   _children: Entity[] = [];
   /** @internal */
   _scene: Scene;
@@ -124,7 +122,7 @@ export class Entity extends EngineObject {
   private _transform: Transform;
   private _templateResource: ReferResource;
   private _parent: Entity = null;
-  private _activeChangedComponents: Component[];
+  private _isActiveChanging: boolean = false;
   private _modifyFlagManager: UpdateFlagManager;
 
   /**
@@ -214,16 +212,14 @@ export class Entity extends EngineObject {
   }
 
   set siblingIndex(value: number) {
-    if (this._siblingIndex === -1) {
-      throw `The entity ${this.name} is not in the hierarchy`;
-    }
-
     if (this._isRoot) {
       this._setSiblingIndex(this._scene._rootEntities, value);
-    } else {
+    } else if (this._parent) {
       const parent = this._parent;
       this._setSiblingIndex(parent._children, value);
       parent._dispatchModify(EntityModifyFlags.Child, parent);
+    } else {
+      Logger.warn(`The entity ${this.name} is not in the hierarchy`);
     }
   }
 
@@ -343,7 +339,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 entity that was found
+   * @returns	The component which be found
    */
   getChild(index: number): Entity {
     return this._children[index];
@@ -351,8 +347,8 @@ export class Entity extends EngineObject {
 
   /**
    * Find entity by name.
-   * @param name - The name of the entity to find
-   * @returns The entity that was found
+   * @param name - The name of the entity which want to be found
+   * @returns The component which be found
    */
   findByName(name: string): Entity {
     if (name === this.name) {
@@ -371,13 +367,14 @@ export class Entity extends EngineObject {
   /**
    * Find the entity by path.
    * @param path - The path of the entity eg: /entity
-   * @returns The entity that was found
+   * @returns The component which be found
    */
   findByPath(path: string): Entity {
     const splits = path.split("/").filter(Boolean);
     if (!splits.length) {
       return this;
     }
+
     return Entity._findChildByName(this, 0, splits, 0);
   }
 
@@ -404,6 +401,11 @@ export class Entity extends EngineObject {
     for (let i = children.length - 1; i >= 0; i--) {
       const child = children[i];
       child._parent = null;
+      child._siblingIndex = -1;
+      // Dispatch `Child` to the old parent before `_processInActive` (which unregisters
+      // UI listeners via `cleanRootCanvas`), so subscribers such as UICanvas can react
+      // to the hierarchy change while still attached.
+      this._dispatchModify(EntityModifyFlags.Child, this);
 
       let activeChangeFlag = ActiveChangeFlag.None;
       child._isActiveInHierarchy && (activeChangeFlag |= ActiveChangeFlag.Hierarchy);
@@ -411,6 +413,8 @@ export class Entity extends EngineObject {
       activeChangeFlag && child._processInActive(activeChangeFlag);
 
       Entity._traverseSetOwnerScene(child, null); // Must after child._processInActive().
+
+      child._setParentChange();
     }
     children.length = 0;
   }
@@ -539,7 +543,6 @@ export class Entity extends EngineObject {
   _addScript(script: Script) {
     script._entityScriptsIndex = this._scripts.length;
     this._scripts.add(script);
-    this._scriptsVersion++;
   }
 
   /**
@@ -549,7 +552,6 @@ export class Entity extends EngineObject {
     const replaced = this._scripts.deleteByIndex(script._entityScriptsIndex);
     replaced && (replaced._entityScriptsIndex = script._entityScriptsIndex);
     script._entityScriptsIndex = -1;
-    this._scriptsVersion++;
   }
 
   /**
@@ -568,24 +570,24 @@ export class Entity extends EngineObject {
    * @internal
    */
   _processActive(activeChangeFlag: ActiveChangeFlag): void {
-    if (this._activeChangedComponents) {
+    if (this._isActiveChanging) {
       throw "Note: can't set the 'main inActive entity' active in hierarchy, if the operation is in main inActive entity or it's children script's onDisable Event.";
     }
-    this._activeChangedComponents = this._scene._componentsManager.getActiveChangedTempList();
-    this._setActiveInHierarchy(this._activeChangedComponents, activeChangeFlag);
-    this._setActiveComponents(true, activeChangeFlag);
+    this._isActiveChanging = true;
+    this._setActiveInHierarchy(activeChangeFlag);
+    this._isActiveChanging = false;
   }
 
   /**
    * @internal
    */
   _processInActive(activeChangeFlag: ActiveChangeFlag): void {
-    if (this._activeChangedComponents) {
+    if (this._isActiveChanging) {
       throw "Note: can't set the 'main active entity' inActive in hierarchy, if the operation is in main active entity or it's children script's onEnable Event.";
     }
-    this._activeChangedComponents = this._scene._componentsManager.getActiveChangedTempList();
-    this._setInActiveInHierarchy(this._activeChangedComponents, activeChangeFlag);
-    this._setActiveComponents(false, activeChangeFlag);
+    this._isActiveChanging = true;
+    this._setInActiveInHierarchy(activeChangeFlag);
+    this._isActiveChanging = false;
   }
 
   /**
@@ -682,57 +684,46 @@ export class Entity extends EngineObject {
   }
 
   private _getComponentsInChildren<T extends Component>(type: ComponentConstructor<T>, results: T[]): void {
-    for (let i = this._components.length - 1; i >= 0; i--) {
-      const component = this._components[i];
+    const components = this._components;
+    for (let i = 0, n = components.length; i < n; i++) {
+      const component = components[i];
       if (component instanceof type) {
         results.push(component);
       }
     }
-    for (let i = this._children.length - 1; i >= 0; i--) {
-      this._children[i]._getComponentsInChildren<T>(type, results);
-    }
-  }
-
-  private _setActiveComponents(isActive: boolean, activeChangeFlag: ActiveChangeFlag): void {
-    const activeChangedComponents = this._activeChangedComponents;
-    for (let i = 0, length = activeChangedComponents.length; i < length; ++i) {
-      const component = activeChangedComponents[i];
-      // Skip components whose scene was already cleared by an earlier callback's removeChild
-      if (!isActive && !component._entity._scene) continue;
-      component._setActive(isActive, activeChangeFlag);
+    const children = this._children;
+    for (let i = 0, n = children.length; i < n; i++) {
+      children[i]._getComponentsInChildren<T>(type, results);
     }
-    this._scene._componentsManager.putActiveChangedTempList(activeChangedComponents);
-    this._activeChangedComponents = null;
   }
 
-  private _setActiveInHierarchy(activeChangedComponents: Component[], activeChangeFlag: ActiveChangeFlag): void {
+  private _setActiveInHierarchy(activeChangeFlag: ActiveChangeFlag): void {
     activeChangeFlag & ActiveChangeFlag.Hierarchy && (this._isActiveInHierarchy = true);
     activeChangeFlag & ActiveChangeFlag.Scene && (this._isActiveInScene = true);
     const components = this._components;
     for (let i = 0, n = components.length; i < n; i++) {
       const component = components[i];
-      (component.enabled || !component._awoken) && activeChangedComponents.push(component);
+      (component.enabled || !component._awoken) && component._setActive(true, activeChangeFlag);
     }
     const children = this._children;
-    for (let i = 0, n = children.length; i < n; i++) {
+    for (let i = children.length - 1; i >= 0; i--) {
       const child = children[i];
-      child.isActive && child._setActiveInHierarchy(activeChangedComponents, activeChangeFlag);
+      child.isActive && child._setActiveInHierarchy(activeChangeFlag);
     }
   }
 
-  private _setInActiveInHierarchy(activeChangedComponents: Component[], activeChangeFlag: ActiveChangeFlag): void {
-    // Children-first, reverse traversal for safe removeChild during callbacks
-    const children = this._children;
-    for (let i = children.length - 1; i >= 0; i--) {
-      const child = children[i];
-      child.isActive && child._setInActiveInHierarchy(activeChangedComponents, activeChangeFlag);
-    }
+  private _setInActiveInHierarchy(activeChangeFlag: ActiveChangeFlag): void {
     activeChangeFlag & ActiveChangeFlag.Hierarchy && (this._isActiveInHierarchy = false);
     activeChangeFlag & ActiveChangeFlag.Scene && (this._isActiveInScene = false);
     const components = this._components;
     for (let i = 0, n = components.length; i < n; i++) {
       const component = components[i];
-      component.enabled && activeChangedComponents.push(component);
+      component.enabled && component._setActive(false, activeChangeFlag);
+    }
+    const children = this._children;
+    for (let i = children.length - 1; i >= 0; i--) {
+      const child = children[i];
+      child.isActive && child._setInActiveInHierarchy(activeChangeFlag);
     }
   }
 
diff --git a/packages/core/src/animation/AnimationClip.ts b/packages/core/src/animation/AnimationClip.ts
index adb0c07c91..9f7b6779fc 100644
--- a/packages/core/src/animation/AnimationClip.ts
+++ b/packages/core/src/animation/AnimationClip.ts
@@ -204,6 +204,15 @@ export class AnimationClip extends EngineObject {
     this._length = 0;
   }
 
+  /**
+   * Samples an animation at a given time.
+   * @param entity - The animated entity
+   * @param time - The time to sample an animation
+   */
+  sampleAnimation(entity: Entity, time: number): void {
+    this._sampleAnimation(entity, time);
+  }
+
   /**
    * @internal
    * Samples an animation at a given time.
diff --git a/packages/core/src/animation/Animator.ts b/packages/core/src/animation/Animator.ts
index 42fc2ee3fa..2c1638abf1 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";
@@ -19,6 +19,7 @@ import { AnimatorCullingMode } from "./enums/AnimatorCullingMode";
 import { AnimatorLayerBlendingMode } from "./enums/AnimatorLayerBlendingMode";
 import { AnimatorStatePlayState } from "./enums/AnimatorStatePlayState";
 import { LayerState } from "./enums/LayerState";
+import { WrapMode } from "./enums/WrapMode";
 import { AnimationCurveLayerOwner } from "./internal/AnimationCurveLayerOwner";
 import { AnimationEventHandler } from "./internal/AnimationEventHandler";
 import { AnimatorLayerData } from "./internal/AnimatorLayerData";
@@ -31,13 +32,15 @@ import { AnimationCurveOwner } from "./internal/animationCurveOwner/AnimationCur
  */
 export class Animator extends Component {
   private static _passedTriggerParameterNames = new Array<string>();
-  private static _tempScripts: Script[] = [];
 
   /** Culling mode of this Animator. */
   cullingMode: AnimatorCullingMode = AnimatorCullingMode.None;
   /** The playback speed of the Animator, 1.0 is normal playback speed. */
   @assignmentClone
   speed = 1.0;
+  /** Whether the Animator sends AnimationEvent callbacks. */
+  @assignmentClone
+  fireEvents = true;
 
   /** @internal */
   _playFrameCount = -1;
@@ -56,6 +59,8 @@ 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
@@ -114,7 +119,9 @@ 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 {
-    this._resetIfControllerUpdated();
+    if (this._controllerUpdateFlag?.flag) {
+      this._reset();
+    }
 
     const stateInfo = this._getAnimatorStateInfo(stateName, layerIndex);
     const { state } = stateInfo;
@@ -189,7 +196,9 @@ export class Animator extends Component {
       return;
     }
 
-    this._resetIfControllerUpdated();
+    if (this._controllerUpdateFlag?.flag) {
+      this._reset();
+    }
 
     this._updateMark++;
 
@@ -201,34 +210,43 @@ export class Animator extends Component {
   }
 
   /**
-   * Get the state instance currently playing on the target layer.
+   * Get the playing state from the target layerIndex.
    * @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): AnimatorStateInstance | null {
-    this._resetIfControllerUpdated();
-    return this._animatorLayersData[layerIndex]?.srcPlayData?.instance ?? null;
+  getCurrentAnimatorState(layerIndex: number): AnimatorState {
+    return this._animatorLayersData[layerIndex]?.srcPlayData?.state;
   }
 
   /**
-   * Get the state instance for a named state on this Animator.
-   * Overrides on the returned instance only affect this Animator.
+   * Get the state by name.
+   * @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
+   */
+  /**
+   * Find the per-instance play data for a state by name.
+   * The returned object's `speed` and `wrapMode` are per-instance and safe to modify without affecting other Animator instances.
    * @param stateName - The 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.
+   * @returns Per-instance AnimatorStatePlayData, or null if not found
    */
-  findAnimatorState(stateName: string, layerIndex: number = -1): AnimatorStateInstance | null {
-    this._resetIfControllerUpdated();
+  findAnimatorState(stateName: string, layerIndex: number = -1): AnimatorStatePlayData {
     const { state, layerIndex: foundLayer } = this._getAnimatorStateInfo(stateName, layerIndex);
-    if (!state) return null;
-    return this._getAnimatorLayerData(foundLayer).getOrCreateInstance(state);
+    if (!state || foundLayer < 0) return null;
+    const layerData = this._animatorLayersData[foundLayer];
+    if (!layerData) return null;
+    // Check srcPlayData and destPlayData for the matching state
+    if (layerData.srcPlayData.state === state) return layerData.srcPlayData;
+    if (layerData.destPlayData.state === state) return layerData.destPlayData;
+    // State exists in controller but not currently playing — return srcPlayData initialized with the state
+    return layerData.srcPlayData;
   }
 
   /**
    * Get the layer by name.
    * @param name - The layer's name.
+   * @todo Return per-instance layer data (like AnimatorStatePlayData for states) instead of shared asset.
+   *       Currently returns the shared AnimatorControllerLayer — modifying `weight` affects all instances.
+   *       Should follow Unity's pattern: Animator.SetLayerWeight/GetLayerWeight (per-instance).
    */
   findLayerByName(name: string): AnimatorControllerLayer {
     return this._animatorController?._layersMap[name];
@@ -328,18 +346,13 @@ 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
    */
@@ -367,12 +380,11 @@ export class Animator extends Component {
     normalizedTimeOffset: number,
     isFixedDuration: boolean
   ): void {
-    this._resetIfControllerUpdated();
+    if (this._controllerUpdateFlag?.flag) {
+      this._reset();
+    }
 
     const { state, layerIndex: playLayerIndex } = this._getAnimatorStateInfo(stateName, layerIndex);
-    if (!state) {
-      return;
-    }
     const { manuallyTransition } = this._getAnimatorLayerData(playLayerIndex);
     manuallyTransition.duration = duration;
 
@@ -398,10 +410,8 @@ export class Animator extends Component {
             break;
           }
         }
-      } else if (layerIndex >= 0 && layerIndex < layers.length) {
-        state = layers[layerIndex].stateMachine.findStateByName(stateName);
       } else {
-        layerIndex = -1;
+        state = layers[layerIndex].stateMachine.findStateByName(stateName);
       }
     }
     stateInfo.layerIndex = layerIndex;
@@ -410,18 +420,19 @@ export class Animator extends Component {
   }
 
   private _getAnimatorStateData(
+    stateName: string,
     animatorState: AnimatorState,
     animatorLayerData: AnimatorLayerData,
     layerIndex: number
   ): AnimatorStateData {
     const { animatorStateDataMap } = animatorLayerData;
-    let animatorStateData = animatorStateDataMap.get(animatorState);
+    let animatorStateData = animatorStateDataMap[stateName];
     if (!animatorStateData) {
-      animatorStateData = new AnimatorStateData(animatorState);
-      animatorStateDataMap.set(animatorState, animatorStateData);
+      animatorStateData = new AnimatorStateData();
+      animatorStateDataMap[stateName] = animatorStateData;
       this._saveAnimatorStateData(animatorState, animatorStateData, animatorLayerData, layerIndex);
+      this._saveAnimatorEventHandlers(animatorState, animatorStateData);
     }
-    this._ensureEventHandlers(animatorState, animatorStateData);
     return animatorStateData;
   }
 
@@ -478,41 +489,34 @@ export class Animator extends Component {
     }
   }
 
-  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 = Animator._tempScripts;
-    this._entity.getComponents(Script, scripts);
-    const scriptCount = scripts.length;
-    const { events } = state.clip;
+  private _saveAnimatorEventHandlers(state: AnimatorState, animatorStateData: AnimatorStateData): void {
+    const eventHandlerPool = this._animationEventHandlerPool;
+    const scripts = [];
     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;
 
-      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);
+    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);
       }
-      eventHandlers.push(eventHandler);
-    }
-    scripts.length = 0;
-    animatorStateData.eventsBuiltVersion = stateVersion;
-    animatorStateData.eventsBuiltScriptsVersion = scriptsVersion;
+    };
+    clipChangedListener();
+    state._updateFlagManager.addListener(clipChangedListener);
   }
 
   private _clearCrossData(animatorLayerData: AnimatorLayerData): void {
@@ -539,8 +543,8 @@ export class Animator extends Component {
   }
 
   private _prepareStandbyCrossFading(animatorLayerData: AnimatorLayerData): void {
-    // 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);
+    // 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);
     // Add dest cross curve data
     this._prepareDestCrossData(animatorLayerData, true);
   }
@@ -632,9 +636,9 @@ export class Animator extends Component {
     aniUpdate: boolean
   ): void {
     const { srcPlayData } = layerData;
-    const state = srcPlayData.instance._state;
+    const { state } = srcPlayData;
 
-    const playSpeed = srcPlayData.instance.speed * this.speed;
+    const playSpeed = srcPlayData.speed * this.speed;
     const playDeltaTime = playSpeed * deltaTime;
 
     srcPlayData.updateOrientation(playDeltaTime);
@@ -717,9 +721,8 @@ export class Animator extends Component {
     );
 
     if (transition) {
-      // 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;
+      // Remove speed factor, use actual cost time
+      const remainDeltaTime = deltaTime - playCostTime / playSpeed;
       remainDeltaTime > 0 && this._updateState(layerData, remainDeltaTime, aniUpdate);
     }
   }
@@ -730,7 +733,7 @@ export class Animator extends Component {
     additive: boolean,
     aniUpdate: boolean
   ): void {
-    const curveBindings = playData.instance.clip._curveBindings;
+    const curveBindings = playData.state.clip._curveBindings;
     const finished = playData.playState === AnimatorStatePlayState.Finished;
 
     if (aniUpdate || finished) {
@@ -764,20 +767,20 @@ export class Animator extends Component {
   ) {
     const { srcPlayData, destPlayData, layerIndex } = layerData;
     const { speed } = this;
-    const srcState = srcPlayData.instance._state;
-    const destState = destPlayData.instance._state;
+    const { state: srcState } = srcPlayData;
+    const { state: destState } = destPlayData;
     const transitionDuration = layerData.crossFadeTransition._getFixedDuration();
 
     if (this._tryCrossFadeInterrupt(layerData, transitionDuration, destState, deltaTime, aniUpdate)) {
       return;
     }
 
-    const srcPlaySpeed = srcPlayData.instance.speed * speed;
-    const dstPlaySpeed = destPlayData.instance.speed * speed;
+    const srcPlaySpeed = srcPlayData.speed * speed;
+    const dstPlaySpeed = destPlayData.speed * speed;
     const dstPlayDeltaTime = dstPlaySpeed * deltaTime;
 
-    srcPlayData.updateOrientation(srcPlaySpeed * deltaTime);
-    destPlayData.updateOrientation(dstPlayDeltaTime);
+    srcPlayData && srcPlayData.updateOrientation(srcPlaySpeed * deltaTime);
+    destPlayData && destPlayData.updateOrientation(dstPlayDeltaTime);
 
     const { clipTime: lastSrcClipTime, playState: lastSrcPlayState } = srcPlayData;
     const { clipTime: lastDestClipTime, playState: lastDstPlayState } = destPlayData;
@@ -855,8 +858,8 @@ export class Animator extends Component {
     aniUpdate: boolean
   ) {
     const { crossLayerOwnerCollection } = layerData;
-    const { _curveBindings: srcCurves } = srcPlayData.instance.clip;
-    const destState = destPlayData.instance._state;
+    const { _curveBindings: srcCurves } = srcPlayData.state.clip;
+    const { state: destState } = destPlayData;
     const { _curveBindings: destCurves } = destState.clip;
 
     const finished = destPlayData.playState === AnimatorStatePlayState.Finished;
@@ -895,14 +898,14 @@ export class Animator extends Component {
     aniUpdate: boolean
   ) {
     const { destPlayData } = layerData;
-    const state = destPlayData.instance._state;
+    const { state } = destPlayData;
     const transitionDuration = layerData.crossFadeTransition._getFixedDuration();
 
     if (this._tryCrossFadeInterrupt(layerData, transitionDuration, state, deltaTime, aniUpdate)) {
       return;
     }
 
-    const playSpeed = destPlayData.instance.speed * this.speed;
+    const playSpeed = destPlayData.speed * this.speed;
     const playDeltaTime = playSpeed * deltaTime;
 
     destPlayData.updateOrientation(playDeltaTime);
@@ -969,7 +972,7 @@ export class Animator extends Component {
     aniUpdate: boolean
   ) {
     const { crossLayerOwnerCollection } = layerData;
-    const state = destPlayData.instance._state;
+    const { state } = destPlayData;
     const { _curveBindings: curveBindings } = state.clip;
 
     const { clipTime: destClipTime, playState } = destPlayData;
@@ -1007,8 +1010,8 @@ export class Animator extends Component {
     aniUpdate: boolean
   ): void {
     const playData = layerData.srcPlayData;
-    const state = playData.instance._state;
-    const actualSpeed = playData.instance.speed * this.speed;
+    const { state } = playData;
+    const actualSpeed = playData.speed * this.speed;
     const actualDeltaTime = actualSpeed * deltaTime;
 
     playData.updateOrientation(actualDeltaTime);
@@ -1049,7 +1052,7 @@ export class Animator extends Component {
     }
 
     const { curveLayerOwner } = playData.stateData;
-    const { _curveBindings: curveBindings } = playData.instance.clip;
+    const { _curveBindings: curveBindings } = playData.state.clip;
 
     for (let i = curveBindings.length - 1; i >= 0; i--) {
       const layerOwner = curveLayerOwner[i];
@@ -1070,13 +1073,14 @@ export class Animator extends Component {
     } else {
       layerData.layerState = LayerState.Playing;
     }
-    layerData.completeCrossFade();
+    layerData.switchPlayData();
+    layerData.crossFadeTransition = null;
   }
 
   private _preparePlayOwner(layerData: AnimatorLayerData, playState: AnimatorState): void {
     if (layerData.layerState === LayerState.Playing) {
       const srcPlayData = layerData.srcPlayData;
-      if (srcPlayData.instance._state !== playState) {
+      if (srcPlayData.state !== playState) {
         const { curveLayerOwner } = srcPlayData.stateData;
         for (let i = curveLayerOwner.length - 1; i >= 0; i--) {
           curveLayerOwner[i]?.curveOwner.revertDefaultValue();
@@ -1100,7 +1104,7 @@ export class Animator extends Component {
     deltaTime: number,
     aniUpdate: boolean
   ): AnimatorStateTransition {
-    const state = playData.instance._state;
+    const { state } = playData;
     const clipDuration = state.clip.length;
     let targetTransition: AnimatorStateTransition = null;
     const startTime = state.clipStartTime * clipDuration;
@@ -1317,23 +1321,19 @@ 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 ${state.name} has no AnimationClip data.`);
+      Logger.warn(`The state named ${name} has no AnimationClip data.`);
       return false;
     }
 
     const animatorLayerData = this._getAnimatorLayerData(layerIndex);
-    const animatorStateData = this._getAnimatorStateData(state, animatorLayerData, layerIndex);
+    const animatorStateData = this._getAnimatorStateData(name, state, animatorLayerData, layerIndex);
 
     this._preparePlayOwner(animatorLayerData, state);
 
     animatorLayerData.layerState = LayerState.Playing;
-    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.srcPlayData.reset(state, animatorStateData, state._getClipActualEndTime() * normalizedTimeOffset);
     animatorLayerData.resetCurrentCheckIndex();
 
     return true;
@@ -1433,21 +1433,13 @@ export class Animator extends Component {
     }
 
     const animatorLayerData = this._getAnimatorLayerData(layerIndex);
+    const animatorStateData = this._getAnimatorStateData(crossState.name, crossState, animatorLayerData, layerIndex);
 
-    // 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.destPlayData.reset(
+      crossState,
+      animatorStateData,
+      transition.offset * crossState._getClipActualEndTime()
+    );
     animatorLayerData.resetCurrentCheckIndex();
 
     switch (animatorLayerData.layerState) {
@@ -1482,24 +1474,28 @@ export class Animator extends Component {
     lastClipTime: number,
     deltaTime: number
   ): void {
-    const { isForward, clipTime } = playData;
-    const state = playData.instance._state;
+    const { state, isForward, clipTime, wrapMode } = playData;
     const startTime = state._getClipActualStartTime();
     const endTime = state._getClipActualEndTime();
+    const canWrap = wrapMode === WrapMode.Loop;
 
     if (isForward) {
       if (lastClipTime + deltaTime >= endTime) {
         this._fireSubAnimationEvents(playData, eventHandlers, lastClipTime, endTime);
-        playData.currentEventIndex = 0;
-        this._fireSubAnimationEvents(playData, eventHandlers, startTime, clipTime);
+        if (canWrap) {
+          playData.currentEventIndex = 0;
+          this._fireSubAnimationEvents(playData, eventHandlers, startTime, clipTime);
+        }
       } else {
         this._fireSubAnimationEvents(playData, eventHandlers, lastClipTime, clipTime);
       }
     } else {
       if (lastClipTime + deltaTime <= startTime) {
         this._fireBackwardSubAnimationEvents(playData, eventHandlers, lastClipTime, startTime);
-        playData.currentEventIndex = eventHandlers.length - 1;
-        this._fireBackwardSubAnimationEvents(playData, eventHandlers, endTime, clipTime);
+        if (canWrap) {
+          playData.currentEventIndex = eventHandlers.length - 1;
+          this._fireBackwardSubAnimationEvents(playData, eventHandlers, endTime, clipTime);
+        }
       } else {
         this._fireBackwardSubAnimationEvents(playData, eventHandlers, lastClipTime, clipTime);
       }
@@ -1595,12 +1591,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);
+    this.fireEvents &&
+      eventHandlers.length &&
+      this._fireAnimationEvents(playData, eventHandlers, lastClipTime, deltaTime);
 
     if (lastPlayState === AnimatorStatePlayState.UnStarted) {
       state._callOnEnter(this, layerIndex);
diff --git a/packages/core/src/animation/AnimatorStateInstance.ts b/packages/core/src/animation/AnimatorStateInstance.ts
deleted file mode 100644
index 9bcdfa0fb5..0000000000
--- a/packages/core/src/animation/AnimatorStateInstance.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { AnimationClip } from "./AnimationClip";
-import { AnimatorState } from "./AnimatorState";
-import { AnimatorStatePlayData } from "./internal/AnimatorStatePlayData";
-import { WrapMode } from "./enums/WrapMode";
-
-/**
- * Per-Animator view of an `AnimatorState`.
- *
- * Override fields (speed, wrapMode) are scoped to this Animator; 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;
-
-  /**
-   * The name of the underlying state.
-   */
-  get name(): string {
-    return this._state.name;
-  }
-
-  /**
-   * The animation clip of the underlying state.
-   */
-  get clip(): AnimationClip {
-    return this._state.clip;
-  }
-
-  /**
-   * The normalized clip start time of the underlying state.
-   */
-  get clipStartTime(): number {
-    return this._state.clipStartTime;
-  }
-
-  /**
-   * The normalized clip end time of the underlying state.
-   */
-  get clipEndTime(): number {
-    return this._state.clipEndTime;
-  }
-
-  /**
-   * Playback speed for this Animator; overrides the underlying state when set.
-   */
-  get speed(): number {
-    return this._speed ?? this._state.speed;
-  }
-
-  set speed(value: number) {
-    this._speed = value;
-  }
-
-  /**
-   * Wrap mode for this Animator; overrides the underlying state when set.
-   */
-  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 3200aab5df..7a2914280a 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. Cleared to `null` if the state is removed via `removeState`.
+   * @remarks When the Animator's AnimatorController changed or the Animator's onEnable be triggered.
    */
-  defaultState: AnimatorState | null = null;
+  defaultState: AnimatorState;
 
   /** @internal */
   _entryTransitionCollection = new AnimatorStateTransitionCollection();
@@ -68,11 +68,8 @@ 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 1bbffce883..bd201a871f 100644
--- a/packages/core/src/animation/index.ts
+++ b/packages/core/src/animation/index.ts
@@ -11,7 +11,7 @@ export { Animator } from "./Animator";
 export { AnimatorController } from "./AnimatorController";
 export { AnimatorControllerLayer } from "./AnimatorControllerLayer";
 export { AnimatorState } from "./AnimatorState";
-export { AnimatorStateInstance } from "./AnimatorStateInstance";
+export { AnimatorStatePlayData } from "./internal/AnimatorStatePlayData";
 export { AnimatorStateMachine } from "./AnimatorStateMachine";
 export { AnimatorStateTransition } from "./AnimatorStateTransition";
 export { AnimatorConditionMode } from "./enums/AnimatorConditionMode";
diff --git a/packages/core/src/animation/internal/AnimationEventHandler.ts b/packages/core/src/animation/internal/AnimationEventHandler.ts
index b3231e24bf..9124846f92 100644
--- a/packages/core/src/animation/internal/AnimationEventHandler.ts
+++ b/packages/core/src/animation/internal/AnimationEventHandler.ts
@@ -1,9 +1,11 @@
+import { IPoolElement } from "../../utils/ObjectPool";
 import { AnimationEvent } from "../AnimationEvent";
-
 /**
  * @internal
  */
-export class AnimationEventHandler {
+export class AnimationEventHandler implements IPoolElement {
   event: AnimationEvent;
   handlers: Function[] = [];
+
+  dispose() {}
 }
diff --git a/packages/core/src/animation/internal/AnimatorLayerData.ts b/packages/core/src/animation/internal/AnimatorLayerData.ts
index a3b2677c0b..a7bd04f1a5 100644
--- a/packages/core/src/animation/internal/AnimatorLayerData.ts
+++ b/packages/core/src/animation/internal/AnimatorLayerData.ts
@@ -1,11 +1,9 @@
 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 type { AnimatorStatePlayData } from "./AnimatorStatePlayData";
+import { AnimatorStatePlayData } from "./AnimatorStatePlayData";
 
 /**
  * @internal
@@ -14,35 +12,20 @@ export class AnimatorLayerData {
   layerIndex: number;
   layer: AnimatorControllerLayer;
   curveOwnerPool: Record<number, Record<string, AnimationCurveLayerOwner>> = Object.create(null);
-  animatorStateDataMap: WeakMap<AnimatorState, AnimatorStateData> = new WeakMap();
-  instanceMap: WeakMap<AnimatorState, AnimatorStateInstance> = new WeakMap();
-  srcPlayData: AnimatorStatePlayData | null = null;
-  destPlayData: AnimatorStatePlayData | null = null;
+  animatorStateDataMap: Record<string, AnimatorStateData> = {};
+  srcPlayData: AnimatorStatePlayData = new AnimatorStatePlayData();
+  destPlayData: AnimatorStatePlayData = new AnimatorStatePlayData();
   layerState: LayerState = LayerState.Standby;
   crossCurveMark: number = 0;
   manuallyTransition: AnimatorStateTransition = new AnimatorStateTransition();
   crossFadeTransition: AnimatorStateTransition;
   crossLayerOwnerCollection: AnimationCurveLayerOwner[] = [];
 
-  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;
+  switchPlayData(): void {
+    const srcPlayData = this.destPlayData;
+    const switchTemp = this.srcPlayData;
+    this.srcPlayData = srcPlayData;
+    this.destPlayData = switchTemp;
   }
 
   resetCurrentCheckIndex(): void {
diff --git a/packages/core/src/animation/internal/AnimatorStateData.ts b/packages/core/src/animation/internal/AnimatorStateData.ts
index 08d455ac38..146c0bb52f 100644
--- a/packages/core/src/animation/internal/AnimatorStateData.ts
+++ b/packages/core/src/animation/internal/AnimatorStateData.ts
@@ -1,4 +1,3 @@
-import { AnimatorState } from "../AnimatorState";
 import { AnimationCurveLayerOwner } from "./AnimationCurveLayerOwner";
 import { AnimationEventHandler } from "./AnimationEventHandler";
 
@@ -8,8 +7,4 @@ 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 a4f2c80142..7adc90c2f4 100644
--- a/packages/core/src/animation/internal/AnimatorStatePlayData.ts
+++ b/packages/core/src/animation/internal/AnimatorStatePlayData.ts
@@ -1,36 +1,75 @@
-import { AnimatorStateInstance } from "../AnimatorStateInstance";
+import { AnimationClip } from "../AnimationClip";
+import { AnimatorState } from "../AnimatorState";
+import { AnimatorStateTransition } from "../AnimatorStateTransition";
 import { AnimatorStatePlayState } from "../enums/AnimatorStatePlayState";
 import { WrapMode } from "../enums/WrapMode";
+import { StateMachineScript } from "../StateMachineScript";
 import { AnimatorStateData } from "./AnimatorStateData";
 
 /**
- * @internal
+ * Per-instance runtime data for an AnimatorState.
+ * Proxies read-only properties from the shared AnimatorState asset,
+ * while providing per-instance mutable properties (e.g. speed, wrapMode).
  */
 export class AnimatorStatePlayData {
+  /** @internal */
+  state: AnimatorState;
+  /** @internal */
   stateData: AnimatorStateData;
+  /** @internal */
+  playedTime: number;
+  playState: AnimatorStatePlayState;
+  /** @internal */
+  clipTime: number;
+  /** @internal */
+  currentEventIndex: number;
+  /** @internal */
+  isForward = true;
+  /** @internal */
+  offsetFrameTime: number;
+  /** Per-instance speed. Initialized from AnimatorState.speed, safe to modify without affecting other instances. */
+  speed: number = 1.0;
+  /** Per-instance wrap mode. Initialized from AnimatorState.wrapMode, safe to modify without affecting other instances. */
+  wrapMode: WrapMode = WrapMode.Loop;
 
-  playedTime: number = 0;
-  playState: AnimatorStatePlayState = AnimatorStatePlayState.UnStarted;
-  clipTime: number = 0;
-  currentEventIndex: number = 0;
-  isForward: boolean = true;
-  offsetFrameTime: number = 0;
+  // ── Proxy properties from AnimatorState (read-only) ──
 
-  private _changedOrientation: boolean = false;
+  /** The name of the state. */
+  get name(): string {
+    return this.state.name;
+  }
 
-  constructor(public readonly instance: AnimatorStateInstance) {}
+  /** The clip played by this state. */
+  get clip(): AnimationClip {
+    return this.state.clip;
+  }
 
-  reset(stateData: AnimatorStateData, offsetFrameTime: number): void {
-    const state = this.instance._state;
-    this.stateData = stateData;
-    this.offsetFrameTime = offsetFrameTime;
+  /** The transitions going out of this state. */
+  get transitions(): Readonly<AnimatorStateTransition[]> {
+    return this.state.transitions;
+  }
+
+  /**
+   * Add a state machine script to the underlying AnimatorState.
+   */
+  addStateMachineScript<T extends StateMachineScript>(scriptType: new () => T): T {
+    return this.state.addStateMachineScript(scriptType);
+  }
+
+  private _changedOrientation = false;
+
+  reset(state: AnimatorState, stateData: AnimatorStateData, offsetFrameTime: number): void {
+    this.state = state;
     this.playedTime = 0;
+    this.offsetFrameTime = offsetFrameTime;
+    this.stateData = stateData;
     this.playState = AnimatorStatePlayState.UnStarted;
     this.clipTime = state.clipStartTime * state.clip.length;
     this.currentEventIndex = 0;
     this.isForward = true;
-    this._changedOrientation = false;
-    state._transitionCollection.needResetCurrentCheckIndex = true;
+    this.speed = state.speed;
+    this.wrapMode = state.wrapMode;
+    this.state._transitionCollection.needResetCurrentCheckIndex = true;
   }
 
   updateOrientation(deltaTime: number): void {
@@ -46,12 +85,11 @@ export class AnimatorStatePlayData {
 
   update(deltaTime: number): void {
     this.playedTime += deltaTime;
-    const instance = this.instance;
-    const state = instance._state;
+    const state = this.state;
     let time = this.playedTime + this.offsetFrameTime;
     const duration = state._getDuration();
     this.playState = AnimatorStatePlayState.Playing;
-    if (instance.wrapMode === WrapMode.Loop) {
+    if (this.wrapMode === WrapMode.Loop) {
       time = duration ? time % duration : 0;
     } else {
       if (Math.abs(time) >= duration) {
@@ -69,9 +107,8 @@ export class AnimatorStatePlayData {
     }
   }
 
-  private _correctTime(): void {
-    const state = this.instance._state;
-    // Reverse playback at clipTime=0 would step into negatives; jump to clipEnd.
+  private _correctTime() {
+    const { state } = this;
     if (this.clipTime === 0) {
       this.clipTime = state.clipEndTime * state.clip.length;
     }
diff --git a/packages/core/src/audio/AudioManager.ts b/packages/core/src/audio/AudioManager.ts
index 3aff4b19ee..b1c4c5651b 100644
--- a/packages/core/src/audio/AudioManager.ts
+++ b/packages/core/src/audio/AudioManager.ts
@@ -1,3 +1,9 @@
+type ResumableAudioSource = {
+  _resumePendingPlayback(): void;
+  _suspendPlaybackForInterruption(): boolean;
+  _resumeInterruptedPlayback(): void;
+};
+
 /**
  * Audio Manager for managing global audio context and settings.
  */
@@ -7,15 +13,22 @@ export class AudioManager {
 
   private static _context: AudioContext;
   private static _gainNode: GainNode;
-  private static _resumePromise: Promise<void> = null;
   private static _needsUserGestureResume = false;
+  private static _pendingSources = new Set<ResumableAudioSource>();
+  private static _playingSources = new Set<ResumableAudioSource>();
+  private static _interruptedSources = new Set<ResumableAudioSource>();
+  private static _foregroundRestoreDelay = 300;
+  private static _foregroundRestoreTimer: number | undefined;
+  private static _hidden = false;
+  private static _eventsBound = false;
 
   /**
    * Suspend the audio context.
    * @returns A promise that resolves when the audio context is suspended
    */
   static suspend(): Promise<void> {
-    return AudioManager.getContext().suspend();
+    AudioManager._suspendActiveSourcesForInterruption();
+    return AudioManager._context?.suspend() ?? Promise.resolve();
   }
 
   /**
@@ -24,14 +37,48 @@ export class AudioManager {
    * @returns A promise that resolves when the audio context is resumed
    */
   static resume(): Promise<void> {
-    return (AudioManager._resumePromise ??= AudioManager.getContext()
-      .resume()
-      .then(() => {
-        AudioManager._needsUserGestureResume = false;
-      })
-      .finally(() => {
-        AudioManager._resumePromise = null;
-      }));
+    const context = AudioManager._context;
+    if (!context) {
+      return Promise.resolve();
+    }
+    if (context.state === "running") {
+      AudioManager._clearForegroundRestore();
+      AudioManager._needsUserGestureResume = false;
+      AudioManager._resumePendingSources();
+      AudioManager._resumeInterruptedSources();
+      return Promise.resolve();
+    }
+    return context.resume().then(() => {
+      AudioManager._clearForegroundRestore();
+      AudioManager._needsUserGestureResume = false;
+      AudioManager._resumePendingSources();
+      AudioManager._resumeInterruptedSources();
+    });
+  }
+
+  /** @internal */
+  static _registerPendingSource(source: ResumableAudioSource): void {
+    AudioManager._pendingSources.add(source);
+  }
+
+  /** @internal */
+  static _unregisterPendingSource(source: ResumableAudioSource): void {
+    AudioManager._pendingSources.delete(source);
+  }
+
+  /** @internal */
+  static _registerPlayingSource(source: ResumableAudioSource): void {
+    AudioManager._playingSources.add(source);
+  }
+
+  /** @internal */
+  static _unregisterPlayingSource(source: ResumableAudioSource): void {
+    AudioManager._playingSources.delete(source);
+  }
+
+  /** @internal */
+  static _unregisterInterruptedSource(source: ResumableAudioSource): void {
+    AudioManager._interruptedSources.delete(source);
   }
 
   /**
@@ -41,11 +88,12 @@ export class AudioManager {
     let context = AudioManager._context;
     if (!context) {
       AudioManager._context = context = new window.AudioContext();
-      document.addEventListener("visibilitychange", AudioManager._onVisibilityChange);
-      // iOS Safari requires user gesture to resume AudioContext
-      document.addEventListener("touchstart", AudioManager._resumeAfterInterruption, { passive: true });
-      document.addEventListener("touchend", AudioManager._resumeAfterInterruption, { passive: true });
-      document.addEventListener("click", AudioManager._resumeAfterInterruption);
+      context.onstatechange = AudioManager._onContextStateChange;
+      if (!AudioManager._eventsBound) {
+        AudioManager._eventsBound = true;
+        AudioManager._bindLifecycleEvents();
+        AudioManager._bindGestureEvents();
+      }
     }
     return context;
   }
@@ -70,22 +118,153 @@ export class AudioManager {
     return AudioManager.getContext().state === "running";
   }
 
-  private static _onVisibilityChange(): void {
-    if (!document.hidden && AudioManager._playingCount > 0 && !AudioManager.isAudioContextRunning()) {
-      // iOS WKWebView WebKit bug(Triggered in LingGuang App): AudioContext may be in a "zombie" state where
-      // state reports "suspended" but resume() alone won't restart audio rendering.
-      // Calling suspend() first forces a clean internal state reset before user gesture triggers resume.
-      // Related: https://bugs.webkit.org/show_bug.cgi?id=263627
-      AudioManager.suspend();
-      AudioManager._needsUserGestureResume = true;
+  private static _onContextStateChange(): void {
+    if (AudioManager._context?.state === "running") {
+      if (AudioManager._hidden || AudioManager._needsUserGestureResume) {
+        return;
+      }
+      AudioManager._needsUserGestureResume = false;
+      AudioManager._resumePendingSources();
+      AudioManager._resumeInterruptedSources();
+    }
+  }
+
+  private static _resumePendingSources(): void {
+    if (!AudioManager._pendingSources.size || !AudioManager.isAudioContextRunning()) {
+      return;
+    }
+
+    const pendingSources = Array.from(AudioManager._pendingSources);
+    AudioManager._pendingSources.clear();
+
+    for (let i = 0, n = pendingSources.length; i < n; i++) {
+      pendingSources[i]._resumePendingPlayback();
+    }
+  }
+
+  private static _suspendActiveSourcesForInterruption(): void {
+    if (!AudioManager._playingSources.size) {
+      return;
+    }
+
+    const playingSources = Array.from(AudioManager._playingSources);
+    for (let i = 0, n = playingSources.length; i < n; i++) {
+      const source = playingSources[i];
+      if (source._suspendPlaybackForInterruption()) {
+        AudioManager._interruptedSources.add(source);
+      }
+    }
+  }
+
+  private static _resumeInterruptedSources(): void {
+    if (!AudioManager._interruptedSources.size || !AudioManager.isAudioContextRunning()) {
+      return;
+    }
+
+    const interruptedSources = Array.from(AudioManager._interruptedSources);
+    AudioManager._interruptedSources.clear();
+
+    for (let i = 0, n = interruptedSources.length; i < n; i++) {
+      interruptedSources[i]._resumeInterruptedPlayback();
+    }
+  }
+
+  private static _bindLifecycleEvents(): void {
+    const hiddenProp = AudioManager._getHiddenProp();
+    const visibilityEvents = [
+      "visibilitychange",
+      "mozvisibilitychange",
+      "msvisibilitychange",
+      "webkitvisibilitychange",
+      "qbrowserVisibilityChange"
+    ];
+
+    for (let i = 0, n = visibilityEvents.length; i < n; i++) {
+      document.addEventListener(visibilityEvents[i], (event) => {
+        const hidden = hiddenProp ? Boolean((document as any)[hiddenProp] || (event as any)?.hidden) : document.hidden;
+        hidden ? AudioManager._onHidden() : AudioManager._onShown();
+      });
+    }
+
+    window.addEventListener("pagehide", AudioManager._onHidden);
+    window.addEventListener("pageshow", AudioManager._onShown);
+    document.addEventListener("pagehide", AudioManager._onHidden);
+    document.addEventListener("pageshow", AudioManager._onShown);
+  }
+
+  private static _bindGestureEvents(): void {
+    const gestureEvents = ["pointerdown", "pointerup", "touchstart", "touchend", "mouseup", "click"];
+    for (let i = 0, n = gestureEvents.length; i < n; i++) {
+      document.addEventListener(gestureEvents[i], AudioManager._resumeAfterInterruption, { passive: true });
+    }
+  }
+
+  private static _getHiddenProp(): string {
+    const doc = document as any;
+    if (typeof doc.hidden !== "undefined") return "hidden";
+    if (typeof doc.mozHidden !== "undefined") return "mozHidden";
+    if (typeof doc.msHidden !== "undefined") return "msHidden";
+    if (typeof doc.webkitHidden !== "undefined") return "webkitHidden";
+    return "";
+  }
+
+  private static _hasResumeWork(): boolean {
+    return (
+      AudioManager._needsUserGestureResume ||
+      AudioManager._pendingSources.size > 0 ||
+      AudioManager._interruptedSources.size > 0
+    );
+  }
+
+  private static _onHidden(): void {
+    if (AudioManager._hidden) {
+      return;
+    }
+    AudioManager._hidden = true;
+    AudioManager._clearForegroundRestore();
+    AudioManager.suspend().catch(() => {});
+  }
+
+  private static _onShown(): void {
+    if (!AudioManager._hidden) {
+      return;
+    }
+    AudioManager._hidden = false;
+
+    if (AudioManager._hasResumeWork()) {
+      AudioManager._prepareGestureResume();
+      AudioManager._scheduleForegroundRestore();
     }
   }
 
   private static _resumeAfterInterruption(): void {
-    if (AudioManager._needsUserGestureResume) {
+    if (AudioManager._hasResumeWork()) {
       AudioManager.resume().catch((e) => {
         console.warn("Failed to resume AudioContext:", e);
       });
     }
   }
+
+  private static _scheduleForegroundRestore(): void {
+    AudioManager._clearForegroundRestore();
+    AudioManager._foregroundRestoreTimer = window.setTimeout(() => {
+      AudioManager._foregroundRestoreTimer = undefined;
+      AudioManager.resume().catch(() => AudioManager._prepareGestureResume());
+    }, AudioManager._foregroundRestoreDelay);
+  }
+
+  private static _clearForegroundRestore(): void {
+    if (AudioManager._foregroundRestoreTimer === undefined) {
+      return;
+    }
+    window.clearTimeout(AudioManager._foregroundRestoreTimer);
+    AudioManager._foregroundRestoreTimer = undefined;
+  }
+
+  private static _prepareGestureResume(): Promise<void> {
+    // iOS WKWebView may report a resumable state while rendering is still frozen.
+    // Force a clean context edge, then let a gesture or foreground retry restore sources.
+    AudioManager._needsUserGestureResume = true;
+    return AudioManager.suspend().catch(() => {});
+  }
 }
diff --git a/packages/core/src/audio/AudioSource.ts b/packages/core/src/audio/AudioSource.ts
index 29a3ed8bc1..3dacf53ec3 100644
--- a/packages/core/src/audio/AudioSource.ts
+++ b/packages/core/src/audio/AudioSource.ts
@@ -159,27 +159,11 @@ export class AudioSource extends Component {
     if (AudioManager.isAudioContextRunning()) {
       this._startPlayback();
     } else {
-      // iOS Safari requires resume() to be called within the same user gesture callback that triggers playback.
-      // Document-level events won't work - must call resume() directly here in play().
       this._pendingPlay = true;
-      AudioManager.resume().then(
-        () => {
-          // Check if cancelled by stop()/pause()
-          if (!this._pendingPlay) {
-            return;
-          }
-          this._pendingPlay = false;
-          // Check if still valid to play after async resume
-          if (this._destroyed || !this.enabled || !this._clip) {
-            return;
-          }
-          this._startPlayback();
-        },
-        (e) => {
-          this._pendingPlay = false;
-          console.warn("Failed to resume AudioContext:", e);
-        }
-      );
+      AudioManager._registerPendingSource(this);
+      AudioManager.resume().catch((e) => {
+        console.warn("Failed to resume AudioContext:", e);
+      });
     }
   }
 
@@ -187,23 +171,27 @@ export class AudioSource extends Component {
    * Stops playing the clip.
    */
   stop(): void {
-    this._pendingPlay = false;
+    this._cancelPendingPlayback();
+    AudioManager._unregisterInterruptedSource(this);
 
     if (this._isPlaying) {
       this._clearSourceNode();
 
       this._isPlaying = false;
-      this._pausedTime = -1;
-      this._playTime = -1;
       AudioManager._playingCount--;
+      AudioManager._unregisterPlayingSource(this);
     }
+
+    this._pausedTime = -1;
+    this._playTime = -1;
   }
 
   /**
    * Pauses playing the clip.
    */
   pause(): void {
-    this._pendingPlay = false;
+    this._cancelPendingPlayback();
+    AudioManager._unregisterInterruptedSource(this);
 
     if (this._isPlaying) {
       this._clearSourceNode();
@@ -211,6 +199,7 @@ export class AudioSource extends Component {
       this._pausedTime = AudioManager.getContext().currentTime;
       this._isPlaying = false;
       AudioManager._playingCount--;
+      AudioManager._unregisterPlayingSource(this);
     }
   }
 
@@ -250,34 +239,120 @@ export class AudioSource extends Component {
     this.stop();
   }
 
+  /** @internal */
+  _resumePendingPlayback(): void {
+    if (!this._pendingPlay) {
+      return;
+    }
+
+    this._pendingPlay = false;
+
+    if (this._destroyed || !this.enabled || !this._clip?._getAudioSource()) {
+      return;
+    }
+
+    this._startPlayback();
+  }
+
+  /** @internal */
+  _suspendPlaybackForInterruption(): boolean {
+    if (!this._isPlaying) {
+      return false;
+    }
+
+    const pausedTime = AudioManager.getContext().currentTime;
+    this._clearSourceNode();
+
+    this._pausedTime = pausedTime;
+    this._isPlaying = false;
+    AudioManager._playingCount--;
+    AudioManager._unregisterPlayingSource(this);
+
+    return true;
+  }
+
+  /** @internal */
+  _resumeInterruptedPlayback(): void {
+    if (
+      this._destroyed ||
+      !this.enabled ||
+      this._isPlaying ||
+      this._pendingPlay ||
+      !this._clip?._getAudioSource() ||
+      this._playTime < 0
+    ) {
+      return;
+    }
+
+    if (AudioManager.isAudioContextRunning()) {
+      this._startPlayback();
+    } else {
+      this._pendingPlay = true;
+      AudioManager._registerPendingSource(this);
+    }
+  }
+
   private _startPlayback(): void {
     const startTime = this._pausedTime > 0 ? this._pausedTime - this._playTime : 0;
-    this._initSourceNode(startTime);
+    if (!this._initSourceNode(startTime)) {
+      this._pausedTime = -1;
+      this._playTime = -1;
+      return;
+    }
 
     this._playTime = AudioManager.getContext().currentTime - startTime;
     this._pausedTime = -1;
     this._isPlaying = true;
     AudioManager._playingCount++;
+    AudioManager._registerPlayingSource(this);
   }
 
-  private _initSourceNode(startTime: number): void {
+  private _initSourceNode(startTime: number): boolean {
     const context = AudioManager.getContext();
     const sourceNode = context.createBufferSource();
+    const audioBuffer = this._clip._getAudioSource();
+    const duration = audioBuffer.duration;
+    let offset = Math.max(0, startTime);
+
+    if (duration > 0) {
+      if (this._loop) {
+        offset %= duration;
+      } else if (offset >= duration) {
+        return false;
+      }
+    }
 
-    sourceNode.buffer = this._clip._getAudioSource();
+    sourceNode.buffer = audioBuffer;
     sourceNode.playbackRate.value = this._playbackRate;
     sourceNode.loop = this._loop;
     sourceNode.onended = this._onPlayEnd;
     this._sourceNode = sourceNode;
 
     sourceNode.connect(this._gainNode);
-    sourceNode.start(0, startTime);
+    sourceNode.start(0, offset);
+    return true;
   }
 
   private _clearSourceNode(): void {
-    this._sourceNode.stop();
-    this._sourceNode.disconnect();
-    this._sourceNode.onended = null;
+    const sourceNode = this._sourceNode;
+    if (!sourceNode) {
+      return;
+    }
+
+    sourceNode.onended = null;
+    try {
+      sourceNode.stop();
+    } catch {}
+    sourceNode.disconnect();
     this._sourceNode = null;
   }
+
+  private _cancelPendingPlayback(): void {
+    if (!this._pendingPlay) {
+      return;
+    }
+
+    this._pendingPlay = false;
+    AudioManager._unregisterPendingSource(this);
+  }
 }
diff --git a/packages/core/src/clone/CloneManager.ts b/packages/core/src/clone/CloneManager.ts
index be46462982..b6f94ce248 100644
--- a/packages/core/src/clone/CloneManager.ts
+++ b/packages/core/src/clone/CloneManager.ts
@@ -105,21 +105,46 @@ export class CloneManager {
   ): void {
     const sourceProperty = source[k];
 
-    // Remappable references (Entity/Component) are always remapped, regardless of clone decorator
+    // 1. Remappable references (Entity/Component) are always remapped, highest priority
     if (sourceProperty instanceof Object && (<ICustomClone>sourceProperty)._remap) {
       target[k] = (<ICustomClone>sourceProperty)._remap(srcRoot, targetRoot);
       return;
     }
 
+    // 2. Explicit ignore
     if (cloneMode === CloneMode.Ignore) return;
 
-    // Primitives, undecorated, or @assignmentClone: direct assign
-    if (!(sourceProperty instanceof Object) || cloneMode === undefined || cloneMode === CloneMode.Assignment) {
+    // 3. Primitives / null / undefined - direct assign
+    if (!(sourceProperty instanceof Object)) {
       target[k] = sourceProperty;
       return;
     }
 
-    // @shallowClone / @deepClone: deep copy complex objects
+    // 4. Determine effective clone mode
+    let effectiveCloneMode: CloneMode = cloneMode;
+    if (effectiveCloneMode === undefined) {
+      // Undecorated: infer from runtime type
+      effectiveCloneMode = CloneManager._inferCloneMode(sourceProperty, target[k]);
+    } else if (effectiveCloneMode !== CloneMode.Assignment) {
+      // Decorated Shallow/Deep: upgrade to Deep if target already has independent same-type instance.
+      // Assignment is never upgraded — it means the user explicitly wants a reference copy.
+      const targetProperty = target[k];
+      if (
+        targetProperty &&
+        targetProperty !== sourceProperty &&
+        targetProperty.constructor === sourceProperty.constructor
+      ) {
+        effectiveCloneMode = CloneMode.Deep;
+      }
+    }
+
+    // 5. Assignment - direct reference copy
+    if (effectiveCloneMode === CloneMode.Assignment) {
+      target[k] = sourceProperty;
+      return;
+    }
+
+    // 6. Shallow/Deep clone for complex types
     const type = sourceProperty.constructor;
     switch (type) {
       case Uint8Array:
@@ -137,6 +162,37 @@ export class CloneManager {
           targetPropertyT.set(<TypedArray>sourceProperty);
         }
         break;
+      case Map:
+        let targetPropertyM = <Map<any, any>>target[k];
+        if (targetPropertyM == null) {
+          target[k] = targetPropertyM = new Map<any, any>();
+        } else {
+          targetPropertyM.clear();
+        }
+        (<Map<any, any>>sourceProperty).forEach((value, key) => {
+          if (key instanceof Object && (<ICustomClone>key)._remap) {
+            key = (<ICustomClone>key)._remap(srcRoot, targetRoot);
+          }
+          if (value instanceof Object && (<ICustomClone>value)._remap) {
+            value = (<ICustomClone>value)._remap(srcRoot, targetRoot);
+          }
+          targetPropertyM.set(key, value);
+        });
+        break;
+      case Set:
+        let targetPropertyS = <Set<any>>target[k];
+        if (targetPropertyS == null) {
+          target[k] = targetPropertyS = new Set<any>();
+        } else {
+          targetPropertyS.clear();
+        }
+        (<Set<any>>sourceProperty).forEach((value) => {
+          if (value instanceof Object && (<ICustomClone>value)._remap) {
+            value = (<ICustomClone>value)._remap(srcRoot, targetRoot);
+          }
+          targetPropertyS.add(value);
+        });
+        break;
       case Array:
         let targetPropertyA = <Array<any>>target[k];
         const length = (<Array<any>>sourceProperty).length;
@@ -150,7 +206,7 @@ export class CloneManager {
             <Array<any>>sourceProperty,
             targetPropertyA,
             i,
-            cloneMode,
+            cloneMode, // Pass original mode: decorated → children inherit, undecorated → children infer independently
             srcRoot,
             targetRoot,
             deepInstanceMap
@@ -158,25 +214,27 @@ export class CloneManager {
         }
         break;
       default:
-        let targetProperty = <Object>target[k];
-        // If the target property is undefined, create new instance and keep reference sharing like the source
-        if (!targetProperty) {
-          targetProperty = deepInstanceMap.get(sourceProperty);
-          if (!targetProperty) {
-            targetProperty = new sourceProperty.constructor();
-            deepInstanceMap.set(sourceProperty, targetProperty);
-          }
-          target[k] = targetProperty;
+        // Check if we've already visited this source object (cycle detection)
+        if (deepInstanceMap.has(sourceProperty)) {
+          target[k] = deepInstanceMap.get(sourceProperty);
+          return;
+        }
+
+        let targetPropertyD = <Object>target[k];
+        if (!targetPropertyD) {
+          targetPropertyD = new sourceProperty.constructor();
+          target[k] = targetPropertyD;
         }
+        deepInstanceMap.set(sourceProperty, targetPropertyD);
 
         if ((<ICustomClone>sourceProperty).copyFrom) {
-          (<ICustomClone>targetProperty).copyFrom(<ICustomClone>sourceProperty);
+          (<ICustomClone>targetPropertyD).copyFrom(<ICustomClone>sourceProperty);
         } else {
           const cloneModes = CloneManager.getCloneMode(sourceProperty.constructor);
           for (let k in sourceProperty) {
             CloneManager.cloneProperty(
               <Object>sourceProperty,
-              targetProperty,
+              targetPropertyD,
               k,
               cloneModes[k],
               srcRoot,
@@ -184,12 +242,46 @@ export class CloneManager {
               deepInstanceMap
             );
           }
-          (<ICustomClone>sourceProperty)._cloneTo?.(<ICustomClone>targetProperty, srcRoot, targetRoot);
+          (<ICustomClone>sourceProperty)._cloneTo?.(<ICustomClone>targetPropertyD, srcRoot, targetRoot);
         }
         break;
     }
   }
 
+  /**
+   * Infer the appropriate clone mode for an undecorated property based on its runtime type.
+   * This enables user custom scripts to get correct clone behavior without decorators.
+   */
+  private static _inferCloneMode(sourceProperty: Object, targetProperty: any): CloneMode {
+    // If target already has an independent instance of the same type,
+    // deep clone to preserve isolation (e.g., constructor-created objects)
+    if (
+      targetProperty &&
+      targetProperty !== sourceProperty &&
+      targetProperty.constructor === sourceProperty.constructor
+    ) {
+      return CloneMode.Deep;
+    }
+
+    // Arrays need recursive processing (may contain Entity/Component refs)
+    if (Array.isArray(sourceProperty)) return CloneMode.Deep;
+
+    // TypedArrays - copy data
+    if (ArrayBuffer.isView(sourceProperty)) return CloneMode.Deep;
+
+    // Maps and Sets - create independent copies
+    if (sourceProperty instanceof Map || sourceProperty instanceof Set) return CloneMode.Deep;
+
+    // Value types with copyFrom (math types like Vector3, Color, etc.)
+    if ((<ICustomClone>sourceProperty).copyFrom) return CloneMode.Deep;
+
+    // Plain objects - deep clone (may contain Entity/Component refs)
+    if (sourceProperty.constructor === Object) return CloneMode.Deep;
+
+    // Other class instances (engine resources like Material, Texture) - shared reference
+    return CloneMode.Assignment;
+  }
+
   static deepCloneObject(source: Object, target: Object, deepInstanceMap: Map<Object, Object>): void {
     for (let k in source) {
       CloneManager.cloneProperty(source, target, k, CloneMode.Deep, null, null, deepInstanceMap);
diff --git a/packages/core/src/physics/CharacterController.ts b/packages/core/src/physics/CharacterController.ts
index f3c9e6f048..ea6961b70f 100644
--- a/packages/core/src/physics/CharacterController.ts
+++ b/packages/core/src/physics/CharacterController.ts
@@ -1,5 +1,5 @@
 import { ICharacterController } from "@galacean/engine-design";
-import { Vector3 } from "@galacean/engine-math";
+import { Quaternion, Vector3 } from "@galacean/engine-math";
 import { Engine } from "../Engine";
 import { Entity } from "../Entity";
 import { Collider } from "./Collider";
@@ -162,6 +162,10 @@ export class CharacterController extends Collider {
     (<ICharacterController>this._nativeCollider).setSlopeLimit(this._slopeLimit);
   }
 
+  protected override _teleportToEntityTransform(worldPosition: Vector3, _worldRotation: Quaternion): void {
+    (<ICharacterController>this._nativeCollider).setWorldPosition(worldPosition);
+  }
+
   private _syncWorldPositionFromPhysicalSpace(): void {
     (<ICharacterController>this._nativeCollider).getWorldPosition(this.entity.transform.worldPosition);
   }
diff --git a/packages/core/src/physics/Collider.ts b/packages/core/src/physics/Collider.ts
index a8a591fe56..5afa164403 100644
--- a/packages/core/src/physics/Collider.ts
+++ b/packages/core/src/physics/Collider.ts
@@ -1,4 +1,5 @@
 import { ICollider, IStaticCollider } from "@galacean/engine-design";
+import { Quaternion, Vector3 } from "@galacean/engine-math";
 import { BoolUpdateFlag } from "../BoolUpdateFlag";
 import { deepClone, ignoreClone } from "../clone/CloneManager";
 import { ICustomClone } from "../clone/ComponentCloner";
@@ -28,6 +29,16 @@ export class Collider extends Component implements ICustomClone {
   protected _shapes: ColliderShape[] = [];
   protected _collisionLayerIndex: number = 0;
 
+  /**
+   * Disabling a collider only detaches its native actor from the simulation
+   * scene; the actor is not destroyed, so on re-enable it still holds its
+   * pre-disable pose. The first transform sync after (re-)enable must teleport,
+   * never sweep — otherwise a kinematic actor drags across the scene from that
+   * stale pose and fires spurious contacts along the path.
+   */
+  @ignoreClone
+  private _pendingReenterTeleport: boolean = false;
+
   /**
    * The shapes of this collider.
    */
@@ -108,20 +119,29 @@ export class Collider extends Component implements ICustomClone {
    * @internal
    */
   _onUpdate(): void {
-    if (this._updateFlag.flag) {
+    const shapes = this._shapes;
+    if (this._pendingReenterTeleport || this._updateFlag.flag) {
       const { transform } = this.entity;
-      (<IStaticCollider>this._nativeCollider).setWorldTransform(
-        transform.worldPosition,
-        transform.worldRotationQuaternion
-      );
+      if (this._pendingReenterTeleport) {
+        this._teleportToEntityTransform(transform.worldPosition, transform.worldRotationQuaternion);
+        this._pendingReenterTeleport = false;
+      } else {
+        this._syncEntityTransformToNative(transform.worldPosition, transform.worldRotationQuaternion);
+      }
 
       const worldScale = transform.lossyWorldScale;
-      const shapes = this._shapes;
       for (let i = 0, n = shapes.length; i < n; i++) {
         shapes[i]._nativeShape?.setWorldScale(worldScale);
       }
       this._updateFlag.flag = false;
     }
+
+    // Drive per-shape physics update (e.g. MeshColliderShape retries pending
+    // native shape creation when mesh data becomes accessible asynchronously).
+    // No-op for shape types that don't override `_onPhysicsUpdate`.
+    for (let i = 0, n = shapes.length; i < n; i++) {
+      shapes[i]._onPhysicsUpdate();
+    }
   }
 
   /**
@@ -134,6 +154,7 @@ export class Collider extends Component implements ICustomClone {
    */
   override _onEnableInScene(): void {
     this.scene.physics._addCollider(this);
+    this._pendingReenterTeleport = true;
   }
 
   /**
@@ -164,6 +185,32 @@ export class Collider extends Component implements ICustomClone {
       this._addNativeShape(this.shapes[i]);
     }
     this._setCollisionLayer();
+    // Teleport native actor to entity's current world pose.
+    // The native actor was created in constructor() with the entity's then-current
+    // worldPosition/Rotation. On clone, the entity's transform fields are deep-cloned
+    // AFTER the Component (and its native actor) are constructed, so the native actor's
+    // pose lags behind the cloned entity transform until this sync.
+    const { transform } = this.entity;
+    this._teleportToEntityTransform(transform.worldPosition, transform.worldRotationQuaternion);
+  }
+
+  /**
+   * Teleport native actor to a world pose (instant, no implied velocity).
+   * Used during initialization paths (clone) where the native actor must be re-aligned
+   * with the entity transform after construction-time pose was based on stale defaults.
+   */
+  protected _teleportToEntityTransform(worldPosition: Vector3, worldRotation: Quaternion): void {
+    (<IStaticCollider>this._nativeCollider).setWorldTransform(worldPosition, worldRotation);
+  }
+
+  /**
+   * Sync entity world transform to native actor for per-frame updates.
+   * Default semantics: teleport (setGlobalPose). Subclasses override to express
+   * physics-aware movement (e.g. DynamicCollider routes kinematic actors through
+   * setKinematicTarget to generate contact events on swept motion).
+   */
+  protected _syncEntityTransformToNative(worldPosition: Vector3, worldRotation: Quaternion): void {
+    (<IStaticCollider>this._nativeCollider).setWorldTransform(worldPosition, worldRotation);
   }
 
   /**
diff --git a/packages/core/src/physics/Collision.ts b/packages/core/src/physics/Collision.ts
index 16edfd5bb3..440864e4fe 100644
--- a/packages/core/src/physics/Collision.ts
+++ b/packages/core/src/physics/Collision.ts
@@ -29,8 +29,7 @@ export class Collision {
    */
   getContacts(outContacts: ContactPoint[]): number {
     const nativeCollision = this._nativeCollision;
-    const smallerShapeId = Math.min(nativeCollision.shape0Id, nativeCollision.shape1Id);
-    const factor = this.shape.id === smallerShapeId ? 1 : -1;
+    const factor = this.shape.id === nativeCollision.shape1Id ? 1 : -1;
     const nativeContactPoints = nativeCollision.getContacts();
     const length = nativeContactPoints.size();
     for (let i = 0; i < length; i++) {
diff --git a/packages/core/src/physics/DynamicCollider.ts b/packages/core/src/physics/DynamicCollider.ts
index 380a3b927f..debf078b14 100644
--- a/packages/core/src/physics/DynamicCollider.ts
+++ b/packages/core/src/physics/DynamicCollider.ts
@@ -13,6 +13,8 @@ import { MeshColliderShape } from "./shape/MeshColliderShape";
  */
 export class DynamicCollider extends Collider {
   private static _tempVector3 = new Vector3();
+  private static _tempVector3_1 = new Vector3();
+  private static _tempVector3_2 = new Vector3();
   private static _tempQuat = new Quaternion();
 
   private _linearDamping = 0;
@@ -33,7 +35,9 @@ export class DynamicCollider extends Collider {
   private _isKinematic = false;
   private _constraints: DynamicColliderConstraints = 0;
   private _collisionDetectionMode: CollisionDetectionMode = CollisionDetectionMode.Discrete;
-  private _sleepThreshold = 5e-3;
+  private _kinematicTransformSyncMode: DynamicColliderKinematicTransformSyncMode =
+    DynamicColliderKinematicTransformSyncMode.Target;
+  private _sleepThreshold: number | undefined;
   private _automaticCenterOfMass = true;
   private _automaticInertiaTensor = true;
 
@@ -223,7 +227,7 @@ export class DynamicCollider extends Collider {
    * The mass-normalized energy threshold, below which objects start going to sleep.
    */
   get sleepThreshold(): number {
-    return this._sleepThreshold;
+    return this._sleepThreshold ?? Engine._nativePhysics?.getDefaultSleepThreshold?.() ?? 5e-3;
   }
 
   set sleepThreshold(value: number) {
@@ -325,6 +329,22 @@ export class DynamicCollider extends Collider {
     }
   }
 
+  /**
+   * Controls how entity transform changes are synchronized to a kinematic native actor.
+   *
+   * @remarks
+   * `Target` routes transform changes through {@link move}, so PhysX treats the
+   * actor as moving between frames and can generate swept contacts. `Teleport`
+   * writes the native pose directly and does not imply velocity.
+   */
+  get kinematicTransformSyncMode(): DynamicColliderKinematicTransformSyncMode {
+    return this._kinematicTransformSyncMode;
+  }
+
+  set kinematicTransformSyncMode(value: DynamicColliderKinematicTransformSyncMode) {
+    this._kinematicTransformSyncMode = value;
+  }
+
   /**
    * @internal
    */
@@ -367,6 +387,33 @@ export class DynamicCollider extends Collider {
     this._phasedActiveInScene && (<IDynamicCollider>this._nativeCollider).addTorque(torque);
   }
 
+  /**
+   * Apply a force to the DynamicCollider at a given position in world space.
+   * The force generates both linear acceleration through the center of mass and angular
+   * acceleration about it (torque = (position - centerOfMass) × force).
+   * @param force - The force to apply, in world space
+   * @param position - The position where the force is applied, in world space
+   */
+  applyForceAtPosition(force: Vector3, position: Vector3): void {
+    if (!this._phasedActiveInScene) return;
+    const nativeCollider = <IDynamicCollider>this._nativeCollider;
+
+    const localCoM = DynamicCollider._tempVector3;
+    nativeCollider.getCenterOfMass(localCoM);
+
+    const transform = this.entity.transform;
+    const worldCoM = DynamicCollider._tempVector3_1;
+    Vector3.transformByQuat(localCoM, transform.worldRotationQuaternion, worldCoM);
+    worldCoM.add(transform.worldPosition);
+
+    const torque = DynamicCollider._tempVector3_2;
+    Vector3.subtract(position, worldCoM, torque);
+    Vector3.cross(torque, force, torque);
+
+    nativeCollider.addForce(force);
+    nativeCollider.addTorque(torque);
+  }
+
   /**
    * Moves the kinematic collider to the specified position.
    * @remarks Only available when {@link isKinematic} is true.
@@ -433,6 +480,30 @@ export class DynamicCollider extends Collider {
     super.addShape(shape);
   }
 
+  /**
+   * Route per-frame entity → native transform sync to the correct physics API based
+   * on kinematic state.
+   *
+   * PhysX 4.x docs (PxRigidDynamic):
+   *   "If you intend to move a kinematic actor with [setGlobalPose] and want
+   *    collision detection, use setKinematicTarget() instead."
+   *
+   * setGlobalPose is a teleport: PhysX skips contact detection between the old
+   * and new pose. setKinematicTarget tells PhysX the actor is animating to the
+   * target during the next simulate(), enabling swept contacts. Some compatibility
+   * layers need transform writes to stay teleport-like, so the sync mode is
+   * explicit while {@link move} always keeps target semantics.
+   *
+   * @internal
+   */
+  protected override _syncEntityTransformToNative(worldPosition: Vector3, worldRotation: Quaternion): void {
+    if (this._isKinematic && this._kinematicTransformSyncMode === DynamicColliderKinematicTransformSyncMode.Target) {
+      (<IDynamicCollider>this._nativeCollider).move(worldPosition, worldRotation);
+    } else {
+      super._syncEntityTransformToNative(worldPosition, worldRotation);
+    }
+  }
+
   /**
    * @internal
    */
@@ -460,6 +531,7 @@ export class DynamicCollider extends Collider {
     target._angularVelocity.copyFrom(this.angularVelocity);
     target._centerOfMass.copyFrom(this.centerOfMass);
     target._inertiaTensor.copyFrom(this.inertiaTensor);
+    target._kinematicTransformSyncMode = this._kinematicTransformSyncMode;
     super._cloneTo(target);
   }
 
@@ -489,7 +561,9 @@ export class DynamicCollider extends Collider {
     }
     (<IDynamicCollider>this._nativeCollider).setMaxAngularVelocity(this._maxAngularVelocity);
     (<IDynamicCollider>this._nativeCollider).setMaxDepenetrationVelocity(this._maxDepenetrationVelocity);
-    (<IDynamicCollider>this._nativeCollider).setSleepThreshold(this._sleepThreshold);
+    if (this._sleepThreshold !== undefined) {
+      (<IDynamicCollider>this._nativeCollider).setSleepThreshold(this._sleepThreshold);
+    }
     (<IDynamicCollider>this._nativeCollider).setSolverIterations(this._solverIterations);
     (<IDynamicCollider>this._nativeCollider).setUseGravity(this._useGravity);
     (<IDynamicCollider>this._nativeCollider).setIsKinematic(this._isKinematic);
@@ -555,6 +629,16 @@ export enum CollisionDetectionMode {
   ContinuousSpeculative
 }
 
+/**
+ * Kinematic transform synchronization mode.
+ */
+export enum DynamicColliderKinematicTransformSyncMode {
+  /** Synchronize transform changes through PhysX setKinematicTarget. */
+  Target,
+  /** Synchronize transform changes by directly teleporting the native actor. */
+  Teleport
+}
+
 /**
  * Use these flags to constrain motion of dynamic collider.
  */
diff --git a/packages/core/src/physics/PhysicsMaterial.ts b/packages/core/src/physics/PhysicsMaterial.ts
index 3ac16e66d8..aa22bc8c24 100644
--- a/packages/core/src/physics/PhysicsMaterial.ts
+++ b/packages/core/src/physics/PhysicsMaterial.ts
@@ -1,6 +1,7 @@
 import { IPhysicsMaterial } from "@galacean/engine-design";
 import { Engine } from "../Engine";
 import { PhysicsMaterialCombineMode } from "./enums/PhysicsMaterialCombineMode";
+import { ignoreClone } from "../clone/CloneManager";
 
 /**
  * Material class to represent a set of surface properties.
@@ -14,6 +15,7 @@ export class PhysicsMaterial {
   private _destroyed: boolean;
 
   /** @internal */
+  @ignoreClone
   _nativeMaterial: IPhysicsMaterial;
 
   constructor() {
@@ -21,8 +23,8 @@ export class PhysicsMaterial {
       this._staticFriction,
       this._dynamicFriction,
       this._bounciness,
-      this._bounceCombine,
-      this._frictionCombine
+      this._frictionCombine,
+      this._bounceCombine
     );
   }
 
@@ -103,4 +105,23 @@ export class PhysicsMaterial {
     !this._destroyed && this._nativeMaterial.destroy();
     this._destroyed = true;
   }
+
+  /**
+   * @internal
+   */
+  _cloneTo(target: PhysicsMaterial): void {
+    target._syncNative();
+  }
+
+  /**
+   * @internal
+   */
+  _syncNative(): void {
+    const nativeMaterial = this._nativeMaterial;
+    nativeMaterial.setStaticFriction(this._staticFriction);
+    nativeMaterial.setDynamicFriction(this._dynamicFriction);
+    nativeMaterial.setBounciness(this._bounciness);
+    nativeMaterial.setFrictionCombine(this._frictionCombine);
+    nativeMaterial.setBounceCombine(this._bounceCombine);
+  }
 }
diff --git a/packages/core/src/physics/index.ts b/packages/core/src/physics/index.ts
index 537bd367d6..f2d4cdf576 100644
--- a/packages/core/src/physics/index.ts
+++ b/packages/core/src/physics/index.ts
@@ -1,6 +1,11 @@
 export { CharacterController } from "./CharacterController";
 export { Collider } from "./Collider";
-export { CollisionDetectionMode, DynamicCollider, DynamicColliderConstraints } from "./DynamicCollider";
+export {
+  CollisionDetectionMode,
+  DynamicCollider,
+  DynamicColliderConstraints,
+  DynamicColliderKinematicTransformSyncMode
+} from "./DynamicCollider";
 export { HitResult } from "./HitResult";
 export { PhysicsMaterial } from "./PhysicsMaterial";
 export { PhysicsScene } from "./PhysicsScene";
diff --git a/packages/core/src/physics/shape/ColliderShape.ts b/packages/core/src/physics/shape/ColliderShape.ts
index 2ac82319fd..e74736ff64 100644
--- a/packages/core/src/physics/shape/ColliderShape.ts
+++ b/packages/core/src/physics/shape/ColliderShape.ts
@@ -27,7 +27,7 @@ export abstract class ColliderShape implements ICustomClone {
   private _rotation: Vector3 = new Vector3();
   @deepClone
   private _position: Vector3 = new Vector3();
-  private _contactOffset: number = 0.02;
+  private _contactOffset: number | undefined;
 
   /**
    * @internal
@@ -55,7 +55,7 @@ export abstract class ColliderShape implements ICustomClone {
    * @defaultValue 0.02
    */
   get contactOffset(): number {
-    return this._contactOffset;
+    return this._contactOffset ?? Engine._nativePhysics?.getDefaultContactOffset?.() ?? 0.02;
   }
 
   set contactOffset(value: number) {
@@ -168,6 +168,18 @@ export abstract class ColliderShape implements ICustomClone {
     target._syncNative();
   }
 
+  /**
+   * @internal
+   *
+   * Called once per physics update tick by `Collider._onUpdate`. Base no-op.
+   *
+   * Subclasses can override for frame-driven maintenance. Currently used by
+   * `MeshColliderShape` to retry native shape creation when mesh data becomes
+   * accessible later or PhysX cooking previously failed due to transient state
+   * (async resource loading, cook pipeline warmup, etc.).
+   */
+  _onPhysicsUpdate(): void {}
+
   /**
    * @internal
    */
@@ -183,7 +195,9 @@ export abstract class ColliderShape implements ICustomClone {
     if (!this._nativeShape) return;
     this._nativeShape.setPosition(this._position);
     this._nativeShape.setRotation(this._rotation);
-    this._nativeShape.setContactOffset(this._contactOffset);
+    if (this._contactOffset !== undefined) {
+      this._nativeShape.setContactOffset(this._contactOffset);
+    }
     this._nativeShape.setIsTrigger(this._isTrigger);
     this._nativeShape.setMaterial(this._material._nativeMaterial);
 
diff --git a/packages/core/src/physics/shape/MeshColliderShape.ts b/packages/core/src/physics/shape/MeshColliderShape.ts
index 51a46ab0e0..83935fe10c 100644
--- a/packages/core/src/physics/shape/MeshColliderShape.ts
+++ b/packages/core/src/physics/shape/MeshColliderShape.ts
@@ -16,6 +16,12 @@ export class MeshColliderShape extends ColliderShape {
   private _indices: Uint8Array | Uint16Array | Uint32Array | null = null;
   private _cookingFlags = MeshColliderShapeCookingFlag.Cleaning | MeshColliderShapeCookingFlag.VertexWelding;
   private _isShapeAttached = false;
+  /**
+   * `true` if a native shape creation was attempted but failed (mesh data not yet
+   * accessible, PhysX cooking transient failure, etc.). The `_onPhysicsUpdate` hook
+   * will keep retrying every frame until creation succeeds.
+   */
+  private _pendingNativeShapeCreation = false;
 
   /**
    * Cooking flags for this mesh collider shape.
@@ -74,15 +80,25 @@ export class MeshColliderShape extends ColliderShape {
       this._mesh?._addReferCount(-1);
       value?._addReferCount(1);
       this._mesh = value;
-      if (value && this._extractMeshData(value)) {
-        if (this._nativeShape) {
-          this._updateNativeShapeData();
+      if (value) {
+        if (this._extractMeshData(value)) {
+          if (this._nativeShape) {
+            this._updateNativeShapeData();
+          } else {
+            this._createNativeShape();
+          }
+          // _createNativeShape can fail silently (cookMesh transient failure); mark pending if so
+          this._pendingNativeShapeCreation = !this._nativeShape;
         } else {
-          this._createNativeShape();
+          // Mesh not yet accessible — keep pending so `_onPhysicsUpdate` retries later
+          this._destroyNativeShape();
+          this._clearMeshData();
+          this._pendingNativeShapeCreation = true;
         }
       } else {
         this._destroyNativeShape();
         this._clearMeshData();
+        this._pendingNativeShapeCreation = false;
       }
     }
   }
@@ -197,10 +213,13 @@ export class MeshColliderShape extends ColliderShape {
     );
 
     if (!nativeShape) {
+      // Cook failed — `_onPhysicsUpdate` will retry next frame
+      this._pendingNativeShapeCreation = true;
       return;
     }
 
     this._nativeShape = nativeShape;
+    this._pendingNativeShapeCreation = false;
 
     // Sync base class properties (position, rotation, contactOffset, isTrigger, material)
     super._syncNative();
@@ -211,4 +230,38 @@ export class MeshColliderShape extends ColliderShape {
       this._attachToCollider();
     }
   }
+
+  /**
+   * @internal
+   * Retry hook: keep attempting `_createNativeShape` until it succeeds.
+   *
+   * Triggered every physics update tick by `Collider._onUpdate`. Handles the case
+   * where `_cookMesh` fails on first attempt due to PhysX cooking pipeline timing
+   * (the mesh data was extracted successfully at `set mesh` time, but the native
+   * cook call returned null). No-op once a valid native shape exists.
+   *
+   * We DO NOT re-call `_extractMeshData` here — once `set mesh` finished, either:
+   *   - extraction succeeded → `_positions` is populated and we reuse it
+   *   - extraction failed → `_clearMeshData` cleared `_positions`, and `mesh.accessible`
+   *     won't recover (GPU upload is one-way), so re-extracting would fail again
+   */
+  override _onPhysicsUpdate(): void {
+    if (!this._pendingNativeShapeCreation || !this._mesh || !this._positions) return;
+    this._createNativeShape();
+  }
+
+  /**
+   * @internal
+   * After CloneManager deep-copies `_positions` / `_indices` / `_mesh` and remaps `_collider`,
+   * the cloned shape still has no native PhysX shape because `_nativeShape` is `@ignoreClone`.
+   * Cook a fresh native shape now using the already-cloned vertex/index buffers; on transient
+   * cook failure `_createNativeShape` sets `_pendingNativeShapeCreation = true` and
+   * `_onPhysicsUpdate` will retry next tick.
+   */
+  override _cloneTo(target: MeshColliderShape): void {
+    super._cloneTo(target);
+    if (target._positions) {
+      target._createNativeShape();
+    }
+  }
 }
diff --git a/packages/design/src/physics/IPhysics.ts b/packages/design/src/physics/IPhysics.ts
index 17c9b6b466..91a6c1c7c6 100644
--- a/packages/design/src/physics/IPhysics.ts
+++ b/packages/design/src/physics/IPhysics.ts
@@ -36,6 +36,16 @@ export interface IPhysics {
    */
   createPhysicsScene(physicsManager: IPhysicsManager): IPhysicsScene;
 
+  /**
+   * Get the default contact offset for collider shapes.
+   */
+  getDefaultContactOffset?(): number;
+
+  /**
+   * Get the default sleep threshold for dynamic colliders.
+   */
+  getDefaultSleepThreshold?(): number;
+
   /**
    * Create dynamic collider.
    * @param position - The global position
diff --git a/packages/loader/package.json b/packages/loader/package.json
index 2cf33bba0b..5e69bbe4e3 100644
--- a/packages/loader/package.json
+++ b/packages/loader/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-loader",
-  "version": "2.0.0-alpha.33",
+  "version": "0.0.0-experimental-2.0-game.14",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
diff --git a/packages/loader/src/AudioLoader.ts b/packages/loader/src/AudioLoader.ts
index 46cc16e13e..29cd7d40b7 100644
--- a/packages/loader/src/AudioLoader.ts
+++ b/packages/loader/src/AudioLoader.ts
@@ -9,7 +9,7 @@ import {
   ResourceManager,
   resourceLoader
 } from "@galacean/engine-core";
-@resourceLoader(AssetType.Audio, ["mp3", "ogg", "wav", "m4a", "aac", "flac"])
+@resourceLoader(AssetType.Audio, ["mp3", "ogg", "wav", "audio", "m4a", "aac", "flac"])
 class AudioLoader extends Loader<AudioClip> {
   load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<AudioClip> {
     return new AssetPromise((resolve, reject) => {
diff --git a/packages/loader/src/HDRDecoder.ts b/packages/loader/src/HDRDecoder.ts
index d0692926f0..3dd7419192 100644
--- a/packages/loader/src/HDRDecoder.ts
+++ b/packages/loader/src/HDRDecoder.ts
@@ -1,18 +1,23 @@
 /**
- * HDR (Radiance RGBE) image decoder.
- *
- * Decodes .hdr files into pixel data. Supports parsing the header
- * and decoding RLE-compressed RGBE scanlines into R16G16B16A16 half-float pixels.
+ * HDR panorama to cubemap decoder.
  */
 export class HDRDecoder {
+  // Float32 to Float16 lookup tables (http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf)
   private static _float2HalfTables = HDRDecoder._generateFloat2HalfTables();
   private static _floatView = new Float32Array(1);
   private static _uint32View = new Uint32Array(HDRDecoder._floatView.buffer);
+  private static _one = 0x3c00; // Half float for 1.0
+
+  // prettier-ignore
+  private static _faces = [ // Cubemap face corners [bottomLeft, bottomRight, topLeft, topRight] as flat xyz
+    /* +X */ [ 1,-1,-1,  1,-1, 1,  1, 1,-1,  1, 1, 1],
+    /* -X */ [-1,-1, 1, -1,-1,-1, -1, 1, 1, -1, 1,-1],
+    /* +Y */ [-1,-1, 1,  1,-1, 1, -1,-1,-1,  1,-1,-1],
+    /* -Y */ [-1, 1,-1,  1, 1,-1, -1, 1, 1,  1, 1, 1],
+    /* +Z */ [-1,-1,-1,  1,-1,-1, -1, 1,-1,  1, 1,-1],
+    /* -Z */ [ 1,-1, 1, -1,-1, 1,  1, 1, 1, -1, 1, 1]
+  ];
 
-  /**
-   * Parse the header of an HDR file.
-   * @returns Header info including width, height, and data start position.
-   */
   static parseHeader(uint8array: Uint8Array): IHDRHeader {
     let line = this._readStringLine(uint8array, 0);
     if (line[0] !== "#" || line[1] !== "?") {
@@ -51,50 +56,140 @@ export class HDRDecoder {
     return { height, width, dataPosition: lineIndex + line.length + 1 };
   }
 
-  /**
-   * Decode an HDR file buffer into R16G16B16A16 half-float pixel data.
-   * @param buffer - The full HDR file as Uint8Array.
-   * @returns Object with width, height, and half-float pixel data.
-   */
-  static decode(buffer: Uint8Array): { width: number; height: number; pixels: Uint16Array } {
-    const header = this.parseHeader(buffer);
+  static decodeFaces(
+    bufferArray: Uint8Array,
+    header: IHDRHeader,
+    onFace: (faceIndex: number, data: Uint16Array) => void
+  ): void {
     const { width, height, dataPosition } = header;
-    const rgbe = this._readPixels(buffer.subarray(dataPosition), width, height);
-    const pixels = this._rgbeToHalfFloat(rgbe, width, height);
-    return { width, height, pixels };
+    const cubeSize = height >> 1;
+    const pixels = HDRDecoder._readPixels(bufferArray.subarray(dataPosition), width, height);
+
+    const faces = HDRDecoder._faces;
+    const faceBuffer = new Uint16Array(cubeSize * cubeSize * 4);
+    for (let faceIndex = 0; faceIndex < 6; faceIndex++) {
+      HDRDecoder._createCubemapData(cubeSize, faces[faceIndex], pixels, width, height, faceBuffer);
+      onFace(faceIndex, faceBuffer);
+    }
+  }
+
+  private static _generateFloat2HalfTables(): { baseTable: Uint32Array; shiftTable: Uint32Array } {
+    const baseTable = new Uint32Array(512);
+    const shiftTable = new Uint32Array(512);
+    for (let i = 0; i < 256; ++i) {
+      const e = i - 127;
+      if (e < -27) {
+        baseTable[i] = 0x0000;
+        baseTable[i | 0x100] = 0x8000;
+        shiftTable[i] = 24;
+        shiftTable[i | 0x100] = 24;
+      } else if (e < -14) {
+        baseTable[i] = 0x0400 >> (-e - 14);
+        baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;
+        shiftTable[i] = -e - 1;
+        shiftTable[i | 0x100] = -e - 1;
+      } else if (e <= 15) {
+        baseTable[i] = (e + 15) << 10;
+        baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;
+        shiftTable[i] = 13;
+        shiftTable[i | 0x100] = 13;
+      } else if (e < 128) {
+        baseTable[i] = 0x7c00;
+        baseTable[i | 0x100] = 0xfc00;
+        shiftTable[i] = 24;
+        shiftTable[i | 0x100] = 24;
+      } else {
+        baseTable[i] = 0x7c00;
+        baseTable[i | 0x100] = 0xfc00;
+        shiftTable[i] = 13;
+        shiftTable[i | 0x100] = 13;
+      }
+    }
+    return { baseTable, shiftTable };
   }
 
-  /**
-   * Convert RGBE pixel data to R16G16B16A16 half-float.
-   */
-  static _rgbeToHalfFloat(rgbe: Uint8Array, width: number, height: number): Uint16Array {
-    const floatView = this._floatView;
-    const uint32View = this._uint32View;
-    const { baseTable, shiftTable } = this._float2HalfTables;
-    const one = 0x3c00; // Half float 1.0
-    const pixelCount = width * height;
-    const result = new Uint16Array(pixelCount * 4);
-
-    for (let i = 0; i < pixelCount; i++) {
-      const srcIdx = i * 4;
-      const dstIdx = i * 4;
-      const scaleFactor = Math.pow(2, rgbe[srcIdx + 3] - 128 - 8);
-
-      for (let c = 0; c < 3; c++) {
-        floatView[0] = Math.min(rgbe[srcIdx + c] * scaleFactor, 65504);
-        const f = uint32View[0];
-        const e = (f >> 23) & 0x1ff;
-        result[dstIdx + c] = baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);
+  private static _createCubemapData(
+    texSize: number,
+    face: number[],
+    pixels: Uint8Array,
+    inputWidth: number,
+    inputHeight: number,
+    facePixels: Uint16Array
+  ): void {
+    const invSize = 1 / texSize;
+    const rotDX1X = (face[3] - face[0]) * invSize;
+    const rotDX1Y = (face[4] - face[1]) * invSize;
+    const rotDX1Z = (face[5] - face[2]) * invSize;
+    const rotDX2X = (face[9] - face[6]) * invSize;
+    const rotDX2Y = (face[10] - face[7]) * invSize;
+    const rotDX2Z = (face[11] - face[8]) * invSize;
+
+    const floatView = HDRDecoder._floatView;
+    const uint32View = HDRDecoder._uint32View;
+    const { baseTable, shiftTable } = HDRDecoder._float2HalfTables;
+    const one = HDRDecoder._one;
+
+    let fy = 0;
+    for (let y = 0; y < texSize; y++) {
+      let xv1X = face[0],
+        xv1Y = face[1],
+        xv1Z = face[2];
+      let xv2X = face[6],
+        xv2Y = face[7],
+        xv2Z = face[8];
+
+      for (let x = 0; x < texSize; x++) {
+        let dirX = xv1X + (xv2X - xv1X) * fy;
+        let dirY = xv1Y + (xv2Y - xv1Y) * fy;
+        let dirZ = xv1Z + (xv2Z - xv1Z) * fy;
+        const invLen = 1 / Math.sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ);
+        dirX *= invLen;
+        dirY *= invLen;
+        dirZ *= invLen;
+
+        let px = Math.round(((Math.atan2(dirZ, dirX) / Math.PI) * 0.5 + 0.5) * inputWidth);
+        if (px < 0) px = 0;
+        else if (px >= inputWidth) px = inputWidth - 1;
+
+        let py = Math.round((Math.acos(dirY) / Math.PI) * inputHeight);
+        if (py < 0) py = 0;
+        else if (py >= inputHeight) py = inputHeight - 1;
+
+        const srcIndex = (inputHeight - py - 1) * inputWidth * 4 + px * 4;
+        const scaleFactor = Math.pow(2, pixels[srcIndex + 3] - 128) / 255;
+        const dstIndex = y * texSize * 4 + x * 4;
+
+        for (let c = 0; c < 3; c++) {
+          // Clamp to half-float max (65504) to prevent Infinity in R16G16B16A16
+          floatView[0] = Math.min(pixels[srcIndex + c] * scaleFactor, 65504);
+          const f = uint32View[0];
+          const e = (f >> 23) & 0x1ff;
+          facePixels[dstIndex + c] = baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);
+        }
+        facePixels[dstIndex + 3] = one;
+
+        xv1X += rotDX1X;
+        xv1Y += rotDX1Y;
+        xv1Z += rotDX1Z;
+        xv2X += rotDX2X;
+        xv2Y += rotDX2Y;
+        xv2Z += rotDX2Z;
       }
-      result[dstIdx + 3] = one;
+      fy += invSize;
+    }
+  }
+
+  private static _readStringLine(uint8array: Uint8Array, startIndex: number): string {
+    let line = "";
+    for (let i = startIndex, n = uint8array.length; i < n; i++) {
+      const character = String.fromCharCode(uint8array[i]);
+      if (character === "\n") break;
+      line += character;
     }
-    return result;
+    return line;
   }
 
-  /**
-   * Decode RLE-compressed RGBE scanlines into raw RGBE pixel data.
-   */
-  static _readPixels(buffer: Uint8Array, width: number, height: number): Uint8Array {
+  private static _readPixels(buffer: Uint8Array, width: number, height: number): Uint8Array {
     const byteLength = buffer.byteLength;
     const dataRGBA = new Uint8Array(4 * width * height);
     let offset = 0;
@@ -141,54 +236,9 @@ export class HDRDecoder {
     }
     return dataRGBA;
   }
-
-  private static _generateFloat2HalfTables(): { baseTable: Uint32Array; shiftTable: Uint32Array } {
-    const baseTable = new Uint32Array(512);
-    const shiftTable = new Uint32Array(512);
-    for (let i = 0; i < 256; ++i) {
-      const e = i - 127;
-      if (e < -27) {
-        baseTable[i] = 0x0000;
-        baseTable[i | 0x100] = 0x8000;
-        shiftTable[i] = 24;
-        shiftTable[i | 0x100] = 24;
-      } else if (e < -14) {
-        baseTable[i] = 0x0400 >> (-e - 14);
-        baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;
-        shiftTable[i] = -e - 1;
-        shiftTable[i | 0x100] = -e - 1;
-      } else if (e <= 15) {
-        baseTable[i] = (e + 15) << 10;
-        baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;
-        shiftTable[i] = 13;
-        shiftTable[i | 0x100] = 13;
-      } else if (e < 128) {
-        baseTable[i] = 0x7c00;
-        baseTable[i | 0x100] = 0xfc00;
-        shiftTable[i] = 24;
-        shiftTable[i | 0x100] = 24;
-      } else {
-        baseTable[i] = 0x7c00;
-        baseTable[i | 0x100] = 0xfc00;
-        shiftTable[i] = 13;
-        shiftTable[i | 0x100] = 13;
-      }
-    }
-    return { baseTable, shiftTable };
-  }
-
-  private static _readStringLine(uint8array: Uint8Array, startIndex: number): string {
-    let line = "";
-    for (let i = startIndex, n = uint8array.length; i < n; i++) {
-      const character = String.fromCharCode(uint8array[i]);
-      if (character === "\n") break;
-      line += character;
-    }
-    return line;
-  }
 }
 
-export interface IHDRHeader {
+interface IHDRHeader {
   width: number;
   height: number;
   dataPosition: number;
diff --git a/packages/loader/src/MaterialLoader.ts b/packages/loader/src/MaterialLoader.ts
index 89d3f835bb..ec3c2a9942 100644
--- a/packages/loader/src/MaterialLoader.ts
+++ b/packages/loader/src/MaterialLoader.ts
@@ -11,15 +11,25 @@ import {
   resourceLoader
 } from "@galacean/engine-core";
 import { Color, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
-import type { RefItem } from "./schema/CommonSchema";
 import {
   MaterialLoaderType,
+  type IAssetRef,
   type IColor,
   type IMaterialSchema,
   type IVector2,
   type IVector3,
   type IVector4
-} from "./schema";
+} from "./resource-deserialize";
+
+function parseProperty(object: Object, key: string, value: any) {
+  if (typeof value === "object") {
+    for (let subKey in value) {
+      parseProperty(object[key], subKey, value[subKey]);
+    }
+  } else {
+    object[key] = value;
+  }
+}
 
 @resourceLoader(AssetType.Material, ["mat"])
 class MaterialLoader extends Loader<Material> {
@@ -41,7 +51,7 @@ class MaterialLoader extends Loader<Material> {
             resolve(
               resourceManager
                 // @ts-ignore
-                .getResourceByRef<Shader>(<RefItem>shaderRef)
+                .getResourceByRef<Shader>(<IAssetRef>shaderRef)
                 .then((shader) => this._getMaterialByShader(materialSchema, shader, engine))
             );
           }
@@ -51,7 +61,7 @@ class MaterialLoader extends Loader<Material> {
   }
 
   private _getMaterialByShader(materialSchema: IMaterialSchema, shader: Shader, engine: Engine): Promise<Material> {
-    const { name, shaderData, macros } = materialSchema;
+    const { name, shaderData, macros, renderState } = materialSchema;
 
     const material = new Material(engine, shader);
     material.name = name;
@@ -89,7 +99,7 @@ class MaterialLoader extends Loader<Material> {
         case MaterialLoaderType.Texture:
           texturePromises.push(
             // @ts-ignore
-            engine.resourceManager.getResourceByRef<Texture2D>(<RefItem>value).then((texture) => {
+            engine.resourceManager.getResourceByRef<Texture2D>(<IAssetRef>value).then((texture) => {
               materialShaderData.setTexture(key, texture);
             })
           );
@@ -112,6 +122,8 @@ class MaterialLoader extends Loader<Material> {
       }
     }
 
+    parseProperty(material, "renderState", renderState);
+
     return Promise.all(texturePromises).then(() => {
       return material;
     });
diff --git a/packages/loader/src/PrefabLoader.ts b/packages/loader/src/PrefabLoader.ts
index 26255dfbcb..b3d63df5ba 100644
--- a/packages/loader/src/PrefabLoader.ts
+++ b/packages/loader/src/PrefabLoader.ts
@@ -1,7 +1,7 @@
 import { AssetPromise, AssetType, Loader, LoadItem, resourceLoader, ResourceManager } from "@galacean/engine-core";
 import { PrefabParser } from "./prefab/PrefabParser";
 import { PrefabResource } from "./prefab/PrefabResource";
-import type { PrefabFile } from "./schema/PrefabSchema";
+import { IHierarchyFile } from "./resource-deserialize";
 
 @resourceLoader(AssetType.Prefab, ["prefab"])
 export class PrefabLoader extends Loader<PrefabResource> {
@@ -11,7 +11,7 @@ export class PrefabLoader extends Loader<PrefabResource> {
     return new AssetPromise((resolve, reject) => {
       resourceManager
         // @ts-ignore
-        ._request<PrefabFile>(item.url, {
+        ._request<IHierarchyFile>(item.url, {
           ...item,
           type: "json"
         })
diff --git a/packages/loader/src/SceneLoader.ts b/packages/loader/src/SceneLoader.ts
index 7c94a82109..b16fb2cc92 100644
--- a/packages/loader/src/SceneLoader.ts
+++ b/packages/loader/src/SceneLoader.ts
@@ -11,179 +11,155 @@ import {
   ResourceManager,
   Scene
 } from "@galacean/engine-core";
-import { resolveRefItem } from "./schema/refs";
-import type { RefItem } from "./schema/CommonSchema";
-import { SpecularMode, type SceneFile } from "./schema/SceneSchema";
-import { ParserContext, ParserType, SceneParser } from "./resource-deserialize";
+import { IScene, ParserContext, ParserType, SceneParser, SpecularMode } from "./resource-deserialize";
 
-function loadRef<T>(refs: RefItem[], index: number, resourceManager: ResourceManager, label: string): Promise<T> {
-  const ref = resolveRefItem(refs, index, "SceneLoader", label);
-  // @ts-ignore
-  return resourceManager.getResourceByRef<T>(ref);
-}
+@resourceLoader(AssetType.Scene, ["scene"], true)
+class SceneLoader extends Loader<Scene> {
+  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Scene> {
+    const { engine } = resourceManager;
+    return new AssetPromise((resolve, reject, setTaskCompleteProgress) => {
+      resourceManager
+        // @ts-ignore
+        ._request<IScene>(item.url, { ...item, type: "json" })
+        .then((data: IScene) => {
+          const scene = new Scene(engine, data.name ?? "");
+          const context = new ParserContext<IScene, Scene>(engine, ParserType.Scene, scene);
+          const parser = new SceneParser(data, context, scene);
+          parser._collectDependentAssets(data);
+          context._setTaskCompleteProgress = setTaskCompleteProgress;
+          parser.start();
+          return parser.promise.then(() => {
+            const promises = [];
+            // parse ambient light
+            const ambient = data.scene.ambient;
+            if (ambient) {
+              const useCustomAmbient = ambient.specularMode === SpecularMode.Custom;
+              const useSH = ambient.diffuseMode === DiffuseMode.SphericalHarmonics;
 
-/**
- * Apply scene-level data (ambient, background, shadow, fog, AO) to a Scene.
- * @internal
- */
-export function applySceneData(
-  scene: Scene,
-  sceneData: SceneFile["scene"],
-  resourceManager: ResourceManager,
-  refs: RefItem[]
-): Promise<void> {
-  const promises: Promise<unknown>[] = [];
+              scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
+              scene.ambientLight.specularIntensity = ambient.specularIntensity;
+              scene.ambientLight.diffuseMode = ambient.diffuseMode;
+              scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
 
-  try {
-    // parse ambient light
-    const ambient = sceneData.ambient;
-    if (ambient) {
-      const useCustomAmbient = ambient.specularMode === SpecularMode.Custom;
-      const useSH = ambient.diffuseMode === DiffuseMode.SphericalHarmonics;
+              if (useCustomAmbient && ambient.customAmbientLight) {
+                promises.push(
+                  // @ts-ignore
+                  resourceManager.getResourceByRef<any>(ambient.customAmbientLight).then((ambientLight) => {
+                    scene.ambientLight.specularTexture = ambientLight?.specularTexture;
+                  })
+                );
+              }
 
-      scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
-      scene.ambientLight.specularIntensity = ambient.specularIntensity;
-      scene.ambientLight.diffuseMode = ambient.diffuseMode;
-      const solidColor = ambient.diffuseSolidColor;
-      if (solidColor) {
-        scene.ambientLight.diffuseSolidColor.set(solidColor[0], solidColor[1], solidColor[2], solidColor[3]);
-      }
+              if (ambient.ambientLight && (!useCustomAmbient || useSH)) {
+                promises.push(
+                  // @ts-ignore
+                  resourceManager.getResourceByRef<any>(ambient.ambientLight).then((ambientLight) => {
+                    if (!useCustomAmbient) {
+                      scene.ambientLight.specularTexture = ambientLight?.specularTexture;
+                    }
 
-      if (useCustomAmbient && ambient.customAmbientLight != null) {
-        promises.push(
-          loadRef<any>(refs, ambient.customAmbientLight, resourceManager, "scene.ambient.customAmbientLight").then(
-            (ambientLight) => {
-              scene.ambientLight.specularTexture = ambientLight?.specularTexture;
+                    if (useSH) {
+                      scene.ambientLight.diffuseSphericalHarmonics = ambientLight?.diffuseSphericalHarmonics;
+                    }
+                  })
+                );
+              }
             }
-          )
-        );
-      }
 
-      if (ambient.ambientLight != null && (!useCustomAmbient || useSH)) {
-        promises.push(
-          loadRef<any>(refs, ambient.ambientLight, resourceManager, "scene.ambient.ambientLight").then(
-            (ambientLight) => {
-              if (!useCustomAmbient) {
-                scene.ambientLight.specularTexture = ambientLight?.specularTexture;
-              }
+            // parse background
+            const background = data.scene.background;
+            scene.background.mode = background.mode;
 
-              if (useSH) {
-                scene.ambientLight.diffuseSphericalHarmonics = ambientLight?.diffuseSphericalHarmonics;
-              }
+            switch (scene.background.mode) {
+              case BackgroundMode.SolidColor:
+                scene.background.solidColor.copyFrom(background.color);
+                break;
+              case BackgroundMode.Sky:
+                if (background.skyMesh && background.skyMaterial) {
+                  // @ts-ignore
+                  const skyMeshPromise = resourceManager.getResourceByRef<Mesh>(background.skyMesh).then((mesh) => {
+                    scene.background.sky.mesh = mesh;
+                  });
+                  // @ts-ignore
+                  // prettier-ignore
+                  const skyMaterialPromise = resourceManager.getResourceByRef<Material>(background.skyMaterial).then((material) => {
+                    scene.background.sky.material = material;
+                  });
+                  promises.push(skyMeshPromise, skyMaterialPromise);
+                } else {
+                  Logger.warn("Sky background mode requires skyMesh and skyMaterial");
+                }
+                break;
+              case BackgroundMode.Texture:
+                if (background.texture) {
+                  // @ts-ignore
+                  // prettier-ignore
+                  const backgroundPromise = resourceManager.getResourceByRef<any>(background.texture).then((texture) => {
+                    scene.background.texture = texture;
+                  });
+                  promises.push(backgroundPromise);
+                  scene.background.textureFillMode = background.textureFillMode ?? scene.background.textureFillMode;
+                }
+                break;
             }
-          )
-        );
-      }
-    }
-
-    // parse background
-    const background = sceneData.background;
-    scene.background.mode = background.mode;
 
-    switch (scene.background.mode) {
-      case BackgroundMode.SolidColor: {
-        const color = background.color;
-        scene.background.solidColor.set(color[0], color[1], color[2], color[3]);
-        break;
-      }
-      case BackgroundMode.Sky:
-        if (background.skyMesh != null && background.skyMaterial != null) {
-          promises.push(
-            loadRef<Mesh>(refs, background.skyMesh, resourceManager, "scene.background.skyMesh").then((mesh) => {
-              scene.background.sky.mesh = mesh;
-            }),
-            loadRef<any>(refs, background.skyMaterial, resourceManager, "scene.background.skyMaterial").then(
-              (material) => {
-                scene.background.sky.material = material;
+            // parse shadow
+            const shadow = data.scene.shadow;
+            if (shadow) {
+              if (shadow.castShadows != undefined) scene.castShadows = shadow.castShadows;
+              if (shadow.shadowResolution != undefined) scene.shadowResolution = shadow.shadowResolution;
+              if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
+              if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
+              if (shadow.enableTransparentShadow != undefined) {
+                scene.enableTransparentShadow = shadow.enableTransparentShadow;
               }
-            )
-          );
-        } else {
-          Logger.warn("Sky background mode requires skyMesh and skyMaterial");
-        }
-        break;
-      case BackgroundMode.Texture:
-        if (background.texture != null) {
-          promises.push(
-            loadRef<any>(refs, background.texture, resourceManager, "scene.background.texture").then((texture) => {
-              scene.background.texture = texture;
-            })
-          );
-          scene.background.textureFillMode = background.textureFillMode ?? scene.background.textureFillMode;
-        }
-        break;
-    }
-  } catch (error) {
-    return Promise.reject(error);
-  }
-
-  // parse shadow
-  const shadow = sceneData.shadow;
-  if (shadow) {
-    if (shadow.castShadows != undefined) scene.castShadows = shadow.castShadows;
-    if (shadow.shadowResolution != undefined) scene.shadowResolution = shadow.shadowResolution;
-    if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
-    if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
-    if (shadow.enableTransparentShadow != undefined) scene.enableTransparentShadow = shadow.enableTransparentShadow;
-    if (shadow.shadowTwoCascadeSplits != undefined) scene.shadowTwoCascadeSplits = shadow.shadowTwoCascadeSplits;
-    if (shadow.shadowFourCascadeSplits) {
-      const splits = shadow.shadowFourCascadeSplits;
-      scene.shadowFourCascadeSplits.set(splits[0], splits[1], splits[2]);
-    }
-    if (shadow.shadowFadeBorder != undefined) scene.shadowFadeBorder = shadow.shadowFadeBorder;
-  }
+              scene.shadowTwoCascadeSplits = shadow.shadowTwoCascadeSplits ?? scene.shadowTwoCascadeSplits;
+              shadow.shadowFourCascadeSplits && scene.shadowFourCascadeSplits.copyFrom(shadow.shadowFourCascadeSplits);
+              scene.shadowFadeBorder = shadow.shadowFadeBorder ?? scene.shadowFadeBorder;
+            }
 
-  // parse fog
-  const fog = sceneData.fog;
-  if (fog) {
-    if (fog.fogMode != undefined) scene.fogMode = fog.fogMode;
-    if (fog.fogStart != undefined) scene.fogStart = fog.fogStart;
-    if (fog.fogEnd != undefined) scene.fogEnd = fog.fogEnd;
-    if (fog.fogDensity != undefined) scene.fogDensity = fog.fogDensity;
-    if (fog.fogColor) scene.fogColor.set(fog.fogColor[0], fog.fogColor[1], fog.fogColor[2], fog.fogColor[3]);
-  }
+            // parse fog
+            const fog = data.scene.fog;
+            if (fog) {
+              if (fog.fogMode != undefined) scene.fogMode = fog.fogMode;
+              if (fog.fogStart != undefined) scene.fogStart = fog.fogStart;
+              if (fog.fogEnd != undefined) scene.fogEnd = fog.fogEnd;
+              if (fog.fogDensity != undefined) scene.fogDensity = fog.fogDensity;
+              if (fog.fogColor != undefined) scene.fogColor.copyFrom(fog.fogColor);
+            }
 
-  // Post Process
-  if (sceneData.postProcess) {
-    Logger.warn("Post Process is not supported in scene yet, please add PostProcess component in entity instead.");
-  }
+            // parse physics
+            const physics = data.scene.physics;
+            // PhysicsScene has a native backing only when the engine was created with a physics backend.
+            // Keep scene files loadable for render-only engines by ignoring serialized physics settings there.
+            if (physics && (engine as any)._physicsInitialized) {
+              if (physics.gravity != undefined) scene.physics.gravity.copyFrom(physics.gravity);
+              if (physics.fixedTimeStep != undefined) scene.physics.fixedTimeStep = physics.fixedTimeStep;
+            }
 
-  // Ambient Occlusion
-  const ambientOcclusion = sceneData.ambientOcclusion;
-  if (ambientOcclusion) {
-    const sceneAO = scene.ambientOcclusion;
-    if (ambientOcclusion.enabledAmbientOcclusion != undefined)
-      sceneAO.enabled = ambientOcclusion.enabledAmbientOcclusion;
-    if (ambientOcclusion.quality != undefined) sceneAO.quality = ambientOcclusion.quality;
-    if (ambientOcclusion.intensity != undefined) sceneAO.intensity = ambientOcclusion.intensity;
-    if (ambientOcclusion.radius != undefined) sceneAO.radius = ambientOcclusion.radius;
-    if (ambientOcclusion.bias != undefined) sceneAO.bias = ambientOcclusion.bias;
-    if (ambientOcclusion.power != undefined) sceneAO.power = ambientOcclusion.power;
-    if (ambientOcclusion.bilateralThreshold != undefined)
-      sceneAO.bilateralThreshold = ambientOcclusion.bilateralThreshold;
-    if (ambientOcclusion.minHorizonAngle != undefined) sceneAO.minHorizonAngle = ambientOcclusion.minHorizonAngle;
-  }
+            // Post Process
+            const postProcessData = data.scene.postProcess;
+            if (postProcessData) {
+              Logger.warn(
+                "Post Process is not supported in scene yet, please add PostProcess component in entity instead."
+              );
+            }
 
-  return Promise.all(promises).then(() => {});
-}
+            // Ambient Occlusion
+            const ambientOcclusion = data.scene.ambientOcclusion;
+            if (ambientOcclusion) {
+              const sceneAmbientOcclusion = scene.ambientOcclusion;
+              sceneAmbientOcclusion.enabled = ambientOcclusion.enabledAmbientOcclusion;
+              sceneAmbientOcclusion.intensity = ambientOcclusion.intensity;
+              sceneAmbientOcclusion.radius = ambientOcclusion.radius;
+              sceneAmbientOcclusion.bias = ambientOcclusion.bias;
+              sceneAmbientOcclusion.power = ambientOcclusion.power;
+              sceneAmbientOcclusion.quality = ambientOcclusion.quality;
+              sceneAmbientOcclusion.bilateralThreshold = ambientOcclusion.bilateralThreshold;
+              sceneAmbientOcclusion.minHorizonAngle = ambientOcclusion.minHorizonAngle;
+            }
 
-@resourceLoader(AssetType.Scene, ["scene"], true)
-class SceneLoader extends Loader<Scene> {
-  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Scene> {
-    const { engine } = resourceManager;
-    return new AssetPromise((resolve, reject, setTaskCompleteProgress) => {
-      resourceManager
-        // @ts-ignore
-        ._request<SceneFile>(item.url, { ...item, type: "json" })
-        .then((data: SceneFile) => {
-          const scene = new Scene(engine, data.scene.name ?? "");
-          const context = new ParserContext(engine, ParserType.Scene, scene);
-          const parser = new SceneParser(data, context, scene);
-          parser._collectDependentAssets(data);
-          context._setTaskCompleteProgress = setTaskCompleteProgress;
-          parser.start();
-          return parser.promise.then(() => {
-            return applySceneData(scene, data.scene, resourceManager, data.refs).then(() => {
+            return Promise.all(promises).then(() => {
               resolve(scene);
             });
           });
diff --git a/packages/loader/src/ShaderChunkLoader.ts b/packages/loader/src/ShaderChunkLoader.ts
new file mode 100644
index 0000000000..ede33d9952
--- /dev/null
+++ b/packages/loader/src/ShaderChunkLoader.ts
@@ -0,0 +1,51 @@
+import {
+  AssetPromise,
+  LoadItem,
+  Loader,
+  ResourceManager,
+  ShaderFactory,
+  resourceLoader,
+  // @ts-ignore
+  ShaderLib,
+  Utils
+} from "@galacean/engine-core";
+
+@resourceLoader("ShaderChunk", ["glsl"])
+export class ShaderChunkLoader extends Loader<void[]> {
+  private static _shaderIncludeRegex = /#include\s+"([./][^\\"]+)"/gm;
+
+  /**
+   * @internal
+   */
+  static _loadChunksInCode(code: string, basePath: string, resourceManager: ResourceManager): Promise<void[]> {
+    const shaderChunkPaths = new Array<string>();
+    const matches = code.matchAll(ShaderChunkLoader._shaderIncludeRegex);
+    for (const match of matches) {
+      const chunkPath = Utils.resolveAbsoluteUrl(basePath, match[1]);
+      if (!ShaderLib[chunkPath.substring(1)]) {
+        shaderChunkPaths.push(chunkPath);
+      }
+    }
+
+    return Promise.all(
+      shaderChunkPaths.map((chunkPath) => {
+        // @ts-ignore
+        return resourceManager.load<void>({
+          type: "ShaderChunk",
+          url: chunkPath
+        });
+      })
+    );
+  }
+
+  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<void[]> {
+    const { url } = item;
+
+    // @ts-ignore
+    return resourceManager._request<string>(url, { ...item, type: "text" }).then((code) => {
+      ShaderFactory.registerInclude(url.substring(1), code);
+
+      return ShaderChunkLoader._loadChunksInCode(code, url, resourceManager);
+    });
+  }
+}
diff --git a/packages/loader/src/ShaderLoader.ts b/packages/loader/src/ShaderLoader.ts
index 4c5fd2e027..d7e714af50 100644
--- a/packages/loader/src/ShaderLoader.ts
+++ b/packages/loader/src/ShaderLoader.ts
@@ -7,23 +7,31 @@ import {
   Shader,
   resourceLoader
 } from "@galacean/engine-core";
+import { ShaderChunkLoader } from "./ShaderChunkLoader";
 
-@resourceLoader(AssetType.Shader, ["shader", "shaderc"])
+@resourceLoader(AssetType.Shader, ["shader"])
 class ShaderLoader extends Loader<Shader> {
-  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Shader> {
-    const url = item.url!;
+  private static _builtinRegex = /^\s*\/\/\s*@builtin\s+(\w+)/;
 
-    if (url.endsWith(".shaderc")) {
-      // @ts-ignore
-      return resourceManager._request(url, { ...item, type: "json" }).then((data) => {
-        // @ts-ignore - _createFromPrecompiled is @internal
-        return Shader._createFromPrecompiled(data);
-      });
-    }
+  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Shader> {
+    const { url } = item;
 
     // @ts-ignore
     return resourceManager._request<string>(url, { ...item, type: "text" }).then((code: string) => {
-      return Shader.create(code, undefined, url);
+      const builtinShader = this._getBuiltinShader(code);
+      if (builtinShader) {
+        return Shader.find(builtinShader);
+      }
+
+      return ShaderChunkLoader._loadChunksInCode(code, url, resourceManager).then(() => {
+        const shader = Shader.create(code, undefined, url);
+        return shader;
+      });
     });
   }
+
+  private _getBuiltinShader(code: string) {
+    const match = code.match(ShaderLoader._builtinRegex);
+    if (match && match[1]) return match[1];
+  }
 }
diff --git a/packages/loader/src/SpriteAtlasLoader.ts b/packages/loader/src/SpriteAtlasLoader.ts
index 0d0fe7550f..c5a1d6a550 100644
--- a/packages/loader/src/SpriteAtlasLoader.ts
+++ b/packages/loader/src/SpriteAtlasLoader.ts
@@ -51,7 +51,7 @@ class SpriteAtlasLoader extends Loader<SpriteAtlas> {
                 resourceManager
                   .load<Texture2D>({
                     url: Utils.resolveAbsoluteUrl(item.url, atlasItem.img),
-                    type: atlasItem.type ?? AssetType.Texture,
+                    type: atlasItem.type ?? AssetType.Texture2D,
                     params: { format, mipmap }
                   })
                   .then((texture: Texture2D) => {
@@ -102,7 +102,7 @@ class SpriteAtlasLoader extends Loader<SpriteAtlas> {
         const { x: offsetLeft, y: offsetTop, z: offsetRight, w: offsetBottom } = atlasRegionOffset;
         sprite.atlasRegionOffset.set(offsetLeft * invW, offsetTop * invH, offsetRight * invW, offsetBottom * invH);
       }
-      config.atlasRotated && (sprite.atlasRotated = true);
+      sprite.atlasRotated = config.atlasRotated ?? false;
     }
     width === undefined || (sprite.width = width);
     height === undefined || (sprite.height = height);
diff --git a/packages/loader/src/SpriteLoader.ts b/packages/loader/src/SpriteLoader.ts
index 489bc5d8aa..582d1d575b 100644
--- a/packages/loader/src/SpriteLoader.ts
+++ b/packages/loader/src/SpriteLoader.ts
@@ -32,7 +32,7 @@ class SpriteLoader extends Loader<Sprite> {
     return (
       resourceManager
         // @ts-ignore
-        .getResourceByRef<SpriteAtlas>(data.belongToAtlas)
+        .getResourceByRef(data.belongToAtlas)
         .then((atlas: SpriteAtlas) => {
           return atlas.getSprite(data.fullPath) || this._loadFromTexture(resourceManager, data);
         })
@@ -44,7 +44,7 @@ class SpriteLoader extends Loader<Sprite> {
       return (
         resourceManager
           // @ts-ignore
-          .getResourceByRef<Texture2D>(data.texture)
+          .getResourceByRef(data.texture)
           .then((texture: Texture2D) => {
             const sprite = new Sprite(resourceManager.engine, texture, data.region, data.pivot, data.border);
             const { width, height } = data;
diff --git a/packages/loader/src/Texture2DLoader.ts b/packages/loader/src/Texture2DLoader.ts
new file mode 100644
index 0000000000..127b37eb96
--- /dev/null
+++ b/packages/loader/src/Texture2DLoader.ts
@@ -0,0 +1,148 @@
+import {
+  AssetPromise,
+  AssetType,
+  ContentRestorer,
+  LoadItem,
+  Loader,
+  RequestConfig,
+  ResourceManager,
+  Texture2D,
+  TextureFilterMode,
+  TextureFormat,
+  TextureUtils,
+  TextureWrapMode,
+  resourceLoader
+} from "@galacean/engine-core";
+import { decode } from "./resource-deserialize";
+import { FileHeader } from "./resource-deserialize/utils/FileHeader";
+
+function loadImageFromBuffer(buffer: ArrayBuffer): AssetPromise<HTMLImageElement> {
+  return new AssetPromise((resolve, reject) => {
+    const blob = new Blob([buffer]);
+    const img = new Image();
+    img.onload = () => {
+      URL.revokeObjectURL(img.src);
+      resolve(img);
+    };
+    img.onerror = reject;
+    img.src = URL.createObjectURL(blob);
+  });
+}
+
+@resourceLoader(AssetType.Texture2D, ["png", "jpg", "webp", "jpeg", "tex"])
+class Texture2DLoader extends Loader<Texture2D> {
+  override load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture2D> {
+    const url = item.url;
+    const requestConfig = <RequestConfig>{ ...item, type: "arraybuffer" };
+    return new AssetPromise((resolve, reject, setTaskCompleteProgress, setTaskDetailProgress) => {
+      resourceManager
+        // @ts-ignore
+        ._request<ArrayBuffer>(url, requestConfig)
+        .onProgress(setTaskCompleteProgress, setTaskDetailProgress)
+        .then((buffer) => {
+          if (FileHeader.checkMagic(buffer)) {
+            decode<Texture2D>(buffer, resourceManager.engine).then((texture) => {
+              resourceManager.addContentRestorer(new Texture2DContentRestorer(texture, url, requestConfig));
+              resolve(texture);
+            }, reject);
+          } else {
+            loadImageFromBuffer(buffer).then((img) => {
+              const texture = this._createTexture(img, item, resourceManager);
+              resourceManager.addContentRestorer(new Texture2DContentRestorer(texture, url, requestConfig));
+              resolve(texture);
+            }, reject);
+          }
+        })
+        .catch(reject);
+    });
+  }
+
+  private _createTexture(img: HTMLImageElement, item: LoadItem, resourceManager: ResourceManager): Texture2D {
+    const {
+      format = TextureFormat.R8G8B8A8,
+      anisoLevel,
+      wrapModeU,
+      wrapModeV,
+      filterMode,
+      isSRGBColorSpace = true,
+      mipmap = true
+    } = (item.params as Partial<Texture2DParams>) ?? {};
+    const { width, height } = img;
+    const engine = resourceManager.engine;
+
+    const generateMipmap = TextureUtils.supportGenerateMipmapsWithCorrection(
+      engine,
+      width,
+      height,
+      format,
+      mipmap,
+      isSRGBColorSpace
+    );
+
+    const texture = new Texture2D(engine, width, height, format, generateMipmap, isSRGBColorSpace);
+    texture.anisoLevel = anisoLevel ?? texture.anisoLevel;
+    texture.filterMode = filterMode ?? texture.filterMode;
+    texture.wrapModeU = wrapModeU ?? texture.wrapModeU;
+    texture.wrapModeV = wrapModeV ?? texture.wrapModeV;
+    texture.setImageSource(img);
+    generateMipmap && texture.generateMipmaps();
+
+    const url = item.url;
+    if (url.indexOf("data:") !== 0) {
+      texture.name = url.substring(url.lastIndexOf("/") + 1);
+    }
+
+    return texture;
+  }
+}
+
+class Texture2DContentRestorer extends ContentRestorer<Texture2D> {
+  constructor(
+    resource: Texture2D,
+    public url: string,
+    public requestConfig: RequestConfig
+  ) {
+    super(resource);
+  }
+
+  override restoreContent(): AssetPromise<Texture2D> {
+    const texture = this.resource;
+    const engine = texture.engine;
+    return (
+      engine.resourceManager
+        // @ts-ignore
+        ._request<ArrayBuffer>(this.url, this.requestConfig)
+        .then((buffer) => {
+          if (FileHeader.checkMagic(buffer)) {
+            return decode<Texture2D>(buffer, engine, texture);
+          } else {
+            return loadImageFromBuffer(buffer).then((img) => {
+              texture.setImageSource(img);
+              texture.generateMipmaps();
+              return texture;
+            });
+          }
+        })
+    );
+  }
+}
+
+/**
+ * Texture2D loader params interface.
+ */
+export interface Texture2DParams {
+  /** Texture format. default  `TextureFormat.R8G8B8A8` */
+  format: TextureFormat;
+  /** Whether to use multi-level texture, default is true. */
+  mipmap: boolean;
+  /** Wrapping mode for texture coordinate S. */
+  wrapModeU: TextureWrapMode;
+  /** Wrapping mode for texture coordinate T. */
+  wrapModeV: TextureWrapMode;
+  /** Filter mode for texture. */
+  filterMode: TextureFilterMode;
+  /** Anisotropic level for texture. */
+  anisoLevel: number;
+  /** Whether the texture data is in sRGB color space, otherwise is linear color space. @defaultValue `true` */
+  isSRGBColorSpace: boolean;
+}
diff --git a/packages/loader/src/TextureCubeLoader.ts b/packages/loader/src/TextureCubeLoader.ts
new file mode 100644
index 0000000000..aee01285f1
--- /dev/null
+++ b/packages/loader/src/TextureCubeLoader.ts
@@ -0,0 +1,78 @@
+import {
+  AssetPromise,
+  AssetType,
+  ContentRestorer,
+  LoadItem,
+  Loader,
+  RequestConfig,
+  ResourceManager,
+  SystemInfo,
+  TextureCube,
+  TextureCubeFace,
+  TextureFormat,
+  resourceLoader
+} from "@galacean/engine-core";
+import { HDRDecoder } from "./HDRDecoder";
+
+@resourceLoader(AssetType.TextureCube, ["texCube", "hdr"])
+class TextureCubeLoader extends Loader<TextureCube> {
+  override load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<TextureCube> {
+    return new AssetPromise((resolve, reject) => {
+      const engine = resourceManager.engine;
+      const url = item.url;
+      const requestConfig = { ...item, type: "arraybuffer" } as RequestConfig;
+      resourceManager
+        // @ts-ignore
+        ._request<ArrayBuffer>(url, requestConfig)
+        .then((buffer) => {
+          if (!SystemInfo.supportsTextureFormat(engine, TextureFormat.R16G16B16A16)) {
+            reject(new Error("TextureCubeLoader: HDR texture requires half float support."));
+            return;
+          }
+          const { mipmap = true, anisoLevel, wrapModeU, wrapModeV, filterMode } = item.params ?? {};
+          const bufferArray = new Uint8Array(buffer);
+          const header = HDRDecoder.parseHeader(bufferArray);
+          const texture = new TextureCube(engine, header.height >> 1, TextureFormat.R16G16B16A16, mipmap, false);
+          HDRDecoder.decodeFaces(bufferArray, header, (faceIndex, data) => {
+            texture.setPixelBuffer(TextureCubeFace.PositiveX + faceIndex, data, 0);
+          });
+          texture.generateMipmaps();
+          texture.anisoLevel = anisoLevel ?? texture.anisoLevel;
+          texture.filterMode = filterMode ?? texture.filterMode;
+          texture.wrapModeU = wrapModeU ?? texture.wrapModeU;
+          texture.wrapModeV = wrapModeV ?? texture.wrapModeV;
+          resourceManager.addContentRestorer(new HDRContentRestorer(texture, url, requestConfig));
+          resolve(texture);
+        })
+        .catch(reject);
+    });
+  }
+}
+
+class HDRContentRestorer extends ContentRestorer<TextureCube> {
+  constructor(
+    resource: TextureCube,
+    public url: string,
+    public requestConfig: RequestConfig
+  ) {
+    super(resource);
+  }
+
+  override restoreContent(): AssetPromise<TextureCube> {
+    return new AssetPromise((resolve, reject) => {
+      const resource = this.resource;
+      resource.engine.resourceManager
+        // @ts-ignore
+        ._request<ArrayBuffer>(this.url, this.requestConfig)
+        .then((buffer) => {
+          const bufferArray = new Uint8Array(buffer);
+          HDRDecoder.decodeFaces(bufferArray, HDRDecoder.parseHeader(bufferArray), (faceIndex, data) => {
+            resource.setPixelBuffer(TextureCubeFace.PositiveX + faceIndex, data, 0);
+          });
+          resource.generateMipmaps();
+          resolve(resource);
+        })
+        .catch(reject);
+    });
+  }
+}
diff --git a/packages/loader/src/TextureLoader.ts b/packages/loader/src/TextureLoader.ts
deleted file mode 100644
index ff669d6c59..0000000000
--- a/packages/loader/src/TextureLoader.ts
+++ /dev/null
@@ -1,192 +0,0 @@
-import {
-  AssetPromise,
-  AssetType,
-  ContentRestorer,
-  LoadItem,
-  Loader,
-  RequestConfig,
-  ResourceManager,
-  SystemInfo,
-  Texture,
-  Texture2D,
-  TextureFilterMode,
-  TextureFormat,
-  TextureUtils,
-  TextureWrapMode,
-  resourceLoader
-} from "@galacean/engine-core";
-import { decode } from "./resource-deserialize";
-import { FileHeader } from "./resource-deserialize/utils/FileHeader";
-import { HDRDecoder } from "./HDRDecoder";
-
-@resourceLoader(AssetType.Texture, ["tex", "png", "jpg", "webp", "jpeg", "hdr"])
-class TextureLoader extends Loader<Texture> {
-  override load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture> {
-    const url = item.url;
-    const requestConfig = <RequestConfig>{ ...item, type: "arraybuffer" };
-    return new AssetPromise((resolve, reject, setTaskCompleteProgress, setTaskDetailProgress) => {
-      resourceManager
-        // @ts-ignore
-        ._request<ArrayBuffer>(url, requestConfig)
-        .onProgress(setTaskCompleteProgress, setTaskDetailProgress)
-        .then((buffer) => {
-          this._decode(buffer, item, resourceManager).then((texture) => {
-            resourceManager.addContentRestorer(new TextureContentRestorer(texture, url, requestConfig));
-            resolve(texture);
-          }, reject);
-        })
-        .catch(reject);
-    });
-  }
-
-  private _decode(buffer: ArrayBuffer, item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture> {
-    if (FileHeader.checkMagic(buffer)) {
-      return decode<Texture>(buffer, resourceManager.engine);
-    }
-
-    const bufferView = new Uint8Array(buffer);
-    const isHDR = bufferView[0] === 0x23 && bufferView[1] === 0x3f;
-
-    if (isHDR) {
-      return this._decodeHDR(bufferView, item, resourceManager);
-    }
-    return this._decodeImage(buffer, item, resourceManager);
-  }
-
-  private _decodeHDR(buffer: Uint8Array, item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture2D> {
-    return new AssetPromise((resolve, reject) => {
-      const engine = resourceManager.engine;
-      if (!SystemInfo.supportsTextureFormat(engine, TextureFormat.R16G16B16A16)) {
-        reject(new Error("TextureLoader: HDR texture requires half float support."));
-        return;
-      }
-      const { width, height, pixels } = HDRDecoder.decode(buffer);
-      const { mipmap = true } = (item.params as Partial<TextureParams>) ?? {};
-
-      const texture = new Texture2D(engine, width, height, TextureFormat.R16G16B16A16, mipmap, false);
-      texture.setPixelBuffer(pixels);
-      mipmap && texture.generateMipmaps();
-      this._applyParams(texture, item);
-      resolve(texture);
-    });
-  }
-
-  private _decodeImage(buffer: ArrayBuffer, item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture2D> {
-    return new AssetPromise((resolve, reject) => {
-      const blob = new Blob([buffer]);
-      const img = new Image();
-      img.onload = () => {
-        URL.revokeObjectURL(img.src);
-        const {
-          format = TextureFormat.R8G8B8A8,
-          isSRGBColorSpace = true,
-          mipmap = true
-        } = (item.params as Partial<TextureParams>) ?? {};
-
-        const engine = resourceManager.engine;
-        const { width, height } = img;
-        const generateMipmap = TextureUtils.supportGenerateMipmapsWithCorrection(
-          engine,
-          width,
-          height,
-          format,
-          mipmap,
-          isSRGBColorSpace
-        );
-
-        const texture = new Texture2D(engine, width, height, format, generateMipmap, isSRGBColorSpace);
-        texture.setImageSource(img);
-        generateMipmap && texture.generateMipmaps();
-        this._applyParams(texture, item);
-        resolve(texture);
-      };
-      img.onerror = (e) => {
-        URL.revokeObjectURL(img.src);
-        reject(e);
-      };
-      img.src = URL.createObjectURL(blob);
-    });
-  }
-
-  private _applyParams(texture: Texture2D, item: LoadItem): void {
-    const { anisoLevel, wrapModeU, wrapModeV, filterMode } = (item.params as Partial<TextureParams>) ?? {};
-    texture.anisoLevel = anisoLevel ?? texture.anisoLevel;
-    texture.filterMode = filterMode ?? texture.filterMode;
-    texture.wrapModeU = wrapModeU ?? texture.wrapModeU;
-    texture.wrapModeV = wrapModeV ?? texture.wrapModeV;
-
-    const url = item.url;
-    if (url.indexOf("data:") !== 0) {
-      texture.name = url.substring(url.lastIndexOf("/") + 1);
-    }
-  }
-}
-
-class TextureContentRestorer extends ContentRestorer<Texture> {
-  constructor(
-    resource: Texture,
-    public url: string,
-    public requestConfig: RequestConfig
-  ) {
-    super(resource);
-  }
-
-  override restoreContent(): AssetPromise<Texture> {
-    return (
-      this.resource.engine.resourceManager
-        // @ts-ignore
-        ._request<ArrayBuffer>(this.url, this.requestConfig)
-        .then((buffer) => {
-          if (FileHeader.checkMagic(buffer)) {
-            return decode<Texture>(buffer, this.resource.engine, this.resource);
-          }
-
-          const bufferView = new Uint8Array(buffer);
-          const texture = this.resource as Texture2D;
-
-          if (bufferView[0] === 0x23 && bufferView[1] === 0x3f) {
-            const { pixels } = HDRDecoder.decode(bufferView);
-            texture.setPixelBuffer(pixels);
-            texture.mipmapCount > 1 && texture.generateMipmaps();
-            return texture;
-          }
-
-          return new AssetPromise<Texture>((resolve, reject) => {
-            const blob = new Blob([buffer]);
-            const img = new Image();
-            img.onload = () => {
-              URL.revokeObjectURL(img.src);
-              texture.setImageSource(img);
-              texture.mipmapCount > 1 && texture.generateMipmaps();
-              resolve(texture);
-            };
-            img.onerror = (e) => {
-              URL.revokeObjectURL(img.src);
-              reject(e);
-            };
-            img.src = URL.createObjectURL(blob);
-          });
-        })
-    );
-  }
-}
-
-/**
- * Texture loader params interface.
- */
-export interface TextureParams {
-  /** Texture format. default `TextureFormat.R8G8B8A8` */
-  format: TextureFormat;
-  /** Whether to use multi-level texture, default is true. */
-  mipmap: boolean;
-  /** Wrapping mode for texture coordinate S. */
-  wrapModeU: TextureWrapMode;
-  /** Wrapping mode for texture coordinate T. */
-  wrapModeV: TextureWrapMode;
-  /** Filter mode for texture. */
-  filterMode: TextureFilterMode;
-  /** Anisotropic level for texture. */
-  anisoLevel: number;
-  /** Whether the texture data is in sRGB color space. @defaultValue `true` */
-  isSRGBColorSpace: boolean;
-}
diff --git a/packages/loader/src/gltf/GLTFUtils.ts b/packages/loader/src/gltf/GLTFUtils.ts
index a8164a290b..35f6488010 100644
--- a/packages/loader/src/gltf/GLTFUtils.ts
+++ b/packages/loader/src/gltf/GLTFUtils.ts
@@ -364,13 +364,11 @@ export class GLTFUtils {
       const blob = new window.Blob([imageBuffer], { type });
       const img = new Image();
       img.onerror = function () {
-        URL.revokeObjectURL(img.src);
         reject(new Error("Failed to load image buffer"));
       };
       img.onload = function () {
         // Call requestAnimationFrame to avoid iOS's bug.
         requestAnimationFrame(() => {
-          URL.revokeObjectURL(img.src);
           resolve(img);
           img.onload = null;
           img.onerror = null;
diff --git a/packages/loader/src/gltf/extensions/GLTFExtensionSchema.ts b/packages/loader/src/gltf/extensions/GLTFExtensionSchema.ts
index 522876e53b..126d3cab2b 100644
--- a/packages/loader/src/gltf/extensions/GLTFExtensionSchema.ts
+++ b/packages/loader/src/gltf/extensions/GLTFExtensionSchema.ts
@@ -1,5 +1,4 @@
 import type { IMaterialNormalTextureInfo, ITextureInfo } from "../GLTFSchema";
-import type { RefItem } from "../../schema/CommonSchema";
 
 /**
  * Interfaces from the KHR_lights_punctual extension
@@ -153,7 +152,9 @@ export interface IEXTMeshoptCompressionSchema {
   filter?: "NONE" | "OCTAHEDRAL" | "QUATERNION" | "EXPONENTIAL";
 }
 
-export interface IGalaceanMaterialRemap extends RefItem {
+export interface IGalaceanMaterialRemap {
+  url: string;
+  key?: string;
   isClone?: boolean;
 }
 
diff --git a/packages/loader/src/gltf/parser/GLTFSceneParser.ts b/packages/loader/src/gltf/parser/GLTFSceneParser.ts
index 5ee981b1d3..553bf177f2 100644
--- a/packages/loader/src/gltf/parser/GLTFSceneParser.ts
+++ b/packages/loader/src/gltf/parser/GLTFSceneParser.ts
@@ -38,6 +38,7 @@ export class GLTFSceneParser extends GLTFParser {
       sceneRoot.addChild(context.get<Entity>(GLTFParserType.Entity, sceneNodes[i]));
     }
 
+    (glTFResource._sceneRoots ||= [])[index] = sceneRoot;
     if (isDefaultScene) {
       glTFResource._defaultSceneRoot = sceneRoot;
     }
@@ -195,49 +196,9 @@ export class GLTFSceneParser extends GLTFParser {
     if (rootBoneIndex !== -1) {
       BoundingBox.transform(mesh.bounds, inverseBindMatrices[rootBoneIndex], skinnedMeshRenderer.localBounds);
     } else {
-      // Root bone is not in joints list, we can only compute approximate inverse bind matrix
-      // Average all root bone's children inverse bind matrix
-      const approximateBindMatrix = new Matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-      let subRootBoneCount = this._computeApproximateBindMatrix(
-        bones,
-        inverseBindMatrices,
-        rootBone,
-        approximateBindMatrix
-      );
-
-      if (subRootBoneCount !== 0) {
-        Matrix.multiplyScalar(approximateBindMatrix, 1.0 / subRootBoneCount, approximateBindMatrix);
-        BoundingBox.transform(mesh.bounds, approximateBindMatrix, skinnedMeshRenderer.localBounds);
-      } else {
-        skinnedMeshRenderer.localBounds.copyFrom(mesh.bounds);
-      }
-    }
-  }
-
-  private _computeApproximateBindMatrix(
-    jointEntities: ReadonlyArray<Entity>,
-    inverseBindMatrices: Matrix[],
-    rootEntity: Entity,
-    approximateBindMatrix: Matrix
-  ): number {
-    let subRootBoneCount = 0;
-    const children = rootEntity.children;
-    for (let i = 0, n = children.length; i < n; i++) {
-      const rootChild = children[i];
-      const index = jointEntities.indexOf(rootChild);
-      if (index !== -1) {
-        Matrix.add(approximateBindMatrix, inverseBindMatrices[index], approximateBindMatrix);
-        subRootBoneCount++;
-      } else {
-        subRootBoneCount += this._computeApproximateBindMatrix(
-          jointEntities,
-          inverseBindMatrices,
-          rootChild,
-          approximateBindMatrix
-        );
-      }
+      const inverseRootBoneWorld = new Matrix();
+      Matrix.invert(rootBone.transform.worldMatrix, inverseRootBoneWorld);
+      BoundingBox.transform(mesh.bounds, inverseRootBoneWorld, skinnedMeshRenderer.localBounds);
     }
-
-    return subRootBoneCount;
   }
 }
diff --git a/packages/loader/src/gltf/parser/GLTFSkinParser.test.ts b/packages/loader/src/gltf/parser/GLTFSkinParser.test.ts
new file mode 100644
index 0000000000..bb5714b847
--- /dev/null
+++ b/packages/loader/src/gltf/parser/GLTFSkinParser.test.ts
@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+
+describe("GLTFSkinParser rootBone resolution", () => {
+  async function createParser(): Promise<any> {
+    (globalThis as any).window = { AudioContext: undefined, TextMetrics: undefined };
+    const { GLTFSkinParser } = await import("./GLTFSkinParser");
+    return new GLTFSkinParser();
+  }
+
+  it("includes skinned mesh nodes when resolving missing skin.skeleton", async () => {
+    const parser = await createParser();
+    const sceneRoot = { name: "GLTF_ROOT" };
+    const meshRoot = { name: "Character_Man", parent: sceneRoot };
+    const hips = { name: "mixamorig:Hips", parent: sceneRoot };
+    const spine = { name: "mixamorig:Spine", parent: hips };
+
+    const rootBone = (parser as any)._findSkinRootBoneByLCA(
+      0,
+      [1, 2],
+      [meshRoot, hips, spine],
+      [{ name: "Character_Man", skin: 0 }, { name: "mixamorig:Hips" }, { name: "mixamorig:Spine" }]
+    );
+
+    expect(rootBone).toBe(sceneRoot);
+  });
+
+  it("does not promote to the scene wrapper for unrelated top-level siblings", async () => {
+    const parser = await createParser();
+    const sceneRoot = { name: "GLTF_ROOT" };
+    const characterRoot = { name: "Character_Root", parent: sceneRoot };
+    const mesh = { name: "Character_Mesh", parent: characterRoot };
+    const hips = { name: "mixamorig:Hips", parent: characterRoot };
+    const light = { name: "Light", parent: sceneRoot };
+
+    const rootBone = (parser as any)._findSkinRootBoneByLCA(
+      0,
+      [3],
+      [characterRoot, mesh, light, hips],
+      [{ name: "Character_Root" }, { name: "Character_Mesh", skin: 0 }, { name: "Light" }, { name: "mixamorig:Hips" }]
+    );
+
+    expect(rootBone).toBe(characterRoot);
+  });
+});
diff --git a/packages/loader/src/gltf/parser/GLTFSkinParser.ts b/packages/loader/src/gltf/parser/GLTFSkinParser.ts
index e8959b4b70..3f11f487e5 100644
--- a/packages/loader/src/gltf/parser/GLTFSkinParser.ts
+++ b/packages/loader/src/gltf/parser/GLTFSkinParser.ts
@@ -34,20 +34,17 @@ export class GLTFSkinParser extends GLTFParser {
       }
       skin.bones = bones;
 
-      // 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
+      // Get skeleton
       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) {
+        const rootBone = this._findSkinRootBoneByLCA(index, joints, entities, glTF.nodes);
+        if (rootBone) {
+          skin.rootBone = rootBone;
+        } else {
           throw "Failed to find skeleton root bone.";
         }
-        skin.rootBone = rootBone;
       }
 
       return skin;
@@ -56,32 +53,50 @@ export class GLTFSkinParser extends GLTFParser {
     return AssetPromise.resolve(skinPromise);
   }
 
-  /**
-   * 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) {
+  private _findSkinRootBoneByLCA(
+    skinIndex: number,
+    joints: number[],
+    entities: Entity[],
+    nodes: Array<{ skin?: number }> = []
+  ): Entity | null {
+    const nodeIndices = joints.slice();
+    for (let i = 0, n = nodes.length; i < n; i++) {
+      if (nodes[i]?.skin === skinIndex) {
+        nodeIndices.push(i);
+      }
+    }
+
+    return this._findRootBoneByLCA(nodeIndices, entities);
+  }
+
+  private _findRootBoneByLCA(nodeIndices: number[], entities: Entity[]): Entity | null {
+    const paths: Entity[][] = [];
+    for (const index of nodeIndices) {
       const path = new Array<Entity>();
       let entity = entities[index];
       while (entity) {
         path.unshift(entity);
         entity = entity.parent;
       }
-      paths[index] = path;
+      if (path.length) {
+        paths.push(path);
+      }
+    }
+
+    if (!paths.length) {
+      return null;
     }
 
     let rootNode: Entity | null = null;
     for (let i = 0; ; i++) {
-      let path = paths[joints[0]];
+      let path = paths[0];
       if (i >= path.length) {
         return rootNode;
       }
 
       const entity = path[i];
-      for (let j = 1, m = joints.length; j < m; j++) {
-        path = paths[joints[j]];
+      for (let j = 1, m = paths.length; j < m; j++) {
+        path = paths[j];
         if (i >= path.length || entity !== path[i]) {
           return rootNode;
         }
diff --git a/packages/loader/src/gltf/parser/GLTFTextureParser.ts b/packages/loader/src/gltf/parser/GLTFTextureParser.ts
index fd0524ab2b..4da7f1cc5b 100644
--- a/packages/loader/src/gltf/parser/GLTFTextureParser.ts
+++ b/packages/loader/src/gltf/parser/GLTFTextureParser.ts
@@ -44,7 +44,7 @@ export class GLTFTextureParser extends GLTFParser {
     if (uri) {
       const extIndex = uri.lastIndexOf(".");
       const ext = uri.substring(extIndex + 1);
-      const type = ext.startsWith("ktx") ? AssetType.KTX : AssetType.Texture;
+      const type = ext.startsWith("ktx") ? AssetType.KTX : AssetType.Texture2D;
       texture = engine.resourceManager
         .load<Texture2D>({
           url: Utils.resolveAbsoluteUrl(url, uri),
diff --git a/packages/loader/src/index.ts b/packages/loader/src/index.ts
index 58381544c9..31417dee5c 100644
--- a/packages/loader/src/index.ts
+++ b/packages/loader/src/index.ts
@@ -16,17 +16,19 @@ import "./SourceFontLoader";
 import "./SpriteAtlasLoader";
 import "./SpriteLoader";
 import "./TextLoader";
-import "./TextureLoader";
+import "./Texture2DLoader";
+import "./TextureCubeLoader";
 import "./AudioLoader";
 import "./ktx2/KTX2Loader";
 import "./ShaderLoader";
+import "./ShaderChunkLoader";
 import "./PhysicsMaterialLoader";
 import "./RenderTargetLoader";
 
 export { GLTFLoader } from "./GLTFLoader";
 export type { GLTFParams } from "./GLTFLoader";
-import "./SceneLoader";
-export type { TextureParams } from "./TextureLoader";
+export * from "./SceneLoader";
+export type { Texture2DParams } from "./Texture2DLoader";
 export { parseSingleKTX } from "./compressed-texture";
 export * from "./gltf";
 export { KTX2Loader } from "./ktx2/KTX2Loader";
diff --git a/packages/loader/src/prefab/PrefabParser.ts b/packages/loader/src/prefab/PrefabParser.ts
index bd38232c53..5b5bdefd57 100644
--- a/packages/loader/src/prefab/PrefabParser.ts
+++ b/packages/loader/src/prefab/PrefabParser.ts
@@ -1,38 +1,34 @@
 import { Engine, Entity } from "@galacean/engine-core";
-import type { HierarchyFile } from "../schema/HierarchySchema";
-import type { PrefabFile } from "../schema/PrefabSchema";
+import { IEntity, IHierarchyFile, ParserContext, ParserType } from "../resource-deserialize";
 import { HierarchyParser } from "../resource-deserialize/resources/parser/HierarchyParser";
-import { ParserContext, ParserType } from "../resource-deserialize/resources/parser/ParserContext";
 import { PrefabResource } from "./PrefabResource";
 
-export class PrefabParser extends HierarchyParser<PrefabResource, ParserContext> {
-  static parse(engine: Engine, url: string, data: PrefabFile): Promise<PrefabResource> {
+export class PrefabParser extends HierarchyParser<PrefabResource, ParserContext<IHierarchyFile, Entity>> {
+  static parse(engine: Engine, url: string, data: IHierarchyFile): Promise<PrefabResource> {
     const prefabResource = new PrefabResource(engine, url);
-    const context = new ParserContext(engine, ParserType.Prefab, prefabResource);
+    const context = new ParserContext<IHierarchyFile, Entity>(engine, ParserType.Prefab, prefabResource);
     const parser = new PrefabParser(data, context, prefabResource);
     parser.start();
-    return parser.promise;
+    return parser.promise.then(() => prefabResource);
   }
 
   constructor(
-    data: HierarchyFile,
-    context: ParserContext,
+    data: IHierarchyFile,
+    context: ParserContext<IHierarchyFile, Entity>,
     public readonly prefabResource: PrefabResource
   ) {
     super(data, context);
   }
 
-  protected override _onEntityCreated(entity: Entity): void {
+  protected override _applyEntityData(entity: Entity, entityConfig: IEntity = {}): Entity {
+    super._applyEntityData(entity, entityConfig);
     // @ts-ignore
     entity._markAsTemplate(this.context.resource);
+    return entity;
   }
 
-  protected override _getRootIndices(): number[] {
-    return [(this.data as PrefabFile).root];
-  }
-
-  protected override _handleRootEntity(index: number): void {
-    this.prefabResource._root = this.context.entityInstances[index];
+  protected override _handleRootEntity(id: string): void {
+    this.prefabResource._root = this.context.entityMap.get(id);
   }
 
   protected override _clearAndResolve(): PrefabResource {
diff --git a/packages/loader/src/prefab/PrefabResource.ts b/packages/loader/src/prefab/PrefabResource.ts
index f6cf61c45e..2a49228793 100644
--- a/packages/loader/src/prefab/PrefabResource.ts
+++ b/packages/loader/src/prefab/PrefabResource.ts
@@ -44,7 +44,7 @@ export class PrefabResource extends ReferResource {
 
   protected override _onDestroy(): void {
     super._onDestroy();
-    this._root?.destroy();
+    this._root.destroy();
     this._dependenceAssets.forEach((asset) => {
       if (asset instanceof ReferResource) {
         // @ts-ignore
diff --git a/packages/loader/src/resource-deserialize/index.ts b/packages/loader/src/resource-deserialize/index.ts
index e68f06a0d8..b50923d1cb 100644
--- a/packages/loader/src/resource-deserialize/index.ts
+++ b/packages/loader/src/resource-deserialize/index.ts
@@ -7,8 +7,7 @@ export * from "./resources/animationClip/AnimationClipDecoder";
 export type { IModelMesh } from "./resources/mesh/IModelMesh";
 export { MeshDecoder } from "./resources/mesh/MeshDecoder";
 export { ReflectionParser } from "./resources/parser/ReflectionParser";
-import "./resources/texture2D/Texture2DDecoder";
-import "./resources/textureCube/TextureCubeDecoder";
+export { Texture2DDecoder } from "./resources/texture2D/TextureDecoder";
 
 /**
  * Decode engine binary resource.
@@ -28,7 +27,7 @@ export function decode<T>(arrayBuffer: ArrayBuffer, engine: Engine, ...args: any
 export * from "./resources/parser/HierarchyParser";
 export * from "./resources/parser/ParserContext";
 export * from "./resources/scene/SceneParser";
-export * from "../schema";
+export * from "./resources/schema";
 
 export * from "./utils/BufferReader";
 export * from "./utils/Decorator";
diff --git a/packages/loader/src/resource-deserialize/resources/mesh/IModelMesh.d.ts b/packages/loader/src/resource-deserialize/resources/mesh/IModelMesh.d.ts
index 3b5d99a388..368bd4a75f 100644
--- a/packages/loader/src/resource-deserialize/resources/mesh/IModelMesh.d.ts
+++ b/packages/loader/src/resource-deserialize/resources/mesh/IModelMesh.d.ts
@@ -1,5 +1,5 @@
 import { MeshTopology } from "@galacean/engine-core";
-import type { IColor, IVector2, IVector3, IVector4 } from "../../../schema/BasicSchema";
+import type { IColor, IVector2, IVector3, IVector4 } from "../schema/BasicSchema";
 
 export interface IEncodedModelMesh {
   positions: {
diff --git a/packages/loader/src/resource-deserialize/resources/parser/HierarchyParser.ts b/packages/loader/src/resource-deserialize/resources/parser/HierarchyParser.ts
index 2216ea3b42..b02e872acb 100644
--- a/packages/loader/src/resource-deserialize/resources/parser/HierarchyParser.ts
+++ b/packages/loader/src/resource-deserialize/resources/parser/HierarchyParser.ts
@@ -1,24 +1,15 @@
-import { Component, Engine, Entity, Loader, Scene } from "@galacean/engine-core";
+import { Component, Engine, Entity, Loader, Scene, Transform } from "@galacean/engine-core";
 import { GLTFResource } from "../../../gltf";
 import { PrefabResource } from "../../../prefab/PrefabResource";
-import { resolveRefItem } from "../../../schema/refs";
-import {
-  type ComponentSchema,
-  type ComponentSelector,
-  type ComponentOverride,
-  type EntityPropOverride,
-  type EntityOverrideProps,
-  type EntitySchema,
-  type InstanceOverrides,
-  type PrefabInstanceEntitySchema
-} from "../../../schema/HierarchySchema";
-import type { RefItem } from "../../../schema/CommonSchema";
-import type { HierarchyFile } from "../../../schema/HierarchySchema";
+import type { IEntity, IHierarchyFile, IRefEntity, IStrippedEntity } from "../schema";
 import { ParserContext, ParserType } from "./ParserContext";
 import { ReflectionParser } from "./ReflectionParser";
 
 /** @Internal */
-export abstract class HierarchyParser<T extends Scene | PrefabResource, V extends ParserContext> {
+export abstract class HierarchyParser<T extends Scene | PrefabResource, V extends ParserContext<IHierarchyFile, T>> {
+  /**
+   * The promise of parsed object.
+   */
   readonly promise: Promise<T>;
 
   protected _resolve: (item: T) => void;
@@ -26,317 +17,350 @@ export abstract class HierarchyParser<T extends Scene | PrefabResource, V extend
   protected _engine: Engine;
   protected _reflectionParser: ReflectionParser;
 
+  private _prefabContextMap = new WeakMap<Entity, ParserContext<IHierarchyFile, Entity>>();
+
+  private _prefabPromiseMap = new Map<
+    string,
+    {
+      resolve: (context: ParserContext<IHierarchyFile, Entity>) => void;
+      reject: (reason: any) => void;
+    }[]
+  >();
+
   constructor(
-    public readonly data: HierarchyFile,
+    public readonly data: IHierarchyFile,
     public readonly context: V
   ) {
-    if (data.version !== "2.0") {
-      const resourceType = context.type === ParserType.Scene ? "scene" : "prefab";
-      throw new Error(`Unsupported ${resourceType} format version "${data.version}". Expected "2.0".`);
-    }
-
     this._engine = this.context.engine;
+    this._organizeEntities = this._organizeEntities.bind(this);
+    this._parseComponents = this._parseComponents.bind(this);
+    this._parsePrefabModification = this._parsePrefabModification.bind(this);
+    this._parseAddedComponents = this._parseAddedComponents.bind(this);
+    this._parseComponentsPropsAndMethods = this._parseComponentsPropsAndMethods.bind(this);
+    this._parsePrefabRemovedEntities = this._parsePrefabRemovedEntities.bind(this);
+    this._parsePrefabRemovedComponents = this._parsePrefabRemovedComponents.bind(this);
+    this._clearAndResolve = this._clearAndResolve.bind(this);
     this.promise = new Promise<T>((resolve, reject) => {
       this._reject = reject;
       this._resolve = resolve;
     });
-    this._reflectionParser = new ReflectionParser(context, data.refs);
+    this._reflectionParser = new ReflectionParser(context);
   }
 
+  /** start parse the scene or prefab or others */
   public start() {
     this._parseEntities()
-      .then(() => this._organizeEntities())
-      .then(() => this._parseComponents())
-      .then(() => this._parseComponentsPropsAndCalls())
-      .then(() => this._parsePrefabOverrides())
-      .then(() => this._clearAndResolve())
+      .then(this._organizeEntities)
+      .then(this._parseComponents)
+      .then(this._parseAddedComponents)
+      .then(this._parseComponentsPropsAndMethods)
+      .then(this._parsePrefabModification)
+      .then(this._parsePrefabRemovedEntities)
+      .then(this._parsePrefabRemovedComponents)
+      .then(this._clearAndResolve)
       .then(this._resolve)
       .catch(this._reject);
   }
 
-  /** Root entity indices for this hierarchy (scene.rootEntities or [prefab.root]). */
-  protected abstract _getRootIndices(): number[];
-  protected abstract _handleRootEntity(index: number): void;
-  protected abstract _clearAndResolve(): Scene | PrefabResource;
-
-  protected _onEntityCreated(_entity: Entity): void {}
-
-  // ---------------------------------------------------------------------------
-  // Stage 1: Create entity instances
-  // ---------------------------------------------------------------------------
-
-  private _parseEntities(): Promise<unknown> {
-    const entities = this.data.entities;
-    const entityInstances = this.context.entityInstances;
-    const engine = this._engine;
-    const promises: Promise<void>[] = [];
-
-    for (let i = 0, n = entities.length; i < n; i++) {
-      const entityConfig = entities[i];
-
-      if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) {
-        promises.push(
-          this._loadPrefabInstance(entityConfig, engine).then((entity) => {
-            entityInstances[i] = entity;
-          })
-        );
-      } else {
-        const entity = new Entity(engine, entityConfig.name);
-        HierarchyParser._applyEntityProps(entity, entityConfig);
-        this._onEntityCreated(entity);
-        entityInstances[i] = entity;
-      }
+  protected _applyEntityData(entity: Entity, entityConfig: IEntity = {}): Entity {
+    entity.isActive = entityConfig.isActive ?? entity.isActive;
+    entity.name = entityConfig.name ?? entity.name;
+    const transform = entity.transform;
+    const transformConfig = entityConfig.transform;
+    if (transformConfig) {
+      this._reflectionParser.parsePropsAndMethods(transform, transformConfig);
+    } else {
+      const { position, rotation, scale } = entityConfig;
+      if (position) transform.position.copyFrom(position);
+      if (rotation) transform.rotation.copyFrom(rotation);
+      if (scale) transform.scale.copyFrom(scale);
     }
-
-    return Promise.all(promises);
+    if (entityConfig.layer) entity.layer = entityConfig.layer;
+    return entity;
   }
 
-  // ---------------------------------------------------------------------------
-  // Stage 2: Build parent-child hierarchy
-  // ---------------------------------------------------------------------------
-
-  private _organizeEntities(): void {
-    const entities = this.data.entities;
-    const entityInstances = this.context.entityInstances;
-
-    for (let i = 0, n = entities.length; i < n; i++) {
-      const entityConfig = entities[i];
-      // Prefab instance entities manage their own children.
-      if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
-
-      const children = entityConfig.children;
-      if (!children) continue;
+  protected abstract _handleRootEntity(id: string): void;
+  protected abstract _clearAndResolve(): Scene | PrefabResource;
 
-      const parent = entityInstances[i];
-      for (let j = 0, m = children.length; j < m; j++) {
-        parent.addChild(entityInstances[children[j]]);
+  private _parseEntities(): Promise<Entity[]> {
+    const entitiesConfig = this.data.entities;
+    const entityConfigMap = this.context.entityConfigMap;
+    const entityMap = this.context.entityMap;
+    const engine = this._engine;
+    const promises = entitiesConfig.map((entityConfig) => {
+      const id = (entityConfig as IStrippedEntity).strippedId ?? entityConfig.id;
+      entityConfig.id = id;
+      entityConfigMap.set(id, entityConfig);
+      return this._getEntityByConfig(entityConfig, engine);
+    });
+    return Promise.all(promises).then((entities) => {
+      for (let i = 0, l = entities.length; i < l; i++) {
+        entityMap.set(entitiesConfig[i].id, entities[i]);
       }
-    }
-
-    const rootIndices = this._getRootIndices();
-    for (let i = 0, n = rootIndices.length; i < n; i++) {
-      this._handleRootEntity(rootIndices[i]);
-    }
+      // Build rootIds in serialization order (not async completion order)
+      const rootIds = this.context.rootIds;
+      for (let i = 0, l = entitiesConfig.length; i < l; i++) {
+        if (!entitiesConfig[i].parent && !(entitiesConfig[i] as IStrippedEntity).strippedId) {
+          rootIds.push(entitiesConfig[i].id);
+        }
+      }
+      return entities;
+    });
   }
 
-  // ---------------------------------------------------------------------------
-  // Stage 3: Add components to entities
-  // ---------------------------------------------------------------------------
-
   private _parseComponents(): void {
-    const entities = this.data.entities;
-    const allComponents = this.data.components;
-    const entityInstances = this.context.entityInstances;
-    const pendingComponents = this.context.pendingComponents;
-    const refs = this.data.refs;
-
-    for (let i = 0, n = entities.length; i < n; i++) {
-      const entityConfig = entities[i];
-      if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
-
-      const entity = entityInstances[i];
-      const componentIndices = entityConfig.components;
-      if (!componentIndices) continue;
-
-      for (let j = 0, m = componentIndices.length; j < m; j++) {
-        const config = allComponents[componentIndices[j]];
-        const instance = HierarchyParser._addComponentFromConfig(entity, config, refs);
-        pendingComponents.push({ instance, config });
+    const entitiesConfig = this.data.entities;
+    const entityMap = this.context.entityMap;
+
+    for (let i = 0, l = entitiesConfig.length; i < l; i++) {
+      const entityConfig = entitiesConfig[i];
+      if ((entityConfig as IStrippedEntity).strippedId) {
+        continue;
       }
+      const entity = entityMap.get(entityConfig.id);
+      this._addComponents(entity, entityConfig.components);
     }
   }
 
-  // ---------------------------------------------------------------------------
-  // Stage 4: Apply props and execute calls on components
-  // ---------------------------------------------------------------------------
+  private _parsePrefabModification() {
+    const entitiesConfig = this.data.entities;
+    const entityMap = this.context.entityMap;
 
-  private _parseComponentsPropsAndCalls(): Promise<unknown> {
-    const { pendingComponents } = this.context;
-    const reflectionParser = this._reflectionParser;
-    const promises: Promise<unknown>[] = [];
+    const promises = [];
+    for (let i = 0, l = entitiesConfig.length; i < l; i++) {
+      const entityConfig = entitiesConfig[i];
+      const { id, modifications } = entityConfig as IRefEntity;
 
-    for (let i = 0, n = pendingComponents.length; i < n; i++) {
-      const { instance, config } = pendingComponents[i];
-      promises.push(reflectionParser.parseMutationBlock(instance, config));
+      if (modifications?.length) {
+        const rootEntity = entityMap.get(id);
+        promises.push(
+          ...modifications.map((modification) => {
+            const { target, props, methods } = modification;
+            const { entityId, componentId } = target;
+            const context = this._prefabContextMap.get(rootEntity);
+            const targetEntity = context.entityMap.get(entityId);
+            const targetComponent = context.components.get(componentId);
+            if (targetComponent) {
+              return this._reflectionParser.parsePropsAndMethods(targetComponent, {
+                props,
+                methods
+              });
+            } else if (targetEntity) {
+              return Promise.resolve(this._applyEntityData(targetEntity, props));
+            }
+          })
+        );
+      }
     }
 
     return Promise.all(promises);
   }
 
-  // ---------------------------------------------------------------------------
-  // Stage 5: Apply prefab instance overrides
-  // ---------------------------------------------------------------------------
-
-  private _parsePrefabOverrides(): Promise<unknown> {
-    const entities = this.data.entities;
-    const entityInstances = this.context.entityInstances;
-    const promises: Promise<unknown>[] = [];
-
-    for (let i = 0, n = entities.length; i < n; i++) {
-      const entityConfig = entities[i];
-      if (!HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
+  private _parseAddedComponents(): void {
+    const entityMap = this.context.entityMap;
+    const entityConfigMap = this.context.entityConfigMap;
+    const strippedIds = this.context.strippedIds;
 
-      const overrides = entityConfig.instance.overrides;
-      if (!overrides) continue;
-
-      this._applyOverrides(entityInstances[i], overrides, promises);
+    for (let i = 0, n = strippedIds.length; i < n; i++) {
+      const entityConfig = entityConfigMap.get(strippedIds[i]) as IStrippedEntity;
+      const prefabContext = this._prefabContextMap.get(entityMap.get(entityConfig.prefabInstanceId));
+      const entity = prefabContext.entityMap.get(entityConfig.prefabSource.entityId);
+      this._addComponents(entity, entityConfig.components);
     }
-
-    return Promise.all(promises);
   }
 
-  private _applyOverrides(rootEntity: Entity, overrides: InstanceOverrides, promises: Promise<unknown>[]): void {
-    const refs = this.data.refs;
-    const reflectionParser = this._reflectionParser;
-
-    // entityProps — entity-level property overrides
-    if (overrides.entityProps) {
-      for (let j = 0, m = overrides.entityProps.length; j < m; j++) {
-        const override = overrides.entityProps[j] as EntityPropOverride;
-        HierarchyParser._applyEntityProps(HierarchyParser._resolveEntity(rootEntity, override.path), override);
+  private _parsePrefabRemovedEntities() {
+    const entitiesConfig = this.data.entities;
+    const entityMap = this.context.entityMap;
+
+    for (let i = 0, l = entitiesConfig.length; i < l; i++) {
+      const entityConfig = entitiesConfig[i];
+      const { id, removedEntities } = entityConfig as IRefEntity;
+
+      if (removedEntities?.length) {
+        const rootEntity = entityMap.get(id);
+        for (let j = 0, m = removedEntities.length; j < m; j++) {
+          const target = removedEntities[j];
+          const { entityId } = target;
+          const context = this._prefabContextMap.get(rootEntity);
+          const targetEntity = context.entityMap.get(entityId);
+          if (targetEntity) {
+            targetEntity.destroy();
+          }
+        }
       }
     }
+  }
 
-    // componentProps — component-level property overrides
-    if (overrides.componentProps) {
-      for (let j = 0, m = overrides.componentProps.length; j < m; j++) {
-        const override = overrides.componentProps[j] as ComponentOverride;
-        const entity = HierarchyParser._resolveEntity(rootEntity, override.path);
-        const target = HierarchyParser._resolveComponent(entity, override.selector);
-        promises.push(reflectionParser.parseMutationBlock(target, override));
+  private _parsePrefabRemovedComponents() {
+    const entitiesConfig = this.data.entities;
+    const entityMap = this.context.entityMap;
+    const prefabContextMap = this._prefabContextMap;
+
+    for (let i = 0, l = entitiesConfig.length; i < l; i++) {
+      const entityConfig = entitiesConfig[i];
+      const { id, removedComponents } = entityConfig as IRefEntity;
+
+      if (removedComponents?.length) {
+        const rootEntity = entityMap.get(id);
+        for (let j = 0, m = removedComponents.length; j < m; j++) {
+          const target = removedComponents[j];
+          const { componentId } = target;
+          const context = prefabContextMap.get(rootEntity);
+          const targetComponent = context.components.get(componentId);
+          if (targetComponent) {
+            targetComponent.destroy();
+          }
+        }
       }
     }
+  }
 
-    // addedComponents — attach top-level components[index] to a prefab entity and parse props
-    if (overrides.addedComponents) {
-      const allComponents = this.data.components;
-      for (let j = 0, m = overrides.addedComponents.length; j < m; j++) {
-        const added = overrides.addedComponents[j];
-        const entity = HierarchyParser._resolveEntity(rootEntity, added.target);
-        const config = allComponents[added.component];
-        const component = HierarchyParser._addComponentFromConfig(entity, config, refs);
-        promises.push(reflectionParser.parseMutationBlock(component, config));
-      }
+  private _organizeEntities(): void {
+    const { rootIds, strippedIds } = this.context;
+    const parentIds = rootIds.concat(strippedIds);
+    for (let i = 0, l = parentIds.length; i < l; i++) {
+      this._parseChildren(parentIds[i]);
     }
-
-    // addedEntities — attach already-created top-level entityInstances[index] as a child
-    if (overrides.addedEntities) {
-      const entityInstances = this.context.entityInstances;
-      for (let j = 0, m = overrides.addedEntities.length; j < m; j++) {
-        const added = overrides.addedEntities[j];
-        const parent = HierarchyParser._resolveEntity(rootEntity, added.parent);
-        parent.addChild(entityInstances[added.entity]);
-      }
+    for (let i = 0; i < rootIds.length; i++) {
+      this._handleRootEntity(rootIds[i]);
     }
+  }
 
-    // removedEntities — pre-resolve all targets then destroy (destroy shifts sibling indices)
-    if (overrides.removedEntities) {
-      const removed = overrides.removedEntities;
-      const targets = new Array<Entity>(removed.length);
-      for (let j = 0, m = removed.length; j < m; j++) {
-        targets[j] = HierarchyParser._resolveEntity(rootEntity, removed[j]);
-      }
-      for (let j = 0, m = targets.length; j < m; j++) {
-        targets[j].destroy();
-      }
+  private _getEntityByConfig(entityConfig: IEntity, engine: Engine): Promise<Entity> {
+    let entityPromise: Promise<Entity>;
+    if ((<IRefEntity>entityConfig).assetUrl) {
+      entityPromise = this._parsePrefab(<IRefEntity>entityConfig, engine);
+    } else if ((<IStrippedEntity>entityConfig).strippedId) {
+      entityPromise = this._parseStrippedEntity(<IStrippedEntity>entityConfig);
+    } else {
+      entityPromise = this._parseEntity(entityConfig, engine);
     }
+    return entityPromise.then((entity) => {
+      return this._applyEntityData(entity, entityConfig);
+    });
+  }
 
-    // removedComponents — pre-resolve all targets then destroy (destroy shifts component indices)
-    if (overrides.removedComponents) {
-      const targets: Component[] = [];
-      for (let j = 0, m = overrides.removedComponents.length; j < m; j++) {
-        const override = overrides.removedComponents[j];
-        const entity = HierarchyParser._resolveEntity(rootEntity, override.path);
-        const selectors = override.selectors;
-        for (let k = 0, p = selectors.length; k < p; k++) {
-          targets.push(HierarchyParser._resolveComponent(entity, selectors[k]));
-        }
-      }
-      for (let j = 0, m = targets.length; j < m; j++) {
-        targets[j].destroy();
-      }
-    }
+  private _parseEntity(entityConfig: IEntity, engine: Engine): Promise<Entity> {
+    const transform = entityConfig.transform;
+    const entity = new Entity(engine, entityConfig.name, transform ? Loader.getClass(transform.class) : Transform);
+    this._addEntityPlugin(entityConfig.id, entity);
+    return Promise.resolve(entity);
   }
 
-  // ---------------------------------------------------------------------------
-  // Prefab instance loading
-  // ---------------------------------------------------------------------------
-
-  private _loadPrefabInstance(entityConfig: PrefabInstanceEntitySchema, engine: Engine): Promise<Entity> {
-    const instance = entityConfig.instance;
-    let refItem: RefItem;
-    try {
-      refItem = resolveRefItem(this.data.refs, instance.asset, "HierarchyParser", "instance.asset");
-    } catch (error) {
-      return Promise.reject(error);
-    }
+  private _parsePrefab(entityConfig: IRefEntity, engine: Engine): Promise<Entity> {
+    const assetUrl: string = entityConfig.assetUrl;
 
     return (
       engine.resourceManager
         // @ts-ignore
-        .getResourceByRef<Entity>(refItem)
+        .getResourceByRef<Entity>({
+          url: assetUrl
+        })
         .then((prefabResource: PrefabResource | GLTFResource) => {
           const entity =
             prefabResource instanceof PrefabResource
               ? prefabResource.instantiate()
               : prefabResource.instantiateSceneRoot();
-          this._onEntityCreated(entity);
+          const instanceContext = new ParserContext<IHierarchyFile, Entity>(engine, ParserType.Prefab, null);
+          this._generateInstanceContext(entity, instanceContext, "");
+
+          this._prefabContextMap.set(entity, instanceContext);
+          const cbArray = this._prefabPromiseMap.get(entityConfig.id);
+          if (cbArray) {
+            for (let i = 0, n = cbArray.length; i < n; i++) {
+              cbArray[i].resolve(instanceContext);
+            }
+          }
           return entity;
         })
     );
   }
 
-  // ---------------------------------------------------------------------------
-  // Utilities
-  // ---------------------------------------------------------------------------
-
-  /** Resolve an entity inside a prefab instance by walking the child-index path from root */
-  private static _resolveEntity(root: Entity, path: number[]): Entity {
-    let entity = root;
-    for (let i = 0, n = path.length; i < n; i++) {
-      entity = entity.children[path[i]];
-      if (!entity)
-        throw new Error(`HierarchyParser: override target entity not found at path [${path}], failed at depth ${i}`);
-    }
-    return entity;
+  private _parseStrippedEntity(entityConfig: IStrippedEntity): Promise<Entity> {
+    this.context.strippedIds.push(entityConfig.id);
+
+    return new Promise<ParserContext<IHierarchyFile, Entity>>((resolve, reject) => {
+      const cbArray = this._prefabPromiseMap.get((<IStrippedEntity>entityConfig).prefabInstanceId) ?? [];
+      cbArray.push({ resolve, reject });
+      this._prefabPromiseMap.set((<IStrippedEntity>entityConfig).prefabInstanceId, cbArray);
+    }).then((context) => {
+      const { entityId } = entityConfig.prefabSource;
+
+      return context.entityMap.get(entityId);
+    });
   }
 
-  /** Resolve a component on an entity by type name + per-type index */
-  private static _resolveComponent(entity: Entity, selector: ComponentSelector): Component {
-    const type = Loader.getClass(selector.type);
-    if (!type) throw new Error(`HierarchyParser: override target component type "${selector.type}" is not registered`);
-    const buffer = ReflectionParser._componentBuffer;
-    buffer.length = 0;
-    entity.getComponents(type, buffer);
-    const result = buffer[selector.index];
-    buffer.length = 0;
-    if (!result)
-      throw new Error(`HierarchyParser: override target component not found: ${selector.type}/${selector.index}`);
-    return result;
+  private _parseChildren(parentId: string) {
+    const { entityConfigMap, entityMap } = this.context;
+    const children = entityConfigMap.get(parentId).children;
+    if (children && children.length > 0) {
+      const parent = entityMap.get(parentId);
+      for (let i = 0; i < children.length; i++) {
+        const childId = children[i];
+        const entity = entityMap.get(childId);
+        parent.addChild(entity);
+        this._parseChildren(childId);
+      }
+    }
   }
 
-  /** Resolve component class from config and add to entity. Throws if class is not registered. */
-  private static _addComponentFromConfig(entity: Entity, config: ComponentSchema, refs: RefItem[]): Component {
-    const key =
-      config.script != null
-        ? resolveRefItem(refs, config.script, "HierarchyParser", "component.script").url
-        : config.type;
-    const Class = Loader.getClass(key);
-    if (!Class) throw new Error(`Loader.getClass: class "${key}" is not registered`);
-    return entity.addComponent(Class);
+  private _addComponents(entity: Entity, components: IEntity["components"]): void {
+    const context = this.context;
+    const componentMap = context.components;
+    const componentConfigMap = context.componentConfigMap;
+
+    for (let i = 0, n = components.length; i < n; i++) {
+      const componentConfig = components[i];
+      const key = !componentConfig.url ? componentConfig.class : componentConfig.url;
+      const componentId = componentConfig.id;
+      const component = entity.addComponent(Loader.getClass(key));
+      componentMap.set(componentId, component);
+      componentConfigMap.set(componentId, componentConfig);
+      this._addComponentPlugin(componentId, component);
+    }
   }
 
-  private static _isPrefabInstanceEntity(entityConfig: EntitySchema): entityConfig is PrefabInstanceEntitySchema {
-    return "instance" in entityConfig;
+  private _generateInstanceContext(entity: Entity, context: ParserContext<IHierarchyFile, Entity>, path: string) {
+    const { entityMap, components } = context;
+    const componentsMap = {};
+    const componentIndexMap = {};
+
+    entityMap.set(path, entity);
+    // @ts-ignore
+    entity._components.forEach((component) => {
+      // @ts-ignore
+      const name = Loader.getClassName(component.constructor);
+      if (!componentsMap[name]) {
+        componentsMap[name] = entity.getComponents(component.constructor, []);
+        componentIndexMap[name] = 0;
+      }
+      components.set(`${path}:${name}/${componentIndexMap[name]++}`, component);
+    });
+    for (let i = 0, n = entity.children.length; i < n; i++) {
+      const child = entity.children[i];
+      const childPath = path ? `${path}/${i}` : `${i}`;
+      this._generateInstanceContext(child, context, childPath);
+    }
   }
 
-  /** Apply entity-level props (name, isActive, layer, transform) to an entity. */
-  private static _applyEntityProps(entity: Entity, props: EntityOverrideProps): void {
-    if (props.name != null) entity.name = props.name;
-    if (props.isActive != null) entity.isActive = props.isActive;
-    if (props.layer != null) entity.layer = props.layer;
-    if (props.position) entity.transform.position.set(props.position[0], props.position[1], props.position[2]);
-    if (props.rotation) entity.transform.rotation.set(props.rotation[0], props.rotation[1], props.rotation[2]);
-    if (props.scale) entity.transform.scale.set(props.scale[0], props.scale[1], props.scale[2]);
+  private _parseComponentsPropsAndMethods(): Promise<any[]> {
+    const context = this.context;
+    const componentConfigMap = context.componentConfigMap;
+    const reflectionParser = this._reflectionParser;
+    const promises = [];
+
+    for (const [componentId, component] of context.components) {
+      const componentConfig = componentConfigMap.get(componentId);
+      if (componentConfig) {
+        promises.push(reflectionParser.parsePropsAndMethods(component, componentConfig));
+      }
+    }
+
+    return Promise.all(promises);
   }
+
+  private _addComponentPlugin(componentId: string, component: Component): void {}
+
+  private _addEntityPlugin(entityId: string, entity: Entity): void {}
 }
diff --git a/packages/loader/src/resource-deserialize/resources/parser/ParserContext.ts b/packages/loader/src/resource-deserialize/resources/parser/ParserContext.ts
index 44712a0d61..26a735c471 100644
--- a/packages/loader/src/resource-deserialize/resources/parser/ParserContext.ts
+++ b/packages/loader/src/resource-deserialize/resources/parser/ParserContext.ts
@@ -1,22 +1,33 @@
-import { AssetPromise, Component, Engine, Entity, ReferResource, ResourceManager, Scene } from "@galacean/engine-core";
-import type { ComponentSchema } from "../../../schema/HierarchySchema";
+import {
+  AssetPromise,
+  Component,
+  Engine,
+  EngineObject,
+  Entity,
+  ReferResource,
+  ResourceManager,
+  Scene
+} from "@galacean/engine-core";
+import type { IEntity, IHierarchyFile } from "../schema";
 
 export enum ParserType {
   Prefab,
   Scene
 }
-
 /**
  * @internal
  */
-export class ParserContext {
-  /** Runtime Entity instances, indexed by the flat entities[] position. */
-  entityInstances: Entity[] = [];
-  /** Components waiting for props/calls application (Stage 4). */
-  pendingComponents: Array<{ instance: Component; config: ComponentSchema }> = [];
+export class ParserContext<T extends IHierarchyFile, I extends EngineObject> {
+  entityMap: Map<string, Entity> = new Map();
+  entityConfigMap: Map<string, IEntity> = new Map();
+  components: Map<string, Component> = new Map();
+  componentConfigMap: Map<string, any> = new Map();
+  rootIds: string[] = [];
+  strippedIds: string[] = [];
 
   readonly resourceManager: ResourceManager;
 
+  private _tasks: Set<string> = new Set();
   private _loaded: number = 0;
   private _total: number = 0;
 
@@ -29,16 +40,23 @@ export class ParserContext {
   }
 
   clear() {
-    this.entityInstances.length = 0;
-    this.pendingComponents.length = 0;
+    this.entityMap.clear();
+    this.components.clear();
+    this.componentConfigMap.clear();
+    this.entityConfigMap.clear();
+    this.rootIds.length = 0;
+    this.strippedIds.length = 0;
   }
 
   /** @internal */
   _setTaskCompleteProgress: (loaded: number, total: number) => void;
 
   /** @internal */
-  _addDependentAsset(promise: AssetPromise<any>): void {
+  _addDependentAsset(url: string, promise: AssetPromise<any>): void {
+    const tasks = this._tasks;
+    if (tasks.has(url)) return;
     ++this._total;
+    tasks.add(url);
     promise.finally(() => {
       ++this._loaded;
       this._setTaskCompleteProgress(this._loaded, this._total);
diff --git a/packages/loader/src/resource-deserialize/resources/parser/ReflectionParser.ts b/packages/loader/src/resource-deserialize/resources/parser/ReflectionParser.ts
index 2e038238ce..fe92bbcf6a 100644
--- a/packages/loader/src/resource-deserialize/resources/parser/ReflectionParser.ts
+++ b/packages/loader/src/resource-deserialize/resources/parser/ReflectionParser.ts
@@ -1,208 +1,234 @@
-import { Component, Entity, Loader } from "@galacean/engine-core";
-import { resolveRefItem } from "../../../schema/refs";
-import type { CallSpec, ComponentRef, MutationBlock, RefItem, SignalListener } from "../../../schema/CommonSchema";
+import { EngineObject, Entity, Loader, Signal, Transform } from "@galacean/engine-core";
+import type {
+  IAssetRef,
+  IBasicType,
+  IClass,
+  IClassType,
+  IComponentRef,
+  IEntity,
+  IEntityRef,
+  IHierarchyFile,
+  IMethod,
+  IMethodParams,
+  IRefEntity,
+  ISignalRef
+} from "../schema";
 import { ParserContext, ParserType } from "./ParserContext";
 
 export class ReflectionParser {
-  /** @internal shared with HierarchyParser; each use must length=0 -> getComponents -> read -> length=0 synchronously. */
-  static _componentBuffer: Component[] = [];
-
-  constructor(
-    private readonly _context: ParserContext,
-    private readonly _refs: RefItem[]
-  ) {}
-
-  /**
-   * Apply v2 props to a component/object instance.
-   * Each prop value is resolved recursively (handling $ref, $type, $class, $entity, $component, $signal).
-   */
-  parseProps(instance: any, props?: Record<string, unknown>): Promise<any> {
-    const promises: Promise<any>[] = [];
-    if (props) {
-      for (const key in props) {
-        const promise = this._resolveValue(props[key], instance[key]).then((v) => {
-          instance[key] = v;
-        });
-        promises.push(promise);
+  constructor(private readonly _context: ParserContext<IHierarchyFile, EngineObject>) {}
+
+  parseEntity(entityConfig: IEntity): Promise<Entity> {
+    return this._getEntityByConfig(entityConfig).then((entity) => {
+      entity.isActive = entityConfig.isActive ?? true;
+      const transform = entity.transform;
+      const transformConfig = entityConfig.transform;
+      if (transformConfig) {
+        this.parsePropsAndMethods(transform, transformConfig);
+      } else {
+        const { position, rotation, scale } = entityConfig;
+        if (position) transform.position.copyFrom(position);
+        if (rotation) transform.rotation.copyFrom(rotation);
+        if (scale) transform.scale.copyFrom(scale);
       }
-    }
-    return Promise.all(promises).then(() => instance);
+      entity.layer = entityConfig.layer ?? entity.layer;
+      // @ts-ignore
+      this._context.type === ParserType.Prefab && entity._markAsTemplate(this._context.resource);
+      return entity;
+    });
   }
 
-  /**
-   * Execute calls sequentially on a target instance.
-   * Call args are resolved with the same v2 value rules as props.
-   */
-  parseCalls(instance: any, calls?: CallSpec[]): Promise<any> {
-    if (!calls?.length) return Promise.resolve(instance);
-
-    let chain = Promise.resolve();
-    for (let i = 0, n = calls.length; i < n; i++) {
-      const call = calls[i];
-      chain = chain.then(() => {
-        const method = instance?.[call.method];
-        if (typeof method !== "function") {
-          return Promise.reject(new Error(`Call target does not have method "${call.method}"`));
+  parseClassObject(item: IClass) {
+    const Class = Loader.getClass(item.class);
+    const params = item.constructParams ?? [];
+    return Promise.all(params.map((param) => this.parseBasicType(param)))
+      .then((resultParams) => new Class(...resultParams))
+      .then((instance) => this.parsePropsAndMethods(instance, item));
+  }
+
+  parsePropsAndMethods(instance: any, item: Omit<IClass, "class">) {
+    const promises = [];
+    if (item.methods) {
+      for (let methodName in item.methods) {
+        const methodParams = item.methods[methodName];
+        for (let i = 0, count = methodParams.length; i < count; i++) {
+          promises.push(this.parseMethod(instance, methodName, methodParams[i]));
         }
+      }
+    }
 
-        return Promise.all((call.args ?? []).map((arg) => this._resolveValue(arg)))
-          .then((resolvedArgs) => Promise.resolve(method.apply(instance, resolvedArgs)))
-          .then((result) => {
-            if (!call.result) return result;
-            if (result == null || (typeof result !== "object" && typeof result !== "function")) {
-              return Promise.reject(
-                new Error(`Call "${call.method}" returned ${result} and cannot be mutated by result`)
-              );
-            }
-            return this.parseMutationBlock(result, call.result);
-          });
-      });
+    if (item.props) {
+      for (let key in item.props) {
+        const value = item.props[key];
+        const promise = this.parseBasicType(value, instance[key]).then((v) => {
+          return (instance[key] = v);
+        });
+        promises.push(promise);
+      }
     }
 
-    return chain.then(() => instance);
+    return Promise.all(promises).then(() => instance);
   }
 
-  /**
-   * Apply props and calls from the same mutation block without imposing ordering between them.
-   */
-  parseMutationBlock(target: any, block?: MutationBlock): Promise<any> {
-    if (!block) return Promise.resolve(target);
-    return Promise.all([this.parseProps(target, block.props), this.parseCalls(target, block.calls)]).then(() => target);
-  }
+  parseMethod(instance: any, methodName: string, methodParams: IMethodParams) {
+    const isMethodObject = ReflectionParser._isMethodObject(methodParams);
+    const params = isMethodObject ? methodParams.params : methodParams;
 
-  /**
-   * Resolve a v2 value with $ prefix detection.
-   *
-   * Priority:
-   * 1. null/undefined/primitive → passthrough
-   * 2. Array → recurse each element
-   * 3. { $ref }       → asset reference
-   * 4. { $type }      → polymorphic type construct
-   * 5. { $class }     → registered class constructor
-   * 6. { $entity }    → entity reference by path (flat index + optional children descent)
-   * 7. { $component } → component reference
-   * 8. { $signal }    → signal binding
-   * 9. plain object   → recurse values (modify originValue in place if exists)
-   */
-  private _resolveValue(value: unknown, originValue?: any): Promise<any> {
-    if (value == null || typeof value !== "object") return Promise.resolve(value);
-    if (Array.isArray(value)) return Promise.all(value.map((v) => this._resolveValue(v)));
-
-    const obj = value as Record<string, unknown>;
-
-    // $ref — asset reference (index into refs array)
-    if ("$ref" in obj) {
-      const { _context: context } = this;
-      let refItem: RefItem;
-      try {
-        refItem = resolveRefItem(this._refs, obj.$ref as number, "ReflectionParser", "$ref");
-      } catch (error) {
-        return Promise.reject(error);
+    return Promise.all(params.map((param) => this.parseBasicType(param))).then((result) => {
+      const methodResult = instance[methodName](...result);
+      if (isMethodObject && methodParams.result) {
+        return this.parsePropsAndMethods(methodResult, methodParams.result);
+      } else {
+        return methodResult;
       }
-      // @ts-ignore
-      return context.resourceManager.getResourceByRef(refItem).then((resource) => {
-        if (resource && context.type === ParserType.Prefab) {
-          // @ts-ignore
-          context.resource._addDependenceAsset(resource);
-        }
-        return resource;
-      });
-    }
-
-    // $type — polymorphic type: construct instance and apply remaining props
-    if ("$type" in obj) {
-      const { $type, ...rest } = obj;
-      return this._resolveRegisteredClass($type, "$type").then((Class) => {
-        const instance = new Class();
-        return Object.keys(rest).length > 0 ? this.parseProps(instance, rest) : instance;
-      });
-    }
+    });
+  }
 
-    // $class — registered class constructor for factory-style methods.
-    if ("$class" in obj) {
-      return this._resolveRegisteredClass(obj.$class, "$class");
-    }
+  parseSignal(signalRef: ISignalRef): Promise<Signal> {
+    const signal = new Signal();
+    return Promise.all(
+      signalRef.listeners.map((listener) =>
+        Promise.all([
+          this.parseBasicType(listener.target),
+          listener.arguments ? Promise.all(listener.arguments.map((a) => this.parseBasicType(a))) : Promise.resolve([])
+        ]).then(([target, resolvedArgs]) => {
+          if (target) {
+            signal.on(target, listener.methodName, ...resolvedArgs);
+          }
+        })
+      )
+    ).then(() => signal);
+  }
 
-    // $entity — entity reference by path (first element = flat index, subsequent = children indices)
-    if ("$entity" in obj) {
-      return Promise.resolve(this._resolveEntityRef(obj.$entity as number[]));
+  parseBasicType(value: IBasicType, originValue?: any): Promise<any> {
+    if (Array.isArray(value)) {
+      return Promise.all(value.map((item) => this.parseBasicType(item)));
+    } else if (typeof value === "object" && value != null) {
+      if (ReflectionParser._isClassType(value)) {
+        return Promise.resolve(Loader.getClass(value["classType"]));
+      } else if (ReflectionParser._isClass(value)) {
+        // class object
+        return this.parseClassObject(value);
+      } else if (ReflectionParser._isAssetRef(value)) {
+        const { _context: context } = this;
+        // reference object
+        // @ts-ignore
+        return context.resourceManager.getResourceByRef(value).then((resource) => {
+          if (resource && context.type === ParserType.Prefab) {
+            // @ts-ignore
+            context.resource._addDependenceAsset(resource);
+          }
+          return resource;
+        });
+      } else if (ReflectionParser._isComponentRef(value)) {
+        const entity = this._resolveEntityByPath(value.entityPath);
+        if (!entity) return Promise.resolve(null);
+        const type = Loader.getClass(value.componentType);
+        if (!type) return Promise.resolve(null);
+        // Try direct components first, fallback to children search (for GLB clone entities
+        // where the component lives on a child entity inside the clone)
+        const direct = entity.getComponents(type, []);
+        const result = direct[value.componentIndex];
+        if (result) return Promise.resolve(result);
+        const includeChildren: any[] = [];
+        entity.getComponentsIncludeChildren(type, includeChildren);
+        return Promise.resolve(includeChildren[value.componentIndex] ?? null);
+      } else if (ReflectionParser._isEntityRef(value)) {
+        return Promise.resolve(this._resolveEntityByPath(value.entityPath));
+      } else if (ReflectionParser._isSignalRef(value)) {
+        return this.parseSignal(value);
+      } else if (originValue) {
+        const promises: Promise<any>[] = [];
+        for (let key in value as any) {
+          if (key === "methods") {
+            const methods: any = value[key];
+            for (let methodName in methods) {
+              const methodParams = methods[methodName];
+              for (let i = 0, count = methodParams.length; i < count; i++) {
+                const params = methodParams[i];
+                const promise = this.parseMethod(originValue, methodName, params);
+                promises.push(promise);
+              }
+            }
+          } else {
+            promises.push(this.parseBasicType(value[key], originValue[key]).then((v) => (originValue[key] = v)));
+          }
+        }
+        return Promise.all(promises).then(() => originValue);
+      }
     }
+    // primitive type
+    return Promise.resolve(value);
+  }
 
-    // $component — component reference: { entity, type, index }
-    if ("$component" in obj) {
-      return Promise.resolve(this._resolveComponent(obj.$component as ComponentRef));
-    }
+  private _getEntityByConfig(entityConfig: IEntity) {
+    // @ts-ignore
+    const assetUrl: string = entityConfig.assetUrl;
+    const engine = this._context.engine;
 
-    // $signal — signal binding: register listeners on the existing Signal instance
-    if ("$signal" in obj) {
-      return this._resolveSignal(originValue, obj.$signal as SignalListener[]);
+    if (assetUrl) {
+      return (
+        engine.resourceManager
+          // @ts-ignore
+          .getResourceByRef({
+            url: assetUrl,
+            key: (entityConfig as IRefEntity).key,
+            isClone: (entityConfig as IRefEntity).isClone
+          })
+          .then((entity) => {
+            // @ts-ignore
+            const resource = engine.resourceManager._objectPool[assetUrl];
+            if (resource && this._context.type === ParserType.Prefab) {
+              // @ts-ignore
+              this._context.resource._addDependenceAsset(resource);
+            }
+            entity.name = entityConfig.name;
+            return entity;
+          })
+      );
+    } else {
+      const transform = entityConfig.transform;
+      const entity = new Entity(engine, entityConfig.name, transform ? Loader.getClass(transform.class) : Transform);
+      return Promise.resolve(entity);
     }
+  }
 
-    // Plain object — recurse each value, modifying originValue in place or building a new object
-    const target =
-      originValue && typeof originValue === "object" && !Array.isArray(originValue)
-        ? originValue
-        : ({} as Record<string, unknown>);
-    const promises: Promise<any>[] = [];
-    for (const key in obj) {
-      promises.push(this._resolveValue(obj[key], target[key]).then((v) => (target[key] = v)));
+  private _resolveEntityByPath(entityPath: number[]): Entity | null {
+    const { rootIds, entityMap } = this._context;
+    if (!entityPath.length || entityPath[0] >= rootIds.length) return null;
+    let entity = entityMap.get(rootIds[entityPath[0]]);
+    for (let i = 1; i < entityPath.length; i++) {
+      if (!entity || entityPath[i] >= entity.children.length) return null;
+      entity = entity.children[entityPath[i]];
     }
-    return Promise.all(promises).then(() => target);
+    return entity;
   }
 
-  private _getRegisteredClass(value: unknown, sentinel: "$type" | "$class"): any {
-    if (typeof value !== "string" || value.length === 0) {
-      throw new Error(`${sentinel} must be a non-empty registered class name string`);
-    }
+  private static _isClass(value: any): value is IClass {
+    return value["class"] !== undefined;
+  }
 
-    const Class = Loader.getClass(value);
-    if (!Class) throw new Error(`Loader.getClass: class "${value}" is not registered`);
-    return Class;
+  private static _isClassType(value: any): value is IClassType {
+    return value["classType"] !== undefined;
   }
 
-  /** Promise-adapt {@link _getRegisteredClass} so $type/$class branches can fold into the resolver chain. */
-  private _resolveRegisteredClass(value: unknown, sentinel: "$type" | "$class"): Promise<any> {
-    try {
-      return Promise.resolve(this._getRegisteredClass(value, sentinel));
-    } catch (error) {
-      return Promise.reject(error);
-    }
+  private static _isAssetRef(value: any): value is IAssetRef {
+    return value["url"] !== undefined;
   }
 
-  private _resolveSignal(signal: any, listeners: SignalListener[]): Promise<any> {
-    if (!signal || typeof signal.on !== "function") {
-      return Promise.reject(new Error("$signal requires a pre-initialized Signal instance on the target property"));
-    }
-    const promises = listeners.map((listener) => {
-      const targetComponent = this._resolveComponent(listener.target.$component);
-      if (!targetComponent) return Promise.resolve();
+  private static _isEntityRef(value: any): value is IEntityRef {
+    return Array.isArray(value["entityPath"]) && value["componentType"] === undefined;
+  }
 
-      return Promise.all((listener.args ?? []).map((a) => this._resolveValue(a))).then((resolvedArgs) => {
-        signal.on(targetComponent, listener.methodName, ...resolvedArgs);
-      });
-    });
-    return Promise.all(promises).then(() => signal);
+  private static _isComponentRef(value: any): value is IComponentRef {
+    return Array.isArray(value["entityPath"]) && value["componentType"] !== undefined;
   }
 
-  private _resolveComponent(comp: ComponentRef): Component | null {
-    const entity = this._resolveEntityRef(comp.entity);
-    if (!entity) return null;
-    const type = Loader.getClass(comp.type);
-    if (!type) return null;
-    const buffer = ReflectionParser._componentBuffer;
-    buffer.length = 0;
-    entity.getComponents(type, buffer);
-    const result = buffer[comp.index] ?? null;
-    buffer.length = 0;
-    return result;
+  private static _isSignalRef(value: any): value is ISignalRef {
+    return value["listeners"] !== undefined;
   }
 
-  private _resolveEntityRef(path: number[]): Entity | null {
-    if (!path || path.length === 0) return null;
-    let entity = this._context.entityInstances[path[0]] ?? null;
-    for (let i = 1, n = path.length; entity && i < n; i++) {
-      entity = entity.children[path[i]] ?? null;
-    }
-    return entity;
+  private static _isMethodObject(value: any): value is IMethod {
+    return Array.isArray(value?.params);
   }
 }
diff --git a/packages/loader/src/resource-deserialize/resources/scene/SceneParser.ts b/packages/loader/src/resource-deserialize/resources/scene/SceneParser.ts
index c585251d69..48041b0ee0 100644
--- a/packages/loader/src/resource-deserialize/resources/scene/SceneParser.ts
+++ b/packages/loader/src/resource-deserialize/resources/scene/SceneParser.ts
@@ -1,13 +1,14 @@
-import { Scene } from "@galacean/engine-core";
-import type { SceneFile } from "../../../schema/SceneSchema";
+import { BackgroundMode, DiffuseMode, Scene } from "@galacean/engine-core";
 import { HierarchyParser } from "../parser/HierarchyParser";
 import { ParserContext } from "../parser/ParserContext";
+import { ReflectionParser } from "../parser/ReflectionParser";
+import { IHierarchyFile, IRefEntity, IStrippedEntity, SpecularMode, type IScene } from "../schema";
 
 /** @Internal */
-export class SceneParser extends HierarchyParser<Scene, ParserContext> {
+export class SceneParser extends HierarchyParser<Scene, ParserContext<IScene, Scene>> {
   constructor(
-    data: SceneFile,
-    context: ParserContext,
+    data: IScene,
+    context: ParserContext<IScene, Scene>,
     public readonly scene: Scene
   ) {
     super(data, context);
@@ -16,26 +17,91 @@ export class SceneParser extends HierarchyParser<Scene, ParserContext> {
   /**
    * @internal
    */
-  _collectDependentAssets(data: SceneFile): void {
+  _collectDependentAssets(data: IScene): void {
     const context = this.context;
     const resourceManager = context.resourceManager;
-    const refs = data.refs;
-    for (let i = 0, n = refs.length; i < n; i++) {
-      // @ts-ignore
-      context._addDependentAsset(resourceManager.getResourceByRef(refs[i]));
+    this._parseDependentAssets(data);
+    const scene = data.scene;
+    const ambient = scene.ambient;
+    if (ambient) {
+      const useCustomAmbient = ambient.specularMode === SpecularMode.Custom;
+      const useSH = ambient.diffuseMode === DiffuseMode.SphericalHarmonics;
+      const { customAmbientLight, ambientLight } = ambient;
+      if (useCustomAmbient && customAmbientLight) {
+        // @ts-ignore
+        context._addDependentAsset(customAmbientLight.url, resourceManager.getResourceByRef(customAmbientLight));
+      }
+      if (ambientLight && (!useCustomAmbient || useSH)) {
+        // @ts-ignore
+        context._addDependentAsset(ambientLight.url, resourceManager.getResourceByRef(ambientLight));
+      }
     }
-  }
 
-  protected override _getRootIndices(): number[] {
-    return (this.data as SceneFile).scene.rootEntities;
+    const background = scene.background;
+    const backgroundMode = background.mode;
+    if (backgroundMode === BackgroundMode.Texture) {
+      const texture = background.texture;
+      // @ts-ignore
+      texture && context._addDependentAsset(texture.url, resourceManager.getResourceByRef(texture));
+    } else if (backgroundMode === BackgroundMode.Sky) {
+      const { skyMesh, skyMaterial } = background;
+      if (skyMesh && skyMaterial) {
+        // @ts-ignore
+        context._addDependentAsset(skyMesh.url, resourceManager.getResourceByRef(skyMesh));
+        // @ts-ignore
+        context._addDependentAsset(skyMaterial.url, resourceManager.getResourceByRef(skyMaterial));
+      }
+    }
   }
 
-  protected override _handleRootEntity(index: number): void {
-    this.scene.addRootEntity(this.context.entityInstances[index]);
+  protected override _handleRootEntity(id: string): void {
+    const { entityMap } = this.context;
+    this.scene.addRootEntity(entityMap.get(id));
   }
 
   protected override _clearAndResolve() {
     this.context.clear();
     return this.scene;
   }
+
+  private _parseDependentAssets(file: IHierarchyFile): void {
+    const entities = file.entities;
+    for (let i = 0, n = entities.length; i < n; i++) {
+      const entity = entities[i];
+      if (!!(<IRefEntity>entity).assetUrl) {
+        const context = this.context;
+        const { assetUrl: url, key } = <IRefEntity>entity;
+        // @ts-ignore
+        context._addDependentAsset(url, context.resourceManager.getResourceByRef({ url, key }));
+      } else if ((<IStrippedEntity>entity).strippedId) {
+        continue;
+      } else {
+        const components = entity.components;
+        for (let j = 0, m = components.length; j < m; j++) {
+          const component = components[j];
+          this._searchDependentAssets(component.methods);
+          this._searchDependentAssets(component.props);
+        }
+      }
+    }
+  }
+
+  private _searchDependentAssets(value: any): void {
+    if (Array.isArray(value)) {
+      for (let i = 0, n = value.length; i < n; i++) {
+        this._searchDependentAssets(value[i]);
+      }
+    } else if (!!value && typeof value === "object") {
+      // @ts-ignore
+      if (ReflectionParser._isAssetRef(value)) {
+        const context = this.context;
+        // @ts-ignore
+        context._addDependentAsset(value.url, context.resourceManager.getResourceByRef(value));
+      } else {
+        for (let key in value) {
+          this._searchDependentAssets(value[key]);
+        }
+      }
+    }
+  }
 }
diff --git a/packages/loader/src/resource-deserialize/resources/schema/BasicSchema.ts b/packages/loader/src/resource-deserialize/resources/schema/BasicSchema.ts
new file mode 100644
index 0000000000..97be075674
--- /dev/null
+++ b/packages/loader/src/resource-deserialize/resources/schema/BasicSchema.ts
@@ -0,0 +1,122 @@
+import { Layer } from "@galacean/engine-core";
+
+export interface IVector3 {
+  x: number;
+  y: number;
+  z: number;
+}
+export interface IVector2 {
+  x: number;
+  y: number;
+}
+
+export interface IVector4 {
+  x: number;
+  y: number;
+  z: number;
+  w: number;
+}
+
+export interface IColor {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
+
+export interface IHierarchyFile {
+  entities: Array<IEntity>;
+}
+
+export type IMethod = {
+  params: Array<IBasicType>;
+  result?: IInstance;
+};
+
+export type IMethodParams = Array<IBasicType> | IMethod;
+
+export interface IBasicEntity {
+  name?: string;
+  id?: string;
+  transform?: IComponent;
+  components?: Array<IComponent>;
+  isActive?: boolean;
+  position?: IVector3;
+  rotation?: IVector3;
+  scale?: IVector3;
+  children?: Array<string>;
+  parent?: string;
+  layer?: Layer;
+}
+
+export type IEntity = IBasicEntity | IRefEntity | IStrippedEntity;
+
+export interface IRefEntity extends IBasicEntity {
+  assetUrl: string;
+  key?: string;
+  isClone?: boolean;
+  modifications: (IInstance & {
+    target: IPrefabModifyTarget;
+  })[];
+  removedEntities: IPrefabModifyTarget[];
+  removedComponents: IPrefabModifyTarget[];
+}
+
+export interface IPrefabModifyTarget {
+  entityId?: string;
+  componentId?: string;
+}
+
+export interface IStrippedEntity extends IBasicEntity {
+  strippedId: string;
+  prefabInstanceId: string;
+  prefabSource: { assetId: string; entityId: string };
+}
+
+export type IComponent = { id: string; url?: string } & IClass;
+
+export type IClass = {
+  class: string;
+  constructParams?: Array<IBasicType>;
+} & IInstance;
+
+export interface IInstance {
+  methods?: { [methodName: string]: Array<IMethodParams> };
+  props?: { [key: string]: IBasicType | IMethodParams };
+}
+
+export type IClassType = {
+  classType: string;
+};
+
+export type IBasicType =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | IAssetRef
+  | IClass
+  | IClassType
+  | IMethodParams
+  | IEntityRef
+  | IComponentRef
+  | ISignalRef;
+
+export type IAssetRef = { key?: string; url: string };
+
+export type IEntityRef = { entityPath: number[] };
+
+export type IComponentRef = {
+  entityPath: number[];
+  componentType: string;
+  componentIndex: number;
+};
+
+export type ISignalRef = {
+  listeners: Array<{
+    target: IComponentRef;
+    methodName: string;
+    arguments?: Array<IBasicType>;
+  }>;
+};
diff --git a/packages/loader/src/resource-deserialize/resources/schema/MaterialSchema.ts b/packages/loader/src/resource-deserialize/resources/schema/MaterialSchema.ts
new file mode 100644
index 0000000000..f2f6012918
--- /dev/null
+++ b/packages/loader/src/resource-deserialize/resources/schema/MaterialSchema.ts
@@ -0,0 +1,111 @@
+import {
+  BlendFactor,
+  BlendOperation,
+  ColorWriteMask,
+  CompareFunction,
+  CullMode,
+  RenderQueueType,
+  StencilOperation
+} from "@galacean/engine-core";
+import type { IAssetRef, IColor, IVector2, IVector3 } from "./BasicSchema";
+
+export interface IRenderState {
+  /** Blend state. */
+  blendState: {
+    /** The blend state of the render target. */
+    targetBlendState: {
+      /** Whether to enable blend. */
+      enabled: boolean;
+      /** color (RGB) blend operation. */
+      colorBlendOperation: BlendOperation;
+      /** alpha (A) blend operation. */
+      alphaBlendOperation: BlendOperation;
+      /** color blend factor (RGB) for source. */
+      sourceColorBlendFactor: BlendFactor;
+      /** alpha blend factor (A) for source. */
+      sourceAlphaBlendFactor: BlendFactor;
+      /** color blend factor (RGB) for destination. */
+      destinationColorBlendFactor: BlendFactor;
+      /** alpha blend factor (A) for destination. */
+      destinationAlphaBlendFactor: BlendFactor;
+      /** color mask. */
+      colorWriteMask: ColorWriteMask;
+    };
+    blendColor: IColor;
+    /** Whether to use (Alpha-to-Coverage) technology. */
+    alphaToCoverage: boolean;
+  };
+
+  /** Depth state. */
+  depthState: {
+    /** Whether to enable the depth test. */
+    enabled: boolean;
+    /** Whether the depth value can be written.*/
+    writeEnabled: boolean;
+    /** Depth comparison function. */
+    compareFunction: CompareFunction;
+  };
+  /** Stencil state. */
+  stencilState: {
+    /** Whether to enable stencil test. */
+    enabled: boolean;
+    /** Write the reference value of the stencil buffer. */
+    referenceValue: number;
+    /** Specifying a bit-wise mask that is used to AND the reference value and the stored stencil value when the test is done. */
+    mask: number;
+    /** Specifying a bit mask to enable or disable writing of individual bits in the stencil planes. */
+    writeMask: number;
+    /** The comparison function of the reference value of the front face of the geometry and the current buffer storage value. */
+    compareFunctionFront: CompareFunction;
+    /** The comparison function of the reference value of the back of the geometry and the current buffer storage value. */
+    compareFunctionBack: CompareFunction;
+    /** specifying the function to use for front face when both the stencil test and the depth test pass. */
+    passOperationFront: StencilOperation;
+    /** specifying the function to use for back face when both the stencil test and the depth test pass. */
+    passOperationBack: StencilOperation;
+    /** specifying the function to use for front face when the stencil test fails. */
+    failOperationFront: StencilOperation;
+    /** specifying the function to use for back face when the stencil test fails. */
+    failOperationBack: StencilOperation;
+    /** specifying the function to use for front face when the stencil test passes, but the depth test fails. */
+    zFailOperationFront: StencilOperation;
+    /** specifying the function to use for back face when the stencil test passes, but the depth test fails. */
+    zFailOperationBack: StencilOperation;
+  };
+  /** Raster state. */
+  rasterState: {
+    /** Specifies whether or not front- and/or back-facing polygons can be culled. */
+    cullMode: CullMode;
+    /** The multiplier by which an implementation-specific value is multiplied with to create a constant depth offset. */
+    depthBias: number;
+    /** The scale factor for the variable depth offset for each polygon. */
+    slopeScaledDepthBias: number;
+  };
+  /** Render queue type. */
+  renderQueueType: RenderQueueType;
+}
+
+export interface IMaterialSchema {
+  name: string;
+  shader: string;
+  shaderData: {
+    [key: string]: {
+      type: MaterialLoaderType;
+      value: IVector3 | IVector2 | IColor | number | IAssetRef;
+    };
+  };
+  macros: Array<{ name: string; value?: string }>;
+  renderState: IRenderState;
+  shaderRef: IAssetRef;
+}
+
+export enum MaterialLoaderType {
+  Vector2 = "Vector2",
+  Vector3 = "Vector3",
+  Vector4 = "Vector4",
+  Color = "Color",
+  Float = "Float",
+  Texture = "Texture",
+  Boolean = "Boolean",
+  Integer = "Integer"
+}
diff --git a/packages/loader/src/schema/ProjectSchema.ts b/packages/loader/src/resource-deserialize/resources/schema/ProjectSchema.ts
similarity index 100%
rename from packages/loader/src/schema/ProjectSchema.ts
rename to packages/loader/src/resource-deserialize/resources/schema/ProjectSchema.ts
diff --git a/packages/loader/src/resource-deserialize/resources/schema/SceneSchema.ts b/packages/loader/src/resource-deserialize/resources/schema/SceneSchema.ts
new file mode 100644
index 0000000000..1f64dcb87c
--- /dev/null
+++ b/packages/loader/src/resource-deserialize/resources/schema/SceneSchema.ts
@@ -0,0 +1,90 @@
+import {
+  BackgroundMode,
+  BackgroundTextureFillMode,
+  BloomDownScaleMode,
+  DiffuseMode,
+  FogMode,
+  ShadowCascadesMode,
+  ShadowResolution,
+  TonemappingMode
+} from "@galacean/engine-core";
+import type { IAssetRef, IColor, IHierarchyFile, IVector3 } from "./BasicSchema";
+
+export enum SpecularMode {
+  Sky = "Sky",
+  Custom = "Custom"
+}
+
+export interface IScene extends IHierarchyFile {
+  name?: string;
+  scene: {
+    background: {
+      mode: BackgroundMode;
+      color: IColor;
+      texture?: IAssetRef;
+      textureFillMode?: BackgroundTextureFillMode;
+      skyMesh?: IAssetRef;
+      skyMaterial?: IAssetRef;
+    };
+    ambient: {
+      diffuseMode: DiffuseMode;
+      ambientLight: IAssetRef;
+      customAmbientLight: IAssetRef;
+      customSpecularTexture: IAssetRef;
+      diffuseSolidColor: IColor;
+      diffuseIntensity: number;
+      specularIntensity: number;
+      specularMode: SpecularMode;
+      bakerResolution: number;
+    };
+    shadow?: {
+      castShadows: boolean;
+      enableTransparentShadow: boolean;
+      shadowResolution: ShadowResolution;
+      shadowDistance: number;
+      shadowCascades: ShadowCascadesMode;
+      shadowTwoCascadeSplits: number;
+      shadowFourCascadeSplits: IVector3;
+      shadowFadeBorder: number;
+    };
+    fog?: {
+      fogMode: FogMode;
+      fogStart: number;
+      fogEnd: number;
+      fogDensity: number;
+      fogColor: IColor;
+    };
+    physics?: {
+      gravity?: IVector3;
+      fixedTimeStep?: number;
+    };
+    postProcess?: {
+      isActive: boolean;
+      bloom: {
+        enabled: boolean;
+        downScale: BloomDownScaleMode;
+        threshold: number;
+        scatter: number;
+        intensity: number;
+        tint: IColor;
+        dirtTexture: IAssetRef;
+        dirtIntensity: number;
+      };
+      tonemapping: {
+        enabled: boolean;
+        mode: TonemappingMode;
+      };
+    };
+    ambientOcclusion?: {
+      bias: number;
+      bilateralThreshold: number;
+      enabledAmbientOcclusion: boolean;
+      intensity: number;
+      power: number;
+      quality: number;
+      radius: number;
+      minHorizonAngle: number;
+    };
+  };
+  files: Array<{ id: string; type: string; virtualPath: string; path: string }>;
+}
diff --git a/packages/loader/src/schema/index.ts b/packages/loader/src/resource-deserialize/resources/schema/index.ts
similarity index 56%
rename from packages/loader/src/schema/index.ts
rename to packages/loader/src/resource-deserialize/resources/schema/index.ts
index 457f1e9097..bac8725fc1 100644
--- a/packages/loader/src/schema/index.ts
+++ b/packages/loader/src/resource-deserialize/resources/schema/index.ts
@@ -1,7 +1,4 @@
-export * from "./CommonSchema";
-export * from "./HierarchySchema";
-export * from "./SceneSchema";
-export * from "./PrefabSchema";
 export * from "./BasicSchema";
 export * from "./MaterialSchema";
 export * from "./ProjectSchema";
+export * from "./SceneSchema";
diff --git a/packages/loader/src/resource-deserialize/resources/texture2D/Texture2DDecoder.ts b/packages/loader/src/resource-deserialize/resources/texture2D/Texture2DDecoder.ts
deleted file mode 100644
index c0061e89cd..0000000000
--- a/packages/loader/src/resource-deserialize/resources/texture2D/Texture2DDecoder.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { AssetPromise, Engine, Texture2D, TextureFormat } from "@galacean/engine-core";
-import { BufferReader } from "../../utils/BufferReader";
-import { decoder } from "../../utils/Decorator";
-import { HDRDecoder } from "../../../HDRDecoder";
-
-/**
- * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
- * [format(1B)] [width(2B)] [height(2B)] [isSRGBColorSpace(1B)] [Uint32(imageSize) + imageBytes]
- */
-@decoder("Texture2D")
-class Texture2DDecoder {
-  static decode(engine: Engine, bufferReader: BufferReader, restoredTexture?: Texture2D): AssetPromise<Texture2D> {
-    return new AssetPromise((resolve, reject) => {
-      const url = bufferReader.nextStr();
-      const mipmap = !!bufferReader.nextUint8();
-      const filterMode = bufferReader.nextUint8();
-      const anisoLevel = bufferReader.nextUint8();
-      const wrapModeU = bufferReader.nextUint8();
-      const wrapModeV = bufferReader.nextUint8();
-      const format = bufferReader.nextUint8();
-      const width = bufferReader.nextUint16();
-      const height = bufferReader.nextUint16();
-      const isSRGBColorSpace = !!bufferReader.nextUint8();
-
-      const imageData = bufferReader.nextImagesData(1)[0];
-
-      const isHDR = imageData[0] === 0x23 && imageData[1] === 0x3f;
-      const textureFormat = isHDR ? TextureFormat.R16G16B16A16 : format;
-      const texture =
-        restoredTexture ||
-        new Texture2D(engine, width, height, textureFormat, mipmap, isHDR ? false : isSRGBColorSpace);
-      texture.filterMode = filterMode;
-      texture.anisoLevel = anisoLevel;
-      texture.wrapModeU = wrapModeU;
-      texture.wrapModeV = wrapModeV;
-
-      if (isHDR) {
-        const { pixels } = HDRDecoder.decode(imageData);
-        texture.setPixelBuffer(pixels);
-        mipmap && texture.generateMipmaps();
-        resolve(texture);
-      } else {
-        const blob = new Blob([imageData]);
-        const img = new Image();
-        img.onload = () => {
-          URL.revokeObjectURL(img.src);
-          texture.setImageSource(img);
-          mipmap && texture.generateMipmaps();
-          resolve(texture);
-        };
-        img.onerror = (e) => {
-          URL.revokeObjectURL(img.src);
-          reject(e);
-        };
-        img.src = URL.createObjectURL(blob);
-      }
-    });
-  }
-}
diff --git a/packages/loader/src/resource-deserialize/resources/texture2D/TextureDecoder.ts b/packages/loader/src/resource-deserialize/resources/texture2D/TextureDecoder.ts
new file mode 100644
index 0000000000..05de1b8be2
--- /dev/null
+++ b/packages/loader/src/resource-deserialize/resources/texture2D/TextureDecoder.ts
@@ -0,0 +1,77 @@
+import { AssetPromise, Engine, Texture2D } from "@galacean/engine-core";
+import { BufferReader } from "../../utils/BufferReader";
+import { decoder } from "../../utils/Decorator";
+
+/**
+ * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
+ * [format(1B)] [width(2B)] [height(2B)] [isPixelBuffer(1B)] [isSRGBColorSpace(1B)] [mipCount(1B)] [imageData...]
+ */
+@decoder("Texture2D")
+export class Texture2DDecoder {
+  static decode(engine: Engine, bufferReader: BufferReader, restoredTexture?: Texture2D): AssetPromise<Texture2D> {
+    return new AssetPromise((resolve, reject) => {
+      const url = bufferReader.nextStr();
+      const mipmap = !!bufferReader.nextUint8();
+      const filterMode = bufferReader.nextUint8();
+      const anisoLevel = bufferReader.nextUint8();
+      const wrapModeU = bufferReader.nextUint8();
+      const wrapModeV = bufferReader.nextUint8();
+      const format = bufferReader.nextUint8();
+      const width = bufferReader.nextUint16();
+      const height = bufferReader.nextUint16();
+      const isPixelBuffer = bufferReader.nextUint8();
+      const isSRGBColorSpace = !!bufferReader.nextUint8();
+
+      const mipCount = bufferReader.nextUint8();
+      const imagesData = bufferReader.nextImagesData(mipCount);
+
+      const texture2D = restoredTexture || new Texture2D(engine, width, height, format, mipmap, isSRGBColorSpace);
+      texture2D.filterMode = filterMode;
+      texture2D.anisoLevel = anisoLevel;
+      texture2D.wrapModeU = wrapModeU;
+      texture2D.wrapModeV = wrapModeV;
+
+      if (isPixelBuffer) {
+        const pixelBuffer = imagesData[0];
+        texture2D.setPixelBuffer(pixelBuffer);
+        if (mipmap) {
+          texture2D.generateMipmaps();
+          for (let i = 1; i < mipCount; i++) {
+            const pixelBuffer = imagesData[i];
+            texture2D.setPixelBuffer(pixelBuffer, i);
+          }
+        }
+        // @ts-ignore
+        engine.resourceManager._objectPool[url] = texture2D;
+        resolve(texture2D);
+      } else {
+        const blob = new window.Blob([imagesData[0]]);
+        const img = new Image();
+        img.onload = () => {
+          texture2D.setImageSource(img);
+          let completedCount = 0;
+          const onComplete = () => {
+            completedCount++;
+            if (completedCount >= mipCount) {
+              resolve(texture2D);
+            }
+          };
+          onComplete();
+          if (mipmap) {
+            texture2D.generateMipmaps();
+            for (let i = 1; i < mipCount; i++) {
+              const blob = new window.Blob([imagesData[i]]);
+              const img = new Image();
+              img.onload = () => {
+                texture2D.setImageSource(img, i);
+                onComplete();
+              };
+              img.src = URL.createObjectURL(blob);
+            }
+          }
+        };
+        img.src = URL.createObjectURL(blob);
+      }
+    });
+  }
+}
diff --git a/packages/loader/src/resource-deserialize/resources/textureCube/TextureCubeDecoder.ts b/packages/loader/src/resource-deserialize/resources/textureCube/TextureCubeDecoder.ts
deleted file mode 100644
index 9b8aad970d..0000000000
--- a/packages/loader/src/resource-deserialize/resources/textureCube/TextureCubeDecoder.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-import { AssetPromise, Engine, TextureCube, TextureCubeFace, TextureFormat } from "@galacean/engine-core";
-import { BufferReader } from "../../utils/BufferReader";
-import { decoder } from "../../utils/Decorator";
-import { HDRDecoder } from "../../../HDRDecoder";
-
-/**
- * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
- * [format(1B)] [faceSize(2B)] [isSRGBColorSpace(1B)] [Uint32(size) + faceBytes] × 6
- */
-@decoder("TextureCube")
-class TextureCubeDecoder {
-  static decode(engine: Engine, bufferReader: BufferReader, restoredTexture?: TextureCube): AssetPromise<TextureCube> {
-    return new AssetPromise((resolve, reject) => {
-      const url = bufferReader.nextStr();
-      const mipmap = !!bufferReader.nextUint8();
-      const filterMode = bufferReader.nextUint8();
-      const anisoLevel = bufferReader.nextUint8();
-      const wrapModeU = bufferReader.nextUint8();
-      const wrapModeV = bufferReader.nextUint8();
-      const format = bufferReader.nextUint8();
-      const faceSize = bufferReader.nextUint16();
-      const isSRGBColorSpace = !!bufferReader.nextUint8();
-
-      const facesData = bufferReader.nextImagesData(6);
-
-      // Detect format by first face's magic bytes
-      const isHDR = facesData[0][0] === 0x23 && facesData[0][1] === 0x3f;
-      const textureFormat = isHDR ? TextureFormat.R16G16B16A16 : format;
-      const texture = restoredTexture || new TextureCube(engine, faceSize, textureFormat, mipmap, isSRGBColorSpace);
-      texture.filterMode = filterMode;
-      texture.anisoLevel = anisoLevel;
-      texture.wrapModeU = wrapModeU;
-      texture.wrapModeV = wrapModeV;
-
-      if (isHDR) {
-        for (let i = 0; i < 6; i++) {
-          const { pixels } = HDRDecoder.decode(facesData[i]);
-          texture.setPixelBuffer(TextureCubeFace.PositiveX + i, pixels, 0);
-        }
-        mipmap && texture.generateMipmaps();
-        resolve(texture);
-      } else {
-        let loadedCount = 0;
-        for (let i = 0; i < 6; i++) {
-          const blob = new Blob([facesData[i]]);
-          const img = new Image();
-          img.onload = () => {
-            URL.revokeObjectURL(img.src);
-            texture.setImageSource(TextureCubeFace.PositiveX + i, img);
-            if (++loadedCount === 6) {
-              mipmap && texture.generateMipmaps();
-              resolve(texture);
-            }
-          };
-          img.onerror = (e) => {
-            URL.revokeObjectURL(img.src);
-            reject(e);
-          };
-          img.src = URL.createObjectURL(blob);
-        }
-      }
-    });
-  }
-}
diff --git a/packages/loader/src/schema/BasicSchema.ts b/packages/loader/src/schema/BasicSchema.ts
deleted file mode 100644
index 8389190515..0000000000
--- a/packages/loader/src/schema/BasicSchema.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-export interface IVector3 {
-  x: number;
-  y: number;
-  z: number;
-}
-
-export interface IVector2 {
-  x: number;
-  y: number;
-}
-
-export interface IVector4 {
-  x: number;
-  y: number;
-  z: number;
-  w: number;
-}
-
-export interface IColor {
-  r: number;
-  g: number;
-  b: number;
-  a: number;
-}
diff --git a/packages/loader/src/schema/CommonSchema.ts b/packages/loader/src/schema/CommonSchema.ts
deleted file mode 100644
index ae61dc8ce4..0000000000
--- a/packages/loader/src/schema/CommonSchema.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-export type Vec3Tuple = [number, number, number];
-export type Vec4Tuple = [number, number, number, number];
-
-export interface RefItem {
-  url: string;
-  key?: string;
-}
-
-/** path[0] = flat index into top-level entities[]; subsequent indices descend via children. */
-export type EntityRef = number[];
-
-export interface ComponentRef {
-  entity: EntityRef;
-  type: string;
-  index: number;
-}
-
-/** Reference to a registered runtime class constructor. */
-export interface ClassRef {
-  $class: string;
-}
-
-export interface SignalListener {
-  target: { $component: ComponentRef };
-  methodName: string;
-  args?: unknown[];
-}
-
-export interface CallSpec {
-  method: string;
-  args?: unknown[];
-  result?: MutationBlock;
-}
-
-export interface MutationBlock {
-  props?: Record<string, unknown>;
-  calls?: CallSpec[];
-}
diff --git a/packages/loader/src/schema/HierarchySchema.ts b/packages/loader/src/schema/HierarchySchema.ts
deleted file mode 100644
index c26afb70a5..0000000000
--- a/packages/loader/src/schema/HierarchySchema.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import type { MutationBlock, RefItem, Vec3Tuple } from "./CommonSchema";
-
-export interface ComponentSchema extends MutationBlock {
-  type: string;
-  script?: number;
-}
-
-export interface EntityOverrideProps {
-  name?: string;
-  isActive?: boolean;
-  layer?: number;
-  position?: Vec3Tuple;
-  rotation?: Vec3Tuple;
-  scale?: Vec3Tuple;
-}
-
-export interface AddedEntityOverride {
-  /** Parent path from prefab instance root via children indices. `[]` = instance root. */
-  parent: number[];
-  /** Index into the top-level entities[] array. */
-  entity: number;
-}
-
-export interface AddedComponentOverride {
-  /** Target entity path from prefab instance root via children indices. `[]` = instance root. */
-  target: number[];
-  /** Index into the top-level components[] array. */
-  component: number;
-}
-
-export interface EntityPropOverride extends EntityOverrideProps {
-  /** Path from prefab instance root via children indices. `[]` = instance root. */
-  path: number[];
-}
-
-export interface ComponentSelector {
-  type: string;
-  index: number;
-}
-
-export interface ComponentOverride extends MutationBlock {
-  /** Path from prefab instance root via children indices. `[]` = instance root. */
-  path: number[];
-  selector: ComponentSelector;
-}
-
-export interface RemovedComponentOverride {
-  /** Path from prefab instance root via children indices. `[]` = instance root. */
-  path: number[];
-  selectors: ComponentSelector[];
-}
-
-export interface InstanceOverrides {
-  entityProps?: EntityPropOverride[];
-  componentProps?: ComponentOverride[];
-  /** Each element is a path from prefab instance root via children indices. */
-  removedEntities?: number[][];
-  removedComponents?: RemovedComponentOverride[];
-  addedEntities?: AddedEntityOverride[];
-  addedComponents?: AddedComponentOverride[];
-}
-
-export interface InstanceSchema {
-  asset: number;
-  overrides?: InstanceOverrides;
-}
-
-export interface NormalEntitySchema extends EntityOverrideProps {
-  children?: number[];
-  components?: number[];
-}
-
-export interface PrefabInstanceEntitySchema {
-  instance: InstanceSchema;
-}
-
-export type EntitySchema = NormalEntitySchema | PrefabInstanceEntitySchema;
-
-/** Common base for v2 scene and prefab files. */
-export interface HierarchyFile {
-  version: "2.0";
-  refs: RefItem[];
-  entities: EntitySchema[];
-  components: ComponentSchema[];
-}
diff --git a/packages/loader/src/schema/MaterialSchema.ts b/packages/loader/src/schema/MaterialSchema.ts
deleted file mode 100644
index 6f0128d052..0000000000
--- a/packages/loader/src/schema/MaterialSchema.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import type { RefItem } from "./CommonSchema";
-import type { IColor, IVector2, IVector3 } from "./BasicSchema";
-
-export interface IMaterialSchema {
-  name: string;
-  shader: string;
-  shaderData: {
-    [key: string]: {
-      type: MaterialLoaderType;
-      value: IVector3 | IVector2 | IColor | number | RefItem;
-    };
-  };
-  macros: Array<{ name: string; value?: string }>;
-  shaderRef: RefItem;
-}
-
-export enum MaterialLoaderType {
-  Vector2 = "Vector2",
-  Vector3 = "Vector3",
-  Vector4 = "Vector4",
-  Color = "Color",
-  Float = "Float",
-  Texture = "Texture",
-  Boolean = "Boolean",
-  Integer = "Integer"
-}
diff --git a/packages/loader/src/schema/PrefabSchema.ts b/packages/loader/src/schema/PrefabSchema.ts
deleted file mode 100644
index b779cee508..0000000000
--- a/packages/loader/src/schema/PrefabSchema.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import type { HierarchyFile } from "./HierarchySchema";
-
-export interface PrefabFile extends HierarchyFile {
-  root: number;
-}
diff --git a/packages/loader/src/schema/SceneSchema.ts b/packages/loader/src/schema/SceneSchema.ts
deleted file mode 100644
index 659f4b6186..0000000000
--- a/packages/loader/src/schema/SceneSchema.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import {
-  BackgroundMode,
-  BackgroundTextureFillMode,
-  DiffuseMode,
-  FogMode,
-  ShadowCascadesMode,
-  ShadowResolution
-} from "@galacean/engine-core";
-import type { HierarchyFile } from "./HierarchySchema";
-import type { Vec3Tuple, Vec4Tuple } from "./CommonSchema";
-
-export enum SpecularMode {
-  Sky = 0,
-  Custom = 1
-}
-
-export interface SceneFile extends HierarchyFile {
-  scene: {
-    name?: string;
-    rootEntities: number[];
-    background: {
-      mode: BackgroundMode;
-      color: Vec4Tuple;
-      texture?: number;
-      textureFillMode?: BackgroundTextureFillMode;
-      skyMesh?: number;
-      skyMaterial?: number;
-    };
-    ambient?: {
-      diffuseMode: DiffuseMode;
-      ambientLight?: number;
-      customAmbientLight?: number;
-      diffuseSolidColor?: Vec4Tuple;
-      diffuseIntensity: number;
-      specularIntensity: number;
-      specularMode: SpecularMode;
-    };
-    shadow?: {
-      castShadows?: boolean;
-      enableTransparentShadow?: boolean;
-      shadowResolution?: ShadowResolution;
-      shadowDistance?: number;
-      shadowCascades?: ShadowCascadesMode;
-      shadowTwoCascadeSplits?: number;
-      shadowFourCascadeSplits?: Vec3Tuple;
-      shadowFadeBorder?: number;
-    };
-    fog?: {
-      fogMode?: FogMode;
-      fogStart?: number;
-      fogEnd?: number;
-      fogDensity?: number;
-      fogColor?: Vec4Tuple;
-    };
-    ambientOcclusion?: {
-      enabledAmbientOcclusion?: boolean;
-      quality?: number;
-      intensity?: number;
-      radius?: number;
-      bias?: number;
-      power?: number;
-      bilateralThreshold?: number;
-      minHorizonAngle?: number;
-    };
-    /** Not supported in scene yet; presence triggers a warning. */
-    postProcess?: unknown;
-  };
-}
diff --git a/packages/loader/src/schema/refs.ts b/packages/loader/src/schema/refs.ts
deleted file mode 100644
index 5a8fc38cc9..0000000000
--- a/packages/loader/src/schema/refs.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import type { RefItem } from "./CommonSchema";
-
-export function resolveRefItem(refs: RefItem[], index: number, owner: string, label: string): RefItem {
-  if (!Number.isInteger(index) || index < 0 || index >= refs.length) {
-    throw new Error(`${owner}: invalid ref index ${index} for ${label}`);
-  }
-
-  return refs[index];
-}
diff --git a/packages/physics-lite/package.json b/packages/physics-lite/package.json
index bc58a8decf..9eaa1e74c4 100644
--- a/packages/physics-lite/package.json
+++ b/packages/physics-lite/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-physics-lite",
-  "version": "2.0.0-alpha.33",
+  "version": "0.0.0-experimental-2.0-game.14",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
diff --git a/packages/physics-lite/src/LitePhysicsMaterial.ts b/packages/physics-lite/src/LitePhysicsMaterial.ts
index 7983beb394..de1a0dee53 100644
--- a/packages/physics-lite/src/LitePhysicsMaterial.ts
+++ b/packages/physics-lite/src/LitePhysicsMaterial.ts
@@ -2,8 +2,16 @@ import { IPhysicsMaterial } from "@galacean/engine-design";
 
 /**
  * Physics material describes how to handle colliding objects (friction, bounciness).
+ *
+ * Physics-lite does not implement material effects; setters are no-ops (matching
+ * the convention used by `LiteColliderShape.setMaterial/setContactOffset/setIsTrigger`).
+ * This lets engine-side state changes (including clone `_syncNative` re-writes) flow
+ * through without crashing while still leaving a one-time hint via console.log on
+ * the first write so users notice the limitation.
  */
 export class LitePhysicsMaterial implements IPhysicsMaterial {
+  private static _warned = false;
+
   constructor(
     staticFriction: number,
     dynamicFriction: number,
@@ -16,39 +24,45 @@ export class LitePhysicsMaterial implements IPhysicsMaterial {
    * {@inheritDoc IPhysicsMaterial.setBounciness }
    */
   setBounciness(value: number): void {
-    throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    LitePhysicsMaterial._warnOnce();
   }
 
   /**
    * {@inheritDoc IPhysicsMaterial.setDynamicFriction }
    */
   setDynamicFriction(value: number): void {
-    throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    LitePhysicsMaterial._warnOnce();
   }
 
   /**
    * {@inheritDoc IPhysicsMaterial.setStaticFriction }
    */
   setStaticFriction(value: number): void {
-    throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    LitePhysicsMaterial._warnOnce();
   }
 
   /**
    * {@inheritDoc IPhysicsMaterial.setBounceCombine }
    */
   setBounceCombine(value: number): void {
-    throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    LitePhysicsMaterial._warnOnce();
   }
 
   /**
    * {@inheritDoc IPhysicsMaterial.setFrictionCombine }
    */
   setFrictionCombine(value: number): void {
-    throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    LitePhysicsMaterial._warnOnce();
   }
 
   /**
    * {@inheritDoc IPhysicsMaterial.destroy }
    */
   destroy(): void {}
+
+  private static _warnOnce(): void {
+    if (LitePhysicsMaterial._warned) return;
+    LitePhysicsMaterial._warned = true;
+    console.log("Physics-lite don't support physics material. Use Physics-PhysX instead!");
+  }
 }
diff --git a/packages/physics-physx/package.json b/packages/physics-physx/package.json
index b545c794fc..d97107856f 100644
--- a/packages/physics-physx/package.json
+++ b/packages/physics-physx/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-physics-physx",
-  "version": "2.0.0-alpha.33",
+  "version": "0.0.0-experimental-2.0-game.14",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
diff --git a/packages/physics-physx/src/PhysXDynamicCollider.ts b/packages/physics-physx/src/PhysXDynamicCollider.ts
index 31510ae2de..05614dd5bf 100644
--- a/packages/physics-physx/src/PhysXDynamicCollider.ts
+++ b/packages/physics-physx/src/PhysXDynamicCollider.ts
@@ -24,6 +24,20 @@ export class PhysXDynamicCollider extends PhysXCollider implements IDynamicColli
   private static _tempTranslation = new Vector3();
   private static _tempRotation = new Quaternion();
 
+  /**
+   * Whether actor is currently kinematic.
+   * PhysX 拒绝在 kinematic actor 上启用 CCD（会打印警告并忽略），
+   * 所以 setCollisionDetectionMode 在 kinematic 状态下只缓存目标值，
+   * 等切回 dynamic 时再真正写到 PhysX。
+   */
+  private _isKinematic: boolean = false;
+
+  /**
+   * Cached collision detection mode. Always reflects user's intent.
+   * 实际 PhysX CCD flag 可能跟这个不一致（kinematic 时强制 Discrete）。
+   */
+  private _collisionDetectionMode: number = CollisionDetectionMode.Discrete;
+
   constructor(physXPhysics: PhysXPhysics, position: Vector3, rotation: Quaternion) {
     super(physXPhysics);
     const transform = this._transform(position, rotation);
@@ -158,10 +172,52 @@ export class PhysXDynamicCollider extends PhysXCollider implements IDynamicColli
 
   /**
    * {@inheritDoc IDynamicCollider.setCollisionDetectionMode }
+   *
+   * PhysX 在 kinematic actor 上调用 setRigidBodyFlag(eENABLE_CCD, true) 会触发警告:
+   *   "kinematic bodies with CCD enabled are not supported! CCD will be ignored"
+   * 虽然 PhysX 会忽略这次调用而非真的拒绝（切回 dynamic 时 flag 不会自动恢复），
+   * 但每次 setIsKinematic 切换都会让这个 warning 重复打印，污染日志，
+   * 同时让 actor 在 dynamic 状态下 CCD flag 状态不确定。
+   *
+   * 解决: 只在 dynamic 状态时立即 apply CCD flags。kinematic 时仅缓存到
+   * `_collisionDetectionMode`，等切回 dynamic 时由 setIsKinematic 重新 apply。
    */
   setCollisionDetectionMode(value: number): void {
+    this._collisionDetectionMode = value;
+    if (!this._isKinematic) {
+      this._applyCollisionDetectionFlags(value);
+    }
+  }
+
+  /**
+   * {@inheritDoc IDynamicCollider.setUseGravity }
+   */
+  setUseGravity(value: boolean): void {
+    this._pxActor.setActorFlag(this._physXPhysics._physX.PxActorFlag.eDISABLE_GRAVITY, !value);
+  }
+
+  /**
+   * {@inheritDoc IDynamicCollider.setIsKinematic }
+   *
+   * 切换 kinematic 状态时同步处理 CCD flag：
+   *   - 切到 kinematic 前先关 CCD（避免 PhysX 警告 + 让状态显式）
+   *   - 切回 dynamic 后恢复用户期望的 CCD mode（来自 `_collisionDetectionMode` 缓存）
+   */
+  setIsKinematic(value: boolean): void {
+    if (this._isKinematic === value) return;
     const physX = this._physXPhysics._physX;
+    if (value) {
+      this._applyCollisionDetectionFlags(CollisionDetectionMode.Discrete);
+      this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eKINEMATIC, true);
+    } else {
+      this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eKINEMATIC, false);
+      this._applyCollisionDetectionFlags(this._collisionDetectionMode);
+    }
+    this._isKinematic = value;
+  }
 
+  private _applyCollisionDetectionFlags(value: number): void {
+    const physX = this._physXPhysics._physX;
     switch (value) {
       case CollisionDetectionMode.Continuous:
         this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, true);
@@ -186,24 +242,6 @@ export class PhysXDynamicCollider extends PhysXCollider implements IDynamicColli
     }
   }
 
-  /**
-   * {@inheritDoc IDynamicCollider.setUseGravity }
-   */
-  setUseGravity(value: boolean): void {
-    this._pxActor.setActorFlag(this._physXPhysics._physX.PxActorFlag.eDISABLE_GRAVITY, !value);
-  }
-
-  /**
-   * {@inheritDoc IDynamicCollider.setIsKinematic }
-   */
-  setIsKinematic(value: boolean): void {
-    if (value) {
-      this._pxActor.setRigidBodyFlag(this._physXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, true);
-    } else {
-      this._pxActor.setRigidBodyFlag(this._physXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, false);
-    }
-  }
-
   /**
    * {@inheritDoc IDynamicCollider.setConstraints }
    */
@@ -213,34 +251,52 @@ export class PhysXDynamicCollider extends PhysXCollider implements IDynamicColli
 
   /**
    * {@inheritDoc IDynamicCollider.addForce }
+   *
+   * PhysX 在 kinematic actor 上调 addForce 是 no-op（doc: "kinematic bodies don't
+   * respond to forces"）。提前 return 避免无意义的 wasm boundary cross。
+   *
+   * Sleeping actor 不需要显式 wakeUp — wasm binding 调用 `addForce(force, eFORCE,
+   * autowake=true)`，PhysX 自动唤醒（已通过 `applyForce on sleeping actor` 测试验证）。
    */
   addForce(force: Vector3) {
+    if (this._isKinematic) return;
     this._pxActor.addForce({ x: force.x, y: force.y, z: force.z });
   }
 
   /**
    * {@inheritDoc IDynamicCollider.addTorque }
+   *
+   * 同 addForce — kinematic 提前 return，sleeping 由 PhysX autowake 自动处理。
    */
   addTorque(torque: Vector3) {
+    if (this._isKinematic) return;
     this._pxActor.addTorque({ x: torque.x, y: torque.y, z: torque.z });
   }
 
   /**
    * {@inheritDoc IDynamicCollider.move }
+   *
+   * PhysX 要求 setKinematicTarget 的 rotation 是 normalized quaternion，否则会触发
+   * 内部 assertion / 警告，并把 actor 转到错误的姿态。所以在写入 wasm 边界前统一 normalize。
    */
   move(positionOrRotation: Vector3 | Quaternion, rotation?: Quaternion): void {
+    const tempTranslation = PhysXDynamicCollider._tempTranslation;
+    const tempRotation = PhysXDynamicCollider._tempRotation;
+
     if (rotation) {
-      this._pxActor.setKinematicTarget(positionOrRotation, rotation);
+      tempRotation.copyFrom(rotation).normalize();
+      this._pxActor.setKinematicTarget(positionOrRotation, tempRotation);
       return;
     }
 
-    const tempTranslation = PhysXDynamicCollider._tempTranslation;
-    const tempRotation = PhysXDynamicCollider._tempRotation;
-    this.getWorldTransform(tempTranslation, tempRotation);
     if (positionOrRotation instanceof Vector3) {
+      this.getWorldTransform(tempTranslation, tempRotation);
+      // current rotation read from PhysX is already normalized; no extra work needed
       this._pxActor.setKinematicTarget(positionOrRotation, tempRotation);
     } else {
-      this._pxActor.setKinematicTarget(tempTranslation, positionOrRotation);
+      this.getWorldTransform(tempTranslation, tempRotation);
+      tempRotation.copyFrom(positionOrRotation).normalize();
+      this._pxActor.setKinematicTarget(tempTranslation, tempRotation);
     }
   }
 
diff --git a/packages/physics-physx/src/PhysXPhysics.ts b/packages/physics-physx/src/PhysXPhysics.ts
index 6c5d788aa1..867ee68dff 100644
--- a/packages/physics-physx/src/PhysXPhysics.ts
+++ b/packages/physics-physx/src/PhysXPhysics.ts
@@ -57,13 +57,26 @@ export class PhysXPhysics implements IPhysics {
   private _tolerancesScale: any;
   private _wasmSIMDModeUrl: string;
   private _wasmModeUrl: string;
+  private _tolerancesScaleOptions: PhysXTolerancesScale | undefined;
+  private _defaultContactOffset = 0.02;
+  private _defaultSleepThreshold = 5e-3;
 
   /**
    * Create a PhysXPhysics instance.
    * @param runtimeMode - Runtime mode, `Auto` prefers WebAssembly SIMD if supported @see {@link PhysXRuntimeMode}
    * @param runtimeUrls - Manually specify the runtime URLs
+   * @param options - PhysX options.
    */
-  constructor(runtimeMode: PhysXRuntimeMode = PhysXRuntimeMode.Auto, runtimeUrls?: PhysXRuntimeUrls) {
+  constructor(runtimeMode?: PhysXRuntimeMode, runtimeUrls?: PhysXRuntimeUrls, options?: PhysXPhysicsOptions);
+  constructor(options?: PhysXPhysicsOptions);
+  constructor(
+    runtimeModeOrOptions: PhysXRuntimeMode | PhysXPhysicsOptions = PhysXRuntimeMode.Auto,
+    runtimeUrls?: PhysXRuntimeUrls,
+    options?: PhysXPhysicsOptions
+  ) {
+    const isOptionsObject = typeof runtimeModeOrOptions === "object";
+    const runtimeMode = isOptionsObject ? PhysXRuntimeMode.Auto : (runtimeModeOrOptions ?? PhysXRuntimeMode.Auto);
+    const resolvedOptions = isOptionsObject ? runtimeModeOrOptions : options;
     this._runTimeMode = runtimeMode;
     this._wasmSIMDModeUrl =
       runtimeUrls?.wasmSIMDModeUrl ??
@@ -71,6 +84,8 @@ export class PhysXPhysics implements IPhysics {
     this._wasmModeUrl =
       runtimeUrls?.wasmModeUrl ??
       "https://mdn.alipayobjects.com/rms/afts/file/A*DFuvR6Mv5C0AAAAAQ4AAAAgAehQnAQ/physx.release.js";
+    this._tolerancesScaleOptions = resolvedOptions?.tolerancesScale;
+    this._updateScaledDefaults(this._tolerancesScaleOptions?.length ?? 1, this._tolerancesScaleOptions?.speed ?? 10);
   }
 
   /**
@@ -156,6 +171,20 @@ export class PhysXPhysics implements IPhysics {
     return scene;
   }
 
+  /**
+   * {@inheritDoc IPhysics.getDefaultContactOffset }
+   */
+  getDefaultContactOffset(): number {
+    return this._defaultContactOffset;
+  }
+
+  /**
+   * {@inheritDoc IPhysics.getDefaultSleepThreshold }
+   */
+  getDefaultSleepThreshold(): number {
+    return this._defaultSleepThreshold;
+  }
+
   /**
    * {@inheritDoc IPhysics.createStaticCollider }
    */
@@ -279,6 +308,7 @@ export class PhysXPhysics implements IPhysics {
     const allocator = new physX.PxDefaultAllocator();
     const pxFoundation = physX.PxCreateFoundation(version, allocator, defaultErrorCallback);
     const tolerancesScale = new physX.PxTolerancesScale();
+    this._applyTolerancesScale(tolerancesScale);
     const pxPhysics = physX.PxCreatePhysics(version, pxFoundation, tolerancesScale, false, null);
 
     physX.PxInitExtensions(pxPhysics, null);
@@ -302,6 +332,29 @@ export class PhysXPhysics implements IPhysics {
     this._allocator = allocator;
     this._tolerancesScale = tolerancesScale;
   }
+
+  private _applyTolerancesScale(tolerancesScale: any): void {
+    const length = this._tolerancesScaleOptions?.length ?? tolerancesScale.length;
+    const speed = this._tolerancesScaleOptions?.speed ?? tolerancesScale.speed;
+
+    this._assertPositiveFinite(length, "tolerancesScale.length");
+    this._assertPositiveFinite(speed, "tolerancesScale.speed");
+
+    tolerancesScale.length = length;
+    tolerancesScale.speed = speed;
+    this._updateScaledDefaults(length, speed);
+  }
+
+  private _assertPositiveFinite(value: number, name: string): void {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`PhysXPhysics ${name} must be a positive finite number.`);
+    }
+  }
+
+  private _updateScaledDefaults(length: number, speed: number): void {
+    this._defaultContactOffset = 0.02 * length;
+    this._defaultSleepThreshold = 5e-5 * speed * speed;
+  }
 }
 
 enum InitializeState {
@@ -316,3 +369,15 @@ interface PhysXRuntimeUrls {
   /*** The URL of `PhysXRuntimeMode.WebAssemblySIMD` mode. */
   wasmSIMDModeUrl?: string;
 }
+
+export interface PhysXTolerancesScale {
+  /** Approximate object length in the simulation unit. PhysX default is 1. */
+  length?: number;
+  /** Typical object speed in the simulation unit. PhysX default is 10. */
+  speed?: number;
+}
+
+export interface PhysXPhysicsOptions {
+  /** PhysX world unit scale used before PxPhysics, PxSceneDesc and PxCookingParams are created. */
+  tolerancesScale?: PhysXTolerancesScale;
+}
diff --git a/packages/physics-physx/src/shape/PhysXColliderShape.ts b/packages/physics-physx/src/shape/PhysXColliderShape.ts
index ea5a3df8b4..61b9fdf6a3 100644
--- a/packages/physics-physx/src/shape/PhysXColliderShape.ts
+++ b/packages/physics-physx/src/shape/PhysXColliderShape.ts
@@ -56,6 +56,7 @@ export abstract class PhysXColliderShape implements IColliderShape {
 
   constructor(physXPhysics: PhysXPhysics) {
     this._physXPhysics = physXPhysics;
+    this._contractOffset = physXPhysics.getDefaultContactOffset();
   }
 
   /**
diff --git a/tests/src/core/Animator.test.ts b/tests/src/core/Animator.test.ts
index 9544a7591e..22fe8b110b 100644
--- a/tests/src/core/Animator.test.ts
+++ b/tests/src/core/Animator.test.ts
@@ -20,8 +20,8 @@ import {
 } from "@galacean/engine-core";
 import "@galacean/engine-loader";
 import type { GLTFResource } from "@galacean/engine-loader";
-import { Quaternion, Vector3 } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine";
+import { Quaternion } from "@galacean/engine-math";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
 import { glbResource } from "./model/fox";
 const canvasDOM = document.createElement("canvas");
@@ -70,18 +70,16 @@ describe("Animator test", function () {
     stateMachine.clearAnyStateTransitions();
     stateMachine.clearEntryStateTransitions();
 
-    // 清理各状态的 transitions 并恢复默认属性 (mutate shared AnimatorState)
+    // 清理各状态的 transitions 并恢复默认属性
     const stateNames = ["Survey", "Walk", "Run"];
     for (const name of stateNames) {
-      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();
+      const state = animator.findAnimatorState(name);
+      if (state) {
+        state.clearTransitions();
+        state.speed = 1;
+        state.clipStartTime = 0;
+        state.clipEndTime = 1;
+        state.wrapMode = WrapMode.Loop;
       }
     }
   });
@@ -198,9 +196,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);
@@ -208,7 +206,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", () => {
@@ -240,6 +238,89 @@ describe("Animator test", function () {
     expect(layerState).to.eq(2);
   });
 
+  it("crossFade advances with per-instance playData speed instead of shared AnimatorState speed", () => {
+    const sharedStates = animator.animatorController.layers[0].stateMachine.states;
+    const sharedWalkState = sharedStates.find((state) => state.name === "Walk");
+    const sharedRunState = sharedStates.find((state) => state.name === "Run");
+    const oldWalkSpeed = sharedWalkState.speed;
+    const oldRunSpeed = sharedRunState.speed;
+
+    try {
+      animator.play("Walk");
+      animator.crossFade("Run", 1.0, 0);
+
+      const layerData = animator["_animatorLayersData"][0];
+      layerData.srcPlayData.speed = 0.25;
+      layerData.destPlayData.speed = 0.25;
+      sharedWalkState.speed = 10;
+      sharedRunState.speed = 10;
+
+      const srcPlayedTime = layerData.srcPlayData.playedTime;
+      const destPlayedTime = layerData.destPlayData.playedTime;
+      // @ts-ignore
+      animator.engine.time._frameCount++;
+      animator.update(0.2);
+
+      expect(layerData.srcPlayData.playedTime - srcPlayedTime).toBeCloseTo(0.05, 5);
+      expect(layerData.destPlayData.playedTime - destPlayedTime).toBeCloseTo(0.05, 5);
+    } finally {
+      sharedWalkState.speed = oldWalkSpeed;
+      sharedRunState.speed = oldRunSpeed;
+    }
+  });
+
+  it("playData wrapMode overrides shared AnimatorState wrapMode per instance", () => {
+    const sharedWalkState = animator.animatorController.layers[0].stateMachine.states.find(
+      (state) => state.name === "Walk"
+    );
+    const oldWrapMode = sharedWalkState.wrapMode;
+
+    try {
+      sharedWalkState.wrapMode = WrapMode.Loop;
+      animator.play("Walk");
+
+      const layerData = animator["_animatorLayersData"][0];
+      const playData = layerData.srcPlayData;
+      playData.wrapMode = WrapMode.Once;
+
+      expect(sharedWalkState.wrapMode).to.eq(WrapMode.Loop);
+
+      // @ts-ignore
+      animator.engine.time._frameCount++;
+      animator.update(playData.state.clip.length + 0.1);
+
+      expect(layerData.layerState).to.eq(LayerState.Finished);
+    } finally {
+      sharedWalkState.wrapMode = oldWrapMode;
+    }
+  });
+
+  it("playData wrapMode does not leak between animators sharing one controller", () => {
+    const sharedWalkState = animator.animatorController.layers[0].stateMachine.states.find(
+      (state) => state.name === "Walk"
+    );
+    const oldWrapMode = sharedWalkState.wrapMode;
+    const otherEntity = new Entity(engine);
+    const otherAnimator = otherEntity.addComponent(Animator);
+    otherAnimator.animatorController = animator.animatorController;
+
+    try {
+      sharedWalkState.wrapMode = WrapMode.Loop;
+      animator.play("Walk");
+      otherAnimator.play("Walk");
+
+      const playData = animator["_animatorLayersData"][0].srcPlayData;
+      const otherPlayData = otherAnimator["_animatorLayersData"][0].srcPlayData;
+      playData.wrapMode = WrapMode.Once;
+
+      expect(otherPlayData.wrapMode).to.eq(WrapMode.Loop);
+      expect(sharedWalkState.wrapMode).to.eq(WrapMode.Loop);
+    } finally {
+      sharedWalkState.wrapMode = oldWrapMode;
+      otherEntity.destroy();
+    }
+  });
+
   it("cross fade in fixed time", () => {
     const runState = animator.findAnimatorState("Run");
     animator.play("Walk");
@@ -252,25 +333,25 @@ describe("Animator test", function () {
     // @ts-ignore
     const layerData = animator._getAnimatorLayerData(0);
     const srcPlayData = layerData.srcPlayData;
-    expect(srcPlayData.instance.name).to.eq("Run");
+    expect(srcPlayData.state.name).to.eq("Run");
     expect(srcPlayData.playedTime).to.eq(0.3);
     // @ts-ignore
-    expect(srcPlayData.clipTime).to.eq(0.3 + 0.1 * (runState as any)._state._getDuration());
+    expect(srcPlayData.clipTime).to.eq(0.3 + 0.1 * runState._getDuration());
   });
 
   it("animation cross fade by transition", () => {
     const walkState = animator.findAnimatorState("Walk");
     const runState = animator.findAnimatorState("Run");
     const transition = new AnimatorStateTransition();
-    transition.destinationState = (runState as any)._state;
+    transition.destinationState = runState;
     transition.duration = 1;
     transition.exitTime = 1;
-    (walkState as any)._state.addTransition(transition);
+    walkState.addTransition(transition);
 
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update((walkState as any)._state.clip.length - 0.1);
+    animator.update(walkState.clip.length - 0.1);
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
@@ -313,7 +394,7 @@ describe("Animator test", function () {
     additiveLayer.mask = mask;
     additiveLayer.blendingMode = AnimatorLayerBlendingMode.Additive;
     animatorController.addLayer(additiveLayer);
-    const clip = (animator.findAnimatorState("Run") as any)._state.clip;
+    const clip = animator.findAnimatorState("Run").clip;
     const newState = animatorStateMachine.addState("Run");
     newState.clipStartTime = 1;
     newState.clip = clip;
@@ -368,64 +449,82 @@ 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
+  it("fireEvents gates AnimationEvent dispatch without consuming the event", () => {
+    animator.play("Walk");
 
     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++;
+    const testScript = animator.entity.addComponent(TestScript);
+    const testScriptSpy = vi.spyOn(testScript, "event0");
+
+    const event0 = new AnimationEvent();
+    event0.functionName = "event0";
+    event0.time = 0;
+
+    const state = animator.findAnimatorState("Walk");
+    state.clip.addEvent(event0);
+
+    animator.fireEvents = false;
+    animator.update(0);
+    expect(testScriptSpy).not.toHaveBeenCalled();
+
+    animator.fireEvents = true;
     animator.update(0.1);
-    expect(spy).toHaveBeenCalledTimes(1);
+    expect(testScriptSpy).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;
+  it("does not refire animation events when a once clip reaches the end", () => {
+    const entity = new Entity(engine);
+    const onceAnimator = entity.addComponent(Animator);
+    const controller = new AnimatorController(engine);
+    const layer = new AnimatorControllerLayer("Base Layer");
+    controller.addLayer(layer);
 
-    // Old clip: add an event matching event0
-    const oldEvent = new AnimationEvent();
-    oldEvent.functionName = "event0";
-    oldEvent.time = 0;
-    originalClip.addEvent(oldEvent);
+    const state = layer.stateMachine.addState("once");
+    state.wrapMode = WrapMode.Once;
+
+    const clip = new AnimationClip("once-clip");
+    const curve = new AnimationFloatCurve();
+    const start = new Keyframe<number>();
+    const end = new Keyframe<number>();
+    start.time = 0;
+    start.value = 0;
+    end.time = 1;
+    end.value = 1;
+    curve.addKey(start);
+    curve.addKey(end);
+    clip.addCurveBinding("", Transform, "position.x", curve);
 
     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);
+    const event0 = new AnimationEvent();
+    event0.functionName = "event0";
+    event0.time = 0.5;
+    clip.addEvent(event0);
+    state.clip = clip;
+    onceAnimator.animatorController = controller;
 
-    // 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;
+    const testScript = entity.addComponent(TestScript);
+    const testScriptSpy = vi.spyOn(testScript, "event0");
 
-    spy0.mockClear();
-    animator.play("Walk");
-    // @ts-ignore
-    animator.engine.time._frameCount++;
-    animator.update(0.1);
-    expect(spy0).toHaveBeenCalledTimes(0); // swapped clip has no event0
+    try {
+      onceAnimator.play("once");
+      // @ts-ignore
+      onceAnimator.engine.time._frameCount++;
+      onceAnimator.update(0.75);
+      expect(testScriptSpy).toHaveBeenCalledTimes(1);
 
-    // restore for other tests
-    walkState.clip = originalClip;
+      // @ts-ignore
+      onceAnimator.engine.time._frameCount++;
+      onceAnimator.update(0.5);
+      expect(testScriptSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      entity.destroy();
+    }
   });
 
   it("stateMachine", () => {
@@ -434,11 +533,11 @@ describe("Animator test", function () {
     const idleState = animator.findAnimatorState("Survey");
     const idleSpeed = 2;
     idleState.speed = idleSpeed;
-    (idleState as any)._state.clearTransitions();
+    idleState.clearTransitions();
     const walkState = animator.findAnimatorState("Walk");
-    (walkState as any)._state.clearTransitions();
+    walkState.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    (runState as any)._state.clearTransitions();
+    runState.clearTransitions();
     let idleToWalkTime = 0;
     let walkToRunTime = 0;
     let runToWalkTime = 0;
@@ -446,68 +545,68 @@ describe("Animator test", function () {
 
     // handle idle state
     const toWalkTransition = new AnimatorStateTransition();
-    toWalkTransition.destinationState = (walkState as any)._state;
+    toWalkTransition.destinationState = walkState;
     toWalkTransition.duration = 0.2;
     toWalkTransition.exitTime = 0.9;
     toWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Greater, 0);
-    (idleState as any)._state.addTransition(toWalkTransition);
+    idleState.addTransition(toWalkTransition);
     idleToWalkTime =
       //@ts-ignore
-      (toWalkTransition.exitTime * (idleState as any)._state._getDuration()) / idleSpeed +
+      (toWalkTransition.exitTime * idleState._getDuration()) / idleSpeed +
       //@ts-ignore
-      toWalkTransition.duration * (walkState as any)._state._getDuration();
+      toWalkTransition.duration * walkState._getDuration();
 
-    const exitTransition = (idleState as any)._state.addExitTransition();
+    const exitTransition = idleState.addExitTransition();
     exitTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
     // to walk state
     const toRunTransition = new AnimatorStateTransition();
-    toRunTransition.destinationState = (runState as any)._state;
+    toRunTransition.destinationState = runState;
     toRunTransition.duration = 0.3;
     toRunTransition.exitTime = 0.9;
     toRunTransition.addCondition("playerSpeed", AnimatorConditionMode.Greater, 0.5);
-    (walkState as any)._state.addTransition(toRunTransition);
+    walkState.addTransition(toRunTransition);
     walkToRunTime =
       //@ts-ignore
-      (toRunTransition.exitTime - toWalkTransition.duration) * (walkState as any)._state._getDuration() +
+      (toRunTransition.exitTime - toWalkTransition.duration) * walkState._getDuration() +
       //@ts-ignore
-      toRunTransition.duration * (runState as any)._state._getDuration();
+      toRunTransition.duration * runState._getDuration();
     const toIdleTransition = new AnimatorStateTransition();
-    toIdleTransition.destinationState = (idleState as any)._state;
+    toIdleTransition.destinationState = idleState;
     toIdleTransition.duration = 0.3;
     toIdleTransition.exitTime = 0.9;
     toIdleTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
-    (walkState as any)._state.addTransition(toIdleTransition);
+    walkState.addTransition(toIdleTransition);
     walkToIdleTime =
       //@ts-ignore
-      (toIdleTransition.exitTime - toRunTransition.duration) * (walkState as any)._state._getDuration() +
+      (toIdleTransition.exitTime - toRunTransition.duration) * walkState._getDuration() +
       //@ts-ignore
-      (toIdleTransition.duration * (idleState as any)._state._getDuration()) / idleSpeed;
+      (toIdleTransition.duration * idleState._getDuration()) / idleSpeed;
 
     // to run state
     const runToWalkTransition = new AnimatorStateTransition();
-    runToWalkTransition.destinationState = (walkState as any)._state;
+    runToWalkTransition.destinationState = walkState;
     runToWalkTransition.duration = 0.3;
     runToWalkTransition.exitTime = 0.9;
     runToWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Less, 0.5);
-    (runState as any)._state.addTransition(runToWalkTransition);
+    runState.addTransition(runToWalkTransition);
     runToWalkTime =
       //@ts-ignore
-      (runToWalkTransition.exitTime - toRunTransition.duration) * (runState as any)._state._getDuration() +
+      (runToWalkTransition.exitTime - toRunTransition.duration) * runState._getDuration() +
       //@ts-ignore
-      runToWalkTransition.duration * (walkState as any)._state._getDuration();
+      runToWalkTransition.duration * walkState._getDuration();
 
-    stateMachine.addEntryStateTransition((idleState as any)._state);
+    stateMachine.addEntryStateTransition(idleState);
 
-    const anyTransition = stateMachine.addAnyStateTransition((idleState as any)._state);
+    const anyTransition = stateMachine.addAnyStateTransition(idleState);
     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 as any)._state._getDuration() +
+      (anyTransition.exitTime - toIdleTransition.duration) * walkState._getDuration() +
       // @ts-ignore
-      (anyTransition.duration * (idleState as any)._state._getDuration()) / idleSpeed;
+      (anyTransition.duration * idleState._getDuration()) / idleSpeed;
 
     // @ts-ignore
     animator.engine.time._frameCount++;
@@ -559,11 +658,11 @@ describe("Animator test", function () {
     const idleState = animator.findAnimatorState("Survey");
     const idleSpeed = 2;
     idleState.speed = idleSpeed;
-    (idleState as any)._state.clearTransitions();
+    idleState.clearTransitions();
     const walkState = animator.findAnimatorState("Walk");
-    (walkState as any)._state.clearTransitions();
+    walkState.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    (runState as any)._state.clearTransitions();
+    runState.clearTransitions();
     let idleToWalkTime = 0;
     let walkToRunTime = 0;
     let runToWalkTime = 0;
@@ -571,68 +670,68 @@ describe("Animator test", function () {
 
     // handle idle state
     const toWalkTransition = new AnimatorStateTransition();
-    toWalkTransition.destinationState = (walkState as any)._state;
+    toWalkTransition.destinationState = walkState;
     toWalkTransition.duration = 0.2;
     toWalkTransition.exitTime = 0.1;
     toWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Greater, 0);
-    (idleState as any)._state.addTransition(toWalkTransition);
+    idleState.addTransition(toWalkTransition);
     idleToWalkTime =
       //@ts-ignore
-      ((1 - toWalkTransition.exitTime) * (idleState as any)._state._getDuration()) / idleSpeed +
+      ((1 - toWalkTransition.exitTime) * idleState._getDuration()) / idleSpeed +
       //@ts-ignore
-      toWalkTransition.duration * (walkState as any)._state._getDuration();
+      toWalkTransition.duration * walkState._getDuration();
 
-    const exitTransition = (idleState as any)._state.addExitTransition();
+    const exitTransition = idleState.addExitTransition();
     exitTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
     // to walk state
     const toRunTransition = new AnimatorStateTransition();
-    toRunTransition.destinationState = (runState as any)._state;
+    toRunTransition.destinationState = runState;
     toRunTransition.duration = 0.3;
     toRunTransition.exitTime = 0.1;
     toRunTransition.addCondition("playerSpeed", AnimatorConditionMode.Greater, 0.5);
-    (walkState as any)._state.addTransition(toRunTransition);
+    walkState.addTransition(toRunTransition);
     walkToRunTime =
       //@ts-ignore
-      (1 - toRunTransition.exitTime - toWalkTransition.duration) * (walkState as any)._state._getDuration() +
+      (1 - toRunTransition.exitTime - toWalkTransition.duration) * walkState._getDuration() +
       //@ts-ignore
-      toRunTransition.duration * (runState as any)._state._getDuration();
+      toRunTransition.duration * runState._getDuration();
     const toIdleTransition = new AnimatorStateTransition();
-    toIdleTransition.destinationState = (idleState as any)._state;
+    toIdleTransition.destinationState = idleState;
     toIdleTransition.duration = 0.3;
     toIdleTransition.exitTime = 0.1;
     toIdleTransition.addCondition("playerSpeed", AnimatorConditionMode.Equals, 0);
-    (walkState as any)._state.addTransition(toIdleTransition);
+    walkState.addTransition(toIdleTransition);
     walkToIdleTime =
       //@ts-ignore
-      (1 - toIdleTransition.exitTime - toRunTransition.duration) * (walkState as any)._state._getDuration() +
+      (1 - toIdleTransition.exitTime - toRunTransition.duration) * walkState._getDuration() +
       //@ts-ignore
-      (toIdleTransition.duration * (idleState as any)._state._getDuration()) / idleSpeed;
+      (toIdleTransition.duration * idleState._getDuration()) / idleSpeed;
 
     // to run state
     const runToWalkTransition = new AnimatorStateTransition();
-    runToWalkTransition.destinationState = (walkState as any)._state;
+    runToWalkTransition.destinationState = walkState;
     runToWalkTransition.duration = 0.3;
     runToWalkTransition.exitTime = 0.1;
     runToWalkTransition.addCondition("playerSpeed", AnimatorConditionMode.Less, 0.5);
-    (runState as any)._state.addTransition(runToWalkTransition);
+    runState.addTransition(runToWalkTransition);
     runToWalkTime =
       //@ts-ignore
-      (1 - runToWalkTransition.exitTime - toRunTransition.duration) * (runState as any)._state._getDuration() +
+      (1 - runToWalkTransition.exitTime - toRunTransition.duration) * runState._getDuration() +
       //@ts-ignore
-      runToWalkTransition.duration * (walkState as any)._state._getDuration();
+      runToWalkTransition.duration * walkState._getDuration();
 
-    stateMachine.addEntryStateTransition((idleState as any)._state);
+    stateMachine.addEntryStateTransition(idleState);
 
-    const anyTransition = stateMachine.addAnyStateTransition((idleState as any)._state);
+    const anyTransition = stateMachine.addAnyStateTransition(idleState);
     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 as any)._state._getDuration() +
+      (1 - anyTransition.exitTime - toIdleTransition.duration) * walkState._getDuration() +
       // @ts-ignore
-      (anyTransition.duration * (idleState as any)._state._getDuration()) / idleSpeed;
+      (anyTransition.duration * idleState._getDuration()) / idleSpeed;
 
     // @ts-ignore
     animator.engine.time._frameCount++;
@@ -676,10 +775,10 @@ describe("Animator test", function () {
 
   it("transitionOffset", () => {
     const walkState = animator.findAnimatorState("Walk");
-    (walkState as any)._state.clearTransitions();
+    walkState.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    (runState as any)._state.clearTransitions();
-    const toRunTransition = (walkState as any)._state.addTransition((runState as any)._state);
+    runState.clearTransitions();
+    const toRunTransition = walkState.addTransition(runState);
     toRunTransition.exitTime = 0;
     toRunTransition.duration = 1;
     toRunTransition.offset = 0.5;
@@ -689,7 +788,7 @@ describe("Animator test", function () {
     animator.update(0.01);
 
     const destPlayData = animator["_animatorLayersData"][0].destPlayData;
-    const destState = (destPlayData.instance as any)._state;
+    const destState = destPlayData.state;
     const transitionDuration = toRunTransition.duration * destState._getDuration();
     const crossWeight = animator["_animatorLayersData"][0].destPlayData.playedTime / transitionDuration;
     expect(crossWeight).to.lessThan(0.01);
@@ -698,21 +797,21 @@ describe("Animator test", function () {
   it("clipStartTime crossFade", () => {
     const walkState = animator.findAnimatorState("Walk");
     walkState.wrapMode = WrapMode.Once;
-    (walkState as any)._state.clipStartTime = 0.8;
-    (walkState as any)._state.clearTransitions();
+    walkState.clipStartTime = 0.8;
+    walkState.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    (runState as any)._state.clearTransitions();
-    const toRunTransition = (walkState as any)._state.addTransition((runState as any)._state);
+    runState.clearTransitions();
+    const toRunTransition = walkState.addTransition(runState);
     toRunTransition.exitTime = 0.5;
     toRunTransition.duration = 1;
-    (runState as any)._state.clipStartTime = 0.5;
+    runState.clipStartTime = 0.5;
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
 
     const destPlayData = animator["_animatorLayersData"][0].destPlayData;
-    expect(destPlayData.instance?.name).to.eq("Run");
+    expect(destPlayData.state?.name).to.eq("Run");
   });
 
   it("transition to exit but no entry", () => {
@@ -720,8 +819,8 @@ describe("Animator test", function () {
 
     const walkState = animator.findAnimatorState("Walk");
     walkState.wrapMode = WrapMode.Once;
-    (walkState as any)._state.clearTransitions();
-    (walkState as any)._state.addExitTransition();
+    walkState.clearTransitions();
+    walkState.addExitTransition();
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
@@ -888,15 +987,15 @@ describe("Animator test", function () {
     stateMachine.clearAnyStateTransitions();
     const walkState = animator.findAnimatorState("Run");
     // For test clipStartTime is not 0 and transition duration is 0
-    (walkState as any)._state.clipStartTime = 0.5;
-    (walkState as any)._state.addStateMachineScript(
+    walkState.clipStartTime = 0.5;
+    walkState.addStateMachineScript(
       class extends StateMachineScript {
         onStateEnter(animator) {
           animator.setParameterValue("playRun", 0);
         }
       }
     );
-    const transition = stateMachine.addAnyStateTransition((animator.findAnimatorState("Run") as any)._state);
+    const transition = stateMachine.addAnyStateTransition(animator.findAnimatorState("Run"));
     transition.addCondition("playRun", AnimatorConditionMode.Equals, 1);
     // For test clipStartTime is not 0 and transition duration is 0
     transition.duration = 0;
@@ -907,9 +1006,9 @@ describe("Animator test", function () {
     animator.engine.time._frameCount++;
     animator.update(0.5);
 
-    expect(layerData.srcPlayData.instance.name).to.eq("Run");
+    expect(layerData.srcPlayData.state.name).to.eq("Run");
     expect(layerData.srcPlayData.playedTime).to.eq(0.5);
-    expect(layerData.srcPlayData.clipTime).to.eq((walkState as any)._state.clip.length * 0.5 + 0.5);
+    expect(layerData.srcPlayData.clipTime).to.eq(walkState.clip.length * 0.5 + 0.5);
   });
 
   it("hasExitTime", () => {
@@ -922,13 +1021,13 @@ describe("Animator test", function () {
     stateMachine.clearAnyStateTransitions();
     const idleState = animator.findAnimatorState("Survey");
     idleState.speed = 1;
-    (idleState as any)._state.clearTransitions();
+    idleState.clearTransitions();
     const walkState = animator.findAnimatorState("Walk");
-    (walkState as any)._state.clipStartTime = 0;
-    (walkState as any)._state.clearTransitions();
+    walkState.clipStartTime = 0;
+    walkState.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    (runState as any)._state.clearTransitions();
-    const walkToRunTransition = (walkState as any)._state.addTransition((runState as any)._state);
+    runState.clearTransitions();
+    const walkToRunTransition = walkState.addTransition(runState);
     walkToRunTransition.hasExitTime = true;
     walkToRunTransition.exitTime = 0.5;
     walkToRunTransition.duration = 0;
@@ -936,10 +1035,10 @@ describe("Animator test", function () {
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update((walkState as any)._state.clip.length * 0.5);
-    expect(layerData.destPlayData.instance.name).to.eq("Run");
+    animator.update(walkState.clip.length * 0.5);
+    expect(layerData.destPlayData.state.name).to.eq("Run");
     expect(layerData.destPlayData.playedTime).to.eq(0);
-    const anyToIdleTransition = stateMachine.addAnyStateTransition((idleState as any)._state);
+    const anyToIdleTransition = stateMachine.addAnyStateTransition(idleState);
     anyToIdleTransition.hasExitTime = false;
     anyToIdleTransition.duration = 0.2;
     anyToIdleTransition.addCondition("triggerIdle", AnimatorConditionMode.If, true);
@@ -947,13 +1046,13 @@ describe("Animator test", function () {
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
-    expect(layerData.srcPlayData.instance.name).to.eq("Run");
+    expect(layerData.srcPlayData.state.name).to.eq("Run");
     expect(layerData.srcPlayData.playedTime).to.eq(0.1);
     // @ts-ignore
     animator.engine.time._frameCount++;
-    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);
+    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);
   });
 
   it("setTriggerParameter", () => {
@@ -966,16 +1065,16 @@ describe("Animator test", function () {
     stateMachine.clearEntryStateTransitions();
     stateMachine.clearAnyStateTransitions();
     const walkState = animator.findAnimatorState("Walk");
-    (walkState as any)._state.clearTransitions();
+    walkState.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    (runState as any)._state.clipStartTime = 0;
-    (runState as any)._state.clearTransitions();
-    const walkToRunTransition = (walkState as any)._state.addTransition((runState as any)._state);
+    runState.clipStartTime = 0;
+    runState.clearTransitions();
+    const walkToRunTransition = walkState.addTransition(runState);
     walkToRunTransition.hasExitTime = false;
     walkToRunTransition.duration = 0.1;
     walkToRunTransition.addCondition("triggerRun", AnimatorConditionMode.If, true);
 
-    const runToWalkTransition = (runState as any)._state.addTransition((walkState as any)._state);
+    const runToWalkTransition = runState.addTransition(walkState);
     runToWalkTransition.hasExitTime = true;
     runToWalkTransition.exitTime = 0.7;
     runToWalkTransition.duration = 0.3;
@@ -987,28 +1086,28 @@ describe("Animator test", function () {
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
-    expect(layerData.srcPlayData.instance.name).to.eq("Walk");
+    expect(layerData.srcPlayData.state.name).to.eq("Walk");
     expect(layerData.srcPlayData.playedTime).to.eq(0.1);
-    expect(layerData.destPlayData.instance.name).to.eq("Run");
+    expect(layerData.destPlayData.state.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 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);
+    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);
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update((runState as any)._state.clip.length * 0.6);
-    expect(layerData.destPlayData.instance.name).to.eq("Walk");
+    animator.update(runState.clip.length * 0.6);
+    expect(layerData.destPlayData.state.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 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);
+    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);
   });
 
   it("fixedDuration", () => {
@@ -1018,11 +1117,11 @@ describe("Animator test", function () {
     // @ts-ignore
     const layerData = animator._getAnimatorLayerData(0);
     const walkState = animator.findAnimatorState("Walk");
-    (walkState as any)._state.clearTransitions();
+    walkState.clearTransitions();
     const runState = animator.findAnimatorState("Run");
-    (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);
+    runState.clipStartTime = runState.clipEndTime = 0;
+    runState.clearTransitions();
+    const walkToRunTransition = walkState.addTransition(runState);
     walkToRunTransition.hasExitTime = false;
     walkToRunTransition.isFixedDuration = true;
     walkToRunTransition.duration = 0.1;
@@ -1032,7 +1131,7 @@ describe("Animator test", function () {
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.1);
-    expect(layerData.srcPlayData.instance.name).to.eq("Run");
+    expect(layerData.srcPlayData.state.name).to.eq("Run");
     expect(layerData.srcPlayData.playedTime).to.eq(0.1);
     expect(layerData.srcPlayData.clipTime).to.eq(0);
   });
@@ -1095,13 +1194,13 @@ describe("Animator test", function () {
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.6);
-    expect(animatorLayerData[0]?.srcPlayData.instance.name).to.eq("state1");
+    expect(animatorLayerData[0]?.srcPlayData.state.name).to.eq("state1");
 
     transition2.mute = false;
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(0.3);
-    expect(animatorLayerData[0]?.srcPlayData.instance.name).to.eq("state2");
+    expect(animatorLayerData[0]?.srcPlayData.state.name).to.eq("state2");
   });
 
   it("Clone", () => {
@@ -1150,6 +1249,40 @@ describe("Animator test", function () {
     expect(spine.transform.position.y).to.eq(1);
   });
 
+  it("sampleAnimation samples clip curves without firing AnimationEvents", () => {
+    const entity = new Entity(engine, "sample-root");
+    const clip = new AnimationClip("sample");
+    const curve = new AnimationFloatCurve();
+    const start = new Keyframe<number>();
+    const end = new Keyframe<number>();
+    start.time = 0;
+    start.value = 0;
+    end.time = 1;
+    end.value = 3;
+    curve.addKey(start);
+    curve.addKey(end);
+    clip.addCurveBinding("", Transform, "position.x", curve);
+
+    class TestScript extends Script {
+      event0(): void {}
+    }
+
+    const script = entity.addComponent(TestScript);
+    const eventSpy = vi.spyOn(script, "event0");
+    const event0 = new AnimationEvent();
+    event0.functionName = "event0";
+    event0.time = 0;
+    clip.addEvent(event0);
+
+    try {
+      clip.sampleAnimation(entity, 1);
+      expect(entity.transform.position.x).to.eq(3);
+      expect(eventSpy).not.toHaveBeenCalled();
+    } finally {
+      entity.destroy();
+    }
+  });
+
   it("anyState transition interrupts crossFade", () => {
     const { animatorController } = animator;
     animatorController.addParameter("interrupt", false);
@@ -1157,7 +1290,7 @@ describe("Animator test", function () {
     const idleState = animator.findAnimatorState("Survey");
 
     // AnyState -> Idle (can interrupt)
-    const anyToIdle = stateMachine.addAnyStateTransition((idleState as any)._state);
+    const anyToIdle = stateMachine.addAnyStateTransition(idleState);
     anyToIdle.hasExitTime = false;
     anyToIdle.duration = 0.2;
     anyToIdle.addCondition("interrupt", AnimatorConditionMode.If, true);
@@ -1174,7 +1307,7 @@ describe("Animator test", function () {
     const layerData = animator._getAnimatorLayerData(0);
 
     expect(layerData.layerState).to.eq(LayerState.CrossFading);
-    expect(layerData.destPlayData.instance.name).to.eq("Run");
+    expect(layerData.destPlayData.state.name).to.eq("Run");
 
     // Trigger interrupt during crossFade
     animator.setParameterValue("interrupt", true);
@@ -1183,7 +1316,7 @@ describe("Animator test", function () {
     animator.update(0.1);
 
     // Should have interrupted to Idle
-    expect(layerData.destPlayData.instance.name).to.eq("Survey");
+    expect(layerData.destPlayData.state.name).to.eq("Survey");
   });
 
   it("noExitTime transition scan should ignore exitTime transitions", () => {
@@ -1195,12 +1328,12 @@ describe("Animator test", function () {
     const runState = animator.findAnimatorState("Run");
     const idleState = animator.findAnimatorState("Survey");
 
-    (walkState as any)._state.clipStartTime = 0;
-    (walkState as any)._state.clipEndTime = 1;
-    (walkState as any)._state.clearTransitions();
+    walkState.clipStartTime = 0;
+    walkState.clipEndTime = 1;
+    walkState.clearTransitions();
 
     // A noExitTime transition that fails (ensures noExitTimeCount > 0).
-    const noExitFailTransition = (walkState as any)._state.addTransition((idleState as any)._state);
+    const noExitFailTransition = walkState.addTransition(idleState);
     noExitFailTransition.hasExitTime = false;
     noExitFailTransition.duration = 0;
     noExitFailTransition.addCondition("never", AnimatorConditionMode.If, true);
@@ -1209,26 +1342,26 @@ describe("Animator test", function () {
     const exitTimeTransition = new AnimatorStateTransition();
     exitTimeTransition.exitTime = 0.5;
     exitTimeTransition.duration = 0;
-    exitTimeTransition.destinationState = (runState as any)._state;
+    exitTimeTransition.destinationState = runState;
     exitTimeTransition.addCondition("goRun", AnimatorConditionMode.If, true);
-    (walkState as any)._state.addTransition(exitTimeTransition);
+    walkState.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 as any)._state.clip.length * 0.25;
+    const preExitDeltaTime = walkState.clip.length * 0.25;
     // @ts-ignore
     animator.engine.time._frameCount++;
     animator.update(preExitDeltaTime);
-    expect(layerData.srcPlayData.instance.name).to.eq("Walk");
-    expect(layerData.destPlayData).to.be.null;
+    expect(layerData.srcPlayData.state.name).to.eq("Walk");
+    expect(layerData.destPlayData.state).to.be.undefined;
 
     // Update past exitTime, should transition to Run.
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update((walkState as any)._state.clip.length * 0.5);
+    animator.update(walkState.clip.length * 0.5);
     expect(animator.getCurrentAnimatorState(0).name).to.eq("Run");
   });
 
@@ -1240,7 +1373,7 @@ describe("Animator test", function () {
     const walkState = animator.findAnimatorState("Walk");
 
     // AnyState -> Idle (can interrupt)
-    const anyToIdle = stateMachine.addAnyStateTransition((idleState as any)._state);
+    const anyToIdle = stateMachine.addAnyStateTransition(idleState);
     anyToIdle.hasExitTime = false;
     anyToIdle.duration = 0.2;
     anyToIdle.addCondition("interrupt", AnimatorConditionMode.If, true);
@@ -1250,7 +1383,7 @@ describe("Animator test", function () {
     animator.play("Walk");
     // @ts-ignore
     animator.engine.time._frameCount++;
-    animator.update((walkState as any)._state.clip.length + 0.1);
+    animator.update(walkState.clip.length + 0.1);
 
     // @ts-ignore
     const layerData = animator._getAnimatorLayerData(0);
@@ -1264,7 +1397,7 @@ describe("Animator test", function () {
     animator.update(0.1);
 
     expect(layerData.layerState).to.eq(LayerState.FixedCrossFading);
-    expect(layerData.destPlayData.instance.name).to.eq("Run");
+    expect(layerData.destPlayData.state.name).to.eq("Run");
 
     // Trigger interrupt during FixedCrossFading
     animator.setParameterValue("interrupt", true);
@@ -1273,7 +1406,7 @@ describe("Animator test", function () {
     animator.update(0.1);
 
     // Should have interrupted to Idle
-    expect(layerData.destPlayData.instance.name).to.eq("Survey");
+    expect(layerData.destPlayData.state.name).to.eq("Survey");
   });
 
   it("anyState interrupt should skip transition to same destination state", () => {
@@ -1283,7 +1416,7 @@ describe("Animator test", function () {
     const runState = animator.findAnimatorState("Run");
 
     // AnyState -> Run (always true, noExitTime)
-    const anyToRun = stateMachine.addAnyStateTransition((runState as any)._state);
+    const anyToRun = stateMachine.addAnyStateTransition(runState);
     anyToRun.hasExitTime = false;
     anyToRun.duration = 0.2;
     anyToRun.addCondition("alwaysTrue", AnimatorConditionMode.If, true);
@@ -1300,7 +1433,7 @@ describe("Animator test", function () {
 
     // Should be in CrossFading state, dest = Run
     expect(layerData.layerState).to.eq(LayerState.CrossFading);
-    expect(layerData.destPlayData.instance.name).to.eq("Run");
+    expect(layerData.destPlayData.state.name).to.eq("Run");
 
     // Update again - anyState -> Run should be skipped because dest is already Run
     // @ts-ignore
@@ -1309,7 +1442,7 @@ describe("Animator test", function () {
 
     // Should still be CrossFading to Run (not interrupted/reset)
     expect(layerData.layerState).to.eq(LayerState.CrossFading);
-    expect(layerData.destPlayData.instance.name).to.eq("Run");
+    expect(layerData.destPlayData.state.name).to.eq("Run");
   });
 
   it("zero-duration crossFade should not be interrupted by anyState transition", () => {
@@ -1319,7 +1452,7 @@ describe("Animator test", function () {
     const idleState = animator.findAnimatorState("Survey");
 
     // AnyState -> Idle (always true, noExitTime)
-    const anyToIdle = stateMachine.addAnyStateTransition((idleState as any)._state);
+    const anyToIdle = stateMachine.addAnyStateTransition(idleState);
     anyToIdle.hasExitTime = false;
     anyToIdle.duration = 0.2;
     anyToIdle.addCondition("interrupt", AnimatorConditionMode.If, true);
@@ -1335,26 +1468,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.instance.name).to.eq("Run");
+    expect(layerData.srcPlayData.state.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 as any)._state.clearTransitions();
+    walkState.clearTransitions();
 
     // Add a noExitTime transition
-    const t1 = (walkState as any)._state.addTransition((runState as any)._state);
+    const t1 = walkState.addTransition(runState);
     t1.hasExitTime = false;
 
     // Add a hasExitTime transition
-    const t2 = (walkState as any)._state.addTransition((idleState as any)._state);
+    const t2 = walkState.addTransition(idleState);
     t2.hasExitTime = true;
     t2.exitTime = 0.5;
 
     // @ts-ignore
-    const collection = (walkState as any)._state._transitionCollection;
+    const collection = walkState._transitionCollection;
     expect(collection.noExitTimeCount).to.eq(1);
     expect(collection.count).to.eq(2);
 
@@ -1373,446 +1506,4 @@ 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/audio/AudioSource.test.ts b/tests/src/core/audio/AudioSource.test.ts
index dd8fa6c6f1..875c8035d1 100644
--- a/tests/src/core/audio/AudioSource.test.ts
+++ b/tests/src/core/audio/AudioSource.test.ts
@@ -1,6 +1,6 @@
 import { AssetType, AudioClip, AudioManager, AudioSource, Engine } from "@galacean/engine-core";
 import "@galacean/engine-loader";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { beforeAll, describe, expect, it } from "vitest";
 import { sound } from "../model/sound";
 
diff --git a/tests/src/core/audio/AudioSourcePendingPlayback.test.ts b/tests/src/core/audio/AudioSourcePendingPlayback.test.ts
new file mode 100644
index 0000000000..5e7e4645a1
--- /dev/null
+++ b/tests/src/core/audio/AudioSourcePendingPlayback.test.ts
@@ -0,0 +1,358 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AudioManager, AudioSource } from "@galacean/engine-core";
+
+class MockGainNode {
+  gain = {
+    setValueAtTime: vi.fn()
+  };
+
+  connect = vi.fn();
+}
+
+class MockBufferSourceNode {
+  buffer: unknown = null;
+  loop = false;
+  onended: (() => void) | null = null;
+  playbackRate = {
+    value: 1
+  };
+
+  connect = vi.fn();
+  disconnect = vi.fn();
+  start = vi.fn();
+  stop = vi.fn();
+}
+
+class MockAudioContext {
+  static shouldResumeSucceed = true;
+  static resumeResultQueue: Array<Promise<void> | Error> | null = null;
+
+  currentTime = 0;
+  destination = {};
+  onstatechange: (() => void) | null = null;
+  state: AudioContextState = "suspended";
+
+  createBufferSource(): AudioBufferSourceNode {
+    return new MockBufferSourceNode() as unknown as AudioBufferSourceNode;
+  }
+
+  createGain(): GainNode {
+    return new MockGainNode() as unknown as GainNode;
+  }
+
+  resume(): Promise<void> {
+    const queuedResult = MockAudioContext.resumeResultQueue?.shift();
+    if (queuedResult instanceof Promise) {
+      return queuedResult;
+    }
+    if (queuedResult instanceof Error) {
+      return Promise.reject(queuedResult);
+    }
+    if (!MockAudioContext.shouldResumeSucceed) {
+      return Promise.reject(new Error("autoplay blocked"));
+    }
+    this.state = "running";
+    this.onstatechange?.();
+    return Promise.resolve();
+  }
+
+  suspend(): Promise<void> {
+    this.state = "suspended";
+    this.onstatechange?.();
+    return Promise.resolve();
+  }
+}
+
+async function flushAsync(): Promise<void> {
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+function createAudioSource(): AudioSource {
+  const audioSource = new AudioSource({
+    _isActiveInHierarchy: true,
+    _isActiveInScene: true,
+    _removeComponent() {},
+    engine: {}
+  } as any);
+
+  audioSource.clip = {
+    _addReferCount() {},
+    _getAudioSource() {
+      return {};
+    }
+  } as any;
+
+  return audioSource;
+}
+
+describe("AudioSource pending playback", () => {
+  beforeEach(() => {
+    (window as any).AudioContext = MockAudioContext;
+    (AudioManager as any)._context = null;
+    (AudioManager as any)._gainNode = null;
+    (AudioManager as any)._needsUserGestureResume = false;
+    (AudioManager as any)._pendingSources = new Set();
+    (AudioManager as any)._playingSources = new Set();
+    (AudioManager as any)._interruptedSources = new Set();
+    (AudioManager as any)._foregroundRestoreTimer = undefined;
+    (AudioManager as any)._hidden = false;
+    MockAudioContext.shouldResumeSucceed = true;
+    MockAudioContext.resumeResultQueue = null;
+    AudioManager._playingCount = 0;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    document.replaceChildren();
+  });
+
+  it("replays pending playback on the next user gesture after autoplay blocking", async () => {
+    const audioSource = createAudioSource();
+
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    MockAudioContext.shouldResumeSucceed = false;
+
+    audioSource.play();
+    await flushAsync();
+
+    expect((audioSource as any)._pendingPlay).to.be.true;
+    expect((AudioManager as any)._pendingSources.size).to.equal(1);
+    expect((AudioManager as any)._needsUserGestureResume).to.be.false;
+    expect(audioSource.isPlaying).to.be.false;
+
+    MockAudioContext.shouldResumeSucceed = true;
+    document.dispatchEvent(new Event("click"));
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.true;
+    expect((audioSource as any)._pendingPlay).to.be.false;
+    expect((AudioManager as any)._pendingSources.size).to.equal(0);
+    expect((AudioManager as any)._needsUserGestureResume).to.be.false;
+  });
+
+  it("cancels pending playback before the unlocking gesture arrives", async () => {
+    const audioSource = createAudioSource();
+
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    MockAudioContext.shouldResumeSucceed = false;
+
+    audioSource.play();
+    await flushAsync();
+
+    audioSource.stop();
+    expect((audioSource as any)._pendingPlay).to.be.false;
+    expect((AudioManager as any)._pendingSources.size).to.equal(0);
+
+    MockAudioContext.shouldResumeSucceed = true;
+    document.dispatchEvent(new Event("click"));
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.false;
+    expect((audioSource as any)._pendingPlay).to.be.false;
+  });
+
+  it("keeps resume a no-op until a context already exists", async () => {
+    expect((AudioManager as any)._context).to.be.null;
+
+    await AudioManager.resume();
+
+    expect((AudioManager as any)._context).to.be.null;
+  });
+
+  it("does not resume foreground audio before a hide event", async () => {
+    createAudioSource();
+    const context = (AudioManager as any)._context as MockAudioContext;
+
+    vi.spyOn(document, "hidden", "get").mockReturnValue(false);
+    const resumeSpy = vi.spyOn(context, "resume");
+    const suspendSpy = vi.spyOn(AudioManager, "suspend");
+
+    context.state = "suspended";
+    AudioManager._playingCount = 1;
+
+    document.dispatchEvent(new Event("visibilitychange"));
+    await flushAsync();
+
+    expect(resumeSpy).not.toHaveBeenCalled();
+    expect(suspendSpy).not.toHaveBeenCalled();
+    expect((AudioManager as any)._needsUserGestureResume).to.be.false;
+  });
+
+  it("recreates interrupted source nodes from a foreground gesture", async () => {
+    const audioSource = createAudioSource();
+    const context = (AudioManager as any)._context as MockAudioContext;
+
+    context.state = "running";
+    audioSource.play();
+
+    const firstSourceNode = (audioSource as any)._sourceNode as MockBufferSourceNode;
+    expect(audioSource.isPlaying).to.be.true;
+    expect(AudioManager._playingCount).to.equal(1);
+
+    const hiddenSpy = vi.spyOn(document, "hidden", "get").mockReturnValue(true);
+    document.dispatchEvent(new Event("visibilitychange"));
+    await flushAsync();
+
+    expect(firstSourceNode.stop).toHaveBeenCalledTimes(1);
+    expect(audioSource.isPlaying).to.be.false;
+    expect(AudioManager._playingCount).to.equal(0);
+    expect((AudioManager as any)._interruptedSources.size).to.equal(1);
+
+    hiddenSpy.mockReturnValue(false);
+    document.dispatchEvent(new Event("visibilitychange"));
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.false;
+    expect((AudioManager as any)._interruptedSources.size).to.equal(1);
+    expect((AudioManager as any)._needsUserGestureResume).to.be.true;
+
+    document.dispatchEvent(new Event("touchend"));
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.true;
+    expect(AudioManager._playingCount).to.equal(1);
+    expect((AudioManager as any)._interruptedSources.size).to.equal(0);
+    expect((audioSource as any)._sourceNode).not.to.equal(firstSourceNode);
+  });
+
+  it("recovers interrupted source nodes from foreground retry after the restore delay", async () => {
+    vi.useFakeTimers();
+    const audioSource = createAudioSource();
+    const context = (AudioManager as any)._context as MockAudioContext;
+
+    context.state = "running";
+    audioSource.play();
+
+    const hiddenSpy = vi.spyOn(document, "hidden", "get").mockReturnValue(true);
+    document.dispatchEvent(new Event("visibilitychange"));
+    await flushAsync();
+
+    hiddenSpy.mockReturnValue(false);
+    document.dispatchEvent(new Event("visibilitychange"));
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.false;
+
+    await vi.advanceTimersByTimeAsync(299);
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.false;
+
+    await vi.advanceTimersByTimeAsync(1);
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.true;
+    expect((AudioManager as any)._interruptedSources.size).to.equal(0);
+  });
+
+  it("handles document pagehide/pageshow and mouseup recovery", async () => {
+    const audioSource = createAudioSource();
+    const context = (AudioManager as any)._context as MockAudioContext;
+
+    context.state = "running";
+    audioSource.play();
+
+    document.dispatchEvent(new Event("pagehide"));
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.false;
+    expect((AudioManager as any)._interruptedSources.size).to.equal(1);
+
+    document.dispatchEvent(new Event("pageshow"));
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.false;
+    expect((AudioManager as any)._needsUserGestureResume).to.be.true;
+
+    document.dispatchEvent(new Event("mouseup"));
+    await flushAsync();
+
+    expect(audioSource.isPlaying).to.be.true;
+    expect((AudioManager as any)._interruptedSources.size).to.equal(0);
+  });
+
+  it("keeps gesture recovery when foreground resume fails", async () => {
+    vi.useFakeTimers();
+    const audioSource = createAudioSource();
+    const context = (AudioManager as any)._context as MockAudioContext;
+
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    const hiddenSpy = vi.spyOn(document, "hidden", "get").mockReturnValue(true);
+    const resumeSpy = vi.spyOn(context, "resume");
+    const suspendSpy = vi.spyOn(AudioManager, "suspend");
+
+    context.state = "running";
+    audioSource.play();
+
+    document.dispatchEvent(new Event("visibilitychange"));
+    await flushAsync();
+
+    MockAudioContext.shouldResumeSucceed = false;
+    hiddenSpy.mockReturnValue(false);
+    document.dispatchEvent(new Event("visibilitychange"));
+    await flushAsync();
+
+    expect(resumeSpy).not.toHaveBeenCalled();
+    expect(suspendSpy).toHaveBeenCalledTimes(2);
+    expect((AudioManager as any)._needsUserGestureResume).to.be.true;
+
+    await vi.advanceTimersByTimeAsync(299);
+    await flushAsync();
+
+    expect(resumeSpy).not.toHaveBeenCalled();
+    expect(suspendSpy).toHaveBeenCalledTimes(2);
+    expect((AudioManager as any)._needsUserGestureResume).to.be.true;
+
+    await vi.advanceTimersByTimeAsync(1);
+    await flushAsync();
+
+    expect(resumeSpy).toHaveBeenCalledTimes(1);
+    expect(suspendSpy).toHaveBeenCalledTimes(3);
+    expect((AudioManager as any)._needsUserGestureResume).to.be.true;
+
+    document.dispatchEvent(new Event("click"));
+    await flushAsync();
+
+    expect(resumeSpy).toHaveBeenCalledTimes(2);
+    expect((AudioManager as any)._needsUserGestureResume).to.be.true;
+
+    MockAudioContext.shouldResumeSucceed = true;
+    document.dispatchEvent(new Event("click"));
+    await flushAsync();
+
+    expect(resumeSpy).toHaveBeenCalledTimes(3);
+    expect(context.state).to.equal("running");
+    expect((AudioManager as any)._needsUserGestureResume).to.be.false;
+  });
+
+  it("retries context.resume inside a later user gesture even if an earlier resume is still pending", async () => {
+    createAudioSource();
+    const context = (AudioManager as any)._context as MockAudioContext;
+    const firstResume = new Promise<void>(() => {});
+
+    MockAudioContext.resumeResultQueue = [firstResume];
+    const resumeSpy = vi.spyOn(context, "resume");
+
+    AudioManager.resume().catch(() => {});
+    await flushAsync();
+
+    expect(resumeSpy).toHaveBeenCalledTimes(1);
+
+    MockAudioContext.resumeResultQueue = [
+      Promise.resolve().then(() => {
+        context.state = "running";
+        context.onstatechange?.();
+      })
+    ];
+    (AudioManager as any)._needsUserGestureResume = true;
+
+    document.dispatchEvent(new Event("click"));
+    await flushAsync();
+
+    expect(resumeSpy).toHaveBeenCalledTimes(2);
+    expect(context.state).to.equal("running");
+    expect((AudioManager as any)._needsUserGestureResume).to.be.false;
+  });
+});
diff --git a/tests/src/core/particle/Burst.test.ts b/tests/src/core/particle/Burst.test.ts
deleted file mode 100644
index 7765171e54..0000000000
--- a/tests/src/core/particle/Burst.test.ts
+++ /dev/null
@@ -1,187 +0,0 @@
-import {
-  Burst,
-  Camera,
-  Engine,
-  ParticleCompositeCurve,
-  ParticleMaterial,
-  ParticleRenderer,
-  ParticleStopMode
-} from "@galacean/engine-core";
-import { Color } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine";
-import { beforeAll, describe, expect, it } from "vitest";
-
-function updateEngine(engine: Engine, frames: number, deltaTime = 100) {
-  //@ts-ignore
-  engine._vSyncCount = Infinity;
-  //@ts-ignore
-  engine._time._lastSystemTime = 0;
-  let times = 0;
-  performance.now = function () {
-    times++;
-    return times * deltaTime;
-  };
-  for (let i = 0; i < frames; i++) {
-    engine.update();
-  }
-}
-
-describe("Burst", () => {
-  let engine: Engine;
-
-  beforeAll(async function () {
-    engine = await WebGLEngine.create({
-      canvas: document.createElement("canvas")
-    });
-
-    const scene = engine.sceneManager.activeScene;
-    const rootEntity = scene.createRootEntity("root");
-    const cameraEntity = rootEntity.createChild("Camera");
-    cameraEntity.addComponent(Camera);
-    cameraEntity.transform.setPosition(0, 0, 10);
-
-    engine.run();
-  });
-
-  it("Default constructor", () => {
-    const burst = new Burst(0.5, new ParticleCompositeCurve(10), 1, 0.01);
-    expect(burst.time).to.equal(0.5);
-    expect(burst.count.evaluate(undefined, undefined)).to.equal(10);
-    expect(burst.cycles).to.equal(1);
-    expect(burst.repeatInterval).to.equal(0.01);
-  });
-
-  it("Constructor with cycles and repeatInterval", () => {
-    const burst = new Burst(0.5, new ParticleCompositeCurve(10), 3, 0.2);
-    expect(burst.time).to.equal(0.5);
-    expect(burst.count.evaluate(undefined, undefined)).to.equal(10);
-    expect(burst.cycles).to.equal(3);
-    expect(burst.repeatInterval).to.equal(0.2);
-  });
-
-  it("Modify cycles and repeatInterval", () => {
-    const burst = new Burst(0, new ParticleCompositeCurve(5), 1, 0.01);
-    burst.cycles = 5;
-    burst.repeatInterval = 0.1;
-    expect(burst.cycles).to.equal(5);
-    expect(burst.repeatInterval).to.equal(0.1);
-  });
-
-  it("Single cycle backward compatible", () => {
-    const scene = engine.sceneManager.activeScene;
-    const entity = scene.createRootEntity("SingleCycle");
-    const renderer = entity.addComponent(ParticleRenderer);
-    const material = new ParticleMaterial(engine);
-    material.baseColor = new Color(1, 1, 1, 1);
-    renderer.setMaterial(material);
-
-    const generator = renderer.generator;
-    generator.useAutoRandomSeed = false;
-    generator.main.duration = 5;
-    generator.main.isLoop = false;
-    generator.main.maxParticles = 1000;
-    generator.main.startLifetime.constant = 10;
-    generator.emission.rateOverTime.constant = 0;
-
-    // Default cycles=1 should behave like original
-    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(10), 1, 0.01));
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-
-    // 20 frames at 100ms = 2s, burst at t=0 fires once
-    updateEngine(engine, 20);
-    expect(generator._getAliveParticleCount()).to.equal(10);
-
-    entity.destroy();
-  });
-
-  it("Burst cycles emit multiple times", () => {
-    const scene = engine.sceneManager.activeScene;
-    const entity = scene.createRootEntity("BurstCycles");
-    const renderer = entity.addComponent(ParticleRenderer);
-    const material = new ParticleMaterial(engine);
-    material.baseColor = new Color(1, 1, 1, 1);
-    renderer.setMaterial(material);
-
-    const generator = renderer.generator;
-    generator.useAutoRandomSeed = false;
-    generator.main.duration = 5;
-    generator.main.isLoop = false;
-    generator.main.maxParticles = 1000;
-    generator.main.startLifetime.constant = 10;
-    generator.emission.rateOverTime.constant = 0;
-
-    // Burst at t=0, count=10, cycles=3, interval=0.5 -> fires at 0s, 0.5s, 1.0s
-    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(10), 3, 0.5));
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-
-    // 15 frames at 100ms = 1.5s, all 3 cycles should have fired
-    updateEngine(engine, 15);
-    expect(generator._getAliveParticleCount()).to.equal(30);
-
-    entity.destroy();
-  });
-
-  it("Burst cycles survive float drift (no skipped cycle)", () => {
-    const scene = engine.sceneManager.activeScene;
-    const entity = scene.createRootEntity("FloatDrift");
-    const renderer = entity.addComponent(ParticleRenderer);
-    const material = new ParticleMaterial(engine);
-    material.baseColor = new Color(1, 1, 1, 1);
-    renderer.setMaterial(material);
-
-    const generator = renderer.generator;
-    generator.useAutoRandomSeed = false;
-    generator.main.duration = 5;
-    generator.main.isLoop = false;
-    generator.main.maxParticles = 1000;
-    generator.main.startLifetime.constant = 10;
-    generator.emission.rateOverTime.constant = 0;
-
-    // interval=0.1 triggers IEEE 754 drift (e.g. 0.1+0.2 != 0.3). Without tolerance in the
-    // cycle-index math, `ceil((startTime - burstTime) / 0.1)` can land at cycle + 1 and
-    // permanently skip a cycle at accumulated integer-multiple times.
-    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(1), 10, 0.1));
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-
-    // 15 frames at 100ms = 1.5s, all 10 cycles (0, 0.1, 0.2, ..., 0.9) must have fired
-    updateEngine(engine, 15);
-    expect(generator._getAliveParticleCount()).to.equal(10);
-
-    entity.destroy();
-  });
-
-  it("Burst cycles=Infinity emits infinitely within duration", () => {
-    const scene = engine.sceneManager.activeScene;
-    const entity = scene.createRootEntity("InfiniteCycles");
-    const renderer = entity.addComponent(ParticleRenderer);
-    const material = new ParticleMaterial(engine);
-    material.baseColor = new Color(1, 1, 1, 1);
-    renderer.setMaterial(material);
-
-    const generator = renderer.generator;
-    generator.useAutoRandomSeed = false;
-    generator.main.duration = 2;
-    generator.main.isLoop = false;
-    generator.main.maxParticles = 1000;
-    generator.main.startLifetime.constant = 10;
-    generator.emission.rateOverTime.constant = 0;
-
-    // cycles=Infinity means unlimited, interval=0.5 -> fires at 0, 0.5, 1.0, 1.5 within duration=2
-    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(5), Infinity, 0.5));
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-
-    // 25 frames at 100ms = 2.5s, should fire 4 times (at 0, 0.5, 1.0, 1.5) = 20 particles
-    updateEngine(engine, 25);
-    expect(generator._getAliveParticleCount()).to.equal(20);
-
-    entity.destroy();
-  });
-});
diff --git a/tests/src/core/particle/LimitVelocityOverLifetime.test.ts b/tests/src/core/particle/LimitVelocityOverLifetime.test.ts
index 3bfe8c89ce..91b0a321bb 100644
--- a/tests/src/core/particle/LimitVelocityOverLifetime.test.ts
+++ b/tests/src/core/particle/LimitVelocityOverLifetime.test.ts
@@ -12,7 +12,7 @@ import {
   CurveKey
 } from "@galacean/engine-core";
 import { Color, Vector3 } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { LitePhysics } from "@galacean/engine-physics-lite";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
 
diff --git a/tests/src/core/particle/ParticleBoundingBox.test.ts b/tests/src/core/particle/ParticleBoundingBox.test.ts
index 1f33c6fa10..8b4e78b8f5 100644
--- a/tests/src/core/particle/ParticleBoundingBox.test.ts
+++ b/tests/src/core/particle/ParticleBoundingBox.test.ts
@@ -15,7 +15,7 @@ import {
   ParticleStopMode
 } from "@galacean/engine-core";
 import { Color, Vector3 } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { LitePhysics } from "@galacean/engine-physics-lite";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
 
@@ -404,73 +404,6 @@ describe("ParticleBoundingBox", function () {
     );
   });
 
-  it("ShapeTransform-Position", function () {
-    const shape = new BoxShape();
-    shape.position.set(5, 0, 0);
-    particleRenderer.generator.emission.shape = shape;
-
-    // Same as default BoxShape bounds shifted by (5,0,0)
-    testParticleRendererBounds(
-      engine,
-      particleRenderer,
-      { x: 3.086, y: -1.914, z: -26.914 },
-      { x: 6.914, y: 1.914, z: 1.914 },
-      delta
-    );
-  });
-
-  it("ShapeTransform-Rotation", function () {
-    const shape = new BoxShape();
-    shape.size.set(1, 2, 1);
-    shape.rotation.set(0, 0, 90);
-    particleRenderer.generator.emission.shape = shape;
-
-    // size(1,2,1): local pos range (-0.5,-1,-0.5)~(0.5,1,0.5)
-    // rotated 90 Z: x<->y swapped -> (-1,-0.5,-0.5)~(1,0.5,0.5)
-    testParticleRendererBounds(
-      engine,
-      particleRenderer,
-      { x: -2.414, y: -1.914, z: -26.914 },
-      { x: 2.414, y: 1.914, z: 1.914 },
-      delta
-    );
-  });
-
-  it("ShapeTransform-Scale", function () {
-    const shape = new BoxShape();
-    shape.scale.set(3, 1, 1);
-    particleRenderer.generator.emission.shape = shape;
-
-    // Default box pos range (-0.5,-0.5,-0.5)~(0.5,0.5,0.5), X scaled 3x -> (-1.5,...)~(1.5,...)
-    testParticleRendererBounds(
-      engine,
-      particleRenderer,
-      { x: -2.914, y: -1.914, z: -26.914 },
-      { x: 2.914, y: 1.914, z: 1.914 },
-      delta
-    );
-  });
-
-  it("ShapeTransform-Combined", function () {
-    const shape = new BoxShape();
-    shape.position.set(0, 0, 5);
-    shape.rotation.set(0, 0, 90);
-    shape.scale.set(2, 1, 1);
-    particleRenderer.generator.emission.shape = shape;
-
-    // Default size(1,1,1): local (-0.5,-0.5,-0.5)~(0.5,0.5,0.5)
-    // scale(2,1,1) -> (-1,-0.5,-0.5)~(1,0.5,0.5)
-    // rotate 90 Z: x<->y -> (-0.5,-1,-0.5)~(0.5,1,0.5)
-    // + position(0,0,5) -> (-0.5,-1,4.5)~(0.5,1,5.5)
-    testParticleRendererBounds(
-      engine,
-      particleRenderer,
-      { x: -1.914, y: -2.414, z: -21.914 },
-      { x: 1.914, y: 2.414, z: 6.914 },
-      delta
-    );
-  });
-
   it("Transform", function () {
     entity.transform.position.set(1, 2, 3);
     testParticleRendererBounds(
diff --git a/tests/src/core/particle/ParticleRenderer.test.ts b/tests/src/core/particle/ParticleRenderer.test.ts
index 737631b139..dada7b9be0 100644
--- a/tests/src/core/particle/ParticleRenderer.test.ts
+++ b/tests/src/core/particle/ParticleRenderer.test.ts
@@ -1,5 +1,5 @@
 import { Camera, ModelMesh, ParticleRenderer, ParticleRenderMode, Scene } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { beforeAll, describe, expect, it } from "vitest";
 
 describe("ParticleRenderer", () => {
diff --git a/tests/src/core/particle/ParticleShapeTransform.test.ts b/tests/src/core/particle/ParticleShapeTransform.test.ts
deleted file mode 100644
index d3ac6d2ac6..0000000000
--- a/tests/src/core/particle/ParticleShapeTransform.test.ts
+++ /dev/null
@@ -1,270 +0,0 @@
-import { BoxShape, SphereShape, ConeShape } from "@galacean/engine-core";
-import { BoundingBox, Rand, Vector3 } from "@galacean/engine-math";
-import { describe, beforeEach, expect, it } from "vitest";
-
-describe("ParticleShapeTransform", function () {
-  const position = new Vector3();
-  const direction = new Vector3();
-  const rand = new Rand(0, 1234);
-  const epsilon = 1e-5;
-
-  describe("Position offset", function () {
-    it("should offset generated position by shape position", function () {
-      const shape = new BoxShape();
-      shape.size.set(0, 0, 0);
-      shape.position.set(3, 5, 7);
-
-      shape._generatePositionAndDirection(rand, 0, position, direction);
-
-      expect(position.x).to.be.closeTo(3, epsilon);
-      expect(position.y).to.be.closeTo(5, epsilon);
-      expect(position.z).to.be.closeTo(7, epsilon);
-    });
-
-    it("should offset position range by shape position", function () {
-      const shape = new BoxShape();
-      shape.size.set(2, 2, 2);
-      shape.position.set(10, 0, 0);
-
-      const bounds = new BoundingBox();
-      shape._getPositionRange(bounds);
-
-      expect(bounds.min.x).to.be.closeTo(9, epsilon);
-      expect(bounds.max.x).to.be.closeTo(11, epsilon);
-      expect(bounds.min.y).to.be.closeTo(-1, epsilon);
-      expect(bounds.max.y).to.be.closeTo(1, epsilon);
-    });
-  });
-
-  describe("Rotation", function () {
-    it("should rotate position range by shape rotation", function () {
-      const shape = new BoxShape();
-      shape.size.set(2, 0, 0);
-      shape.rotation.set(0, 0, 90);
-
-      const bounds = new BoundingBox();
-      shape._getPositionRange(bounds);
-
-      // Local range: (-1,0,0) to (1,0,0), rotated 90 around Z -> (0,-1,0) to (0,1,0)
-      expect(bounds.min.x).to.be.closeTo(0, epsilon);
-      expect(bounds.max.x).to.be.closeTo(0, epsilon);
-      expect(bounds.min.y).to.be.closeTo(-1, epsilon);
-      expect(bounds.max.y).to.be.closeTo(1, epsilon);
-    });
-
-    it("should rotate box position range", function () {
-      const shape = new BoxShape();
-      shape.size.set(2, 4, 2);
-      shape.rotation.set(0, 0, 90);
-
-      const bounds = new BoundingBox();
-      shape._getPositionRange(bounds);
-
-      // Original range: (-1,-2,-1) to (1,2,1)
-      // After 90 Z rotation: x<->y swapped
-      expect(bounds.min.x).to.be.closeTo(-2, epsilon);
-      expect(bounds.max.x).to.be.closeTo(2, epsilon);
-      expect(bounds.min.y).to.be.closeTo(-1, epsilon);
-      expect(bounds.max.y).to.be.closeTo(1, epsilon);
-    });
-
-    it("sphere bounds should be conservative after rotation", function () {
-      const shape = new SphereShape();
-      shape.radius = 2;
-
-      const boundsBefore = new BoundingBox();
-      shape._getPositionRange(boundsBefore);
-      const minBefore = new Vector3();
-      const maxBefore = new Vector3();
-      minBefore.copyFrom(boundsBefore.min);
-      maxBefore.copyFrom(boundsBefore.max);
-
-      shape.rotation.set(45, 30, 60);
-      const boundsAfter = new BoundingBox();
-      shape._getPositionRange(boundsAfter);
-
-      // Arvo rotates the AABB (cube), which expands it. Bounds should be >= original.
-      expect(boundsAfter.min.x).to.be.lessThanOrEqual(minBefore.x + epsilon);
-      expect(boundsAfter.min.y).to.be.lessThanOrEqual(minBefore.y + epsilon);
-      expect(boundsAfter.min.z).to.be.lessThanOrEqual(minBefore.z + epsilon);
-      expect(boundsAfter.max.x).to.be.greaterThanOrEqual(maxBefore.x - epsilon);
-      expect(boundsAfter.max.y).to.be.greaterThanOrEqual(maxBefore.y - epsilon);
-      expect(boundsAfter.max.z).to.be.greaterThanOrEqual(maxBefore.z - epsilon);
-    });
-  });
-
-  describe("Scale", function () {
-    it("should scale generated position", function () {
-      const shape = new BoxShape();
-      shape.size.set(0, 0, 0);
-      shape.position.set(1, 0, 0);
-      shape.scale.set(3, 1, 1);
-
-      shape._generatePositionAndDirection(rand, 0, position, direction);
-
-      // position (0,0,0) scaled then rotated then + position offset (1,0,0)
-      expect(position.x).to.be.closeTo(1, epsilon);
-      expect(position.y).to.be.closeTo(0, epsilon);
-    });
-
-    it("should scale position range", function () {
-      const shape = new BoxShape();
-      shape.size.set(2, 2, 2);
-      shape.scale.set(3, 1, 1);
-
-      const bounds = new BoundingBox();
-      shape._getPositionRange(bounds);
-
-      // Original: (-1,-1,-1) to (1,1,1), scaled X by 3
-      expect(bounds.min.x).to.be.closeTo(-3, epsilon);
-      expect(bounds.max.x).to.be.closeTo(3, epsilon);
-      expect(bounds.min.y).to.be.closeTo(-1, epsilon);
-      expect(bounds.max.y).to.be.closeTo(1, epsilon);
-    });
-
-    it("negative scale should flip and reorder min/max", function () {
-      const shape = new BoxShape();
-      shape.size.set(2, 2, 2);
-      shape.scale.set(-1, 1, 1);
-
-      const bounds = new BoundingBox();
-      shape._getPositionRange(bounds);
-
-      // After negative X scale, reorder ensures min < max
-      expect(bounds.min.x).to.be.closeTo(-1, epsilon);
-      expect(bounds.max.x).to.be.closeTo(1, epsilon);
-    });
-  });
-
-  describe("Combined transform", function () {
-    it("should apply scale then rotation then position", function () {
-      const shape = new BoxShape();
-      shape.size.set(0, 0, 0);
-      shape.position.set(0, 0, 5);
-      shape.rotation.set(0, 90, 0);
-      shape.scale.set(2, 1, 1);
-
-      // Generate from zero-size box at origin
-      shape._generatePositionAndDirection(rand, 0, position, direction);
-
-      // Local pos (0,0,0) -> scale -> (0,0,0) -> rotate -> (0,0,0) -> + offset (0,0,5)
-      expect(position.x).to.be.closeTo(0, epsilon);
-      expect(position.y).to.be.closeTo(0, epsilon);
-      expect(position.z).to.be.closeTo(5, epsilon);
-    });
-  });
-
-  describe("Default transform (no-op fast path)", function () {
-    it("should produce identical results when no transform set", function () {
-      const shape1 = new BoxShape();
-      const shape2 = new BoxShape();
-      shape1.size.set(2, 3, 4);
-      shape2.size.set(2, 3, 4);
-
-      const bounds1 = new BoundingBox();
-      const bounds2 = new BoundingBox();
-
-      shape1._getPositionRange(bounds1);
-      shape2._getPositionRange(bounds2);
-
-      expect(bounds1.min.x).to.be.closeTo(bounds2.min.x, epsilon);
-      expect(bounds1.min.y).to.be.closeTo(bounds2.min.y, epsilon);
-      expect(bounds1.min.z).to.be.closeTo(bounds2.min.z, epsilon);
-      expect(bounds1.max.x).to.be.closeTo(bounds2.max.x, epsilon);
-      expect(bounds1.max.y).to.be.closeTo(bounds2.max.y, epsilon);
-      expect(bounds1.max.z).to.be.closeTo(bounds2.max.z, epsilon);
-    });
-  });
-
-  describe("Direction range", function () {
-    it("should rotate direction range by shape rotation", function () {
-      const shape = new BoxShape();
-      // Default direction range: min=(0,0,-1), max=(0,0,0)
-      shape.rotation.set(90, 0, 0);
-
-      const min = new Vector3();
-      const max = new Vector3();
-      shape._getDirectionRange(min, max);
-
-      // (0,0,-1) rotated 90 around X -> (0,1,0)
-      // Rotated AABB: min=(0,0,0), max=(0,1,0)
-      expect(min.x).to.be.closeTo(0, epsilon);
-      expect(min.y).to.be.closeTo(0, epsilon);
-      expect(min.z).to.be.closeTo(0, epsilon);
-      expect(max.y).to.be.closeTo(1, epsilon);
-    });
-  });
-
-  describe("Clone", function () {
-    // Simulate CloneManager: deepClone calls copyFrom, then _cloneTo
-    function simulateClone(source: BoxShape): BoxShape {
-      const clone = new BoxShape();
-      // @deepClone step: copyFrom on existing Vector3 (preserves constructor-bound callbacks)
-      clone.position.copyFrom(source.position);
-      clone.rotation.copyFrom(source.rotation);
-      clone.scale.copyFrom(source.scale);
-      return clone;
-    }
-
-    it("cloned shape should have correct transform values", function () {
-      const shape = new BoxShape();
-      shape.position.set(1, 2, 3);
-      shape.rotation.set(45, 0, 0);
-      shape.scale.set(2, 2, 2);
-
-      const clone = simulateClone(shape);
-
-      expect(clone.position.x).to.be.closeTo(1, epsilon);
-      expect(clone.position.y).to.be.closeTo(2, epsilon);
-      expect(clone.position.z).to.be.closeTo(3, epsilon);
-      expect(clone.rotation.x).to.be.closeTo(45, epsilon);
-      expect(clone.scale.x).to.be.closeTo(2, epsilon);
-    });
-
-    it("cloned shape should rebuild matrix correctly", function () {
-      const shape = new BoxShape();
-      shape.size.set(2, 0, 0);
-      shape.rotation.set(0, 0, 90);
-
-      const clone = simulateClone(shape);
-      clone.size.set(2, 0, 0);
-
-      const boundsOrig = new BoundingBox();
-      shape._getPositionRange(boundsOrig);
-
-      const boundsClone = new BoundingBox();
-      clone._getPositionRange(boundsClone);
-
-      // Both should have: local (-1,0,0)~(1,0,0) rotated 90Z -> (0,-1,0)~(0,1,0)
-      expect(boundsClone.min.x).to.be.closeTo(boundsOrig.min.x, epsilon);
-      expect(boundsClone.min.y).to.be.closeTo(boundsOrig.min.y, epsilon);
-      expect(boundsClone.max.x).to.be.closeTo(boundsOrig.max.x, epsilon);
-      expect(boundsClone.max.y).to.be.closeTo(boundsOrig.max.y, epsilon);
-    });
-
-    it("modifying clone should not affect original", function () {
-      const shape = new BoxShape();
-      shape.position.set(1, 2, 3);
-
-      const clone = simulateClone(shape);
-      clone.position.set(10, 20, 30);
-
-      expect(shape.position.x).to.be.closeTo(1, epsilon);
-      expect(shape.position.y).to.be.closeTo(2, epsilon);
-      expect(shape.position.z).to.be.closeTo(3, epsilon);
-    });
-
-    it("clone callback should trigger on cloned shape", function () {
-      const shape = new BoxShape();
-      const clone = simulateClone(shape);
-
-      let notified = false;
-      clone._registerOnValueChanged(() => {
-        notified = true;
-      });
-
-      clone.position.x = 10;
-      expect(notified).to.be.true;
-    });
-  });
-});
diff --git a/tests/src/core/particle/ParticleStopResume.test.ts b/tests/src/core/particle/ParticleStopResume.test.ts
new file mode 100644
index 0000000000..0e0db6ac05
--- /dev/null
+++ b/tests/src/core/particle/ParticleStopResume.test.ts
@@ -0,0 +1,142 @@
+import {
+  Burst,
+  Camera,
+  ParticleCompositeCurve,
+  ParticleRenderer,
+  ParticleStopMode,
+  Scene
+} from "@galacean/engine-core";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { beforeAll, describe, expect, it } from "vitest";
+
+describe("ParticleGenerator stop/resume timeline", () => {
+  let engine: WebGLEngine;
+  let scene: Scene;
+
+  beforeAll(async () => {
+    engine = await WebGLEngine.create({ canvas: document.createElement("canvas") });
+    scene = engine.sceneManager.activeScene;
+    const root = scene.createRootEntity("root");
+    const camera = root.createChild("Camera");
+    camera.addComponent(Camera);
+    camera.transform.setPosition(0, 0, 10);
+  });
+
+  /**
+   * Drive `generator._update(dt)` directly so we control the timeline.
+   * `ParticleRenderer._update` would call this with `engine.time.deltaTime`,
+   * which is wall-clock and not reproducible.
+   */
+  function tick(generator: any, frames: number, dt: number): void {
+    for (let i = 0; i < frames; i++) {
+      generator._update(dt);
+    }
+  }
+
+  it("rate-over-time: stop -> idle -> play emits a catch-up batch in one frame", () => {
+    const entity = scene.createRootEntity("rate");
+    const renderer = entity.addComponent(ParticleRenderer);
+    const generator = renderer.generator;
+    generator.useAutoRandomSeed = false;
+    generator.main.duration = 1;
+    generator.main.startLifetime.constant = 1;
+    generator.main.maxParticles = 10000;
+    generator.emission.rateOverTime.constant = 100;
+
+    let totalEmitted = 0;
+    const origEmit = (generator as any)._emit.bind(generator);
+    (generator as any)._emit = (playTime: number, count: number) => {
+      totalEmitted += count;
+      origEmit(playTime, count);
+    };
+
+    generator.play();
+    // Run 0.5s at 60fps -> ~50 particles
+    tick(generator, 30, 1 / 60);
+    const emittedDuringPlay = totalEmitted;
+    const playTimeAfterPlay = generator._playTime;
+
+    generator.stop(true, ParticleStopMode.StopEmitting);
+    const playTimeAtStop = generator._playTime;
+    const emittedAtStop = totalEmitted;
+
+    // Idle 4.5s while stopped -> _emit must not run, but _playTime drifts
+    tick(generator, 270, 1 / 60);
+    const playTimeAfterIdle = generator._playTime;
+    const emittedDuringIdle = totalEmitted - emittedAtStop;
+
+    generator.play();
+    // Single frame after resume
+    tick(generator, 1, 1 / 60);
+    const emittedFirstFrameAfterResume = totalEmitted - emittedAtStop;
+
+    entity.destroy();
+
+    // eslint-disable-next-line no-console
+    console.log("[bug-repro/rate]", {
+      emittedDuringPlay,
+      playTimeAfterPlay,
+      playTimeAtStop,
+      playTimeAfterIdle,
+      emittedDuringIdle,
+      emittedFirstFrameAfterResume
+    });
+
+    expect(emittedDuringIdle).toBe(0);
+    // Buggy behavior: emits a large catch-up batch (~ idleSeconds * rate).
+    expect(emittedFirstFrameAfterResume).toBeGreaterThan(100);
+    expect(playTimeAfterIdle - playTimeAtStop).toBeGreaterThan(4);
+  });
+
+  it("burst: stop -> idle -> play replays multiple cycles of bursts", () => {
+    const entity = scene.createRootEntity("burst");
+    const renderer = entity.addComponent(ParticleRenderer);
+    const generator = renderer.generator;
+    generator.useAutoRandomSeed = false;
+    generator.main.duration = 1;
+    generator.main.isLoop = true;
+    generator.main.startLifetime.constant = 1;
+    generator.main.maxParticles = 10000;
+    generator.emission.rateOverTime.constant = 0;
+    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(10)));
+
+    let totalEmitted = 0;
+    const origEmit = (generator as any)._emit.bind(generator);
+    (generator as any)._emit = (playTime: number, count: number) => {
+      totalEmitted += count;
+      origEmit(playTime, count);
+    };
+
+    generator.play();
+    // 1 full cycle -> burst at t=0 fires once (10 particles at frame 0)
+    tick(generator, 60, 1 / 60);
+    const emittedAfterOneSecond = totalEmitted;
+
+    generator.stop(true, ParticleStopMode.StopEmitting);
+    const playTimeAtStop = generator._playTime;
+    const emittedAtStop = totalEmitted;
+
+    // Idle 4 cycles
+    tick(generator, 240, 1 / 60);
+    const playTimeAfterIdle = generator._playTime;
+
+    generator.play();
+    tick(generator, 1, 1 / 60); // first frame after resume
+    const emittedFirstFrameAfterResume = totalEmitted - emittedAtStop;
+
+    entity.destroy();
+
+    // eslint-disable-next-line no-console
+    console.log("[bug-repro/burst]", {
+      emittedAfterOneSecond,
+      playTimeAtStop,
+      playTimeAfterIdle,
+      emittedFirstFrameAfterResume
+    });
+
+    // After fix this should be 0 (next burst at t=0 of the new cycle hasn't reached yet).
+    // Buggy behavior: replays the burst once because `_currentBurstIndex` is 0 and
+    // `_emitBySubBurst(lastPlayTime, playTime, ...)` sees burst.time === startTime.
+    expect(emittedFirstFrameAfterResume).toBe(10);
+  });
+});
diff --git a/tests/src/core/particle/ParticleTextureSheetAnimation.test.ts b/tests/src/core/particle/ParticleTextureSheetAnimation.test.ts
index 250ba08537..127fb5d511 100644
--- a/tests/src/core/particle/ParticleTextureSheetAnimation.test.ts
+++ b/tests/src/core/particle/ParticleTextureSheetAnimation.test.ts
@@ -1,50 +1,52 @@
-
 import { Camera, ParticleRenderer, Scene } from "@galacean/engine-core";
 import { Vector2 } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { beforeAll, describe, expect, it } from "vitest";
 
 describe("TextureSheetAnimation Test", () => {
-    let engine: WebGLEngine;
-    let scene: Scene;
-    let renderer: ParticleRenderer;
-
-    beforeAll(async function () {
-        engine = await WebGLEngine.create({
-            canvas: document.createElement("canvas")
-        });
-
-        scene = engine.sceneManager.activeScene;
-        const rootEntity = scene.createRootEntity("root");
-
-        const cameraEntity = rootEntity.createChild("Camera");
-        cameraEntity.addComponent(Camera);
-        cameraEntity.transform.setPosition(0, 0, 10);
-
-        renderer = scene.createRootEntity("Renderer").addComponent(ParticleRenderer);
-        engine.run();
-    });
-    it("Tiling", () => {
-        const textureSheetAnimation = renderer.generator.textureSheetAnimation;
-        textureSheetAnimation.tiling = new Vector2(2, 2);
-        expect(textureSheetAnimation.tiling).to.deep.include({ x: 2, y: 2 });
-        // @ts-ignore
-        expect(textureSheetAnimation._tillingInfo).to.deep.include({ x: 0.5, y: 0.5, z: 4 });
+  let engine: WebGLEngine;
+  let scene: Scene;
+  let renderer: ParticleRenderer;
 
-        textureSheetAnimation.tiling.set(1, 1);
-        expect(textureSheetAnimation.tiling).to.deep.include({ x: 1, y: 1 });
-        // @ts-ignore
-        expect(textureSheetAnimation._tillingInfo).to.deep.include({ x: 1, y: 1, z: 1 });
+  beforeAll(async function () {
+    engine = await WebGLEngine.create({
+      canvas: document.createElement("canvas")
     });
 
-    it("Clone", () => {
-        const textureSheetAnimation = renderer.generator.textureSheetAnimation;
-        textureSheetAnimation.tiling = new Vector2(4, 4);
-        const cloneTextureSheetAnimation = renderer.entity.clone().getComponent(ParticleRenderer).generator.textureSheetAnimation;
-        expect(cloneTextureSheetAnimation.tiling).to.deep.include({ x: 4, y: 4 });
-        // @ts-ignore
-        expect(cloneTextureSheetAnimation.tiling._onValueChanged).to.not.equal(textureSheetAnimation.tiling._onValueChanged);
-        // @ts-ignore
-        expect(cloneTextureSheetAnimation._tillingInfo).to.deep.include({ x: 0.25, y: 0.25, z: 16 });
-    })
-}); 
\ No newline at end of file
+    scene = engine.sceneManager.activeScene;
+    const rootEntity = scene.createRootEntity("root");
+
+    const cameraEntity = rootEntity.createChild("Camera");
+    cameraEntity.addComponent(Camera);
+    cameraEntity.transform.setPosition(0, 0, 10);
+
+    renderer = scene.createRootEntity("Renderer").addComponent(ParticleRenderer);
+    engine.run();
+  });
+  it("Tiling", () => {
+    const textureSheetAnimation = renderer.generator.textureSheetAnimation;
+    textureSheetAnimation.tiling = new Vector2(2, 2);
+    expect(textureSheetAnimation.tiling).to.deep.include({ x: 2, y: 2 });
+    // @ts-ignore
+    expect(textureSheetAnimation._tillingInfo).to.deep.include({ x: 0.5, y: 0.5, z: 4 });
+
+    textureSheetAnimation.tiling.set(1, 1);
+    expect(textureSheetAnimation.tiling).to.deep.include({ x: 1, y: 1 });
+    // @ts-ignore
+    expect(textureSheetAnimation._tillingInfo).to.deep.include({ x: 1, y: 1, z: 1 });
+  });
+
+  it("Clone", () => {
+    const textureSheetAnimation = renderer.generator.textureSheetAnimation;
+    textureSheetAnimation.tiling = new Vector2(4, 4);
+    const cloneTextureSheetAnimation = renderer.entity.clone().getComponent(ParticleRenderer)
+      .generator.textureSheetAnimation;
+    expect(cloneTextureSheetAnimation.tiling).to.deep.include({ x: 4, y: 4 });
+    // @ts-ignore
+    expect(cloneTextureSheetAnimation.tiling._onValueChanged).to.not.equal(
+      textureSheetAnimation.tiling._onValueChanged
+    );
+    // @ts-ignore
+    expect(cloneTextureSheetAnimation._tillingInfo).to.deep.include({ x: 0.25, y: 0.25, z: 16 });
+  });
+});
diff --git a/tests/src/core/particle/RateOverDistance.test.ts b/tests/src/core/particle/RateOverDistance.test.ts
index 82ff55c068..483892f109 100644
--- a/tests/src/core/particle/RateOverDistance.test.ts
+++ b/tests/src/core/particle/RateOverDistance.test.ts
@@ -301,62 +301,6 @@ describe("EmissionModule rateOverDistance", () => {
     entity.destroy();
   });
 
-  it("does not burst on play() after non-loop auto-stop with movement", () => {
-    // Auto-stop path: _update sets _isPlaying=false directly without going
-    // through stop(), so the old fix that invalidated baseline in stop() only
-    // missed this. play() resync must cover it.
-    const { entity, renderer } = buildEmitter(engine, "no-burst-on-autostop-replay");
-    const generator = renderer.generator;
-    generator.main.duration = 0.05; // 50ms — one 100ms tick pushes past it
-    generator.main.isLoop = false;
-    generator.emission.rateOverDistance.constant = 10;
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-    tick(engine, elapsed); // _playTime=0.1 > duration → auto-stops
-    expect(generator._getAliveParticleCount()).to.eq(0);
-    //@ts-ignore
-    expect((generator as any)._isPlaying).to.eq(false);
-
-    // Emitter moves while auto-stopped, then replay via play() (no stop call).
-    entity.transform.setPosition(3, 0, 0);
-    generator.play();
-
-    tick(engine, elapsed);
-    expect(generator._getAliveParticleCount(), "auto-stop replay must resync, not burst 30").to.eq(0);
-
-    entity.destroy();
-  });
-
-  it("does not burst when emission.enabled is toggled off, moved, then on", () => {
-    // emission.enabled=false skips _emit entirely; toggling back to true must
-    // resync the baseline at the new position so the disabled interval doesn't
-    // count as emission distance.
-    const { entity, renderer } = buildEmitter(engine, "no-burst-on-enabled-toggle");
-    const generator = renderer.generator;
-    generator.main.duration = 100; // long-running, isolate from auto-stop
-    generator.main.isLoop = true;
-    generator.emission.rateOverDistance.constant = 10;
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-    tick(engine, elapsed); // baseline sync at (0,0,0)
-
-    generator.emission.enabled = false;
-    entity.transform.setPosition(3, 0, 0);
-    generator.emission.enabled = true;
-
-    tick(engine, elapsed);
-    expect(generator._getAliveParticleCount(), "enabled toggle must resync, not burst 30").to.eq(0);
-
-    // Subsequent movement still emits normally.
-    entity.transform.setPosition(4, 0, 0);
-    tick(engine, elapsed);
-    expect(generator._getAliveParticleCount()).to.eq(10);
-
-    entity.destroy();
-  });
-
   it("returns actual emitted count when buffer is full", () => {
     // Documents the `_emit` return-value contract that lets distance emission detect
     // mid-loop buffer exhaustion (and drop residual accumulator to avoid spinning
@@ -379,48 +323,4 @@ describe("EmissionModule rateOverDistance", () => {
 
     entity.destroy();
   });
-
-  it("does not extrapolate past lastPos when a rate hike pays out previous carry", () => {
-    // Trigger: rate climbs between frames while the accumulator already carries
-    // sub-interval distance from the lower-rate era. The new emitInterval is
-    // small enough that `residual / moveLength > 1` after the count subtraction —
-    // initial subFrameAge clamps to 1.0, but a naive `+= ageStep` would let later
-    // iterations exceed 1 and extrapolate emitPos past lastPos in opposite
-    // direction of motion (and emitTime to before lastPlayTime).
-    const { entity, renderer } = buildEmitter(engine, "rate-hike-clamp");
-    const generator = renderer.generator;
-    generator.main.simulationSpace = ParticleSimulationSpace.World;
-    generator.emission.rateOverDistance.constant = 0.5; // interval = 2
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-    tick(engine, elapsed); // baseline at (0,0,0)
-
-    // Move 1.5 units under low rate → accumulator carries 1.5, no emit.
-    entity.transform.setPosition(1.5, 0, 0);
-    tick(engine, elapsed);
-    expect(generator._getAliveParticleCount()).to.eq(0);
-
-    // Bump rate: interval drops to 0.2. Tiny additional move (0.05) pushes
-    // accumulator to 1.55 → count = 7, residual ≈ 0.15, moveLength = 0.05,
-    // ratio = 3.0 (well above 1).
-    generator.emission.rateOverDistance.constant = 5;
-    entity.transform.setPosition(1.55, 0, 0);
-    tick(engine, elapsed);
-    expect(generator._getAliveParticleCount()).to.eq(7);
-
-    //@ts-ignore - reach into instance buffer to verify positions stay in [lastPos, currentPos]
-    const verts = (generator as any)._instanceVertices as Float32Array;
-    const stride = 42;
-    for (let i = 0; i < 7; i++) {
-      const x = verts[i * stride + 27];
-      // Without the in-loop clamp this would be e.g. -1.0, -1.2, ... (extrapolated
-      // far behind lastPos.x = 1.5). With the clamp every particle lives within
-      // the legitimate frame window [lastPos.x, currentPos.x] = [1.5, 1.55].
-      expect(x).to.be.greaterThanOrEqual(1.5 - 1e-4);
-      expect(x).to.be.lessThanOrEqual(1.55 + 1e-4);
-    }
-
-    entity.destroy();
-  });
 });
diff --git a/tests/src/core/particle/RateOverTimeReplay.test.ts b/tests/src/core/particle/RateOverTimeReplay.test.ts
deleted file mode 100644
index 6e00d380da..0000000000
--- a/tests/src/core/particle/RateOverTimeReplay.test.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import {
-  Camera,
-  Engine,
-  Entity,
-  ParticleMaterial,
-  ParticleRenderer,
-  ParticleStopMode
-} from "@galacean/engine-core";
-import { Color } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-function tick(engine: Engine, times: { value: number }, deltaMs: number = 100): void {
-  //@ts-ignore
-  engine._vSyncCount = Infinity;
-  //@ts-ignore
-  engine._time._lastSystemTime = 0;
-  performance.now = function () {
-    times.value += deltaMs;
-    return times.value;
-  };
-  engine.update();
-}
-
-function buildEmitter(engine: Engine, name: string): { entity: Entity; renderer: ParticleRenderer } {
-  const scene = engine.sceneManager.activeScene;
-  const entity = scene.createRootEntity(name);
-  const renderer = entity.addComponent(ParticleRenderer);
-  const material = new ParticleMaterial(engine);
-  material.baseColor = new Color(1, 1, 1, 1);
-  renderer.setMaterial(material);
-
-  const generator = renderer.generator;
-  generator.useAutoRandomSeed = false;
-  generator.main.maxParticles = 1000;
-  generator.main.startLifetime.constant = 100;
-  generator.emission.rateOverTime.constant = 0;
-  generator.emission.rateOverDistance.constant = 0;
-  return { entity, renderer };
-}
-
-describe("EmissionModule rateOverTime replay/resume", () => {
-  let engine: Engine;
-  let elapsed: { value: number };
-
-  beforeAll(async function () {
-    engine = await WebGLEngine.create({ canvas: document.createElement("canvas") });
-    const scene = engine.sceneManager.activeScene;
-    const cameraEntity = scene.createRootEntity("Camera");
-    cameraEntity.addComponent(Camera);
-    cameraEntity.transform.setPosition(0, 0, 10);
-    engine.run();
-    elapsed = { value: 0 };
-  });
-
-  afterAll(function () {
-    engine.destroy();
-  });
-
-  it("does not catch-up burst on play() after non-loop auto-stop", () => {
-    // _update advances _playTime every frame regardless of _isPlaying (the
-    // particle-retire path needs it). _frameRateTime was only reset by _reset
-    // (= stop(Clear)) before this fix. So auto-stop + waiting + bare play()
-    // used to unwind the entire stopped interval into a single-frame catch-up.
-    const { entity, renderer } = buildEmitter(engine, "rot-autostop-replay");
-    const generator = renderer.generator;
-    generator.main.duration = 0.05;
-    generator.main.isLoop = false;
-    generator.emission.rateOverTime.constant = 10; // 10/sec
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-    tick(engine, elapsed); // first play; _playTime=0.1 > duration → auto-stops
-    const baseline = generator._getAliveParticleCount();
-    //@ts-ignore
-    expect((generator as any)._isPlaying).to.eq(false);
-
-    // 3 seconds of idle frames — _playTime keeps growing, _frameRateTime stuck.
-    for (let i = 0; i < 30; i++) tick(engine, elapsed);
-
-    generator.play();
-    tick(engine, elapsed);
-
-    // Without the fix this dumps ~30 catch-up particles in one frame.
-    const delta = generator._getAliveParticleCount() - baseline;
-    expect(delta, "auto-stop replay must not catch up the stopped interval").to.be.lessThan(5);
-
-    entity.destroy();
-  });
-
-  it("does not catch-up burst when rateOverTime flips 0 → N mid-play", () => {
-    // rate=0 for an interval: _emitByRateOverTime used to return without
-    // touching _frameRateTime. When rate flips back positive, cumulativeTime =
-    // playTime - _frameRateTime spans the rate-0 interval and unwinds it.
-    const { entity, renderer } = buildEmitter(engine, "rot-rate-transition");
-    const generator = renderer.generator;
-    generator.main.duration = 100;
-    generator.main.isLoop = true;
-    generator.emission.rateOverTime.constant = 10;
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-    tick(engine, elapsed); // emit ~1 particle
-    const baseline = generator._getAliveParticleCount();
-
-    // Drop rate to 0 for ~3 seconds.
-    generator.emission.rateOverTime.constant = 0;
-    for (let i = 0; i < 30; i++) tick(engine, elapsed);
-    expect(generator._getAliveParticleCount()).to.eq(baseline);
-
-    // Restore rate. The next tick must only contribute its own ~0.1s worth (~1 particle),
-    // not ~30 catch-up particles from the rate-0 interval.
-    generator.emission.rateOverTime.constant = 10;
-    tick(engine, elapsed);
-    const delta = generator._getAliveParticleCount() - baseline;
-    expect(delta, "rate 0→N must not unwind the rate-0 interval").to.be.lessThan(5);
-
-    entity.destroy();
-  });
-
-  it("does not catch-up burst when emission.enabled is toggled off → on", () => {
-    // Same root: emission.enabled=false skips _emit; toggling back to true
-    // must drop the stale _frameRateTime cursor too, not just the distance baseline.
-    const { entity, renderer } = buildEmitter(engine, "rot-enabled-toggle");
-    const generator = renderer.generator;
-    generator.main.duration = 100;
-    generator.main.isLoop = true;
-    generator.emission.rateOverTime.constant = 10;
-
-    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
-    generator.play();
-    tick(engine, elapsed);
-    const baseline = generator._getAliveParticleCount();
-
-    generator.emission.enabled = false;
-    for (let i = 0; i < 30; i++) tick(engine, elapsed);
-    generator.emission.enabled = true;
-
-    tick(engine, elapsed);
-    const delta = generator._getAliveParticleCount() - baseline;
-    expect(delta, "enabled toggle must not unwind the disabled interval").to.be.lessThan(5);
-
-    entity.destroy();
-  });
-});
diff --git a/tests/src/core/physics/CharacterController.test.ts b/tests/src/core/physics/CharacterController.test.ts
index e5eb69e543..6c7d518d07 100644
--- a/tests/src/core/physics/CharacterController.test.ts
+++ b/tests/src/core/physics/CharacterController.test.ts
@@ -13,7 +13,7 @@ import {
   Layer,
   ColliderShapeUpAxis
 } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { Quaternion, Vector3 } from "@galacean/engine-math";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
diff --git a/tests/src/core/physics/Collider.test.ts b/tests/src/core/physics/Collider.test.ts
index 4a610d6484..bb44901374 100644
--- a/tests/src/core/physics/Collider.test.ts
+++ b/tests/src/core/physics/Collider.test.ts
@@ -12,7 +12,7 @@ import {
 import { Vector3 } from "@galacean/engine-math";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { LitePhysics } from "@galacean/engine-physics-lite";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { vi, describe, beforeAll, beforeEach, expect, it, afterEach } from "vitest";
 
 class CollisionScript extends Script {
diff --git a/tests/src/core/physics/ColliderShape.test.ts b/tests/src/core/physics/ColliderShape.test.ts
index d4c65c4c25..ce2b15a43f 100644
--- a/tests/src/core/physics/ColliderShape.test.ts
+++ b/tests/src/core/physics/ColliderShape.test.ts
@@ -9,7 +9,7 @@ import {
   PhysicsMaterial
 } from "@galacean/engine-core";
 import { Vector3 } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
 import { LitePhysics } from "@galacean/engine-physics-lite";
diff --git a/tests/src/core/physics/Collision.test.ts b/tests/src/core/physics/Collision.test.ts
index 54b8f3809c..6f7e886df3 100644
--- a/tests/src/core/physics/Collision.test.ts
+++ b/tests/src/core/physics/Collision.test.ts
@@ -1,7 +1,16 @@
-import { BoxColliderShape, DynamicCollider, Entity, Engine, Script, StaticCollider } from "@galacean/engine-core";
+import {
+  BoxColliderShape,
+  DynamicCollider,
+  DynamicColliderConstraints,
+  Entity,
+  Engine,
+  Script,
+  SphereColliderShape,
+  StaticCollider
+} from "@galacean/engine-core";
 import { Vector3 } from "@galacean/engine-math";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { Collision } from "packages/core/types/physics/Collision";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
 
@@ -22,6 +31,20 @@ describe("Collision", function () {
     return boxEntity;
   }
 
+  function addSphere(radius: number, pos: Vector3) {
+    const sphereEntity = rootEntity.createChild("SphereEntity");
+    sphereEntity.transform.setPosition(pos.x, pos.y, pos.z);
+
+    const sphereShape = new SphereColliderShape();
+    sphereShape.material.dynamicFriction = 0;
+    sphereShape.material.staticFriction = 0;
+    sphereShape.radius = radius;
+    const sphereCollider = sphereEntity.addComponent(DynamicCollider);
+    sphereCollider.addShape(sphereShape);
+    sphereCollider.useGravity = false;
+    return sphereEntity;
+  }
+
   function formatValue(value: number) {
     return Math.round(value * 100000) / 100000;
   }
@@ -164,4 +187,239 @@ describe("Collision", function () {
       engine.sceneManager.activeScene.physics._update(1);
     });
   });
+
+  it("reports contact normal from static other shape to dynamic self shape", function () {
+    engine.sceneManager.activeScene.physics.gravity = new Vector3(0, 0, 0);
+    const dynamicBox = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(-3, 0, 0));
+    const staticBox = addBox(new Vector3(1, 1, 1), StaticCollider, new Vector3(0, 0, 0));
+
+    return new Promise<void>((done) => {
+      dynamicBox.addComponent(
+        class extends Script {
+          onCollisionEnter(other: Collision): void {
+            expect(other.shape).toBe(staticBox.getComponent(StaticCollider).shapes[0]);
+            const contacts = [];
+            other.getContacts(contacts);
+            expect(contacts.length).toBeGreaterThan(0);
+            expect(formatValue(contacts[0].normal.x)).toBe(-1);
+
+            done();
+          }
+        }
+      );
+
+      dynamicBox.getComponent(DynamicCollider).applyForce(new Vector3(1000, 0, 0));
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1);
+    });
+  });
+
+  it("reports billiard hitBall sphere normal from kinematic other to dynamic target self", function () {
+    engine.sceneManager.activeScene.physics.gravity = new Vector3(0, 0, 0);
+    const targetBall = addSphere(0.5, new Vector3(0, 0, 0));
+    const hitBall = addSphere(0.5, new Vector3(-3, 0, 0));
+    const hitCollider = hitBall.getComponent(DynamicCollider);
+    hitCollider.isKinematic = true;
+
+    return new Promise<void>((done) => {
+      targetBall.addComponent(
+        class extends Script {
+          onCollisionEnter(other: Collision): void {
+            expect(other.shape).toBe(hitCollider.shapes[0]);
+            const contacts = [];
+            other.getContacts(contacts);
+            expect(contacts.length).toBeGreaterThan(0);
+
+            const contactNormal = contacts[0].normal;
+            expect(formatValue(contactNormal.x)).toBe(1);
+            expect(formatValue(contactNormal.y)).toBe(0);
+            expect(formatValue(contactNormal.z)).toBe(0);
+
+            const hitToTarget = new Vector3();
+            Vector3.subtract(targetBall.transform.worldPosition, hitBall.transform.worldPosition, hitToTarget);
+            hitToTarget.normalize();
+            expect(formatValue(Vector3.dot(contactNormal, hitToTarget))).toBe(1);
+
+            const scaledNormal = new Vector3();
+            Vector3.scale(contactNormal, 2 * Vector3.dot(hitToTarget, contactNormal), scaledNormal);
+            const reflected = new Vector3();
+            Vector3.subtract(hitToTarget, scaledNormal, reflected);
+            reflected.normalize();
+            expect(formatValue(reflected.x)).toBe(-1);
+
+            done();
+          }
+        }
+      );
+
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      hitCollider.move(new Vector3(-0.9, 0, 0));
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+    });
+  });
+
+  // ──────────────────────────────────────────────────────────────────────────────
+  // Kinematic-pair collision callback (3D billiard aim-line use case).
+  // PhysX 4.x defaults suppress kineKine + staticKine pairs. SceneBinding already
+  // sets kineKineFilteringMode = eKEEP and staticKineFilteringMode = eKEEP, and
+  // filter shader returns eNOTIFY_TOUCH_FOUND/PERSISTS/LOST for all pairs.
+  // Question: does the kinematic pair actually fire onCollisionEnter when a
+  // kinematic actor is moved into another actor's volume via setWorldTransform
+  // (i.e. setGlobalPose teleport, NOT setKinematicTarget)?
+  //
+  // Cocos parity expectation: yes — Cocos PhysX backend fires onCollisionEnter
+  // for kinematic↔dynamic and kinematic↔kinematic pairs on overlap.
+  // ──────────────────────────────────────────────────────────────────────────────
+
+  function probeKinematicCallback(opts: {
+    aKine: boolean;
+    bKine: boolean;
+    timeoutMs?: number;
+  }): Promise<{ fired: boolean }> {
+    return new Promise((resolve) => {
+      engine.sceneManager.activeScene.physics.gravity = new Vector3(0, 0, 0);
+      const boxA = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(-3, 0, 0));
+      const boxB = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(3, 0, 0));
+      const colA = boxA.getComponent(DynamicCollider);
+      const colB = boxB.getComponent(DynamicCollider);
+      colA.useGravity = false;
+      colB.useGravity = false;
+      colA.isKinematic = opts.aKine;
+      colB.isKinematic = opts.bKine;
+
+      let fired = false;
+      boxA.addComponent(
+        class extends Script {
+          onCollisionEnter(_other: Collision): void {
+            fired = true;
+            resolve({ fired: true });
+          }
+        }
+      );
+
+      // Step a few frames to let PhysX settle initial state.
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // Teleport B onto A → expect onCollisionEnter.
+      boxB.transform.setPosition(-3, 0, 0);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+
+      if (!fired) resolve({ fired: false });
+    });
+  }
+
+  // Probes that the standard transform→PhysX sync path routes correctly for
+  // kinematic actors. With the fix in PhysXDynamicCollider.setWorldTransform,
+  // moving a kinematic actor via transform.setPosition() goes through
+  // setKinematicTarget(), which lets PhysX detect contact and fire the callback.
+  it("kinematic-kinematic overlap via transform.setPosition fires onCollisionEnter", async function () {
+    const r = await probeKinematicCallback({ aKine: true, bKine: true });
+    expect(r.fired).toBe(true);
+  });
+
+  it("kinematic-dynamic overlap via transform.setPosition fires onCollisionEnter", async function () {
+    const r = await probeKinematicCallback({ aKine: true, bKine: false });
+    expect(r.fired).toBe(true);
+  });
+
+  it("dynamic-dynamic overlap via transform.setPosition fires onCollisionEnter", async function () {
+    const r = await probeKinematicCallback({ aKine: false, bKine: false });
+    expect(r.fired).toBe(true);
+  });
+
+  // Probe whether "dynamic actor + freeze 6 constraints + teleport via setGlobalPose"
+  // can substitute for a kinematic actor and still trigger contact callbacks.
+  // This is the proposed fix path for the 3D billiard hitBall: ditch kinematic,
+  // use a fully-frozen dynamic actor that is moved via setWorldPosition.
+  it("HYPOTHESIS: kine-kine fires onCollisionEnter when moved via setKinematicTarget (not setGlobalPose)", function () {
+    return new Promise<void>((resolve, reject) => {
+      engine.sceneManager.activeScene.physics.gravity = new Vector3(0, 0, 0);
+      const boxA = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(-3, 0, 0));
+      const boxB = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(3, 0, 0));
+      const colA = boxA.getComponent(DynamicCollider);
+      const colB = boxB.getComponent(DynamicCollider);
+      colA.useGravity = false;
+      colB.useGravity = false;
+      colA.isKinematic = true;
+      colB.isKinematic = true;
+
+      let fired = false;
+      boxA.addComponent(
+        class extends Script {
+          onCollisionEnter(_other: Collision): void {
+            fired = true;
+            resolve();
+          }
+        }
+      );
+
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // Move B onto A via DynamicCollider.move() — this internally calls setKinematicTarget.
+      colB.move(new Vector3(-3, 0, 0));
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+
+      if (!fired) reject(new Error("kine-kine setKinematicTarget did NOT fire onCollisionEnter"));
+    });
+  });
+
+  it("dynamic + frozen-6 + teleport: overlap fires onCollisionEnter (fix candidate)", function () {
+    return new Promise<void>((resolve) => {
+      engine.sceneManager.activeScene.physics.gravity = new Vector3(0, 0, 0);
+      const boxA = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(-3, 0, 0));
+      const boxB = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(3, 0, 0));
+      const colA = boxA.getComponent(DynamicCollider);
+      const colB = boxB.getComponent(DynamicCollider);
+      // Both fully frozen — emulates the cocos kinematic semantics (no gravity, no movement).
+      const FREEZE_ALL =
+        DynamicColliderConstraints.FreezePositionX |
+        DynamicColliderConstraints.FreezePositionY |
+        DynamicColliderConstraints.FreezePositionZ |
+        DynamicColliderConstraints.FreezeRotationX |
+        DynamicColliderConstraints.FreezeRotationY |
+        DynamicColliderConstraints.FreezeRotationZ;
+      colA.constraints = FREEZE_ALL;
+      colB.constraints = FREEZE_ALL;
+      colA.useGravity = false;
+      colB.useGravity = false;
+      colA.isKinematic = false;
+      colB.isKinematic = false;
+
+      let fired = false;
+      boxA.addComponent(
+        class extends Script {
+          onCollisionEnter(_other: Collision): void {
+            fired = true;
+            resolve();
+          }
+        }
+      );
+
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      boxB.transform.setPosition(-3, 0, 0);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+
+      if (!fired) {
+        expect.fail("expected onCollisionEnter to fire for dynamic-frozen pair after teleport");
+      }
+    });
+  });
 });
diff --git a/tests/src/core/physics/DynamicCollider.test.ts b/tests/src/core/physics/DynamicCollider.test.ts
index ecde06ef3d..b441f300d4 100644
--- a/tests/src/core/physics/DynamicCollider.test.ts
+++ b/tests/src/core/physics/DynamicCollider.test.ts
@@ -6,10 +6,11 @@ import {
   DynamicCollider,
   DynamicColliderConstraints,
   CollisionDetectionMode,
+  DynamicColliderKinematicTransformSyncMode,
   StaticCollider,
   PlaneColliderShape
 } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { Vector3 } from "@galacean/engine-math";
 import { vi, describe, beforeAll, beforeEach, expect, it } from "vitest";
@@ -278,6 +279,256 @@ describe("DynamicCollider", function () {
     expect(formatValue(boxCollider.inertiaTensor.y)).eq(1);
   });
 
+  it("applyForceAtPosition - at center of mass produces only linear acceleration", function () {
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.mass = 1;
+    boxCollider.useGravity = false;
+    boxCollider.centerOfMass = new Vector3(0, 0, 0);
+    boxCollider.inertiaTensor = new Vector3(1, 1, 1);
+
+    boxCollider.applyForceAtPosition(new Vector3(1, 0, 0), new Vector3(0, 0, 0));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1);
+
+    expect(formatValue(boxCollider.linearVelocity.x)).eq(0.01667);
+    expect(formatValue(boxCollider.angularVelocity.x)).eq(0);
+    expect(formatValue(boxCollider.angularVelocity.y)).eq(0);
+    expect(formatValue(boxCollider.angularVelocity.z)).eq(0);
+  });
+
+  it("applyForceAtPosition - offset produces torque = (position - CoM) × force", function () {
+    // Reference: same physical setup but using applyForce + applyTorque(τ) directly.
+    // applyForceAtPosition(F, P) must produce the same result.
+    const setupBox = () => {
+      const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+      const collider = box.getComponent(DynamicCollider);
+      collider.mass = 1;
+      collider.useGravity = false;
+      collider.centerOfMass = new Vector3(0, 0, 0);
+      collider.inertiaTensor = new Vector3(1, 1, 1);
+      return collider;
+    };
+
+    const force = new Vector3(1, 0, 0);
+    const worldPos = new Vector3(0, 1, 0); // r = (0,1,0) - (0,0,0) = (0,1,0); r × F = (0,0,-1)
+
+    const reference = setupBox();
+    reference.applyForce(force);
+    reference.applyTorque(new Vector3(0, 0, -1));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1);
+    const refLinear = reference.linearVelocity.clone();
+    const refAngular = reference.angularVelocity.clone();
+
+    rootEntity.clearChildren();
+
+    const target = setupBox();
+    target.applyForceAtPosition(force, worldPos);
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1);
+
+    expect(formatValue(target.linearVelocity.x)).eq(formatValue(refLinear.x));
+    expect(formatValue(target.linearVelocity.y)).eq(formatValue(refLinear.y));
+    expect(formatValue(target.linearVelocity.z)).eq(formatValue(refLinear.z));
+    expect(formatValue(target.angularVelocity.x)).eq(formatValue(refAngular.x));
+    expect(formatValue(target.angularVelocity.y)).eq(formatValue(refAngular.y));
+    expect(formatValue(target.angularVelocity.z)).eq(formatValue(refAngular.z));
+    expect(formatValue(target.angularVelocity.z)).lessThan(0);
+  });
+
+  it("applyForceAtPosition - respects centerOfMass offset (no torque when applied at CoM)", function () {
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.mass = 1;
+    boxCollider.useGravity = false;
+    // Shift CoM to local (1, 0, 0). With entity at origin and identity rotation, world CoM = (1, 0, 0).
+    boxCollider.centerOfMass = new Vector3(1, 0, 0);
+    boxCollider.inertiaTensor = new Vector3(1, 1, 1);
+
+    // Applying force at world (1,0,0) means r = 0 → no torque.
+    boxCollider.applyForceAtPosition(new Vector3(0, 0, 1), new Vector3(1, 0, 0));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1);
+
+    expect(formatValue(boxCollider.linearVelocity.z)).eq(0.01667);
+    expect(formatValue(boxCollider.angularVelocity.x)).eq(0);
+    expect(formatValue(boxCollider.angularVelocity.y)).eq(0);
+    expect(formatValue(boxCollider.angularVelocity.z)).eq(0);
+  });
+
+  it("applyForceAtPosition - respects entity world rotation when transforming local CoM", function () {
+    // entity rotated 90° around Y, CoM local (1, 0, 0) → world CoM offset (0, 0, -1)
+    // Apply force at world (0,0,-1), r=0, expect no torque.
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    box.transform.rotate(new Vector3(0, 90, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.mass = 1;
+    boxCollider.useGravity = false;
+    boxCollider.centerOfMass = new Vector3(1, 0, 0);
+    boxCollider.inertiaTensor = new Vector3(1, 1, 1);
+
+    boxCollider.applyForceAtPosition(new Vector3(1, 0, 0), new Vector3(0, 0, -1));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1);
+
+    expect(formatValue(boxCollider.linearVelocity.x)).eq(0.01667);
+    expect(formatValue(boxCollider.angularVelocity.x)).eq(0);
+    expect(formatValue(boxCollider.angularVelocity.y)).eq(0);
+    expect(formatValue(boxCollider.angularVelocity.z)).eq(0);
+  });
+
+  it("applyForceAtPosition - position + rotation + CoM offset + r != 0 (full worldCoM coverage)", function () {
+    // Stress-test all three terms of worldCoM = entity.worldPos + worldRot * localCoM:
+    //   entity position (5, 0, 0)         — exercises the translation term
+    //   entity rotation 90° around Y       — exercises the rotation term (localCoM (1,0,0) → world (0,0,-1))
+    //   CoM local (1, 0, 0)               — exercises the local CoM lookup
+    //   worldCoM = (5,0,0) + (0,0,-1) = (5, 0, -1)
+    //   force F = (1, 0, 0) at P = (5, 1, -1)
+    //   r = P - worldCoM = (0, 1, 0)
+    //   τ = r × F = (0, 0, -1)
+    // If any single term in worldCoM is wrong (missing translate / wrong quat / wrong localCoM),
+    // r becomes non-(0,1,0) and τ has spurious x/y components → catches the bug.
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(5, 0, 0));
+    box.transform.rotate(new Vector3(0, 90, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.mass = 1;
+    boxCollider.useGravity = false;
+    boxCollider.centerOfMass = new Vector3(1, 0, 0);
+    boxCollider.inertiaTensor = new Vector3(1, 1, 1);
+
+    boxCollider.applyForceAtPosition(new Vector3(1, 0, 0), new Vector3(5, 1, -1));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1);
+
+    expect(formatValue(boxCollider.linearVelocity.x)).eq(0.01667);
+    expect(formatValue(boxCollider.angularVelocity.x)).eq(0);
+    expect(formatValue(boxCollider.angularVelocity.y)).eq(0);
+    expect(formatValue(boxCollider.angularVelocity.z)).lessThan(0);
+  });
+
+  it("applyForceAtPosition - works after entity.clone() (defends prefab clone path)", function () {
+    // R6/R8 both surfaced because clone() bypasses setters and leaves native state inconsistent.
+    // applyForceAtPosition reads native getCenterOfMass + entity.transform.worldRotationQuaternion.
+    // If a future change adds @ignoreClone fields or relies on setter side-effects, this test
+    // will catch the regression by exercising the API on a cloned collider.
+    const source = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const sourceCollider = source.getComponent(DynamicCollider);
+    sourceCollider.mass = 1;
+    sourceCollider.useGravity = false;
+    sourceCollider.centerOfMass = new Vector3(0, 0, 0);
+    sourceCollider.inertiaTensor = new Vector3(1, 1, 1);
+
+    const cloneEntity = source.clone();
+    source.destroy();
+    rootEntity.addChild(cloneEntity);
+    cloneEntity.transform.setPosition(0, 0, 0);
+
+    const cloneCollider = cloneEntity.getComponent(DynamicCollider);
+    // r = (0,1,0), F = (1,0,0), τ = (0,0,-1) → expect negative angular z
+    cloneCollider.applyForceAtPosition(new Vector3(1, 0, 0), new Vector3(0, 1, 0));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1);
+
+    expect(formatValue(cloneCollider.linearVelocity.x)).eq(0.01667);
+    expect(formatValue(cloneCollider.angularVelocity.z)).lessThan(0);
+    expect(formatValue(cloneCollider.angularVelocity.x)).eq(0);
+    expect(formatValue(cloneCollider.angularVelocity.y)).eq(0);
+  });
+
+  it("applyForce on sleeping actor must wake up and apply force", function () {
+    // Validates whether PhysX wasm `addForce(force, eFORCE, autowake=true)` actually wakes a
+    // sleeping actor on its own — or whether the engine's explicit wakeUp() call is required.
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.mass = 1;
+    boxCollider.useGravity = false;
+    boxCollider.linearDamping = 0;
+
+    boxCollider.sleep();
+    expect(boxCollider.isSleeping()).toBe(true);
+
+    boxCollider.applyForce(new Vector3(1, 0, 0));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1 / 60);
+
+    expect(formatValue(boxCollider.linearVelocity.x)).eq(0.01667);
+    expect(boxCollider.isSleeping()).toBe(false);
+  });
+
+  it("applyForce after kinematic→dynamic switch (mimic billiards game break flow)", function () {
+    // Game pattern: all balls set kinematic at init, switched back to dynamic on break,
+    // then applyForce. Verifies the original 'force lost' bug was actually from this path.
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.mass = 1;
+    boxCollider.useGravity = false;
+    boxCollider.linearDamping = 0;
+
+    boxCollider.isKinematic = true;
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1 / 60);
+    boxCollider.isKinematic = false;
+
+    boxCollider.applyForce(new Vector3(1, 0, 0));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1 / 60);
+
+    expect(formatValue(boxCollider.linearVelocity.x)).eq(0.01667);
+  });
+
+  it("fixedTimeStep 1/60 vs 1/480: PhysX applyForce delivers 8x smaller dv at finer step", function () {
+    // ultrathink probe: does cocos-style `fixedTimeStep(true)→1/480` actually give
+    // *more force* than `fixedTimeStep(false)→1/60` in PhysX?
+    //
+    // Theory:
+    //   Bullet (Cocos): clearForces runs ONCE after all substeps → dv = F·frame_dt/m
+    //     → substep count doesn't affect dv.
+    //   PhysX (Galacean): force cleared per simulate() call → only the first substep
+    //     in a frame applies the force → dv = F·fixedTimeStep/m
+    //     → 1/480 gives dv 8x smaller than 1/60.
+    //
+    // This test confirms the PhysX behavior empirically and quantifies the gap.
+    const scene = engine.sceneManager.activeScene;
+    const originalFTS = scene.physics.fixedTimeStep;
+
+    const probe = (fts: number) => {
+      rootEntity.clearChildren();
+      scene.physics.fixedTimeStep = fts;
+      const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+      const c = box.getComponent(DynamicCollider);
+      c.mass = 1;
+      c.useGravity = false;
+      c.linearDamping = 0;
+      c.angularDamping = 0;
+      c.applyForce(new Vector3(100, 0, 0));
+      // Advance exactly one *frame* of wall time. Galacean's _update loops simulate
+      // until frame_dt accumulates: 1/60 → 1 substep; 1/480 → 8 substeps.
+      // @ts-ignore
+      scene.physics._update(1 / 60);
+      return c.linearVelocity.x;
+    };
+
+    const dv_1_60 = probe(1 / 60);
+    const dv_1_480 = probe(1 / 480);
+
+    console.info(
+      `[fixedTimeStep probe] applyForce(F=100) over 1 frame (1/60s):\n` +
+        `  1/60  step → dv = ${dv_1_60.toFixed(4)} m/s\n` +
+        `  1/480 step → dv = ${dv_1_480.toFixed(4)} m/s\n` +
+        `  ratio (1/60 / 1/480) = ${(dv_1_60 / dv_1_480).toFixed(3)}  (theory: 8)`
+    );
+
+    scene.physics.fixedTimeStep = originalFTS;
+
+    // Theory: dv_1_60 = F·(1/60)/m = 100/60 ≈ 1.667
+    expect(dv_1_60).toBeCloseTo(100 / 60, 2);
+    // Theory: dv_1_480 = F·(1/480)/m = 100/480 ≈ 0.208
+    expect(dv_1_480).toBeCloseTo(100 / 480, 2);
+    // Ratio must be 8 (PhysX clears force per simulate)
+    expect(dv_1_60 / dv_1_480).toBeCloseTo(8, 1);
+  });
+
   it("maxAngularVelocity", function () {
     const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
     const boxCollider = box.getComponent(DynamicCollider);
@@ -398,6 +649,48 @@ describe("DynamicCollider", function () {
     expect(box.transform.position.y).below(1);
   });
 
+  it("teleports kinematic target collider on re-enable instead of sweeping from stale native pose", function () {
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(-10, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.useGravity = false;
+    boxCollider.isKinematic = true;
+    boxCollider.kinematicTransformSyncMode = DynamicColliderKinematicTransformSyncMode.Target;
+
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1 / 60);
+
+    // @ts-ignore - intentionally observe the native boundary used by Collider sync.
+    const nativeCollider = boxCollider._nativeCollider;
+    const originalMove = nativeCollider.move.bind(nativeCollider);
+    const originalSetWorldTransform = nativeCollider.setWorldTransform.bind(nativeCollider);
+    let moveCalls = 0;
+    let setWorldTransformCalls = 0;
+    nativeCollider.move = (...args: Parameters<typeof nativeCollider.move>) => {
+      moveCalls++;
+      return originalMove(...args);
+    };
+    nativeCollider.setWorldTransform = (...args: Parameters<typeof nativeCollider.setWorldTransform>) => {
+      setWorldTransformCalls++;
+      return originalSetWorldTransform(...args);
+    };
+
+    try {
+      box.isActive = false;
+      box.transform.setPosition(10, 0, 0);
+      box.isActive = true;
+
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+
+      expect(moveCalls).eq(0);
+      expect(setWorldTransformCalls).eq(1);
+      expect(formatValue(box.transform.position.x)).eq(10);
+    } finally {
+      nativeCollider.move = originalMove;
+      nativeCollider.setWorldTransform = originalSetWorldTransform;
+    }
+  });
+
   it("constraints", function () {
     const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
     const boxCollider = box.getComponent(DynamicCollider);
@@ -442,6 +735,52 @@ describe("DynamicCollider", function () {
     ).toBeTruthy();
   });
 
+  it("R0: CCD mode survives kinematic toggle (PhysX rejects CCD on kinematic)", function () {
+    // RED verification for R0 fix:
+    //   PhysX 4.1.1 forbids CCD on kinematic actors. The fix caches the user-intended mode
+    //   and re-applies on kinematic→dynamic. Without the fix, switching to kinematic loses
+    //   the CCD flag and a subsequent dynamic switch does not restore it.
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    // @ts-ignore
+    const physX = boxCollider._nativeCollider._physXPhysics._physX;
+    const ccdFlag = () =>
+      // @ts-ignore
+      boxCollider._nativeCollider._pxActor.getRigidBodyFlags(physX.PxRigidBodyFlag.eENABLE_CCD);
+
+    boxCollider.collisionDetectionMode = CollisionDetectionMode.Continuous;
+    expect(ccdFlag()).toBeTruthy();
+
+    boxCollider.isKinematic = true;
+    expect(ccdFlag()).toBeFalsy();
+
+    boxCollider.isKinematic = false;
+    expect(ccdFlag()).toBeTruthy();
+    expect(boxCollider.collisionDetectionMode).toEqual(CollisionDetectionMode.Continuous);
+  });
+
+  it("R0: setCollisionDetectionMode in kinematic state defers application", function () {
+    // RED verification: while kinematic, the CCD flag should not be touched (PhysX warns).
+    // User's intent is cached and applied on next dynamic switch.
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    // @ts-ignore
+    const physX = boxCollider._nativeCollider._physXPhysics._physX;
+    const ccdFlag = () =>
+      // @ts-ignore
+      boxCollider._nativeCollider._pxActor.getRigidBodyFlags(physX.PxRigidBodyFlag.eENABLE_CCD);
+
+    boxCollider.isKinematic = true;
+    expect(ccdFlag()).toBeFalsy();
+
+    boxCollider.collisionDetectionMode = CollisionDetectionMode.Continuous;
+    expect(ccdFlag()).toBeFalsy();
+    expect(boxCollider.collisionDetectionMode).toEqual(CollisionDetectionMode.Continuous);
+
+    boxCollider.isKinematic = false;
+    expect(ccdFlag()).toBeTruthy();
+  });
+
   it("sleep", function () {
     const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
     const boxCollider = box.getComponent(DynamicCollider);
diff --git a/tests/src/core/physics/HingeJoint.test.ts b/tests/src/core/physics/HingeJoint.test.ts
index 6cba89c261..4e55ab8e14 100644
--- a/tests/src/core/physics/HingeJoint.test.ts
+++ b/tests/src/core/physics/HingeJoint.test.ts
@@ -9,7 +9,7 @@ import {
   Engine,
   CapsuleColliderShape
 } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { Vector3 } from "@galacean/engine-math";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
diff --git a/tests/src/core/physics/Joint.test.ts b/tests/src/core/physics/Joint.test.ts
index 40d3ae7760..bfde78a127 100644
--- a/tests/src/core/physics/Joint.test.ts
+++ b/tests/src/core/physics/Joint.test.ts
@@ -1,5 +1,5 @@
 import { FixedJoint, Entity, DynamicCollider, StaticCollider, BoxColliderShape, Engine } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { Vector3 } from "@galacean/engine-math";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { vi, describe, beforeAll, beforeEach, expect, it } from "vitest";
diff --git a/tests/src/core/physics/MeshColliderShape.test.ts b/tests/src/core/physics/MeshColliderShape.test.ts
index 3daa37ed94..1b85709d29 100644
--- a/tests/src/core/physics/MeshColliderShape.test.ts
+++ b/tests/src/core/physics/MeshColliderShape.test.ts
@@ -11,7 +11,7 @@ import {
   ModelMesh
 } from "@galacean/engine-core";
 import { Vector3 } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { describe, beforeAll, beforeEach, expect, it, vi } from "vitest";
 
@@ -31,11 +31,7 @@ class CollisionScript extends Script {
  * @param indices - Optional triangle indices
  * @returns A ModelMesh with readable data
  */
-function createModelMesh(
-  engine: WebGLEngine,
-  positions: number[],
-  indices?: number[]
-): ModelMesh {
+function createModelMesh(engine: WebGLEngine, positions: number[], indices?: number[]): ModelMesh {
   const mesh = new ModelMesh(engine);
   const vec3Positions: Vector3[] = [];
   for (let i = 0; i < positions.length; i += 3) {
@@ -107,11 +103,7 @@ describe("MeshColliderShape PhysX", () => {
       const meshShape = new MeshColliderShape();
       const meshMaterial = meshShape.material;
       // Ground plane at y=0, CCW winding -> normal +Y
-      const mesh = createModelMesh(
-        engine,
-        [-10, 0, -10, 10, 0, -10, -10, 0, 10, 10, 0, 10],
-        [0, 2, 1, 1, 2, 3]
-      );
+      const mesh = createModelMesh(engine, [-10, 0, -10, 10, 0, -10, -10, 0, 10, 10, 0, 10], [0, 2, 1, 1, 2, 3]);
       meshShape.mesh = mesh;
       groundCollider.addShape(meshShape);
 
@@ -190,6 +182,57 @@ describe("MeshColliderShape PhysX", () => {
       defaultMaterial?.destroy();
       material?.destroy();
     });
+
+    it("R6: cloned MeshColliderShape rebuilds its native PhysX shape", async () => {
+      // RED verification for R6 fix:
+      //   MeshColliderShape's `_nativeShape` is `@ignoreClone` — without an
+      //   override of `_cloneTo` cooking a fresh shape from cloned vertex/index
+      //   buffers, the cloned entity has no physical surface (sphere falls
+      //   straight through).
+      const groundEntity = root.createChild("meshGroundForClone");
+      groundEntity.transform.setPosition(0, 0, 0);
+      const groundCollider = groundEntity.addComponent(StaticCollider);
+      const meshShape = new MeshColliderShape();
+      const meshMaterial = meshShape.material;
+      const mesh = createModelMesh(engine, [-10, 0, -10, 10, 0, -10, -10, 0, 10, 10, 0, 10], [0, 2, 1, 1, 2, 3]);
+      meshShape.mesh = mesh;
+      groundCollider.addShape(meshShape);
+
+      const clonedGround = groundEntity.clone();
+      // Move the original aside so the cloned ground is the only surface below the sphere.
+      groundEntity.transform.setPosition(1000, 0, 0);
+      root.addChild(clonedGround);
+      clonedGround.transform.setPosition(0, 0, 0);
+
+      const clonedShape = clonedGround.getComponent(StaticCollider).shapes[0] as MeshColliderShape;
+      // @ts-ignore — inspect that the cloned shape actually has a usable native PhysX handle
+      expect(clonedShape._nativeShape).not.toBeNull();
+      // @ts-ignore
+      expect(clonedShape._nativeShape._pxShape).toBeDefined();
+
+      const sphereEntity = root.createChild("sphereForClone");
+      sphereEntity.transform.setPosition(0, 2, 0);
+      const dynamicCollider = sphereEntity.addComponent(DynamicCollider);
+      const sphereShape = new SphereColliderShape();
+      const sphereMaterial = sphereShape.material;
+      sphereShape.radius = 0.5;
+      dynamicCollider.addShape(sphereShape);
+
+      for (let i = 0; i < 60; i++) {
+        physicsScene._update(1 / 60);
+      }
+
+      // Sphere lands on cloned ground (y > -1), not falls forever (y < -10).
+      const sphereY = sphereEntity.transform.position.y;
+      expect(sphereY).toBeGreaterThan(-1);
+      expect(sphereY).toBeLessThan(2);
+
+      groundEntity.destroy();
+      clonedGround.destroy();
+      sphereEntity.destroy();
+      meshMaterial?.destroy();
+      sphereMaterial?.destroy();
+    });
   });
 
   describe("Convex Mesh (Dynamic)", () => {
@@ -265,9 +308,10 @@ describe("MeshColliderShape PhysX", () => {
       const meshShape = new MeshColliderShape();
       const meshMaterial = meshShape.material;
       meshShape.isConvex = true;
-      const mesh = createModelMesh(engine, [
-        -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1
-      ]);
+      const mesh = createModelMesh(
+        engine,
+        [-1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1]
+      );
       meshShape.mesh = mesh;
       meshShape.isTrigger = true;
       triggerCollider.addShape(meshShape);
@@ -417,11 +461,7 @@ describe("MeshColliderShape PhysX", () => {
       staticCollider.addShape(meshShape);
 
       // Update mesh
-      const mesh2 = createModelMesh(
-        engine,
-        [0, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 2, 2, 0, 0, 2, 0],
-        [0, 1, 2, 3, 4, 5]
-      );
+      const mesh2 = createModelMesh(engine, [0, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 2, 2, 0, 0, 2, 0], [0, 1, 2, 3, 4, 5]);
       meshShape.mesh = mesh2;
 
       expect(staticCollider.shapes.length).toBe(1);
@@ -695,11 +735,7 @@ describe("MeshColliderShape PhysX", () => {
       expect(meshShape._nativeShape).toBeNull();
 
       // Re-enable with new mesh
-      const mesh2 = createModelMesh(
-        engine,
-        [0, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 2, 2, 0, 0, 2, 0],
-        [0, 1, 2, 3, 4, 5]
-      );
+      const mesh2 = createModelMesh(engine, [0, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 2, 2, 0, 0, 2, 0], [0, 1, 2, 3, 4, 5]);
       meshShape.mesh = mesh2;
       // @ts-ignore
       expect(meshShape._nativeShape).not.toBeNull();
diff --git a/tests/src/core/physics/PhysicsMaterial.test.ts b/tests/src/core/physics/PhysicsMaterial.test.ts
index 676f917fe3..7bfd0e0e88 100644
--- a/tests/src/core/physics/PhysicsMaterial.test.ts
+++ b/tests/src/core/physics/PhysicsMaterial.test.ts
@@ -8,7 +8,7 @@ import {
   StaticCollider,
   PlaneColliderShape
 } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { Vector3 } from "@galacean/engine-math";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
@@ -79,6 +79,56 @@ describe("PhysicsMaterial", () => {
     expect(formatValue(boxEntity2.transform.position.y)).eq(0);
   });
 
+  it("cloned collider shape material keeps native values", () => {
+    const scene = engine.sceneManager.activeScene;
+    const originalGravity = scene.physics.gravity.clone();
+    const originalFixedTimeStep = scene.physics.fixedTimeStep;
+    scene.physics.gravity = new Vector3(0, 0, 0);
+    scene.physics.fixedTimeStep = 1 / 60;
+
+    try {
+      const wallEntity = addBox(new Vector3(1, 8, 8), StaticCollider, new Vector3(0, 0, 0));
+      const wallMaterial = wallEntity.getComponent(StaticCollider).shapes[0].material;
+      wallMaterial.bounciness = 1;
+      wallMaterial.dynamicFriction = 0;
+      wallMaterial.staticFriction = 0;
+      wallMaterial.bounceCombine = PhysicsMaterialCombineMode.Multiply;
+      wallMaterial.frictionCombine = PhysicsMaterialCombineMode.Multiply;
+
+      const sourceEntity = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(-3, 0, 0));
+      const sourceCollider = sourceEntity.getComponent(DynamicCollider);
+      sourceCollider.linearDamping = 0;
+      sourceCollider.angularDamping = 0;
+      sourceCollider.automaticCenterOfMass = false;
+      sourceCollider.automaticInertiaTensor = false;
+
+      const sourceMaterial = sourceCollider.shapes[0].material;
+      sourceMaterial.bounciness = 1;
+      sourceMaterial.dynamicFriction = 0;
+      sourceMaterial.staticFriction = 0;
+      sourceMaterial.bounceCombine = PhysicsMaterialCombineMode.Multiply;
+      sourceMaterial.frictionCombine = PhysicsMaterialCombineMode.Multiply;
+
+      const cloneEntity = sourceEntity.clone();
+      sourceEntity.destroy();
+      rootEntity.addChild(cloneEntity);
+      cloneEntity.transform.setPosition(-3, 0, 0);
+
+      const cloneCollider = cloneEntity.getComponent(DynamicCollider);
+      cloneCollider.linearVelocity = new Vector3(10, 0, 0);
+
+      for (let i = 0; i < 40; i++) {
+        // @ts-ignore
+        scene.physics._update(scene.physics.fixedTimeStep);
+      }
+
+      expect(cloneCollider.linearVelocity.x).lessThan(-1);
+    } finally {
+      scene.physics.gravity = originalGravity;
+      scene.physics.fixedTimeStep = originalFixedTimeStep;
+    }
+  });
+
   it("bounceCombine Average", () => {
     const boxEntity = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(0, 5, 0));
     const ground = addPlane(0, -0.5, 0);
diff --git a/tests/src/core/physics/PhysicsScene.test.ts b/tests/src/core/physics/PhysicsScene.test.ts
index d514abf337..a62067db59 100644
--- a/tests/src/core/physics/PhysicsScene.test.ts
+++ b/tests/src/core/physics/PhysicsScene.test.ts
@@ -12,13 +12,12 @@ import {
   Scene,
   Script,
   SphereColliderShape,
-  StaticCollider,
-  OverlapHitResult
+  StaticCollider
 } from "@galacean/engine-core";
 import { Ray, Vector3, Quaternion } from "@galacean/engine-math";
 import { LitePhysics } from "@galacean/engine-physics-lite";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { vi, describe, beforeAll, expect, it, afterEach } from "vitest";
 
 class CollisionTestScript extends Script {
@@ -503,6 +502,7 @@ describe("Physics Test", () => {
       expect(physicsScene.raycast(ray, Number.MAX_VALUE, Layer.Everything, outHitResult)).to.eq(false);
 
       const rootEntityCharacter = root.createChild("root_character");
+      rootEntityCharacter.layer = Layer.Layer3;
       rootEntityCharacter.transform.position = new Vector3(0, 0, 0);
 
       const characterController = rootEntityCharacter.addComponent(CharacterController);
@@ -536,286 +536,6 @@ describe("Physics Test", () => {
       root.destroy();
     });
 
-    it("raycast skips initial overlap when ray origin is inside a collider", () => {
-      const scene = enginePhysX.sceneManager.activeScene;
-      const physicsScene = scene.physics;
-      const root = scene.createRootEntity("root");
-
-      // Box at origin, encompassing the ray origin
-      const insideBox = root.createChild("inside_box");
-      insideBox.transform.position = new Vector3(0, 0, 0);
-      const insideCollider = insideBox.addComponent(StaticCollider);
-      const insideShape = new BoxColliderShape();
-      insideShape.size = new Vector3(2, 2, 2);
-      insideCollider.addShape(insideShape);
-
-      // Box further along the ray direction
-      const farBox = root.createChild("far_box");
-      farBox.transform.position = new Vector3(5, 0, 0);
-      const farCollider = farBox.addComponent(StaticCollider);
-      const farShape = new BoxColliderShape();
-      farShape.size = new Vector3(2, 2, 2);
-      farCollider.addShape(farShape);
-
-      // Cast ray from origin (inside `insideBox`) outward
-      const hit = new HitResult();
-      const ray = new Ray(new Vector3(0, 0, 0), new Vector3(1, 0, 0));
-      const ok = physicsScene.raycast(ray, 100, hit);
-
-      expect(ok).to.eq(true);
-      // Should hit the far box, NOT the box at origin (initial overlap is skipped)
-      expect(hit.entity).to.eq(farBox);
-      expect(hit.distance).to.be.greaterThan(0);
-
-      root.destroy();
-    });
-
-    it("boxCast skips initial overlap and hits far collider beyond", () => {
-      const scene = enginePhysX.sceneManager.activeScene;
-      const physicsScene = scene.physics;
-      const root = scene.createRootEntity("boxcast_initial_overlap_root");
-
-      const insideBox = root.createChild("inside_box");
-      insideBox.transform.position = new Vector3(0, 0, 0);
-      const insideCol = insideBox.addComponent(StaticCollider);
-      const insideShape = new BoxColliderShape();
-      insideShape.size = new Vector3(2, 2, 2);
-      insideCol.addShape(insideShape);
-
-      const farBox = root.createChild("far_box");
-      farBox.transform.position = new Vector3(5, 0, 0);
-      const farCol = farBox.addComponent(StaticCollider);
-      const farShape = new BoxColliderShape();
-      farShape.size = new Vector3(2, 2, 2);
-      farCol.addShape(farShape);
-
-      const halfExtents = new Vector3(0.5, 0.5, 0.5);
-      const direction = new Vector3(1, 0, 0);
-      const hit = new HitResult();
-      // Sweep origin (0,0,0) is inside insideBox; should skip and hit farBox
-      const ok = physicsScene.boxCast(new Vector3(0, 0, 0), halfExtents, direction, 100, hit);
-
-      expect(ok).to.eq(true);
-      expect(hit.entity).to.eq(farBox);
-      expect(hit.distance).to.be.greaterThan(0);
-
-      root.destroy();
-    });
-
-    it("sphereCast skips initial overlap and hits far collider beyond", () => {
-      const scene = enginePhysX.sceneManager.activeScene;
-      const physicsScene = scene.physics;
-      const root = scene.createRootEntity("spherecast_initial_overlap_root");
-
-      const insideBox = root.createChild("inside_box");
-      insideBox.transform.position = new Vector3(0, 0, 0);
-      const insideCol = insideBox.addComponent(StaticCollider);
-      const insideShape = new BoxColliderShape();
-      insideShape.size = new Vector3(2, 2, 2);
-      insideCol.addShape(insideShape);
-
-      const farBox = root.createChild("far_box");
-      farBox.transform.position = new Vector3(5, 0, 0);
-      const farCol = farBox.addComponent(StaticCollider);
-      const farShape = new BoxColliderShape();
-      farShape.size = new Vector3(2, 2, 2);
-      farCol.addShape(farShape);
-
-      const direction = new Vector3(1, 0, 0);
-      const hit = new HitResult();
-      const ok = physicsScene.sphereCast(new Vector3(0, 0, 0), 0.4, direction, 100, hit);
-
-      expect(ok).to.eq(true);
-      expect(hit.entity).to.eq(farBox);
-      expect(hit.distance).to.be.greaterThan(0);
-
-      root.destroy();
-    });
-
-    it("capsuleCast skips initial overlap and hits far collider beyond", () => {
-      const scene = enginePhysX.sceneManager.activeScene;
-      const physicsScene = scene.physics;
-      const root = scene.createRootEntity("capsulecast_initial_overlap_root");
-
-      const insideBox = root.createChild("inside_box");
-      insideBox.transform.position = new Vector3(0, 0, 0);
-      const insideCol = insideBox.addComponent(StaticCollider);
-      const insideShape = new BoxColliderShape();
-      insideShape.size = new Vector3(2, 2, 2);
-      insideCol.addShape(insideShape);
-
-      const farBox = root.createChild("far_box");
-      farBox.transform.position = new Vector3(5, 0, 0);
-      const farCol = farBox.addComponent(StaticCollider);
-      const farShape = new BoxColliderShape();
-      farShape.size = new Vector3(2, 2, 2);
-      farCol.addShape(farShape);
-
-      const direction = new Vector3(1, 0, 0);
-      const hit = new HitResult();
-      const ok = physicsScene.capsuleCast(new Vector3(0, 0, 0), 0.3, 0.5, direction, 100, hit);
-
-      expect(ok).to.eq(true);
-      expect(hit.entity).to.eq(farBox);
-      expect(hit.distance).to.be.greaterThan(0);
-
-      root.destroy();
-    });
-
-    it("raycast nested inside another raycast's onRaycast keeps stack ordering", () => {
-      const scene = enginePhysX.sceneManager.activeScene;
-      const root = scene.createRootEntity("nested_raycast_root");
-      // Native PhysX scene exposes the (ray, distance, onRaycast, hit) signature
-      // that takes a per-call filter; the persistent-callback stack pattern is
-      // verified through this layer.
-      const nativeScene = (scene.physics as any)._nativePhysicsScene;
-
-      const boxA = root.createChild("box_a");
-      boxA.transform.position = new Vector3(2, 0, 0);
-      const colA = boxA.addComponent(StaticCollider);
-      const shapeA = new BoxColliderShape();
-      shapeA.size = new Vector3(1, 1, 1);
-      colA.addShape(shapeA);
-
-      const boxB = root.createChild("box_b");
-      boxB.transform.position = new Vector3(0, 2, 0);
-      const colB = boxB.addComponent(StaticCollider);
-      const shapeB = new BoxColliderShape();
-      shapeB.size = new Vector3(1, 1, 1);
-      colB.addShape(shapeB);
-
-      const seenInOuter: number[] = [];
-      const seenInInner: number[] = [];
-
-      const outerRay = new Ray(new Vector3(-5, 0, 0), new Vector3(1, 0, 0));
-      nativeScene.raycast(outerRay, 100, (uuid: number) => {
-        seenInOuter.push(uuid);
-        // Nested raycast inside the outer's filter callback. If the stack got
-        // mixed up, the inner ray's preFilter would dispatch to the outer
-        // recorder (or vice versa).
-        const innerRay = new Ray(new Vector3(0, -5, 0), new Vector3(0, 1, 0));
-        nativeScene.raycast(innerRay, 100, (innerUuid: number) => {
-          seenInInner.push(innerUuid);
-          return true;
-        });
-        return true;
-      });
-
-      // The outer ray (along +X from -5,0,0) cannot intersect boxB at (0,2,0),
-      // so its preFilter must never see shapeB. Conversely, the inner ray
-      // (along +Y from 0,-5,0) cannot intersect boxA at (2,0,0), so its
-      // preFilter must never see shapeA. Stack mixing would violate either.
-      expect(seenInOuter).to.not.include(shapeB.id);
-      expect(seenInInner).to.not.include(shapeA.id);
-      // Both filters must have run — otherwise the assertions above are vacuous.
-      expect(seenInOuter.length).to.be.greaterThan(0);
-      expect(seenInInner.length).to.be.greaterThan(0);
-
-      root.destroy();
-    });
-
-    it("sweep nested inside raycast's onRaycast uses independent filter stacks", () => {
-      const scene = enginePhysX.sceneManager.activeScene;
-      const root = scene.createRootEntity("nested_mixed_root");
-      const nativeScene = (scene.physics as any)._nativePhysicsScene;
-
-      const boxA = root.createChild("box_a");
-      boxA.transform.position = new Vector3(3, 0, 0);
-      const colA = boxA.addComponent(StaticCollider);
-      const shapeA = new BoxColliderShape();
-      shapeA.size = new Vector3(1, 1, 1);
-      colA.addShape(shapeA);
-
-      let outerCalls = 0;
-      let innerSweepCalls = 0;
-      const innerSweepUuids: number[] = [];
-
-      const outerRay = new Ray(new Vector3(-5, 0, 0), new Vector3(1, 0, 0));
-      const outerHitFn = (uuid: number, distance: number, _p: Vector3, _n: Vector3) => {
-        // The outer raycast must successfully report a hit on shapeA's UUID.
-        expect(uuid).to.eq(shapeA.id);
-        expect(distance).to.be.greaterThan(0);
-      };
-      const result = nativeScene.raycast(
-        outerRay,
-        100,
-        (uuid: number) => {
-          outerCalls++;
-          // Nested boxCast (sweep) inside the raycast filter — uses a different
-          // persistent callback / stack on the PhysX side. The two stacks must
-          // not interfere.
-          const sweepCenter = new Vector3(3, 0, 0);
-          const halfExtents = new Vector3(0.5, 0.5, 0.5);
-          const direction = new Vector3(0, 1, 0);
-          const orientation = new Quaternion(0, 0, 0, 1);
-          nativeScene.boxCast(
-            sweepCenter,
-            orientation,
-            halfExtents,
-            direction,
-            100,
-            (sweepUuid: number) => {
-              innerSweepCalls++;
-              innerSweepUuids.push(sweepUuid);
-              return false; // skip everything in inner sweep
-            }
-          );
-          return uuid === shapeA.id;
-        },
-        outerHitFn
-      );
-
-      // Outer raycast must succeed despite the nested sweep with its own filter.
-      expect(result).to.eq(true);
-      expect(outerCalls).to.be.greaterThan(0);
-      // Nested sweep had to actually run at least once for this test to be meaningful.
-      expect(innerSweepCalls).to.be.greaterThan(0);
-
-      root.destroy();
-    });
-
-    it("raycast callback throwing leaves the filter stack clean for subsequent calls", () => {
-      const scene = enginePhysX.sceneManager.activeScene;
-      const root = scene.createRootEntity("throw_recovery_root");
-      const nativeScene = (scene.physics as any)._nativePhysicsScene;
-
-      const box = root.createChild("box");
-      box.transform.position = new Vector3(2, 0, 0);
-      const col = box.addComponent(StaticCollider);
-      const shape = new BoxColliderShape();
-      shape.size = new Vector3(1, 1, 1);
-      col.addShape(shape);
-
-      const ray = new Ray(new Vector3(-5, 0, 0), new Vector3(1, 0, 0));
-
-      expect(() => {
-        nativeScene.raycast(ray, 100, () => {
-          throw new Error("intentional in test");
-        });
-      }).to.throw("intentional in test");
-
-      // Stack must be clean — subsequent raycast must work and the shared
-      // persistent callback must dispatch to the new filter, not a stale one.
-      let secondCalled = false;
-      let observedUuid = -1;
-      const ok = nativeScene.raycast(
-        ray,
-        100,
-        (uuid: number) => {
-          secondCalled = true;
-          observedUuid = uuid;
-          return true;
-        },
-        (_uuid: number, _distance: number, _p: Vector3, _n: Vector3) => {}
-      );
-
-      expect(secondCalled).to.eq(true);
-      expect(ok).to.eq(true);
-      expect(observedUuid).to.eq(shape.id);
-
-      root.destroy();
-    });
-
     it("boxCast", () => {
       const scene = enginePhysX.sceneManager.activeScene;
       const physicsScene = scene.physics;
@@ -833,7 +553,7 @@ describe("Physics Test", () => {
       const halfExtents = new Vector3(0.5, 0.5, 0.5);
       const direction = new Vector3(0, 1, 0);
       const orientation = new Quaternion();
-      expect(physicsScene.boxCast(center, halfExtents, direction, orientation)).to.eq(false);
+      expect(physicsScene.boxCast(center, halfExtents, direction)).to.eq(false);
 
       // Test boxCast with hit
       direction.set(-1, -1, -1);
@@ -1787,14 +1507,16 @@ describe("Physics Test", () => {
         collisionTestScript.useLite = false;
 
         // Test that collision works correctly, A is dynamic and kinematic, B is static.
+        // SceneDesc.staticKineFilteringMode = eKEEP + Collider.move() routing kinematic
+        // to setKinematicTarget make static-kinematic pairs generate contact events.
         resetSpy();
         setColliderProps(entity1, true, false, true);
         setColliderProps(entity2, false, false, false);
         updatePhysics(physicsMgr);
 
-        expect(collisionTestScript.onCollisionEnter).not.toHaveBeenCalled();
-        expect(collisionTestScript.onCollisionStay).not.toHaveBeenCalled();
-        expect(collisionTestScript.onCollisionExit).not.toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionEnter).toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionStay).toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionExit).toHaveBeenCalled();
         expect(collisionTestScript.onTriggerEnter).not.toHaveBeenCalled();
         expect(collisionTestScript.onTriggerStay).not.toHaveBeenCalled();
         expect(collisionTestScript.onTriggerExit).not.toHaveBeenCalled();
@@ -1907,14 +1629,16 @@ describe("Physics Test", () => {
         collisionTestScript.useLite = false;
 
         // Test that collision works correctly, both A,B are dynamic, kinematic.
+        // SceneDesc.kineKineFilteringMode = eKEEP + Collider.move() routing kinematic
+        // to setKinematicTarget make kine-kine pairs generate contact events.
         resetSpy();
         setColliderProps(entity1, true, false, true);
         setColliderProps(entity2, true, false, true);
         updatePhysics(physicsMgr);
 
-        expect(collisionTestScript.onCollisionEnter).not.toHaveBeenCalled();
-        expect(collisionTestScript.onCollisionStay).not.toHaveBeenCalled();
-        expect(collisionTestScript.onCollisionExit).not.toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionEnter).toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionStay).toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionExit).toHaveBeenCalled();
         expect(collisionTestScript.onTriggerEnter).not.toHaveBeenCalled();
         expect(collisionTestScript.onTriggerStay).not.toHaveBeenCalled();
         expect(collisionTestScript.onTriggerExit).not.toHaveBeenCalled();
diff --git a/tests/src/core/physics/SpringJoint.test.ts b/tests/src/core/physics/SpringJoint.test.ts
index ebc62d0287..768a200382 100644
--- a/tests/src/core/physics/SpringJoint.test.ts
+++ b/tests/src/core/physics/SpringJoint.test.ts
@@ -1,5 +1,5 @@
 import { Entity, DynamicCollider, StaticCollider, BoxColliderShape, Engine, SpringJoint } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { Vector3 } from "@galacean/engine-math";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
diff --git a/tests/src/loader/GLTFLoader.test.ts b/tests/src/loader/GLTFLoader.test.ts
index 6f3eaf0b17..164dd788aa 100644
--- a/tests/src/loader/GLTFLoader.test.ts
+++ b/tests/src/loader/GLTFLoader.test.ts
@@ -26,7 +26,7 @@ import {
   registerGLTFParser
 } from "@galacean/engine-loader";
 import { Color } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { describe, beforeAll, afterAll, expect, it } from "vitest";
 
 let engine: WebGLEngine;
@@ -40,7 +40,7 @@ beforeAll(async function () {
   class GLTFCustomJSONParser extends GLTFParser {
     parse(context: GLTFParserContext) {
       if (context.glTFResource.url.endsWith("testSkinRoot.gltf")) {
-        context.buffers = [new ArrayBuffer(192)];
+        context.buffers = [new ArrayBuffer(128)];
         return Promise.resolve({
           asset: {
             version: "2.0"
@@ -53,7 +53,8 @@ beforeAll(async function () {
           ],
           nodes: [
             {
-              name: "Character_Man"
+              name: "Character_Man",
+              skin: 0
             },
             {
               name: "mixamorig:Hips",
@@ -66,8 +67,7 @@ beforeAll(async function () {
           skins: [
             {
               inverseBindMatrices: 0,
-              // Joints span both top-level scene roots: Character_Man (0) and Hips (1)/Spine (2).
-              joints: [0, 1, 2]
+              joints: [1, 2]
             }
           ],
           accessors: [
@@ -75,7 +75,7 @@ beforeAll(async function () {
               bufferView: 0,
               byteOffset: 0,
               componentType: 5126,
-              count: 3,
+              count: 2,
               type: "MAT4"
             }
           ],
@@ -83,19 +83,26 @@ beforeAll(async function () {
             {
               buffer: 0,
               byteOffset: 0,
-              byteLength: 192
+              byteLength: 128
             }
           ],
           buffers: [
             {
-              byteLength: 192
+              byteLength: 128
             }
           ]
         });
       }
 
-      if (context.glTFResource.url.endsWith("testSingleSkeleton.gltf")) {
-        context.buffers = [new ArrayBuffer(128)];
+      if (context.glTFResource.url.endsWith("testSkinRootBounds.gltf")) {
+        const buffer = new ArrayBuffer(152);
+        const floats = new Float32Array(buffer);
+        // Inverse bind matrices for Hips and Spine. Their bind pose world x is
+        // Character_Group(3) + Hips(10), so inverse bind translates by -13.
+        floats.set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, -13, 0, 0, 1], 0);
+        floats.set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, -13, 0, 0, 1], 16);
+        floats.set([9, -1, -1, 11, 1, 1], 32);
+        context.buffers = [buffer];
         return Promise.resolve({
           asset: {
             version: "2.0"
@@ -103,27 +110,45 @@ beforeAll(async function () {
           scene: 0,
           scenes: [
             {
-              // Two top-level roots: a character skeleton and an unrelated sibling (e.g., a light).
-              nodes: [0, 2]
+              nodes: [0]
             }
           ],
           nodes: [
             {
-              name: "Character_Root",
-              children: [1]
+              name: "Character_Group",
+              translation: [3, 0, 0],
+              children: [1, 2]
             },
             {
-              name: "mixamorig:Hips"
+              name: "Character_Man",
+              mesh: 0,
+              skin: 0
             },
             {
-              name: "Light"
+              name: "mixamorig:Hips",
+              translation: [10, 0, 0],
+              children: [3]
+            },
+            {
+              name: "mixamorig:Spine"
             }
           ],
           skins: [
             {
               inverseBindMatrices: 0,
-              // All joints converge to a single top-level root (Character_Root).
-              joints: [0, 1]
+              joints: [2, 3]
+            }
+          ],
+          meshes: [
+            {
+              primitives: [
+                {
+                  attributes: {
+                    POSITION: 1
+                  },
+                  mode: 4
+                }
+              ]
             }
           ],
           accessors: [
@@ -133,6 +158,15 @@ beforeAll(async function () {
               componentType: 5126,
               count: 2,
               type: "MAT4"
+            },
+            {
+              bufferView: 1,
+              byteOffset: 0,
+              componentType: 5126,
+              count: 2,
+              type: "VEC3",
+              min: [9, -1, -1],
+              max: [11, 1, 1]
             }
           ],
           bufferViews: [
@@ -140,11 +174,16 @@ beforeAll(async function () {
               buffer: 0,
               byteOffset: 0,
               byteLength: 128
+            },
+            {
+              buffer: 0,
+              byteOffset: 128,
+              byteLength: 24
             }
           ],
           buffers: [
             {
-              byteLength: 128
+              byteLength: 152
             }
           ]
         });
@@ -504,7 +543,7 @@ beforeAll(async function () {
 
 afterAll(() => {
   @registerGLTFParser(GLTFParserType.Schema)
-  class test extends GLTFSchemaParser { }
+  class test extends GLTFSchemaParser {}
 });
 
 describe("glTF Loader test", function () {
@@ -665,19 +704,21 @@ describe("glTF scene root structure", function () {
     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 () => {
+  it("Skinned mesh bounds should stay in rootBone space when inferred rootBone is outside joints", async () => {
     const glTFResource: GLTFResource = await engine.resourceManager.load({
       type: AssetType.GLTF,
-      url: "mock/path/testSingleSkeleton.gltf"
+      url: "mock/path/testSkinRootBounds.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");
+    const characterGroup = defaultSceneRoot.children[0];
+    const characterMesh = characterGroup.children[0];
+    const renderer = characterMesh.getComponent(SkinnedMeshRenderer);
+
+    expect(skins[0].rootBone).to.equal(characterGroup);
+    expect(renderer.localBounds.min.x).to.be.closeTo(6, 1e-5);
+    expect(renderer.localBounds.max.x).to.be.closeTo(8, 1e-5);
+    expect(renderer.bounds.min.x).to.be.closeTo(9, 1e-5);
+    expect(renderer.bounds.max.x).to.be.closeTo(11, 1e-5);
   });
 });
 
diff --git a/tests/src/loader/KTX2Loader.test.ts b/tests/src/loader/KTX2Loader.test.ts
index d4e645ec2d..93cd915e16 100644
--- a/tests/src/loader/KTX2Loader.test.ts
+++ b/tests/src/loader/KTX2Loader.test.ts
@@ -1,6 +1,6 @@
 import { GLCapabilityType, Texture2D, TextureFormat } from "@galacean/engine-core";
 import { KTX2Loader } from "@galacean/engine-loader";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 let engine: WebGLEngine;
diff --git a/tests/src/loader/PrefabResource.test.ts b/tests/src/loader/PrefabResource.test.ts
index cc0636e1e9..9555b9f60d 100644
--- a/tests/src/loader/PrefabResource.test.ts
+++ b/tests/src/loader/PrefabResource.test.ts
@@ -1,8 +1,8 @@
 import { expect, beforeAll, afterAll, describe, it } from "vitest";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import type { IHierarchyFile } from "@galacean/engine-loader";
 import { Loader, MeshRenderer, Script } from "@galacean/engine-core";
 import { PrefabParser } from "../../../packages/loader/src/prefab/PrefabParser";
-import type { PrefabFile } from "../../../packages/loader/src/schema/PrefabSchema";
 
 let engine: WebGLEngine;
 
@@ -11,22 +11,8 @@ class DiceScript extends Script {
   numMesh: MeshRenderer = null;
 }
 
-class OverrideCallScript extends Script {
-  value = "";
-  receivedArgs: string[] = [];
-
-  appendSuffix(suffix: string): void {
-    this.value += suffix;
-  }
-
-  captureResolvedArgs(...args: string[]): void {
-    this.receivedArgs = args;
-  }
-}
-
 Loader.registerClass("MeshRenderer", MeshRenderer);
 Loader.registerClass("DiceScript", DiceScript);
-Loader.registerClass("OverrideCallScript", OverrideCallScript);
 
 beforeAll(async () => {
   const canvas = document.createElement("canvas");
@@ -40,27 +26,22 @@ afterAll(() => {
 });
 
 describe("PrefabResource refCount", () => {
-  it("should reject prefab data with an unsupported version", () => {
-    const prefabData = {
-      version: "1.0",
-      refs: [],
-      entities: [{ name: "root" }],
-      components: [],
-      root: 0
-    } as any;
-
-    expect(() => PrefabParser.parse(engine, "invalid.prefab", prefabData)).toThrow(
-      'Unsupported prefab format version "1.0". Expected "2.0".'
-    );
-  });
-
   it("should increase and decrease with instantiated entities", async () => {
-    const prefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root", children: [1] }, { name: "child" }],
-      components: [],
-      root: 0
+    const prefabData: IHierarchyFile = {
+      entities: [
+        {
+          id: "0",
+          name: "root",
+          components: [],
+          children: ["1"]
+        },
+        {
+          id: "1",
+          name: "child",
+          parent: "0",
+          components: []
+        }
+      ]
     };
 
     const prefab = await PrefabParser.parse(engine, "prefab.json", prefabData);
@@ -79,576 +60,55 @@ describe("PrefabResource refCount", () => {
     instance2.destroy();
     expect(prefab.refCount).toBe(0);
   });
-
-  it("should support destroy then re-instantiate cycle", async () => {
-    const prefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root", children: [1] }, { name: "child" }],
-      components: [],
-      root: 0
-    };
-
-    const prefab = await PrefabParser.parse(engine, "lifecycle.prefab", prefabData);
-
-    // First cycle: instantiate → destroy
-    const instance1 = prefab.instantiate();
-    expect(instance1.name).toBe("root");
-    expect(instance1.children[0].name).toBe("child");
-    expect(prefab.refCount).toBe(2);
-
-    instance1.destroy();
-    expect(prefab.refCount).toBe(0);
-
-    // Second cycle: re-instantiate from same prefab
-    const instance2 = prefab.instantiate();
-    expect(instance2.name).toBe("root");
-    expect(instance2.children[0].name).toBe("child");
-    expect(prefab.refCount).toBe(2);
-
-    // Verify independence from destroyed instance
-    expect(instance2).not.toBe(instance1);
-
-    instance2.destroy();
-    expect(prefab.refCount).toBe(0);
-  });
-
-  it("should count instances when prefab root comes from a nested prefab instance", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "nestedRoot", children: [1] }, { name: "nestedChild" }],
-      components: [],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested-root-instance.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested-root-instance.prefab"] = nestedPrefab;
-
-    try {
-      const outerPrefabData: PrefabFile = {
-        version: "2.0",
-        refs: [{ url: "nested-root-instance.prefab" }],
-        entities: [{ instance: { asset: 0 } }],
-        components: [],
-        root: 0
-      };
-
-      const outerPrefab = await PrefabParser.parse(engine, "outer-root-instance.prefab", outerPrefabData);
-
-      expect(outerPrefab.refCount).toBe(0);
-
-      const instance1 = outerPrefab.instantiate();
-      const instance2 = outerPrefab.instantiate();
-
-      expect(outerPrefab.refCount).toBe(2);
-
-      instance1.destroy();
-      expect(outerPrefab.refCount).toBe(1);
-
-      instance2.destroy();
-      expect(outerPrefab.refCount).toBe(0);
-    } finally {
-      // @ts-ignore
-      delete engine.resourceManager._objectPool["nested-root-instance.prefab"];
-    }
-  });
 });
 
-describe("$ref null guard in Prefab mode", () => {
-  it("should not add null to dependence assets when $ref resolves to null", async () => {
-    const prefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "missing-asset.png" }],
-      entities: [{ name: "root", components: [0] }],
-      components: [{ type: "DiceScript", props: { skinMesh: { $ref: 0 } } }],
-      root: 0
-    };
-
-    const prefab = await PrefabParser.parse(engine, "test.prefab", prefabData);
-    // @ts-ignore — access private field for verification
-    expect(prefab._dependenceAssets.size).toBe(0);
-
-    // Verify the component property was actually resolved to null (not skipped)
-    const root = prefab.instantiate();
-    const script = root.getComponent(DiceScript);
-    expect(script.skinMesh).toBeNull();
-    root.destroy();
-  });
-});
-
-describe("Prefab instance overrides", () => {
-  it("should throw a clear error when prefab instance asset ref index is out of range", async () => {
-    const prefabData = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "outerRoot", children: [1] }, { instance: { asset: 0 } }],
-      components: [],
-      root: 0
-    } as any;
-
-    await expect(PrefabParser.parse(engine, "invalid-ref.prefab", prefabData)).rejects.toThrow(
-      "HierarchyParser: invalid ref index 0 for instance.asset"
-    );
-  });
-
-  it("should apply entityProps overrides to nested prefab entities", async () => {
-    // Nested prefab: root → child
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "originalRoot", children: [1] }, { name: "originalChild" }],
-      components: [],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested.prefab"] = nestedPrefab;
-
-    // Outer prefab with instance overrides: rename child entity
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "nested.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1] },
-        {
-          instance: {
-            asset: 0,
-            overrides: {
-              entityProps: [
-                { path: [], name: "renamedRoot" },
-                { path: [0], name: "renamedChild", isActive: false }
-              ]
-            }
-          }
-        }
-      ],
-      components: [],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const instanceEntity = root.children[0];
-    expect(instanceEntity.name).toBe("renamedRoot");
-    expect(instanceEntity.children[0].name).toBe("renamedChild");
-    expect(instanceEntity.children[0].isActive).toBe(false);
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["nested.prefab"];
-  });
-
-  it("should override component props via componentProps", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root", components: [0] }],
-      components: [{ type: "MeshRenderer" }],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested-cp.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested-cp.prefab"] = nestedPrefab;
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "nested-cp.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1] },
-        {
-          instance: {
-            asset: 0,
-            overrides: {
-              componentProps: [{ path: [], selector: { type: "MeshRenderer", index: 0 }, props: { enabled: false } }]
-            }
-          }
-        }
-      ],
-      components: [],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer-cp.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const instanceEntity = root.children[0];
-    const meshRenderer = instanceEntity.getComponent(MeshRenderer);
-    expect(meshRenderer.enabled).toBe(false);
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["nested-cp.prefab"];
-  });
-
-  it("should apply component override props and calls from the same schema", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root", components: [0] }],
-      components: [{ type: "OverrideCallScript" }],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested-calls.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested-calls.prefab"] = nestedPrefab;
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "nested-calls.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1] },
-        {
-          instance: {
-            asset: 0,
-            overrides: {
-              componentProps: [
-                {
-                  path: [],
-                  selector: { type: "OverrideCallScript", index: 0 },
-                  props: { value: "base" },
-                  calls: [{ method: "captureResolvedArgs", args: ["override"] }]
-                }
-              ]
-            }
-          }
-        }
-      ],
-      components: [],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer-calls.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const instanceEntity = root.children[0];
-    const overrideScript = instanceEntity.getComponent(OverrideCallScript);
-    expect(overrideScript.value).toBe("base");
-    expect(overrideScript.receivedArgs).toEqual(["override"]);
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["nested-calls.prefab"];
-  });
-
-  it("should add components via addedComponents", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root" }],
-      components: [],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested-ac.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested-ac.prefab"] = nestedPrefab;
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "nested-ac.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1] },
-        {
-          instance: {
-            asset: 0,
-            overrides: {
-              addedComponents: [{ target: [], component: 0 }]
-            }
-          }
-        }
-      ],
-      components: [
-        {
-          type: "OverrideCallScript",
-          props: { value: "base" },
-          calls: [{ method: "captureResolvedArgs", args: ["added"] }]
-        }
-      ],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer-ac.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const instanceEntity = root.children[0];
-    const overrideScript = instanceEntity.getComponent(OverrideCallScript);
-    expect(overrideScript).not.toBeNull();
-    expect(overrideScript.value).toBe("base");
-    expect(overrideScript.receivedArgs).toEqual(["added"]);
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["nested-ac.prefab"];
-  });
-
-  it("should add entities via addedEntities", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root" }],
-      components: [],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested-ae.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested-ae.prefab"] = nestedPrefab;
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "nested-ae.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1] },
-        {
-          instance: {
-            asset: 0,
-            overrides: {
-              addedEntities: [{ parent: [] as number[], entity: 2 }]
-            }
-          }
-        },
-        {
-          name: "addedChild",
-          position: [1, 2, 3] as [number, number, number],
-          components: [0]
-        }
-      ],
-      components: [
-        {
-          type: "OverrideCallScript",
-          props: { value: "base" },
-          calls: [{ method: "captureResolvedArgs", args: ["inline"] }]
-        }
-      ],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer-ae.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const instanceEntity = root.children[0];
-    expect(instanceEntity.children.length).toBe(1);
-    const addedChild = instanceEntity.children[0];
-    expect(addedChild.name).toBe("addedChild");
-    expect(addedChild.transform.position.x).toBe(1);
-    expect(addedChild.transform.position.y).toBe(2);
-    expect(addedChild.transform.position.z).toBe(3);
-    const overrideScript = addedChild.getComponent(OverrideCallScript);
-    expect(overrideScript.value).toBe("base");
-    expect(overrideScript.receivedArgs).toEqual(["inline"]);
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["nested-ae.prefab"];
-  });
-
-  it("should remove entities via removedEntities", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root", children: [1] }, { name: "child" }],
-      components: [],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested-re.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested-re.prefab"] = nestedPrefab;
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "nested-re.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1] },
-        {
-          instance: {
-            asset: 0,
-            overrides: {
-              removedEntities: [[0]]
-            }
-          }
-        }
-      ],
-      components: [],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer-re.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const instanceEntity = root.children[0];
-    expect(instanceEntity.children.length).toBe(0);
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["nested-re.prefab"];
-  });
-
-  it("should remove multiple sibling entities via removedEntities", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root", children: [1, 2, 3] }, { name: "A" }, { name: "B" }, { name: "C" }],
-      components: [],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested-re-multi.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested-re-multi.prefab"] = nestedPrefab;
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "nested-re-multi.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1] },
-        {
-          instance: {
-            asset: 0,
-            overrides: {
-              removedEntities: [[0], [2]]
-            }
-          }
-        }
-      ],
-      components: [],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer-re-multi.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const instanceEntity = root.children[0];
-    expect(instanceEntity.children.length).toBe(1);
-    expect(instanceEntity.children[0].name).toBe("B");
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["nested-re-multi.prefab"];
-  });
-
-  it("should remove multiple components of same type via removedComponents", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root", components: [0, 1, 2] }],
-      components: [{ type: "MeshRenderer" }, { type: "MeshRenderer" }, { type: "MeshRenderer" }],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested-rc-multi.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested-rc-multi.prefab"] = nestedPrefab;
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "nested-rc-multi.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1] },
-        {
-          instance: {
-            asset: 0,
-            overrides: {
-              removedComponents: [{ path: [], selectors: [{ type: "MeshRenderer", index: 0 }, { type: "MeshRenderer", index: 2 }] }]
-            }
-          }
-        }
-      ],
-      components: [],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer-rc-multi.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const instanceEntity = root.children[0];
-    const buffer: MeshRenderer[] = [];
-    instanceEntity.getComponents(MeshRenderer, buffer);
-    expect(buffer.length).toBe(1);
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["nested-rc-multi.prefab"];
-  });
-
-  it("should remove components via removedComponents", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "root", components: [0] }],
-      components: [{ type: "MeshRenderer" }],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "nested-rc.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["nested-rc.prefab"] = nestedPrefab;
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "nested-rc.prefab" }],
+describe("Cross-prefab IComponentRef (path-based)", () => {
+  it("should resolve component ref inside nested prefab instance via entityPath", async () => {
+    // 1. nested prefab (dice.prefab): single root entity with MeshRenderer
+    const nestedPrefabData: IHierarchyFile = {
       entities: [
-        { name: "outerRoot", children: [1] },
         {
-          instance: {
-            asset: 0,
-            overrides: {
-              removedComponents: [{ path: [], selectors: [{ type: "MeshRenderer", index: 0 }] }]
-            }
-          }
+          id: "0",
+          name: "diceRoot",
+          components: [{ id: "mesh-comp", class: "MeshRenderer" }],
+          children: []
         }
-      ],
-      components: [],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer-rc.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const instanceEntity = root.children[0];
-    const meshRenderer = instanceEntity.getComponent(MeshRenderer);
-    expect(meshRenderer).toBeNull();
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["nested-rc.prefab"];
-  });
-});
-
-describe("Cross-prefab $component ref", () => {
-  it("should resolve component ref inside nested prefab instance", async () => {
-    // 1. nested prefab (dice.prefab): single root entity with MeshRenderer
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "diceRoot", components: [0] }],
-      components: [{ type: "MeshRenderer" }],
-      root: 0
+      ]
     };
     const nestedPrefab = await PrefabParser.parse(engine, "dice.prefab", nestedPrefabData);
     // @ts-ignore — register to resourceManager so getResourceByRef can find it
     engine.resourceManager._objectPool["dice.prefab"] = nestedPrefab;
 
     // 2. outer prefab (DiceNode.prefab)
-    //    Entity 0: DiceNode (root) — has DiceScript referencing entity 1's MeshRenderer
-    //    Entity 1: dice (nested prefab instance)
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "dice.prefab" }],
+    //    resolved tree: DiceNode(root=[0]) -> [0]dice(nested)
+    //    skinMesh crosses nested prefab boundary via entityPath
+    const outerPrefabData: IHierarchyFile = {
       entities: [
-        { name: "DiceNode", children: [1], components: [0] },
         {
-          instance: {
-            asset: 0,
-            overrides: { entityProps: [{ path: [], name: "dice" }] }
-          }
-        }
-      ],
-      components: [
+          id: "root",
+          name: "DiceNode",
+          components: [
+            {
+              id: "script-comp",
+              class: "DiceScript",
+              props: {
+                skinMesh: { entityPath: [0, 0], componentType: "MeshRenderer", componentIndex: 0 }
+              }
+            }
+          ],
+          children: ["dice-inst"]
+        },
         {
-          type: "DiceScript",
-          props: {
-            skinMesh: { $component: { entity: [1], type: "MeshRenderer", index: 0 } }
-          }
+          id: "dice-inst",
+          name: "dice",
+          parent: "root",
+          components: [],
+          assetUrl: "dice.prefab",
+          modifications: [],
+          removedEntities: [],
+          removedComponents: []
         }
-      ],
-      root: 0
+      ]
     };
 
     const outerPrefab = await PrefabParser.parse(engine, "DiceNode.prefab", outerPrefabData);
@@ -666,44 +126,55 @@ describe("Cross-prefab $component ref", () => {
   });
 
   it("should resolve both local and cross-prefab refs, and survive clone independently", async () => {
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "diceRoot", components: [0] }],
-      components: [{ type: "MeshRenderer" }],
-      root: 0
+    const nestedPrefabData: IHierarchyFile = {
+      entities: [
+        {
+          id: "0",
+          name: "diceRoot",
+          components: [{ id: "mesh-comp", class: "MeshRenderer" }],
+          children: []
+        }
+      ]
     };
     const nestedPrefab = await PrefabParser.parse(engine, "dice.prefab", nestedPrefabData);
     // @ts-ignore
     engine.resourceManager._objectPool["dice.prefab"] = nestedPrefab;
 
-    // Entity 0: DiceNode (root) — DiceScript with numMesh + skinMesh
-    // Entity 1: numCube — local entity with MeshRenderer
-    // Entity 2: dice — nested prefab instance
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "dice.prefab" }],
+    // resolved tree: DiceNode(root=[0]) -> [0]numCube, [1]dice(nested)
+    const outerPrefabData: IHierarchyFile = {
       entities: [
-        { name: "DiceNode", children: [1, 2], components: [0] },
-        { name: "numCube", components: [1] },
         {
-          instance: {
-            asset: 0,
-            overrides: { entityProps: [{ path: [], name: "dice" }] }
-          }
-        }
-      ],
-      components: [
+          id: "root",
+          name: "DiceNode",
+          components: [
+            {
+              id: "script-comp",
+              class: "DiceScript",
+              props: {
+                numMesh: { entityPath: [0, 0], componentType: "MeshRenderer", componentIndex: 0 },
+                skinMesh: { entityPath: [0, 1], componentType: "MeshRenderer", componentIndex: 0 }
+              }
+            }
+          ],
+          children: ["num-cube", "dice-inst"]
+        },
         {
-          type: "DiceScript",
-          props: {
-            numMesh: { $component: { entity: [1], type: "MeshRenderer", index: 0 } },
-            skinMesh: { $component: { entity: [2], type: "MeshRenderer", index: 0 } }
-          }
+          id: "num-cube",
+          name: "numCube",
+          parent: "root",
+          components: [{ id: "num-mesh-comp", class: "MeshRenderer" }]
         },
-        { type: "MeshRenderer" }
-      ],
-      root: 0
+        {
+          id: "dice-inst",
+          name: "dice",
+          parent: "root",
+          components: [],
+          assetUrl: "dice.prefab",
+          modifications: [],
+          removedEntities: [],
+          removedComponents: []
+        }
+      ]
     };
 
     const outerPrefab = await PrefabParser.parse(engine, "DiceNode.prefab", outerPrefabData);
@@ -735,106 +206,4 @@ describe("Cross-prefab $component ref", () => {
     // @ts-ignore
     delete engine.resourceManager._objectPool["dice.prefab"];
   });
-
-  it("should resolve $entity into prefab instance deep child", async () => {
-    // nested prefab: root with a child "inner"
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [{ name: "nestedRoot", children: [1] }, { name: "inner" }],
-      components: [],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "deep-entity-nested.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["deep-entity-nested.prefab"] = nestedPrefab;
-
-    // outer prefab: DiceScript.skinMesh is Entity (we reuse skinMesh field as any Entity holder via getComponent)
-    // We need a script holding an Entity ref — reuse OverrideCallScript? It doesn't have an Entity field.
-    // Use DiceScript but expose a targetEntity through a separate Script below.
-    class EntityRefScript extends Script {
-      target: Entity = null;
-    }
-    Loader.registerClass("EntityRefScript", EntityRefScript);
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "deep-entity-nested.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1], components: [0] },
-        { instance: { asset: 0 } }
-      ],
-      components: [
-        {
-          type: "EntityRefScript",
-          props: {
-            // Reference entities[1]'s child at path [0] — the "inner" entity inside the prefab instance
-            target: { $entity: [1, 0] }
-          }
-        }
-      ],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "deep-entity-outer.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-    const script = root.getComponent(EntityRefScript);
-
-    expect(script.target).not.toBeNull();
-    expect(script.target.name).toBe("inner");
-    // Confirm it's really the child inside the prefab instance
-    expect(script.target.parent).toBe(root.children[0]);
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["deep-entity-nested.prefab"];
-  });
-
-  it("should resolve $component into prefab instance deep child component", async () => {
-    // nested prefab: root with child "inner" holding a MeshRenderer
-    const nestedPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [],
-      entities: [
-        { name: "nestedRoot", children: [1] },
-        { name: "inner", components: [0] }
-      ],
-      components: [{ type: "MeshRenderer" }],
-      root: 0
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "deep-comp-nested.prefab", nestedPrefabData);
-    // @ts-ignore
-    engine.resourceManager._objectPool["deep-comp-nested.prefab"] = nestedPrefab;
-
-    const outerPrefabData: PrefabFile = {
-      version: "2.0",
-      refs: [{ url: "deep-comp-nested.prefab" }],
-      entities: [
-        { name: "outerRoot", children: [1], components: [0] },
-        { instance: { asset: 0 } }
-      ],
-      components: [
-        {
-          type: "DiceScript",
-          props: {
-            // Reference the MeshRenderer on the "inner" entity inside the prefab instance
-            skinMesh: { $component: { entity: [1, 0], type: "MeshRenderer", index: 0 } }
-          }
-        }
-      ],
-      root: 0
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "deep-comp-outer.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-    const script = root.getComponent(DiceScript);
-
-    const innerEntity = root.children[0].children[0];
-    const innerMeshRenderer = innerEntity.getComponent(MeshRenderer);
-    expect(script.skinMesh).toBe(innerMeshRenderer);
-
-    root.destroy();
-    // @ts-ignore
-    delete engine.resourceManager._objectPool["deep-comp-nested.prefab"];
-  });
 });
diff --git a/tests/src/loader/RawAssetLoader.test.ts b/tests/src/loader/RawAssetLoader.test.ts
index 96591836c4..424eacbd3a 100644
--- a/tests/src/loader/RawAssetLoader.test.ts
+++ b/tests/src/loader/RawAssetLoader.test.ts
@@ -1,6 +1,6 @@
 import { AssetType, BufferAsset, JSONAsset, TextAsset } from "@galacean/engine";
 import "@galacean/engine-loader";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 let engine: WebGLEngine;
diff --git a/tests/src/loader/RenderTargetLoader.test.ts b/tests/src/loader/RenderTargetLoader.test.ts
index 543f33e91c..a3e3555887 100644
--- a/tests/src/loader/RenderTargetLoader.test.ts
+++ b/tests/src/loader/RenderTargetLoader.test.ts
@@ -1,6 +1,6 @@
 import { AssetType, RenderTarget, Texture2D, TextureFormat } from "@galacean/engine-core";
 import "@galacean/engine-loader";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 let engine: WebGLEngine;
@@ -67,14 +67,16 @@ describe("RenderTargetLoader", () => {
       depthFormat: TextureFormat.Depth,
       antiAliasing: 1,
       autoGenerateMipmaps: false,
-      colorTextures: [{
-        mipmap: false,
-        isSRGBColorSpace: true,
-        filterMode: 1,
-        wrapModeU: 1,
-        wrapModeV: 1,
-        anisoLevel: 4
-      }]
+      colorTextures: [
+        {
+          mipmap: false,
+          isSRGBColorSpace: true,
+          filterMode: 1,
+          wrapModeU: 1,
+          wrapModeV: 1,
+          anisoLevel: 4
+        }
+      ]
     });
 
     const rt = await engine.resourceManager.load<RenderTarget>({ url, type: AssetType.RenderTarget });
diff --git a/tests/src/loader/SceneFormatV2.test.ts b/tests/src/loader/SceneFormatV2.test.ts
deleted file mode 100644
index 95cdc3a693..0000000000
--- a/tests/src/loader/SceneFormatV2.test.ts
+++ /dev/null
@@ -1,1164 +0,0 @@
-import "@galacean/engine-loader";
-import {
-  BackgroundTextureFillMode,
-  BackgroundMode,
-  Camera,
-  BloomEffect,
-  DiffuseMode,
-  Entity,
-  FogMode,
-  Loader,
-  PostProcess,
-  Scene,
-  Script,
-  ShadowCascadesMode,
-  ShadowResolution,
-  Transform
-} from "@galacean/engine-core";
-import { SpecularMode, type SceneFile } from "../../../packages/loader/src/schema/SceneSchema";
-import { applySceneData } from "../../../packages/loader/src/SceneLoader";
-import {
-  ParserContext,
-  ParserType
-} from "../../../packages/loader/src/resource-deserialize/resources/parser/ParserContext";
-import { ReflectionParser } from "../../../packages/loader/src/resource-deserialize/resources/parser/ReflectionParser";
-import { SceneParser } from "../../../packages/loader/src/resource-deserialize/resources/scene/SceneParser";
-import { WebGLEngine } from "@galacean/engine";
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-
-Loader.registerClass("Transform", Transform);
-Loader.registerClass("Camera", Camera);
-Loader.registerClass("PostProcess", PostProcess);
-Loader.registerClass("BloomEffect", BloomEffect);
-
-class TestValueType {
-  x = 0;
-  y = 0;
-}
-Loader.registerClass("TestValueType", TestValueType);
-
-class CallOrderComponent extends Script {
-  value = "";
-  receivedArgs: any[] = [];
-  lastResult: any = null;
-
-  appendSuffix(suffix: string): void {
-    this.value += suffix;
-  }
-
-  captureResolvedArgs(...args: any[]): void {
-    this.receivedArgs = args;
-  }
-
-  setBaseDelayed(base: string): Promise<void> {
-    return Promise.resolve().then(() => {
-      this.value = base;
-    });
-  }
-
-  createResult(seed: number) {
-    const result = {
-      x: seed,
-      y: 0,
-      setY(next: number) {
-        this.y = next;
-      }
-    };
-    this.lastResult = result;
-    return result;
-  }
-}
-Loader.registerClass("CallOrderComponent", CallOrderComponent);
-
-let engine: WebGLEngine;
-
-describe("SceneFile v2 schema enums", () => {
-  it("uses numeric enum values for ambient specularMode", () => {
-    expect(SpecularMode.Sky).to.equal(0);
-    expect(SpecularMode.Custom).to.equal(1);
-  });
-});
-
-beforeAll(async function () {
-  const canvasDOM = document.createElement("canvas");
-  canvasDOM.width = 100;
-  canvasDOM.height = 100;
-  engine = await WebGLEngine.create({ canvas: canvasDOM });
-});
-
-afterAll(() => {
-  engine?.destroy();
-});
-
-// ---------------------------------------------------------------------------
-// ReflectionParser — $ prefix props resolution
-// ---------------------------------------------------------------------------
-
-describe("ReflectionParser v2 props resolution", () => {
-  it("should resolve primitive values directly", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      name: "test",
-      value: 42,
-      flag: true
-    });
-    expect(target.name).to.equal("test");
-    expect(target.value).to.equal(42);
-    expect(target.flag).to.equal(true);
-  });
-
-  it("should resolve nested plain objects recursively", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      nested: { a: 1, b: { c: 2 } }
-    });
-    expect(target.nested).to.deep.equal({ a: 1, b: { c: 2 } });
-  });
-
-  it("should modify existing object properties in place", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const original = { x: 0, y: 0, z: 0 };
-    const target: any = { position: original };
-    await parser.parseProps(target, {
-      position: { x: 1, y: 2, z: 3 }
-    });
-    // Should modify in place, not replace
-    expect(target.position).to.equal(original);
-    expect(target.position.x).to.equal(1);
-    expect(target.position.y).to.equal(2);
-    expect(target.position.z).to.equal(3);
-  });
-
-  it("should resolve arrays recursively", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      items: [1, "two", { key: 3 }]
-    });
-    expect(target.items).to.deep.equal([1, "two", { key: 3 }]);
-  });
-
-  it("should resolve $entity by flat index", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const entity0 = new Entity(engine, "entity0");
-    const entity1 = new Entity(engine, "entity1");
-    context.entityInstances[0] = entity0;
-    context.entityInstances[1] = entity1;
-
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      target: { $entity: [1] }
-    });
-    expect(target.target).to.equal(entity1);
-  });
-
-  it("should resolve missing $entity to null", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      target: { $entity: [999] }
-    });
-    expect(target.target).to.be.null;
-  });
-
-  it("should resolve $entity deep child by path", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const root = new Entity(engine, "root");
-    const child = new Entity(engine, "child");
-    const grandchild = new Entity(engine, "grandchild");
-    root.addChild(child);
-    child.addChild(grandchild);
-    context.entityInstances[0] = root;
-
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      a: { $entity: [0] },
-      b: { $entity: [0, 0] },
-      c: { $entity: [0, 0, 0] }
-    });
-    expect(target.a).to.equal(root);
-    expect(target.b).to.equal(child);
-    expect(target.c).to.equal(grandchild);
-  });
-
-  it("should resolve $entity with out-of-range path element to null", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const root = new Entity(engine, "root");
-    context.entityInstances[0] = root;
-
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      target: { $entity: [0, 5] }
-    });
-    expect(target.target).to.be.null;
-  });
-
-  it("should throw a clear error when $ref index is out of range", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-
-    await expect(
-      parser.parseProps(target, {
-        asset: { $ref: 0 }
-      })
-    ).rejects.toThrow("ReflectionParser: invalid ref index 0 for $ref");
-  });
-
-  it("should resolve $component by entity index + type + index", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const entity = new Entity(engine, "test");
-    context.entityInstances[0] = entity;
-
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      comp: { $component: { entity: [0], type: "Transform", index: 0 } }
-    });
-    expect(target.comp).to.equal(entity.transform);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// ReflectionParser — calls execution
-// ---------------------------------------------------------------------------
-
-describe("ReflectionParser calls resolution", () => {
-  it("should resolve $class call args as constructors for factory-style methods", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const entity = new Entity(engine, "post-process");
-    const postProcess = entity.addComponent(PostProcess);
-
-    await parser.parseCalls(postProcess, [
-      {
-        method: "addEffect",
-        args: [{ $class: "BloomEffect" }],
-        result: {
-          props: {
-            threshold: { value: 0.9 },
-            scatter: { value: 0.6 },
-            intensity: { value: 1.5 }
-          }
-        }
-      }
-    ]);
-
-    const effect = postProcess.getEffect(BloomEffect);
-    expect(effect).to.be.instanceOf(BloomEffect);
-    expect(effect.threshold.value).to.equal(0.9);
-    expect(effect.scatter.value).to.equal(0.6);
-    expect(effect.intensity.value).to.equal(1.5);
-  });
-
-  it("should resolve special call args through v2 value rules", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const entity = new Entity(engine, "target");
-    context.entityInstances[1] = entity;
-
-    const asset = { name: "call-asset" };
-    const getResourceByRef = vi
-      .spyOn(engine.resourceManager as any, "getResourceByRef")
-      .mockResolvedValue(asset as any);
-    const refs = [{ url: "call-asset" }];
-    const parser = new ReflectionParser(context, refs);
-    const target = new CallOrderComponent(new Entity(engine, "host"));
-
-    try {
-      await parser.parseCalls(target, [
-        {
-          method: "captureResolvedArgs",
-          args: [
-            { $ref: 0 },
-            { $type: "TestValueType", x: 3, y: 4 },
-            { $entity: [1] },
-            { $component: { entity: [1], type: "Transform", index: 0 } }
-          ]
-        }
-      ]);
-    } finally {
-      getResourceByRef.mockRestore();
-    }
-
-    expect(target.receivedArgs[0]).to.equal(asset);
-    expect(target.receivedArgs[1]).to.be.instanceOf(TestValueType);
-    expect(target.receivedArgs[1].x).to.equal(3);
-    expect(target.receivedArgs[1].y).to.equal(4);
-    expect(target.receivedArgs[2]).to.equal(entity);
-    expect(target.receivedArgs[3]).to.equal(entity.transform);
-  });
-
-  it("should apply result props and nested calls", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target = new CallOrderComponent(new Entity(engine, "host"));
-
-    await parser.parseCalls(target, [
-      {
-        method: "createResult",
-        args: [0],
-        result: {
-          props: { x: 1 },
-          calls: [{ method: "setY", args: [2] }]
-        }
-      }
-    ]);
-
-    expect(target.lastResult.x).to.equal(1);
-    expect(target.lastResult.y).to.equal(2);
-  });
-
-  it("should await each call before executing the next one", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target = new CallOrderComponent(new Entity(engine, "host"));
-
-    await parser.parseCalls(target, [
-      { method: "setBaseDelayed", args: ["base"] },
-      { method: "appendSuffix", args: ["-after"] }
-    ]);
-
-    expect(target.value).to.equal("base-after");
-  });
-
-  it("should throw a clear error when the target method is missing", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-
-    await expect(parser.parseCalls(target, [{ method: "missingMethod" }])).rejects.toThrow("missingMethod");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// SceneParser — v2 entity tree construction
-// ---------------------------------------------------------------------------
-
-describe("SceneParser v2 entity tree", () => {
-  function createSceneData(
-    entities: SceneFile["entities"],
-    components: SceneFile["components"],
-    rootEntities: number[],
-    refs: SceneFile["refs"] = []
-  ): SceneFile {
-    return {
-      version: "2.0",
-      refs,
-      entities,
-      components,
-      scene: {
-        rootEntities,
-        background: {
-          mode: 0,
-          color: [0.25, 0.25, 0.25, 1]
-        },
-        ambient: {
-          diffuseMode: 0,
-          diffuseIntensity: 1,
-          specularIntensity: 1,
-          specularMode: SpecularMode.Sky
-        }
-      }
-    };
-  }
-
-  it("should reject scene data without the v2 version marker", () => {
-    const data = {
-      entities: [{ name: "Entity" }],
-      components: [],
-      scene: {
-        rootEntities: [0],
-        background: {
-          mode: BackgroundMode.SolidColor,
-          color: [0.25, 0.25, 0.25, 1]
-        }
-      }
-    } as any;
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-
-    expect(() => new SceneParser(data, context, scene)).toThrow(
-      'Unsupported scene format version "undefined". Expected "2.0".'
-    );
-  });
-
-  it("should build single-root entity tree from flat array", async () => {
-    const data = createSceneData([{ name: "Root", children: [1, 2] }, { name: "Camera" }, { name: "Light" }], [], [0]);
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await parser.promise;
-
-    expect(scene.rootEntitiesCount).to.equal(1);
-    const root = scene.rootEntities[0];
-    expect(root.name).to.equal("Root");
-    expect(root.childCount).to.equal(2);
-    expect(root.children[0].name).to.equal("Camera");
-    expect(root.children[1].name).to.equal("Light");
-  });
-
-  it("should build multi-root entity tree", async () => {
-    const data = createSceneData([{ name: "Root1", children: [2] }, { name: "Root2" }, { name: "Child" }], [], [0, 1]);
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await parser.promise;
-
-    expect(scene.rootEntitiesCount).to.equal(2);
-    expect(scene.rootEntities[0].name).to.equal("Root1");
-    expect(scene.rootEntities[1].name).to.equal("Root2");
-    expect(scene.rootEntities[0].childCount).to.equal(1);
-    expect(scene.rootEntities[0].children[0].name).to.equal("Child");
-  });
-
-  it("should apply entity transforms from Vec3Tuple", async () => {
-    const data = createSceneData(
-      [
-        {
-          name: "Entity",
-          position: [1, 2, 3],
-          rotation: [45, 90, 0],
-          scale: [2, 2, 2]
-        }
-      ],
-      [],
-      [0]
-    );
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await parser.promise;
-
-    const entity = scene.rootEntities[0];
-    expect(entity.transform.position.x).to.equal(1);
-    expect(entity.transform.position.y).to.equal(2);
-    expect(entity.transform.position.z).to.equal(3);
-    expect(entity.transform.rotation.x).to.equal(45);
-    expect(entity.transform.rotation.y).to.equal(90);
-    expect(entity.transform.rotation.z).to.equal(0);
-    expect(entity.transform.scale.x).to.equal(2);
-    expect(entity.transform.scale.y).to.equal(2);
-    expect(entity.transform.scale.z).to.equal(2);
-  });
-
-  it("should set entity isActive and layer", async () => {
-    const data = createSceneData([{ name: "Inactive", isActive: false, layer: 3 }], [], [0]);
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await parser.promise;
-
-    const entity = scene.rootEntities[0];
-    expect(entity.isActive).to.equal(false);
-    expect(entity.layer).to.equal(3);
-  });
-
-  it("should handle deep entity nesting", async () => {
-    const data = createSceneData(
-      [{ name: "A", children: [1] }, { name: "B", children: [2] }, { name: "C", children: [3] }, { name: "D" }],
-      [],
-      [0]
-    );
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await parser.promise;
-
-    const a = scene.rootEntities[0];
-    expect(a.name).to.equal("A");
-    expect(a.children[0].name).to.equal("B");
-    expect(a.children[0].children[0].name).to.equal("C");
-    expect(a.children[0].children[0].children[0].name).to.equal("D");
-  });
-
-  it("should default missing transform to identity", async () => {
-    const data = createSceneData([{ name: "Default" }], [], [0]);
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await parser.promise;
-
-    const entity = scene.rootEntities[0];
-    expect(entity.transform.position.x).to.equal(0);
-    expect(entity.transform.position.y).to.equal(0);
-    expect(entity.transform.position.z).to.equal(0);
-    expect(entity.transform.scale.x).to.equal(1);
-    expect(entity.transform.scale.y).to.equal(1);
-    expect(entity.transform.scale.z).to.equal(1);
-  });
-
-  it("should add components and apply props (Stage 3-4)", async () => {
-    const data = createSceneData(
-      [{ name: "CamEntity", components: [0] }],
-      [{ type: "Camera", props: { nearClipPlane: 0.5, farClipPlane: 500 } }],
-      [0]
-    );
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await parser.promise;
-
-    const entity = scene.rootEntities[0];
-    const camera = entity.getComponent(Camera);
-    expect(camera).to.not.be.null;
-    expect(camera.nearClipPlane).to.equal(0.5);
-    expect(camera.farClipPlane).to.equal(500);
-  });
-
-  it("should apply component props and calls from the same schema", async () => {
-    const data = createSceneData(
-      [{ name: "CallEntity", components: [0] }],
-      [
-        {
-          type: "CallOrderComponent",
-          props: { value: "base" },
-          calls: [{ method: "captureResolvedArgs", args: ["after"] }]
-        } as any
-      ],
-      [0]
-    );
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await parser.promise;
-
-    const component = scene.rootEntities[0].getComponent(CallOrderComponent);
-    expect(component).to.not.be.null;
-    expect(component.value).to.equal("base");
-    expect(component.receivedArgs).to.deep.equal(["after"]);
-  });
-
-  it("should apply component calls with $class args through scene parsing", async () => {
-    const data = createSceneData(
-      [{ name: "PostProcessEntity", components: [0] }],
-      [
-        {
-          type: "PostProcess",
-          props: { isGlobal: true, priority: 2 },
-          calls: [
-            {
-              method: "addEffect",
-              args: [{ $class: "BloomEffect" }],
-              result: {
-                props: {
-                  threshold: { value: 0.85 },
-                  intensity: { value: 1.25 }
-                }
-              }
-            }
-          ]
-        } as any
-      ],
-      [0]
-    );
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await parser.promise;
-
-    const postProcess = scene.rootEntities[0].getComponent(PostProcess);
-    const effect = postProcess.getEffect(BloomEffect);
-    expect(postProcess.priority).to.equal(2);
-    expect(effect).to.be.instanceOf(BloomEffect);
-    expect(effect.threshold.value).to.equal(0.85);
-    expect(effect.intensity.value).to.equal(1.25);
-  });
-
-  it("should throw a clear error when component type is not registered", async () => {
-    const data = createSceneData([{ name: "Entity", components: [0] }], [{ type: "UnregisteredComponent999" }], [0]);
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new SceneParser(data, context, scene);
-    parser.start();
-    await expect(parser.promise).rejects.toThrow("UnregisteredComponent999");
-  });
-
-  it("should collect dependent assets from refs array", () => {
-    const data: SceneFile = {
-      version: "2.0",
-      refs: [
-        { url: "nested.prefab" },
-        { url: "component-call.mat" },
-        { url: "override-call.mat" },
-        { url: "texture.png", key: "mipmap" }
-      ],
-      entities: [{ name: "Root", components: [0] }],
-      components: [{ type: "CallOrderComponent" }],
-      scene: {
-        rootEntities: [0],
-        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
-        ambient: {
-          diffuseMode: DiffuseMode.SolidColor,
-          diffuseIntensity: 1,
-          specularIntensity: 1,
-          specularMode: SpecularMode.Sky
-        }
-      }
-    };
-
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    context._setTaskCompleteProgress = () => {};
-    const parser = new SceneParser(data, context, scene);
-    const getResourceByRef = vi
-      .spyOn(engine.resourceManager as any, "getResourceByRef")
-      .mockResolvedValue({ _addReferCount() {} } as any);
-
-    let collectedRefs: Array<{ url: string; key?: string }>;
-    try {
-      parser._collectDependentAssets(data);
-      collectedRefs = getResourceByRef.mock.calls.map((args) => args[0] as any);
-    } finally {
-      getResourceByRef.mockRestore();
-    }
-    expect(collectedRefs).to.have.length(4);
-    expect(collectedRefs.map((r) => r.url)).to.deep.equal([
-      "nested.prefab",
-      "component-call.mat",
-      "override-call.mat",
-      "texture.png"
-    ]);
-    expect(collectedRefs[3].key).to.equal("mipmap");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// ReflectionParser — $signal binding
-// ---------------------------------------------------------------------------
-
-describe("ReflectionParser $signal resolution", () => {
-  it("should bind listeners to target component method", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const entity0 = new Entity(engine, "source");
-    const entity1 = new Entity(engine, "target");
-    context.entityInstances[0] = entity0;
-    context.entityInstances[1] = entity1;
-
-    const parser = new ReflectionParser(context, []);
-
-    const bound: Array<{ target: any; method: string; args: any[] }> = [];
-    const mockSignal = {
-      on(target: any, method: string, ...args: any[]) {
-        bound.push({ target, method, args });
-      }
-    };
-
-    const target: any = { onClick: mockSignal };
-    await parser.parseProps(target, {
-      onClick: {
-        $signal: [{ target: { $component: { entity: [1], type: "Transform", index: 0 } }, methodName: "reset" }]
-      }
-    });
-
-    // Signal object should be preserved (not replaced)
-    expect(target.onClick).to.equal(mockSignal);
-    // Listener should be bound to entity1's Transform
-    expect(bound.length).to.equal(1);
-    expect(bound[0].target).to.equal(entity1.transform);
-    expect(bound[0].method).to.equal("reset");
-  });
-
-  it("should skip binding when target component is missing", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const entity0 = new Entity(engine, "source");
-    context.entityInstances[0] = entity0;
-    // entity 1 does NOT exist in entityMap
-
-    const parser = new ReflectionParser(context, []);
-
-    const bound: any[] = [];
-    const mockSignal = {
-      on(target: any, method: string, ...args: any[]) {
-        bound.push({ target, method, args });
-      }
-    };
-
-    const target: any = { onClick: mockSignal };
-    await parser.parseProps(target, {
-      onClick: {
-        $signal: [{ target: { $component: { entity: [1], type: "Transform", index: 0 } }, methodName: "reset" }]
-      }
-    });
-
-    // Signal preserved, but no listener bound (entity missing)
-    expect(target.onClick).to.equal(mockSignal);
-    expect(bound.length).to.equal(0);
-  });
-
-  it("should throw a clear error when $signal target property is not initialized", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const entity0 = new Entity(engine, "source");
-    const entity1 = new Entity(engine, "target");
-    context.entityInstances[0] = entity0;
-    context.entityInstances[1] = entity1;
-
-    const parser = new ReflectionParser(context, []);
-
-    // onClick is undefined — not initialized as a Signal
-    const target: any = { onClick: undefined };
-    await expect(
-      parser.parseProps(target, {
-        onClick: {
-          $signal: [{ target: { $component: { entity: [1], type: "Transform", index: 0 } }, methodName: "reset" }]
-        }
-      })
-    ).rejects.toThrow("$signal");
-  });
-
-  it("should return null when $component references an unregistered type", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const entity = new Entity(engine, "test");
-    context.entityInstances[0] = entity;
-
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      comp: { $component: { entity: [0], type: "NonExistentType999", index: 0 } }
-    });
-    expect(target.comp).to.be.null;
-  });
-});
-
-// ---------------------------------------------------------------------------
-// ReflectionParser — $type polymorphic resolution
-// ---------------------------------------------------------------------------
-
-describe("ReflectionParser $type resolution", () => {
-  it("should construct $type instance and apply remaining props", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      value: { $type: "TestValueType", x: 10, y: 20 }
-    });
-    expect(target.value).to.be.instanceOf(TestValueType);
-    expect(target.value.x).to.equal(10);
-    expect(target.value.y).to.equal(20);
-  });
-
-  it("should construct $type instance without props", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      value: { $type: "TestValueType" }
-    });
-    expect(target.value).to.be.instanceOf(TestValueType);
-    expect(target.value.x).to.equal(0);
-    expect(target.value.y).to.equal(0);
-  });
-
-  it("should throw a clear error when $type references an unregistered class", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await expect(
-      parser.parseProps(target, {
-        value: { $type: "NonExistentClass123" }
-      })
-    ).rejects.toThrow("NonExistentClass123");
-  });
-
-  it("should throw a clear error when $type is not a non-empty string", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await expect(
-      parser.parseProps(target, {
-        value: { $type: 123 } as any
-      })
-    ).rejects.toThrow("$type must be a non-empty registered class name string");
-  });
-});
-
-describe("ReflectionParser $class resolution", () => {
-  it("should resolve $class as the registered constructor through parseProps", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await parser.parseProps(target, {
-      value: { $class: "TestValueType" }
-    });
-    expect(target.value).to.equal(TestValueType);
-  });
-
-  it("should throw a clear error when $class is an empty string", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await expect(
-      parser.parseProps(target, {
-        value: { $class: "" }
-      })
-    ).rejects.toThrow("$class must be a non-empty registered class name string");
-  });
-
-  it("should throw a clear error when $class is not a string", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await expect(
-      parser.parseProps(target, {
-        value: { $class: 123 } as any
-      })
-    ).rejects.toThrow("$class must be a non-empty registered class name string");
-  });
-
-  it("should throw a clear error when $class references an unregistered class", async () => {
-    const scene = new Scene(engine);
-    const context = new ParserContext(engine, ParserType.Scene, scene);
-    const parser = new ReflectionParser(context, []);
-    const target: any = {};
-    await expect(
-      parser.parseProps(target, {
-        value: { $class: "NonExistentClass123" }
-      })
-    ).rejects.toThrow("NonExistentClass123");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// applySceneData — scene property parsing (shadow / fog / AO / background)
-// ---------------------------------------------------------------------------
-// Tests call the same applySceneData function that SceneLoader.load() uses,
-// so any change to the parsing logic is automatically covered.
-
-describe("applySceneData scene property parsing", () => {
-  it("should resolve ambient resources for custom specular and spherical harmonics", async () => {
-    const scene = new Scene(engine);
-    const noop = () => {};
-    const customAmbientTexture = { name: "custom-specular-texture", _addReferCount: noop };
-    const ambientTexture = { name: "sh-specular-texture", _addReferCount: noop };
-    const diffuseSphericalHarmonics = { name: "ambient-sh", coefficients: new Float32Array(27) };
-    const getResourceByRef = vi
-      .spyOn(engine.resourceManager as any, "getResourceByRef")
-      .mockImplementation((ref: any) => {
-        switch (ref.url) {
-          case "custom-ambient":
-            return Promise.resolve({ specularTexture: customAmbientTexture }) as any;
-          case "ambient-light":
-            return Promise.resolve({
-              specularTexture: ambientTexture,
-              diffuseSphericalHarmonics
-            }) as any;
-          default:
-            return Promise.resolve(null) as any;
-        }
-      });
-
-    const refs = [{ url: "custom-ambient" }, { url: "ambient-light" }];
-    try {
-      await applySceneData(
-        scene,
-        {
-          rootEntities: [0],
-          background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
-          ambient: {
-            diffuseMode: DiffuseMode.SphericalHarmonics,
-            diffuseIntensity: 1,
-            specularIntensity: 1,
-            specularMode: SpecularMode.Custom,
-            customAmbientLight: 0,
-            ambientLight: 1
-          }
-        },
-        engine.resourceManager,
-        refs
-      );
-    } finally {
-      getResourceByRef.mockRestore();
-    }
-
-    expect(scene.ambientLight.specularTexture).to.equal(customAmbientTexture);
-    expect(scene.ambientLight.diffuseSphericalHarmonics).to.equal(diffuseSphericalHarmonics);
-  });
-
-  it("should apply sky background resources", async () => {
-    const scene = new Scene(engine);
-    const noop = () => {};
-    const skyMesh = { name: "sky-mesh", _addReferCount: noop };
-    const skyMaterial = { name: "sky-material", _addReferCount: noop };
-    const getResourceByRef = vi
-      .spyOn(engine.resourceManager as any, "getResourceByRef")
-      .mockImplementation((ref: any) => {
-        switch (ref.url) {
-          case "sky-mesh":
-            return Promise.resolve(skyMesh) as any;
-          case "sky-material":
-            return Promise.resolve(skyMaterial) as any;
-          default:
-            return Promise.resolve(null) as any;
-        }
-      });
-
-    const refs = [{ url: "sky-mesh" }, { url: "sky-material" }];
-    try {
-      await applySceneData(
-        scene,
-        {
-          rootEntities: [0],
-          background: {
-            mode: BackgroundMode.Sky,
-            color: [0, 0, 0, 1],
-            skyMesh: 0,
-            skyMaterial: 1
-          }
-        },
-        engine.resourceManager,
-        refs
-      );
-    } finally {
-      getResourceByRef.mockRestore();
-    }
-
-    expect(scene.background.sky.mesh).to.equal(skyMesh);
-    expect(scene.background.sky.material).to.equal(skyMaterial);
-  });
-
-  it("should apply texture background resources and fill mode", async () => {
-    const scene = new Scene(engine);
-    const backgroundTexture = { name: "background-texture", _addReferCount: () => {} };
-    const getResourceByRef = vi
-      .spyOn(engine.resourceManager as any, "getResourceByRef")
-      .mockImplementation((ref: any) => {
-        if (ref.url === "background-texture") {
-          return Promise.resolve(backgroundTexture) as any;
-        }
-        return Promise.resolve(null) as any;
-      });
-
-    const refs = [{ url: "background-texture" }];
-    try {
-      await applySceneData(
-        scene,
-        {
-          rootEntities: [0],
-          background: {
-            mode: BackgroundMode.Texture,
-            color: [0, 0, 0, 1],
-            texture: 0,
-            textureFillMode: BackgroundTextureFillMode.Fill
-          }
-        },
-        engine.resourceManager,
-        refs
-      );
-    } finally {
-      getResourceByRef.mockRestore();
-    }
-
-    expect(scene.background.texture).to.equal(backgroundTexture);
-    expect(scene.background.textureFillMode).to.equal(BackgroundTextureFillMode.Fill);
-  });
-
-  it("should throw a clear error when scene ref index is out of range", async () => {
-    const scene = new Scene(engine);
-
-    await expect(
-      applySceneData(
-        scene,
-        {
-          rootEntities: [0],
-          background: {
-            mode: BackgroundMode.Texture,
-            color: [0, 0, 0, 1],
-            texture: 0
-          }
-        },
-        engine.resourceManager,
-        []
-      )
-    ).rejects.toThrow("SceneLoader: invalid ref index 0 for scene.background.texture");
-  });
-
-  it("should apply shadow properties to scene", async () => {
-    const scene = new Scene(engine);
-    await applySceneData(
-      scene,
-      {
-        rootEntities: [0],
-        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
-        shadow: {
-          castShadows: false,
-          enableTransparentShadow: true,
-          shadowResolution: ShadowResolution.High,
-          shadowDistance: 100,
-          shadowCascades: ShadowCascadesMode.FourCascades,
-          shadowTwoCascadeSplits: 0.5,
-          shadowFourCascadeSplits: [0.1, 0.3, 0.7],
-          shadowFadeBorder: 0.2
-        }
-      },
-      engine.resourceManager,
-      []
-    );
-
-    expect(scene.castShadows).to.equal(false);
-    expect(scene.enableTransparentShadow).to.equal(true);
-    expect(scene.shadowResolution).to.equal(ShadowResolution.High);
-    expect(scene.shadowDistance).to.equal(100);
-    expect(scene.shadowCascades).to.equal(ShadowCascadesMode.FourCascades);
-    expect(scene.shadowTwoCascadeSplits).to.equal(0.5);
-    expect(scene.shadowFourCascadeSplits.x).to.be.closeTo(0.1, 0.001);
-    expect(scene.shadowFourCascadeSplits.y).to.be.closeTo(0.3, 0.001);
-    expect(scene.shadowFourCascadeSplits.z).to.be.closeTo(0.7, 0.001);
-    expect(scene.shadowFadeBorder).to.equal(0.2);
-  });
-
-  it("should apply fog properties to scene", async () => {
-    const scene = new Scene(engine);
-    await applySceneData(
-      scene,
-      {
-        rootEntities: [0],
-        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
-        fog: {
-          fogMode: FogMode.ExponentialSquared,
-          fogStart: 10,
-          fogEnd: 200,
-          fogDensity: 0.05,
-          fogColor: [1, 0, 0, 1]
-        }
-      },
-      engine.resourceManager,
-      []
-    );
-
-    expect(scene.fogMode).to.equal(FogMode.ExponentialSquared);
-    expect(scene.fogStart).to.equal(10);
-    expect(scene.fogEnd).to.equal(200);
-    expect(scene.fogDensity).to.equal(0.05);
-    expect(scene.fogColor.r).to.equal(1);
-    expect(scene.fogColor.g).to.equal(0);
-    expect(scene.fogColor.b).to.equal(0);
-    expect(scene.fogColor.a).to.equal(1);
-  });
-
-  it("should apply ambient occlusion properties to scene", async () => {
-    const scene = new Scene(engine);
-    await applySceneData(
-      scene,
-      {
-        rootEntities: [0],
-        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
-        ambientOcclusion: {
-          enabledAmbientOcclusion: true,
-          intensity: 0.8,
-          radius: 0.5,
-          bias: 0.02,
-          power: 3,
-          quality: 2,
-          bilateralThreshold: 0.1,
-          minHorizonAngle: 0.04
-        }
-      },
-      engine.resourceManager,
-      []
-    );
-
-    const ao = scene.ambientOcclusion;
-    expect(ao.enabled).to.equal(true);
-    expect(ao.intensity).to.equal(0.8);
-    expect(ao.radius).to.equal(0.5);
-    expect(ao.bias).to.equal(0.02);
-    expect(ao.power).to.equal(3);
-    expect(ao.quality).to.equal(2);
-    expect(ao.bilateralThreshold).to.equal(0.1);
-    expect(ao.minHorizonAngle).to.equal(0.04);
-  });
-
-  it("should apply SolidColor background from Vec4Tuple", async () => {
-    const scene = new Scene(engine);
-    await applySceneData(
-      scene,
-      {
-        rootEntities: [0],
-        background: {
-          mode: BackgroundMode.SolidColor,
-          color: [0.5, 0.6, 0.7, 1]
-        }
-      },
-      engine.resourceManager,
-      []
-    );
-
-    expect(scene.background.mode).to.equal(BackgroundMode.SolidColor);
-    expect(scene.background.solidColor.r).to.be.closeTo(0.5, 0.001);
-    expect(scene.background.solidColor.g).to.be.closeTo(0.6, 0.001);
-    expect(scene.background.solidColor.b).to.be.closeTo(0.7, 0.001);
-    expect(scene.background.solidColor.a).to.equal(1);
-  });
-
-  it("should preserve defaults when shadow/fog/AO sections are absent", async () => {
-    const scene = new Scene(engine);
-    await applySceneData(
-      scene,
-      {
-        rootEntities: [0],
-        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] }
-      },
-      engine.resourceManager,
-      []
-    );
-
-    expect(scene.castShadows).to.equal(true);
-    expect(scene.fogMode).to.equal(FogMode.None);
-    expect(scene.ambientOcclusion.enabled).to.equal(false);
-  });
-});
diff --git a/tests/src/loader/SceneParser.test.ts b/tests/src/loader/SceneParser.test.ts
new file mode 100644
index 0000000000..9ed2eb4944
--- /dev/null
+++ b/tests/src/loader/SceneParser.test.ts
@@ -0,0 +1,6 @@
+import { describe, it } from "vitest";
+
+describe("ProjectLoader Component Reference Tests", function () {
+  // TODO: update project.json to new format (old one contains deprecated "Environment" asset type)
+  it.skip("should load project successfully with component be deleted", async () => {});
+});
diff --git a/tests/src/loader/ScenePhysics.test.ts b/tests/src/loader/ScenePhysics.test.ts
new file mode 100644
index 0000000000..74a1a452cf
--- /dev/null
+++ b/tests/src/loader/ScenePhysics.test.ts
@@ -0,0 +1,50 @@
+import { AssetType, BackgroundMode, Scene } from "@galacean/engine";
+import "@galacean/engine-loader";
+import { PhysXPhysics } from "@galacean/engine-physics-physx";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+let engine: WebGLEngine;
+
+beforeAll(async () => {
+  engine = await WebGLEngine.create({
+    canvas: document.createElement("canvas"),
+    physics: new PhysXPhysics()
+  });
+});
+
+afterAll(() => {
+  engine?.destroy();
+});
+
+describe("SceneLoader physics settings", () => {
+  it("applies serialized scene physics settings to PhysicsScene", async () => {
+    const sceneData = {
+      name: "physics-scene",
+      entities: [],
+      scene: {
+        background: {
+          mode: BackgroundMode.SolidColor,
+          color: { r: 0, g: 0, b: 0, a: 1 }
+        },
+        physics: {
+          gravity: { x: 0, y: -3200, z: 0 },
+          fixedTimeStep: 1 / 120
+        }
+      },
+      files: []
+    };
+    const sceneUrl =
+      URL.createObjectURL(new Blob([JSON.stringify(sceneData)], { type: "application/json" })) + "#.scene";
+
+    const scene = await engine.resourceManager.load<Scene>({
+      url: sceneUrl,
+      type: AssetType.Scene
+    });
+
+    expect(scene.physics.gravity.x).toBe(0);
+    expect(scene.physics.gravity.y).toBe(-3200);
+    expect(scene.physics.gravity.z).toBe(0);
+    expect(scene.physics.fixedTimeStep).toBe(1 / 120);
+  });
+});
diff --git a/tests/src/loader/StrippedEntity.test.ts b/tests/src/loader/StrippedEntity.test.ts
new file mode 100644
index 0000000000..6f078d1d17
--- /dev/null
+++ b/tests/src/loader/StrippedEntity.test.ts
@@ -0,0 +1,277 @@
+/**
+ * Tests stripped entities that proxy internal prefab-instance entities.
+ *
+ * A stripped entity can resolve to an entity inside a nested prefab instance and
+ * serve as the parent for newly added entities.
+ */
+import { expect, beforeAll, afterAll, describe, it } from "vitest";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import type { IHierarchyFile } from "@galacean/engine-loader";
+import { Vector3 } from "@galacean/engine-math";
+import { PrefabParser } from "../../../packages/loader/src/prefab/PrefabParser";
+
+let engine: WebGLEngine;
+
+function getResourceObjectPool(): Record<string, unknown> {
+  return (engine.resourceManager as unknown as { _objectPool: Record<string, unknown> })._objectPool;
+}
+
+function cachePrefab(url: string, prefab: unknown): void {
+  getResourceObjectPool()[url] = prefab;
+}
+
+function removeCachedPrefab(url: string): void {
+  delete getResourceObjectPool()[url];
+}
+
+beforeAll(async () => {
+  const canvas = document.createElement("canvas");
+  canvas.width = 256;
+  canvas.height = 256;
+  engine = await WebGLEngine.create({ canvas });
+});
+
+afterAll(() => {
+  engine?.destroy();
+});
+
+describe("IStrippedEntity as addedEntities mechanism", () => {
+  it("keeps nested prefab children after instantiation", async () => {
+    const nestedPrefabData: IHierarchyFile = {
+      entities: [
+        { id: "0", name: "nestedRoot", components: [], children: ["1", "2"] },
+        { id: "1", name: "boneHand", parent: "0", components: [] },
+        { id: "2", name: "otherChild", parent: "0", components: [] }
+      ]
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "sanity.prefab", nestedPrefabData);
+    const inst = nestedPrefab.instantiate();
+    const names = inst.children.map((c) => c.name);
+    expect(names).toContain("boneHand");
+    expect(names).toContain("otherChild");
+    inst.destroy();
+  });
+
+  it("should attach new child entity under an internal entity of a nested prefab", async () => {
+    // Nested prefab:
+    //   root
+    //     - boneHand    (proxied by the stripped entity)
+    //     - otherChild
+    const nestedPrefabData: IHierarchyFile = {
+      entities: [
+        { id: "0", name: "nestedRoot", components: [], children: ["1", "2"] },
+        { id: "1", name: "boneHand", parent: "0", components: [] },
+        { id: "2", name: "otherChild", parent: "0", components: [] }
+      ]
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "char.prefab", nestedPrefabData);
+    cachePrefab("char.prefab", nestedPrefab);
+
+    // Outer prefab:
+    //   - IRefEntity instantiating the nested prefab (only direct child of outerRoot)
+    //   - IStrippedEntity proxying to boneHand, not in outerRoot.children
+    //   - weaponslot listed in stripped entity's children
+    const outerPrefabData: IHierarchyFile = {
+      entities: [
+        {
+          id: "outerRoot",
+          name: "Character",
+          components: [],
+          children: ["charInst"]
+        },
+        {
+          id: "charInst",
+          name: "char",
+          parent: "outerRoot",
+          components: [],
+          assetUrl: "char.prefab",
+          isClone: true,
+          modifications: [],
+          removedEntities: [],
+          removedComponents: []
+        } as any,
+        {
+          // Do not set `name`: _applyEntityData would override the internal entity's name.
+          strippedId: "boneHandle",
+          prefabInstanceId: "charInst",
+          prefabSource: { assetId: "", entityId: "0" },
+          components: [],
+          children: ["weaponslot"]
+        } as any,
+        {
+          id: "weaponslot",
+          name: "weaponslot1",
+          parent: "boneHandle",
+          components: [],
+          position: { x: 0.5, y: 0.25, z: 0 }
+        }
+      ]
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const charInst = root.children.find((c) => c.name === "char");
+    expect(charInst, "char instance should be a child of outerRoot").not.toBeUndefined();
+
+    const boneHand = charInst!.children.find((c) => c.name === "boneHand");
+    expect(boneHand, "boneHand should exist inside nested prefab").not.toBeUndefined();
+
+    const weaponslot = boneHand!.children.find((c) => c.name === "weaponslot1");
+    expect(weaponslot, "weaponslot1 should be attached as child of boneHand via stripped entity").not.toBeUndefined();
+    expect(weaponslot!.transform.position.x).toBeCloseTo(0.5, 5);
+    expect(weaponslot!.transform.position.y).toBeCloseTo(0.25, 5);
+    expect(weaponslot!.transform.position.z).toBeCloseTo(0, 5);
+
+    root.destroy();
+    removeCachedPrefab("char.prefab");
+  });
+
+  it("should support multiple stripped entities targeting different internal entities (LeftHand / RightHand socket case)", async () => {
+    // Nested prefab: root -> [LeftHand, RightHand]
+    const nestedPrefabData: IHierarchyFile = {
+      entities: [
+        { id: "0", name: "nestedRoot", components: [], children: ["1", "2"] },
+        { id: "1", name: "LeftHand", parent: "0", components: [] },
+        { id: "2", name: "RightHand", parent: "0", components: [] }
+      ]
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "body.prefab", nestedPrefabData);
+    cachePrefab("body.prefab", nestedPrefab);
+
+    // entityId is the path string generated by _generateInstanceContext:
+    //   nestedRoot = ""
+    //   nestedRoot.children[0] = LeftHand  -> "0"
+    //   nestedRoot.children[1] = RightHand -> "1"
+    const outerPrefabData: IHierarchyFile = {
+      entities: [
+        {
+          id: "outerRoot",
+          name: "Player",
+          components: [],
+          children: ["bodyInst"]
+        },
+        {
+          id: "bodyInst",
+          name: "body",
+          parent: "outerRoot",
+          components: [],
+          assetUrl: "body.prefab",
+          isClone: true,
+          modifications: [],
+          removedEntities: [],
+          removedComponents: []
+        } as any,
+        {
+          strippedId: "lhHandle",
+          prefabInstanceId: "bodyInst",
+          prefabSource: { assetId: "", entityId: "0" },
+          components: [],
+          children: ["ws1"]
+        } as any,
+        {
+          strippedId: "rhHandle",
+          prefabInstanceId: "bodyInst",
+          prefabSource: { assetId: "", entityId: "1" },
+          components: [],
+          children: ["ws2", "ws3"]
+        } as any,
+        { id: "ws1", name: "weaponslot1", parent: "lhHandle", components: [] },
+        { id: "ws2", name: "weaponslot2", parent: "rhHandle", components: [] },
+        { id: "ws3", name: "weaponslot3", parent: "rhHandle", components: [] }
+      ]
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "player.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+    const bodyInst = root.children.find((c) => c.name === "body")!;
+    const leftHand = bodyInst.children.find((c) => c.name === "LeftHand")!;
+    const rightHand = bodyInst.children.find((c) => c.name === "RightHand")!;
+
+    const slot1 = leftHand.children.find((c) => c.name === "weaponslot1");
+    const slot2 = rightHand.children.find((c) => c.name === "weaponslot2");
+    const slot3 = rightHand.children.find((c) => c.name === "weaponslot3");
+
+    expect(slot1, "weaponslot1 under LeftHand").not.toBeUndefined();
+    expect(slot2, "weaponslot2 under RightHand").not.toBeUndefined();
+    expect(slot3, "weaponslot3 under RightHand").not.toBeUndefined();
+
+    // No new entities should remain as direct children of outerRoot after reparenting
+    expect(root.children.find((c) => c.name === "weaponslot1")).toBeUndefined();
+    expect(root.children.find((c) => c.name === "lh-proxy")).toBeUndefined();
+
+    root.destroy();
+    removeCachedPrefab("body.prefab");
+  });
+
+  it("should propagate internal entity transform changes to the attached child (bone-drives-weapon behavior)", async () => {
+    // When an internal entity moves, the child attached through the stripped
+    // entity follows through normal hierarchy transforms.
+    const nestedPrefabData: IHierarchyFile = {
+      entities: [
+        { id: "0", name: "nestedRoot", components: [], children: ["1"] },
+        { id: "1", name: "bone", parent: "0", components: [] }
+      ]
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "skel.prefab", nestedPrefabData);
+    cachePrefab("skel.prefab", nestedPrefab);
+
+    const outerPrefabData: IHierarchyFile = {
+      entities: [
+        {
+          id: "outerRoot",
+          name: "Actor",
+          components: [],
+          children: ["skelInst"]
+        },
+        {
+          id: "skelInst",
+          name: "skel",
+          parent: "outerRoot",
+          components: [],
+          assetUrl: "skel.prefab",
+          isClone: true,
+          modifications: [],
+          removedEntities: [],
+          removedComponents: []
+        } as any,
+        {
+          strippedId: "boneHandle",
+          prefabInstanceId: "skelInst",
+          prefabSource: { assetId: "", entityId: "0" },
+          components: [],
+          children: ["weapon"]
+        } as any,
+        {
+          id: "weapon",
+          name: "weapon",
+          parent: "boneHandle",
+          components: [],
+          position: { x: 1, y: 0, z: 0 }
+        }
+      ]
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "actor.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+    const bone = root.children.find((c) => c.name === "skel")!.children.find((c) => c.name === "bone")!;
+    const weapon = bone.children.find((c) => c.name === "weapon")!;
+
+    // Initial: bone at origin, weapon world position = (1, 0, 0)
+    const worldPos = new Vector3();
+    worldPos.copyFrom(weapon.transform.worldPosition);
+    expect(worldPos.x).toBeCloseTo(1, 5);
+    expect(worldPos.y).toBeCloseTo(0, 5);
+    expect(worldPos.z).toBeCloseTo(0, 5);
+
+    // Simulate transform animation: move bone to (10, 5, -3)
+    bone.transform.setPosition(10, 5, -3);
+    worldPos.copyFrom(weapon.transform.worldPosition);
+    expect(worldPos.x).toBeCloseTo(11, 5); // 10 + 1
+    expect(worldPos.y).toBeCloseTo(5, 5); //  5 + 0
+    expect(worldPos.z).toBeCloseTo(-3, 5); // -3 + 0
+
+    root.destroy();
+    removeCachedPrefab("skel.prefab");
+  });
+});

From 1ca303174fdd89310e2242297ec5dfd3cd9a9844 Mon Sep 17 00:00:00 2001
From: luzhuang <wz84888@antgroup.com>
Date: Mon, 25 May 2026 20:45:22 +0800
Subject: [PATCH 02/10] chore: remove worktree husky symlink artifact

---
 .husky/_/husky.sh | 1 -
 1 file changed, 1 deletion(-)
 delete mode 120000 .husky/_/husky.sh

diff --git a/.husky/_/husky.sh b/.husky/_/husky.sh
deleted file mode 120000
index 7ca6a94c02..0000000000
--- a/.husky/_/husky.sh
+++ /dev/null
@@ -1 +0,0 @@
-/Users/wz/Documents/website/engine/.husky/_/husky.sh
\ No newline at end of file

From 0113e445b97efb6b12c2b4e9b060c5ca89500786 Mon Sep 17 00:00:00 2001
From: luzhuang <wz84888@antgroup.com>
Date: Mon, 25 May 2026 20:46:54 +0800
Subject: [PATCH 03/10] revert: remove clone changes from this PR

---
 packages/core/src/clone/CloneManager.ts | 126 ++++--------------------
 1 file changed, 17 insertions(+), 109 deletions(-)

diff --git a/packages/core/src/clone/CloneManager.ts b/packages/core/src/clone/CloneManager.ts
index b6f94ce248..be46462982 100644
--- a/packages/core/src/clone/CloneManager.ts
+++ b/packages/core/src/clone/CloneManager.ts
@@ -105,46 +105,21 @@ export class CloneManager {
   ): void {
     const sourceProperty = source[k];
 
-    // 1. Remappable references (Entity/Component) are always remapped, highest priority
+    // Remappable references (Entity/Component) are always remapped, regardless of clone decorator
     if (sourceProperty instanceof Object && (<ICustomClone>sourceProperty)._remap) {
       target[k] = (<ICustomClone>sourceProperty)._remap(srcRoot, targetRoot);
       return;
     }
 
-    // 2. Explicit ignore
     if (cloneMode === CloneMode.Ignore) return;
 
-    // 3. Primitives / null / undefined - direct assign
-    if (!(sourceProperty instanceof Object)) {
+    // Primitives, undecorated, or @assignmentClone: direct assign
+    if (!(sourceProperty instanceof Object) || cloneMode === undefined || cloneMode === CloneMode.Assignment) {
       target[k] = sourceProperty;
       return;
     }
 
-    // 4. Determine effective clone mode
-    let effectiveCloneMode: CloneMode = cloneMode;
-    if (effectiveCloneMode === undefined) {
-      // Undecorated: infer from runtime type
-      effectiveCloneMode = CloneManager._inferCloneMode(sourceProperty, target[k]);
-    } else if (effectiveCloneMode !== CloneMode.Assignment) {
-      // Decorated Shallow/Deep: upgrade to Deep if target already has independent same-type instance.
-      // Assignment is never upgraded — it means the user explicitly wants a reference copy.
-      const targetProperty = target[k];
-      if (
-        targetProperty &&
-        targetProperty !== sourceProperty &&
-        targetProperty.constructor === sourceProperty.constructor
-      ) {
-        effectiveCloneMode = CloneMode.Deep;
-      }
-    }
-
-    // 5. Assignment - direct reference copy
-    if (effectiveCloneMode === CloneMode.Assignment) {
-      target[k] = sourceProperty;
-      return;
-    }
-
-    // 6. Shallow/Deep clone for complex types
+    // @shallowClone / @deepClone: deep copy complex objects
     const type = sourceProperty.constructor;
     switch (type) {
       case Uint8Array:
@@ -162,37 +137,6 @@ export class CloneManager {
           targetPropertyT.set(<TypedArray>sourceProperty);
         }
         break;
-      case Map:
-        let targetPropertyM = <Map<any, any>>target[k];
-        if (targetPropertyM == null) {
-          target[k] = targetPropertyM = new Map<any, any>();
-        } else {
-          targetPropertyM.clear();
-        }
-        (<Map<any, any>>sourceProperty).forEach((value, key) => {
-          if (key instanceof Object && (<ICustomClone>key)._remap) {
-            key = (<ICustomClone>key)._remap(srcRoot, targetRoot);
-          }
-          if (value instanceof Object && (<ICustomClone>value)._remap) {
-            value = (<ICustomClone>value)._remap(srcRoot, targetRoot);
-          }
-          targetPropertyM.set(key, value);
-        });
-        break;
-      case Set:
-        let targetPropertyS = <Set<any>>target[k];
-        if (targetPropertyS == null) {
-          target[k] = targetPropertyS = new Set<any>();
-        } else {
-          targetPropertyS.clear();
-        }
-        (<Set<any>>sourceProperty).forEach((value) => {
-          if (value instanceof Object && (<ICustomClone>value)._remap) {
-            value = (<ICustomClone>value)._remap(srcRoot, targetRoot);
-          }
-          targetPropertyS.add(value);
-        });
-        break;
       case Array:
         let targetPropertyA = <Array<any>>target[k];
         const length = (<Array<any>>sourceProperty).length;
@@ -206,7 +150,7 @@ export class CloneManager {
             <Array<any>>sourceProperty,
             targetPropertyA,
             i,
-            cloneMode, // Pass original mode: decorated → children inherit, undecorated → children infer independently
+            cloneMode,
             srcRoot,
             targetRoot,
             deepInstanceMap
@@ -214,27 +158,25 @@ export class CloneManager {
         }
         break;
       default:
-        // Check if we've already visited this source object (cycle detection)
-        if (deepInstanceMap.has(sourceProperty)) {
-          target[k] = deepInstanceMap.get(sourceProperty);
-          return;
-        }
-
-        let targetPropertyD = <Object>target[k];
-        if (!targetPropertyD) {
-          targetPropertyD = new sourceProperty.constructor();
-          target[k] = targetPropertyD;
+        let targetProperty = <Object>target[k];
+        // If the target property is undefined, create new instance and keep reference sharing like the source
+        if (!targetProperty) {
+          targetProperty = deepInstanceMap.get(sourceProperty);
+          if (!targetProperty) {
+            targetProperty = new sourceProperty.constructor();
+            deepInstanceMap.set(sourceProperty, targetProperty);
+          }
+          target[k] = targetProperty;
         }
-        deepInstanceMap.set(sourceProperty, targetPropertyD);
 
         if ((<ICustomClone>sourceProperty).copyFrom) {
-          (<ICustomClone>targetPropertyD).copyFrom(<ICustomClone>sourceProperty);
+          (<ICustomClone>targetProperty).copyFrom(<ICustomClone>sourceProperty);
         } else {
           const cloneModes = CloneManager.getCloneMode(sourceProperty.constructor);
           for (let k in sourceProperty) {
             CloneManager.cloneProperty(
               <Object>sourceProperty,
-              targetPropertyD,
+              targetProperty,
               k,
               cloneModes[k],
               srcRoot,
@@ -242,46 +184,12 @@ export class CloneManager {
               deepInstanceMap
             );
           }
-          (<ICustomClone>sourceProperty)._cloneTo?.(<ICustomClone>targetPropertyD, srcRoot, targetRoot);
+          (<ICustomClone>sourceProperty)._cloneTo?.(<ICustomClone>targetProperty, srcRoot, targetRoot);
         }
         break;
     }
   }
 
-  /**
-   * Infer the appropriate clone mode for an undecorated property based on its runtime type.
-   * This enables user custom scripts to get correct clone behavior without decorators.
-   */
-  private static _inferCloneMode(sourceProperty: Object, targetProperty: any): CloneMode {
-    // If target already has an independent instance of the same type,
-    // deep clone to preserve isolation (e.g., constructor-created objects)
-    if (
-      targetProperty &&
-      targetProperty !== sourceProperty &&
-      targetProperty.constructor === sourceProperty.constructor
-    ) {
-      return CloneMode.Deep;
-    }
-
-    // Arrays need recursive processing (may contain Entity/Component refs)
-    if (Array.isArray(sourceProperty)) return CloneMode.Deep;
-
-    // TypedArrays - copy data
-    if (ArrayBuffer.isView(sourceProperty)) return CloneMode.Deep;
-
-    // Maps and Sets - create independent copies
-    if (sourceProperty instanceof Map || sourceProperty instanceof Set) return CloneMode.Deep;
-
-    // Value types with copyFrom (math types like Vector3, Color, etc.)
-    if ((<ICustomClone>sourceProperty).copyFrom) return CloneMode.Deep;
-
-    // Plain objects - deep clone (may contain Entity/Component refs)
-    if (sourceProperty.constructor === Object) return CloneMode.Deep;
-
-    // Other class instances (engine resources like Material, Texture) - shared reference
-    return CloneMode.Assignment;
-  }
-
   static deepCloneObject(source: Object, target: Object, deepInstanceMap: Map<Object, Object>): void {
     for (let k in source) {
       CloneManager.cloneProperty(source, target, k, CloneMode.Deep, null, null, deepInstanceMap);

From 2eeed9728a6a639fdb7dfc5774f1467a6c7fc922 Mon Sep 17 00:00:00 2001
From: luzhuang <wz84888@antgroup.com>
Date: Tue, 26 May 2026 11:03:01 +0800
Subject: [PATCH 04/10] fix(animation, loader): fix 5 P1 bugs from code review

- Remove dead parseProperty/renderState in MaterialLoader
- Restore revokeObjectURL in GLTFUtils.loadImageBuffer
- Add null guard in Animator._crossFade
- Guard playSpeed=0 division in _updatePlayingState
- Clean up clipChangedListener in Animator._reset
---
 packages/core/src/animation/Animator.ts       | 22 ++++++++++++++++---
 .../animation/internal/AnimatorStateData.ts   |  3 +++
 packages/loader/src/MaterialLoader.ts         | 14 +-----------
 packages/loader/src/gltf/GLTFUtils.ts         |  2 ++
 4 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/packages/core/src/animation/Animator.ts b/packages/core/src/animation/Animator.ts
index 2c1638abf1..12a77b6d88 100644
--- a/packages/core/src/animation/Animator.ts
+++ b/packages/core/src/animation/Animator.ts
@@ -334,7 +334,7 @@ export class Animator extends Component {
    * @internal
    */
   _reset(): void {
-    const { _curveOwnerPool: animationCurveOwners } = this;
+    const { _curveOwnerPool: animationCurveOwners, _animatorLayersData: layersData } = this;
     for (let instanceId in animationCurveOwners) {
       const propertyOwners = animationCurveOwners[instanceId];
       for (let property in propertyOwners) {
@@ -343,7 +343,20 @@ export class Animator extends Component {
       }
     }
 
-    this._animatorLayersData.length = 0;
+    for (let i = 0, n = layersData.length; i < n; i++) {
+      const { animatorStateDataMap } = layersData[i];
+      for (let name in animatorStateDataMap) {
+        const stateData = animatorStateDataMap[name];
+        const { clipChangedListener, animatorState } = stateData;
+        if (clipChangedListener) {
+          animatorState._updateFlagManager.removeListener(clipChangedListener);
+          stateData.clipChangedListener = null;
+          stateData.animatorState = null;
+        }
+      }
+    }
+
+    layersData.length = 0;
     this._curveOwnerPool = Object.create(null);
     this._parametersValueMap = Object.create(null);
     this._animationEventHandlerPool.clear();
@@ -385,6 +398,7 @@ export class Animator extends Component {
     }
 
     const { state, layerIndex: playLayerIndex } = this._getAnimatorStateInfo(stateName, layerIndex);
+    if (!state) return;
     const { manuallyTransition } = this._getAnimatorLayerData(playLayerIndex);
     manuallyTransition.duration = duration;
 
@@ -516,6 +530,8 @@ export class Animator extends Component {
       }
     };
     clipChangedListener();
+    animatorStateData.animatorState = state;
+    animatorStateData.clipChangedListener = clipChangedListener;
     state._updateFlagManager.addListener(clipChangedListener);
   }
 
@@ -722,7 +738,7 @@ export class Animator extends Component {
 
     if (transition) {
       // Remove speed factor, use actual cost time
-      const remainDeltaTime = deltaTime - playCostTime / playSpeed;
+      const remainDeltaTime = playSpeed === 0 ? deltaTime : deltaTime - playCostTime / playSpeed;
       remainDeltaTime > 0 && this._updateState(layerData, remainDeltaTime, aniUpdate);
     }
   }
diff --git a/packages/core/src/animation/internal/AnimatorStateData.ts b/packages/core/src/animation/internal/AnimatorStateData.ts
index 146c0bb52f..284176f69c 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,6 @@ import { AnimationEventHandler } from "./AnimationEventHandler";
 export class AnimatorStateData {
   curveLayerOwner: AnimationCurveLayerOwner[] = [];
   eventHandlers: AnimationEventHandler[] = [];
+  animatorState: AnimatorState;
+  clipChangedListener: () => void;
 }
diff --git a/packages/loader/src/MaterialLoader.ts b/packages/loader/src/MaterialLoader.ts
index ec3c2a9942..a710a0f579 100644
--- a/packages/loader/src/MaterialLoader.ts
+++ b/packages/loader/src/MaterialLoader.ts
@@ -21,16 +21,6 @@ import {
   type IVector4
 } from "./resource-deserialize";
 
-function parseProperty(object: Object, key: string, value: any) {
-  if (typeof value === "object") {
-    for (let subKey in value) {
-      parseProperty(object[key], subKey, value[subKey]);
-    }
-  } else {
-    object[key] = value;
-  }
-}
-
 @resourceLoader(AssetType.Material, ["mat"])
 class MaterialLoader extends Loader<Material> {
   load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Material> {
@@ -61,7 +51,7 @@ class MaterialLoader extends Loader<Material> {
   }
 
   private _getMaterialByShader(materialSchema: IMaterialSchema, shader: Shader, engine: Engine): Promise<Material> {
-    const { name, shaderData, macros, renderState } = materialSchema;
+    const { name, shaderData, macros } = materialSchema;
 
     const material = new Material(engine, shader);
     material.name = name;
@@ -122,8 +112,6 @@ class MaterialLoader extends Loader<Material> {
       }
     }
 
-    parseProperty(material, "renderState", renderState);
-
     return Promise.all(texturePromises).then(() => {
       return material;
     });
diff --git a/packages/loader/src/gltf/GLTFUtils.ts b/packages/loader/src/gltf/GLTFUtils.ts
index 35f6488010..a8164a290b 100644
--- a/packages/loader/src/gltf/GLTFUtils.ts
+++ b/packages/loader/src/gltf/GLTFUtils.ts
@@ -364,11 +364,13 @@ export class GLTFUtils {
       const blob = new window.Blob([imageBuffer], { type });
       const img = new Image();
       img.onerror = function () {
+        URL.revokeObjectURL(img.src);
         reject(new Error("Failed to load image buffer"));
       };
       img.onload = function () {
         // Call requestAnimationFrame to avoid iOS's bug.
         requestAnimationFrame(() => {
+          URL.revokeObjectURL(img.src);
           resolve(img);
           img.onload = null;
           img.onerror = null;

From c2c751e5bc2ff663b0deb240e33d9e2eadf5d556 Mon Sep 17 00:00:00 2001
From: luzhuang <wz84888@antgroup.com>
Date: Tue, 26 May 2026 11:26:09 +0800
Subject: [PATCH 05/10] fix: narrow PR scope to gltf/animation/physics/audio
 only

Revert non-gltf loader changes and restore misdeleted
files back to dev/2.0 state.
---
 packages/core/src/Entity.ts                   |   93 +-
 .../src/animation/AnimatorStateInstance.ts    |   76 ++
 packages/loader/package.json                  |    2 +-
 packages/loader/src/HDRDecoder.ts             |  232 ++--
 packages/loader/src/MaterialLoader.ts         |    8 +-
 packages/loader/src/PrefabLoader.ts           |    4 +-
 packages/loader/src/SceneLoader.ts            |  290 ++--
 packages/loader/src/ShaderChunkLoader.ts      |   51 -
 packages/loader/src/ShaderLoader.ts           |   30 +-
 packages/loader/src/SpriteAtlasLoader.ts      |    4 +-
 packages/loader/src/SpriteLoader.ts           |    4 +-
 packages/loader/src/Texture2DLoader.ts        |  148 ---
 packages/loader/src/TextureCubeLoader.ts      |   78 --
 packages/loader/src/TextureLoader.ts          |  192 +++
 packages/loader/src/index.ts                  |    8 +-
 packages/loader/src/prefab/PrefabParser.ts    |   28 +-
 packages/loader/src/prefab/PrefabResource.ts  |    2 +-
 .../loader/src/resource-deserialize/index.ts  |    5 +-
 .../resources/mesh/IModelMesh.d.ts            |    2 +-
 .../resources/parser/HierarchyParser.ts       |  530 ++++----
 .../resources/parser/ParserContext.ts         |   40 +-
 .../resources/parser/ReflectionParser.ts      |  370 +++---
 .../resources/scene/SceneParser.ts            |   96 +-
 .../resources/schema/BasicSchema.ts           |  122 --
 .../resources/schema/MaterialSchema.ts        |  111 --
 .../resources/schema/SceneSchema.ts           |   90 --
 .../resources/texture2D/Texture2DDecoder.ts   |   59 +
 .../resources/texture2D/TextureDecoder.ts     |   77 --
 .../textureCube/TextureCubeDecoder.ts         |   64 +
 packages/loader/src/schema/BasicSchema.ts     |   24 +
 packages/loader/src/schema/CommonSchema.ts    |   38 +
 packages/loader/src/schema/HierarchySchema.ts |   85 ++
 packages/loader/src/schema/MaterialSchema.ts  |   26 +
 packages/loader/src/schema/PrefabSchema.ts    |    5 +
 .../resources => }/schema/ProjectSchema.ts    |    0
 packages/loader/src/schema/SceneSchema.ts     |   68 +
 .../resources => }/schema/index.ts            |    5 +-
 packages/loader/src/schema/refs.ts            |    9 +
 tests/src/core/particle/Burst.test.ts         |  187 +++
 .../LimitVelocityOverLifetime.test.ts         |    2 +-
 .../core/particle/ParticleBoundingBox.test.ts |   69 +-
 .../core/particle/ParticleRenderer.test.ts    |    2 +-
 .../particle/ParticleShapeTransform.test.ts   |  270 ++++
 .../core/particle/ParticleStopResume.test.ts  |  142 --
 .../ParticleTextureSheetAnimation.test.ts     |    2 +-
 .../core/particle/RateOverDistance.test.ts    |  100 ++
 .../core/particle/RateOverTimeReplay.test.ts  |  138 ++
 tests/src/loader/KTX2Loader.test.ts           |    2 +-
 tests/src/loader/PrefabResource.test.ts       |  815 ++++++++++--
 tests/src/loader/RawAssetLoader.test.ts       |    2 +-
 tests/src/loader/RenderTargetLoader.test.ts   |    2 +-
 tests/src/loader/SceneFormatV2.test.ts        | 1164 +++++++++++++++++
 tests/src/loader/SceneParser.test.ts          |    6 -
 tests/src/loader/ScenePhysics.test.ts         |   50 -
 tests/src/loader/StrippedEntity.test.ts       |  277 ----
 55 files changed, 4103 insertions(+), 2203 deletions(-)
 create mode 100644 packages/core/src/animation/AnimatorStateInstance.ts
 delete mode 100644 packages/loader/src/ShaderChunkLoader.ts
 delete mode 100644 packages/loader/src/Texture2DLoader.ts
 delete mode 100644 packages/loader/src/TextureCubeLoader.ts
 create mode 100644 packages/loader/src/TextureLoader.ts
 delete mode 100644 packages/loader/src/resource-deserialize/resources/schema/BasicSchema.ts
 delete mode 100644 packages/loader/src/resource-deserialize/resources/schema/MaterialSchema.ts
 delete mode 100644 packages/loader/src/resource-deserialize/resources/schema/SceneSchema.ts
 create mode 100644 packages/loader/src/resource-deserialize/resources/texture2D/Texture2DDecoder.ts
 delete mode 100644 packages/loader/src/resource-deserialize/resources/texture2D/TextureDecoder.ts
 create mode 100644 packages/loader/src/resource-deserialize/resources/textureCube/TextureCubeDecoder.ts
 create mode 100644 packages/loader/src/schema/BasicSchema.ts
 create mode 100644 packages/loader/src/schema/CommonSchema.ts
 create mode 100644 packages/loader/src/schema/HierarchySchema.ts
 create mode 100644 packages/loader/src/schema/MaterialSchema.ts
 create mode 100644 packages/loader/src/schema/PrefabSchema.ts
 rename packages/loader/src/{resource-deserialize/resources => }/schema/ProjectSchema.ts (100%)
 create mode 100644 packages/loader/src/schema/SceneSchema.ts
 rename packages/loader/src/{resource-deserialize/resources => }/schema/index.ts (56%)
 create mode 100644 packages/loader/src/schema/refs.ts
 create mode 100644 tests/src/core/particle/Burst.test.ts
 create mode 100644 tests/src/core/particle/ParticleShapeTransform.test.ts
 delete mode 100644 tests/src/core/particle/ParticleStopResume.test.ts
 create mode 100644 tests/src/core/particle/RateOverTimeReplay.test.ts
 create mode 100644 tests/src/loader/SceneFormatV2.test.ts
 delete mode 100644 tests/src/loader/SceneParser.test.ts
 delete mode 100644 tests/src/loader/ScenePhysics.test.ts
 delete mode 100644 tests/src/loader/StrippedEntity.test.ts

diff --git a/packages/core/src/Entity.ts b/packages/core/src/Entity.ts
index 5b0c929ac1..063fbe1c1c 100644
--- a/packages/core/src/Entity.ts
+++ b/packages/core/src/Entity.ts
@@ -9,7 +9,7 @@ import { Script } from "./Script";
 import { Transform } from "./Transform";
 import { UpdateFlagManager } from "./UpdateFlagManager";
 import { ReferResource } from "./asset/ReferResource";
-import { EngineObject, Logger } from "./base";
+import { EngineObject } from "./base";
 import { CloneUtils } from "./clone/CloneUtils";
 import { ComponentCloner } from "./clone/ComponentCloner";
 import { ActiveChangeFlag } from "./enums/ActiveChangeFlag";
@@ -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;
@@ -122,7 +124,7 @@ export class Entity extends EngineObject {
   private _transform: Transform;
   private _templateResource: ReferResource;
   private _parent: Entity = null;
-  private _isActiveChanging: boolean = false;
+  private _activeChangedComponents: Component[];
   private _modifyFlagManager: UpdateFlagManager;
 
   /**
@@ -212,14 +214,16 @@ export class Entity extends EngineObject {
   }
 
   set siblingIndex(value: number) {
+    if (this._siblingIndex === -1) {
+      throw `The entity ${this.name} is not in the hierarchy`;
+    }
+
     if (this._isRoot) {
       this._setSiblingIndex(this._scene._rootEntities, value);
-    } else if (this._parent) {
+    } else {
       const parent = this._parent;
       this._setSiblingIndex(parent._children, value);
       parent._dispatchModify(EntityModifyFlags.Child, parent);
-    } else {
-      Logger.warn(`The entity ${this.name} is not in the hierarchy`);
     }
   }
 
@@ -339,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];
@@ -347,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) {
@@ -367,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);
   }
 
@@ -401,11 +404,6 @@ export class Entity extends EngineObject {
     for (let i = children.length - 1; i >= 0; i--) {
       const child = children[i];
       child._parent = null;
-      child._siblingIndex = -1;
-      // Dispatch `Child` to the old parent before `_processInActive` (which unregisters
-      // UI listeners via `cleanRootCanvas`), so subscribers such as UICanvas can react
-      // to the hierarchy change while still attached.
-      this._dispatchModify(EntityModifyFlags.Child, this);
 
       let activeChangeFlag = ActiveChangeFlag.None;
       child._isActiveInHierarchy && (activeChangeFlag |= ActiveChangeFlag.Hierarchy);
@@ -413,8 +411,6 @@ export class Entity extends EngineObject {
       activeChangeFlag && child._processInActive(activeChangeFlag);
 
       Entity._traverseSetOwnerScene(child, null); // Must after child._processInActive().
-
-      child._setParentChange();
     }
     children.length = 0;
   }
@@ -543,6 +539,7 @@ export class Entity extends EngineObject {
   _addScript(script: Script) {
     script._entityScriptsIndex = this._scripts.length;
     this._scripts.add(script);
+    this._scriptsVersion++;
   }
 
   /**
@@ -552,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++;
   }
 
   /**
@@ -570,24 +568,24 @@ export class Entity extends EngineObject {
    * @internal
    */
   _processActive(activeChangeFlag: ActiveChangeFlag): void {
-    if (this._isActiveChanging) {
+    if (this._activeChangedComponents) {
       throw "Note: can't set the 'main inActive entity' active in hierarchy, if the operation is in main inActive entity or it's children script's onDisable Event.";
     }
-    this._isActiveChanging = true;
-    this._setActiveInHierarchy(activeChangeFlag);
-    this._isActiveChanging = false;
+    this._activeChangedComponents = this._scene._componentsManager.getActiveChangedTempList();
+    this._setActiveInHierarchy(this._activeChangedComponents, activeChangeFlag);
+    this._setActiveComponents(true, activeChangeFlag);
   }
 
   /**
    * @internal
    */
   _processInActive(activeChangeFlag: ActiveChangeFlag): void {
-    if (this._isActiveChanging) {
+    if (this._activeChangedComponents) {
       throw "Note: can't set the 'main active entity' inActive in hierarchy, if the operation is in main active entity or it's children script's onEnable Event.";
     }
-    this._isActiveChanging = true;
-    this._setInActiveInHierarchy(activeChangeFlag);
-    this._isActiveChanging = false;
+    this._activeChangedComponents = this._scene._componentsManager.getActiveChangedTempList();
+    this._setInActiveInHierarchy(this._activeChangedComponents, activeChangeFlag);
+    this._setActiveComponents(false, activeChangeFlag);
   }
 
   /**
@@ -684,46 +682,57 @@ export class Entity extends EngineObject {
   }
 
   private _getComponentsInChildren<T extends Component>(type: ComponentConstructor<T>, results: T[]): void {
-    const components = this._components;
-    for (let i = 0, n = components.length; i < n; i++) {
-      const component = components[i];
+    for (let i = this._components.length - 1; i >= 0; i--) {
+      const component = this._components[i];
       if (component instanceof type) {
         results.push(component);
       }
     }
-    const children = this._children;
-    for (let i = 0, n = children.length; i < n; i++) {
-      children[i]._getComponentsInChildren<T>(type, results);
+    for (let i = this._children.length - 1; i >= 0; i--) {
+      this._children[i]._getComponentsInChildren<T>(type, results);
     }
   }
 
-  private _setActiveInHierarchy(activeChangeFlag: ActiveChangeFlag): void {
+  private _setActiveComponents(isActive: boolean, activeChangeFlag: ActiveChangeFlag): void {
+    const activeChangedComponents = this._activeChangedComponents;
+    for (let i = 0, length = activeChangedComponents.length; i < length; ++i) {
+      const component = activeChangedComponents[i];
+      // Skip components whose scene was already cleared by an earlier callback's removeChild
+      if (!isActive && !component._entity._scene) continue;
+      component._setActive(isActive, activeChangeFlag);
+    }
+    this._scene._componentsManager.putActiveChangedTempList(activeChangedComponents);
+    this._activeChangedComponents = null;
+  }
+
+  private _setActiveInHierarchy(activeChangedComponents: Component[], activeChangeFlag: ActiveChangeFlag): void {
     activeChangeFlag & ActiveChangeFlag.Hierarchy && (this._isActiveInHierarchy = true);
     activeChangeFlag & ActiveChangeFlag.Scene && (this._isActiveInScene = true);
     const components = this._components;
     for (let i = 0, n = components.length; i < n; i++) {
       const component = components[i];
-      (component.enabled || !component._awoken) && component._setActive(true, activeChangeFlag);
+      (component.enabled || !component._awoken) && activeChangedComponents.push(component);
     }
     const children = this._children;
-    for (let i = children.length - 1; i >= 0; i--) {
+    for (let i = 0, n = children.length; i < n; i++) {
       const child = children[i];
-      child.isActive && child._setActiveInHierarchy(activeChangeFlag);
+      child.isActive && child._setActiveInHierarchy(activeChangedComponents, activeChangeFlag);
     }
   }
 
-  private _setInActiveInHierarchy(activeChangeFlag: ActiveChangeFlag): void {
+  private _setInActiveInHierarchy(activeChangedComponents: Component[], activeChangeFlag: ActiveChangeFlag): void {
+    // Children-first, reverse traversal for safe removeChild during callbacks
+    const children = this._children;
+    for (let i = children.length - 1; i >= 0; i--) {
+      const child = children[i];
+      child.isActive && child._setInActiveInHierarchy(activeChangedComponents, activeChangeFlag);
+    }
     activeChangeFlag & ActiveChangeFlag.Hierarchy && (this._isActiveInHierarchy = false);
     activeChangeFlag & ActiveChangeFlag.Scene && (this._isActiveInScene = false);
     const components = this._components;
     for (let i = 0, n = components.length; i < n; i++) {
       const component = components[i];
-      component.enabled && component._setActive(false, activeChangeFlag);
-    }
-    const children = this._children;
-    for (let i = children.length - 1; i >= 0; i--) {
-      const child = children[i];
-      child.isActive && child._setInActiveInHierarchy(activeChangeFlag);
+      component.enabled && activeChangedComponents.push(component);
     }
   }
 
diff --git a/packages/core/src/animation/AnimatorStateInstance.ts b/packages/core/src/animation/AnimatorStateInstance.ts
new file mode 100644
index 0000000000..9bcdfa0fb5
--- /dev/null
+++ b/packages/core/src/animation/AnimatorStateInstance.ts
@@ -0,0 +1,76 @@
+import { AnimationClip } from "./AnimationClip";
+import { AnimatorState } from "./AnimatorState";
+import { AnimatorStatePlayData } from "./internal/AnimatorStatePlayData";
+import { WrapMode } from "./enums/WrapMode";
+
+/**
+ * Per-Animator view of an `AnimatorState`.
+ *
+ * Override fields (speed, wrapMode) are scoped to this Animator; 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;
+
+  /**
+   * The name of the underlying state.
+   */
+  get name(): string {
+    return this._state.name;
+  }
+
+  /**
+   * The animation clip of the underlying state.
+   */
+  get clip(): AnimationClip {
+    return this._state.clip;
+  }
+
+  /**
+   * The normalized clip start time of the underlying state.
+   */
+  get clipStartTime(): number {
+    return this._state.clipStartTime;
+  }
+
+  /**
+   * The normalized clip end time of the underlying state.
+   */
+  get clipEndTime(): number {
+    return this._state.clipEndTime;
+  }
+
+  /**
+   * Playback speed for this Animator; overrides the underlying state when set.
+   */
+  get speed(): number {
+    return this._speed ?? this._state.speed;
+  }
+
+  set speed(value: number) {
+    this._speed = value;
+  }
+
+  /**
+   * Wrap mode for this Animator; overrides the underlying state when set.
+   */
+  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/loader/package.json b/packages/loader/package.json
index 5e69bbe4e3..2cf33bba0b 100644
--- a/packages/loader/package.json
+++ b/packages/loader/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-loader",
-  "version": "0.0.0-experimental-2.0-game.14",
+  "version": "2.0.0-alpha.33",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
diff --git a/packages/loader/src/HDRDecoder.ts b/packages/loader/src/HDRDecoder.ts
index 3dd7419192..d0692926f0 100644
--- a/packages/loader/src/HDRDecoder.ts
+++ b/packages/loader/src/HDRDecoder.ts
@@ -1,23 +1,18 @@
 /**
- * HDR panorama to cubemap decoder.
+ * HDR (Radiance RGBE) image decoder.
+ *
+ * Decodes .hdr files into pixel data. Supports parsing the header
+ * and decoding RLE-compressed RGBE scanlines into R16G16B16A16 half-float pixels.
  */
 export class HDRDecoder {
-  // Float32 to Float16 lookup tables (http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf)
   private static _float2HalfTables = HDRDecoder._generateFloat2HalfTables();
   private static _floatView = new Float32Array(1);
   private static _uint32View = new Uint32Array(HDRDecoder._floatView.buffer);
-  private static _one = 0x3c00; // Half float for 1.0
-
-  // prettier-ignore
-  private static _faces = [ // Cubemap face corners [bottomLeft, bottomRight, topLeft, topRight] as flat xyz
-    /* +X */ [ 1,-1,-1,  1,-1, 1,  1, 1,-1,  1, 1, 1],
-    /* -X */ [-1,-1, 1, -1,-1,-1, -1, 1, 1, -1, 1,-1],
-    /* +Y */ [-1,-1, 1,  1,-1, 1, -1,-1,-1,  1,-1,-1],
-    /* -Y */ [-1, 1,-1,  1, 1,-1, -1, 1, 1,  1, 1, 1],
-    /* +Z */ [-1,-1,-1,  1,-1,-1, -1, 1,-1,  1, 1,-1],
-    /* -Z */ [ 1,-1, 1, -1,-1, 1,  1, 1, 1, -1, 1, 1]
-  ];
 
+  /**
+   * Parse the header of an HDR file.
+   * @returns Header info including width, height, and data start position.
+   */
   static parseHeader(uint8array: Uint8Array): IHDRHeader {
     let line = this._readStringLine(uint8array, 0);
     if (line[0] !== "#" || line[1] !== "?") {
@@ -56,140 +51,50 @@ export class HDRDecoder {
     return { height, width, dataPosition: lineIndex + line.length + 1 };
   }
 
-  static decodeFaces(
-    bufferArray: Uint8Array,
-    header: IHDRHeader,
-    onFace: (faceIndex: number, data: Uint16Array) => void
-  ): void {
+  /**
+   * Decode an HDR file buffer into R16G16B16A16 half-float pixel data.
+   * @param buffer - The full HDR file as Uint8Array.
+   * @returns Object with width, height, and half-float pixel data.
+   */
+  static decode(buffer: Uint8Array): { width: number; height: number; pixels: Uint16Array } {
+    const header = this.parseHeader(buffer);
     const { width, height, dataPosition } = header;
-    const cubeSize = height >> 1;
-    const pixels = HDRDecoder._readPixels(bufferArray.subarray(dataPosition), width, height);
-
-    const faces = HDRDecoder._faces;
-    const faceBuffer = new Uint16Array(cubeSize * cubeSize * 4);
-    for (let faceIndex = 0; faceIndex < 6; faceIndex++) {
-      HDRDecoder._createCubemapData(cubeSize, faces[faceIndex], pixels, width, height, faceBuffer);
-      onFace(faceIndex, faceBuffer);
-    }
-  }
-
-  private static _generateFloat2HalfTables(): { baseTable: Uint32Array; shiftTable: Uint32Array } {
-    const baseTable = new Uint32Array(512);
-    const shiftTable = new Uint32Array(512);
-    for (let i = 0; i < 256; ++i) {
-      const e = i - 127;
-      if (e < -27) {
-        baseTable[i] = 0x0000;
-        baseTable[i | 0x100] = 0x8000;
-        shiftTable[i] = 24;
-        shiftTable[i | 0x100] = 24;
-      } else if (e < -14) {
-        baseTable[i] = 0x0400 >> (-e - 14);
-        baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;
-        shiftTable[i] = -e - 1;
-        shiftTable[i | 0x100] = -e - 1;
-      } else if (e <= 15) {
-        baseTable[i] = (e + 15) << 10;
-        baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;
-        shiftTable[i] = 13;
-        shiftTable[i | 0x100] = 13;
-      } else if (e < 128) {
-        baseTable[i] = 0x7c00;
-        baseTable[i | 0x100] = 0xfc00;
-        shiftTable[i] = 24;
-        shiftTable[i | 0x100] = 24;
-      } else {
-        baseTable[i] = 0x7c00;
-        baseTable[i | 0x100] = 0xfc00;
-        shiftTable[i] = 13;
-        shiftTable[i | 0x100] = 13;
-      }
-    }
-    return { baseTable, shiftTable };
+    const rgbe = this._readPixels(buffer.subarray(dataPosition), width, height);
+    const pixels = this._rgbeToHalfFloat(rgbe, width, height);
+    return { width, height, pixels };
   }
 
-  private static _createCubemapData(
-    texSize: number,
-    face: number[],
-    pixels: Uint8Array,
-    inputWidth: number,
-    inputHeight: number,
-    facePixels: Uint16Array
-  ): void {
-    const invSize = 1 / texSize;
-    const rotDX1X = (face[3] - face[0]) * invSize;
-    const rotDX1Y = (face[4] - face[1]) * invSize;
-    const rotDX1Z = (face[5] - face[2]) * invSize;
-    const rotDX2X = (face[9] - face[6]) * invSize;
-    const rotDX2Y = (face[10] - face[7]) * invSize;
-    const rotDX2Z = (face[11] - face[8]) * invSize;
-
-    const floatView = HDRDecoder._floatView;
-    const uint32View = HDRDecoder._uint32View;
-    const { baseTable, shiftTable } = HDRDecoder._float2HalfTables;
-    const one = HDRDecoder._one;
-
-    let fy = 0;
-    for (let y = 0; y < texSize; y++) {
-      let xv1X = face[0],
-        xv1Y = face[1],
-        xv1Z = face[2];
-      let xv2X = face[6],
-        xv2Y = face[7],
-        xv2Z = face[8];
-
-      for (let x = 0; x < texSize; x++) {
-        let dirX = xv1X + (xv2X - xv1X) * fy;
-        let dirY = xv1Y + (xv2Y - xv1Y) * fy;
-        let dirZ = xv1Z + (xv2Z - xv1Z) * fy;
-        const invLen = 1 / Math.sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ);
-        dirX *= invLen;
-        dirY *= invLen;
-        dirZ *= invLen;
-
-        let px = Math.round(((Math.atan2(dirZ, dirX) / Math.PI) * 0.5 + 0.5) * inputWidth);
-        if (px < 0) px = 0;
-        else if (px >= inputWidth) px = inputWidth - 1;
-
-        let py = Math.round((Math.acos(dirY) / Math.PI) * inputHeight);
-        if (py < 0) py = 0;
-        else if (py >= inputHeight) py = inputHeight - 1;
-
-        const srcIndex = (inputHeight - py - 1) * inputWidth * 4 + px * 4;
-        const scaleFactor = Math.pow(2, pixels[srcIndex + 3] - 128) / 255;
-        const dstIndex = y * texSize * 4 + x * 4;
-
-        for (let c = 0; c < 3; c++) {
-          // Clamp to half-float max (65504) to prevent Infinity in R16G16B16A16
-          floatView[0] = Math.min(pixels[srcIndex + c] * scaleFactor, 65504);
-          const f = uint32View[0];
-          const e = (f >> 23) & 0x1ff;
-          facePixels[dstIndex + c] = baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);
-        }
-        facePixels[dstIndex + 3] = one;
-
-        xv1X += rotDX1X;
-        xv1Y += rotDX1Y;
-        xv1Z += rotDX1Z;
-        xv2X += rotDX2X;
-        xv2Y += rotDX2Y;
-        xv2Z += rotDX2Z;
+  /**
+   * Convert RGBE pixel data to R16G16B16A16 half-float.
+   */
+  static _rgbeToHalfFloat(rgbe: Uint8Array, width: number, height: number): Uint16Array {
+    const floatView = this._floatView;
+    const uint32View = this._uint32View;
+    const { baseTable, shiftTable } = this._float2HalfTables;
+    const one = 0x3c00; // Half float 1.0
+    const pixelCount = width * height;
+    const result = new Uint16Array(pixelCount * 4);
+
+    for (let i = 0; i < pixelCount; i++) {
+      const srcIdx = i * 4;
+      const dstIdx = i * 4;
+      const scaleFactor = Math.pow(2, rgbe[srcIdx + 3] - 128 - 8);
+
+      for (let c = 0; c < 3; c++) {
+        floatView[0] = Math.min(rgbe[srcIdx + c] * scaleFactor, 65504);
+        const f = uint32View[0];
+        const e = (f >> 23) & 0x1ff;
+        result[dstIdx + c] = baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);
       }
-      fy += invSize;
-    }
-  }
-
-  private static _readStringLine(uint8array: Uint8Array, startIndex: number): string {
-    let line = "";
-    for (let i = startIndex, n = uint8array.length; i < n; i++) {
-      const character = String.fromCharCode(uint8array[i]);
-      if (character === "\n") break;
-      line += character;
+      result[dstIdx + 3] = one;
     }
-    return line;
+    return result;
   }
 
-  private static _readPixels(buffer: Uint8Array, width: number, height: number): Uint8Array {
+  /**
+   * Decode RLE-compressed RGBE scanlines into raw RGBE pixel data.
+   */
+  static _readPixels(buffer: Uint8Array, width: number, height: number): Uint8Array {
     const byteLength = buffer.byteLength;
     const dataRGBA = new Uint8Array(4 * width * height);
     let offset = 0;
@@ -236,9 +141,54 @@ export class HDRDecoder {
     }
     return dataRGBA;
   }
+
+  private static _generateFloat2HalfTables(): { baseTable: Uint32Array; shiftTable: Uint32Array } {
+    const baseTable = new Uint32Array(512);
+    const shiftTable = new Uint32Array(512);
+    for (let i = 0; i < 256; ++i) {
+      const e = i - 127;
+      if (e < -27) {
+        baseTable[i] = 0x0000;
+        baseTable[i | 0x100] = 0x8000;
+        shiftTable[i] = 24;
+        shiftTable[i | 0x100] = 24;
+      } else if (e < -14) {
+        baseTable[i] = 0x0400 >> (-e - 14);
+        baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;
+        shiftTable[i] = -e - 1;
+        shiftTable[i | 0x100] = -e - 1;
+      } else if (e <= 15) {
+        baseTable[i] = (e + 15) << 10;
+        baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;
+        shiftTable[i] = 13;
+        shiftTable[i | 0x100] = 13;
+      } else if (e < 128) {
+        baseTable[i] = 0x7c00;
+        baseTable[i | 0x100] = 0xfc00;
+        shiftTable[i] = 24;
+        shiftTable[i | 0x100] = 24;
+      } else {
+        baseTable[i] = 0x7c00;
+        baseTable[i | 0x100] = 0xfc00;
+        shiftTable[i] = 13;
+        shiftTable[i | 0x100] = 13;
+      }
+    }
+    return { baseTable, shiftTable };
+  }
+
+  private static _readStringLine(uint8array: Uint8Array, startIndex: number): string {
+    let line = "";
+    for (let i = startIndex, n = uint8array.length; i < n; i++) {
+      const character = String.fromCharCode(uint8array[i]);
+      if (character === "\n") break;
+      line += character;
+    }
+    return line;
+  }
 }
 
-interface IHDRHeader {
+export interface IHDRHeader {
   width: number;
   height: number;
   dataPosition: number;
diff --git a/packages/loader/src/MaterialLoader.ts b/packages/loader/src/MaterialLoader.ts
index a710a0f579..89d3f835bb 100644
--- a/packages/loader/src/MaterialLoader.ts
+++ b/packages/loader/src/MaterialLoader.ts
@@ -11,15 +11,15 @@ import {
   resourceLoader
 } from "@galacean/engine-core";
 import { Color, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import type { RefItem } from "./schema/CommonSchema";
 import {
   MaterialLoaderType,
-  type IAssetRef,
   type IColor,
   type IMaterialSchema,
   type IVector2,
   type IVector3,
   type IVector4
-} from "./resource-deserialize";
+} from "./schema";
 
 @resourceLoader(AssetType.Material, ["mat"])
 class MaterialLoader extends Loader<Material> {
@@ -41,7 +41,7 @@ class MaterialLoader extends Loader<Material> {
             resolve(
               resourceManager
                 // @ts-ignore
-                .getResourceByRef<Shader>(<IAssetRef>shaderRef)
+                .getResourceByRef<Shader>(<RefItem>shaderRef)
                 .then((shader) => this._getMaterialByShader(materialSchema, shader, engine))
             );
           }
@@ -89,7 +89,7 @@ class MaterialLoader extends Loader<Material> {
         case MaterialLoaderType.Texture:
           texturePromises.push(
             // @ts-ignore
-            engine.resourceManager.getResourceByRef<Texture2D>(<IAssetRef>value).then((texture) => {
+            engine.resourceManager.getResourceByRef<Texture2D>(<RefItem>value).then((texture) => {
               materialShaderData.setTexture(key, texture);
             })
           );
diff --git a/packages/loader/src/PrefabLoader.ts b/packages/loader/src/PrefabLoader.ts
index b3d63df5ba..26255dfbcb 100644
--- a/packages/loader/src/PrefabLoader.ts
+++ b/packages/loader/src/PrefabLoader.ts
@@ -1,7 +1,7 @@
 import { AssetPromise, AssetType, Loader, LoadItem, resourceLoader, ResourceManager } from "@galacean/engine-core";
 import { PrefabParser } from "./prefab/PrefabParser";
 import { PrefabResource } from "./prefab/PrefabResource";
-import { IHierarchyFile } from "./resource-deserialize";
+import type { PrefabFile } from "./schema/PrefabSchema";
 
 @resourceLoader(AssetType.Prefab, ["prefab"])
 export class PrefabLoader extends Loader<PrefabResource> {
@@ -11,7 +11,7 @@ export class PrefabLoader extends Loader<PrefabResource> {
     return new AssetPromise((resolve, reject) => {
       resourceManager
         // @ts-ignore
-        ._request<IHierarchyFile>(item.url, {
+        ._request<PrefabFile>(item.url, {
           ...item,
           type: "json"
         })
diff --git a/packages/loader/src/SceneLoader.ts b/packages/loader/src/SceneLoader.ts
index b16fb2cc92..7c94a82109 100644
--- a/packages/loader/src/SceneLoader.ts
+++ b/packages/loader/src/SceneLoader.ts
@@ -11,155 +11,179 @@ import {
   ResourceManager,
   Scene
 } from "@galacean/engine-core";
-import { IScene, ParserContext, ParserType, SceneParser, SpecularMode } from "./resource-deserialize";
+import { resolveRefItem } from "./schema/refs";
+import type { RefItem } from "./schema/CommonSchema";
+import { SpecularMode, type SceneFile } from "./schema/SceneSchema";
+import { ParserContext, ParserType, SceneParser } from "./resource-deserialize";
 
-@resourceLoader(AssetType.Scene, ["scene"], true)
-class SceneLoader extends Loader<Scene> {
-  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Scene> {
-    const { engine } = resourceManager;
-    return new AssetPromise((resolve, reject, setTaskCompleteProgress) => {
-      resourceManager
-        // @ts-ignore
-        ._request<IScene>(item.url, { ...item, type: "json" })
-        .then((data: IScene) => {
-          const scene = new Scene(engine, data.name ?? "");
-          const context = new ParserContext<IScene, Scene>(engine, ParserType.Scene, scene);
-          const parser = new SceneParser(data, context, scene);
-          parser._collectDependentAssets(data);
-          context._setTaskCompleteProgress = setTaskCompleteProgress;
-          parser.start();
-          return parser.promise.then(() => {
-            const promises = [];
-            // parse ambient light
-            const ambient = data.scene.ambient;
-            if (ambient) {
-              const useCustomAmbient = ambient.specularMode === SpecularMode.Custom;
-              const useSH = ambient.diffuseMode === DiffuseMode.SphericalHarmonics;
+function loadRef<T>(refs: RefItem[], index: number, resourceManager: ResourceManager, label: string): Promise<T> {
+  const ref = resolveRefItem(refs, index, "SceneLoader", label);
+  // @ts-ignore
+  return resourceManager.getResourceByRef<T>(ref);
+}
 
-              scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
-              scene.ambientLight.specularIntensity = ambient.specularIntensity;
-              scene.ambientLight.diffuseMode = ambient.diffuseMode;
-              scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
+/**
+ * Apply scene-level data (ambient, background, shadow, fog, AO) to a Scene.
+ * @internal
+ */
+export function applySceneData(
+  scene: Scene,
+  sceneData: SceneFile["scene"],
+  resourceManager: ResourceManager,
+  refs: RefItem[]
+): Promise<void> {
+  const promises: Promise<unknown>[] = [];
 
-              if (useCustomAmbient && ambient.customAmbientLight) {
-                promises.push(
-                  // @ts-ignore
-                  resourceManager.getResourceByRef<any>(ambient.customAmbientLight).then((ambientLight) => {
-                    scene.ambientLight.specularTexture = ambientLight?.specularTexture;
-                  })
-                );
-              }
+  try {
+    // parse ambient light
+    const ambient = sceneData.ambient;
+    if (ambient) {
+      const useCustomAmbient = ambient.specularMode === SpecularMode.Custom;
+      const useSH = ambient.diffuseMode === DiffuseMode.SphericalHarmonics;
 
-              if (ambient.ambientLight && (!useCustomAmbient || useSH)) {
-                promises.push(
-                  // @ts-ignore
-                  resourceManager.getResourceByRef<any>(ambient.ambientLight).then((ambientLight) => {
-                    if (!useCustomAmbient) {
-                      scene.ambientLight.specularTexture = ambientLight?.specularTexture;
-                    }
+      scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
+      scene.ambientLight.specularIntensity = ambient.specularIntensity;
+      scene.ambientLight.diffuseMode = ambient.diffuseMode;
+      const solidColor = ambient.diffuseSolidColor;
+      if (solidColor) {
+        scene.ambientLight.diffuseSolidColor.set(solidColor[0], solidColor[1], solidColor[2], solidColor[3]);
+      }
 
-                    if (useSH) {
-                      scene.ambientLight.diffuseSphericalHarmonics = ambientLight?.diffuseSphericalHarmonics;
-                    }
-                  })
-                );
-              }
+      if (useCustomAmbient && ambient.customAmbientLight != null) {
+        promises.push(
+          loadRef<any>(refs, ambient.customAmbientLight, resourceManager, "scene.ambient.customAmbientLight").then(
+            (ambientLight) => {
+              scene.ambientLight.specularTexture = ambientLight?.specularTexture;
             }
+          )
+        );
+      }
 
-            // parse background
-            const background = data.scene.background;
-            scene.background.mode = background.mode;
+      if (ambient.ambientLight != null && (!useCustomAmbient || useSH)) {
+        promises.push(
+          loadRef<any>(refs, ambient.ambientLight, resourceManager, "scene.ambient.ambientLight").then(
+            (ambientLight) => {
+              if (!useCustomAmbient) {
+                scene.ambientLight.specularTexture = ambientLight?.specularTexture;
+              }
 
-            switch (scene.background.mode) {
-              case BackgroundMode.SolidColor:
-                scene.background.solidColor.copyFrom(background.color);
-                break;
-              case BackgroundMode.Sky:
-                if (background.skyMesh && background.skyMaterial) {
-                  // @ts-ignore
-                  const skyMeshPromise = resourceManager.getResourceByRef<Mesh>(background.skyMesh).then((mesh) => {
-                    scene.background.sky.mesh = mesh;
-                  });
-                  // @ts-ignore
-                  // prettier-ignore
-                  const skyMaterialPromise = resourceManager.getResourceByRef<Material>(background.skyMaterial).then((material) => {
-                    scene.background.sky.material = material;
-                  });
-                  promises.push(skyMeshPromise, skyMaterialPromise);
-                } else {
-                  Logger.warn("Sky background mode requires skyMesh and skyMaterial");
-                }
-                break;
-              case BackgroundMode.Texture:
-                if (background.texture) {
-                  // @ts-ignore
-                  // prettier-ignore
-                  const backgroundPromise = resourceManager.getResourceByRef<any>(background.texture).then((texture) => {
-                    scene.background.texture = texture;
-                  });
-                  promises.push(backgroundPromise);
-                  scene.background.textureFillMode = background.textureFillMode ?? scene.background.textureFillMode;
-                }
-                break;
+              if (useSH) {
+                scene.ambientLight.diffuseSphericalHarmonics = ambientLight?.diffuseSphericalHarmonics;
+              }
             }
+          )
+        );
+      }
+    }
+
+    // parse background
+    const background = sceneData.background;
+    scene.background.mode = background.mode;
 
-            // parse shadow
-            const shadow = data.scene.shadow;
-            if (shadow) {
-              if (shadow.castShadows != undefined) scene.castShadows = shadow.castShadows;
-              if (shadow.shadowResolution != undefined) scene.shadowResolution = shadow.shadowResolution;
-              if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
-              if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
-              if (shadow.enableTransparentShadow != undefined) {
-                scene.enableTransparentShadow = shadow.enableTransparentShadow;
+    switch (scene.background.mode) {
+      case BackgroundMode.SolidColor: {
+        const color = background.color;
+        scene.background.solidColor.set(color[0], color[1], color[2], color[3]);
+        break;
+      }
+      case BackgroundMode.Sky:
+        if (background.skyMesh != null && background.skyMaterial != null) {
+          promises.push(
+            loadRef<Mesh>(refs, background.skyMesh, resourceManager, "scene.background.skyMesh").then((mesh) => {
+              scene.background.sky.mesh = mesh;
+            }),
+            loadRef<any>(refs, background.skyMaterial, resourceManager, "scene.background.skyMaterial").then(
+              (material) => {
+                scene.background.sky.material = material;
               }
-              scene.shadowTwoCascadeSplits = shadow.shadowTwoCascadeSplits ?? scene.shadowTwoCascadeSplits;
-              shadow.shadowFourCascadeSplits && scene.shadowFourCascadeSplits.copyFrom(shadow.shadowFourCascadeSplits);
-              scene.shadowFadeBorder = shadow.shadowFadeBorder ?? scene.shadowFadeBorder;
-            }
+            )
+          );
+        } else {
+          Logger.warn("Sky background mode requires skyMesh and skyMaterial");
+        }
+        break;
+      case BackgroundMode.Texture:
+        if (background.texture != null) {
+          promises.push(
+            loadRef<any>(refs, background.texture, resourceManager, "scene.background.texture").then((texture) => {
+              scene.background.texture = texture;
+            })
+          );
+          scene.background.textureFillMode = background.textureFillMode ?? scene.background.textureFillMode;
+        }
+        break;
+    }
+  } catch (error) {
+    return Promise.reject(error);
+  }
 
-            // parse fog
-            const fog = data.scene.fog;
-            if (fog) {
-              if (fog.fogMode != undefined) scene.fogMode = fog.fogMode;
-              if (fog.fogStart != undefined) scene.fogStart = fog.fogStart;
-              if (fog.fogEnd != undefined) scene.fogEnd = fog.fogEnd;
-              if (fog.fogDensity != undefined) scene.fogDensity = fog.fogDensity;
-              if (fog.fogColor != undefined) scene.fogColor.copyFrom(fog.fogColor);
-            }
+  // parse shadow
+  const shadow = sceneData.shadow;
+  if (shadow) {
+    if (shadow.castShadows != undefined) scene.castShadows = shadow.castShadows;
+    if (shadow.shadowResolution != undefined) scene.shadowResolution = shadow.shadowResolution;
+    if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
+    if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
+    if (shadow.enableTransparentShadow != undefined) scene.enableTransparentShadow = shadow.enableTransparentShadow;
+    if (shadow.shadowTwoCascadeSplits != undefined) scene.shadowTwoCascadeSplits = shadow.shadowTwoCascadeSplits;
+    if (shadow.shadowFourCascadeSplits) {
+      const splits = shadow.shadowFourCascadeSplits;
+      scene.shadowFourCascadeSplits.set(splits[0], splits[1], splits[2]);
+    }
+    if (shadow.shadowFadeBorder != undefined) scene.shadowFadeBorder = shadow.shadowFadeBorder;
+  }
 
-            // parse physics
-            const physics = data.scene.physics;
-            // PhysicsScene has a native backing only when the engine was created with a physics backend.
-            // Keep scene files loadable for render-only engines by ignoring serialized physics settings there.
-            if (physics && (engine as any)._physicsInitialized) {
-              if (physics.gravity != undefined) scene.physics.gravity.copyFrom(physics.gravity);
-              if (physics.fixedTimeStep != undefined) scene.physics.fixedTimeStep = physics.fixedTimeStep;
-            }
+  // parse fog
+  const fog = sceneData.fog;
+  if (fog) {
+    if (fog.fogMode != undefined) scene.fogMode = fog.fogMode;
+    if (fog.fogStart != undefined) scene.fogStart = fog.fogStart;
+    if (fog.fogEnd != undefined) scene.fogEnd = fog.fogEnd;
+    if (fog.fogDensity != undefined) scene.fogDensity = fog.fogDensity;
+    if (fog.fogColor) scene.fogColor.set(fog.fogColor[0], fog.fogColor[1], fog.fogColor[2], fog.fogColor[3]);
+  }
 
-            // Post Process
-            const postProcessData = data.scene.postProcess;
-            if (postProcessData) {
-              Logger.warn(
-                "Post Process is not supported in scene yet, please add PostProcess component in entity instead."
-              );
-            }
+  // Post Process
+  if (sceneData.postProcess) {
+    Logger.warn("Post Process is not supported in scene yet, please add PostProcess component in entity instead.");
+  }
 
-            // Ambient Occlusion
-            const ambientOcclusion = data.scene.ambientOcclusion;
-            if (ambientOcclusion) {
-              const sceneAmbientOcclusion = scene.ambientOcclusion;
-              sceneAmbientOcclusion.enabled = ambientOcclusion.enabledAmbientOcclusion;
-              sceneAmbientOcclusion.intensity = ambientOcclusion.intensity;
-              sceneAmbientOcclusion.radius = ambientOcclusion.radius;
-              sceneAmbientOcclusion.bias = ambientOcclusion.bias;
-              sceneAmbientOcclusion.power = ambientOcclusion.power;
-              sceneAmbientOcclusion.quality = ambientOcclusion.quality;
-              sceneAmbientOcclusion.bilateralThreshold = ambientOcclusion.bilateralThreshold;
-              sceneAmbientOcclusion.minHorizonAngle = ambientOcclusion.minHorizonAngle;
-            }
+  // Ambient Occlusion
+  const ambientOcclusion = sceneData.ambientOcclusion;
+  if (ambientOcclusion) {
+    const sceneAO = scene.ambientOcclusion;
+    if (ambientOcclusion.enabledAmbientOcclusion != undefined)
+      sceneAO.enabled = ambientOcclusion.enabledAmbientOcclusion;
+    if (ambientOcclusion.quality != undefined) sceneAO.quality = ambientOcclusion.quality;
+    if (ambientOcclusion.intensity != undefined) sceneAO.intensity = ambientOcclusion.intensity;
+    if (ambientOcclusion.radius != undefined) sceneAO.radius = ambientOcclusion.radius;
+    if (ambientOcclusion.bias != undefined) sceneAO.bias = ambientOcclusion.bias;
+    if (ambientOcclusion.power != undefined) sceneAO.power = ambientOcclusion.power;
+    if (ambientOcclusion.bilateralThreshold != undefined)
+      sceneAO.bilateralThreshold = ambientOcclusion.bilateralThreshold;
+    if (ambientOcclusion.minHorizonAngle != undefined) sceneAO.minHorizonAngle = ambientOcclusion.minHorizonAngle;
+  }
+
+  return Promise.all(promises).then(() => {});
+}
 
-            return Promise.all(promises).then(() => {
+@resourceLoader(AssetType.Scene, ["scene"], true)
+class SceneLoader extends Loader<Scene> {
+  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Scene> {
+    const { engine } = resourceManager;
+    return new AssetPromise((resolve, reject, setTaskCompleteProgress) => {
+      resourceManager
+        // @ts-ignore
+        ._request<SceneFile>(item.url, { ...item, type: "json" })
+        .then((data: SceneFile) => {
+          const scene = new Scene(engine, data.scene.name ?? "");
+          const context = new ParserContext(engine, ParserType.Scene, scene);
+          const parser = new SceneParser(data, context, scene);
+          parser._collectDependentAssets(data);
+          context._setTaskCompleteProgress = setTaskCompleteProgress;
+          parser.start();
+          return parser.promise.then(() => {
+            return applySceneData(scene, data.scene, resourceManager, data.refs).then(() => {
               resolve(scene);
             });
           });
diff --git a/packages/loader/src/ShaderChunkLoader.ts b/packages/loader/src/ShaderChunkLoader.ts
deleted file mode 100644
index ede33d9952..0000000000
--- a/packages/loader/src/ShaderChunkLoader.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import {
-  AssetPromise,
-  LoadItem,
-  Loader,
-  ResourceManager,
-  ShaderFactory,
-  resourceLoader,
-  // @ts-ignore
-  ShaderLib,
-  Utils
-} from "@galacean/engine-core";
-
-@resourceLoader("ShaderChunk", ["glsl"])
-export class ShaderChunkLoader extends Loader<void[]> {
-  private static _shaderIncludeRegex = /#include\s+"([./][^\\"]+)"/gm;
-
-  /**
-   * @internal
-   */
-  static _loadChunksInCode(code: string, basePath: string, resourceManager: ResourceManager): Promise<void[]> {
-    const shaderChunkPaths = new Array<string>();
-    const matches = code.matchAll(ShaderChunkLoader._shaderIncludeRegex);
-    for (const match of matches) {
-      const chunkPath = Utils.resolveAbsoluteUrl(basePath, match[1]);
-      if (!ShaderLib[chunkPath.substring(1)]) {
-        shaderChunkPaths.push(chunkPath);
-      }
-    }
-
-    return Promise.all(
-      shaderChunkPaths.map((chunkPath) => {
-        // @ts-ignore
-        return resourceManager.load<void>({
-          type: "ShaderChunk",
-          url: chunkPath
-        });
-      })
-    );
-  }
-
-  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<void[]> {
-    const { url } = item;
-
-    // @ts-ignore
-    return resourceManager._request<string>(url, { ...item, type: "text" }).then((code) => {
-      ShaderFactory.registerInclude(url.substring(1), code);
-
-      return ShaderChunkLoader._loadChunksInCode(code, url, resourceManager);
-    });
-  }
-}
diff --git a/packages/loader/src/ShaderLoader.ts b/packages/loader/src/ShaderLoader.ts
index d7e714af50..4c5fd2e027 100644
--- a/packages/loader/src/ShaderLoader.ts
+++ b/packages/loader/src/ShaderLoader.ts
@@ -7,31 +7,23 @@ import {
   Shader,
   resourceLoader
 } from "@galacean/engine-core";
-import { ShaderChunkLoader } from "./ShaderChunkLoader";
 
-@resourceLoader(AssetType.Shader, ["shader"])
+@resourceLoader(AssetType.Shader, ["shader", "shaderc"])
 class ShaderLoader extends Loader<Shader> {
-  private static _builtinRegex = /^\s*\/\/\s*@builtin\s+(\w+)/;
-
   load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Shader> {
-    const { url } = item;
+    const url = item.url!;
+
+    if (url.endsWith(".shaderc")) {
+      // @ts-ignore
+      return resourceManager._request(url, { ...item, type: "json" }).then((data) => {
+        // @ts-ignore - _createFromPrecompiled is @internal
+        return Shader._createFromPrecompiled(data);
+      });
+    }
 
     // @ts-ignore
     return resourceManager._request<string>(url, { ...item, type: "text" }).then((code: string) => {
-      const builtinShader = this._getBuiltinShader(code);
-      if (builtinShader) {
-        return Shader.find(builtinShader);
-      }
-
-      return ShaderChunkLoader._loadChunksInCode(code, url, resourceManager).then(() => {
-        const shader = Shader.create(code, undefined, url);
-        return shader;
-      });
+      return Shader.create(code, undefined, url);
     });
   }
-
-  private _getBuiltinShader(code: string) {
-    const match = code.match(ShaderLoader._builtinRegex);
-    if (match && match[1]) return match[1];
-  }
 }
diff --git a/packages/loader/src/SpriteAtlasLoader.ts b/packages/loader/src/SpriteAtlasLoader.ts
index c5a1d6a550..0d0fe7550f 100644
--- a/packages/loader/src/SpriteAtlasLoader.ts
+++ b/packages/loader/src/SpriteAtlasLoader.ts
@@ -51,7 +51,7 @@ class SpriteAtlasLoader extends Loader<SpriteAtlas> {
                 resourceManager
                   .load<Texture2D>({
                     url: Utils.resolveAbsoluteUrl(item.url, atlasItem.img),
-                    type: atlasItem.type ?? AssetType.Texture2D,
+                    type: atlasItem.type ?? AssetType.Texture,
                     params: { format, mipmap }
                   })
                   .then((texture: Texture2D) => {
@@ -102,7 +102,7 @@ class SpriteAtlasLoader extends Loader<SpriteAtlas> {
         const { x: offsetLeft, y: offsetTop, z: offsetRight, w: offsetBottom } = atlasRegionOffset;
         sprite.atlasRegionOffset.set(offsetLeft * invW, offsetTop * invH, offsetRight * invW, offsetBottom * invH);
       }
-      sprite.atlasRotated = config.atlasRotated ?? false;
+      config.atlasRotated && (sprite.atlasRotated = true);
     }
     width === undefined || (sprite.width = width);
     height === undefined || (sprite.height = height);
diff --git a/packages/loader/src/SpriteLoader.ts b/packages/loader/src/SpriteLoader.ts
index 582d1d575b..489bc5d8aa 100644
--- a/packages/loader/src/SpriteLoader.ts
+++ b/packages/loader/src/SpriteLoader.ts
@@ -32,7 +32,7 @@ class SpriteLoader extends Loader<Sprite> {
     return (
       resourceManager
         // @ts-ignore
-        .getResourceByRef(data.belongToAtlas)
+        .getResourceByRef<SpriteAtlas>(data.belongToAtlas)
         .then((atlas: SpriteAtlas) => {
           return atlas.getSprite(data.fullPath) || this._loadFromTexture(resourceManager, data);
         })
@@ -44,7 +44,7 @@ class SpriteLoader extends Loader<Sprite> {
       return (
         resourceManager
           // @ts-ignore
-          .getResourceByRef(data.texture)
+          .getResourceByRef<Texture2D>(data.texture)
           .then((texture: Texture2D) => {
             const sprite = new Sprite(resourceManager.engine, texture, data.region, data.pivot, data.border);
             const { width, height } = data;
diff --git a/packages/loader/src/Texture2DLoader.ts b/packages/loader/src/Texture2DLoader.ts
deleted file mode 100644
index 127b37eb96..0000000000
--- a/packages/loader/src/Texture2DLoader.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import {
-  AssetPromise,
-  AssetType,
-  ContentRestorer,
-  LoadItem,
-  Loader,
-  RequestConfig,
-  ResourceManager,
-  Texture2D,
-  TextureFilterMode,
-  TextureFormat,
-  TextureUtils,
-  TextureWrapMode,
-  resourceLoader
-} from "@galacean/engine-core";
-import { decode } from "./resource-deserialize";
-import { FileHeader } from "./resource-deserialize/utils/FileHeader";
-
-function loadImageFromBuffer(buffer: ArrayBuffer): AssetPromise<HTMLImageElement> {
-  return new AssetPromise((resolve, reject) => {
-    const blob = new Blob([buffer]);
-    const img = new Image();
-    img.onload = () => {
-      URL.revokeObjectURL(img.src);
-      resolve(img);
-    };
-    img.onerror = reject;
-    img.src = URL.createObjectURL(blob);
-  });
-}
-
-@resourceLoader(AssetType.Texture2D, ["png", "jpg", "webp", "jpeg", "tex"])
-class Texture2DLoader extends Loader<Texture2D> {
-  override load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture2D> {
-    const url = item.url;
-    const requestConfig = <RequestConfig>{ ...item, type: "arraybuffer" };
-    return new AssetPromise((resolve, reject, setTaskCompleteProgress, setTaskDetailProgress) => {
-      resourceManager
-        // @ts-ignore
-        ._request<ArrayBuffer>(url, requestConfig)
-        .onProgress(setTaskCompleteProgress, setTaskDetailProgress)
-        .then((buffer) => {
-          if (FileHeader.checkMagic(buffer)) {
-            decode<Texture2D>(buffer, resourceManager.engine).then((texture) => {
-              resourceManager.addContentRestorer(new Texture2DContentRestorer(texture, url, requestConfig));
-              resolve(texture);
-            }, reject);
-          } else {
-            loadImageFromBuffer(buffer).then((img) => {
-              const texture = this._createTexture(img, item, resourceManager);
-              resourceManager.addContentRestorer(new Texture2DContentRestorer(texture, url, requestConfig));
-              resolve(texture);
-            }, reject);
-          }
-        })
-        .catch(reject);
-    });
-  }
-
-  private _createTexture(img: HTMLImageElement, item: LoadItem, resourceManager: ResourceManager): Texture2D {
-    const {
-      format = TextureFormat.R8G8B8A8,
-      anisoLevel,
-      wrapModeU,
-      wrapModeV,
-      filterMode,
-      isSRGBColorSpace = true,
-      mipmap = true
-    } = (item.params as Partial<Texture2DParams>) ?? {};
-    const { width, height } = img;
-    const engine = resourceManager.engine;
-
-    const generateMipmap = TextureUtils.supportGenerateMipmapsWithCorrection(
-      engine,
-      width,
-      height,
-      format,
-      mipmap,
-      isSRGBColorSpace
-    );
-
-    const texture = new Texture2D(engine, width, height, format, generateMipmap, isSRGBColorSpace);
-    texture.anisoLevel = anisoLevel ?? texture.anisoLevel;
-    texture.filterMode = filterMode ?? texture.filterMode;
-    texture.wrapModeU = wrapModeU ?? texture.wrapModeU;
-    texture.wrapModeV = wrapModeV ?? texture.wrapModeV;
-    texture.setImageSource(img);
-    generateMipmap && texture.generateMipmaps();
-
-    const url = item.url;
-    if (url.indexOf("data:") !== 0) {
-      texture.name = url.substring(url.lastIndexOf("/") + 1);
-    }
-
-    return texture;
-  }
-}
-
-class Texture2DContentRestorer extends ContentRestorer<Texture2D> {
-  constructor(
-    resource: Texture2D,
-    public url: string,
-    public requestConfig: RequestConfig
-  ) {
-    super(resource);
-  }
-
-  override restoreContent(): AssetPromise<Texture2D> {
-    const texture = this.resource;
-    const engine = texture.engine;
-    return (
-      engine.resourceManager
-        // @ts-ignore
-        ._request<ArrayBuffer>(this.url, this.requestConfig)
-        .then((buffer) => {
-          if (FileHeader.checkMagic(buffer)) {
-            return decode<Texture2D>(buffer, engine, texture);
-          } else {
-            return loadImageFromBuffer(buffer).then((img) => {
-              texture.setImageSource(img);
-              texture.generateMipmaps();
-              return texture;
-            });
-          }
-        })
-    );
-  }
-}
-
-/**
- * Texture2D loader params interface.
- */
-export interface Texture2DParams {
-  /** Texture format. default  `TextureFormat.R8G8B8A8` */
-  format: TextureFormat;
-  /** Whether to use multi-level texture, default is true. */
-  mipmap: boolean;
-  /** Wrapping mode for texture coordinate S. */
-  wrapModeU: TextureWrapMode;
-  /** Wrapping mode for texture coordinate T. */
-  wrapModeV: TextureWrapMode;
-  /** Filter mode for texture. */
-  filterMode: TextureFilterMode;
-  /** Anisotropic level for texture. */
-  anisoLevel: number;
-  /** Whether the texture data is in sRGB color space, otherwise is linear color space. @defaultValue `true` */
-  isSRGBColorSpace: boolean;
-}
diff --git a/packages/loader/src/TextureCubeLoader.ts b/packages/loader/src/TextureCubeLoader.ts
deleted file mode 100644
index aee01285f1..0000000000
--- a/packages/loader/src/TextureCubeLoader.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import {
-  AssetPromise,
-  AssetType,
-  ContentRestorer,
-  LoadItem,
-  Loader,
-  RequestConfig,
-  ResourceManager,
-  SystemInfo,
-  TextureCube,
-  TextureCubeFace,
-  TextureFormat,
-  resourceLoader
-} from "@galacean/engine-core";
-import { HDRDecoder } from "./HDRDecoder";
-
-@resourceLoader(AssetType.TextureCube, ["texCube", "hdr"])
-class TextureCubeLoader extends Loader<TextureCube> {
-  override load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<TextureCube> {
-    return new AssetPromise((resolve, reject) => {
-      const engine = resourceManager.engine;
-      const url = item.url;
-      const requestConfig = { ...item, type: "arraybuffer" } as RequestConfig;
-      resourceManager
-        // @ts-ignore
-        ._request<ArrayBuffer>(url, requestConfig)
-        .then((buffer) => {
-          if (!SystemInfo.supportsTextureFormat(engine, TextureFormat.R16G16B16A16)) {
-            reject(new Error("TextureCubeLoader: HDR texture requires half float support."));
-            return;
-          }
-          const { mipmap = true, anisoLevel, wrapModeU, wrapModeV, filterMode } = item.params ?? {};
-          const bufferArray = new Uint8Array(buffer);
-          const header = HDRDecoder.parseHeader(bufferArray);
-          const texture = new TextureCube(engine, header.height >> 1, TextureFormat.R16G16B16A16, mipmap, false);
-          HDRDecoder.decodeFaces(bufferArray, header, (faceIndex, data) => {
-            texture.setPixelBuffer(TextureCubeFace.PositiveX + faceIndex, data, 0);
-          });
-          texture.generateMipmaps();
-          texture.anisoLevel = anisoLevel ?? texture.anisoLevel;
-          texture.filterMode = filterMode ?? texture.filterMode;
-          texture.wrapModeU = wrapModeU ?? texture.wrapModeU;
-          texture.wrapModeV = wrapModeV ?? texture.wrapModeV;
-          resourceManager.addContentRestorer(new HDRContentRestorer(texture, url, requestConfig));
-          resolve(texture);
-        })
-        .catch(reject);
-    });
-  }
-}
-
-class HDRContentRestorer extends ContentRestorer<TextureCube> {
-  constructor(
-    resource: TextureCube,
-    public url: string,
-    public requestConfig: RequestConfig
-  ) {
-    super(resource);
-  }
-
-  override restoreContent(): AssetPromise<TextureCube> {
-    return new AssetPromise((resolve, reject) => {
-      const resource = this.resource;
-      resource.engine.resourceManager
-        // @ts-ignore
-        ._request<ArrayBuffer>(this.url, this.requestConfig)
-        .then((buffer) => {
-          const bufferArray = new Uint8Array(buffer);
-          HDRDecoder.decodeFaces(bufferArray, HDRDecoder.parseHeader(bufferArray), (faceIndex, data) => {
-            resource.setPixelBuffer(TextureCubeFace.PositiveX + faceIndex, data, 0);
-          });
-          resource.generateMipmaps();
-          resolve(resource);
-        })
-        .catch(reject);
-    });
-  }
-}
diff --git a/packages/loader/src/TextureLoader.ts b/packages/loader/src/TextureLoader.ts
new file mode 100644
index 0000000000..ff669d6c59
--- /dev/null
+++ b/packages/loader/src/TextureLoader.ts
@@ -0,0 +1,192 @@
+import {
+  AssetPromise,
+  AssetType,
+  ContentRestorer,
+  LoadItem,
+  Loader,
+  RequestConfig,
+  ResourceManager,
+  SystemInfo,
+  Texture,
+  Texture2D,
+  TextureFilterMode,
+  TextureFormat,
+  TextureUtils,
+  TextureWrapMode,
+  resourceLoader
+} from "@galacean/engine-core";
+import { decode } from "./resource-deserialize";
+import { FileHeader } from "./resource-deserialize/utils/FileHeader";
+import { HDRDecoder } from "./HDRDecoder";
+
+@resourceLoader(AssetType.Texture, ["tex", "png", "jpg", "webp", "jpeg", "hdr"])
+class TextureLoader extends Loader<Texture> {
+  override load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture> {
+    const url = item.url;
+    const requestConfig = <RequestConfig>{ ...item, type: "arraybuffer" };
+    return new AssetPromise((resolve, reject, setTaskCompleteProgress, setTaskDetailProgress) => {
+      resourceManager
+        // @ts-ignore
+        ._request<ArrayBuffer>(url, requestConfig)
+        .onProgress(setTaskCompleteProgress, setTaskDetailProgress)
+        .then((buffer) => {
+          this._decode(buffer, item, resourceManager).then((texture) => {
+            resourceManager.addContentRestorer(new TextureContentRestorer(texture, url, requestConfig));
+            resolve(texture);
+          }, reject);
+        })
+        .catch(reject);
+    });
+  }
+
+  private _decode(buffer: ArrayBuffer, item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture> {
+    if (FileHeader.checkMagic(buffer)) {
+      return decode<Texture>(buffer, resourceManager.engine);
+    }
+
+    const bufferView = new Uint8Array(buffer);
+    const isHDR = bufferView[0] === 0x23 && bufferView[1] === 0x3f;
+
+    if (isHDR) {
+      return this._decodeHDR(bufferView, item, resourceManager);
+    }
+    return this._decodeImage(buffer, item, resourceManager);
+  }
+
+  private _decodeHDR(buffer: Uint8Array, item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture2D> {
+    return new AssetPromise((resolve, reject) => {
+      const engine = resourceManager.engine;
+      if (!SystemInfo.supportsTextureFormat(engine, TextureFormat.R16G16B16A16)) {
+        reject(new Error("TextureLoader: HDR texture requires half float support."));
+        return;
+      }
+      const { width, height, pixels } = HDRDecoder.decode(buffer);
+      const { mipmap = true } = (item.params as Partial<TextureParams>) ?? {};
+
+      const texture = new Texture2D(engine, width, height, TextureFormat.R16G16B16A16, mipmap, false);
+      texture.setPixelBuffer(pixels);
+      mipmap && texture.generateMipmaps();
+      this._applyParams(texture, item);
+      resolve(texture);
+    });
+  }
+
+  private _decodeImage(buffer: ArrayBuffer, item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture2D> {
+    return new AssetPromise((resolve, reject) => {
+      const blob = new Blob([buffer]);
+      const img = new Image();
+      img.onload = () => {
+        URL.revokeObjectURL(img.src);
+        const {
+          format = TextureFormat.R8G8B8A8,
+          isSRGBColorSpace = true,
+          mipmap = true
+        } = (item.params as Partial<TextureParams>) ?? {};
+
+        const engine = resourceManager.engine;
+        const { width, height } = img;
+        const generateMipmap = TextureUtils.supportGenerateMipmapsWithCorrection(
+          engine,
+          width,
+          height,
+          format,
+          mipmap,
+          isSRGBColorSpace
+        );
+
+        const texture = new Texture2D(engine, width, height, format, generateMipmap, isSRGBColorSpace);
+        texture.setImageSource(img);
+        generateMipmap && texture.generateMipmaps();
+        this._applyParams(texture, item);
+        resolve(texture);
+      };
+      img.onerror = (e) => {
+        URL.revokeObjectURL(img.src);
+        reject(e);
+      };
+      img.src = URL.createObjectURL(blob);
+    });
+  }
+
+  private _applyParams(texture: Texture2D, item: LoadItem): void {
+    const { anisoLevel, wrapModeU, wrapModeV, filterMode } = (item.params as Partial<TextureParams>) ?? {};
+    texture.anisoLevel = anisoLevel ?? texture.anisoLevel;
+    texture.filterMode = filterMode ?? texture.filterMode;
+    texture.wrapModeU = wrapModeU ?? texture.wrapModeU;
+    texture.wrapModeV = wrapModeV ?? texture.wrapModeV;
+
+    const url = item.url;
+    if (url.indexOf("data:") !== 0) {
+      texture.name = url.substring(url.lastIndexOf("/") + 1);
+    }
+  }
+}
+
+class TextureContentRestorer extends ContentRestorer<Texture> {
+  constructor(
+    resource: Texture,
+    public url: string,
+    public requestConfig: RequestConfig
+  ) {
+    super(resource);
+  }
+
+  override restoreContent(): AssetPromise<Texture> {
+    return (
+      this.resource.engine.resourceManager
+        // @ts-ignore
+        ._request<ArrayBuffer>(this.url, this.requestConfig)
+        .then((buffer) => {
+          if (FileHeader.checkMagic(buffer)) {
+            return decode<Texture>(buffer, this.resource.engine, this.resource);
+          }
+
+          const bufferView = new Uint8Array(buffer);
+          const texture = this.resource as Texture2D;
+
+          if (bufferView[0] === 0x23 && bufferView[1] === 0x3f) {
+            const { pixels } = HDRDecoder.decode(bufferView);
+            texture.setPixelBuffer(pixels);
+            texture.mipmapCount > 1 && texture.generateMipmaps();
+            return texture;
+          }
+
+          return new AssetPromise<Texture>((resolve, reject) => {
+            const blob = new Blob([buffer]);
+            const img = new Image();
+            img.onload = () => {
+              URL.revokeObjectURL(img.src);
+              texture.setImageSource(img);
+              texture.mipmapCount > 1 && texture.generateMipmaps();
+              resolve(texture);
+            };
+            img.onerror = (e) => {
+              URL.revokeObjectURL(img.src);
+              reject(e);
+            };
+            img.src = URL.createObjectURL(blob);
+          });
+        })
+    );
+  }
+}
+
+/**
+ * Texture loader params interface.
+ */
+export interface TextureParams {
+  /** Texture format. default `TextureFormat.R8G8B8A8` */
+  format: TextureFormat;
+  /** Whether to use multi-level texture, default is true. */
+  mipmap: boolean;
+  /** Wrapping mode for texture coordinate S. */
+  wrapModeU: TextureWrapMode;
+  /** Wrapping mode for texture coordinate T. */
+  wrapModeV: TextureWrapMode;
+  /** Filter mode for texture. */
+  filterMode: TextureFilterMode;
+  /** Anisotropic level for texture. */
+  anisoLevel: number;
+  /** Whether the texture data is in sRGB color space. @defaultValue `true` */
+  isSRGBColorSpace: boolean;
+}
diff --git a/packages/loader/src/index.ts b/packages/loader/src/index.ts
index 31417dee5c..58381544c9 100644
--- a/packages/loader/src/index.ts
+++ b/packages/loader/src/index.ts
@@ -16,19 +16,17 @@ import "./SourceFontLoader";
 import "./SpriteAtlasLoader";
 import "./SpriteLoader";
 import "./TextLoader";
-import "./Texture2DLoader";
-import "./TextureCubeLoader";
+import "./TextureLoader";
 import "./AudioLoader";
 import "./ktx2/KTX2Loader";
 import "./ShaderLoader";
-import "./ShaderChunkLoader";
 import "./PhysicsMaterialLoader";
 import "./RenderTargetLoader";
 
 export { GLTFLoader } from "./GLTFLoader";
 export type { GLTFParams } from "./GLTFLoader";
-export * from "./SceneLoader";
-export type { Texture2DParams } from "./Texture2DLoader";
+import "./SceneLoader";
+export type { TextureParams } from "./TextureLoader";
 export { parseSingleKTX } from "./compressed-texture";
 export * from "./gltf";
 export { KTX2Loader } from "./ktx2/KTX2Loader";
diff --git a/packages/loader/src/prefab/PrefabParser.ts b/packages/loader/src/prefab/PrefabParser.ts
index 5b5bdefd57..bd38232c53 100644
--- a/packages/loader/src/prefab/PrefabParser.ts
+++ b/packages/loader/src/prefab/PrefabParser.ts
@@ -1,34 +1,38 @@
 import { Engine, Entity } from "@galacean/engine-core";
-import { IEntity, IHierarchyFile, ParserContext, ParserType } from "../resource-deserialize";
+import type { HierarchyFile } from "../schema/HierarchySchema";
+import type { PrefabFile } from "../schema/PrefabSchema";
 import { HierarchyParser } from "../resource-deserialize/resources/parser/HierarchyParser";
+import { ParserContext, ParserType } from "../resource-deserialize/resources/parser/ParserContext";
 import { PrefabResource } from "./PrefabResource";
 
-export class PrefabParser extends HierarchyParser<PrefabResource, ParserContext<IHierarchyFile, Entity>> {
-  static parse(engine: Engine, url: string, data: IHierarchyFile): Promise<PrefabResource> {
+export class PrefabParser extends HierarchyParser<PrefabResource, ParserContext> {
+  static parse(engine: Engine, url: string, data: PrefabFile): Promise<PrefabResource> {
     const prefabResource = new PrefabResource(engine, url);
-    const context = new ParserContext<IHierarchyFile, Entity>(engine, ParserType.Prefab, prefabResource);
+    const context = new ParserContext(engine, ParserType.Prefab, prefabResource);
     const parser = new PrefabParser(data, context, prefabResource);
     parser.start();
-    return parser.promise.then(() => prefabResource);
+    return parser.promise;
   }
 
   constructor(
-    data: IHierarchyFile,
-    context: ParserContext<IHierarchyFile, Entity>,
+    data: HierarchyFile,
+    context: ParserContext,
     public readonly prefabResource: PrefabResource
   ) {
     super(data, context);
   }
 
-  protected override _applyEntityData(entity: Entity, entityConfig: IEntity = {}): Entity {
-    super._applyEntityData(entity, entityConfig);
+  protected override _onEntityCreated(entity: Entity): void {
     // @ts-ignore
     entity._markAsTemplate(this.context.resource);
-    return entity;
   }
 
-  protected override _handleRootEntity(id: string): void {
-    this.prefabResource._root = this.context.entityMap.get(id);
+  protected override _getRootIndices(): number[] {
+    return [(this.data as PrefabFile).root];
+  }
+
+  protected override _handleRootEntity(index: number): void {
+    this.prefabResource._root = this.context.entityInstances[index];
   }
 
   protected override _clearAndResolve(): PrefabResource {
diff --git a/packages/loader/src/prefab/PrefabResource.ts b/packages/loader/src/prefab/PrefabResource.ts
index 2a49228793..f6cf61c45e 100644
--- a/packages/loader/src/prefab/PrefabResource.ts
+++ b/packages/loader/src/prefab/PrefabResource.ts
@@ -44,7 +44,7 @@ export class PrefabResource extends ReferResource {
 
   protected override _onDestroy(): void {
     super._onDestroy();
-    this._root.destroy();
+    this._root?.destroy();
     this._dependenceAssets.forEach((asset) => {
       if (asset instanceof ReferResource) {
         // @ts-ignore
diff --git a/packages/loader/src/resource-deserialize/index.ts b/packages/loader/src/resource-deserialize/index.ts
index b50923d1cb..e68f06a0d8 100644
--- a/packages/loader/src/resource-deserialize/index.ts
+++ b/packages/loader/src/resource-deserialize/index.ts
@@ -7,7 +7,8 @@ export * from "./resources/animationClip/AnimationClipDecoder";
 export type { IModelMesh } from "./resources/mesh/IModelMesh";
 export { MeshDecoder } from "./resources/mesh/MeshDecoder";
 export { ReflectionParser } from "./resources/parser/ReflectionParser";
-export { Texture2DDecoder } from "./resources/texture2D/TextureDecoder";
+import "./resources/texture2D/Texture2DDecoder";
+import "./resources/textureCube/TextureCubeDecoder";
 
 /**
  * Decode engine binary resource.
@@ -27,7 +28,7 @@ export function decode<T>(arrayBuffer: ArrayBuffer, engine: Engine, ...args: any
 export * from "./resources/parser/HierarchyParser";
 export * from "./resources/parser/ParserContext";
 export * from "./resources/scene/SceneParser";
-export * from "./resources/schema";
+export * from "../schema";
 
 export * from "./utils/BufferReader";
 export * from "./utils/Decorator";
diff --git a/packages/loader/src/resource-deserialize/resources/mesh/IModelMesh.d.ts b/packages/loader/src/resource-deserialize/resources/mesh/IModelMesh.d.ts
index 368bd4a75f..3b5d99a388 100644
--- a/packages/loader/src/resource-deserialize/resources/mesh/IModelMesh.d.ts
+++ b/packages/loader/src/resource-deserialize/resources/mesh/IModelMesh.d.ts
@@ -1,5 +1,5 @@
 import { MeshTopology } from "@galacean/engine-core";
-import type { IColor, IVector2, IVector3, IVector4 } from "../schema/BasicSchema";
+import type { IColor, IVector2, IVector3, IVector4 } from "../../../schema/BasicSchema";
 
 export interface IEncodedModelMesh {
   positions: {
diff --git a/packages/loader/src/resource-deserialize/resources/parser/HierarchyParser.ts b/packages/loader/src/resource-deserialize/resources/parser/HierarchyParser.ts
index b02e872acb..2216ea3b42 100644
--- a/packages/loader/src/resource-deserialize/resources/parser/HierarchyParser.ts
+++ b/packages/loader/src/resource-deserialize/resources/parser/HierarchyParser.ts
@@ -1,15 +1,24 @@
-import { Component, Engine, Entity, Loader, Scene, Transform } from "@galacean/engine-core";
+import { Component, Engine, Entity, Loader, Scene } from "@galacean/engine-core";
 import { GLTFResource } from "../../../gltf";
 import { PrefabResource } from "../../../prefab/PrefabResource";
-import type { IEntity, IHierarchyFile, IRefEntity, IStrippedEntity } from "../schema";
+import { resolveRefItem } from "../../../schema/refs";
+import {
+  type ComponentSchema,
+  type ComponentSelector,
+  type ComponentOverride,
+  type EntityPropOverride,
+  type EntityOverrideProps,
+  type EntitySchema,
+  type InstanceOverrides,
+  type PrefabInstanceEntitySchema
+} from "../../../schema/HierarchySchema";
+import type { RefItem } from "../../../schema/CommonSchema";
+import type { HierarchyFile } from "../../../schema/HierarchySchema";
 import { ParserContext, ParserType } from "./ParserContext";
 import { ReflectionParser } from "./ReflectionParser";
 
 /** @Internal */
-export abstract class HierarchyParser<T extends Scene | PrefabResource, V extends ParserContext<IHierarchyFile, T>> {
-  /**
-   * The promise of parsed object.
-   */
+export abstract class HierarchyParser<T extends Scene | PrefabResource, V extends ParserContext> {
   readonly promise: Promise<T>;
 
   protected _resolve: (item: T) => void;
@@ -17,350 +26,317 @@ export abstract class HierarchyParser<T extends Scene | PrefabResource, V extend
   protected _engine: Engine;
   protected _reflectionParser: ReflectionParser;
 
-  private _prefabContextMap = new WeakMap<Entity, ParserContext<IHierarchyFile, Entity>>();
-
-  private _prefabPromiseMap = new Map<
-    string,
-    {
-      resolve: (context: ParserContext<IHierarchyFile, Entity>) => void;
-      reject: (reason: any) => void;
-    }[]
-  >();
-
   constructor(
-    public readonly data: IHierarchyFile,
+    public readonly data: HierarchyFile,
     public readonly context: V
   ) {
+    if (data.version !== "2.0") {
+      const resourceType = context.type === ParserType.Scene ? "scene" : "prefab";
+      throw new Error(`Unsupported ${resourceType} format version "${data.version}". Expected "2.0".`);
+    }
+
     this._engine = this.context.engine;
-    this._organizeEntities = this._organizeEntities.bind(this);
-    this._parseComponents = this._parseComponents.bind(this);
-    this._parsePrefabModification = this._parsePrefabModification.bind(this);
-    this._parseAddedComponents = this._parseAddedComponents.bind(this);
-    this._parseComponentsPropsAndMethods = this._parseComponentsPropsAndMethods.bind(this);
-    this._parsePrefabRemovedEntities = this._parsePrefabRemovedEntities.bind(this);
-    this._parsePrefabRemovedComponents = this._parsePrefabRemovedComponents.bind(this);
-    this._clearAndResolve = this._clearAndResolve.bind(this);
     this.promise = new Promise<T>((resolve, reject) => {
       this._reject = reject;
       this._resolve = resolve;
     });
-    this._reflectionParser = new ReflectionParser(context);
+    this._reflectionParser = new ReflectionParser(context, data.refs);
   }
 
-  /** start parse the scene or prefab or others */
   public start() {
     this._parseEntities()
-      .then(this._organizeEntities)
-      .then(this._parseComponents)
-      .then(this._parseAddedComponents)
-      .then(this._parseComponentsPropsAndMethods)
-      .then(this._parsePrefabModification)
-      .then(this._parsePrefabRemovedEntities)
-      .then(this._parsePrefabRemovedComponents)
-      .then(this._clearAndResolve)
+      .then(() => this._organizeEntities())
+      .then(() => this._parseComponents())
+      .then(() => this._parseComponentsPropsAndCalls())
+      .then(() => this._parsePrefabOverrides())
+      .then(() => this._clearAndResolve())
       .then(this._resolve)
       .catch(this._reject);
   }
 
-  protected _applyEntityData(entity: Entity, entityConfig: IEntity = {}): Entity {
-    entity.isActive = entityConfig.isActive ?? entity.isActive;
-    entity.name = entityConfig.name ?? entity.name;
-    const transform = entity.transform;
-    const transformConfig = entityConfig.transform;
-    if (transformConfig) {
-      this._reflectionParser.parsePropsAndMethods(transform, transformConfig);
-    } else {
-      const { position, rotation, scale } = entityConfig;
-      if (position) transform.position.copyFrom(position);
-      if (rotation) transform.rotation.copyFrom(rotation);
-      if (scale) transform.scale.copyFrom(scale);
-    }
-    if (entityConfig.layer) entity.layer = entityConfig.layer;
-    return entity;
-  }
-
-  protected abstract _handleRootEntity(id: string): void;
+  /** Root entity indices for this hierarchy (scene.rootEntities or [prefab.root]). */
+  protected abstract _getRootIndices(): number[];
+  protected abstract _handleRootEntity(index: number): void;
   protected abstract _clearAndResolve(): Scene | PrefabResource;
 
-  private _parseEntities(): Promise<Entity[]> {
-    const entitiesConfig = this.data.entities;
-    const entityConfigMap = this.context.entityConfigMap;
-    const entityMap = this.context.entityMap;
+  protected _onEntityCreated(_entity: Entity): void {}
+
+  // ---------------------------------------------------------------------------
+  // Stage 1: Create entity instances
+  // ---------------------------------------------------------------------------
+
+  private _parseEntities(): Promise<unknown> {
+    const entities = this.data.entities;
+    const entityInstances = this.context.entityInstances;
     const engine = this._engine;
-    const promises = entitiesConfig.map((entityConfig) => {
-      const id = (entityConfig as IStrippedEntity).strippedId ?? entityConfig.id;
-      entityConfig.id = id;
-      entityConfigMap.set(id, entityConfig);
-      return this._getEntityByConfig(entityConfig, engine);
-    });
-    return Promise.all(promises).then((entities) => {
-      for (let i = 0, l = entities.length; i < l; i++) {
-        entityMap.set(entitiesConfig[i].id, entities[i]);
+    const promises: Promise<void>[] = [];
+
+    for (let i = 0, n = entities.length; i < n; i++) {
+      const entityConfig = entities[i];
+
+      if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) {
+        promises.push(
+          this._loadPrefabInstance(entityConfig, engine).then((entity) => {
+            entityInstances[i] = entity;
+          })
+        );
+      } else {
+        const entity = new Entity(engine, entityConfig.name);
+        HierarchyParser._applyEntityProps(entity, entityConfig);
+        this._onEntityCreated(entity);
+        entityInstances[i] = entity;
       }
-      // Build rootIds in serialization order (not async completion order)
-      const rootIds = this.context.rootIds;
-      for (let i = 0, l = entitiesConfig.length; i < l; i++) {
-        if (!entitiesConfig[i].parent && !(entitiesConfig[i] as IStrippedEntity).strippedId) {
-          rootIds.push(entitiesConfig[i].id);
-        }
+    }
+
+    return Promise.all(promises);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Stage 2: Build parent-child hierarchy
+  // ---------------------------------------------------------------------------
+
+  private _organizeEntities(): void {
+    const entities = this.data.entities;
+    const entityInstances = this.context.entityInstances;
+
+    for (let i = 0, n = entities.length; i < n; i++) {
+      const entityConfig = entities[i];
+      // Prefab instance entities manage their own children.
+      if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
+
+      const children = entityConfig.children;
+      if (!children) continue;
+
+      const parent = entityInstances[i];
+      for (let j = 0, m = children.length; j < m; j++) {
+        parent.addChild(entityInstances[children[j]]);
       }
-      return entities;
-    });
+    }
+
+    const rootIndices = this._getRootIndices();
+    for (let i = 0, n = rootIndices.length; i < n; i++) {
+      this._handleRootEntity(rootIndices[i]);
+    }
   }
 
-  private _parseComponents(): void {
-    const entitiesConfig = this.data.entities;
-    const entityMap = this.context.entityMap;
+  // ---------------------------------------------------------------------------
+  // Stage 3: Add components to entities
+  // ---------------------------------------------------------------------------
 
-    for (let i = 0, l = entitiesConfig.length; i < l; i++) {
-      const entityConfig = entitiesConfig[i];
-      if ((entityConfig as IStrippedEntity).strippedId) {
-        continue;
+  private _parseComponents(): void {
+    const entities = this.data.entities;
+    const allComponents = this.data.components;
+    const entityInstances = this.context.entityInstances;
+    const pendingComponents = this.context.pendingComponents;
+    const refs = this.data.refs;
+
+    for (let i = 0, n = entities.length; i < n; i++) {
+      const entityConfig = entities[i];
+      if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
+
+      const entity = entityInstances[i];
+      const componentIndices = entityConfig.components;
+      if (!componentIndices) continue;
+
+      for (let j = 0, m = componentIndices.length; j < m; j++) {
+        const config = allComponents[componentIndices[j]];
+        const instance = HierarchyParser._addComponentFromConfig(entity, config, refs);
+        pendingComponents.push({ instance, config });
       }
-      const entity = entityMap.get(entityConfig.id);
-      this._addComponents(entity, entityConfig.components);
     }
   }
 
-  private _parsePrefabModification() {
-    const entitiesConfig = this.data.entities;
-    const entityMap = this.context.entityMap;
+  // ---------------------------------------------------------------------------
+  // Stage 4: Apply props and execute calls on components
+  // ---------------------------------------------------------------------------
 
-    const promises = [];
-    for (let i = 0, l = entitiesConfig.length; i < l; i++) {
-      const entityConfig = entitiesConfig[i];
-      const { id, modifications } = entityConfig as IRefEntity;
+  private _parseComponentsPropsAndCalls(): Promise<unknown> {
+    const { pendingComponents } = this.context;
+    const reflectionParser = this._reflectionParser;
+    const promises: Promise<unknown>[] = [];
 
-      if (modifications?.length) {
-        const rootEntity = entityMap.get(id);
-        promises.push(
-          ...modifications.map((modification) => {
-            const { target, props, methods } = modification;
-            const { entityId, componentId } = target;
-            const context = this._prefabContextMap.get(rootEntity);
-            const targetEntity = context.entityMap.get(entityId);
-            const targetComponent = context.components.get(componentId);
-            if (targetComponent) {
-              return this._reflectionParser.parsePropsAndMethods(targetComponent, {
-                props,
-                methods
-              });
-            } else if (targetEntity) {
-              return Promise.resolve(this._applyEntityData(targetEntity, props));
-            }
-          })
-        );
-      }
+    for (let i = 0, n = pendingComponents.length; i < n; i++) {
+      const { instance, config } = pendingComponents[i];
+      promises.push(reflectionParser.parseMutationBlock(instance, config));
     }
 
     return Promise.all(promises);
   }
 
-  private _parseAddedComponents(): void {
-    const entityMap = this.context.entityMap;
-    const entityConfigMap = this.context.entityConfigMap;
-    const strippedIds = this.context.strippedIds;
+  // ---------------------------------------------------------------------------
+  // Stage 5: Apply prefab instance overrides
+  // ---------------------------------------------------------------------------
+
+  private _parsePrefabOverrides(): Promise<unknown> {
+    const entities = this.data.entities;
+    const entityInstances = this.context.entityInstances;
+    const promises: Promise<unknown>[] = [];
+
+    for (let i = 0, n = entities.length; i < n; i++) {
+      const entityConfig = entities[i];
+      if (!HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
 
-    for (let i = 0, n = strippedIds.length; i < n; i++) {
-      const entityConfig = entityConfigMap.get(strippedIds[i]) as IStrippedEntity;
-      const prefabContext = this._prefabContextMap.get(entityMap.get(entityConfig.prefabInstanceId));
-      const entity = prefabContext.entityMap.get(entityConfig.prefabSource.entityId);
-      this._addComponents(entity, entityConfig.components);
+      const overrides = entityConfig.instance.overrides;
+      if (!overrides) continue;
+
+      this._applyOverrides(entityInstances[i], overrides, promises);
     }
+
+    return Promise.all(promises);
   }
 
-  private _parsePrefabRemovedEntities() {
-    const entitiesConfig = this.data.entities;
-    const entityMap = this.context.entityMap;
-
-    for (let i = 0, l = entitiesConfig.length; i < l; i++) {
-      const entityConfig = entitiesConfig[i];
-      const { id, removedEntities } = entityConfig as IRefEntity;
-
-      if (removedEntities?.length) {
-        const rootEntity = entityMap.get(id);
-        for (let j = 0, m = removedEntities.length; j < m; j++) {
-          const target = removedEntities[j];
-          const { entityId } = target;
-          const context = this._prefabContextMap.get(rootEntity);
-          const targetEntity = context.entityMap.get(entityId);
-          if (targetEntity) {
-            targetEntity.destroy();
-          }
-        }
+  private _applyOverrides(rootEntity: Entity, overrides: InstanceOverrides, promises: Promise<unknown>[]): void {
+    const refs = this.data.refs;
+    const reflectionParser = this._reflectionParser;
+
+    // entityProps — entity-level property overrides
+    if (overrides.entityProps) {
+      for (let j = 0, m = overrides.entityProps.length; j < m; j++) {
+        const override = overrides.entityProps[j] as EntityPropOverride;
+        HierarchyParser._applyEntityProps(HierarchyParser._resolveEntity(rootEntity, override.path), override);
       }
     }
-  }
 
-  private _parsePrefabRemovedComponents() {
-    const entitiesConfig = this.data.entities;
-    const entityMap = this.context.entityMap;
-    const prefabContextMap = this._prefabContextMap;
-
-    for (let i = 0, l = entitiesConfig.length; i < l; i++) {
-      const entityConfig = entitiesConfig[i];
-      const { id, removedComponents } = entityConfig as IRefEntity;
-
-      if (removedComponents?.length) {
-        const rootEntity = entityMap.get(id);
-        for (let j = 0, m = removedComponents.length; j < m; j++) {
-          const target = removedComponents[j];
-          const { componentId } = target;
-          const context = prefabContextMap.get(rootEntity);
-          const targetComponent = context.components.get(componentId);
-          if (targetComponent) {
-            targetComponent.destroy();
-          }
-        }
+    // componentProps — component-level property overrides
+    if (overrides.componentProps) {
+      for (let j = 0, m = overrides.componentProps.length; j < m; j++) {
+        const override = overrides.componentProps[j] as ComponentOverride;
+        const entity = HierarchyParser._resolveEntity(rootEntity, override.path);
+        const target = HierarchyParser._resolveComponent(entity, override.selector);
+        promises.push(reflectionParser.parseMutationBlock(target, override));
       }
     }
-  }
 
-  private _organizeEntities(): void {
-    const { rootIds, strippedIds } = this.context;
-    const parentIds = rootIds.concat(strippedIds);
-    for (let i = 0, l = parentIds.length; i < l; i++) {
-      this._parseChildren(parentIds[i]);
+    // addedComponents — attach top-level components[index] to a prefab entity and parse props
+    if (overrides.addedComponents) {
+      const allComponents = this.data.components;
+      for (let j = 0, m = overrides.addedComponents.length; j < m; j++) {
+        const added = overrides.addedComponents[j];
+        const entity = HierarchyParser._resolveEntity(rootEntity, added.target);
+        const config = allComponents[added.component];
+        const component = HierarchyParser._addComponentFromConfig(entity, config, refs);
+        promises.push(reflectionParser.parseMutationBlock(component, config));
+      }
     }
-    for (let i = 0; i < rootIds.length; i++) {
-      this._handleRootEntity(rootIds[i]);
+
+    // addedEntities — attach already-created top-level entityInstances[index] as a child
+    if (overrides.addedEntities) {
+      const entityInstances = this.context.entityInstances;
+      for (let j = 0, m = overrides.addedEntities.length; j < m; j++) {
+        const added = overrides.addedEntities[j];
+        const parent = HierarchyParser._resolveEntity(rootEntity, added.parent);
+        parent.addChild(entityInstances[added.entity]);
+      }
     }
-  }
 
-  private _getEntityByConfig(entityConfig: IEntity, engine: Engine): Promise<Entity> {
-    let entityPromise: Promise<Entity>;
-    if ((<IRefEntity>entityConfig).assetUrl) {
-      entityPromise = this._parsePrefab(<IRefEntity>entityConfig, engine);
-    } else if ((<IStrippedEntity>entityConfig).strippedId) {
-      entityPromise = this._parseStrippedEntity(<IStrippedEntity>entityConfig);
-    } else {
-      entityPromise = this._parseEntity(entityConfig, engine);
+    // removedEntities — pre-resolve all targets then destroy (destroy shifts sibling indices)
+    if (overrides.removedEntities) {
+      const removed = overrides.removedEntities;
+      const targets = new Array<Entity>(removed.length);
+      for (let j = 0, m = removed.length; j < m; j++) {
+        targets[j] = HierarchyParser._resolveEntity(rootEntity, removed[j]);
+      }
+      for (let j = 0, m = targets.length; j < m; j++) {
+        targets[j].destroy();
+      }
     }
-    return entityPromise.then((entity) => {
-      return this._applyEntityData(entity, entityConfig);
-    });
-  }
 
-  private _parseEntity(entityConfig: IEntity, engine: Engine): Promise<Entity> {
-    const transform = entityConfig.transform;
-    const entity = new Entity(engine, entityConfig.name, transform ? Loader.getClass(transform.class) : Transform);
-    this._addEntityPlugin(entityConfig.id, entity);
-    return Promise.resolve(entity);
+    // removedComponents — pre-resolve all targets then destroy (destroy shifts component indices)
+    if (overrides.removedComponents) {
+      const targets: Component[] = [];
+      for (let j = 0, m = overrides.removedComponents.length; j < m; j++) {
+        const override = overrides.removedComponents[j];
+        const entity = HierarchyParser._resolveEntity(rootEntity, override.path);
+        const selectors = override.selectors;
+        for (let k = 0, p = selectors.length; k < p; k++) {
+          targets.push(HierarchyParser._resolveComponent(entity, selectors[k]));
+        }
+      }
+      for (let j = 0, m = targets.length; j < m; j++) {
+        targets[j].destroy();
+      }
+    }
   }
 
-  private _parsePrefab(entityConfig: IRefEntity, engine: Engine): Promise<Entity> {
-    const assetUrl: string = entityConfig.assetUrl;
+  // ---------------------------------------------------------------------------
+  // Prefab instance loading
+  // ---------------------------------------------------------------------------
+
+  private _loadPrefabInstance(entityConfig: PrefabInstanceEntitySchema, engine: Engine): Promise<Entity> {
+    const instance = entityConfig.instance;
+    let refItem: RefItem;
+    try {
+      refItem = resolveRefItem(this.data.refs, instance.asset, "HierarchyParser", "instance.asset");
+    } catch (error) {
+      return Promise.reject(error);
+    }
 
     return (
       engine.resourceManager
         // @ts-ignore
-        .getResourceByRef<Entity>({
-          url: assetUrl
-        })
+        .getResourceByRef<Entity>(refItem)
         .then((prefabResource: PrefabResource | GLTFResource) => {
           const entity =
             prefabResource instanceof PrefabResource
               ? prefabResource.instantiate()
               : prefabResource.instantiateSceneRoot();
-          const instanceContext = new ParserContext<IHierarchyFile, Entity>(engine, ParserType.Prefab, null);
-          this._generateInstanceContext(entity, instanceContext, "");
-
-          this._prefabContextMap.set(entity, instanceContext);
-          const cbArray = this._prefabPromiseMap.get(entityConfig.id);
-          if (cbArray) {
-            for (let i = 0, n = cbArray.length; i < n; i++) {
-              cbArray[i].resolve(instanceContext);
-            }
-          }
+          this._onEntityCreated(entity);
           return entity;
         })
     );
   }
 
-  private _parseStrippedEntity(entityConfig: IStrippedEntity): Promise<Entity> {
-    this.context.strippedIds.push(entityConfig.id);
-
-    return new Promise<ParserContext<IHierarchyFile, Entity>>((resolve, reject) => {
-      const cbArray = this._prefabPromiseMap.get((<IStrippedEntity>entityConfig).prefabInstanceId) ?? [];
-      cbArray.push({ resolve, reject });
-      this._prefabPromiseMap.set((<IStrippedEntity>entityConfig).prefabInstanceId, cbArray);
-    }).then((context) => {
-      const { entityId } = entityConfig.prefabSource;
-
-      return context.entityMap.get(entityId);
-    });
-  }
-
-  private _parseChildren(parentId: string) {
-    const { entityConfigMap, entityMap } = this.context;
-    const children = entityConfigMap.get(parentId).children;
-    if (children && children.length > 0) {
-      const parent = entityMap.get(parentId);
-      for (let i = 0; i < children.length; i++) {
-        const childId = children[i];
-        const entity = entityMap.get(childId);
-        parent.addChild(entity);
-        this._parseChildren(childId);
-      }
+  // ---------------------------------------------------------------------------
+  // Utilities
+  // ---------------------------------------------------------------------------
+
+  /** Resolve an entity inside a prefab instance by walking the child-index path from root */
+  private static _resolveEntity(root: Entity, path: number[]): Entity {
+    let entity = root;
+    for (let i = 0, n = path.length; i < n; i++) {
+      entity = entity.children[path[i]];
+      if (!entity)
+        throw new Error(`HierarchyParser: override target entity not found at path [${path}], failed at depth ${i}`);
     }
+    return entity;
   }
 
-  private _addComponents(entity: Entity, components: IEntity["components"]): void {
-    const context = this.context;
-    const componentMap = context.components;
-    const componentConfigMap = context.componentConfigMap;
-
-    for (let i = 0, n = components.length; i < n; i++) {
-      const componentConfig = components[i];
-      const key = !componentConfig.url ? componentConfig.class : componentConfig.url;
-      const componentId = componentConfig.id;
-      const component = entity.addComponent(Loader.getClass(key));
-      componentMap.set(componentId, component);
-      componentConfigMap.set(componentId, componentConfig);
-      this._addComponentPlugin(componentId, component);
-    }
+  /** Resolve a component on an entity by type name + per-type index */
+  private static _resolveComponent(entity: Entity, selector: ComponentSelector): Component {
+    const type = Loader.getClass(selector.type);
+    if (!type) throw new Error(`HierarchyParser: override target component type "${selector.type}" is not registered`);
+    const buffer = ReflectionParser._componentBuffer;
+    buffer.length = 0;
+    entity.getComponents(type, buffer);
+    const result = buffer[selector.index];
+    buffer.length = 0;
+    if (!result)
+      throw new Error(`HierarchyParser: override target component not found: ${selector.type}/${selector.index}`);
+    return result;
   }
 
-  private _generateInstanceContext(entity: Entity, context: ParserContext<IHierarchyFile, Entity>, path: string) {
-    const { entityMap, components } = context;
-    const componentsMap = {};
-    const componentIndexMap = {};
-
-    entityMap.set(path, entity);
-    // @ts-ignore
-    entity._components.forEach((component) => {
-      // @ts-ignore
-      const name = Loader.getClassName(component.constructor);
-      if (!componentsMap[name]) {
-        componentsMap[name] = entity.getComponents(component.constructor, []);
-        componentIndexMap[name] = 0;
-      }
-      components.set(`${path}:${name}/${componentIndexMap[name]++}`, component);
-    });
-    for (let i = 0, n = entity.children.length; i < n; i++) {
-      const child = entity.children[i];
-      const childPath = path ? `${path}/${i}` : `${i}`;
-      this._generateInstanceContext(child, context, childPath);
-    }
+  /** Resolve component class from config and add to entity. Throws if class is not registered. */
+  private static _addComponentFromConfig(entity: Entity, config: ComponentSchema, refs: RefItem[]): Component {
+    const key =
+      config.script != null
+        ? resolveRefItem(refs, config.script, "HierarchyParser", "component.script").url
+        : config.type;
+    const Class = Loader.getClass(key);
+    if (!Class) throw new Error(`Loader.getClass: class "${key}" is not registered`);
+    return entity.addComponent(Class);
   }
 
-  private _parseComponentsPropsAndMethods(): Promise<any[]> {
-    const context = this.context;
-    const componentConfigMap = context.componentConfigMap;
-    const reflectionParser = this._reflectionParser;
-    const promises = [];
-
-    for (const [componentId, component] of context.components) {
-      const componentConfig = componentConfigMap.get(componentId);
-      if (componentConfig) {
-        promises.push(reflectionParser.parsePropsAndMethods(component, componentConfig));
-      }
-    }
-
-    return Promise.all(promises);
+  private static _isPrefabInstanceEntity(entityConfig: EntitySchema): entityConfig is PrefabInstanceEntitySchema {
+    return "instance" in entityConfig;
   }
 
-  private _addComponentPlugin(componentId: string, component: Component): void {}
-
-  private _addEntityPlugin(entityId: string, entity: Entity): void {}
+  /** Apply entity-level props (name, isActive, layer, transform) to an entity. */
+  private static _applyEntityProps(entity: Entity, props: EntityOverrideProps): void {
+    if (props.name != null) entity.name = props.name;
+    if (props.isActive != null) entity.isActive = props.isActive;
+    if (props.layer != null) entity.layer = props.layer;
+    if (props.position) entity.transform.position.set(props.position[0], props.position[1], props.position[2]);
+    if (props.rotation) entity.transform.rotation.set(props.rotation[0], props.rotation[1], props.rotation[2]);
+    if (props.scale) entity.transform.scale.set(props.scale[0], props.scale[1], props.scale[2]);
+  }
 }
diff --git a/packages/loader/src/resource-deserialize/resources/parser/ParserContext.ts b/packages/loader/src/resource-deserialize/resources/parser/ParserContext.ts
index 26a735c471..44712a0d61 100644
--- a/packages/loader/src/resource-deserialize/resources/parser/ParserContext.ts
+++ b/packages/loader/src/resource-deserialize/resources/parser/ParserContext.ts
@@ -1,33 +1,22 @@
-import {
-  AssetPromise,
-  Component,
-  Engine,
-  EngineObject,
-  Entity,
-  ReferResource,
-  ResourceManager,
-  Scene
-} from "@galacean/engine-core";
-import type { IEntity, IHierarchyFile } from "../schema";
+import { AssetPromise, Component, Engine, Entity, ReferResource, ResourceManager, Scene } from "@galacean/engine-core";
+import type { ComponentSchema } from "../../../schema/HierarchySchema";
 
 export enum ParserType {
   Prefab,
   Scene
 }
+
 /**
  * @internal
  */
-export class ParserContext<T extends IHierarchyFile, I extends EngineObject> {
-  entityMap: Map<string, Entity> = new Map();
-  entityConfigMap: Map<string, IEntity> = new Map();
-  components: Map<string, Component> = new Map();
-  componentConfigMap: Map<string, any> = new Map();
-  rootIds: string[] = [];
-  strippedIds: string[] = [];
+export class ParserContext {
+  /** Runtime Entity instances, indexed by the flat entities[] position. */
+  entityInstances: Entity[] = [];
+  /** Components waiting for props/calls application (Stage 4). */
+  pendingComponents: Array<{ instance: Component; config: ComponentSchema }> = [];
 
   readonly resourceManager: ResourceManager;
 
-  private _tasks: Set<string> = new Set();
   private _loaded: number = 0;
   private _total: number = 0;
 
@@ -40,23 +29,16 @@ export class ParserContext<T extends IHierarchyFile, I extends EngineObject> {
   }
 
   clear() {
-    this.entityMap.clear();
-    this.components.clear();
-    this.componentConfigMap.clear();
-    this.entityConfigMap.clear();
-    this.rootIds.length = 0;
-    this.strippedIds.length = 0;
+    this.entityInstances.length = 0;
+    this.pendingComponents.length = 0;
   }
 
   /** @internal */
   _setTaskCompleteProgress: (loaded: number, total: number) => void;
 
   /** @internal */
-  _addDependentAsset(url: string, promise: AssetPromise<any>): void {
-    const tasks = this._tasks;
-    if (tasks.has(url)) return;
+  _addDependentAsset(promise: AssetPromise<any>): void {
     ++this._total;
-    tasks.add(url);
     promise.finally(() => {
       ++this._loaded;
       this._setTaskCompleteProgress(this._loaded, this._total);
diff --git a/packages/loader/src/resource-deserialize/resources/parser/ReflectionParser.ts b/packages/loader/src/resource-deserialize/resources/parser/ReflectionParser.ts
index fe92bbcf6a..2e038238ce 100644
--- a/packages/loader/src/resource-deserialize/resources/parser/ReflectionParser.ts
+++ b/packages/loader/src/resource-deserialize/resources/parser/ReflectionParser.ts
@@ -1,234 +1,208 @@
-import { EngineObject, Entity, Loader, Signal, Transform } from "@galacean/engine-core";
-import type {
-  IAssetRef,
-  IBasicType,
-  IClass,
-  IClassType,
-  IComponentRef,
-  IEntity,
-  IEntityRef,
-  IHierarchyFile,
-  IMethod,
-  IMethodParams,
-  IRefEntity,
-  ISignalRef
-} from "../schema";
+import { Component, Entity, Loader } from "@galacean/engine-core";
+import { resolveRefItem } from "../../../schema/refs";
+import type { CallSpec, ComponentRef, MutationBlock, RefItem, SignalListener } from "../../../schema/CommonSchema";
 import { ParserContext, ParserType } from "./ParserContext";
 
 export class ReflectionParser {
-  constructor(private readonly _context: ParserContext<IHierarchyFile, EngineObject>) {}
-
-  parseEntity(entityConfig: IEntity): Promise<Entity> {
-    return this._getEntityByConfig(entityConfig).then((entity) => {
-      entity.isActive = entityConfig.isActive ?? true;
-      const transform = entity.transform;
-      const transformConfig = entityConfig.transform;
-      if (transformConfig) {
-        this.parsePropsAndMethods(transform, transformConfig);
-      } else {
-        const { position, rotation, scale } = entityConfig;
-        if (position) transform.position.copyFrom(position);
-        if (rotation) transform.rotation.copyFrom(rotation);
-        if (scale) transform.scale.copyFrom(scale);
-      }
-      entity.layer = entityConfig.layer ?? entity.layer;
-      // @ts-ignore
-      this._context.type === ParserType.Prefab && entity._markAsTemplate(this._context.resource);
-      return entity;
-    });
-  }
-
-  parseClassObject(item: IClass) {
-    const Class = Loader.getClass(item.class);
-    const params = item.constructParams ?? [];
-    return Promise.all(params.map((param) => this.parseBasicType(param)))
-      .then((resultParams) => new Class(...resultParams))
-      .then((instance) => this.parsePropsAndMethods(instance, item));
-  }
-
-  parsePropsAndMethods(instance: any, item: Omit<IClass, "class">) {
-    const promises = [];
-    if (item.methods) {
-      for (let methodName in item.methods) {
-        const methodParams = item.methods[methodName];
-        for (let i = 0, count = methodParams.length; i < count; i++) {
-          promises.push(this.parseMethod(instance, methodName, methodParams[i]));
-        }
-      }
-    }
-
-    if (item.props) {
-      for (let key in item.props) {
-        const value = item.props[key];
-        const promise = this.parseBasicType(value, instance[key]).then((v) => {
-          return (instance[key] = v);
+  /** @internal shared with HierarchyParser; each use must length=0 -> getComponents -> read -> length=0 synchronously. */
+  static _componentBuffer: Component[] = [];
+
+  constructor(
+    private readonly _context: ParserContext,
+    private readonly _refs: RefItem[]
+  ) {}
+
+  /**
+   * Apply v2 props to a component/object instance.
+   * Each prop value is resolved recursively (handling $ref, $type, $class, $entity, $component, $signal).
+   */
+  parseProps(instance: any, props?: Record<string, unknown>): Promise<any> {
+    const promises: Promise<any>[] = [];
+    if (props) {
+      for (const key in props) {
+        const promise = this._resolveValue(props[key], instance[key]).then((v) => {
+          instance[key] = v;
         });
         promises.push(promise);
       }
     }
-
     return Promise.all(promises).then(() => instance);
   }
 
-  parseMethod(instance: any, methodName: string, methodParams: IMethodParams) {
-    const isMethodObject = ReflectionParser._isMethodObject(methodParams);
-    const params = isMethodObject ? methodParams.params : methodParams;
+  /**
+   * Execute calls sequentially on a target instance.
+   * Call args are resolved with the same v2 value rules as props.
+   */
+  parseCalls(instance: any, calls?: CallSpec[]): Promise<any> {
+    if (!calls?.length) return Promise.resolve(instance);
+
+    let chain = Promise.resolve();
+    for (let i = 0, n = calls.length; i < n; i++) {
+      const call = calls[i];
+      chain = chain.then(() => {
+        const method = instance?.[call.method];
+        if (typeof method !== "function") {
+          return Promise.reject(new Error(`Call target does not have method "${call.method}"`));
+        }
 
-    return Promise.all(params.map((param) => this.parseBasicType(param))).then((result) => {
-      const methodResult = instance[methodName](...result);
-      if (isMethodObject && methodParams.result) {
-        return this.parsePropsAndMethods(methodResult, methodParams.result);
-      } else {
-        return methodResult;
-      }
-    });
+        return Promise.all((call.args ?? []).map((arg) => this._resolveValue(arg)))
+          .then((resolvedArgs) => Promise.resolve(method.apply(instance, resolvedArgs)))
+          .then((result) => {
+            if (!call.result) return result;
+            if (result == null || (typeof result !== "object" && typeof result !== "function")) {
+              return Promise.reject(
+                new Error(`Call "${call.method}" returned ${result} and cannot be mutated by result`)
+              );
+            }
+            return this.parseMutationBlock(result, call.result);
+          });
+      });
+    }
+
+    return chain.then(() => instance);
   }
 
-  parseSignal(signalRef: ISignalRef): Promise<Signal> {
-    const signal = new Signal();
-    return Promise.all(
-      signalRef.listeners.map((listener) =>
-        Promise.all([
-          this.parseBasicType(listener.target),
-          listener.arguments ? Promise.all(listener.arguments.map((a) => this.parseBasicType(a))) : Promise.resolve([])
-        ]).then(([target, resolvedArgs]) => {
-          if (target) {
-            signal.on(target, listener.methodName, ...resolvedArgs);
-          }
-        })
-      )
-    ).then(() => signal);
+  /**
+   * Apply props and calls from the same mutation block without imposing ordering between them.
+   */
+  parseMutationBlock(target: any, block?: MutationBlock): Promise<any> {
+    if (!block) return Promise.resolve(target);
+    return Promise.all([this.parseProps(target, block.props), this.parseCalls(target, block.calls)]).then(() => target);
   }
 
-  parseBasicType(value: IBasicType, originValue?: any): Promise<any> {
-    if (Array.isArray(value)) {
-      return Promise.all(value.map((item) => this.parseBasicType(item)));
-    } else if (typeof value === "object" && value != null) {
-      if (ReflectionParser._isClassType(value)) {
-        return Promise.resolve(Loader.getClass(value["classType"]));
-      } else if (ReflectionParser._isClass(value)) {
-        // class object
-        return this.parseClassObject(value);
-      } else if (ReflectionParser._isAssetRef(value)) {
-        const { _context: context } = this;
-        // reference object
-        // @ts-ignore
-        return context.resourceManager.getResourceByRef(value).then((resource) => {
-          if (resource && context.type === ParserType.Prefab) {
-            // @ts-ignore
-            context.resource._addDependenceAsset(resource);
-          }
-          return resource;
-        });
-      } else if (ReflectionParser._isComponentRef(value)) {
-        const entity = this._resolveEntityByPath(value.entityPath);
-        if (!entity) return Promise.resolve(null);
-        const type = Loader.getClass(value.componentType);
-        if (!type) return Promise.resolve(null);
-        // Try direct components first, fallback to children search (for GLB clone entities
-        // where the component lives on a child entity inside the clone)
-        const direct = entity.getComponents(type, []);
-        const result = direct[value.componentIndex];
-        if (result) return Promise.resolve(result);
-        const includeChildren: any[] = [];
-        entity.getComponentsIncludeChildren(type, includeChildren);
-        return Promise.resolve(includeChildren[value.componentIndex] ?? null);
-      } else if (ReflectionParser._isEntityRef(value)) {
-        return Promise.resolve(this._resolveEntityByPath(value.entityPath));
-      } else if (ReflectionParser._isSignalRef(value)) {
-        return this.parseSignal(value);
-      } else if (originValue) {
-        const promises: Promise<any>[] = [];
-        for (let key in value as any) {
-          if (key === "methods") {
-            const methods: any = value[key];
-            for (let methodName in methods) {
-              const methodParams = methods[methodName];
-              for (let i = 0, count = methodParams.length; i < count; i++) {
-                const params = methodParams[i];
-                const promise = this.parseMethod(originValue, methodName, params);
-                promises.push(promise);
-              }
-            }
-          } else {
-            promises.push(this.parseBasicType(value[key], originValue[key]).then((v) => (originValue[key] = v)));
-          }
-        }
-        return Promise.all(promises).then(() => originValue);
+  /**
+   * Resolve a v2 value with $ prefix detection.
+   *
+   * Priority:
+   * 1. null/undefined/primitive → passthrough
+   * 2. Array → recurse each element
+   * 3. { $ref }       → asset reference
+   * 4. { $type }      → polymorphic type construct
+   * 5. { $class }     → registered class constructor
+   * 6. { $entity }    → entity reference by path (flat index + optional children descent)
+   * 7. { $component } → component reference
+   * 8. { $signal }    → signal binding
+   * 9. plain object   → recurse values (modify originValue in place if exists)
+   */
+  private _resolveValue(value: unknown, originValue?: any): Promise<any> {
+    if (value == null || typeof value !== "object") return Promise.resolve(value);
+    if (Array.isArray(value)) return Promise.all(value.map((v) => this._resolveValue(v)));
+
+    const obj = value as Record<string, unknown>;
+
+    // $ref — asset reference (index into refs array)
+    if ("$ref" in obj) {
+      const { _context: context } = this;
+      let refItem: RefItem;
+      try {
+        refItem = resolveRefItem(this._refs, obj.$ref as number, "ReflectionParser", "$ref");
+      } catch (error) {
+        return Promise.reject(error);
       }
+      // @ts-ignore
+      return context.resourceManager.getResourceByRef(refItem).then((resource) => {
+        if (resource && context.type === ParserType.Prefab) {
+          // @ts-ignore
+          context.resource._addDependenceAsset(resource);
+        }
+        return resource;
+      });
     }
-    // primitive type
-    return Promise.resolve(value);
-  }
 
-  private _getEntityByConfig(entityConfig: IEntity) {
-    // @ts-ignore
-    const assetUrl: string = entityConfig.assetUrl;
-    const engine = this._context.engine;
+    // $type — polymorphic type: construct instance and apply remaining props
+    if ("$type" in obj) {
+      const { $type, ...rest } = obj;
+      return this._resolveRegisteredClass($type, "$type").then((Class) => {
+        const instance = new Class();
+        return Object.keys(rest).length > 0 ? this.parseProps(instance, rest) : instance;
+      });
+    }
 
-    if (assetUrl) {
-      return (
-        engine.resourceManager
-          // @ts-ignore
-          .getResourceByRef({
-            url: assetUrl,
-            key: (entityConfig as IRefEntity).key,
-            isClone: (entityConfig as IRefEntity).isClone
-          })
-          .then((entity) => {
-            // @ts-ignore
-            const resource = engine.resourceManager._objectPool[assetUrl];
-            if (resource && this._context.type === ParserType.Prefab) {
-              // @ts-ignore
-              this._context.resource._addDependenceAsset(resource);
-            }
-            entity.name = entityConfig.name;
-            return entity;
-          })
-      );
-    } else {
-      const transform = entityConfig.transform;
-      const entity = new Entity(engine, entityConfig.name, transform ? Loader.getClass(transform.class) : Transform);
-      return Promise.resolve(entity);
+    // $class — registered class constructor for factory-style methods.
+    if ("$class" in obj) {
+      return this._resolveRegisteredClass(obj.$class, "$class");
     }
-  }
 
-  private _resolveEntityByPath(entityPath: number[]): Entity | null {
-    const { rootIds, entityMap } = this._context;
-    if (!entityPath.length || entityPath[0] >= rootIds.length) return null;
-    let entity = entityMap.get(rootIds[entityPath[0]]);
-    for (let i = 1; i < entityPath.length; i++) {
-      if (!entity || entityPath[i] >= entity.children.length) return null;
-      entity = entity.children[entityPath[i]];
+    // $entity — entity reference by path (first element = flat index, subsequent = children indices)
+    if ("$entity" in obj) {
+      return Promise.resolve(this._resolveEntityRef(obj.$entity as number[]));
     }
-    return entity;
-  }
 
-  private static _isClass(value: any): value is IClass {
-    return value["class"] !== undefined;
-  }
+    // $component — component reference: { entity, type, index }
+    if ("$component" in obj) {
+      return Promise.resolve(this._resolveComponent(obj.$component as ComponentRef));
+    }
 
-  private static _isClassType(value: any): value is IClassType {
-    return value["classType"] !== undefined;
+    // $signal — signal binding: register listeners on the existing Signal instance
+    if ("$signal" in obj) {
+      return this._resolveSignal(originValue, obj.$signal as SignalListener[]);
+    }
+
+    // Plain object — recurse each value, modifying originValue in place or building a new object
+    const target =
+      originValue && typeof originValue === "object" && !Array.isArray(originValue)
+        ? originValue
+        : ({} as Record<string, unknown>);
+    const promises: Promise<any>[] = [];
+    for (const key in obj) {
+      promises.push(this._resolveValue(obj[key], target[key]).then((v) => (target[key] = v)));
+    }
+    return Promise.all(promises).then(() => target);
   }
 
-  private static _isAssetRef(value: any): value is IAssetRef {
-    return value["url"] !== undefined;
+  private _getRegisteredClass(value: unknown, sentinel: "$type" | "$class"): any {
+    if (typeof value !== "string" || value.length === 0) {
+      throw new Error(`${sentinel} must be a non-empty registered class name string`);
+    }
+
+    const Class = Loader.getClass(value);
+    if (!Class) throw new Error(`Loader.getClass: class "${value}" is not registered`);
+    return Class;
   }
 
-  private static _isEntityRef(value: any): value is IEntityRef {
-    return Array.isArray(value["entityPath"]) && value["componentType"] === undefined;
+  /** Promise-adapt {@link _getRegisteredClass} so $type/$class branches can fold into the resolver chain. */
+  private _resolveRegisteredClass(value: unknown, sentinel: "$type" | "$class"): Promise<any> {
+    try {
+      return Promise.resolve(this._getRegisteredClass(value, sentinel));
+    } catch (error) {
+      return Promise.reject(error);
+    }
   }
 
-  private static _isComponentRef(value: any): value is IComponentRef {
-    return Array.isArray(value["entityPath"]) && value["componentType"] !== undefined;
+  private _resolveSignal(signal: any, listeners: SignalListener[]): Promise<any> {
+    if (!signal || typeof signal.on !== "function") {
+      return Promise.reject(new Error("$signal requires a pre-initialized Signal instance on the target property"));
+    }
+    const promises = listeners.map((listener) => {
+      const targetComponent = this._resolveComponent(listener.target.$component);
+      if (!targetComponent) return Promise.resolve();
+
+      return Promise.all((listener.args ?? []).map((a) => this._resolveValue(a))).then((resolvedArgs) => {
+        signal.on(targetComponent, listener.methodName, ...resolvedArgs);
+      });
+    });
+    return Promise.all(promises).then(() => signal);
   }
 
-  private static _isSignalRef(value: any): value is ISignalRef {
-    return value["listeners"] !== undefined;
+  private _resolveComponent(comp: ComponentRef): Component | null {
+    const entity = this._resolveEntityRef(comp.entity);
+    if (!entity) return null;
+    const type = Loader.getClass(comp.type);
+    if (!type) return null;
+    const buffer = ReflectionParser._componentBuffer;
+    buffer.length = 0;
+    entity.getComponents(type, buffer);
+    const result = buffer[comp.index] ?? null;
+    buffer.length = 0;
+    return result;
   }
 
-  private static _isMethodObject(value: any): value is IMethod {
-    return Array.isArray(value?.params);
+  private _resolveEntityRef(path: number[]): Entity | null {
+    if (!path || path.length === 0) return null;
+    let entity = this._context.entityInstances[path[0]] ?? null;
+    for (let i = 1, n = path.length; entity && i < n; i++) {
+      entity = entity.children[path[i]] ?? null;
+    }
+    return entity;
   }
 }
diff --git a/packages/loader/src/resource-deserialize/resources/scene/SceneParser.ts b/packages/loader/src/resource-deserialize/resources/scene/SceneParser.ts
index 48041b0ee0..c585251d69 100644
--- a/packages/loader/src/resource-deserialize/resources/scene/SceneParser.ts
+++ b/packages/loader/src/resource-deserialize/resources/scene/SceneParser.ts
@@ -1,14 +1,13 @@
-import { BackgroundMode, DiffuseMode, Scene } from "@galacean/engine-core";
+import { Scene } from "@galacean/engine-core";
+import type { SceneFile } from "../../../schema/SceneSchema";
 import { HierarchyParser } from "../parser/HierarchyParser";
 import { ParserContext } from "../parser/ParserContext";
-import { ReflectionParser } from "../parser/ReflectionParser";
-import { IHierarchyFile, IRefEntity, IStrippedEntity, SpecularMode, type IScene } from "../schema";
 
 /** @Internal */
-export class SceneParser extends HierarchyParser<Scene, ParserContext<IScene, Scene>> {
+export class SceneParser extends HierarchyParser<Scene, ParserContext> {
   constructor(
-    data: IScene,
-    context: ParserContext<IScene, Scene>,
+    data: SceneFile,
+    context: ParserContext,
     public readonly scene: Scene
   ) {
     super(data, context);
@@ -17,91 +16,26 @@ export class SceneParser extends HierarchyParser<Scene, ParserContext<IScene, Sc
   /**
    * @internal
    */
-  _collectDependentAssets(data: IScene): void {
+  _collectDependentAssets(data: SceneFile): void {
     const context = this.context;
     const resourceManager = context.resourceManager;
-    this._parseDependentAssets(data);
-    const scene = data.scene;
-    const ambient = scene.ambient;
-    if (ambient) {
-      const useCustomAmbient = ambient.specularMode === SpecularMode.Custom;
-      const useSH = ambient.diffuseMode === DiffuseMode.SphericalHarmonics;
-      const { customAmbientLight, ambientLight } = ambient;
-      if (useCustomAmbient && customAmbientLight) {
-        // @ts-ignore
-        context._addDependentAsset(customAmbientLight.url, resourceManager.getResourceByRef(customAmbientLight));
-      }
-      if (ambientLight && (!useCustomAmbient || useSH)) {
-        // @ts-ignore
-        context._addDependentAsset(ambientLight.url, resourceManager.getResourceByRef(ambientLight));
-      }
-    }
-
-    const background = scene.background;
-    const backgroundMode = background.mode;
-    if (backgroundMode === BackgroundMode.Texture) {
-      const texture = background.texture;
+    const refs = data.refs;
+    for (let i = 0, n = refs.length; i < n; i++) {
       // @ts-ignore
-      texture && context._addDependentAsset(texture.url, resourceManager.getResourceByRef(texture));
-    } else if (backgroundMode === BackgroundMode.Sky) {
-      const { skyMesh, skyMaterial } = background;
-      if (skyMesh && skyMaterial) {
-        // @ts-ignore
-        context._addDependentAsset(skyMesh.url, resourceManager.getResourceByRef(skyMesh));
-        // @ts-ignore
-        context._addDependentAsset(skyMaterial.url, resourceManager.getResourceByRef(skyMaterial));
-      }
+      context._addDependentAsset(resourceManager.getResourceByRef(refs[i]));
     }
   }
 
-  protected override _handleRootEntity(id: string): void {
-    const { entityMap } = this.context;
-    this.scene.addRootEntity(entityMap.get(id));
+  protected override _getRootIndices(): number[] {
+    return (this.data as SceneFile).scene.rootEntities;
+  }
+
+  protected override _handleRootEntity(index: number): void {
+    this.scene.addRootEntity(this.context.entityInstances[index]);
   }
 
   protected override _clearAndResolve() {
     this.context.clear();
     return this.scene;
   }
-
-  private _parseDependentAssets(file: IHierarchyFile): void {
-    const entities = file.entities;
-    for (let i = 0, n = entities.length; i < n; i++) {
-      const entity = entities[i];
-      if (!!(<IRefEntity>entity).assetUrl) {
-        const context = this.context;
-        const { assetUrl: url, key } = <IRefEntity>entity;
-        // @ts-ignore
-        context._addDependentAsset(url, context.resourceManager.getResourceByRef({ url, key }));
-      } else if ((<IStrippedEntity>entity).strippedId) {
-        continue;
-      } else {
-        const components = entity.components;
-        for (let j = 0, m = components.length; j < m; j++) {
-          const component = components[j];
-          this._searchDependentAssets(component.methods);
-          this._searchDependentAssets(component.props);
-        }
-      }
-    }
-  }
-
-  private _searchDependentAssets(value: any): void {
-    if (Array.isArray(value)) {
-      for (let i = 0, n = value.length; i < n; i++) {
-        this._searchDependentAssets(value[i]);
-      }
-    } else if (!!value && typeof value === "object") {
-      // @ts-ignore
-      if (ReflectionParser._isAssetRef(value)) {
-        const context = this.context;
-        // @ts-ignore
-        context._addDependentAsset(value.url, context.resourceManager.getResourceByRef(value));
-      } else {
-        for (let key in value) {
-          this._searchDependentAssets(value[key]);
-        }
-      }
-    }
-  }
 }
diff --git a/packages/loader/src/resource-deserialize/resources/schema/BasicSchema.ts b/packages/loader/src/resource-deserialize/resources/schema/BasicSchema.ts
deleted file mode 100644
index 97be075674..0000000000
--- a/packages/loader/src/resource-deserialize/resources/schema/BasicSchema.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import { Layer } from "@galacean/engine-core";
-
-export interface IVector3 {
-  x: number;
-  y: number;
-  z: number;
-}
-export interface IVector2 {
-  x: number;
-  y: number;
-}
-
-export interface IVector4 {
-  x: number;
-  y: number;
-  z: number;
-  w: number;
-}
-
-export interface IColor {
-  r: number;
-  g: number;
-  b: number;
-  a: number;
-}
-
-export interface IHierarchyFile {
-  entities: Array<IEntity>;
-}
-
-export type IMethod = {
-  params: Array<IBasicType>;
-  result?: IInstance;
-};
-
-export type IMethodParams = Array<IBasicType> | IMethod;
-
-export interface IBasicEntity {
-  name?: string;
-  id?: string;
-  transform?: IComponent;
-  components?: Array<IComponent>;
-  isActive?: boolean;
-  position?: IVector3;
-  rotation?: IVector3;
-  scale?: IVector3;
-  children?: Array<string>;
-  parent?: string;
-  layer?: Layer;
-}
-
-export type IEntity = IBasicEntity | IRefEntity | IStrippedEntity;
-
-export interface IRefEntity extends IBasicEntity {
-  assetUrl: string;
-  key?: string;
-  isClone?: boolean;
-  modifications: (IInstance & {
-    target: IPrefabModifyTarget;
-  })[];
-  removedEntities: IPrefabModifyTarget[];
-  removedComponents: IPrefabModifyTarget[];
-}
-
-export interface IPrefabModifyTarget {
-  entityId?: string;
-  componentId?: string;
-}
-
-export interface IStrippedEntity extends IBasicEntity {
-  strippedId: string;
-  prefabInstanceId: string;
-  prefabSource: { assetId: string; entityId: string };
-}
-
-export type IComponent = { id: string; url?: string } & IClass;
-
-export type IClass = {
-  class: string;
-  constructParams?: Array<IBasicType>;
-} & IInstance;
-
-export interface IInstance {
-  methods?: { [methodName: string]: Array<IMethodParams> };
-  props?: { [key: string]: IBasicType | IMethodParams };
-}
-
-export type IClassType = {
-  classType: string;
-};
-
-export type IBasicType =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined
-  | IAssetRef
-  | IClass
-  | IClassType
-  | IMethodParams
-  | IEntityRef
-  | IComponentRef
-  | ISignalRef;
-
-export type IAssetRef = { key?: string; url: string };
-
-export type IEntityRef = { entityPath: number[] };
-
-export type IComponentRef = {
-  entityPath: number[];
-  componentType: string;
-  componentIndex: number;
-};
-
-export type ISignalRef = {
-  listeners: Array<{
-    target: IComponentRef;
-    methodName: string;
-    arguments?: Array<IBasicType>;
-  }>;
-};
diff --git a/packages/loader/src/resource-deserialize/resources/schema/MaterialSchema.ts b/packages/loader/src/resource-deserialize/resources/schema/MaterialSchema.ts
deleted file mode 100644
index f2f6012918..0000000000
--- a/packages/loader/src/resource-deserialize/resources/schema/MaterialSchema.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-import {
-  BlendFactor,
-  BlendOperation,
-  ColorWriteMask,
-  CompareFunction,
-  CullMode,
-  RenderQueueType,
-  StencilOperation
-} from "@galacean/engine-core";
-import type { IAssetRef, IColor, IVector2, IVector3 } from "./BasicSchema";
-
-export interface IRenderState {
-  /** Blend state. */
-  blendState: {
-    /** The blend state of the render target. */
-    targetBlendState: {
-      /** Whether to enable blend. */
-      enabled: boolean;
-      /** color (RGB) blend operation. */
-      colorBlendOperation: BlendOperation;
-      /** alpha (A) blend operation. */
-      alphaBlendOperation: BlendOperation;
-      /** color blend factor (RGB) for source. */
-      sourceColorBlendFactor: BlendFactor;
-      /** alpha blend factor (A) for source. */
-      sourceAlphaBlendFactor: BlendFactor;
-      /** color blend factor (RGB) for destination. */
-      destinationColorBlendFactor: BlendFactor;
-      /** alpha blend factor (A) for destination. */
-      destinationAlphaBlendFactor: BlendFactor;
-      /** color mask. */
-      colorWriteMask: ColorWriteMask;
-    };
-    blendColor: IColor;
-    /** Whether to use (Alpha-to-Coverage) technology. */
-    alphaToCoverage: boolean;
-  };
-
-  /** Depth state. */
-  depthState: {
-    /** Whether to enable the depth test. */
-    enabled: boolean;
-    /** Whether the depth value can be written.*/
-    writeEnabled: boolean;
-    /** Depth comparison function. */
-    compareFunction: CompareFunction;
-  };
-  /** Stencil state. */
-  stencilState: {
-    /** Whether to enable stencil test. */
-    enabled: boolean;
-    /** Write the reference value of the stencil buffer. */
-    referenceValue: number;
-    /** Specifying a bit-wise mask that is used to AND the reference value and the stored stencil value when the test is done. */
-    mask: number;
-    /** Specifying a bit mask to enable or disable writing of individual bits in the stencil planes. */
-    writeMask: number;
-    /** The comparison function of the reference value of the front face of the geometry and the current buffer storage value. */
-    compareFunctionFront: CompareFunction;
-    /** The comparison function of the reference value of the back of the geometry and the current buffer storage value. */
-    compareFunctionBack: CompareFunction;
-    /** specifying the function to use for front face when both the stencil test and the depth test pass. */
-    passOperationFront: StencilOperation;
-    /** specifying the function to use for back face when both the stencil test and the depth test pass. */
-    passOperationBack: StencilOperation;
-    /** specifying the function to use for front face when the stencil test fails. */
-    failOperationFront: StencilOperation;
-    /** specifying the function to use for back face when the stencil test fails. */
-    failOperationBack: StencilOperation;
-    /** specifying the function to use for front face when the stencil test passes, but the depth test fails. */
-    zFailOperationFront: StencilOperation;
-    /** specifying the function to use for back face when the stencil test passes, but the depth test fails. */
-    zFailOperationBack: StencilOperation;
-  };
-  /** Raster state. */
-  rasterState: {
-    /** Specifies whether or not front- and/or back-facing polygons can be culled. */
-    cullMode: CullMode;
-    /** The multiplier by which an implementation-specific value is multiplied with to create a constant depth offset. */
-    depthBias: number;
-    /** The scale factor for the variable depth offset for each polygon. */
-    slopeScaledDepthBias: number;
-  };
-  /** Render queue type. */
-  renderQueueType: RenderQueueType;
-}
-
-export interface IMaterialSchema {
-  name: string;
-  shader: string;
-  shaderData: {
-    [key: string]: {
-      type: MaterialLoaderType;
-      value: IVector3 | IVector2 | IColor | number | IAssetRef;
-    };
-  };
-  macros: Array<{ name: string; value?: string }>;
-  renderState: IRenderState;
-  shaderRef: IAssetRef;
-}
-
-export enum MaterialLoaderType {
-  Vector2 = "Vector2",
-  Vector3 = "Vector3",
-  Vector4 = "Vector4",
-  Color = "Color",
-  Float = "Float",
-  Texture = "Texture",
-  Boolean = "Boolean",
-  Integer = "Integer"
-}
diff --git a/packages/loader/src/resource-deserialize/resources/schema/SceneSchema.ts b/packages/loader/src/resource-deserialize/resources/schema/SceneSchema.ts
deleted file mode 100644
index 1f64dcb87c..0000000000
--- a/packages/loader/src/resource-deserialize/resources/schema/SceneSchema.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import {
-  BackgroundMode,
-  BackgroundTextureFillMode,
-  BloomDownScaleMode,
-  DiffuseMode,
-  FogMode,
-  ShadowCascadesMode,
-  ShadowResolution,
-  TonemappingMode
-} from "@galacean/engine-core";
-import type { IAssetRef, IColor, IHierarchyFile, IVector3 } from "./BasicSchema";
-
-export enum SpecularMode {
-  Sky = "Sky",
-  Custom = "Custom"
-}
-
-export interface IScene extends IHierarchyFile {
-  name?: string;
-  scene: {
-    background: {
-      mode: BackgroundMode;
-      color: IColor;
-      texture?: IAssetRef;
-      textureFillMode?: BackgroundTextureFillMode;
-      skyMesh?: IAssetRef;
-      skyMaterial?: IAssetRef;
-    };
-    ambient: {
-      diffuseMode: DiffuseMode;
-      ambientLight: IAssetRef;
-      customAmbientLight: IAssetRef;
-      customSpecularTexture: IAssetRef;
-      diffuseSolidColor: IColor;
-      diffuseIntensity: number;
-      specularIntensity: number;
-      specularMode: SpecularMode;
-      bakerResolution: number;
-    };
-    shadow?: {
-      castShadows: boolean;
-      enableTransparentShadow: boolean;
-      shadowResolution: ShadowResolution;
-      shadowDistance: number;
-      shadowCascades: ShadowCascadesMode;
-      shadowTwoCascadeSplits: number;
-      shadowFourCascadeSplits: IVector3;
-      shadowFadeBorder: number;
-    };
-    fog?: {
-      fogMode: FogMode;
-      fogStart: number;
-      fogEnd: number;
-      fogDensity: number;
-      fogColor: IColor;
-    };
-    physics?: {
-      gravity?: IVector3;
-      fixedTimeStep?: number;
-    };
-    postProcess?: {
-      isActive: boolean;
-      bloom: {
-        enabled: boolean;
-        downScale: BloomDownScaleMode;
-        threshold: number;
-        scatter: number;
-        intensity: number;
-        tint: IColor;
-        dirtTexture: IAssetRef;
-        dirtIntensity: number;
-      };
-      tonemapping: {
-        enabled: boolean;
-        mode: TonemappingMode;
-      };
-    };
-    ambientOcclusion?: {
-      bias: number;
-      bilateralThreshold: number;
-      enabledAmbientOcclusion: boolean;
-      intensity: number;
-      power: number;
-      quality: number;
-      radius: number;
-      minHorizonAngle: number;
-    };
-  };
-  files: Array<{ id: string; type: string; virtualPath: string; path: string }>;
-}
diff --git a/packages/loader/src/resource-deserialize/resources/texture2D/Texture2DDecoder.ts b/packages/loader/src/resource-deserialize/resources/texture2D/Texture2DDecoder.ts
new file mode 100644
index 0000000000..c0061e89cd
--- /dev/null
+++ b/packages/loader/src/resource-deserialize/resources/texture2D/Texture2DDecoder.ts
@@ -0,0 +1,59 @@
+import { AssetPromise, Engine, Texture2D, TextureFormat } from "@galacean/engine-core";
+import { BufferReader } from "../../utils/BufferReader";
+import { decoder } from "../../utils/Decorator";
+import { HDRDecoder } from "../../../HDRDecoder";
+
+/**
+ * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
+ * [format(1B)] [width(2B)] [height(2B)] [isSRGBColorSpace(1B)] [Uint32(imageSize) + imageBytes]
+ */
+@decoder("Texture2D")
+class Texture2DDecoder {
+  static decode(engine: Engine, bufferReader: BufferReader, restoredTexture?: Texture2D): AssetPromise<Texture2D> {
+    return new AssetPromise((resolve, reject) => {
+      const url = bufferReader.nextStr();
+      const mipmap = !!bufferReader.nextUint8();
+      const filterMode = bufferReader.nextUint8();
+      const anisoLevel = bufferReader.nextUint8();
+      const wrapModeU = bufferReader.nextUint8();
+      const wrapModeV = bufferReader.nextUint8();
+      const format = bufferReader.nextUint8();
+      const width = bufferReader.nextUint16();
+      const height = bufferReader.nextUint16();
+      const isSRGBColorSpace = !!bufferReader.nextUint8();
+
+      const imageData = bufferReader.nextImagesData(1)[0];
+
+      const isHDR = imageData[0] === 0x23 && imageData[1] === 0x3f;
+      const textureFormat = isHDR ? TextureFormat.R16G16B16A16 : format;
+      const texture =
+        restoredTexture ||
+        new Texture2D(engine, width, height, textureFormat, mipmap, isHDR ? false : isSRGBColorSpace);
+      texture.filterMode = filterMode;
+      texture.anisoLevel = anisoLevel;
+      texture.wrapModeU = wrapModeU;
+      texture.wrapModeV = wrapModeV;
+
+      if (isHDR) {
+        const { pixels } = HDRDecoder.decode(imageData);
+        texture.setPixelBuffer(pixels);
+        mipmap && texture.generateMipmaps();
+        resolve(texture);
+      } else {
+        const blob = new Blob([imageData]);
+        const img = new Image();
+        img.onload = () => {
+          URL.revokeObjectURL(img.src);
+          texture.setImageSource(img);
+          mipmap && texture.generateMipmaps();
+          resolve(texture);
+        };
+        img.onerror = (e) => {
+          URL.revokeObjectURL(img.src);
+          reject(e);
+        };
+        img.src = URL.createObjectURL(blob);
+      }
+    });
+  }
+}
diff --git a/packages/loader/src/resource-deserialize/resources/texture2D/TextureDecoder.ts b/packages/loader/src/resource-deserialize/resources/texture2D/TextureDecoder.ts
deleted file mode 100644
index 05de1b8be2..0000000000
--- a/packages/loader/src/resource-deserialize/resources/texture2D/TextureDecoder.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { AssetPromise, Engine, Texture2D } from "@galacean/engine-core";
-import { BufferReader } from "../../utils/BufferReader";
-import { decoder } from "../../utils/Decorator";
-
-/**
- * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
- * [format(1B)] [width(2B)] [height(2B)] [isPixelBuffer(1B)] [isSRGBColorSpace(1B)] [mipCount(1B)] [imageData...]
- */
-@decoder("Texture2D")
-export class Texture2DDecoder {
-  static decode(engine: Engine, bufferReader: BufferReader, restoredTexture?: Texture2D): AssetPromise<Texture2D> {
-    return new AssetPromise((resolve, reject) => {
-      const url = bufferReader.nextStr();
-      const mipmap = !!bufferReader.nextUint8();
-      const filterMode = bufferReader.nextUint8();
-      const anisoLevel = bufferReader.nextUint8();
-      const wrapModeU = bufferReader.nextUint8();
-      const wrapModeV = bufferReader.nextUint8();
-      const format = bufferReader.nextUint8();
-      const width = bufferReader.nextUint16();
-      const height = bufferReader.nextUint16();
-      const isPixelBuffer = bufferReader.nextUint8();
-      const isSRGBColorSpace = !!bufferReader.nextUint8();
-
-      const mipCount = bufferReader.nextUint8();
-      const imagesData = bufferReader.nextImagesData(mipCount);
-
-      const texture2D = restoredTexture || new Texture2D(engine, width, height, format, mipmap, isSRGBColorSpace);
-      texture2D.filterMode = filterMode;
-      texture2D.anisoLevel = anisoLevel;
-      texture2D.wrapModeU = wrapModeU;
-      texture2D.wrapModeV = wrapModeV;
-
-      if (isPixelBuffer) {
-        const pixelBuffer = imagesData[0];
-        texture2D.setPixelBuffer(pixelBuffer);
-        if (mipmap) {
-          texture2D.generateMipmaps();
-          for (let i = 1; i < mipCount; i++) {
-            const pixelBuffer = imagesData[i];
-            texture2D.setPixelBuffer(pixelBuffer, i);
-          }
-        }
-        // @ts-ignore
-        engine.resourceManager._objectPool[url] = texture2D;
-        resolve(texture2D);
-      } else {
-        const blob = new window.Blob([imagesData[0]]);
-        const img = new Image();
-        img.onload = () => {
-          texture2D.setImageSource(img);
-          let completedCount = 0;
-          const onComplete = () => {
-            completedCount++;
-            if (completedCount >= mipCount) {
-              resolve(texture2D);
-            }
-          };
-          onComplete();
-          if (mipmap) {
-            texture2D.generateMipmaps();
-            for (let i = 1; i < mipCount; i++) {
-              const blob = new window.Blob([imagesData[i]]);
-              const img = new Image();
-              img.onload = () => {
-                texture2D.setImageSource(img, i);
-                onComplete();
-              };
-              img.src = URL.createObjectURL(blob);
-            }
-          }
-        };
-        img.src = URL.createObjectURL(blob);
-      }
-    });
-  }
-}
diff --git a/packages/loader/src/resource-deserialize/resources/textureCube/TextureCubeDecoder.ts b/packages/loader/src/resource-deserialize/resources/textureCube/TextureCubeDecoder.ts
new file mode 100644
index 0000000000..9b8aad970d
--- /dev/null
+++ b/packages/loader/src/resource-deserialize/resources/textureCube/TextureCubeDecoder.ts
@@ -0,0 +1,64 @@
+import { AssetPromise, Engine, TextureCube, TextureCubeFace, TextureFormat } from "@galacean/engine-core";
+import { BufferReader } from "../../utils/BufferReader";
+import { decoder } from "../../utils/Decorator";
+import { HDRDecoder } from "../../../HDRDecoder";
+
+/**
+ * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
+ * [format(1B)] [faceSize(2B)] [isSRGBColorSpace(1B)] [Uint32(size) + faceBytes] × 6
+ */
+@decoder("TextureCube")
+class TextureCubeDecoder {
+  static decode(engine: Engine, bufferReader: BufferReader, restoredTexture?: TextureCube): AssetPromise<TextureCube> {
+    return new AssetPromise((resolve, reject) => {
+      const url = bufferReader.nextStr();
+      const mipmap = !!bufferReader.nextUint8();
+      const filterMode = bufferReader.nextUint8();
+      const anisoLevel = bufferReader.nextUint8();
+      const wrapModeU = bufferReader.nextUint8();
+      const wrapModeV = bufferReader.nextUint8();
+      const format = bufferReader.nextUint8();
+      const faceSize = bufferReader.nextUint16();
+      const isSRGBColorSpace = !!bufferReader.nextUint8();
+
+      const facesData = bufferReader.nextImagesData(6);
+
+      // Detect format by first face's magic bytes
+      const isHDR = facesData[0][0] === 0x23 && facesData[0][1] === 0x3f;
+      const textureFormat = isHDR ? TextureFormat.R16G16B16A16 : format;
+      const texture = restoredTexture || new TextureCube(engine, faceSize, textureFormat, mipmap, isSRGBColorSpace);
+      texture.filterMode = filterMode;
+      texture.anisoLevel = anisoLevel;
+      texture.wrapModeU = wrapModeU;
+      texture.wrapModeV = wrapModeV;
+
+      if (isHDR) {
+        for (let i = 0; i < 6; i++) {
+          const { pixels } = HDRDecoder.decode(facesData[i]);
+          texture.setPixelBuffer(TextureCubeFace.PositiveX + i, pixels, 0);
+        }
+        mipmap && texture.generateMipmaps();
+        resolve(texture);
+      } else {
+        let loadedCount = 0;
+        for (let i = 0; i < 6; i++) {
+          const blob = new Blob([facesData[i]]);
+          const img = new Image();
+          img.onload = () => {
+            URL.revokeObjectURL(img.src);
+            texture.setImageSource(TextureCubeFace.PositiveX + i, img);
+            if (++loadedCount === 6) {
+              mipmap && texture.generateMipmaps();
+              resolve(texture);
+            }
+          };
+          img.onerror = (e) => {
+            URL.revokeObjectURL(img.src);
+            reject(e);
+          };
+          img.src = URL.createObjectURL(blob);
+        }
+      }
+    });
+  }
+}
diff --git a/packages/loader/src/schema/BasicSchema.ts b/packages/loader/src/schema/BasicSchema.ts
new file mode 100644
index 0000000000..8389190515
--- /dev/null
+++ b/packages/loader/src/schema/BasicSchema.ts
@@ -0,0 +1,24 @@
+export interface IVector3 {
+  x: number;
+  y: number;
+  z: number;
+}
+
+export interface IVector2 {
+  x: number;
+  y: number;
+}
+
+export interface IVector4 {
+  x: number;
+  y: number;
+  z: number;
+  w: number;
+}
+
+export interface IColor {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
diff --git a/packages/loader/src/schema/CommonSchema.ts b/packages/loader/src/schema/CommonSchema.ts
new file mode 100644
index 0000000000..ae61dc8ce4
--- /dev/null
+++ b/packages/loader/src/schema/CommonSchema.ts
@@ -0,0 +1,38 @@
+export type Vec3Tuple = [number, number, number];
+export type Vec4Tuple = [number, number, number, number];
+
+export interface RefItem {
+  url: string;
+  key?: string;
+}
+
+/** path[0] = flat index into top-level entities[]; subsequent indices descend via children. */
+export type EntityRef = number[];
+
+export interface ComponentRef {
+  entity: EntityRef;
+  type: string;
+  index: number;
+}
+
+/** Reference to a registered runtime class constructor. */
+export interface ClassRef {
+  $class: string;
+}
+
+export interface SignalListener {
+  target: { $component: ComponentRef };
+  methodName: string;
+  args?: unknown[];
+}
+
+export interface CallSpec {
+  method: string;
+  args?: unknown[];
+  result?: MutationBlock;
+}
+
+export interface MutationBlock {
+  props?: Record<string, unknown>;
+  calls?: CallSpec[];
+}
diff --git a/packages/loader/src/schema/HierarchySchema.ts b/packages/loader/src/schema/HierarchySchema.ts
new file mode 100644
index 0000000000..c26afb70a5
--- /dev/null
+++ b/packages/loader/src/schema/HierarchySchema.ts
@@ -0,0 +1,85 @@
+import type { MutationBlock, RefItem, Vec3Tuple } from "./CommonSchema";
+
+export interface ComponentSchema extends MutationBlock {
+  type: string;
+  script?: number;
+}
+
+export interface EntityOverrideProps {
+  name?: string;
+  isActive?: boolean;
+  layer?: number;
+  position?: Vec3Tuple;
+  rotation?: Vec3Tuple;
+  scale?: Vec3Tuple;
+}
+
+export interface AddedEntityOverride {
+  /** Parent path from prefab instance root via children indices. `[]` = instance root. */
+  parent: number[];
+  /** Index into the top-level entities[] array. */
+  entity: number;
+}
+
+export interface AddedComponentOverride {
+  /** Target entity path from prefab instance root via children indices. `[]` = instance root. */
+  target: number[];
+  /** Index into the top-level components[] array. */
+  component: number;
+}
+
+export interface EntityPropOverride extends EntityOverrideProps {
+  /** Path from prefab instance root via children indices. `[]` = instance root. */
+  path: number[];
+}
+
+export interface ComponentSelector {
+  type: string;
+  index: number;
+}
+
+export interface ComponentOverride extends MutationBlock {
+  /** Path from prefab instance root via children indices. `[]` = instance root. */
+  path: number[];
+  selector: ComponentSelector;
+}
+
+export interface RemovedComponentOverride {
+  /** Path from prefab instance root via children indices. `[]` = instance root. */
+  path: number[];
+  selectors: ComponentSelector[];
+}
+
+export interface InstanceOverrides {
+  entityProps?: EntityPropOverride[];
+  componentProps?: ComponentOverride[];
+  /** Each element is a path from prefab instance root via children indices. */
+  removedEntities?: number[][];
+  removedComponents?: RemovedComponentOverride[];
+  addedEntities?: AddedEntityOverride[];
+  addedComponents?: AddedComponentOverride[];
+}
+
+export interface InstanceSchema {
+  asset: number;
+  overrides?: InstanceOverrides;
+}
+
+export interface NormalEntitySchema extends EntityOverrideProps {
+  children?: number[];
+  components?: number[];
+}
+
+export interface PrefabInstanceEntitySchema {
+  instance: InstanceSchema;
+}
+
+export type EntitySchema = NormalEntitySchema | PrefabInstanceEntitySchema;
+
+/** Common base for v2 scene and prefab files. */
+export interface HierarchyFile {
+  version: "2.0";
+  refs: RefItem[];
+  entities: EntitySchema[];
+  components: ComponentSchema[];
+}
diff --git a/packages/loader/src/schema/MaterialSchema.ts b/packages/loader/src/schema/MaterialSchema.ts
new file mode 100644
index 0000000000..6f0128d052
--- /dev/null
+++ b/packages/loader/src/schema/MaterialSchema.ts
@@ -0,0 +1,26 @@
+import type { RefItem } from "./CommonSchema";
+import type { IColor, IVector2, IVector3 } from "./BasicSchema";
+
+export interface IMaterialSchema {
+  name: string;
+  shader: string;
+  shaderData: {
+    [key: string]: {
+      type: MaterialLoaderType;
+      value: IVector3 | IVector2 | IColor | number | RefItem;
+    };
+  };
+  macros: Array<{ name: string; value?: string }>;
+  shaderRef: RefItem;
+}
+
+export enum MaterialLoaderType {
+  Vector2 = "Vector2",
+  Vector3 = "Vector3",
+  Vector4 = "Vector4",
+  Color = "Color",
+  Float = "Float",
+  Texture = "Texture",
+  Boolean = "Boolean",
+  Integer = "Integer"
+}
diff --git a/packages/loader/src/schema/PrefabSchema.ts b/packages/loader/src/schema/PrefabSchema.ts
new file mode 100644
index 0000000000..b779cee508
--- /dev/null
+++ b/packages/loader/src/schema/PrefabSchema.ts
@@ -0,0 +1,5 @@
+import type { HierarchyFile } from "./HierarchySchema";
+
+export interface PrefabFile extends HierarchyFile {
+  root: number;
+}
diff --git a/packages/loader/src/resource-deserialize/resources/schema/ProjectSchema.ts b/packages/loader/src/schema/ProjectSchema.ts
similarity index 100%
rename from packages/loader/src/resource-deserialize/resources/schema/ProjectSchema.ts
rename to packages/loader/src/schema/ProjectSchema.ts
diff --git a/packages/loader/src/schema/SceneSchema.ts b/packages/loader/src/schema/SceneSchema.ts
new file mode 100644
index 0000000000..659f4b6186
--- /dev/null
+++ b/packages/loader/src/schema/SceneSchema.ts
@@ -0,0 +1,68 @@
+import {
+  BackgroundMode,
+  BackgroundTextureFillMode,
+  DiffuseMode,
+  FogMode,
+  ShadowCascadesMode,
+  ShadowResolution
+} from "@galacean/engine-core";
+import type { HierarchyFile } from "./HierarchySchema";
+import type { Vec3Tuple, Vec4Tuple } from "./CommonSchema";
+
+export enum SpecularMode {
+  Sky = 0,
+  Custom = 1
+}
+
+export interface SceneFile extends HierarchyFile {
+  scene: {
+    name?: string;
+    rootEntities: number[];
+    background: {
+      mode: BackgroundMode;
+      color: Vec4Tuple;
+      texture?: number;
+      textureFillMode?: BackgroundTextureFillMode;
+      skyMesh?: number;
+      skyMaterial?: number;
+    };
+    ambient?: {
+      diffuseMode: DiffuseMode;
+      ambientLight?: number;
+      customAmbientLight?: number;
+      diffuseSolidColor?: Vec4Tuple;
+      diffuseIntensity: number;
+      specularIntensity: number;
+      specularMode: SpecularMode;
+    };
+    shadow?: {
+      castShadows?: boolean;
+      enableTransparentShadow?: boolean;
+      shadowResolution?: ShadowResolution;
+      shadowDistance?: number;
+      shadowCascades?: ShadowCascadesMode;
+      shadowTwoCascadeSplits?: number;
+      shadowFourCascadeSplits?: Vec3Tuple;
+      shadowFadeBorder?: number;
+    };
+    fog?: {
+      fogMode?: FogMode;
+      fogStart?: number;
+      fogEnd?: number;
+      fogDensity?: number;
+      fogColor?: Vec4Tuple;
+    };
+    ambientOcclusion?: {
+      enabledAmbientOcclusion?: boolean;
+      quality?: number;
+      intensity?: number;
+      radius?: number;
+      bias?: number;
+      power?: number;
+      bilateralThreshold?: number;
+      minHorizonAngle?: number;
+    };
+    /** Not supported in scene yet; presence triggers a warning. */
+    postProcess?: unknown;
+  };
+}
diff --git a/packages/loader/src/resource-deserialize/resources/schema/index.ts b/packages/loader/src/schema/index.ts
similarity index 56%
rename from packages/loader/src/resource-deserialize/resources/schema/index.ts
rename to packages/loader/src/schema/index.ts
index bac8725fc1..457f1e9097 100644
--- a/packages/loader/src/resource-deserialize/resources/schema/index.ts
+++ b/packages/loader/src/schema/index.ts
@@ -1,4 +1,7 @@
+export * from "./CommonSchema";
+export * from "./HierarchySchema";
+export * from "./SceneSchema";
+export * from "./PrefabSchema";
 export * from "./BasicSchema";
 export * from "./MaterialSchema";
 export * from "./ProjectSchema";
-export * from "./SceneSchema";
diff --git a/packages/loader/src/schema/refs.ts b/packages/loader/src/schema/refs.ts
new file mode 100644
index 0000000000..5a8fc38cc9
--- /dev/null
+++ b/packages/loader/src/schema/refs.ts
@@ -0,0 +1,9 @@
+import type { RefItem } from "./CommonSchema";
+
+export function resolveRefItem(refs: RefItem[], index: number, owner: string, label: string): RefItem {
+  if (!Number.isInteger(index) || index < 0 || index >= refs.length) {
+    throw new Error(`${owner}: invalid ref index ${index} for ${label}`);
+  }
+
+  return refs[index];
+}
diff --git a/tests/src/core/particle/Burst.test.ts b/tests/src/core/particle/Burst.test.ts
new file mode 100644
index 0000000000..7765171e54
--- /dev/null
+++ b/tests/src/core/particle/Burst.test.ts
@@ -0,0 +1,187 @@
+import {
+  Burst,
+  Camera,
+  Engine,
+  ParticleCompositeCurve,
+  ParticleMaterial,
+  ParticleRenderer,
+  ParticleStopMode
+} from "@galacean/engine-core";
+import { Color } from "@galacean/engine-math";
+import { WebGLEngine } from "@galacean/engine";
+import { beforeAll, describe, expect, it } from "vitest";
+
+function updateEngine(engine: Engine, frames: number, deltaTime = 100) {
+  //@ts-ignore
+  engine._vSyncCount = Infinity;
+  //@ts-ignore
+  engine._time._lastSystemTime = 0;
+  let times = 0;
+  performance.now = function () {
+    times++;
+    return times * deltaTime;
+  };
+  for (let i = 0; i < frames; i++) {
+    engine.update();
+  }
+}
+
+describe("Burst", () => {
+  let engine: Engine;
+
+  beforeAll(async function () {
+    engine = await WebGLEngine.create({
+      canvas: document.createElement("canvas")
+    });
+
+    const scene = engine.sceneManager.activeScene;
+    const rootEntity = scene.createRootEntity("root");
+    const cameraEntity = rootEntity.createChild("Camera");
+    cameraEntity.addComponent(Camera);
+    cameraEntity.transform.setPosition(0, 0, 10);
+
+    engine.run();
+  });
+
+  it("Default constructor", () => {
+    const burst = new Burst(0.5, new ParticleCompositeCurve(10), 1, 0.01);
+    expect(burst.time).to.equal(0.5);
+    expect(burst.count.evaluate(undefined, undefined)).to.equal(10);
+    expect(burst.cycles).to.equal(1);
+    expect(burst.repeatInterval).to.equal(0.01);
+  });
+
+  it("Constructor with cycles and repeatInterval", () => {
+    const burst = new Burst(0.5, new ParticleCompositeCurve(10), 3, 0.2);
+    expect(burst.time).to.equal(0.5);
+    expect(burst.count.evaluate(undefined, undefined)).to.equal(10);
+    expect(burst.cycles).to.equal(3);
+    expect(burst.repeatInterval).to.equal(0.2);
+  });
+
+  it("Modify cycles and repeatInterval", () => {
+    const burst = new Burst(0, new ParticleCompositeCurve(5), 1, 0.01);
+    burst.cycles = 5;
+    burst.repeatInterval = 0.1;
+    expect(burst.cycles).to.equal(5);
+    expect(burst.repeatInterval).to.equal(0.1);
+  });
+
+  it("Single cycle backward compatible", () => {
+    const scene = engine.sceneManager.activeScene;
+    const entity = scene.createRootEntity("SingleCycle");
+    const renderer = entity.addComponent(ParticleRenderer);
+    const material = new ParticleMaterial(engine);
+    material.baseColor = new Color(1, 1, 1, 1);
+    renderer.setMaterial(material);
+
+    const generator = renderer.generator;
+    generator.useAutoRandomSeed = false;
+    generator.main.duration = 5;
+    generator.main.isLoop = false;
+    generator.main.maxParticles = 1000;
+    generator.main.startLifetime.constant = 10;
+    generator.emission.rateOverTime.constant = 0;
+
+    // Default cycles=1 should behave like original
+    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(10), 1, 0.01));
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+
+    // 20 frames at 100ms = 2s, burst at t=0 fires once
+    updateEngine(engine, 20);
+    expect(generator._getAliveParticleCount()).to.equal(10);
+
+    entity.destroy();
+  });
+
+  it("Burst cycles emit multiple times", () => {
+    const scene = engine.sceneManager.activeScene;
+    const entity = scene.createRootEntity("BurstCycles");
+    const renderer = entity.addComponent(ParticleRenderer);
+    const material = new ParticleMaterial(engine);
+    material.baseColor = new Color(1, 1, 1, 1);
+    renderer.setMaterial(material);
+
+    const generator = renderer.generator;
+    generator.useAutoRandomSeed = false;
+    generator.main.duration = 5;
+    generator.main.isLoop = false;
+    generator.main.maxParticles = 1000;
+    generator.main.startLifetime.constant = 10;
+    generator.emission.rateOverTime.constant = 0;
+
+    // Burst at t=0, count=10, cycles=3, interval=0.5 -> fires at 0s, 0.5s, 1.0s
+    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(10), 3, 0.5));
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+
+    // 15 frames at 100ms = 1.5s, all 3 cycles should have fired
+    updateEngine(engine, 15);
+    expect(generator._getAliveParticleCount()).to.equal(30);
+
+    entity.destroy();
+  });
+
+  it("Burst cycles survive float drift (no skipped cycle)", () => {
+    const scene = engine.sceneManager.activeScene;
+    const entity = scene.createRootEntity("FloatDrift");
+    const renderer = entity.addComponent(ParticleRenderer);
+    const material = new ParticleMaterial(engine);
+    material.baseColor = new Color(1, 1, 1, 1);
+    renderer.setMaterial(material);
+
+    const generator = renderer.generator;
+    generator.useAutoRandomSeed = false;
+    generator.main.duration = 5;
+    generator.main.isLoop = false;
+    generator.main.maxParticles = 1000;
+    generator.main.startLifetime.constant = 10;
+    generator.emission.rateOverTime.constant = 0;
+
+    // interval=0.1 triggers IEEE 754 drift (e.g. 0.1+0.2 != 0.3). Without tolerance in the
+    // cycle-index math, `ceil((startTime - burstTime) / 0.1)` can land at cycle + 1 and
+    // permanently skip a cycle at accumulated integer-multiple times.
+    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(1), 10, 0.1));
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+
+    // 15 frames at 100ms = 1.5s, all 10 cycles (0, 0.1, 0.2, ..., 0.9) must have fired
+    updateEngine(engine, 15);
+    expect(generator._getAliveParticleCount()).to.equal(10);
+
+    entity.destroy();
+  });
+
+  it("Burst cycles=Infinity emits infinitely within duration", () => {
+    const scene = engine.sceneManager.activeScene;
+    const entity = scene.createRootEntity("InfiniteCycles");
+    const renderer = entity.addComponent(ParticleRenderer);
+    const material = new ParticleMaterial(engine);
+    material.baseColor = new Color(1, 1, 1, 1);
+    renderer.setMaterial(material);
+
+    const generator = renderer.generator;
+    generator.useAutoRandomSeed = false;
+    generator.main.duration = 2;
+    generator.main.isLoop = false;
+    generator.main.maxParticles = 1000;
+    generator.main.startLifetime.constant = 10;
+    generator.emission.rateOverTime.constant = 0;
+
+    // cycles=Infinity means unlimited, interval=0.5 -> fires at 0, 0.5, 1.0, 1.5 within duration=2
+    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(5), Infinity, 0.5));
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+
+    // 25 frames at 100ms = 2.5s, should fire 4 times (at 0, 0.5, 1.0, 1.5) = 20 particles
+    updateEngine(engine, 25);
+    expect(generator._getAliveParticleCount()).to.equal(20);
+
+    entity.destroy();
+  });
+});
diff --git a/tests/src/core/particle/LimitVelocityOverLifetime.test.ts b/tests/src/core/particle/LimitVelocityOverLifetime.test.ts
index 91b0a321bb..3bfe8c89ce 100644
--- a/tests/src/core/particle/LimitVelocityOverLifetime.test.ts
+++ b/tests/src/core/particle/LimitVelocityOverLifetime.test.ts
@@ -12,7 +12,7 @@ import {
   CurveKey
 } from "@galacean/engine-core";
 import { Color, Vector3 } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { WebGLEngine } from "@galacean/engine";
 import { LitePhysics } from "@galacean/engine-physics-lite";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
 
diff --git a/tests/src/core/particle/ParticleBoundingBox.test.ts b/tests/src/core/particle/ParticleBoundingBox.test.ts
index 8b4e78b8f5..1f33c6fa10 100644
--- a/tests/src/core/particle/ParticleBoundingBox.test.ts
+++ b/tests/src/core/particle/ParticleBoundingBox.test.ts
@@ -15,7 +15,7 @@ import {
   ParticleStopMode
 } from "@galacean/engine-core";
 import { Color, Vector3 } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { WebGLEngine } from "@galacean/engine";
 import { LitePhysics } from "@galacean/engine-physics-lite";
 import { describe, beforeAll, beforeEach, expect, it } from "vitest";
 
@@ -404,6 +404,73 @@ describe("ParticleBoundingBox", function () {
     );
   });
 
+  it("ShapeTransform-Position", function () {
+    const shape = new BoxShape();
+    shape.position.set(5, 0, 0);
+    particleRenderer.generator.emission.shape = shape;
+
+    // Same as default BoxShape bounds shifted by (5,0,0)
+    testParticleRendererBounds(
+      engine,
+      particleRenderer,
+      { x: 3.086, y: -1.914, z: -26.914 },
+      { x: 6.914, y: 1.914, z: 1.914 },
+      delta
+    );
+  });
+
+  it("ShapeTransform-Rotation", function () {
+    const shape = new BoxShape();
+    shape.size.set(1, 2, 1);
+    shape.rotation.set(0, 0, 90);
+    particleRenderer.generator.emission.shape = shape;
+
+    // size(1,2,1): local pos range (-0.5,-1,-0.5)~(0.5,1,0.5)
+    // rotated 90 Z: x<->y swapped -> (-1,-0.5,-0.5)~(1,0.5,0.5)
+    testParticleRendererBounds(
+      engine,
+      particleRenderer,
+      { x: -2.414, y: -1.914, z: -26.914 },
+      { x: 2.414, y: 1.914, z: 1.914 },
+      delta
+    );
+  });
+
+  it("ShapeTransform-Scale", function () {
+    const shape = new BoxShape();
+    shape.scale.set(3, 1, 1);
+    particleRenderer.generator.emission.shape = shape;
+
+    // Default box pos range (-0.5,-0.5,-0.5)~(0.5,0.5,0.5), X scaled 3x -> (-1.5,...)~(1.5,...)
+    testParticleRendererBounds(
+      engine,
+      particleRenderer,
+      { x: -2.914, y: -1.914, z: -26.914 },
+      { x: 2.914, y: 1.914, z: 1.914 },
+      delta
+    );
+  });
+
+  it("ShapeTransform-Combined", function () {
+    const shape = new BoxShape();
+    shape.position.set(0, 0, 5);
+    shape.rotation.set(0, 0, 90);
+    shape.scale.set(2, 1, 1);
+    particleRenderer.generator.emission.shape = shape;
+
+    // Default size(1,1,1): local (-0.5,-0.5,-0.5)~(0.5,0.5,0.5)
+    // scale(2,1,1) -> (-1,-0.5,-0.5)~(1,0.5,0.5)
+    // rotate 90 Z: x<->y -> (-0.5,-1,-0.5)~(0.5,1,0.5)
+    // + position(0,0,5) -> (-0.5,-1,4.5)~(0.5,1,5.5)
+    testParticleRendererBounds(
+      engine,
+      particleRenderer,
+      { x: -1.914, y: -2.414, z: -21.914 },
+      { x: 1.914, y: 2.414, z: 6.914 },
+      delta
+    );
+  });
+
   it("Transform", function () {
     entity.transform.position.set(1, 2, 3);
     testParticleRendererBounds(
diff --git a/tests/src/core/particle/ParticleRenderer.test.ts b/tests/src/core/particle/ParticleRenderer.test.ts
index dada7b9be0..737631b139 100644
--- a/tests/src/core/particle/ParticleRenderer.test.ts
+++ b/tests/src/core/particle/ParticleRenderer.test.ts
@@ -1,5 +1,5 @@
 import { Camera, ModelMesh, ParticleRenderer, ParticleRenderMode, Scene } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { WebGLEngine } from "@galacean/engine";
 import { beforeAll, describe, expect, it } from "vitest";
 
 describe("ParticleRenderer", () => {
diff --git a/tests/src/core/particle/ParticleShapeTransform.test.ts b/tests/src/core/particle/ParticleShapeTransform.test.ts
new file mode 100644
index 0000000000..d3ac6d2ac6
--- /dev/null
+++ b/tests/src/core/particle/ParticleShapeTransform.test.ts
@@ -0,0 +1,270 @@
+import { BoxShape, SphereShape, ConeShape } from "@galacean/engine-core";
+import { BoundingBox, Rand, Vector3 } from "@galacean/engine-math";
+import { describe, beforeEach, expect, it } from "vitest";
+
+describe("ParticleShapeTransform", function () {
+  const position = new Vector3();
+  const direction = new Vector3();
+  const rand = new Rand(0, 1234);
+  const epsilon = 1e-5;
+
+  describe("Position offset", function () {
+    it("should offset generated position by shape position", function () {
+      const shape = new BoxShape();
+      shape.size.set(0, 0, 0);
+      shape.position.set(3, 5, 7);
+
+      shape._generatePositionAndDirection(rand, 0, position, direction);
+
+      expect(position.x).to.be.closeTo(3, epsilon);
+      expect(position.y).to.be.closeTo(5, epsilon);
+      expect(position.z).to.be.closeTo(7, epsilon);
+    });
+
+    it("should offset position range by shape position", function () {
+      const shape = new BoxShape();
+      shape.size.set(2, 2, 2);
+      shape.position.set(10, 0, 0);
+
+      const bounds = new BoundingBox();
+      shape._getPositionRange(bounds);
+
+      expect(bounds.min.x).to.be.closeTo(9, epsilon);
+      expect(bounds.max.x).to.be.closeTo(11, epsilon);
+      expect(bounds.min.y).to.be.closeTo(-1, epsilon);
+      expect(bounds.max.y).to.be.closeTo(1, epsilon);
+    });
+  });
+
+  describe("Rotation", function () {
+    it("should rotate position range by shape rotation", function () {
+      const shape = new BoxShape();
+      shape.size.set(2, 0, 0);
+      shape.rotation.set(0, 0, 90);
+
+      const bounds = new BoundingBox();
+      shape._getPositionRange(bounds);
+
+      // Local range: (-1,0,0) to (1,0,0), rotated 90 around Z -> (0,-1,0) to (0,1,0)
+      expect(bounds.min.x).to.be.closeTo(0, epsilon);
+      expect(bounds.max.x).to.be.closeTo(0, epsilon);
+      expect(bounds.min.y).to.be.closeTo(-1, epsilon);
+      expect(bounds.max.y).to.be.closeTo(1, epsilon);
+    });
+
+    it("should rotate box position range", function () {
+      const shape = new BoxShape();
+      shape.size.set(2, 4, 2);
+      shape.rotation.set(0, 0, 90);
+
+      const bounds = new BoundingBox();
+      shape._getPositionRange(bounds);
+
+      // Original range: (-1,-2,-1) to (1,2,1)
+      // After 90 Z rotation: x<->y swapped
+      expect(bounds.min.x).to.be.closeTo(-2, epsilon);
+      expect(bounds.max.x).to.be.closeTo(2, epsilon);
+      expect(bounds.min.y).to.be.closeTo(-1, epsilon);
+      expect(bounds.max.y).to.be.closeTo(1, epsilon);
+    });
+
+    it("sphere bounds should be conservative after rotation", function () {
+      const shape = new SphereShape();
+      shape.radius = 2;
+
+      const boundsBefore = new BoundingBox();
+      shape._getPositionRange(boundsBefore);
+      const minBefore = new Vector3();
+      const maxBefore = new Vector3();
+      minBefore.copyFrom(boundsBefore.min);
+      maxBefore.copyFrom(boundsBefore.max);
+
+      shape.rotation.set(45, 30, 60);
+      const boundsAfter = new BoundingBox();
+      shape._getPositionRange(boundsAfter);
+
+      // Arvo rotates the AABB (cube), which expands it. Bounds should be >= original.
+      expect(boundsAfter.min.x).to.be.lessThanOrEqual(minBefore.x + epsilon);
+      expect(boundsAfter.min.y).to.be.lessThanOrEqual(minBefore.y + epsilon);
+      expect(boundsAfter.min.z).to.be.lessThanOrEqual(minBefore.z + epsilon);
+      expect(boundsAfter.max.x).to.be.greaterThanOrEqual(maxBefore.x - epsilon);
+      expect(boundsAfter.max.y).to.be.greaterThanOrEqual(maxBefore.y - epsilon);
+      expect(boundsAfter.max.z).to.be.greaterThanOrEqual(maxBefore.z - epsilon);
+    });
+  });
+
+  describe("Scale", function () {
+    it("should scale generated position", function () {
+      const shape = new BoxShape();
+      shape.size.set(0, 0, 0);
+      shape.position.set(1, 0, 0);
+      shape.scale.set(3, 1, 1);
+
+      shape._generatePositionAndDirection(rand, 0, position, direction);
+
+      // position (0,0,0) scaled then rotated then + position offset (1,0,0)
+      expect(position.x).to.be.closeTo(1, epsilon);
+      expect(position.y).to.be.closeTo(0, epsilon);
+    });
+
+    it("should scale position range", function () {
+      const shape = new BoxShape();
+      shape.size.set(2, 2, 2);
+      shape.scale.set(3, 1, 1);
+
+      const bounds = new BoundingBox();
+      shape._getPositionRange(bounds);
+
+      // Original: (-1,-1,-1) to (1,1,1), scaled X by 3
+      expect(bounds.min.x).to.be.closeTo(-3, epsilon);
+      expect(bounds.max.x).to.be.closeTo(3, epsilon);
+      expect(bounds.min.y).to.be.closeTo(-1, epsilon);
+      expect(bounds.max.y).to.be.closeTo(1, epsilon);
+    });
+
+    it("negative scale should flip and reorder min/max", function () {
+      const shape = new BoxShape();
+      shape.size.set(2, 2, 2);
+      shape.scale.set(-1, 1, 1);
+
+      const bounds = new BoundingBox();
+      shape._getPositionRange(bounds);
+
+      // After negative X scale, reorder ensures min < max
+      expect(bounds.min.x).to.be.closeTo(-1, epsilon);
+      expect(bounds.max.x).to.be.closeTo(1, epsilon);
+    });
+  });
+
+  describe("Combined transform", function () {
+    it("should apply scale then rotation then position", function () {
+      const shape = new BoxShape();
+      shape.size.set(0, 0, 0);
+      shape.position.set(0, 0, 5);
+      shape.rotation.set(0, 90, 0);
+      shape.scale.set(2, 1, 1);
+
+      // Generate from zero-size box at origin
+      shape._generatePositionAndDirection(rand, 0, position, direction);
+
+      // Local pos (0,0,0) -> scale -> (0,0,0) -> rotate -> (0,0,0) -> + offset (0,0,5)
+      expect(position.x).to.be.closeTo(0, epsilon);
+      expect(position.y).to.be.closeTo(0, epsilon);
+      expect(position.z).to.be.closeTo(5, epsilon);
+    });
+  });
+
+  describe("Default transform (no-op fast path)", function () {
+    it("should produce identical results when no transform set", function () {
+      const shape1 = new BoxShape();
+      const shape2 = new BoxShape();
+      shape1.size.set(2, 3, 4);
+      shape2.size.set(2, 3, 4);
+
+      const bounds1 = new BoundingBox();
+      const bounds2 = new BoundingBox();
+
+      shape1._getPositionRange(bounds1);
+      shape2._getPositionRange(bounds2);
+
+      expect(bounds1.min.x).to.be.closeTo(bounds2.min.x, epsilon);
+      expect(bounds1.min.y).to.be.closeTo(bounds2.min.y, epsilon);
+      expect(bounds1.min.z).to.be.closeTo(bounds2.min.z, epsilon);
+      expect(bounds1.max.x).to.be.closeTo(bounds2.max.x, epsilon);
+      expect(bounds1.max.y).to.be.closeTo(bounds2.max.y, epsilon);
+      expect(bounds1.max.z).to.be.closeTo(bounds2.max.z, epsilon);
+    });
+  });
+
+  describe("Direction range", function () {
+    it("should rotate direction range by shape rotation", function () {
+      const shape = new BoxShape();
+      // Default direction range: min=(0,0,-1), max=(0,0,0)
+      shape.rotation.set(90, 0, 0);
+
+      const min = new Vector3();
+      const max = new Vector3();
+      shape._getDirectionRange(min, max);
+
+      // (0,0,-1) rotated 90 around X -> (0,1,0)
+      // Rotated AABB: min=(0,0,0), max=(0,1,0)
+      expect(min.x).to.be.closeTo(0, epsilon);
+      expect(min.y).to.be.closeTo(0, epsilon);
+      expect(min.z).to.be.closeTo(0, epsilon);
+      expect(max.y).to.be.closeTo(1, epsilon);
+    });
+  });
+
+  describe("Clone", function () {
+    // Simulate CloneManager: deepClone calls copyFrom, then _cloneTo
+    function simulateClone(source: BoxShape): BoxShape {
+      const clone = new BoxShape();
+      // @deepClone step: copyFrom on existing Vector3 (preserves constructor-bound callbacks)
+      clone.position.copyFrom(source.position);
+      clone.rotation.copyFrom(source.rotation);
+      clone.scale.copyFrom(source.scale);
+      return clone;
+    }
+
+    it("cloned shape should have correct transform values", function () {
+      const shape = new BoxShape();
+      shape.position.set(1, 2, 3);
+      shape.rotation.set(45, 0, 0);
+      shape.scale.set(2, 2, 2);
+
+      const clone = simulateClone(shape);
+
+      expect(clone.position.x).to.be.closeTo(1, epsilon);
+      expect(clone.position.y).to.be.closeTo(2, epsilon);
+      expect(clone.position.z).to.be.closeTo(3, epsilon);
+      expect(clone.rotation.x).to.be.closeTo(45, epsilon);
+      expect(clone.scale.x).to.be.closeTo(2, epsilon);
+    });
+
+    it("cloned shape should rebuild matrix correctly", function () {
+      const shape = new BoxShape();
+      shape.size.set(2, 0, 0);
+      shape.rotation.set(0, 0, 90);
+
+      const clone = simulateClone(shape);
+      clone.size.set(2, 0, 0);
+
+      const boundsOrig = new BoundingBox();
+      shape._getPositionRange(boundsOrig);
+
+      const boundsClone = new BoundingBox();
+      clone._getPositionRange(boundsClone);
+
+      // Both should have: local (-1,0,0)~(1,0,0) rotated 90Z -> (0,-1,0)~(0,1,0)
+      expect(boundsClone.min.x).to.be.closeTo(boundsOrig.min.x, epsilon);
+      expect(boundsClone.min.y).to.be.closeTo(boundsOrig.min.y, epsilon);
+      expect(boundsClone.max.x).to.be.closeTo(boundsOrig.max.x, epsilon);
+      expect(boundsClone.max.y).to.be.closeTo(boundsOrig.max.y, epsilon);
+    });
+
+    it("modifying clone should not affect original", function () {
+      const shape = new BoxShape();
+      shape.position.set(1, 2, 3);
+
+      const clone = simulateClone(shape);
+      clone.position.set(10, 20, 30);
+
+      expect(shape.position.x).to.be.closeTo(1, epsilon);
+      expect(shape.position.y).to.be.closeTo(2, epsilon);
+      expect(shape.position.z).to.be.closeTo(3, epsilon);
+    });
+
+    it("clone callback should trigger on cloned shape", function () {
+      const shape = new BoxShape();
+      const clone = simulateClone(shape);
+
+      let notified = false;
+      clone._registerOnValueChanged(() => {
+        notified = true;
+      });
+
+      clone.position.x = 10;
+      expect(notified).to.be.true;
+    });
+  });
+});
diff --git a/tests/src/core/particle/ParticleStopResume.test.ts b/tests/src/core/particle/ParticleStopResume.test.ts
deleted file mode 100644
index 0e0db6ac05..0000000000
--- a/tests/src/core/particle/ParticleStopResume.test.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import {
-  Burst,
-  Camera,
-  ParticleCompositeCurve,
-  ParticleRenderer,
-  ParticleStopMode,
-  Scene
-} from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
-import { beforeAll, describe, expect, it } from "vitest";
-
-describe("ParticleGenerator stop/resume timeline", () => {
-  let engine: WebGLEngine;
-  let scene: Scene;
-
-  beforeAll(async () => {
-    engine = await WebGLEngine.create({ canvas: document.createElement("canvas") });
-    scene = engine.sceneManager.activeScene;
-    const root = scene.createRootEntity("root");
-    const camera = root.createChild("Camera");
-    camera.addComponent(Camera);
-    camera.transform.setPosition(0, 0, 10);
-  });
-
-  /**
-   * Drive `generator._update(dt)` directly so we control the timeline.
-   * `ParticleRenderer._update` would call this with `engine.time.deltaTime`,
-   * which is wall-clock and not reproducible.
-   */
-  function tick(generator: any, frames: number, dt: number): void {
-    for (let i = 0; i < frames; i++) {
-      generator._update(dt);
-    }
-  }
-
-  it("rate-over-time: stop -> idle -> play emits a catch-up batch in one frame", () => {
-    const entity = scene.createRootEntity("rate");
-    const renderer = entity.addComponent(ParticleRenderer);
-    const generator = renderer.generator;
-    generator.useAutoRandomSeed = false;
-    generator.main.duration = 1;
-    generator.main.startLifetime.constant = 1;
-    generator.main.maxParticles = 10000;
-    generator.emission.rateOverTime.constant = 100;
-
-    let totalEmitted = 0;
-    const origEmit = (generator as any)._emit.bind(generator);
-    (generator as any)._emit = (playTime: number, count: number) => {
-      totalEmitted += count;
-      origEmit(playTime, count);
-    };
-
-    generator.play();
-    // Run 0.5s at 60fps -> ~50 particles
-    tick(generator, 30, 1 / 60);
-    const emittedDuringPlay = totalEmitted;
-    const playTimeAfterPlay = generator._playTime;
-
-    generator.stop(true, ParticleStopMode.StopEmitting);
-    const playTimeAtStop = generator._playTime;
-    const emittedAtStop = totalEmitted;
-
-    // Idle 4.5s while stopped -> _emit must not run, but _playTime drifts
-    tick(generator, 270, 1 / 60);
-    const playTimeAfterIdle = generator._playTime;
-    const emittedDuringIdle = totalEmitted - emittedAtStop;
-
-    generator.play();
-    // Single frame after resume
-    tick(generator, 1, 1 / 60);
-    const emittedFirstFrameAfterResume = totalEmitted - emittedAtStop;
-
-    entity.destroy();
-
-    // eslint-disable-next-line no-console
-    console.log("[bug-repro/rate]", {
-      emittedDuringPlay,
-      playTimeAfterPlay,
-      playTimeAtStop,
-      playTimeAfterIdle,
-      emittedDuringIdle,
-      emittedFirstFrameAfterResume
-    });
-
-    expect(emittedDuringIdle).toBe(0);
-    // Buggy behavior: emits a large catch-up batch (~ idleSeconds * rate).
-    expect(emittedFirstFrameAfterResume).toBeGreaterThan(100);
-    expect(playTimeAfterIdle - playTimeAtStop).toBeGreaterThan(4);
-  });
-
-  it("burst: stop -> idle -> play replays multiple cycles of bursts", () => {
-    const entity = scene.createRootEntity("burst");
-    const renderer = entity.addComponent(ParticleRenderer);
-    const generator = renderer.generator;
-    generator.useAutoRandomSeed = false;
-    generator.main.duration = 1;
-    generator.main.isLoop = true;
-    generator.main.startLifetime.constant = 1;
-    generator.main.maxParticles = 10000;
-    generator.emission.rateOverTime.constant = 0;
-    generator.emission.addBurst(new Burst(0, new ParticleCompositeCurve(10)));
-
-    let totalEmitted = 0;
-    const origEmit = (generator as any)._emit.bind(generator);
-    (generator as any)._emit = (playTime: number, count: number) => {
-      totalEmitted += count;
-      origEmit(playTime, count);
-    };
-
-    generator.play();
-    // 1 full cycle -> burst at t=0 fires once (10 particles at frame 0)
-    tick(generator, 60, 1 / 60);
-    const emittedAfterOneSecond = totalEmitted;
-
-    generator.stop(true, ParticleStopMode.StopEmitting);
-    const playTimeAtStop = generator._playTime;
-    const emittedAtStop = totalEmitted;
-
-    // Idle 4 cycles
-    tick(generator, 240, 1 / 60);
-    const playTimeAfterIdle = generator._playTime;
-
-    generator.play();
-    tick(generator, 1, 1 / 60); // first frame after resume
-    const emittedFirstFrameAfterResume = totalEmitted - emittedAtStop;
-
-    entity.destroy();
-
-    // eslint-disable-next-line no-console
-    console.log("[bug-repro/burst]", {
-      emittedAfterOneSecond,
-      playTimeAtStop,
-      playTimeAfterIdle,
-      emittedFirstFrameAfterResume
-    });
-
-    // After fix this should be 0 (next burst at t=0 of the new cycle hasn't reached yet).
-    // Buggy behavior: replays the burst once because `_currentBurstIndex` is 0 and
-    // `_emitBySubBurst(lastPlayTime, playTime, ...)` sees burst.time === startTime.
-    expect(emittedFirstFrameAfterResume).toBe(10);
-  });
-});
diff --git a/tests/src/core/particle/ParticleTextureSheetAnimation.test.ts b/tests/src/core/particle/ParticleTextureSheetAnimation.test.ts
index 127fb5d511..934d1f1082 100644
--- a/tests/src/core/particle/ParticleTextureSheetAnimation.test.ts
+++ b/tests/src/core/particle/ParticleTextureSheetAnimation.test.ts
@@ -1,6 +1,6 @@
 import { Camera, ParticleRenderer, Scene } from "@galacean/engine-core";
 import { Vector2 } from "@galacean/engine-math";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { WebGLEngine } from "@galacean/engine";
 import { beforeAll, describe, expect, it } from "vitest";
 
 describe("TextureSheetAnimation Test", () => {
diff --git a/tests/src/core/particle/RateOverDistance.test.ts b/tests/src/core/particle/RateOverDistance.test.ts
index 483892f109..82ff55c068 100644
--- a/tests/src/core/particle/RateOverDistance.test.ts
+++ b/tests/src/core/particle/RateOverDistance.test.ts
@@ -301,6 +301,62 @@ describe("EmissionModule rateOverDistance", () => {
     entity.destroy();
   });
 
+  it("does not burst on play() after non-loop auto-stop with movement", () => {
+    // Auto-stop path: _update sets _isPlaying=false directly without going
+    // through stop(), so the old fix that invalidated baseline in stop() only
+    // missed this. play() resync must cover it.
+    const { entity, renderer } = buildEmitter(engine, "no-burst-on-autostop-replay");
+    const generator = renderer.generator;
+    generator.main.duration = 0.05; // 50ms — one 100ms tick pushes past it
+    generator.main.isLoop = false;
+    generator.emission.rateOverDistance.constant = 10;
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+    tick(engine, elapsed); // _playTime=0.1 > duration → auto-stops
+    expect(generator._getAliveParticleCount()).to.eq(0);
+    //@ts-ignore
+    expect((generator as any)._isPlaying).to.eq(false);
+
+    // Emitter moves while auto-stopped, then replay via play() (no stop call).
+    entity.transform.setPosition(3, 0, 0);
+    generator.play();
+
+    tick(engine, elapsed);
+    expect(generator._getAliveParticleCount(), "auto-stop replay must resync, not burst 30").to.eq(0);
+
+    entity.destroy();
+  });
+
+  it("does not burst when emission.enabled is toggled off, moved, then on", () => {
+    // emission.enabled=false skips _emit entirely; toggling back to true must
+    // resync the baseline at the new position so the disabled interval doesn't
+    // count as emission distance.
+    const { entity, renderer } = buildEmitter(engine, "no-burst-on-enabled-toggle");
+    const generator = renderer.generator;
+    generator.main.duration = 100; // long-running, isolate from auto-stop
+    generator.main.isLoop = true;
+    generator.emission.rateOverDistance.constant = 10;
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+    tick(engine, elapsed); // baseline sync at (0,0,0)
+
+    generator.emission.enabled = false;
+    entity.transform.setPosition(3, 0, 0);
+    generator.emission.enabled = true;
+
+    tick(engine, elapsed);
+    expect(generator._getAliveParticleCount(), "enabled toggle must resync, not burst 30").to.eq(0);
+
+    // Subsequent movement still emits normally.
+    entity.transform.setPosition(4, 0, 0);
+    tick(engine, elapsed);
+    expect(generator._getAliveParticleCount()).to.eq(10);
+
+    entity.destroy();
+  });
+
   it("returns actual emitted count when buffer is full", () => {
     // Documents the `_emit` return-value contract that lets distance emission detect
     // mid-loop buffer exhaustion (and drop residual accumulator to avoid spinning
@@ -323,4 +379,48 @@ describe("EmissionModule rateOverDistance", () => {
 
     entity.destroy();
   });
+
+  it("does not extrapolate past lastPos when a rate hike pays out previous carry", () => {
+    // Trigger: rate climbs between frames while the accumulator already carries
+    // sub-interval distance from the lower-rate era. The new emitInterval is
+    // small enough that `residual / moveLength > 1` after the count subtraction —
+    // initial subFrameAge clamps to 1.0, but a naive `+= ageStep` would let later
+    // iterations exceed 1 and extrapolate emitPos past lastPos in opposite
+    // direction of motion (and emitTime to before lastPlayTime).
+    const { entity, renderer } = buildEmitter(engine, "rate-hike-clamp");
+    const generator = renderer.generator;
+    generator.main.simulationSpace = ParticleSimulationSpace.World;
+    generator.emission.rateOverDistance.constant = 0.5; // interval = 2
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+    tick(engine, elapsed); // baseline at (0,0,0)
+
+    // Move 1.5 units under low rate → accumulator carries 1.5, no emit.
+    entity.transform.setPosition(1.5, 0, 0);
+    tick(engine, elapsed);
+    expect(generator._getAliveParticleCount()).to.eq(0);
+
+    // Bump rate: interval drops to 0.2. Tiny additional move (0.05) pushes
+    // accumulator to 1.55 → count = 7, residual ≈ 0.15, moveLength = 0.05,
+    // ratio = 3.0 (well above 1).
+    generator.emission.rateOverDistance.constant = 5;
+    entity.transform.setPosition(1.55, 0, 0);
+    tick(engine, elapsed);
+    expect(generator._getAliveParticleCount()).to.eq(7);
+
+    //@ts-ignore - reach into instance buffer to verify positions stay in [lastPos, currentPos]
+    const verts = (generator as any)._instanceVertices as Float32Array;
+    const stride = 42;
+    for (let i = 0; i < 7; i++) {
+      const x = verts[i * stride + 27];
+      // Without the in-loop clamp this would be e.g. -1.0, -1.2, ... (extrapolated
+      // far behind lastPos.x = 1.5). With the clamp every particle lives within
+      // the legitimate frame window [lastPos.x, currentPos.x] = [1.5, 1.55].
+      expect(x).to.be.greaterThanOrEqual(1.5 - 1e-4);
+      expect(x).to.be.lessThanOrEqual(1.55 + 1e-4);
+    }
+
+    entity.destroy();
+  });
 });
diff --git a/tests/src/core/particle/RateOverTimeReplay.test.ts b/tests/src/core/particle/RateOverTimeReplay.test.ts
new file mode 100644
index 0000000000..8973117d29
--- /dev/null
+++ b/tests/src/core/particle/RateOverTimeReplay.test.ts
@@ -0,0 +1,138 @@
+import { Camera, Engine, Entity, ParticleMaterial, ParticleRenderer, ParticleStopMode } from "@galacean/engine-core";
+import { Color } from "@galacean/engine-math";
+import { WebGLEngine } from "@galacean/engine";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+function tick(engine: Engine, times: { value: number }, deltaMs: number = 100): void {
+  //@ts-ignore
+  engine._vSyncCount = Infinity;
+  //@ts-ignore
+  engine._time._lastSystemTime = 0;
+  performance.now = function () {
+    times.value += deltaMs;
+    return times.value;
+  };
+  engine.update();
+}
+
+function buildEmitter(engine: Engine, name: string): { entity: Entity; renderer: ParticleRenderer } {
+  const scene = engine.sceneManager.activeScene;
+  const entity = scene.createRootEntity(name);
+  const renderer = entity.addComponent(ParticleRenderer);
+  const material = new ParticleMaterial(engine);
+  material.baseColor = new Color(1, 1, 1, 1);
+  renderer.setMaterial(material);
+
+  const generator = renderer.generator;
+  generator.useAutoRandomSeed = false;
+  generator.main.maxParticles = 1000;
+  generator.main.startLifetime.constant = 100;
+  generator.emission.rateOverTime.constant = 0;
+  generator.emission.rateOverDistance.constant = 0;
+  return { entity, renderer };
+}
+
+describe("EmissionModule rateOverTime replay/resume", () => {
+  let engine: Engine;
+  let elapsed: { value: number };
+
+  beforeAll(async function () {
+    engine = await WebGLEngine.create({ canvas: document.createElement("canvas") });
+    const scene = engine.sceneManager.activeScene;
+    const cameraEntity = scene.createRootEntity("Camera");
+    cameraEntity.addComponent(Camera);
+    cameraEntity.transform.setPosition(0, 0, 10);
+    engine.run();
+    elapsed = { value: 0 };
+  });
+
+  afterAll(function () {
+    engine.destroy();
+  });
+
+  it("does not catch-up burst on play() after non-loop auto-stop", () => {
+    // _update advances _playTime every frame regardless of _isPlaying (the
+    // particle-retire path needs it). _frameRateTime was only reset by _reset
+    // (= stop(Clear)) before this fix. So auto-stop + waiting + bare play()
+    // used to unwind the entire stopped interval into a single-frame catch-up.
+    const { entity, renderer } = buildEmitter(engine, "rot-autostop-replay");
+    const generator = renderer.generator;
+    generator.main.duration = 0.05;
+    generator.main.isLoop = false;
+    generator.emission.rateOverTime.constant = 10; // 10/sec
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+    tick(engine, elapsed); // first play; _playTime=0.1 > duration → auto-stops
+    const baseline = generator._getAliveParticleCount();
+    //@ts-ignore
+    expect((generator as any)._isPlaying).to.eq(false);
+
+    // 3 seconds of idle frames — _playTime keeps growing, _frameRateTime stuck.
+    for (let i = 0; i < 30; i++) tick(engine, elapsed);
+
+    generator.play();
+    tick(engine, elapsed);
+
+    // Without the fix this dumps ~30 catch-up particles in one frame.
+    const delta = generator._getAliveParticleCount() - baseline;
+    expect(delta, "auto-stop replay must not catch up the stopped interval").to.be.lessThan(5);
+
+    entity.destroy();
+  });
+
+  it("does not catch-up burst when rateOverTime flips 0 → N mid-play", () => {
+    // rate=0 for an interval: _emitByRateOverTime used to return without
+    // touching _frameRateTime. When rate flips back positive, cumulativeTime =
+    // playTime - _frameRateTime spans the rate-0 interval and unwinds it.
+    const { entity, renderer } = buildEmitter(engine, "rot-rate-transition");
+    const generator = renderer.generator;
+    generator.main.duration = 100;
+    generator.main.isLoop = true;
+    generator.emission.rateOverTime.constant = 10;
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+    tick(engine, elapsed); // emit ~1 particle
+    const baseline = generator._getAliveParticleCount();
+
+    // Drop rate to 0 for ~3 seconds.
+    generator.emission.rateOverTime.constant = 0;
+    for (let i = 0; i < 30; i++) tick(engine, elapsed);
+    expect(generator._getAliveParticleCount()).to.eq(baseline);
+
+    // Restore rate. The next tick must only contribute its own ~0.1s worth (~1 particle),
+    // not ~30 catch-up particles from the rate-0 interval.
+    generator.emission.rateOverTime.constant = 10;
+    tick(engine, elapsed);
+    const delta = generator._getAliveParticleCount() - baseline;
+    expect(delta, "rate 0→N must not unwind the rate-0 interval").to.be.lessThan(5);
+
+    entity.destroy();
+  });
+
+  it("does not catch-up burst when emission.enabled is toggled off → on", () => {
+    // Same root: emission.enabled=false skips _emit; toggling back to true
+    // must drop the stale _frameRateTime cursor too, not just the distance baseline.
+    const { entity, renderer } = buildEmitter(engine, "rot-enabled-toggle");
+    const generator = renderer.generator;
+    generator.main.duration = 100;
+    generator.main.isLoop = true;
+    generator.emission.rateOverTime.constant = 10;
+
+    generator.stop(true, ParticleStopMode.StopEmittingAndClear);
+    generator.play();
+    tick(engine, elapsed);
+    const baseline = generator._getAliveParticleCount();
+
+    generator.emission.enabled = false;
+    for (let i = 0; i < 30; i++) tick(engine, elapsed);
+    generator.emission.enabled = true;
+
+    tick(engine, elapsed);
+    const delta = generator._getAliveParticleCount() - baseline;
+    expect(delta, "enabled toggle must not unwind the disabled interval").to.be.lessThan(5);
+
+    entity.destroy();
+  });
+});
diff --git a/tests/src/loader/KTX2Loader.test.ts b/tests/src/loader/KTX2Loader.test.ts
index 93cd915e16..d4e645ec2d 100644
--- a/tests/src/loader/KTX2Loader.test.ts
+++ b/tests/src/loader/KTX2Loader.test.ts
@@ -1,6 +1,6 @@
 import { GLCapabilityType, Texture2D, TextureFormat } from "@galacean/engine-core";
 import { KTX2Loader } from "@galacean/engine-loader";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { WebGLEngine } from "@galacean/engine";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 let engine: WebGLEngine;
diff --git a/tests/src/loader/PrefabResource.test.ts b/tests/src/loader/PrefabResource.test.ts
index 9555b9f60d..24088c2932 100644
--- a/tests/src/loader/PrefabResource.test.ts
+++ b/tests/src/loader/PrefabResource.test.ts
@@ -1,8 +1,8 @@
 import { expect, beforeAll, afterAll, describe, it } from "vitest";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
-import type { IHierarchyFile } from "@galacean/engine-loader";
+import { WebGLEngine } from "@galacean/engine";
 import { Loader, MeshRenderer, Script } from "@galacean/engine-core";
 import { PrefabParser } from "../../../packages/loader/src/prefab/PrefabParser";
+import type { PrefabFile } from "../../../packages/loader/src/schema/PrefabSchema";
 
 let engine: WebGLEngine;
 
@@ -11,8 +11,22 @@ class DiceScript extends Script {
   numMesh: MeshRenderer = null;
 }
 
+class OverrideCallScript extends Script {
+  value = "";
+  receivedArgs: string[] = [];
+
+  appendSuffix(suffix: string): void {
+    this.value += suffix;
+  }
+
+  captureResolvedArgs(...args: string[]): void {
+    this.receivedArgs = args;
+  }
+}
+
 Loader.registerClass("MeshRenderer", MeshRenderer);
 Loader.registerClass("DiceScript", DiceScript);
+Loader.registerClass("OverrideCallScript", OverrideCallScript);
 
 beforeAll(async () => {
   const canvas = document.createElement("canvas");
@@ -26,22 +40,27 @@ afterAll(() => {
 });
 
 describe("PrefabResource refCount", () => {
+  it("should reject prefab data with an unsupported version", () => {
+    const prefabData = {
+      version: "1.0",
+      refs: [],
+      entities: [{ name: "root" }],
+      components: [],
+      root: 0
+    } as any;
+
+    expect(() => PrefabParser.parse(engine, "invalid.prefab", prefabData)).toThrow(
+      'Unsupported prefab format version "1.0". Expected "2.0".'
+    );
+  });
+
   it("should increase and decrease with instantiated entities", async () => {
-    const prefabData: IHierarchyFile = {
-      entities: [
-        {
-          id: "0",
-          name: "root",
-          components: [],
-          children: ["1"]
-        },
-        {
-          id: "1",
-          name: "child",
-          parent: "0",
-          components: []
-        }
-      ]
+    const prefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root", children: [1] }, { name: "child" }],
+      components: [],
+      root: 0
     };
 
     const prefab = await PrefabParser.parse(engine, "prefab.json", prefabData);
@@ -60,55 +79,584 @@ describe("PrefabResource refCount", () => {
     instance2.destroy();
     expect(prefab.refCount).toBe(0);
   });
+
+  it("should support destroy then re-instantiate cycle", async () => {
+    const prefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root", children: [1] }, { name: "child" }],
+      components: [],
+      root: 0
+    };
+
+    const prefab = await PrefabParser.parse(engine, "lifecycle.prefab", prefabData);
+
+    // First cycle: instantiate → destroy
+    const instance1 = prefab.instantiate();
+    expect(instance1.name).toBe("root");
+    expect(instance1.children[0].name).toBe("child");
+    expect(prefab.refCount).toBe(2);
+
+    instance1.destroy();
+    expect(prefab.refCount).toBe(0);
+
+    // Second cycle: re-instantiate from same prefab
+    const instance2 = prefab.instantiate();
+    expect(instance2.name).toBe("root");
+    expect(instance2.children[0].name).toBe("child");
+    expect(prefab.refCount).toBe(2);
+
+    // Verify independence from destroyed instance
+    expect(instance2).not.toBe(instance1);
+
+    instance2.destroy();
+    expect(prefab.refCount).toBe(0);
+  });
+
+  it("should count instances when prefab root comes from a nested prefab instance", async () => {
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "nestedRoot", children: [1] }, { name: "nestedChild" }],
+      components: [],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested-root-instance.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested-root-instance.prefab"] = nestedPrefab;
+
+    try {
+      const outerPrefabData: PrefabFile = {
+        version: "2.0",
+        refs: [{ url: "nested-root-instance.prefab" }],
+        entities: [{ instance: { asset: 0 } }],
+        components: [],
+        root: 0
+      };
+
+      const outerPrefab = await PrefabParser.parse(engine, "outer-root-instance.prefab", outerPrefabData);
+
+      expect(outerPrefab.refCount).toBe(0);
+
+      const instance1 = outerPrefab.instantiate();
+      const instance2 = outerPrefab.instantiate();
+
+      expect(outerPrefab.refCount).toBe(2);
+
+      instance1.destroy();
+      expect(outerPrefab.refCount).toBe(1);
+
+      instance2.destroy();
+      expect(outerPrefab.refCount).toBe(0);
+    } finally {
+      // @ts-ignore
+      delete engine.resourceManager._objectPool["nested-root-instance.prefab"];
+    }
+  });
 });
 
-describe("Cross-prefab IComponentRef (path-based)", () => {
-  it("should resolve component ref inside nested prefab instance via entityPath", async () => {
-    // 1. nested prefab (dice.prefab): single root entity with MeshRenderer
-    const nestedPrefabData: IHierarchyFile = {
+describe("$ref null guard in Prefab mode", () => {
+  it("should not add null to dependence assets when $ref resolves to null", async () => {
+    const prefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "missing-asset.png" }],
+      entities: [{ name: "root", components: [0] }],
+      components: [{ type: "DiceScript", props: { skinMesh: { $ref: 0 } } }],
+      root: 0
+    };
+
+    const prefab = await PrefabParser.parse(engine, "test.prefab", prefabData);
+    // @ts-ignore — access private field for verification
+    expect(prefab._dependenceAssets.size).toBe(0);
+
+    // Verify the component property was actually resolved to null (not skipped)
+    const root = prefab.instantiate();
+    const script = root.getComponent(DiceScript);
+    expect(script.skinMesh).toBeNull();
+    root.destroy();
+  });
+});
+
+describe("Prefab instance overrides", () => {
+  it("should throw a clear error when prefab instance asset ref index is out of range", async () => {
+    const prefabData = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "outerRoot", children: [1] }, { instance: { asset: 0 } }],
+      components: [],
+      root: 0
+    } as any;
+
+    await expect(PrefabParser.parse(engine, "invalid-ref.prefab", prefabData)).rejects.toThrow(
+      "HierarchyParser: invalid ref index 0 for instance.asset"
+    );
+  });
+
+  it("should apply entityProps overrides to nested prefab entities", async () => {
+    // Nested prefab: root → child
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "originalRoot", children: [1] }, { name: "originalChild" }],
+      components: [],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested.prefab"] = nestedPrefab;
+
+    // Outer prefab with instance overrides: rename child entity
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "nested.prefab" }],
+      entities: [
+        { name: "outerRoot", children: [1] },
+        {
+          instance: {
+            asset: 0,
+            overrides: {
+              entityProps: [
+                { path: [], name: "renamedRoot" },
+                { path: [0], name: "renamedChild", isActive: false }
+              ]
+            }
+          }
+        }
+      ],
+      components: [],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const instanceEntity = root.children[0];
+    expect(instanceEntity.name).toBe("renamedRoot");
+    expect(instanceEntity.children[0].name).toBe("renamedChild");
+    expect(instanceEntity.children[0].isActive).toBe(false);
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["nested.prefab"];
+  });
+
+  it("should override component props via componentProps", async () => {
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root", components: [0] }],
+      components: [{ type: "MeshRenderer" }],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested-cp.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested-cp.prefab"] = nestedPrefab;
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "nested-cp.prefab" }],
       entities: [
+        { name: "outerRoot", children: [1] },
         {
-          id: "0",
-          name: "diceRoot",
-          components: [{ id: "mesh-comp", class: "MeshRenderer" }],
-          children: []
+          instance: {
+            asset: 0,
+            overrides: {
+              componentProps: [{ path: [], selector: { type: "MeshRenderer", index: 0 }, props: { enabled: false } }]
+            }
+          }
         }
-      ]
+      ],
+      components: [],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer-cp.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const instanceEntity = root.children[0];
+    const meshRenderer = instanceEntity.getComponent(MeshRenderer);
+    expect(meshRenderer.enabled).toBe(false);
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["nested-cp.prefab"];
+  });
+
+  it("should apply component override props and calls from the same schema", async () => {
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root", components: [0] }],
+      components: [{ type: "OverrideCallScript" }],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested-calls.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested-calls.prefab"] = nestedPrefab;
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "nested-calls.prefab" }],
+      entities: [
+        { name: "outerRoot", children: [1] },
+        {
+          instance: {
+            asset: 0,
+            overrides: {
+              componentProps: [
+                {
+                  path: [],
+                  selector: { type: "OverrideCallScript", index: 0 },
+                  props: { value: "base" },
+                  calls: [{ method: "captureResolvedArgs", args: ["override"] }]
+                }
+              ]
+            }
+          }
+        }
+      ],
+      components: [],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer-calls.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const instanceEntity = root.children[0];
+    const overrideScript = instanceEntity.getComponent(OverrideCallScript);
+    expect(overrideScript.value).toBe("base");
+    expect(overrideScript.receivedArgs).toEqual(["override"]);
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["nested-calls.prefab"];
+  });
+
+  it("should add components via addedComponents", async () => {
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root" }],
+      components: [],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested-ac.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested-ac.prefab"] = nestedPrefab;
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "nested-ac.prefab" }],
+      entities: [
+        { name: "outerRoot", children: [1] },
+        {
+          instance: {
+            asset: 0,
+            overrides: {
+              addedComponents: [{ target: [], component: 0 }]
+            }
+          }
+        }
+      ],
+      components: [
+        {
+          type: "OverrideCallScript",
+          props: { value: "base" },
+          calls: [{ method: "captureResolvedArgs", args: ["added"] }]
+        }
+      ],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer-ac.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const instanceEntity = root.children[0];
+    const overrideScript = instanceEntity.getComponent(OverrideCallScript);
+    expect(overrideScript).not.toBeNull();
+    expect(overrideScript.value).toBe("base");
+    expect(overrideScript.receivedArgs).toEqual(["added"]);
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["nested-ac.prefab"];
+  });
+
+  it("should add entities via addedEntities", async () => {
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root" }],
+      components: [],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested-ae.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested-ae.prefab"] = nestedPrefab;
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "nested-ae.prefab" }],
+      entities: [
+        { name: "outerRoot", children: [1] },
+        {
+          instance: {
+            asset: 0,
+            overrides: {
+              addedEntities: [{ parent: [] as number[], entity: 2 }]
+            }
+          }
+        },
+        {
+          name: "addedChild",
+          position: [1, 2, 3] as [number, number, number],
+          components: [0]
+        }
+      ],
+      components: [
+        {
+          type: "OverrideCallScript",
+          props: { value: "base" },
+          calls: [{ method: "captureResolvedArgs", args: ["inline"] }]
+        }
+      ],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer-ae.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const instanceEntity = root.children[0];
+    expect(instanceEntity.children.length).toBe(1);
+    const addedChild = instanceEntity.children[0];
+    expect(addedChild.name).toBe("addedChild");
+    expect(addedChild.transform.position.x).toBe(1);
+    expect(addedChild.transform.position.y).toBe(2);
+    expect(addedChild.transform.position.z).toBe(3);
+    const overrideScript = addedChild.getComponent(OverrideCallScript);
+    expect(overrideScript.value).toBe("base");
+    expect(overrideScript.receivedArgs).toEqual(["inline"]);
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["nested-ae.prefab"];
+  });
+
+  it("should remove entities via removedEntities", async () => {
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root", children: [1] }, { name: "child" }],
+      components: [],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested-re.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested-re.prefab"] = nestedPrefab;
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "nested-re.prefab" }],
+      entities: [
+        { name: "outerRoot", children: [1] },
+        {
+          instance: {
+            asset: 0,
+            overrides: {
+              removedEntities: [[0]]
+            }
+          }
+        }
+      ],
+      components: [],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer-re.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const instanceEntity = root.children[0];
+    expect(instanceEntity.children.length).toBe(0);
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["nested-re.prefab"];
+  });
+
+  it("should remove multiple sibling entities via removedEntities", async () => {
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root", children: [1, 2, 3] }, { name: "A" }, { name: "B" }, { name: "C" }],
+      components: [],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested-re-multi.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested-re-multi.prefab"] = nestedPrefab;
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "nested-re-multi.prefab" }],
+      entities: [
+        { name: "outerRoot", children: [1] },
+        {
+          instance: {
+            asset: 0,
+            overrides: {
+              removedEntities: [[0], [2]]
+            }
+          }
+        }
+      ],
+      components: [],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer-re-multi.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const instanceEntity = root.children[0];
+    expect(instanceEntity.children.length).toBe(1);
+    expect(instanceEntity.children[0].name).toBe("B");
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["nested-re-multi.prefab"];
+  });
+
+  it("should remove multiple components of same type via removedComponents", async () => {
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root", components: [0, 1, 2] }],
+      components: [{ type: "MeshRenderer" }, { type: "MeshRenderer" }, { type: "MeshRenderer" }],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested-rc-multi.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested-rc-multi.prefab"] = nestedPrefab;
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "nested-rc-multi.prefab" }],
+      entities: [
+        { name: "outerRoot", children: [1] },
+        {
+          instance: {
+            asset: 0,
+            overrides: {
+              removedComponents: [
+                {
+                  path: [],
+                  selectors: [
+                    { type: "MeshRenderer", index: 0 },
+                    { type: "MeshRenderer", index: 2 }
+                  ]
+                }
+              ]
+            }
+          }
+        }
+      ],
+      components: [],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer-rc-multi.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const instanceEntity = root.children[0];
+    const buffer: MeshRenderer[] = [];
+    instanceEntity.getComponents(MeshRenderer, buffer);
+    expect(buffer.length).toBe(1);
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["nested-rc-multi.prefab"];
+  });
+
+  it("should remove components via removedComponents", async () => {
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "root", components: [0] }],
+      components: [{ type: "MeshRenderer" }],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "nested-rc.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["nested-rc.prefab"] = nestedPrefab;
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "nested-rc.prefab" }],
+      entities: [
+        { name: "outerRoot", children: [1] },
+        {
+          instance: {
+            asset: 0,
+            overrides: {
+              removedComponents: [{ path: [], selectors: [{ type: "MeshRenderer", index: 0 }] }]
+            }
+          }
+        }
+      ],
+      components: [],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "outer-rc.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+
+    const instanceEntity = root.children[0];
+    const meshRenderer = instanceEntity.getComponent(MeshRenderer);
+    expect(meshRenderer).toBeNull();
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["nested-rc.prefab"];
+  });
+});
+
+describe("Cross-prefab $component ref", () => {
+  it("should resolve component ref inside nested prefab instance", async () => {
+    // 1. nested prefab (dice.prefab): single root entity with MeshRenderer
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "diceRoot", components: [0] }],
+      components: [{ type: "MeshRenderer" }],
+      root: 0
     };
     const nestedPrefab = await PrefabParser.parse(engine, "dice.prefab", nestedPrefabData);
     // @ts-ignore — register to resourceManager so getResourceByRef can find it
     engine.resourceManager._objectPool["dice.prefab"] = nestedPrefab;
 
     // 2. outer prefab (DiceNode.prefab)
-    //    resolved tree: DiceNode(root=[0]) -> [0]dice(nested)
-    //    skinMesh crosses nested prefab boundary via entityPath
-    const outerPrefabData: IHierarchyFile = {
+    //    Entity 0: DiceNode (root) — has DiceScript referencing entity 1's MeshRenderer
+    //    Entity 1: dice (nested prefab instance)
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "dice.prefab" }],
       entities: [
+        { name: "DiceNode", children: [1], components: [0] },
         {
-          id: "root",
-          name: "DiceNode",
-          components: [
-            {
-              id: "script-comp",
-              class: "DiceScript",
-              props: {
-                skinMesh: { entityPath: [0, 0], componentType: "MeshRenderer", componentIndex: 0 }
-              }
-            }
-          ],
-          children: ["dice-inst"]
-        },
+          instance: {
+            asset: 0,
+            overrides: { entityProps: [{ path: [], name: "dice" }] }
+          }
+        }
+      ],
+      components: [
         {
-          id: "dice-inst",
-          name: "dice",
-          parent: "root",
-          components: [],
-          assetUrl: "dice.prefab",
-          modifications: [],
-          removedEntities: [],
-          removedComponents: []
+          type: "DiceScript",
+          props: {
+            skinMesh: { $component: { entity: [1], type: "MeshRenderer", index: 0 } }
+          }
         }
-      ]
+      ],
+      root: 0
     };
 
     const outerPrefab = await PrefabParser.parse(engine, "DiceNode.prefab", outerPrefabData);
@@ -126,55 +674,44 @@ describe("Cross-prefab IComponentRef (path-based)", () => {
   });
 
   it("should resolve both local and cross-prefab refs, and survive clone independently", async () => {
-    const nestedPrefabData: IHierarchyFile = {
-      entities: [
-        {
-          id: "0",
-          name: "diceRoot",
-          components: [{ id: "mesh-comp", class: "MeshRenderer" }],
-          children: []
-        }
-      ]
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "diceRoot", components: [0] }],
+      components: [{ type: "MeshRenderer" }],
+      root: 0
     };
     const nestedPrefab = await PrefabParser.parse(engine, "dice.prefab", nestedPrefabData);
     // @ts-ignore
     engine.resourceManager._objectPool["dice.prefab"] = nestedPrefab;
 
-    // resolved tree: DiceNode(root=[0]) -> [0]numCube, [1]dice(nested)
-    const outerPrefabData: IHierarchyFile = {
+    // Entity 0: DiceNode (root) — DiceScript with numMesh + skinMesh
+    // Entity 1: numCube — local entity with MeshRenderer
+    // Entity 2: dice — nested prefab instance
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "dice.prefab" }],
       entities: [
+        { name: "DiceNode", children: [1, 2], components: [0] },
+        { name: "numCube", components: [1] },
         {
-          id: "root",
-          name: "DiceNode",
-          components: [
-            {
-              id: "script-comp",
-              class: "DiceScript",
-              props: {
-                numMesh: { entityPath: [0, 0], componentType: "MeshRenderer", componentIndex: 0 },
-                skinMesh: { entityPath: [0, 1], componentType: "MeshRenderer", componentIndex: 0 }
-              }
-            }
-          ],
-          children: ["num-cube", "dice-inst"]
-        },
+          instance: {
+            asset: 0,
+            overrides: { entityProps: [{ path: [], name: "dice" }] }
+          }
+        }
+      ],
+      components: [
         {
-          id: "num-cube",
-          name: "numCube",
-          parent: "root",
-          components: [{ id: "num-mesh-comp", class: "MeshRenderer" }]
+          type: "DiceScript",
+          props: {
+            numMesh: { $component: { entity: [1], type: "MeshRenderer", index: 0 } },
+            skinMesh: { $component: { entity: [2], type: "MeshRenderer", index: 0 } }
+          }
         },
-        {
-          id: "dice-inst",
-          name: "dice",
-          parent: "root",
-          components: [],
-          assetUrl: "dice.prefab",
-          modifications: [],
-          removedEntities: [],
-          removedComponents: []
-        }
-      ]
+        { type: "MeshRenderer" }
+      ],
+      root: 0
     };
 
     const outerPrefab = await PrefabParser.parse(engine, "DiceNode.prefab", outerPrefabData);
@@ -206,4 +743,100 @@ describe("Cross-prefab IComponentRef (path-based)", () => {
     // @ts-ignore
     delete engine.resourceManager._objectPool["dice.prefab"];
   });
+
+  it("should resolve $entity into prefab instance deep child", async () => {
+    // nested prefab: root with a child "inner"
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [{ name: "nestedRoot", children: [1] }, { name: "inner" }],
+      components: [],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "deep-entity-nested.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["deep-entity-nested.prefab"] = nestedPrefab;
+
+    // outer prefab: DiceScript.skinMesh is Entity (we reuse skinMesh field as any Entity holder via getComponent)
+    // We need a script holding an Entity ref — reuse OverrideCallScript? It doesn't have an Entity field.
+    // Use DiceScript but expose a targetEntity through a separate Script below.
+    class EntityRefScript extends Script {
+      target: Entity = null;
+    }
+    Loader.registerClass("EntityRefScript", EntityRefScript);
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "deep-entity-nested.prefab" }],
+      entities: [{ name: "outerRoot", children: [1], components: [0] }, { instance: { asset: 0 } }],
+      components: [
+        {
+          type: "EntityRefScript",
+          props: {
+            // Reference entities[1]'s child at path [0] — the "inner" entity inside the prefab instance
+            target: { $entity: [1, 0] }
+          }
+        }
+      ],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "deep-entity-outer.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+    const script = root.getComponent(EntityRefScript);
+
+    expect(script.target).not.toBeNull();
+    expect(script.target.name).toBe("inner");
+    // Confirm it's really the child inside the prefab instance
+    expect(script.target.parent).toBe(root.children[0]);
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["deep-entity-nested.prefab"];
+  });
+
+  it("should resolve $component into prefab instance deep child component", async () => {
+    // nested prefab: root with child "inner" holding a MeshRenderer
+    const nestedPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [],
+      entities: [
+        { name: "nestedRoot", children: [1] },
+        { name: "inner", components: [0] }
+      ],
+      components: [{ type: "MeshRenderer" }],
+      root: 0
+    };
+    const nestedPrefab = await PrefabParser.parse(engine, "deep-comp-nested.prefab", nestedPrefabData);
+    // @ts-ignore
+    engine.resourceManager._objectPool["deep-comp-nested.prefab"] = nestedPrefab;
+
+    const outerPrefabData: PrefabFile = {
+      version: "2.0",
+      refs: [{ url: "deep-comp-nested.prefab" }],
+      entities: [{ name: "outerRoot", children: [1], components: [0] }, { instance: { asset: 0 } }],
+      components: [
+        {
+          type: "DiceScript",
+          props: {
+            // Reference the MeshRenderer on the "inner" entity inside the prefab instance
+            skinMesh: { $component: { entity: [1, 0], type: "MeshRenderer", index: 0 } }
+          }
+        }
+      ],
+      root: 0
+    };
+
+    const outerPrefab = await PrefabParser.parse(engine, "deep-comp-outer.prefab", outerPrefabData);
+    const root = outerPrefab.instantiate();
+    const script = root.getComponent(DiceScript);
+
+    const innerEntity = root.children[0].children[0];
+    const innerMeshRenderer = innerEntity.getComponent(MeshRenderer);
+    expect(script.skinMesh).toBe(innerMeshRenderer);
+
+    root.destroy();
+    // @ts-ignore
+    delete engine.resourceManager._objectPool["deep-comp-nested.prefab"];
+  });
 });
diff --git a/tests/src/loader/RawAssetLoader.test.ts b/tests/src/loader/RawAssetLoader.test.ts
index 424eacbd3a..96591836c4 100644
--- a/tests/src/loader/RawAssetLoader.test.ts
+++ b/tests/src/loader/RawAssetLoader.test.ts
@@ -1,6 +1,6 @@
 import { AssetType, BufferAsset, JSONAsset, TextAsset } from "@galacean/engine";
 import "@galacean/engine-loader";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { WebGLEngine } from "@galacean/engine";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 let engine: WebGLEngine;
diff --git a/tests/src/loader/RenderTargetLoader.test.ts b/tests/src/loader/RenderTargetLoader.test.ts
index a3e3555887..805c791392 100644
--- a/tests/src/loader/RenderTargetLoader.test.ts
+++ b/tests/src/loader/RenderTargetLoader.test.ts
@@ -1,6 +1,6 @@
 import { AssetType, RenderTarget, Texture2D, TextureFormat } from "@galacean/engine-core";
 import "@galacean/engine-loader";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { WebGLEngine } from "@galacean/engine";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
 let engine: WebGLEngine;
diff --git a/tests/src/loader/SceneFormatV2.test.ts b/tests/src/loader/SceneFormatV2.test.ts
new file mode 100644
index 0000000000..95cdc3a693
--- /dev/null
+++ b/tests/src/loader/SceneFormatV2.test.ts
@@ -0,0 +1,1164 @@
+import "@galacean/engine-loader";
+import {
+  BackgroundTextureFillMode,
+  BackgroundMode,
+  Camera,
+  BloomEffect,
+  DiffuseMode,
+  Entity,
+  FogMode,
+  Loader,
+  PostProcess,
+  Scene,
+  Script,
+  ShadowCascadesMode,
+  ShadowResolution,
+  Transform
+} from "@galacean/engine-core";
+import { SpecularMode, type SceneFile } from "../../../packages/loader/src/schema/SceneSchema";
+import { applySceneData } from "../../../packages/loader/src/SceneLoader";
+import {
+  ParserContext,
+  ParserType
+} from "../../../packages/loader/src/resource-deserialize/resources/parser/ParserContext";
+import { ReflectionParser } from "../../../packages/loader/src/resource-deserialize/resources/parser/ReflectionParser";
+import { SceneParser } from "../../../packages/loader/src/resource-deserialize/resources/scene/SceneParser";
+import { WebGLEngine } from "@galacean/engine";
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+
+Loader.registerClass("Transform", Transform);
+Loader.registerClass("Camera", Camera);
+Loader.registerClass("PostProcess", PostProcess);
+Loader.registerClass("BloomEffect", BloomEffect);
+
+class TestValueType {
+  x = 0;
+  y = 0;
+}
+Loader.registerClass("TestValueType", TestValueType);
+
+class CallOrderComponent extends Script {
+  value = "";
+  receivedArgs: any[] = [];
+  lastResult: any = null;
+
+  appendSuffix(suffix: string): void {
+    this.value += suffix;
+  }
+
+  captureResolvedArgs(...args: any[]): void {
+    this.receivedArgs = args;
+  }
+
+  setBaseDelayed(base: string): Promise<void> {
+    return Promise.resolve().then(() => {
+      this.value = base;
+    });
+  }
+
+  createResult(seed: number) {
+    const result = {
+      x: seed,
+      y: 0,
+      setY(next: number) {
+        this.y = next;
+      }
+    };
+    this.lastResult = result;
+    return result;
+  }
+}
+Loader.registerClass("CallOrderComponent", CallOrderComponent);
+
+let engine: WebGLEngine;
+
+describe("SceneFile v2 schema enums", () => {
+  it("uses numeric enum values for ambient specularMode", () => {
+    expect(SpecularMode.Sky).to.equal(0);
+    expect(SpecularMode.Custom).to.equal(1);
+  });
+});
+
+beforeAll(async function () {
+  const canvasDOM = document.createElement("canvas");
+  canvasDOM.width = 100;
+  canvasDOM.height = 100;
+  engine = await WebGLEngine.create({ canvas: canvasDOM });
+});
+
+afterAll(() => {
+  engine?.destroy();
+});
+
+// ---------------------------------------------------------------------------
+// ReflectionParser — $ prefix props resolution
+// ---------------------------------------------------------------------------
+
+describe("ReflectionParser v2 props resolution", () => {
+  it("should resolve primitive values directly", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      name: "test",
+      value: 42,
+      flag: true
+    });
+    expect(target.name).to.equal("test");
+    expect(target.value).to.equal(42);
+    expect(target.flag).to.equal(true);
+  });
+
+  it("should resolve nested plain objects recursively", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      nested: { a: 1, b: { c: 2 } }
+    });
+    expect(target.nested).to.deep.equal({ a: 1, b: { c: 2 } });
+  });
+
+  it("should modify existing object properties in place", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const original = { x: 0, y: 0, z: 0 };
+    const target: any = { position: original };
+    await parser.parseProps(target, {
+      position: { x: 1, y: 2, z: 3 }
+    });
+    // Should modify in place, not replace
+    expect(target.position).to.equal(original);
+    expect(target.position.x).to.equal(1);
+    expect(target.position.y).to.equal(2);
+    expect(target.position.z).to.equal(3);
+  });
+
+  it("should resolve arrays recursively", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      items: [1, "two", { key: 3 }]
+    });
+    expect(target.items).to.deep.equal([1, "two", { key: 3 }]);
+  });
+
+  it("should resolve $entity by flat index", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const entity0 = new Entity(engine, "entity0");
+    const entity1 = new Entity(engine, "entity1");
+    context.entityInstances[0] = entity0;
+    context.entityInstances[1] = entity1;
+
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      target: { $entity: [1] }
+    });
+    expect(target.target).to.equal(entity1);
+  });
+
+  it("should resolve missing $entity to null", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      target: { $entity: [999] }
+    });
+    expect(target.target).to.be.null;
+  });
+
+  it("should resolve $entity deep child by path", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const root = new Entity(engine, "root");
+    const child = new Entity(engine, "child");
+    const grandchild = new Entity(engine, "grandchild");
+    root.addChild(child);
+    child.addChild(grandchild);
+    context.entityInstances[0] = root;
+
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      a: { $entity: [0] },
+      b: { $entity: [0, 0] },
+      c: { $entity: [0, 0, 0] }
+    });
+    expect(target.a).to.equal(root);
+    expect(target.b).to.equal(child);
+    expect(target.c).to.equal(grandchild);
+  });
+
+  it("should resolve $entity with out-of-range path element to null", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const root = new Entity(engine, "root");
+    context.entityInstances[0] = root;
+
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      target: { $entity: [0, 5] }
+    });
+    expect(target.target).to.be.null;
+  });
+
+  it("should throw a clear error when $ref index is out of range", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+
+    await expect(
+      parser.parseProps(target, {
+        asset: { $ref: 0 }
+      })
+    ).rejects.toThrow("ReflectionParser: invalid ref index 0 for $ref");
+  });
+
+  it("should resolve $component by entity index + type + index", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const entity = new Entity(engine, "test");
+    context.entityInstances[0] = entity;
+
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      comp: { $component: { entity: [0], type: "Transform", index: 0 } }
+    });
+    expect(target.comp).to.equal(entity.transform);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ReflectionParser — calls execution
+// ---------------------------------------------------------------------------
+
+describe("ReflectionParser calls resolution", () => {
+  it("should resolve $class call args as constructors for factory-style methods", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const entity = new Entity(engine, "post-process");
+    const postProcess = entity.addComponent(PostProcess);
+
+    await parser.parseCalls(postProcess, [
+      {
+        method: "addEffect",
+        args: [{ $class: "BloomEffect" }],
+        result: {
+          props: {
+            threshold: { value: 0.9 },
+            scatter: { value: 0.6 },
+            intensity: { value: 1.5 }
+          }
+        }
+      }
+    ]);
+
+    const effect = postProcess.getEffect(BloomEffect);
+    expect(effect).to.be.instanceOf(BloomEffect);
+    expect(effect.threshold.value).to.equal(0.9);
+    expect(effect.scatter.value).to.equal(0.6);
+    expect(effect.intensity.value).to.equal(1.5);
+  });
+
+  it("should resolve special call args through v2 value rules", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const entity = new Entity(engine, "target");
+    context.entityInstances[1] = entity;
+
+    const asset = { name: "call-asset" };
+    const getResourceByRef = vi
+      .spyOn(engine.resourceManager as any, "getResourceByRef")
+      .mockResolvedValue(asset as any);
+    const refs = [{ url: "call-asset" }];
+    const parser = new ReflectionParser(context, refs);
+    const target = new CallOrderComponent(new Entity(engine, "host"));
+
+    try {
+      await parser.parseCalls(target, [
+        {
+          method: "captureResolvedArgs",
+          args: [
+            { $ref: 0 },
+            { $type: "TestValueType", x: 3, y: 4 },
+            { $entity: [1] },
+            { $component: { entity: [1], type: "Transform", index: 0 } }
+          ]
+        }
+      ]);
+    } finally {
+      getResourceByRef.mockRestore();
+    }
+
+    expect(target.receivedArgs[0]).to.equal(asset);
+    expect(target.receivedArgs[1]).to.be.instanceOf(TestValueType);
+    expect(target.receivedArgs[1].x).to.equal(3);
+    expect(target.receivedArgs[1].y).to.equal(4);
+    expect(target.receivedArgs[2]).to.equal(entity);
+    expect(target.receivedArgs[3]).to.equal(entity.transform);
+  });
+
+  it("should apply result props and nested calls", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target = new CallOrderComponent(new Entity(engine, "host"));
+
+    await parser.parseCalls(target, [
+      {
+        method: "createResult",
+        args: [0],
+        result: {
+          props: { x: 1 },
+          calls: [{ method: "setY", args: [2] }]
+        }
+      }
+    ]);
+
+    expect(target.lastResult.x).to.equal(1);
+    expect(target.lastResult.y).to.equal(2);
+  });
+
+  it("should await each call before executing the next one", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target = new CallOrderComponent(new Entity(engine, "host"));
+
+    await parser.parseCalls(target, [
+      { method: "setBaseDelayed", args: ["base"] },
+      { method: "appendSuffix", args: ["-after"] }
+    ]);
+
+    expect(target.value).to.equal("base-after");
+  });
+
+  it("should throw a clear error when the target method is missing", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+
+    await expect(parser.parseCalls(target, [{ method: "missingMethod" }])).rejects.toThrow("missingMethod");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// SceneParser — v2 entity tree construction
+// ---------------------------------------------------------------------------
+
+describe("SceneParser v2 entity tree", () => {
+  function createSceneData(
+    entities: SceneFile["entities"],
+    components: SceneFile["components"],
+    rootEntities: number[],
+    refs: SceneFile["refs"] = []
+  ): SceneFile {
+    return {
+      version: "2.0",
+      refs,
+      entities,
+      components,
+      scene: {
+        rootEntities,
+        background: {
+          mode: 0,
+          color: [0.25, 0.25, 0.25, 1]
+        },
+        ambient: {
+          diffuseMode: 0,
+          diffuseIntensity: 1,
+          specularIntensity: 1,
+          specularMode: SpecularMode.Sky
+        }
+      }
+    };
+  }
+
+  it("should reject scene data without the v2 version marker", () => {
+    const data = {
+      entities: [{ name: "Entity" }],
+      components: [],
+      scene: {
+        rootEntities: [0],
+        background: {
+          mode: BackgroundMode.SolidColor,
+          color: [0.25, 0.25, 0.25, 1]
+        }
+      }
+    } as any;
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+
+    expect(() => new SceneParser(data, context, scene)).toThrow(
+      'Unsupported scene format version "undefined". Expected "2.0".'
+    );
+  });
+
+  it("should build single-root entity tree from flat array", async () => {
+    const data = createSceneData([{ name: "Root", children: [1, 2] }, { name: "Camera" }, { name: "Light" }], [], [0]);
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await parser.promise;
+
+    expect(scene.rootEntitiesCount).to.equal(1);
+    const root = scene.rootEntities[0];
+    expect(root.name).to.equal("Root");
+    expect(root.childCount).to.equal(2);
+    expect(root.children[0].name).to.equal("Camera");
+    expect(root.children[1].name).to.equal("Light");
+  });
+
+  it("should build multi-root entity tree", async () => {
+    const data = createSceneData([{ name: "Root1", children: [2] }, { name: "Root2" }, { name: "Child" }], [], [0, 1]);
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await parser.promise;
+
+    expect(scene.rootEntitiesCount).to.equal(2);
+    expect(scene.rootEntities[0].name).to.equal("Root1");
+    expect(scene.rootEntities[1].name).to.equal("Root2");
+    expect(scene.rootEntities[0].childCount).to.equal(1);
+    expect(scene.rootEntities[0].children[0].name).to.equal("Child");
+  });
+
+  it("should apply entity transforms from Vec3Tuple", async () => {
+    const data = createSceneData(
+      [
+        {
+          name: "Entity",
+          position: [1, 2, 3],
+          rotation: [45, 90, 0],
+          scale: [2, 2, 2]
+        }
+      ],
+      [],
+      [0]
+    );
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await parser.promise;
+
+    const entity = scene.rootEntities[0];
+    expect(entity.transform.position.x).to.equal(1);
+    expect(entity.transform.position.y).to.equal(2);
+    expect(entity.transform.position.z).to.equal(3);
+    expect(entity.transform.rotation.x).to.equal(45);
+    expect(entity.transform.rotation.y).to.equal(90);
+    expect(entity.transform.rotation.z).to.equal(0);
+    expect(entity.transform.scale.x).to.equal(2);
+    expect(entity.transform.scale.y).to.equal(2);
+    expect(entity.transform.scale.z).to.equal(2);
+  });
+
+  it("should set entity isActive and layer", async () => {
+    const data = createSceneData([{ name: "Inactive", isActive: false, layer: 3 }], [], [0]);
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await parser.promise;
+
+    const entity = scene.rootEntities[0];
+    expect(entity.isActive).to.equal(false);
+    expect(entity.layer).to.equal(3);
+  });
+
+  it("should handle deep entity nesting", async () => {
+    const data = createSceneData(
+      [{ name: "A", children: [1] }, { name: "B", children: [2] }, { name: "C", children: [3] }, { name: "D" }],
+      [],
+      [0]
+    );
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await parser.promise;
+
+    const a = scene.rootEntities[0];
+    expect(a.name).to.equal("A");
+    expect(a.children[0].name).to.equal("B");
+    expect(a.children[0].children[0].name).to.equal("C");
+    expect(a.children[0].children[0].children[0].name).to.equal("D");
+  });
+
+  it("should default missing transform to identity", async () => {
+    const data = createSceneData([{ name: "Default" }], [], [0]);
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await parser.promise;
+
+    const entity = scene.rootEntities[0];
+    expect(entity.transform.position.x).to.equal(0);
+    expect(entity.transform.position.y).to.equal(0);
+    expect(entity.transform.position.z).to.equal(0);
+    expect(entity.transform.scale.x).to.equal(1);
+    expect(entity.transform.scale.y).to.equal(1);
+    expect(entity.transform.scale.z).to.equal(1);
+  });
+
+  it("should add components and apply props (Stage 3-4)", async () => {
+    const data = createSceneData(
+      [{ name: "CamEntity", components: [0] }],
+      [{ type: "Camera", props: { nearClipPlane: 0.5, farClipPlane: 500 } }],
+      [0]
+    );
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await parser.promise;
+
+    const entity = scene.rootEntities[0];
+    const camera = entity.getComponent(Camera);
+    expect(camera).to.not.be.null;
+    expect(camera.nearClipPlane).to.equal(0.5);
+    expect(camera.farClipPlane).to.equal(500);
+  });
+
+  it("should apply component props and calls from the same schema", async () => {
+    const data = createSceneData(
+      [{ name: "CallEntity", components: [0] }],
+      [
+        {
+          type: "CallOrderComponent",
+          props: { value: "base" },
+          calls: [{ method: "captureResolvedArgs", args: ["after"] }]
+        } as any
+      ],
+      [0]
+    );
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await parser.promise;
+
+    const component = scene.rootEntities[0].getComponent(CallOrderComponent);
+    expect(component).to.not.be.null;
+    expect(component.value).to.equal("base");
+    expect(component.receivedArgs).to.deep.equal(["after"]);
+  });
+
+  it("should apply component calls with $class args through scene parsing", async () => {
+    const data = createSceneData(
+      [{ name: "PostProcessEntity", components: [0] }],
+      [
+        {
+          type: "PostProcess",
+          props: { isGlobal: true, priority: 2 },
+          calls: [
+            {
+              method: "addEffect",
+              args: [{ $class: "BloomEffect" }],
+              result: {
+                props: {
+                  threshold: { value: 0.85 },
+                  intensity: { value: 1.25 }
+                }
+              }
+            }
+          ]
+        } as any
+      ],
+      [0]
+    );
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await parser.promise;
+
+    const postProcess = scene.rootEntities[0].getComponent(PostProcess);
+    const effect = postProcess.getEffect(BloomEffect);
+    expect(postProcess.priority).to.equal(2);
+    expect(effect).to.be.instanceOf(BloomEffect);
+    expect(effect.threshold.value).to.equal(0.85);
+    expect(effect.intensity.value).to.equal(1.25);
+  });
+
+  it("should throw a clear error when component type is not registered", async () => {
+    const data = createSceneData([{ name: "Entity", components: [0] }], [{ type: "UnregisteredComponent999" }], [0]);
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new SceneParser(data, context, scene);
+    parser.start();
+    await expect(parser.promise).rejects.toThrow("UnregisteredComponent999");
+  });
+
+  it("should collect dependent assets from refs array", () => {
+    const data: SceneFile = {
+      version: "2.0",
+      refs: [
+        { url: "nested.prefab" },
+        { url: "component-call.mat" },
+        { url: "override-call.mat" },
+        { url: "texture.png", key: "mipmap" }
+      ],
+      entities: [{ name: "Root", components: [0] }],
+      components: [{ type: "CallOrderComponent" }],
+      scene: {
+        rootEntities: [0],
+        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
+        ambient: {
+          diffuseMode: DiffuseMode.SolidColor,
+          diffuseIntensity: 1,
+          specularIntensity: 1,
+          specularMode: SpecularMode.Sky
+        }
+      }
+    };
+
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    context._setTaskCompleteProgress = () => {};
+    const parser = new SceneParser(data, context, scene);
+    const getResourceByRef = vi
+      .spyOn(engine.resourceManager as any, "getResourceByRef")
+      .mockResolvedValue({ _addReferCount() {} } as any);
+
+    let collectedRefs: Array<{ url: string; key?: string }>;
+    try {
+      parser._collectDependentAssets(data);
+      collectedRefs = getResourceByRef.mock.calls.map((args) => args[0] as any);
+    } finally {
+      getResourceByRef.mockRestore();
+    }
+    expect(collectedRefs).to.have.length(4);
+    expect(collectedRefs.map((r) => r.url)).to.deep.equal([
+      "nested.prefab",
+      "component-call.mat",
+      "override-call.mat",
+      "texture.png"
+    ]);
+    expect(collectedRefs[3].key).to.equal("mipmap");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ReflectionParser — $signal binding
+// ---------------------------------------------------------------------------
+
+describe("ReflectionParser $signal resolution", () => {
+  it("should bind listeners to target component method", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const entity0 = new Entity(engine, "source");
+    const entity1 = new Entity(engine, "target");
+    context.entityInstances[0] = entity0;
+    context.entityInstances[1] = entity1;
+
+    const parser = new ReflectionParser(context, []);
+
+    const bound: Array<{ target: any; method: string; args: any[] }> = [];
+    const mockSignal = {
+      on(target: any, method: string, ...args: any[]) {
+        bound.push({ target, method, args });
+      }
+    };
+
+    const target: any = { onClick: mockSignal };
+    await parser.parseProps(target, {
+      onClick: {
+        $signal: [{ target: { $component: { entity: [1], type: "Transform", index: 0 } }, methodName: "reset" }]
+      }
+    });
+
+    // Signal object should be preserved (not replaced)
+    expect(target.onClick).to.equal(mockSignal);
+    // Listener should be bound to entity1's Transform
+    expect(bound.length).to.equal(1);
+    expect(bound[0].target).to.equal(entity1.transform);
+    expect(bound[0].method).to.equal("reset");
+  });
+
+  it("should skip binding when target component is missing", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const entity0 = new Entity(engine, "source");
+    context.entityInstances[0] = entity0;
+    // entity 1 does NOT exist in entityMap
+
+    const parser = new ReflectionParser(context, []);
+
+    const bound: any[] = [];
+    const mockSignal = {
+      on(target: any, method: string, ...args: any[]) {
+        bound.push({ target, method, args });
+      }
+    };
+
+    const target: any = { onClick: mockSignal };
+    await parser.parseProps(target, {
+      onClick: {
+        $signal: [{ target: { $component: { entity: [1], type: "Transform", index: 0 } }, methodName: "reset" }]
+      }
+    });
+
+    // Signal preserved, but no listener bound (entity missing)
+    expect(target.onClick).to.equal(mockSignal);
+    expect(bound.length).to.equal(0);
+  });
+
+  it("should throw a clear error when $signal target property is not initialized", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const entity0 = new Entity(engine, "source");
+    const entity1 = new Entity(engine, "target");
+    context.entityInstances[0] = entity0;
+    context.entityInstances[1] = entity1;
+
+    const parser = new ReflectionParser(context, []);
+
+    // onClick is undefined — not initialized as a Signal
+    const target: any = { onClick: undefined };
+    await expect(
+      parser.parseProps(target, {
+        onClick: {
+          $signal: [{ target: { $component: { entity: [1], type: "Transform", index: 0 } }, methodName: "reset" }]
+        }
+      })
+    ).rejects.toThrow("$signal");
+  });
+
+  it("should return null when $component references an unregistered type", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const entity = new Entity(engine, "test");
+    context.entityInstances[0] = entity;
+
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      comp: { $component: { entity: [0], type: "NonExistentType999", index: 0 } }
+    });
+    expect(target.comp).to.be.null;
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ReflectionParser — $type polymorphic resolution
+// ---------------------------------------------------------------------------
+
+describe("ReflectionParser $type resolution", () => {
+  it("should construct $type instance and apply remaining props", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      value: { $type: "TestValueType", x: 10, y: 20 }
+    });
+    expect(target.value).to.be.instanceOf(TestValueType);
+    expect(target.value.x).to.equal(10);
+    expect(target.value.y).to.equal(20);
+  });
+
+  it("should construct $type instance without props", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      value: { $type: "TestValueType" }
+    });
+    expect(target.value).to.be.instanceOf(TestValueType);
+    expect(target.value.x).to.equal(0);
+    expect(target.value.y).to.equal(0);
+  });
+
+  it("should throw a clear error when $type references an unregistered class", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await expect(
+      parser.parseProps(target, {
+        value: { $type: "NonExistentClass123" }
+      })
+    ).rejects.toThrow("NonExistentClass123");
+  });
+
+  it("should throw a clear error when $type is not a non-empty string", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await expect(
+      parser.parseProps(target, {
+        value: { $type: 123 } as any
+      })
+    ).rejects.toThrow("$type must be a non-empty registered class name string");
+  });
+});
+
+describe("ReflectionParser $class resolution", () => {
+  it("should resolve $class as the registered constructor through parseProps", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await parser.parseProps(target, {
+      value: { $class: "TestValueType" }
+    });
+    expect(target.value).to.equal(TestValueType);
+  });
+
+  it("should throw a clear error when $class is an empty string", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await expect(
+      parser.parseProps(target, {
+        value: { $class: "" }
+      })
+    ).rejects.toThrow("$class must be a non-empty registered class name string");
+  });
+
+  it("should throw a clear error when $class is not a string", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await expect(
+      parser.parseProps(target, {
+        value: { $class: 123 } as any
+      })
+    ).rejects.toThrow("$class must be a non-empty registered class name string");
+  });
+
+  it("should throw a clear error when $class references an unregistered class", async () => {
+    const scene = new Scene(engine);
+    const context = new ParserContext(engine, ParserType.Scene, scene);
+    const parser = new ReflectionParser(context, []);
+    const target: any = {};
+    await expect(
+      parser.parseProps(target, {
+        value: { $class: "NonExistentClass123" }
+      })
+    ).rejects.toThrow("NonExistentClass123");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// applySceneData — scene property parsing (shadow / fog / AO / background)
+// ---------------------------------------------------------------------------
+// Tests call the same applySceneData function that SceneLoader.load() uses,
+// so any change to the parsing logic is automatically covered.
+
+describe("applySceneData scene property parsing", () => {
+  it("should resolve ambient resources for custom specular and spherical harmonics", async () => {
+    const scene = new Scene(engine);
+    const noop = () => {};
+    const customAmbientTexture = { name: "custom-specular-texture", _addReferCount: noop };
+    const ambientTexture = { name: "sh-specular-texture", _addReferCount: noop };
+    const diffuseSphericalHarmonics = { name: "ambient-sh", coefficients: new Float32Array(27) };
+    const getResourceByRef = vi
+      .spyOn(engine.resourceManager as any, "getResourceByRef")
+      .mockImplementation((ref: any) => {
+        switch (ref.url) {
+          case "custom-ambient":
+            return Promise.resolve({ specularTexture: customAmbientTexture }) as any;
+          case "ambient-light":
+            return Promise.resolve({
+              specularTexture: ambientTexture,
+              diffuseSphericalHarmonics
+            }) as any;
+          default:
+            return Promise.resolve(null) as any;
+        }
+      });
+
+    const refs = [{ url: "custom-ambient" }, { url: "ambient-light" }];
+    try {
+      await applySceneData(
+        scene,
+        {
+          rootEntities: [0],
+          background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
+          ambient: {
+            diffuseMode: DiffuseMode.SphericalHarmonics,
+            diffuseIntensity: 1,
+            specularIntensity: 1,
+            specularMode: SpecularMode.Custom,
+            customAmbientLight: 0,
+            ambientLight: 1
+          }
+        },
+        engine.resourceManager,
+        refs
+      );
+    } finally {
+      getResourceByRef.mockRestore();
+    }
+
+    expect(scene.ambientLight.specularTexture).to.equal(customAmbientTexture);
+    expect(scene.ambientLight.diffuseSphericalHarmonics).to.equal(diffuseSphericalHarmonics);
+  });
+
+  it("should apply sky background resources", async () => {
+    const scene = new Scene(engine);
+    const noop = () => {};
+    const skyMesh = { name: "sky-mesh", _addReferCount: noop };
+    const skyMaterial = { name: "sky-material", _addReferCount: noop };
+    const getResourceByRef = vi
+      .spyOn(engine.resourceManager as any, "getResourceByRef")
+      .mockImplementation((ref: any) => {
+        switch (ref.url) {
+          case "sky-mesh":
+            return Promise.resolve(skyMesh) as any;
+          case "sky-material":
+            return Promise.resolve(skyMaterial) as any;
+          default:
+            return Promise.resolve(null) as any;
+        }
+      });
+
+    const refs = [{ url: "sky-mesh" }, { url: "sky-material" }];
+    try {
+      await applySceneData(
+        scene,
+        {
+          rootEntities: [0],
+          background: {
+            mode: BackgroundMode.Sky,
+            color: [0, 0, 0, 1],
+            skyMesh: 0,
+            skyMaterial: 1
+          }
+        },
+        engine.resourceManager,
+        refs
+      );
+    } finally {
+      getResourceByRef.mockRestore();
+    }
+
+    expect(scene.background.sky.mesh).to.equal(skyMesh);
+    expect(scene.background.sky.material).to.equal(skyMaterial);
+  });
+
+  it("should apply texture background resources and fill mode", async () => {
+    const scene = new Scene(engine);
+    const backgroundTexture = { name: "background-texture", _addReferCount: () => {} };
+    const getResourceByRef = vi
+      .spyOn(engine.resourceManager as any, "getResourceByRef")
+      .mockImplementation((ref: any) => {
+        if (ref.url === "background-texture") {
+          return Promise.resolve(backgroundTexture) as any;
+        }
+        return Promise.resolve(null) as any;
+      });
+
+    const refs = [{ url: "background-texture" }];
+    try {
+      await applySceneData(
+        scene,
+        {
+          rootEntities: [0],
+          background: {
+            mode: BackgroundMode.Texture,
+            color: [0, 0, 0, 1],
+            texture: 0,
+            textureFillMode: BackgroundTextureFillMode.Fill
+          }
+        },
+        engine.resourceManager,
+        refs
+      );
+    } finally {
+      getResourceByRef.mockRestore();
+    }
+
+    expect(scene.background.texture).to.equal(backgroundTexture);
+    expect(scene.background.textureFillMode).to.equal(BackgroundTextureFillMode.Fill);
+  });
+
+  it("should throw a clear error when scene ref index is out of range", async () => {
+    const scene = new Scene(engine);
+
+    await expect(
+      applySceneData(
+        scene,
+        {
+          rootEntities: [0],
+          background: {
+            mode: BackgroundMode.Texture,
+            color: [0, 0, 0, 1],
+            texture: 0
+          }
+        },
+        engine.resourceManager,
+        []
+      )
+    ).rejects.toThrow("SceneLoader: invalid ref index 0 for scene.background.texture");
+  });
+
+  it("should apply shadow properties to scene", async () => {
+    const scene = new Scene(engine);
+    await applySceneData(
+      scene,
+      {
+        rootEntities: [0],
+        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
+        shadow: {
+          castShadows: false,
+          enableTransparentShadow: true,
+          shadowResolution: ShadowResolution.High,
+          shadowDistance: 100,
+          shadowCascades: ShadowCascadesMode.FourCascades,
+          shadowTwoCascadeSplits: 0.5,
+          shadowFourCascadeSplits: [0.1, 0.3, 0.7],
+          shadowFadeBorder: 0.2
+        }
+      },
+      engine.resourceManager,
+      []
+    );
+
+    expect(scene.castShadows).to.equal(false);
+    expect(scene.enableTransparentShadow).to.equal(true);
+    expect(scene.shadowResolution).to.equal(ShadowResolution.High);
+    expect(scene.shadowDistance).to.equal(100);
+    expect(scene.shadowCascades).to.equal(ShadowCascadesMode.FourCascades);
+    expect(scene.shadowTwoCascadeSplits).to.equal(0.5);
+    expect(scene.shadowFourCascadeSplits.x).to.be.closeTo(0.1, 0.001);
+    expect(scene.shadowFourCascadeSplits.y).to.be.closeTo(0.3, 0.001);
+    expect(scene.shadowFourCascadeSplits.z).to.be.closeTo(0.7, 0.001);
+    expect(scene.shadowFadeBorder).to.equal(0.2);
+  });
+
+  it("should apply fog properties to scene", async () => {
+    const scene = new Scene(engine);
+    await applySceneData(
+      scene,
+      {
+        rootEntities: [0],
+        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
+        fog: {
+          fogMode: FogMode.ExponentialSquared,
+          fogStart: 10,
+          fogEnd: 200,
+          fogDensity: 0.05,
+          fogColor: [1, 0, 0, 1]
+        }
+      },
+      engine.resourceManager,
+      []
+    );
+
+    expect(scene.fogMode).to.equal(FogMode.ExponentialSquared);
+    expect(scene.fogStart).to.equal(10);
+    expect(scene.fogEnd).to.equal(200);
+    expect(scene.fogDensity).to.equal(0.05);
+    expect(scene.fogColor.r).to.equal(1);
+    expect(scene.fogColor.g).to.equal(0);
+    expect(scene.fogColor.b).to.equal(0);
+    expect(scene.fogColor.a).to.equal(1);
+  });
+
+  it("should apply ambient occlusion properties to scene", async () => {
+    const scene = new Scene(engine);
+    await applySceneData(
+      scene,
+      {
+        rootEntities: [0],
+        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] },
+        ambientOcclusion: {
+          enabledAmbientOcclusion: true,
+          intensity: 0.8,
+          radius: 0.5,
+          bias: 0.02,
+          power: 3,
+          quality: 2,
+          bilateralThreshold: 0.1,
+          minHorizonAngle: 0.04
+        }
+      },
+      engine.resourceManager,
+      []
+    );
+
+    const ao = scene.ambientOcclusion;
+    expect(ao.enabled).to.equal(true);
+    expect(ao.intensity).to.equal(0.8);
+    expect(ao.radius).to.equal(0.5);
+    expect(ao.bias).to.equal(0.02);
+    expect(ao.power).to.equal(3);
+    expect(ao.quality).to.equal(2);
+    expect(ao.bilateralThreshold).to.equal(0.1);
+    expect(ao.minHorizonAngle).to.equal(0.04);
+  });
+
+  it("should apply SolidColor background from Vec4Tuple", async () => {
+    const scene = new Scene(engine);
+    await applySceneData(
+      scene,
+      {
+        rootEntities: [0],
+        background: {
+          mode: BackgroundMode.SolidColor,
+          color: [0.5, 0.6, 0.7, 1]
+        }
+      },
+      engine.resourceManager,
+      []
+    );
+
+    expect(scene.background.mode).to.equal(BackgroundMode.SolidColor);
+    expect(scene.background.solidColor.r).to.be.closeTo(0.5, 0.001);
+    expect(scene.background.solidColor.g).to.be.closeTo(0.6, 0.001);
+    expect(scene.background.solidColor.b).to.be.closeTo(0.7, 0.001);
+    expect(scene.background.solidColor.a).to.equal(1);
+  });
+
+  it("should preserve defaults when shadow/fog/AO sections are absent", async () => {
+    const scene = new Scene(engine);
+    await applySceneData(
+      scene,
+      {
+        rootEntities: [0],
+        background: { mode: BackgroundMode.SolidColor, color: [0, 0, 0, 1] }
+      },
+      engine.resourceManager,
+      []
+    );
+
+    expect(scene.castShadows).to.equal(true);
+    expect(scene.fogMode).to.equal(FogMode.None);
+    expect(scene.ambientOcclusion.enabled).to.equal(false);
+  });
+});
diff --git a/tests/src/loader/SceneParser.test.ts b/tests/src/loader/SceneParser.test.ts
deleted file mode 100644
index 9ed2eb4944..0000000000
--- a/tests/src/loader/SceneParser.test.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import { describe, it } from "vitest";
-
-describe("ProjectLoader Component Reference Tests", function () {
-  // TODO: update project.json to new format (old one contains deprecated "Environment" asset type)
-  it.skip("should load project successfully with component be deleted", async () => {});
-});
diff --git a/tests/src/loader/ScenePhysics.test.ts b/tests/src/loader/ScenePhysics.test.ts
deleted file mode 100644
index 74a1a452cf..0000000000
--- a/tests/src/loader/ScenePhysics.test.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { AssetType, BackgroundMode, Scene } from "@galacean/engine";
-import "@galacean/engine-loader";
-import { PhysXPhysics } from "@galacean/engine-physics-physx";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-let engine: WebGLEngine;
-
-beforeAll(async () => {
-  engine = await WebGLEngine.create({
-    canvas: document.createElement("canvas"),
-    physics: new PhysXPhysics()
-  });
-});
-
-afterAll(() => {
-  engine?.destroy();
-});
-
-describe("SceneLoader physics settings", () => {
-  it("applies serialized scene physics settings to PhysicsScene", async () => {
-    const sceneData = {
-      name: "physics-scene",
-      entities: [],
-      scene: {
-        background: {
-          mode: BackgroundMode.SolidColor,
-          color: { r: 0, g: 0, b: 0, a: 1 }
-        },
-        physics: {
-          gravity: { x: 0, y: -3200, z: 0 },
-          fixedTimeStep: 1 / 120
-        }
-      },
-      files: []
-    };
-    const sceneUrl =
-      URL.createObjectURL(new Blob([JSON.stringify(sceneData)], { type: "application/json" })) + "#.scene";
-
-    const scene = await engine.resourceManager.load<Scene>({
-      url: sceneUrl,
-      type: AssetType.Scene
-    });
-
-    expect(scene.physics.gravity.x).toBe(0);
-    expect(scene.physics.gravity.y).toBe(-3200);
-    expect(scene.physics.gravity.z).toBe(0);
-    expect(scene.physics.fixedTimeStep).toBe(1 / 120);
-  });
-});
diff --git a/tests/src/loader/StrippedEntity.test.ts b/tests/src/loader/StrippedEntity.test.ts
deleted file mode 100644
index 6f078d1d17..0000000000
--- a/tests/src/loader/StrippedEntity.test.ts
+++ /dev/null
@@ -1,277 +0,0 @@
-/**
- * Tests stripped entities that proxy internal prefab-instance entities.
- *
- * A stripped entity can resolve to an entity inside a nested prefab instance and
- * serve as the parent for newly added entities.
- */
-import { expect, beforeAll, afterAll, describe, it } from "vitest";
-import { WebGLEngine } from "@galacean/engine-rhi-webgl";
-import type { IHierarchyFile } from "@galacean/engine-loader";
-import { Vector3 } from "@galacean/engine-math";
-import { PrefabParser } from "../../../packages/loader/src/prefab/PrefabParser";
-
-let engine: WebGLEngine;
-
-function getResourceObjectPool(): Record<string, unknown> {
-  return (engine.resourceManager as unknown as { _objectPool: Record<string, unknown> })._objectPool;
-}
-
-function cachePrefab(url: string, prefab: unknown): void {
-  getResourceObjectPool()[url] = prefab;
-}
-
-function removeCachedPrefab(url: string): void {
-  delete getResourceObjectPool()[url];
-}
-
-beforeAll(async () => {
-  const canvas = document.createElement("canvas");
-  canvas.width = 256;
-  canvas.height = 256;
-  engine = await WebGLEngine.create({ canvas });
-});
-
-afterAll(() => {
-  engine?.destroy();
-});
-
-describe("IStrippedEntity as addedEntities mechanism", () => {
-  it("keeps nested prefab children after instantiation", async () => {
-    const nestedPrefabData: IHierarchyFile = {
-      entities: [
-        { id: "0", name: "nestedRoot", components: [], children: ["1", "2"] },
-        { id: "1", name: "boneHand", parent: "0", components: [] },
-        { id: "2", name: "otherChild", parent: "0", components: [] }
-      ]
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "sanity.prefab", nestedPrefabData);
-    const inst = nestedPrefab.instantiate();
-    const names = inst.children.map((c) => c.name);
-    expect(names).toContain("boneHand");
-    expect(names).toContain("otherChild");
-    inst.destroy();
-  });
-
-  it("should attach new child entity under an internal entity of a nested prefab", async () => {
-    // Nested prefab:
-    //   root
-    //     - boneHand    (proxied by the stripped entity)
-    //     - otherChild
-    const nestedPrefabData: IHierarchyFile = {
-      entities: [
-        { id: "0", name: "nestedRoot", components: [], children: ["1", "2"] },
-        { id: "1", name: "boneHand", parent: "0", components: [] },
-        { id: "2", name: "otherChild", parent: "0", components: [] }
-      ]
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "char.prefab", nestedPrefabData);
-    cachePrefab("char.prefab", nestedPrefab);
-
-    // Outer prefab:
-    //   - IRefEntity instantiating the nested prefab (only direct child of outerRoot)
-    //   - IStrippedEntity proxying to boneHand, not in outerRoot.children
-    //   - weaponslot listed in stripped entity's children
-    const outerPrefabData: IHierarchyFile = {
-      entities: [
-        {
-          id: "outerRoot",
-          name: "Character",
-          components: [],
-          children: ["charInst"]
-        },
-        {
-          id: "charInst",
-          name: "char",
-          parent: "outerRoot",
-          components: [],
-          assetUrl: "char.prefab",
-          isClone: true,
-          modifications: [],
-          removedEntities: [],
-          removedComponents: []
-        } as any,
-        {
-          // Do not set `name`: _applyEntityData would override the internal entity's name.
-          strippedId: "boneHandle",
-          prefabInstanceId: "charInst",
-          prefabSource: { assetId: "", entityId: "0" },
-          components: [],
-          children: ["weaponslot"]
-        } as any,
-        {
-          id: "weaponslot",
-          name: "weaponslot1",
-          parent: "boneHandle",
-          components: [],
-          position: { x: 0.5, y: 0.25, z: 0 }
-        }
-      ]
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "outer.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-
-    const charInst = root.children.find((c) => c.name === "char");
-    expect(charInst, "char instance should be a child of outerRoot").not.toBeUndefined();
-
-    const boneHand = charInst!.children.find((c) => c.name === "boneHand");
-    expect(boneHand, "boneHand should exist inside nested prefab").not.toBeUndefined();
-
-    const weaponslot = boneHand!.children.find((c) => c.name === "weaponslot1");
-    expect(weaponslot, "weaponslot1 should be attached as child of boneHand via stripped entity").not.toBeUndefined();
-    expect(weaponslot!.transform.position.x).toBeCloseTo(0.5, 5);
-    expect(weaponslot!.transform.position.y).toBeCloseTo(0.25, 5);
-    expect(weaponslot!.transform.position.z).toBeCloseTo(0, 5);
-
-    root.destroy();
-    removeCachedPrefab("char.prefab");
-  });
-
-  it("should support multiple stripped entities targeting different internal entities (LeftHand / RightHand socket case)", async () => {
-    // Nested prefab: root -> [LeftHand, RightHand]
-    const nestedPrefabData: IHierarchyFile = {
-      entities: [
-        { id: "0", name: "nestedRoot", components: [], children: ["1", "2"] },
-        { id: "1", name: "LeftHand", parent: "0", components: [] },
-        { id: "2", name: "RightHand", parent: "0", components: [] }
-      ]
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "body.prefab", nestedPrefabData);
-    cachePrefab("body.prefab", nestedPrefab);
-
-    // entityId is the path string generated by _generateInstanceContext:
-    //   nestedRoot = ""
-    //   nestedRoot.children[0] = LeftHand  -> "0"
-    //   nestedRoot.children[1] = RightHand -> "1"
-    const outerPrefabData: IHierarchyFile = {
-      entities: [
-        {
-          id: "outerRoot",
-          name: "Player",
-          components: [],
-          children: ["bodyInst"]
-        },
-        {
-          id: "bodyInst",
-          name: "body",
-          parent: "outerRoot",
-          components: [],
-          assetUrl: "body.prefab",
-          isClone: true,
-          modifications: [],
-          removedEntities: [],
-          removedComponents: []
-        } as any,
-        {
-          strippedId: "lhHandle",
-          prefabInstanceId: "bodyInst",
-          prefabSource: { assetId: "", entityId: "0" },
-          components: [],
-          children: ["ws1"]
-        } as any,
-        {
-          strippedId: "rhHandle",
-          prefabInstanceId: "bodyInst",
-          prefabSource: { assetId: "", entityId: "1" },
-          components: [],
-          children: ["ws2", "ws3"]
-        } as any,
-        { id: "ws1", name: "weaponslot1", parent: "lhHandle", components: [] },
-        { id: "ws2", name: "weaponslot2", parent: "rhHandle", components: [] },
-        { id: "ws3", name: "weaponslot3", parent: "rhHandle", components: [] }
-      ]
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "player.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-    const bodyInst = root.children.find((c) => c.name === "body")!;
-    const leftHand = bodyInst.children.find((c) => c.name === "LeftHand")!;
-    const rightHand = bodyInst.children.find((c) => c.name === "RightHand")!;
-
-    const slot1 = leftHand.children.find((c) => c.name === "weaponslot1");
-    const slot2 = rightHand.children.find((c) => c.name === "weaponslot2");
-    const slot3 = rightHand.children.find((c) => c.name === "weaponslot3");
-
-    expect(slot1, "weaponslot1 under LeftHand").not.toBeUndefined();
-    expect(slot2, "weaponslot2 under RightHand").not.toBeUndefined();
-    expect(slot3, "weaponslot3 under RightHand").not.toBeUndefined();
-
-    // No new entities should remain as direct children of outerRoot after reparenting
-    expect(root.children.find((c) => c.name === "weaponslot1")).toBeUndefined();
-    expect(root.children.find((c) => c.name === "lh-proxy")).toBeUndefined();
-
-    root.destroy();
-    removeCachedPrefab("body.prefab");
-  });
-
-  it("should propagate internal entity transform changes to the attached child (bone-drives-weapon behavior)", async () => {
-    // When an internal entity moves, the child attached through the stripped
-    // entity follows through normal hierarchy transforms.
-    const nestedPrefabData: IHierarchyFile = {
-      entities: [
-        { id: "0", name: "nestedRoot", components: [], children: ["1"] },
-        { id: "1", name: "bone", parent: "0", components: [] }
-      ]
-    };
-    const nestedPrefab = await PrefabParser.parse(engine, "skel.prefab", nestedPrefabData);
-    cachePrefab("skel.prefab", nestedPrefab);
-
-    const outerPrefabData: IHierarchyFile = {
-      entities: [
-        {
-          id: "outerRoot",
-          name: "Actor",
-          components: [],
-          children: ["skelInst"]
-        },
-        {
-          id: "skelInst",
-          name: "skel",
-          parent: "outerRoot",
-          components: [],
-          assetUrl: "skel.prefab",
-          isClone: true,
-          modifications: [],
-          removedEntities: [],
-          removedComponents: []
-        } as any,
-        {
-          strippedId: "boneHandle",
-          prefabInstanceId: "skelInst",
-          prefabSource: { assetId: "", entityId: "0" },
-          components: [],
-          children: ["weapon"]
-        } as any,
-        {
-          id: "weapon",
-          name: "weapon",
-          parent: "boneHandle",
-          components: [],
-          position: { x: 1, y: 0, z: 0 }
-        }
-      ]
-    };
-
-    const outerPrefab = await PrefabParser.parse(engine, "actor.prefab", outerPrefabData);
-    const root = outerPrefab.instantiate();
-    const bone = root.children.find((c) => c.name === "skel")!.children.find((c) => c.name === "bone")!;
-    const weapon = bone.children.find((c) => c.name === "weapon")!;
-
-    // Initial: bone at origin, weapon world position = (1, 0, 0)
-    const worldPos = new Vector3();
-    worldPos.copyFrom(weapon.transform.worldPosition);
-    expect(worldPos.x).toBeCloseTo(1, 5);
-    expect(worldPos.y).toBeCloseTo(0, 5);
-    expect(worldPos.z).toBeCloseTo(0, 5);
-
-    // Simulate transform animation: move bone to (10, 5, -3)
-    bone.transform.setPosition(10, 5, -3);
-    worldPos.copyFrom(weapon.transform.worldPosition);
-    expect(worldPos.x).toBeCloseTo(11, 5); // 10 + 1
-    expect(worldPos.y).toBeCloseTo(5, 5); //  5 + 0
-    expect(worldPos.z).toBeCloseTo(-3, 5); // -3 + 0
-
-    root.destroy();
-    removeCachedPrefab("skel.prefab");
-  });
-});

From 0375f073f58e73cfd4ab4d40f7c484e869bd17fc Mon Sep 17 00:00:00 2001
From: luzhuang <wz84888@antgroup.com>
Date: Tue, 26 May 2026 11:30:09 +0800
Subject: [PATCH 06/10] fix(loader): revert GLTFTextureParser
 AssetType.Texture2D back to Texture

AssetType enum has no Texture2D member; this was an incorrect
change from fix/shaderlab.
---
 packages/loader/src/gltf/parser/GLTFTextureParser.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/loader/src/gltf/parser/GLTFTextureParser.ts b/packages/loader/src/gltf/parser/GLTFTextureParser.ts
index 4da7f1cc5b..fd0524ab2b 100644
--- a/packages/loader/src/gltf/parser/GLTFTextureParser.ts
+++ b/packages/loader/src/gltf/parser/GLTFTextureParser.ts
@@ -44,7 +44,7 @@ export class GLTFTextureParser extends GLTFParser {
     if (uri) {
       const extIndex = uri.lastIndexOf(".");
       const ext = uri.substring(extIndex + 1);
-      const type = ext.startsWith("ktx") ? AssetType.KTX : AssetType.Texture2D;
+      const type = ext.startsWith("ktx") ? AssetType.KTX : AssetType.Texture;
       texture = engine.resourceManager
         .load<Texture2D>({
           url: Utils.resolveAbsoluteUrl(url, uri),

From 096d044271ac6dcce945428d5c25a30e3ef47ca8 Mon Sep 17 00:00:00 2001
From: cptbtptpbcptdtptp <njktsmshh@gmail.com>
Date: Tue, 26 May 2026 19:37:01 +0800
Subject: [PATCH 07/10] fix(animation): remove clip changed listener on
 Animator destroy

Animator added a clipChangedListener to each AnimatorState's update flag
manager but never removed it. After destroy, the listener kept the state
and the destroyed Animator graph reachable, leaking memory across reloads.
Track the listener on AnimatorStateData and unsubscribe in _reset; call
_reset from _onDestroy.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 packages/core/src/animation/Animator.ts        | 18 +++++++++---------
 .../animation/internal/AnimatorStateData.ts    |  4 ++--
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/packages/core/src/animation/Animator.ts b/packages/core/src/animation/Animator.ts
index 12a77b6d88..c8c274395b 100644
--- a/packages/core/src/animation/Animator.ts
+++ b/packages/core/src/animation/Animator.ts
@@ -344,14 +344,13 @@ export class Animator extends Component {
     }
 
     for (let i = 0, n = layersData.length; i < n; i++) {
-      const { animatorStateDataMap } = layersData[i];
-      for (let name in animatorStateDataMap) {
-        const stateData = animatorStateDataMap[name];
-        const { clipChangedListener, animatorState } = stateData;
-        if (clipChangedListener) {
-          animatorState._updateFlagManager.removeListener(clipChangedListener);
+      const stateDataMap = layersData[i].animatorStateDataMap;
+      for (const stateName in stateDataMap) {
+        const stateData = stateDataMap[stateName];
+        if (stateData.clipChangedListener && stateData.state) {
+          stateData.state._updateFlagManager.removeListener(stateData.clipChangedListener);
           stateData.clipChangedListener = null;
-          stateData.animatorState = null;
+          stateData.state = null;
         }
       }
     }
@@ -379,6 +378,7 @@ export class Animator extends Component {
 
   protected override _onDestroy(): void {
     super._onDestroy();
+    this._reset();
     const controller = this._animatorController;
     if (controller) {
       this._addResourceReferCount(controller, -1);
@@ -530,9 +530,9 @@ export class Animator extends Component {
       }
     };
     clipChangedListener();
-    animatorStateData.animatorState = state;
-    animatorStateData.clipChangedListener = clipChangedListener;
     state._updateFlagManager.addListener(clipChangedListener);
+    animatorStateData.state = state;
+    animatorStateData.clipChangedListener = clipChangedListener;
   }
 
   private _clearCrossData(animatorLayerData: AnimatorLayerData): void {
diff --git a/packages/core/src/animation/internal/AnimatorStateData.ts b/packages/core/src/animation/internal/AnimatorStateData.ts
index 284176f69c..42b50edd87 100644
--- a/packages/core/src/animation/internal/AnimatorStateData.ts
+++ b/packages/core/src/animation/internal/AnimatorStateData.ts
@@ -8,6 +8,6 @@ import { AnimationEventHandler } from "./AnimationEventHandler";
 export class AnimatorStateData {
   curveLayerOwner: AnimationCurveLayerOwner[] = [];
   eventHandlers: AnimationEventHandler[] = [];
-  animatorState: AnimatorState;
-  clipChangedListener: () => void;
+  state: AnimatorState = null;
+  clipChangedListener: () => void = null;
 }

From 012b3700cdf9db70d945c8a2e3b35ddffde460d2 Mon Sep 17 00:00:00 2001
From: cptbtptpbcptdtptp <njktsmshh@gmail.com>
Date: Thu, 28 May 2026 20:09:10 +0800
Subject: [PATCH 08/10] fix(animation): switch instanceId records to weakmaps
 and guard _reset cleanup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two related leaks the previous `Record<instanceId, ...>` layout caused:

1. `Animator._curveOwnerPool` and `AnimatorLayerData.curveOwnerPool` were
   keyed by `Component.instanceId`. Destroying the bound component left
   the entry pinned for the Animator's lifetime, so the curve owners
   (and the entity-tree defaults they captured) couldn't be collected.
   `AnimationClipCurveBinding._tempCurveOwner` had the same shape keyed
   by `Entity.instanceId`. Re-key all three by the live object via
   `WeakMap<Component | Entity, ...>` so dead keys release the entry.

2. `Animator._reset` reverted default values for every owner *before*
   removing each state's `clipChangedListener`. If any owner threw on a
   dead target, the listener-remove block was skipped, leaving the
   polyfill listener on a shared `AnimatorState`; the listener closure
   captures `this` (the Animator), which pins the whole entity tree
   until the AnimatorState itself dies.

   Move listener cleanup into the inner loop, wrap each
   `revertDefaultValue` in its own `try/catch`, so listener cleanup
   always runs. (Root-cause fix would be a destroyed-target guard
   inside `AnimationCurveOwner.revertDefaultValue` itself — left as a
   follow-up.)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../animation/AnimationClipCurveBinding.ts    | 11 +++--
 packages/core/src/animation/Animator.ts       | 48 +++++++++++--------
 .../animation/internal/AnimatorLayerData.ts   |  3 +-
 3 files changed, 35 insertions(+), 27 deletions(-)

diff --git a/packages/core/src/animation/AnimationClipCurveBinding.ts b/packages/core/src/animation/AnimationClipCurveBinding.ts
index 906c154087..e6e4066181 100644
--- a/packages/core/src/animation/AnimationClipCurveBinding.ts
+++ b/packages/core/src/animation/AnimationClipCurveBinding.ts
@@ -33,7 +33,7 @@ export class AnimationClipCurveBinding {
   /** The animation curve. */
   curve: AnimationCurve<KeyframeValueType>;
 
-  private _tempCurveOwner: Record<number, AnimationCurveOwner<KeyframeValueType>> = {};
+  private _tempCurveOwner = new WeakMap<Entity, AnimationCurveOwner<KeyframeValueType>>();
 
   /**
    * @internal
@@ -63,10 +63,11 @@ export class AnimationClipCurveBinding {
    * @internal
    */
   _getTempCurveOwner(entity: Entity, component: Component): AnimationCurveOwner<KeyframeValueType> {
-    const { instanceId } = entity;
-    if (!this._tempCurveOwner[instanceId]) {
-      this._tempCurveOwner[instanceId] = this._createCurveOwner(entity, component);
+    let owner = this._tempCurveOwner.get(entity);
+    if (!owner) {
+      owner = this._createCurveOwner(entity, component);
+      this._tempCurveOwner.set(entity, owner);
     }
-    return this._tempCurveOwner[instanceId];
+    return owner;
   }
 }
diff --git a/packages/core/src/animation/Animator.ts b/packages/core/src/animation/Animator.ts
index c8c274395b..4413f393a6 100644
--- a/packages/core/src/animation/Animator.ts
+++ b/packages/core/src/animation/Animator.ts
@@ -57,7 +57,7 @@ export class Animator extends Component {
   @ignoreClone
   private _animatorLayersData = new Array<AnimatorLayerData>();
   @ignoreClone
-  private _curveOwnerPool: Record<number, Record<string, AnimationCurveOwner<KeyframeValueType>>> = Object.create(null);
+  private _curveOwnerPool: WeakMap<Component, Record<string, AnimationCurveOwner<KeyframeValueType>>> = new WeakMap();
   @ignoreClone
   private _animationEventHandlerPool = new ClearableObjectPool(AnimationEventHandler);
   @ignoreClone
@@ -334,19 +334,22 @@ export class Animator extends Component {
    * @internal
    */
   _reset(): void {
-    const { _curveOwnerPool: animationCurveOwners, _animatorLayersData: layersData } = this;
-    for (let instanceId in animationCurveOwners) {
-      const propertyOwners = animationCurveOwners[instanceId];
-      for (let property in propertyOwners) {
-        const owner = propertyOwners[property];
-        owner.revertDefaultValue();
-      }
-    }
-
+    // revertDefaultValue 可能在死 target 上抛；listener 清理必须始终发生，否则
+    // polyfill 的 clipChangedListener 会留在共享的 AnimatorState 上，捕获 this(Animator)→Entity 整树。
+    // 用 try/catch 隔离 revert，listener 块紧跟其后无条件执行。
+    const layersData = this._animatorLayersData;
     for (let i = 0, n = layersData.length; i < n; i++) {
       const stateDataMap = layersData[i].animatorStateDataMap;
       for (const stateName in stateDataMap) {
         const stateData = stateDataMap[stateName];
+        const layerOwners = stateData.curveLayerOwner;
+        for (let j = 0, m = layerOwners.length; j < m; j++) {
+          try {
+            layerOwners[j]?.curveOwner?.revertDefaultValue();
+          } catch (e) {
+            Logger.warn("Animator._reset: revertDefaultValue threw", e);
+          }
+        }
         if (stateData.clipChangedListener && stateData.state) {
           stateData.state._updateFlagManager.removeListener(stateData.clipChangedListener);
           stateData.clipChangedListener = null;
@@ -355,8 +358,8 @@ export class Animator extends Component {
       }
     }
 
-    layersData.length = 0;
-    this._curveOwnerPool = Object.create(null);
+    this._animatorLayersData.length = 0;
+    this._curveOwnerPool = new WeakMap();
     this._parametersValueMap = Object.create(null);
     this._animationEventHandlerPool.clear();
 
@@ -478,17 +481,20 @@ export class Animator extends Component {
         }
 
         const { property } = curve;
-        const { instanceId } = component;
-        // Get owner
-        const propertyOwners = (curveOwnerPool[instanceId] ||= <Record<string, AnimationCurveOwner<KeyframeValueType>>>(
-          Object.create(null)
-        ));
+        // Get owner — WeakMap keyed by Component so dead components let entries GC.
+        let propertyOwners = curveOwnerPool.get(component);
+        if (!propertyOwners) {
+          propertyOwners = <Record<string, AnimationCurveOwner<KeyframeValueType>>>Object.create(null);
+          curveOwnerPool.set(component, propertyOwners);
+        }
         const owner = (propertyOwners[property] ||= curve._createCurveOwner(targetEntity, component));
 
-        // Get layer owner
-        const layerPropertyOwners = (layerCurveOwnerPool[instanceId] ||= <Record<string, AnimationCurveLayerOwner>>(
-          Object.create(null)
-        ));
+        // Get layer owner — same WeakMap-by-Component pattern (was Record<instanceId,...> which kept dead components pinned for the Animator's lifetime).
+        let layerPropertyOwners = layerCurveOwnerPool.get(component);
+        if (!layerPropertyOwners) {
+          layerPropertyOwners = <Record<string, AnimationCurveLayerOwner>>Object.create(null);
+          layerCurveOwnerPool.set(component, layerPropertyOwners);
+        }
         const layerOwner = (layerPropertyOwners[property] ||= curve._createCurveLayerOwner(owner));
 
         if (mask && mask.pathMasks.length) {
diff --git a/packages/core/src/animation/internal/AnimatorLayerData.ts b/packages/core/src/animation/internal/AnimatorLayerData.ts
index a7bd04f1a5..959aadf208 100644
--- a/packages/core/src/animation/internal/AnimatorLayerData.ts
+++ b/packages/core/src/animation/internal/AnimatorLayerData.ts
@@ -1,3 +1,4 @@
+import { Component } from "../../Component";
 import { AnimatorControllerLayer } from "../AnimatorControllerLayer";
 import { AnimatorStateTransition } from "../AnimatorStateTransition";
 import { LayerState } from "../enums/LayerState";
@@ -11,7 +12,7 @@ import { AnimatorStatePlayData } from "./AnimatorStatePlayData";
 export class AnimatorLayerData {
   layerIndex: number;
   layer: AnimatorControllerLayer;
-  curveOwnerPool: Record<number, Record<string, AnimationCurveLayerOwner>> = Object.create(null);
+  curveOwnerPool: WeakMap<Component, Record<string, AnimationCurveLayerOwner>> = new WeakMap();
   animatorStateDataMap: Record<string, AnimatorStateData> = {};
   srcPlayData: AnimatorStatePlayData = new AnimatorStatePlayData();
   destPlayData: AnimatorStatePlayData = new AnimatorStatePlayData();

From 09081f1b7b4aaee55efc5a609c7669515423a97d Mon Sep 17 00:00:00 2001
From: luzhuang <wz84888@antgroup.com>
Date: Thu, 11 Jun 2026 15:37:56 +0800
Subject: [PATCH 09/10] chore(animation): remove stale animator state instance

---
 .../src/animation/AnimatorStateInstance.ts    | 76 -------------------
 tests/src/core/AnimatorHang.test.ts           | 20 +++++
 2 files changed, 20 insertions(+), 76 deletions(-)
 delete mode 100644 packages/core/src/animation/AnimatorStateInstance.ts
 create mode 100644 tests/src/core/AnimatorHang.test.ts

diff --git a/packages/core/src/animation/AnimatorStateInstance.ts b/packages/core/src/animation/AnimatorStateInstance.ts
deleted file mode 100644
index 9bcdfa0fb5..0000000000
--- a/packages/core/src/animation/AnimatorStateInstance.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { AnimationClip } from "./AnimationClip";
-import { AnimatorState } from "./AnimatorState";
-import { AnimatorStatePlayData } from "./internal/AnimatorStatePlayData";
-import { WrapMode } from "./enums/WrapMode";
-
-/**
- * Per-Animator view of an `AnimatorState`.
- *
- * Override fields (speed, wrapMode) are scoped to this Animator; 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;
-
-  /**
-   * The name of the underlying state.
-   */
-  get name(): string {
-    return this._state.name;
-  }
-
-  /**
-   * The animation clip of the underlying state.
-   */
-  get clip(): AnimationClip {
-    return this._state.clip;
-  }
-
-  /**
-   * The normalized clip start time of the underlying state.
-   */
-  get clipStartTime(): number {
-    return this._state.clipStartTime;
-  }
-
-  /**
-   * The normalized clip end time of the underlying state.
-   */
-  get clipEndTime(): number {
-    return this._state.clipEndTime;
-  }
-
-  /**
-   * Playback speed for this Animator; overrides the underlying state when set.
-   */
-  get speed(): number {
-    return this._speed ?? this._state.speed;
-  }
-
-  set speed(value: number) {
-    this._speed = value;
-  }
-
-  /**
-   * Wrap mode for this Animator; overrides the underlying state when set.
-   */
-  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/tests/src/core/AnimatorHang.test.ts b/tests/src/core/AnimatorHang.test.ts
new file mode 100644
index 0000000000..99a8a5ba14
--- /dev/null
+++ b/tests/src/core/AnimatorHang.test.ts
@@ -0,0 +1,20 @@
+import { Animator, Camera } from "@galacean/engine-core";
+import "@galacean/engine-loader";
+import type { GLTFResource } from "@galacean/engine-loader";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
+import { describe, expect, it } from "vitest";
+import { glbResource } from "./model/fox";
+const canvasDOM = document.createElement("canvas");
+canvasDOM.width = 1024;
+canvasDOM.height = 1024;
+describe("Canvas 1024 test", async function () {
+  const engine = await WebGLEngine.create({ canvas: canvasDOM });
+  const scene = engine.sceneManager.activeScene;
+  const rootEntity = scene.createRootEntity();
+  rootEntity.addComponent(Camera);
+  const resource = await engine.resourceManager.load<GLTFResource>(glbResource);
+  const defaultSceneRoot = resource.defaultSceneRoot;
+  rootEntity.addChild(defaultSceneRoot);
+  const animator = defaultSceneRoot.getComponent(Animator);
+  it("loaded", () => { expect(animator).not.eq(null); });
+});

From 8a0924f3ff1e2bb62f73cd1e6f7f2e6e550b4f28 Mon Sep 17 00:00:00 2001
From: luzhuang <wz84888@antgroup.com>
Date: Mon, 1 Jun 2026 17:14:20 +0800
Subject: [PATCH 10/10] fix: optimize physics contact event demand

---
 packages/core/src/physics/PhysicsScene.ts     | 23 +++++
 packages/design/src/physics/IPhysicsScene.ts  |  6 ++
 packages/physics-lite/src/LitePhysicsScene.ts |  7 ++
 .../physics-physx/src/PhysXPhysicsScene.ts    | 17 ++++
 tests/src/core/physics/PhysicsScene.test.ts   | 92 +++++++++++++++++++
 5 files changed, 145 insertions(+)

diff --git a/packages/core/src/physics/PhysicsScene.ts b/packages/core/src/physics/PhysicsScene.ts
index ce6bf2e4e8..5fccc08246 100644
--- a/packages/core/src/physics/PhysicsScene.ts
+++ b/packages/core/src/physics/PhysicsScene.ts
@@ -646,6 +646,7 @@ export class PhysicsScene {
     for (let i = 0; i < step; i++) {
       componentsManager.callScriptOnPhysicsUpdate();
       this._callColliderOnUpdate();
+      nativePhysicsManager.setContactEventEnabled(this._hasCollisionEventConsumers());
       nativePhysicsManager.update(fixedTimeStep);
       this._callColliderOnLateUpdate();
       this._dispatchEvents(nativePhysicsManager.updateEvents());
@@ -825,6 +826,28 @@ export class PhysicsScene {
     }
   }
 
+  private _hasCollisionEventConsumers(): boolean {
+    const { _elements: colliders } = this._colliders;
+    const { onCollisionEnter, onCollisionExit, onCollisionStay } = Script.prototype;
+
+    for (let i = this._colliders.length - 1; i >= 0; --i) {
+      const scripts = colliders[i].entity._scripts;
+      const scriptElements = scripts._elements;
+      for (let j = scripts.length - 1; j >= 0; --j) {
+        const script = scriptElements[j];
+        if (
+          script.onCollisionEnter !== onCollisionEnter ||
+          script.onCollisionExit !== onCollisionExit ||
+          script.onCollisionStay !== onCollisionStay
+        ) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   private _setGravity(): void {
     this._nativePhysicsScene.setGravity(this._gravity);
   }
diff --git a/packages/design/src/physics/IPhysicsScene.ts b/packages/design/src/physics/IPhysicsScene.ts
index 5520114104..e5b8d9f335 100644
--- a/packages/design/src/physics/IPhysicsScene.ts
+++ b/packages/design/src/physics/IPhysicsScene.ts
@@ -43,6 +43,12 @@ export interface IPhysicsScene {
    */
   update(elapsedTime: number): void;
 
+  /**
+   * Enable contact event buffering.
+   * @param enabled - Whether collision contact events should be buffered for dispatch.
+   */
+  setContactEventEnabled(enabled: boolean): void;
+
   /**
    * Collect buffered collision and trigger events.
    * Must be called after update() and after syncing transforms back from physics.
diff --git a/packages/physics-lite/src/LitePhysicsScene.ts b/packages/physics-lite/src/LitePhysicsScene.ts
index 0b6b6eb3e8..58742b5069 100644
--- a/packages/physics-lite/src/LitePhysicsScene.ts
+++ b/packages/physics-lite/src/LitePhysicsScene.ts
@@ -115,6 +115,13 @@ export class LitePhysicsScene implements IPhysicsScene {
     }
   }
 
+  /**
+   * {@inheritDoc IPhysicsScene.setContactEventEnabled }
+   */
+  setContactEventEnabled(_enabled: boolean): void {
+    // Physics-lite only produces trigger events, so there is no contact buffer to toggle.
+  }
+
   /**
    * {@inheritDoc IPhysicsScene.updateEvents }
    */
diff --git a/packages/physics-physx/src/PhysXPhysicsScene.ts b/packages/physics-physx/src/PhysXPhysicsScene.ts
index d026304e4d..bee2ab2dc2 100644
--- a/packages/physics-physx/src/PhysXPhysicsScene.ts
+++ b/packages/physics-physx/src/PhysXPhysicsScene.ts
@@ -50,6 +50,7 @@ export class PhysXPhysicsScene implements IPhysicsScene {
   private _activeTriggers: DisorderedArray<TriggerEvent> = new DisorderedArray<TriggerEvent>();
   private _contactEvents: ContactEvent[] = [];
   private _contactEventCount = 0;
+  private _contactEventEnabled = true;
   private _triggerEvents: TriggerEvent[] = [];
   private _physicsEvents: IPhysicsEvents = { contactEvents: [], contactEventCount: 0, triggerEvents: [] };
 
@@ -191,6 +192,20 @@ export class PhysXPhysicsScene implements IPhysicsScene {
     this._fetchResults();
   }
 
+  /**
+   * {@inheritDoc IPhysicsScene.setContactEventEnabled }
+   */
+  setContactEventEnabled(enabled: boolean): void {
+    if (this._contactEventEnabled === enabled) {
+      return;
+    }
+
+    this._contactEventEnabled = enabled;
+    if (!enabled) {
+      this._contactEventCount = 0;
+    }
+  }
+
   /**
    * {@inheritDoc IPhysicsScene.updateEvents }
    */
@@ -547,6 +562,8 @@ export class PhysXPhysicsScene implements IPhysicsScene {
   }
 
   private _bufferContactEvent(collision: ICollision, state: number): void {
+    if (!this._contactEventEnabled) return;
+
     const index = this._contactEventCount++;
     const event = (this._contactEvents[index] ||= new ContactEvent());
     event.shape0Id = collision.shape0Id;
diff --git a/tests/src/core/physics/PhysicsScene.test.ts b/tests/src/core/physics/PhysicsScene.test.ts
index a62067db59..9f258a1e2d 100644
--- a/tests/src/core/physics/PhysicsScene.test.ts
+++ b/tests/src/core/physics/PhysicsScene.test.ts
@@ -73,12 +73,44 @@ class CollisionTestScript extends Script {
   }
 }
 
+class CollisionDemandScript extends Script {
+  onCollisionEnter(): void {}
+}
+
+class TriggerDemandScript extends Script {
+  onTriggerEnter(): void {}
+}
+
 function updatePhysics(physics) {
   for (let i = 0; i < 5; ++i) {
     physics._update(8);
   }
 }
 
+function watchNativeContactEventDemand(physicsScene: PhysicsScene) {
+  const nativeScene = (physicsScene as any)._nativePhysicsScene;
+  const original = nativeScene.setContactEventEnabled;
+  const calls: boolean[] = [];
+  nativeScene.setContactEventEnabled = (enabled: boolean) => {
+    calls.push(enabled);
+    original?.call(nativeScene, enabled);
+  };
+  return {
+    calls,
+    restore() {
+      if (original) {
+        nativeScene.setContactEventEnabled = original;
+      } else {
+        delete nativeScene.setContactEventEnabled;
+      }
+    }
+  };
+}
+
+function getLastContactEventDemandCall(calls: boolean[]): boolean {
+  return calls[calls.length - 1];
+}
+
 function resetSpy() {
   // reset spy on collision test script.
   CollisionTestScript.prototype.onCollisionEnter = vi.fn(CollisionTestScript.prototype.onCollisionEnter);
@@ -421,6 +453,66 @@ describe("Physics Test", () => {
       expect(enginePhysX.sceneManager.scenes[0].physics.fixedTimeStep).to.eq(fixedTimeStep);
     });
 
+    it("auto-disables native contact events when no active collision callback exists", () => {
+      const scene = enginePhysX.sceneManager.activeScene;
+      const physicsScene = scene.physics;
+      const root = scene.createRootEntity("contact-demand-disabled");
+      const entity = root.createChild("body");
+      const collider = entity.addComponent(StaticCollider);
+      collider.addShape(new BoxColliderShape());
+      const contactEventDemand = watchNativeContactEventDemand(physicsScene);
+
+      try {
+        physicsScene._update(physicsScene.fixedTimeStep);
+        expect(getLastContactEventDemandCall(contactEventDemand.calls)).to.eq(false);
+      } finally {
+        contactEventDemand.restore();
+        root.destroy();
+      }
+    });
+
+    it("auto-enables native contact events only while an active collision callback exists", () => {
+      const scene = enginePhysX.sceneManager.activeScene;
+      const physicsScene = scene.physics;
+      const root = scene.createRootEntity("contact-demand-enabled");
+      const entity = root.createChild("body");
+      const collider = entity.addComponent(StaticCollider);
+      collider.addShape(new BoxColliderShape());
+      const script = entity.addComponent(CollisionDemandScript);
+      const contactEventDemand = watchNativeContactEventDemand(physicsScene);
+
+      try {
+        physicsScene._update(physicsScene.fixedTimeStep);
+        expect(getLastContactEventDemandCall(contactEventDemand.calls)).to.eq(true);
+
+        script.enabled = false;
+        physicsScene._update(physicsScene.fixedTimeStep);
+        expect(getLastContactEventDemandCall(contactEventDemand.calls)).to.eq(false);
+      } finally {
+        contactEventDemand.restore();
+        root.destroy();
+      }
+    });
+
+    it("keeps native contact events disabled when only trigger callbacks exist", () => {
+      const scene = enginePhysX.sceneManager.activeScene;
+      const physicsScene = scene.physics;
+      const root = scene.createRootEntity("contact-demand-trigger-only");
+      const entity = root.createChild("body");
+      const collider = entity.addComponent(StaticCollider);
+      collider.addShape(new BoxColliderShape());
+      entity.addComponent(TriggerDemandScript);
+      const contactEventDemand = watchNativeContactEventDemand(physicsScene);
+
+      try {
+        physicsScene._update(physicsScene.fixedTimeStep);
+        expect(getLastContactEventDemandCall(contactEventDemand.calls)).to.eq(false);
+      } finally {
+        contactEventDemand.restore();
+        root.destroy();
+      }
+    });
+
     it("raycast", () => {
       const scene = enginePhysX.sceneManager.activeScene;
       const physicsScene = scene.physics;