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/mesh/ModelMesh.ts b/packages/core/src/mesh/ModelMesh.ts
index 27b92ced49..8ee92c4825 100644
--- a/packages/core/src/mesh/ModelMesh.ts
+++ b/packages/core/src/mesh/ModelMesh.ts
@@ -925,7 +925,7 @@ export class ModelMesh extends Mesh {
       return null;
     }
     if (!buffer.readable) {
-      throw "Not allowed to access data while vertex buffer readable is false.";
+      throw new Error("Not allowed to access data while vertex buffer readable is false.");
     }
 
     const vertexCount = this.vertexCount;
diff --git a/tests/src/core/CloneUtils.test.ts b/tests/src/core/CloneUtils.test.ts
index 79fb05fdfa..80ffbe27dd 100644
--- a/tests/src/core/CloneUtils.test.ts
+++ b/tests/src/core/CloneUtils.test.ts
@@ -7,7 +7,7 @@ import {
   deepClone,
   ignoreClone
 } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { describe, expect, it } from "vitest";
 
 class TestScript extends Script {
@@ -87,6 +87,26 @@ class NestedObjectScript extends Script {
   config: { target: Entity; label: string } = { target: null, label: "" };
 }
 
+/** Script with UNDECORATED array of entities (no @deepClone) */
+class UndecoratedArrayScript extends Script {
+  entities: Entity[] = [];
+}
+
+/** Script with UNDECORATED nested object containing entity refs */
+class UndecoratedObjectScript extends Script {
+  config: { target: Entity; label: string } = { target: null, label: "" };
+}
+
+/** Script with UNDECORATED nested array of arrays containing entities */
+class NestedArrayScript extends Script {
+  groups: Entity[][] = [];
+}
+
+/** Script with UNDECORATED Map containing entity values */
+class MapRefScript extends Script {
+  entityMap: Map<string, Entity> = new Map();
+}
+
 /** Script for testing multiple same-type components on one entity */
 class CounterScript extends Script {
   value: number = 0;
@@ -244,7 +264,9 @@ describe("Clone remap", async () => {
       expect(clonedScript.speed).eq(42);
       expect(clonedScript.name2).eq("test");
       expect(clonedScript.flag).eq(true);
-      expect(clonedScript.data).eq(obj);
+      // Plain objects are now deep cloned (independent copy) for undecorated properties
+      expect(clonedScript.data).not.eq(obj);
+      expect((<any>clonedScript.data).x).eq(1);
 
       rootEntity.destroy();
     });
@@ -873,4 +895,142 @@ describe("Clone remap", async () => {
       rootEntity.destroy();
     });
   });
+
+  describe("Undecorated array auto clone + remap (type inference)", () => {
+    it("undecorated entity array should create new array and remap elements", () => {
+      const rootEntity = scene.createRootEntity("root");
+      const parent = rootEntity.createChild("parent");
+      const childA = parent.createChild("childA");
+      const childB = parent.createChild("childB");
+      const script = parent.addComponent(UndecoratedArrayScript);
+      script.entities = [childA, childB];
+
+      const cloned = parent.clone();
+      const cs = cloned.getComponent(UndecoratedArrayScript);
+
+      expect(cs.entities).not.eq(script.entities);
+      expect(cs.entities.length).eq(2);
+      expect(cs.entities[0]).not.eq(childA);
+      expect(cs.entities[1]).not.eq(childB);
+      expect(cs.entities[0]).eq(cloned.children[0]);
+      expect(cs.entities[1]).eq(cloned.children[1]);
+
+      rootEntity.destroy();
+    });
+
+    it("undecorated entity array with external ref keeps original", () => {
+      const rootEntity = scene.createRootEntity("root");
+      const parent = rootEntity.createChild("parent");
+      const child = parent.createChild("child");
+      const external = rootEntity.createChild("external");
+      const script = parent.addComponent(UndecoratedArrayScript);
+      script.entities = [child, external];
+
+      const cloned = parent.clone();
+      const cs = cloned.getComponent(UndecoratedArrayScript);
+
+      expect(cs.entities[0]).eq(cloned.children[0]);
+      expect(cs.entities[1]).eq(external);
+
+      rootEntity.destroy();
+    });
+
+    it("undecorated empty array stays empty with independent reference", () => {
+      const rootEntity = scene.createRootEntity("root");
+      const parent = rootEntity.createChild("parent");
+      const script = parent.addComponent(UndecoratedArrayScript);
+      script.entities = [];
+
+      const cloned = parent.clone();
+      const cs = cloned.getComponent(UndecoratedArrayScript);
+
+      expect(cs.entities).not.eq(script.entities);
+      expect(cs.entities.length).eq(0);
+
+      rootEntity.destroy();
+    });
+  });
+
+  describe("Undecorated nested object auto clone + remap (type inference)", () => {
+    it("undecorated object with entity ref should deep clone and remap", () => {
+      const rootEntity = scene.createRootEntity("root");
+      const parent = rootEntity.createChild("parent");
+      const child = parent.createChild("child");
+      const script = parent.addComponent(UndecoratedObjectScript);
+      script.config = { target: child, label: "hello" };
+
+      const cloned = parent.clone();
+      const cs = cloned.getComponent(UndecoratedObjectScript);
+
+      expect(cs.config).not.eq(script.config);
+      expect(cs.config.label).eq("hello");
+      expect(cs.config.target).not.eq(child);
+      expect(cs.config.target).eq(cloned.children[0]);
+
+      rootEntity.destroy();
+    });
+
+    it("undecorated object with external entity ref keeps original", () => {
+      const rootEntity = scene.createRootEntity("root");
+      const parent = rootEntity.createChild("parent");
+      const external = rootEntity.createChild("external");
+      const script = parent.addComponent(UndecoratedObjectScript);
+      script.config = { target: external, label: "ext" };
+
+      const cloned = parent.clone();
+      const cs = cloned.getComponent(UndecoratedObjectScript);
+
+      expect(cs.config.target).eq(external);
+      expect(cs.config.label).eq("ext");
+
+      rootEntity.destroy();
+    });
+  });
+
+  describe("Nested array of arrays with entity refs (type inference)", () => {
+    it("undecorated nested entity arrays should recursively clone and remap", () => {
+      const rootEntity = scene.createRootEntity("root");
+      const parent = rootEntity.createChild("parent");
+      const childA = parent.createChild("childA");
+      const childB = parent.createChild("childB");
+      const childC = parent.createChild("childC");
+      const script = parent.addComponent(NestedArrayScript);
+      script.groups = [[childA, childB], [childC]];
+
+      const cloned = parent.clone();
+      const cs = cloned.getComponent(NestedArrayScript);
+
+      expect(cs.groups).not.eq(script.groups);
+      expect(cs.groups.length).eq(2);
+      expect(cs.groups[0]).not.eq(script.groups[0]);
+      expect(cs.groups[1]).not.eq(script.groups[1]);
+      expect(cs.groups[0][0]).eq(cloned.children[0]);
+      expect(cs.groups[0][1]).eq(cloned.children[1]);
+      expect(cs.groups[1][0]).eq(cloned.children[2]);
+
+      rootEntity.destroy();
+    });
+  });
+
+  describe("Map with entity values (type inference)", () => {
+    it("undecorated Map should create new Map and remap entity values", () => {
+      const rootEntity = scene.createRootEntity("root");
+      const parent = rootEntity.createChild("parent");
+      const child = parent.createChild("child");
+      const external = rootEntity.createChild("external");
+      const script = parent.addComponent(MapRefScript);
+      script.entityMap.set("internal", child);
+      script.entityMap.set("external", external);
+
+      const cloned = parent.clone();
+      const cs = cloned.getComponent(MapRefScript);
+
+      expect(cs.entityMap).not.eq(script.entityMap);
+      expect(cs.entityMap.size).eq(2);
+      expect(cs.entityMap.get("internal")).eq(cloned.children[0]);
+      expect(cs.entityMap.get("external")).eq(external);
+
+      rootEntity.destroy();
+    });
+  });
 });