@directivegames/genesys.js 3.1.24

package/dist/src/systems/WorldSerialization.js

@@ -0,0 +1,1082 @@
+/**
+ * WorldSerialization converts game objects to and from plain JSON structures.
+ *
+ * Detailed explanation:
+ * - Provides `WorldSerializationContext` which handles constructor mapping, default values and external references.
+ * - Defines schemas for actors, components and full worlds so exports can be validated before saving.
+ * - Includes helpers to construct objects from serialized data, wiring up scene hierarchies automatically.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Use `exportObject` or the static load helpers when persisting or loading scenes and prefabs.
+ * - Register additional constructors with `ClassRegistry` before loading to ensure custom classes instantiate correctly.
+ * - Avoid serializing transient runtime data like DOM elements or temporary THREE objects.
+ */
+import * as THREE from 'three';
+import { z } from 'zod';
+import { SceneComponent } from '../components/SceneComponent.js';
+import { SerializationVersion } from '../const.js';
+import { MaterialUtils } from '../materials.js';
+import { AssetPath } from '../storage/storageProvider.js';
+import { resourceManager } from '../utils/ResourceManager.js';
+import { loadPrefabTemplateInstance } from '../utils/serialization/prefab.js';
+import { Dumper, DumperFlags, Loader, LoaderFlags } from '../utils/serialization/serializer.js';
+import { deepMerge, replace_uuids } from '../utils/Utils.js';
+import { ClassRegistry } from './ClassRegistry.js';
+const serializationVersionKey = '$version';
+const externalRefKey = '@external';
+const internalRefKey = '@ref';
+const objectSchema = z.object({
+    // optional for an internal ref object
+    class: z.string().optional(),
+    uuid: z.string().optional(),
+    prefabName: z.string().optional(),
+    parentPrefabName: z.string().optional(),
+    [serializationVersionKey]: z.nativeEnum(SerializationVersion).optional(),
+    ctor: z.union([
+        z.record(z.any()),
+        z.array(z.any())
+    ]).optional(),
+    properties: z.record(z.string(), z.any()).optional(),
+}).strict();
+const componentSchema = objectSchema.extend({}).strict();
+const sceneComponentSchema = z.lazy(() => componentSchema.extend({
+    children: z.array(sceneComponentSchema).optional(),
+}).strict());
+const actorSchema = objectSchema.extend({}).strict();
+const sceneResourcesSchema = z.object({
+    lightmap: z.object({
+        metadataPath: z.string(),
+        texturePath: z.string(),
+    }).optional(),
+    navMesh: z.object({
+        path: z.string(),
+    }).optional(),
+}).strict();
+const worldSchema = objectSchema.extend({
+    actors: z.array(actorSchema).optional(),
+    prefabs: z.record(z.string(), actorSchema).optional(),
+    resources: sceneResourcesSchema.optional(),
+}).strict();
+export function isLegacyData(data) {
+    // no data, considered new, because we can load prefab without having to provide prefab data
+    if (data === undefined)
+        return false;
+    const version = data?.[serializationVersionKey];
+    if (version !== undefined) {
+        // version clearly says it's legacy or new
+        return version < SerializationVersion.V1;
+    }
+    // now we are in a state where we have a bunch of data, but without $version field
+    return true;
+}
+export class WorldSerializationContext {
+    constructor() {
+        Object.defineProperty(this, "exportedObjects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // Map that stores the call stacks for each exported object (when debug is enabled)
+        Object.defineProperty(this, "exportCallStacks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // Loading context state
+        Object.defineProperty(this, "constructedObjects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakSet()
+        });
+        Object.defineProperty(this, "loadedObjectsByUUID", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "loadedPrefabData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "currentPrefabRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "isEditor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    static get ExternalObjects() {
+        if (!this.externalObjects.size) {
+            this.externalObjects.set('DefaultTexture', MaterialUtils.DefaultTexture);
+            this.externalObjects.set('DefaultMaterial', MaterialUtils.DefaultMaterial);
+            this.externalObjects.set('MeshWorldSpaceNormalMaterial', MaterialUtils.MeshWorldSpaceNormalMaterial);
+            for (const [k, v] of this.externalObjects) {
+                v.export = (context, includeDefaults) => ({
+                    [externalRefKey]: k,
+                });
+                v.isExternal = true;
+            }
+        }
+        return this.externalObjects;
+    }
+    /**
+     * Exports an object to a serializable format.
+     * @param object - The object to export
+     * @param asPrefab - Whether it's exported as a prefab or regular storage
+     * @param inlineToPrefab - Whether to inline to the actor's prefab itself, as against to creating a new prefab that is dependent on the actor's prefab
+     * @returns The serialized object
+     */
+    exportObject(object, asPrefab, inlineToPrefab = false) {
+        const flags = (DumperFlags.None
+            | (asPrefab ? DumperFlags.AsPrefab : 0)
+            | (inlineToPrefab ? DumperFlags.Inline : 0));
+        const dumper = new Dumper({ flags });
+        const data = dumper.dump(object);
+        return data;
+    }
+    static addConstructorHandler(type, handler) {
+        this.constructorHandlers.set(type.prototype, handler);
+    }
+    static getDefaultObject(obj) {
+        const ctor = obj.constructor;
+        if (!this.classDefaultObjects.has(ctor)) {
+            try {
+                this.classDefaultObjects.set(ctor, new ctor());
+            }
+            catch (error) {
+                // If we can't create a default object (e.g., due to arrays with null/undefined),
+                // store null to indicate this class doesn't support default comparison
+                this.classDefaultObjects.set(ctor, null);
+            }
+        }
+        return this.classDefaultObjects.get(ctor);
+    }
+    removeDefaultProperties(obj, properties) {
+        let defaultObject = WorldSerializationContext.getDefaultObject(obj);
+        // If the object is a component and its actor is a prefab, compare against the prefab defaults instead of class defaults
+        if (obj instanceof SceneComponent) {
+            const actor = obj.getActor();
+            const prefabName = actor?.getPrefabName();
+            const prefabInheritanceChain = actor?.getPrefabInheritanceChain();
+            if (prefabName && prefabInheritanceChain) {
+                try {
+                    // Use the stored inheritance chain to load the prefab template actor
+                    const prefabTemplateActor = WorldSerializer.loadPrefabTemplateActor(prefabName, prefabInheritanceChain);
+                    const actorComponents = actor?.getComponents() ?? [];
+                    const prefabComponents = prefabTemplateActor?.getComponents() ?? [];
+                    const componentIndex = actorComponents.indexOf(obj);
+                    if (componentIndex >= 0 && componentIndex < prefabComponents.length) {
+                        defaultObject = prefabComponents[componentIndex];
+                    }
+                }
+                catch (error) {
+                    // If we can't load the prefab template actor, fall back to class defaults
+                    console.warn(`⚠️ Could not load prefab template actor for comparison: ${error}. Using class defaults.`);
+                }
+            }
+        }
+        if (defaultObject === null) {
+            return properties;
+        }
+        return WorldSerializationContext.removeDefaultPropertiesCommon(obj, properties, defaultObject);
+    }
+    static removeDefaultPropertiesStatic(obj, properties) {
+        const defaultObject = WorldSerializationContext.getDefaultObject(obj);
+        return WorldSerializationContext.removeDefaultPropertiesCommon(obj, properties, defaultObject);
+    }
+    static removeDefaultPropertiesCommon(obj, properties, defaultObject) {
+        for (const [k, instanceValue] of Object.entries(properties)) {
+            const defaultValue = defaultObject[k];
+            if (instanceValue && instanceValue.equals && instanceValue.equals(defaultValue)) {
+                delete properties[k];
+                continue;
+            }
+            if (instanceValue === defaultValue) {
+                delete properties[k];
+                continue;
+            }
+            if (typeof instanceValue === 'object' && instanceValue && Object.keys(instanceValue).length === 0) {
+                delete properties[k];
+                continue;
+            }
+        }
+        return properties;
+    }
+    static getDebugName(obj) {
+        if (obj.getPathName) {
+            return obj.getPathName();
+        }
+        if (obj.name) {
+            return obj.name;
+        }
+        if (obj.class) {
+            return obj.class;
+        }
+        const className = ClassRegistry.getClassName(obj);
+        if (className) {
+            return className;
+        }
+        if (obj.constructor) {
+            return obj.constructor.name;
+        }
+        return obj.toString();
+    }
+    /**
+     * Normalizes a number to reduce precision artifacts and file size.
+     * - Rounds near-zero values to 0
+     * - Rounds near-integer values to integers
+     * - Limits decimal precision to 6 places
+     */
+    static normalizeNumber(n) {
+        if (!this.ENABLE_PRECISION_NORMALIZATION) {
+            return n;
+        }
+        // Handle near-zero values
+        if (Math.abs(n) < 1e-10) {
+            return 0;
+        }
+        // Check if close to an integer
+        const rounded = Math.round(n);
+        if (Math.abs(n - rounded) < 1e-10) {
+            return rounded;
+        }
+        // Limit precision to 6 decimal places
+        return Math.round(n * 1000000) / 1000000;
+    }
+    /**
+     * Normalizes an array of numbers for more compact serialization.
+     */
+    static normalizeNumberArray(arr) {
+        if (!this.ENABLE_PRECISION_NORMALIZATION) {
+            return arr;
+        }
+        return arr.map(n => this.normalizeNumber(n));
+    }
+    static registerConstructorHandlers() {
+        if (this.constructorHandlersRegistered) {
+            return;
+        }
+        function getObjectParameters(obj, fields, includeDefaults) {
+            const result = {};
+            for (const field of fields) {
+                const value = obj[field];
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                if (value instanceof THREE.Texture) {
+                    // continue;
+                }
+                result[field] = value;
+            }
+            if (!includeDefaults) {
+                // For static context, we can't access instance prefab data, so use class defaults only
+                return WorldSerializationContext.removeDefaultPropertiesStatic(obj, result);
+            }
+            return result;
+        }
+        // core classes
+        this.addConstructorHandler(THREE.Vector2, (obj, includeDefaults) => {
+            return this.normalizeNumberArray([obj.x, obj.y]);
+        });
+        this.addConstructorHandler(THREE.Vector3, (obj, includeDefaults) => {
+            return this.normalizeNumberArray([obj.x, obj.y, obj.z]);
+        });
+        this.addConstructorHandler(THREE.Vector4, (obj, includeDefaults) => {
+            return this.normalizeNumberArray([obj.x, obj.y, obj.z, obj.w]);
+        });
+        this.addConstructorHandler(THREE.Color, (obj, includeDefaults) => {
+            return this.normalizeNumberArray([obj.r, obj.g, obj.b]);
+        });
+        this.addConstructorHandler(THREE.Euler, (obj, includeDefaults) => {
+            return this.normalizeNumberArray([obj.x, obj.y, obj.z]);
+        });
+        this.addConstructorHandler(THREE.Quaternion, (obj, includeDefaults) => {
+            return this.normalizeNumberArray([obj.x, obj.y, obj.z, obj.w]);
+        });
+        this.addConstructorHandler(THREE.Matrix2, (obj, includeDefaults) => { return obj.elements; });
+        this.addConstructorHandler(THREE.Matrix3, (obj, includeDefaults) => { return obj.elements; });
+        this.addConstructorHandler(THREE.Matrix4, (obj, includeDefaults) => { return obj.elements; });
+        this.addConstructorHandler(THREE.Box2, (obj, includeDefaults) => { return [obj.min, obj.max]; });
+        this.addConstructorHandler(THREE.Box3, (obj, includeDefaults) => { return [obj.min, obj.max]; });
+        this.addConstructorHandler(THREE.Sphere, (obj, includeDefaults) => { return [obj.center, obj.radius]; });
+        this.addConstructorHandler(THREE.Plane, (obj, includeDefaults) => { return [obj.normal, obj.constant]; });
+        // geometry classes
+        this.addConstructorHandler(THREE.BoxGeometry, (obj, includeDefaults) => { return [obj.parameters.width, obj.parameters.height, obj.parameters.depth]; });
+        this.addConstructorHandler(THREE.SphereGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.widthSegments, obj.parameters.heightSegments]; });
+        this.addConstructorHandler(THREE.CylinderGeometry, (obj) => { return [obj.parameters.radiusTop, obj.parameters.radiusBottom, obj.parameters.height, obj.parameters.radialSegments, obj.parameters.heightSegments, obj.parameters.openEnded]; });
+        this.addConstructorHandler(THREE.PlaneGeometry, (obj, includeDefaults) => { return [obj.parameters.width, obj.parameters.height]; });
+        this.addConstructorHandler(THREE.CapsuleGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.height, obj.parameters.capSegments, obj.parameters.radialSegments]; });
+        this.addConstructorHandler(THREE.ConeGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.height, obj.parameters.radialSegments, obj.parameters.heightSegments]; });
+        this.addConstructorHandler(THREE.CircleGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.segments, obj.parameters.thetaStart, obj.parameters.thetaLength]; });
+        this.addConstructorHandler(THREE.TorusGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.tube, obj.parameters.radialSegments, obj.parameters.tubularSegments]; });
+        this.addConstructorHandler(THREE.TorusKnotGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.tube, obj.parameters.radialSegments, obj.parameters.tubularSegments, obj.parameters.radialSegments, obj.parameters.tubularSegments]; });
+        this.addConstructorHandler(THREE.TubeGeometry, (obj, includeDefaults) => { return [obj.parameters.path, obj.parameters.tubularSegments, obj.parameters.radius, obj.parameters.radialSegments, obj.parameters.closed]; });
+        this.addConstructorHandler(THREE.DodecahedronGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.detail]; });
+        this.addConstructorHandler(THREE.EdgesGeometry, (obj, includeDefaults) => { return [obj.parameters.geometry, obj.parameters.thresholdAngle]; });
+        this.addConstructorHandler(THREE.ExtrudeGeometry, (obj, includeDefaults) => { return [obj.parameters.shapes, obj.parameters.options]; });
+        this.addConstructorHandler(THREE.IcosahedronGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.detail]; });
+        this.addConstructorHandler(THREE.LatheGeometry, (obj, includeDefaults) => { return [obj.parameters.points, obj.parameters.segments, obj.parameters.phiStart, obj.parameters.phiLength]; });
+        this.addConstructorHandler(THREE.OctahedronGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.detail]; });
+        this.addConstructorHandler(THREE.PolyhedronGeometry, (obj, includeDefaults) => { return [obj.parameters.vertices, obj.parameters.indices, obj.parameters.radius, obj.parameters.detail]; });
+        this.addConstructorHandler(THREE.RingGeometry, (obj, includeDefaults) => { return [obj.parameters.innerRadius, obj.parameters.outerRadius, obj.parameters.thetaSegments, obj.parameters.phiSegments]; });
+        this.addConstructorHandler(THREE.ShapeGeometry, (obj, includeDefaults) => { return [obj.parameters.shapes, obj.parameters.curveSegments]; });
+        this.addConstructorHandler(THREE.TetrahedronGeometry, (obj, includeDefaults) => { return [obj.parameters.radius, obj.parameters.detail]; });
+        this.addConstructorHandler(THREE.WireframeGeometry, (obj, includeDefaults) => { return [obj.parameters.geometry]; });
+        // lights
+        this.addConstructorHandler(THREE.AmbientLight, (obj, includeDefaults) => { return [obj.color, obj.intensity]; });
+        this.addConstructorHandler(THREE.DirectionalLight, (obj, includeDefaults) => { return [obj.color, obj.intensity]; });
+        this.addConstructorHandler(THREE.HemisphereLight, (obj, includeDefaults) => { return [obj.color, obj.intensity]; });
+        this.addConstructorHandler(THREE.PointLight, (obj, includeDefaults) => { return [obj.color, obj.intensity, obj.distance, obj.decay]; });
+        this.addConstructorHandler(THREE.LightProbe, (obj, includeDefaults) => { return [obj.sh, obj.intensity]; });
+        this.addConstructorHandler(THREE.RectAreaLight, (obj, includeDefaults) => { return [obj.color, obj.intensity, obj.width, obj.height]; });
+        this.addConstructorHandler(THREE.SpotLight, (obj, includeDefaults) => { return [obj.color, obj.intensity, obj.distance, obj.angle, obj.penumbra, obj.decay]; });
+        // fog
+        this.addConstructorHandler(THREE.Fog, (obj, includeDefaults) => { return [obj.color, obj.near, obj.far]; });
+        this.addConstructorHandler(THREE.FogExp2, (obj, includeDefaults) => { return [obj.color, obj.density]; });
+        // material classes
+        // see MaterialParameters
+        const MaterialParametersFields = [
+            'alphaHash', 'alphaTest', 'alphaToCoverage', 'blendAlpha', 'blendColor',
+            'blendDst', 'blendDstAlpha', 'blendEquation', 'blendEquationAlpha',
+            'blending', 'blendSrc', 'blendSrcAlpha', 'clipIntersection', 'clippingPlanes',
+            'clipShadows', 'colorWrite', 'defines', 'depthFunc', 'depthTest',
+            'depthWrite', 'name', 'opacity', 'polygonOffset', 'polygonOffsetFactor',
+            'polygonOffsetUnits', 'precision', 'premultipliedAlpha', 'forceSinglePass',
+            'allowOverride', 'dithering', 'side', 'shadowSide', 'toneMapped',
+            'transparent', 'vertexColors', 'visible', 'format', 'stencilWrite',
+            'stencilFunc', 'stencilRef', 'stencilWriteMask', 'stencilFuncMask',
+            'stencilFail', 'stencilZFail', 'stencilZPass', 'userData'
+        ];
+        const MeshStandardMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'color', 'roughness', 'metalness', 'map', 'lightMap', 'lightMapIntensity', 'aoMap', 'aoMapIntensity',
+            'emissive', 'emissiveIntensity', 'emissiveMap', 'bumpMap', 'bumpScale', 'normalMap',
+            'normalMapType', 'normalScale', 'displacementMap', 'displacementScale', 'displacementBias',
+            'roughnessMap', 'metalnessMap', 'alphaMap', 'envMap', 'envMapRotation', 'envMapIntensity',
+            'wireframe', 'wireframeLinewidth', 'fog', 'flatShading'
+        ];
+        const LineBasicMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'color', 'fog', 'linewidth', 'linecap', 'linejoin'
+        ];
+        const LineDashedMaterialParametersFields = [
+            ...LineBasicMaterialParametersFields,
+            'scale', 'dashSize', 'gapSize'
+        ];
+        const MeshBasicMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'color', 'opacity', 'map', 'lightMap', 'lightMapIntensity', 'aoMap', 'aoMapIntensity',
+            'specularMap', 'alphaMap', 'fog', 'envMap', 'envMapRotation', 'combine', 'reflectivity', 'refractionRatio',
+            'wireframe', 'wireframeLinewidth', 'wireframeLinecap', 'wireframeLinejoin'
+        ];
+        const MeshDepthMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'map', 'alphaMap', 'depthPacking', 'displacementMap', 'displacementScale', 'displacementBias',
+            'wireframe', 'wireframeLinewidth'
+        ];
+        const MeshDistanceMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'map', 'alphaMap', 'displacementMap', 'displacementScale', 'displacementBias',
+            'farDistance', 'nearDistance', 'referencePosition'
+        ];
+        const MeshLambertMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'bumpMap', 'bumpScale', 'color', 'displacementMap', 'displacementScale', 'displacementBias',
+            'emissive', 'emissiveIntensity', 'emissiveMap', 'flatShading', 'map', 'lightMap', 'lightMapIntensity',
+            'normalMap', 'normalScale', 'aoMap', 'aoMapIntensity', 'specularMap', 'alphaMap', 'envMap',
+            'envMapRotation', 'combine', 'reflectivity', 'refractionRatio', 'wireframe', 'wireframeLinewidth',
+            'wireframeLinecap', 'wireframeLinejoin', 'fog'
+        ];
+        const MeshMatcapMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'color', 'matcap', 'map', 'bumpMap', 'bumpScale', 'normalMap', 'normalMapType', 'normalScale',
+            'displacementMap', 'displacementScale', 'displacementBias', 'alphaMap', 'fog', 'flatShading'
+        ];
+        const MeshNormalMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'bumpMap', 'bumpScale', 'normalMap', 'normalMapType', 'normalScale', 'displacementMap',
+            'displacementScale', 'displacementBias', 'wireframe', 'wireframeLinewidth', 'flatShading'
+        ];
+        const MeshPhongMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'color', 'specular', 'shininess', 'opacity', 'map', 'lightMap', 'lightMapIntensity', 'aoMap', 'aoMapIntensity',
+            'emissive', 'emissiveIntensity', 'emissiveMap', 'bumpMap', 'bumpScale', 'normalMap', 'normalMapType', 'normalScale',
+            'displacementMap', 'displacementScale', 'displacementBias', 'specularMap', 'alphaMap', 'envMap', 'envMapRotation',
+            'combine', 'reflectivity', 'refractionRatio', 'wireframe', 'wireframeLinewidth', 'wireframeLinecap', 'wireframeLinejoin',
+            'fog', 'flatShading'
+        ];
+        const MeshPhysicalMaterialParametersFields = [
+            ...MeshStandardMaterialParametersFields,
+            'anisotropyRotation', 'anisotropyMap', 'clearcoatMap', 'clearcoatRoughness', 'clearcoatRoughnessMap',
+            'clearcoatNormalScale', 'clearcoatNormalMap', 'ior', 'reflectivity', 'iridescenceMap', 'iridescenceIOR',
+            'iridescenceThicknessRange', 'iridescenceThicknessMap', 'sheenColor', 'sheenColorMap', 'sheenRoughness',
+            'sheenRoughnessMap', 'transmissionMap', 'thickness', 'thicknessMap', 'attenuationDistance',
+            'attenuationColor', 'specularIntensity', 'specularIntensityMap', 'specularColor', 'specularColorMap',
+            'anisotropy', 'clearcoat', 'iridescence', 'dispersion', 'sheen', 'transmission'
+        ];
+        const MeshToonMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'color', 'opacity', 'gradientMap', 'map', 'lightMap', 'lightMapIntensity', 'aoMap', 'aoMapIntensity',
+            'emissive', 'emissiveIntensity', 'emissiveMap', 'bumpMap', 'bumpScale', 'normalMap', 'normalMapType', 'normalScale',
+            'displacementMap', 'displacementScale', 'displacementBias', 'alphaMap', 'wireframe', 'wireframeLinewidth',
+            'wireframeLinecap', 'wireframeLinejoin', 'fog'
+        ];
+        const ShaderMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'uniforms', 'uniformsGroups', 'vertexShader', 'fragmentShader', 'linewidth', 'wireframe', 'wireframeLinewidth',
+            'lights', 'clipping', 'fog', 'extensions', 'glslVersion'
+        ];
+        const ShadowMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'color', 'fog'
+        ];
+        const PointsMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'color', 'map', 'alphaMap', 'size', 'sizeAttenuation', 'fog'
+        ];
+        const SpriteMaterialParametersFields = [
+            ...MaterialParametersFields,
+            'color', 'map', 'alphaMap', 'rotation', 'sizeAttenuation', 'fog'
+        ];
+        this.addConstructorHandler(THREE.MeshStandardMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshStandardMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.LineBasicMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, LineBasicMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.LineDashedMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, LineDashedMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.MeshBasicMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshBasicMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.MeshDepthMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshDepthMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.MeshDistanceMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshDistanceMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.MeshLambertMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshLambertMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.MeshMatcapMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshMatcapMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.MeshNormalMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshNormalMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.MeshPhongMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshPhongMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.MeshPhysicalMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshPhysicalMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.MeshToonMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, MeshToonMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.RawShaderMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, ShaderMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.ShaderMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, ShaderMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.ShadowMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, ShadowMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.PointsMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, PointsMaterialParametersFields, includeDefaults); });
+        this.addConstructorHandler(THREE.SpriteMaterial, (obj, includeDefaults) => { return getObjectParameters(obj, SpriteMaterialParametersFields, includeDefaults); });
+        this.constructorHandlersRegistered = true;
+    }
+    // Loading methods
+    /**
+     * Sets whether the context is in editor mode
+     */
+    setEditorMode(isEditor) {
+        this.isEditor = isEditor;
+    }
+    /**
+     * Loads an actor from serialized data.
+     * @param actorData - The serialized actor data
+     * @param prefabs - A map of prefab names to their serialized data
+     * @returns The loaded actor
+     */
+    async loadActor(data, prefabs = {}) {
+        if (!isLegacyData(data)) {
+            const loader = new Loader({ flags: this.isEditor ? LoaderFlags.None : LoaderFlags.WithoutEditor });
+            return loader.load(data);
+        }
+        // support legacy data
+        const actorData = data;
+        this.currentPrefabRegistry = prefabs;
+        const instanceData = WorldSerializer.parseActorData(actorData);
+        const prefabData = await this.resolvePrefab(instanceData, prefabs);
+        const actor = await this.buildActor(instanceData, prefabData);
+        if (actor && instanceData.prefabName) {
+            console.warn('⚠️ Instantiating from legacy prefab. Please resave the prefab asset!');
+        }
+        return actor;
+    }
+    /**
+     * Loads an actor from serialized data, synchronous version.
+     * @param actorData - The serialized actor data
+     * @param prefabs - A map of prefab names to their serialized data
+     * @returns The loaded actor
+     */
+    loadActorSync(data, prefabs = {}) {
+        if (!isLegacyData(data)) {
+            const loader = new Loader({ flags: this.isEditor ? LoaderFlags.None : LoaderFlags.WithoutEditor });
+            return loader.load(data);
+        }
+        // support legacy data
+        const actorData = data;
+        this.currentPrefabRegistry = prefabs;
+        const instanceData = WorldSerializer.parseActorData(actorData);
+        const prefabData = this.resolvePrefabSync(instanceData, prefabs);
+        const actor = this.buildActorSync(instanceData, prefabData);
+        if (actor && instanceData.prefabName) {
+            console.warn('⚠️ Instantiating from legacy prefab. Please resave the prefab asset!');
+        }
+        return actor;
+    }
+    /**
+     * Loads world data into an existing world instance.
+     * @param world - The target world to load data into
+     * @param data - The raw world data to load
+     */
+    async loadWorld(world, data) {
+        if (!isLegacyData(data)) {
+            // New format, use Loader
+            const loader = new Loader();
+            await loader.loadToInstanceAsync(data, world);
+            return;
+        }
+        const worldData = data;
+        const parsedData = WorldSerializer.parseWorldData(worldData);
+        const actors = [];
+        if (parsedData.uuid) {
+            world.uuid = parsedData.uuid;
+        }
+        if (this.isEditor && parsedData.properties?.editorData) {
+            try {
+                world.editorData = structuredClone(parsedData.properties.editorData);
+            }
+            catch (error) {
+                console.error('❌ Failed to load world editor data:', error);
+            }
+        }
+        // Load post-processing configuration
+        if (parsedData.properties?.postProcessConfiguration) {
+            try {
+                world.setPostProcessConfiguration(parsedData.properties.postProcessConfiguration);
+            }
+            catch (error) {
+                console.error('❌ Failed to load post-processing configuration:', error);
+            }
+        }
+        // Load scene resource references
+        if (parsedData.resources) {
+            world.sceneResources = parsedData.resources;
+        }
+        if (parsedData.actors) {
+            for (const actorData of parsedData.actors) {
+                try {
+                    const actor = await this.loadActor(actorData, parsedData.prefabs);
+                    if (actor) {
+                        actors.push(actor);
+                    }
+                }
+                catch (error) {
+                    console.error(`Failed to load actor: ${actorData.uuid}, class: ${actorData.class}. Error: ${error}`, error instanceof Error ? error.stack : undefined);
+                }
+            }
+        }
+        // add all the actors in the end to make sure the loading is atomic
+        world.addActors(...actors);
+    }
+    /**
+     * Imports an object from serialized data.
+     * @param objectData - The serialized object data
+     * @returns The imported object
+     */
+    importObject(data) {
+        if (!isLegacyData(data)) {
+            const loader = new Loader({ flags: this.isEditor ? LoaderFlags.None : LoaderFlags.WithoutEditor });
+            return loader.load(data);
+        }
+        const objectData = data;
+        return this.construct(objectData);
+    }
+    getPrefabName(instanceData) {
+        if (instanceData.prefabName) {
+            return instanceData.prefabName;
+        }
+        const ctor = instanceData.ctor;
+        if (ctor?.prefabName) {
+            return ctor.prefabName;
+        }
+        return null;
+    }
+    /**
+     * Gets the parent prefab name from actor data
+     */
+    getParentPrefabName(actorData) {
+        return actorData.parentPrefabName ?? null;
+    }
+    /**
+     * Resolves the complete prefab inheritance chain, detecting circular dependencies
+     * @param prefabName - The starting prefab name
+     * @param prefabs - Available prefab data
+     * @param visited - Set of visited prefab names to detect cycles
+     * @returns Array of prefab data in inheritance order (base → derived)
+     */
+    async resolvePrefabInheritanceChain(prefabName, prefabs, visited = new Set()) {
+        if (visited.has(prefabName)) {
+            throw new Error(`🔄 Circular prefab dependency detected: ${Array.from(visited).join(' → ')} → ${prefabName}`);
+        }
+        visited.add(prefabName);
+        // Load the current prefab data
+        let prefabData = prefabs[prefabName];
+        prefabData ??= this.loadedPrefabData.get(prefabName);
+        prefabData ??= await resourceManager.loadJsonObject(AssetPath.fromString(prefabName));
+        if (!prefabData) {
+            throw new Error(`❌ Prefab ${prefabName} not found`);
+        }
+        this.loadedPrefabData.set(prefabName, prefabData);
+        // Check if this prefab has a parent
+        const parentPrefabName = this.getParentPrefabName(prefabData);
+        if (parentPrefabName) {
+            // Recursively resolve parent chain
+            const parentChain = await this.resolvePrefabInheritanceChain(parentPrefabName, prefabs, new Set(visited));
+            visited.delete(prefabName);
+            return [...parentChain, prefabData];
+        }
+        else {
+            visited.delete(prefabName);
+            return [prefabData];
+        }
+    }
+    /**
+     * Synchronous version of resolvePrefabInheritanceChain
+     */
+    resolvePrefabInheritanceChainSync(prefabName, prefabs, visited = new Set()) {
+        if (visited.has(prefabName)) {
+            throw new Error(`🔄 Circular prefab dependency detected: ${Array.from(visited).join(' → ')} → ${prefabName}`);
+        }
+        visited.add(prefabName);
+        // Load the current prefab data
+        let prefabData = prefabs[prefabName];
+        prefabData ??= this.loadedPrefabData.get(prefabName);
+        if (!prefabData) {
+            throw new Error(`❌ Prefab ${prefabName} not found`);
+        }
+        this.loadedPrefabData.set(prefabName, prefabData);
+        // Check if this prefab has a parent
+        const parentPrefabName = this.getParentPrefabName(prefabData);
+        if (parentPrefabName) {
+            // Recursively resolve parent chain
+            const parentChain = this.resolvePrefabInheritanceChainSync(parentPrefabName, prefabs, new Set(visited));
+            visited.delete(prefabName);
+            return [...parentChain, prefabData];
+        }
+        else {
+            visited.delete(prefabName);
+            return [prefabData];
+        }
+    }
+    async resolvePrefab(instanceData, prefabs) {
+        const prefabName = this.getPrefabName(instanceData);
+        if (!prefabName)
+            return null;
+        // Resolve the complete inheritance chain
+        const inheritanceChain = await this.resolvePrefabInheritanceChain(prefabName, prefabs);
+        // Apply inheritance by merging from base to derived
+        let resolvedPrefabData = inheritanceChain[0];
+        for (let i = 1; i < inheritanceChain.length; i++) {
+            const childPrefab = inheritanceChain[i];
+            resolvedPrefabData = deepMerge(resolvedPrefabData, childPrefab);
+        }
+        // Always remove UUID from prefab data - UUIDs are instance-specific, not part of prefab definition
+        // The instance UUID will be applied to the actor during construction, but should not be stored in prefab data
+        delete resolvedPrefabData.uuid;
+        return resolvedPrefabData;
+    }
+    resolvePrefabSync(instanceData, prefabs) {
+        const prefabName = this.getPrefabName(instanceData);
+        if (!prefabName)
+            return null;
+        // Resolve the complete inheritance chain
+        const inheritanceChain = this.resolvePrefabInheritanceChainSync(prefabName, prefabs);
+        // Apply inheritance by merging from base to derived
+        let resolvedPrefabData = inheritanceChain[0];
+        for (let i = 1; i < inheritanceChain.length; i++) {
+            const childPrefab = inheritanceChain[i];
+            resolvedPrefabData = deepMerge(resolvedPrefabData, childPrefab);
+        }
+        // Always remove UUID from prefab data - UUIDs are instance-specific, not part of prefab definition
+        // The instance UUID will be applied to the actor during construction, but should not be stored in prefab data
+        delete resolvedPrefabData.uuid;
+        return resolvedPrefabData;
+    }
+    async buildActor(instanceData, prefabData) {
+        // use a copy of the data to avoid modifying the original data which could be part of the world data (that we shouldn't modify)
+        const prefabDataCopy = prefabData ? structuredClone(prefabData) : null;
+        let resolvedData;
+        if (prefabDataCopy) {
+            resolvedData = deepMerge(prefabDataCopy, instanceData);
+        }
+        else {
+            resolvedData = structuredClone(instanceData);
+        }
+        if (prefabDataCopy) {
+            // the instance data may contain an irrelevant class name, use the prefab class instead
+            resolvedData.class = prefabDataCopy.class;
+        }
+        if (!resolvedData.ctor) {
+            throw new Error('Actor data is invalid, missing ctor');
+        }
+        if (Array.isArray(resolvedData.ctor)) {
+            throw new Error('Actor data is invalid, ctor is an array');
+        }
+        // Skip editor only actor in game
+        if (resolvedData.properties?.editorOnly && !this.isEditor) {
+            return null;
+        }
+        if (resolvedData.ctor.rootComponent) {
+            resolvedData.ctor.rootComponent = this.loadSceneObject(null, resolvedData.ctor.rootComponent);
+            if (!resolvedData.ctor.rootComponent) {
+                // Skip editor only root component in game (skips the actor)
+                return null;
+            }
+        }
+        {
+            // TEMP hack to load the components from the now deprecated ctor.components field
+            const sceneComponents = resolvedData.ctor.sceneComponents ?? [];
+            const components = resolvedData.ctor.components ?? [];
+            resolvedData.ctor.sceneComponents = [...sceneComponents, ...components];
+        }
+        // Construct actor
+        const actor = this.construct(resolvedData);
+        const prefabName = this.getPrefabName(instanceData);
+        if (prefabName && prefabDataCopy) {
+            // Store the entire prefab registry for this actor so it can resolve inheritance chains later
+            // Ensure prefab data doesn't contain instance-specific UUID
+            const cleanPrefabData = JSON.parse(JSON.stringify(prefabDataCopy));
+            delete cleanPrefabData.uuid;
+            actor.setPrefab(prefabName, cleanPrefabData, this.currentPrefabRegistry);
+        }
+        return actor;
+    }
+    buildActorSync(instanceData, prefabData) {
+        // use a copy of the data to avoid modifying the original data which could be part of the world data (that we shouldn't modify)
+        const prefabDataCopy = prefabData ? structuredClone(prefabData) : null;
+        let resolvedData;
+        if (prefabDataCopy) {
+            resolvedData = deepMerge(prefabDataCopy, instanceData);
+        }
+        else {
+            resolvedData = structuredClone(instanceData);
+        }
+        if (prefabDataCopy) {
+            // the instance data may contain an irrelevant class name, use the prefab class instead
+            resolvedData.class = prefabDataCopy.class;
+        }
+        if (!resolvedData.ctor) {
+            throw new Error('Actor data is invalid, missing ctor');
+        }
+        if (Array.isArray(resolvedData.ctor)) {
+            throw new Error('Actor data is invalid, ctor is an array');
+        }
+        // Skip editor only actor in game
+        if (resolvedData.properties?.editorOnly && !this.isEditor) {
+            return null;
+        }
+        if (resolvedData.ctor.rootComponent) {
+            resolvedData.ctor.rootComponent = this.loadSceneObject(null, resolvedData.ctor.rootComponent);
+            if (!resolvedData.ctor.rootComponent) {
+                // Skip editor only root component in game (skips the actor)
+                return null;
+            }
+        }
+        {
+            // TEMP hack to load the components from the now deprecated ctor.components field
+            const sceneComponents = resolvedData.ctor.sceneComponents ?? [];
+            const components = resolvedData.ctor.components ?? [];
+            resolvedData.ctor.sceneComponents = [...sceneComponents, ...components];
+        }
+        // Construct actor
+        const actor = this.construct(resolvedData);
+        const prefabName = this.getPrefabName(instanceData);
+        if (prefabName && prefabDataCopy) {
+            // Store the entire prefab registry for this actor so it can resolve inheritance chains later
+            // Ensure prefab data doesn't contain instance-specific UUID
+            const cleanPrefabData = JSON.parse(JSON.stringify(prefabDataCopy));
+            delete cleanPrefabData.uuid;
+            actor.setPrefab(prefabName, cleanPrefabData, this.currentPrefabRegistry);
+        }
+        return actor;
+    }
+    construct(objectData) {
+        if (objectData === null || objectData === undefined) {
+            return objectData;
+        }
+        if (objectData[externalRefKey]) {
+            return WorldSerializationContext.ExternalObjects.get(objectData[externalRefKey]);
+        }
+        if (objectData[internalRefKey]) {
+            // Resolve internal reference to already loaded object
+            const refUUID = objectData[internalRefKey];
+            const referencedObject = this.loadedObjectsByUUID.get(refUUID);
+            if (!referencedObject) {
+                console.warn(`Referenced object with uuid ${refUUID} not found in loaded objects`);
+            }
+            return referencedObject;
+        }
+        if (Array.isArray(objectData)) {
+            // Check for compact vector format with type tags
+            if (objectData.length >= 2 && typeof objectData[objectData.length - 1] === 'string') {
+                const typeTag = objectData[objectData.length - 1];
+                switch (typeTag) {
+                    case 'v2':
+                        return new THREE.Vector2(objectData[0], objectData[1]);
+                    case 'v': // v for Vector3 (most common)
+                    case 'v3': // Keep v3 for backward compatibility
+                        return new THREE.Vector3(objectData[0], objectData[1], objectData[2]);
+                    case 'v4':
+                        return new THREE.Vector4(objectData[0], objectData[1], objectData[2], objectData[3]);
+                    case 'e':
+                        return new THREE.Euler(objectData[0], objectData[1], objectData[2]);
+                    case 'q':
+                        return new THREE.Quaternion(objectData[0], objectData[1], objectData[2], objectData[3]);
+                    case 'c':
+                        return new THREE.Color(objectData[0], objectData[1], objectData[2]);
+                    case 'ia':
+                        return new Int32Array(objectData.slice(0, objectData.length - 1));
+                    case 'fa':
+                        return new Float32Array(objectData.slice(0, objectData.length - 1));
+                }
+            }
+            // array value, construct each value
+            return objectData.map(v => v != null ? this.construct(v) : null).filter(v => v != null);
+        }
+        else if (typeof objectData === 'object') {
+            if (this.constructedObjects.has(objectData)) {
+                // return the object as-is if it's already constructed
+                return objectData;
+            }
+            const className = this.construct(objectData.class);
+            if (className) {
+                // object value needs construction, construct it
+                const object = ClassRegistry.constructObject(className, true, this.construct(objectData.ctor));
+                const properties = this.construct(objectData.properties);
+                if (properties) {
+                    if (properties.editorOnly && !this.isEditor) {
+                        return null; // Skip editor only objects in game
+                    }
+                    if (properties.position) {
+                        object.position.copy(properties.position);
+                        delete properties.position;
+                    }
+                    if (properties.rotation) {
+                        object.rotation.copy(properties.rotation);
+                        delete properties.rotation;
+                    }
+                    if (properties.scale) {
+                        object.scale.copy(properties.scale);
+                        delete properties.scale;
+                    }
+                    if (properties.tags && typeof object.setTags === 'function') {
+                        object.setTags(properties.tags);
+                        delete properties.tags;
+                    }
+                    if (properties.hiddenInGame !== undefined && typeof object.setHiddenInGame === 'function') {
+                        object.setHiddenInGame(properties.hiddenInGame);
+                        delete properties.hiddenInGame;
+                    }
+                    if (properties.editorOnly !== undefined && typeof object.setEditorOnly === 'function') {
+                        object.setEditorOnly(properties.editorOnly);
+                        delete properties.editorOnly;
+                    }
+                    Object.assign(object, properties);
+                }
+                if (objectData.uuid) {
+                    object.uuid = objectData.uuid;
+                    // Store the object for potential reference resolution
+                    this.loadedObjectsByUUID.set(objectData.uuid, object);
+                }
+                this.constructedObjects.add(object);
+                return object;
+            }
+            else {
+                // regular object value, construct each property
+                const expandedObject = {};
+                for (const [k, v] of Object.entries(objectData)) {
+                    expandedObject[k] = this.construct(v);
+                }
+                this.constructedObjects.add(expandedObject);
+                return expandedObject;
+            }
+        }
+        else {
+            // none of the above, most likely just a primitive value
+            return objectData;
+        }
+    }
+    loadSceneObject(parent, sceneObjectData) {
+        const sceneObject = this.construct(sceneObjectData);
+        if (!sceneObject) {
+            return null;
+        }
+        if (parent) {
+            parent.add(sceneObject);
+        }
+        for (const childData of sceneObjectData.children ?? []) {
+            this.loadSceneObject(sceneObject, childData);
+        }
+        return sceneObject;
+    }
+}
+// Debug flag to enable call stack tracking for exports
+Object.defineProperty(WorldSerializationContext, "DEBUG_EXPORT_STACK", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: false
+});
+// Flag to enable precision normalization for numbers (reduces file size)
+Object.defineProperty(WorldSerializationContext, "ENABLE_PRECISION_NORMALIZATION", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: true
+});
+// Flag to enable compact format for Vector3/Euler with type tags (further reduces file size)
+Object.defineProperty(WorldSerializationContext, "ENABLE_COMPACT_VECTORS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: true
+});
+Object.defineProperty(WorldSerializationContext, "constructorHandlersRegistered", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: false
+});
+Object.defineProperty(WorldSerializationContext, "constructorHandlers", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Map()
+});
+Object.defineProperty(WorldSerializationContext, "classDefaultObjects", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Map()
+});
+Object.defineProperty(WorldSerializationContext, "externalObjects", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Map()
+});
+/**
+ * Handles loading and parsing of world data into the engine.
+ * Provides functionality to convert serialized world data into
+ * runtime objects and components.
+ */
+export class WorldSerializer {
+    /**
+     * Exports an object to a serializable format.
+     * @param object - The object to export
+     * @param includeDefaults - Whether to include default values
+     * @returns The serialized object
+     */
+    static exportObject(object, includeDefaults) {
+        let data = new WorldSerializationContext().exportObject(object, false);
+        if (typeof data === 'object' && !(serializationVersionKey in data)) {
+            data = {
+                [serializationVersionKey]: SerializationVersion.Legacy,
+                ...data
+            };
+        }
+        return data;
+    }
+    static exportAsPrefab(obj, inlineToPrefab = false) {
+        const asPrefab = true;
+        const data = new WorldSerializationContext().exportObject(obj, asPrefab, inlineToPrefab);
+        return data;
+    }
+    /**
+     * Validates and parses raw actor data against the defined schema.
+     * @param actorData - The raw actor data object to parse
+     * @returns The validated actor data object
+     */
+    static parseActorData(actorData) {
+        return actorSchema.parse(actorData);
+    }
+    /**
+     * Loads an actor from serialized data.
+     * @param actorData - The serialized actor data
+     * @param prefabs - A map of prefab names to their serialized data
+     * @returns The loaded actor
+     */
+    static async loadActor(actorData, prefabs = {}, isEditor) {
+        const context = new WorldSerializationContext();
+        context.setEditorMode(isEditor ?? false);
+        const loadedActor = context.loadActor(actorData, prefabs);
+        return loadedActor;
+    }
+    /**
+     * Loads an actor from serialized data, synchronous version.
+     * @param actorData - The serialized actor data
+     * @param prefabs - A map of prefab names to their serialized data. It must be provided if actorData contains a prefabName
+     * @returns The loaded actor
+     */
+    static loadActorSync(actorData, prefabs = {}, isEditor) {
+        const context = new WorldSerializationContext();
+        context.setEditorMode(isEditor ?? false);
+        return context.loadActorSync(actorData, prefabs);
+    }
+    /**
+     * Validates and parses raw world data against the defined schema.
+     * @param worldData - The raw world data object to parse
+     * @returns The validated world data object
+     */
+    static parseWorldData(worldData) {
+        return worldSchema.parse(worldData);
+    }
+    /**
+     * Loads world data into an existing world instance.
+     * Creates actors, components, and scene hierarchies based on the provided data.
+     * @param world - The target world to load data into
+     * @param worldData - The raw world data to load
+     * @param isEditor - Whether the world is being loaded in the editor
+     */
+    static async loadWorld(world, worldData, isEditor) {
+        const context = new WorldSerializationContext();
+        context.setEditorMode(isEditor ?? false);
+        return context.loadWorld(world, worldData);
+    }
+    static importObject(objectData, isEditor) {
+        const context = new WorldSerializationContext();
+        context.setEditorMode(isEditor ?? false);
+        return context.importObject(objectData);
+    }
+    /**
+     * Creates prefab data from an actor
+     * @param actor - The actor to create prefab data from
+     * @param inlineToPrefab - whether to inline to the actor's prefab itself, as against to creating a new prefab that is dependent on the actor's prefab
+     * @returns The prefab data
+     */
+    static createPrefabDataFromActor(actor, inlineToPrefab = false) {
+        return WorldSerializer.exportAsPrefab(actor, inlineToPrefab);
+    }
+    /** Creates prefab data from an actor with a parent prefab  */
+    static createPrefabDataFromActorWithParent(actor, parentPrefabName) {
+        const prefabData = actor.asExportedObject();
+        replace_uuids(prefabData, { deleteKey: true });
+        delete prefabData.prefabName;
+        prefabData.parentPrefabName = parentPrefabName;
+        return prefabData;
+    }
+    /** Loads the template actor from a prefab */
+    static loadPrefabTemplateActor(prefabName, prefabs, isEditor = true) {
+        const prefabData = prefabs[prefabName];
+        if (isLegacyData(prefabData)) {
+            const prefab = WorldSerializer.loadActorSync({
+                prefabName,
+            }, prefabs, isEditor);
+            if (!prefab) {
+                throw new Error('Failed to load prefab template actor');
+            }
+            if (prefab.getPrefabName() === prefabName) {
+                prefab.clearPrefab(); // Clear prefab reference to avoid circular dependency.
+            }
+            return prefab;
+        }
+        return loadPrefabTemplateInstance(prefabName, prefabs, { withoutEditor: !isEditor });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WorldSerialization.js","sourceRoot":"","sources":["../../../src/systems/WorldSerialization.ts"],"names":[],"mappings":"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"}