@directivegames/genesys.js 3.1.24

package/dist/test/prefab.test.js

@@ -0,0 +1,903 @@
+import * as ENGINE from 'genesys.js';
+import QUnit from 'qunit';
+import * as THREE from 'three';
+import { reloadActor, TestActor, TestSceneComponent, } from './utils.js';
+const DEBUG_LOG_PREFAB_PROPERTY_OVERRIDE = false;
+const DEBUG_LOG_PREFAB_INHERITANCE_MULTI_LEVEL = false;
+const DEBUG_LOG_PREFAB_UUID = false;
+const warningExists = (func, searchString) => {
+    const originWarn = console.warn;
+    const warnings = [];
+    console.warn = (...args) => { warnings.push(...args); };
+    func();
+    console.warn = originWarn;
+    return warnings.some(msg => String(msg).includes(searchString));
+};
+const warningExistsAsync = async (func, searchString) => {
+    const originWarn = console.warn;
+    const warnings = [];
+    console.warn = (...args) => { warnings.push(...args); };
+    await func();
+    console.warn = originWarn;
+    return warnings.some(msg => String(msg).includes(searchString));
+};
+QUnit.module('Prefab', hooks => {
+    hooks.before(() => {
+    });
+    hooks.beforeEach(() => {
+        ENGINE.clearCdoCache();
+    });
+    QUnit.test('prefab instance override', async (assert) => {
+        const prefabRootData = [123, 456];
+        const prefabComponentData = [789, 101];
+        const originalRootComponent = new TestSceneComponent({
+            data: prefabRootData[0],
+        });
+        originalRootComponent.otherData = prefabRootData[1];
+        const originalSceneComponent = new TestSceneComponent({
+            data: prefabComponentData[0],
+        });
+        originalSceneComponent.otherData = prefabComponentData[1];
+        const originalActor = new TestActor({
+            rootComponent: originalRootComponent,
+            sceneComponents: [
+                originalSceneComponent,
+            ],
+        });
+        //=========================================================================
+        const prefabData = originalActor.asExportedPrefabData();
+        const prefabName = 'prefab';
+        const instancePosition = new THREE.Vector3(10, 20, 30);
+        const instanceRotation = new THREE.Euler(0.4, 0.5, 0.6);
+        const instanceScale = new THREE.Vector3(100, 200, 300);
+        for (let index = 0; index < 4; index++) {
+            const instanceRootData = [index === 0 ? -123 : undefined, index === 1 ? -456 : undefined];
+            const instanceComponentData = [index === 2 ? -789 : undefined, index === 3 ? -101 : undefined];
+            // laod an instance actor them modify its properties
+            const instanceActor = await ENGINE.Actor.spawnPrefabActor(prefabName, {
+                position: instancePosition,
+                rotation: instanceRotation,
+                scale: instanceScale,
+            }, { [prefabName]: prefabData });
+            assert.ok(instanceActor instanceof TestActor, 'Instance actor is a TestActor');
+            assert.deepEqual(instanceActor.getWorldPosition(), instancePosition);
+            const instanceActorData = `instance actor data ${index}`;
+            const instanceActorCustomData = `instance actor other data ${index}`;
+            instanceActor.options.actorData = instanceActorData;
+            instanceActor.customActorData = instanceActorCustomData;
+            if (instanceRootData[0]) {
+                instanceActor.getComponents(TestSceneComponent)[0].options.data = instanceRootData[0];
+            }
+            if (instanceRootData[1]) {
+                instanceActor.getComponents(TestSceneComponent)[0].otherData = instanceRootData[1];
+            }
+            if (instanceComponentData[0]) {
+                instanceActor.getComponents(TestSceneComponent)[1].options.data = instanceComponentData[0];
+            }
+            if (instanceComponentData[1]) {
+                instanceActor.getComponents(TestSceneComponent)[1].otherData = instanceComponentData[1];
+            }
+            const loadedActor = reloadActor(instanceActor, false, { [prefabName]: prefabData });
+            //assert.equal(loadedActor.options.actorData, instanceActorData, 'Loaded actor has the correct actor data');
+            assert.equal(loadedActor.customActorData, instanceActorCustomData, 'Loaded actor has the correct custom actor data');
+            assert.ok(loadedActor.getWorldPosition().almostEquals(instancePosition), 'Loaded actor has the same position');
+            assert.ok(loadedActor.getWorldRotation().almostEquals(instanceRotation), 'Loaded actor has the same rotation');
+            assert.ok(loadedActor.getWorldScale().almostEquals(instanceScale), 'Loaded actor has the same scale');
+            assert.equal(loadedActor.getComponents(TestSceneComponent).length, 2, 'Loaded actor has two scene components');
+            const loadedRootComponent = loadedActor.getComponents(TestSceneComponent)[0];
+            if (loadedRootComponent) {
+                // assert.equal(loadedRootComponent.options.data, instanceRootData[0] ?? prefabRootData[0], 'Loaded root component has the correct data');
+                assert.equal(loadedRootComponent.otherData, instanceRootData[1] ?? prefabRootData[1], 'Loaded root component has the correct other data');
+            }
+            const loadedSceneComponent = loadedActor.getComponents(TestSceneComponent)[1];
+            if (loadedSceneComponent) {
+                // assert.equal(loadedSceneComponent.options.data, instanceComponentData[0] ?? prefabComponentData[0], 'Loaded scene component has the correct data');
+                assert.equal(loadedSceneComponent.otherData, instanceComponentData[1] ?? prefabComponentData[1], 'Loaded scene component has the correct other data');
+            }
+        }
+    });
+    QUnit.test('load prefab template', async (assert) => {
+        {
+            const prefabRootData = [123, 456];
+            const prefabComponentData = [789, 101];
+            const originalRootComponent = new TestSceneComponent({
+                data: prefabRootData[0],
+            });
+            originalRootComponent.otherData = prefabRootData[1];
+            const originalSceneComponent = new TestSceneComponent({
+                data: prefabComponentData[0],
+            });
+            originalSceneComponent.otherData = prefabComponentData[1];
+            const originalActor = new TestActor({
+                position: new THREE.Vector3(1, 2, 3),
+                rotation: new THREE.Euler(0.1, 0.2, 0.3),
+                scale: new THREE.Vector3(4, 5, 6),
+                rootComponent: originalRootComponent,
+                sceneComponents: [
+                    originalSceneComponent,
+                ],
+            });
+            const prefabPosition = new THREE.Vector3(10, 20, 30);
+            const prefabRotation = new THREE.Euler(0.4, 0.5, 0.6);
+            const prefabScale = new THREE.Vector3(100, 200, 300);
+            const prefabData = originalActor.asExportedObject();
+            const prefabName = 'prefab';
+            const prefabActor = await ENGINE.Actor.spawnPrefabActor(prefabName, {
+                position: prefabPosition,
+                rotation: prefabRotation,
+                scale: prefabScale,
+            }, { [prefabName]: prefabData });
+            assert.ok(prefabActor instanceof TestActor, 'Prefab actor is a TestActor');
+            const loadedActor = reloadActor(prefabActor, false, { [prefabName]: prefabData });
+            assert.ok(loadedActor.getWorldPosition().almostEquals(prefabPosition), 'Loaded actor has the same position');
+            assert.ok(loadedActor.getWorldRotation().almostEquals(prefabRotation), 'Loaded actor has the same rotation');
+            assert.ok(loadedActor.getWorldScale().almostEquals(prefabScale), 'Loaded actor has the same scale');
+            assert.equal(loadedActor.getComponents(TestSceneComponent).length, 2, 'Loaded actor has two scene components');
+            const loadedRootComponent = loadedActor.getComponents(TestSceneComponent)[0];
+            if (loadedRootComponent) {
+                assert.equal(loadedRootComponent.options.data, prefabRootData[0], 'Loaded root component has the correct data');
+                assert.equal(loadedRootComponent.otherData, prefabRootData[1], 'Loaded root component has the correct other data');
+            }
+            const loadedSceneComponent = loadedActor.getComponents(TestSceneComponent)[1];
+            if (loadedSceneComponent) {
+                assert.equal(loadedSceneComponent.options.data, prefabComponentData[0], 'Loaded scene component has the correct data');
+                assert.equal(loadedSceneComponent.otherData, prefabComponentData[1], 'Loaded scene component has the correct other data');
+            }
+            // loading prefab actor with no data should throw
+            // remove the prefab data from cache first to simulate missing data
+            ENGINE.PrefabManager.setPrefabData(prefabName, undefined);
+            assert.ok(warningExists(() => {
+                reloadActor(prefabActor, false);
+            }, 'Failed to instantiate prefab'), 'Loading prefab actor with no prefab data should warn');
+        }
+    });
+    QUnit.test('load legacy prefab template', async (assert) => {
+        {
+            const prefabRootData = [123, 456];
+            const prefabComponentData = [789, 101];
+            const originalRootComponent = new TestSceneComponent({
+                data: prefabRootData[0],
+            });
+            originalRootComponent.otherData = prefabRootData[1];
+            const originalSceneComponent = new TestSceneComponent({
+                data: prefabComponentData[0],
+            });
+            originalSceneComponent.otherData = prefabComponentData[1];
+            const originalActor = new TestActor({
+                position: new THREE.Vector3(1, 2, 3),
+                rotation: new THREE.Euler(0.1, 0.2, 0.3),
+                scale: new THREE.Vector3(4, 5, 6),
+                rootComponent: originalRootComponent,
+                sceneComponents: [
+                    originalSceneComponent,
+                ],
+            });
+            const prefabPosition = new THREE.Vector3(10, 20, 30);
+            const prefabRotation = new THREE.Euler(0.4, 0.5, 0.6);
+            const prefabScale = new THREE.Vector3(100, 200, 300);
+            const prefabData = originalActor.asExportedObject();
+            const prefabName = 'prefab';
+            const prefabActor = await ENGINE.Actor.spawnPrefabActor(prefabName, {
+                position: prefabPosition,
+                rotation: prefabRotation,
+                scale: prefabScale,
+            }, { [prefabName]: prefabData });
+            assert.ok(prefabActor instanceof TestActor, 'Prefab actor is a TestActor');
+            const prefabActorData = JSON.parse(JSON.stringify(prefabActor.asExportedObject()));
+            const loadedActor = ENGINE.WorldSerializer.loadActorSync(prefabActorData, { [prefabName]: prefabData });
+            assert.ok(loadedActor, 'Loaded actor should not be null');
+            if (!loadedActor)
+                return;
+            assert.ok(loadedActor.getWorldPosition().almostEquals(prefabPosition), 'Loaded actor has the same position');
+            assert.ok(loadedActor.getWorldRotation().almostEquals(prefabRotation), 'Loaded actor has the same rotation');
+            assert.ok(loadedActor.getWorldScale().almostEquals(prefabScale), 'Loaded actor has the same scale');
+            assert.equal(loadedActor.getComponents(TestSceneComponent).length, 2, 'Loaded actor has two scene components');
+            const loadedRootComponent = loadedActor.getComponents(TestSceneComponent)[0];
+            if (loadedRootComponent) {
+                assert.equal(loadedRootComponent.options.data, prefabRootData[0], 'Loaded root component has the correct data');
+                assert.equal(loadedRootComponent.otherData, prefabRootData[1], 'Loaded root component has the correct other data');
+            }
+            const loadedSceneComponent = loadedActor.getComponents(TestSceneComponent)[1];
+            if (loadedSceneComponent) {
+                assert.equal(loadedSceneComponent.options.data, prefabComponentData[0], 'Loaded scene component has the correct data');
+                assert.equal(loadedSceneComponent.otherData, prefabComponentData[1], 'Loaded scene component has the correct other data');
+            }
+            // loading prefab actor with no data should throw
+            ENGINE.PrefabManager.setPrefabData(prefabName, undefined);
+            assert.ok(warningExists(() => {
+                ENGINE.WorldSerializer.loadActorSync(prefabActorData);
+            }, 'Failed to instantiate prefab'), 'Loading prefab actor with no prefab data should warn');
+        }
+    });
+    QUnit.test('spawn prefab instance', async (assert) => {
+        {
+            const prefabRootData = [123, 456];
+            const prefabComponentData = [789, 101];
+            const originalRootComponent = new TestSceneComponent({
+                data: prefabRootData[0],
+            });
+            originalRootComponent.otherData = prefabRootData[1];
+            const originalSceneComponent = new TestSceneComponent({
+                data: prefabComponentData[0],
+            });
+            originalSceneComponent.otherData = prefabComponentData[1];
+            const originalActor = new TestActor({
+                position: new THREE.Vector3(1, 2, 3),
+                rotation: new THREE.Euler(0.1, 0.2, 0.3),
+                scale: new THREE.Vector3(4, 5, 6),
+                rootComponent: originalRootComponent,
+                sceneComponents: [
+                    originalSceneComponent,
+                ],
+            });
+            const prefabPosition = new THREE.Vector3(10, 20, 30);
+            const prefabRotation = new THREE.Euler(0.4, 0.5, 0.6);
+            const prefabScale = new THREE.Vector3(100, 200, 300);
+            const prefabData = originalActor.asExportedObject();
+            const prefabName = 'prefab';
+            const loadedActor = await ENGINE.Actor.spawnPrefabActor(prefabName, {
+                position: prefabPosition,
+                rotation: prefabRotation,
+                scale: prefabScale,
+            }, { [prefabName]: prefabData });
+            assert.ok(loadedActor instanceof TestActor, 'Loaded actor is a TestActor');
+            assert.ok(loadedActor, 'Loaded actor should not be null');
+            if (!loadedActor)
+                return;
+            assert.equal(loadedActor.getPrefabName(), prefabName, 'Loaded actor has the correct prefab name');
+            assert.ok(loadedActor.getWorldPosition().almostEquals(prefabPosition), 'Loaded actor has the same position');
+            assert.ok(loadedActor.getWorldRotation().almostEquals(prefabRotation), 'Loaded actor has the same rotation');
+            assert.ok(loadedActor.getWorldScale().almostEquals(prefabScale), 'Loaded actor has the same scale');
+            assert.equal(loadedActor.getComponents(TestSceneComponent).length, 2, 'Loaded actor has two scene components');
+            const loadedRootComponent = loadedActor.getComponents(TestSceneComponent)[0];
+            if (loadedRootComponent) {
+                assert.equal(loadedRootComponent.options.data, prefabRootData[0], 'Loaded root component has the correct data');
+                assert.equal(loadedRootComponent.otherData, prefabRootData[1], 'Loaded root component has the correct other data');
+            }
+            const loadedSceneComponent = loadedActor.getComponents(TestSceneComponent)[1];
+            if (loadedSceneComponent) {
+                assert.equal(loadedSceneComponent.options.data, prefabComponentData[0], 'Loaded scene component has the correct data');
+                assert.equal(loadedSceneComponent.otherData, prefabComponentData[1], 'Loaded scene component has the correct other data');
+            }
+            // spawning prefab actor with no data should throw
+            ENGINE.PrefabManager.setPrefabData(prefabName, undefined);
+            await assert.rejects(ENGINE.Actor.spawnPrefabActor(prefabName, {
+                position: prefabPosition,
+                rotation: prefabRotation,
+                scale: prefabScale,
+            }), 'Spawning prefab actor with no prefab data should throw');
+        }
+    });
+    QUnit.test('prefab template property override', async (assert) => {
+        const originalActor = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 123 }),
+        });
+        const prefabName = 'basePrefab';
+        // Create initial prefab data
+        let prefabData = ENGINE.WorldSerializer.createPrefabDataFromActor(originalActor);
+        DEBUG_LOG_PREFAB_PROPERTY_OVERRIDE && console.log('🛠 originalActor', originalActor.uuid, JSON.stringify(prefabData, null, 2));
+        // Load the prefab template actor and modify its visible property
+        const templateActor = ENGINE.WorldSerializer.loadPrefabTemplateActor(prefabName, { [prefabName]: prefabData });
+        templateActor.rootComponent.visible = false;
+        prefabData = templateActor.asExportedObject(false);
+        DEBUG_LOG_PREFAB_PROPERTY_OVERRIDE && console.log('🔧 templateActor', templateActor.uuid, JSON.stringify(prefabData, null, 2));
+        // Spawn the prefab instance actor and modify its visible property
+        const visibleTestPrefab = 'visibleTestPrefab';
+        const instanceActor = await ENGINE.Actor.spawnPrefabActor(visibleTestPrefab, {}, { [visibleTestPrefab]: prefabData });
+        instanceActor.rootComponent.visible = true;
+        const instanceActorData = instanceActor.asExportedObject(false);
+        DEBUG_LOG_PREFAB_PROPERTY_OVERRIDE && console.log('🎭 instanceActor', instanceActor.uuid, JSON.stringify(instanceActorData, null, 2));
+        // The exported data should contain the visible override in the root component
+        assert.ok(instanceActorData.$root && instanceActorData.$root.rootComponent);
+        assert.ok('visible' in instanceActorData.$root.rootComponent, 'Instance data should contain visible property override in root component');
+        assert.equal(instanceActorData.$root.rootComponent.visible, true, 'Visible property override should be true (instance has visible=true, prefab has visible=false)');
+        // Reload the actor to verify the override persists
+        const reloadedActor = reloadActor(instanceActor, false, { [visibleTestPrefab]: prefabData });
+        assert.equal(reloadedActor.rootComponent.visible, true, 'reloadedActor should have visible=true from override');
+        const reloadedActorData = reloadedActor.asExportedObject(false);
+        DEBUG_LOG_PREFAB_PROPERTY_OVERRIDE && console.log('🔄 reloadedActor', reloadedActor.uuid, JSON.stringify(reloadedActorData, null, 2));
+        // Actor should have a uuid
+        assert.ok(reloadedActor.uuid, 'Reloaded actor should have a uuid');
+    });
+    QUnit.test('prefab template inheritance - multi-level hierarchy', async (assert) => {
+        // Create base prefab A (full data)
+        const prefabA = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 100 }),
+            sceneComponents: [
+                new TestSceneComponent({ data: 200 }),
+            ],
+        });
+        prefabA.rootComponent.visible = false;
+        prefabA.rootComponent.castShadow = false;
+        prefabA.customActorData = 'base-data';
+        const prefabAData = ENGINE.WorldSerializer.createPrefabDataFromActor(prefabA);
+        const prefabAName = 'prefabA';
+        DEBUG_LOG_PREFAB_INHERITANCE_MULTI_LEVEL && console.log('🧬 prefabAData', prefabA.uuid, JSON.stringify(prefabAData, null, 2));
+        // Create prefab B that inherits from A (spawn A, then modify and export overrides)
+        const prefabBInstance = await ENGINE.Actor.spawnPrefabActor(prefabAName, {}, { [prefabAName]: prefabAData });
+        prefabBInstance.rootComponent.visible = true; // Override visible from A
+        prefabBInstance.rootComponent.receiveShadow = true; // Add new property
+        prefabBInstance.customActorData = 'override-b-data'; // Override actor data
+        const prefabBData = prefabBInstance.asExportedObject(false); // Export only overrides
+        prefabBData.parentPrefabName = 'prefabA'; // Set parent reference
+        const prefabBName = 'prefabB';
+        DEBUG_LOG_PREFAB_INHERITANCE_MULTI_LEVEL && console.log('🧬 prefabBData', prefabBInstance.uuid, JSON.stringify(prefabBData, null, 2));
+        // Create prefab C that inherits from B (spawn B, then modify and export overrides)
+        const prefabCInstance = await ENGINE.Actor.spawnPrefabActor(prefabBName, {}, {
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        prefabCInstance.rootComponent.castShadow = true; // Override castShadow from A
+        prefabCInstance.rootComponent.renderOrder = 10; // Add new property
+        prefabCInstance.getComponents(TestSceneComponent)[1].options.data = 999; // Override component data
+        const prefabCData = prefabCInstance.asExportedObject(false); // Export only overrides
+        prefabCData.parentPrefabName = 'prefabB'; // Set parent reference
+        const prefabCName = 'prefabC';
+        DEBUG_LOG_PREFAB_INHERITANCE_MULTI_LEVEL && console.log('🧬 prefabCData', prefabCInstance.uuid, JSON.stringify(prefabCData, null, 2));
+        // Test loading prefab C (should inherit from B which inherits from A)
+        const finalPrefabCInstance = await ENGINE.Actor.spawnPrefabActor(prefabCName, {}, {
+            [prefabCName]: prefabCData,
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        DEBUG_LOG_PREFAB_INHERITANCE_MULTI_LEVEL && console.log('🧬 finalPrefabCInstance loaded', finalPrefabCInstance.uuid);
+        // Test that prefab C instance has correct resolved values from inheritance chain
+        assert.equal(finalPrefabCInstance.rootComponent.visible, true, 'C should inherit visible=true from B');
+        assert.equal(finalPrefabCInstance.rootComponent.castShadow, true, 'C should have castShadow=true (overrides A)');
+        assert.equal(finalPrefabCInstance.rootComponent.receiveShadow, true, 'C should inherit receiveShadow=true from B');
+        assert.equal(finalPrefabCInstance.rootComponent.renderOrder, 10, 'C should have renderOrder=10 (new in C)');
+        assert.equal(finalPrefabCInstance.customActorData, 'override-b-data', 'C should inherit customActorData from B');
+        //assert.equal(finalPrefabCInstance.getComponents(TestSceneComponent)[1].options.data, 999, 'C should have overridden component data');
+        // Test reloading the full hierarchy using reloadActor
+        const reloadedC = reloadActor(finalPrefabCInstance, false, {
+            [prefabCName]: prefabCData,
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        DEBUG_LOG_PREFAB_INHERITANCE_MULTI_LEVEL && console.log('🧬 reloadedC', reloadedC.uuid);
+        // Verify the reloaded instance has all the correct resolved values
+        assert.equal(reloadedC.rootComponent.visible, true, 'Reloaded C should have visible=true from B');
+        assert.equal(reloadedC.rootComponent.castShadow, true, 'Reloaded C should have castShadow=true from C');
+        assert.equal(reloadedC.rootComponent.receiveShadow, true, 'Reloaded C should have receiveShadow=true from B');
+        assert.equal(reloadedC.rootComponent.renderOrder, 10, 'Reloaded C should have renderOrder=10 from C');
+        assert.equal(reloadedC.customActorData, 'override-b-data', 'Reloaded C should have customActorData from B');
+        //assert.equal(reloadedC.getComponents(TestSceneComponent)[1].options.data, 999, 'Reloaded C should have component data from C');
+        // Test that actors have UUIDs
+        assert.ok(reloadedC.uuid, 'Reloaded C should have a UUID');
+        assert.ok(reloadedC.rootComponent.uuid, 'Reloaded C root component should have a UUID');
+    });
+    QUnit.test('load legacy prefab instance actor', assert => {
+        const legacyActor = new ENGINE.Actor({
+            prefabName: 'prefab',
+        });
+        assert.equal(legacyActor.getPrefabName(), 'prefab', 'Legacy actor has the correct prefab name');
+        const savedData = legacyActor.asExportedObject();
+        assert.equal(savedData.$root.$base.$ctorArgs[0].prefabName, 'prefab', 'Saved data has the correct prefab name');
+        assert.equal(savedData.$root.$base.$path, undefined, 'Saved data has no prefab name in ctor');
+    });
+    QUnit.test('prefab template inheritance - instance overrides with inheritance', async (assert) => {
+        // Create base prefab A
+        const prefabA = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 100 }),
+        });
+        prefabA.rootComponent.visible = true;
+        prefabA.customActorData = 'base-data';
+        const prefabAData = ENGINE.WorldSerializer.createPrefabDataFromActor(prefabA);
+        // Create prefab B that inherits from A
+        const prefabBInstance = await ENGINE.Actor.spawnPrefabActor('prefabA', {}, { prefabA: prefabAData });
+        prefabBInstance.rootComponent.castShadow = true; // Add new property
+        prefabBInstance.customActorData = 'child-data'; // Override actor data
+        const prefabBData = prefabBInstance.asExportedObject(false); // Export only overrides
+        prefabBData.parentPrefabName = 'prefabA'; // Set parent reference
+        prefabBData.uuid = 'prefab-B-uuid'; // Set prefab UUID
+        // Create an instance of prefab B and apply instance-specific overrides
+        const instanceActor = await ENGINE.Actor.spawnPrefabActor('prefabB', {
+            position: new THREE.Vector3(10, 20, 30),
+            rotation: new THREE.Euler(0.1, 0.2, 0.3),
+            scale: new THREE.Vector3(2, 2, 2),
+        }, {
+            prefabB: prefabBData,
+            prefabA: prefabAData
+        });
+        // Apply instance-specific overrides
+        instanceActor.rootComponent.visible = false; // Override from inherited visible=true
+        instanceActor.rootComponent.receiveShadow = true; // Add instance-specific property
+        instanceActor.customActorData = 'instance-override';
+        // Test that instance has correct values from inheritance + instance overrides
+        assert.equal(instanceActor.rootComponent.visible, false, 'Instance should override visible to false');
+        assert.equal(instanceActor.rootComponent.castShadow, true, 'Instance should inherit castShadow=true from B');
+        assert.equal(instanceActor.rootComponent.receiveShadow, true, 'Instance should have instance-specific receiveShadow');
+        assert.equal(instanceActor.customActorData, 'instance-override', 'Instance should have instance-specific data');
+        // Test reloading with inheritance + instance overrides
+        const reloadedInstance = reloadActor(instanceActor, false, {
+            prefabB: prefabBData,
+            prefabA: prefabAData
+        });
+        assert.equal(reloadedInstance.rootComponent.visible, false, 'Reloaded instance should preserve visible override');
+        assert.equal(reloadedInstance.rootComponent.castShadow, true, 'Reloaded instance should preserve inherited castShadow');
+        assert.equal(reloadedInstance.rootComponent.receiveShadow, true, 'Reloaded instance should preserve instance receiveShadow');
+        assert.equal(reloadedInstance.customActorData, 'instance-override', 'Reloaded instance should preserve instance data');
+    });
+    QUnit.test('prefab template inheritance - circular dependency detection', async (assert) => {
+        // Create prefab A
+        const prefabA = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 100 }),
+        });
+        const prefabAData = ENGINE.WorldSerializer.createPrefabDataFromActor(prefabA);
+        // Create prefab B that inherits from prefab A
+        const prefabB = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 200 }),
+        });
+        const prefabBData = ENGINE.WorldSerializer.createPrefabDataFromActorWithParent(prefabB, 'prefabA');
+        // Manually create a circular dependency: A -> B, B -> A
+        const circularPrefabAData = { ...prefabAData };
+        circularPrefabAData.parentPrefabName = 'prefabB';
+        // Test that circular dependency is detected
+        // await assert.rejects(
+        //   ENGINE.Actor.spawnPrefabActor('prefabA', {}, {
+        //     prefabA: circularPrefabAData,
+        //     prefabB: prefabBData
+        //   }),
+        //   /Circular prefab dependency detected/,
+        //   'Should detect circular dependency A -> B -> A'
+        // );
+        // Test with sync loading as well
+        // assert.throws(() => {
+        //   ENGINE.WorldSerializer.loadActorSync({
+        //     prefabName: 'prefabA'
+        //   }, {
+        //     prefabA: circularPrefabAData,
+        //     prefabB: prefabBData
+        //   });
+        // }, /Circular prefab dependency detected/, 'Sync loading should also detect circular dependency');
+        // circular prefab is now supported
+        assert.expect(0);
+    });
+    QUnit.test('prefab template inheritance - deep hierarchy (4 levels)', async (assert) => {
+        // Create a 4-level deep inheritance hierarchy: A -> B -> C -> D
+        const prefabA = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 100 }),
+        });
+        prefabA.customActorData = 'level-A';
+        const prefabAData = ENGINE.WorldSerializer.createPrefabDataFromActor(prefabA);
+        const prefabBInstance = await ENGINE.Actor.spawnPrefabActor('prefabA', {}, { prefabA: prefabAData });
+        prefabBInstance.customActorData = 'level-B';
+        prefabBInstance.rootComponent.visible = false;
+        const prefabBData = prefabBInstance.asExportedObject(false);
+        prefabBData.parentPrefabName = 'prefabA';
+        prefabBData.uuid = 'prefab-B-uuid';
+        const prefabCInstance = await ENGINE.Actor.spawnPrefabActor('prefabB', {}, {
+            prefabB: prefabBData,
+            prefabA: prefabAData
+        });
+        prefabCInstance.customActorData = 'level-C';
+        prefabCInstance.rootComponent.castShadow = true;
+        const prefabCData = prefabCInstance.asExportedObject(false);
+        prefabCData.parentPrefabName = 'prefabB';
+        prefabCData.uuid = 'prefab-C-uuid';
+        const prefabDInstance = await ENGINE.Actor.spawnPrefabActor('prefabC', {}, {
+            prefabC: prefabCData,
+            prefabB: prefabBData,
+            prefabA: prefabAData
+        });
+        prefabDInstance.customActorData = 'level-D';
+        prefabDInstance.rootComponent.receiveShadow = true;
+        const prefabDData = prefabDInstance.asExportedObject(false);
+        prefabDData.parentPrefabName = 'prefabC';
+        prefabDData.uuid = 'prefab-D-uuid';
+        // Load prefab D (should inherit through C -> B -> A)
+        const instanceD = await ENGINE.Actor.spawnPrefabActor('prefabD', {}, {
+            prefabD: prefabDData,
+            prefabC: prefabCData,
+            prefabB: prefabBData,
+            prefabA: prefabAData
+        });
+        // Verify inheritance through 4 levels
+        assert.equal(instanceD.customActorData, 'level-D', 'Should have level-D data (most derived)');
+        assert.equal(instanceD.rootComponent.visible, false, 'Should inherit visible=false from B');
+        assert.equal(instanceD.rootComponent.castShadow, true, 'Should inherit castShadow=true from C');
+        assert.equal(instanceD.rootComponent.receiveShadow, true, 'Should have receiveShadow=true from D');
+    });
+    QUnit.test('prefab template inheritance - missing parent prefab error', async (assert) => {
+        // Create prefab B that references non-existent parent A
+        const prefabB = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 200 }),
+        });
+        const prefabBData = prefabB.asExportedPrefabData();
+        prefabBData.$root.$base.$path = 'nonExistentPrefabA';
+        delete prefabBData.$root.$base.$ctorArgs;
+        delete prefabBData.$root.$base.$class;
+        // Test that missing parent prefab throws error
+        assert.ok(await warningExistsAsync(async () => {
+            await ENGINE.Actor.spawnPrefabActor('prefabB', {}, {
+                prefabB: prefabBData
+                // Note: nonExistentPrefabA is not provided
+            });
+        }, 'Failed to instantiate prefab'), 'Should warn when parent prefab is missing');
+    });
+    QUnit.test('prefab instance overrides', async (assert) => {
+        // Test actor
+        const actor = new TestActor();
+        // Prefab data created from test actor
+        const actorPrefabData = ENGINE.WorldSerializer.createPrefabDataFromActor(actor);
+        const prefabsData = {
+            'testPrefab': structuredClone(actorPrefabData)
+        };
+        const prefabTemplateActor = ENGINE.WorldSerializer.loadPrefabTemplateActor('testPrefab', prefabsData);
+        const prefabInstanceActor = await ENGINE.Actor.spawnPrefabActor('testPrefab', {}, prefabsData);
+        const testPosition = new THREE.Vector3(1, 2, 3);
+        prefabInstanceActor.rootComponent.position.set(testPosition.x, testPosition.y, testPosition.z);
+        const savedPrefabInstanceData = prefabInstanceActor.asExportedObject(false);
+        const loadedPrefabInstanceActor = ENGINE.WorldSerializer.loadActorSync(savedPrefabInstanceData, prefabsData);
+        assert.ok(loadedPrefabInstanceActor?.rootComponent.position.equals(testPosition), 'Saved prefab instance data position should be 1, 2, 3');
+        // log uuid of root components
+        if (DEBUG_LOG_PREFAB_UUID) {
+            console.log('[test prefab instance overrides] - actor root component uuid', actor.rootComponent.uuid);
+            console.log('[test prefab instance overrides] - template prefab actor root component uuid', prefabTemplateActor.rootComponent.uuid);
+            console.log('[test prefab instance overrides] - root component uuid', prefabInstanceActor.rootComponent.uuid);
+            console.log('[test prefab instance overrides] - loaded prefab instance actor root component uuid', loadedPrefabInstanceActor?.rootComponent.uuid);
+        }
+    });
+    QUnit.test('prefab template component addition - single level', async (assert) => {
+        ENGINE.clearCdoCache();
+        // Create base prefab A with 2 components
+        const prefabA = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 100 }),
+            sceneComponents: [
+                new TestSceneComponent({ data: 200 }),
+            ],
+        });
+        prefabA.rootComponent.visible = false;
+        prefabA.customActorData = 'base-data';
+        const prefabAData = ENGINE.WorldSerializer.createPrefabDataFromActor(prefabA);
+        const prefabAName = 'prefabA';
+        // Create prefab B that inherits from A and adds new components
+        const prefabBInstance = await ENGINE.Actor.spawnPrefabActor(prefabAName, {}, { [prefabAName]: prefabAData });
+        // Add new components to prefab B
+        const newComponent1 = new TestSceneComponent({ data: 300 });
+        newComponent1.name = 'NewComponent1';
+        newComponent1.visible = true;
+        prefabBInstance.addComponent(newComponent1);
+        const newComponent2 = new TestSceneComponent({ data: 400 });
+        newComponent2.name = 'NewComponent2';
+        newComponent2.castShadow = true;
+        prefabBInstance.addComponent(newComponent2);
+        // Also modify existing properties
+        prefabBInstance.rootComponent.visible = true;
+        prefabBInstance.customActorData = 'modified-data';
+        const prefabBData = prefabBInstance.asExportedObject(false); // Export only overrides
+        prefabBData.parentPrefabName = 'prefabA';
+        const prefabBName = 'prefabB';
+        // Test loading prefab B
+        const loadedPrefabB = await ENGINE.Actor.spawnPrefabActor(prefabBName, {}, {
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        // Verify inheritance and new components
+        assert.equal(loadedPrefabB.getComponents(TestSceneComponent).length, 4, 'Should have 4 components (root + 1 inherited + 2 new)');
+        assert.equal(loadedPrefabB.rootComponent.visible, true, 'Should inherit visible override');
+        assert.equal(loadedPrefabB.customActorData, 'modified-data', 'Should inherit custom data override');
+        // Verify inherited component
+        const inheritedComponent = loadedPrefabB.getComponents(TestSceneComponent)[1];
+        assert.equal(inheritedComponent.options.data, 200, 'Inherited component should have original data');
+        // Verify new components
+        const addedComponents = loadedPrefabB.getComponents(TestSceneComponent).slice(2);
+        assert.equal(addedComponents.length, 2, 'Should have 2 new components');
+        assert.equal(addedComponents[0].options.data, 300, 'First new component should have correct data');
+        assert.equal(addedComponents[0].name, 'NewComponent1', 'First new component should have correct name');
+        assert.equal(addedComponents[1].options.data, 400, 'Second new component should have correct data');
+        assert.equal(addedComponents[1].name, 'NewComponent2', 'Second new component should have correct name');
+        assert.equal(addedComponents[1].castShadow, true, 'Second new component should have castShadow property');
+    });
+    QUnit.test('prefab template component addition - multi-level hierarchy', async (assert) => {
+        // Create base prefab A with 1 component
+        const componentA = new TestSceneComponent({ data: 200 });
+        componentA.name = 'ComponentA';
+        const prefabA = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 100 }),
+            sceneComponents: [
+                componentA
+            ],
+        });
+        prefabA.customActorData = 'level-A';
+        const prefabAData = ENGINE.WorldSerializer.createPrefabDataFromActor(prefabA);
+        const prefabAName = 'prefabA';
+        assert.equal(prefabA.getComponents(TestSceneComponent).length, 2, 'Prefab A should have 2 components');
+        // Create prefab B that inherits from A and adds 1 component
+        const prefabBInstance = await ENGINE.Actor.spawnPrefabActor(prefabAName, {}, { [prefabAName]: prefabAData });
+        {
+            const components = prefabBInstance.getComponents(TestSceneComponent);
+            assert.equal(components.length, 2, 'Prefab B should initially have 2 components (inherited)');
+            assert.deepEqual(components.map(c => c.name), ['', 'ComponentA'], 'Prefab B should have correct component names initially');
+        }
+        const componentB = new TestSceneComponent({ data: 300 });
+        componentB.name = 'ComponentB';
+        componentB.visible = false;
+        prefabBInstance.addComponent(componentB);
+        prefabBInstance.customActorData = 'level-B';
+        {
+            const components = prefabBInstance.getComponents(TestSceneComponent);
+            assert.equal(components.length, 3, 'Prefab B should have 3 components after addition');
+            assert.deepEqual(components.map(c => c.name), ['', 'ComponentA', 'ComponentB'], 'Prefab B should have correct component names after addition');
+        }
+        const prefabBData = prefabBInstance.asExportedObject(false);
+        prefabBData.parentPrefabName = 'prefabA';
+        const prefabBName = 'prefabB';
+        // Create prefab C that inherits from B and adds 2 more components
+        const prefabCInstance = await ENGINE.Actor.spawnPrefabActor(prefabBName, {}, {
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        {
+            const components = prefabCInstance.getComponents(TestSceneComponent);
+            assert.equal(components.length, 3, 'Prefab C should initially have 3 components (inherited)');
+            assert.deepEqual(components.map(c => c.name), ['', 'ComponentA', 'ComponentB'], 'Prefab C should have correct component names initially');
+        }
+        const componentC1 = new TestSceneComponent({ data: 400 });
+        componentC1.name = 'ComponentC1';
+        componentC1.receiveShadow = true;
+        prefabCInstance.addComponent(componentC1);
+        const componentC2 = new TestSceneComponent({ data: 500 });
+        componentC2.name = 'ComponentC2';
+        componentC2.renderOrder = 5;
+        prefabCInstance.addComponent(componentC2);
+        prefabCInstance.customActorData = 'level-C';
+        {
+            const components = prefabCInstance.getComponents(TestSceneComponent);
+            assert.equal(components.length, 5, 'Prefab C should have 5 components after additions');
+            assert.deepEqual(components.map(c => c.name), ['', 'ComponentA', 'ComponentB', 'ComponentC1', 'ComponentC2'], 'Prefab C should have correct component names after additions');
+        }
+        const prefabCData = prefabCInstance.asExportedPrefabData();
+        prefabCData.parentPrefabName = 'prefabB';
+        const prefabCName = 'prefabC';
+        // Create prefab D that inherits from C and adds 1 more component
+        const prefabDInstance = await ENGINE.Actor.spawnPrefabActor(prefabCName, {}, {
+            [prefabCName]: prefabCData,
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        {
+            const components = prefabDInstance.getComponents(TestSceneComponent);
+            assert.equal(components.length, 5, 'Prefab D should initially have 5 components (inherited)');
+            assert.deepEqual(components.map(c => c.name), ['', 'ComponentA', 'ComponentB', 'ComponentC1', 'ComponentC2'], 'Prefab D should have correct component names initially');
+        }
+        const componentD = new TestSceneComponent({ data: 600 });
+        componentD.name = 'ComponentD';
+        componentD.castShadow = true;
+        componentD.receiveShadow = true;
+        prefabDInstance.addComponent(componentD);
+        prefabDInstance.customActorData = 'level-D';
+        const prefabDData = prefabDInstance.asExportedPrefabData();
+        prefabDData.parentPrefabName = 'prefabC';
+        const prefabDName = 'prefabD';
+        // Test loading prefab D (should inherit through C -> B -> A)
+        const loadedPrefabD = await ENGINE.Actor.spawnPrefabActor(prefabDName, {}, {
+            [prefabDName]: prefabDData,
+            [prefabCName]: prefabCData,
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        // Verify complete inheritance chain with component additions
+        const allComponents = loadedPrefabD.getComponents(TestSceneComponent);
+        assert.equal(allComponents.length, 6, 'Should have 6 components total (root + 1 from A + 1 from B + 2 from C + 1 from D)');
+        assert.deepEqual(allComponents.map(c => c.name), ['', 'ComponentA', 'ComponentB', 'ComponentC1', 'ComponentC2', 'ComponentD'], 'Should have correct component names');
+        assert.equal(loadedPrefabD.customActorData, 'level-D', 'Should have final level data');
+        // Verify components by name
+        const componentsByName = new Map();
+        allComponents.forEach(comp => {
+            if (comp.name) {
+                componentsByName.set(comp.name, comp);
+            }
+        });
+        // Check inherited component from A (index 1)
+        assert.equal(allComponents[1].options.data, 200, 'Component from A should have correct data');
+        // Check component from B
+        const compB = componentsByName.get('ComponentB');
+        assert.ok(compB, 'ComponentB should exist');
+        assert.equal(compB.options.data, 300, 'ComponentB should have correct data');
+        assert.equal(compB.visible, false, 'ComponentB should have correct visibility');
+        // Check components from C
+        const compC1 = componentsByName.get('ComponentC1');
+        const compC2 = componentsByName.get('ComponentC2');
+        assert.ok(compC1, 'ComponentC1 should exist');
+        assert.ok(compC2, 'ComponentC2 should exist');
+        assert.equal(compC1.options.data, 400, 'ComponentC1 should have correct data');
+        assert.equal(compC1.receiveShadow, true, 'ComponentC1 should have receiveShadow');
+        assert.equal(compC2.options.data, 500, 'ComponentC2 should have correct data');
+        assert.equal(compC2.renderOrder, 5, 'ComponentC2 should have correct renderOrder');
+        // Check component from D
+        const compD = componentsByName.get('ComponentD');
+        assert.ok(compD, 'ComponentD should exist');
+        assert.equal(compD.options.data, 600, 'ComponentD should have correct data');
+        assert.equal(compD.castShadow, true, 'ComponentD should have castShadow');
+        assert.equal(compD.receiveShadow, true, 'ComponentD should have receiveShadow');
+    });
+    QUnit.test('prefab instance component addition with overrides', async (assert) => {
+        // Create base prefab with 2 components
+        const prefabA = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 100 }),
+            sceneComponents: [
+                new TestSceneComponent({ data: 200 }),
+                new TestSceneComponent({ data: 250 }),
+            ],
+        });
+        const prefabAData = ENGINE.WorldSerializer.createPrefabDataFromActor(prefabA);
+        const prefabAName = 'prefabA';
+        // Create prefab B that adds components
+        const prefabBInstance = await ENGINE.Actor.spawnPrefabActor(prefabAName, {}, { [prefabAName]: prefabAData });
+        const newComponent = new TestSceneComponent({ data: 300 });
+        newComponent.name = 'PrefabBComponent';
+        prefabBInstance.addComponent(newComponent);
+        const prefabBData = prefabBInstance.asExportedPrefabData();
+        prefabBData.parentPrefabName = 'prefabA';
+        const prefabBName = 'prefabB';
+        // Create an instance of prefab B and add instance-specific components
+        const instanceActor = await ENGINE.Actor.spawnPrefabActor(prefabBName, {}, {
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        // Add instance-specific components
+        const instanceComponent1 = new TestSceneComponent({ data: 400 });
+        instanceComponent1.name = 'InstanceComponent1';
+        instanceComponent1.visible = false;
+        instanceActor.addComponent(instanceComponent1);
+        const instanceComponent2 = new TestSceneComponent({ data: 500 });
+        instanceComponent2.name = 'InstanceComponent2';
+        instanceComponent2.castShadow = true;
+        instanceActor.addComponent(instanceComponent2);
+        // Also modify existing components
+        instanceActor.getComponents(TestSceneComponent)[1].otherData = 999; // Modify inherited component
+        instanceActor.customActorData = 'instance-data';
+        // Test reloading the instance
+        const reloadedInstance = reloadActor(instanceActor, false, {
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        // Verify all components are preserved
+        const reloadedComponents = reloadedInstance.getComponents(TestSceneComponent);
+        assert.equal(reloadedComponents.length, 6, 'Should have 6 components (root + 2 from A + 1 from B + 2 instance)');
+        // Verify inherited components
+        assert.equal(reloadedComponents[1].options.data, 200, 'First inherited component should have original data');
+        assert.equal(reloadedComponents[1].otherData, 999, 'First inherited component should have instance override');
+        assert.equal(reloadedComponents[2].options.data, 250, 'Second inherited component should have original data');
+        // Verify prefab B component
+        const prefabBComp = reloadedComponents.find(c => c.name === 'PrefabBComponent');
+        assert.ok(prefabBComp, 'PrefabB component should exist');
+        if (prefabBComp) {
+            assert.equal(prefabBComp.options.data, 300, 'PrefabB component should have correct data');
+        }
+        // Verify instance components
+        const instanceComp1 = reloadedComponents.find(c => c.name === 'InstanceComponent1');
+        const instanceComp2 = reloadedComponents.find(c => c.name === 'InstanceComponent2');
+        assert.ok(instanceComp1, 'Instance component 1 should exist');
+        assert.ok(instanceComp2, 'Instance component 2 should exist');
+        if (instanceComp1) {
+            assert.equal(instanceComp1.options.data, 400, 'Instance component 1 should have correct data');
+            assert.equal(instanceComp1.visible, false, 'Instance component 1 should have correct visibility');
+        }
+        if (instanceComp2) {
+            assert.equal(instanceComp2.options.data, 500, 'Instance component 2 should have correct data');
+            assert.equal(instanceComp2.castShadow, true, 'Instance component 2 should have correct castShadow');
+        }
+        // Verify instance data
+        assert.equal(reloadedInstance.customActorData, 'instance-data', 'Instance should have custom data');
+    });
+    QUnit.test('prefab template component addition with mixed modifications', async (assert) => {
+        // Test complex scenario with component additions, modifications, and property overrides
+        // Create base prefab A
+        const prefabA = new TestActor({
+            rootComponent: new TestSceneComponent({ data: 100 }),
+            sceneComponents: [
+                new TestSceneComponent({ data: 200 }),
+            ],
+        });
+        prefabA.rootComponent.visible = true;
+        prefabA.rootComponent.castShadow = false;
+        const prefabAData = ENGINE.WorldSerializer.createPrefabDataFromActor(prefabA);
+        const prefabAName = 'prefabA';
+        // Create prefab B that modifies existing and adds new components
+        const prefabBInstance = await ENGINE.Actor.spawnPrefabActor(prefabAName, {}, { [prefabAName]: prefabAData });
+        // Modify existing components
+        prefabBInstance.rootComponent.visible = false; // Override root visibility
+        prefabBInstance.getComponents(TestSceneComponent)[1].otherData = 777; // Modify inherited component
+        // Add new components
+        const componentB1 = new TestSceneComponent({ data: 300 });
+        componentB1.name = 'ComponentB1';
+        componentB1.position.set(1, 2, 3);
+        prefabBInstance.addComponent(componentB1);
+        const componentB2 = new TestSceneComponent({ data: 350 });
+        componentB2.name = 'ComponentB2';
+        componentB2.receiveShadow = true;
+        prefabBInstance.addComponent(componentB2);
+        const prefabBData = prefabBInstance.asExportedObject(false);
+        prefabBData.parentPrefabName = 'prefabA';
+        const prefabBName = 'prefabB';
+        // Create prefab C that further modifies and adds components
+        const prefabCInstance = await ENGINE.Actor.spawnPrefabActor(prefabBName, {}, {
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        // Modify existing components from different levels
+        prefabCInstance.rootComponent.castShadow = true; // Override root castShadow
+        prefabCInstance.getComponents(TestSceneComponent)[1].options.data = 299; // Modify component from A
+        // Modify component from B
+        const compB1 = prefabCInstance.getComponents(TestSceneComponent).find(c => c.name === 'ComponentB1');
+        if (compB1) {
+            compB1.visible = false;
+            compB1.position.set(10, 20, 30);
+        }
+        // Add new component in C
+        const componentC = new TestSceneComponent({ data: 400 });
+        componentC.name = 'ComponentC';
+        componentC.renderOrder = 10;
+        prefabCInstance.addComponent(componentC);
+        const prefabCData = prefabCInstance.asExportedObject(false);
+        prefabCData.parentPrefabName = 'prefabB';
+        const prefabCName = 'prefabC';
+        // Test loading prefab C
+        const loadedPrefabC = await ENGINE.Actor.spawnPrefabActor(prefabCName, {}, {
+            [prefabCName]: prefabCData,
+            [prefabBName]: prefabBData,
+            [prefabAName]: prefabAData
+        });
+        // Verify complex inheritance with modifications and additions
+        const allComponents = loadedPrefabC.getComponents(TestSceneComponent);
+        assert.equal(allComponents.length, 5, 'Should have 5 components total');
+        // Verify root component has all overrides
+        assert.equal(loadedPrefabC.rootComponent.visible, false, 'Root should have visibility override from B');
+        assert.equal(loadedPrefabC.rootComponent.castShadow, true, 'Root should have castShadow override from C');
+        // Verify component from A has override from C
+        // assert.equal(allComponents[1].options.data, 299, 'Component from A should have data override from C');
+        assert.equal(allComponents[1].otherData, 777, 'Component from A should have otherData override from B');
+        // Verify components from B
+        const compB1Loaded = allComponents.find(c => c.name === 'ComponentB1');
+        const compB2Loaded = allComponents.find(c => c.name === 'ComponentB2');
+        assert.ok(compB1Loaded, 'ComponentB1 should exist');
+        assert.ok(compB2Loaded, 'ComponentB2 should exist');
+        if (compB1Loaded) {
+            assert.equal(compB1Loaded.options.data, 300, 'ComponentB1 should have original data');
+            assert.equal(compB1Loaded.visible, false, 'ComponentB1 should have visibility override from C');
+            assert.ok(compB1Loaded.position.equals(new THREE.Vector3(10, 20, 30)), 'ComponentB1 should have position override from C');
+        }
+        if (compB2Loaded) {
+            assert.equal(compB2Loaded.options.data, 350, 'ComponentB2 should have original data');
+            assert.equal(compB2Loaded.receiveShadow, true, 'ComponentB2 should have original receiveShadow');
+        }
+        // Verify component from C
+        const compCLoaded = allComponents.find(c => c.name === 'ComponentC');
+        assert.ok(compCLoaded, 'ComponentC should exist');
+        if (compCLoaded) {
+            assert.equal(compCLoaded.options.data, 400, 'ComponentC should have correct data');
+            assert.equal(compCLoaded.renderOrder, 10, 'ComponentC should have correct renderOrder');
+        }
+    });
+    QUnit.test('prefab UUID', async (assert) => {
+        // Test actor
+        const actor = new TestActor();
+        // Prefab data created from test actor
+        const actorPrefabData = ENGINE.WorldSerializer.createPrefabDataFromActor(actor);
+        const prefabsData = {
+            'testPrefab': structuredClone(actorPrefabData)
+        };
+        const prefabDefaultActor = ENGINE.WorldSerializer.loadPrefabTemplateActor('testPrefab', prefabsData);
+        const prefabInstanceActor = await ENGINE.Actor.spawnPrefabActor('testPrefab', {}, prefabsData);
+        const savedPrefabInstanceData = prefabInstanceActor.asExportedObject(false);
+        const loadedPrefabInstanceActor = ENGINE.WorldSerializer.loadActorSync(savedPrefabInstanceData, prefabsData);
+        const loadedPrefabInstanceData = loadedPrefabInstanceActor?.asExportedObject(false);
+        // log uuid, same log
+        if (DEBUG_LOG_PREFAB_UUID) {
+            console.log('[test prefab UUID] - actor uuid', actor.uuid);
+            console.log('[test prefab UUID] - actorPrefabData uuid', actorPrefabData.uuid);
+            console.log('[test prefab UUID] - prefabDefaultActor uuid', prefabDefaultActor.uuid);
+            console.log('[test prefab UUID] - prefabInstanceActor uuid', prefabInstanceActor.uuid);
+            console.log('[test prefab UUID] - savedPrefabInstanceData uuid', savedPrefabInstanceData.uuid);
+            console.log('[test prefab UUID] - loadedPrefabInstanceActor uuid', loadedPrefabInstanceActor?.uuid);
+            console.log('[test prefab UUID] - loadedPrefabInstanceData uuid', loadedPrefabInstanceData?.uuid);
+        }
+        // assert prefabInstanceActor uuid same as prefabInstanceActorData
+        assert.equal(prefabInstanceActor.uuid, savedPrefabInstanceData.$root.uuid, 'Prefab instance actor uuid should be the same as prefab instance actor data uuid');
+        assert.equal(prefabInstanceActor.uuid, loadedPrefabInstanceActor?.uuid, 'Prefab instance actor uuid should be the same as loaded prefab instance actor uuid');
+        assert.equal(prefabInstanceActor.uuid, loadedPrefabInstanceData.$root.uuid, 'Prefab instance actor uuid should be the same as loaded prefab instance actor data uuid');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prefab.test.js","sourceRoot":"","sources":["../../test/prefab.test.ts"],"names":[],"mappings":"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"}