unity-agentic-tools 0.3.1 → 0.3.2

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.2",
     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";
@@ -2391,6 +2549,16 @@ function yaml_default_for_type(csharp_type, version) {
 function generate_field_yaml(fields, version, indent = "  ") {
   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;
@@ -2434,6 +2602,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 +2648,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 +2675,17 @@ 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 replacement_value = effective_ref ?? yaml_quote_if_needed(value);
+        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 +2700,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 +2710,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 +2729,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 +2738,44 @@ 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 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 +2831,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);
     }
@@ -3531,6 +3755,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 +3784,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 +3845,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 +3858,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 +3927,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 +3977,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 +4010,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 +4108,14 @@ function addComponentToGameObject(doc, gameObjectId, componentId) {
 `);
   goBlock.replace_raw(raw);
 }
-function createMonoBehaviourYAML(componentId, gameObjectId, scriptGuid, fields, version) {
+function createMonoBehaviourYAML(componentId, gameObjectId, scriptGuid, fields, version, scriptFileId = 11500000) {
   const field_yaml = fields && fields.length > 0 ? generate_field_yaml(fields, version) : `
 `;
+  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 +4125,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 +4226,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 +4250,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 +4696,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:
@@ -4457,7 +4814,7 @@ function createScriptableObject(options) {
   const baseName = path5.basename(output_path, ".asset");
   const field_yaml = resolved.fields && resolved.fields.length > 0 ? generate_field_yaml(resolved.fields, version) : `
 `;
-  const assetYaml = `%YAML 1.1
+  let assetYaml = `%YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
 --- !u!114 &11400000
 MonoBehaviour:
@@ -4471,6 +4828,16 @@ 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) {
+      for (const [key, val] of Object.entries(options.initial_values)) {
+        block.set_property(key, val);
+      }
+      assetYaml = doc.serialize();
+    }
+  }
   try {
     import_fs10.writeFileSync(output_path, assetYaml, "utf-8");
   } catch (err) {
@@ -4551,6 +4918,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 +5017,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 +5044,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 +5053,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 +5089,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 +5102,20 @@ 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);
+    }
+    componentYAML = createMonoBehaviourYAML(componentId, gameObjectId, resolved.guid, resolved.fields, version, scriptFileId);
     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 +5192,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 +5222,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 +5409,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 +5498,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 +5511,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 +5555,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 +5572,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 +5618,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 +5767,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 +5875,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 +6246,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 +6288,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);
     }