@game_engine/scene 0.1.0-alpha

package/dist/index.js

@@ -0,0 +1,3996 @@
+// src/index.ts
+import { existsSync, statSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import Ajv from "ajv";
+import { parse, stringify } from "yaml";
+import {
+  assetManifestSchema,
+  componentFieldOrder,
+  componentOrder,
+  componentSchemas,
+  generatedMapSchema,
+  mapGenerationConfigSchema,
+  patchSchema,
+  prefabSchema,
+  projectSchema,
+  sceneSchema,
+  supportedPatchOperations
+} from "@game_engine/contracts";
+import {
+  assetManifestSchema as assetManifestSchema2,
+  componentSchemas as componentSchemas2,
+  generatedMapSchema as generatedMapSchema2,
+  mapGenerationConfigSchema as mapGenerationConfigSchema2,
+  patchSchema as patchSchema2,
+  prefabSchema as prefabSchema2,
+  projectSchema as projectSchema2,
+  sceneSchema as sceneSchema2
+} from "@game_engine/contracts";
+var componentReferenceFields = {
+  CharacterController: ["groundEntityId", "targetEntityId"],
+  CameraFollow: ["target"],
+  Camera3D: ["targetEntityId"],
+  GroundedState: ["groundEntityId"],
+  Parent: ["entityId"]
+};
+var ajv = new Ajv({ allErrors: true, strict: false });
+var validateAssetManifestSchema = ajv.compile(assetManifestSchema);
+var validateMapGenerationConfigSchema = ajv.compile(mapGenerationConfigSchema);
+var validateGeneratedMapSchema = ajv.compile(generatedMapSchema);
+var validateProjectSchema = ajv.compile(projectSchema);
+var validateSceneSchema = ajv.compile(sceneSchema);
+var validatePrefabSchema = ajv.compile(prefabSchema);
+var validatePatchSchema = ajv.compile(patchSchema);
+var componentValidators = Object.fromEntries(
+  Object.entries(componentSchemas).map(([name, schema]) => [name, ajv.compile(schema)])
+);
+function parseProjectSource(source, file = "agent.project.yml") {
+  return parseYamlSource(source, file);
+}
+function parseSceneSource(source, file = "scene.yml") {
+  return parseYamlSource(source, file);
+}
+function parsePrefabSource(source, file = "prefab.yml") {
+  return parseYamlSource(source, file);
+}
+function parseAssetManifestSource(source, file = "agent.assets.yml") {
+  return parseYamlSource(source, file);
+}
+function parseMapGenerationConfigSource(source, file = "map.yml") {
+  return parseYamlSource(source, file);
+}
+function parseGeneratedMapSource(source, file = "generated-map.yml") {
+  return parseYamlSource(source, file);
+}
+function parsePatchSource(source, file = "patch.json") {
+  try {
+    const document = path.extname(file).toLowerCase() === ".json" ? JSON.parse(source) : parse(source);
+    if (document === null || document === void 0) {
+      return {
+        file,
+        diagnostics: [
+          {
+            severity: "error",
+            code: "PATCH_EMPTY_DOCUMENT",
+            file,
+            path: "$",
+            message: "Patch document is empty.",
+            suggestion: "Add version, target, and operations before applying the patch."
+          }
+        ]
+      };
+    }
+    return {
+      file,
+      document,
+      diagnostics: []
+    };
+  } catch (error) {
+    return {
+      file,
+      diagnostics: [
+        {
+          severity: "error",
+          code: "PATCH_PARSE_ERROR",
+          file,
+          path: "$",
+          message: error instanceof Error ? error.message : String(error),
+          suggestion: "Fix the patch JSON or YAML syntax before applying it."
+        }
+      ]
+    };
+  }
+}
+async function loadProjectFile(projectPath = ".", options = {}) {
+  const file = resolveProjectFile(projectPath, options.cwd);
+  return loadYamlFile(file);
+}
+async function loadSceneFile(scenePath, options = {}) {
+  const file = path.resolve(options.cwd ?? process.cwd(), scenePath);
+  return loadYamlFile(file);
+}
+async function loadPrefabFile(prefabPath, options = {}) {
+  const file = path.resolve(options.cwd ?? process.cwd(), prefabPath);
+  return loadYamlFile(file);
+}
+async function loadAssetManifestFile(assetManifestPath, options = {}) {
+  const file = path.resolve(options.cwd ?? process.cwd(), assetManifestPath);
+  return loadYamlFile(file);
+}
+async function loadMapGenerationConfigFile(configPath, options = {}) {
+  const file = path.resolve(options.cwd ?? process.cwd(), configPath);
+  return loadYamlFile(file);
+}
+async function loadGeneratedMapFile(generatedMapPath, options = {}) {
+  const file = path.resolve(options.cwd ?? process.cwd(), generatedMapPath);
+  return loadYamlFile(file);
+}
+async function loadPatchFile(patchPath, options = {}) {
+  const file = path.resolve(options.cwd ?? process.cwd(), patchPath);
+  try {
+    const source = await readFile(file, "utf8");
+    return parsePatchSource(source, file);
+  } catch (error) {
+    return {
+      file,
+      diagnostics: [
+        {
+          severity: "error",
+          code: "FILE_READ_FAILED",
+          file,
+          path: "$",
+          message: error instanceof Error ? error.message : String(error),
+          suggestion: "Check that the patch path exists and is readable."
+        }
+      ]
+    };
+  }
+}
+function validateProjectDocument(project, file = "agent.project.yml") {
+  const diagnostics = schemaDiagnostics(validateProjectSchema, project, file, "PROJECT_SCHEMA_INVALID");
+  if (isRecord(project) && Array.isArray(project.scenes) && typeof project.defaultScene === "string") {
+    if (!project.scenes.includes(project.defaultScene)) {
+      diagnostics.push({
+        severity: "error",
+        code: "PROJECT_DEFAULT_SCENE_MISSING",
+        file,
+        path: "$.defaultScene",
+        message: `Default scene '${project.defaultScene}' is not listed in scenes.`,
+        suggestion: "Add the default scene path to the scenes array."
+      });
+    }
+  }
+  return diagnostics;
+}
+function validateAssetManifestDocument(assetManifest, file = "agent.assets.yml") {
+  const diagnostics = schemaDiagnostics(
+    validateAssetManifestSchema,
+    assetManifest,
+    file,
+    "ASSET_MANIFEST_SCHEMA_INVALID"
+  );
+  if (!isRecord(assetManifest) || !Array.isArray(assetManifest.assets)) {
+    return diagnostics;
+  }
+  const assetsById = /* @__PURE__ */ new Map();
+  assetManifest.assets.forEach((asset, index) => {
+    const assetPath = `$.assets[${index}]`;
+    if (!isRecord(asset)) {
+      return;
+    }
+    if (typeof asset.type === "string" && !["texture", "sprite", "atlas", "audio", "font"].includes(asset.type)) {
+      diagnostics.push({
+        severity: "error",
+        code: "ASSET_UNKNOWN_TYPE",
+        file,
+        path: `${assetPath}.type`,
+        message: `Unknown asset type '${asset.type}'.`,
+        suggestion: "Use one of: texture, sprite, atlas, audio, font."
+      });
+    }
+    if (typeof asset.path === "string" && !isPortableAssetPath(asset.path)) {
+      diagnostics.push({
+        severity: "error",
+        code: "ASSET_PATH_INVALID",
+        file,
+        path: `${assetPath}.path`,
+        message: `Asset path '${asset.path}' is not a portable project-relative path.`,
+        suggestion: "Use a relative path with forward slashes, no drive letters, no leading slash, and no '..' segments."
+      });
+    }
+    if (asset.type === "sprite" && Object.prototype.hasOwnProperty.call(asset, "rect")) {
+      diagnostics.push(...validateAssetRectMetadata(asset.rect, file, `${assetPath}.rect`, String(asset.id)));
+    }
+    if (asset.type === "atlas" && Array.isArray(asset.frames)) {
+      diagnostics.push(...validateAtlasFramesMetadata(asset.frames, file, `${assetPath}.frames`, String(asset.id)));
+    }
+    if (typeof asset.id !== "string") {
+      return;
+    }
+    if (assetsById.has(asset.id)) {
+      diagnostics.push({
+        severity: "error",
+        code: "ASSET_DUPLICATE_ID",
+        file,
+        path: `${assetPath}.id`,
+        message: `Duplicate asset id '${asset.id}'.`,
+        suggestion: "Give every asset one unique stable id and update references to the chosen id."
+      });
+      return;
+    }
+    if (typeof asset.type === "string" && typeof asset.path === "string") {
+      const record = {
+        type: asset.type,
+        path: asset.path,
+        dataPath: assetPath,
+        ...typeof asset.texture === "string" ? { texture: asset.texture } : {},
+        ...typeof asset.atlas === "string" ? { atlas: asset.atlas } : {},
+        ...typeof asset.frame === "string" ? { frame: asset.frame } : {},
+        ...asset.type === "atlas" && Array.isArray(asset.frames) ? { frames: readAtlasFrameRecords(asset.frames, `${assetPath}.frames`) } : {}
+      };
+      assetsById.set(asset.id, record);
+    }
+  });
+  assetManifest.assets.forEach((asset, index) => {
+    if (!isRecord(asset) || typeof asset.id !== "string" || typeof asset.type !== "string") {
+      return;
+    }
+    const assetPath = `$.assets[${index}]`;
+    if (asset.type === "sprite") {
+      if (typeof asset.texture === "string") {
+        diagnostics.push(
+          ...validateAssetReferenceToType({
+            assetsById,
+            file,
+            path: `${assetPath}.texture`,
+            assetId: asset.id,
+            referencedId: asset.texture,
+            expectedType: "texture",
+            missingCode: "ASSET_BROKEN_REFERENCE",
+            mismatchCode: "ASSET_TYPE_MISMATCH",
+            ownerType: "Sprite asset",
+            suggestion: "Point SpriteAsset.texture to a texture asset id or remove the texture reference."
+          })
+        );
+      }
+      diagnostics.push(...validateSpriteAtlasFrameReference(asset, assetsById, file, assetPath));
+      return;
+    }
+    if (asset.type === "atlas" && typeof asset.texture === "string") {
+      diagnostics.push(
+        ...validateAssetReferenceToType({
+          assetsById,
+          file,
+          path: `${assetPath}.texture`,
+          assetId: asset.id,
+          referencedId: asset.texture,
+          expectedType: "texture",
+          missingCode: "ASSET_ATLAS_TEXTURE_REFERENCE_UNRESOLVED",
+          mismatchCode: "ASSET_ATLAS_TEXTURE_TYPE_MISMATCH",
+          ownerType: "Atlas asset",
+          suggestion: "Point atlas.texture to a texture asset id or remove the source texture reference."
+        })
+      );
+    }
+  });
+  return diagnostics;
+}
+function validateAssetRectMetadata(rect, file, dataPath, assetId) {
+  if (!Array.isArray(rect) || rect.length !== 4) {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_RECT_INVALID",
+        file,
+        path: dataPath,
+        message: `Sprite asset '${assetId}' rect must be [x, y, width, height].`,
+        suggestion: "Use four finite numbers and keep width and height greater than zero."
+      }
+    ];
+  }
+  const invalidIndex = rect.findIndex((value) => typeof value !== "number" || !Number.isFinite(value));
+  if (invalidIndex !== -1) {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_RECT_INVALID",
+        file,
+        path: `${dataPath}[${invalidIndex}]`,
+        message: `Sprite asset '${assetId}' rect value at index ${invalidIndex} must be a finite number.`,
+        suggestion: "Use numeric [x, y, width, height] atlas planning metadata."
+      }
+    ];
+  }
+  const [, , width, height] = rect;
+  if (width <= 0 || height <= 0) {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_RECT_INVALID",
+        file,
+        path: width <= 0 ? `${dataPath}[2]` : `${dataPath}[3]`,
+        message: `Sprite asset '${assetId}' rect width and height must be greater than zero.`,
+        suggestion: "Use positive width and height values. No atlas slicing is performed from this metadata."
+      }
+    ];
+  }
+  return [];
+}
+function validateAtlasFramesMetadata(frames, file, dataPath, atlasId) {
+  const diagnostics = [];
+  const frameIds = /* @__PURE__ */ new Map();
+  frames.forEach((frame, index) => {
+    const framePath = `${dataPath}[${index}]`;
+    if (!isRecord(frame)) {
+      return;
+    }
+    if (typeof frame.id === "string") {
+      const existingPath = frameIds.get(frame.id);
+      if (existingPath) {
+        diagnostics.push({
+          severity: "error",
+          code: "ASSET_ATLAS_DUPLICATE_FRAME_ID",
+          file,
+          path: `${framePath}.id`,
+          message: `Atlas asset '${atlasId}' defines duplicate frame id '${frame.id}'.`,
+          suggestion: `Keep one '${frame.id}' frame in this atlas. First occurrence is at ${existingPath}.`
+        });
+      } else {
+        frameIds.set(frame.id, `${framePath}.id`);
+      }
+    }
+    if (Object.prototype.hasOwnProperty.call(frame, "rect")) {
+      diagnostics.push(...validateAtlasFrameRectMetadata(frame.rect, file, `${framePath}.rect`, atlasId, String(frame.id)));
+    }
+  });
+  return diagnostics;
+}
+function validateAtlasFrameRectMetadata(rect, file, dataPath, atlasId, frameId) {
+  if (!Array.isArray(rect) || rect.length !== 4) {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_ATLAS_FRAME_RECT_INVALID",
+        file,
+        path: dataPath,
+        message: `Atlas frame '${frameId}' in atlas '${atlasId}' rect must be [x, y, width, height].`,
+        suggestion: "Use four finite numbers and keep width and height greater than zero."
+      }
+    ];
+  }
+  const invalidIndex = rect.findIndex((value) => typeof value !== "number" || !Number.isFinite(value));
+  if (invalidIndex !== -1) {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_ATLAS_FRAME_RECT_INVALID",
+        file,
+        path: `${dataPath}[${invalidIndex}]`,
+        message: `Atlas frame '${frameId}' in atlas '${atlasId}' rect value at index ${invalidIndex} must be a finite number.`,
+        suggestion: "Use numeric [x, y, width, height] atlas metadata."
+      }
+    ];
+  }
+  const [, , width, height] = rect;
+  if (width <= 0 || height <= 0) {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_ATLAS_FRAME_RECT_INVALID",
+        file,
+        path: width <= 0 ? `${dataPath}[2]` : `${dataPath}[3]`,
+        message: `Atlas frame '${frameId}' in atlas '${atlasId}' rect width and height must be greater than zero.`,
+        suggestion: "Use positive width and height values. No atlas slicing is performed from this metadata."
+      }
+    ];
+  }
+  return [];
+}
+function readAtlasFrameRecords(frames, dataPath) {
+  return frames.flatMap((frame, index) => {
+    if (!isRecord(frame) || typeof frame.id !== "string") {
+      return [];
+    }
+    const rect = readRectTuple(frame.rect);
+    if (!rect) {
+      return [];
+    }
+    return [
+      {
+        id: frame.id,
+        rect,
+        dataPath: `${dataPath}[${index}]`
+      }
+    ];
+  });
+}
+function validateAssetReferenceToType(input) {
+  const referenced = input.assetsById.get(input.referencedId);
+  if (!referenced) {
+    return [
+      {
+        severity: "error",
+        code: input.missingCode,
+        file: input.file,
+        path: input.path,
+        message: `${input.ownerType} '${input.assetId}' references missing ${input.expectedType} asset '${input.referencedId}'.`,
+        suggestion: input.suggestion
+      }
+    ];
+  }
+  if (referenced.type !== input.expectedType) {
+    return [
+      {
+        severity: "error",
+        code: input.mismatchCode,
+        file: input.file,
+        path: input.path,
+        message: `${input.ownerType} '${input.assetId}' references '${input.referencedId}', but it is '${referenced.type}', not '${input.expectedType}'.`,
+        suggestion: input.suggestion
+      }
+    ];
+  }
+  return [];
+}
+function validateSpriteAtlasFrameReference(asset, assetsById, file, assetPath) {
+  const hasAtlas = typeof asset.atlas === "string";
+  const hasFrame = typeof asset.frame === "string";
+  if (!hasAtlas && !hasFrame) {
+    return [];
+  }
+  if (!hasAtlas || !hasFrame) {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_ATLAS_FRAME_REFERENCE_INCOMPLETE",
+        file,
+        path: hasAtlas ? `${assetPath}.frame` : `${assetPath}.atlas`,
+        message: `Sprite asset '${String(asset.id)}' must set both atlas and frame when referencing atlas metadata.`,
+        suggestion: "Set atlas to an atlas asset id and frame to a frame id inside that atlas."
+      }
+    ];
+  }
+  const atlas = assetsById.get(String(asset.atlas));
+  if (!atlas) {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_ATLAS_REFERENCE_UNRESOLVED",
+        file,
+        path: `${assetPath}.atlas`,
+        message: `Sprite asset '${String(asset.id)}' references missing atlas asset '${String(asset.atlas)}'.`,
+        suggestion: "Add the atlas asset or update SpriteAsset.atlas to an existing atlas id."
+      }
+    ];
+  }
+  if (atlas.type !== "atlas") {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_ATLAS_REFERENCE_TYPE_MISMATCH",
+        file,
+        path: `${assetPath}.atlas`,
+        message: `Sprite asset '${String(asset.id)}' references '${String(asset.atlas)}', but it is '${atlas.type}', not 'atlas'.`,
+        suggestion: "Point SpriteAsset.atlas to an atlas asset id."
+      }
+    ];
+  }
+  const frame = atlas.frames?.find((candidate) => candidate.id === asset.frame);
+  if (!frame) {
+    return [
+      {
+        severity: "error",
+        code: "ASSET_ATLAS_FRAME_REFERENCE_UNRESOLVED",
+        file,
+        path: `${assetPath}.frame`,
+        message: `Sprite asset '${String(asset.id)}' references missing frame '${String(asset.frame)}' in atlas '${String(asset.atlas)}'.`,
+        suggestion: "Use a frame id defined in the referenced atlas asset."
+      }
+    ];
+  }
+  return [];
+}
+function validateMapGenerationConfigDocument(config, file = "map.yml") {
+  const diagnostics = schemaDiagnostics(
+    validateMapGenerationConfigSchema,
+    config,
+    file,
+    "MAP_CONFIG_SCHEMA_INVALID"
+  );
+  if (!isRecord(config) || !Array.isArray(config.prefabRefs)) {
+    return diagnostics;
+  }
+  const prefabRefIds = /* @__PURE__ */ new Set();
+  for (const [index, prefabRef] of config.prefabRefs.entries()) {
+    if (!isRecord(prefabRef)) {
+      continue;
+    }
+    if (typeof prefabRef.id === "string") {
+      if (prefabRefIds.has(prefabRef.id)) {
+        diagnostics.push({
+          severity: "error",
+          code: "MAP_PREFAB_REF_DUPLICATE",
+          file,
+          path: `$.prefabRefs[${index}].id`,
+          message: `Duplicate prefab ref id '${prefabRef.id}'.`,
+          suggestion: "Use one stable prefab ref id once per map generation config."
+        });
+      }
+      prefabRefIds.add(prefabRef.id);
+    }
+    if (typeof prefabRef.prefab === "string" && !isPortableSourcePath(prefabRef.prefab)) {
+      diagnostics.push({
+        severity: "error",
+        code: "MAP_PREFAB_PATH_INVALID",
+        file,
+        path: `$.prefabRefs[${index}].prefab`,
+        message: `Prefab path '${prefabRef.prefab}' is not a portable relative source path.`,
+        suggestion: "Use a relative path with forward slashes, no drive letters, no leading slash, and no '..' escape."
+      });
+    }
+  }
+  const platformCount = typeof config.platformCount === "number" ? config.platformCount : 0;
+  const enemyCount = typeof config.enemyCount === "number" ? config.enemyCount : 0;
+  const width = typeof config.width === "number" ? config.width : 0;
+  const minPlatformSpacing = isRecord(config.constraints) && typeof config.constraints.minPlatformSpacing === "number" ? config.constraints.minPlatformSpacing : 0;
+  const minEnemySpacing = isRecord(config.constraints) && typeof config.constraints.minEnemySpacing === "number" ? config.constraints.minEnemySpacing : 0;
+  if (platformCount > 0 && !hasPrefabRole(config.prefabRefs, "platform")) {
+    diagnostics.push({
+      severity: "error",
+      code: "MAP_PREFAB_ROLE_REQUIRED",
+      file,
+      path: "$.prefabRefs",
+      message: "platformCount is greater than zero but no platform prefab ref exists.",
+      suggestion: "Add a prefabRefs entry with role: platform."
+    });
+  }
+  if (enemyCount > 0 && !hasPrefabRole(config.prefabRefs, "enemy")) {
+    diagnostics.push({
+      severity: "error",
+      code: "MAP_PREFAB_ROLE_REQUIRED",
+      file,
+      path: "$.prefabRefs",
+      message: "enemyCount is greater than zero but no enemy prefab ref exists.",
+      suggestion: "Add a prefabRefs entry with role: enemy."
+    });
+  }
+  if (enemyCount > 0 && platformCount === 0) {
+    diagnostics.push({
+      severity: "error",
+      code: "MAP_CONSTRAINT_UNSATISFIABLE",
+      file,
+      path: "$.enemyCount",
+      message: "Enemies require at least one generated platform in procedural-map-v0.",
+      suggestion: "Increase platformCount or set enemyCount to 0."
+    });
+  }
+  if (platformCount > 0 && width > 0 && platformCount + minPlatformSpacing * Math.max(platformCount - 1, 0) > width) {
+    diagnostics.push({
+      severity: "error",
+      code: "MAP_CONSTRAINT_UNSATISFIABLE",
+      file,
+      path: "$.constraints.minPlatformSpacing",
+      message: "Platform spacing constraints cannot fit within the requested width.",
+      suggestion: "Reduce platformCount, reduce minPlatformSpacing, or increase width."
+    });
+  }
+  if (enemyCount > 1 && width > 0 && enemyCount + minEnemySpacing * (enemyCount - 1) > width) {
+    diagnostics.push({
+      severity: "error",
+      code: "MAP_CONSTRAINT_UNSATISFIABLE",
+      file,
+      path: "$.constraints.minEnemySpacing",
+      message: "Enemy spacing constraints cannot fit within the requested width.",
+      suggestion: "Reduce enemyCount, reduce minEnemySpacing, or increase width."
+    });
+  }
+  return diagnostics;
+}
+function validateGeneratedMapDocument(map, file = "generated-map.yml") {
+  const diagnostics = schemaDiagnostics(validateGeneratedMapSchema, map, file, "GENERATED_MAP_SCHEMA_INVALID");
+  if (!isRecord(map) || !isRecord(map.config) || !isRecord(map.stats) || !Array.isArray(map.entities)) {
+    return diagnostics;
+  }
+  const configDiagnostics = validateMapGenerationConfigDocument(map.config, file).map((diagnostic) => ({
+    ...diagnostic,
+    path: diagnostic.path === "$" ? "$.config" : `$.config${diagnostic.path.slice(1)}`
+  }));
+  diagnostics.push(...configDiagnostics);
+  const prefabRefs = Array.isArray(map.config.prefabRefs) ? map.config.prefabRefs : [];
+  const prefabRefIds = new Set(
+    prefabRefs.filter(isRecord).map((prefabRef) => prefabRef.id).filter((id) => typeof id === "string")
+  );
+  let platformCount = 0;
+  let enemyCount = 0;
+  for (const [index, entity] of map.entities.entries()) {
+    const entityPath = `$.entities[${index}]`;
+    if (!isRecord(entity)) {
+      continue;
+    }
+    if (typeof entity.prefabRef === "string" && !prefabRefIds.has(entity.prefabRef)) {
+      diagnostics.push({
+        severity: "error",
+        code: "GENERATED_MAP_PREFAB_REF_MISSING",
+        file,
+        path: `${entityPath}.prefabRef`,
+        message: `Generated entity references unknown prefab ref '${entity.prefabRef}'.`,
+        suggestion: "Regenerate the map from a config containing that prefab ref id."
+      });
+    }
+    if (entity.role === "platform") {
+      platformCount += 1;
+    }
+    if (entity.role === "enemy") {
+      enemyCount += 1;
+    }
+    if (Array.isArray(entity.position) && typeof map.stats.width === "number" && typeof map.stats.height === "number") {
+      const [x, y] = entity.position;
+      if (typeof x === "number" && typeof y === "number" && (x < 0 || y < 0 || x >= map.stats.width || y >= map.stats.height)) {
+        diagnostics.push({
+          severity: "error",
+          code: "GENERATED_MAP_ENTITY_OUT_OF_BOUNDS",
+          file,
+          path: `${entityPath}.position`,
+          message: `Generated entity '${String(entity.id)}' is outside the map bounds.`,
+          suggestion: "Regenerate the map with valid constraints or adjust the dimensions."
+        });
+      }
+    }
+  }
+  if (typeof map.stats.platformCount === "number" && map.stats.platformCount !== platformCount) {
+    diagnostics.push({
+      severity: "error",
+      code: "GENERATED_MAP_STATS_MISMATCH",
+      file,
+      path: "$.stats.platformCount",
+      message: `Generated map stats report ${map.stats.platformCount} platforms, but entities contain ${platformCount}.`,
+      suggestion: "Regenerate the map so stats match generated entities."
+    });
+  }
+  if (typeof map.stats.enemyCount === "number" && map.stats.enemyCount !== enemyCount) {
+    diagnostics.push({
+      severity: "error",
+      code: "GENERATED_MAP_STATS_MISMATCH",
+      file,
+      path: "$.stats.enemyCount",
+      message: `Generated map stats report ${map.stats.enemyCount} enemies, but entities contain ${enemyCount}.`,
+      suggestion: "Regenerate the map so stats match generated entities."
+    });
+  }
+  return diagnostics;
+}
+function validatePatchDocument(patch, file = "patch.json") {
+  const diagnostics = schemaDiagnostics(validatePatchSchema, patch, file, "PATCH_SCHEMA_INVALID");
+  if (!isRecord(patch) || !Array.isArray(patch.operations)) {
+    return diagnostics;
+  }
+  patch.operations.forEach((operation, index) => {
+    const operationPath = `$.operations[${index}]`;
+    if (!isRecord(operation)) {
+      return;
+    }
+    if (typeof operation.op === "string" && !supportedPatchOperations.includes(operation.op)) {
+      diagnostics.push({
+        severity: "error",
+        code: "PATCH_UNKNOWN_OPERATION",
+        file,
+        path: `${operationPath}.op`,
+        message: `Unknown patch operation '${operation.op}'.`,
+        suggestion: `Use one of: ${supportedPatchOperations.join(", ")}.`
+      });
+    }
+    if ((operation.op === "add_component" || operation.op === "set_component_field" || operation.op === "update_component") && typeof operation.component === "string" && !componentValidators[operation.component]) {
+      diagnostics.push({
+        severity: "error",
+        code: "PATCH_UNKNOWN_COMPONENT",
+        file,
+        path: `${operationPath}.component`,
+        message: `Unknown component '${operation.component}'.`,
+        suggestion: `Use one of: ${componentOrder.join(", ")}.`
+      });
+    }
+    if (operation.op === "duplicate_entity" && isRecord(operation.overrides)) {
+      for (const componentName of Object.keys(operation.overrides)) {
+        if (!componentValidators[componentName]) {
+          diagnostics.push({
+            severity: "error",
+            code: "PATCH_UNKNOWN_COMPONENT",
+            file,
+            path: `${operationPath}.overrides.${componentName}`,
+            message: `Unknown component '${componentName}'.`,
+            suggestion: `Use one of: ${componentOrder.join(", ")}.`
+          });
+        }
+      }
+    }
+  });
+  return diagnostics;
+}
+function validatePrefabDocument(prefab, file = "prefab.yml") {
+  const diagnostics = schemaDiagnostics(validatePrefabSchema, prefab, file, "PREFAB_SCHEMA_INVALID");
+  if (!isRecord(prefab) || !isRecord(prefab.components)) {
+    return diagnostics;
+  }
+  for (const [componentName, componentValue] of Object.entries(prefab.components)) {
+    const componentPath = `$.components.${componentName}`;
+    const componentValidator = componentValidators[componentName];
+    if (!componentValidator) {
+      diagnostics.push({
+        severity: "error",
+        code: "PREFAB_UNKNOWN_COMPONENT",
+        file,
+        path: componentPath,
+        message: `Unknown component '${componentName}'.`,
+        suggestion: `Use one of: ${componentOrder.join(", ")}.`
+      });
+      continue;
+    }
+    diagnostics.push(
+      ...schemaDiagnostics(componentValidator, componentValue, file, "PREFAB_COMPONENT_INVALID", componentPath)
+    );
+  }
+  return diagnostics;
+}
+async function validatePrefabFile(prefabPath, options = {}) {
+  const result = await loadPrefabFile(prefabPath, options);
+  if (result.document !== void 0) {
+    result.diagnostics.push(...validatePrefabDocument(result.document, result.file));
+  }
+  return result;
+}
+async function validateAssetManifestFile(assetManifestPath, options = {}) {
+  const result = await loadAssetManifestFile(assetManifestPath, options);
+  if (result.document !== void 0) {
+    result.diagnostics.push(...validateAssetManifestDocument(result.document, result.file));
+  }
+  return result;
+}
+async function validateMapGenerationConfigFile(configPath, options = {}) {
+  const result = await loadMapGenerationConfigFile(configPath, options);
+  if (result.document === void 0) {
+    return result;
+  }
+  result.diagnostics.push(...validateMapGenerationConfigDocument(result.document, result.file));
+  if (hasErrors(result.diagnostics)) {
+    return result;
+  }
+  result.diagnostics.push(...await validateMapPrefabRefs(result.document, result.file));
+  return result;
+}
+async function validateGeneratedMapFile(generatedMapPath, options = {}) {
+  const result = await loadGeneratedMapFile(generatedMapPath, options);
+  if (result.document !== void 0) {
+    result.diagnostics.push(...validateGeneratedMapDocument(result.document, result.file));
+  }
+  return result;
+}
+async function loadProjectAssetManifests(projectPath = ".", options = {}) {
+  const projectFile = resolveProjectFile(projectPath, options.cwd);
+  const rootPath = path.dirname(projectFile);
+  const projectResult = await loadProjectFile(projectFile);
+  const diagnostics = [...projectResult.diagnostics];
+  if (projectResult.document !== void 0) {
+    diagnostics.push(...validateProjectDocument(projectResult.document, projectFile));
+  }
+  if (projectResult.document === void 0 || hasErrors(diagnostics)) {
+    return {
+      projectFile,
+      rootPath,
+      manifestFiles: [],
+      assets: [],
+      assetsById: /* @__PURE__ */ new Map(),
+      diagnostics
+    };
+  }
+  const context = await loadProjectAssetManifestContext(projectFile, projectResult.document);
+  return {
+    projectFile,
+    rootPath,
+    manifestFiles: context.manifestFiles,
+    assets: context.assets,
+    assetsById: context.assetsById,
+    diagnostics: [...diagnostics, ...context.diagnostics]
+  };
+}
+async function loadProjectAssetManifestContext(projectFile, project) {
+  const manifestRefs = project.assetManifests ?? [];
+  const context = createAssetManifestContext();
+  const rootPath = path.dirname(projectFile);
+  for (const [manifestIndex, manifestRef] of manifestRefs.entries()) {
+    const manifestFile = path.resolve(rootPath, manifestRef);
+    context.manifestFiles.push(manifestFile);
+    if (!existsSync(manifestFile)) {
+      context.diagnostics.push({
+        severity: "error",
+        code: "PROJECT_ASSET_MANIFEST_NOT_FOUND",
+        file: projectFile,
+        path: `$.assetManifests[${manifestIndex}]`,
+        message: `Asset manifest '${manifestRef}' was not found.`,
+        suggestion: "Create the asset manifest file or remove the path from assetManifests."
+      });
+      continue;
+    }
+    const manifestResult = await validateAssetManifestFile(manifestFile);
+    context.diagnostics.push(...manifestResult.diagnostics);
+    if (!manifestResult.document || hasErrors(manifestResult.diagnostics)) {
+      continue;
+    }
+    for (const [assetIndex, asset] of manifestResult.document.assets.entries()) {
+      const existing = context.assetsById.get(asset.id);
+      const assetPath = `$.assets[${assetIndex}].id`;
+      if (existing) {
+        context.diagnostics.push({
+          severity: "error",
+          code: "ASSET_DUPLICATE_ID",
+          file: manifestFile,
+          path: assetPath,
+          message: `Asset id '${asset.id}' already exists in '${existing.manifestFile}'.`,
+          suggestion: "Use one stable asset id once across all project asset manifests."
+        });
+        continue;
+      }
+      const record = {
+        id: asset.id,
+        type: asset.type,
+        path: asset.path,
+        ...(asset.type === "sprite" || asset.type === "atlas") && typeof asset.texture === "string" ? { texture: asset.texture } : {},
+        ...asset.type === "sprite" && Array.isArray(asset.rect) ? { rect: asset.rect } : {},
+        ...asset.type === "sprite" && typeof asset.atlas === "string" ? { atlas: asset.atlas } : {},
+        ...asset.type === "sprite" && typeof asset.frame === "string" ? { frame: asset.frame } : {},
+        ...asset.type === "atlas" ? { frames: readAtlasFrameRecords(asset.frames, `$.assets[${assetIndex}].frames`) } : {},
+        manifestFile,
+        dataPath: `$.assets[${assetIndex}]`
+      };
+      context.assetsById.set(asset.id, record);
+    }
+  }
+  context.assets = sortedAssetDefinitions(context.assetsById);
+  return context;
+}
+function validateSceneDocument(scene, file = "scene.yml", options = {}) {
+  const diagnostics = schemaDiagnostics(validateSceneSchema, scene, file, "SCENE_SCHEMA_INVALID");
+  if (!isRecord(scene) || !Array.isArray(scene.entities)) {
+    return diagnostics;
+  }
+  const ids = /* @__PURE__ */ new Set();
+  scene.entities.forEach((entity, index) => {
+    if (!isRecord(entity)) {
+      return;
+    }
+    if (typeof entity.id === "string") {
+      if (ids.has(entity.id)) {
+        diagnostics.push({
+          severity: "error",
+          code: "SCENE_DUPLICATE_ENTITY_ID",
+          file,
+          path: `$.entities[${index}].id`,
+          message: `Duplicate entity id '${entity.id}'.`,
+          suggestion: "Give every entity a unique stable id."
+        });
+      }
+      ids.add(entity.id);
+    }
+  });
+  scene.entities.forEach((entity, entityIndex) => {
+    if (!isRecord(entity) || !isRecord(entity.components)) {
+      return;
+    }
+    for (const [componentName, componentValue] of Object.entries(entity.components)) {
+      const componentPath = `$.entities[${entityIndex}].components.${componentName}`;
+      const componentValidator = componentValidators[componentName];
+      if (!componentValidator) {
+        diagnostics.push({
+          severity: "error",
+          code: "SCENE_UNKNOWN_COMPONENT",
+          file,
+          path: componentPath,
+          message: `Unknown component '${componentName}'.`,
+          suggestion: `Use one of: ${componentOrder.join(", ")}.`
+        });
+        continue;
+      }
+      diagnostics.push(
+        ...schemaDiagnostics(componentValidator, componentValue, file, "COMPONENT_SCHEMA_INVALID", componentPath)
+      );
+      for (const reference of findEntityReferences(scene).filter(
+        (candidate) => candidate.path.startsWith(componentPath)
+      )) {
+        if (!ids.has(reference.value)) {
+          diagnostics.push({
+            severity: "error",
+            code: "SCENE_BROKEN_ENTITY_REFERENCE",
+            file,
+            path: reference.path,
+            message: `Entity reference '${reference.value}' does not resolve.`,
+            suggestion: "Use the stable id of an entity in this scene."
+          });
+        }
+      }
+    }
+  });
+  diagnostics.push(...validateHierarchyRules(scene, file, ids));
+  diagnostics.push(...validateAnimationRules(scene, file));
+  diagnostics.push(...validate3DContractRules(scene, file));
+  if (options.assets) {
+    diagnostics.push(...validateSceneAssetReferences(scene, file, options.assets));
+  }
+  return diagnostics;
+}
+async function validateProjectFile(projectPath = ".", options = {}) {
+  const projectFile = resolveProjectFile(projectPath, options.cwd);
+  const result = await loadYamlFile(projectFile);
+  if (result.document === void 0) {
+    return result;
+  }
+  result.diagnostics.push(...validateProjectDocument(result.document, projectFile));
+  if (hasErrors(result.diagnostics)) {
+    return result;
+  }
+  const rootPath = path.dirname(projectFile);
+  const assetContext = await loadProjectAssetManifestContext(projectFile, result.document);
+  result.diagnostics.push(...assetContext.diagnostics);
+  if (hasErrors(result.diagnostics)) {
+    return result;
+  }
+  for (const sceneRef of result.document.scenes) {
+    const sceneFile = path.resolve(rootPath, sceneRef);
+    if (!existsSync(sceneFile)) {
+      result.diagnostics.push({
+        severity: "error",
+        code: "PROJECT_SCENE_NOT_FOUND",
+        file: projectFile,
+        path: "$.scenes",
+        message: `Scene file '${sceneRef}' was not found.`,
+        suggestion: "Create the scene file or remove the scene path from the project."
+      });
+      continue;
+    }
+    const sceneResult = await validateSceneFile(sceneFile, { assets: assetContext });
+    result.diagnostics.push(...sceneResult.diagnostics);
+  }
+  return result;
+}
+async function validateSceneFile(scenePath, options = {}) {
+  const file = path.resolve(options.cwd ?? process.cwd(), scenePath);
+  const result = await loadYamlFile(file);
+  if (result.document !== void 0) {
+    const expanded = await expandSceneDocument(result.document, { sceneFile: file, assets: options.assets });
+    result.diagnostics.push(...expanded.diagnostics);
+  }
+  return result;
+}
+async function loadExpandedSceneFile(scenePath, options = {}) {
+  const file = path.resolve(options.cwd ?? process.cwd(), scenePath);
+  const result = await loadYamlFile(file);
+  if (result.document === void 0) {
+    return result;
+  }
+  const expanded = await expandSceneDocument(result.document, { sceneFile: file, assets: options.assets });
+  return {
+    file,
+    document: expanded.document,
+    diagnostics: [...result.diagnostics, ...expanded.diagnostics]
+  };
+}
+async function expandSceneDocument(scene, options = {}) {
+  const sceneFile = options.sceneFile ?? "scene.yml";
+  const diagnostics = validateSceneDocument(scene, sceneFile, { assets: options.assets });
+  if (hasErrors(diagnostics)) {
+    return {
+      file: sceneFile,
+      diagnostics
+    };
+  }
+  const expandedEntities = [];
+  for (const [entityIndex, entity] of scene.entities.entries()) {
+    if (typeof entity.prefab !== "string") {
+      expandedEntities.push({
+        id: entity.id,
+        components: cloneJson(entity.components ?? {})
+      });
+      continue;
+    }
+    const prefabFile = resolveScenePrefabPath(sceneFile, entity.prefab);
+    const prefabResult = await loadPrefabFile(prefabFile);
+    const prefabDiagnostics = [...prefabResult.diagnostics];
+    if (prefabResult.document !== void 0) {
+      prefabDiagnostics.push(...validatePrefabDocument(prefabResult.document, prefabResult.file));
+    }
+    if (prefabResult.document === void 0 || hasErrors(prefabDiagnostics)) {
+      if (prefabResult.diagnostics.some((diagnostic) => diagnostic.code === "FILE_READ_FAILED")) {
+        diagnostics.push({
+          severity: "error",
+          code: "SCENE_PREFAB_NOT_FOUND",
+          file: sceneFile,
+          path: `$.entities[${entityIndex}].prefab`,
+          message: `Prefab file '${entity.prefab}' was not found.`,
+          suggestion: "Create the prefab file or update the prefab path relative to the scene file."
+        });
+      }
+      diagnostics.push(...prefabDiagnostics);
+      continue;
+    }
+    const overrideDiagnostics = validatePrefabOverrides(entity, prefabResult.document, sceneFile, entityIndex);
+    diagnostics.push(...overrideDiagnostics);
+    if (hasErrors(overrideDiagnostics)) {
+      continue;
+    }
+    expandedEntities.push({
+      id: entity.id,
+      components: mergePrefabComponents(prefabResult.document.components, entity.overrides)
+    });
+  }
+  if (hasErrors(diagnostics)) {
+    return {
+      file: sceneFile,
+      diagnostics
+    };
+  }
+  const expandedScene = {
+    version: scene.version,
+    name: scene.name,
+    entities: expandedEntities
+  };
+  diagnostics.push(...validateSceneDocument(expandedScene, sceneFile, { assets: options.assets }));
+  return {
+    file: sceneFile,
+    document: hasErrors(diagnostics) ? void 0 : expandedScene,
+    diagnostics
+  };
+}
+function formatProject(project) {
+  return toYaml({
+    version: project.version,
+    name: project.name,
+    defaultScene: project.defaultScene,
+    ...project.assetManifests ? { assetManifests: [...project.assetManifests] } : {},
+    scenes: [...project.scenes]
+  });
+}
+function formatScene(scene) {
+  return toYaml({
+    version: scene.version,
+    name: scene.name,
+    entities: scene.entities.map((entity) => {
+      if (typeof entity.prefab === "string") {
+        return {
+          id: entity.id,
+          prefab: entity.prefab,
+          ...entity.overrides ? { overrides: orderComponents(entity.overrides) } : {}
+        };
+      }
+      return {
+        id: entity.id,
+        components: orderComponents(entity.components ?? {})
+      };
+    })
+  });
+}
+function formatPrefab(prefab) {
+  return toYaml({
+    prefab: prefab.prefab,
+    version: prefab.version,
+    components: orderComponents(prefab.components)
+  });
+}
+function formatMapGenerationConfig(config) {
+  return toYaml({
+    version: config.version,
+    name: config.name,
+    seed: config.seed,
+    width: config.width,
+    height: config.height,
+    platformCount: config.platformCount,
+    enemyCount: config.enemyCount,
+    prefabRefs: config.prefabRefs.map((prefabRef) => ({
+      id: prefabRef.id,
+      prefab: prefabRef.prefab,
+      role: prefabRef.role
+    })),
+    ...config.tileSetRef ? { tileSetRef: config.tileSetRef } : {},
+    ...config.goal ? { goal: config.goal } : {},
+    ...config.constraints ? { constraints: orderObject(config.constraints) } : {}
+  });
+}
+function formatGeneratedMap(map) {
+  return toYaml({
+    generatedMap: map.generatedMap,
+    version: map.version,
+    generator: map.generator,
+    config: parse(formatMapGenerationConfig(map.config)),
+    stats: orderObject(map.stats),
+    regions: map.regions.map((region) => ({
+      id: region.id,
+      x: region.x,
+      y: region.y,
+      width: region.width,
+      height: region.height
+    })),
+    entities: map.entities.map((entity) => ({
+      id: entity.id,
+      prefabRef: entity.prefabRef,
+      role: entity.role,
+      position: entity.position,
+      ...entity.size ? { size: entity.size } : {}
+    }))
+  });
+}
+async function generateMapFromConfigFile(configPath, options = {}) {
+  const configResult = await validateMapGenerationConfigFile(configPath, options);
+  const diagnostics = [...configResult.diagnostics];
+  if (!configResult.document || hasErrors(diagnostics)) {
+    return {
+      configPath: configResult.file,
+      diagnostics,
+      config: configResult.document
+    };
+  }
+  const generated = generateMapDocument(configResult.document, { configFile: configResult.file });
+  diagnostics.push(...generated.diagnostics);
+  if (!generated.document || hasErrors(diagnostics)) {
+    return {
+      configPath: configResult.file,
+      diagnostics,
+      config: configResult.document
+    };
+  }
+  const scene = generatedMapToScene(generated.document);
+  return {
+    configPath: configResult.file,
+    diagnostics,
+    config: configResult.document,
+    map: generated.document,
+    scene,
+    summary: createMapGenerationSummary(generated.document)
+  };
+}
+function generateMapDocument(config, options = {}) {
+  const file = options.configFile ?? "map.yml";
+  const diagnostics = validateMapGenerationConfigDocument(config, file);
+  if (hasErrors(diagnostics)) {
+    return {
+      file,
+      diagnostics
+    };
+  }
+  const configHash = hashStableObject(config);
+  const rng = createSeededRandom(config.seed);
+  const platformRef = findMapPrefabRefByRole(config.prefabRefs, "platform");
+  const enemyRef = findMapPrefabRefByRole(config.prefabRefs, "enemy");
+  const goalRef = findMapPrefabRefByRole(config.prefabRefs, "goal");
+  const entities = [];
+  const platforms = [];
+  if (config.platformCount > 0 && !platformRef) {
+    return {
+      file,
+      diagnostics: [
+        ...diagnostics,
+        {
+          severity: "error",
+          code: "MAP_PREFAB_ROLE_REQUIRED",
+          file,
+          path: "$.prefabRefs",
+          message: "platformCount is greater than zero but no platform prefab ref exists.",
+          suggestion: "Add a prefabRefs entry with role: platform."
+        }
+      ]
+    };
+  }
+  if (config.enemyCount > 0 && !enemyRef) {
+    return {
+      file,
+      diagnostics: [
+        ...diagnostics,
+        {
+          severity: "error",
+          code: "MAP_PREFAB_ROLE_REQUIRED",
+          file,
+          path: "$.prefabRefs",
+          message: "enemyCount is greater than zero but no enemy prefab ref exists.",
+          suggestion: "Add a prefabRefs entry with role: enemy."
+        }
+      ]
+    };
+  }
+  if (platformRef) {
+    const platformWidth = Math.max(2, Math.floor(config.width / Math.max(config.platformCount * 2, 1)));
+    const slotWidth = Math.max(1, Math.floor(config.width / Math.max(config.platformCount, 1)));
+    for (let index = 0; index < config.platformCount; index += 1) {
+      const slotStart = index * slotWidth;
+      const slotEnd = index === config.platformCount - 1 ? config.width - platformWidth : Math.min(config.width - platformWidth, (index + 1) * slotWidth - platformWidth);
+      const x = clampInteger(randomInteger(rng, slotStart, Math.max(slotStart, slotEnd)), 0, Math.max(config.width - platformWidth, 0));
+      const y = index === 0 ? 0 : randomInteger(rng, 0, Math.max(config.height - 2, 0));
+      const platform = {
+        id: `platform_${padNumber(index + 1)}`,
+        prefabRef: platformRef.id,
+        role: "platform",
+        position: [x, y],
+        size: [platformWidth, 1]
+      };
+      platforms.push(platform);
+      entities.push(platform);
+    }
+  }
+  if (enemyRef) {
+    for (let index = 0; index < config.enemyCount; index += 1) {
+      const platform = platforms[index % Math.max(platforms.length, 1)];
+      if (!platform) {
+        diagnostics.push({
+          severity: "error",
+          code: "MAP_CONSTRAINT_UNSATISFIABLE",
+          file,
+          path: "$.enemyCount",
+          message: "Enemies require generated platforms in procedural-map-v0.",
+          suggestion: "Increase platformCount or set enemyCount to 0."
+        });
+        break;
+      }
+      const width = Array.isArray(platform.size) ? Math.max(Math.floor(platform.size[0]), 1) : 1;
+      entities.push({
+        id: `enemy_${padNumber(index + 1)}`,
+        prefabRef: enemyRef.id,
+        role: "enemy",
+        position: [
+          clampInteger(platform.position[0] + randomInteger(rng, 0, width - 1), 0, config.width - 1),
+          clampInteger(platform.position[1] + 1, 0, config.height - 1)
+        ]
+      });
+    }
+  }
+  if (goalRef) {
+    entities.push({
+      id: config.goal?.targetEntityId ?? "goal",
+      prefabRef: goalRef.id,
+      role: "goal",
+      position: [config.width - 1, Math.max(config.height - 1, 0)]
+    });
+  }
+  if (hasErrors(diagnostics)) {
+    return {
+      file,
+      diagnostics
+    };
+  }
+  const map = {
+    generatedMap: config.name,
+    version: 1,
+    generator: "procedural-map-v0",
+    config: cloneJson(config),
+    stats: {
+      seed: config.seed,
+      width: config.width,
+      height: config.height,
+      platformCount: config.platformCount,
+      enemyCount: config.enemyCount,
+      configHash
+    },
+    regions: [
+      {
+        id: "world",
+        x: 0,
+        y: 0,
+        width: config.width,
+        height: config.height
+      }
+    ],
+    entities
+  };
+  diagnostics.push(...validateGeneratedMapDocument(map, file));
+  return {
+    file,
+    document: hasErrors(diagnostics) ? void 0 : map,
+    diagnostics
+  };
+}
+function generatedMapToScene(map, options = {}) {
+  const prefabRefsById = new Map(map.config.prefabRefs.map((prefabRef) => [prefabRef.id, prefabRef]));
+  const entities = [
+    {
+      id: "generated_map_meta",
+      components: {
+        GeneratedMap: {
+          generator: map.generator,
+          seed: map.stats.seed,
+          width: map.stats.width,
+          height: map.stats.height,
+          platformCount: map.stats.platformCount,
+          enemyCount: map.stats.enemyCount,
+          configHash: map.stats.configHash,
+          ...map.config.constraints ? { constraints: cloneJson(map.config.constraints) } : {}
+        }
+      }
+    }
+  ];
+  for (const generatedEntity of map.entities) {
+    const prefabRef = prefabRefsById.get(generatedEntity.prefabRef);
+    if (!prefabRef) {
+      continue;
+    }
+    const overrides = {
+      Transform: {
+        position: generatedEntity.position,
+        rotation: 0,
+        scale: [1, 1]
+      }
+    };
+    if (generatedEntity.role === "platform" && generatedEntity.size) {
+      overrides.Collider = {
+        shape: "box",
+        size: generatedEntity.size,
+        static: true
+      };
+    }
+    entities.push({
+      id: generatedEntity.id,
+      prefab: resolveGeneratedScenePrefabRef(prefabRef, options),
+      overrides
+    });
+  }
+  return {
+    version: 1,
+    name: map.generatedMap,
+    entities
+  };
+}
+async function generateMapSceneFile(configPath, outPath, options = {}) {
+  const result = await generateMapFromConfigFile(configPath, options);
+  const outFile = path.resolve(options.cwd ?? process.cwd(), outPath);
+  const mapOutFile = options.mapOutPath ? path.resolve(options.cwd ?? process.cwd(), options.mapOutPath) : void 0;
+  const diagnostics = [...result.diagnostics];
+  if (!result.map || !result.scene || hasErrors(diagnostics)) {
+    return {
+      ...result,
+      outPath: outFile,
+      ...mapOutFile ? { mapOutPath: mapOutFile } : {},
+      diagnostics
+    };
+  }
+  const scene = generatedMapToScene(result.map, {
+    configFile: result.configPath,
+    sceneFile: outFile
+  });
+  await mkdir(path.dirname(outFile), { recursive: true });
+  await writeFile(outFile, formatScene(scene), "utf8");
+  if (mapOutFile) {
+    await mkdir(path.dirname(mapOutFile), { recursive: true });
+    await writeFile(mapOutFile, formatGeneratedMap(result.map), "utf8");
+  }
+  const sceneValidation = await validateSceneFile(outFile);
+  diagnostics.push(...sceneValidation.diagnostics);
+  return {
+    ...result,
+    outPath: outFile,
+    ...mapOutFile ? { mapOutPath: mapOutFile } : {},
+    diagnostics,
+    scene: hasErrors(diagnostics) ? void 0 : scene
+  };
+}
+function createMapGenerationSummary(map) {
+  return {
+    generator: map.generator,
+    seed: map.stats.seed,
+    width: map.stats.width,
+    height: map.stats.height,
+    platformCount: map.stats.platformCount,
+    enemyCount: map.stats.enemyCount,
+    entityCount: map.entities.length,
+    configHash: map.stats.configHash
+  };
+}
+async function formatProjectFiles(projectPath = ".", options = {}) {
+  const projectFile = resolveProjectFile(projectPath, options.cwd);
+  const projectResult = await loadYamlFile(projectFile);
+  const diagnostics = [...projectResult.diagnostics];
+  const files = [];
+  if (projectResult.document === void 0) {
+    return { files, diagnostics };
+  }
+  diagnostics.push(...validateProjectDocument(projectResult.document, projectFile));
+  if (hasErrors(diagnostics)) {
+    return { files, diagnostics };
+  }
+  const assetContext = await loadProjectAssetManifestContext(projectFile, projectResult.document);
+  diagnostics.push(...assetContext.diagnostics);
+  if (hasErrors(diagnostics)) {
+    return { files, diagnostics };
+  }
+  await writeFile(projectFile, formatProject(projectResult.document), "utf8");
+  files.push(projectFile);
+  const rootPath = path.dirname(projectFile);
+  for (const sceneRef of projectResult.document.scenes) {
+    const sceneFile = path.resolve(rootPath, sceneRef);
+    const sceneResult = await loadYamlFile(sceneFile);
+    diagnostics.push(...sceneResult.diagnostics);
+    if (sceneResult.document === void 0) {
+      continue;
+    }
+    const sceneValidation = await validateSceneFile(sceneFile, { assets: assetContext });
+    const sceneDiagnostics = sceneValidation.diagnostics;
+    diagnostics.push(...sceneDiagnostics);
+    if (hasErrors(sceneDiagnostics)) {
+      continue;
+    }
+    await writeFile(sceneFile, formatScene(sceneResult.document), "utf8");
+    files.push(sceneFile);
+  }
+  return { files, diagnostics };
+}
+function applyPatchDocument(scene, patch, options = {}) {
+  const patchFile = options.patchFile ?? "patch.json";
+  const sceneFile = options.sceneFile ?? patch.target.scene;
+  const diagnostics = validatePatchDocument(patch, patchFile);
+  const summary = createPatchSummary();
+  if (hasErrors(diagnostics)) {
+    return {
+      file: sceneFile,
+      diagnostics,
+      summary
+    };
+  }
+  const nextScene = cloneJson(scene);
+  patch.operations.forEach((operation, index) => {
+    if (hasErrors(diagnostics)) {
+      return;
+    }
+    diagnostics.push(...applyPatchOperation(nextScene, operation, index, patchFile, summary));
+  });
+  if (!hasErrors(diagnostics)) {
+    diagnostics.push(...validateSceneDocument(nextScene, sceneFile));
+  }
+  return {
+    file: sceneFile,
+    document: hasErrors(diagnostics) ? void 0 : nextScene,
+    diagnostics,
+    summary
+  };
+}
+async function applyPatchDocumentWithFileValidation(scene, patch, options) {
+  const patchFile = options.patchFile ?? "patch.json";
+  const sceneFile = options.sceneFile;
+  const patched = applyPatchDocument(scene, patch, { patchFile, sceneFile });
+  const diagnostics = [...patched.diagnostics];
+  const assetContext = await loadNearestProjectAssetManifestContext(sceneFile);
+  diagnostics.push(...assetContext.diagnostics);
+  if (!patched.document || hasErrors(diagnostics)) {
+    return {
+      file: sceneFile,
+      diagnostics,
+      summary: patched.summary
+    };
+  }
+  diagnostics.push(...await validateInstantiatePrefabOperations(patch, patchFile, sceneFile));
+  if (hasErrors(diagnostics)) {
+    return {
+      file: sceneFile,
+      diagnostics,
+      summary: patched.summary
+    };
+  }
+  const expandedPatched = await expandSceneDocument(patched.document, { sceneFile, assets: assetContext });
+  diagnostics.push(...expandedPatched.diagnostics);
+  return {
+    file: sceneFile,
+    document: hasErrors(diagnostics) ? void 0 : patched.document,
+    diagnostics,
+    summary: patched.summary
+  };
+}
+async function applyPatchFile(patchPath, options = {}) {
+  const patchFile = path.resolve(options.cwd ?? process.cwd(), patchPath);
+  const patchResult = await loadPatchFile(patchFile);
+  const diagnostics = [...patchResult.diagnostics];
+  if (patchResult.document === void 0) {
+    return {
+      patchPath: patchFile,
+      diagnostics,
+      changed: false,
+      summary: createPatchSummary()
+    };
+  }
+  diagnostics.push(...validatePatchDocument(patchResult.document, patchFile));
+  if (hasErrors(diagnostics)) {
+    return {
+      patchPath: patchFile,
+      scenePath: resolvePatchScenePath(patchFile, patchResult.document.target?.scene),
+      diagnostics,
+      changed: false,
+      summary: createPatchSummary()
+    };
+  }
+  const sceneFile = path.resolve(path.dirname(patchFile), patchResult.document.target.scene);
+  const sceneResult = await loadSceneFile(sceneFile);
+  diagnostics.push(...sceneResult.diagnostics);
+  if (sceneResult.document === void 0 || hasErrors(diagnostics)) {
+    return {
+      patchPath: patchFile,
+      scenePath: sceneFile,
+      diagnostics,
+      changed: false,
+      summary: createPatchSummary()
+    };
+  }
+  const patched = await applyPatchDocumentWithFileValidation(sceneResult.document, patchResult.document, {
+    patchFile,
+    sceneFile
+  });
+  diagnostics.push(...patched.diagnostics);
+  if (!patched.document || hasErrors(diagnostics)) {
+    return {
+      patchPath: patchFile,
+      scenePath: sceneFile,
+      diagnostics,
+      changed: false,
+      summary: patched.summary
+    };
+  }
+  await writeFile(sceneFile, formatScene(patched.document), "utf8");
+  return {
+    patchPath: patchFile,
+    scenePath: sceneFile,
+    diagnostics,
+    changed: true,
+    summary: patched.summary
+  };
+}
+function inspectSceneDocument(scene, scenePath = "scene.yml", expandedScene = scene, assets = createAssetManifestContext()) {
+  const expandedById = new Map(expandedScene.entities.map((entity) => [entity.id, entity]));
+  const hierarchy = deriveHierarchy(expandedScene, scenePath);
+  const worldTransforms = computeWorldTransforms(expandedScene, scenePath);
+  const hierarchySummary = createHierarchySummary(hierarchy);
+  const animationSummary = inspectSceneAnimations(expandedScene, assets);
+  const assetSummary = createSceneAssetSummary(expandedScene, assets);
+  return {
+    scenePath,
+    name: scene.name,
+    entityCount: scene.entities.length,
+    hierarchy: hierarchySummary,
+    animations: animationSummary,
+    assets: assetSummary,
+    entities: scene.entities.map((entity) => {
+      const expandedEntity = expandedById.get(entity.id);
+      const parent = hierarchy.parentByEntityId[entity.id];
+      const worldTransform = worldTransforms.transforms[entity.id];
+      return {
+        id: entity.id,
+        ...entity.prefab ? { prefab: entity.prefab } : {},
+        components: Object.keys(expandedEntity?.components ?? entity.components ?? {}),
+        ...entity.overrides ? { overrides: Object.keys(entity.overrides) } : {},
+        ...parent ? { parent } : {},
+        children: hierarchy.childrenByEntityId[entity.id] ?? [],
+        ...worldTransform ? { worldTransform } : {}
+      };
+    })
+  };
+}
+async function inspectSceneFile(scenePath, options = {}) {
+  const sceneResult = await loadSceneFile(scenePath, options);
+  if (sceneResult.document === void 0) {
+    return {
+      file: sceneResult.file,
+      diagnostics: sceneResult.diagnostics
+    };
+  }
+  const assetContext = await loadNearestProjectAssetManifestContext(sceneResult.file);
+  const expandedResult = await expandSceneDocument(sceneResult.document, {
+    sceneFile: sceneResult.file,
+    assets: assetContext
+  });
+  const diagnostics = [...sceneResult.diagnostics, ...assetContext.diagnostics, ...expandedResult.diagnostics];
+  if (!expandedResult.document || hasErrors(diagnostics)) {
+    return {
+      file: sceneResult.file,
+      diagnostics
+    };
+  }
+  return {
+    file: sceneResult.file,
+    document: inspectSceneDocument(sceneResult.document, sceneResult.file, expandedResult.document, assetContext),
+    diagnostics
+  };
+}
+async function inspectEntityFile(scenePath, entityId, options = {}) {
+  const sceneResult = await loadExpandedSceneFile(scenePath, options);
+  if (!sceneResult.document || hasErrors(sceneResult.diagnostics)) {
+    return {
+      file: sceneResult.file,
+      diagnostics: sceneResult.diagnostics
+    };
+  }
+  const entity = sceneResult.document.entities.find((candidate) => candidate.id === entityId);
+  if (!entity) {
+    return {
+      file: sceneResult.file,
+      diagnostics: [
+        {
+          severity: "error",
+          code: "SCENE_ENTITY_NOT_FOUND",
+          file: sceneResult.file,
+          path: "$.entities",
+          message: `Entity '${entityId}' was not found.`,
+          suggestion: "Inspect the scene to list available entity ids."
+        }
+      ]
+    };
+  }
+  const inspection = inspectSceneDocument(sceneResult.document, sceneResult.file);
+  const entitySummary = inspection.entities.find((candidate) => candidate.id === entityId);
+  return {
+    file: sceneResult.file,
+    document: {
+      scenePath: sceneResult.file,
+      entity,
+      hierarchy: {
+        ...entitySummary?.parent ? { parent: entitySummary.parent } : {},
+        children: entitySummary?.children ?? [],
+        depth: inspection.hierarchy.nodes.find((node) => node.entityId === entityId)?.depth ?? 0,
+        ...entitySummary?.worldTransform ? { worldTransform: entitySummary.worldTransform } : {}
+      }
+    },
+    diagnostics: sceneResult.diagnostics
+  };
+}
+function inspectPrefabDocument(prefab, prefabPath = "prefab.yml") {
+  return {
+    prefabPath,
+    prefab: prefab.prefab,
+    components: Object.keys(prefab.components ?? {})
+  };
+}
+async function inspectPrefabFile(prefabPath, options = {}) {
+  const result = await validatePrefabFile(prefabPath, options);
+  if (!result.document || hasErrors(result.diagnostics)) {
+    return {
+      file: result.file,
+      diagnostics: result.diagnostics
+    };
+  }
+  return {
+    file: result.file,
+    document: inspectPrefabDocument(result.document, result.file),
+    diagnostics: result.diagnostics
+  };
+}
+function inspectAssetManifestDocument(assetManifest, assetManifestPath = "agent.assets.yml") {
+  return {
+    assetManifestPath,
+    ...assetManifest.assetManifest ? { assetManifest: assetManifest.assetManifest } : {},
+    assetCount: assetManifest.assets.length,
+    assetsByType: countAssetsByType(assetManifest.assets),
+    assets: assetManifest.assets.map((asset) => {
+      if (asset.type === "sprite") {
+        return {
+          id: asset.id,
+          type: asset.type,
+          path: asset.path,
+          ...asset.texture ? { texture: asset.texture } : {},
+          ...asset.rect ? { rect: asset.rect } : {},
+          ...asset.atlas ? { atlas: asset.atlas } : {},
+          ...asset.frame ? { frame: asset.frame } : {}
+        };
+      }
+      if (asset.type === "atlas") {
+        const frames = asset.frames.map((frame) => ({
+          id: frame.id,
+          rect: frame.rect
+        })).sort((left, right) => left.id.localeCompare(right.id));
+        return {
+          id: asset.id,
+          type: asset.type,
+          path: asset.path,
+          ...asset.texture ? { texture: asset.texture } : {},
+          frameCount: frames.length,
+          frames
+        };
+      }
+      return {
+        id: asset.id,
+        type: asset.type,
+        path: asset.path
+      };
+    }).sort((left, right) => left.id.localeCompare(right.id))
+  };
+}
+async function inspectAssetManifestFile(assetManifestPath, options = {}) {
+  const result = await validateAssetManifestFile(assetManifestPath, options);
+  if (!result.document || hasErrors(result.diagnostics)) {
+    return {
+      file: result.file,
+      diagnostics: result.diagnostics
+    };
+  }
+  return {
+    file: result.file,
+    document: inspectAssetManifestDocument(result.document, result.file),
+    diagnostics: result.diagnostics
+  };
+}
+async function inspectProjectFile(projectPath = ".", options = {}) {
+  const projectFile = resolveProjectFile(projectPath, options.cwd);
+  const projectResult = await validateProjectFile(projectFile);
+  const rootPath = path.dirname(projectFile);
+  const inspection = {
+    projectPath: projectFile,
+    rootPath,
+    scenes: [],
+    assetManifests: [],
+    diagnostics: projectResult.diagnostics
+  };
+  if (projectResult.document === void 0 || hasErrors(projectResult.diagnostics)) {
+    return inspection;
+  }
+  inspection.name = projectResult.document.name;
+  inspection.defaultScene = projectResult.document.defaultScene;
+  for (const manifestRef of projectResult.document.assetManifests ?? []) {
+    const manifestFile = path.resolve(rootPath, manifestRef);
+    const manifestResult = await loadYamlFile(manifestFile);
+    inspection.assetManifests.push({
+      path: manifestRef,
+      assetCount: Array.isArray(manifestResult.document?.assets) ? manifestResult.document.assets.length : void 0
+    });
+  }
+  for (const sceneRef of projectResult.document.scenes) {
+    const sceneFile = path.resolve(rootPath, sceneRef);
+    const sceneResult = await loadYamlFile(sceneFile);
+    if (sceneResult.document !== void 0) {
+      inspection.scenes.push({
+        path: sceneRef,
+        name: sceneResult.document.name,
+        entityCount: Array.isArray(sceneResult.document.entities) ? sceneResult.document.entities.length : void 0
+      });
+    } else {
+      inspection.scenes.push({ path: sceneRef });
+    }
+  }
+  return inspection;
+}
+function applyPatchOperation(scene, operation, index, patchFile, summary) {
+  switch (operation.op) {
+    case "add_entity":
+      return applyAddEntity(scene, operation, index, patchFile);
+    case "add_component":
+      return applyAddComponent(scene, operation, index, patchFile);
+    case "set_component_field":
+      return applySetComponentField(scene, operation, index, patchFile);
+    case "remove_component":
+      return applyRemoveComponent(scene, operation, index, patchFile);
+    case "remove_entity":
+      return applyRemoveEntity(scene, operation, index, patchFile);
+    case "rename_entity":
+      return applyRenameEntity(scene, operation, index, patchFile, summary);
+    case "rename_entity_at_source":
+      return applyRenameEntityAtSource(scene, operation, index, patchFile);
+    case "replace_reference":
+      return applyReplaceReference(scene, operation, index, patchFile, summary);
+    case "update_component":
+      return applyUpdateComponent(scene, operation, index, patchFile);
+    case "duplicate_entity":
+      return applyDuplicateEntity(scene, operation, index, patchFile);
+    case "instantiate_prefab":
+      return applyInstantiatePrefab(scene, operation, index, patchFile);
+    case "set_parent":
+      return applySetParent(scene, operation, index, patchFile);
+    case "clear_parent":
+      return applyClearParent(scene, operation, index, patchFile);
+    case "add_animation_frame":
+      return applyAddAnimationFrame(scene, operation, index, patchFile);
+    case "update_animation_frame":
+      return applyUpdateAnimationFrame(scene, operation, index, patchFile);
+    case "remove_animation_frame":
+      return applyRemoveAnimationFrame(scene, operation, index, patchFile);
+    case "set_animator_clip":
+      return applySetAnimatorClip(scene, operation, index, patchFile);
+  }
+}
+function applyAddEntity(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  if (!isRecord(operation.entity) || typeof operation.entity.id !== "string" || !isRecord(operation.entity.components)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_INVALID_ENTITY",
+        file: patchFile,
+        path: `${operationPath}.entity`,
+        message: "add_entity requires an entity with stable id and components.",
+        suggestion: "Provide entity.id and entity.components."
+      }
+    ];
+  }
+  if (findEntity(scene, operation.entity.id)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_DUPLICATE_ENTITY_ID",
+        file: patchFile,
+        path: `${operationPath}.entity.id`,
+        message: `Entity id '${operation.entity.id}' already exists.`,
+        suggestion: "Use a new stable entity id."
+      }
+    ];
+  }
+  scene.entities.push(cloneJson(operation.entity));
+  return [];
+}
+function applyAddComponent(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const entity = findEntity(scene, operation.entityId);
+  if (!entity) {
+    return targetEntityNotFound(operation.entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (!isRecord(entity.components)) {
+    return entityComponentsUnavailable(operation.entityId, patchFile, operationPath);
+  }
+  if (!componentValidators[operation.component]) {
+    return unknownComponent(operation.component, patchFile, `${operationPath}.component`);
+  }
+  if (Object.hasOwn(entity.components, operation.component)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_COMPONENT_ALREADY_EXISTS",
+        file: patchFile,
+        path: `${operationPath}.component`,
+        message: `Entity '${operation.entityId}' already has component '${operation.component}'.`,
+        suggestion: "Use set_component_field to modify an existing component."
+      }
+    ];
+  }
+  const componentDiagnostics = validateComponentValue(
+    operation.component,
+    operation.value,
+    patchFile,
+    `${operationPath}.value`,
+    "PATCH_COMPONENT_INVALID"
+  );
+  if (componentDiagnostics.length > 0) {
+    return componentDiagnostics;
+  }
+  entity.components[operation.component] = cloneJson(operation.value);
+  return [];
+}
+function applySetComponentField(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const entity = findEntity(scene, operation.entityId);
+  if (!entity) {
+    return targetEntityNotFound(operation.entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (!isRecord(entity.components)) {
+    return entityComponentsUnavailable(operation.entityId, patchFile, operationPath);
+  }
+  if (!componentValidators[operation.component]) {
+    return unknownComponent(operation.component, patchFile, `${operationPath}.component`);
+  }
+  if (!Object.hasOwn(entity.components, operation.component)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_COMPONENT_NOT_FOUND",
+        file: patchFile,
+        path: `${operationPath}.component`,
+        message: `Entity '${operation.entityId}' does not have component '${operation.component}'.`,
+        suggestion: "Add the component before setting its fields."
+      }
+    ];
+  }
+  const componentValue = entity.components[operation.component];
+  const pointerDiagnostics = setJsonPointer(componentValue, operation.path, operation.value, patchFile, operationPath);
+  if (pointerDiagnostics.length > 0) {
+    return pointerDiagnostics;
+  }
+  return validateComponentValue(
+    operation.component,
+    componentValue,
+    patchFile,
+    operationPath,
+    "PATCH_COMPONENT_INVALID"
+  );
+}
+function applyRemoveComponent(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const entity = findEntity(scene, operation.entityId);
+  if (!entity) {
+    return targetEntityNotFound(operation.entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (!isRecord(entity.components)) {
+    return entityComponentsUnavailable(operation.entityId, patchFile, operationPath);
+  }
+  if (!Object.hasOwn(entity.components, operation.component)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_COMPONENT_NOT_FOUND",
+        file: patchFile,
+        path: `${operationPath}.component`,
+        message: `Entity '${operation.entityId}' does not have component '${operation.component}'.`,
+        suggestion: "Inspect the entity before removing components."
+      }
+    ];
+  }
+  delete entity.components[operation.component];
+  return [];
+}
+function applyRemoveEntity(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const entityIndex = scene.entities.findIndex((entity) => entity.id === operation.entityId);
+  if (entityIndex === -1) {
+    return targetEntityNotFound(operation.entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (!operation.allowDanglingReferences) {
+    const references = findEntityReferences(scene, operation.entityId);
+    if (references.length > 0) {
+      return references.map((reference) => ({
+        severity: "error",
+        code: "PATCH_ENTITY_HAS_REFERENCES",
+        file: patchFile,
+        path: `${operationPath}.entityId`,
+        message: `Entity '${operation.entityId}' is referenced by entity '${reference.entityId}' at ${reference.component}.${reference.field}.`,
+        suggestion: "Use rename_entity, replace_reference, or set allowDanglingReferences only when a later operation repairs references."
+      }));
+    }
+  }
+  scene.entities.splice(entityIndex, 1);
+  return [];
+}
+function applyRenameEntity(scene, operation, index, patchFile, summary) {
+  const operationPath = `$.operations[${index}]`;
+  const entity = findEntity(scene, operation.entityId);
+  if (!entity) {
+    return targetEntityNotFound(operation.entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (findEntity(scene, operation.newEntityId)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_DUPLICATE_ENTITY_ID",
+        file: patchFile,
+        path: `${operationPath}.newEntityId`,
+        message: `Entity id '${operation.newEntityId}' already exists.`,
+        suggestion: "Use a new stable entity id."
+      }
+    ];
+  }
+  entity.id = operation.newEntityId;
+  replaceReferences(scene, operation.entityId, operation.newEntityId, summary);
+  return [];
+}
+function applyRenameEntityAtSource(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const sourceIndex = entityIndexFromSourcePath(operation.sourcePath);
+  if (sourceIndex === void 0) {
+    return patchSourceSelectorInvalid(
+      patchFile,
+      `${operationPath}.sourcePath`,
+      "rename_entity_at_source sourcePath must target an entity array item.",
+      "Use a source path such as $.entities[1]."
+    );
+  }
+  const keepIndex = entityIndexFromSourcePath(operation.keepEntitySourcePath);
+  if (keepIndex === void 0) {
+    return patchSourceSelectorInvalid(
+      patchFile,
+      `${operationPath}.keepEntitySourcePath`,
+      "rename_entity_at_source keepEntitySourcePath must target an entity array item.",
+      "Use a source path such as $.entities[0]."
+    );
+  }
+  const selectedEntity = scene.entities[sourceIndex];
+  if (!selectedEntity || selectedEntity.id !== operation.entityId) {
+    return patchSourceSelectorMismatch(
+      patchFile,
+      `${operationPath}.sourcePath`,
+      `Selected source path '${operation.sourcePath}' no longer identifies duplicate entity '${operation.entityId}'.`
+    );
+  }
+  const duplicateIndexes = scene.entities.map((entity, entityIndex) => entity.id === operation.entityId ? entityIndex : -1).filter((entityIndex) => entityIndex >= 0);
+  if (duplicateIndexes.length !== operation.occurrenceCount || duplicateIndexes.length < 2) {
+    return patchSourceSelectorMismatch(
+      patchFile,
+      `${operationPath}.occurrenceCount`,
+      `Duplicate occurrence count for '${operation.entityId}' changed from ${operation.occurrenceCount} to ${duplicateIndexes.length}.`
+    );
+  }
+  const currentOccurrenceIndex = duplicateIndexes.indexOf(sourceIndex) + 1;
+  if (currentOccurrenceIndex !== operation.occurrenceIndex) {
+    return patchSourceSelectorMismatch(
+      patchFile,
+      `${operationPath}.occurrenceIndex`,
+      `Selected source path '${operation.sourcePath}' is occurrence ${currentOccurrenceIndex}, not occurrence ${operation.occurrenceIndex}.`
+    );
+  }
+  const keptEntity = scene.entities[keepIndex];
+  if (keepIndex === sourceIndex || !keptEntity || keptEntity.id !== operation.entityId || !duplicateIndexes.includes(keepIndex)) {
+    return patchSourceSelectorMismatch(
+      patchFile,
+      `${operationPath}.keepEntitySourcePath`,
+      "keepEntitySourcePath must identify a different current duplicate occurrence that keeps the original id."
+    );
+  }
+  if (operation.newEntityId === operation.entityId || findEntity(scene, operation.newEntityId)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_DUPLICATE_ENTITY_ID",
+        file: patchFile,
+        path: `${operationPath}.newEntityId`,
+        message: `Entity id '${operation.newEntityId}' already exists or matches the duplicate id.`,
+        suggestion: "Use a new stable entity id for only the selected duplicate occurrence."
+      }
+    ];
+  }
+  if (operation.referenceOwnership.trim().length === 0) {
+    return patchSourceSelectorMismatch(
+      patchFile,
+      `${operationPath}.referenceOwnership`,
+      "rename_entity_at_source requires a reviewed reference ownership note."
+    );
+  }
+  selectedEntity.id = operation.newEntityId;
+  return [];
+}
+function applyReplaceReference(scene, operation, index, patchFile, summary) {
+  const operationPath = `$.operations[${index}]`;
+  if (!findEntity(scene, operation.toEntityId)) {
+    return targetEntityNotFound(operation.toEntityId, patchFile, `${operationPath}.toEntityId`);
+  }
+  replaceReferences(scene, operation.fromEntityId, operation.toEntityId, summary);
+  return [];
+}
+function applyUpdateComponent(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const entity = findEntity(scene, operation.entityId);
+  if (!entity) {
+    return targetEntityNotFound(operation.entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (!isRecord(entity.components)) {
+    return entityComponentsUnavailable(operation.entityId, patchFile, operationPath);
+  }
+  if (!componentValidators[operation.component]) {
+    return unknownComponent(operation.component, patchFile, `${operationPath}.component`);
+  }
+  if (!Object.hasOwn(entity.components, operation.component)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_COMPONENT_NOT_FOUND",
+        file: patchFile,
+        path: `${operationPath}.component`,
+        message: `Entity '${operation.entityId}' does not have component '${operation.component}'.`,
+        suggestion: "Add the component before updating it."
+      }
+    ];
+  }
+  if (!isRecord(operation.value)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_COMPONENT_UPDATE_INVALID",
+        file: patchFile,
+        path: `${operationPath}.value`,
+        message: "update_component requires an object value to deep-merge into the component.",
+        suggestion: "Use an object containing only the component fields to update."
+      }
+    ];
+  }
+  entity.components[operation.component] = deepMergeObjects(entity.components[operation.component], operation.value);
+  return validateComponentValue(
+    operation.component,
+    entity.components[operation.component],
+    patchFile,
+    `${operationPath}.value`,
+    "PATCH_COMPONENT_INVALID"
+  );
+}
+function applyDuplicateEntity(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const sourceEntity = findEntity(scene, operation.entityId);
+  if (!sourceEntity) {
+    return targetEntityNotFound(operation.entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (findEntity(scene, operation.newEntityId)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_DUPLICATE_ENTITY_ID",
+        file: patchFile,
+        path: `${operationPath}.newEntityId`,
+        message: `Entity id '${operation.newEntityId}' already exists.`,
+        suggestion: "Use a new stable entity id."
+      }
+    ];
+  }
+  if (!isRecord(sourceEntity.components)) {
+    return entityComponentsUnavailable(operation.entityId, patchFile, operationPath);
+  }
+  const duplicatedComponents = cloneJson(sourceEntity.components);
+  const duplicatedEntity = {
+    id: operation.newEntityId,
+    components: duplicatedComponents
+  };
+  if (operation.overrides) {
+    for (const [componentName, override] of Object.entries(operation.overrides)) {
+      if (!componentValidators[componentName]) {
+        return unknownComponent(componentName, patchFile, `${operationPath}.overrides.${componentName}`);
+      }
+      duplicatedComponents[componentName] = Object.hasOwn(duplicatedComponents, componentName) ? deepMergeObjects(duplicatedComponents[componentName], override) : cloneJson(override);
+      const componentDiagnostics = validateComponentValue(
+        componentName,
+        duplicatedComponents[componentName],
+        patchFile,
+        `${operationPath}.overrides.${componentName}`,
+        "PATCH_COMPONENT_INVALID"
+      );
+      if (componentDiagnostics.length > 0) {
+        return componentDiagnostics;
+      }
+    }
+  }
+  scene.entities.push(duplicatedEntity);
+  return [];
+}
+function applyInstantiatePrefab(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  if (findEntity(scene, operation.entityId)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_DUPLICATE_ENTITY_ID",
+        file: patchFile,
+        path: `${operationPath}.entityId`,
+        message: `Entity id '${operation.entityId}' already exists.`,
+        suggestion: "Use a new stable entity id for the prefab instance."
+      }
+    ];
+  }
+  if (typeof operation.prefab !== "string" || operation.prefab.trim().length === 0) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_INVALID_PREFAB_PATH",
+        file: patchFile,
+        path: `${operationPath}.prefab`,
+        message: "instantiate_prefab requires a non-empty prefab path.",
+        suggestion: "Use a prefab path relative to the target scene, such as ../prefabs/slime.prefab.yml."
+      }
+    ];
+  }
+  const entity = {
+    id: operation.entityId,
+    prefab: operation.prefab
+  };
+  if (operation.overrides !== void 0) {
+    entity.overrides = cloneJson(operation.overrides);
+  }
+  scene.entities.push(entity);
+  return [];
+}
+function applySetParent(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const entity = findEntity(scene, operation.entityId);
+  if (!entity) {
+    return targetEntityNotFound(operation.entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (!findEntity(scene, operation.parentEntityId)) {
+    return targetEntityNotFound(operation.parentEntityId, patchFile, `${operationPath}.parentEntityId`);
+  }
+  if (operation.entityId === operation.parentEntityId) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_SELF_PARENT",
+        file: patchFile,
+        path: `${operationPath}.parentEntityId`,
+        message: `Entity '${operation.entityId}' cannot parent itself.`,
+        suggestion: "Use a different parent entity id or clear the parent."
+      }
+    ];
+  }
+  if (!isRecord(entity.components)) {
+    return entityComponentsUnavailable(operation.entityId, patchFile, operationPath);
+  }
+  entity.components.Parent = { entityId: operation.parentEntityId };
+  return [];
+}
+function applyClearParent(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const entity = findEntity(scene, operation.entityId);
+  if (!entity) {
+    return targetEntityNotFound(operation.entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (!isRecord(entity.components)) {
+    return entityComponentsUnavailable(operation.entityId, patchFile, operationPath);
+  }
+  delete entity.components.Parent;
+  return [];
+}
+function applyAddAnimationFrame(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const clipResult = findAnimationClipForPatch(scene, operation.entityId, patchFile, operationPath);
+  if (Array.isArray(clipResult)) {
+    return clipResult;
+  }
+  if (clipResult.frames.some((frame) => isRecord(frame) && frame.id === operation.frame.id)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_ANIMATION_FRAME_DUPLICATE",
+        file: patchFile,
+        path: `${operationPath}.frame.id`,
+        message: `Animation frame '${operation.frame.id}' already exists in clip '${String(clipResult.clip.id)}'.`,
+        suggestion: "Use a new stable SpriteFrame.id or update the existing frame."
+      }
+    ];
+  }
+  const insertIndex = animationFrameInsertIndex(clipResult.frames, operation.afterFrameId);
+  if (insertIndex === void 0) {
+    return animationFrameNotFound(
+      operation.afterFrameId ?? "<unknown>",
+      patchFile,
+      `${operationPath}.afterFrameId`,
+      "Choose an existing SpriteFrame.id from the target AnimationClip."
+    );
+  }
+  if (Array.isArray(clipResult.clip.frameOrder) && operation.afterFrameId) {
+    const frameOrderIndex = clipResult.clip.frameOrder.indexOf(operation.afterFrameId);
+    if (frameOrderIndex === -1) {
+      return animationFrameNotFound(
+        operation.afterFrameId,
+        patchFile,
+        `${operationPath}.afterFrameId`,
+        "When frameOrder is explicit, afterFrameId must also appear in AnimationClip.frameOrder."
+      );
+    }
+    clipResult.clip.frameOrder.splice(frameOrderIndex + 1, 0, operation.frame.id);
+  } else if (Array.isArray(clipResult.clip.frameOrder)) {
+    clipResult.clip.frameOrder.push(operation.frame.id);
+  }
+  clipResult.frames.splice(insertIndex, 0, cloneJson(operation.frame));
+  return validateComponentValue("AnimationClip", clipResult.clip, patchFile, operationPath, "PATCH_COMPONENT_INVALID");
+}
+function applyUpdateAnimationFrame(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const clipResult = findAnimationClipForPatch(scene, operation.entityId, patchFile, operationPath);
+  if (Array.isArray(clipResult)) {
+    return clipResult;
+  }
+  if (Object.keys(operation.value).length === 0) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_ANIMATION_FRAME_UPDATE_EMPTY",
+        file: patchFile,
+        path: `${operationPath}.value`,
+        message: "update_animation_frame requires at least one frame field to update.",
+        suggestion: "Set durationFrames, sprite, or rect."
+      }
+    ];
+  }
+  const frame = clipResult.frames.find((candidate) => isRecord(candidate) && candidate.id === operation.frameId);
+  if (!frame || !isRecord(frame)) {
+    return animationFrameNotFound(
+      operation.frameId,
+      patchFile,
+      `${operationPath}.frameId`,
+      "Inspect the target AnimationClip and choose an existing SpriteFrame.id."
+    );
+  }
+  Object.assign(frame, cloneJson(operation.value));
+  return validateComponentValue("AnimationClip", clipResult.clip, patchFile, operationPath, "PATCH_COMPONENT_INVALID");
+}
+function applyRemoveAnimationFrame(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  const clipResult = findAnimationClipForPatch(scene, operation.entityId, patchFile, operationPath);
+  if (Array.isArray(clipResult)) {
+    return clipResult;
+  }
+  const frameIndex = clipResult.frames.findIndex((frame) => isRecord(frame) && frame.id === operation.frameId);
+  if (frameIndex === -1) {
+    return animationFrameNotFound(
+      operation.frameId,
+      patchFile,
+      `${operationPath}.frameId`,
+      "Inspect the target AnimationClip and choose an existing SpriteFrame.id."
+    );
+  }
+  if (clipResult.frames.length <= 1) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_ANIMATION_FRAME_REQUIRED",
+        file: patchFile,
+        path: `${operationPath}.frameId`,
+        message: `AnimationClip '${String(clipResult.clip.id)}' must keep at least one frame.`,
+        suggestion: "Update the frame instead of removing the final frame, or add a replacement frame first."
+      }
+    ];
+  }
+  clipResult.frames.splice(frameIndex, 1);
+  if (Array.isArray(clipResult.clip.frameOrder)) {
+    clipResult.clip.frameOrder = clipResult.clip.frameOrder.filter((frameId) => frameId !== operation.frameId);
+  }
+  return validateComponentValue("AnimationClip", clipResult.clip, patchFile, operationPath, "PATCH_COMPONENT_INVALID");
+}
+function applySetAnimatorClip(scene, operation, index, patchFile) {
+  const operationPath = `$.operations[${index}]`;
+  if (!findAnimationClipById(scene, operation.clipId)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_ANIMATION_CLIP_NOT_FOUND",
+        file: patchFile,
+        path: `${operationPath}.clipId`,
+        message: `AnimationClip '${operation.clipId}' does not exist in the scene.`,
+        suggestion: "Use an AnimationClip.id from the target scene."
+      }
+    ];
+  }
+  const animatorResult = findAnimatorForPatch(scene, operation.entityId, patchFile, operationPath);
+  if (Array.isArray(animatorResult)) {
+    return animatorResult;
+  }
+  if (!Array.isArray(animatorResult.clips)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_ANIMATOR_CLIPS_INVALID",
+        file: patchFile,
+        path: `${operationPath}.entityId`,
+        message: `Entity '${operation.entityId}' Animator.clips must be an array before setting a clip.`,
+        suggestion: "Run scene validation and repair Animator.clips first."
+      }
+    ];
+  }
+  if (!animatorResult.clips.includes(operation.clipId)) {
+    animatorResult.clips.push(operation.clipId);
+  }
+  switch (operation.slot ?? "current") {
+    case "current":
+      animatorResult.currentClip = operation.clipId;
+      break;
+    case "default":
+      animatorResult.defaultClip = operation.clipId;
+      break;
+    case "active":
+      animatorResult.activeClip = operation.clipId;
+      break;
+  }
+  return validateComponentValue("Animator", animatorResult, patchFile, operationPath, "PATCH_COMPONENT_INVALID");
+}
+function findAnimationClipForPatch(scene, entityId, patchFile, operationPath) {
+  const entity = findEntity(scene, entityId);
+  if (!entity) {
+    return targetEntityNotFound(entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (!isRecord(entity.components)) {
+    return entityComponentsUnavailable(entityId, patchFile, operationPath);
+  }
+  const clip = getComponentRecord(entity, "AnimationClip");
+  if (!clip || !Array.isArray(clip.frames)) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_ANIMATION_CLIP_NOT_FOUND",
+        file: patchFile,
+        path: `${operationPath}.entityId`,
+        message: `Entity '${entityId}' does not have an AnimationClip component.`,
+        suggestion: "Target an entity that owns the AnimationClip component."
+      }
+    ];
+  }
+  return { entity, clip, frames: clip.frames };
+}
+function findAnimatorForPatch(scene, entityId, patchFile, operationPath) {
+  const entity = findEntity(scene, entityId);
+  if (!entity) {
+    return targetEntityNotFound(entityId, patchFile, `${operationPath}.entityId`);
+  }
+  if (!isRecord(entity.components)) {
+    return entityComponentsUnavailable(entityId, patchFile, operationPath);
+  }
+  const animator = getComponentRecord(entity, "Animator");
+  if (!animator) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_ANIMATOR_NOT_FOUND",
+        file: patchFile,
+        path: `${operationPath}.entityId`,
+        message: `Entity '${entityId}' does not have an Animator component.`,
+        suggestion: "Target an entity that owns the Animator component."
+      }
+    ];
+  }
+  return animator;
+}
+function findAnimationClipById(scene, clipId) {
+  for (const entity of scene.entities) {
+    const clip = getComponentRecord(entity, "AnimationClip");
+    if (clip?.id === clipId) {
+      return clip;
+    }
+  }
+  return void 0;
+}
+function animationFrameInsertIndex(frames, afterFrameId) {
+  if (afterFrameId === void 0) {
+    return frames.length;
+  }
+  const frameIndex = frames.findIndex((frame) => isRecord(frame) && frame.id === afterFrameId);
+  return frameIndex === -1 ? void 0 : frameIndex + 1;
+}
+function animationFrameNotFound(frameId, patchFile, dataPath, suggestion) {
+  return [
+    {
+      severity: "error",
+      code: "PATCH_ANIMATION_FRAME_NOT_FOUND",
+      file: patchFile,
+      path: dataPath,
+      message: `Animation frame '${frameId}' was not found.`,
+      suggestion
+    }
+  ];
+}
+async function validateInstantiatePrefabOperations(patch, patchFile, sceneFile) {
+  const diagnostics = [];
+  for (const [index, operation] of patch.operations.entries()) {
+    if (operation.op !== "instantiate_prefab") {
+      continue;
+    }
+    const operationPath = `$.operations[${index}]`;
+    if (typeof operation.prefab !== "string" || operation.prefab.trim().length === 0) {
+      diagnostics.push({
+        severity: "error",
+        code: "PATCH_INVALID_PREFAB_PATH",
+        file: patchFile,
+        path: `${operationPath}.prefab`,
+        message: "instantiate_prefab requires a non-empty prefab path.",
+        suggestion: "Use a prefab path relative to the target scene, such as ../prefabs/slime.prefab.yml."
+      });
+      continue;
+    }
+    const prefabFile = resolveScenePrefabPath(sceneFile, operation.prefab);
+    const prefabResult = await loadPrefabFile(prefabFile);
+    if (prefabResult.document === void 0 && prefabResult.diagnostics.some((diagnostic) => diagnostic.code === "FILE_READ_FAILED")) {
+      diagnostics.push({
+        severity: "error",
+        code: "PATCH_MISSING_PREFAB",
+        file: patchFile,
+        path: `${operationPath}.prefab`,
+        message: `Prefab file '${operation.prefab}' was not found.`,
+        suggestion: "Create the prefab file or update the prefab path relative to the target scene."
+      });
+      continue;
+    }
+    const prefabDiagnostics = [...prefabResult.diagnostics];
+    if (prefabResult.document !== void 0) {
+      prefabDiagnostics.push(...validatePrefabDocument(prefabResult.document, prefabResult.file));
+    }
+    if (prefabResult.document === void 0 || hasErrors(prefabDiagnostics)) {
+      diagnostics.push({
+        severity: "error",
+        code: "PATCH_INVALID_PREFAB",
+        file: patchFile,
+        path: `${operationPath}.prefab`,
+        message: `Prefab file '${operation.prefab}' is invalid.`,
+        suggestion: "Validate the prefab file before instantiating it."
+      });
+      diagnostics.push(...prefabDiagnostics);
+      continue;
+    }
+    diagnostics.push(
+      ...validatePrefabOverrideEntries(operation.overrides, prefabResult.document, patchFile, `${operationPath}.overrides`, {
+        invalidOverrides: "PATCH_INVALID_PREFAB_OVERRIDES",
+        unknownComponent: "PATCH_INVALID_PREFAB_OVERRIDES",
+        componentNotFound: "PATCH_INVALID_PREFAB_OVERRIDES",
+        invalidOverride: "PATCH_INVALID_PREFAB_OVERRIDES"
+      })
+    );
+  }
+  return diagnostics;
+}
+function validateComponentValue(componentName, value, file, dataPath, code) {
+  const validator = componentValidators[componentName];
+  if (!validator) {
+    return unknownComponent(componentName, file, dataPath);
+  }
+  return schemaDiagnostics(validator, value, file, code, dataPath);
+}
+function validatePrefabOverrides(entity, prefab, sceneFile, entityIndex) {
+  return validatePrefabOverrideEntries(
+    entity.overrides,
+    prefab,
+    sceneFile,
+    `$.entities[${entityIndex}].overrides`,
+    {
+      invalidOverrides: "SCENE_PREFAB_OVERRIDES_INVALID",
+      unknownComponent: "SCENE_PREFAB_OVERRIDE_UNKNOWN_COMPONENT",
+      componentNotFound: "SCENE_PREFAB_OVERRIDE_COMPONENT_NOT_FOUND",
+      invalidOverride: "SCENE_PREFAB_OVERRIDE_INVALID"
+    }
+  );
+}
+function validatePrefabOverrideEntries(overrides, prefab, file, pathPrefix, codes) {
+  const diagnostics = [];
+  if (overrides === void 0) {
+    return diagnostics;
+  }
+  if (!isRecord(overrides)) {
+    return [
+      {
+        severity: "error",
+        code: codes.invalidOverrides,
+        file,
+        path: pathPrefix,
+        message: "Prefab overrides must be an object keyed by component name.",
+        suggestion: "Use component names such as Transform under overrides."
+      }
+    ];
+  }
+  for (const [componentName, overrideValue] of Object.entries(overrides)) {
+    const overridePath = `${pathPrefix}.${componentName}`;
+    if (!componentValidators[componentName]) {
+      diagnostics.push({
+        severity: "error",
+        code: codes.unknownComponent,
+        file,
+        path: overridePath,
+        message: `Unknown component '${componentName}' in prefab override.`,
+        suggestion: `Use one of: ${componentOrder.join(", ")}.`
+      });
+      continue;
+    }
+    if (!Object.hasOwn(prefab.components, componentName)) {
+      diagnostics.push({
+        severity: "error",
+        code: codes.componentNotFound,
+        file,
+        path: overridePath,
+        message: `Prefab '${prefab.prefab}' does not define component '${componentName}'.`,
+        suggestion: "Override only components defined by the prefab in v0."
+      });
+      continue;
+    }
+    if (!isRecord(overrideValue)) {
+      diagnostics.push({
+        severity: "error",
+        code: codes.invalidOverride,
+        file,
+        path: overridePath,
+        message: `Override for component '${componentName}' must be an object.`,
+        suggestion: "Provide only the component fields to override."
+      });
+      continue;
+    }
+    const mergedValue = deepMergeObjects(prefab.components[componentName], overrideValue);
+    diagnostics.push(
+      ...validateComponentValue(componentName, mergedValue, file, overridePath, codes.invalidOverride)
+    );
+  }
+  return diagnostics;
+}
+function targetEntityNotFound(entityId, file, dataPath) {
+  return [
+    {
+      severity: "error",
+      code: "PATCH_TARGET_ENTITY_NOT_FOUND",
+      file,
+      path: dataPath,
+      message: `Target entity '${entityId}' was not found.`,
+      suggestion: "Inspect the scene and use an existing stable entity id."
+    }
+  ];
+}
+function entityComponentsUnavailable(entityId, file, operationPath) {
+  return [
+    {
+      severity: "error",
+      code: "PATCH_ENTITY_COMPONENTS_UNAVAILABLE",
+      file,
+      path: `${operationPath}.entityId`,
+      message: `Entity '${entityId}' does not define direct components.`,
+      suggestion: "For prefab instances, edit overrides or instantiate a direct entity before component patch operations."
+    }
+  ];
+}
+function unknownComponent(componentName, file, dataPath) {
+  return [
+    {
+      severity: "error",
+      code: "PATCH_UNKNOWN_COMPONENT",
+      file,
+      path: dataPath,
+      message: `Unknown component '${componentName}'.`,
+      suggestion: `Use one of: ${componentOrder.join(", ")}.`
+    }
+  ];
+}
+function entityIndexFromSourcePath(sourcePath) {
+  const match = /^\$\.entities\[(\d+)\]$/.exec(sourcePath);
+  if (!match) {
+    return void 0;
+  }
+  return Number(match[1]);
+}
+function patchSourceSelectorInvalid(file, dataPath, message, suggestion) {
+  return [
+    {
+      severity: "error",
+      code: "PATCH_SOURCE_SELECTOR_INVALID",
+      file,
+      path: dataPath,
+      message,
+      suggestion
+    }
+  ];
+}
+function patchSourceSelectorMismatch(file, dataPath, message) {
+  return [
+    {
+      severity: "error",
+      code: "PATCH_SOURCE_SELECTOR_MISMATCH",
+      file,
+      path: dataPath,
+      message,
+      suggestion: "Re-run validation and regenerate the selector-based repair artifact from current source evidence."
+    }
+  ];
+}
+function findEntity(scene, entityId) {
+  return scene.entities.find((entity) => entity.id === entityId);
+}
+function findEntityReferences(scene, targetEntityId) {
+  const references = [];
+  scene.entities.forEach((entity, entityIndex) => {
+    if (!isRecord(entity) || typeof entity.id !== "string" || !isRecord(entity.components)) {
+      return;
+    }
+    for (const [componentName, componentValue] of Object.entries(entity.components ?? {})) {
+      if (!isRecord(componentValue)) {
+        continue;
+      }
+      for (const referenceField of componentReferenceFields[componentName] ?? []) {
+        const referencedId = componentValue[referenceField];
+        if (typeof referencedId !== "string") {
+          continue;
+        }
+        if (targetEntityId && referencedId !== targetEntityId) {
+          continue;
+        }
+        references.push({
+          entityId: entity.id,
+          component: componentName,
+          field: referenceField,
+          path: `$.entities[${entityIndex}].components.${componentName}.${referenceField}`,
+          value: referencedId
+        });
+      }
+    }
+  });
+  return references;
+}
+function replaceReferences(scene, fromEntityId, toEntityId, summary) {
+  const changes = [];
+  for (const reference of findEntityReferences(scene, fromEntityId)) {
+    const entity = findEntity(scene, reference.entityId);
+    const componentValue = entity?.components?.[reference.component];
+    if (!isRecord(componentValue)) {
+      continue;
+    }
+    componentValue[reference.field] = toEntityId;
+    const change = {
+      ...reference,
+      from: fromEntityId,
+      to: toEntityId
+    };
+    changes.push(change);
+    summary.changedReferences.push(change);
+  }
+  return changes;
+}
+function deriveHierarchy(scene, file = "scene.yml") {
+  const ids = scene.entities.map((entity) => entity.id).filter((entityId) => typeof entityId === "string").sort();
+  const idSet = new Set(ids);
+  const parentByEntityId = {};
+  const childrenByEntityId = Object.fromEntries(ids.map((entityId) => [entityId, []]));
+  const diagnostics = [];
+  for (const [entityIndex, entity] of scene.entities.entries()) {
+    const parentEntityId = getParentEntityId(entity);
+    if (typeof entity.id !== "string" || parentEntityId === void 0) {
+      continue;
+    }
+    const parentPath = `$.entities[${entityIndex}].components.Parent.entityId`;
+    if (!idSet.has(parentEntityId)) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_BROKEN_ENTITY_REFERENCE",
+        file,
+        path: parentPath,
+        message: `Parent entity reference '${parentEntityId}' does not resolve.`,
+        suggestion: "Use the stable id of an entity in this scene."
+      });
+      continue;
+    }
+    if (parentEntityId === entity.id) {
+      diagnostics.push(selfParentDiagnostic(entity.id, file, parentPath));
+      continue;
+    }
+    parentByEntityId[entity.id] = parentEntityId;
+    childrenByEntityId[parentEntityId]?.push(entity.id);
+  }
+  for (const children of Object.values(childrenByEntityId)) {
+    children.sort();
+  }
+  diagnostics.push(...findParentCycleDiagnostics(scene, file, parentByEntityId));
+  return {
+    roots: ids.filter((entityId) => !Object.hasOwn(parentByEntityId, entityId)),
+    childrenByEntityId,
+    parentByEntityId,
+    depthByEntityId: computeHierarchyDepths(ids, parentByEntityId),
+    diagnostics
+  };
+}
+function computeWorldTransforms(scene, file = "scene.yml") {
+  const hierarchy = deriveHierarchy(scene, file);
+  const entityById = new Map(scene.entities.map((entity) => [entity.id, entity]));
+  const transforms = {};
+  const visiting = /* @__PURE__ */ new Set();
+  function resolveWorldTransform(entityId) {
+    if (Object.hasOwn(transforms, entityId)) {
+      return transforms[entityId];
+    }
+    if (visiting.has(entityId)) {
+      return void 0;
+    }
+    visiting.add(entityId);
+    const entity = entityById.get(entityId);
+    const localTransform = getTransformSummary(entity);
+    if (!localTransform) {
+      visiting.delete(entityId);
+      return void 0;
+    }
+    const parentId = hierarchy.parentByEntityId[entityId];
+    const parentTransform = parentId ? resolveWorldTransform(parentId) : void 0;
+    const worldTransform = parentTransform ? composeTransform(parentTransform, localTransform) : localTransform;
+    transforms[entityId] = worldTransform;
+    visiting.delete(entityId);
+    return worldTransform;
+  }
+  for (const entityId of scene.entities.map((entity) => entity.id).filter((id) => typeof id === "string").sort()) {
+    resolveWorldTransform(entityId);
+  }
+  return {
+    transforms,
+    diagnostics: hierarchy.diagnostics
+  };
+}
+function validateHierarchyRules(scene, file, ids) {
+  const diagnostics = [];
+  const parentByEntityId = {};
+  for (const [entityIndex, entity] of scene.entities.entries()) {
+    const parentEntityId = getParentEntityId(entity);
+    if (typeof entity.id !== "string" || parentEntityId === void 0 || !ids.has(parentEntityId)) {
+      continue;
+    }
+    const parentPath = `$.entities[${entityIndex}].components.Parent.entityId`;
+    if (parentEntityId === entity.id) {
+      diagnostics.push(selfParentDiagnostic(entity.id, file, parentPath));
+      continue;
+    }
+    parentByEntityId[entity.id] = parentEntityId;
+  }
+  diagnostics.push(...findParentCycleDiagnostics(scene, file, parentByEntityId));
+  return diagnostics;
+}
+function validateAnimationRules(scene, file) {
+  const diagnostics = [];
+  const clips = /* @__PURE__ */ new Map();
+  for (const [entityIndex, entity] of scene.entities.entries()) {
+    const clip = getComponentRecord(entity, "AnimationClip");
+    if (!clip || typeof clip.id !== "string") {
+      continue;
+    }
+    const frames = Array.isArray(clip.frames) ? clip.frames : [];
+    const frameIds = /* @__PURE__ */ new Set();
+    frames.forEach((frame, frameIndex) => {
+      if (!isRecord(frame) || typeof frame.id !== "string") {
+        return;
+      }
+      if (frameIds.has(frame.id)) {
+        diagnostics.push({
+          severity: "error",
+          code: "SCENE_DUPLICATE_ANIMATION_FRAME_ID",
+          file,
+          path: `$.entities[${entityIndex}].components.AnimationClip.frames[${frameIndex}].id`,
+          message: `Duplicate animation frame id '${frame.id}' in clip '${clip.id}'.`,
+          suggestion: "Use stable SpriteFrame.id values that are unique within each AnimationClip."
+        });
+        return;
+      }
+      frameIds.add(frame.id);
+    });
+    if (Array.isArray(clip.frameOrder)) {
+      clip.frameOrder.forEach((frameId, frameOrderIndex) => {
+        if (typeof frameId === "string" && !frameIds.has(frameId)) {
+          diagnostics.push({
+            severity: "error",
+            code: "SCENE_BROKEN_ANIMATION_FRAME_REFERENCE",
+            file,
+            path: `$.entities[${entityIndex}].components.AnimationClip.frameOrder[${frameOrderIndex}]`,
+            message: `AnimationClip frameOrder references missing frame '${frameId}'.`,
+            suggestion: "Use a SpriteFrame.id defined in AnimationClip.frames."
+          });
+        }
+      });
+    }
+    const clipPath = `$.entities[${entityIndex}].components.AnimationClip.id`;
+    if (clips.has(clip.id)) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_DUPLICATE_ANIMATION_CLIP_ID",
+        file,
+        path: clipPath,
+        message: `Duplicate animation clip id '${clip.id}'.`,
+        suggestion: "Use one stable AnimationClip.id per scene."
+      });
+      continue;
+    }
+    clips.set(clip.id, {
+      entityId: entity.id,
+      frameCount: Array.isArray(clip.frameOrder) ? clip.frameOrder.length : frames.length,
+      frameIds
+    });
+  }
+  for (const [entityIndex, entity] of scene.entities.entries()) {
+    const animator = getComponentRecord(entity, "Animator");
+    if (!animator) {
+      continue;
+    }
+    if (Array.isArray(animator.clips)) {
+      animator.clips.forEach((clipId, clipIndex) => {
+        if (typeof clipId === "string" && !clips.has(clipId)) {
+          diagnostics.push({
+            severity: "error",
+            code: "SCENE_BROKEN_ANIMATION_CLIP_REFERENCE",
+            file,
+            path: `$.entities[${entityIndex}].components.Animator.clips[${clipIndex}]`,
+            message: `Animator references missing animation clip '${clipId}'.`,
+            suggestion: "Use an AnimationClip.id defined in this scene."
+          });
+        }
+      });
+    }
+    if (typeof animator.defaultClip === "string") {
+      const defaultClipPath = `$.entities[${entityIndex}].components.Animator.defaultClip`;
+      if (!clips.has(animator.defaultClip)) {
+        diagnostics.push({
+          severity: "error",
+          code: "SCENE_BROKEN_ANIMATION_CLIP_REFERENCE",
+          file,
+          path: defaultClipPath,
+          message: `Animator defaultClip '${animator.defaultClip}' does not resolve.`,
+          suggestion: "Use an AnimationClip.id defined in this scene."
+        });
+      } else if (Array.isArray(animator.clips) && !animator.clips.includes(animator.defaultClip)) {
+        diagnostics.push({
+          severity: "error",
+          code: "SCENE_ANIMATOR_DEFAULT_CLIP_NOT_LISTED",
+          file,
+          path: defaultClipPath,
+          message: `Animator defaultClip '${animator.defaultClip}' is not listed in Animator.clips.`,
+          suggestion: "Add the default clip id to Animator.clips or choose a listed clip."
+        });
+      }
+    }
+    const activeClipId = typeof animator.activeClip === "string" ? animator.activeClip : void 0;
+    const activeClip = activeClipId ? clips.get(activeClipId) : void 0;
+    if (activeClipId) {
+      const activeClipPath = `$.entities[${entityIndex}].components.Animator.activeClip`;
+      if (!activeClip) {
+        diagnostics.push({
+          severity: "error",
+          code: "SCENE_BROKEN_ANIMATION_CLIP_REFERENCE",
+          file,
+          path: activeClipPath,
+          message: `Animator activeClip '${activeClipId}' does not resolve.`,
+          suggestion: "Use an AnimationClip.id defined in this scene."
+        });
+      } else if (Array.isArray(animator.clips) && !animator.clips.includes(activeClipId)) {
+        diagnostics.push({
+          severity: "error",
+          code: "SCENE_ANIMATOR_ACTIVE_CLIP_NOT_LISTED",
+          file,
+          path: activeClipPath,
+          message: `Animator activeClip '${activeClipId}' is not listed in Animator.clips.`,
+          suggestion: "Add the active clip id to Animator.clips or choose a listed clip."
+        });
+      }
+    }
+    if (typeof animator.currentClip !== "string") {
+      continue;
+    }
+    const currentClipPath = `$.entities[${entityIndex}].components.Animator.currentClip`;
+    const currentClip = clips.get(animator.currentClip);
+    if (!currentClip) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_BROKEN_ANIMATION_CLIP_REFERENCE",
+        file,
+        path: currentClipPath,
+        message: `Animator currentClip '${animator.currentClip}' does not resolve.`,
+        suggestion: "Use an AnimationClip.id defined in this scene."
+      });
+      continue;
+    }
+    if (Array.isArray(animator.clips) && !animator.clips.includes(animator.currentClip)) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_ANIMATOR_CURRENT_CLIP_NOT_LISTED",
+        file,
+        path: currentClipPath,
+        message: `Animator currentClip '${animator.currentClip}' is not listed in Animator.clips.`,
+        suggestion: "Add the current clip id to Animator.clips or choose a listed clip."
+      });
+    }
+    const playbackClip = activeClip ?? currentClip;
+    if (typeof animator.activeFrameId === "string" && playbackClip && !playbackClip.frameIds.has(animator.activeFrameId)) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_BROKEN_ANIMATION_FRAME_REFERENCE",
+        file,
+        path: `$.entities[${entityIndex}].components.Animator.activeFrameId`,
+        message: `Animator activeFrameId '${animator.activeFrameId}' does not resolve in '${activeClipId ?? animator.currentClip}'.`,
+        suggestion: "Use a SpriteFrame.id from the active animation clip."
+      });
+    }
+    if (typeof animator.currentFrameIndex === "number" && Number.isInteger(animator.currentFrameIndex) && animator.currentFrameIndex >= playbackClip.frameCount) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_ANIMATOR_FRAME_OUT_OF_RANGE",
+        file,
+        path: `$.entities[${entityIndex}].components.Animator.currentFrameIndex`,
+        message: `Animator currentFrameIndex ${animator.currentFrameIndex} is outside '${activeClipId ?? animator.currentClip}'.`,
+        suggestion: `Use a frame index from 0 to ${Math.max(playbackClip.frameCount - 1, 0)} or omit currentFrameIndex.`
+      });
+    }
+  }
+  return diagnostics;
+}
+function validate3DContractRules(scene, file) {
+  const diagnostics = [];
+  const meshRefs = /* @__PURE__ */ new Map();
+  for (const [entityIndex, entity] of scene.entities.entries()) {
+    const transform = getComponentRecord(entity, "Transform3D");
+    if (transform) {
+      diagnostics.push(...validateTransform3DValue(transform, file, `$.entities[${entityIndex}].components.Transform3D`));
+    }
+    const camera = getComponentRecord(entity, "Camera3D");
+    if (camera) {
+      diagnostics.push(...validateCamera3DValue(camera, file, `$.entities[${entityIndex}].components.Camera3D`));
+    }
+    const collider = getComponentRecord(entity, "Collider3D");
+    if (collider) {
+      diagnostics.push(...validateCollider3DValue(collider, file, `$.entities[${entityIndex}].components.Collider3D`));
+    }
+    const meshRef = getComponentRecord(entity, "MeshRef");
+    if (!meshRef || typeof meshRef.id !== "string") {
+      continue;
+    }
+    const meshPath = `$.entities[${entityIndex}].components.MeshRef`;
+    if (meshRefs.has(meshRef.id)) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_DUPLICATE_MESH_REF_ID",
+        file,
+        path: `${meshPath}.id`,
+        message: `Duplicate MeshRef id '${meshRef.id}'.`,
+        suggestion: "Use one stable MeshRef.id per expanded scene."
+      });
+    } else {
+      meshRefs.set(meshRef.id, {
+        entityId: entity.id,
+        path: meshPath
+      });
+    }
+    if (typeof meshRef.path === "string" && !isPortableAssetPath(meshRef.path)) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_MESH_PATH_INVALID",
+        file,
+        path: `${meshPath}.path`,
+        message: `Mesh path '${meshRef.path}' is not a portable project-relative path.`,
+        suggestion: "Use a relative path with forward slashes, no drive letters, no leading slash, and no '..' segments."
+      });
+    }
+  }
+  for (const [entityIndex, entity] of scene.entities.entries()) {
+    const renderer = getComponentRecord(entity, "MeshRenderer3D");
+    if (!renderer || typeof renderer.mesh !== "string") {
+      continue;
+    }
+    if (!meshRefs.has(renderer.mesh)) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_BROKEN_MESH_REFERENCE",
+        file,
+        path: `$.entities[${entityIndex}].components.MeshRenderer3D.mesh`,
+        message: `MeshRenderer3D references missing MeshRef '${renderer.mesh}'.`,
+        suggestion: "Use a MeshRef.id defined in this expanded scene."
+      });
+    }
+  }
+  return diagnostics;
+}
+function createHierarchySummary(hierarchy) {
+  const entityIds = Object.keys(hierarchy.childrenByEntityId).sort();
+  return {
+    roots: [...hierarchy.roots].sort(),
+    nodes: entityIds.map((entityId) => ({
+      entityId,
+      ...hierarchy.parentByEntityId[entityId] ? { parent: hierarchy.parentByEntityId[entityId] } : {},
+      children: hierarchy.childrenByEntityId[entityId] ?? [],
+      depth: hierarchy.depthByEntityId[entityId] ?? 0
+    }))
+  };
+}
+function inspectSceneAnimations(scene, assets = createAssetManifestContext()) {
+  const clips = [];
+  const animators = [];
+  for (const entity of scene.entities) {
+    const clip = getComponentRecord(entity, "AnimationClip");
+    if (clip && typeof clip.id === "string" && Array.isArray(clip.frames)) {
+      const frameOrder = Array.isArray(clip.frameOrder) ? clip.frameOrder.filter((frameId) => typeof frameId === "string") : void 0;
+      const orderedFrameIds = orderedAnimationFrameIds(clip.frames, frameOrder);
+      clips.push({
+        id: clip.id,
+        entityId: entity.id,
+        frameCount: clip.frames.length,
+        durationFrames: sumFrameDurations(clip.frames),
+        ...typeof clip.fps === "number" ? { fps: clip.fps } : {},
+        ...frameOrder ? { frameOrder } : {},
+        orderedFrameIds,
+        spriteAssetIds: [
+          ...new Set(
+            clip.frames.map((frame) => isRecord(frame) && typeof frame.sprite === "string" ? frame.sprite : void 0).filter((sprite) => typeof sprite === "string")
+          )
+        ].sort(),
+        frames: createAnimationFrameSummaries(clip.frames, orderedFrameIds, assets)
+      });
+    }
+    const animator = getComponentRecord(entity, "Animator");
+    if (animator && Array.isArray(animator.clips) && typeof animator.currentClip === "string") {
+      animators.push({
+        entityId: entity.id,
+        clips: animator.clips.filter((clipId) => typeof clipId === "string"),
+        ...typeof animator.defaultClip === "string" ? { defaultClip: animator.defaultClip } : {},
+        currentClip: animator.currentClip,
+        ...typeof animator.activeClip === "string" ? { activeClip: animator.activeClip } : {},
+        ...typeof animator.activeFrameId === "string" ? { activeFrameId: animator.activeFrameId } : {},
+        ...typeof animator.currentFrameIndex === "number" ? { currentFrameIndex: animator.currentFrameIndex } : {},
+        ...typeof animator.elapsedFrames === "number" ? { elapsedFrames: animator.elapsedFrames } : {},
+        ...typeof animator.elapsedSeconds === "number" ? { elapsedSeconds: animator.elapsedSeconds } : {}
+      });
+    }
+  }
+  return {
+    clips: clips.sort((left, right) => left.id.localeCompare(right.id) || left.entityId.localeCompare(right.entityId)),
+    animators: animators.sort((left, right) => left.entityId.localeCompare(right.entityId))
+  };
+}
+function orderedAnimationFrameIds(frames, frameOrder) {
+  const frameIds = frames.map((frame) => isRecord(frame) && typeof frame.id === "string" ? frame.id : void 0).filter((frameId) => typeof frameId === "string");
+  if (!frameOrder || frameOrder.length === 0) {
+    return frameIds;
+  }
+  const frameIdSet = new Set(frameIds);
+  return frameOrder.filter((frameId) => frameIdSet.has(frameId));
+}
+function createAnimationFrameSummaries(frames, orderedFrameIds, assets) {
+  const playbackOrderByFrameId = new Map(orderedFrameIds.map((frameId, index) => [frameId, index]));
+  return frames.flatMap((frame, index) => {
+    if (!isRecord(frame) || typeof frame.id !== "string" || typeof frame.durationFrames !== "number") {
+      return [];
+    }
+    const sprite = typeof frame.sprite === "string" ? frame.sprite : void 0;
+    const asset = sprite ? assets.assetsById.get(sprite) : void 0;
+    const atlasFrame = asset ? resolveAssetAtlasFrame(asset, assets) : void 0;
+    const rect = readRectTuple(frame.rect);
+    return [
+      {
+        id: frame.id,
+        durationFrames: frame.durationFrames,
+        order: index,
+        playbackOrder: playbackOrderByFrameId.get(frame.id) ?? index,
+        ...sprite ? { sprite } : {},
+        ...rect ? { rect } : {},
+        ...sprite ? { assetResolved: asset?.type === "sprite" } : {},
+        ...asset ? { assetType: asset.type, assetPath: asset.path } : {},
+        ...asset?.texture ? { texture: asset.texture } : {},
+        ...asset?.rect ? { assetRect: asset.rect } : {},
+        ...asset?.atlas ? { assetAtlas: asset.atlas } : {},
+        ...asset?.frame ? { assetFrame: asset.frame } : {},
+        ...atlasFrame ? { assetFrameRect: atlasFrame.rect } : {}
+      }
+    ];
+  });
+}
+function resolveAssetAtlasFrame(asset, assets) {
+  if (!asset.atlas || !asset.frame) {
+    return void 0;
+  }
+  const atlas = assets.assetsById.get(asset.atlas);
+  if (atlas?.type !== "atlas") {
+    return void 0;
+  }
+  return atlas.frames?.find((frame) => frame.id === asset.frame);
+}
+function readRectTuple(value) {
+  if (!Array.isArray(value) || value.length !== 4 || !value.every((item) => typeof item === "number" && Number.isFinite(item))) {
+    return void 0;
+  }
+  return [value[0], value[1], value[2], value[3]];
+}
+function validateSceneAssetReferences(scene, file, assets) {
+  const diagnostics = [];
+  for (const reference of findSceneAssetReferences(scene)) {
+    const asset = assets.assetsById.get(reference.assetId);
+    if (!asset) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_BROKEN_ASSET_REFERENCE",
+        file,
+        path: reference.path,
+        message: `Asset reference '${reference.assetId}' does not resolve.`,
+        suggestion: "Add the asset id to a project asset manifest or update the scene reference."
+      });
+      continue;
+    }
+    if (asset.type !== reference.expectedType) {
+      diagnostics.push({
+        severity: "error",
+        code: "SCENE_ASSET_TYPE_MISMATCH",
+        file,
+        path: reference.path,
+        message: `Asset reference '${reference.assetId}' is '${asset.type}', not '${reference.expectedType}'.`,
+        suggestion: `Use an asset id with type '${reference.expectedType}' for this field.`
+      });
+    }
+  }
+  return diagnostics;
+}
+function createSceneAssetSummary(scene, assets) {
+  const references = findSceneAssetReferences(scene).map((reference) => {
+    const asset = assets.assetsById.get(reference.assetId);
+    return {
+      assetId: reference.assetId,
+      expectedType: reference.expectedType,
+      path: reference.path,
+      entityId: reference.entityId,
+      component: reference.component,
+      field: reference.field,
+      resolved: asset?.type === reference.expectedType,
+      ...asset ? { actualType: asset.type } : {}
+    };
+  });
+  return {
+    manifestCount: assets.manifestFiles.length,
+    assetCount: assets.assetsById.size,
+    atlasCount: [...assets.assetsById.values()].filter((asset) => asset.type === "atlas").length,
+    atlasFrameCount: [...assets.assetsById.values()].reduce(
+      (total, asset) => total + (asset.type === "atlas" ? asset.frames?.length ?? 0 : 0),
+      0
+    ),
+    referencedAssets: references,
+    unresolvedReferences: references.filter((reference) => !reference.resolved)
+  };
+}
+function findSceneAssetReferences(scene) {
+  const references = [];
+  scene.entities.forEach((entity, entityIndex) => {
+    const clip = getComponentRecord(entity, "AnimationClip");
+    if (!clip || !Array.isArray(clip.frames)) {
+      return;
+    }
+    clip.frames.forEach((frame, frameIndex) => {
+      if (!isRecord(frame) || typeof frame.sprite !== "string") {
+        return;
+      }
+      references.push({
+        assetId: frame.sprite,
+        expectedType: "sprite",
+        path: `$.entities[${entityIndex}].components.AnimationClip.frames[${frameIndex}].sprite`,
+        entityId: entity.id,
+        component: "AnimationClip",
+        field: "frames[].sprite"
+      });
+    });
+  });
+  return references;
+}
+function getComponentRecord(entity, componentName) {
+  if (!isRecord(entity.components)) {
+    return void 0;
+  }
+  const component = entity.components[componentName];
+  return isRecord(component) ? component : void 0;
+}
+function sumFrameDurations(frames) {
+  return frames.reduce((total, frame) => {
+    if (!isRecord(frame) || typeof frame.durationFrames !== "number") {
+      return total;
+    }
+    return total + frame.durationFrames;
+  }, 0);
+}
+function selfParentDiagnostic(entityId, file, dataPath) {
+  return {
+    severity: "error",
+    code: "SCENE_SELF_PARENT",
+    file,
+    path: dataPath,
+    message: `Entity '${entityId}' cannot parent itself.`,
+    suggestion: "Use a different parent entity id or remove the Parent component."
+  };
+}
+function findParentCycleDiagnostics(scene, file, parentByEntityId) {
+  const diagnostics = [];
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  const reportedCycles = /* @__PURE__ */ new Set();
+  function visit(entityId) {
+    const currentState = state.get(entityId);
+    if (currentState === "visited") {
+      return;
+    }
+    if (currentState === "visiting") {
+      const cycleStart = stack.indexOf(entityId);
+      const cycleEntities = cycleStart >= 0 ? stack.slice(cycleStart) : [entityId];
+      const cycleKey = [...cycleEntities].sort().join(">");
+      if (!reportedCycles.has(cycleKey)) {
+        reportedCycles.add(cycleKey);
+        const cyclePath = [...cycleEntities, entityId].join(" -> ");
+        diagnostics.push({
+          severity: "error",
+          code: "SCENE_PARENT_CYCLE",
+          file,
+          path: parentFieldPath(scene, cycleEntities[0] ?? entityId),
+          message: `Parent cycle detected: ${cyclePath}.`,
+          suggestion: "Clear or retarget one Parent component so the hierarchy is a tree or forest."
+        });
+      }
+      return;
+    }
+    state.set(entityId, "visiting");
+    stack.push(entityId);
+    const parentEntityId = parentByEntityId[entityId];
+    if (parentEntityId) {
+      visit(parentEntityId);
+    }
+    stack.pop();
+    state.set(entityId, "visited");
+  }
+  for (const entityId of Object.keys(parentByEntityId).sort()) {
+    visit(entityId);
+  }
+  return diagnostics;
+}
+function computeHierarchyDepths(ids, parentByEntityId) {
+  const depths = {};
+  function depthOf(entityId, visiting = /* @__PURE__ */ new Set()) {
+    if (Object.hasOwn(depths, entityId)) {
+      return depths[entityId];
+    }
+    const parentEntityId = parentByEntityId[entityId];
+    if (!parentEntityId || visiting.has(entityId)) {
+      depths[entityId] = 0;
+      return depths[entityId];
+    }
+    visiting.add(entityId);
+    depths[entityId] = depthOf(parentEntityId, visiting) + 1;
+    visiting.delete(entityId);
+    return depths[entityId];
+  }
+  for (const entityId of ids) {
+    depthOf(entityId);
+  }
+  return depths;
+}
+function parentFieldPath(scene, entityId) {
+  const entityIndex = scene.entities.findIndex((entity) => entity.id === entityId);
+  return entityIndex >= 0 ? `$.entities[${entityIndex}].components.Parent.entityId` : "$.entities";
+}
+function getParentEntityId(entity) {
+  const parent = entity.components?.Parent;
+  if (!isRecord(parent) || typeof parent.entityId !== "string") {
+    return void 0;
+  }
+  return parent.entityId;
+}
+function getTransformSummary(entity) {
+  const transform = entity?.components?.Transform;
+  if (!isRecord(transform)) {
+    return void 0;
+  }
+  const position = transform.position;
+  const scale = transform.scale;
+  const rotation = transform.rotation;
+  if (!isVector2(position) || !isVector2(scale) || typeof rotation !== "number") {
+    return void 0;
+  }
+  return {
+    position: [position[0], position[1]],
+    rotation,
+    scale: [scale[0], scale[1]]
+  };
+}
+function composeTransform(parent, local) {
+  const scaledLocalX = local.position[0] * parent.scale[0];
+  const scaledLocalY = local.position[1] * parent.scale[1];
+  const cos = Math.cos(parent.rotation);
+  const sin = Math.sin(parent.rotation);
+  return {
+    position: [
+      roundDeterministic(parent.position[0] + scaledLocalX * cos - scaledLocalY * sin),
+      roundDeterministic(parent.position[1] + scaledLocalX * sin + scaledLocalY * cos)
+    ],
+    rotation: roundDeterministic(parent.rotation + local.rotation),
+    scale: [
+      roundDeterministic(parent.scale[0] * local.scale[0]),
+      roundDeterministic(parent.scale[1] * local.scale[1])
+    ]
+  };
+}
+function isVector2(value) {
+  return Array.isArray(value) && value.length === 2 && value.every((item) => typeof item === "number");
+}
+function isVector3(value) {
+  return Array.isArray(value) && value.length === 3 && value.every((item) => typeof item === "number");
+}
+function validateTransform3DValue(transform, file, basePath) {
+  const diagnostics = [];
+  diagnostics.push(...validateFiniteVector3(transform.position, file, `${basePath}.position`, "SCENE_3D_COORDINATE_INVALID"));
+  diagnostics.push(...validateFiniteVector3(transform.rotation, file, `${basePath}.rotation`, "SCENE_3D_ROTATION_INVALID"));
+  diagnostics.push(
+    ...validateFiniteVector3(transform.scale, file, `${basePath}.scale`, "SCENE_3D_SCALE_INVALID", {
+      requirePositive: true
+    })
+  );
+  return diagnostics;
+}
+function validateCamera3DValue(camera, file, basePath) {
+  const diagnostics = [];
+  if (typeof camera.near === "number" && typeof camera.far === "number" && camera.far <= camera.near) {
+    diagnostics.push({
+      severity: "error",
+      code: "SCENE_3D_CAMERA_RANGE_INVALID",
+      file,
+      path: `${basePath}.far`,
+      message: `Camera3D far plane ${camera.far} must be greater than near plane ${camera.near}.`,
+      suggestion: "Use a far value greater than near."
+    });
+  }
+  if (camera.projection === "perspective" && typeof camera.fov !== "number") {
+    diagnostics.push({
+      severity: "error",
+      code: "SCENE_3D_CAMERA_FOV_REQUIRED",
+      file,
+      path: `${basePath}.fov`,
+      message: "Perspective Camera3D requires fov.",
+      suggestion: "Add fov with a value greater than 0 and less than 180."
+    });
+  }
+  if (camera.projection === "orthographic" && typeof camera.orthographicSize !== "number") {
+    diagnostics.push({
+      severity: "error",
+      code: "SCENE_3D_CAMERA_SIZE_REQUIRED",
+      file,
+      path: `${basePath}.orthographicSize`,
+      message: "Orthographic Camera3D requires orthographicSize.",
+      suggestion: "Add orthographicSize with a positive value."
+    });
+  }
+  return diagnostics;
+}
+function validateCollider3DValue(collider, file, basePath) {
+  return validateFiniteVector3(collider.size, file, `${basePath}.size`, "SCENE_3D_COLLIDER_SIZE_INVALID", {
+    requirePositive: true
+  });
+}
+function validateFiniteVector3(value, file, dataPath, code, options = {}) {
+  if (!isVector3(value)) {
+    return [];
+  }
+  const diagnostics = [];
+  value.forEach((item, index) => {
+    if (!Number.isFinite(item) || Math.abs(item) > 1e6) {
+      diagnostics.push({
+        severity: "error",
+        code,
+        file,
+        path: `${dataPath}[${index}]`,
+        message: `3D vector value '${String(item)}' is outside the supported experimental range.`,
+        suggestion: "Use finite coordinate values with absolute magnitude no greater than 1000000."
+      });
+    }
+    if (options.requirePositive && item <= 0) {
+      diagnostics.push({
+        severity: "error",
+        code,
+        file,
+        path: `${dataPath}[${index}]`,
+        message: `3D vector value '${String(item)}' must be positive.`,
+        suggestion: "Use positive non-zero scale and collider size values."
+      });
+    }
+  });
+  return diagnostics;
+}
+function roundDeterministic(value) {
+  const rounded = Number(value.toFixed(12));
+  const nearestInteger = Math.round(rounded);
+  if (Math.abs(rounded - nearestInteger) < 1e-9) {
+    return nearestInteger;
+  }
+  return rounded;
+}
+function createPatchSummary() {
+  return {
+    changedReferences: []
+  };
+}
+function mergePrefabComponents(components, overrides) {
+  const merged = cloneJson(components);
+  if (!overrides) {
+    return merged;
+  }
+  for (const [componentName, overrideValue] of Object.entries(overrides)) {
+    if (Object.hasOwn(merged, componentName)) {
+      merged[componentName] = deepMergeObjects(merged[componentName], overrideValue);
+    }
+  }
+  return merged;
+}
+function deepMergeObjects(existingValue, patchValue) {
+  if (!isRecord(existingValue) || !isRecord(patchValue)) {
+    return cloneJson(patchValue);
+  }
+  const merged = cloneJson(existingValue);
+  for (const [key, value] of Object.entries(patchValue)) {
+    merged[key] = isRecord(value) && isRecord(merged[key]) ? deepMergeObjects(merged[key], value) : cloneJson(value);
+  }
+  return merged;
+}
+function setJsonPointer(root, pointer, value, file, operationPath) {
+  if (!pointer.startsWith("/")) {
+    return [
+      {
+        severity: "error",
+        code: "PATCH_INVALID_FIELD_PATH",
+        file,
+        path: `${operationPath}.path`,
+        message: `Field path '${pointer}' is not a JSON Pointer.`,
+        suggestion: "Use a JSON Pointer path such as /position/0 or /current."
+      }
+    ];
+  }
+  const tokens = pointer.slice(1).split("/").map((token) => token.replace(/~1/g, "/").replace(/~0/g, "~"));
+  let parent = root;
+  for (const token of tokens.slice(0, -1)) {
+    const next = getPointerChild(parent, token);
+    if (next === void 0) {
+      return [
+        {
+          severity: "error",
+          code: "PATCH_FIELD_PATH_NOT_FOUND",
+          file,
+          path: `${operationPath}.path`,
+          message: `Field path '${pointer}' does not resolve.`,
+          suggestion: "Inspect the component and target an existing nested object or array element."
+        }
+      ];
+    }
+    parent = next;
+  }
+  const finalToken = tokens[tokens.length - 1];
+  if (finalToken === void 0) {
+    return [];
+  }
+  if (Array.isArray(parent)) {
+    if (!/^\d+$/.test(finalToken)) {
+      return [
+        {
+          severity: "error",
+          code: "PATCH_INVALID_ARRAY_INDEX",
+          file,
+          path: `${operationPath}.path`,
+          message: `Array path token '${finalToken}' is not a numeric index.`,
+          suggestion: "Use a numeric array index."
+        }
+      ];
+    }
+    const index = Number(finalToken);
+    if (index < 0 || index >= parent.length) {
+      return [
+        {
+          severity: "error",
+          code: "PATCH_ARRAY_INDEX_OUT_OF_RANGE",
+          file,
+          path: `${operationPath}.path`,
+          message: `Array index '${index}' is out of range.`,
+          suggestion: "Inspect the component and target an existing array index."
+        }
+      ];
+    }
+    parent[index] = cloneJson(value);
+    return [];
+  }
+  if (isRecord(parent)) {
+    parent[finalToken] = cloneJson(value);
+    return [];
+  }
+  return [
+    {
+      severity: "error",
+      code: "PATCH_FIELD_PATH_NOT_FOUND",
+      file,
+      path: `${operationPath}.path`,
+      message: `Field path '${pointer}' does not resolve to an object or array.`,
+      suggestion: "Inspect the component and target an object field or array element."
+    }
+  ];
+}
+function getPointerChild(parent, token) {
+  if (Array.isArray(parent)) {
+    if (!/^\d+$/.test(token)) {
+      return void 0;
+    }
+    return parent[Number(token)];
+  }
+  if (isRecord(parent)) {
+    return parent[token];
+  }
+  return void 0;
+}
+function resolvePatchScenePath(patchFile, sceneRef) {
+  if (typeof sceneRef !== "string") {
+    return void 0;
+  }
+  return path.resolve(path.dirname(patchFile), sceneRef);
+}
+function resolveScenePrefabPath(sceneFile, prefabRef) {
+  return path.resolve(path.dirname(sceneFile), prefabRef);
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function hasErrors(diagnostics) {
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+function resolveProjectFile(projectPath = ".", cwd = process.cwd()) {
+  const resolved = path.resolve(cwd, projectPath);
+  if (existsSync(resolved) && statSync(resolved).isDirectory()) {
+    return path.join(resolved, "agent.project.yml");
+  }
+  return resolved;
+}
+async function loadYamlFile(file) {
+  try {
+    const source = await readFile(file, "utf8");
+    return parseYamlSource(source, file);
+  } catch (error) {
+    return {
+      file,
+      diagnostics: [
+        {
+          severity: "error",
+          code: "FILE_READ_FAILED",
+          file,
+          path: "$",
+          message: error instanceof Error ? error.message : String(error),
+          suggestion: "Check that the path exists and is readable."
+        }
+      ]
+    };
+  }
+}
+function parseYamlSource(source, file) {
+  try {
+    const document = parse(source);
+    if (document === null || document === void 0) {
+      return {
+        file,
+        diagnostics: [
+          {
+            severity: "error",
+            code: "YAML_EMPTY_DOCUMENT",
+            file,
+            path: "$",
+            message: "YAML document is empty.",
+            suggestion: "Add the required document fields before running validation again."
+          }
+        ]
+      };
+    }
+    return {
+      file,
+      document,
+      diagnostics: []
+    };
+  } catch (error) {
+    return {
+      file,
+      diagnostics: [
+        {
+          severity: "error",
+          code: "YAML_PARSE_ERROR",
+          file,
+          path: "$",
+          message: error instanceof Error ? error.message : String(error),
+          suggestion: "Fix the YAML syntax before running validation again."
+        }
+      ]
+    };
+  }
+}
+async function loadNearestProjectAssetManifestContext(sceneFile) {
+  const projectFile = findNearestProjectFile(path.dirname(sceneFile));
+  if (!projectFile) {
+    return createAssetManifestContext();
+  }
+  const projectResult = await loadYamlFile(projectFile);
+  const diagnostics = [...projectResult.diagnostics];
+  if (projectResult.document === void 0) {
+    return {
+      ...createAssetManifestContext(),
+      diagnostics
+    };
+  }
+  diagnostics.push(...validateProjectDocument(projectResult.document, projectFile));
+  if (hasErrors(diagnostics)) {
+    return {
+      ...createAssetManifestContext(),
+      diagnostics
+    };
+  }
+  const context = await loadProjectAssetManifestContext(projectFile, projectResult.document);
+  return {
+    manifestFiles: context.manifestFiles,
+    assets: context.assets,
+    assetsById: context.assetsById,
+    diagnostics: [...diagnostics, ...context.diagnostics]
+  };
+}
+function findNearestProjectFile(startDir) {
+  let currentDir = path.resolve(startDir);
+  while (true) {
+    const candidate = path.join(currentDir, "agent.project.yml");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function createAssetManifestContext() {
+  return {
+    manifestFiles: [],
+    assets: [],
+    assetsById: /* @__PURE__ */ new Map(),
+    diagnostics: []
+  };
+}
+function sortedAssetDefinitions(assetsById) {
+  return [...assetsById.values()].sort((left, right) => left.id.localeCompare(right.id)).map((asset) => {
+    if (asset.type === "sprite") {
+      return {
+        id: asset.id,
+        type: "sprite",
+        path: asset.path,
+        ...typeof asset.texture === "string" ? { texture: asset.texture } : {},
+        ...asset.rect ? { rect: asset.rect } : {},
+        ...typeof asset.atlas === "string" ? { atlas: asset.atlas } : {},
+        ...typeof asset.frame === "string" ? { frame: asset.frame } : {}
+      };
+    }
+    if (asset.type === "atlas") {
+      return {
+        id: asset.id,
+        type: "atlas",
+        path: asset.path,
+        ...typeof asset.texture === "string" ? { texture: asset.texture } : {},
+        frames: (asset.frames ?? []).map((frame) => ({
+          id: frame.id,
+          rect: frame.rect
+        })).sort((left, right) => left.id.localeCompare(right.id))
+      };
+    }
+    return {
+      id: asset.id,
+      type: asset.type,
+      path: asset.path
+    };
+  });
+}
+function countAssetsByType(assets) {
+  const counts = {};
+  for (const asset of assets) {
+    counts[asset.type] = (counts[asset.type] ?? 0) + 1;
+  }
+  return Object.fromEntries(Object.entries(counts).sort(([left], [right]) => left.localeCompare(right)));
+}
+function isPortableAssetPath(assetPath) {
+  if (assetPath.length === 0) {
+    return false;
+  }
+  if (assetPath.includes("\\") || assetPath.includes("://") || assetPath.startsWith("/") || path.isAbsolute(assetPath)) {
+    return false;
+  }
+  return assetPath.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function isPortableSourcePath(sourcePath) {
+  if (sourcePath.length === 0) {
+    return false;
+  }
+  if (sourcePath.includes("\\") || sourcePath.includes("://") || sourcePath.startsWith("/") || path.isAbsolute(sourcePath)) {
+    return false;
+  }
+  return sourcePath.split("/").every((segment) => segment.length > 0 && segment !== ".");
+}
+function hasPrefabRole(prefabRefs, role) {
+  return prefabRefs.some((prefabRef) => isRecord(prefabRef) && prefabRef.role === role);
+}
+function findMapPrefabRefByRole(prefabRefs, role) {
+  return prefabRefs.find((prefabRef) => prefabRef.role === role);
+}
+async function validateMapPrefabRefs(config, file) {
+  const diagnostics = [];
+  for (const [index, prefabRef] of config.prefabRefs.entries()) {
+    const prefabFile = resolveMapPrefabPath(file, prefabRef.prefab);
+    const prefabResult = await loadPrefabFile(prefabFile);
+    const prefabDiagnostics = [...prefabResult.diagnostics];
+    if (prefabResult.document !== void 0) {
+      prefabDiagnostics.push(...validatePrefabDocument(prefabResult.document, prefabResult.file));
+    }
+    if (prefabResult.document === void 0 || hasErrors(prefabDiagnostics)) {
+      if (prefabResult.diagnostics.some((diagnostic) => diagnostic.code === "FILE_READ_FAILED")) {
+        diagnostics.push({
+          severity: "error",
+          code: "MAP_PREFAB_REF_NOT_FOUND",
+          file,
+          path: `$.prefabRefs[${index}].prefab`,
+          message: `Prefab file '${prefabRef.prefab}' was not found.`,
+          suggestion: "Create the prefab file or update the prefab path relative to the map config file."
+        });
+      }
+      diagnostics.push(...prefabDiagnostics);
+      continue;
+    }
+    diagnostics.push(...validateMapPrefabRoleConsistency(prefabRef, prefabResult.document, file, index));
+  }
+  return diagnostics;
+}
+function validateMapPrefabRoleConsistency(prefabRef, prefab, file, index) {
+  const diagnostics = [];
+  const components = prefab.components ?? {};
+  if (!Object.hasOwn(components, "Transform")) {
+    diagnostics.push({
+      severity: "error",
+      code: "MAP_PREFAB_ROLE_MISMATCH",
+      file,
+      path: `$.prefabRefs[${index}].prefab`,
+      message: `Prefab ref '${prefabRef.id}' with role '${prefabRef.role}' must provide Transform.`,
+      suggestion: "Add Transform to the prefab or use a prefab intended for generated map placement."
+    });
+  }
+  if (prefabRef.role === "platform" && !Object.hasOwn(components, "Collider")) {
+    diagnostics.push({
+      severity: "error",
+      code: "MAP_PREFAB_ROLE_MISMATCH",
+      file,
+      path: `$.prefabRefs[${index}].prefab`,
+      message: `Platform prefab ref '${prefabRef.id}' must provide Collider.`,
+      suggestion: "Use a platform prefab with Transform and Collider."
+    });
+  }
+  return diagnostics;
+}
+function resolveMapPrefabPath(configFile, prefabRef) {
+  return path.resolve(path.dirname(configFile), prefabRef);
+}
+function resolveGeneratedScenePrefabRef(prefabRef, options) {
+  if (!options.configFile || !options.sceneFile) {
+    return prefabRef.prefab;
+  }
+  const prefabFile = resolveMapPrefabPath(options.configFile, prefabRef.prefab);
+  const relativePath = path.relative(path.dirname(options.sceneFile), prefabFile).replace(/\\/g, "/");
+  return relativePath.length > 0 ? relativePath : path.basename(prefabFile);
+}
+function hashStableObject(value) {
+  const stable = JSON.stringify(orderObject(value));
+  let hash = 2166136261;
+  for (let index = 0; index < stable.length; index += 1) {
+    hash ^= stable.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `fnv1a-${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function createSeededRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = Math.imul(state, 1664525) + 1013904223 >>> 0;
+    return state / 4294967296;
+  };
+}
+function randomInteger(rng, min, max) {
+  const low = Math.ceil(Math.min(min, max));
+  const high = Math.floor(Math.max(min, max));
+  return low + Math.floor(rng() * (high - low + 1));
+}
+function clampInteger(value, min, max) {
+  return Math.min(Math.max(Math.round(value), min), max);
+}
+function padNumber(value) {
+  return String(value).padStart(3, "0");
+}
+function schemaDiagnostics(validator, value, file, code, basePath = "$") {
+  const valid = validator(value);
+  if (valid) {
+    return [];
+  }
+  return (validator.errors ?? []).map((error) => ({
+    severity: "error",
+    code,
+    file,
+    path: joinDataPath(basePath, errorPath(error)),
+    message: schemaMessage(error),
+    suggestion: schemaSuggestion(error)
+  }));
+}
+function errorPath(error) {
+  const base = instancePathToDataPath(error.instancePath);
+  if (error.keyword === "required" && isRecord(error.params) && typeof error.params.missingProperty === "string") {
+    return `${base}.${error.params.missingProperty}`;
+  }
+  return base;
+}
+function instancePathToDataPath(instancePath) {
+  if (!instancePath) {
+    return "$";
+  }
+  return `$${instancePath.split("/").slice(1).map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~")).map((segment) => /^\d+$/.test(segment) ? `[${segment}]` : `.${segment}`).join("")}`;
+}
+function joinDataPath(basePath, childPath) {
+  if (basePath === "$") {
+    return childPath;
+  }
+  if (childPath === "$") {
+    return basePath;
+  }
+  return `${basePath}${childPath.slice(1)}`;
+}
+function schemaMessage(error) {
+  if (error.keyword === "required" && isRecord(error.params) && typeof error.params.missingProperty === "string") {
+    return `Missing required property '${error.params.missingProperty}'.`;
+  }
+  if (error.keyword === "additionalProperties" && isRecord(error.params)) {
+    return `Unknown property '${String(error.params.additionalProperty)}'.`;
+  }
+  return error.message ?? "Value does not match schema.";
+}
+function schemaSuggestion(error) {
+  if (error.keyword === "required" && isRecord(error.params) && typeof error.params.missingProperty === "string") {
+    return `Add '${error.params.missingProperty}'.`;
+  }
+  if (error.keyword === "type") {
+    return "Use the expected value type for this field.";
+  }
+  if (error.keyword === "additionalProperties") {
+    return "Remove the unknown property or add it to the engine schema.";
+  }
+  return void 0;
+}
+function toYaml(value) {
+  return `${stringify(value, { lineWidth: 0 }).trimEnd()}
+`;
+}
+function orderComponents(components) {
+  const ordered = {};
+  const componentNames = [
+    ...componentOrder.filter((name) => Object.hasOwn(components, name)),
+    ...Object.keys(components).filter((name) => !componentOrder.includes(name)).sort()
+  ];
+  for (const componentName of componentNames) {
+    ordered[componentName] = orderObject(components[componentName], componentFieldOrder[componentName]);
+  }
+  return ordered;
+}
+function orderObject(value, preferredKeys = []) {
+  if (Array.isArray(value)) {
+    return value.map((item) => orderObject(item));
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const result = {};
+  const keys = [
+    ...preferredKeys.filter((key) => Object.hasOwn(value, key)),
+    ...Object.keys(value).filter((key) => !preferredKeys.includes(key)).sort()
+  ];
+  for (const key of keys) {
+    result[key] = orderObject(value[key]);
+  }
+  return result;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  applyPatchDocument,
+  applyPatchDocumentWithFileValidation,
+  applyPatchFile,
+  assetManifestSchema2 as assetManifestSchema,
+  componentSchemas2 as componentSchemas,
+  computeWorldTransforms,
+  createMapGenerationSummary,
+  deriveHierarchy,
+  expandSceneDocument,
+  formatGeneratedMap,
+  formatMapGenerationConfig,
+  formatPrefab,
+  formatProject,
+  formatProjectFiles,
+  formatScene,
+  generateMapDocument,
+  generateMapFromConfigFile,
+  generateMapSceneFile,
+  generatedMapSchema2 as generatedMapSchema,
+  generatedMapToScene,
+  hasErrors,
+  inspectAssetManifestDocument,
+  inspectAssetManifestFile,
+  inspectEntityFile,
+  inspectPrefabDocument,
+  inspectPrefabFile,
+  inspectProjectFile,
+  inspectSceneAnimations,
+  inspectSceneDocument,
+  inspectSceneFile,
+  loadAssetManifestFile,
+  loadExpandedSceneFile,
+  loadGeneratedMapFile,
+  loadMapGenerationConfigFile,
+  loadPatchFile,
+  loadPrefabFile,
+  loadProjectAssetManifestContext,
+  loadProjectAssetManifests,
+  loadProjectFile,
+  loadSceneFile,
+  mapGenerationConfigSchema2 as mapGenerationConfigSchema,
+  parseAssetManifestSource,
+  parseGeneratedMapSource,
+  parseMapGenerationConfigSource,
+  parsePatchSource,
+  parsePrefabSource,
+  parseProjectSource,
+  parseSceneSource,
+  patchSchema2 as patchSchema,
+  prefabSchema2 as prefabSchema,
+  projectSchema2 as projectSchema,
+  resolveProjectFile,
+  sceneSchema2 as sceneSchema,
+  validateAssetManifestDocument,
+  validateAssetManifestFile,
+  validateGeneratedMapDocument,
+  validateGeneratedMapFile,
+  validateMapGenerationConfigDocument,
+  validateMapGenerationConfigFile,
+  validatePatchDocument,
+  validatePrefabDocument,
+  validatePrefabFile,
+  validateProjectDocument,
+  validateProjectFile,
+  validateSceneDocument,
+  validateSceneFile
+};
+//# sourceMappingURL=index.js.map