@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/esm/unity-integration/UnityImport.js

@@ -1,1246 +1,1142 @@
-/**
- * @file UnityImport.ts
- * @description Unity Project Import system for Nice2Dev Game Engine
- * PRO-1.8.1: Unity Project Import
- *
- * Features:
- * - Unity Project Importer (scene, prefab, hierarchy, components)
- * - Unity Asset Database Integration (meta files, GUIDs, dependencies)
- * - Unity Animation Import (clips, controllers, masks, events)
- * - Unity Script Import (MonoBehaviour parsing, SerializeField extraction)
- */
 function parseUnityYAML(content) {
-    const documents = [];
-    // Unity YAML uses --- !u! markers
-    const docRegex = /--- !u!(\d+) &(\d+)(?:\s+stripped)?/g;
-    const matches = [...content.matchAll(docRegex)];
-    for (let i = 0; i < matches.length; i++) {
-        const match = matches[i];
-        const classID = parseInt(match[1], 10);
-        const fileID = parseInt(match[2], 10);
-        // Find content between this document and next
-        const startIdx = match.index + match[0].length;
-        const endIdx = i < matches.length - 1 ? matches[i + 1].index : content.length;
-        const docContent = content.slice(startIdx, endIdx).trim();
-        // Parse YAML content (simplified parser)
-        const data = parseUnityYAMLContent(docContent);
-        documents.push({
-            fileID,
-            classID,
-            stripped: match[0].includes('stripped'),
-            data,
-        });
-    }
-    return documents;
+  const documents = [];
+  const docRegex = /--- !u!(\d+) &(\d+)(?:\s+stripped)?/g;
+  const matches = [...content.matchAll(docRegex)];
+  for (let i = 0; i < matches.length; i++) {
+    const match = matches[i];
+    const classID = parseInt(match[1], 10);
+    const fileID = parseInt(match[2], 10);
+    const startIdx = match.index + match[0].length;
+    const endIdx = i < matches.length - 1 ? matches[i + 1].index : content.length;
+    const docContent = content.slice(startIdx, endIdx).trim();
+    const data = parseUnityYAMLContent(docContent);
+    documents.push({
+      fileID,
+      classID,
+      stripped: match[0].includes("stripped"),
+      data
+    });
+  }
+  return documents;
 }
 function parseUnityYAMLContent(content) {
-    const result = {};
-    const lines = content.split('\n');
-    const stack = [
-        { obj: result, indent: -1 },
-    ];
-    for (const line of lines) {
-        if (!line.trim() || line.trim().startsWith('#')) {
-            continue;
-        }
-        const indent = line.search(/\S/);
-        const trimmed = line.trim();
-        // Pop stack until we find parent with smaller indent
-        while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
-            stack.pop();
-        }
-        const parent = stack[stack.length - 1].obj;
-        // Check for key: value
-        const colonIdx = trimmed.indexOf(':');
-        if (colonIdx > 0) {
-            const key = trimmed.slice(0, colonIdx).trim();
-            const value = trimmed.slice(colonIdx + 1).trim();
-            if (value === '' || value === '{}') {
-                // Nested object
-                const nested = {};
-                parent[key] = nested;
-                stack.push({ obj: nested, indent });
-            }
-            else if (value.startsWith('{') && value.endsWith('}')) {
-                // Inline object like {fileID: 0}
-                parent[key] = parseInlineYAML(value);
-            }
-            else if (value.startsWith('[') && value.endsWith(']')) {
-                // Inline array
-                parent[key] = parseInlineArray(value);
-            }
-            else {
-                // Simple value
-                parent[key] = parseYAMLValue(value);
-            }
-        }
-        else if (trimmed.startsWith('- ')) {
-            // Array element
-            trimmed.slice(2).trim();
-        }
+  const result = {};
+  const lines = content.split("\n");
+  const stack = [
+    { obj: result, indent: -1 }
+  ];
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith("#")) {
+      continue;
     }
-    return result;
-}
-function parseInlineYAML(inline) {
-    const result = {};
-    // Remove braces
-    const content = inline.slice(1, -1).trim();
-    if (!content) {
-        return result;
+    const indent = line.search(/\S/);
+    const trimmed = line.trim();
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
     }
-    // Split by comma (simplified, doesn't handle nested)
-    const pairs = content.split(',');
-    for (const pair of pairs) {
-        const [key, value] = pair.split(':').map((s) => s.trim());
-        if (key && value !== undefined) {
-            result[key] = parseYAMLValue(value);
-        }
+    const parent = stack[stack.length - 1].obj;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx > 0) {
+      const key = trimmed.slice(0, colonIdx).trim();
+      const value = trimmed.slice(colonIdx + 1).trim();
+      if (value === "" || value === "{}") {
+        const nested = {};
+        parent[key] = nested;
+        stack.push({ obj: nested, indent });
+      } else if (value.startsWith("{") && value.endsWith("}")) {
+        parent[key] = parseInlineYAML(value);
+      } else if (value.startsWith("[") && value.endsWith("]")) {
+        parent[key] = parseInlineArray(value);
+      } else {
+        parent[key] = parseYAMLValue(value);
+      }
+    } else if (trimmed.startsWith("- ")) {
+      trimmed.slice(2).trim();
     }
+  }
+  return result;
+}
+function parseInlineYAML(inline) {
+  const result = {};
+  const content = inline.slice(1, -1).trim();
+  if (!content) {
     return result;
+  }
+  const pairs = content.split(",");
+  for (const pair of pairs) {
+    const [key, value] = pair.split(":").map((s) => s.trim());
+    if (key && value !== void 0) {
+      result[key] = parseYAMLValue(value);
+    }
+  }
+  return result;
 }
 function parseInlineArray(inline) {
-    const content = inline.slice(1, -1).trim();
-    if (!content) {
-        return [];
-    }
-    // Simplified array parsing
-    return content.split(',').map((s) => parseYAMLValue(s.trim()));
+  const content = inline.slice(1, -1).trim();
+  if (!content) {
+    return [];
+  }
+  return content.split(",").map((s) => parseYAMLValue(s.trim()));
 }
 function parseYAMLValue(value) {
-    // Remove quotes if present
-    if ((value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))) {
-        return value.slice(1, -1);
-    }
-    // Boolean
-    if (value === 'true' || value === '1') {
-        return true;
-    }
-    if (value === 'false' || value === '0') {
-        return false;
-    }
-    // Null
-    if (value === 'null' || value === '~' || value === '') {
-        return null;
-    }
-    // Number
-    const num = parseFloat(value);
-    if (!isNaN(num) && isFinite(num)) {
-        return num;
-    }
-    return value;
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "true" || value === "1") {
+    return true;
+  }
+  if (value === "false" || value === "0") {
+    return false;
+  }
+  if (value === "null" || value === "~" || value === "") {
+    return null;
+  }
+  const num = parseFloat(value);
+  if (!isNaN(num) && isFinite(num)) {
+    return num;
+  }
+  return value;
 }
 function parseUnityMeta(content) {
-    // Meta files are simpler YAML
-    const lines = content.split('\n');
-    const meta = {
-        guid: '',
-        importerType: 'unknown',
-        importSettings: {},
-    };
-    for (const line of lines) {
-        if (line.startsWith('guid:')) {
-            meta.guid = line.slice(5).trim();
-        }
-        else if (line.includes('Importer:') || line.includes('importer:')) {
-            meta.importerType = line.split(':')[0].trim();
-        }
-        else if (line.startsWith('timeCreated:')) {
-            meta.timestamp = parseInt(line.slice(12).trim(), 10);
-        }
-        else if (line.startsWith('userData:')) {
-            meta.userData = line.slice(9).trim();
-        }
+  const lines = content.split("\n");
+  const meta = {
+    guid: "",
+    importerType: "unknown",
+    importSettings: {}
+  };
+  for (const line of lines) {
+    if (line.startsWith("guid:")) {
+      meta.guid = line.slice(5).trim();
+    } else if (line.includes("Importer:") || line.includes("importer:")) {
+      meta.importerType = line.split(":")[0].trim();
+    } else if (line.startsWith("timeCreated:")) {
+      meta.timestamp = parseInt(line.slice(12).trim(), 10);
+    } else if (line.startsWith("userData:")) {
+      meta.userData = line.slice(9).trim();
     }
-    return meta;
+  }
+  return meta;
 }
-// ============================================================
-// Unity Class ID Mapping
-// ============================================================
 const UNITY_CLASS_IDS = {
-    1: 'GameObject',
-    2: 'Component',
-    3: 'LevelGameManager',
-    4: 'Transform',
-    20: 'Camera',
-    21: 'Material',
-    23: 'MeshRenderer',
-    25: 'Renderer',
-    28: 'Texture2D',
-    33: 'MeshFilter',
-    43: 'Mesh',
-    48: 'Shader',
-    49: 'TextAsset',
-    54: 'Rigidbody',
-    56: 'Collider',
-    61: 'BoxCollider',
-    64: 'MeshCollider',
-    65: 'SphereCollider',
-    82: 'AudioSource',
-    83: 'AudioClip',
-    84: 'RenderTexture',
-    87: 'MeshAnimator',
-    89: 'Cubemap',
-    91: 'AnimationClip',
-    93: 'RuntimeAnimatorController',
-    95: 'Animator',
-    104: 'RenderSettings',
-    108: 'Light',
-    109: 'CGProgram',
-    111: 'Animation',
-    114: 'MonoBehaviour',
-    115: 'MonoScript',
-    120: 'LineRenderer',
-    122: 'TrailRenderer',
-    124: 'Behaviour',
-    128: 'Font',
-    134: 'PhysicMaterial',
-    135: 'SphereCollider',
-    136: 'CapsuleCollider',
-    137: 'SkinnedMeshRenderer',
-    142: 'AssetBundle',
-    143: 'Prefab',
-    150: 'PreviewAnimationClip',
-    152: 'AudioListener',
-    156: 'Terrain',
-    157: 'TerrainCollider',
-    158: 'TerrainData',
-    177: 'VideoClip',
-    181: 'VideoPlayer',
-    183: 'Sprite',
-    184: 'CachedSpriteAtlas',
-    186: 'ReflectionProbe',
-    187: 'ReflectionProbes',
-    188: 'Terrain',
-    189: 'LightProbes',
-    191: 'LightProbeGroup',
-    192: 'SpriteAtlas',
-    193: 'SpriteAtlasDatabase',
-    195: 'NavMeshArea',
-    196: 'NavMeshAgent',
-    198: 'ParticleSystem',
-    199: 'ParticleSystemRenderer',
-    200: 'ShaderVariantCollection',
-    205: 'LODGroup',
-    206: 'BlendTree',
-    207: 'AudioMixer',
-    208: 'AudioMixerController',
-    212: 'SpriteRenderer',
-    213: 'Tilemap',
-    218: 'AudioMixerGroup',
-    220: 'CinemachineVirtualCamera',
-    221: 'AnimatorOverrideController',
-    222: 'Canvas',
-    223: 'CanvasRenderer',
-    224: 'RectTransform',
-    225: 'CanvasGroup',
-    226: 'BillboardAsset',
-    227: 'BillboardRenderer',
-    228: 'SpeedTreeWindAsset',
-    229: 'AnchoredJoint2D',
-    230: 'Joint2D',
-    231: 'SpringJoint2D',
-    232: 'DistanceJoint2D',
-    233: 'HingeJoint2D',
-    234: 'SliderJoint2D',
-    235: 'WheelJoint2D',
-    238: 'NavMeshData',
-    240: 'AudioMixerSnapshot',
-    241: 'AudioMixerEffectController',
-    243: 'PhysicsMaterial2D',
-    244: 'Rigidbody2D',
-    245: 'Collider2D',
-    246: 'BoxCollider2D',
-    247: 'CircleCollider2D',
-    248: 'CompositeCollider2D',
-    249: 'EdgeCollider2D',
-    250: 'PolygonCollider2D',
-    251: 'CapsuleCollider2D',
-    328: 'VideoClip',
-    334: 'PlayerSettings',
-    367: 'VideoPlayer',
+  1: "GameObject",
+  2: "Component",
+  3: "LevelGameManager",
+  4: "Transform",
+  20: "Camera",
+  21: "Material",
+  23: "MeshRenderer",
+  25: "Renderer",
+  28: "Texture2D",
+  33: "MeshFilter",
+  43: "Mesh",
+  48: "Shader",
+  49: "TextAsset",
+  54: "Rigidbody",
+  56: "Collider",
+  61: "BoxCollider",
+  64: "MeshCollider",
+  65: "SphereCollider",
+  82: "AudioSource",
+  83: "AudioClip",
+  84: "RenderTexture",
+  87: "MeshAnimator",
+  89: "Cubemap",
+  91: "AnimationClip",
+  93: "RuntimeAnimatorController",
+  95: "Animator",
+  104: "RenderSettings",
+  108: "Light",
+  109: "CGProgram",
+  111: "Animation",
+  114: "MonoBehaviour",
+  115: "MonoScript",
+  120: "LineRenderer",
+  122: "TrailRenderer",
+  124: "Behaviour",
+  128: "Font",
+  134: "PhysicMaterial",
+  135: "SphereCollider",
+  136: "CapsuleCollider",
+  137: "SkinnedMeshRenderer",
+  142: "AssetBundle",
+  143: "Prefab",
+  150: "PreviewAnimationClip",
+  152: "AudioListener",
+  156: "Terrain",
+  157: "TerrainCollider",
+  158: "TerrainData",
+  177: "VideoClip",
+  181: "VideoPlayer",
+  183: "Sprite",
+  184: "CachedSpriteAtlas",
+  186: "ReflectionProbe",
+  187: "ReflectionProbes",
+  188: "Terrain",
+  189: "LightProbes",
+  191: "LightProbeGroup",
+  192: "SpriteAtlas",
+  193: "SpriteAtlasDatabase",
+  195: "NavMeshArea",
+  196: "NavMeshAgent",
+  198: "ParticleSystem",
+  199: "ParticleSystemRenderer",
+  200: "ShaderVariantCollection",
+  205: "LODGroup",
+  206: "BlendTree",
+  207: "AudioMixer",
+  208: "AudioMixerController",
+  212: "SpriteRenderer",
+  213: "Tilemap",
+  218: "AudioMixerGroup",
+  220: "CinemachineVirtualCamera",
+  221: "AnimatorOverrideController",
+  222: "Canvas",
+  223: "CanvasRenderer",
+  224: "RectTransform",
+  225: "CanvasGroup",
+  226: "BillboardAsset",
+  227: "BillboardRenderer",
+  228: "SpeedTreeWindAsset",
+  229: "AnchoredJoint2D",
+  230: "Joint2D",
+  231: "SpringJoint2D",
+  232: "DistanceJoint2D",
+  233: "HingeJoint2D",
+  234: "SliderJoint2D",
+  235: "WheelJoint2D",
+  238: "NavMeshData",
+  240: "AudioMixerSnapshot",
+  241: "AudioMixerEffectController",
+  243: "PhysicsMaterial2D",
+  244: "Rigidbody2D",
+  245: "Collider2D",
+  246: "BoxCollider2D",
+  247: "CircleCollider2D",
+  248: "CompositeCollider2D",
+  249: "EdgeCollider2D",
+  250: "PolygonCollider2D",
+  251: "CapsuleCollider2D",
+  328: "VideoClip",
+  334: "PlayerSettings",
+  367: "VideoPlayer"
 };
 function getUnityClassName(classID) {
-    return UNITY_CLASS_IDS[classID] ?? `Unknown_${classID}`;
+  return UNITY_CLASS_IDS[classID] ?? `Unknown_${classID}`;
 }
 class UnityProjectImporter {
-    constructor() {
-        this.callbacks = {};
+  constructor() {
+    this.callbacks = {};
+  }
+  // ─── Project Scanning ──────────────────────────────────
+  async scanProject(projectPath) {
+    this.project = {
+      name: this.extractProjectName(projectPath),
+      path: projectPath,
+      unityVersion: "",
+      renderPipeline: "builtin",
+      assets: /* @__PURE__ */ new Map(),
+      scenes: [],
+      prefabs: [],
+      scripts: [],
+      materials: [],
+      missingRefs: []
+    };
+    this.project.unityVersion = await this.detectUnityVersion(projectPath);
+    this.project.renderPipeline = await this.detectRenderPipeline(projectPath);
+    await this.scanAssetsFolder(`${projectPath}/Assets`);
+    this.buildDependencyGraph();
+    this.detectMissingReferences();
+    this.callbacks.onProjectScanned?.(this.project);
+    return this.project;
+  }
+  extractProjectName(path) {
+    const parts = path.replace(/\\/g, "/").split("/");
+    return parts[parts.length - 1] || "UnknownProject";
+  }
+  async detectUnityVersion(_projectPath) {
+    return "2022.3.10f1";
+  }
+  async detectRenderPipeline(_projectPath) {
+    return "builtin";
+  }
+  async scanAssetsFolder(_assetsPath) {
+    this.callbacks.onScanProgress?.("Scanning assets...", 0);
+  }
+  // ─── Scene Import ──────────────────────────────────────
+  async importScene(scenePath, sceneContent) {
+    const documents = parseUnityYAML(sceneContent);
+    const scene = {
+      name: this.extractFileName(scenePath),
+      path: scenePath,
+      objects: /* @__PURE__ */ new Map(),
+      roots: []
+    };
+    for (const doc of documents) {
+      const typeName = getUnityClassName(doc.classID);
+      scene.objects.set(doc.fileID, {
+        fileID: doc.fileID,
+        type: typeName,
+        classID: doc.classID,
+        data: doc.data
+      });
+      if (typeName === "RenderSettings") {
+        scene.renderSettings = doc.data;
+      } else if (typeName === "LightmapSettings") {
+        scene.lightmapSettings = doc.data;
+      } else if (typeName === "NavMeshSettings") {
+        scene.navMeshSettings = doc.data;
+      } else if (typeName === "OcclusionCullingSettings") {
+        scene.occlusionSettings = doc.data;
+      }
     }
-    // ─── Project Scanning ──────────────────────────────────
-    async scanProject(projectPath) {
-        this.project = {
-            name: this.extractProjectName(projectPath),
-            path: projectPath,
-            unityVersion: '',
-            renderPipeline: 'builtin',
-            assets: new Map(),
-            scenes: [],
-            prefabs: [],
-            scripts: [],
-            materials: [],
-            missingRefs: [],
-        };
-        // Detect Unity version from ProjectSettings
-        this.project.unityVersion = await this.detectUnityVersion(projectPath);
-        // Detect render pipeline
-        this.project.renderPipeline = await this.detectRenderPipeline(projectPath);
-        // Scan Assets folder
-        await this.scanAssetsFolder(`${projectPath}/Assets`);
-        // Build dependency graph
-        this.buildDependencyGraph();
-        // Detect missing references
-        this.detectMissingReferences();
-        this.callbacks.onProjectScanned?.(this.project);
-        return this.project;
+    for (const obj of scene.objects.values()) {
+      if (obj.type === "Transform") {
+        const transform = obj.data["Transform"];
+        if (transform) {
+          const parent = transform["m_Father"];
+          if (!parent || parent.fileID === 0) {
+            const goRef = transform["m_GameObject"];
+            if (goRef?.fileID) {
+              scene.roots.push(goRef.fileID);
+            }
+          }
+        }
+      }
     }
-    extractProjectName(path) {
-        const parts = path.replace(/\\/g, '/').split('/');
-        return parts[parts.length - 1] || 'UnknownProject';
+    this.callbacks.onSceneImported?.(scene);
+    return scene;
+  }
+  extractFileName(path) {
+    const parts = path.replace(/\\/g, "/").split("/");
+    const filename = parts[parts.length - 1];
+    return filename.replace(/\.[^/.]+$/, "");
+  }
+  // ─── Prefab Import ─────────────────────────────────────
+  async importPrefab(prefabPath, prefabContent, guid) {
+    const documents = parseUnityYAML(prefabContent);
+    const prefab = {
+      name: this.extractFileName(prefabPath),
+      guid,
+      path: prefabPath,
+      rootFileID: 0,
+      objects: /* @__PURE__ */ new Map(),
+      isVariant: false
+    };
+    for (const doc of documents) {
+      const typeName = getUnityClassName(doc.classID);
+      if (typeName === "PrefabInstance") {
+        prefab.isVariant = true;
+        const prefabInstance = doc.data["PrefabInstance"];
+        if (prefabInstance) {
+          const sourceRef = prefabInstance["m_SourcePrefab"];
+          if (sourceRef?.guid) {
+            prefab.basePrefabGUID = sourceRef.guid;
+          }
+        }
+      }
+      prefab.objects.set(doc.fileID, {
+        fileID: doc.fileID,
+        type: typeName,
+        classID: doc.classID,
+        data: doc.data
+      });
     }
-    async detectUnityVersion(_projectPath) {
-        // Read ProjectSettings/ProjectVersion.txt
-        // In real implementation, read from file system
-        // Format: m_EditorVersion: 2022.3.10f1
-        return '2022.3.10f1';
+    for (const obj of prefab.objects.values()) {
+      if (obj.type === "Transform") {
+        const transform = obj.data["Transform"];
+        if (transform) {
+          const parent = transform["m_Father"];
+          if (!parent || parent.fileID === 0) {
+            const goRef = transform["m_GameObject"];
+            if (goRef?.fileID) {
+              prefab.rootFileID = goRef.fileID;
+              break;
+            }
+          }
+        }
+      }
     }
-    async detectRenderPipeline(_projectPath) {
-        // Check for URP/HDRP packages in Packages/manifest.json
-        // Or check QualitySettings for render pipeline asset
-        return 'builtin';
+    this.callbacks.onPrefabImported?.(prefab);
+    return prefab;
+  }
+  // ─── Script Import ─────────────────────────────────────
+  parseScript(scriptPath, scriptContent, guid) {
+    const scriptInfo = {
+      guid,
+      path: scriptPath,
+      type: "script",
+      className: "",
+      isMonoBehaviour: false,
+      isScriptableObject: false,
+      serializedFields: [],
+      publicMethods: [],
+      unityMessages: [],
+      dependencies: [],
+      dependents: []
+    };
+    scriptContent.split("\n");
+    const namespaceMatch = scriptContent.match(/namespace\s+([\w.]+)/);
+    if (namespaceMatch) {
+      scriptInfo.namespace = namespaceMatch[1];
     }
-    async scanAssetsFolder(_assetsPath) {
-        // In real implementation, use file system to scan
-        // For now, simulate scanning
-        this.callbacks.onScanProgress?.('Scanning assets...', 0);
-        // This would recursively scan directories and process:
-        // - .meta files for GUIDs
-        // - .unity files for scenes
-        // - .prefab files for prefabs
-        // - .cs files for scripts
-        // - .mat files for materials
-        // - etc.
+    const classMatch = scriptContent.match(/class\s+(\w+)\s*(?::\s*([\w,\s<>]+))?/);
+    if (classMatch) {
+      scriptInfo.className = classMatch[1];
+      const baseClasses = classMatch[2]?.split(",").map((s) => s.trim()) ?? [];
+      scriptInfo.isMonoBehaviour = baseClasses.some(
+        (b) => b === "MonoBehaviour" || b.includes("MonoBehaviour")
+      );
+      scriptInfo.isScriptableObject = baseClasses.some(
+        (b) => b === "ScriptableObject" || b.includes("ScriptableObject")
+      );
     }
-    // ─── Scene Import ──────────────────────────────────────
-    async importScene(scenePath, sceneContent) {
-        const documents = parseUnityYAML(sceneContent);
-        const scene = {
-            name: this.extractFileName(scenePath),
-            path: scenePath,
-            objects: new Map(),
-            roots: [],
-        };
-        // First pass: create all objects
-        for (const doc of documents) {
-            const typeName = getUnityClassName(doc.classID);
-            scene.objects.set(doc.fileID, {
-                fileID: doc.fileID,
-                type: typeName,
-                classID: doc.classID,
-                data: doc.data,
-            });
-            // Extract settings
-            if (typeName === 'RenderSettings') {
-                scene.renderSettings = doc.data;
-            }
-            else if (typeName === 'LightmapSettings') {
-                scene.lightmapSettings = doc.data;
-            }
-            else if (typeName === 'NavMeshSettings') {
-                scene.navMeshSettings = doc.data;
-            }
-            else if (typeName === 'OcclusionCullingSettings') {
-                scene.occlusionSettings = doc.data;
-            }
-        }
-        // Second pass: find root objects
-        for (const obj of scene.objects.values()) {
-            if (obj.type === 'Transform') {
-                const transform = obj.data['Transform'];
-                if (transform) {
-                    const parent = transform['m_Father'];
-                    if (!parent || parent.fileID === 0) {
-                        // This is a root transform, find its GameObject
-                        const goRef = transform['m_GameObject'];
-                        if (goRef?.fileID) {
-                            scene.roots.push(goRef.fileID);
-                        }
-                    }
-                }
-            }
-        }
-        this.callbacks.onSceneImported?.(scene);
-        return scene;
+    const fieldRegex = /\[SerializeField\][\s\S]*?(?:private|protected)?\s*([\w<>[\],\s]+)\s+(\w+)\s*[;=]/g;
+    const publicFieldRegex = /public\s+([\w<>[\],\s]+)\s+(\w+)\s*[;=]/g;
+    const methodRegex = /(?:public|private|protected)\s+(?:override\s+)?(?:virtual\s+)?(?:async\s+)?(\w+(?:<[\w,\s]+>)?)\s+(\w+)\s*\(/g;
+    let fieldMatch;
+    while ((fieldMatch = fieldRegex.exec(scriptContent)) !== null) {
+      const field = this.parseFieldDeclaration(fieldMatch[1], fieldMatch[2], false, true);
+      scriptInfo.serializedFields.push(field);
+    }
+    while ((fieldMatch = publicFieldRegex.exec(scriptContent)) !== null) {
+      const field = this.parseFieldDeclaration(fieldMatch[1], fieldMatch[2], true, false);
+      if (!scriptContent.slice(Math.max(0, fieldMatch.index - 20), fieldMatch.index).includes("static")) {
+        scriptInfo.serializedFields.push(field);
+      }
     }
-    extractFileName(path) {
-        const parts = path.replace(/\\/g, '/').split('/');
-        const filename = parts[parts.length - 1];
-        return filename.replace(/\.[^/.]+$/, '');
+    let methodMatch;
+    while ((methodMatch = methodRegex.exec(scriptContent)) !== null) {
+      const methodName = methodMatch[2];
+      if (UNITY_MESSAGES.includes(methodName)) {
+        scriptInfo.unityMessages.push(methodName);
+      }
+      const methodContext = scriptContent.slice(
+        Math.max(0, methodMatch.index - 10),
+        methodMatch.index
+      );
+      if (methodContext.includes("public")) {
+        scriptInfo.publicMethods.push(methodName);
+      }
     }
-    // ─── Prefab Import ─────────────────────────────────────
-    async importPrefab(prefabPath, prefabContent, guid) {
-        const documents = parseUnityYAML(prefabContent);
-        const prefab = {
-            name: this.extractFileName(prefabPath),
-            guid,
-            path: prefabPath,
-            rootFileID: 0,
-            objects: new Map(),
-            isVariant: false,
+    this.parseFieldAttributes(scriptContent, scriptInfo.serializedFields);
+    this.callbacks.onScriptParsed?.(scriptInfo);
+    return scriptInfo;
+  }
+  parseFieldDeclaration(typeStr, name, isPublic, hasSerializeField) {
+    const cleanType = typeStr.trim();
+    const isArray = cleanType.endsWith("[]") || cleanType.includes("List<");
+    return {
+      name,
+      type: this.mapCSharpType(cleanType),
+      customType: this.isCustomType(cleanType) ? cleanType : void 0,
+      isArray,
+      isPublic,
+      hasSerializeField
+    };
+  }
+  mapCSharpType(typeStr) {
+    const baseType = typeStr.replace("[]", "").replace(/List<(.+)>/, "$1").trim();
+    const typeMap = {
+      int: "int",
+      Int32: "int",
+      float: "float",
+      Single: "float",
+      double: "float",
+      bool: "bool",
+      Boolean: "bool",
+      string: "string",
+      String: "string",
+      Vector2: "Vector2",
+      Vector3: "Vector3",
+      Vector4: "Vector4",
+      Quaternion: "Quaternion",
+      Color: "Color",
+      Color32: "Color",
+      LayerMask: "LayerMask",
+      AnimationCurve: "AnimationCurve",
+      Gradient: "Gradient",
+      GameObject: "Object",
+      Transform: "Object",
+      Sprite: "Object",
+      Texture: "Object",
+      Texture2D: "Object",
+      Material: "Object",
+      AudioClip: "Object"
+    };
+    return typeMap[baseType] ?? "Custom";
+  }
+  isCustomType(typeStr) {
+    const knownTypes = [
+      "int",
+      "float",
+      "double",
+      "bool",
+      "string",
+      "Vector2",
+      "Vector3",
+      "Vector4",
+      "Quaternion",
+      "Color",
+      "Color32",
+      "LayerMask",
+      "AnimationCurve",
+      "Gradient",
+      "GameObject",
+      "Transform",
+      "Sprite",
+      "Texture",
+      "Texture2D",
+      "Material",
+      "AudioClip",
+      "Rigidbody",
+      "Collider"
+    ];
+    const baseType = typeStr.replace("[]", "").replace(/List<(.+)>/, "$1").trim();
+    return !knownTypes.includes(baseType);
+  }
+  parseFieldAttributes(scriptContent, fields) {
+    for (const field of fields) {
+      const fieldPattern = new RegExp(
+        `((?:\\[.*?\\]\\s*)*?)(?:public|private|protected)?\\s*\\w+\\s+${field.name}\\s*[;=]`,
+        "s"
+      );
+      const match = scriptContent.match(fieldPattern);
+      if (!match) {
+        continue;
+      }
+      const attrBlock = match[1];
+      const headerMatch = attrBlock.match(/\[Header\("([^"]+)"\)\]/);
+      if (headerMatch) {
+        field.header = headerMatch[1];
+      }
+      const tooltipMatch = attrBlock.match(/\[Tooltip\("([^"]+)"\)\]/);
+      if (tooltipMatch) {
+        field.tooltip = tooltipMatch[1];
+      }
+      const rangeMatch = attrBlock.match(/\[Range\(([^,]+),\s*([^)]+)\)\]/);
+      if (rangeMatch) {
+        field.range = {
+          min: parseFloat(rangeMatch[1]),
+          max: parseFloat(rangeMatch[2])
         };
-        // Check if it's a prefab variant
-        for (const doc of documents) {
-            const typeName = getUnityClassName(doc.classID);
-            if (typeName === 'PrefabInstance') {
-                prefab.isVariant = true;
-                const prefabInstance = doc.data['PrefabInstance'];
-                if (prefabInstance) {
-                    const sourceRef = prefabInstance['m_SourcePrefab'];
-                    if (sourceRef?.guid) {
-                        prefab.basePrefabGUID = sourceRef.guid;
-                    }
-                }
-            }
-            prefab.objects.set(doc.fileID, {
-                fileID: doc.fileID,
-                type: typeName,
-                classID: doc.classID,
-                data: doc.data,
-            });
+      }
+    }
+  }
+  // ─── Material Import ───────────────────────────────────
+  parseMaterial(matPath, matContent, guid) {
+    const documents = parseUnityYAML(matContent);
+    const matInfo = {
+      guid,
+      path: matPath,
+      type: "material",
+      shaderName: "Standard",
+      textures: {},
+      floats: {},
+      colors: {},
+      vectors: {},
+      renderQueue: 2e3,
+      keywords: [],
+      dependencies: [],
+      dependents: []
+    };
+    for (const doc of documents) {
+      if (getUnityClassName(doc.classID) === "Material") {
+        const material = doc.data["Material"];
+        if (!material) {
+          continue;
         }
-        // Find root transform
-        for (const obj of prefab.objects.values()) {
-            if (obj.type === 'Transform') {
-                const transform = obj.data['Transform'];
-                if (transform) {
-                    const parent = transform['m_Father'];
-                    if (!parent || parent.fileID === 0) {
-                        const goRef = transform['m_GameObject'];
-                        if (goRef?.fileID) {
-                            prefab.rootFileID = goRef.fileID;
-                            break;
-                        }
-                    }
-                }
-            }
+        const shaderRef = material["m_Shader"];
+        if (shaderRef?.guid) {
+          matInfo.shaderGUID = shaderRef.guid;
+        }
+        const shaderKeywords = material["m_ShaderKeywords"];
+        if (shaderKeywords) {
+          matInfo.keywords = shaderKeywords.split(" ").filter(Boolean);
+        }
+        const texEnvs = material["m_TexEnvs"];
+        if (texEnvs) {
+          for (const texEnv of texEnvs) {
+            const name = Object.keys(texEnv)[0];
+            const data = texEnv[name];
+            const texRef = data?.["m_Texture"];
+            matInfo.textures[name] = texRef?.guid ?? null;
+          }
+        }
+        const floats = material["m_Floats"];
+        if (floats) {
+          for (const floatProp of floats) {
+            const name = Object.keys(floatProp)[0];
+            matInfo.floats[name] = floatProp[name];
+          }
+        }
+        const colors = material["m_Colors"];
+        if (colors) {
+          for (const colorProp of colors) {
+            const name = Object.keys(colorProp)[0];
+            const c = colorProp[name];
+            matInfo.colors[name] = {
+              r: c.r ?? 0,
+              g: c.g ?? 0,
+              b: c.b ?? 0,
+              a: c.a ?? 1
+            };
+          }
         }
-        this.callbacks.onPrefabImported?.(prefab);
-        return prefab;
+        if (typeof material["m_CustomRenderQueue"] === "number") {
+          matInfo.renderQueue = material["m_CustomRenderQueue"];
+        }
+      }
     }
-    // ─── Script Import ─────────────────────────────────────
-    parseScript(scriptPath, scriptContent, guid) {
-        const scriptInfo = {
-            guid,
-            path: scriptPath,
-            type: 'script',
-            className: '',
-            isMonoBehaviour: false,
-            isScriptableObject: false,
-            serializedFields: [],
-            publicMethods: [],
-            unityMessages: [],
-            dependencies: [],
-            dependents: [],
-        };
-        // Parse C# content
-        scriptContent.split('\n');
-        // Extract namespace
-        const namespaceMatch = scriptContent.match(/namespace\s+([\w.]+)/);
-        if (namespaceMatch) {
-            scriptInfo.namespace = namespaceMatch[1];
+    this.callbacks.onMaterialParsed?.(matInfo);
+    return matInfo;
+  }
+  // ─── Animation Import ──────────────────────────────────
+  parseAnimationClip(clipPath, clipContent, guid) {
+    const documents = parseUnityYAML(clipContent);
+    const clipInfo = {
+      guid,
+      path: clipPath,
+      name: this.extractFileName(clipPath),
+      length: 0,
+      frameRate: 60,
+      wrapMode: "Default",
+      isLooping: false,
+      curves: [],
+      events: []
+    };
+    for (const doc of documents) {
+      if (getUnityClassName(doc.classID) === "AnimationClip") {
+        const clip = doc.data["AnimationClip"];
+        if (!clip) {
+          continue;
         }
-        // Extract class declaration
-        const classMatch = scriptContent.match(/class\s+(\w+)\s*(?::\s*([\w,\s<>]+))?/);
-        if (classMatch) {
-            scriptInfo.className = classMatch[1];
-            const baseClasses = classMatch[2]?.split(',').map((s) => s.trim()) ?? [];
-            scriptInfo.isMonoBehaviour = baseClasses.some((b) => b === 'MonoBehaviour' || b.includes('MonoBehaviour'));
-            scriptInfo.isScriptableObject = baseClasses.some((b) => b === 'ScriptableObject' || b.includes('ScriptableObject'));
+        clipInfo.name = clip["m_Name"] ?? clipInfo.name;
+        const settings = clip["m_AnimationClipSettings"];
+        if (settings) {
+          clipInfo.length = settings["m_StopTime"] ?? 0;
+          clipInfo.isLooping = settings["m_LoopTime"] ?? false;
         }
-        // Parse fields and methods
-        const fieldRegex = /\[SerializeField\][\s\S]*?(?:private|protected)?\s*([\w<>[\],\s]+)\s+(\w+)\s*[;=]/g;
-        const publicFieldRegex = /public\s+([\w<>[\],\s]+)\s+(\w+)\s*[;=]/g;
-        const methodRegex = /(?:public|private|protected)\s+(?:override\s+)?(?:virtual\s+)?(?:async\s+)?(\w+(?:<[\w,\s]+>)?)\s+(\w+)\s*\(/g;
-        // Extract SerializeField fields
-        let fieldMatch;
-        while ((fieldMatch = fieldRegex.exec(scriptContent)) !== null) {
-            const field = this.parseFieldDeclaration(fieldMatch[1], fieldMatch[2], false, true);
-            scriptInfo.serializedFields.push(field);
+        clipInfo.frameRate = clip["m_SampleRate"] ?? 60;
+        const positionCurves = clip["m_PositionCurves"];
+        const rotationCurves = clip["m_RotationCurves"];
+        const scaleCurves = clip["m_ScaleCurves"];
+        const floatCurves = clip["m_FloatCurves"];
+        if (positionCurves) {
+          for (const curve of positionCurves) {
+            clipInfo.curves.push(this.parseCurve(curve, "position"));
+          }
         }
-        // Extract public fields (auto-serialized)
-        while ((fieldMatch = publicFieldRegex.exec(scriptContent)) !== null) {
-            const field = this.parseFieldDeclaration(fieldMatch[1], fieldMatch[2], true, false);
-            // Exclude static fields
-            if (!scriptContent
-                .slice(Math.max(0, fieldMatch.index - 20), fieldMatch.index)
-                .includes('static')) {
-                scriptInfo.serializedFields.push(field);
-            }
+        if (rotationCurves) {
+          for (const curve of rotationCurves) {
+            clipInfo.curves.push(this.parseCurve(curve, "rotation"));
+          }
+        }
+        if (scaleCurves) {
+          for (const curve of scaleCurves) {
+            clipInfo.curves.push(this.parseCurve(curve, "scale"));
+          }
+        }
+        if (floatCurves) {
+          for (const curve of floatCurves) {
+            clipInfo.curves.push(this.parseCurve(curve, "float"));
+          }
         }
-        // Extract methods
-        let methodMatch;
-        while ((methodMatch = methodRegex.exec(scriptContent)) !== null) {
-            const methodName = methodMatch[2];
-            // Check if it's a Unity message
-            if (UNITY_MESSAGES.includes(methodName)) {
-                scriptInfo.unityMessages.push(methodName);
+        const events = clip["m_Events"];
+        if (events) {
+          for (const event of events) {
+            clipInfo.events.push(this.parseAnimationEvent(event));
+          }
+        }
+      }
+    }
+    return clipInfo;
+  }
+  parseCurve(curve, type) {
+    return {
+      path: curve["path"] ?? "",
+      propertyName: curve["attribute"] ?? type,
+      type,
+      keyframes: []
+      // Would parse m_Curve keyframes
+    };
+  }
+  parseAnimationEvent(event) {
+    return {
+      time: event["time"] ?? 0,
+      functionName: event["functionName"] ?? "",
+      stringParameter: event["data"],
+      floatParameter: event["floatParameter"],
+      intParameter: event["intParameter"],
+      objectReferenceParameter: event["objectReferenceParameter"]?.guid
+    };
+  }
+  parseAnimatorController(controllerPath, controllerContent, guid) {
+    const documents = parseUnityYAML(controllerContent);
+    const controllerInfo = {
+      guid,
+      path: controllerPath,
+      name: this.extractFileName(controllerPath),
+      parameters: [],
+      layers: []
+    };
+    const states = /* @__PURE__ */ new Map();
+    const transitions = /* @__PURE__ */ new Map();
+    for (const doc of documents) {
+      const typeName = getUnityClassName(doc.classID);
+      if (typeName === "AnimatorController") {
+        const controller = doc.data["AnimatorController"];
+        if (controller) {
+          controllerInfo.name = controller["m_Name"] ?? controllerInfo.name;
+          const params = controller["m_AnimatorParameters"];
+          if (params) {
+            for (const param of params) {
+              const p = param;
+              const defaultVal = p["m_DefaultFloat"] ?? p["m_DefaultInt"] ?? p["m_DefaultBool"];
+              controllerInfo.parameters.push({
+                name: p["m_Name"] ?? "",
+                type: this.mapAnimatorParameterType(p["m_Type"]),
+                defaultValue: typeof defaultVal === "number" || typeof defaultVal === "boolean" ? defaultVal : 0
+              });
             }
-            // Check if public
-            const methodContext = scriptContent.slice(Math.max(0, methodMatch.index - 10), methodMatch.index);
-            if (methodContext.includes('public')) {
-                scriptInfo.publicMethods.push(methodName);
+          }
+        }
+      } else if (typeName === "AnimatorStateMachine") {
+        const stateMachine = doc.data["AnimatorStateMachine"];
+        if (stateMachine) {
+          const layer = {
+            name: stateMachine["m_Name"] ?? "Base Layer",
+            stateMachine: {
+              fileID: doc.fileID,
+              states: [],
+              transitions: [],
+              defaultStateIndex: 0
+            },
+            weight: 1,
+            blendingMode: "Override"
+          };
+          controllerInfo.layers.push(layer);
+        }
+      } else if (typeName === "AnimatorState") {
+        const state = doc.data["AnimatorState"];
+        if (state) {
+          const stateInfo = {
+            fileID: doc.fileID,
+            name: state["m_Name"] ?? "",
+            speed: state["m_Speed"] ?? 1,
+            motionGUID: state["m_Motion"]?.guid,
+            transitions: []
+          };
+          states.set(doc.fileID, stateInfo);
+        }
+      } else if (typeName === "AnimatorStateTransition") {
+        const transition = doc.data["AnimatorStateTransition"];
+        if (transition) {
+          const transInfo = {
+            fileID: doc.fileID,
+            destinationStateID: transition["m_DstState"]?.fileID ?? 0,
+            hasExitTime: transition["m_HasExitTime"] ?? false,
+            exitTime: transition["m_ExitTime"] ?? 0.9,
+            duration: transition["m_TransitionDuration"] ?? 0.25,
+            conditions: []
+          };
+          const conditions = transition["m_Conditions"];
+          if (conditions) {
+            for (const cond of conditions) {
+              const c = cond;
+              transInfo.conditions.push({
+                parameter: c["m_ConditionEvent"] ?? "",
+                mode: this.mapConditionMode(c["m_ConditionMode"]),
+                threshold: c["m_EventTreshold"] ?? 0
+              });
             }
+          }
+          transitions.set(doc.fileID, transInfo);
         }
-        // Extract attributes (Header, Tooltip, Range)
-        this.parseFieldAttributes(scriptContent, scriptInfo.serializedFields);
-        this.callbacks.onScriptParsed?.(scriptInfo);
-        return scriptInfo;
+      }
     }
-    parseFieldDeclaration(typeStr, name, isPublic, hasSerializeField) {
-        const cleanType = typeStr.trim();
-        const isArray = cleanType.endsWith('[]') || cleanType.includes('List<');
-        return {
-            name,
-            type: this.mapCSharpType(cleanType),
-            customType: this.isCustomType(cleanType) ? cleanType : undefined,
-            isArray,
-            isPublic,
-            hasSerializeField,
-        };
+    return controllerInfo;
+  }
+  mapAnimatorParameterType(type) {
+    const types = {
+      1: "Float",
+      3: "Int",
+      4: "Bool",
+      9: "Trigger"
+    };
+    return types[type] ?? "Float";
+  }
+  mapConditionMode(mode) {
+    const modes = {
+      1: "If",
+      2: "IfNot",
+      3: "Greater",
+      4: "Less",
+      6: "Equals",
+      7: "NotEquals"
+    };
+    return modes[mode] ?? "If";
+  }
+  // ─── Dependency Graph ──────────────────────────────────
+  buildDependencyGraph() {
+    for (const [guid, asset] of this.project.assets) {
+      for (const depGUID of asset.dependencies) {
+        const depAsset = this.project.assets.get(depGUID);
+        if (depAsset && !depAsset.dependents.includes(guid)) {
+          depAsset.dependents.push(guid);
+        }
+      }
     }
-    mapCSharpType(typeStr) {
-        const baseType = typeStr
-            .replace('[]', '')
-            .replace(/List<(.+)>/, '$1')
-            .trim();
-        const typeMap = {
-            int: 'int',
-            Int32: 'int',
-            float: 'float',
-            Single: 'float',
-            double: 'float',
-            bool: 'bool',
-            Boolean: 'bool',
-            string: 'string',
-            String: 'string',
-            Vector2: 'Vector2',
-            Vector3: 'Vector3',
-            Vector4: 'Vector4',
-            Quaternion: 'Quaternion',
-            Color: 'Color',
-            Color32: 'Color',
-            LayerMask: 'LayerMask',
-            AnimationCurve: 'AnimationCurve',
-            Gradient: 'Gradient',
-            GameObject: 'Object',
-            Transform: 'Object',
-            Sprite: 'Object',
-            Texture: 'Object',
-            Texture2D: 'Object',
-            Material: 'Object',
-            AudioClip: 'Object',
-        };
-        return typeMap[baseType] ?? 'Custom';
+  }
+  detectMissingReferences() {
+    for (const [guid, asset] of this.project.assets) {
+      for (const depGUID of asset.dependencies) {
+        if (!this.project.assets.has(depGUID)) {
+          this.project.missingRefs.push({
+            assetGUID: guid,
+            assetPath: asset.path,
+            missingGUID: depGUID,
+            propertyPath: "unknown"
+            // Would need context to determine
+          });
+        }
+      }
     }
-    isCustomType(typeStr) {
-        const knownTypes = [
-            'int',
-            'float',
-            'double',
-            'bool',
-            'string',
-            'Vector2',
-            'Vector3',
-            'Vector4',
-            'Quaternion',
-            'Color',
-            'Color32',
-            'LayerMask',
-            'AnimationCurve',
-            'Gradient',
-            'GameObject',
-            'Transform',
-            'Sprite',
-            'Texture',
-            'Texture2D',
-            'Material',
-            'AudioClip',
-            'Rigidbody',
-            'Collider',
-        ];
-        const baseType = typeStr
-            .replace('[]', '')
-            .replace(/List<(.+)>/, '$1')
-            .trim();
-        return !knownTypes.includes(baseType);
+  }
+  // ─── Conversion to Nice2Dev ────────────────────────────
+  convertSceneToNice2Dev(scene) {
+    const nice2devScene = {
+      name: scene.name,
+      entities: [],
+      cameras: [],
+      lights: []
+    };
+    for (const rootID of scene.roots) {
+      const entity = this.convertGameObject(scene, rootID);
+      if (entity) {
+        nice2devScene.entities.push(entity);
+      }
     }
-    parseFieldAttributes(scriptContent, fields) {
-        for (const field of fields) {
-            // Find field in content and check preceding attributes
-            const fieldPattern = new RegExp(`((?:\\[.*?\\]\\s*)*?)(?:public|private|protected)?\\s*\\w+\\s+${field.name}\\s*[;=]`, 's');
-            const match = scriptContent.match(fieldPattern);
-            if (!match) {
-                continue;
-            }
-            const attrBlock = match[1];
-            // Header
-            const headerMatch = attrBlock.match(/\[Header\("([^"]+)"\)\]/);
-            if (headerMatch) {
-                field.header = headerMatch[1];
+    return nice2devScene;
+  }
+  convertGameObject(scene, fileID) {
+    const goObj = scene.objects.get(fileID);
+    if (!goObj || goObj.type !== "GameObject") {
+      return null;
+    }
+    const goData = goObj.data["GameObject"];
+    if (!goData) {
+      return null;
+    }
+    const entity = {
+      name: goData["m_Name"] ?? "GameObject",
+      active: goData["m_IsActive"] ?? true,
+      tag: goData["m_Tag"] ?? "Untagged",
+      layer: goData["m_Layer"] ?? 0,
+      transform: {
+        position: { x: 0, y: 0, z: 0 },
+        rotation: { x: 0, y: 0, z: 0, w: 1 },
+        scale: { x: 1, y: 1, z: 1 }
+      },
+      components: [],
+      children: []
+    };
+    const components = goData["m_Component"];
+    if (components) {
+      for (const compRef of components) {
+        if (compRef.component.fileID === void 0) {
+          continue;
+        }
+        const compObj = scene.objects.get(compRef.component.fileID);
+        if (!compObj) {
+          continue;
+        }
+        if (compObj.type === "Transform" || compObj.type === "RectTransform") {
+          const transform = compObj.data[compObj.type];
+          if (transform) {
+            const pos = transform["m_LocalPosition"];
+            const rot = transform["m_LocalRotation"];
+            const scale = transform["m_LocalScale"];
+            if (pos) {
+              entity.transform.position = { x: pos.x, y: pos.y, z: pos.z };
             }
-            // Tooltip
-            const tooltipMatch = attrBlock.match(/\[Tooltip\("([^"]+)"\)\]/);
-            if (tooltipMatch) {
-                field.tooltip = tooltipMatch[1];
+            if (rot) {
+              entity.transform.rotation = { x: rot.x, y: rot.y, z: rot.z, w: rot.w };
             }
-            // Range
-            const rangeMatch = attrBlock.match(/\[Range\(([^,]+),\s*([^)]+)\)\]/);
-            if (rangeMatch) {
-                field.range = {
-                    min: parseFloat(rangeMatch[1]),
-                    max: parseFloat(rangeMatch[2]),
-                };
+            if (scale) {
+              entity.transform.scale = { x: scale.x, y: scale.y, z: scale.z };
             }
-        }
-    }
-    // ─── Material Import ───────────────────────────────────
-    parseMaterial(matPath, matContent, guid) {
-        const documents = parseUnityYAML(matContent);
-        const matInfo = {
-            guid,
-            path: matPath,
-            type: 'material',
-            shaderName: 'Standard',
-            textures: {},
-            floats: {},
-            colors: {},
-            vectors: {},
-            renderQueue: 2000,
-            keywords: [],
-            dependencies: [],
-            dependents: [],
-        };
-        for (const doc of documents) {
-            if (getUnityClassName(doc.classID) === 'Material') {
-                const material = doc.data['Material'];
-                if (!material) {
-                    continue;
-                }
-                // Shader reference
-                const shaderRef = material['m_Shader'];
-                if (shaderRef?.guid) {
-                    matInfo.shaderGUID = shaderRef.guid;
-                }
-                // Shader name from saved properties (if built-in shader)
-                const shaderKeywords = material['m_ShaderKeywords'];
-                if (shaderKeywords) {
-                    matInfo.keywords = shaderKeywords.split(' ').filter(Boolean);
-                }
-                // Texture properties
-                const texEnvs = material['m_TexEnvs'];
-                if (texEnvs) {
-                    for (const texEnv of texEnvs) {
-                        const name = Object.keys(texEnv)[0];
-                        const data = texEnv[name];
-                        const texRef = data?.['m_Texture'];
-                        matInfo.textures[name] = texRef?.guid ?? null;
-                    }
-                }
-                // Float properties
-                const floats = material['m_Floats'];
-                if (floats) {
-                    for (const floatProp of floats) {
-                        const name = Object.keys(floatProp)[0];
-                        matInfo.floats[name] = floatProp[name];
-                    }
+            const children = transform["m_Children"];
+            if (children) {
+              for (const childRef of children) {
+                if (childRef.fileID === void 0) {
+                  continue;
                 }
-                // Color properties
-                const colors = material['m_Colors'];
-                if (colors) {
-                    for (const colorProp of colors) {
-                        const name = Object.keys(colorProp)[0];
-                        const c = colorProp[name];
-                        matInfo.colors[name] = {
-                            r: c.r ?? 0,
-                            g: c.g ?? 0,
-                            b: c.b ?? 0,
-                            a: c.a ?? 1,
-                        };
+                const childTransform = scene.objects.get(childRef.fileID);
+                if (childTransform) {
+                  const childGO = childTransform.data["Transform"]?.["m_GameObject"];
+                  if (childGO?.fileID) {
+                    const childEntity = this.convertGameObject(scene, childGO.fileID);
+                    if (childEntity) {
+                      entity.children.push(childEntity);
                     }
+                  }
                 }
-                // Render queue
-                if (typeof material['m_CustomRenderQueue'] === 'number') {
-                    matInfo.renderQueue = material['m_CustomRenderQueue'];
-                }
+              }
             }
+          }
+        } else {
+          const compData = this.convertComponent(compObj);
+          if (compData) {
+            entity.components.push(compData);
+          }
         }
-        this.callbacks.onMaterialParsed?.(matInfo);
-        return matInfo;
+      }
     }
-    // ─── Animation Import ──────────────────────────────────
-    parseAnimationClip(clipPath, clipContent, guid) {
-        const documents = parseUnityYAML(clipContent);
-        const clipInfo = {
-            guid,
-            path: clipPath,
-            name: this.extractFileName(clipPath),
-            length: 0,
-            frameRate: 60,
-            wrapMode: 'Default',
-            isLooping: false,
-            curves: [],
-            events: [],
-        };
-        for (const doc of documents) {
-            if (getUnityClassName(doc.classID) === 'AnimationClip') {
-                const clip = doc.data['AnimationClip'];
-                if (!clip) {
-                    continue;
-                }
-                clipInfo.name = clip['m_Name'] ?? clipInfo.name;
-                const settings = clip['m_AnimationClipSettings'];
-                if (settings) {
-                    clipInfo.length = settings['m_StopTime'] ?? 0;
-                    clipInfo.isLooping = settings['m_LoopTime'] ?? false;
-                }
-                clipInfo.frameRate = clip['m_SampleRate'] ?? 60;
-                // Parse curves
-                const positionCurves = clip['m_PositionCurves'];
-                const rotationCurves = clip['m_RotationCurves'];
-                const scaleCurves = clip['m_ScaleCurves'];
-                const floatCurves = clip['m_FloatCurves'];
-                if (positionCurves) {
-                    for (const curve of positionCurves) {
-                        clipInfo.curves.push(this.parseCurve(curve, 'position'));
-                    }
-                }
-                if (rotationCurves) {
-                    for (const curve of rotationCurves) {
-                        clipInfo.curves.push(this.parseCurve(curve, 'rotation'));
-                    }
-                }
-                if (scaleCurves) {
-                    for (const curve of scaleCurves) {
-                        clipInfo.curves.push(this.parseCurve(curve, 'scale'));
-                    }
-                }
-                if (floatCurves) {
-                    for (const curve of floatCurves) {
-                        clipInfo.curves.push(this.parseCurve(curve, 'float'));
-                    }
-                }
-                // Parse events
-                const events = clip['m_Events'];
-                if (events) {
-                    for (const event of events) {
-                        clipInfo.events.push(this.parseAnimationEvent(event));
-                    }
-                }
-            }
-        }
-        return clipInfo;
+    return entity;
+  }
+  convertComponent(compObj) {
+    const typeName = compObj.type;
+    const data = compObj.data[typeName];
+    if (!data) {
+      return null;
     }
-    parseCurve(curve, type) {
+    switch (typeName) {
+      case "Camera":
         return {
-            path: curve['path'] ?? '',
-            propertyName: curve['attribute'] ?? type,
-            type,
-            keyframes: [], // Would parse m_Curve keyframes
+          type: "Camera",
+          data: {
+            fieldOfView: data["field of view"] ?? 60,
+            nearClip: data["near clip plane"] ?? 0.3,
+            farClip: data["far clip plane"] ?? 1e3,
+            orthographic: data["orthographic"] ?? false,
+            orthographicSize: data["orthographic size"] ?? 5
+          }
         };
-    }
-    parseAnimationEvent(event) {
+      case "Light":
         return {
-            time: event['time'] ?? 0,
-            functionName: event['functionName'] ?? '',
-            stringParameter: event['data'],
-            floatParameter: event['floatParameter'],
-            intParameter: event['intParameter'],
-            objectReferenceParameter: event['objectReferenceParameter']?.guid,
+          type: "Light",
+          data: {
+            type: this.mapLightType(data["m_Type"]),
+            color: data["m_Color"] ?? { r: 1, g: 1, b: 1, a: 1 },
+            intensity: data["m_Intensity"] ?? 1,
+            range: data["m_Range"] ?? 10,
+            spotAngle: data["m_SpotAngle"] ?? 30,
+            shadows: data["m_Shadows"] !== 0
+          }
         };
-    }
-    parseAnimatorController(controllerPath, controllerContent, guid) {
-        const documents = parseUnityYAML(controllerContent);
-        const controllerInfo = {
-            guid,
-            path: controllerPath,
-            name: this.extractFileName(controllerPath),
-            parameters: [],
-            layers: [],
+      case "MeshRenderer":
+      case "SkinnedMeshRenderer":
+        return {
+          type: "MeshRenderer",
+          data: {
+            enabled: data["m_Enabled"] ?? true,
+            castShadows: data["m_CastShadows"] ?? true,
+            receiveShadows: data["m_ReceiveShadows"] ?? true,
+            materials: []
+            // Would resolve material GUIDs
+          }
         };
-        const states = new Map();
-        const transitions = new Map();
-        for (const doc of documents) {
-            const typeName = getUnityClassName(doc.classID);
-            if (typeName === 'AnimatorController') {
-                const controller = doc.data['AnimatorController'];
-                if (controller) {
-                    controllerInfo.name = controller['m_Name'] ?? controllerInfo.name;
-                    // Parse parameters
-                    const params = controller['m_AnimatorParameters'];
-                    if (params) {
-                        for (const param of params) {
-                            const p = param;
-                            const defaultVal = p['m_DefaultFloat'] ?? p['m_DefaultInt'] ?? p['m_DefaultBool'];
-                            controllerInfo.parameters.push({
-                                name: p['m_Name'] ?? '',
-                                type: this.mapAnimatorParameterType(p['m_Type']),
-                                defaultValue: typeof defaultVal === 'number' || typeof defaultVal === 'boolean'
-                                    ? defaultVal
-                                    : 0,
-                            });
-                        }
-                    }
-                }
-            }
-            else if (typeName === 'AnimatorStateMachine') {
-                const stateMachine = doc.data['AnimatorStateMachine'];
-                if (stateMachine) {
-                    const layer = {
-                        name: stateMachine['m_Name'] ?? 'Base Layer',
-                        stateMachine: {
-                            fileID: doc.fileID,
-                            states: [],
-                            transitions: [],
-                            defaultStateIndex: 0,
-                        },
-                        weight: 1,
-                        blendingMode: 'Override',
-                    };
-                    controllerInfo.layers.push(layer);
-                }
-            }
-            else if (typeName === 'AnimatorState') {
-                const state = doc.data['AnimatorState'];
-                if (state) {
-                    const stateInfo = {
-                        fileID: doc.fileID,
-                        name: state['m_Name'] ?? '',
-                        speed: state['m_Speed'] ?? 1,
-                        motionGUID: state['m_Motion']?.guid,
-                        transitions: [],
-                    };
-                    states.set(doc.fileID, stateInfo);
-                }
-            }
-            else if (typeName === 'AnimatorStateTransition') {
-                const transition = doc.data['AnimatorStateTransition'];
-                if (transition) {
-                    const transInfo = {
-                        fileID: doc.fileID,
-                        destinationStateID: transition['m_DstState']?.fileID ?? 0,
-                        hasExitTime: transition['m_HasExitTime'] ?? false,
-                        exitTime: transition['m_ExitTime'] ?? 0.9,
-                        duration: transition['m_TransitionDuration'] ?? 0.25,
-                        conditions: [],
-                    };
-                    const conditions = transition['m_Conditions'];
-                    if (conditions) {
-                        for (const cond of conditions) {
-                            const c = cond;
-                            transInfo.conditions.push({
-                                parameter: c['m_ConditionEvent'] ?? '',
-                                mode: this.mapConditionMode(c['m_ConditionMode']),
-                                threshold: c['m_EventTreshold'] ?? 0,
-                            });
-                        }
-                    }
-                    transitions.set(doc.fileID, transInfo);
-                }
-            }
-        }
-        // Link states and transitions to layers
-        // (Simplified - real implementation would trace m_ChildStates references)
-        return controllerInfo;
-    }
-    mapAnimatorParameterType(type) {
-        const types = {
-            1: 'Float',
-            3: 'Int',
-            4: 'Bool',
-            9: 'Trigger',
+      case "SpriteRenderer":
+        return {
+          type: "SpriteRenderer",
+          data: {
+            color: data["m_Color"] ?? { r: 1, g: 1, b: 1, a: 1 },
+            flipX: data["m_FlipX"] ?? false,
+            flipY: data["m_FlipY"] ?? false,
+            sortingLayer: data["m_SortingLayer"] ?? 0,
+            sortingOrder: data["m_SortingOrder"] ?? 0
+          }
         };
-        return types[type] ?? 'Float';
-    }
-    mapConditionMode(mode) {
-        const modes = {
-            1: 'If',
-            2: 'IfNot',
-            3: 'Greater',
-            4: 'Less',
-            6: 'Equals',
-            7: 'NotEquals',
+      case "Rigidbody":
+        return {
+          type: "Rigidbody3D",
+          data: {
+            mass: data["m_Mass"] ?? 1,
+            drag: data["m_Drag"] ?? 0,
+            angularDrag: data["m_AngularDrag"] ?? 0.05,
+            useGravity: data["m_UseGravity"] ?? true,
+            isKinematic: data["m_IsKinematic"] ?? false
+          }
         };
-        return modes[mode] ?? 'If';
-    }
-    // ─── Dependency Graph ──────────────────────────────────
-    buildDependencyGraph() {
-        // For each asset, find what it references and update dependents
-        for (const [guid, asset] of this.project.assets) {
-            for (const depGUID of asset.dependencies) {
-                const depAsset = this.project.assets.get(depGUID);
-                if (depAsset && !depAsset.dependents.includes(guid)) {
-                    depAsset.dependents.push(guid);
-                }
-            }
-        }
-    }
-    detectMissingReferences() {
-        for (const [guid, asset] of this.project.assets) {
-            for (const depGUID of asset.dependencies) {
-                if (!this.project.assets.has(depGUID)) {
-                    this.project.missingRefs.push({
-                        assetGUID: guid,
-                        assetPath: asset.path,
-                        missingGUID: depGUID,
-                        propertyPath: 'unknown', // Would need context to determine
-                    });
-                }
-            }
-        }
-    }
-    // ─── Conversion to Nice2Dev ────────────────────────────
-    convertSceneToNice2Dev(scene) {
-        const nice2devScene = {
-            name: scene.name,
-            entities: [],
-            cameras: [],
-            lights: [],
+      case "Rigidbody2D":
+        return {
+          type: "Rigidbody2D",
+          data: {
+            bodyType: this.mapRigidBodyType(data["m_BodyType"]),
+            mass: data["m_Mass"] ?? 1,
+            linearDrag: data["m_LinearDrag"] ?? 0,
+            angularDrag: data["m_AngularDrag"] ?? 0.05,
+            gravityScale: data["m_GravityScale"] ?? 1
+          }
         };
-        // Convert each root and its children
-        for (const rootID of scene.roots) {
-            const entity = this.convertGameObject(scene, rootID);
-            if (entity) {
-                nice2devScene.entities.push(entity);
-            }
-        }
-        return nice2devScene;
-    }
-    convertGameObject(scene, fileID) {
-        const goObj = scene.objects.get(fileID);
-        if (!goObj || goObj.type !== 'GameObject') {
-            return null;
-        }
-        const goData = goObj.data['GameObject'];
-        if (!goData) {
-            return null;
-        }
-        const entity = {
-            name: goData['m_Name'] ?? 'GameObject',
-            active: goData['m_IsActive'] ?? true,
-            tag: goData['m_Tag'] ?? 'Untagged',
-            layer: goData['m_Layer'] ?? 0,
-            transform: {
-                position: { x: 0, y: 0, z: 0 },
-                rotation: { x: 0, y: 0, z: 0, w: 1 },
-                scale: { x: 1, y: 1, z: 1 },
-            },
-            components: [],
-            children: [],
+      case "BoxCollider":
+        return {
+          type: "BoxCollider3D",
+          data: {
+            isTrigger: data["m_IsTrigger"] ?? false,
+            center: data["m_Center"] ?? { x: 0, y: 0, z: 0 },
+            size: data["m_Size"] ?? { x: 1, y: 1, z: 1 }
+          }
         };
-        // Find transform
-        const components = goData['m_Component'];
-        if (components) {
-            for (const compRef of components) {
-                if (compRef.component.fileID === undefined) {
-                    continue;
-                }
-                const compObj = scene.objects.get(compRef.component.fileID);
-                if (!compObj) {
-                    continue;
-                }
-                if (compObj.type === 'Transform' || compObj.type === 'RectTransform') {
-                    const transform = compObj.data[compObj.type];
-                    if (transform) {
-                        const pos = transform['m_LocalPosition'];
-                        const rot = transform['m_LocalRotation'];
-                        const scale = transform['m_LocalScale'];
-                        if (pos) {
-                            entity.transform.position = { x: pos.x, y: pos.y, z: pos.z };
-                        }
-                        if (rot) {
-                            entity.transform.rotation = { x: rot.x, y: rot.y, z: rot.z, w: rot.w };
-                        }
-                        if (scale) {
-                            entity.transform.scale = { x: scale.x, y: scale.y, z: scale.z };
-                        }
-                        // Get children
-                        const children = transform['m_Children'];
-                        if (children) {
-                            for (const childRef of children) {
-                                if (childRef.fileID === undefined) {
-                                    continue;
-                                }
-                                const childTransform = scene.objects.get(childRef.fileID);
-                                if (childTransform) {
-                                    const childGO = childTransform.data['Transform']?.['m_GameObject'];
-                                    if (childGO?.fileID) {
-                                        const childEntity = this.convertGameObject(scene, childGO.fileID);
-                                        if (childEntity) {
-                                            entity.children.push(childEntity);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                else {
-                    // Convert other components
-                    const compData = this.convertComponent(compObj);
-                    if (compData) {
-                        entity.components.push(compData);
-                    }
-                }
-            }
-        }
-        return entity;
-    }
-    convertComponent(compObj) {
-        const typeName = compObj.type;
-        const data = compObj.data[typeName];
-        if (!data) {
-            return null;
-        }
-        switch (typeName) {
-            case 'Camera':
-                return {
-                    type: 'Camera',
-                    data: {
-                        fieldOfView: data['field of view'] ?? 60,
-                        nearClip: data['near clip plane'] ?? 0.3,
-                        farClip: data['far clip plane'] ?? 1000,
-                        orthographic: data['orthographic'] ?? false,
-                        orthographicSize: data['orthographic size'] ?? 5,
-                    },
-                };
-            case 'Light':
-                return {
-                    type: 'Light',
-                    data: {
-                        type: this.mapLightType(data['m_Type']),
-                        color: data['m_Color'] ?? { r: 1, g: 1, b: 1, a: 1 },
-                        intensity: data['m_Intensity'] ?? 1,
-                        range: data['m_Range'] ?? 10,
-                        spotAngle: data['m_SpotAngle'] ?? 30,
-                        shadows: data['m_Shadows'] !== 0,
-                    },
-                };
-            case 'MeshRenderer':
-            case 'SkinnedMeshRenderer':
-                return {
-                    type: 'MeshRenderer',
-                    data: {
-                        enabled: data['m_Enabled'] ?? true,
-                        castShadows: data['m_CastShadows'] ?? true,
-                        receiveShadows: data['m_ReceiveShadows'] ?? true,
-                        materials: [], // Would resolve material GUIDs
-                    },
-                };
-            case 'SpriteRenderer':
-                return {
-                    type: 'SpriteRenderer',
-                    data: {
-                        color: data['m_Color'] ?? { r: 1, g: 1, b: 1, a: 1 },
-                        flipX: data['m_FlipX'] ?? false,
-                        flipY: data['m_FlipY'] ?? false,
-                        sortingLayer: data['m_SortingLayer'] ?? 0,
-                        sortingOrder: data['m_SortingOrder'] ?? 0,
-                    },
-                };
-            case 'Rigidbody':
-                return {
-                    type: 'Rigidbody3D',
-                    data: {
-                        mass: data['m_Mass'] ?? 1,
-                        drag: data['m_Drag'] ?? 0,
-                        angularDrag: data['m_AngularDrag'] ?? 0.05,
-                        useGravity: data['m_UseGravity'] ?? true,
-                        isKinematic: data['m_IsKinematic'] ?? false,
-                    },
-                };
-            case 'Rigidbody2D':
-                return {
-                    type: 'Rigidbody2D',
-                    data: {
-                        bodyType: this.mapRigidBodyType(data['m_BodyType']),
-                        mass: data['m_Mass'] ?? 1,
-                        linearDrag: data['m_LinearDrag'] ?? 0,
-                        angularDrag: data['m_AngularDrag'] ?? 0.05,
-                        gravityScale: data['m_GravityScale'] ?? 1,
-                    },
-                };
-            case 'BoxCollider':
-                return {
-                    type: 'BoxCollider3D',
-                    data: {
-                        isTrigger: data['m_IsTrigger'] ?? false,
-                        center: data['m_Center'] ?? { x: 0, y: 0, z: 0 },
-                        size: data['m_Size'] ?? { x: 1, y: 1, z: 1 },
-                    },
-                };
-            case 'BoxCollider2D':
-                return {
-                    type: 'BoxCollider2D',
-                    data: {
-                        isTrigger: data['m_IsTrigger'] ?? false,
-                        offset: data['m_Offset'] ?? { x: 0, y: 0 },
-                        size: data['m_Size'] ?? { x: 1, y: 1 },
-                    },
-                };
-            case 'CircleCollider2D':
-                return {
-                    type: 'CircleCollider2D',
-                    data: {
-                        isTrigger: data['m_IsTrigger'] ?? false,
-                        offset: data['m_Offset'] ?? { x: 0, y: 0 },
-                        radius: data['m_Radius'] ?? 0.5,
-                    },
-                };
-            case 'Animator':
-                return {
-                    type: 'Animator',
-                    data: {
-                        controllerGUID: data['m_Controller']?.guid,
-                        applyRootMotion: data['m_ApplyRootMotion'] ?? false,
-                        updateMode: data['m_UpdateMode'] ?? 0,
-                        cullingMode: data['m_CullingMode'] ?? 0,
-                    },
-                };
-            case 'AudioSource': {
-                const panCurve = data['panLevelCustomCurve'];
-                const curveData = panCurve?.['m_Curve'];
-                return {
-                    type: 'AudioSource',
-                    data: {
-                        clipGUID: data['m_audioClip']?.guid,
-                        playOnAwake: data['m_PlayOnAwake'] ?? true,
-                        loop: data['Loop'] ?? false,
-                        volume: data['m_Volume'] ?? 1,
-                        pitch: data['m_Pitch'] ?? 1,
-                        spatialBlend: curveData?.[0]?.value ?? 0,
-                    },
-                };
-            }
-            case 'ParticleSystem':
-                return {
-                    type: 'ParticleSystem',
-                    data: {
-                        // Particle systems are complex, just mark as present
-                        hasEmission: true,
-                    },
-                };
-            case 'MonoBehaviour':
-                return {
-                    type: 'Script',
-                    data: {
-                        scriptGUID: data['m_Script']?.guid,
-                        serializedData: this.extractMonoBehaviourData(data),
-                    },
-                };
-            default:
-                return {
-                    type: 'Unknown',
-                    data: { originalType: typeName },
-                };
-        }
-    }
-    mapLightType(type) {
-        const types = {
-            0: 'spot',
-            1: 'directional',
-            2: 'point',
-            3: 'area',
+      case "BoxCollider2D":
+        return {
+          type: "BoxCollider2D",
+          data: {
+            isTrigger: data["m_IsTrigger"] ?? false,
+            offset: data["m_Offset"] ?? { x: 0, y: 0 },
+            size: data["m_Size"] ?? { x: 1, y: 1 }
+          }
         };
-        return types[type] ?? 'point';
-    }
-    mapRigidBodyType(type) {
-        const types = {
-            0: 'dynamic',
-            1: 'kinematic',
-            2: 'static',
+      case "CircleCollider2D":
+        return {
+          type: "CircleCollider2D",
+          data: {
+            isTrigger: data["m_IsTrigger"] ?? false,
+            offset: data["m_Offset"] ?? { x: 0, y: 0 },
+            radius: data["m_Radius"] ?? 0.5
+          }
+        };
+      case "Animator":
+        return {
+          type: "Animator",
+          data: {
+            controllerGUID: data["m_Controller"]?.guid,
+            applyRootMotion: data["m_ApplyRootMotion"] ?? false,
+            updateMode: data["m_UpdateMode"] ?? 0,
+            cullingMode: data["m_CullingMode"] ?? 0
+          }
+        };
+      case "AudioSource": {
+        const panCurve = data["panLevelCustomCurve"];
+        const curveData = panCurve?.["m_Curve"];
+        return {
+          type: "AudioSource",
+          data: {
+            clipGUID: data["m_audioClip"]?.guid,
+            playOnAwake: data["m_PlayOnAwake"] ?? true,
+            loop: data["Loop"] ?? false,
+            volume: data["m_Volume"] ?? 1,
+            pitch: data["m_Pitch"] ?? 1,
+            spatialBlend: curveData?.[0]?.value ?? 0
+          }
+        };
+      }
+      case "ParticleSystem":
+        return {
+          type: "ParticleSystem",
+          data: {
+            // Particle systems are complex, just mark as present
+            hasEmission: true
+          }
+        };
+      case "MonoBehaviour":
+        return {
+          type: "Script",
+          data: {
+            scriptGUID: data["m_Script"]?.guid,
+            serializedData: this.extractMonoBehaviourData(data)
+          }
+        };
+      default:
+        return {
+          type: "Unknown",
+          data: { originalType: typeName }
         };
-        return types[type] ?? 'dynamic';
-    }
-    extractMonoBehaviourData(data) {
-        const result = {};
-        // Extract all non-internal properties
-        for (const [key, value] of Object.entries(data)) {
-            if (!key.startsWith('m_') ||
-                [
-                    'm_Enabled',
-                    'm_Script',
-                    'm_Name',
-                    'm_EditorHideFlags',
-                    'm_GameObject',
-                    'm_EditorClassIdentifier',
-                ].includes(key)) {
-                continue;
-            }
-            // Remove m_ prefix and convert to camelCase
-            const propName = key.slice(2, 3).toLowerCase() + key.slice(3);
-            result[propName] = value;
-        }
-        return result;
     }
-    // ─── Callbacks ─────────────────────────────────────────
-    setCallbacks(callbacks) {
-        this.callbacks = { ...this.callbacks, ...callbacks };
+  }
+  mapLightType(type) {
+    const types = {
+      0: "spot",
+      1: "directional",
+      2: "point",
+      3: "area"
+    };
+    return types[type] ?? "point";
+  }
+  mapRigidBodyType(type) {
+    const types = {
+      0: "dynamic",
+      1: "kinematic",
+      2: "static"
+    };
+    return types[type] ?? "dynamic";
+  }
+  extractMonoBehaviourData(data) {
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (!key.startsWith("m_") || [
+        "m_Enabled",
+        "m_Script",
+        "m_Name",
+        "m_EditorHideFlags",
+        "m_GameObject",
+        "m_EditorClassIdentifier"
+      ].includes(key)) {
+        continue;
+      }
+      const propName = key.slice(2, 3).toLowerCase() + key.slice(3);
+      result[propName] = value;
     }
+    return result;
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
 }
-// ============================================================
-// Unity Messages List
-// ============================================================
 const UNITY_MESSAGES = [
-    'Awake',
-    'Start',
-    'Update',
-    'FixedUpdate',
-    'LateUpdate',
-    'OnEnable',
-    'OnDisable',
-    'OnDestroy',
-    'OnTriggerEnter',
-    'OnTriggerStay',
-    'OnTriggerExit',
-    'OnTriggerEnter2D',
-    'OnTriggerStay2D',
-    'OnTriggerExit2D',
-    'OnCollisionEnter',
-    'OnCollisionStay',
-    'OnCollisionExit',
-    'OnCollisionEnter2D',
-    'OnCollisionStay2D',
-    'OnCollisionExit2D',
-    'OnMouseDown',
-    'OnMouseUp',
-    'OnMouseEnter',
-    'OnMouseExit',
-    'OnMouseOver',
-    'OnMouseDrag',
-    'OnGUI',
-    'OnDrawGizmos',
-    'OnDrawGizmosSelected',
-    'OnBecameVisible',
-    'OnBecameInvisible',
-    'OnPreCull',
-    'OnPreRender',
-    'OnPostRender',
-    'OnRenderImage',
-    'OnRenderObject',
-    'OnWillRenderObject',
-    'OnAnimatorMove',
-    'OnAnimatorIK',
-    'OnApplicationFocus',
-    'OnApplicationPause',
-    'OnApplicationQuit',
-    'OnValidate',
-    'Reset',
+  "Awake",
+  "Start",
+  "Update",
+  "FixedUpdate",
+  "LateUpdate",
+  "OnEnable",
+  "OnDisable",
+  "OnDestroy",
+  "OnTriggerEnter",
+  "OnTriggerStay",
+  "OnTriggerExit",
+  "OnTriggerEnter2D",
+  "OnTriggerStay2D",
+  "OnTriggerExit2D",
+  "OnCollisionEnter",
+  "OnCollisionStay",
+  "OnCollisionExit",
+  "OnCollisionEnter2D",
+  "OnCollisionStay2D",
+  "OnCollisionExit2D",
+  "OnMouseDown",
+  "OnMouseUp",
+  "OnMouseEnter",
+  "OnMouseExit",
+  "OnMouseOver",
+  "OnMouseDrag",
+  "OnGUI",
+  "OnDrawGizmos",
+  "OnDrawGizmosSelected",
+  "OnBecameVisible",
+  "OnBecameInvisible",
+  "OnPreCull",
+  "OnPreRender",
+  "OnPostRender",
+  "OnRenderImage",
+  "OnRenderObject",
+  "OnWillRenderObject",
+  "OnAnimatorMove",
+  "OnAnimatorIK",
+  "OnApplicationFocus",
+  "OnApplicationPause",
+  "OnApplicationQuit",
+  "OnValidate",
+  "Reset"
 ];
-// ============================================================
-// Factory Functions
-// ============================================================
 function createUnityProjectImporter() {
-    return new UnityProjectImporter();
+  return new UnityProjectImporter();
 }
-
-export { UnityProjectImporter, createUnityProjectImporter, getUnityClassName, parseUnityMeta, parseUnityYAML };
+export {
+  UnityProjectImporter,
+  createUnityProjectImporter,
+  getUnityClassName,
+  parseUnityMeta,
+  parseUnityYAML
+};