unity-agentic-tools 0.3.1 → 0.3.3

package/dist/index.js

@@ -76,6 +76,7 @@ __export(exports_scanner, {
   getNativeExtractCsharpTypes: () => getNativeExtractCsharpTypes,
   getNativeBuildTypeRegistry: () => getNativeBuildTypeRegistry,
   getNativeBuildPackageGuidCache: () => getNativeBuildPackageGuidCache,
+  getNativeBuildLocalPackageGuidCache: () => getNativeBuildLocalPackageGuidCache,
   getNativeBuildGuidCache: () => getNativeBuildGuidCache,
   UnityScanner: () => UnityScanner
 });
@@ -156,13 +157,16 @@ function getNativeExtractDllTypes() {
 function getNativeBuildPackageGuidCache() {
   return nativeBuildPackageGuidCache;
 }
+function getNativeBuildLocalPackageGuidCache() {
+  return nativeBuildLocalPackageGuidCache;
+}
 function getNativeExtractSerializedFields() {
   return nativeExtractSerializedFields;
 }
 function getNativeExtractDllFields() {
   return nativeExtractDllFields;
 }
-var import_module, import_fs, import_path, __dirname = "/home/runner/work/unity-agentic-tools/unity-agentic-tools/unity-agentic-tools/src", RustScanner = null, nativeModuleError = null, nativeWalkProjectFiles = null, nativeGrepProject = null, nativeBuildGuidCache = null, nativeExtractCsharpTypes = null, nativeBuildTypeRegistry = null, nativeExtractDllTypes = null, nativeBuildPackageGuidCache = null, nativeExtractSerializedFields = null, nativeExtractDllFields = null;
+var import_module, import_fs, import_path, __dirname = "/home/runner/work/unity-agentic-tools/unity-agentic-tools/unity-agentic-tools/src", RustScanner = null, nativeModuleError = null, nativeWalkProjectFiles = null, nativeGrepProject = null, nativeBuildGuidCache = null, nativeExtractCsharpTypes = null, nativeBuildTypeRegistry = null, nativeExtractDllTypes = null, nativeBuildPackageGuidCache = null, nativeBuildLocalPackageGuidCache = null, nativeExtractSerializedFields = null, nativeExtractDllFields = null;
 var init_scanner = __esm(() => {
   import_module = require("module");
   import_fs = require("fs");
@@ -186,6 +190,7 @@ var init_scanner = __esm(() => {
     nativeBuildTypeRegistry = rustModule.buildTypeRegistry || null;
     nativeExtractDllTypes = rustModule.extractDllTypes || null;
     nativeBuildPackageGuidCache = rustModule.buildPackageGuidCache || null;
+    nativeBuildLocalPackageGuidCache = rustModule.buildLocalPackageGuidCache || null;
     nativeExtractSerializedFields = rustModule.extractSerializedFields || null;
     nativeExtractDllFields = rustModule.extractDllFields || null;
   } catch (err) {
@@ -200,7 +205,7 @@ var require_package = __commonJS((exports2, module2) => {
   module2.exports = {
     name: "unity-agentic-tools",
     packageManager: "bun@latest",
-    version: "0.3.1",
+    version: "0.3.3",
     description: "Fast, token-efficient Unity YAML parser for AI agents",
     exports: {
       ".": {
@@ -330,6 +335,7 @@ var CONFIG_DIR = ".unity-agentic";
 var CONFIG_FILE = "config.json";
 var GUID_CACHE_FILE = "guid-cache.json";
 var PACKAGE_CACHE_FILE = "package-cache.json";
+var LOCAL_PACKAGE_CACHE_FILE = "local-package-cache.json";
 var TYPE_REGISTRY_FILE = "type-registry.json";
 var DOC_INDEX_FILE = "doc-index.json";
 function setup(options = {}) {
@@ -373,6 +379,17 @@ function setup(options = {}) {
       packageGuidCount = Object.keys(packageCache).length;
     } catch {}
   }
+  const nativeLocalPkgBuild = getNativeBuildLocalPackageGuidCache();
+  if (nativeLocalPkgBuild) {
+    try {
+      const localPkgCache = nativeLocalPkgBuild(projectPath);
+      const localPkgCount = Object.keys(localPkgCache).length;
+      if (localPkgCount > 0) {
+        const localPkgCachePath = import_path2.join(configPath, LOCAL_PACKAGE_CACHE_FILE);
+        import_fs2.writeFileSync(localPkgCachePath, JSON.stringify(localPkgCache, null, 2));
+      }
+    } catch {}
+  }
   let typeRegistryCreated = false;
   let typeCount;
   const nativeRegistryBuild = getNativeBuildTypeRegistry();
@@ -555,31 +572,44 @@ function atomicWrite(filePath, content) {
       };
     }
   }
-  const tmpPath = `${filePath}.tmp`;
+  const suffix = `${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+  const tmpPath = `${filePath}.${suffix}.tmp`;
+  const bakPath = `${filePath}.${suffix}.bak`;
+  let bakCreated = false;
   try {
     import_fs4.writeFileSync(tmpPath, content, "utf-8");
-    if (import_fs4.existsSync(filePath)) {
-      import_fs4.renameSync(filePath, `${filePath}.bak`);
-    }
-    import_fs4.renameSync(tmpPath, filePath);
     try {
-      if (import_fs4.existsSync(`${filePath}.bak`)) {
-        import_fs4.unlinkSync(`${filePath}.bak`);
+      import_fs4.renameSync(filePath, bakPath);
+      bakCreated = true;
+    } catch (err) {
+      if (is_enoent(err)) {
+        bakCreated = false;
+      } else {
+        throw err;
       }
-    } catch {}
+    }
+    import_fs4.renameSync(tmpPath, filePath);
+    if (bakCreated) {
+      try {
+        import_fs4.unlinkSync(bakPath);
+      } catch {}
+    }
     return {
       success: true,
       file_path: filePath,
       bytes_written: Buffer.byteLength(content, "utf-8")
     };
   } catch (error) {
-    if (import_fs4.existsSync(`${filePath}.bak`)) {
+    if (bakCreated) {
       try {
-        import_fs4.renameSync(`${filePath}.bak`, filePath);
+        import_fs4.renameSync(bakPath, filePath);
       } catch (restoreError) {
         console.error("Failed to restore backup:", restoreError);
       }
     }
+    try {
+      import_fs4.unlinkSync(tmpPath);
+    } catch {}
     return {
       success: false,
       file_path: filePath,
@@ -587,6 +617,12 @@ function atomicWrite(filePath, content) {
     };
   }
 }
+function is_enoent(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+function normalize_property_path(path) {
+  return path.replace(/\.Array\.data\.(\d+)/g, ".Array.data[$1]");
+}
 function is_match_all(pattern) {
   return pattern === "*" || pattern === "." || pattern === "**" || pattern === ".*";
 }
@@ -2076,6 +2112,31 @@ function extractGuidFromMeta(metaPath) {
     return null;
   }
 }
+function resolve_source_prefab(doc, file_path, project_path) {
+  const pi_blocks = doc.find_by_class_id(1001);
+  if (pi_blocks.length === 0)
+    return null;
+  const pi_block = pi_blocks[0];
+  const source_match = pi_block.raw.match(/m_SourcePrefab:[ \t]*\{[^}]*guid:[ \t]*([a-f0-9]{32})/);
+  if (!source_match)
+    return null;
+  const source_guid = source_match[1];
+  const resolved_project = project_path || find_unity_project_root(path3.dirname(file_path));
+  if (!resolved_project)
+    return null;
+  const cache = load_guid_cache_for_file(file_path, resolved_project);
+  if (!cache)
+    return null;
+  const source_path = cache.resolve_absolute(source_guid);
+  if (!source_path || !import_fs8.existsSync(source_path))
+    return null;
+  return {
+    source_guid,
+    source_path,
+    prefab_instance_id: pi_block.file_id,
+    prefab_instance_block: pi_block
+  };
+}
 function resolveScriptGuid(script, projectPath) {
   if (/^[a-f0-9]{32}$/i.test(script)) {
     return { guid: script.toLowerCase(), path: null };
@@ -2125,27 +2186,122 @@ function resolveScriptGuid(script, projectPath) {
             return false;
           return true;
         });
-        if (matches.length === 1 && matches[0].guid) {
-          return { guid: matches[0].guid, path: matches[0].filePath };
+        if (matches.length === 1) {
+          if (matches[0].guid) {
+            return { guid: matches[0].guid, path: matches[0].filePath };
+          }
+          if (matches[0].filePath && projectPath) {
+            const fullFilePath = path3.isAbsolute(matches[0].filePath) ? matches[0].filePath : path3.join(projectPath, matches[0].filePath);
+            const metaPath = fullFilePath + ".meta";
+            if (import_fs8.existsSync(metaPath)) {
+              const guid = extractGuidFromMeta(metaPath);
+              if (guid)
+                return { guid, path: matches[0].filePath };
+            }
+            if (matches[0].filePath.startsWith("Packages/")) {
+              const pkgPath = path3.join(projectPath, matches[0].filePath);
+              const pkgMetaPath = pkgPath + ".meta";
+              if (import_fs8.existsSync(pkgMetaPath)) {
+                const guid = extractGuidFromMeta(pkgMetaPath);
+                if (guid)
+                  return { guid, path: matches[0].filePath };
+              }
+            }
+            if (matches[0].filePath?.endsWith(".dll")) {
+              const dllBasename = path3.basename(matches[0].filePath).toLowerCase();
+              for (const cacheName of ["package-cache.json", "local-package-cache.json"]) {
+                const cachePath = path3.join(projectPath, ".unity-agentic", cacheName);
+                if (!import_fs8.existsSync(cachePath))
+                  continue;
+                try {
+                  const cache = JSON.parse(import_fs8.readFileSync(cachePath, "utf-8"));
+                  for (const [guid, assetPath] of Object.entries(cache)) {
+                    if (assetPath.toLowerCase().endsWith(".dll") && path3.basename(assetPath).toLowerCase() === dllBasename) {
+                      return { guid, path: assetPath };
+                    }
+                  }
+                } catch {}
+              }
+            }
+          }
         }
         if (matches.length > 1) {
           const withGuid = matches.filter((m) => m.guid);
           if (withGuid.length === 1) {
             return { guid: withGuid[0].guid, path: withGuid[0].filePath };
           }
+          const resolvedFromMeta = matches.filter((m) => !m.guid && m.filePath).map((m) => {
+            const fullPath = path3.isAbsolute(m.filePath) ? m.filePath : path3.join(projectPath, m.filePath);
+            let guid = import_fs8.existsSync(fullPath + ".meta") ? extractGuidFromMeta(fullPath + ".meta") : null;
+            if (!guid && m.filePath.startsWith("Packages/")) {
+              const pkgPath = path3.join(projectPath, m.filePath);
+              if (import_fs8.existsSync(pkgPath + ".meta")) {
+                guid = extractGuidFromMeta(pkgPath + ".meta");
+              }
+            }
+            if (!guid && m.filePath?.endsWith(".dll")) {
+              const dllBase = path3.basename(m.filePath).toLowerCase();
+              for (const cn of ["package-cache.json", "local-package-cache.json"]) {
+                const cp = path3.join(projectPath, ".unity-agentic", cn);
+                if (!import_fs8.existsSync(cp))
+                  continue;
+                try {
+                  const c = JSON.parse(import_fs8.readFileSync(cp, "utf-8"));
+                  for (const [g, p] of Object.entries(c)) {
+                    if (p.toLowerCase().endsWith(".dll") && path3.basename(p).toLowerCase() === dllBase) {
+                      guid = g;
+                      break;
+                    }
+                  }
+                } catch {}
+                if (guid)
+                  break;
+              }
+            }
+            return guid ? { guid, path: m.filePath } : null;
+          }).filter((r) => r !== null);
+          const allResolved = [...withGuid.map((m) => ({ guid: m.guid, path: m.filePath })), ...resolvedFromMeta];
+          if (allResolved.length === 1) {
+            return allResolved[0];
+          }
+          if (allResolved.length > 1) {
+            const pkgCachePaths = [
+              path3.join(projectPath, ".unity-agentic", "package-cache.json"),
+              path3.join(projectPath, ".unity-agentic", "local-package-cache.json")
+            ];
+            for (const cachePath of pkgCachePaths) {
+              if (!import_fs8.existsSync(cachePath))
+                continue;
+              try {
+                const cache = JSON.parse(import_fs8.readFileSync(cachePath, "utf-8"));
+                const inCache = allResolved.filter((r) => (r.guid in cache));
+                if (inCache.length === 1)
+                  return inCache[0];
+              } catch {}
+            }
+            const paths = allResolved.map((m) => m.path).join(", ");
+            throw new Error(`Ambiguous type "${script}": found ${allResolved.length} matches (${paths}). ` + `Use a qualified name (e.g., "Namespace.${targetName}") or provide the full path.`);
+          }
         }
       } catch {}
     }
-    const packageCachePath = path3.join(projectPath, ".unity-agentic", "package-cache.json");
-    if (import_fs8.existsSync(packageCachePath)) {
+    const scriptNameLower = script.toLowerCase().replace(/\.cs$/, "");
+    const dotIdx = scriptNameLower.lastIndexOf(".");
+    const classNameOnly = dotIdx > 0 ? scriptNameLower.substring(dotIdx + 1) : null;
+    const cachePaths = [
+      path3.join(projectPath, ".unity-agentic", "package-cache.json"),
+      path3.join(projectPath, ".unity-agentic", "local-package-cache.json")
+    ];
+    for (const cachePath of cachePaths) {
+      if (!import_fs8.existsSync(cachePath))
+        continue;
       try {
-        const packageCache = JSON.parse(import_fs8.readFileSync(packageCachePath, "utf-8"));
-        const scriptNameLower = script.toLowerCase().replace(/\.cs$/, "");
-        for (const [guid, assetPath] of Object.entries(packageCache)) {
+        const cache = JSON.parse(import_fs8.readFileSync(cachePath, "utf-8"));
+        for (const [guid, assetPath] of Object.entries(cache)) {
           if (!assetPath.endsWith(".cs"))
             continue;
           const fileName = path3.basename(assetPath, ".cs").toLowerCase();
-          if (fileName === scriptNameLower) {
+          if (fileName === scriptNameLower || classNameOnly && fileName === classNameOnly) {
             return { guid, path: assetPath };
           }
         }
@@ -2196,6 +2352,8 @@ function resolve_script_with_fields(script, project_path) {
             result.fields = chosen.fields;
             result.base_class = chosen.baseClass ?? undefined;
             result.kind = chosen.kind;
+            result.namespace = chosen.namespace ?? undefined;
+            result.class_name = chosen.name;
           }
         } else {
           result.extraction_error = "Native extractDllFields function not available";
@@ -2244,178 +2402,61 @@ function resolve_enum_fields(fields, project_path) {
     }
   } catch {}
 }
-
-// src/editor/yaml-fields.ts
-var PRIMITIVE_DEFAULTS = {
-  int: "0",
-  float: "0",
-  double: "0",
-  bool: "0",
-  string: "",
-  byte: "0",
-  sbyte: "0",
-  short: "0",
-  ushort: "0",
-  uint: "0",
-  long: "0",
-  ulong: "0",
-  char: "0",
-  Int32: "0",
-  Single: "0",
-  Double: "0",
-  Boolean: "0",
-  String: "",
-  Byte: "0",
-  SByte: "0",
-  Int16: "0",
-  UInt16: "0",
-  UInt32: "0",
-  Int64: "0",
-  UInt64: "0",
-  Char: "0"
-};
-var STRUCT_DEFAULTS = {
-  Vector2: "{x: 0, y: 0}",
-  Vector3: "{x: 0, y: 0, z: 0}",
-  Vector4: "{x: 0, y: 0, z: 0, w: 0}",
-  Vector2Int: "{x: 0, y: 0}",
-  Vector3Int: "{x: 0, y: 0, z: 0}",
-  Quaternion: "{x: 0, y: 0, z: 0, w: 1}",
-  Color: "{r: 0, g: 0, b: 0, a: 0}",
-  Color32: "{r: 0, g: 0, b: 0, a: 0}",
-  Rect: `serializedVersion: 2
-    x: 0
-    y: 0
-    width: 0
-    height: 0`,
-  RectInt: "{x: 0, y: 0, width: 0, height: 0}",
-  RectOffset: "{m_Left: 0, m_Right: 0, m_Top: 0, m_Bottom: 0}",
-  Matrix4x4: "{e00: 1, e01: 0, e02: 0, e03: 0, e10: 0, e11: 1, e12: 0, e13: 0, e20: 0, e21: 0, e22: 1, e23: 0, e30: 0, e31: 0, e32: 0, e33: 1}",
-  LayerMask: `serializedVersion: 2
-    m_Bits: 0`
-};
-var VERSION_GATED_STRUCT_DEFAULTS = {
-  Hash128: { value: `serializedVersion: 2
-    Hash: 00000000000000000000000000000000`, min_major: 2021, min_minor: 1 },
-  RenderingLayerMask: { value: `serializedVersion: 2
-    m_Bits: 0`, min_major: 6000, min_minor: 0 }
-};
-var BLOCK_STRUCT_DEFAULTS = {
-  Bounds: `m_Center: {x: 0, y: 0, z: 0}
-    m_Extent: {x: 0, y: 0, z: 0}`,
-  BoundsInt: `m_Position: {x: 0, y: 0, z: 0}
-    m_Size: {x: 0, y: 0, z: 0}`
-};
-var OBJECT_REF_TYPES = new Set([
-  "GameObject",
-  "Transform",
-  "RectTransform",
-  "Material",
-  "Texture",
-  "Texture2D",
-  "Texture3D",
-  "RenderTexture",
-  "Sprite",
-  "AudioClip",
-  "VideoClip",
-  "Mesh",
-  "Shader",
-  "ComputeShader",
-  "AnimationClip",
-  "AnimatorController",
-  "RuntimeAnimatorController",
-  "PhysicMaterial",
-  "PhysicsMaterial",
-  "PhysicsMaterial2D",
-  "Font",
-  "TMP_FontAsset",
-  "Object",
-  "Component",
-  "Behaviour",
-  "MonoBehaviour",
-  "ScriptableObject",
-  "Rigidbody",
-  "Rigidbody2D",
-  "Collider",
-  "Collider2D",
-  "Camera",
-  "Light",
-  "Canvas",
-  "CanvasGroup",
-  "EventSystem",
-  "AudioSource",
-  "ParticleSystem",
-  "TextAsset",
-  "TerrainData"
-]);
-function version_at_least(version, min_major, min_minor) {
-  if (!version)
-    return false;
-  if (version.major > min_major)
-    return true;
-  if (version.major === min_major)
-    return version.minor >= min_minor;
-  return false;
-}
-function yaml_default_for_type(csharp_type, version) {
-  if (csharp_type.endsWith("?")) {
-    return null;
-  }
-  if (csharp_type in PRIMITIVE_DEFAULTS) {
-    return PRIMITIVE_DEFAULTS[csharp_type];
-  }
-  if (csharp_type in STRUCT_DEFAULTS) {
-    return STRUCT_DEFAULTS[csharp_type];
-  }
-  if (csharp_type in VERSION_GATED_STRUCT_DEFAULTS) {
-    const gated = VERSION_GATED_STRUCT_DEFAULTS[csharp_type];
-    if (version_at_least(version, gated.min_major, gated.min_minor)) {
-      return gated.value;
+function build_type_lookup(project_path) {
+  let extractFn = null;
+  try {
+    const { getNativeExtractSerializedFields: getNativeExtractSerializedFields2 } = (init_scanner(), __toCommonJS(exports_scanner));
+    extractFn = getNativeExtractSerializedFields2();
+  } catch {}
+  if (!extractFn)
+    return () => null;
+  const assetsDir = path3.join(project_path, "Assets");
+  const csIndex = new Map;
+  try {
+    const { readdirSync: readdirSync4 } = require("fs");
+    const entries = readdirSync4(assetsDir, { recursive: true, withFileTypes: false });
+    for (const entry of entries) {
+      if (typeof entry === "string" && entry.endsWith(".cs")) {
+        const basename4 = entry.substring(entry.lastIndexOf("/") + 1).replace(/\.cs$/, "");
+        if (!csIndex.has(basename4)) {
+          csIndex.set(basename4, path3.join(assetsDir, entry));
+        }
+      }
     }
-    return null;
-  }
-  if (csharp_type in BLOCK_STRUCT_DEFAULTS) {
-    return BLOCK_STRUCT_DEFAULTS[csharp_type];
-  }
-  if (csharp_type.endsWith("[]")) {
-    return "[]";
-  }
-  if (csharp_type.startsWith("List<") && csharp_type.endsWith(">")) {
-    return "[]";
-  }
-  if (OBJECT_REF_TYPES.has(csharp_type)) {
-    return "{fileID: 0}";
-  }
-  return "{fileID: 0}";
-}
-function generate_field_yaml(fields, version, indent = "  ") {
-  const lines = [];
-  for (const field of fields) {
-    const default_value = yaml_default_for_type(field.typeName, version);
-    if (default_value === null) {
-      continue;
+  } catch {}
+  if (csIndex.size === 0)
+    return () => null;
+  const cache = new Map;
+  return (typeName) => {
+    if (cache.has(typeName))
+      return cache.get(typeName) ?? null;
+    const shortName = typeName.includes(".") ? typeName.substring(typeName.lastIndexOf(".") + 1) : typeName;
+    const csPath = csIndex.get(shortName);
+    if (!csPath || !import_fs8.existsSync(csPath)) {
+      cache.set(typeName, null);
+      return null;
     }
-    if (default_value.includes(`
-`)) {
-      lines.push(`${indent}${field.name}:`);
-      for (const sub_line of default_value.split(`
-`)) {
-        lines.push(`${indent}${sub_line}`);
+    try {
+      const typeInfos = extractFn(csPath);
+      if (!typeInfos || typeInfos.length === 0) {
+        cache.set(typeName, null);
+        return null;
       }
-    } else {
-      lines.push(`${indent}${field.name}: ${default_value}`);
+      const match = typeInfos.find((t) => t.name === shortName);
+      if (match && match.fields && match.fields.length > 0) {
+        resolve_enum_fields(match.fields, project_path);
+        cache.set(typeName, match.fields);
+        return match.fields;
+      }
+      cache.set(typeName, null);
+      return null;
+    } catch {
+      cache.set(typeName, null);
+      return null;
     }
-  }
-  return lines.length > 0 ? `
-` + lines.join(`
-`) + `
-` : `
-`;
+  };
 }
 
-// src/editor/unity-document.ts
-var import_fs9 = require("fs");
-
 // src/editor/unity-block.ts
 var HEADER_PATTERN = /^--- !u!(\d+) &(-?\d+)(\s+stripped)?/;
 function parse_header(raw) {
@@ -2434,6 +2475,17 @@ function parse_header(raw) {
 function escape_regex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function yaml_quote_if_needed(value) {
+  if (value === "")
+    return value;
+  if (value.startsWith("{") && value.endsWith("}") || value.startsWith("[") && value.endsWith("]")) {
+    return value;
+  }
+  if (value.includes(": ") || value.includes(" #") || /^[#\{\[*&!|>'"]/.test(value) || value !== value.trim()) {
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  return value;
+}
 
 class UnityBlock {
   _raw;
@@ -2469,6 +2521,7 @@ class UnityBlock {
     return this._dirty;
   }
   get_property(path4) {
+    path4 = normalize_property_path(path4);
     if (path4.includes("Array.data[")) {
       return this._get_array_element(path4);
     }
@@ -2495,13 +2548,43 @@ class UnityBlock {
     return match ? match[1].trim() : null;
   }
   set_property(path4, value, object_reference) {
+    path4 = normalize_property_path(path4);
     const old_raw = this._raw;
     const effective_ref = object_reference && object_reference !== "{fileID: 0}" ? object_reference : undefined;
     if (!path4.includes(".") && !path4.includes("Array")) {
-      const prop_pattern = new RegExp(`(^\\s*${escape_regex(path4)}:\\s*)(.*)$`, "m");
-      if (prop_pattern.test(this._raw)) {
-        const replacement_value = effective_ref ?? value;
-        this._raw = this._raw.replace(prop_pattern, `$1${replacement_value}`);
+      const prop_pattern = new RegExp(`(^\\s*${escape_regex(path4)}:[ \\t]*)(.*)$`, "m");
+      const match = this._raw.match(prop_pattern);
+      if (match && match.index !== undefined) {
+        const replacement_value = effective_ref ?? yaml_quote_if_needed(value);
+        const current_inline = match[2];
+        if (current_inline.trim() === "") {
+          const key_indent = (match[0].match(/^[ \t]*/)?.[0] || "").length;
+          const after = match.index + match[0].length;
+          let end = after;
+          const rest = this._raw.slice(after);
+          const rest_lines = rest.split(`
+`);
+          for (let i = 1;i < rest_lines.length; i++) {
+            const line = rest_lines[i];
+            if (line.trim() === "") {
+              end += 1 + line.length;
+              continue;
+            }
+            const line_indent = (line.match(/^[ \t]*/)?.[0] || "").length;
+            if (line_indent > key_indent) {
+              end += 1 + line.length;
+            } else {
+              break;
+            }
+          }
+          const prefix = match[1].trimEnd() + " ";
+          this._raw = this._raw.slice(0, match.index) + prefix + replacement_value + this._raw.slice(end);
+        } else {
+          this._raw = this._raw.replace(prop_pattern, (_match, prefix) => prefix + replacement_value);
+        }
+      } else {
+        const insert_value = effective_ref ?? yaml_quote_if_needed(value);
+        this._insert_property(path4, insert_value);
       }
       return this._check_dirty(old_raw);
     }
@@ -2516,8 +2599,8 @@ class UnityBlock {
         const fields = inline_match[2];
         const field_pattern = new RegExp(`(${escape_regex(sub_field)}:\\s*)([^,}]+)`);
         if (field_pattern.test(fields)) {
-          const updated_fields = fields.replace(field_pattern, `$1${value}`);
-          this._raw = this._raw.replace(inline_pattern, `$1${updated_fields}$3`);
+          const updated_fields = fields.replace(field_pattern, (_m, prefix) => prefix + value);
+          this._raw = this._raw.replace(inline_pattern, (_m, g1, _g2, g3) => g1 + updated_fields + g3);
           inline_applied = true;
         }
       }
@@ -2526,6 +2609,8 @@ class UnityBlock {
         const block_result = this._resolve_block_style_path(parts, effective_value);
         if (block_result !== null) {
           this._raw = block_result;
+        } else if (parts.length === 2) {
+          this._insert_struct_property(parent_prop, sub_field, effective_value);
         }
       }
       return this._check_dirty(old_raw);
@@ -2543,7 +2628,7 @@ class UnityBlock {
 `).filter((l) => l.trim().startsWith("-"));
           if (index < lines.length) {
             const old_line = lines[index];
-            const new_line = old_line.replace(/-\s*.*/, `- ${ref_value}`);
+            const new_line = old_line.replace(/-\s*.*/, () => `- ${ref_value}`);
             this._raw = this._raw.replace(old_line, new_line);
           }
         }
@@ -2552,6 +2637,49 @@ class UnityBlock {
     }
     return false;
   }
+  _insert_property(path4, value) {
+    const alt = path4.startsWith("m_") ? path4.slice(2) : "m_" + path4;
+    const alt_pattern = new RegExp(`^\\s*${escape_regex(alt)}:`, "m");
+    if (alt_pattern.test(this._raw)) {
+      return;
+    }
+    const indented_line = `  ${path4}: ${value}`;
+    const eci_pattern = /^([ \t]*m_EditorClassIdentifier:[ \t]*[^\n]*)/m;
+    const eci_match = this._raw.match(eci_pattern);
+    if (eci_match && eci_match.index !== undefined) {
+      const insert_after = eci_match.index + eci_match[0].length;
+      this._raw = this._raw.slice(0, insert_after) + `
+` + indented_line + this._raw.slice(insert_after);
+      return;
+    }
+    this._raw = this._raw.trimEnd() + `
+` + indented_line + `
+`;
+  }
+  _insert_struct_property(parent, child, value) {
+    const parent_pattern = new RegExp(`^[ 	]*${escape_regex(parent)}:`, "m");
+    if (parent_pattern.test(this._raw)) {
+      return;
+    }
+    const alt = parent.startsWith("m_") ? parent.slice(2) : "m_" + parent;
+    const alt_pattern = new RegExp(`^[ \\t]*${escape_regex(alt)}:`, "m");
+    if (alt_pattern.test(this._raw)) {
+      return;
+    }
+    const struct_block = `  ${parent}:
+    ${child}: ${value}`;
+    const eci_pattern = /^([ \t]*m_EditorClassIdentifier:[ \t]*[^\n]*)/m;
+    const eci_match = this._raw.match(eci_pattern);
+    if (eci_match && eci_match.index !== undefined) {
+      const insert_after = eci_match.index + eci_match[0].length;
+      this._raw = this._raw.slice(0, insert_after) + `
+` + struct_block + this._raw.slice(insert_after);
+      return;
+    }
+    this._raw = this._raw.trimEnd() + `
+` + struct_block + `
+`;
+  }
   has_property(path4) {
     return this.get_property(path4) !== null;
   }
@@ -2607,7 +2735,7 @@ class UnityBlock {
     if (empty_match) {
       const base_indent = empty_match[2];
       const element_indent2 = base_indent + "  ";
-      this._raw = this._raw.replace(empty_pattern, `$1
+      this._raw = this._raw.replace(empty_pattern, (_m, g1) => `${g1}
 ${element_indent2}- ${value}`);
       return this._check_dirty(old_raw);
     }
@@ -2840,81 +2968,359 @@ ${element_indent2}- ${value}`);
     }
     return null;
   }
-  _resolve_block_style_path(segments, value) {
-    const lines = this._raw.split(`
+  _resolve_block_style_path(segments, value) {
+    const lines = this._raw.split(`
+`);
+    let search_start = 0;
+    let search_end = lines.length;
+    for (let seg = 0;seg < segments.length - 1; seg++) {
+      const segment = segments[seg];
+      let parent_idx = -1;
+      let parent_indent = -1;
+      for (let i = search_start;i < search_end; i++) {
+        const match = lines[i].match(new RegExp(`^(\\s*)${escape_regex(segment)}:\\s*(.*)$`));
+        if (match) {
+          const trailing = match[2].trim();
+          if (trailing === "") {
+            parent_idx = i;
+            parent_indent = match[1].length;
+            break;
+          }
+          for (let j = i + 1;j < search_end; j++) {
+            if (lines[j].trim() === "")
+              continue;
+            const nextLeading = lines[j].match(/^(\s*)/);
+            if (nextLeading && nextLeading[1].length > match[1].length) {
+              parent_idx = i;
+              parent_indent = match[1].length;
+            }
+            break;
+          }
+          if (parent_idx !== -1)
+            break;
+        }
+      }
+      if (parent_idx === -1)
+        return null;
+      let child_indent = -1;
+      for (let i = parent_idx + 1;i < search_end; i++) {
+        if (lines[i].trim() === "")
+          continue;
+        const leading_spaces = lines[i].match(/^(\s*)/);
+        if (leading_spaces) {
+          const indent = leading_spaces[1].length;
+          if (indent > parent_indent) {
+            child_indent = indent;
+            break;
+          }
+        }
+        break;
+      }
+      if (child_indent === -1)
+        return null;
+      search_start = parent_idx + 1;
+      for (let i = parent_idx + 1;i < search_end; i++) {
+        if (lines[i].trim() === "")
+          continue;
+        const leading_spaces = lines[i].match(/^(\s*)/);
+        if (leading_spaces && leading_spaces[1].length < child_indent) {
+          search_end = i;
+          break;
+        }
+      }
+    }
+    const final_prop = segments[segments.length - 1];
+    for (let i = search_start;i < search_end; i++) {
+      const match = lines[i].match(new RegExp(`^(\\s*${escape_regex(final_prop)}:\\s*).+$`));
+      if (match) {
+        lines[i] = match[1] + value;
+        return lines.join(`
+`);
+      }
+    }
+    return null;
+  }
+}
+
+// src/editor/yaml-fields.ts
+var PRIMITIVE_DEFAULTS = {
+  int: "0",
+  float: "0",
+  double: "0",
+  bool: "0",
+  string: "",
+  byte: "0",
+  sbyte: "0",
+  short: "0",
+  ushort: "0",
+  uint: "0",
+  long: "0",
+  ulong: "0",
+  char: "0",
+  Int32: "0",
+  Single: "0",
+  Double: "0",
+  Boolean: "0",
+  String: "",
+  Byte: "0",
+  SByte: "0",
+  Int16: "0",
+  UInt16: "0",
+  UInt32: "0",
+  Int64: "0",
+  UInt64: "0",
+  Char: "0"
+};
+var STRUCT_DEFAULTS = {
+  Vector2: "{x: 0, y: 0}",
+  Vector3: "{x: 0, y: 0, z: 0}",
+  Vector4: "{x: 0, y: 0, z: 0, w: 0}",
+  Vector2Int: "{x: 0, y: 0}",
+  Vector3Int: "{x: 0, y: 0, z: 0}",
+  Quaternion: "{x: 0, y: 0, z: 0, w: 1}",
+  Color: "{r: 0, g: 0, b: 0, a: 0}",
+  Color32: "{r: 0, g: 0, b: 0, a: 0}",
+  Rect: `serializedVersion: 2
+    x: 0
+    y: 0
+    width: 0
+    height: 0`,
+  RectInt: "{x: 0, y: 0, width: 0, height: 0}",
+  RectOffset: "{m_Left: 0, m_Right: 0, m_Top: 0, m_Bottom: 0}",
+  Matrix4x4: "{e00: 1, e01: 0, e02: 0, e03: 0, e10: 0, e11: 1, e12: 0, e13: 0, e20: 0, e21: 0, e22: 1, e23: 0, e30: 0, e31: 0, e32: 0, e33: 1}",
+  LayerMask: `serializedVersion: 2
+    m_Bits: 0`
+};
+var VERSION_GATED_STRUCT_DEFAULTS = {
+  Hash128: { value: `serializedVersion: 2
+    Hash: 00000000000000000000000000000000`, min_major: 2021, min_minor: 1 },
+  RenderingLayerMask: { value: `serializedVersion: 2
+    m_Bits: 0`, min_major: 6000, min_minor: 0 }
+};
+var BLOCK_STRUCT_DEFAULTS = {
+  Bounds: `m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 0, y: 0, z: 0}`,
+  BoundsInt: `m_Position: {x: 0, y: 0, z: 0}
+    m_Size: {x: 0, y: 0, z: 0}`
+};
+var OBJECT_REF_TYPES = new Set([
+  "GameObject",
+  "Transform",
+  "RectTransform",
+  "Material",
+  "Texture",
+  "Texture2D",
+  "Texture3D",
+  "RenderTexture",
+  "Sprite",
+  "AudioClip",
+  "VideoClip",
+  "Mesh",
+  "Shader",
+  "ComputeShader",
+  "AnimationClip",
+  "AnimatorController",
+  "RuntimeAnimatorController",
+  "PhysicMaterial",
+  "PhysicsMaterial",
+  "PhysicsMaterial2D",
+  "Font",
+  "TMP_FontAsset",
+  "Object",
+  "Component",
+  "Behaviour",
+  "MonoBehaviour",
+  "ScriptableObject",
+  "Rigidbody",
+  "Rigidbody2D",
+  "Collider",
+  "Collider2D",
+  "Camera",
+  "Light",
+  "Canvas",
+  "CanvasGroup",
+  "EventSystem",
+  "AudioSource",
+  "ParticleSystem",
+  "TextAsset",
+  "TerrainData"
+]);
+function version_at_least(version, min_major, min_minor) {
+  if (!version)
+    return false;
+  if (version.major > min_major)
+    return true;
+  if (version.major === min_major)
+    return version.minor >= min_minor;
+  return false;
+}
+function yaml_default_for_type(csharp_type, version) {
+  if (csharp_type.endsWith("?")) {
+    return null;
+  }
+  if (csharp_type in PRIMITIVE_DEFAULTS) {
+    return PRIMITIVE_DEFAULTS[csharp_type];
+  }
+  if (csharp_type in STRUCT_DEFAULTS) {
+    return STRUCT_DEFAULTS[csharp_type];
+  }
+  if (csharp_type in VERSION_GATED_STRUCT_DEFAULTS) {
+    const gated = VERSION_GATED_STRUCT_DEFAULTS[csharp_type];
+    if (version_at_least(version, gated.min_major, gated.min_minor)) {
+      return gated.value;
+    }
+    return null;
+  }
+  if (csharp_type in BLOCK_STRUCT_DEFAULTS) {
+    return BLOCK_STRUCT_DEFAULTS[csharp_type];
+  }
+  if (csharp_type.endsWith("[]")) {
+    return "[]";
+  }
+  if (csharp_type.startsWith("List<") && csharp_type.endsWith(">")) {
+    return "[]";
+  }
+  if (OBJECT_REF_TYPES.has(csharp_type)) {
+    return "{fileID: 0}";
+  }
+  return "{fileID: 0}";
+}
+function generate_field_yaml(fields, version, indent = "  ", type_lookup) {
+  const lines = [];
+  for (const field of fields) {
+    if (field.hasSerializeReference) {
+      const t = field.typeName;
+      if (t.endsWith("[]") || t.startsWith("List<") && t.endsWith(">")) {
+        lines.push(`${indent}${field.name}: []`);
+      } else {
+        lines.push(`${indent}${field.name}:`);
+        lines.push(`${indent}  rid: 0`);
+      }
+      continue;
+    }
+    const default_value = yaml_default_for_type(field.typeName, version);
+    if (default_value === null) {
+      continue;
+    }
+    if (default_value === "{fileID: 0}" && type_lookup) {
+      const struct_fields = type_lookup(field.typeName);
+      if (struct_fields && struct_fields.length > 0) {
+        lines.push(`${indent}${field.name}:`);
+        const nested = generate_field_yaml(struct_fields, version, indent + "  ", type_lookup);
+        const nested_lines = nested.slice(1).replace(/\n$/, "").split(`
 `);
-    let search_start = 0;
-    let search_end = lines.length;
-    for (let seg = 0;seg < segments.length - 1; seg++) {
-      const segment = segments[seg];
-      let parent_idx = -1;
-      let parent_indent = -1;
-      for (let i = search_start;i < search_end; i++) {
-        const match = lines[i].match(new RegExp(`^(\\s*)${escape_regex(segment)}:\\s*(.*)$`));
-        if (match) {
-          const trailing = match[2].trim();
-          if (trailing === "") {
-            parent_idx = i;
-            parent_indent = match[1].length;
-            break;
-          }
-          for (let j = i + 1;j < search_end; j++) {
-            if (lines[j].trim() === "")
-              continue;
-            const nextLeading = lines[j].match(/^(\s*)/);
-            if (nextLeading && nextLeading[1].length > match[1].length) {
-              parent_idx = i;
-              parent_indent = match[1].length;
-            }
-            break;
-          }
-          if (parent_idx !== -1)
-            break;
+        for (const nl of nested_lines) {
+          lines.push(nl);
         }
+        continue;
       }
-      if (parent_idx === -1)
-        return null;
-      let child_indent = -1;
-      for (let i = parent_idx + 1;i < search_end; i++) {
-        if (lines[i].trim() === "")
-          continue;
-        const leading_spaces = lines[i].match(/^(\s*)/);
-        if (leading_spaces) {
-          const indent = leading_spaces[1].length;
-          if (indent > parent_indent) {
-            child_indent = indent;
-            break;
-          }
-        }
-        break;
+    }
+    if (default_value.includes(`
+`)) {
+      lines.push(`${indent}${field.name}:`);
+      for (const sub_line of default_value.split(`
+`)) {
+        lines.push(`${indent}${sub_line}`);
       }
-      if (child_indent === -1)
-        return null;
-      search_start = parent_idx + 1;
-      for (let i = parent_idx + 1;i < search_end; i++) {
-        if (lines[i].trim() === "")
-          continue;
-        const leading_spaces = lines[i].match(/^(\s*)/);
-        if (leading_spaces && leading_spaces[1].length < child_indent) {
-          search_end = i;
-          break;
+    } else {
+      lines.push(`${indent}${field.name}: ${default_value}`);
+    }
+  }
+  return lines.length > 0 ? `
+` + lines.join(`
+`) + `
+` : `
+`;
+}
+function json_value_to_yaml_lines(value, indent = "  ") {
+  if (value === null || value === undefined) {
+    return [""];
+  }
+  if (typeof value === "string") {
+    return [yaml_quote_if_needed(value)];
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return ["[]"];
+    const lines = [];
+    for (const item of value) {
+      if (is_scalar(item) || is_empty_collection(item)) {
+        const scalar = json_value_to_yaml_lines(item);
+        lines.push(`${indent}- ${scalar[0]}`);
+      } else if (is_flow_mappable(item)) {
+        lines.push(`${indent}- ${to_flow_mapping(item)}`);
+      } else {
+        const child_lines = json_value_to_yaml_lines(item, indent + "  ");
+        lines.push(`${indent}- ${child_lines[0].trimStart()}`);
+        for (let i = 1;i < child_lines.length; i++) {
+          lines.push(child_lines[i]);
         }
       }
     }
-    const final_prop = segments[segments.length - 1];
-    for (let i = search_start;i < search_end; i++) {
-      const match = lines[i].match(new RegExp(`^(\\s*${escape_regex(final_prop)}:\\s*).+$`));
-      if (match) {
-        lines[i] = match[1] + value;
-        return lines.join(`
-`);
+    return lines;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+      return ["{}"];
+    const lines = [];
+    for (const [key, val] of entries) {
+      if (is_scalar(val) || is_empty_collection(val)) {
+        const scalar = json_value_to_yaml_lines(val);
+        lines.push(`${indent}${key}: ${scalar[0]}`);
+      } else if (is_flow_mappable(val)) {
+        lines.push(`${indent}${key}: ${to_flow_mapping(val)}`);
+      } else {
+        const child_indent = Array.isArray(val) ? indent : indent + "  ";
+        lines.push(`${indent}${key}:`);
+        const child_lines = json_value_to_yaml_lines(val, child_indent);
+        for (const cl of child_lines) {
+          lines.push(cl);
+        }
       }
     }
-    return null;
+    return lines;
   }
+  return [String(value)];
+}
+function is_scalar(value) {
+  return value === null || value === undefined || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function is_empty_collection(value) {
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (typeof value === "object" && value !== null)
+    return Object.keys(value).length === 0;
+  return false;
+}
+function is_flow_mappable(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const entries = Object.entries(value);
+  if (entries.length === 0)
+    return false;
+  return entries.every(([, v]) => is_scalar(v) || is_empty_collection(v));
+}
+function to_flow_mapping(obj) {
+  const parts = Object.entries(obj).map(([k, v]) => {
+    if (v === null || v === undefined)
+      return `${k}: `;
+    if (typeof v === "string")
+      return `${k}: ${yaml_quote_if_needed(v)}`;
+    if (Array.isArray(v) && v.length === 0)
+      return `${k}: []`;
+    if (typeof v === "object" && v !== null && Object.keys(v).length === 0)
+      return `${k}: {}`;
+    return `${k}: ${String(v)}`;
+  });
+  return `{${parts.join(", ")}}`;
 }
 
 // src/editor/unity-document.ts
+var import_fs9 = require("fs");
 class UnityDocument {
   file_path;
   _header;
@@ -3531,6 +3937,20 @@ function read_project_version(projectPath) {
 }
 
 // src/editor/create.ts
+function compute_dll_script_file_id(namespace, class_name) {
+  const { createHash } = require("crypto");
+  const full_name = namespace ? `${namespace}.${class_name}` : class_name;
+  const name_bytes = Buffer.from(full_name, "utf-8");
+  const input = Buffer.alloc(4 + name_bytes.length);
+  input.writeInt32LE(114, 0);
+  name_bytes.copy(input, 4);
+  const hash = createHash("md4").update(input).digest();
+  const a = hash.readInt32LE(0);
+  const b = hash.readInt32LE(4);
+  const c = hash.readInt32LE(8);
+  const d = hash.readInt32LE(12);
+  return a ^ b ^ c ^ d;
+}
 function get_layer_from_parent(doc, parentTransformId) {
   if (parentTransformId === "0")
     return 0;
@@ -3546,7 +3966,7 @@ function get_layer_from_parent(doc, parentTransformId) {
   const layerMatch = parentGo.raw.match(/m_Layer:\s*(\d+)/);
   return layerMatch ? parseInt(layerMatch[1], 10) : 0;
 }
-function createGameObjectYAML(gameObjectId, transformId, name, parentTransformId = 0, rootOrder = 0, layer = 0) {
+function createGameObjectYAML(gameObjectId, transformId, name, parentTransformId = "0", rootOrder = 0, layer = 0) {
   return `--- !u!1 &${gameObjectId}
 GameObject:
   m_ObjectHideFlags: 0
@@ -3607,9 +4027,9 @@ function findStrippedRootTransform(doc, prefabInstanceId) {
   for (const block of doc.blocks) {
     if (block.class_id !== 4 || !block.is_stripped)
       continue;
-    const piMatch = block.raw.match(/m_PrefabInstance:\s*\{fileID:\s*(\d+)\}/);
+    const piMatch = block.raw.match(/m_PrefabInstance:[ \t]*\{fileID:[ \t]*(-?\d+)\}/);
     if (piMatch && piMatch[1] === prefabInstanceId) {
-      const sourceMatch = block.raw.match(/m_CorrespondingSourceObject:\s*(\{[^}]+\})/);
+      const sourceMatch = block.raw.match(/m_CorrespondingSourceObject:[ \t]*(\{[^}]+\})/);
       if (sourceMatch) {
         return {
           transformId: block.file_id,
@@ -3620,6 +4040,66 @@ function findStrippedRootTransform(doc, prefabInstanceId) {
   }
   return null;
 }
+function find_game_object_in_variant(doc, name, file_path, project_path) {
+  const pi_blocks = doc.find_by_class_id(1001);
+  for (const pi_block of pi_blocks) {
+    const mod_pattern = /- target:[ \t]*(\{[^}]+\})\s*propertyPath:[ \t]*m_Name\s*value:[ \t]*([^\n]*)/g;
+    let mod_match;
+    while ((mod_match = mod_pattern.exec(pi_block.raw)) !== null) {
+      const target_ref = mod_match[1];
+      const mod_value = mod_match[2].trim();
+      if (mod_value !== name)
+        continue;
+      for (const block of doc.blocks) {
+        if (block.class_id !== 1 || !block.is_stripped)
+          continue;
+        const source_match = block.raw.match(/m_CorrespondingSourceObject:[ \t]*(\{[^}]+\})/);
+        if (!source_match)
+          continue;
+        const normalized_source = source_match[1].replace(/\s+/g, " ");
+        const normalized_target = target_ref.replace(/\s+/g, " ");
+        if (normalized_source === normalized_target) {
+          return {
+            stripped_go_id: block.file_id,
+            source_ref: target_ref,
+            prefab_instance_id: pi_block.file_id
+          };
+        }
+      }
+    }
+  }
+  const source_info = resolve_source_prefab(doc, file_path, project_path);
+  if (!source_info)
+    return null;
+  let source_doc;
+  try {
+    source_doc = UnityDocument.from_file(source_info.source_path);
+  } catch {
+    return null;
+  }
+  const source_gos = source_doc.find_game_objects_by_name(name);
+  if (source_gos.length !== 1)
+    return null;
+  const source_go = source_gos[0];
+  const source_go_file_id = source_go.file_id;
+  const source_guid = source_info.source_guid;
+  for (const block of doc.blocks) {
+    if (block.class_id !== 1 || !block.is_stripped)
+      continue;
+    const source_match = block.raw.match(/m_CorrespondingSourceObject:[ \t]*\{[^}]*fileID:[ \t]*(-?\d+)[^}]*guid:[ \t]*([a-f0-9]{32})/);
+    if (!source_match)
+      continue;
+    if (source_match[1] === source_go_file_id && source_match[2] === source_guid) {
+      const source_ref = `{fileID: ${source_go_file_id}, guid: ${source_guid}, type: 3}`;
+      return {
+        stripped_go_id: block.file_id,
+        source_ref,
+        prefab_instance_id: source_info.prefab_instance_id
+      };
+    }
+  }
+  return null;
+}
 function appendToAddedGameObjects(doc, piId, targetSourceRef, newGoId) {
   const piBlock = doc.find_by_file_id(piId);
   if (!piBlock)
@@ -3629,13 +4109,34 @@ function appendToAddedGameObjects(doc, piId, targetSourceRef, newGoId) {
       insertIndex: -1
       addedObject: {fileID: ${newGoId}}`;
   let raw = piBlock.raw;
-  const emptyPattern = /m_AddedGameObjects:\s*\[\]/;
+  const emptyPattern = /m_AddedGameObjects:[ \t]*\[\]/;
   if (emptyPattern.test(raw)) {
     raw = raw.replace(emptyPattern, `m_AddedGameObjects:${entry}`);
     piBlock.replace_raw(raw);
     return;
   }
-  const existingPattern = /(m_AddedGameObjects:\s*\n(?:\s+-[\s\S]*?(?=\n\s+m_|$))*)/;
+  const existingPattern = /(m_AddedGameObjects:[ \t]*\n(?:[ \t]+-[\s\S]*?(?=\n[ \t]+m_|$))*)/;
+  if (existingPattern.test(raw)) {
+    raw = raw.replace(existingPattern, `$1${entry}`);
+    piBlock.replace_raw(raw);
+  }
+}
+function appendToAddedComponents(doc, piId, targetSourceRef, newComponentId) {
+  const piBlock = doc.find_by_file_id(piId);
+  if (!piBlock)
+    return;
+  const entry = `
+    - targetCorrespondingSourceObject: ${targetSourceRef}
+      insertIndex: -1
+      addedObject: {fileID: ${newComponentId}}`;
+  let raw = piBlock.raw;
+  const emptyPattern = /m_AddedComponents:[ \t]*\[\]/;
+  if (emptyPattern.test(raw)) {
+    raw = raw.replace(emptyPattern, `m_AddedComponents:${entry}`);
+    piBlock.replace_raw(raw);
+    return;
+  }
+  const existingPattern = /(m_AddedComponents:[ \t]*\n(?:[ \t]+-[\s\S]*?(?=\n[ \t]+m_|$))*)/;
   if (existingPattern.test(raw)) {
     raw = raw.replace(existingPattern, `$1${entry}`);
     piBlock.replace_raw(raw);
@@ -3658,11 +4159,31 @@ var COMPONENT_DEFAULTS = {
   m_Materials:
   - {fileID: 0}`,
   33: `  m_Mesh: {fileID: 0}`,
+  50: `  m_BodyType: 0
+  m_Mass: 1
+  m_LinearDrag: 0
+  m_AngularDrag: 0.05
+  m_GravityScale: 1
+  m_Interpolate: 0
+  m_SleepingMode: 1
+  m_CollisionDetection: 0`,
   54: `  m_Mass: 1
   m_Drag: 0
   m_AngularDrag: 0.05
   m_UseGravity: 1
   m_IsKinematic: 0`,
+  58: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Radius: 0.5`,
+  60: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Points: []`,
+  61: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Size: {x: 1, y: 1}`,
   64: `  m_IsTrigger: 0
   m_Convex: 0
   m_CookingOptions: 30
@@ -3671,6 +4192,19 @@ var COMPONENT_DEFAULTS = {
   m_Material: {fileID: 0}
   m_Center: {x: 0, y: 0, z: 0}
   m_Size: {x: 1, y: 1, z: 1}`,
+  66: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_GeometryType: 0`,
+  68: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Points: []`,
+  70: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Size: {x: 1, y: 1}
+  m_Direction: 0`,
   82: `  m_PlayOnAwake: 1
   m_Volume: 1
   m_Pitch: 1
@@ -3756,9 +4290,14 @@ function addComponentToGameObject(doc, gameObjectId, componentId) {
 `);
   goBlock.replace_raw(raw);
 }
-function createMonoBehaviourYAML(componentId, gameObjectId, scriptGuid, fields, version) {
-  const field_yaml = fields && fields.length > 0 ? generate_field_yaml(fields, version) : `
+function createMonoBehaviourYAML(componentId, gameObjectId, scriptGuid, fields, version, scriptFileId = 11500000, type_lookup) {
+  const field_yaml = fields && fields.length > 0 ? generate_field_yaml(fields, version, "  ", type_lookup) : `
 `;
+  const has_serialize_ref = fields?.some((f) => f.hasSerializeReference) ?? false;
+  const references_section = has_serialize_ref ? `  references:
+    version: 2
+    RefIds: []
+` : "";
   return `--- !u!114 &${componentId}
 MonoBehaviour:
   m_ObjectHideFlags: 0
@@ -3768,9 +4307,9 @@ MonoBehaviour:
   m_GameObject: {fileID: ${gameObjectId}}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: ${scriptGuid}, type: 3}
+  m_Script: {fileID: ${scriptFileId}, guid: ${scriptGuid}, type: 3}
   m_Name:
-  m_EditorClassIdentifier:${field_yaml}`;
+  m_EditorClassIdentifier:${field_yaml}${references_section}`;
 }
 function createGameObject(options) {
   const { file_path, name, parent } = options;
@@ -3869,9 +4408,9 @@ function createGameObject(options) {
   const layer = get_layer_from_parent(doc, parentTransformIdStr);
   const gameObjectIdStr = doc.generate_file_id();
   const transformIdStr = doc.generate_file_id();
-  const gameObjectId = parseInt(gameObjectIdStr, 10);
-  const transformId = parseInt(transformIdStr, 10);
-  const parentTransformId = parseInt(parentTransformIdStr, 10);
+  const gameObjectId = gameObjectIdStr;
+  const transformId = transformIdStr;
+  const parentTransformId = parentTransformIdStr;
   const newBlocks = createGameObjectYAML(gameObjectId, transformId, name.trim(), parentTransformId, rootOrder, layer);
   doc.append_raw(newBlocks);
   if (parentTransformIdStr !== "0" && !variantPiId) {
@@ -3893,7 +4432,7 @@ function createGameObject(options) {
     file_path,
     game_object_id: gameObjectId,
     transform_id: transformId,
-    prefab_instance_id: variantPiId ? parseInt(variantPiId, 10) : undefined
+    prefab_instance_id: variantPiId || undefined
   };
 }
 function createScene(options) {
@@ -4339,9 +4878,9 @@ function createPrefabVariant(options) {
   const tempDoc = UnityDocument.from_string(`%YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
 `);
-  const prefabInstanceId = parseInt(tempDoc.generate_file_id(), 10);
-  const strippedGoId = parseInt(tempDoc.generate_file_id(), 10);
-  const strippedTransformId = parseInt(tempDoc.generate_file_id(), 10);
+  const prefabInstanceId = tempDoc.generate_file_id();
+  const strippedGoId = tempDoc.generate_file_id();
+  const strippedTransformId = tempDoc.generate_file_id();
   const finalName = variant_name || `${rootInfo.name} Variant`;
   const variantYaml = `%YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
@@ -4455,9 +4994,10 @@ function createScriptableObject(options) {
     } catch {}
   }
   const baseName = path5.basename(output_path, ".asset");
-  const field_yaml = resolved.fields && resolved.fields.length > 0 ? generate_field_yaml(resolved.fields, version) : `
+  const type_lookup = project_path ? build_type_lookup(project_path) : undefined;
+  const field_yaml = resolved.fields && resolved.fields.length > 0 ? generate_field_yaml(resolved.fields, version, "  ", type_lookup) : `
 `;
-  const assetYaml = `%YAML 1.1
+  let assetYaml = `%YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
 --- !u!114 &11400000
 MonoBehaviour:
@@ -4471,6 +5011,66 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: ${resolved.guid}, type: 3}
   m_Name: ${baseName}
   m_EditorClassIdentifier:${field_yaml}`;
+  if (options.initial_values && Object.keys(options.initial_values).length > 0) {
+    const doc = UnityDocument.from_string(assetYaml);
+    const block = doc.blocks[0];
+    if (block) {
+      const complex_entries = [];
+      for (const [key, val] of Object.entries(options.initial_values)) {
+        if (val === null || val === undefined || typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+          block.set_property(key, String(val ?? ""));
+        } else if (Array.isArray(val) && val.length === 0) {
+          block.set_property(key, "[]");
+        } else if (typeof val === "object" && val !== null && !Array.isArray(val) && Object.keys(val).length === 0) {
+          block.set_property(key, "{}");
+        } else {
+          complex_entries.push([key, val]);
+        }
+      }
+      if (complex_entries.length > 0) {
+        let raw = block.raw;
+        for (const [key, val] of complex_entries) {
+          const yaml_lines = json_value_to_yaml_lines(val, "    ");
+          const key_pattern = new RegExp(`^([ \\t]*${key}:)[^\\n]*$`, "m");
+          const key_match = raw.match(key_pattern);
+          if (key_match && key_match.index !== undefined) {
+            const key_indent = key_match[0].match(/^[ \t]*/)?.[0].length ?? 0;
+            const after_key = key_match.index + key_match[0].length;
+            let end = after_key;
+            const remaining = raw.slice(after_key);
+            const remaining_lines = remaining.split(`
+`);
+            for (let i = 1;i < remaining_lines.length; i++) {
+              const line = remaining_lines[i];
+              if (line.trim() === "") {
+                end += 1 + line.length;
+                continue;
+              }
+              const line_indent = line.match(/^[ \t]*/)?.[0].length ?? 0;
+              if (line_indent > key_indent) {
+                end += 1 + line.length;
+              } else {
+                break;
+              }
+            }
+            const block_yaml = `  ${key}:
+${yaml_lines.join(`
+`)}`;
+            raw = raw.slice(0, key_match.index) + block_yaml + raw.slice(end);
+          } else {
+            const block_yaml = `  ${key}:
+${yaml_lines.join(`
+`)}`;
+            raw = raw.trimEnd() + `
+` + block_yaml + `
+`;
+          }
+        }
+        block.replace_raw(raw);
+      }
+      assetYaml = doc.serialize();
+    }
+  }
   try {
     import_fs10.writeFileSync(output_path, assetYaml, "utf-8");
   } catch (err) {
@@ -4551,6 +5151,80 @@ MonoImporter:
     guid
   };
 }
+var COMPONENT_BASE_CLASSES = new Set([
+  "MonoBehaviour",
+  "NetworkBehaviour",
+  "StateMachineBehaviour"
+]);
+function is_valid_component_base(base_class, project_path, depth = 0) {
+  if (depth > 5)
+    return false;
+  if (COMPONENT_BASE_CLASSES.has(base_class))
+    return true;
+  if (!project_path)
+    return false;
+  const registryPath = path5.join(project_path, ".unity-agentic", "type-registry.json");
+  if (import_fs10.existsSync(registryPath)) {
+    try {
+      const registry = JSON.parse(import_fs10.readFileSync(registryPath, "utf-8"));
+      const match = registry.find((t) => t.name === base_class && t.kind === "class");
+      if (match?.filePath) {
+        const fullPath = path5.isAbsolute(match.filePath) ? match.filePath : path5.join(project_path, match.filePath);
+        if (fullPath.endsWith(".cs") && import_fs10.existsSync(fullPath)) {
+          const { getNativeExtractSerializedFields: getNativeExtractSerializedFields2 } = (init_scanner(), __toCommonJS(exports_scanner));
+          const extract = getNativeExtractSerializedFields2();
+          if (extract) {
+            const typeInfos = extract(fullPath);
+            const info = typeInfos?.find((t) => t.name === base_class);
+            if (info?.baseClass) {
+              return is_valid_component_base(info.baseClass, project_path, depth + 1);
+            }
+          }
+        }
+        if (!fullPath.endsWith(".cs") || !import_fs10.existsSync(fullPath)) {
+          if (match.kind === "class") {
+            return is_likely_component_base_name(base_class);
+          }
+        }
+      }
+    } catch {}
+  }
+  const cachePaths = [
+    path5.join(project_path, ".unity-agentic", "package-cache.json"),
+    path5.join(project_path, ".unity-agentic", "local-package-cache.json")
+  ];
+  for (const cachePath of cachePaths) {
+    if (!import_fs10.existsSync(cachePath))
+      continue;
+    try {
+      const cache = JSON.parse(import_fs10.readFileSync(cachePath, "utf-8"));
+      const baseClassLower = base_class.toLowerCase();
+      for (const [, assetPath] of Object.entries(cache)) {
+        if (!assetPath.endsWith(".cs"))
+          continue;
+        if (path5.basename(assetPath, ".cs").toLowerCase() !== baseClassLower)
+          continue;
+        const fullPath = path5.join(project_path, assetPath);
+        if (!import_fs10.existsSync(fullPath))
+          continue;
+        const { getNativeExtractSerializedFields: getNativeExtractSerializedFields2 } = (init_scanner(), __toCommonJS(exports_scanner));
+        const extract = getNativeExtractSerializedFields2();
+        if (!extract)
+          continue;
+        const typeInfos = extract(fullPath);
+        const info = typeInfos?.find((t) => t.name === base_class);
+        if (info?.baseClass) {
+          return is_valid_component_base(info.baseClass, project_path, depth + 1);
+        }
+      }
+    } catch {}
+  }
+  return false;
+}
+function is_likely_component_base_name(name) {
+  const lower = name.toLowerCase();
+  return lower.endsWith("behaviour") || lower.endsWith("behavior") || lower.includes("monobehaviour") || lower.includes("networkbehaviour");
+}
 function addComponent(options) {
   const { file_path, game_object_name, component_type } = options;
   const project_path = options.project_path || find_unity_project_root(path5.dirname(file_path)) || undefined;
@@ -4576,11 +5250,19 @@ function addComponent(options) {
     };
   }
   const goResult = doc.require_unique_game_object(game_object_name);
+  let gameObjectIdStr;
+  let variantInfo = null;
   if ("error" in goResult) {
-    return { success: false, file_path, error: goResult.error };
+    const vResult = find_game_object_in_variant(doc, game_object_name, file_path, project_path);
+    if (!vResult) {
+      return { success: false, file_path, error: goResult.error };
+    }
+    gameObjectIdStr = vResult.stripped_go_id;
+    variantInfo = { source_ref: vResult.source_ref, prefab_instance_id: vResult.prefab_instance_id };
+  } else {
+    gameObjectIdStr = goResult.file_id;
   }
-  const gameObjectIdStr = goResult.file_id;
-  const gameObjectId = parseInt(gameObjectIdStr, 10);
+  const gameObjectId = gameObjectIdStr;
   const classId = get_class_id(component_type);
   let duplicateWarning;
   const goBlock = doc.find_by_file_id(gameObjectIdStr);
@@ -4595,7 +5277,7 @@ function addComponent(options) {
     }
   }
   const componentIdStr = doc.generate_file_id();
-  const componentId = parseInt(componentIdStr, 10);
+  const componentId = componentIdStr;
   let componentYAML;
   let scriptGuid;
   let scriptPath;
@@ -4604,7 +5286,16 @@ function addComponent(options) {
     const componentName = UNITY_CLASS_IDS[classId] || component_type;
     componentYAML = createGenericComponentYAML(componentName, classId, componentId, gameObjectId);
   } else {
-    const resolved = resolve_script_with_fields(component_type, project_path);
+    let resolved;
+    try {
+      resolved = resolve_script_with_fields(component_type, project_path);
+    } catch (e) {
+      return {
+        success: false,
+        file_path,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
     if (!resolved) {
       const hints = [];
       if (project_path) {
@@ -4631,11 +5322,11 @@ function addComponent(options) {
         error: `"${component_type}" is ${resolved.kind === "enum" ? "an enum" : "an interface"}, not a MonoBehaviour. Cannot add as a component.`
       };
     }
-    if (resolved.base_class && !["MonoBehaviour", "NetworkBehaviour", "StateMachineBehaviour"].includes(resolved.base_class)) {
+    if (resolved.base_class && !COMPONENT_BASE_CLASSES.has(resolved.base_class) && !is_valid_component_base(resolved.base_class, project_path)) {
       return {
         success: false,
         file_path,
-        error: `"${component_type}" extends ${resolved.base_class}, not MonoBehaviour. Cannot add as a component.`
+        error: `"${component_type}" extends ${resolved.base_class}, which does not inherit from MonoBehaviour. Cannot add as a component. If this is incorrect, ensure the type registry is up to date ("setup" command).`
       };
     }
     let version;
@@ -4644,12 +5335,21 @@ function addComponent(options) {
         version = read_project_version(project_path);
       } catch {}
     }
-    componentYAML = createMonoBehaviourYAML(componentId, gameObjectId, resolved.guid, resolved.fields, version);
+    let scriptFileId = 11500000;
+    if (resolved.path?.endsWith(".dll") && resolved.class_name) {
+      scriptFileId = compute_dll_script_file_id(resolved.namespace ?? "", resolved.class_name);
+    }
+    const type_lookup_comp = project_path ? build_type_lookup(project_path) : undefined;
+    componentYAML = createMonoBehaviourYAML(componentId, gameObjectId, resolved.guid, resolved.fields, version, scriptFileId, type_lookup_comp);
     scriptGuid = resolved.guid;
     scriptPath = resolved.path || undefined;
     extractionError = resolved.extraction_error;
   }
-  addComponentToGameObject(doc, gameObjectIdStr, componentIdStr);
+  if (variantInfo) {
+    appendToAddedComponents(doc, variantInfo.prefab_instance_id, variantInfo.source_ref, componentIdStr);
+  } else {
+    addComponentToGameObject(doc, gameObjectIdStr, componentIdStr);
+  }
   doc.append_raw(componentYAML);
   const saveResult = doc.save();
   if (!saveResult.success) {
@@ -4726,6 +5426,14 @@ function copyComponent(options) {
 }
 // src/editor/update.ts
 var import_fs11 = require("fs");
+function enrich_target_ref(targetRef, blockRaw) {
+  if (/guid:/.test(targetRef))
+    return targetRef;
+  const sourceMatch = blockRaw.match(/m_SourcePrefab:[ \t]*\{[^}]*guid:[ \t]*([a-f0-9]{32})/);
+  if (!sourceMatch)
+    return null;
+  return targetRef.replace(/\}$/, `, guid: ${sourceMatch[1]}, type: 3}`);
+}
 function eulerToQuaternion(euler) {
   const deg2rad = Math.PI / 180;
   const x = euler.x * deg2rad;
@@ -4748,6 +5456,9 @@ function validate_value_type(current_value, new_value) {
   const current = current_value.trim();
   const incoming = new_value.trim();
   if (/^\{fileID:/.test(current)) {
+    if (/^\{fileID:[ \t]*0[ \t]*\}$/.test(current)) {
+      return null;
+    }
     if (!/^\{fileID:/.test(incoming)) {
       return `Expected a reference value ({fileID: ...}), got "${incoming}"`;
     }
@@ -4932,10 +5643,10 @@ function safeUnityYAMLEdit(filePath, objectName, propertyName, newValue, project
   const propertyPattern = new RegExp(`(^\\s*m_${normalizedProperty}:\\s*)([^\\n]*)`, "m");
   let updatedRaw = targetBlock.raw;
   if (propertyPattern.test(updatedRaw)) {
-    updatedRaw = updatedRaw.replace(propertyPattern, `$1${newValue}`);
+    updatedRaw = updatedRaw.replace(propertyPattern, (_m, prefix) => prefix + newValue);
   } else {
-    updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, `
-  m_${normalizedProperty}: ${newValue}$1$2`);
+    updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, (_m, g1, g2) => `
+  m_${normalizedProperty}: ${newValue}${g1}${g2}`);
   }
   targetBlock.replace_raw(updatedRaw);
   const saveResult = doc.save();
@@ -5021,7 +5732,9 @@ function editComponentByFileId(options) {
       };
     }
   }
-  const currentValue = targetBlock.get_property(exactProperty) ?? (exactProperty !== prefixedProperty ? targetBlock.get_property(prefixedProperty) : null);
+  const exactValue = targetBlock.get_property(exactProperty);
+  const resolvedProperty = exactValue !== null ? exactProperty : exactProperty !== prefixedProperty && targetBlock.get_property(prefixedProperty) !== null ? prefixedProperty : null;
+  const currentValue = exactValue ?? (resolvedProperty === prefixedProperty ? targetBlock.get_property(prefixedProperty) : null);
   if (currentValue !== null) {
     const typeError = validate_value_type(currentValue, new_value);
     if (typeError) {
@@ -5032,9 +5745,14 @@ function editComponentByFileId(options) {
       };
     }
   }
-  let modified = targetBlock.set_property(exactProperty, new_value, "{fileID: 0}");
-  if (!modified && exactProperty !== prefixedProperty) {
-    modified = targetBlock.set_property(prefixedProperty, new_value, "{fileID: 0}");
+  let modified;
+  if (resolvedProperty) {
+    modified = targetBlock.set_property(resolvedProperty, new_value, "{fileID: 0}");
+  } else {
+    modified = targetBlock.set_property(exactProperty, new_value, "{fileID: 0}");
+    if (!modified && exactProperty !== prefixedProperty) {
+      modified = targetBlock.set_property(prefixedProperty, new_value, "{fileID: 0}");
+    }
   }
   if (!modified) {
     if (currentValue !== null) {
@@ -5071,8 +5789,10 @@ function editComponentByFileId(options) {
   };
 }
 function editPrefabOverride(options) {
-  const { file_path, prefab_instance, property_path, new_value, object_reference, target } = options;
-  const objRef = object_reference ?? "{fileID: 0}";
+  const { file_path, prefab_instance, new_value, object_reference, target, managed_reference } = options;
+  const property_path = /[\[\]]/.test(options.property_path) && !options.property_path.startsWith("'") ? `'${options.property_path}'` : options.property_path;
+  const effectiveValue = managed_reference ?? new_value;
+  const objRef = managed_reference ? "{fileID: 0}" : object_reference ?? "{fileID: 0}";
   if (!import_fs11.existsSync(file_path)) {
     return { success: false, file_path, error: `File not found: ${file_path}` };
   }
@@ -5086,11 +5806,16 @@ function editPrefabOverride(options) {
   if (!targetBlock) {
     return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
   }
-  const escapedPath = property_path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const entryPattern = new RegExp(`(- target:\\s*\\{[^}]+\\}\\s*\\n\\s*propertyPath:\\s*)${escapedPath}(\\s*\\n\\s*value:\\s*)(.*)(\\s*\\n\\s*objectReference:\\s*)(.*)`, "m");
+  const unquotedPath = property_path.replace(/^'|'$/g, "");
+  const quotedPath = `'${unquotedPath}'`;
+  const escapedUnquoted = unquotedPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const escapedQuoted = quotedPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pathAlternation = escapedUnquoted === escapedQuoted ? escapedUnquoted : `(?:${escapedQuoted}|${escapedUnquoted})`;
+  const entryPattern = new RegExp(`(- target:\\s*\\{[^}]+\\}\\s*\\n\\s*propertyPath:\\s*)${pathAlternation}(\\s*\\n\\s*value:\\s*)(.*)(\\s*\\n\\s*objectReference:\\s*)(.*)`, "m");
   const entryMatch = targetBlock.raw.match(entryPattern);
   if (entryMatch) {
-    const updatedText2 = targetBlock.raw.replace(entryPattern, `$1${property_path}$2${new_value}$4${objRef}`);
+    const quotedValue = yaml_quote_if_needed(effectiveValue);
+    const updatedText2 = targetBlock.raw.replace(entryPattern, (_m, g1, g2, _g3, g4) => g1 + property_path + g2 + quotedValue + g4 + objRef);
     targetBlock.replace_raw(updatedText2);
     const saveResult2 = doc.save();
     if (!saveResult2.success) {
@@ -5127,9 +5852,13 @@ function editPrefabOverride(options) {
       error: `Invalid target reference "${targetRef}". Expected format: {fileID: N, guid: ..., type: T}`
     };
   }
+  const enriched = enrich_target_ref(targetRef, targetBlock.raw);
+  if (enriched)
+    targetRef = enriched;
+  const quotedNewValue = yaml_quote_if_needed(effectiveValue);
   const newEntry = `    - target: ${targetRef}
       propertyPath: ${property_path}
-      value: ${new_value}
+      value: ${quotedNewValue}
       objectReference: ${objRef}`;
   const removedPattern = /(\n\s*m_RemovedComponents:)/m;
   const removedMatch = targetBlock.raw.match(removedPattern);
@@ -5272,10 +6001,10 @@ function batchEditProperties(filePath, edits) {
       const propertyPattern = new RegExp(`(^\\s*m_${normalizedProperty}:\\s*)([^\\n]*)`, "m");
       let updatedRaw = targetBlock.raw;
       if (propertyPattern.test(updatedRaw)) {
-        updatedRaw = updatedRaw.replace(propertyPattern, `$1${edit.new_value}`);
+        updatedRaw = updatedRaw.replace(propertyPattern, (_m, prefix) => prefix + edit.new_value);
       } else {
-        updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, `
-  m_${normalizedProperty}: ${edit.new_value}$1$2`);
+        updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, (_m, g1, g2) => `
+  m_${normalizedProperty}: ${edit.new_value}${g1}${g2}`);
       }
       targetBlock.replace_raw(updatedRaw);
     }
@@ -5380,9 +6109,9 @@ function reparentGameObject(options) {
   return {
     success: true,
     file_path,
-    child_transform_id: parseInt(childTransformId, 10),
-    old_parent_transform_id: parseInt(oldParentTransformId, 10),
-    new_parent_transform_id: parseInt(newParentTransformId, 10)
+    child_transform_id: childTransformId,
+    old_parent_transform_id: oldParentTransformId,
+    new_parent_transform_id: newParentTransformId
   };
 }
 function findPrefabInstanceBlock(doc, identifier) {
@@ -5751,9 +6480,9 @@ function removeRemovedGameObject(options) {
   if (!doc.validate()) {
     return { success: false, file_path, error: "Validation failed after removing GameObject" };
   }
-  const saveResult = doc.save();
-  if (!saveResult.success) {
-    return { success: false, file_path, error: saveResult.error };
+  const restoreGoSaveResult = doc.save();
+  if (!restoreGoSaveResult.success) {
+    return { success: false, file_path, error: restoreGoSaveResult.error };
   }
   return {
     success: true,
@@ -5793,7 +6522,8 @@ function removeComponent(options) {
     const parentGoId = goMatch[1];
     const goBlock = doc.find_by_file_id(parentGoId);
     if (goBlock) {
-      const compLinePattern = new RegExp(`\\s*- component: \\{fileID: ${file_id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\}\\n?`);
+      const escaped = file_id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const compLinePattern = new RegExp(`^[ \\t]*- component: \\{fileID: ${escaped}\\}[ \\t]*\\n`, "m");
       const modifiedRaw = goBlock.raw.replace(compLinePattern, "");
       goBlock.replace_raw(modifiedRaw);
     }