@nice2dev/game-engine 1.3.15 → 1.3.17

package/dist/cjs/editor/PrefabSystem.js

@@ -1,861 +1,795 @@
-'use strict';
-
-/**
- * @file PrefabSystem.ts
- * @description Advanced Prefab System with nested prefabs, variants, override tracking
- * PRO-1.4: Professional Editor Features
- *
- * Features:
- * - Prefab definition and instantiation
- * - Nested prefabs (prefabs containing other prefabs)
- * - Prefab variants (inherited modifications)
- * - Override tracking (property-level changes)
- * - Apply/revert overrides
- * - Prefab linking (maintain connection to source)
- * - Unpack prefab (break connection)
- * - Auto-update instances when prefab changes
- * - Serialization/deserialization
- * - Prefab comparison (diff)
- */
-// ============================================================
-// Default Transform
-// ============================================================
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const DEFAULT_TRANSFORM = {
-    position: { x: 0, y: 0, z: 0 },
-    rotation: { x: 0, y: 0, z: 0, w: 1 },
-    scale: { x: 1, y: 1, z: 1 },
+  position: { x: 0, y: 0, z: 0 },
+  rotation: { x: 0, y: 0, z: 0, w: 1 },
+  scale: { x: 1, y: 1, z: 1 }
 };
-// ============================================================
-// Utility Functions
-// ============================================================
 function generateId() {
-    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 }
 function deepClone(obj) {
-    return JSON.parse(JSON.stringify(obj));
+  return JSON.parse(JSON.stringify(obj));
 }
 function getValueAtPath(obj, path) {
-    const parts = path.split('.');
-    let current = obj;
-    for (const part of parts) {
-        if (current === null || current === undefined) {
-            return undefined;
-        }
-        if (typeof current !== 'object') {
-            return undefined;
-        }
-        const index = parseInt(part, 10);
-        if (!isNaN(index) && Array.isArray(current)) {
-            current = current[index];
-        }
-        else {
-            current = current[part];
-        }
-    }
-    return current;
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    const index = parseInt(part, 10);
+    if (!isNaN(index) && Array.isArray(current)) {
+      current = current[index];
+    } else {
+      current = current[part];
+    }
+  }
+  return current;
 }
 function setValueAtPath(obj, path, value) {
-    const parts = path.split('.');
-    let current = obj;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (current === null || current === undefined) {
-            return;
-        }
-        if (typeof current !== 'object') {
-            return;
-        }
-        const index = parseInt(part, 10);
-        if (!isNaN(index) && Array.isArray(current)) {
-            current = current[index];
-        }
-        else {
-            current = current[part];
-        }
-    }
-    if (current && typeof current === 'object') {
-        const lastPart = parts[parts.length - 1];
-        const index = parseInt(lastPart, 10);
-        if (!isNaN(index) && Array.isArray(current)) {
-            current[index] = value;
-        }
-        else {
-            current[lastPart] = value;
-        }
-    }
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current === null || current === void 0) {
+      return;
+    }
+    if (typeof current !== "object") {
+      return;
+    }
+    const index = parseInt(part, 10);
+    if (!isNaN(index) && Array.isArray(current)) {
+      current = current[index];
+    } else {
+      current = current[part];
+    }
+  }
+  if (current && typeof current === "object") {
+    const lastPart = parts[parts.length - 1];
+    const index = parseInt(lastPart, 10);
+    if (!isNaN(index) && Array.isArray(current)) {
+      current[index] = value;
+    } else {
+      current[lastPart] = value;
+    }
+  }
 }
 function compareValues(a, b) {
-    return JSON.stringify(a) === JSON.stringify(b);
+  return JSON.stringify(a) === JSON.stringify(b);
 }
-// ============================================================
-// Prefab Manager
-// ============================================================
 class PrefabManager {
-    constructor() {
-        this.prefabs = new Map();
-        this.instances = new Map();
-        this.prefabVersions = new Map();
-    }
-    // ─── Prefab Creation ───────────────────────────────────
-    createPrefab(name, rootEntity) {
-        const id = `prefab_${generateId()}`;
-        const now = Date.now();
-        const root = {
-            id: `entity_${generateId()}`,
-            name: rootEntity?.name ?? name,
-            parentId: null,
-            transform: rootEntity?.transform ?? deepClone(DEFAULT_TRANSFORM),
-            components: rootEntity?.components ?? [],
-            children: rootEntity?.children ?? [],
-            tags: rootEntity?.tags ?? [],
-            layer: rootEntity?.layer ?? 'default',
-            active: rootEntity?.active ?? true,
-        };
-        const prefab = {
-            id,
-            name,
-            description: '',
-            version: 1,
-            createdAt: now,
-            modifiedAt: now,
-            author: '',
-            rootEntity: root,
-            entities: new Map([[root.id, root]]),
-            nestedPrefabs: [],
-            tags: [],
-            category: 'General',
-        };
-        this.prefabs.set(id, prefab);
-        this.prefabVersions.set(id, 1);
-        return prefab;
-    }
-    createPrefabFromEntities(name, entities) {
-        const prefab = this.createPrefab(name);
-        // Find root (entity with no parent or parent not in list)
-        const entityIds = new Set(entities.map((e) => e.id));
-        const root = entities.find((e) => !e.parentId || !entityIds.has(e.parentId));
-        if (root) {
-            prefab.rootEntity = deepClone(root);
-            prefab.entities.set(root.id, prefab.rootEntity);
-        }
-        // Add all entities
-        for (const entity of entities) {
-            if (entity.id !== prefab.rootEntity.id) {
-                const clone = deepClone(entity);
-                prefab.entities.set(clone.id, clone);
-            }
-        }
-        this.updatePrefabVersion(prefab.id);
-        return prefab;
-    }
-    // ─── Prefab Variants ───────────────────────────────────
-    createVariant(basePrefabId, name) {
-        const basePrefab = this.prefabs.get(basePrefabId);
-        if (!basePrefab) {
-            return null;
-        }
-        const variant = this.createPrefab(name);
-        variant.variantOf = basePrefabId;
-        variant.inheritedOverrides = [];
-        // Copy base structure
-        variant.rootEntity = deepClone(basePrefab.rootEntity);
-        variant.rootEntity.id = `entity_${generateId()}`;
-        variant.entities.clear();
-        variant.entities.set(variant.rootEntity.id, variant.rootEntity);
-        for (const [, entity] of basePrefab.entities) {
-            if (entity.id !== basePrefab.rootEntity.id) {
-                const clone = deepClone(entity);
-                clone.id = `entity_${generateId()}`;
-                variant.entities.set(clone.id, clone);
-            }
-        }
-        variant.nestedPrefabs = deepClone(basePrefab.nestedPrefabs);
-        return variant;
-    }
-    getBasePrefab(variantId) {
-        const variant = this.prefabs.get(variantId);
-        if (!variant?.variantOf) {
-            return null;
-        }
-        return this.prefabs.get(variant.variantOf) ?? null;
-    }
-    applyVariantOverrides(variantId) {
-        const variant = this.prefabs.get(variantId);
-        if (!variant || !variant.variantOf) {
-            return;
-        }
-        const base = this.prefabs.get(variant.variantOf);
-        if (!base) {
-            return;
-        }
-        // Apply inherited overrides from base to variant
-        if (variant.inheritedOverrides) {
-            for (const override of variant.inheritedOverrides) {
-                const targetEntity = this.findEntityByPathRoot(variant, override.path);
-                if (targetEntity) {
-                    setValueAtPath(targetEntity, override.path, override.overridenValue);
-                }
-            }
-        }
-        this.updatePrefabVersion(variantId);
-    }
-    // ─── Nested Prefabs ────────────────────────────────────
-    addNestedPrefab(parentPrefabId, nestedPrefabId, parentEntityId, transform) {
-        const parentPrefab = this.prefabs.get(parentPrefabId);
-        const nestedPrefab = this.prefabs.get(nestedPrefabId);
-        if (!parentPrefab || !nestedPrefab) {
-            return null;
-        }
-        if (!parentPrefab.entities.has(parentEntityId)) {
-            return null;
-        }
-        // Check for circular reference
-        if (this.hasCircularReference(parentPrefabId, nestedPrefabId)) {
-            console.error('Circular prefab reference detected');
-            return null;
-        }
-        const reference = {
-            instanceId: `nested_${generateId()}`,
-            prefabId: nestedPrefabId,
-            parentEntityId,
-            overrides: [],
-            transform: {
-                ...deepClone(DEFAULT_TRANSFORM),
-                ...transform,
-            },
-        };
-        parentPrefab.nestedPrefabs.push(reference);
-        this.updatePrefabVersion(parentPrefabId);
-        return reference;
-    }
-    removeNestedPrefab(parentPrefabId, instanceId) {
-        const parentPrefab = this.prefabs.get(parentPrefabId);
-        if (!parentPrefab) {
-            return false;
-        }
-        const index = parentPrefab.nestedPrefabs.findIndex((n) => n.instanceId === instanceId);
-        if (index === -1) {
-            return false;
-        }
-        parentPrefab.nestedPrefabs.splice(index, 1);
-        this.updatePrefabVersion(parentPrefabId);
-        return true;
-    }
-    hasCircularReference(parentId, childId, visited = new Set()) {
-        if (parentId === childId) {
-            return true;
-        }
-        if (visited.has(childId)) {
-            return true;
-        }
-        visited.add(childId);
-        const childPrefab = this.prefabs.get(childId);
-        if (!childPrefab) {
-            return false;
-        }
-        for (const nested of childPrefab.nestedPrefabs) {
-            if (this.hasCircularReference(parentId, nested.prefabId, visited)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    // ─── Instantiation ─────────────────────────────────────
-    instantiate(prefabId, worldTransform) {
-        const prefab = this.prefabs.get(prefabId);
-        if (!prefab) {
-            return null;
-        }
-        const instance = {
-            id: `instance_${generateId()}`,
-            prefabId,
-            name: prefab.name,
-            overrides: [],
-            worldTransform: {
-                ...deepClone(DEFAULT_TRANSFORM),
-                ...worldTransform,
-            },
-            nestedInstances: new Map(),
-            isLinked: true,
-            createdAt: Date.now(),
-            lastSyncedAt: Date.now(),
-        };
-        // Instantiate nested prefabs recursively
-        for (const nestedRef of prefab.nestedPrefabs) {
-            const nestedInstance = this.instantiate(nestedRef.prefabId, nestedRef.transform);
-            if (nestedInstance) {
-                // Apply nested prefab overrides
-                nestedInstance.overrides = deepClone(nestedRef.overrides);
-                instance.nestedInstances.set(nestedRef.instanceId, nestedInstance);
-            }
-        }
-        this.instances.set(instance.id, instance);
-        return instance;
-    }
-    destroyInstance(instanceId) {
-        const instance = this.instances.get(instanceId);
-        if (!instance) {
-            return false;
-        }
-        // Destroy nested instances
-        for (const [, nested] of instance.nestedInstances) {
-            this.destroyInstance(nested.id);
-        }
-        this.instances.delete(instanceId);
-        return true;
-    }
-    // ─── Override Management ───────────────────────────────
-    setOverride(instanceId, path, value) {
-        const instance = this.instances.get(instanceId);
-        if (!instance) {
-            return;
-        }
-        const prefab = this.prefabs.get(instance.prefabId);
-        if (!prefab) {
-            return;
-        }
-        const originalValue = this.getOriginalValue(prefab, path);
-        // Check if value is same as original
-        if (compareValues(originalValue, value)) {
-            this.removeOverride(instanceId, path);
-            return;
-        }
-        // Check if override already exists
-        const existingIndex = instance.overrides.findIndex((o) => o.path === path);
-        const override = {
-            path,
-            originalValue,
-            overridenValue: value,
-            overrideType: 'modify',
-            timestamp: Date.now(),
-        };
-        if (existingIndex !== -1) {
-            instance.overrides[existingIndex] = override;
-        }
-        else {
-            instance.overrides.push(override);
-        }
-        this.onInstanceChanged?.(instanceId);
-    }
-    removeOverride(instanceId, path) {
-        const instance = this.instances.get(instanceId);
-        if (!instance) {
-            return;
-        }
-        instance.overrides = instance.overrides.filter((o) => o.path !== path);
-        this.onInstanceChanged?.(instanceId);
-    }
-    revertAllOverrides(instanceId) {
-        const instance = this.instances.get(instanceId);
-        if (!instance) {
-            return;
-        }
-        instance.overrides = [];
-        this.onInstanceChanged?.(instanceId);
-    }
-    applyOverridesToPrefab(instanceId) {
-        const instance = this.instances.get(instanceId);
-        if (!instance) {
-            return;
-        }
-        const prefab = this.prefabs.get(instance.prefabId);
-        if (!prefab) {
-            return;
-        }
-        // Apply all overrides to the prefab
-        for (const override of instance.overrides) {
-            const entity = this.findEntityByPathRoot(prefab, override.path);
-            if (entity) {
-                setValueAtPath(entity, override.path, override.overridenValue);
-            }
-        }
-        // Clear instance overrides
-        instance.overrides = [];
-        this.updatePrefabVersion(instance.prefabId);
-    }
-    hasOverrides(instanceId) {
-        const instance = this.instances.get(instanceId);
-        return instance ? instance.overrides.length > 0 : false;
-    }
-    getOverrides(instanceId) {
-        const instance = this.instances.get(instanceId);
-        return instance ? [...instance.overrides] : [];
-    }
-    getOriginalValue(prefab, path) {
-        // Parse path to find the entity and property
-        const entity = this.findEntityByPathRoot(prefab, path);
-        if (!entity) {
-            return undefined;
-        }
-        const relativePath = this.getRelativePropertyPath(path);
-        return getValueAtPath(entity, relativePath);
-    }
-    findEntityByPathRoot(prefab, path) {
-        const parts = path.split('.');
-        // Check if path starts with entity reference
-        if (parts[0].startsWith('entity_')) {
-            return prefab.entities.get(parts[0]) ?? null;
-        }
-        // Default to root entity
-        return prefab.rootEntity;
-    }
-    getRelativePropertyPath(path) {
-        const parts = path.split('.');
-        // Skip entity ID if present
-        if (parts[0].startsWith('entity_')) {
-            return parts.slice(1).join('.');
-        }
-        return path;
-    }
-    // ─── Linking ───────────────────────────────────────────
-    unlinkInstance(instanceId) {
-        const instance = this.instances.get(instanceId);
-        if (!instance) {
-            return;
-        }
-        instance.isLinked = false;
-        instance.unpackedAt = Date.now();
-        // Unlink nested instances
-        for (const [, nested] of instance.nestedInstances) {
-            this.unlinkInstance(nested.id);
-        }
-        this.onInstanceChanged?.(instanceId);
-    }
-    relinkInstance(instanceId) {
-        const instance = this.instances.get(instanceId);
-        if (!instance) {
-            return false;
-        }
-        // Check if prefab still exists
-        if (!this.prefabs.has(instance.prefabId)) {
-            return false;
-        }
-        instance.isLinked = true;
-        instance.unpackedAt = undefined;
-        instance.lastSyncedAt = Date.now();
-        this.onInstanceChanged?.(instanceId);
-        return true;
-    }
-    // ─── Synchronization ───────────────────────────────────
-    syncInstance(instanceId) {
-        const instance = this.instances.get(instanceId);
-        if (!instance || !instance.isLinked) {
-            return;
-        }
-        const prefab = this.prefabs.get(instance.prefabId);
-        if (!prefab) {
-            return;
-        }
-        this.prefabVersions.get(instance.prefabId) ?? 0;
-        // Instance is already synced
-        if (instance.lastSyncedAt >= prefab.modifiedAt) {
-            return;
-        }
-        // Re-apply overrides after sync
-        // (In a real implementation, you'd merge changes intelligently)
-        instance.lastSyncedAt = Date.now();
-        // Sync nested instances
-        for (const [, nested] of instance.nestedInstances) {
-            this.syncInstance(nested.id);
-        }
-        this.onInstanceChanged?.(instanceId);
-    }
-    syncAllInstances(prefabId) {
-        for (const [instanceId, instance] of this.instances) {
-            if (instance.prefabId === prefabId && instance.isLinked) {
-                this.syncInstance(instanceId);
-            }
-        }
-    }
-    updatePrefabVersion(prefabId) {
-        const prefab = this.prefabs.get(prefabId);
-        if (prefab) {
-            prefab.version++;
-            prefab.modifiedAt = Date.now();
-            this.prefabVersions.set(prefabId, prefab.version);
-            this.onPrefabChanged?.(prefabId);
-        }
-    }
-    // ─── Entity Management ─────────────────────────────────
-    addEntity(prefabId, entity, parentId) {
-        const prefab = this.prefabs.get(prefabId);
-        if (!prefab) {
-            return null;
-        }
-        const newEntity = {
-            id: `entity_${generateId()}`,
-            name: entity.name ?? 'New Entity',
-            parentId: parentId ?? prefab.rootEntity.id,
-            transform: entity.transform ?? deepClone(DEFAULT_TRANSFORM),
-            components: entity.components ?? [],
-            children: entity.children ?? [],
-            tags: entity.tags ?? [],
-            layer: entity.layer ?? 'default',
-            active: entity.active ?? true,
-        };
-        prefab.entities.set(newEntity.id, newEntity);
-        // Update parent's children list
-        const parent = prefab.entities.get(newEntity.parentId);
-        if (parent) {
-            parent.children.push(newEntity.id);
-        }
-        this.updatePrefabVersion(prefabId);
-        return newEntity;
-    }
-    removeEntity(prefabId, entityId) {
-        const prefab = this.prefabs.get(prefabId);
-        if (!prefab) {
-            return false;
-        }
-        if (entityId === prefab.rootEntity.id) {
-            return false;
-        } // Can't remove root
-        const entity = prefab.entities.get(entityId);
-        if (!entity) {
-            return false;
-        }
-        // Remove from parent's children
-        if (entity.parentId) {
-            const parent = prefab.entities.get(entity.parentId);
-            if (parent) {
-                parent.children = parent.children.filter((id) => id !== entityId);
-            }
-        }
-        // Remove children recursively
-        for (const childId of entity.children) {
-            this.removeEntity(prefabId, childId);
-        }
-        prefab.entities.delete(entityId);
-        this.updatePrefabVersion(prefabId);
-        return true;
-    }
-    // ─── Component Management ──────────────────────────────
-    addComponent(prefabId, entityId, component) {
-        const prefab = this.prefabs.get(prefabId);
-        if (!prefab) {
-            return null;
-        }
-        const entity = prefab.entities.get(entityId);
-        if (!entity) {
-            return null;
-        }
-        const newComponent = {
-            id: `component_${generateId()}`,
-            type: component.type ?? 'Unknown',
-            properties: component.properties ?? {},
-            enabled: component.enabled ?? true,
-        };
-        entity.components.push(newComponent);
-        this.updatePrefabVersion(prefabId);
-        return newComponent;
-    }
-    removeComponent(prefabId, entityId, componentId) {
-        const prefab = this.prefabs.get(prefabId);
-        if (!prefab) {
-            return false;
-        }
-        const entity = prefab.entities.get(entityId);
-        if (!entity) {
-            return false;
-        }
-        const index = entity.components.findIndex((c) => c.id === componentId);
-        if (index === -1) {
-            return false;
-        }
-        entity.components.splice(index, 1);
-        this.updatePrefabVersion(prefabId);
-        return true;
-    }
-    // ─── Comparison ────────────────────────────────────────
-    comparePrefabs(prefabIdA, prefabIdB) {
-        const prefabA = this.prefabs.get(prefabIdA);
-        const prefabB = this.prefabs.get(prefabIdB);
-        if (!prefabA || !prefabB) {
-            return null;
-        }
-        const diff = {
-            added: [],
-            removed: [],
-            modified: [],
-            componentAdded: [],
-            componentRemoved: [],
-            entityAdded: [],
-            entityRemoved: [],
-        };
-        // Compare entities
-        const entityIdsA = new Set(prefabA.entities.keys());
-        const entityIdsB = new Set(prefabB.entities.keys());
-        for (const id of entityIdsB) {
-            if (!entityIdsA.has(id)) {
-                diff.entityAdded.push(id);
-            }
-        }
-        for (const id of entityIdsA) {
-            if (!entityIdsB.has(id)) {
-                diff.entityRemoved.push(id);
-            }
-        }
-        // Compare matching entities
-        for (const [id, entityA] of prefabA.entities) {
-            const entityB = prefabB.entities.get(id);
-            if (!entityB) {
-                continue;
-            }
-            this.compareEntities(entityA, entityB, id, diff);
-        }
-        return diff;
-    }
-    compareInstanceToPrefab(instanceId) {
-        const instance = this.instances.get(instanceId);
-        if (!instance) {
-            return null;
-        }
-        const prefab = this.prefabs.get(instance.prefabId);
-        if (!prefab) {
-            return null;
-        }
-        const diff = {
-            added: [],
-            removed: [],
-            modified: [],
-            componentAdded: [],
-            componentRemoved: [],
-            entityAdded: [],
-            entityRemoved: [],
-        };
-        // List all overrides as modifications
-        for (const override of instance.overrides) {
-            diff.modified.push({
-                path: override.path,
-                oldValue: override.originalValue,
-                newValue: override.overridenValue,
-            });
-        }
-        return diff;
-    }
-    compareEntities(entityA, entityB, prefix, diff) {
-        // Compare transform
-        this.compareProperty(entityA.transform, entityB.transform, `${prefix}.transform`, diff);
-        // Compare components
-        const compIdsA = new Set(entityA.components.map((c) => c.id));
-        const compIdsB = new Set(entityB.components.map((c) => c.id));
-        for (const comp of entityB.components) {
-            if (!compIdsA.has(comp.id)) {
-                diff.componentAdded.push(`${prefix}.${comp.id}`);
-            }
-        }
-        for (const comp of entityA.components) {
-            if (!compIdsB.has(comp.id)) {
-                diff.componentRemoved.push(`${prefix}.${comp.id}`);
-            }
-        }
-        // Compare matching components
-        for (const compA of entityA.components) {
-            const compB = entityB.components.find((c) => c.id === compA.id);
-            if (!compB) {
-                continue;
-            }
-            this.compareProperty(compA.properties, compB.properties, `${prefix}.${compA.id}.properties`, diff);
-        }
-    }
-    compareProperty(valueA, valueB, path, diff) {
-        if (typeof valueA !== typeof valueB) {
-            diff.modified.push({ path, oldValue: valueA, newValue: valueB });
-            return;
-        }
-        if (valueA === null || valueB === null) {
-            if (valueA !== valueB) {
-                diff.modified.push({ path, oldValue: valueA, newValue: valueB });
-            }
-            return;
-        }
-        if (typeof valueA !== 'object') {
-            if (valueA !== valueB) {
-                diff.modified.push({ path, oldValue: valueA, newValue: valueB });
-            }
-            return;
-        }
-        if (Array.isArray(valueA) && Array.isArray(valueB)) {
-            if (valueA.length !== valueB.length) {
-                diff.modified.push({ path, oldValue: valueA, newValue: valueB });
-                return;
-            }
-            for (let i = 0; i < valueA.length; i++) {
-                this.compareProperty(valueA[i], valueB[i], `${path}.${i}`, diff);
-            }
-            return;
-        }
-        const objA = valueA;
-        const objB = valueB;
-        const keysA = new Set(Object.keys(objA));
-        const keysB = new Set(Object.keys(objB));
-        for (const key of keysB) {
-            if (!keysA.has(key)) {
-                diff.added.push(`${path}.${key}`);
-            }
-        }
-        for (const key of keysA) {
-            if (!keysB.has(key)) {
-                diff.removed.push(`${path}.${key}`);
-            }
-            else {
-                this.compareProperty(objA[key], objB[key], `${path}.${key}`, diff);
-            }
-        }
-    }
-    // ─── Serialization ─────────────────────────────────────
-    serializePrefab(prefabId) {
-        const prefab = this.prefabs.get(prefabId);
-        if (!prefab) {
-            return null;
-        }
-        const serialized = {
-            ...prefab,
-            entities: Object.fromEntries(prefab.entities),
-        };
-        return JSON.stringify(serialized, null, 2);
-    }
-    deserializePrefab(json) {
-        try {
-            const data = JSON.parse(json);
-            const prefab = {
-                ...data,
-                entities: new Map(Object.entries(data.entities)),
-                createdAt: data.createdAt ?? Date.now(),
-                modifiedAt: data.modifiedAt ?? Date.now(),
-            };
-            this.prefabs.set(prefab.id, prefab);
-            this.prefabVersions.set(prefab.id, prefab.version);
-            return prefab;
-        }
-        catch (error) {
-            console.error('Failed to deserialize prefab:', error);
-            return null;
-        }
-    }
-    serializeInstance(instanceId) {
-        const instance = this.instances.get(instanceId);
-        if (!instance) {
-            return null;
-        }
-        const serialized = {
-            ...instance,
-            nestedInstances: Object.fromEntries(instance.nestedInstances),
-        };
-        return JSON.stringify(serialized, null, 2);
-    }
-    deserializeInstance(json) {
-        try {
-            const data = JSON.parse(json);
-            const instance = {
-                ...data,
-                nestedInstances: new Map(Object.entries(data.nestedInstances)),
-            };
-            this.instances.set(instance.id, instance);
-            return instance;
-        }
-        catch (error) {
-            console.error('Failed to deserialize instance:', error);
-            return null;
-        }
-    }
-    // ─── Queries ───────────────────────────────────────────
-    getPrefab(prefabId) {
-        return this.prefabs.get(prefabId);
-    }
-    getInstance(instanceId) {
-        return this.instances.get(instanceId);
-    }
-    getAllPrefabs() {
-        return Array.from(this.prefabs.values());
-    }
-    getAllInstances() {
-        return Array.from(this.instances.values());
-    }
-    getInstancesOfPrefab(prefabId) {
-        return this.getAllInstances().filter((i) => i.prefabId === prefabId);
-    }
-    searchPrefabs(query) {
-        const lowerQuery = query.toLowerCase();
-        return this.getAllPrefabs().filter((p) => p.name.toLowerCase().includes(lowerQuery) ||
-            p.description.toLowerCase().includes(lowerQuery) ||
-            p.tags.some((t) => t.toLowerCase().includes(lowerQuery)));
-    }
-    getPrefabsByCategory(category) {
-        return this.getAllPrefabs().filter((p) => p.category === category);
-    }
-    getCategories() {
-        const categories = new Set();
-        for (const prefab of this.prefabs.values()) {
-            categories.add(prefab.category);
-        }
-        return Array.from(categories).sort();
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setOnPrefabChanged(callback) {
-        this.onPrefabChanged = callback;
-    }
-    setOnInstanceChanged(callback) {
-        this.onInstanceChanged = callback;
-    }
-    // ─── Cleanup ───────────────────────────────────────────
-    deletePrefab(prefabId) {
-        const prefab = this.prefabs.get(prefabId);
-        if (!prefab) {
-            return false;
-        }
-        // Delete all instances
-        for (const instance of this.getInstancesOfPrefab(prefabId)) {
-            this.destroyInstance(instance.id);
-        }
-        // Remove from variants
-        for (const variant of this.prefabs.values()) {
-            if (variant.variantOf === prefabId) {
-                variant.variantOf = undefined;
-            }
-        }
-        // Remove nested references
-        for (const p of this.prefabs.values()) {
-            p.nestedPrefabs = p.nestedPrefabs.filter((n) => n.prefabId !== prefabId);
-        }
-        this.prefabs.delete(prefabId);
-        this.prefabVersions.delete(prefabId);
+  constructor() {
+    this.prefabs = /* @__PURE__ */ new Map();
+    this.instances = /* @__PURE__ */ new Map();
+    this.prefabVersions = /* @__PURE__ */ new Map();
+  }
+  // ─── Prefab Creation ───────────────────────────────────
+  createPrefab(name, rootEntity) {
+    const id = `prefab_${generateId()}`;
+    const now = Date.now();
+    const root = {
+      id: `entity_${generateId()}`,
+      name: rootEntity?.name ?? name,
+      parentId: null,
+      transform: rootEntity?.transform ?? deepClone(DEFAULT_TRANSFORM),
+      components: rootEntity?.components ?? [],
+      children: rootEntity?.children ?? [],
+      tags: rootEntity?.tags ?? [],
+      layer: rootEntity?.layer ?? "default",
+      active: rootEntity?.active ?? true
+    };
+    const prefab = {
+      id,
+      name,
+      description: "",
+      version: 1,
+      createdAt: now,
+      modifiedAt: now,
+      author: "",
+      rootEntity: root,
+      entities: /* @__PURE__ */ new Map([[root.id, root]]),
+      nestedPrefabs: [],
+      tags: [],
+      category: "General"
+    };
+    this.prefabs.set(id, prefab);
+    this.prefabVersions.set(id, 1);
+    return prefab;
+  }
+  createPrefabFromEntities(name, entities) {
+    const prefab = this.createPrefab(name);
+    const entityIds = new Set(entities.map((e) => e.id));
+    const root = entities.find((e) => !e.parentId || !entityIds.has(e.parentId));
+    if (root) {
+      prefab.rootEntity = deepClone(root);
+      prefab.entities.set(root.id, prefab.rootEntity);
+    }
+    for (const entity of entities) {
+      if (entity.id !== prefab.rootEntity.id) {
+        const clone = deepClone(entity);
+        prefab.entities.set(clone.id, clone);
+      }
+    }
+    this.updatePrefabVersion(prefab.id);
+    return prefab;
+  }
+  // ─── Prefab Variants ───────────────────────────────────
+  createVariant(basePrefabId, name) {
+    const basePrefab = this.prefabs.get(basePrefabId);
+    if (!basePrefab) {
+      return null;
+    }
+    const variant = this.createPrefab(name);
+    variant.variantOf = basePrefabId;
+    variant.inheritedOverrides = [];
+    variant.rootEntity = deepClone(basePrefab.rootEntity);
+    variant.rootEntity.id = `entity_${generateId()}`;
+    variant.entities.clear();
+    variant.entities.set(variant.rootEntity.id, variant.rootEntity);
+    for (const [, entity] of basePrefab.entities) {
+      if (entity.id !== basePrefab.rootEntity.id) {
+        const clone = deepClone(entity);
+        clone.id = `entity_${generateId()}`;
+        variant.entities.set(clone.id, clone);
+      }
+    }
+    variant.nestedPrefabs = deepClone(basePrefab.nestedPrefabs);
+    return variant;
+  }
+  getBasePrefab(variantId) {
+    const variant = this.prefabs.get(variantId);
+    if (!variant?.variantOf) {
+      return null;
+    }
+    return this.prefabs.get(variant.variantOf) ?? null;
+  }
+  applyVariantOverrides(variantId) {
+    const variant = this.prefabs.get(variantId);
+    if (!variant || !variant.variantOf) {
+      return;
+    }
+    const base = this.prefabs.get(variant.variantOf);
+    if (!base) {
+      return;
+    }
+    if (variant.inheritedOverrides) {
+      for (const override of variant.inheritedOverrides) {
+        const targetEntity = this.findEntityByPathRoot(variant, override.path);
+        if (targetEntity) {
+          setValueAtPath(targetEntity, override.path, override.overridenValue);
+        }
+      }
+    }
+    this.updatePrefabVersion(variantId);
+  }
+  // ─── Nested Prefabs ────────────────────────────────────
+  addNestedPrefab(parentPrefabId, nestedPrefabId, parentEntityId, transform) {
+    const parentPrefab = this.prefabs.get(parentPrefabId);
+    const nestedPrefab = this.prefabs.get(nestedPrefabId);
+    if (!parentPrefab || !nestedPrefab) {
+      return null;
+    }
+    if (!parentPrefab.entities.has(parentEntityId)) {
+      return null;
+    }
+    if (this.hasCircularReference(parentPrefabId, nestedPrefabId)) {
+      console.error("Circular prefab reference detected");
+      return null;
+    }
+    const reference = {
+      instanceId: `nested_${generateId()}`,
+      prefabId: nestedPrefabId,
+      parentEntityId,
+      overrides: [],
+      transform: {
+        ...deepClone(DEFAULT_TRANSFORM),
+        ...transform
+      }
+    };
+    parentPrefab.nestedPrefabs.push(reference);
+    this.updatePrefabVersion(parentPrefabId);
+    return reference;
+  }
+  removeNestedPrefab(parentPrefabId, instanceId) {
+    const parentPrefab = this.prefabs.get(parentPrefabId);
+    if (!parentPrefab) {
+      return false;
+    }
+    const index = parentPrefab.nestedPrefabs.findIndex((n) => n.instanceId === instanceId);
+    if (index === -1) {
+      return false;
+    }
+    parentPrefab.nestedPrefabs.splice(index, 1);
+    this.updatePrefabVersion(parentPrefabId);
+    return true;
+  }
+  hasCircularReference(parentId, childId, visited = /* @__PURE__ */ new Set()) {
+    if (parentId === childId) {
+      return true;
+    }
+    if (visited.has(childId)) {
+      return true;
+    }
+    visited.add(childId);
+    const childPrefab = this.prefabs.get(childId);
+    if (!childPrefab) {
+      return false;
+    }
+    for (const nested of childPrefab.nestedPrefabs) {
+      if (this.hasCircularReference(parentId, nested.prefabId, visited)) {
         return true;
-    }
-    clear() {
-        this.prefabs.clear();
-        this.instances.clear();
-        this.prefabVersions.clear();
-    }
+      }
+    }
+    return false;
+  }
+  // ─── Instantiation ─────────────────────────────────────
+  instantiate(prefabId, worldTransform) {
+    const prefab = this.prefabs.get(prefabId);
+    if (!prefab) {
+      return null;
+    }
+    const instance = {
+      id: `instance_${generateId()}`,
+      prefabId,
+      name: prefab.name,
+      overrides: [],
+      worldTransform: {
+        ...deepClone(DEFAULT_TRANSFORM),
+        ...worldTransform
+      },
+      nestedInstances: /* @__PURE__ */ new Map(),
+      isLinked: true,
+      createdAt: Date.now(),
+      lastSyncedAt: Date.now()
+    };
+    for (const nestedRef of prefab.nestedPrefabs) {
+      const nestedInstance = this.instantiate(nestedRef.prefabId, nestedRef.transform);
+      if (nestedInstance) {
+        nestedInstance.overrides = deepClone(nestedRef.overrides);
+        instance.nestedInstances.set(nestedRef.instanceId, nestedInstance);
+      }
+    }
+    this.instances.set(instance.id, instance);
+    return instance;
+  }
+  destroyInstance(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      return false;
+    }
+    for (const [, nested] of instance.nestedInstances) {
+      this.destroyInstance(nested.id);
+    }
+    this.instances.delete(instanceId);
+    return true;
+  }
+  // ─── Override Management ───────────────────────────────
+  setOverride(instanceId, path, value) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      return;
+    }
+    const prefab = this.prefabs.get(instance.prefabId);
+    if (!prefab) {
+      return;
+    }
+    const originalValue = this.getOriginalValue(prefab, path);
+    if (compareValues(originalValue, value)) {
+      this.removeOverride(instanceId, path);
+      return;
+    }
+    const existingIndex = instance.overrides.findIndex((o) => o.path === path);
+    const override = {
+      path,
+      originalValue,
+      overridenValue: value,
+      overrideType: "modify",
+      timestamp: Date.now()
+    };
+    if (existingIndex !== -1) {
+      instance.overrides[existingIndex] = override;
+    } else {
+      instance.overrides.push(override);
+    }
+    this.onInstanceChanged?.(instanceId);
+  }
+  removeOverride(instanceId, path) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      return;
+    }
+    instance.overrides = instance.overrides.filter((o) => o.path !== path);
+    this.onInstanceChanged?.(instanceId);
+  }
+  revertAllOverrides(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      return;
+    }
+    instance.overrides = [];
+    this.onInstanceChanged?.(instanceId);
+  }
+  applyOverridesToPrefab(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      return;
+    }
+    const prefab = this.prefabs.get(instance.prefabId);
+    if (!prefab) {
+      return;
+    }
+    for (const override of instance.overrides) {
+      const entity = this.findEntityByPathRoot(prefab, override.path);
+      if (entity) {
+        setValueAtPath(entity, override.path, override.overridenValue);
+      }
+    }
+    instance.overrides = [];
+    this.updatePrefabVersion(instance.prefabId);
+  }
+  hasOverrides(instanceId) {
+    const instance = this.instances.get(instanceId);
+    return instance ? instance.overrides.length > 0 : false;
+  }
+  getOverrides(instanceId) {
+    const instance = this.instances.get(instanceId);
+    return instance ? [...instance.overrides] : [];
+  }
+  getOriginalValue(prefab, path) {
+    const entity = this.findEntityByPathRoot(prefab, path);
+    if (!entity) {
+      return void 0;
+    }
+    const relativePath = this.getRelativePropertyPath(path);
+    return getValueAtPath(entity, relativePath);
+  }
+  findEntityByPathRoot(prefab, path) {
+    const parts = path.split(".");
+    if (parts[0].startsWith("entity_")) {
+      return prefab.entities.get(parts[0]) ?? null;
+    }
+    return prefab.rootEntity;
+  }
+  getRelativePropertyPath(path) {
+    const parts = path.split(".");
+    if (parts[0].startsWith("entity_")) {
+      return parts.slice(1).join(".");
+    }
+    return path;
+  }
+  // ─── Linking ───────────────────────────────────────────
+  unlinkInstance(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      return;
+    }
+    instance.isLinked = false;
+    instance.unpackedAt = Date.now();
+    for (const [, nested] of instance.nestedInstances) {
+      this.unlinkInstance(nested.id);
+    }
+    this.onInstanceChanged?.(instanceId);
+  }
+  relinkInstance(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      return false;
+    }
+    if (!this.prefabs.has(instance.prefabId)) {
+      return false;
+    }
+    instance.isLinked = true;
+    instance.unpackedAt = void 0;
+    instance.lastSyncedAt = Date.now();
+    this.onInstanceChanged?.(instanceId);
+    return true;
+  }
+  // ─── Synchronization ───────────────────────────────────
+  syncInstance(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance || !instance.isLinked) {
+      return;
+    }
+    const prefab = this.prefabs.get(instance.prefabId);
+    if (!prefab) {
+      return;
+    }
+    this.prefabVersions.get(instance.prefabId) ?? 0;
+    if (instance.lastSyncedAt >= prefab.modifiedAt) {
+      return;
+    }
+    instance.lastSyncedAt = Date.now();
+    for (const [, nested] of instance.nestedInstances) {
+      this.syncInstance(nested.id);
+    }
+    this.onInstanceChanged?.(instanceId);
+  }
+  syncAllInstances(prefabId) {
+    for (const [instanceId, instance] of this.instances) {
+      if (instance.prefabId === prefabId && instance.isLinked) {
+        this.syncInstance(instanceId);
+      }
+    }
+  }
+  updatePrefabVersion(prefabId) {
+    const prefab = this.prefabs.get(prefabId);
+    if (prefab) {
+      prefab.version++;
+      prefab.modifiedAt = Date.now();
+      this.prefabVersions.set(prefabId, prefab.version);
+      this.onPrefabChanged?.(prefabId);
+    }
+  }
+  // ─── Entity Management ─────────────────────────────────
+  addEntity(prefabId, entity, parentId) {
+    const prefab = this.prefabs.get(prefabId);
+    if (!prefab) {
+      return null;
+    }
+    const newEntity = {
+      id: `entity_${generateId()}`,
+      name: entity.name ?? "New Entity",
+      parentId: parentId ?? prefab.rootEntity.id,
+      transform: entity.transform ?? deepClone(DEFAULT_TRANSFORM),
+      components: entity.components ?? [],
+      children: entity.children ?? [],
+      tags: entity.tags ?? [],
+      layer: entity.layer ?? "default",
+      active: entity.active ?? true
+    };
+    prefab.entities.set(newEntity.id, newEntity);
+    const parent = prefab.entities.get(newEntity.parentId);
+    if (parent) {
+      parent.children.push(newEntity.id);
+    }
+    this.updatePrefabVersion(prefabId);
+    return newEntity;
+  }
+  removeEntity(prefabId, entityId) {
+    const prefab = this.prefabs.get(prefabId);
+    if (!prefab) {
+      return false;
+    }
+    if (entityId === prefab.rootEntity.id) {
+      return false;
+    }
+    const entity = prefab.entities.get(entityId);
+    if (!entity) {
+      return false;
+    }
+    if (entity.parentId) {
+      const parent = prefab.entities.get(entity.parentId);
+      if (parent) {
+        parent.children = parent.children.filter((id) => id !== entityId);
+      }
+    }
+    for (const childId of entity.children) {
+      this.removeEntity(prefabId, childId);
+    }
+    prefab.entities.delete(entityId);
+    this.updatePrefabVersion(prefabId);
+    return true;
+  }
+  // ─── Component Management ──────────────────────────────
+  addComponent(prefabId, entityId, component) {
+    const prefab = this.prefabs.get(prefabId);
+    if (!prefab) {
+      return null;
+    }
+    const entity = prefab.entities.get(entityId);
+    if (!entity) {
+      return null;
+    }
+    const newComponent = {
+      id: `component_${generateId()}`,
+      type: component.type ?? "Unknown",
+      properties: component.properties ?? {},
+      enabled: component.enabled ?? true
+    };
+    entity.components.push(newComponent);
+    this.updatePrefabVersion(prefabId);
+    return newComponent;
+  }
+  removeComponent(prefabId, entityId, componentId) {
+    const prefab = this.prefabs.get(prefabId);
+    if (!prefab) {
+      return false;
+    }
+    const entity = prefab.entities.get(entityId);
+    if (!entity) {
+      return false;
+    }
+    const index = entity.components.findIndex((c) => c.id === componentId);
+    if (index === -1) {
+      return false;
+    }
+    entity.components.splice(index, 1);
+    this.updatePrefabVersion(prefabId);
+    return true;
+  }
+  // ─── Comparison ────────────────────────────────────────
+  comparePrefabs(prefabIdA, prefabIdB) {
+    const prefabA = this.prefabs.get(prefabIdA);
+    const prefabB = this.prefabs.get(prefabIdB);
+    if (!prefabA || !prefabB) {
+      return null;
+    }
+    const diff = {
+      added: [],
+      removed: [],
+      modified: [],
+      componentAdded: [],
+      componentRemoved: [],
+      entityAdded: [],
+      entityRemoved: []
+    };
+    const entityIdsA = new Set(prefabA.entities.keys());
+    const entityIdsB = new Set(prefabB.entities.keys());
+    for (const id of entityIdsB) {
+      if (!entityIdsA.has(id)) {
+        diff.entityAdded.push(id);
+      }
+    }
+    for (const id of entityIdsA) {
+      if (!entityIdsB.has(id)) {
+        diff.entityRemoved.push(id);
+      }
+    }
+    for (const [id, entityA] of prefabA.entities) {
+      const entityB = prefabB.entities.get(id);
+      if (!entityB) {
+        continue;
+      }
+      this.compareEntities(entityA, entityB, id, diff);
+    }
+    return diff;
+  }
+  compareInstanceToPrefab(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      return null;
+    }
+    const prefab = this.prefabs.get(instance.prefabId);
+    if (!prefab) {
+      return null;
+    }
+    const diff = {
+      added: [],
+      removed: [],
+      modified: [],
+      componentAdded: [],
+      componentRemoved: [],
+      entityAdded: [],
+      entityRemoved: []
+    };
+    for (const override of instance.overrides) {
+      diff.modified.push({
+        path: override.path,
+        oldValue: override.originalValue,
+        newValue: override.overridenValue
+      });
+    }
+    return diff;
+  }
+  compareEntities(entityA, entityB, prefix, diff) {
+    this.compareProperty(entityA.transform, entityB.transform, `${prefix}.transform`, diff);
+    const compIdsA = new Set(entityA.components.map((c) => c.id));
+    const compIdsB = new Set(entityB.components.map((c) => c.id));
+    for (const comp of entityB.components) {
+      if (!compIdsA.has(comp.id)) {
+        diff.componentAdded.push(`${prefix}.${comp.id}`);
+      }
+    }
+    for (const comp of entityA.components) {
+      if (!compIdsB.has(comp.id)) {
+        diff.componentRemoved.push(`${prefix}.${comp.id}`);
+      }
+    }
+    for (const compA of entityA.components) {
+      const compB = entityB.components.find((c) => c.id === compA.id);
+      if (!compB) {
+        continue;
+      }
+      this.compareProperty(
+        compA.properties,
+        compB.properties,
+        `${prefix}.${compA.id}.properties`,
+        diff
+      );
+    }
+  }
+  compareProperty(valueA, valueB, path, diff) {
+    if (typeof valueA !== typeof valueB) {
+      diff.modified.push({ path, oldValue: valueA, newValue: valueB });
+      return;
+    }
+    if (valueA === null || valueB === null) {
+      if (valueA !== valueB) {
+        diff.modified.push({ path, oldValue: valueA, newValue: valueB });
+      }
+      return;
+    }
+    if (typeof valueA !== "object") {
+      if (valueA !== valueB) {
+        diff.modified.push({ path, oldValue: valueA, newValue: valueB });
+      }
+      return;
+    }
+    if (Array.isArray(valueA) && Array.isArray(valueB)) {
+      if (valueA.length !== valueB.length) {
+        diff.modified.push({ path, oldValue: valueA, newValue: valueB });
+        return;
+      }
+      for (let i = 0; i < valueA.length; i++) {
+        this.compareProperty(valueA[i], valueB[i], `${path}.${i}`, diff);
+      }
+      return;
+    }
+    const objA = valueA;
+    const objB = valueB;
+    const keysA = new Set(Object.keys(objA));
+    const keysB = new Set(Object.keys(objB));
+    for (const key of keysB) {
+      if (!keysA.has(key)) {
+        diff.added.push(`${path}.${key}`);
+      }
+    }
+    for (const key of keysA) {
+      if (!keysB.has(key)) {
+        diff.removed.push(`${path}.${key}`);
+      } else {
+        this.compareProperty(objA[key], objB[key], `${path}.${key}`, diff);
+      }
+    }
+  }
+  // ─── Serialization ─────────────────────────────────────
+  serializePrefab(prefabId) {
+    const prefab = this.prefabs.get(prefabId);
+    if (!prefab) {
+      return null;
+    }
+    const serialized = {
+      ...prefab,
+      entities: Object.fromEntries(prefab.entities)
+    };
+    return JSON.stringify(serialized, null, 2);
+  }
+  deserializePrefab(json) {
+    try {
+      const data = JSON.parse(json);
+      const prefab = {
+        ...data,
+        entities: new Map(Object.entries(data.entities)),
+        createdAt: data.createdAt ?? Date.now(),
+        modifiedAt: data.modifiedAt ?? Date.now()
+      };
+      this.prefabs.set(prefab.id, prefab);
+      this.prefabVersions.set(prefab.id, prefab.version);
+      return prefab;
+    } catch (error) {
+      console.error("Failed to deserialize prefab:", error);
+      return null;
+    }
+  }
+  serializeInstance(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) {
+      return null;
+    }
+    const serialized = {
+      ...instance,
+      nestedInstances: Object.fromEntries(instance.nestedInstances)
+    };
+    return JSON.stringify(serialized, null, 2);
+  }
+  deserializeInstance(json) {
+    try {
+      const data = JSON.parse(json);
+      const instance = {
+        ...data,
+        nestedInstances: new Map(Object.entries(data.nestedInstances))
+      };
+      this.instances.set(instance.id, instance);
+      return instance;
+    } catch (error) {
+      console.error("Failed to deserialize instance:", error);
+      return null;
+    }
+  }
+  // ─── Queries ───────────────────────────────────────────
+  getPrefab(prefabId) {
+    return this.prefabs.get(prefabId);
+  }
+  getInstance(instanceId) {
+    return this.instances.get(instanceId);
+  }
+  getAllPrefabs() {
+    return Array.from(this.prefabs.values());
+  }
+  getAllInstances() {
+    return Array.from(this.instances.values());
+  }
+  getInstancesOfPrefab(prefabId) {
+    return this.getAllInstances().filter((i) => i.prefabId === prefabId);
+  }
+  searchPrefabs(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAllPrefabs().filter(
+      (p) => p.name.toLowerCase().includes(lowerQuery) || p.description.toLowerCase().includes(lowerQuery) || p.tags.some((t) => t.toLowerCase().includes(lowerQuery))
+    );
+  }
+  getPrefabsByCategory(category) {
+    return this.getAllPrefabs().filter((p) => p.category === category);
+  }
+  getCategories() {
+    const categories = /* @__PURE__ */ new Set();
+    for (const prefab of this.prefabs.values()) {
+      categories.add(prefab.category);
+    }
+    return Array.from(categories).sort();
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setOnPrefabChanged(callback) {
+    this.onPrefabChanged = callback;
+  }
+  setOnInstanceChanged(callback) {
+    this.onInstanceChanged = callback;
+  }
+  // ─── Cleanup ───────────────────────────────────────────
+  deletePrefab(prefabId) {
+    const prefab = this.prefabs.get(prefabId);
+    if (!prefab) {
+      return false;
+    }
+    for (const instance of this.getInstancesOfPrefab(prefabId)) {
+      this.destroyInstance(instance.id);
+    }
+    for (const variant of this.prefabs.values()) {
+      if (variant.variantOf === prefabId) {
+        variant.variantOf = void 0;
+      }
+    }
+    for (const p of this.prefabs.values()) {
+      p.nestedPrefabs = p.nestedPrefabs.filter((n) => n.prefabId !== prefabId);
+    }
+    this.prefabs.delete(prefabId);
+    this.prefabVersions.delete(prefabId);
+    return true;
+  }
+  clear() {
+    this.prefabs.clear();
+    this.instances.clear();
+    this.prefabVersions.clear();
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createPrefabManager() {
-    return new PrefabManager();
+  return new PrefabManager();
 }
-function createDefaultEntity(name = 'Entity') {
-    return {
-        id: `entity_${generateId()}`,
-        name,
-        parentId: null,
-        transform: deepClone(DEFAULT_TRANSFORM),
-        components: [],
-        children: [],
-        tags: [],
-        layer: 'default',
-        active: true,
-    };
+function createDefaultEntity(name = "Entity") {
+  return {
+    id: `entity_${generateId()}`,
+    name,
+    parentId: null,
+    transform: deepClone(DEFAULT_TRANSFORM),
+    components: [],
+    children: [],
+    tags: [],
+    layer: "default",
+    active: true
+  };
 }
 function createComponent(type, properties = {}) {
-    return {
-        id: `component_${generateId()}`,
-        type,
-        properties,
-        enabled: true,
-    };
+  return {
+    id: `component_${generateId()}`,
+    type,
+    properties,
+    enabled: true
+  };
 }
-
 exports.DEFAULT_TRANSFORM = DEFAULT_TRANSFORM;
 exports.PrefabManager = PrefabManager;
 exports.createComponent = createComponent;