unity-agentic-tools 0.2.0 → 0.3.0

package/dist/index.js

@@ -5,48 +5,202 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/scanner.ts
+var exports_scanner = {};
+__export(exports_scanner, {
+  isNativeModuleAvailable: () => isNativeModuleAvailable,
+  getNativeWalkProjectFiles: () => getNativeWalkProjectFiles,
+  getNativeModuleError: () => getNativeModuleError,
+  getNativeGrepProject: () => getNativeGrepProject,
+  getNativeExtractSerializedFields: () => getNativeExtractSerializedFields,
+  getNativeExtractDllTypes: () => getNativeExtractDllTypes,
+  getNativeExtractDllFields: () => getNativeExtractDllFields,
+  getNativeExtractCsharpTypes: () => getNativeExtractCsharpTypes,
+  getNativeBuildTypeRegistry: () => getNativeBuildTypeRegistry,
+  getNativeBuildPackageGuidCache: () => getNativeBuildPackageGuidCache,
+  getNativeBuildGuidCache: () => getNativeBuildGuidCache,
+  UnityScanner: () => UnityScanner
+});
+function isNativeModuleAvailable() {
+  return RustScanner !== null;
+}
+function getNativeModuleError() {
+  return nativeModuleError;
+}
+
+class UnityScanner {
+  scanner;
+  constructor() {
+    if (!RustScanner) {
+      throw new Error(nativeModuleError || "Native module not available");
+    }
+    this.scanner = new RustScanner;
+  }
+  setProjectRoot(path) {
+    this.scanner.setProjectRoot(path);
+  }
+  scan_scene_minimal(file) {
+    return this.scanner.scanSceneMinimal(file);
+  }
+  scan_scene_with_components(file, options) {
+    return this.scanner.scanSceneWithComponents(file, options);
+  }
+  scan_scene_metadata(file) {
+    return this.scanner.scanSceneMetadata(file);
+  }
+  find_by_name(file, pattern, fuzzy = true) {
+    return this.scanner.findByName(file, pattern, fuzzy);
+  }
+  inspect(options) {
+    return this.scanner.inspect({
+      file: options.file,
+      identifier: options.identifier,
+      includeProperties: options.include_properties,
+      verbose: options.verbose
+    });
+  }
+  inspect_all(file, include_properties = false, verbose = false) {
+    return this.scanner.inspectAll(file, include_properties, verbose);
+  }
+  inspect_all_paginated(options) {
+    return this.scanner.inspectAllPaginated({
+      file: options.file,
+      includeProperties: options.include_properties,
+      verbose: options.verbose,
+      pageSize: options.page_size,
+      cursor: options.cursor,
+      maxDepth: options.max_depth,
+      filterComponent: options.filter_component
+    });
+  }
+  read_asset(file, decode_mesh) {
+    return this.scanner.readAsset(file, decode_mesh);
+  }
+}
+function getNativeWalkProjectFiles() {
+  return nativeWalkProjectFiles;
+}
+function getNativeGrepProject() {
+  return nativeGrepProject;
+}
+function getNativeBuildGuidCache() {
+  return nativeBuildGuidCache;
+}
+function getNativeExtractCsharpTypes() {
+  return nativeExtractCsharpTypes;
+}
+function getNativeBuildTypeRegistry() {
+  return nativeBuildTypeRegistry;
+}
+function getNativeExtractDllTypes() {
+  return nativeExtractDllTypes;
+}
+function getNativeBuildPackageGuidCache() {
+  return nativeBuildPackageGuidCache;
+}
+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 init_scanner = __esm(() => {
+  import_module = require("module");
+  import_fs = require("fs");
+  import_path = require("path");
+  try {
+    const scriptDir = process.argv[1] ? import_path.dirname(import_path.resolve(process.argv[1])) : __dirname;
+    let rustModule;
+    const nativeLoaderPath = import_path.join(scriptDir, "..", "native", "index.js");
+    if (import_fs.existsSync(nativeLoaderPath)) {
+      const nativeRequire = import_module.createRequire(nativeLoaderPath);
+      rustModule = nativeRequire(nativeLoaderPath);
+    } else {
+      const wsRequire = import_module.createRequire(import_path.join(scriptDir, "_"));
+      rustModule = wsRequire("unity-file-tools");
+    }
+    RustScanner = rustModule.Scanner;
+    nativeWalkProjectFiles = rustModule.walkProjectFiles || null;
+    nativeGrepProject = rustModule.grepProject || null;
+    nativeBuildGuidCache = rustModule.buildGuidCache || null;
+    nativeExtractCsharpTypes = rustModule.extractCsharpTypes || null;
+    nativeBuildTypeRegistry = rustModule.buildTypeRegistry || null;
+    nativeExtractDllTypes = rustModule.extractDllTypes || null;
+    nativeBuildPackageGuidCache = rustModule.buildPackageGuidCache || null;
+    nativeExtractSerializedFields = rustModule.extractSerializedFields || null;
+    nativeExtractDllFields = rustModule.extractDllFields || null;
+  } catch (err) {
+    nativeModuleError = `Failed to load native Rust module.
+` + `Run: bun install (in the project root)
+` + `Original error: ${err.message}`;
+  }
+});
 
 // package.json
 var require_package = __commonJS((exports2, module2) => {
   module2.exports = {
     name: "unity-agentic-tools",
     packageManager: "bun@latest",
-    version: "0.2.0",
+    version: "0.3.0",
     description: "Fast, token-efficient Unity YAML parser for AI agents",
     exports: {
       ".": {
@@ -111,126 +265,72 @@ var require_package = __commonJS((exports2, module2) => {
 });
 
 // src/index.ts
+init_scanner();
 var exports_src = {};
 __export(exports_src, {
+  yaml_default_for_type: () => yaml_default_for_type,
   walk_project_files: () => walk_project_files,
+  validateUnityYAML: () => validateUnityYAML,
+  unpackPrefab: () => unpackPrefab,
   setup: () => setup,
   search_project: () => search_project,
+  resolve_script_with_fields: () => resolve_script_with_fields,
+  reparentGameObject: () => reparentGameObject,
+  removeRemovedGameObject: () => removeRemovedGameObject,
+  removeRemovedComponent: () => removeRemovedComponent,
+  removePrefabOverride: () => removePrefabOverride,
+  removeComponent: () => removeComponent,
   read_settings: () => read_settings,
   isNativeModuleAvailable: () => isNativeModuleAvailable,
   grep_project: () => grep_project,
   getNativeModuleError: () => getNativeModuleError,
+  getNativeExtractDllTypes: () => getNativeExtractDllTypes,
+  getNativeExtractCsharpTypes: () => getNativeExtractCsharpTypes,
+  getNativeBuildTypeRegistry: () => getNativeBuildTypeRegistry,
+  generate_field_yaml: () => generate_field_yaml,
   generateGuid: () => generateGuid,
+  find_unity_project_root: () => find_unity_project_root,
   edit_tag: () => edit_tag,
   edit_sorting_layer: () => edit_sorting_layer,
   edit_settings: () => edit_settings,
   edit_layer: () => edit_layer,
+  editTransform: () => editTransform,
+  editProperty: () => editProperty,
+  editPrefabOverride: () => editPrefabOverride,
+  editComponentByFileId: () => editComponentByFileId,
+  editArray: () => editArray,
+  duplicateGameObject: () => duplicateGameObject,
+  deletePrefabInstance: () => deletePrefabInstance,
+  deleteGameObject: () => deleteGameObject,
+  createScriptableObject: () => createScriptableObject,
   createScene: () => createScene,
+  createPrefabVariant: () => createPrefabVariant,
+  createMetaFile: () => createMetaFile,
+  createGameObject: () => createGameObject,
+  copyComponent: () => copyComponent,
   cleanup: () => cleanup,
+  batchEditProperties: () => batchEditProperties,
+  batchEditComponentProperties: () => batchEditComponentProperties,
   atomicWrite: () => atomicWrite,
-  UnityScanner: () => UnityScanner
+  addRemovedGameObject: () => addRemovedGameObject,
+  addRemovedComponent: () => addRemovedComponent,
+  addComponent: () => addComponent,
+  UnityScanner: () => UnityScanner,
+  UnityDocument: () => UnityDocument,
+  UnityBlock: () => UnityBlock
 });
 module.exports = __toCommonJS(exports_src);
 
-// src/scanner.ts
-var import_module = require("module");
-var import_fs = require("fs");
-var import_path = require("path");
-var __dirname = "/home/runner/work/unity-agentic-tools/unity-agentic-tools/unity-agentic-tools/src";
-var RustScanner = null;
-var nativeModuleError = null;
-var nativeWalkProjectFiles = null;
-var nativeGrepProject = null;
-var nativeBuildGuidCache = null;
-try {
-  const scriptDir = process.argv[1] ? import_path.dirname(import_path.resolve(process.argv[1])) : __dirname;
-  let rustModule;
-  const nativeLoaderPath = import_path.join(scriptDir, "..", "native", "index.js");
-  if (import_fs.existsSync(nativeLoaderPath)) {
-    const nativeRequire = import_module.createRequire(nativeLoaderPath);
-    rustModule = nativeRequire(nativeLoaderPath);
-  } else {
-    const wsRequire = import_module.createRequire(import_path.join(scriptDir, "_"));
-    rustModule = wsRequire("unity-file-tools");
-  }
-  RustScanner = rustModule.Scanner;
-  nativeWalkProjectFiles = rustModule.walkProjectFiles || null;
-  nativeGrepProject = rustModule.grepProject || null;
-  nativeBuildGuidCache = rustModule.buildGuidCache || null;
-} catch (err) {
-  nativeModuleError = `Failed to load native Rust module.
-` + `Run: bun install (in the project root)
-` + `Original error: ${err.message}`;
-}
-function isNativeModuleAvailable() {
-  return RustScanner !== null;
-}
-function getNativeModuleError() {
-  return nativeModuleError;
-}
-
-class UnityScanner {
-  scanner;
-  constructor() {
-    if (!RustScanner) {
-      throw new Error(nativeModuleError || "Native module not available");
-    }
-    this.scanner = new RustScanner;
-  }
-  setProjectRoot(path) {
-    this.scanner.setProjectRoot(path);
-  }
-  scan_scene_minimal(file) {
-    return this.scanner.scanSceneMinimal(file);
-  }
-  scan_scene_with_components(file, options) {
-    return this.scanner.scanSceneWithComponents(file, options);
-  }
-  find_by_name(file, pattern, fuzzy = true) {
-    return this.scanner.findByName(file, pattern, fuzzy);
-  }
-  inspect(options) {
-    return this.scanner.inspect({
-      file: options.file,
-      identifier: options.identifier,
-      includeProperties: options.include_properties,
-      verbose: options.verbose
-    });
-  }
-  inspect_all(file, include_properties = false, verbose = false) {
-    return this.scanner.inspectAll(file, include_properties, verbose);
-  }
-  inspect_all_paginated(options) {
-    return this.scanner.inspectAllPaginated({
-      file: options.file,
-      includeProperties: options.include_properties,
-      verbose: options.verbose,
-      pageSize: options.page_size,
-      cursor: options.cursor,
-      maxDepth: options.max_depth,
-      filterComponent: options.filter_component
-    });
-  }
-  read_asset(file) {
-    return this.scanner.readAsset(file);
-  }
-}
-function getNativeWalkProjectFiles() {
-  return nativeWalkProjectFiles;
-}
-function getNativeGrepProject() {
-  return nativeGrepProject;
-}
-function getNativeBuildGuidCache() {
-  return nativeBuildGuidCache;
-}
 // src/setup.ts
+init_scanner();
 var import_fs2 = require("fs");
 var import_path2 = require("path");
 var VERSION = require_package().version;
 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 TYPE_REGISTRY_FILE = "type-registry.json";
 var DOC_INDEX_FILE = "doc-index.json";
 function setup(options = {}) {
   const projectPath = import_path2.resolve(options.project || process.cwd());
@@ -241,6 +341,8 @@ function setup(options = {}) {
       project_path: projectPath,
       config_path: "",
       guid_cache_created: false,
+      package_cache_created: false,
+      type_registry_created: false,
       doc_index_created: false,
       error: `Not a Unity project: Assets folder not found at ${assetsPath}`
     };
@@ -259,6 +361,30 @@ function setup(options = {}) {
   const guidCache = buildGuidCache(projectPath);
   const guidCachePath = import_path2.join(configPath, GUID_CACHE_FILE);
   import_fs2.writeFileSync(guidCachePath, JSON.stringify(guidCache, null, 2));
+  let packageCacheCreated = false;
+  let packageGuidCount;
+  const nativePkgBuild = getNativeBuildPackageGuidCache();
+  if (nativePkgBuild) {
+    try {
+      const packageCache = nativePkgBuild(projectPath);
+      const packageCachePath = import_path2.join(configPath, PACKAGE_CACHE_FILE);
+      import_fs2.writeFileSync(packageCachePath, JSON.stringify(packageCache, null, 2));
+      packageCacheCreated = true;
+      packageGuidCount = Object.keys(packageCache).length;
+    } catch {}
+  }
+  let typeRegistryCreated = false;
+  let typeCount;
+  const nativeRegistryBuild = getNativeBuildTypeRegistry();
+  if (nativeRegistryBuild) {
+    try {
+      const types = nativeRegistryBuild(projectPath, true, true);
+      const registryPath = import_path2.join(configPath, TYPE_REGISTRY_FILE);
+      import_fs2.writeFileSync(registryPath, JSON.stringify(types, null, 2));
+      typeRegistryCreated = true;
+      typeCount = types.length;
+    } catch {}
+  }
   let docIndexCreated = false;
   if (options.indexDocs) {
     const docIndex = { chunks: {}, last_updated: Date.now() };
@@ -270,8 +396,12 @@ function setup(options = {}) {
     project_path: projectPath,
     config_path: configPath,
     guid_cache_created: true,
+    package_cache_created: packageCacheCreated,
+    type_registry_created: typeRegistryCreated,
     doc_index_created: docIndexCreated,
-    guid_count: Object.keys(guidCache).length
+    guid_count: Object.keys(guidCache).length,
+    package_guid_count: packageGuidCount,
+    type_count: typeCount
   };
 }
 function buildGuidCache(projectRoot) {
@@ -395,7 +525,36 @@ var path = __toESM(require("path"));
 
 // src/utils.ts
 var import_fs4 = require("fs");
+var import_path4 = require("path");
+function find_unity_project_root(startDir) {
+  let dir = import_path4.resolve(startDir || process.cwd());
+  const root = import_path4.resolve("/");
+  while (dir !== root) {
+    if (import_fs4.existsSync(import_path4.join(dir, ".unity-agentic")))
+      return dir;
+    if (import_fs4.existsSync(import_path4.join(dir, "Assets")) && import_fs4.existsSync(import_path4.join(dir, "ProjectSettings")))
+      return dir;
+    if (import_fs4.existsSync(import_path4.join(dir, "Assets")))
+      return dir;
+    const parent = import_path4.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
 function atomicWrite(filePath, content) {
+  if (import_fs4.existsSync(filePath)) {
+    try {
+      import_fs4.accessSync(filePath, import_fs4.constants.W_OK);
+    } catch {
+      return {
+        success: false,
+        file_path: filePath,
+        error: `Permission denied: ${filePath} is not writable`
+      };
+    }
+  }
   const tmpPath = `${filePath}.tmp`;
   try {
     import_fs4.writeFileSync(tmpPath, content, "utf-8");
@@ -428,6 +587,9 @@ function atomicWrite(filePath, content) {
     };
   }
 }
+function is_match_all(pattern) {
+  return pattern === "*" || pattern === "." || pattern === "**" || pattern === ".*";
+}
 function glob_match(pattern, text) {
   if (!pattern.includes("*") && !pattern.includes("?")) {
     return pattern.toLowerCase() === text.toLowerCase();
@@ -472,8 +634,18 @@ function validate_file_path(file_path, operation) {
   if (!isAbsolute && (normalized.includes("/../") || normalized.startsWith("../"))) {
     return "Path traversal (..) is not allowed in relative paths for security reasons.";
   }
-  if (operation === "write" && !isAbsolute && normalized.startsWith("Packages/")) {
-    return "Cannot write to Packages/ directory (read-only in Unity).";
+  if (operation === "write") {
+    if (normalized.includes("/Library/PackageCache/") || normalized.startsWith("Library/PackageCache/")) {
+      return "Cannot write to Library/PackageCache/ (immutable package cache).";
+    }
+    const segments = normalized.split("/");
+    const pkgIdx = segments.indexOf("Packages");
+    if (pkgIdx >= 0) {
+      const assetsIdx = segments.indexOf("Assets");
+      if (assetsIdx < 0 || assetsIdx > pkgIdx) {
+        return "Cannot write to Packages/ directory (read-only in Unity).";
+      }
+    }
   }
   return null;
 }
@@ -507,7 +679,10 @@ var SETTING_ALIASES = {
   project: "ProjectSettings",
   projectsettings: "ProjectSettings",
   navmesh: "NavMeshAreas",
-  navmeshareas: "NavMeshAreas"
+  navmeshareas: "NavMeshAreas",
+  build: "EditorBuildSettings",
+  editorbuild: "EditorBuildSettings",
+  editorbuildsettings: "EditorBuildSettings"
 };
 function resolve_setting_name(setting) {
   const lower = setting.toLowerCase();
@@ -627,6 +802,36 @@ function parse_time_manager(content) {
     max_particle_timestep: get_float("Maximum Particle Timestep")
   };
 }
+function parse_input_manager(content) {
+  const axes = [];
+  const entries = content.split(/\n  - serializedVersion:/);
+  for (let i = 1;i < entries.length; i++) {
+    const block = entries[i];
+    const field = (key) => {
+      const re = new RegExp(`^\\s*${key}:[ \\t]*(.*)$`, "m");
+      const m = re.exec(block);
+      return m ? m[1].trim() : "";
+    };
+    axes.push({
+      name: field("m_Name"),
+      descriptive_name: field("descriptiveName"),
+      descriptive_negative_name: field("descriptiveNegativeName"),
+      negative_button: field("negativeButton"),
+      positive_button: field("positiveButton"),
+      alt_negative_button: field("altNegativeButton"),
+      alt_positive_button: field("altPositiveButton"),
+      gravity: parseFloat(field("gravity") || "0"),
+      dead: parseFloat(field("dead") || "0"),
+      sensitivity: parseFloat(field("sensitivity") || "0"),
+      snap: field("snap") === "1",
+      invert: field("invert") === "1",
+      type: parseInt(field("type") || "0", 10),
+      axis: parseInt(field("axis") || "0", 10),
+      joy_num: parseInt(field("joyNum") || "0", 10)
+    });
+  }
+  return { axes };
+}
 function parse_generic_asset(content) {
   const result = {};
   const lines = content.split(`
@@ -683,6 +888,9 @@ function read_settings(options) {
     case "TimeManager":
       data = parse_time_manager(content);
       break;
+    case "InputManager":
+      data = parse_input_manager(content);
+      break;
     default:
       data = parse_generic_asset(content);
       break;
@@ -697,6 +905,14 @@ function read_settings(options) {
 }
 function edit_settings(options) {
   const { project_path, setting, property, value } = options;
+  if (value === undefined || value === null) {
+    return {
+      success: false,
+      project_path,
+      setting,
+      error: "Value cannot be empty. Provide a valid value with --value."
+    };
+  }
   const file_path = resolve_setting_path(project_path, setting);
   if (!import_fs5.existsSync(file_path)) {
     return {
@@ -730,17 +946,23 @@ function edit_settings(options) {
       if (pascalPattern.test(content)) {
         content = content.replace(pascalPattern, `$1${value}`);
       } else {
-        const spacedName = property.replace(/_/g, " ").replace(/(^| )([a-z])/g, (_, sp, c) => sp + c.toUpperCase());
-        const spacedPattern = new RegExp(`(^\\s*${spacedName}:\\s*)(.*)$`, "m");
-        if (spacedPattern.test(content)) {
-          content = content.replace(spacedPattern, `$1${value}`);
+        const camelSpaced = property.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/(^| )([a-z])/g, (_, sp, c) => sp + c.toUpperCase());
+        const camelSpacedPattern = new RegExp(`(^\\s*${camelSpaced}:\\s*)(.*)$`, "m");
+        if (camelSpacedPattern.test(content)) {
+          content = content.replace(camelSpacedPattern, `$1${value}`);
         } else {
-          return {
-            success: false,
-            project_path,
-            setting,
-            error: `Property "${property}" not found in ${setting}`
-          };
+          const spacedName = property.replace(/_/g, " ").replace(/(^| )([a-z])/g, (_, sp, c) => sp + c.toUpperCase());
+          const spacedPattern = new RegExp(`(^\\s*${spacedName}:\\s*)(.*)$`, "m");
+          if (spacedPattern.test(content)) {
+            content = content.replace(spacedPattern, `$1${value}`);
+          } else {
+            return {
+              success: false,
+              project_path,
+              setting,
+              error: `Property "${property}" not found in ${setting}`
+            };
+          }
         }
       }
     }
@@ -992,7 +1214,8 @@ function edit_sorting_layer(options) {
 `;
     const sortingEnd = content.match(/(m_SortingLayers:\s*\n(?:\s+-\s+name:[\s\S]*?(?=\n[^\s]|\n*$)))/);
     if (sortingEnd) {
-      content = content.replace(sortingEnd[1], sortingEnd[1] + newEntry);
+      content = content.replace(sortingEnd[1], sortingEnd[1] + `
+` + newEntry);
     } else {
       content = content.trimEnd() + `
 ` + newEntry;
@@ -1029,6 +1252,7 @@ function edit_sorting_layer(options) {
   };
 }
 // src/project-search.ts
+init_scanner();
 var import_fs6 = require("fs");
 var path2 = __toESM(require("path"));
 var BINARY_EXTENSIONS = new Set([
@@ -1119,6 +1343,8 @@ function walk_project_files_js(project_path, extensions, exclude_dirs) {
   const assetsDir = path2.join(project_path, "Assets");
   if (import_fs6.existsSync(assetsDir)) {
     walk(assetsDir);
+  } else {
+    walk(project_path);
   }
   if (extSet.has(".asset")) {
     const settingsDir = path2.join(project_path, "ProjectSettings");
@@ -1175,6 +1401,59 @@ function search_project(options) {
       error: `Project path not found: ${project_path}`
     };
   }
+  const ASSET_TYPE_EXTENSIONS = {
+    mat: [".mat"],
+    anim: [".anim"],
+    controller: [".controller"],
+    asset: [".asset"]
+  };
+  const isAssetType = file_type in ASSET_TYPE_EXTENSIONS;
+  if (isAssetType) {
+    const extensions2 = ASSET_TYPE_EXTENSIONS[file_type];
+    const files2 = walk_project_files(project_path, extensions2);
+    const matches2 = [];
+    for (const file of files2) {
+      const relPath = path2.relative(project_path, file);
+      const fileName = path2.basename(file, path2.extname(file));
+      if (name) {
+        const nameLower = name.toLowerCase();
+        const hasWildcard = name.includes("*") || name.includes("?");
+        if (hasWildcard) {
+          if (!glob_match(name, fileName))
+            continue;
+        } else if (exact) {
+          if (fileName !== name)
+            continue;
+        } else {
+          if (!fileName.toLowerCase().includes(nameLower))
+            continue;
+        }
+      }
+      let display_name = fileName;
+      try {
+        const content = import_fs6.readFileSync(file, "utf-8");
+        const nameMatch = /^\s*m_Name:\s*(.+)$/m.exec(content.slice(0, 2000));
+        if (nameMatch)
+          display_name = nameMatch[1].trim();
+      } catch {}
+      matches2.push({
+        file: relPath,
+        game_object: display_name,
+        file_id: "0"
+      });
+      if (max_matches !== undefined && matches2.length >= max_matches)
+        break;
+    }
+    return {
+      success: true,
+      project_path,
+      total_files_scanned: files2.length,
+      total_matches: matches2.length,
+      cursor: 0,
+      truncated: max_matches !== undefined && matches2.length >= max_matches,
+      matches: matches2
+    };
+  }
   if (!isNativeModuleAvailable()) {
     return {
       success: false,
@@ -1198,12 +1477,30 @@ function search_project(options) {
   for (const file of files) {
     try {
       let gameObjects;
-      const needFullData = !!(component || tag || layer !== undefined);
-      if (name && !needFullData) {
+      const needComponents = !!component;
+      const needMetadata = !!(tag || layer !== undefined);
+      if (name && !needMetadata && !needComponents) {
         gameObjects = scanner.find_by_name(file, name, !exact);
-      } else if (needFullData) {
+      } else if (needComponents) {
         gameObjects = scanner.scan_scene_with_components(file);
-        if (name) {
+        if (name && !is_match_all(name)) {
+          const nameLower = name.toLowerCase();
+          const hasWildcard = name.includes("*") || name.includes("?");
+          gameObjects = gameObjects.filter((go) => {
+            if (!go.name)
+              return false;
+            if (hasWildcard) {
+              return glob_match(name, go.name);
+            }
+            if (exact) {
+              return go.name === name;
+            }
+            return go.name.toLowerCase().includes(nameLower);
+          });
+        }
+      } else if (needMetadata) {
+        gameObjects = scanner.scan_scene_metadata(file);
+        if (name && !is_match_all(name)) {
           const nameLower = name.toLowerCase();
           const hasWildcard = name.includes("*") || name.includes("?");
           gameObjects = gameObjects.filter((go) => {
@@ -1344,11 +1641,54 @@ function grep_project_js(options) {
   }
   const EXTENSION_MAP = {
     cs: [".cs"],
-    yaml: [".yaml", ".yml", ".unity", ".prefab", ".asset"],
+    yaml: [
+      ".yaml",
+      ".yml",
+      ".unity",
+      ".prefab",
+      ".asset",
+      ".mat",
+      ".anim",
+      ".controller",
+      ".overrideController",
+      ".mask",
+      ".mixer",
+      ".lighting",
+      ".preset",
+      ".signal",
+      ".playable",
+      ".renderTexture",
+      ".flare",
+      ".guiskin",
+      ".terrainlayer",
+      ".cubemap"
+    ],
     unity: [".unity"],
     prefab: [".prefab"],
     asset: [".asset"],
-    all: [".cs", ".unity", ".prefab", ".asset", ".yaml", ".yml", ".txt", ".json", ".xml", ".shader", ".cginc", ".hlsl", ".compute", ".asmdef", ".asmref"]
+    mat: [".mat"],
+    anim: [".anim"],
+    controller: [".controller"],
+    all: [
+      ".cs",
+      ".unity",
+      ".prefab",
+      ".asset",
+      ".mat",
+      ".anim",
+      ".controller",
+      ".yaml",
+      ".yml",
+      ".txt",
+      ".json",
+      ".xml",
+      ".shader",
+      ".cginc",
+      ".hlsl",
+      ".compute",
+      ".asmdef",
+      ".asmref"
+    ]
   };
   const extensions = EXTENSION_MAP[file_type] || EXTENSION_MAP.all;
   const files = walk_project_files(project_path, extensions);
@@ -1417,7 +1757,77 @@ function grep_project_js(options) {
   };
 }
 // src/editor/create.ts
+var import_fs10 = require("fs");
+var path5 = __toESM(require("path"));
+
+// src/guid-cache.ts
 var import_fs7 = require("fs");
+var import_path5 = require("path");
+var _cache_store = new Map;
+function build_guid_cache(project_path, raw) {
+  return {
+    project_path,
+    cache: raw,
+    count: Object.keys(raw).length,
+    resolve(guid) {
+      return raw[guid] ?? null;
+    },
+    resolve_absolute(guid) {
+      const rel = raw[guid];
+      if (!rel)
+        return null;
+      if (import_path5.isAbsolute(rel))
+        return rel;
+      return import_path5.join(project_path, rel);
+    },
+    resolve_many(guids) {
+      const result = {};
+      for (const guid of guids) {
+        result[guid] = raw[guid] ?? null;
+      }
+      return result;
+    },
+    find_by_name(name, extension) {
+      const nameLower = name.toLowerCase().replace(/\.[^.]+$/, "");
+      let substringMatch = null;
+      for (const [guid, assetPath] of Object.entries(raw)) {
+        if (extension && !assetPath.endsWith(extension))
+          continue;
+        const fileName = import_path5.basename(assetPath, import_path5.extname(assetPath)).toLowerCase();
+        if (fileName === nameLower) {
+          return { guid, path: assetPath };
+        }
+        if (!substringMatch && assetPath.toLowerCase().includes(nameLower)) {
+          substringMatch = { guid, path: assetPath };
+        }
+      }
+      return substringMatch;
+    }
+  };
+}
+function load_guid_cache(project_path) {
+  const resolved = project_path;
+  const existing = _cache_store.get(resolved);
+  if (existing)
+    return existing;
+  const cachePath = import_path5.join(resolved, ".unity-agentic", "guid-cache.json");
+  if (!import_fs7.existsSync(cachePath))
+    return null;
+  try {
+    const raw = JSON.parse(import_fs7.readFileSync(cachePath, "utf-8"));
+    const cache = build_guid_cache(resolved, raw);
+    _cache_store.set(resolved, cache);
+    return cache;
+  } catch {
+    return null;
+  }
+}
+function load_guid_cache_for_file(file_path, explicit_project) {
+  const project_path = explicit_project || find_unity_project_root(import_path5.dirname(file_path));
+  if (!project_path)
+    return null;
+  return load_guid_cache(project_path);
+}
 
 // src/class-ids.ts
 var UNITY_CLASS_IDS = {
@@ -1623,12 +2033,394 @@ var UNITY_CLASS_NAMES = Object.fromEntries(Object.entries(UNITY_CLASS_IDS).map((
 function get_class_id_name(class_id) {
   return UNITY_CLASS_IDS[class_id] || `Unknown_${class_id}`;
 }
+function get_class_id(component_name) {
+  if (UNITY_CLASS_NAMES[component_name] !== undefined) {
+    return UNITY_CLASS_NAMES[component_name];
+  }
+  const lowerName = component_name.toLowerCase();
+  for (const [name, id] of Object.entries(UNITY_CLASS_NAMES)) {
+    if (name.toLowerCase() === lowerName) {
+      return id;
+    }
+  }
+  return null;
+}
 
-// src/editor/unity-block.ts
-var HEADER_PATTERN = /^--- !u!(\d+) &(\d+)(\s+stripped)?/;
-function parse_header(raw) {
-  const first_newline = raw.indexOf(`
-`);
+// src/editor/shared.ts
+var import_fs8 = require("fs");
+var path3 = __toESM(require("path"));
+function validateUnityYAML(content) {
+  if (!content.startsWith("%YAML 1.1")) {
+    return "Missing or invalid YAML header";
+  }
+  const invalidGuids = content.match(/guid:\s*[a-f0-9]{1,29}\b/g);
+  if (invalidGuids) {
+    return "Found invalid GUID format (missing characters)";
+  }
+  const blockOpens = (content.match(/--- !u!/g) || []).length;
+  const blockCloses = (content.match(/\n---(?!u!)/g) || []).length;
+  if (Math.abs(blockOpens - blockCloses) > 1) {
+    return "Unbalanced YAML block markers";
+  }
+  return null;
+}
+function extractGuidFromMeta(metaPath) {
+  if (!import_fs8.existsSync(metaPath)) {
+    return null;
+  }
+  try {
+    const content = import_fs8.readFileSync(metaPath, "utf-8");
+    const match = content.match(/guid:\s*([a-f0-9]{32})/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function resolveScriptGuid(script, projectPath) {
+  if (/^[a-f0-9]{32}$/i.test(script)) {
+    return { guid: script.toLowerCase(), path: null };
+  }
+  if (script.endsWith(".cs")) {
+    const metaPath = script + ".meta";
+    if (import_fs8.existsSync(metaPath)) {
+      const guid = extractGuidFromMeta(metaPath);
+      if (guid) {
+        return { guid, path: script };
+      }
+    }
+    if (projectPath) {
+      const fullPath = path3.join(projectPath, script);
+      const fullMetaPath = fullPath + ".meta";
+      if (import_fs8.existsSync(fullMetaPath)) {
+        const guid = extractGuidFromMeta(fullMetaPath);
+        if (guid) {
+          return { guid, path: script };
+        }
+      }
+    }
+  }
+  if (projectPath) {
+    const guidCache = load_guid_cache(projectPath);
+    if (guidCache) {
+      const result = guidCache.find_by_name(script, ".cs");
+      if (result)
+        return result;
+    }
+    const registryPath = path3.join(projectPath, ".unity-agentic", "type-registry.json");
+    if (import_fs8.existsSync(registryPath)) {
+      try {
+        const registry = JSON.parse(import_fs8.readFileSync(registryPath, "utf-8"));
+        let targetName = script;
+        let targetNamespace = null;
+        const dotIndex = script.lastIndexOf(".");
+        if (dotIndex > 0) {
+          targetNamespace = script.substring(0, dotIndex);
+          targetName = script.substring(dotIndex + 1);
+        }
+        const targetNameLower = targetName.toLowerCase();
+        const matches = registry.filter((t) => {
+          if (t.name.toLowerCase() !== targetNameLower)
+            return false;
+          if (targetNamespace && t.namespace?.toLowerCase() !== targetNamespace.toLowerCase())
+            return false;
+          return true;
+        });
+        if (matches.length === 1 && matches[0].guid) {
+          return { guid: matches[0].guid, path: matches[0].filePath };
+        }
+        if (matches.length > 1) {
+          const withGuid = matches.filter((m) => m.guid);
+          if (withGuid.length === 1) {
+            return { guid: withGuid[0].guid, path: withGuid[0].filePath };
+          }
+        }
+      } catch {}
+    }
+    const packageCachePath = path3.join(projectPath, ".unity-agentic", "package-cache.json");
+    if (import_fs8.existsSync(packageCachePath)) {
+      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)) {
+          if (!assetPath.endsWith(".cs"))
+            continue;
+          const fileName = path3.basename(assetPath, ".cs").toLowerCase();
+          if (fileName === scriptNameLower) {
+            return { guid, path: assetPath };
+          }
+        }
+      } catch {}
+    }
+  }
+  return null;
+}
+function resolve_script_with_fields(script, project_path) {
+  const resolved = resolveScriptGuid(script, project_path);
+  if (!resolved)
+    return null;
+  const result = {
+    guid: resolved.guid,
+    path: resolved.path
+  };
+  if (!project_path)
+    return result;
+  if (resolved.path) {
+    try {
+      const full_path = resolved.path.startsWith("/") ? resolved.path : path3.join(project_path, resolved.path);
+      if (!import_fs8.existsSync(full_path)) {
+        result.extraction_error = `Script file not found at resolved path: ${full_path}`;
+      } else if (resolved.path.endsWith(".cs")) {
+        const { getNativeExtractSerializedFields: getNativeExtractSerializedFields2 } = (init_scanner(), __toCommonJS(exports_scanner));
+        const extract = getNativeExtractSerializedFields2();
+        if (extract) {
+          const type_infos = extract(full_path);
+          if (type_infos && type_infos.length > 0) {
+            const mono = type_infos.find((t) => t.baseClass === "MonoBehaviour" || t.baseClass === "ScriptableObject" || t.baseClass === "NetworkBehaviour" || t.baseClass === "StateMachineBehaviour");
+            const chosen = mono || type_infos[0];
+            result.fields = chosen.fields;
+            result.base_class = chosen.baseClass ?? undefined;
+            result.kind = chosen.kind;
+          }
+        } else {
+          result.extraction_error = "Native extractSerializedFields function not available";
+        }
+      } else if (resolved.path.endsWith(".dll")) {
+        const { getNativeExtractDllFields: getNativeExtractDllFields2 } = (init_scanner(), __toCommonJS(exports_scanner));
+        const extract = getNativeExtractDllFields2();
+        if (extract) {
+          const type_infos = extract(full_path);
+          if (type_infos && type_infos.length > 0) {
+            const script_name = script.includes(".") ? script.split(".").pop() : script;
+            const match = type_infos.find((t) => t.name === script_name);
+            const chosen = match || type_infos[0];
+            result.fields = chosen.fields;
+            result.base_class = chosen.baseClass ?? undefined;
+            result.kind = chosen.kind;
+          }
+        } else {
+          result.extraction_error = "Native extractDllFields function not available";
+        }
+      }
+    } catch (err) {
+      result.extraction_error = `Field extraction failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+  if (result.fields && result.fields.length > 0) {
+    resolve_enum_fields(result.fields, project_path);
+  }
+  return result;
+}
+function resolve_enum_fields(fields, project_path) {
+  const registry_path = path3.join(project_path, ".unity-agentic", "type-registry.json");
+  if (!import_fs8.existsSync(registry_path))
+    return;
+  try {
+    const registry = JSON.parse(import_fs8.readFileSync(registry_path, "utf-8"));
+    const enum_names = new Set;
+    for (const entry of registry) {
+      if (entry.kind === "enum") {
+        enum_names.add(entry.name);
+      }
+    }
+    if (enum_names.size === 0)
+      return;
+    for (const field of fields) {
+      let typeName = field.typeName;
+      const nullable = typeName.endsWith("?");
+      if (nullable) {
+        typeName = typeName.slice(0, -1);
+      }
+      if (enum_names.has(typeName)) {
+        field.typeName = nullable ? "int?" : "int";
+        continue;
+      }
+      const dotIdx = typeName.lastIndexOf(".");
+      if (dotIdx > 0) {
+        const shortName = typeName.substring(dotIdx + 1);
+        if (enum_names.has(shortName)) {
+          field.typeName = nullable ? "int?" : "int";
+        }
+      }
+    }
+  } 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;
+    }
+    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;
+    }
+    if (default_value.includes(`
+`)) {
+      lines.push(`${indent}${field.name}:`);
+      for (const sub_line of default_value.split(`
+`)) {
+        lines.push(`${indent}${sub_line}`);
+      }
+    } else {
+      lines.push(`${indent}${field.name}: ${default_value}`);
+    }
+  }
+  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) {
+  const first_newline = raw.indexOf(`
+`);
   const first_line = first_newline === -1 ? raw : raw.slice(0, first_newline);
   const match = first_line.match(HEADER_PATTERN);
   if (!match)
@@ -1676,12 +2468,12 @@ class UnityBlock {
   get dirty() {
     return this._dirty;
   }
-  get_property(path3) {
-    if (path3.includes("Array.data[")) {
-      return this._get_array_element(path3);
+  get_property(path4) {
+    if (path4.includes("Array.data[")) {
+      return this._get_array_element(path4);
     }
-    if (path3.includes(".")) {
-      const parts = path3.split(".");
+    if (path4.includes(".")) {
+      const parts = path4.split(".");
       const root_prop = parts[0];
       const root_pattern = new RegExp(`^\\s*${escape_regex(root_prop)}:\\s*(.*)$`, "m");
       const root_match = this._raw.match(root_pattern);
@@ -1698,23 +2490,23 @@ class UnityBlock {
         return block_value;
       return null;
     }
-    const prop_pattern = new RegExp(`^\\s*${escape_regex(path3)}:\\s*(.*)$`, "m");
+    const prop_pattern = new RegExp(`^\\s*${escape_regex(path4)}:\\s*(.*)$`, "m");
     const match = this._raw.match(prop_pattern);
     return match ? match[1].trim() : null;
   }
-  set_property(path3, value, object_reference) {
+  set_property(path4, value, object_reference) {
     const old_raw = this._raw;
     const effective_ref = object_reference && object_reference !== "{fileID: 0}" ? object_reference : undefined;
-    if (!path3.includes(".") && !path3.includes("Array")) {
-      const prop_pattern = new RegExp(`(^\\s*${escape_regex(path3)}:\\s*)(.*)$`, "m");
+    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}`);
       }
       return this._check_dirty(old_raw);
     }
-    if (path3.includes(".") && !path3.includes("Array")) {
-      const parts = path3.split(".");
+    if (path4.includes(".") && !path4.includes("Array")) {
+      const parts = path4.split(".");
       const parent_prop = parts[0];
       const sub_field = parts[1];
       const inline_pattern = new RegExp(`(${escape_regex(parent_prop)}:\\s*\\{)([^}]*)(\\})`, "m");
@@ -1738,8 +2530,8 @@ class UnityBlock {
       }
       return this._check_dirty(old_raw);
     }
-    if (path3.includes("Array.data[")) {
-      const array_match = path3.match(/^(.+)\.Array\.data\[(\d+)\]$/);
+    if (path4.includes("Array.data[")) {
+      const array_match = path4.match(/^(.+)\.Array\.data\[(\d+)\]$/);
       if (array_match) {
         const array_prop = array_match[1];
         const index = parseInt(array_match[2], 10);
@@ -1760,8 +2552,8 @@ class UnityBlock {
     }
     return false;
   }
-  has_property(path3) {
-    return this.get_property(path3) !== null;
+  has_property(path4) {
+    return this.get_property(path4) !== null;
   }
   detect_format(property_name) {
     const cached = this._format_cache.get(property_name);
@@ -1773,7 +2565,8 @@ class UnityBlock {
     return result;
   }
   get_array_length(array_property) {
-    const empty_pattern = new RegExp(`^\\s*${escape_regex(array_property)}:\\s*\\[\\]\\s*$`, "m");
+    const clean_prop = array_property.replace(/\.Array$/, "");
+    const empty_pattern = new RegExp(`^\\s*${escape_regex(clean_prop)}:\\s*\\[\\]\\s*$`, "m");
     if (empty_pattern.test(this._raw))
       return 0;
     const lines = this._raw.split(`
@@ -1783,7 +2576,7 @@ class UnityBlock {
     let count = 0;
     for (const line of lines) {
       if (!in_array) {
-        const header_match = line.match(new RegExp(`^(\\s*)${escape_regex(array_property)}:\\s*$`));
+        const header_match = line.match(new RegExp(`^(\\s*)${escape_regex(clean_prop)}:\\s*$`));
         if (header_match) {
           in_array = true;
           array_indent = header_match[1].length;
@@ -1807,8 +2600,9 @@ class UnityBlock {
     return count;
   }
   insert_array_element(array_property, index, value) {
+    const clean_prop = array_property.replace(/\.Array$/, "");
     const old_raw = this._raw;
-    const empty_pattern = new RegExp(`(^(\\s*)${escape_regex(array_property)}:\\s*)\\[\\]`, "m");
+    const empty_pattern = new RegExp(`(^(\\s*)${escape_regex(clean_prop)}:\\s*)\\[\\]`, "m");
     const empty_match = this._raw.match(empty_pattern);
     if (empty_match) {
       const base_indent = empty_match[2];
@@ -1824,7 +2618,7 @@ ${element_indent2}- ${value}`);
     const element_indices = [];
     for (let i = 0;i < lines.length; i++) {
       if (array_header_idx === -1) {
-        const header_match = lines[i].match(new RegExp(`^(\\s*)${escape_regex(array_property)}:\\s*$`));
+        const header_match = lines[i].match(new RegExp(`^(\\s*)${escape_regex(clean_prop)}:\\s*$`));
         if (header_match) {
           array_header_idx = i;
           array_indent = header_match[1].length;
@@ -1868,6 +2662,7 @@ ${element_indent2}- ${value}`);
     return this._check_dirty(old_raw);
   }
   remove_array_element(array_property, index) {
+    const clean_prop = array_property.replace(/\.Array$/, "");
     const old_raw = this._raw;
     const lines = this._raw.split(`
 `);
@@ -1876,7 +2671,7 @@ ${element_indent2}- ${value}`);
     const element_indices = [];
     for (let i = 0;i < lines.length; i++) {
       if (array_header_idx === -1) {
-        const header_match = lines[i].match(new RegExp(`^(\\s*)${escape_regex(array_property)}:\\s*$`));
+        const header_match = lines[i].match(new RegExp(`^(\\s*)${escape_regex(clean_prop)}:\\s*$`));
         if (header_match) {
           array_header_idx = i;
           array_indent = header_match[1].length;
@@ -1904,7 +2699,7 @@ ${element_indent2}- ${value}`);
     if (element_indices.length === 1) {
       const header_indent_match = lines[array_header_idx].match(/^(\s*)/);
       const header_indent = header_indent_match ? header_indent_match[1] : "";
-      lines[array_header_idx] = `${header_indent}${array_property}: []`;
+      lines[array_header_idx] = `${header_indent}${clean_prop}: []`;
     }
     this._raw = lines.join(`
 `);
@@ -1958,8 +2753,8 @@ ${element_indent2}- ${value}`);
     }
     return false;
   }
-  _get_array_element(path3) {
-    const array_match = path3.match(/^(.+)\.Array\.data\[(\d+)\]$/);
+  _get_array_element(path4) {
+    const array_match = path4.match(/^(.+)\.Array\.data\[(\d+)\]$/);
     if (!array_match)
       return null;
     const array_prop = array_match[1];
@@ -2119,249 +2914,1137 @@ ${element_indent2}- ${value}`);
   }
 }
 
-// src/editor/create.ts
-function createScene(options) {
-  const { output_path, include_defaults, scene_guid } = options;
-  const pathError = validate_file_path(output_path, "write");
-  if (pathError) {
-    return { success: false, output_path, error: pathError };
+// src/editor/unity-document.ts
+class UnityDocument {
+  file_path;
+  _header;
+  _blocks;
+  _id_index;
+  _structure_dirty;
+  static from_file(file_path, options) {
+    const content = import_fs9.readFileSync(file_path, "utf-8");
+    const doc = UnityDocument._parse(content, file_path);
+    if (options?.validate && !doc.validate()) {
+      throw new Error(`Invalid Unity YAML file: ${file_path}`);
+    }
+    return doc;
   }
-  if (!output_path.endsWith(".unity")) {
-    return {
-      success: false,
-      output_path,
-      error: "Output path must have .unity extension"
-    };
+  static from_string(content, options) {
+    const doc = UnityDocument._parse(content, null);
+    if (options?.validate && !doc.validate()) {
+      throw new Error("Invalid Unity YAML content");
+    }
+    return doc;
   }
-  if (import_fs7.existsSync(output_path)) {
-    return {
-      success: false,
-      output_path,
-      error: `File already exists: ${output_path}. Delete it first or choose a different path.`
-    };
+  static _parse(content, file_path) {
+    const normalized = content.replace(/\r\n/g, `
+`);
+    const parts = normalized.split(/(?=--- !u!)/);
+    let header = "";
+    const raw_blocks = [];
+    if (parts.length > 0 && !parts[0].startsWith("--- !u!")) {
+      header = parts.shift();
+    }
+    for (const part of parts) {
+      raw_blocks.push(part);
+    }
+    const blocks = raw_blocks.map((raw) => new UnityBlock(raw));
+    return new UnityDocument(file_path, header, blocks);
   }
-  const guid = scene_guid || generateGuid();
-  let yaml = `%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!29 &1
-OcclusionCullingSettings:
-  m_ObjectHideFlags: 0
-  serializedVersion: 2
-  m_OcclusionBakeSettings:
-    smallestOccluder: 5
-    smallestHole: 0.25
-    backfaceThreshold: 100
-  m_SceneGUID: 00000000000000000000000000000000
-  m_OcclusionCullingData: {fileID: 0}
---- !u!104 &2
-RenderSettings:
-  m_ObjectHideFlags: 0
-  serializedVersion: 9
-  m_Fog: 0
-  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
-  m_FogMode: 3
-  m_FogDensity: 0.01
-  m_LinearFogStart: 0
-  m_LinearFogEnd: 300
-  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
-  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
-  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
-  m_AmbientIntensity: 1
-  m_AmbientMode: 0
-  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
-  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
-  m_HaloStrength: 0.5
-  m_FlareStrength: 1
-  m_FlareFadeSpeed: 3
-  m_HaloTexture: {fileID: 0}
-  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
-  m_DefaultReflectionMode: 0
-  m_DefaultReflectionResolution: 128
-  m_ReflectionBounces: 1
-  m_ReflectionIntensity: 1
-  m_CustomReflection: {fileID: 0}
-  m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
-  m_UseRadianceAmbientProbe: 0
---- !u!157 &3
-LightmapSettings:
-  m_ObjectHideFlags: 0
-  serializedVersion: 12
-  m_GIWorkflowMode: 1
-  m_GISettings:
-    serializedVersion: 2
-    m_BounceScale: 1
-    m_IndirectOutputScale: 1
-    m_AlbedoBoost: 1
-    m_EnvironmentLightingMode: 0
-    m_EnableBakedLightmaps: 1
-    m_EnableRealtimeLightmaps: 0
-  m_LightmapEditorSettings:
-    serializedVersion: 12
-    m_Resolution: 2
-    m_BakeResolution: 40
-    m_AtlasSize: 1024
-    m_AO: 0
-    m_AOMaxDistance: 1
-    m_CompAOExponent: 1
-    m_CompAOExponentDirect: 0
-    m_ExtractAmbientOcclusion: 0
-    m_Padding: 2
-    m_LightmapParameters: {fileID: 0}
-    m_LightmapsBakeMode: 1
-    m_TextureCompression: 1
-    m_FinalGather: 0
-    m_FinalGatherFiltering: 1
-    m_FinalGatherRayCount: 256
-    m_ReflectionCompression: 2
-    m_MixedBakeMode: 2
-    m_BakeBackend: 1
-    m_PVRSampling: 1
-    m_PVRDirectSampleCount: 32
-    m_PVRSampleCount: 512
-    m_PVRBounces: 2
-    m_PVREnvironmentSampleCount: 256
-    m_PVREnvironmentReferencePointCount: 2048
-    m_PVRFilteringMode: 1
-    m_PVRDenoiserTypeDirect: 1
-    m_PVRDenoiserTypeIndirect: 1
-    m_PVRDenoiserTypeAO: 1
-    m_PVRFilterTypeDirect: 0
-    m_PVRFilterTypeIndirect: 0
-    m_PVRFilterTypeAO: 0
-    m_PVREnvironmentMIS: 1
-    m_PVRCulling: 1
-    m_PVRFilteringGaussRadiusDirect: 1
-    m_PVRFilteringGaussRadiusIndirect: 5
-    m_PVRFilteringGaussRadiusAO: 2
-    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
-    m_PVRFilteringAtrousPositionSigmaIndirect: 2
-    m_PVRFilteringAtrousPositionSigmaAO: 1
-    m_ExportTrainingData: 0
-    m_TrainingDataDestination: TrainingData
-    m_LightProbeSampleCountMultiplier: 4
-  m_LightingDataAsset: {fileID: 0}
-  m_LightingSettings: {fileID: 0}
---- !u!196 &4
-NavMeshSettings:
-  serializedVersion: 2
-  m_ObjectHideFlags: 0
-  m_BuildSettings:
-    serializedVersion: 3
-    agentTypeID: 0
-    agentRadius: 0.5
-    agentHeight: 2
-    agentSlope: 45
-    agentClimb: 0.4
-    ledgeDropHeight: 0
-    maxJumpAcrossDistance: 0
-    minRegionArea: 2
-    manualCellSize: 0
-    cellSize: 0.16666667
-    manualTileSize: 0
-    tileSize: 256
-    buildHeightMesh: 0
-    maxJobWorkers: 0
-    preserveTilesOutsideBounds: 0
-    debug:
-      m_Flags: 0
-  m_NavMeshData: {fileID: 0}
-`;
-  if (include_defaults) {
-    yaml += `--- !u!1 &519420028
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
+  constructor(file_path, header, blocks) {
+    this.file_path = file_path;
+    this._header = header;
+    this._blocks = blocks;
+    this._id_index = new Map;
+    this._structure_dirty = false;
+    this._rebuild_index();
+  }
+  _rebuild_index() {
+    this._id_index.clear();
+    for (let i = 0;i < this._blocks.length; i++) {
+      const id = this._blocks[i].file_id;
+      if (id !== "0") {
+        this._id_index.set(id, i);
+      }
+    }
+  }
+  get blocks() {
+    return this._blocks;
+  }
+  get count() {
+    return this._blocks.length;
+  }
+  get dirty() {
+    if (this._structure_dirty)
+      return true;
+    for (const block of this._blocks) {
+      if (block.dirty)
+        return true;
+    }
+    return false;
+  }
+  find_by_file_id(file_id) {
+    const index = this._id_index.get(file_id);
+    if (index === undefined)
+      return null;
+    return this._blocks[index];
+  }
+  find_by_class_id(class_id) {
+    const results = [];
+    for (const block of this._blocks) {
+      if (block.class_id === class_id) {
+        results.push(block);
+      }
+    }
+    return results;
+  }
+  find_game_objects_by_name(name) {
+    const results = [];
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`^\\s*m_Name:\\s*${escaped}\\s*$`, "m");
+    for (const block of this._blocks) {
+      if (block.class_id === 1 && pattern.test(block.raw)) {
+        results.push(block);
+      }
+    }
+    return results;
+  }
+  find_transforms_by_name(name) {
+    const game_objects = this.find_game_objects_by_name(name);
+    const transform_ids = [];
+    for (const go of game_objects) {
+      const comp_matches = go.raw.matchAll(/component:[ \t]*\{fileID:[ \t]*(\d+)\}/g);
+      for (const cm of comp_matches) {
+        const comp_block = this.find_by_file_id(cm[1]);
+        if (comp_block && (comp_block.class_id === 4 || comp_block.class_id === 224)) {
+          transform_ids.push(cm[1]);
+          break;
+        }
+      }
+    }
+    return transform_ids;
+  }
+  require_unique_game_object(name_or_id) {
+    if (/^\d+$/.test(name_or_id)) {
+      const block = this.find_by_file_id(name_or_id);
+      if (!block) {
+        return { error: `GameObject with fileID ${name_or_id} not found` };
+      }
+      if (block.class_id !== 1) {
+        return { error: `fileID ${name_or_id} is not a GameObject (class ${block.class_id})` };
+      }
+      return block;
+    }
+    const matches = this.find_game_objects_by_name(name_or_id);
+    if (matches.length === 0) {
+      return { error: `GameObject "${name_or_id}" not found` };
+    }
+    if (matches.length > 1) {
+      const ids = matches.map((b) => b.file_id).join(", ");
+      return { error: `Multiple GameObjects named "${name_or_id}" found (fileIDs: ${ids}). Use numeric fileID to specify which one.` };
+    }
+    return matches[0];
+  }
+  require_unique_transform(name_or_id) {
+    if (/^\d+$/.test(name_or_id)) {
+      const block = this.find_by_file_id(name_or_id);
+      if (!block) {
+        return { error: `Block with fileID ${name_or_id} not found` };
+      }
+      if (block.class_id === 4) {
+        return block;
+      }
+      if (block.class_id === 224) {
+        return block;
+      }
+      if (block.class_id === 1) {
+        const comp_matches = block.raw.matchAll(/component:[ \t]*\{fileID:[ \t]*(\d+)\}/g);
+        for (const cm of comp_matches) {
+          const comp_block = this.find_by_file_id(cm[1]);
+          if (comp_block && (comp_block.class_id === 4 || comp_block.class_id === 224)) {
+            return comp_block;
+          }
+        }
+        return { error: `Transform for GameObject fileID ${name_or_id} not found` };
+      }
+      return { error: `fileID ${name_or_id} is not a GameObject or Transform (class ${block.class_id})` };
+    }
+    const transform_ids = this.find_transforms_by_name(name_or_id);
+    if (transform_ids.length === 0) {
+      return { error: `GameObject "${name_or_id}" not found` };
+    }
+    if (transform_ids.length > 1) {
+      const go_ids = this.find_game_objects_by_name(name_or_id).map((b) => b.file_id).join(", ");
+      return { error: `Multiple GameObjects named "${name_or_id}" found (fileIDs: ${go_ids}). Use numeric fileID to specify which one.` };
+    }
+    const transform = this.find_by_file_id(transform_ids[0]);
+    if (!transform) {
+      return { error: `Transform for "${name_or_id}" not found` };
+    }
+    return transform;
+  }
+  find_prefab_root() {
+    for (const block of this._blocks) {
+      if (block.class_id === 4 && !block.is_stripped && /m_Father:\s*\{fileID:\s*0\}/.test(block.raw)) {
+        const go_match = block.raw.match(/m_GameObject:\s*\{fileID:\s*(\d+)\}/);
+        if (go_match) {
+          const go_block = this.find_by_file_id(go_match[1]);
+          if (go_block) {
+            const name_match = go_block.raw.match(/m_Name:\s*(.+)/);
+            const name = name_match ? name_match[1].trim() : "Prefab";
+            return { game_object: go_block, transform: block, name };
+          }
+        }
+      }
+    }
+    for (const block of this._blocks) {
+      if (block.class_id === 1 && block.is_stripped) {
+        for (const t_block of this._blocks) {
+          if (t_block.class_id === 4 && t_block.is_stripped) {
+            let name = "Variant";
+            for (const pi_block of this._blocks) {
+              if (pi_block.class_id === 1001) {
+                const name_mod = pi_block.raw.match(/propertyPath: m_Name\s*\n\s*value:\s*(.+)/);
+                if (name_mod) {
+                  name = name_mod[1].trim();
+                }
+                break;
+              }
+            }
+            return { game_object: block, transform: t_block, name };
+          }
+        }
+      }
+    }
+    return null;
+  }
+  all_file_ids() {
+    const ids = new Set;
+    for (const block of this._blocks) {
+      const id = block.file_id;
+      if (id !== "0") {
+        ids.add(id);
+      }
+    }
+    return ids;
+  }
+  trace_references(file_id, direction = "both", max_depth = 3) {
+    const edges = [];
+    const visited = new Set;
+    let reverseIndex = null;
+    if (direction === "in" || direction === "both") {
+      reverseIndex = new Map;
+      for (const block of this._blocks) {
+        const refs = block.extract_file_id_refs();
+        for (const ref of refs) {
+          if (!reverseIndex.has(ref))
+            reverseIndex.set(ref, []);
+          reverseIndex.get(ref).push(block.file_id);
+        }
+      }
+    }
+    const queue = [];
+    if (direction === "out" || direction === "both") {
+      queue.push({ id: file_id, depth: 0, dir: "out" });
+    }
+    if (direction === "in" || direction === "both") {
+      queue.push({ id: file_id, depth: 0, dir: "in" });
+    }
+    while (queue.length > 0) {
+      const { id, depth, dir } = queue.shift();
+      if (depth >= max_depth)
+        continue;
+      const visitKey = `${id}:${dir}`;
+      if (visited.has(visitKey))
+        continue;
+      visited.add(visitKey);
+      if (dir === "out") {
+        const block = this.find_by_file_id(id);
+        if (!block)
+          continue;
+        const refs = block.extract_file_id_refs();
+        for (const ref of refs) {
+          const targetBlock = this.find_by_file_id(ref);
+          if (!targetBlock)
+            continue;
+          edges.push({
+            source_file_id: id,
+            target_file_id: ref,
+            source_class_id: block.class_id,
+            target_class_id: targetBlock.class_id,
+            depth: depth + 1
+          });
+          queue.push({ id: ref, depth: depth + 1, dir: "out" });
+        }
+      } else {
+        const sources = reverseIndex?.get(id) || [];
+        for (const sourceId of sources) {
+          const sourceBlock = this.find_by_file_id(sourceId);
+          const targetBlock = this.find_by_file_id(id);
+          if (!sourceBlock || !targetBlock)
+            continue;
+          edges.push({
+            source_file_id: sourceId,
+            target_file_id: id,
+            source_class_id: sourceBlock.class_id,
+            target_class_id: targetBlock.class_id,
+            depth: depth + 1
+          });
+          queue.push({ id: sourceId, depth: depth + 1, dir: "in" });
+        }
+      }
+    }
+    return edges;
+  }
+  append_block(block) {
+    const index = this._blocks.length;
+    this._blocks.push(block);
+    const id = block.file_id;
+    if (id !== "0") {
+      this._id_index.set(id, index);
+    }
+    this._structure_dirty = true;
+  }
+  append_raw(yaml_text) {
+    const parts = yaml_text.split(/(?=--- !u!)/);
+    const new_blocks = [];
+    for (const part of parts) {
+      if (!part.startsWith("--- !u!"))
+        continue;
+      const block = new UnityBlock(part);
+      this.append_block(block);
+      new_blocks.push(block);
+    }
+    return new_blocks;
+  }
+  remove_blocks(file_ids) {
+    const original_count = this._blocks.length;
+    this._blocks = this._blocks.filter((block) => {
+      const id = block.file_id;
+      return !file_ids.has(id);
+    });
+    const removed = original_count - this._blocks.length;
+    if (removed > 0) {
+      this._rebuild_index();
+      this._structure_dirty = true;
+    }
+    return removed;
+  }
+  remove_block(file_id) {
+    const index = this._id_index.get(file_id);
+    if (index === undefined)
+      return false;
+    this._blocks.splice(index, 1);
+    this._rebuild_index();
+    this._structure_dirty = true;
+    return true;
+  }
+  replace_block(index, block) {
+    if (index < 0 || index >= this._blocks.length) {
+      throw new Error(`Block index ${index} out of range (0..${this._blocks.length - 1})`);
+    }
+    const old_id = this._blocks[index].file_id;
+    this._blocks[index] = block;
+    if (old_id !== "0") {
+      this._id_index.delete(old_id);
+    }
+    const new_id = block.file_id;
+    if (new_id !== "0") {
+      this._id_index.set(new_id, index);
+    }
+    this._structure_dirty = true;
+  }
+  add_child_to_parent(parent_id, child_id) {
+    const parent = this.find_by_file_id(parent_id);
+    if (!parent || parent.class_id !== 4)
+      return false;
+    let raw = parent.raw;
+    const inline_empty = /m_Children:\s*\[\]/;
+    if (inline_empty.test(raw)) {
+      raw = raw.replace(inline_empty, `m_Children:
+  - {fileID: ${child_id}}`);
+      parent.replace_raw(raw);
+      return true;
+    }
+    const inline_pattern = /m_Children:\s*\[(.*?)\]/;
+    const inline_match = raw.match(inline_pattern);
+    if (inline_match) {
+      const trimmed = inline_match[1].trim();
+      if (trimmed === "") {
+        raw = raw.replace(inline_pattern, `m_Children:
+  - {fileID: ${child_id}}`);
+      } else {
+        raw = raw.replace(inline_pattern, (match) => {
+          return match.replace("]", "") + `
+  - {fileID: ${child_id}}]`;
+        });
+      }
+      parent.replace_raw(raw);
+      return true;
+    }
+    if (raw.includes("m_Children:") && !raw.includes(`fileID: ${child_id}`)) {
+      raw = raw.replace(/(m_Children:\s*\n(?:\s*-\s*\{fileID:\s*\d+\}\s*\n)*)/, `$1  - {fileID: ${child_id}}
+`);
+      parent.replace_raw(raw);
+      return true;
+    }
+    return false;
+  }
+  remove_child_from_parent(parent_id, child_id) {
+    const parent = this.find_by_file_id(parent_id);
+    if (!parent || parent.class_id !== 4)
+      return false;
+    let raw = parent.raw;
+    const child_line = new RegExp(`\\n[ \\t]*- \\{fileID: ${child_id}\\}`);
+    if (!child_line.test(raw))
+      return false;
+    raw = raw.replace(child_line, "");
+    if (/m_Children:\s*\n\s*m_Father:/.test(raw) || /m_Children:\s*\n\s*m_RootOrder:/.test(raw)) {
+      raw = raw.replace(/m_Children:\s*\n/, `m_Children: []
+`);
+    }
+    parent.replace_raw(raw);
+    return true;
+  }
+  collect_hierarchy(transform_id) {
+    const result = new Set;
+    this._collect_hierarchy_recursive(transform_id, result);
+    return result;
+  }
+  _collect_hierarchy_recursive(transform_id, result) {
+    const transform = this.find_by_file_id(transform_id);
+    if (!transform || transform.class_id !== 4)
+      return;
+    const children_section = transform.raw.match(/m_Children:[\s\S]*?(?=\s*m_Father:)/);
+    if (!children_section)
+      return;
+    const child_ids = [];
+    const child_matches = children_section[0].matchAll(/\{fileID:\s*(\d+)\}/g);
+    for (const m of child_matches) {
+      if (m[1] !== "0")
+        child_ids.push(m[1]);
+    }
+    for (const child_transform_id of child_ids) {
+      result.add(child_transform_id);
+      const child_transform = this.find_by_file_id(child_transform_id);
+      if (child_transform) {
+        const go_match = child_transform.raw.match(/m_GameObject:\s*\{fileID:\s*(\d+)\}/);
+        if (go_match) {
+          const go_id = go_match[1];
+          result.add(go_id);
+          const go_block = this.find_by_file_id(go_id);
+          if (go_block) {
+            const comp_matches = go_block.raw.matchAll(/component:\s*\{fileID:\s*(\d+)\}/g);
+            for (const cm of comp_matches) {
+              result.add(cm[1]);
+            }
+          }
+        }
+      }
+      this._collect_hierarchy_recursive(child_transform_id, result);
+    }
+  }
+  calculate_root_order(parent_id) {
+    if (parent_id === "0") {
+      let count = 0;
+      for (const block of this._blocks) {
+        if (block.class_id === 4 && /m_Father:\s*\{fileID:\s*0\}/.test(block.raw)) {
+          count++;
+        }
+      }
+      return count;
+    }
+    const parent = this.find_by_file_id(parent_id);
+    if (!parent || parent.class_id !== 4)
+      return 0;
+    const children_match = parent.raw.match(/m_Children:[\s\S]*?(?=\s*m_Father:)/);
+    if (children_match) {
+      const entries = children_match[0].match(/\{fileID:\s*\d+\}/g);
+      return entries ? entries.length : 0;
+    }
+    return 0;
+  }
+  reorder_children(parent_id, ordered_child_ids) {
+    const parent = this.find_by_file_id(parent_id);
+    if (!parent || parent.class_id !== 4)
+      return false;
+    let raw = parent.raw;
+    const new_children = ordered_child_ids.map((id) => `  - {fileID: ${id}}`).join(`
+`);
+    const multiline = /m_Children:\n(?:[ \t]*-[^\n]*\n)*/;
+    if (multiline.test(raw)) {
+      raw = raw.replace(multiline, `m_Children:
+${new_children}
+`);
+      parent.replace_raw(raw);
+      return true;
+    }
+    const inline = /m_Children:\s*\[.*?\]/;
+    if (inline.test(raw)) {
+      raw = raw.replace(inline, `m_Children:
+${new_children}`);
+      parent.replace_raw(raw);
+      return true;
+    }
+    return false;
+  }
+  reorder_entities(ordered_transform_ids) {
+    const entity_groups = [];
+    for (const transform_id of ordered_transform_ids) {
+      const transform = this.find_by_file_id(transform_id);
+      if (!transform)
+        continue;
+      const go_match = transform.raw.match(/m_GameObject:\s*\{fileID:\s*(\d+)\}/);
+      if (!go_match)
+        continue;
+      const go_id = go_match[1];
+      const go = this.find_by_file_id(go_id);
+      if (!go)
+        continue;
+      const comp_ids = [];
+      const comp_matches = go.raw.matchAll(/component:\s*\{fileID:\s*(\d+)\}/g);
+      for (const m of comp_matches) {
+        comp_ids.push(m[1]);
+      }
+      entity_groups.push([go_id, ...comp_ids]);
+    }
+    const all_entity_ids = new Set(entity_groups.flat());
+    if (all_entity_ids.size === 0)
+      return;
+    let insert_pos = -1;
+    for (let i = 0;i < this._blocks.length; i++) {
+      if (all_entity_ids.has(this._blocks[i].file_id)) {
+        insert_pos = i;
+        break;
+      }
+    }
+    if (insert_pos === -1)
+      return;
+    const removed = new Map;
+    this._blocks = this._blocks.filter((b) => {
+      if (all_entity_ids.has(b.file_id)) {
+        removed.set(b.file_id, b);
+        return false;
+      }
+      return true;
+    });
+    const ordered_blocks = [];
+    for (const group of entity_groups) {
+      for (const id of group) {
+        const block = removed.get(id);
+        if (block)
+          ordered_blocks.push(block);
+      }
+    }
+    this._blocks.splice(insert_pos, 0, ...ordered_blocks);
+    this._rebuild_index();
+    this._structure_dirty = true;
+  }
+  generate_file_id() {
+    const existing = this.all_file_ids();
+    let id;
+    do {
+      const numeric = Math.floor(Math.random() * 9000000000) + 1e9;
+      id = String(numeric);
+    } while (existing.has(id) || id === "0");
+    return id;
+  }
+  remap_file_ids(id_map, block_ids) {
+    for (const block of this._blocks) {
+      if (block_ids.has(block.file_id)) {
+        for (const [old_id, new_id] of id_map) {
+          block.remap_file_id(old_id, new_id);
+        }
+      }
+    }
+    this._rebuild_index();
+    this._structure_dirty = true;
+  }
+  serialize() {
+    return this._header + this._blocks.map((b) => b.raw).join("");
+  }
+  validate() {
+    const content = this.serialize();
+    if (!content.startsWith("%YAML 1.1")) {
+      return false;
+    }
+    const invalid_guids = content.match(/guid:\s*[a-f0-9]{1,29}\b/g);
+    if (invalid_guids) {
+      return false;
+    }
+    const block_opens = (content.match(/--- !u!/g) || []).length;
+    const block_closes = (content.match(/\n---(?!u!)/g) || []).length;
+    if (Math.abs(block_opens - block_closes) > 1) {
+      return false;
+    }
+    return true;
+  }
+  save(file_path) {
+    const target = file_path ?? this.file_path;
+    if (!target) {
+      return { success: false, error: "No file path specified and document was not loaded from a file" };
+    }
+    const content = this.serialize();
+    const result = atomicWrite(target, content);
+    return {
+      success: result.success,
+      bytes_written: result.bytes_written,
+      error: result.error
+    };
+  }
+}
+
+// src/build-version.ts
+var fs = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+function parse_version(versionString) {
+  const match = versionString.match(/^(\d+)\.(\d+)\.(\d+)([abfp])(\d+)$/);
+  if (!match) {
+    throw new Error(`Invalid Unity version format: ${versionString}`);
+  }
+  return {
+    raw: versionString,
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    releaseType: match[4],
+    revision: parseInt(match[5], 10)
+  };
+}
+function read_project_version(projectPath) {
+  const versionFile = path4.join(projectPath, "ProjectSettings", "ProjectVersion.txt");
+  if (!fs.existsSync(versionFile)) {
+    throw new Error(`ProjectVersion.txt not found at: ${versionFile}`);
+  }
+  const content = fs.readFileSync(versionFile, "utf-8").replace(/\r\n/g, `
+`);
+  const versionMatch = content.match(/m_EditorVersion:\s*(.+)/);
+  if (!versionMatch) {
+    throw new Error("Could not parse m_EditorVersion from ProjectVersion.txt");
+  }
+  const version = parse_version(versionMatch[1].trim());
+  const revisionMatch = content.match(/m_EditorVersionWithRevision:\s*(.+)/);
+  if (revisionMatch) {
+    version.fullRevision = revisionMatch[1].trim();
+  }
+  return version;
+}
+
+// src/editor/create.ts
+function get_layer_from_parent(doc, parentTransformId) {
+  if (parentTransformId === "0")
+    return 0;
+  const parentTransform = doc.find_by_file_id(parentTransformId);
+  if (!parentTransform)
+    return 0;
+  const goMatch = parentTransform.raw.match(/m_GameObject:\s*\{fileID:\s*(\d+)\}/);
+  if (!goMatch)
+    return 0;
+  const parentGo = doc.find_by_file_id(goMatch[1]);
+  if (!parentGo)
+    return 0;
+  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) {
+  return `--- !u!1 &${gameObjectId}
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
-  - component: {fileID: 519420032}
-  - component: {fileID: 519420031}
-  - component: {fileID: 519420029}
-  m_Layer: 0
-  m_Name: Main Camera
-  m_TagString: MainCamera
+  - component: {fileID: ${transformId}}
+  m_Layer: ${layer}
+  m_Name: ${name}
+  m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
---- !u!4 &519420032
+--- !u!4 &${transformId}
 Transform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 519420028}
+  m_GameObject: {fileID: ${gameObjectId}}
   serializedVersion: 2
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_ConstrainProportionsScale: 0
   m_Children: []
-  m_Father: {fileID: 0}
-  m_RootOrder: 0
+  m_Father: {fileID: ${parentTransformId}}
+  m_RootOrder: ${rootOrder}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!20 &519420031
-Camera:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 519420028}
-  m_Enabled: 1
-  serializedVersion: 2
+`;
+}
+function findTransformIdByName(doc, objectName) {
+  const transformIds = doc.find_transforms_by_name(objectName);
+  if (transformIds.length === 0) {
+    for (const block of doc.blocks) {
+      if (block.class_id !== 1001)
+        continue;
+      const nameInMods = block.raw.match(/propertyPath:\s*m_Name\s*\n\s*value:\s*(.+)/);
+      if (nameInMods && nameInMods[1].trim() === objectName) {
+        const stripped = findStrippedRootTransform(doc, block.file_id);
+        if (stripped)
+          return stripped.transformId;
+      }
+    }
+    return null;
+  }
+  if (transformIds.length > 1) {
+    const gameObjects = doc.find_game_objects_by_name(objectName);
+    const ids = gameObjects.map((go) => go.file_id).join(", ");
+    return { error: `Multiple GameObjects named "${objectName}" found (fileIDs: ${ids}). Use numeric fileID to specify which one.` };
+  }
+  return transformIds[0];
+}
+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+)\}/);
+    if (piMatch && piMatch[1] === prefabInstanceId) {
+      const sourceMatch = block.raw.match(/m_CorrespondingSourceObject:\s*(\{[^}]+\})/);
+      if (sourceMatch) {
+        return {
+          transformId: block.file_id,
+          sourceRef: sourceMatch[1]
+        };
+      }
+    }
+  }
+  return null;
+}
+function appendToAddedGameObjects(doc, piId, targetSourceRef, newGoId) {
+  const piBlock = doc.find_by_file_id(piId);
+  if (!piBlock)
+    return;
+  const entry = `
+    - targetCorrespondingSourceObject: ${targetSourceRef}
+      insertIndex: -1
+      addedObject: {fileID: ${newGoId}}`;
+  let raw = piBlock.raw;
+  const emptyPattern = /m_AddedGameObjects:\s*\[\]/;
+  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_|$))*)/;
+  if (existingPattern.test(raw)) {
+    raw = raw.replace(existingPattern, `$1${entry}`);
+    piBlock.replace_raw(raw);
+  }
+}
+var COMPONENT_DEFAULTS = {
+  20: `  serializedVersion: 2
   m_ClearFlags: 1
   m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
   m_projectionMatrixMode: 1
-  m_GateFitMode: 2
   m_FOVAxisMode: 0
-  m_Iso: 200
-  m_ShutterSpeed: 0.005
-  m_Aperture: 16
-  m_FocusDistance: 10
-  m_FocalLength: 50
-  m_BladeCount: 5
-  m_Curvature: {x: 2, y: 11}
-  m_BarrelClipping: 0.25
-  m_Anamorphism: 0
-  m_SensorSize: {x: 36, y: 24}
-  m_LensShift: {x: 0, y: 0}
-  m_NormalizedViewPortRect:
-    serializedVersion: 2
-    x: 0
-    y: 0
-    width: 1
-    height: 1
   near clip plane: 0.3
   far clip plane: 1000
   field of view: 60
   orthographic: 0
   orthographic size: 5
-  m_Depth: -1
-  m_CullingMask:
-    serializedVersion: 2
-    m_Bits: 4294967295
-  m_RenderingPath: -1
-  m_TargetTexture: {fileID: 0}
-  m_TargetDisplay: 0
-  m_TargetEye: 3
-  m_HDR: 1
-  m_AllowMSAA: 1
-  m_AllowDynamicResolution: 0
-  m_ForceIntoRT: 0
-  m_OcclusionCulling: 1
-  m_StereoConvergence: 10
-  m_StereoSeparation: 0.022
---- !u!81 &519420029
-AudioListener:
+  m_Depth: -1`,
+  23: `  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_Materials:
+  - {fileID: 0}`,
+  33: `  m_Mesh: {fileID: 0}`,
+  54: `  m_Mass: 1
+  m_Drag: 0
+  m_AngularDrag: 0.05
+  m_UseGravity: 1
+  m_IsKinematic: 0`,
+  64: `  m_IsTrigger: 0
+  m_Convex: 0
+  m_CookingOptions: 30
+  m_Mesh: {fileID: 0}`,
+  65: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Center: {x: 0, y: 0, z: 0}
+  m_Size: {x: 1, y: 1, z: 1}`,
+  82: `  m_PlayOnAwake: 1
+  m_Volume: 1
+  m_Pitch: 1
+  m_Loop: 0
+  m_Mute: 0
+  m_Priority: 128`,
+  96: `  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_Materials:
+  - {fileID: 0}
+  m_Time: 5
+  m_MinVertexDistance: 0.1`,
+  108: `  m_LightType: 1
+  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_Shadows: 2`,
+  111: `  m_Controller: {fileID: 0}`,
+  121: `  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_Materials:
+  - {fileID: 0}`,
+  135: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Center: {x: 0, y: 0, z: 0}
+  m_Radius: 0.5`,
+  136: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Center: {x: 0, y: 0, z: 0}
+  m_Radius: 0.5
+  m_Height: 2
+  m_Direction: 1`,
+  137: `  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_Quality: 0
+  m_Materials:
+  - {fileID: 0}`,
+  143: `  m_Height: 2
+  m_Radius: 0.5
+  m_SlopeLimit: 45
+  m_StepOffset: 0.3
+  m_SkinWidth: 0.08
+  m_Center: {x: 0, y: 0, z: 0}`,
+  198: `  m_PlayOnAwake: 1`,
+  205: `  serializedVersion: 2
+  m_FadeMode: 0
+  m_AnimateCrossFading: 0`,
+  212: `  m_CastShadows: 0
+  m_ReceiveShadows: 0
+  m_Materials:
+  - {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}`,
+  222: ``,
+  223: `  m_RenderMode: 0
+  m_PixelPerfect: 0
+  m_SortingOrder: 0`,
+  225: `  m_Alpha: 1
+  m_Interactable: 1
+  m_BlocksRaycasts: 1
+  m_IgnoreParentGroups: 0`
+};
+function createGenericComponentYAML(componentName, classId, componentId, gameObjectId) {
+  const defaults = COMPONENT_DEFAULTS[classId] ? `
+` + COMPONENT_DEFAULTS[classId] + `
+` : "";
+  return `--- !u!${classId} &${componentId}
+${componentName}:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 519420028}
+  m_GameObject: {fileID: ${gameObjectId}}
   m_Enabled: 1
---- !u!1 &705507993
+${defaults}`;
+}
+function addComponentToGameObject(doc, gameObjectId, componentId) {
+  const goBlock = doc.find_by_file_id(gameObjectId);
+  if (!goBlock)
+    return;
+  let raw = goBlock.raw;
+  raw = raw.replace(/(m_Component:\s*\n(?:\s*-\s*component:\s*\{fileID:\s*\d+\}\s*\n)*)/, `$1  - component: {fileID: ${componentId}}
+`);
+  goBlock.replace_raw(raw);
+}
+function createMonoBehaviourYAML(componentId, gameObjectId, scriptGuid, fields, version) {
+  const field_yaml = fields && fields.length > 0 ? generate_field_yaml(fields, version) : `
+`;
+  return `--- !u!114 &${componentId}
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: ${gameObjectId}}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: ${scriptGuid}, type: 3}
+  m_Name:
+  m_EditorClassIdentifier:${field_yaml}`;
+}
+function createGameObject(options) {
+  const { file_path, name, parent } = options;
+  const pathError = validate_file_path(file_path, "write");
+  if (pathError) {
+    return { success: false, file_path, error: pathError };
+  }
+  if (!name || name.trim() === "") {
+    return {
+      success: false,
+      file_path,
+      error: "GameObject name cannot be empty"
+    };
+  }
+  const nameError = validate_name(name, "GameObject name");
+  if (nameError) {
+    return { success: false, file_path, error: nameError };
+  }
+  if (!import_fs10.existsSync(file_path)) {
+    return {
+      success: false,
+      file_path,
+      error: `File not found: ${file_path}`
+    };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return {
+      success: false,
+      file_path,
+      error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  let parentTransformIdStr = "0";
+  if (parent !== undefined) {
+    if (typeof parent === "number") {
+      const parentIdStr = String(parent);
+      const parentBlock = doc.find_by_file_id(parentIdStr);
+      if (!parentBlock) {
+        return {
+          success: false,
+          file_path,
+          error: `Parent with fileID ${parent} not found. Provide a GameObject or Transform fileID.`
+        };
+      }
+      if (parentBlock.class_id === 4) {
+        parentTransformIdStr = parentIdStr;
+      } else if (parentBlock.class_id === 1) {
+        const compMatch = parentBlock.raw.match(/m_Component:\s*\n\s*-\s*component:\s*\{fileID:\s*(\d+)\}/);
+        if (compMatch) {
+          parentTransformIdStr = compMatch[1];
+        } else {
+          return {
+            success: false,
+            file_path,
+            error: `Parent with fileID ${parent} not found. Provide a GameObject or Transform fileID.`
+          };
+        }
+      } else {
+        return {
+          success: false,
+          file_path,
+          error: `Parent with fileID ${parent} is not a GameObject or Transform.`
+        };
+      }
+    } else {
+      const foundResult = findTransformIdByName(doc, parent);
+      if (foundResult === null) {
+        return {
+          success: false,
+          file_path,
+          error: `Parent GameObject "${parent}" not found`
+        };
+      }
+      if (typeof foundResult === "object") {
+        return { success: false, file_path, error: foundResult.error };
+      }
+      parentTransformIdStr = foundResult;
+    }
+  }
+  let variantPiId;
+  let strippedSourceRef;
+  const prefabInstanceBlocks = doc.find_by_class_id(1001);
+  if (prefabInstanceBlocks.length > 0 && parentTransformIdStr === "0") {
+    const piId = prefabInstanceBlocks[0].file_id;
+    const strippedInfo = findStrippedRootTransform(doc, piId);
+    if (strippedInfo) {
+      parentTransformIdStr = strippedInfo.transformId;
+      strippedSourceRef = strippedInfo.sourceRef;
+      variantPiId = piId;
+    }
+  }
+  const rootOrder = doc.calculate_root_order(parentTransformIdStr);
+  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 newBlocks = createGameObjectYAML(gameObjectId, transformId, name.trim(), parentTransformId, rootOrder, layer);
+  doc.append_raw(newBlocks);
+  if (parentTransformIdStr !== "0" && !variantPiId) {
+    doc.add_child_to_parent(parentTransformIdStr, transformIdStr);
+  }
+  if (variantPiId && strippedSourceRef) {
+    appendToAddedGameObjects(doc, variantPiId, strippedSourceRef, gameObjectIdStr);
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return {
+      success: false,
+      file_path,
+      error: saveResult.error
+    };
+  }
+  return {
+    success: true,
+    file_path,
+    game_object_id: gameObjectId,
+    transform_id: transformId,
+    prefab_instance_id: variantPiId ? parseInt(variantPiId, 10) : undefined
+  };
+}
+function createScene(options) {
+  const { output_path, include_defaults, scene_guid } = options;
+  const pathError = validate_file_path(output_path, "write");
+  if (pathError) {
+    return { success: false, output_path, error: pathError };
+  }
+  if (!output_path.endsWith(".unity")) {
+    return {
+      success: false,
+      output_path,
+      error: "Output path must have .unity extension"
+    };
+  }
+  if (import_fs10.existsSync(output_path)) {
+    return {
+      success: false,
+      output_path,
+      error: `File already exists: ${output_path}. Delete it first or choose a different path.`
+    };
+  }
+  const guid = scene_guid || generateGuid();
+  let yaml = `%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 12
+  m_GIWorkflowMode: 1
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 512
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 256
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 1
+    m_PVRDenoiserTypeDirect: 1
+    m_PVRDenoiserTypeIndirect: 1
+    m_PVRDenoiserTypeAO: 1
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+    m_LightProbeSampleCountMultiplier: 4
+  m_LightingDataAsset: {fileID: 0}
+  m_LightingSettings: {fileID: 0}
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 3
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    buildHeightMesh: 0
+    maxJobWorkers: 0
+    preserveTilesOutsideBounds: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+`;
+  if (include_defaults) {
+    yaml += `--- !u!1 &519420028
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
@@ -2369,50 +4052,143 @@ GameObject:
   m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
-  - component: {fileID: 705507995}
-  - component: {fileID: 705507994}
+  - component: {fileID: 519420032}
+  - component: {fileID: 519420031}
+  - component: {fileID: 519420029}
   m_Layer: 0
-  m_Name: Directional Light
-  m_TagString: Untagged
+  m_Name: Main Camera
+  m_TagString: MainCamera
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
---- !u!4 &705507995
+--- !u!4 &519420032
 Transform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 705507993}
+  m_GameObject: {fileID: 519420028}
   serializedVersion: 2
-  m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
-  m_LocalPosition: {x: 0, y: 3, z: 0}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_ConstrainProportionsScale: 0
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 1
-  m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
---- !u!108 &705507994
-Light:
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!20 &519420031
+Camera:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 705507993}
+  m_GameObject: {fileID: 519420028}
   m_Enabled: 1
-  serializedVersion: 10
-  m_Type: 1
-  m_Shape: 0
-  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
-  m_Intensity: 1
-  m_Range: 10
-  m_SpotAngle: 30
-  m_InnerSpotAngle: 21.80208
-  m_CookieSize: 10
-  m_Shadows:
-    m_Type: 2
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_Iso: 200
+  m_ShutterSpeed: 0.005
+  m_Aperture: 16
+  m_FocusDistance: 10
+  m_FocalLength: 50
+  m_BladeCount: 5
+  m_Curvature: {x: 2, y: 11}
+  m_BarrelClipping: 0.25
+  m_Anamorphism: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!81 &519420029
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 519420028}
+  m_Enabled: 1
+--- !u!1 &705507993
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 705507995}
+  - component: {fileID: 705507994}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &705507995
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 705507993}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
+  m_LocalPosition: {x: 0, y: 3, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
+--- !u!108 &705507994
+Light:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 705507993}
+  m_Enabled: 1
+  serializedVersion: 10
+  m_Type: 1
+  m_Shape: 0
+  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_InnerSpotAngle: 21.80208
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 2
     m_Resolution: -1
     m_CustomResolution: -1
     m_Strength: 1
@@ -2459,7 +4235,7 @@ Light:
 `;
   }
   try {
-    import_fs7.writeFileSync(output_path, yaml, "utf-8");
+    import_fs10.writeFileSync(output_path, yaml, "utf-8");
   } catch (err) {
     return {
       success: false,
@@ -2477,11 +4253,11 @@ DefaultImporter:
 `;
   const metaPath = output_path + ".meta";
   try {
-    import_fs7.writeFileSync(metaPath, metaContent, "utf-8");
+    import_fs10.writeFileSync(metaPath, metaContent, "utf-8");
   } catch (err) {
     try {
-      const fs = require("fs");
-      fs.unlinkSync(output_path);
+      const fs2 = require("fs");
+      fs2.unlinkSync(output_path);
     } catch {}
     return {
       success: false,
@@ -2496,4 +4272,2049 @@ DefaultImporter:
     meta_path: metaPath
   };
 }
+function createPrefabVariant(options) {
+  const { source_prefab, output_path, variant_name } = options;
+  if (!import_fs10.existsSync(source_prefab)) {
+    return {
+      success: false,
+      output_path,
+      error: `Source prefab not found: ${source_prefab}`
+    };
+  }
+  if (!source_prefab.endsWith(".prefab")) {
+    return {
+      success: false,
+      output_path,
+      error: "Source file must be a .prefab file"
+    };
+  }
+  if (!output_path.endsWith(".prefab")) {
+    return {
+      success: false,
+      output_path,
+      error: "Output path must have .prefab extension"
+    };
+  }
+  if (import_fs10.existsSync(output_path)) {
+    return {
+      success: false,
+      output_path,
+      error: `File already exists: ${output_path}. Delete it first or choose a different path.`
+    };
+  }
+  if (import_fs10.existsSync(output_path + ".meta")) {
+    return {
+      success: false,
+      output_path,
+      error: `Meta file already exists: ${output_path}.meta. Delete it first or choose a different path.`
+    };
+  }
+  const metaPath = source_prefab + ".meta";
+  const sourceGuid = extractGuidFromMeta(metaPath);
+  if (!sourceGuid) {
+    return {
+      success: false,
+      output_path,
+      error: `Could not find or read .meta file for source prefab: ${metaPath}`
+    };
+  }
+  let sourceDoc;
+  try {
+    sourceDoc = UnityDocument.from_file(source_prefab);
+  } catch (err) {
+    return {
+      success: false,
+      output_path,
+      error: `Failed to read source prefab: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const rootInfo = sourceDoc.find_prefab_root();
+  if (!rootInfo) {
+    return {
+      success: false,
+      output_path,
+      error: "Could not find root GameObject in source prefab"
+    };
+  }
+  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 finalName = variant_name || `${rootInfo.name} Variant`;
+  const variantYaml = `%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &${strippedGoId} stripped
+GameObject:
+  m_CorrespondingSourceObject: {fileID: ${rootInfo.game_object.file_id}, guid: ${sourceGuid}, type: 3}
+  m_PrefabInstance: {fileID: ${prefabInstanceId}}
+  m_PrefabAsset: {fileID: 0}
+--- !u!4 &${strippedTransformId} stripped
+Transform:
+  m_CorrespondingSourceObject: {fileID: ${rootInfo.transform.file_id}, guid: ${sourceGuid}, type: 3}
+  m_PrefabInstance: {fileID: ${prefabInstanceId}}
+  m_PrefabAsset: {fileID: 0}
+--- !u!1001 &${prefabInstanceId}
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: ${rootInfo.game_object.file_id}, guid: ${sourceGuid}, type: 3}
+      propertyPath: m_Name
+      value: ${finalName}
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+    m_RemovedGameObjects: []
+    m_AddedGameObjects: []
+    m_AddedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: ${sourceGuid}, type: 3}
+`;
+  try {
+    import_fs10.writeFileSync(output_path, variantYaml, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      output_path,
+      error: `Failed to write variant prefab: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const variantGuid = generateGuid();
+  const variantMetaContent = `fileFormatVersion: 2
+guid: ${variantGuid}
+PrefabImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
+`;
+  try {
+    import_fs10.writeFileSync(output_path + ".meta", variantMetaContent, "utf-8");
+  } catch (err) {
+    try {
+      const fs2 = require("fs");
+      fs2.unlinkSync(output_path);
+    } catch {}
+    return {
+      success: false,
+      output_path,
+      error: `Failed to write .meta file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return {
+    success: true,
+    output_path,
+    source_guid: sourceGuid,
+    prefab_instance_id: prefabInstanceId
+  };
+}
+function createScriptableObject(options) {
+  const { output_path, script } = options;
+  const project_path = options.project_path || find_unity_project_root(path5.dirname(output_path)) || undefined;
+  if (!output_path.endsWith(".asset")) {
+    return { success: false, output_path, error: "Output path must have .asset extension" };
+  }
+  if (import_fs10.existsSync(output_path)) {
+    return { success: false, output_path, error: `File already exists: ${output_path}. Delete it first or choose a different path.` };
+  }
+  if (import_fs10.existsSync(output_path + ".meta")) {
+    return { success: false, output_path, error: `Meta file already exists: ${output_path}.meta. Delete it first or choose a different path.` };
+  }
+  const builtInClassId = get_class_id(script);
+  if (builtInClassId !== null) {
+    return { success: false, output_path, error: `"${script}" is a built-in Unity class (class ${builtInClassId}), not a custom script. ScriptableObjects require a custom script that derives from ScriptableObject. Provide a script GUID, .cs file path, or script name with --project.` };
+  }
+  const resolved = resolve_script_with_fields(script, project_path);
+  if (!resolved) {
+    const hints = [];
+    if (project_path) {
+      const cacheExists = load_guid_cache(project_path) !== null;
+      const registryExists = import_fs10.existsSync(path5.join(project_path, ".unity-agentic", "type-registry.json"));
+      if (!cacheExists && !registryExists) {
+        hints.push(`No GUID cache or type registry found at ${path5.join(project_path, ".unity-agentic/")}. Run "unity-agentic-tools setup" first.`);
+      } else if (!registryExists) {
+        hints.push('Type registry not found. Re-run "unity-agentic-tools setup" to rebuild.');
+      }
+    } else {
+      hints.push("No Unity project detected. Provide --project or run from inside a Unity project directory.");
+    }
+    return { success: false, output_path, error: `Script not found: "${script}". Provide a GUID, script path, or script name.${hints.length > 0 ? " " + hints.join(" ") : ""}` };
+  }
+  if (resolved.kind === "enum" || resolved.kind === "interface") {
+    return { success: false, output_path, error: `"${script}" is ${resolved.kind === "enum" ? "an enum" : "an interface"}, not a ScriptableObject.` };
+  }
+  if (resolved.base_class && resolved.base_class !== "ScriptableObject") {
+    return { success: false, output_path, error: `"${script}" extends ${resolved.base_class}, not ScriptableObject. Cannot create as a ScriptableObject asset.` };
+  }
+  let version;
+  if (project_path) {
+    try {
+      version = read_project_version(project_path);
+    } catch {}
+  }
+  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
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: ${resolved.guid}, type: 3}
+  m_Name: ${baseName}
+  m_EditorClassIdentifier:${field_yaml}`;
+  try {
+    import_fs10.writeFileSync(output_path, assetYaml, "utf-8");
+  } catch (err) {
+    return { success: false, output_path, error: `Failed to write asset file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const assetGuid = generateGuid();
+  const metaContent = `fileFormatVersion: 2
+guid: ${assetGuid}
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData:
+  assetBundleName:
+  assetBundleVariant:
+`;
+  try {
+    import_fs10.writeFileSync(output_path + ".meta", metaContent, "utf-8");
+  } catch (err) {
+    try {
+      const fs2 = require("fs");
+      fs2.unlinkSync(output_path);
+    } catch {}
+    return { success: false, output_path, error: `Failed to write .meta file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const result = {
+    success: true,
+    output_path,
+    script_guid: resolved.guid,
+    asset_guid: assetGuid
+  };
+  if (resolved.extraction_error) {
+    result.warning = resolved.extraction_error;
+  }
+  return result;
+}
+function createMetaFile(options) {
+  const { script_path } = options;
+  const metaPath = script_path + ".meta";
+  if (!import_fs10.existsSync(script_path)) {
+    return {
+      success: false,
+      meta_path: metaPath,
+      error: `Source file not found: ${script_path}`
+    };
+  }
+  if (import_fs10.existsSync(metaPath)) {
+    return {
+      success: false,
+      meta_path: metaPath,
+      error: `.meta file already exists: ${metaPath}`
+    };
+  }
+  const guid = generateGuid();
+  const metaContent = `fileFormatVersion: 2
+guid: ${guid}
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
+`;
+  try {
+    import_fs10.writeFileSync(metaPath, metaContent, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      meta_path: metaPath,
+      error: `Failed to write .meta file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return {
+    success: true,
+    meta_path: metaPath,
+    guid
+  };
+}
+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;
+  const pathError = validate_file_path(file_path, "write");
+  if (pathError) {
+    return { success: false, file_path, error: pathError };
+  }
+  if (!import_fs10.existsSync(file_path)) {
+    return {
+      success: false,
+      file_path,
+      error: `File not found: ${file_path}`
+    };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return {
+      success: false,
+      file_path,
+      error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const goResult = doc.require_unique_game_object(game_object_name);
+  if ("error" in goResult) {
+    return { success: false, file_path, error: goResult.error };
+  }
+  const gameObjectIdStr = goResult.file_id;
+  const gameObjectId = parseInt(gameObjectIdStr, 10);
+  const classId = get_class_id(component_type);
+  let duplicateWarning;
+  const goBlock = doc.find_by_file_id(gameObjectIdStr);
+  if (goBlock && classId !== null) {
+    const compRefs = [...goBlock.raw.matchAll(/component:\s*\{fileID:\s*(\d+)\}/g)].map((m) => m[1]);
+    for (const refId of compRefs) {
+      const compBlock = doc.find_by_file_id(refId);
+      if (compBlock && compBlock.class_id === classId) {
+        duplicateWarning = `GameObject already has a ${component_type} component (fileID: ${refId}). Adding duplicate.`;
+        break;
+      }
+    }
+  }
+  const componentIdStr = doc.generate_file_id();
+  const componentId = parseInt(componentIdStr, 10);
+  let componentYAML;
+  let scriptGuid;
+  let scriptPath;
+  let extractionError;
+  if (classId !== null) {
+    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);
+    if (!resolved) {
+      const hints = [];
+      if (project_path) {
+        const cacheExists = load_guid_cache(project_path) !== null;
+        const registryExists = import_fs10.existsSync(path5.join(project_path, ".unity-agentic", "type-registry.json"));
+        if (!cacheExists && !registryExists) {
+          hints.push(`No GUID cache or type registry found at ${path5.join(project_path, ".unity-agentic/")}. Run "unity-agentic-tools setup" first.`);
+        } else if (!registryExists) {
+          hints.push('Type registry not found. Re-run "unity-agentic-tools setup" to rebuild.');
+        }
+      } else {
+        hints.push("No Unity project detected. Provide --project or run from inside a Unity project directory.");
+      }
+      return {
+        success: false,
+        file_path,
+        error: `Component or script not found: "${component_type}". Use a Unity component name (e.g., "MeshRenderer", "Animator") or provide a script name, path (Assets/Scripts/Foo.cs), or GUID.${hints.length > 0 ? " " + hints.join(" ") : ""}`
+      };
+    }
+    if (resolved.kind === "enum" || resolved.kind === "interface") {
+      return {
+        success: false,
+        file_path,
+        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)) {
+      return {
+        success: false,
+        file_path,
+        error: `"${component_type}" extends ${resolved.base_class}, not MonoBehaviour. Cannot add as a component.`
+      };
+    }
+    let version;
+    if (project_path) {
+      try {
+        version = read_project_version(project_path);
+      } catch {}
+    }
+    componentYAML = createMonoBehaviourYAML(componentId, gameObjectId, resolved.guid, resolved.fields, version);
+    scriptGuid = resolved.guid;
+    scriptPath = resolved.path || undefined;
+    extractionError = resolved.extraction_error;
+  }
+  addComponentToGameObject(doc, gameObjectIdStr, componentIdStr);
+  doc.append_raw(componentYAML);
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return {
+      success: false,
+      file_path,
+      error: saveResult.error
+    };
+  }
+  const warnings = [];
+  if (duplicateWarning)
+    warnings.push(duplicateWarning);
+  if (extractionError)
+    warnings.push(extractionError);
+  const result = {
+    success: true,
+    file_path,
+    component_id: componentId,
+    script_guid: scriptGuid,
+    script_path: scriptPath
+  };
+  if (warnings.length > 0) {
+    result.warning = warnings.join(" ");
+  }
+  return result;
+}
+function copyComponent(options) {
+  const { file_path, source_file_id, target_game_object_name } = options;
+  if (!import_fs10.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const sourceBlock = doc.find_by_file_id(source_file_id);
+  if (!sourceBlock) {
+    return { success: false, file_path, error: `Component with file ID ${source_file_id} not found` };
+  }
+  if (sourceBlock.class_id === 1) {
+    return { success: false, file_path, error: "Cannot copy a GameObject. Use duplicate instead." };
+  }
+  if (sourceBlock.class_id === 4) {
+    return { success: false, file_path, error: "Cannot copy a Transform component." };
+  }
+  const targetResult = doc.require_unique_game_object(target_game_object_name);
+  if ("error" in targetResult) {
+    return { success: false, file_path, error: targetResult.error };
+  }
+  const targetGoIdStr = targetResult.file_id;
+  const targetGoId = parseInt(targetGoIdStr, 10);
+  const newIdStr = doc.generate_file_id();
+  const newId = parseInt(newIdStr, 10);
+  let clonedBlock = sourceBlock.raw.replace(new RegExp(`^(--- !u!${sourceBlock.class_id} &)${source_file_id}`), `$1${newId}`);
+  clonedBlock = clonedBlock.replace(/m_GameObject:\s*\{fileID:\s*\d+\}/, `m_GameObject: {fileID: ${targetGoId}}`);
+  addComponentToGameObject(doc, targetGoIdStr, newIdStr);
+  doc.append_raw(clonedBlock);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after copying component" };
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    source_file_id,
+    new_component_id: newId,
+    target_game_object: target_game_object_name
+  };
+}
+// src/editor/update.ts
+var import_fs11 = require("fs");
+function eulerToQuaternion(euler) {
+  const deg2rad = Math.PI / 180;
+  const x = euler.x * deg2rad;
+  const y = euler.y * deg2rad;
+  const z = euler.z * deg2rad;
+  const cx = Math.cos(x / 2);
+  const sx = Math.sin(x / 2);
+  const cy = Math.cos(y / 2);
+  const sy = Math.sin(y / 2);
+  const cz = Math.cos(z / 2);
+  const sz = Math.sin(z / 2);
+  return {
+    x: sx * cy * cz + cx * sy * sz,
+    y: cx * sy * cz - sx * cy * sz,
+    z: cx * cy * sz - sx * sy * cz,
+    w: cx * cy * cz + sx * sy * sz
+  };
+}
+function validate_value_type(current_value, new_value) {
+  const current = current_value.trim();
+  const incoming = new_value.trim();
+  if (/^\{fileID:/.test(current)) {
+    if (!/^\{fileID:/.test(incoming)) {
+      return `Expected a reference value ({fileID: ...}), got "${incoming}"`;
+    }
+    return null;
+  }
+  if (/^\{.+:.+\}$/.test(current)) {
+    if (!incoming.startsWith("{") || !incoming.endsWith("}")) {
+      return `Expected a compound value (e.g. {x: ..., y: ...}), got "${incoming}"`;
+    }
+    const inner = incoming.slice(1, -1).trim();
+    if (inner.length > 0) {
+      const fields = inner.split(",");
+      for (const field of fields) {
+        const kv = field.split(":");
+        if (kv.length < 2) {
+          return `Malformed struct field in "${incoming}" \u2014 expected "key: value" pairs`;
+        }
+        const val = kv.slice(1).join(":").trim();
+        if (!/^-?\d+(\.\d+)?(e[+-]?\d+)?$/i.test(val) && !/^\{fileID:/.test(val)) {
+          return `Non-numeric value "${val}" in struct "${incoming}" \u2014 expected numeric or {fileID: N}`;
+        }
+      }
+    }
+    return null;
+  }
+  if (/^\[/.test(current) || /^\n?\s*-\s/.test(current)) {
+    if (!incoming.startsWith("[") && incoming !== "[]") {
+      return `Expected an array value (e.g. [] or [...]), got "${incoming}"`;
+    }
+    return null;
+  }
+  if (/^-?\d+(\.\d+)?(e[+-]?\d+)?$/i.test(current)) {
+    if (!/^-?\d+(\.\d+)?(e[+-]?\d+)?$/i.test(incoming)) {
+      return `Expected numeric value, got "${incoming}"`;
+    }
+    return null;
+  }
+  return null;
+}
+function isAncestor(doc, childTransformId, candidateAncestorTransformId) {
+  let currentId = candidateAncestorTransformId;
+  const visited = new Set;
+  while (currentId !== "0") {
+    if (currentId === childTransformId)
+      return true;
+    if (visited.has(currentId))
+      return false;
+    visited.add(currentId);
+    const block = doc.find_by_file_id(currentId);
+    if (!block || block.class_id !== 4)
+      break;
+    const fatherMatch = block.raw.match(/m_Father:\s*\{fileID:\s*(\d+)\}/);
+    currentId = fatherMatch ? fatherMatch[1] : "0";
+  }
+  return false;
+}
+function resolveTransformByGameObjectId(doc, gameObjectFileId) {
+  const found = doc.find_by_file_id(gameObjectFileId);
+  if (!found || found.class_id !== 1) {
+    return { error: `GameObject with fileID ${gameObjectFileId} not found` };
+  }
+  const componentMatch = found.raw.match(/m_Component:\s*\n\s*-\s*component:\s*\{fileID:\s*(\d+)\}/);
+  if (!componentMatch) {
+    return { error: `GameObject fileID ${gameObjectFileId} has no Transform component` };
+  }
+  const transformId = componentMatch[1];
+  const transformBlock = doc.find_by_file_id(transformId);
+  if (!transformBlock || transformBlock.class_id !== 4 && transformBlock.class_id !== 224) {
+    return { error: `First component of GameObject fileID ${gameObjectFileId} is not a Transform` };
+  }
+  return { id: transformId };
+}
+function safeUnityYAMLEdit(filePath, objectName, propertyName, newValue, projectPath) {
+  if (!import_fs11.existsSync(filePath)) {
+    return {
+      success: false,
+      file_path: filePath,
+      error: `File not found: ${filePath}`
+    };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(filePath);
+  } catch (err) {
+    return {
+      success: false,
+      file_path: filePath,
+      error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const normalizedProperty = propertyName.startsWith("m_") ? propertyName.slice(2) : propertyName;
+  const VALID_GO_PROPERTIES = new Set([
+    "Name",
+    "TagString",
+    "IsActive",
+    "Layer",
+    "StaticEditorFlags",
+    "Icon",
+    "NavMeshLayer"
+  ]);
+  if (!VALID_GO_PROPERTIES.has(normalizedProperty)) {
+    const validList = [...VALID_GO_PROPERTIES].map((p) => `m_${p}`).join(", ");
+    return {
+      success: false,
+      file_path: filePath,
+      error: `Unknown GameObject property "m_${normalizedProperty}". Valid properties: ${validList}`
+    };
+  }
+  const BUILTIN_TAGS = ["Untagged", "Respawn", "Finish", "EditorOnly", "MainCamera", "Player", "GameController"];
+  const GO_PROP_VALIDATORS = {
+    IsActive: (v) => v === "0" || v === "1" || v === "true" || v === "false" ? null : "must be 0, 1, true, or false",
+    Layer: (v) => /^\d+$/.test(v) && parseInt(v) >= 0 && parseInt(v) <= 31 ? null : "must be an integer 0-31",
+    StaticEditorFlags: (v) => /^\d+$/.test(v) ? null : "must be a non-negative integer",
+    TagString: (v) => {
+      if (BUILTIN_TAGS.includes(v))
+        return null;
+      if (projectPath) {
+        try {
+          const settings = read_settings({ project_path: projectPath, setting: "tags" });
+          const tags = settings?.data?.tags || [];
+          if (tags.includes(v))
+            return null;
+          return `tag "${v}" not found in project TagManager. Valid tags: ${[...BUILTIN_TAGS, ...tags].join(", ")}`;
+        } catch {}
+      }
+      return null;
+    }
+  };
+  const validator = GO_PROP_VALIDATORS[normalizedProperty];
+  if (validator) {
+    const error = validator(newValue);
+    if (error) {
+      return {
+        success: false,
+        file_path: filePath,
+        error: `Invalid value "${newValue}" for m_${normalizedProperty}: ${error}`
+      };
+    }
+  }
+  if (normalizedProperty === "IsActive") {
+    if (newValue === "true")
+      newValue = "1";
+    else if (newValue === "false")
+      newValue = "0";
+  }
+  let targetBlock = null;
+  if (/^\d+$/.test(objectName)) {
+    targetBlock = doc.find_by_file_id(objectName);
+    if (!targetBlock) {
+      return {
+        success: false,
+        file_path: filePath,
+        error: `GameObject with fileID ${objectName} not found`
+      };
+    }
+    if (targetBlock.class_id !== 1) {
+      return {
+        success: false,
+        file_path: filePath,
+        error: `fileID ${objectName} is not a GameObject (class ${targetBlock.class_id})`
+      };
+    }
+  } else {
+    const matches = doc.find_game_objects_by_name(objectName);
+    if (matches.length === 0) {
+      return {
+        success: false,
+        file_path: filePath,
+        error: `GameObject "${objectName}" not found in file`
+      };
+    }
+    if (matches.length > 1) {
+      const matchedIds = matches.map((b) => b.file_id).join(", ");
+      return {
+        success: false,
+        file_path: filePath,
+        error: `Multiple GameObjects named "${objectName}" found (fileIDs: ${matchedIds}). Use numeric fileID to specify which one.`
+      };
+    }
+    targetBlock = matches[0];
+  }
+  const propertyPattern = new RegExp(`(^\\s*m_${normalizedProperty}:\\s*)([^\\n]*)`, "m");
+  let updatedRaw = targetBlock.raw;
+  if (propertyPattern.test(updatedRaw)) {
+    updatedRaw = updatedRaw.replace(propertyPattern, `$1${newValue}`);
+  } else {
+    updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, `
+  m_${normalizedProperty}: ${newValue}$1$2`);
+  }
+  targetBlock.replace_raw(updatedRaw);
+  const saveResult = doc.save();
+  return {
+    ...saveResult,
+    file_path: filePath
+  };
+}
+function editProperty(options) {
+  const pathError = validate_file_path(options.file_path, "write");
+  if (pathError) {
+    return { success: false, file_path: options.file_path, error: pathError };
+  }
+  const result = safeUnityYAMLEdit(options.file_path, options.object_name, options.property, options.new_value, options.project_path);
+  if (!result.success) {
+    return result;
+  }
+  return result;
+}
+function editComponentByFileId(options) {
+  const { file_path, file_id, property, new_value } = options;
+  const pathError = validate_file_path(file_path, "write");
+  if (pathError) {
+    return { success: false, file_path, error: pathError };
+  }
+  if (!import_fs11.existsSync(file_path)) {
+    return {
+      success: false,
+      file_path,
+      error: `File not found: ${file_path}`
+    };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return {
+      success: false,
+      file_path,
+      error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const exactProperty = property;
+  let prefixedProperty;
+  if (property.includes(".") || property.includes("Array")) {
+    const rootSegment = property.split(".")[0];
+    prefixedProperty = rootSegment.startsWith("m_") ? property : "m_" + property;
+  } else {
+    prefixedProperty = property.startsWith("m_") ? property : "m_" + property;
+  }
+  const targetBlock = doc.find_by_file_id(file_id);
+  if (!targetBlock) {
+    const hasPrefabInstance = doc.find_by_class_id(1001).length > 0;
+    if (hasPrefabInstance) {
+      return {
+        success: false,
+        file_path,
+        error: `Component with file ID ${file_id} not found. This file contains prefab instances \u2014 the fileID may be from the source prefab. Use \`update override\` to edit variant properties.`
+      };
+    }
+    return {
+      success: false,
+      file_path,
+      error: `Component with file ID ${file_id} not found`
+    };
+  }
+  if (targetBlock.is_stripped) {
+    return {
+      success: false,
+      file_path,
+      error: `Component ${file_id} is a stripped reference in a prefab variant. Use \`update override <file> <prefab_instance_id> <property_path> <value>\` to modify overrides.`
+    };
+  }
+  const classId = targetBlock.class_id;
+  const sameFileRefMatch = new_value.match(/^\{fileID:\s*(\d+)\}$/);
+  if (sameFileRefMatch) {
+    const refId = sameFileRefMatch[1];
+    if (refId !== "0" && !doc.find_by_file_id(refId)) {
+      return {
+        success: false,
+        file_path,
+        error: `fileID ${refId} does not exist in this file`
+      };
+    }
+  }
+  const currentValue = targetBlock.get_property(exactProperty) ?? (exactProperty !== prefixedProperty ? targetBlock.get_property(prefixedProperty) : null);
+  if (currentValue !== null) {
+    const typeError = validate_value_type(currentValue, new_value);
+    if (typeError) {
+      return {
+        success: false,
+        file_path,
+        error: typeError
+      };
+    }
+  }
+  let 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) {
+      return {
+        success: true,
+        file_path,
+        file_id,
+        class_id: classId,
+        bytes_written: 0,
+        no_change: true,
+        message: "Property already has the requested value"
+      };
+    }
+    return {
+      success: false,
+      file_path,
+      error: `Property "${property}" not found in component ${file_id} (class ${classId}). Unity only serializes properties that differ from defaults \u2014 newly created or unmodified components may not have this property in YAML yet. Use 'read gameobject --properties' to see available properties, or set the property in the Unity Editor first to make it serializable.`
+    };
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return {
+      success: false,
+      file_path,
+      error: saveResult.error
+    };
+  }
+  return {
+    success: true,
+    file_path,
+    file_id,
+    class_id: classId,
+    bytes_written: saveResult.bytes_written
+  };
+}
+function editPrefabOverride(options) {
+  const { file_path, prefab_instance, property_path, new_value, object_reference, target } = options;
+  const objRef = object_reference ?? "{fileID: 0}";
+  if (!import_fs11.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const targetBlock = findPrefabInstanceBlock(doc, prefab_instance);
+  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 entryMatch = targetBlock.raw.match(entryPattern);
+  if (entryMatch) {
+    const updatedText2 = targetBlock.raw.replace(entryPattern, `$1${property_path}$2${new_value}$4${objRef}`);
+    targetBlock.replace_raw(updatedText2);
+    const saveResult2 = doc.save();
+    if (!saveResult2.success) {
+      return { success: false, file_path, error: saveResult2.error };
+    }
+    return {
+      success: true,
+      file_path,
+      prefab_instance_id: prefab_instance,
+      property_path,
+      action: "updated"
+    };
+  }
+  let targetRef = target;
+  if (!targetRef) {
+    const rootProp = property_path.split(".")[0];
+    const siblingPattern = new RegExp(`- target:\\s*(\\{[^}]+\\})\\s*\\n\\s*propertyPath:\\s*${rootProp.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "m");
+    const siblingMatch = targetBlock.raw.match(siblingPattern);
+    if (siblingMatch) {
+      targetRef = siblingMatch[1];
+    }
+  }
+  if (!targetRef) {
+    return {
+      success: false,
+      file_path,
+      error: `Cannot infer target for new override "${property_path}". Provide --target (e.g., "{fileID: 400000, guid: ..., type: 3}").`
+    };
+  }
+  if (!/^\{fileID:\s*-?\d+/.test(targetRef)) {
+    return {
+      success: false,
+      file_path,
+      error: `Invalid target reference "${targetRef}". Expected format: {fileID: N, guid: ..., type: T}`
+    };
+  }
+  const newEntry = `    - target: ${targetRef}
+      propertyPath: ${property_path}
+      value: ${new_value}
+      objectReference: ${objRef}`;
+  const removedPattern = /(\n\s*m_RemovedComponents:)/m;
+  const removedMatch = targetBlock.raw.match(removedPattern);
+  let updatedText;
+  if (removedMatch) {
+    updatedText = targetBlock.raw.replace(removedPattern, `
+${newEntry}$1`);
+  } else {
+    const lines = targetBlock.raw.split(`
+`);
+    let lastObjRefIdx = -1;
+    let inModifications = false;
+    for (let i = 0;i < lines.length; i++) {
+      if (/m_Modifications:/.test(lines[i])) {
+        inModifications = true;
+        continue;
+      }
+      if (inModifications && /^\s*objectReference:/.test(lines[i])) {
+        lastObjRefIdx = i;
+      }
+      if (inModifications && /^\s*m_\w+:/.test(lines[i]) && !/objectReference/.test(lines[i]) && !/propertyPath/.test(lines[i])) {
+        if (lastObjRefIdx !== -1)
+          break;
+      }
+    }
+    if (lastObjRefIdx !== -1) {
+      lines.splice(lastObjRefIdx + 1, 0, newEntry);
+      updatedText = lines.join(`
+`);
+    } else {
+      return { success: false, file_path, error: "Could not find insertion point in m_Modifications" };
+    }
+  }
+  targetBlock.replace_raw(updatedText);
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    prefab_instance_id: prefab_instance,
+    property_path,
+    action: "added"
+  };
+}
+function editTransform(options) {
+  const { file_path, transform_id, position, rotation, scale } = options;
+  const pathError = validate_file_path(file_path, "write");
+  if (pathError) {
+    return { success: false, file_path, error: pathError };
+  }
+  if (!import_fs11.existsSync(file_path)) {
+    return {
+      success: false,
+      file_path,
+      error: `File not found: ${file_path}`
+    };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return {
+      success: false,
+      file_path,
+      error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const targetBlock = doc.find_by_file_id(String(transform_id));
+  if (!targetBlock || targetBlock.class_id !== 4) {
+    return {
+      success: false,
+      file_path,
+      error: `Transform with fileID ${transform_id} not found`
+    };
+  }
+  if (targetBlock.is_stripped) {
+    return {
+      success: false,
+      file_path,
+      error: `Transform ${transform_id} is a stripped reference in a prefab variant. Use \`update prefab override <file> <prefab_instance_id> <property_path> <value>\` to modify transform overrides (e.g., "m_LocalPosition.x").`
+    };
+  }
+  let blockText = targetBlock.raw;
+  if (position) {
+    blockText = blockText.replace(/m_LocalPosition:\s*\{[^}]+\}/, `m_LocalPosition: {x: ${position.x}, y: ${position.y}, z: ${position.z}}`);
+  }
+  if (rotation) {
+    const quat = eulerToQuaternion(rotation);
+    blockText = blockText.replace(/m_LocalRotation:\s*\{[^}]+\}/, `m_LocalRotation: {x: ${quat.x}, y: ${quat.y}, z: ${quat.z}, w: ${quat.w}}`);
+    blockText = blockText.replace(/m_LocalEulerAnglesHint:\s*\{[^}]+\}/, `m_LocalEulerAnglesHint: {x: ${rotation.x}, y: ${rotation.y}, z: ${rotation.z}}`);
+  }
+  if (scale) {
+    blockText = blockText.replace(/m_LocalScale:\s*\{[^}]+\}/, `m_LocalScale: {x: ${scale.x}, y: ${scale.y}, z: ${scale.z}}`);
+  }
+  targetBlock.replace_raw(blockText);
+  const saveResult = doc.save();
+  return {
+    ...saveResult,
+    file_path
+  };
+}
+function batchEditProperties(filePath, edits) {
+  if (!import_fs11.existsSync(filePath)) {
+    return {
+      success: false,
+      file_path: filePath,
+      error: `File not found: ${filePath}`
+    };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(filePath);
+  } catch (err) {
+    return {
+      success: false,
+      file_path: filePath,
+      error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const editsByObject = new Map;
+  for (const edit of edits) {
+    const existing = editsByObject.get(edit.object_name) || [];
+    existing.push(edit);
+    editsByObject.set(edit.object_name, existing);
+  }
+  for (const [objectName, objectEdits] of editsByObject) {
+    const matches = doc.find_game_objects_by_name(objectName);
+    if (matches.length === 0) {
+      return {
+        success: false,
+        file_path: filePath,
+        error: `Failed to edit ${objectName}.${objectEdits[0].property}: GameObject "${objectName}" not found in file`
+      };
+    }
+    const targetBlock = matches[0];
+    for (const edit of objectEdits) {
+      const normalizedProperty = edit.property.startsWith("m_") ? edit.property.slice(2) : edit.property;
+      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}`);
+      } else {
+        updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, `
+  m_${normalizedProperty}: ${edit.new_value}$1$2`);
+      }
+      targetBlock.replace_raw(updatedRaw);
+    }
+  }
+  if (!doc.validate()) {
+    return {
+      success: false,
+      file_path: filePath,
+      error: "Validation failed after batch edit"
+    };
+  }
+  const saveResult = doc.save();
+  return {
+    ...saveResult,
+    file_path: filePath
+  };
+}
+function reparentGameObject(options) {
+  const { file_path, object_name, new_parent, by_id } = options;
+  if (!import_fs11.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  let childTransformId;
+  if (by_id || /^\d+$/.test(object_name)) {
+    if (isNaN(parseInt(object_name, 10))) {
+      return { success: false, file_path, error: `Invalid fileID: "${object_name}" \u2014 expected a numeric value` };
+    }
+    const resolved = resolveTransformByGameObjectId(doc, object_name);
+    if ("error" in resolved) {
+      return { success: false, file_path, error: resolved.error };
+    }
+    childTransformId = resolved.id;
+  } else {
+    const childResult = doc.require_unique_transform(object_name);
+    if ("error" in childResult) {
+      return { success: false, file_path, error: childResult.error };
+    }
+    childTransformId = childResult.file_id;
+  }
+  const childBlock = doc.find_by_file_id(childTransformId);
+  if (!childBlock) {
+    return { success: false, file_path, error: `Transform ${childTransformId} not found` };
+  }
+  const fatherMatch = childBlock.raw.match(/m_Father:\s*\{fileID:\s*(\d+)\}/);
+  const oldParentTransformId = fatherMatch ? fatherMatch[1] : "0";
+  let newParentTransformId = "0";
+  if (new_parent.toLowerCase() !== "root") {
+    if (by_id || /^\d+$/.test(new_parent)) {
+      if (isNaN(parseInt(new_parent, 10))) {
+        return { success: false, file_path, error: `Invalid parent fileID: "${new_parent}" \u2014 expected a numeric value, or "root"` };
+      }
+      const resolved = resolveTransformByGameObjectId(doc, new_parent);
+      if ("error" in resolved) {
+        return { success: false, file_path, error: `Parent not found: ${resolved.error}` };
+      }
+      newParentTransformId = resolved.id;
+    } else {
+      const parentResult = doc.require_unique_transform(new_parent);
+      if ("error" in parentResult) {
+        return { success: false, file_path, error: `Parent not found: ${parentResult.error}` };
+      }
+      newParentTransformId = parentResult.file_id;
+    }
+    if (newParentTransformId === childTransformId) {
+      return { success: false, file_path, error: "Cannot reparent a GameObject under itself" };
+    }
+    if (isAncestor(doc, childTransformId, newParentTransformId)) {
+      return { success: false, file_path, error: "Cannot reparent: would create circular hierarchy" };
+    }
+  }
+  if (oldParentTransformId !== "0") {
+    doc.remove_child_from_parent(oldParentTransformId, childTransformId);
+  }
+  const fatherPattern = new RegExp(`(m_Father:\\s*)\\{fileID:\\s*\\d+\\}`);
+  let updatedChildRaw = childBlock.raw.replace(fatherPattern, `$1{fileID: ${newParentTransformId}}`);
+  childBlock.replace_raw(updatedChildRaw);
+  {
+    let newRootOrder;
+    if (newParentTransformId === "0") {
+      newRootOrder = doc.calculate_root_order("0") - 1;
+    } else {
+      newRootOrder = doc.calculate_root_order(newParentTransformId);
+    }
+    childBlock.set_property("m_RootOrder", String(newRootOrder));
+  }
+  if (newParentTransformId !== "0") {
+    doc.add_child_to_parent(newParentTransformId, childTransformId);
+  }
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after reparent" };
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  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)
+  };
+}
+function findPrefabInstanceBlock(doc, identifier) {
+  const asId = doc.find_by_file_id(identifier);
+  if (asId && asId.class_id === 1001)
+    return asId;
+  const piBlocks = doc.find_by_class_id(1001);
+  const escaped = identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const namePattern = new RegExp(`propertyPath:\\s*m_Name\\s+value:\\s*${escaped}\\s`);
+  for (const block of piBlocks) {
+    if (namePattern.test(block.raw))
+      return block;
+  }
+  return null;
+}
+function editArray(options) {
+  const { file_path, file_id, array_property, action, value, index } = options;
+  if (!import_fs11.existsSync(file_path)) {
+    return {
+      success: false,
+      file_path,
+      error: `File not found: ${file_path}`
+    };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return {
+      success: false,
+      file_path,
+      error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const targetBlock = doc.find_by_file_id(file_id);
+  if (!targetBlock) {
+    return {
+      success: false,
+      file_path,
+      error: `Component with file ID ${file_id} not found`
+    };
+  }
+  try {
+    if (action === "insert") {
+      if (value === undefined) {
+        return { success: false, file_path, error: "value is required for insert action" };
+      }
+      const ok = targetBlock.insert_array_element(array_property, index ?? 0, value);
+      if (!ok) {
+        const len = targetBlock.get_array_length(array_property);
+        if (len < 0) {
+          return { success: false, file_path, error: `Array property "${array_property}" not found in component ${file_id}` };
+        }
+        return { success: false, file_path, error: `Index ${index ?? 0} out of bounds for "${array_property}" (array length: ${len})` };
+      }
+    } else if (action === "append") {
+      if (value === undefined) {
+        return { success: false, file_path, error: "value is required for append action" };
+      }
+      const ok = targetBlock.insert_array_element(array_property, -1, value);
+      if (!ok) {
+        const len = targetBlock.get_array_length(array_property);
+        if (len < 0) {
+          return { success: false, file_path, error: `Array property "${array_property}" not found in component ${file_id}` };
+        }
+        return { success: false, file_path, error: `Failed to append to "${array_property}"` };
+      }
+    } else if (action === "remove") {
+      const ok = targetBlock.remove_array_element(array_property, index ?? 0);
+      if (!ok) {
+        const len = targetBlock.get_array_length(array_property);
+        if (len < 0) {
+          return { success: false, file_path, error: `Array property "${array_property}" not found in component ${file_id}` };
+        }
+        return { success: false, file_path, error: `Index ${index ?? 0} out of bounds for "${array_property}" (array length: ${len})` };
+      }
+    } else {
+      return { success: false, file_path, error: `Invalid action "${action}". Must be insert, append, or remove.` };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      file_path,
+      error: `Failed to ${action} array element: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const new_length = targetBlock.get_array_length(array_property);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after array edit" };
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    file_id,
+    array_property,
+    action,
+    new_length
+  };
+}
+function batchEditComponentProperties(filePath, edits) {
+  if (!import_fs11.existsSync(filePath)) {
+    return {
+      success: false,
+      file_path: filePath,
+      error: `File not found: ${filePath}`
+    };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(filePath);
+  } catch (err) {
+    return {
+      success: false,
+      file_path: filePath,
+      error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  for (const edit of edits) {
+    const targetBlock = doc.find_by_file_id(edit.file_id);
+    if (!targetBlock) {
+      return {
+        success: false,
+        file_path: filePath,
+        error: `Component with file ID ${edit.file_id} not found`
+      };
+    }
+    const exactProperty = edit.property;
+    let prefixedProperty;
+    if (edit.property.includes(".") || edit.property.includes("Array")) {
+      const rootSegment = edit.property.split(".")[0];
+      prefixedProperty = rootSegment.startsWith("m_") ? edit.property : "m_" + edit.property;
+    } else {
+      prefixedProperty = edit.property.startsWith("m_") ? edit.property : "m_" + edit.property;
+    }
+    let modified = targetBlock.set_property(exactProperty, edit.new_value, "{fileID: 0}");
+    if (!modified && exactProperty !== prefixedProperty) {
+      modified = targetBlock.set_property(prefixedProperty, edit.new_value, "{fileID: 0}");
+    }
+    if (!modified) {
+      const currentValue = targetBlock.get_property(exactProperty) ?? (exactProperty !== prefixedProperty ? targetBlock.get_property(prefixedProperty) : null);
+      if (currentValue !== null) {
+        continue;
+      }
+      return {
+        success: false,
+        file_path: filePath,
+        error: `Property "${edit.property}" not found in component ${edit.file_id}`
+      };
+    }
+  }
+  if (!doc.validate()) {
+    return {
+      success: false,
+      file_path: filePath,
+      error: "Validation failed after batch edit"
+    };
+  }
+  const saveResult = doc.save();
+  return {
+    ...saveResult,
+    file_path: filePath
+  };
+}
+function removePrefabOverride(options) {
+  const { file_path, prefab_instance, property_path, target } = options;
+  if (!import_fs11.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const targetBlock = findPrefabInstanceBlock(doc, prefab_instance);
+  if (!targetBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  const escapedPath = property_path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  let entryPattern;
+  if (target) {
+    const fileIdMatch = target.match(/fileID:\s*(-?\d+)/);
+    if (fileIdMatch) {
+      const fileId = fileIdMatch[1];
+      entryPattern = new RegExp(`[ \\t]*- target:\\s*\\{fileID:\\s*${fileId}[^}]*\\}\\s*\\n\\s*propertyPath:\\s*${escapedPath}\\s*\\n\\s*value:[^\\n]*\\n\\s*objectReference:[^\\n]*\\n?`, "m");
+    } else {
+      const escapedTarget = target.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      entryPattern = new RegExp(`[ \\t]*- target:\\s*${escapedTarget}\\s*\\n\\s*propertyPath:\\s*${escapedPath}\\s*\\n\\s*value:[^\\n]*\\n\\s*objectReference:[^\\n]*\\n?`, "m");
+    }
+  } else {
+    entryPattern = new RegExp(`[ \\t]*- target:\\s*\\{[^}]+\\}\\s*\\n\\s*propertyPath:\\s*${escapedPath}\\s*\\n\\s*value:[^\\n]*\\n\\s*objectReference:[^\\n]*\\n?`, "m");
+  }
+  const entryMatch = targetBlock.raw.match(entryPattern);
+  if (!entryMatch) {
+    return {
+      success: false,
+      file_path,
+      error: `Modification entry for property "${property_path}" not found${target ? ` with target ${target}` : ""}`
+    };
+  }
+  const updatedRaw = targetBlock.raw.replace(entryPattern, "");
+  targetBlock.replace_raw(updatedRaw);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after removing override" };
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    prefab_instance_id: targetBlock.file_id,
+    property_path
+  };
+}
+function addRemovedComponent(options) {
+  const { file_path, prefab_instance, component_ref } = options;
+  if (!import_fs11.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  if (!/^\{fileID:\s*-?\d+/.test(component_ref)) {
+    return { success: false, file_path, error: `Invalid component reference "${component_ref}". Expected format: {fileID: N, guid: ..., type: T}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const targetBlock = findPrefabInstanceBlock(doc, prefab_instance);
+  if (!targetBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  let rawText = targetBlock.raw;
+  if (/m_RemovedComponents:\s*\[\]/.test(rawText)) {
+    rawText = rawText.replace(/m_RemovedComponents:\s*\[\]/, "m_RemovedComponents:");
+  }
+  const removedPattern = /m_RemovedComponents:\s*\n/;
+  if (removedPattern.test(rawText)) {
+    rawText = rawText.replace(removedPattern, `m_RemovedComponents:
+  - ${component_ref}
+`);
+  } else {
+    return { success: false, file_path, error: "m_RemovedComponents property not found in PrefabInstance" };
+  }
+  targetBlock.replace_raw(rawText);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after adding removed component" };
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    prefab_instance_id: targetBlock.file_id
+  };
+}
+function removeRemovedComponent(options) {
+  const { file_path, prefab_instance, component_ref } = options;
+  if (!import_fs11.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const targetBlock = findPrefabInstanceBlock(doc, prefab_instance);
+  if (!targetBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  const escapedRef = component_ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const refPattern = new RegExp(`\\s*- ${escapedRef}\\n?`, "m");
+  if (!refPattern.test(targetBlock.raw)) {
+    return { success: false, file_path, error: `Component reference "${component_ref}" not found in m_RemovedComponents` };
+  }
+  const updatedRaw = targetBlock.raw.replace(refPattern, "");
+  targetBlock.replace_raw(updatedRaw);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after removing component" };
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    prefab_instance_id: targetBlock.file_id
+  };
+}
+function addRemovedGameObject(options) {
+  const { file_path, prefab_instance, component_ref } = options;
+  if (!import_fs11.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  if (!/^\{fileID:\s*-?\d+/.test(component_ref)) {
+    return { success: false, file_path, error: `Invalid GameObject reference "${component_ref}". Expected format: {fileID: N, guid: ..., type: T}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const targetBlock = findPrefabInstanceBlock(doc, prefab_instance);
+  if (!targetBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  let rawText = targetBlock.raw;
+  if (/m_RemovedGameObjects:\s*\[\]/.test(rawText)) {
+    rawText = rawText.replace(/m_RemovedGameObjects:\s*\[\]/, "m_RemovedGameObjects:");
+  }
+  const removedPattern = /m_RemovedGameObjects:\s*\n/;
+  if (removedPattern.test(rawText)) {
+    rawText = rawText.replace(removedPattern, `m_RemovedGameObjects:
+  - ${component_ref}
+`);
+  } else {
+    return { success: false, file_path, error: "m_RemovedGameObjects property not found in PrefabInstance" };
+  }
+  targetBlock.replace_raw(rawText);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after adding removed GameObject" };
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    prefab_instance_id: targetBlock.file_id
+  };
+}
+function removeRemovedGameObject(options) {
+  const { file_path, prefab_instance, component_ref } = options;
+  if (!import_fs11.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const targetBlock = findPrefabInstanceBlock(doc, prefab_instance);
+  if (!targetBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  const escapedRef = component_ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const refPattern = new RegExp(`\\s*- ${escapedRef}\\n?`, "m");
+  if (!refPattern.test(targetBlock.raw)) {
+    return { success: false, file_path, error: `GameObject reference "${component_ref}" not found in m_RemovedGameObjects` };
+  }
+  const updatedRaw = targetBlock.raw.replace(refPattern, "");
+  targetBlock.replace_raw(updatedRaw);
+  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 };
+  }
+  return {
+    success: true,
+    file_path,
+    prefab_instance_id: targetBlock.file_id
+  };
+}
+// src/editor/delete.ts
+var import_fs12 = require("fs");
+function removeComponent(options) {
+  const { file_path, file_id } = options;
+  const pathError = validate_file_path(file_path, "write");
+  if (pathError) {
+    return { success: false, file_path, error: pathError };
+  }
+  if (!import_fs12.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const found = doc.find_by_file_id(file_id);
+  if (!found) {
+    return { success: false, file_path, error: `Component with file ID ${file_id} not found` };
+  }
+  if (found.class_id === 1) {
+    return { success: false, file_path, error: "Cannot remove a GameObject with remove-component. Use delete instead." };
+  }
+  if (found.class_id === 4) {
+    return { success: false, file_path, error: "Cannot remove a Transform with remove-component. Use delete to remove the entire GameObject." };
+  }
+  const goMatch = found.raw.match(/m_GameObject:\s*\{fileID:\s*(\d+)\}/);
+  if (goMatch) {
+    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 modifiedRaw = goBlock.raw.replace(compLinePattern, "");
+      goBlock.replace_raw(modifiedRaw);
+    }
+  }
+  doc.remove_block(file_id);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after removing component" };
+  }
+  const writeResult = doc.save();
+  if (!writeResult.success) {
+    return { success: false, file_path, error: writeResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    removed_file_id: file_id,
+    removed_class_id: found.class_id
+  };
+}
+function deleteGameObject(options) {
+  const { file_path, object_name } = options;
+  const pathError = validate_file_path(file_path, "write");
+  if (pathError) {
+    return { success: false, file_path, error: pathError };
+  }
+  if (!import_fs12.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const goResult = doc.require_unique_game_object(object_name);
+  if ("error" in goResult) {
+    return { success: false, file_path, error: goResult.error };
+  }
+  const goBlock = goResult;
+  const goId = goBlock.file_id;
+  const componentIds = new Set;
+  const compMatches = goBlock.raw.matchAll(/component:\s*\{fileID:\s*(\d+)\}/g);
+  for (const cm of compMatches) {
+    componentIds.add(cm[1]);
+  }
+  let transformId = null;
+  let fatherId = "0";
+  for (const compId of componentIds) {
+    const block = doc.find_by_file_id(compId);
+    if (block && block.class_id === 4) {
+      transformId = compId;
+      const fatherMatch = block.raw.match(/m_Father:\s*\{fileID:\s*(\d+)\}/);
+      if (fatherMatch) {
+        fatherId = fatherMatch[1];
+      }
+      break;
+    }
+  }
+  const allIds = new Set([goId]);
+  for (const id of componentIds) {
+    allIds.add(id);
+  }
+  if (transformId !== null) {
+    const descendants = doc.collect_hierarchy(transformId);
+    for (const id of descendants) {
+      allIds.add(id);
+    }
+  }
+  if (fatherId !== "0" && transformId !== null) {
+    doc.remove_child_from_parent(fatherId, transformId);
+  }
+  doc.remove_blocks(allIds);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after deleting GameObject" };
+  }
+  const writeResult = doc.save();
+  if (!writeResult.success) {
+    return { success: false, file_path, error: writeResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    deleted_count: allIds.size
+  };
+}
+function findPrefabInstanceBlock2(doc, identifier) {
+  const asId = doc.find_by_file_id(identifier);
+  if (asId && asId.class_id === 1001)
+    return asId;
+  const piBlocks = doc.find_by_class_id(1001);
+  const escaped = identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const namePattern = new RegExp(`propertyPath:\\s*m_Name\\s+value:\\s*${escaped}\\s`);
+  for (const block of piBlocks) {
+    if (namePattern.test(block.raw))
+      return block;
+  }
+  return null;
+}
+function deletePrefabInstance(options) {
+  const { file_path, prefab_instance } = options;
+  const pathError = validate_file_path(file_path, "write");
+  if (pathError) {
+    return { success: false, file_path, error: pathError };
+  }
+  if (!import_fs12.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const piBlock = findPrefabInstanceBlock2(doc, prefab_instance);
+  if (!piBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  const piId = piBlock.file_id;
+  const allToRemove = new Set([piId]);
+  const piRefPattern = new RegExp(`m_PrefabInstance:\\s*\\{fileID:\\s*${piId}\\}`);
+  for (const block of doc.blocks) {
+    if (block.is_stripped && piRefPattern.test(block.raw)) {
+      allToRemove.add(block.file_id);
+    }
+  }
+  const addedGOPattern = /m_AddedGameObjects:\s*\n((?:\s*- \{fileID: \d+\}\n)*)/m;
+  const addedGOMatch = piBlock.raw.match(addedGOPattern);
+  if (addedGOMatch) {
+    const addedGOSection = addedGOMatch[1];
+    const goMatches = addedGOSection.matchAll(/fileID:\s*(\d+)/g);
+    for (const match of goMatches) {
+      const goId = match[1];
+      allToRemove.add(goId);
+      const goBlock = doc.find_by_file_id(goId);
+      if (goBlock) {
+        const compMatch = goBlock.raw.match(/component:\s*\{fileID:\s*(\d+)\}/);
+        if (compMatch) {
+          const transformId = compMatch[1];
+          allToRemove.add(transformId);
+          const descendants = doc.collect_hierarchy(transformId);
+          for (const id of descendants) {
+            allToRemove.add(id);
+          }
+        }
+      }
+    }
+  }
+  const addedCompPattern = /m_AddedComponents:\s*\n((?:\s*- \{fileID: \d+\}\n)*)/m;
+  const addedCompMatch = piBlock.raw.match(addedCompPattern);
+  if (addedCompMatch) {
+    const addedCompSection = addedCompMatch[1];
+    const compMatches = addedCompSection.matchAll(/fileID:\s*(\d+)/g);
+    for (const match of compMatches) {
+      allToRemove.add(match[1]);
+    }
+  }
+  const parentMatch = piBlock.raw.match(/m_TransformParent:\s*\{fileID:\s*(\d+)\}/);
+  const parentTransformId = parentMatch ? parentMatch[1] : "0";
+  let strippedRootTransformId = null;
+  for (const id of allToRemove) {
+    const block = doc.find_by_file_id(id);
+    if (block && block.class_id === 4 && block.is_stripped) {
+      strippedRootTransformId = id;
+      break;
+    }
+  }
+  if (parentTransformId !== "0" && strippedRootTransformId !== null) {
+    doc.remove_child_from_parent(parentTransformId, strippedRootTransformId);
+  }
+  doc.remove_blocks(allToRemove);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after deleting PrefabInstance" };
+  }
+  const writeResult = doc.save();
+  if (!writeResult.success) {
+    return { success: false, file_path, error: writeResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    deleted_count: allToRemove.size
+  };
+}
+// src/editor/duplicate.ts
+var import_fs13 = require("fs");
+var path6 = __toESM(require("path"));
+init_scanner();
+function findPrefabInstanceByName(doc, name) {
+  const piBlocks = doc.find_by_class_id(1001);
+  const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const namePattern = new RegExp(`propertyPath:\\s*m_Name\\s+value:\\s*${escapedName}\\s`);
+  for (const block of piBlocks) {
+    if (namePattern.test(block.raw)) {
+      return { id: parseInt(block.file_id, 10) };
+    }
+  }
+  return null;
+}
+function duplicateGameObject(options) {
+  const { file_path, object_name, new_name } = options;
+  if (!import_fs13.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const goResult = doc.require_unique_game_object(object_name);
+  if ("error" in goResult) {
+    const piMatch = findPrefabInstanceByName(doc, object_name);
+    if (piMatch) {
+      return { success: false, file_path, error: `"${object_name}" is a PrefabInstance (fileID: ${piMatch.id}). Cloning PrefabInstances is not yet supported. Consider unpacking it first with \`update prefab\`.` };
+    }
+    return { success: false, file_path, error: goResult.error };
+  }
+  const goBlock = goResult;
+  const goFileId = goBlock.file_id;
+  const componentIds = [];
+  const compMatches = goBlock.raw.matchAll(/component:\s*\{fileID:\s*(\d+)\}/g);
+  for (const cm of compMatches) {
+    componentIds.push(cm[1]);
+  }
+  let transformId = null;
+  let fatherId = "0";
+  for (const compId of componentIds) {
+    const compBlock = doc.find_by_file_id(compId);
+    if (compBlock && compBlock.class_id === 4) {
+      transformId = compId;
+      const fatherMatch = compBlock.raw.match(/m_Father:\s*\{fileID:\s*(\d+)\}/);
+      if (fatherMatch) {
+        fatherId = fatherMatch[1];
+      }
+      break;
+    }
+  }
+  const allOldIds = new Set([goFileId, ...componentIds]);
+  if (transformId !== null) {
+    const descendants = doc.collect_hierarchy(transformId);
+    for (const id of descendants) {
+      allOldIds.add(id);
+    }
+  }
+  const existing = doc.all_file_ids();
+  const idMap = new Map;
+  for (const oldId of allOldIds) {
+    let newId;
+    do {
+      newId = String(Math.floor(Math.random() * 9000000000) + 1e9);
+    } while (existing.has(newId) || newId === "0");
+    existing.add(newId);
+    idMap.set(oldId, newId);
+  }
+  const rootOrder = transformId !== null ? doc.calculate_root_order(fatherId) : 0;
+  for (const block of doc.blocks) {
+    if (allOldIds.has(block.file_id)) {
+      const cloned = block.clone();
+      for (const [oldId, newId] of idMap) {
+        cloned.remap_file_id(oldId, newId);
+      }
+      doc.append_block(cloned);
+    }
+  }
+  const actualName = goBlock.get_property("m_Name") || object_name;
+  const finalName = new_name || `${actualName} (1)`;
+  const clonedGoBlock = doc.find_by_file_id(idMap.get(goFileId));
+  if (clonedGoBlock) {
+    clonedGoBlock.set_property("m_Name", finalName);
+  }
+  if (transformId !== null) {
+    const clonedTransformBlock = doc.find_by_file_id(idMap.get(transformId));
+    if (clonedTransformBlock) {
+      let raw = clonedTransformBlock.raw;
+      if (/m_RootOrder:\s*\d+/.test(raw)) {
+        raw = raw.replace(/m_RootOrder:\s*\d+/, `m_RootOrder: ${rootOrder}`);
+      } else {
+        raw = raw.replace(/(m_Father:\s*\{fileID:\s*\d+\})/, `$1
+  m_RootOrder: ${rootOrder}`);
+      }
+      clonedTransformBlock.replace_raw(raw);
+    }
+  }
+  const clonedObjects = [];
+  for (const oldId of allOldIds) {
+    const originalBlock = doc.find_by_file_id(oldId);
+    if (originalBlock && originalBlock.class_id === 1) {
+      const newId = idMap.get(oldId);
+      if (newId) {
+        const clonedBlock = doc.find_by_file_id(newId);
+        if (clonedBlock) {
+          const name = clonedBlock.get_property("m_Name") || "";
+          clonedObjects.push({ name, file_id: parseInt(newId, 10) });
+        }
+      }
+    }
+  }
+  const newTransformId = transformId !== null ? idMap.get(transformId) : null;
+  if (fatherId !== "0" && newTransformId !== null) {
+    doc.add_child_to_parent(fatherId, newTransformId);
+  }
+  const warnings = [];
+  const allGoBlocks = doc.find_by_class_id(1);
+  const sceneNameCounts = new Map;
+  for (const block of allGoBlocks) {
+    const n = block.get_property("m_Name") || "";
+    sceneNameCounts.set(n, (sceneNameCounts.get(n) || 0) + 1);
+  }
+  for (const cloned of clonedObjects) {
+    const count = sceneNameCounts.get(cloned.name) || 0;
+    if (count >= 2) {
+      warnings.push(`Duplicate name "${cloned.name}" now appears ${count} times in scene. Use fileID ${cloned.file_id} to target this clone.`);
+    }
+  }
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after duplicating GameObject" };
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    game_object_id: idMap.get(goFileId) ? parseInt(idMap.get(goFileId), 10) : undefined,
+    transform_id: newTransformId ? parseInt(newTransformId, 10) : undefined,
+    total_duplicated: allOldIds.size,
+    cloned_objects: clonedObjects,
+    warnings: warnings.length > 0 ? warnings : undefined
+  };
+}
+function unpackPrefab(options) {
+  const { file_path, prefab_instance, project_path } = options;
+  if (!import_fs13.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let sceneDoc;
+  try {
+    sceneDoc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  let prefabInstanceBlock = null;
+  const asNumber = parseInt(prefab_instance, 10);
+  if (!isNaN(asNumber)) {
+    const block = sceneDoc.find_by_file_id(String(asNumber));
+    if (block && block.class_id === 1001) {
+      prefabInstanceBlock = block;
+    }
+  }
+  if (!prefabInstanceBlock) {
+    const piBlocks = sceneDoc.find_by_class_id(1001);
+    const escapedName = prefab_instance.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const nameModPattern = new RegExp(`propertyPath: m_Name\\s*\\n\\s*value: ${escapedName}\\s*$`, "m");
+    for (const block of piBlocks) {
+      if (nameModPattern.test(block.raw)) {
+        prefabInstanceBlock = block;
+        break;
+      }
+    }
+  }
+  if (!prefabInstanceBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  const prefabInstanceId = prefabInstanceBlock.file_id;
+  const sourcePrefabMatch = prefabInstanceBlock.raw.match(/m_SourcePrefab:[\s\S]*?guid:\s*([a-f0-9]+)/);
+  if (!sourcePrefabMatch) {
+    return { success: false, file_path, error: `Could not find m_SourcePrefab GUID in PrefabInstance block (fileID: ${prefabInstanceId})` };
+  }
+  const sourcePrefabGuid = sourcePrefabMatch[1];
+  let sourcePrefabPath = null;
+  if (project_path) {
+    const guidCache = load_guid_cache_for_file(file_path, project_path);
+    if (guidCache) {
+      const resolvedPath = guidCache.resolve_absolute(sourcePrefabGuid);
+      if (resolvedPath)
+        sourcePrefabPath = resolvedPath;
+    }
+  }
+  if (!sourcePrefabPath || !import_fs13.existsSync(sourcePrefabPath)) {
+    const inferredProject = project_path || find_unity_project_root(path6.dirname(file_path));
+    if (inferredProject) {
+      const nativeBuild = getNativeBuildGuidCache();
+      if (nativeBuild) {
+        try {
+          const freshCache = nativeBuild(inferredProject);
+          if (freshCache[sourcePrefabGuid]) {
+            sourcePrefabPath = path6.join(inferredProject, freshCache[sourcePrefabGuid]);
+          }
+        } catch {}
+      }
+    }
+  }
+  if (!sourcePrefabPath || !import_fs13.existsSync(sourcePrefabPath)) {
+    const searchedPaths = [];
+    if (project_path)
+      searchedPaths.push(`GUID cache: ${path6.join(project_path, ".unity-agentic", "guid-cache.json")}`);
+    const inferredProject = project_path || find_unity_project_root(path6.dirname(file_path));
+    if (inferredProject)
+      searchedPaths.push(`Native GUID rebuild from: ${inferredProject}`);
+    const searchInfo = searchedPaths.length > 0 ? ` Searched: ${searchedPaths.join("; ")}` : "";
+    return { success: false, file_path, error: `Could not resolve source prefab with GUID ${sourcePrefabGuid}.${searchInfo} Provide --project path or run 'unity-agentic-tools setup'.` };
+  }
+  let prefabDoc;
+  try {
+    prefabDoc = UnityDocument.from_file(sourcePrefabPath);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read source prefab: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const prefabIds = prefabDoc.all_file_ids();
+  const existing = sceneDoc.all_file_ids();
+  const idMap = new Map;
+  for (const oldId of prefabIds) {
+    let newId;
+    do {
+      newId = String(Math.floor(Math.random() * 9000000000) + 1e9);
+    } while (existing.has(newId) || newId === "0");
+    existing.add(newId);
+    idMap.set(oldId, newId);
+  }
+  const removedComponents = new Set;
+  const removedSection = prefabInstanceBlock.raw.match(/m_RemovedComponents:\s*\n((?:\s*-\s*\{[^}]+\}\s*\n)*)/);
+  if (removedSection) {
+    const removedMatches = removedSection[1].matchAll(/fileID:\s*(\d+)/g);
+    for (const rm of removedMatches) {
+      removedComponents.add(rm[1]);
+    }
+  }
+  const clonedBlocks = [];
+  for (const block of prefabDoc.blocks) {
+    if (removedComponents.has(block.file_id))
+      continue;
+    const cloned = block.clone();
+    for (const [oldId, newId] of idMap) {
+      cloned.remap_file_id(oldId, newId);
+    }
+    let raw = cloned.raw;
+    raw = raw.replace(/\s*m_CorrespondingSourceObject:\s*\{[^}]+\}\n?/, `
+  m_CorrespondingSourceObject: {fileID: 0}
+`);
+    raw = raw.replace(/\s*m_PrefabInstance:\s*\{[^}]+\}\n?/, `
+  m_PrefabInstance: {fileID: 0}
+`);
+    raw = raw.replace(/\s*m_PrefabAsset:\s*\{[^}]+\}\n?/, `
+  m_PrefabAsset: {fileID: 0}
+`);
+    cloned.replace_raw(raw);
+    clonedBlocks.push(cloned);
+  }
+  const modificationsSection = prefabInstanceBlock.raw.match(/m_Modifications:\s*\n((?:\s*-\s*target:[\s\S]*?(?=\s*m_RemovedComponents:|\s*m_RemovedGameObjects:|\s*m_AddedGameObjects:|\s*m_AddedComponents:|\s*m_SourcePrefab:))?)/);
+  if (modificationsSection) {
+    const modEntries = modificationsSection[1].split(/\n\s*-\s*target:/).filter((s) => s.trim());
+    for (const entry of modEntries) {
+      const targetIdMatch = entry.match(/\{fileID:\s*(\d+)/);
+      const propPathMatch = entry.match(/propertyPath:\s*(.+)/);
+      const valueMatch = entry.match(/value:\s*(.*)/);
+      const objRefMatch = entry.match(/objectReference:\s*(\{[^}]*\})/);
+      if (targetIdMatch && propPathMatch) {
+        const targetOldId = targetIdMatch[1];
+        const targetNewId = idMap.get(targetOldId);
+        if (targetNewId === undefined)
+          continue;
+        const propertyPath = propPathMatch[1].trim();
+        const value = valueMatch ? valueMatch[1].trim() : "";
+        const objectReference = objRefMatch ? objRefMatch[1].trim() : "{fileID: 0}";
+        let remappedObjRef = objectReference;
+        if (objectReference !== "{fileID: 0}") {
+          remappedObjRef = objectReference.replace(/(\{fileID:\s*)(\d+)/g, (match, prefix, oldId) => {
+            if (oldId === "0")
+              return match;
+            return idMap.has(oldId) ? `${prefix}${idMap.get(oldId)}` : match;
+          });
+        }
+        for (const clonedBlock of clonedBlocks) {
+          if (clonedBlock.file_id === targetNewId) {
+            clonedBlock.set_property(propertyPath, value, remappedObjRef);
+            break;
+          }
+        }
+      }
+    }
+  }
+  const transformParentMatch = prefabInstanceBlock.raw.match(/m_TransformParent:\s*\{fileID:\s*(\d+)\}/);
+  const transformParentId = transformParentMatch ? transformParentMatch[1] : "0";
+  const rootInfo = prefabDoc.find_prefab_root();
+  if (rootInfo && idMap.has(rootInfo.transform.file_id)) {
+    const newRootTransformId = idMap.get(rootInfo.transform.file_id);
+    for (const clonedBlock of clonedBlocks) {
+      if (clonedBlock.file_id === newRootTransformId && clonedBlock.class_id === 4) {
+        clonedBlock.set_property("m_Father", `{fileID: ${transformParentId}}`);
+        break;
+      }
+    }
+  }
+  const strippedBlockIds = new Set;
+  for (const block of sceneDoc.blocks) {
+    if (block.is_stripped && block.raw.includes(`m_PrefabInstance: {fileID: ${prefabInstanceId}}`)) {
+      strippedBlockIds.add(block.file_id);
+    }
+  }
+  const blocksToRemove = new Set([prefabInstanceId, ...strippedBlockIds]);
+  sceneDoc.remove_blocks(blocksToRemove);
+  for (const clonedBlock of clonedBlocks) {
+    sceneDoc.append_block(clonedBlock);
+  }
+  if (transformParentId !== "0" && rootInfo && idMap.has(rootInfo.transform.file_id)) {
+    sceneDoc.add_child_to_parent(transformParentId, idMap.get(rootInfo.transform.file_id));
+  }
+  if (!sceneDoc.validate()) {
+    return { success: false, file_path, error: "Validation failed after unpacking prefab" };
+  }
+  const saveResult = sceneDoc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  const newRootGoId = rootInfo ? idMap.get(rootInfo.game_object.file_id) : undefined;
+  return {
+    success: true,
+    file_path,
+    unpacked_count: clonedBlocks.length,
+    root_game_object_id: newRootGoId ? parseInt(newRootGoId, 10) : undefined
+  };
+}
 })