@neocompose/cli 0.3.0 → 0.4.0

package/dist/neo.mjs

@@ -1386,11 +1386,11 @@ var init_source_protocol = __esm({
   "src/schema/generated/source-protocol.ts"() {
     "use strict";
     SCHEMA_MANIFEST_FORMAT_VERSION = 3;
-    SCHEMA_MANIFEST_CONTRACT_VERSION = "3.0";
+    SCHEMA_MANIFEST_CONTRACT_VERSION = "3.1";
     SCHEMA_SOURCE_MANIFEST_NAME = "neo-schema-manifest-v3";
-    SCHEMA_COMPILER_PROTOCOL_VERSION = 4;
-    SCHEMA_SDK_VERSION = "3.0.0";
-    SCHEMA_CLI_VERSION = "0.3.0";
+    SCHEMA_COMPILER_PROTOCOL_VERSION = 5;
+    SCHEMA_SDK_VERSION = "3.1.0";
+    SCHEMA_CLI_VERSION = "0.4.0";
     SCHEMA_API_TARGET = "netstandard2.1";
     SCHEMA_REFERENCE_ASSEMBLY_SET = "NETStandard.Library.Ref/2.1.0";
     SCHEMA_REQUIRED_TOOLING_FILES = [
@@ -1455,7 +1455,7 @@ var init_source_protocol = __esm({
         "CompilerResponse": {
           "fields": {
             "protocolVersion": {
-              "literal": 4
+              "literal": 5
             },
             "id": {
               "type": "string",
@@ -1560,7 +1560,8 @@ var init_source_protocol = __esm({
                 "audioTemplate",
                 "localization",
                 "localizationStatus",
-                "registry"
+                "registry",
+                "relationConfiguration"
               ]
             },
             "id": {
@@ -9981,7 +9982,7 @@ var init_schema_contract_generated = __esm({
   "../packages/neoscript-language/src/schema-contract.generated.ts"() {
     "use strict";
     SCHEMA_MANIFEST_FORMAT_VERSION2 = 3;
-    SCHEMA_MANIFEST_CONTRACT_VERSION2 = "3.0";
+    SCHEMA_MANIFEST_CONTRACT_VERSION2 = "3.1";
   }
 });
 
@@ -12106,7 +12107,8 @@ function assertSchemaManifestV3(value) {
     "textureTemplates",
     "audioTemplates",
     "localization",
-    "localizationStatuses"
+    "localizationStatuses",
+    "internalRecordRelations"
   ]);
   exactValue(
     manifest.formatVersion,
@@ -12135,6 +12137,11 @@ function assertSchemaManifestV3(value) {
     "$.localizationStatuses",
     assertLocalizationStatus
   );
+  arrayOf(
+    manifest.internalRecordRelations,
+    "$.internalRecordRelations",
+    assertInternalRecordRelation
+  );
   uniqueIds(manifest.classes, "$.classes");
   uniqueIds(manifest.members, "$.members");
   uniqueIds(manifest.interfaces, "$.interfaces");
@@ -12142,8 +12149,283 @@ function assertSchemaManifestV3(value) {
   uniqueIds(manifest.textureTemplates, "$.textureTemplates");
   uniqueIds(manifest.audioTemplates, "$.audioTemplates");
   uniqueIds(manifest.localizationStatuses, "$.localizationStatuses");
+  uniqueIds(manifest.internalRecordRelations, "$.internalRecordRelations");
+  assertInternalRecordRelationInvariants(manifest);
   assertStaticMemberInvariants(manifest);
 }
+function assertInternalRecordRelation(value, path) {
+  const relation = objectAt(value, path, [
+    "id",
+    "source",
+    "relationKind",
+    "sourceRecordKind",
+    "sourceRecordId",
+    "targetRecordKind",
+    "targetRecordId",
+    "order"
+  ]);
+  nonEmptyString(relation.id, `${path}.id`);
+  assertSourceIdentity(relation.source, `${path}.source`);
+  nonEmptyString(relation.relationKind, `${path}.relationKind`);
+  projectRecordKind(relation.sourceRecordKind, `${path}.sourceRecordKind`);
+  nonEmptyString(relation.sourceRecordId, `${path}.sourceRecordId`);
+  projectRecordKind(relation.targetRecordKind, `${path}.targetRecordKind`);
+  nonEmptyString(relation.targetRecordId, `${path}.targetRecordId`);
+  if (relation.order !== null && (typeof relation.order !== "number" || !Number.isInteger(relation.order) || relation.order < 0)) {
+    invalid(`${path}.order`, "expected null or a non-negative integer.");
+  }
+}
+function assertInternalRecordRelationInvariants(manifest) {
+  const relations = requireArray(
+    manifest.internalRecordRelations,
+    "$.internalRecordRelations"
+  ).map(
+    (value, index) => requireRecord(value, `$.internalRecordRelations[${index}]`)
+  );
+  const seenEdges = /* @__PURE__ */ new Map();
+  const orderedGroups = /* @__PURE__ */ new Map();
+  const classes = requireArray(manifest.classes, "$.classes").map(
+    (value, index) => requireRecord(value, `$.classes[${index}]`)
+  );
+  const classesById = new Map(
+    classes.map((schemaClass2) => [String(schemaClass2.id), schemaClass2])
+  );
+  const endpoints = manifestEndpointKeys(manifest, relations);
+  const singletonSources = /* @__PURE__ */ new Map();
+  const graph = /* @__PURE__ */ new Map();
+  for (const [index, relation] of relations.entries()) {
+    const path = `$.internalRecordRelations[${index}]`;
+    const edgeKey = [
+      relation.relationKind,
+      relation.sourceRecordKind,
+      relation.sourceRecordId,
+      relation.targetRecordKind,
+      relation.targetRecordId
+    ].join("\0");
+    const duplicate = seenEdges.get(edgeKey);
+    if (duplicate !== void 0) {
+      invalid(
+        path,
+        `duplicates the qualified edge declared at $.internalRecordRelations[${duplicate}].`
+      );
+    }
+    seenEdges.set(edgeKey, index);
+    const sourceKey = `${String(relation.sourceRecordKind)}:${String(relation.sourceRecordId)}`;
+    const targetKey = `${String(relation.targetRecordKind)}:${String(relation.targetRecordId)}`;
+    if (manifestContainsEndpointKind(String(relation.sourceRecordKind)) && !endpoints.has(sourceKey)) {
+      invalid(
+        `${path}.sourceRecordId`,
+        `references missing ${String(relation.sourceRecordKind)} record ${JSON.stringify(relation.sourceRecordId)}.`
+      );
+    }
+    if (manifestContainsEndpointKind(String(relation.targetRecordKind)) && !endpoints.has(targetKey)) {
+      invalid(
+        `${path}.targetRecordId`,
+        `references missing ${String(relation.targetRecordKind)} record ${JSON.stringify(relation.targetRecordId)}.`
+      );
+    }
+    if (sourceKey === targetKey) {
+      invalid(
+        path,
+        "self-edges are not allowed by the schema authoring contract."
+      );
+    }
+    const targets = graph.get(sourceKey) ?? [];
+    targets.push(targetKey);
+    graph.set(sourceKey, targets);
+    const contract = WORLD_RELATION_CONTRACTS[String(relation.relationKind)];
+    if (contract === void 0) {
+      invalid(
+        `${path}.relationKind`,
+        `uses unknown relation kind ${JSON.stringify(relation.relationKind)}.`
+      );
+    } else {
+      if (relation.sourceRecordKind !== contract.sourceRecordKind || relation.targetRecordKind !== contract.targetRecordKind) {
+        invalid(
+          path,
+          `${String(relation.relationKind)} requires ${contract.sourceRecordKind}-to-${contract.targetRecordKind} endpoints.`
+        );
+      }
+      const sourceClass = contract.sourceRecordKind === "class" ? classesById.get(String(relation.sourceRecordId)) : void 0;
+      const targetClass = contract.targetRecordKind === "class" ? classesById.get(String(relation.targetRecordId)) : void 0;
+      if (sourceClass !== void 0) {
+        const actual = effectiveWorldKind(sourceClass, classesById);
+        if (actual !== contract.sourceWorldKind) {
+          invalid(
+            `${path}.sourceRecordId`,
+            `${String(relation.relationKind)} requires a ${contract.sourceWorldKind} source Class; received ${actual ?? "no world kind"}.`
+          );
+        }
+      }
+      if (targetClass !== void 0) {
+        const actual = effectiveWorldKind(targetClass, classesById);
+        if (actual !== contract.targetWorldKind) {
+          invalid(
+            `${path}.targetRecordId`,
+            `${String(relation.relationKind)} requires a ${contract.targetWorldKind} target Class; received ${actual ?? "no world kind"}.`
+          );
+        }
+        if (!contract.abstractTarget && targetClass.declarationModifier === "abstract") {
+          invalid(
+            `${path}.targetRecordId`,
+            `${String(relation.relationKind)} requires a concrete target Class.`
+          );
+        }
+      }
+      if (contract.ordered !== (relation.order !== null)) {
+        invalid(
+          `${path}.order`,
+          contract.ordered ? `${String(relation.relationKind)} requires an ordered position.` : `${String(relation.relationKind)} is unordered and must use null.`
+        );
+      }
+      if (contract.singleton) {
+        const singletonKey = `${String(relation.relationKind)}\0${sourceKey}`;
+        const duplicateSingleton = singletonSources.get(singletonKey);
+        if (duplicateSingleton !== void 0) {
+          invalid(
+            path,
+            `declares a second direct singleton already present at $.internalRecordRelations[${duplicateSingleton}].`
+          );
+        }
+        singletonSources.set(singletonKey, index);
+      }
+    }
+    if (relation.order === null) continue;
+    const groupKey = [
+      relation.relationKind,
+      relation.sourceRecordKind,
+      relation.sourceRecordId
+    ].join("\0");
+    const group = orderedGroups.get(groupKey) ?? [];
+    group.push({ order: Number(relation.order), index });
+    orderedGroups.set(groupKey, group);
+  }
+  for (const group of orderedGroups.values()) {
+    group.sort((left, right) => left.order - right.order);
+    for (const [expected, entry] of group.entries()) {
+      if (entry.order === expected) continue;
+      invalid(
+        `$.internalRecordRelations[${entry.index}].order`,
+        `ordered direct relation positions must be contiguous from zero; expected ${expected}.`
+      );
+    }
+  }
+  assertAcyclicRelationGraph(graph);
+  assertDefaultLayerCompatibility(relations, classesById);
+}
+function effectiveWorldKind(schemaClass2, classesById) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = schemaClass2;
+  while (current !== void 0) {
+    const id = String(current.id);
+    if (visited.has(id)) return null;
+    visited.add(id);
+    const system = current.system;
+    if (system !== null && typeof system === "object" && !Array.isArray(system)) {
+      const worldKind2 = system.worldKind;
+      if (typeof worldKind2 === "string") return worldKind2;
+    }
+    current = typeof current.extendsClassId === "string" ? classesById.get(current.extendsClassId) : void 0;
+  }
+  return null;
+}
+function manifestEndpointKeys(manifest, relations) {
+  const result = /* @__PURE__ */ new Set();
+  const collections = [
+    ["classes", "class"],
+    ["members", "member"],
+    ["interfaces", "interface"],
+    ["enums", "enum"],
+    ["textureTemplates", "unity-texture-template"],
+    ["audioTemplates", "unity-audio-clip-template"],
+    ["localizationStatuses", "localization-status"]
+  ];
+  for (const [collection, kind] of collections) {
+    for (const entry of requireArray(manifest[collection], `$.${collection}`)) {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+        continue;
+      const id = entry.id;
+      if (typeof id === "string") result.add(`${kind}:${id}`);
+    }
+  }
+  const localization = requireRecord(manifest.localization, "$.localization");
+  if (typeof localization.id === "string") {
+    result.add(`localization-config:${localization.id}`);
+  }
+  for (const relation of relations) {
+    result.add(`internal-record-relation:${String(relation.id)}`);
+  }
+  return result;
+}
+function manifestContainsEndpointKind(recordKind) {
+  return MANIFEST_ENDPOINT_KINDS.has(recordKind);
+}
+function assertAcyclicRelationGraph(graph) {
+  const complete2 = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (complete2.has(node)) return;
+    if (visiting.has(node)) {
+      invalid(
+        "$.internalRecordRelations",
+        `declared relations contain a cycle through ${JSON.stringify(node)}.`
+      );
+    }
+    visiting.add(node);
+    for (const target of graph.get(node) ?? []) visit(target);
+    visiting.delete(node);
+    complete2.add(node);
+  };
+  for (const node of graph.keys()) visit(node);
+}
+function assertDefaultLayerCompatibility(relations, classesById) {
+  const pairs = [
+    ["world.tile.default-layer", "world.tile.compatible-layer"],
+    ["world.object.default-layer", "world.object.compatible-layer"]
+  ];
+  for (const [defaultKind, compatibleKind] of pairs) {
+    for (const relation of relations.filter(
+      (candidate) => candidate.relationKind === defaultKind
+    )) {
+      const sourceAncestors = classAncestorIds(
+        String(relation.sourceRecordId),
+        classesById
+      );
+      const targetAncestors = classAncestorIds(
+        String(relation.targetRecordId),
+        classesById
+      );
+      const covered = relations.some(
+        (candidate) => candidate.relationKind === compatibleKind && sourceAncestors.includes(String(candidate.sourceRecordId)) && targetAncestors.includes(String(candidate.targetRecordId))
+      );
+      if (!covered) {
+        invalid(
+          "$.internalRecordRelations",
+          `${defaultKind} relation ${JSON.stringify(relation.id)} must also be covered by ${compatibleKind}.`
+        );
+      }
+    }
+  }
+}
+function classAncestorIds(classId, classesById) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = classesById.get(classId);
+  while (current !== void 0) {
+    const id = String(current.id);
+    if (visited.has(id)) break;
+    visited.add(id);
+    result.push(id);
+    current = typeof current.extendsClassId === "string" ? classesById.get(current.extendsClassId) : void 0;
+  }
+  return result;
+}
+function projectRecordKind(value, path) {
+  if (typeof value === "string" && PROJECT_RECORD_KINDS.has(value)) {
+    return;
+  }
+  invalid(path, "expected a registered project record kind.");
+}
 function assertStaticMemberInvariants(manifest) {
   const members = requireArray(manifest.members, "$.members").map(
     (value, index) => requireRecord(value, `$.members[${index}]`)
@@ -13551,7 +13833,7 @@ function exactValue(value, expected, path) {
 function invalid(path, message) {
   throw new SchemaManifestValidationError(path, message);
 }
-var SchemaManifestValidationError, SOURCE_KINDS, SYSTEM_OPERATIONS, WORLD_KINDS, MEMBER_COMMON_KEYS, MEMBER_KEYS_BY_KIND, PRIMITIVE_TYPE_KINDS, TEXTURE_TYPES, ALPHA_SOURCES, NPOT_SCALES, WRAP_MODES, RESIZE_ALGORITHMS, TEXTURE_COMPRESSIONS, PLATFORM_FORMATS, SPRITE_ALIGNMENTS;
+var SchemaManifestValidationError, WORLD_RELATION_CONTRACTS, MANIFEST_ENDPOINT_KINDS, PROJECT_RECORD_KINDS, SOURCE_KINDS, SYSTEM_OPERATIONS, WORLD_KINDS, MEMBER_COMMON_KEYS, MEMBER_KEYS_BY_KIND, PRIMITIVE_TYPE_KINDS, TEXTURE_TYPES, ALPHA_SOURCES, NPOT_SCALES, WRAP_MODES, RESIZE_ALGORITHMS, TEXTURE_COMPRESSIONS, PLATFORM_FORMATS, SPRITE_ALIGNMENTS;
 var init_validate = __esm({
   "src/schema/manifest/validate.ts"() {
     "use strict";
@@ -13566,6 +13848,138 @@ var init_validate = __esm({
       path;
       code;
     };
+    WORLD_RELATION_CONTRACTS = {
+      "world.grid.tile-import": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "tileGrid",
+        targetWorldKind: "tile",
+        abstractTarget: true,
+        ordered: false,
+        singleton: false
+      },
+      "world.grid.object-import": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "tileGrid",
+        targetWorldKind: "object",
+        abstractTarget: true,
+        ordered: false,
+        singleton: false
+      },
+      "world.grid.tile-layer": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "tileGrid",
+        targetWorldKind: "tileLayer",
+        abstractTarget: false,
+        ordered: true,
+        singleton: false
+      },
+      "world.grid.object-layer": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "tileGrid",
+        targetWorldKind: "objectLayer",
+        abstractTarget: false,
+        ordered: true,
+        singleton: false
+      },
+      "world.tile.compatible-layer": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "tile",
+        targetWorldKind: "tileLayer",
+        abstractTarget: true,
+        ordered: false,
+        singleton: false
+      },
+      "world.tile.default-layer": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "tile",
+        targetWorldKind: "tileLayer",
+        abstractTarget: false,
+        ordered: false,
+        singleton: true
+      },
+      "world.object.compatible-layer": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "object",
+        targetWorldKind: "objectLayer",
+        abstractTarget: true,
+        ordered: false,
+        singleton: false
+      },
+      "world.object.default-layer": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "object",
+        targetWorldKind: "objectLayer",
+        abstractTarget: false,
+        ordered: false,
+        singleton: true
+      },
+      "world.tile-layer-link.target": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "tileLayerLink",
+        targetWorldKind: "tileLayer",
+        abstractTarget: false,
+        ordered: false,
+        singleton: true
+      },
+      "world.object-layer-link.target": {
+        sourceRecordKind: "class",
+        targetRecordKind: "class",
+        sourceWorldKind: "objectLayerLink",
+        targetWorldKind: "objectLayer",
+        abstractTarget: false,
+        ordered: false,
+        singleton: true
+      },
+      "world.smart-tile-neighbor.tile": {
+        sourceRecordKind: "value",
+        targetRecordKind: "class",
+        sourceWorldKind: "smartTileNeighbor",
+        targetWorldKind: "tile",
+        abstractTarget: true,
+        ordered: false,
+        singleton: true
+      }
+    };
+    MANIFEST_ENDPOINT_KINDS = /* @__PURE__ */ new Set([
+      "class",
+      "member",
+      "interface",
+      "enum",
+      "unity-texture-template",
+      "unity-audio-clip-template",
+      "localization-config",
+      "localization-status",
+      "internal-record-relation"
+    ]);
+    PROJECT_RECORD_KINDS = /* @__PURE__ */ new Set([
+      "project",
+      "member",
+      "value",
+      "class",
+      "internal-record-relation",
+      "enum",
+      "interface",
+      "dialogue",
+      "dialogue-node",
+      "dialogue-group",
+      "priority-group",
+      "project-file",
+      "unity-texture-template",
+      "unity-audio-clip-template",
+      "localization-config",
+      "localization-status",
+      "localized-text",
+      "migration"
+    ]);
     SOURCE_KINDS = /* @__PURE__ */ new Set([
       "class",
       "member",
@@ -13576,7 +13990,8 @@ var init_validate = __esm({
       "textureTemplate",
       "audioTemplate",
       "localization",
-      "localizationStatus"
+      "localizationStatus",
+      "internalRecordRelation"
     ]);
     SYSTEM_OPERATIONS = /* @__PURE__ */ new Set([
       "editRecord",
@@ -13585,7 +14000,6 @@ var init_validate = __esm({
       "replaceValue"
     ]);
     WORLD_KINDS = /* @__PURE__ */ new Set([
-      "worldAssets",
       "tileGrid",
       "tileLayer",
       "objectLayer",
@@ -14055,7 +14469,6 @@ function systemOperation(value, location2, frontend) {
 function worldKind(value, location2, frontend) {
   const result = lowerFirst(value);
   const allowed = /* @__PURE__ */ new Set([
-    "worldAssets",
     "tileGrid",
     "tileLayer",
     "objectLayer",
@@ -14085,7 +14498,7 @@ function worldKind(value, location2, frontend) {
 function lowerFirst(value) {
   return value.length === 0 ? value : `${value[0].toLowerCase()}${value.slice(1)}`;
 }
-var SchemaFrontendError, SchemaFrontend, map, TEXTURE_TYPES2, ALPHA_SOURCES2, NPOT_SCALES2, MIP_FILTERS, WRAP_MODES2, FILTER_MODES, RESIZE_ALGORITHMS2, COMPRESSIONS, TEXTURE_FORMATS, SPRITE_MODES, MESH_TYPES, ALIGNMENTS, NORMAL_FILTERS, COOKIE_LIGHT_TYPES, SINGLE_CHANNELS, SWIZZLES, AUDIO_LOAD_TYPES, AUDIO_COMPRESSIONS, AUDIO_SAMPLE_RATES;
+var SchemaFrontendError, SPECIALIZED_RELATION_SETTINGS, PROJECT_RECORD_KIND_BY_ENUM, SchemaFrontend, map, TEXTURE_TYPES2, ALPHA_SOURCES2, NPOT_SCALES2, MIP_FILTERS, WRAP_MODES2, FILTER_MODES, RESIZE_ALGORITHMS2, COMPRESSIONS, TEXTURE_FORMATS, SPRITE_MODES, MESH_TYPES, ALIGNMENTS, NORMAL_FILTERS, COOKIE_LIGHT_TYPES, SINGLE_CHANNELS, SWIZZLES, AUDIO_LOAD_TYPES, AUDIO_COMPRESSIONS, AUDIO_SAMPLE_RATES;
 var init_frontend = __esm({
   "src/schema/frontend.ts"() {
     "use strict";
@@ -14101,6 +14514,98 @@ var init_frontend = __esm({
       }
       diagnostics;
     };
+    SPECIALIZED_RELATION_SETTINGS = {
+      "NeoCompose.Schema.NeoGridRelationSettings": [
+        {
+          property: "TileImports",
+          relationKind: "world.grid.tile-import",
+          collection: true,
+          ordered: false
+        },
+        {
+          property: "ObjectImports",
+          relationKind: "world.grid.object-import",
+          collection: true,
+          ordered: false
+        },
+        {
+          property: "TileLayers",
+          relationKind: "world.grid.tile-layer",
+          collection: true,
+          ordered: true
+        },
+        {
+          property: "ObjectLayers",
+          relationKind: "world.grid.object-layer",
+          collection: true,
+          ordered: true
+        }
+      ],
+      "NeoCompose.Schema.NeoTileRelationSettings": [
+        {
+          property: "CompatibleLayers",
+          relationKind: "world.tile.compatible-layer",
+          collection: true,
+          ordered: false
+        },
+        {
+          property: "DefaultLayer",
+          relationKind: "world.tile.default-layer",
+          collection: false,
+          ordered: false
+        }
+      ],
+      "NeoCompose.Schema.NeoObjectRelationSettings": [
+        {
+          property: "CompatibleLayers",
+          relationKind: "world.object.compatible-layer",
+          collection: true,
+          ordered: false
+        },
+        {
+          property: "DefaultLayer",
+          relationKind: "world.object.default-layer",
+          collection: false,
+          ordered: false
+        }
+      ],
+      "NeoCompose.Schema.NeoTileLayerLinkRelationSettings": [
+        {
+          property: "TargetLayer",
+          relationKind: "world.tile-layer-link.target",
+          collection: false,
+          ordered: false
+        }
+      ],
+      "NeoCompose.Schema.NeoObjectLayerLinkRelationSettings": [
+        {
+          property: "TargetLayer",
+          relationKind: "world.object-layer-link.target",
+          collection: false,
+          ordered: false
+        }
+      ]
+    };
+    PROJECT_RECORD_KIND_BY_ENUM = {
+      Project: "project",
+      Member: "member",
+      Value: "value",
+      Class: "class",
+      InternalRecordRelation: "internal-record-relation",
+      Enum: "enum",
+      Interface: "interface",
+      Dialogue: "dialogue",
+      DialogueNode: "dialogue-node",
+      DialogueGroup: "dialogue-group",
+      PriorityGroup: "priority-group",
+      ProjectFile: "project-file",
+      UnityTextureTemplate: "unity-texture-template",
+      UnityAudioClipTemplate: "unity-audio-clip-template",
+      LocalizationConfig: "localization-config",
+      LocalizationStatus: "localization-status",
+      LocalizedText: "localized-text",
+      Migration: "migration"
+    };
     SchemaFrontend = class {
       constructor(source, options) {
         this.source = source;
@@ -14167,6 +14672,7 @@ var init_frontend = __esm({
         }
         const localization = this.parseLocalization(localizationDeclarations[0]);
         const localizationStatuses = this.declarations.filter((entry) => entry.declaration.kind === "localizationStatus").map((entry) => this.parseLocalizationStatus(entry));
+        const internalRecordRelations = this.parseInternalRecordRelations();
         const manifest = {
           formatVersion: SCHEMA_MANIFEST_FORMAT_VERSION,
           contractVersion: SCHEMA_MANIFEST_CONTRACT_VERSION,
@@ -14178,7 +14684,8 @@ var init_frontend = __esm({
           textureTemplates,
           audioTemplates,
           localization,
-          localizationStatuses
+          localizationStatuses,
+          internalRecordRelations
         };
         try {
           assertSchemaManifestV3(manifest);
@@ -14520,6 +15027,280 @@ var init_frontend = __esm({
           extendsGenericBindings
         };
       }
+      parseInternalRecordRelations() {
+        const result = [];
+        for (const info of this.declarations.filter(
+          (entry) => entry.declaration.kind === "class"
+        )) {
+          const fields = info.declaration.members.filter(
+            (member) => member.kind === "settings" && member.name === "NeoRelations"
+          );
+          if (fields.length === 0) continue;
+          if (fields.length !== 1) {
+            this.fail(
+              "NEO3120",
+              `Class ${info.declaration.name} must declare at most one NeoRelations settings field.`,
+              fields[1]?.location ?? info.declaration.location
+            );
+          }
+          const field = fields[0];
+          if (!field.modifiers.includes("static")) {
+            this.fail(
+              "NEO3121",
+              `${info.declaration.name}.NeoRelations must be static.`,
+              field.location
+            );
+          }
+          if (field.initializer === void 0) {
+            this.fail(
+              "NEO3122",
+              `${info.declaration.name}.NeoRelations requires an initializer.`,
+              field.location
+            );
+          }
+          const type = parseTypeShape(field.type ?? "").name;
+          const settings = this.objectValue(
+            field.initializer,
+            `${info.declaration.name}.NeoRelations`,
+            field.location
+          );
+          const groups = SPECIALIZED_RELATION_SETTINGS[type];
+          if (groups === void 0) {
+            this.fail(
+              "NEO3123",
+              `${info.declaration.name}.NeoRelations has unsupported type ${JSON.stringify(field.type)}.`,
+              field.location
+            );
+          }
+          for (const group of groups) {
+            const raw = settings.properties?.[group.property];
+            if (group.collection) {
+              const entries = raw === void 0 ? [] : this.arrayValue(
+                raw,
+                `${type}.${group.property}`,
+                field.location
+              );
+              for (const [index, entry] of entries.entries()) {
+                result.push(
+                  this.parseSpecializedClassRelation(
+                    info,
+                    field,
+                    entry,
+                    group.relationKind,
+                    group.ordered ? index : null,
+                    `${group.property}-${index}`
+                  )
+                );
+              }
+              continue;
+            }
+            if (raw !== void 0 && raw.kind !== "null") {
+              result.push(
+                this.parseSpecializedClassRelation(
+                  info,
+                  field,
+                  raw,
+                  group.relationKind,
+                  null,
+                  group.property
+                )
+              );
+            }
+          }
+        }
+        const configurations = this.declarations.filter(
+          (entry) => entry.declaration.kind === "relationConfiguration"
+        );
+        if (configurations.length > 1) {
+          this.fail(
+            "NEO3124",
+            `At most one [NeoRelationConfiguration] declaration is allowed; found ${configurations.length}.`,
+            configurations[1].declaration.location
+          );
+        }
+        const configuration = configurations[0];
+        if (configuration !== void 0) {
+          if (!configuration.declaration.modifiers.includes("static")) {
+            this.fail(
+              "NEO3131",
+              `[NeoRelationConfiguration] ${configuration.declaration.name} must be a static class.`,
+              configuration.declaration.location
+            );
+          }
+          const fields = configuration.declaration.members.filter(
+            (member) => member.kind === "settings" && member.name === "NeoRelations"
+          );
+          if (fields.length !== 1 || fields[0]?.initializer === void 0) {
+            this.fail(
+              "NEO3125",
+              `[NeoRelationConfiguration] ${configuration.declaration.name} must declare exactly one initialized static NeoRelations field.`,
+              fields[0]?.location ?? configuration.declaration.location
+            );
+          }
+          if (!fields[0].modifiers.includes("static")) {
+            this.fail(
+              "NEO3132",
+              `[NeoRelationConfiguration] ${configuration.declaration.name}.NeoRelations must be static.`,
+              fields[0].location
+            );
+          }
+          const fieldType = parseTypeShape(fields[0].type ?? "");
+          if (!fieldType.array || fieldType.arguments[0]?.name !== "NeoCompose.Schema.NeoInternalRecordRelationDefinition") {
+            this.fail(
+              "NEO3133",
+              `[NeoRelationConfiguration] ${configuration.declaration.name}.NeoRelations must be NeoInternalRecordRelationDefinition[].`,
+              fields[0].location
+            );
+          }
+          for (const [index, entry] of this.arrayValue(
+            fields[0].initializer,
+            "ProjectRelations.NeoRelations",
+            fields[0].location
+          ).entries()) {
+            result.push(
+              this.parseGenericInternalRecordRelation(
+                entry,
+                fields[0],
+                `generic-${index}`
+              )
+            );
+          }
+        }
+        const ids = /* @__PURE__ */ new Map();
+        for (const relation of result) {
+          const duplicate = ids.get(relation.id);
+          if (duplicate !== void 0) {
+            this.fail(
+              "NEO3126",
+              `Duplicate internal relation id ${JSON.stringify(relation.id)}.`,
+              void 0
+            );
+          }
+          ids.set(relation.id, relation);
+        }
+        return result;
+      }
+      parseSpecializedClassRelation(source, field, value, relationKind, order, pendingSuffix) {
+        const definition2 = this.objectValue(
+          value,
+          "NeoClassRelationDefinition",
+          field.location
+        );
+        const positional = definition2.items ?? [];
+        const idValue = definition2.properties?.Id ?? (positional.length === 2 ? positional[0] : void 0);
+        const targetValue = definition2.properties?.Target ?? (positional.length === 2 ? positional[1] : positional[0]);
+        const targetName = this.typeOfArgument(
+          targetValue,
+          "NeoClassRelationDefinition.Target",
+          field.location
+        );
+        if (targetName === void 0) {
+          this.fail(
+            "NEO3127",
+            `Relation ${relationKind} requires a typeof(...) target.`,
+            field.location
+          );
+        }
+        const target = this.resolveDeclaration(this.classesByName, targetName);
+        if (target === void 0) {
+          this.fail(
+            "NEO3128",
+            `Relation ${relationKind} targets unknown Neo Class ${JSON.stringify(targetName)}.`,
+            field.location
+          );
+        }
+        const id = this.stringArgument(
+          idValue,
+          "NeoClassRelationDefinition.Id",
+          field.location
+        ) ?? pendingId("internal-record-relation", field.location, pendingSuffix);
+        return {
+          id,
+          source: sourceIdentity(
+            "internalRecordRelation",
+            id,
+            field.location,
+            field.selectionLocation
+          ),
+          relationKind,
+          sourceRecordKind: "class",
+          sourceRecordId: source.id,
+          targetRecordKind: "class",
+          targetRecordId: target.id,
+          order
+        };
+      }
+      parseGenericInternalRecordRelation(value, field, pendingSuffix) {
+        const definition2 = this.objectValue(
+          value,
+          "NeoInternalRecordRelationDefinition",
+          field.location
+        );
+        const positional = definition2.items ?? [];
+        if (positional.length !== 4) {
+          this.fail(
+            "NEO3129",
+            "NeoInternalRecordRelationDefinition requires id, relation kind, source, and target constructor arguments.",
+            field.location
+          );
+        }
+        const id = this.stringArgument(positional[0], "relation id", field.location) ?? pendingId("internal-record-relation", field.location, pendingSuffix);
+        return {
+          id,
+          source: sourceIdentity(
+            "internalRecordRelation",
+            id,
+            field.location,
+            field.selectionLocation
+          ),
+          relationKind: this.requiredStringArgument(
+            positional[1],
+            "relation kind",
+            field.location
+          ),
+          ...this.parseGenericRelationEndpoints(
+            positional[2],
+            positional[3],
+            field.location
+          ),
+          order: null
+        };
+      }
+      parseGenericRelationEndpoints(sourceValue, targetValue, location2) {
+        const parse = (value, description) => {
+          const reference = this.objectValue(value, description, location2);
+          const positional = reference.items ?? [];
+          const enumName = this.enumArgument(
+            reference.properties?.Kind ?? positional[0],
+            `${description}.Kind`,
+            location2
+          );
+          const kind = enumName === void 0 ? void 0 : PROJECT_RECORD_KIND_BY_ENUM[enumName];
+          if (kind === void 0) {
+            this.fail(
+              "NEO3130",
+              `${description} has an unknown NeoProjectRecordKind.`,
+              location2
+            );
+          }
+          return {
+            kind,
+            id: this.requiredStringArgument(
+              reference.properties?.Id ?? positional[1],
+              `${description}.Id`,
+              location2
+            )
+          };
+        };
+        const source = parse(sourceValue, "relation source");
+        const target = parse(targetValue, "relation target");
+        return {
+          sourceRecordKind: source.kind,
+          sourceRecordId: source.id,
+          targetRecordKind: target.kind,
+          targetRecordId: target.id
+        };
+      }
       compareMemberOrder(left, right) {
         const leftMarker = this.attribute(left.attributes, "NeoMember", false);
         const rightMarker = this.attribute(right.attributes, "NeoMember", false);
@@ -18209,6 +18990,26 @@ var init_document_contracts = __esm({
           "transitionToWhenSourceBecomesStatusId": "missingIsNull",
           "system": "nullIsAbsent"
         }
+      },
+      "internal-record-relation": {
+        "authored": [
+          "id",
+          "relationKind",
+          "sourceRecordKind",
+          "sourceRecordId",
+          "targetRecordKind",
+          "targetRecordId",
+          "orderKey"
+        ],
+        "derived": [],
+        "volatile": [
+          "projectId",
+          "createdAt",
+          "updatedAt"
+        ],
+        "normalization": {
+          "orderKey": "nullIsAbsent"
+        }
       }
     };
   }
@@ -19379,7 +20180,6 @@ function isSchemaSystemMetadata(value) {
     "replaceValue"
   ]);
   const worlds = /* @__PURE__ */ new Set([
-    "worldAssets",
     "tileGrid",
     "tileLayer",
     "objectLayer",
@@ -20191,6 +20991,267 @@ var init_class = __esm({
   }
 });
 
+// src/schema/manifest/record-adapters/internal-record-relation.ts
+function internalRecordRelationFromDocument(record2, context) {
+  const data = normalizeDocumentFieldsV3(
+    "internal-record-relation",
+    record2.data
+  );
+  const relationKind = requiredString(data, "relationKind", record2);
+  const sourceRecordKind = projectRecordKind2(
+    requiredString(data, "sourceRecordKind", record2),
+    record2,
+    "sourceRecordKind"
+  );
+  const sourceRecordId = requiredString(data, "sourceRecordId", record2);
+  const orderKey = optionalStringOrNull(data.orderKey);
+  const order = orderKey === null ? null : orderedDirectGroup(context, {
+    relationKind,
+    sourceRecordKind,
+    sourceRecordId
+  }).findIndex((candidate) => candidate.recordId === record2.recordId);
+  if (orderKey !== null && (order === null || order < 0)) {
+    throw new Error(
+      `Internal relation ${record2.recordId} could not be located in its ordered direct source set.`
+    );
+  }
+  return {
+    id: record2.recordId,
+    source: context.sourceForRecord(
+      "internal-record-relation",
+      record2.recordId,
+      "internalRecordRelation"
+    ),
+    relationKind,
+    sourceRecordKind,
+    sourceRecordId,
+    targetRecordKind: projectRecordKind2(
+      requiredString(data, "targetRecordKind", record2),
+      record2,
+      "targetRecordKind"
+    ),
+    targetRecordId: requiredString(data, "targetRecordId", record2),
+    order
+  };
+}
+function orderedDirectGroup(context, source) {
+  return [...context.recordsByKind.get("internal-record-relation") ?? []].filter((candidate) => {
+    const data = normalizeDocumentFieldsV3(
+      "internal-record-relation",
+      candidate.data
+    );
+    return data.relationKind === source.relationKind && data.sourceRecordKind === source.sourceRecordKind && data.sourceRecordId === source.sourceRecordId && typeof data.orderKey === "string";
+  }).sort((left, right) => {
+    const leftData = normalizeDocumentFieldsV3(
+      "internal-record-relation",
+      left.data
+    );
+    const rightData = normalizeDocumentFieldsV3(
+      "internal-record-relation",
+      right.data
+    );
+    return String(leftData.orderKey).localeCompare(String(rightData.orderKey)) || left.recordId.localeCompare(right.recordId);
+  });
+}
+function internalRecordRelationToDocument(relation, orderKey) {
+  return omitUndefined({
+    id: relation.id,
+    relationKind: relation.relationKind,
+    sourceRecordKind: relation.sourceRecordKind,
+    sourceRecordId: relation.sourceRecordId,
+    targetRecordKind: relation.targetRecordKind,
+    targetRecordId: relation.targetRecordId,
+    orderKey
+  });
+}
+function relationOrderKeys(manifest, context) {
+  const result = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  for (const relation of manifest.internalRecordRelations) {
+    if (relation.order === null) continue;
+    const key = `${relation.relationKind}\0${relation.sourceRecordKind}\0${relation.sourceRecordId}`;
+    const group = groups.get(key) ?? [];
+    group.push(relation);
+    groups.set(key, group);
+  }
+  for (const group of groups.values()) {
+    group.sort(
+      (left, right) => (left.order ?? 0) - (right.order ?? 0) || left.id.localeCompare(right.id)
+    );
+    const groupSource = group[0];
+    const base = group.map(
+      (relation) => context.baseRecord("internal-record-relation", relation.id)
+    ).filter((record2) => record2 !== null).filter((record2) => {
+      if (groupSource === void 0) return false;
+      const data = normalizeDocumentFieldsV3(
+        "internal-record-relation",
+        record2.data
+      );
+      return data.relationKind === groupSource.relationKind && data.sourceRecordKind === groupSource.sourceRecordKind && data.sourceRecordId === groupSource.sourceRecordId;
+    }).map((record2) => ({
+      id: record2.recordId,
+      key: typeof record2.data.orderKey === "string" ? record2.data.orderKey : null
+    })).filter(
+      (entry) => entry.key !== null
+    ).sort((left, right) => left.key.localeCompare(right.key));
+    const unchanged = base.length === group.length && group.every((relation, index) => relation.id === base[index]?.id);
+    if (unchanged) {
+      for (const entry of base) result.set(entry.id, entry.key);
+      continue;
+    }
+    const baseIds = base.map((entry) => entry.id);
+    const desiredIds = group.map((relation) => relation.id);
+    const anchoredIds = new Set(longestCommonSubsequence(baseIds, desiredIds));
+    const baseKeysById = new Map(base.map((entry) => [entry.id, entry.key]));
+    for (const id of anchoredIds) {
+      const key = baseKeysById.get(id);
+      if (key !== void 0) result.set(id, key);
+    }
+    const assignedKeys = new Set(
+      [...anchoredIds].map((id) => baseKeysById.get(id)).filter((key) => key !== void 0)
+    );
+    let failedToAllocate = false;
+    for (const [index, relation] of group.entries()) {
+      if (result.has(relation.id)) continue;
+      const previousKey = findAssignedNeighborKey(group, index, -1, result);
+      const nextKey = findAssignedNeighborKey(group, index, 1, result);
+      const key = relationKeyBetween(previousKey, nextKey, assignedKeys);
+      if (key === null) {
+        failedToAllocate = true;
+        break;
+      }
+      result.set(relation.id, key);
+      assignedKeys.add(key);
+    }
+    if (failedToAllocate) {
+      for (const relation of group) result.delete(relation.id);
+      for (const [index, relation] of group.entries()) {
+        result.set(relation.id, String((index + 1) * 1024).padStart(12, "0"));
+      }
+    }
+  }
+  return result;
+}
+function longestCommonSubsequence(left, right) {
+  const lengths = Array.from(
+    { length: left.length + 1 },
+    () => Array(right.length + 1).fill(0)
+  );
+  for (let leftIndex2 = left.length - 1; leftIndex2 >= 0; leftIndex2 -= 1) {
+    for (let rightIndex2 = right.length - 1; rightIndex2 >= 0; rightIndex2 -= 1) {
+      lengths[leftIndex2][rightIndex2] = left[leftIndex2] === right[rightIndex2] ? 1 + lengths[leftIndex2 + 1][rightIndex2 + 1] : Math.max(
+        lengths[leftIndex2 + 1][rightIndex2],
+        lengths[leftIndex2][rightIndex2 + 1]
+      );
+    }
+  }
+  const result = [];
+  let leftIndex = 0;
+  let rightIndex = 0;
+  while (leftIndex < left.length && rightIndex < right.length) {
+    if (left[leftIndex] === right[rightIndex]) {
+      result.push(left[leftIndex]);
+      leftIndex += 1;
+      rightIndex += 1;
+    } else if (lengths[leftIndex + 1][rightIndex] >= lengths[leftIndex][rightIndex + 1]) {
+      leftIndex += 1;
+    } else {
+      rightIndex += 1;
+    }
+  }
+  return result;
+}
+function findAssignedNeighborKey(group, startIndex, direction, assigned) {
+  for (let index = startIndex + direction; index >= 0 && index < group.length; index += direction) {
+    const relation = group[index];
+    if (relation === void 0) continue;
+    const key = assigned.get(relation.id);
+    if (key !== void 0) return key;
+  }
+  return null;
+}
+function relationKeyBetween(previous, next, assigned) {
+  if (previous === null && next === null) return "000000001024";
+  if (previous !== null && next !== null && /^\d+$/.test(previous) && /^\d+$/.test(next) && previous.length === next.length) {
+    const previousNumber = BigInt(previous);
+    const nextNumber = BigInt(next);
+    if (nextNumber - previousNumber > 1n) {
+      const midpoint = (previousNumber + nextNumber) / 2n;
+      const candidate = midpoint.toString().padStart(previous.length, "0");
+      if (!assigned.has(candidate)) return candidate;
+    }
+  }
+  if (previous === null && next !== null) {
+    for (let depth = 1; depth <= 32; depth += 1) {
+      const candidate = `${"!".repeat(depth)}${next}`;
+      if (candidate.localeCompare(next) < 0 && !assigned.has(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  if (previous !== null) {
+    for (let depth = 1; depth <= 32; depth += 1) {
+      const candidate = `${previous}${"~".repeat(depth)}`;
+      if (candidate.localeCompare(previous) > 0 && (next === null || candidate.localeCompare(next) < 0) && !assigned.has(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function projectRecordKind2(value, record2, field) {
+  switch (value) {
+    case "project":
+    case "member":
+    case "value":
+    case "class":
+    case "internal-record-relation":
+    case "enum":
+    case "interface":
+    case "dialogue":
+    case "dialogue-node":
+    case "dialogue-group":
+    case "priority-group":
+    case "project-file":
+    case "unity-texture-template":
+    case "unity-audio-clip-template":
+    case "localization-config":
+    case "localization-status":
+    case "localized-text":
+    case "migration":
+      return value;
+  }
+  throw new Error(
+    `Schema document ${record2.recordKind}:${record2.recordId} field ${field} has unknown project record kind ${JSON.stringify(value)}.`
+  );
+}
+var INTERNAL_RECORD_RELATION_SCHEMA_RECORD_ADAPTER_V3;
+var init_internal_record_relation = __esm({
+  "src/schema/manifest/record-adapters/internal-record-relation.ts"() {
+    "use strict";
+    init_contracts();
+    init_codecs();
+    INTERNAL_RECORD_RELATION_SCHEMA_RECORD_ADAPTER_V3 = {
+      recordKind: "internal-record-relation",
+      manifestCollection: "internalRecordRelations",
+      cardinality: "many",
+      fromDocument: internalRecordRelationFromDocument,
+      toAuthoredDocuments: (manifest, context) => {
+        const orderKeys = relationOrderKeys(manifest, context);
+        return manifest.internalRecordRelations.map((relation) => ({
+          recordKind: "internal-record-relation",
+          recordId: relation.id,
+          authoredFields: internalRecordRelationToDocument(
+            relation,
+            orderKeys.get(relation.id) ?? null
+          )
+        }));
+      }
+    };
+  }
+});
+
 // src/schema/manifest/record-adapters/registry.ts
 var SCHEMA_RECORD_ADAPTER_REGISTRY_V3, SCHEMA_RECORD_ADAPTERS_V3;
 var init_registry = __esm({
@@ -20202,6 +21263,7 @@ var init_registry = __esm({
     init_member();
     init_template();
     init_class();
+    init_internal_record_relation();
     SCHEMA_RECORD_ADAPTER_REGISTRY_V3 = {
       member: MEMBER_SCHEMA_RECORD_ADAPTER_V3,
       class: CLASS_SCHEMA_RECORD_ADAPTER_V3,
@@ -20210,7 +21272,8 @@ var init_registry = __esm({
       "unity-texture-template": TEXTURE_TEMPLATE_SCHEMA_RECORD_ADAPTER_V3,
       "unity-audio-clip-template": AUDIO_TEMPLATE_SCHEMA_RECORD_ADAPTER_V3,
       "localization-config": LOCALIZATION_SCHEMA_RECORD_ADAPTER_V3,
-      "localization-status": LOCALIZATION_STATUS_SCHEMA_RECORD_ADAPTER_V3
+      "localization-status": LOCALIZATION_STATUS_SCHEMA_RECORD_ADAPTER_V3,
+      "internal-record-relation": INTERNAL_RECORD_RELATION_SCHEMA_RECORD_ADAPTER_V3
     };
     SCHEMA_RECORD_ADAPTERS_V3 = [
       SCHEMA_RECORD_ADAPTER_REGISTRY_V3.class,
@@ -20220,7 +21283,8 @@ var init_registry = __esm({
       SCHEMA_RECORD_ADAPTER_REGISTRY_V3["unity-texture-template"],
       SCHEMA_RECORD_ADAPTER_REGISTRY_V3["unity-audio-clip-template"],
       SCHEMA_RECORD_ADAPTER_REGISTRY_V3["localization-config"],
-      SCHEMA_RECORD_ADAPTER_REGISTRY_V3["localization-status"]
+      SCHEMA_RECORD_ADAPTER_REGISTRY_V3["localization-status"],
+      SCHEMA_RECORD_ADAPTER_REGISTRY_V3["internal-record-relation"]
     ];
   }
 });
@@ -20237,6 +21301,7 @@ var init_record_adapters = __esm({
     init_registry();
     init_template();
     init_class();
+    init_internal_record_relation();
   }
 });
 
@@ -20255,7 +21320,8 @@ function documentsToSchemaManifestV3(records2, optionsOrContext = {}) {
     textureTemplates: [],
     audioTemplates: [],
     localization: void 0,
-    localizationStatuses: []
+    localizationStatuses: [],
+    internalRecordRelations: []
   };
   for (const adapter of SCHEMA_RECORD_ADAPTERS_V3) {
     const adapterRecords = context.recordsByKind.get(adapter.recordKind) ?? [];
@@ -20498,6 +21564,8 @@ function emitSchemaManifestV3(manifest) {
   }
   const loose = emitLooseMembers(context);
   if (loose !== null) append(loose);
+  const genericRelations = emitGenericRelations(context);
+  if (genericRelations !== null) append(genericRelations);
   append(emitLocalization(manifest.localization));
   for (const status of manifest.localizationStatuses) {
     append(
@@ -20875,6 +21943,14 @@ function emitNeoSchemaClass(context, schemaClass2) {
   if (typeBindingEntries.length > 0) {
     lines.push(...indent(typeBindingEntries));
   }
+  const relationSettings = emitClassRelationSettings(context, schemaClass2);
+  if (relationSettings.lines.length > 0) {
+    if (typeBindingEntries.length > 0) lines.push("");
+    lines.push(...indent(relationSettings.lines));
+    for (const relationId of relationSettings.relationIds) {
+      recordKeys.push(`internal-record-relation:${relationId}`);
+    }
+  }
   const orderedKeys2 = orderedSchemaKeys(schemaClass2);
   let emittedMember = false;
   for (const schemaKey of orderedKeys2) {
@@ -20886,7 +21962,9 @@ function emitNeoSchemaClass(context, schemaClass2) {
         `Class ${JSON.stringify(schemaClass2.name)} references missing member ${JSON.stringify(memberId)}.`
       );
     }
-    if (emittedMember || typeBindingEntries.length > 0) lines.push("");
+    if (emittedMember || typeBindingEntries.length > 0 || relationSettings.lines.length > 0) {
+      lines.push("");
+    }
     const memberLines = emitMember(
       context,
       schemaClass2,
@@ -20912,6 +21990,119 @@ function emitNeoSchemaClass(context, schemaClass2) {
     [...new Set(recordKeys)]
   );
 }
+function emitClassRelationSettings(context, schemaClass2) {
+  const relations = context.manifest.internalRecordRelations.filter(
+    (relation) => relation.sourceRecordKind === "class" && relation.sourceRecordId === schemaClass2.id && relation.targetRecordKind === "class" && Object.hasOwn(SPECIALIZED_RELATION_EMISSION, relation.relationKind)
+  );
+  if (relations.length === 0) return { lines: [], relationIds: [] };
+  const descriptors = relations.map((relation) => ({
+    relation,
+    descriptor: SPECIALIZED_RELATION_EMISSION[relation.relationKind]
+  }));
+  const settingsTypes = new Set(
+    descriptors.map((entry) => entry.descriptor.settingsType)
+  );
+  if (settingsTypes.size !== 1) {
+    throw new Error(
+      `Class ${schemaClass2.id} has incompatible specialized relation families: ${[...settingsTypes].join(", ")}.`
+    );
+  }
+  const settingsType = descriptors[0]?.descriptor.settingsType;
+  if (settingsType === void 0) return { lines: [], relationIds: [] };
+  const propertyOrder = [
+    "TileImports",
+    "ObjectImports",
+    "TileLayers",
+    "ObjectLayers",
+    "CompatibleLayers",
+    "DefaultLayer",
+    "TargetLayer"
+  ];
+  const lines = [
+    `private static readonly ${settingsType} NeoRelations = new()`,
+    "{"
+  ];
+  for (const property2 of propertyOrder) {
+    const entries = descriptors.filter(
+      (entry) => entry.descriptor.property === property2
+    );
+    if (entries.length === 0) continue;
+    const singleton = entries[0] !== void 0 && "singleton" in entries[0].descriptor && entries[0].descriptor.singleton === true;
+    if (singleton) {
+      if (entries.length !== 1) {
+        throw new Error(
+          `Class ${schemaClass2.id} declares more than one direct ${entries[0]?.relation.relationKind} relation.`
+        );
+      }
+      lines.push(
+        `    ${property2} = ${emitClassRelationDefinition(context, entries[0].relation)},`
+      );
+      continue;
+    }
+    entries.sort((left, right) => {
+      if (left.descriptor.ordered) {
+        return (left.relation.order ?? 0) - (right.relation.order ?? 0) || left.relation.id.localeCompare(right.relation.id);
+      }
+      return left.relation.targetRecordId.localeCompare(
+        right.relation.targetRecordId
+      ) || left.relation.id.localeCompare(right.relation.id);
+    });
+    lines.push(`    ${property2} =`, "    {");
+    for (const entry of entries) {
+      lines.push(
+        `        ${emitClassRelationDefinition(context, entry.relation)},`
+      );
+    }
+    lines.push("    },");
+  }
+  lines.push("};");
+  return {
+    lines,
+    relationIds: relations.map((relation) => relation.id)
+  };
+}
+function emitClassRelationDefinition(context, relation) {
+  const target = requiredName(
+    context.classNames,
+    relation.targetRecordId,
+    "relation target class"
+  );
+  return `new(${csString(relation.id)}, typeof(${target}))`;
+}
+function emitGenericRelations(context) {
+  const relations = context.manifest.internalRecordRelations.filter(
+    (relation) => !(relation.sourceRecordKind === "class" && relation.targetRecordKind === "class" && Object.hasOwn(SPECIALIZED_RELATION_EMISSION, relation.relationKind))
+  ).sort(
+    (left, right) => left.relationKind === right.relationKind ? left.id.localeCompare(right.id) : left.relationKind.localeCompare(right.relationKind)
+  );
+  if (relations.length === 0) return null;
+  const ordered = relations.find((relation) => relation.order !== null);
+  if (ordered !== void 0) {
+    throw new Error(
+      `Generic relation ${ordered.id} is ordered, but its relation kind has no typed source-owned settings contract. CLI contract upgrade required.`
+    );
+  }
+  const lines = [
+    "[NeoRelationConfiguration]",
+    "internal static class ProjectRelations",
+    "{",
+    "    internal static readonly NeoInternalRecordRelationDefinition[] NeoRelations =",
+    "    {",
+    ...relations.map(
+      (relation) => `        new(${csString(relation.id)}, ${csString(relation.relationKind)}, new(NeoProjectRecordKind.${enumCase(relation.sourceRecordKind)}, ${csString(relation.sourceRecordId)}), new(NeoProjectRecordKind.${enumCase(relation.targetRecordKind)}, ${csString(relation.targetRecordId)})),`
+    ),
+    "    };",
+    "}"
+  ];
+  return emitFile(
+    "ProjectRelations.cs",
+    [
+      { recordKey: null, lines: HEADER.split("\n") },
+      { recordKey: null, lines }
+    ],
+    relations.map((relation) => `internal-record-relation:${relation.id}`)
+  );
+}
 function orderedSchemaKeys(schemaClass2) {
   const keys = Object.keys(schemaClass2.schema);
   const preferred = schemaClass2.schemaKeyOrder ?? [];
@@ -22278,7 +23469,7 @@ function emitLocalizationStatus(status, className) {
     [recordKey]
   );
 }
-var HEADER;
+var HEADER, SPECIALIZED_RELATION_EMISSION;
 var init_emitter = __esm({
   "src/schema/emitter.ts"() {
     "use strict";
@@ -22295,6 +23486,62 @@ using System.Threading.Tasks;
 
 namespace ProjectSchema;
 `;
+    SPECIALIZED_RELATION_EMISSION = {
+      "world.grid.tile-import": {
+        settingsType: "NeoGridRelationSettings",
+        property: "TileImports",
+        ordered: false
+      },
+      "world.grid.object-import": {
+        settingsType: "NeoGridRelationSettings",
+        property: "ObjectImports",
+        ordered: false
+      },
+      "world.grid.tile-layer": {
+        settingsType: "NeoGridRelationSettings",
+        property: "TileLayers",
+        ordered: true
+      },
+      "world.grid.object-layer": {
+        settingsType: "NeoGridRelationSettings",
+        property: "ObjectLayers",
+        ordered: true
+      },
+      "world.tile.compatible-layer": {
+        settingsType: "NeoTileRelationSettings",
+        property: "CompatibleLayers",
+        ordered: false
+      },
+      "world.tile.default-layer": {
+        settingsType: "NeoTileRelationSettings",
+        property: "DefaultLayer",
+        ordered: false,
+        singleton: true
+      },
+      "world.object.compatible-layer": {
+        settingsType: "NeoObjectRelationSettings",
+        property: "CompatibleLayers",
+        ordered: false
+      },
+      "world.object.default-layer": {
+        settingsType: "NeoObjectRelationSettings",
+        property: "DefaultLayer",
+        ordered: false,
+        singleton: true
+      },
+      "world.tile-layer-link.target": {
+        settingsType: "NeoTileLayerLinkRelationSettings",
+        property: "TargetLayer",
+        ordered: false,
+        singleton: true
+      },
+      "world.object-layer-link.target": {
+        settingsType: "NeoObjectLayerLinkRelationSettings",
+        property: "TargetLayer",
+        ordered: false,
+        singleton: true
+      }
+    };
   }
 });
 
@@ -22375,7 +23622,8 @@ var init_project_documents = __esm({
       "unity-texture-template",
       "unity-audio-clip-template",
       "localization-config",
-      "localization-status"
+      "localization-status",
+      "internal-record-relation"
     ]);
   }
 });
@@ -22423,7 +23671,7 @@ function isSystemDisallowedOperation(value) {
   return value === SystemDisallowedOperation.EditRecord || value === SystemDisallowedOperation.DeleteRecord || value === SystemDisallowedOperation.SelectRecord || value === SystemDisallowedOperation.ReplaceValue;
 }
 function isNeoWorldSystemClassKind(value) {
-  return value === NeoWorldSystemClassKind.WorldAssets || value === NeoWorldSystemClassKind.TileGrid || value === NeoWorldSystemClassKind.TileLayer || value === NeoWorldSystemClassKind.ObjectLayer || value === NeoWorldSystemClassKind.Tile || value === NeoWorldSystemClassKind.ObjectBase || value === NeoWorldSystemClassKind.LayerGroupBase || value === NeoWorldSystemClassKind.SpriteObject || value === NeoWorldSystemClassKind.Object || value === NeoWorldSystemClassKind.TileLayerLink || value === NeoWorldSystemClassKind.ObjectLayerLink || value === NeoWorldSystemClassKind.ObjectPlacementTile || value === NeoWorldSystemClassKind.TileInstance || value === NeoWorldSystemClassKind.ObjectCollider || value === NeoWorldSystemClassKind.SortingLayer || value === NeoWorldSystemClassKind.SmartTile || value === NeoWorldSystemClassKind.SmartTileRule || value === NeoWorldSystemClassKind.SmartTileNeighbor;
+  return value === NeoWorldSystemClassKind.TileGrid || value === NeoWorldSystemClassKind.TileLayer || value === NeoWorldSystemClassKind.ObjectLayer || value === NeoWorldSystemClassKind.Tile || value === NeoWorldSystemClassKind.ObjectBase || value === NeoWorldSystemClassKind.LayerGroupBase || value === NeoWorldSystemClassKind.SpriteObject || value === NeoWorldSystemClassKind.Object || value === NeoWorldSystemClassKind.TileLayerLink || value === NeoWorldSystemClassKind.ObjectLayerLink || value === NeoWorldSystemClassKind.ObjectPlacementTile || value === NeoWorldSystemClassKind.TileInstance || value === NeoWorldSystemClassKind.ObjectCollider || value === NeoWorldSystemClassKind.SortingLayer || value === NeoWorldSystemClassKind.SmartTile || value === NeoWorldSystemClassKind.SmartTileRule || value === NeoWorldSystemClassKind.SmartTileNeighbor;
 }
 function isSystemMetadata(value) {
   const v = value;
@@ -22465,7 +23713,6 @@ var init_core_types = __esm({
       ReplaceValue: "replaceValue"
     };
     NeoWorldSystemClassKind = {
-      WorldAssets: "worldAssets",
       TileGrid: "tileGrid",
       TileLayer: "tileLayer",
       ObjectLayer: "objectLayer",
@@ -27149,6 +28396,216 @@ var init_value_responses = __esm({
   }
 });
 
+// ../src/models/project/project-version-types.ts
+function isProjectVersionBumpKind(value) {
+  if (value === ProjectVersionBumpKind.Patch) return true;
+  if (value === ProjectVersionBumpKind.Minor) return true;
+  if (value === ProjectVersionBumpKind.Major) return true;
+  return false;
+}
+function isProjectDocumentRevisionMarker(value) {
+  if (typeof value !== "object") return false;
+  if (value === null) return false;
+  const candidate = value;
+  if (candidate.latestTransactionId !== null && typeof candidate.latestTransactionId !== "string") {
+    return false;
+  }
+  if (typeof candidate.latestTransactionCreatedAt !== "number") return false;
+  return typeof candidate.versionsStamp === "string";
+}
+function isProjectRecordKind(value) {
+  if (value === ProjectRecordKind.Project) return true;
+  if (value === ProjectRecordKind.Member) return true;
+  if (value === ProjectRecordKind.Value) return true;
+  if (value === ProjectRecordKind.Class) return true;
+  if (value === ProjectRecordKind.InternalRecordRelation) return true;
+  if (value === ProjectRecordKind.Enum) return true;
+  if (value === ProjectRecordKind.Interface) return true;
+  if (value === ProjectRecordKind.Dialogue) return true;
+  if (value === ProjectRecordKind.DialogueNode) return true;
+  if (value === ProjectRecordKind.DialogueGroup) return true;
+  if (value === ProjectRecordKind.PriorityGroup) return true;
+  if (value === ProjectRecordKind.ProjectFile) return true;
+  if (value === ProjectRecordKind.UnityTextureTemplate) return true;
+  if (value === ProjectRecordKind.UnityAudioClipTemplate) return true;
+  if (value === ProjectRecordKind.LocalizationConfig) return true;
+  if (value === ProjectRecordKind.LocalizationStatus) return true;
+  if (value === ProjectRecordKind.LocalizedText) return true;
+  if (value === ProjectRecordKind.Migration) return true;
+  return false;
+}
+function isInternalRecordRelation(value) {
+  if (!isWithId(value)) return false;
+  const relation = value;
+  if (!isString(relation.projectId)) return false;
+  if (!isString(relation.relationKind)) return false;
+  if (relation.relationKind.length === 0) return false;
+  if (!isProjectRecordKind(relation.sourceRecordKind)) return false;
+  if (!isString(relation.sourceRecordId)) return false;
+  if (relation.sourceRecordId.length === 0) return false;
+  if (!isProjectRecordKind(relation.targetRecordKind)) return false;
+  if (!isString(relation.targetRecordId)) return false;
+  if (relation.targetRecordId.length === 0) return false;
+  if (relation.orderKey !== void 0 && (!isString(relation.orderKey) || relation.orderKey.length === 0)) {
+    return false;
+  }
+  if (!isNumber(relation.createdAt)) return false;
+  return isNumber(relation.updatedAt);
+}
+function isProjectVersionSemver(value) {
+  if (!isObject(value)) return false;
+  const v = value;
+  if (!isNonNegativeInteger(v.major)) return false;
+  if (!isNonNegativeInteger(v.minor)) return false;
+  if (!isNonNegativeInteger(v.patch)) return false;
+  if (!isString(v.label)) return false;
+  return v.label === `${v.major}.${v.minor}.${v.patch}`;
+}
+function isProjectVersionProps(value) {
+  if (!isWithId(value)) return false;
+  const v = value;
+  if (!isString(v.projectId)) return false;
+  if (!isProjectVersionSemver(v.semver)) return false;
+  if (!isString(v.statusId)) return false;
+  if (!isProjectVersionBumpKind(v.bumpKind)) return false;
+  if (!isNullableString(v.sourceVersionId)) return false;
+  if (!isNullableString(v.sourceHeadVersionId)) return false;
+  if (!isTimestamp(v.createdAt)) return false;
+  if (!isTimestamp(v.updatedAt)) return false;
+  if (!isOptionalNullableTimestamp(v.statusChangedAt)) return false;
+  if (!isOptionalNullableTimestamp(v.releasedAt)) return false;
+  if (!isOptionalNullableTimestamp(v.archivedAt)) return false;
+  if (!isPositiveInteger(v.exportSchemaVersion)) return false;
+  if (!isPositiveInteger(v.runtimeSchemaVersion)) return false;
+  if (!isOptionalNullableString(v.codegenContractHash)) return false;
+  if (v.kind !== void 0 && v.kind !== "branch" && v.kind !== "release") {
+    return false;
+  }
+  if (!isOptionalNullableString(v.name)) return false;
+  return isOptionalNullableString(v.runtimeDataContractHash);
+}
+function projectVersionDisplayLabel(version) {
+  if (version.kind === "branch" && typeof version.name === "string") {
+    return version.name;
+  }
+  return version.semver.label;
+}
+function isProjectVersion(value) {
+  if (!isProjectVersionProps(value)) return false;
+  return isWithId(value);
+}
+function isProjectVersionStatusProps(value) {
+  if (!isWithId(value)) return false;
+  const v = value;
+  if (!isString(v.projectId)) return false;
+  if (!isString(v.name)) return false;
+  if (!isOptionalNullableString(v.description)) return false;
+  if (!isNumber(v.sortOrder)) return false;
+  if (!isOptionalNullableString(v.color)) return false;
+  if (!isOptionalNullableTimestamp(v.archivedAt)) return false;
+  if (!isTimestamp(v.createdAt)) return false;
+  if (!isTimestamp(v.updatedAt)) return false;
+  if (!isBoolean(v.isWritable)) return false;
+  if (!isBoolean(v.canSourceNewVersions)) return false;
+  if (!isStringArray(v.releaseChannelIds)) return false;
+  if (!isStringArray(v.allowedNextStatusIds)) return false;
+  if (v.system !== void 0 && v.system !== null) {
+    return isSystemMetadata(v.system);
+  }
+  return true;
+}
+function isProjectVersionStatus(value) {
+  if (!isProjectVersionStatusProps(value)) return false;
+  return isWithId(value);
+}
+function isProjectReleaseChannelProps(value) {
+  if (!isWithId(value)) return false;
+  const v = value;
+  if (!isString(v.projectId)) return false;
+  if (!isString(v.name)) return false;
+  if (!isString(v.slug)) return false;
+  if (!isOptionalNullableString(v.description)) return false;
+  if (!isNumber(v.sortOrder)) return false;
+  if (!isTimestamp(v.createdAt)) return false;
+  if (!isTimestamp(v.updatedAt)) return false;
+  if (v.system !== void 0 && v.system !== null) {
+    return isSystemMetadata(v.system);
+  }
+  return true;
+}
+function isProjectReleaseChannel(value) {
+  if (!isProjectReleaseChannelProps(value)) return false;
+  return isWithId(value);
+}
+function isNonNegativeInteger(value) {
+  if (typeof value !== "number") return false;
+  if (!Number.isInteger(value)) return false;
+  return value >= 0;
+}
+function isPositiveInteger(value) {
+  if (typeof value !== "number") return false;
+  if (!Number.isInteger(value)) return false;
+  return value > 0;
+}
+function isTimestamp(value) {
+  if (typeof value !== "number") return false;
+  return Number.isFinite(value);
+}
+function isNullableString(value) {
+  if (value === null) return true;
+  return isString(value);
+}
+function isOptionalNullableTimestamp(value) {
+  if (value === void 0) return true;
+  if (value === null) return true;
+  return isTimestamp(value);
+}
+function isStringArray(value) {
+  if (!Array.isArray(value)) return false;
+  return value.every(isString);
+}
+var ProjectVersionBumpKind, ProjectRecordKind;
+var init_project_version_types = __esm({
+  "../src/models/project/project-version-types.ts"() {
+    "use strict";
+    init_core();
+    ProjectVersionBumpKind = {
+      Patch: "patch",
+      Minor: "minor",
+      Major: "major"
+    };
+    ProjectRecordKind = {
+      Project: "project",
+      Member: "member",
+      Value: "value",
+      Class: "class",
+      InternalRecordRelation: "internal-record-relation",
+      Enum: "enum",
+      Interface: "interface",
+      Dialogue: "dialogue",
+      DialogueNode: "dialogue-node",
+      DialogueGroup: "dialogue-group",
+      PriorityGroup: "priority-group",
+      ProjectFile: "project-file",
+      UnityTextureTemplate: "unity-texture-template",
+      UnityAudioClipTemplate: "unity-audio-clip-template",
+      LocalizationConfig: "localization-config",
+      LocalizationStatus: "localization-status",
+      LocalizedText: "localized-text",
+      Migration: "migration"
+    };
+  }
+});
+
+// ../src/models/project/initial-class-internal-record-relation.ts
+var init_initial_class_internal_record_relation = __esm({
+  "../src/models/project/initial-class-internal-record-relation.ts"() {
+    "use strict";
+    init_core();
+    init_project_version_types();
+  }
+});
+
 // ../src/models/classes/add-class-member.ts
 var init_add_class_member = __esm({
   "../src/models/classes/add-class-member.ts"() {
@@ -27156,6 +28613,8 @@ var init_add_class_member = __esm({
     init_members();
     init_enum2();
     init_classes();
+    init_initial_class_internal_record_relation();
+    init_project_version_types();
   }
 });
 
@@ -28884,6 +30343,12 @@ function manifestRecordSources(manifest) {
   for (const status of manifest.localizationStatuses) {
     result.set(recordStateKey("localization-status", status.id), status.source);
   }
+  for (const relation of manifest.internalRecordRelations) {
+    result.set(
+      recordStateKey("internal-record-relation", relation.id),
+      relation.source
+    );
+  }
   return result;
 }
 function mergeMigrationServerFields(fileFields, baseData) {
@@ -28948,187 +30413,6 @@ var init_status = __esm({
   }
 });
 
-// ../src/models/project/project-version-types.ts
-function isProjectVersionBumpKind(value) {
-  if (value === ProjectVersionBumpKind.Patch) return true;
-  if (value === ProjectVersionBumpKind.Minor) return true;
-  if (value === ProjectVersionBumpKind.Major) return true;
-  return false;
-}
-function isProjectDocumentRevisionMarker(value) {
-  if (typeof value !== "object") return false;
-  if (value === null) return false;
-  const candidate = value;
-  if (candidate.latestTransactionId !== null && typeof candidate.latestTransactionId !== "string") {
-    return false;
-  }
-  if (typeof candidate.latestTransactionCreatedAt !== "number") return false;
-  return typeof candidate.versionsStamp === "string";
-}
-function isProjectRecordKind(value) {
-  if (value === ProjectRecordKind.Project) return true;
-  if (value === ProjectRecordKind.Member) return true;
-  if (value === ProjectRecordKind.Value) return true;
-  if (value === ProjectRecordKind.Class) return true;
-  if (value === ProjectRecordKind.Enum) return true;
-  if (value === ProjectRecordKind.Interface) return true;
-  if (value === ProjectRecordKind.Dialogue) return true;
-  if (value === ProjectRecordKind.DialogueNode) return true;
-  if (value === ProjectRecordKind.DialogueGroup) return true;
-  if (value === ProjectRecordKind.PriorityGroup) return true;
-  if (value === ProjectRecordKind.ProjectFile) return true;
-  if (value === ProjectRecordKind.UnityTextureTemplate) return true;
-  if (value === ProjectRecordKind.UnityAudioClipTemplate) return true;
-  if (value === ProjectRecordKind.LocalizationConfig) return true;
-  if (value === ProjectRecordKind.LocalizationStatus) return true;
-  if (value === ProjectRecordKind.LocalizedText) return true;
-  if (value === ProjectRecordKind.Migration) return true;
-  return false;
-}
-function isProjectVersionSemver(value) {
-  if (!isObject(value)) return false;
-  const v = value;
-  if (!isNonNegativeInteger(v.major)) return false;
-  if (!isNonNegativeInteger(v.minor)) return false;
-  if (!isNonNegativeInteger(v.patch)) return false;
-  if (!isString(v.label)) return false;
-  return v.label === `${v.major}.${v.minor}.${v.patch}`;
-}
-function isProjectVersionProps(value) {
-  if (!isWithId(value)) return false;
-  const v = value;
-  if (!isString(v.projectId)) return false;
-  if (!isProjectVersionSemver(v.semver)) return false;
-  if (!isString(v.statusId)) return false;
-  if (!isProjectVersionBumpKind(v.bumpKind)) return false;
-  if (!isNullableString(v.sourceVersionId)) return false;
-  if (!isNullableString(v.sourceHeadVersionId)) return false;
-  if (!isTimestamp(v.createdAt)) return false;
-  if (!isTimestamp(v.updatedAt)) return false;
-  if (!isOptionalNullableTimestamp(v.statusChangedAt)) return false;
-  if (!isOptionalNullableTimestamp(v.releasedAt)) return false;
-  if (!isOptionalNullableTimestamp(v.archivedAt)) return false;
-  if (!isPositiveInteger(v.exportSchemaVersion)) return false;
-  if (!isPositiveInteger(v.runtimeSchemaVersion)) return false;
-  if (!isOptionalNullableString(v.codegenContractHash)) return false;
-  if (v.kind !== void 0 && v.kind !== "branch" && v.kind !== "release") {
-    return false;
-  }
-  if (!isOptionalNullableString(v.name)) return false;
-  return isOptionalNullableString(v.runtimeDataContractHash);
-}
-function projectVersionDisplayLabel(version) {
-  if (version.kind === "branch" && typeof version.name === "string") {
-    return version.name;
-  }
-  return version.semver.label;
-}
-function isProjectVersion(value) {
-  if (!isProjectVersionProps(value)) return false;
-  return isWithId(value);
-}
-function isProjectVersionStatusProps(value) {
-  if (!isWithId(value)) return false;
-  const v = value;
-  if (!isString(v.projectId)) return false;
-  if (!isString(v.name)) return false;
-  if (!isOptionalNullableString(v.description)) return false;
-  if (!isNumber(v.sortOrder)) return false;
-  if (!isOptionalNullableString(v.color)) return false;
-  if (!isOptionalNullableTimestamp(v.archivedAt)) return false;
-  if (!isTimestamp(v.createdAt)) return false;
-  if (!isTimestamp(v.updatedAt)) return false;
-  if (!isBoolean(v.isWritable)) return false;
-  if (!isBoolean(v.canSourceNewVersions)) return false;
-  if (!isStringArray(v.releaseChannelIds)) return false;
-  if (!isStringArray(v.allowedNextStatusIds)) return false;
-  if (v.system !== void 0 && v.system !== null) {
-    return isSystemMetadata(v.system);
-  }
-  return true;
-}
-function isProjectVersionStatus(value) {
-  if (!isProjectVersionStatusProps(value)) return false;
-  return isWithId(value);
-}
-function isProjectReleaseChannelProps(value) {
-  if (!isWithId(value)) return false;
-  const v = value;
-  if (!isString(v.projectId)) return false;
-  if (!isString(v.name)) return false;
-  if (!isString(v.slug)) return false;
-  if (!isOptionalNullableString(v.description)) return false;
-  if (!isNumber(v.sortOrder)) return false;
-  if (!isTimestamp(v.createdAt)) return false;
-  if (!isTimestamp(v.updatedAt)) return false;
-  if (v.system !== void 0 && v.system !== null) {
-    return isSystemMetadata(v.system);
-  }
-  return true;
-}
-function isProjectReleaseChannel(value) {
-  if (!isProjectReleaseChannelProps(value)) return false;
-  return isWithId(value);
-}
-function isNonNegativeInteger(value) {
-  if (typeof value !== "number") return false;
-  if (!Number.isInteger(value)) return false;
-  return value >= 0;
-}
-function isPositiveInteger(value) {
-  if (typeof value !== "number") return false;
-  if (!Number.isInteger(value)) return false;
-  return value > 0;
-}
-function isTimestamp(value) {
-  if (typeof value !== "number") return false;
-  return Number.isFinite(value);
-}
-function isNullableString(value) {
-  if (value === null) return true;
-  return isString(value);
-}
-function isOptionalNullableTimestamp(value) {
-  if (value === void 0) return true;
-  if (value === null) return true;
-  return isTimestamp(value);
-}
-function isStringArray(value) {
-  if (!Array.isArray(value)) return false;
-  return value.every(isString);
-}
-var ProjectVersionBumpKind, ProjectRecordKind;
-var init_project_version_types = __esm({
-  "../src/models/project/project-version-types.ts"() {
-    "use strict";
-    init_core();
-    ProjectVersionBumpKind = {
-      Patch: "patch",
-      Minor: "minor",
-      Major: "major"
-    };
-    ProjectRecordKind = {
-      Project: "project",
-      Member: "member",
-      Value: "value",
-      Class: "class",
-      Enum: "enum",
-      Interface: "interface",
-      Dialogue: "dialogue",
-      DialogueNode: "dialogue-node",
-      DialogueGroup: "dialogue-group",
-      PriorityGroup: "priority-group",
-      ProjectFile: "project-file",
-      UnityTextureTemplate: "unity-texture-template",
-      UnityAudioClipTemplate: "unity-audio-clip-template",
-      LocalizationConfig: "localization-config",
-      LocalizationStatus: "localization-status",
-      LocalizedText: "localized-text",
-      Migration: "migration"
-    };
-  }
-});
-
 // ../convex/_generated/api.js
 var api_exports = {};
 __export(api_exports, {
@@ -29319,6 +30603,144 @@ var init_project_migration_types = __esm({
   }
 });
 
+// ../src/models/project/internal-record-relations.ts
+function worldClassContract(relationKind, sourceWorldKind, targetWorldKind, targetClassPolicy, merge, allowAbstractTarget) {
+  return {
+    relationKind,
+    endpointPairs: [{ sourceRecordKind: "class", targetRecordKind: "class" }],
+    sourceClassPolicy: "include-descendants",
+    targetClassPolicy,
+    merge,
+    allowCycles: false,
+    sourceWorldKind,
+    targetWorldKind,
+    allowAbstractTarget
+  };
+}
+var InternalRecordRelationKind, INTERNAL_RECORD_RELATION_KIND_CONTRACTS;
+var init_internal_record_relations = __esm({
+  "../src/models/project/internal-record-relations.ts"() {
+    "use strict";
+    init_classes();
+    init_core();
+    init_project_version_types();
+    InternalRecordRelationKind = {
+      WorldGridTileImport: "world.grid.tile-import",
+      WorldGridObjectImport: "world.grid.object-import",
+      WorldGridTileLayer: "world.grid.tile-layer",
+      WorldGridObjectLayer: "world.grid.object-layer",
+      WorldTileCompatibleLayer: "world.tile.compatible-layer",
+      WorldTileDefaultLayer: "world.tile.default-layer",
+      WorldObjectCompatibleLayer: "world.object.compatible-layer",
+      WorldObjectDefaultLayer: "world.object.default-layer",
+      WorldTileLayerLinkTarget: "world.tile-layer-link.target",
+      WorldObjectLayerLinkTarget: "world.object-layer-link.target",
+      WorldSmartTileNeighborTile: "world.smart-tile-neighbor.tile"
+    };
+    INTERNAL_RECORD_RELATION_KIND_CONTRACTS = [
+      worldClassContract(
+        InternalRecordRelationKind.WorldGridTileImport,
+        NeoWorldSystemClassKind.TileGrid,
+        NeoWorldSystemClassKind.Tile,
+        "include-descendants",
+        "union",
+        true
+      ),
+      worldClassContract(
+        InternalRecordRelationKind.WorldGridObjectImport,
+        NeoWorldSystemClassKind.TileGrid,
+        NeoWorldSystemClassKind.Object,
+        "include-descendants",
+        "union",
+        true
+      ),
+      worldClassContract(
+        InternalRecordRelationKind.WorldGridTileLayer,
+        NeoWorldSystemClassKind.TileGrid,
+        NeoWorldSystemClassKind.TileLayer,
+        "exact",
+        "ordered-union",
+        false
+      ),
+      worldClassContract(
+        InternalRecordRelationKind.WorldGridObjectLayer,
+        NeoWorldSystemClassKind.TileGrid,
+        NeoWorldSystemClassKind.ObjectLayer,
+        "exact",
+        "ordered-union",
+        false
+      ),
+      worldClassContract(
+        InternalRecordRelationKind.WorldTileCompatibleLayer,
+        NeoWorldSystemClassKind.Tile,
+        NeoWorldSystemClassKind.TileLayer,
+        "include-descendants",
+        "union",
+        true
+      ),
+      worldClassContract(
+        InternalRecordRelationKind.WorldTileDefaultLayer,
+        NeoWorldSystemClassKind.Tile,
+        NeoWorldSystemClassKind.TileLayer,
+        "exact",
+        "nearest-single",
+        false
+      ),
+      worldClassContract(
+        InternalRecordRelationKind.WorldObjectCompatibleLayer,
+        NeoWorldSystemClassKind.Object,
+        NeoWorldSystemClassKind.ObjectLayer,
+        "include-descendants",
+        "union",
+        true
+      ),
+      worldClassContract(
+        InternalRecordRelationKind.WorldObjectDefaultLayer,
+        NeoWorldSystemClassKind.Object,
+        NeoWorldSystemClassKind.ObjectLayer,
+        "exact",
+        "nearest-single",
+        false
+      ),
+      worldClassContract(
+        InternalRecordRelationKind.WorldTileLayerLinkTarget,
+        NeoWorldSystemClassKind.TileLayerLink,
+        NeoWorldSystemClassKind.TileLayer,
+        "exact",
+        "nearest-single",
+        false
+      ),
+      worldClassContract(
+        InternalRecordRelationKind.WorldObjectLayerLinkTarget,
+        NeoWorldSystemClassKind.ObjectLayerLink,
+        NeoWorldSystemClassKind.ObjectLayer,
+        "exact",
+        "nearest-single",
+        false
+      ),
+      {
+        relationKind: InternalRecordRelationKind.WorldSmartTileNeighborTile,
+        endpointPairs: [{ sourceRecordKind: "value", targetRecordKind: "class" }],
+        sourceClassPolicy: "exact",
+        targetClassPolicy: "exact",
+        merge: "nearest-single",
+        allowCycles: false,
+        sourceWorldKind: NeoWorldSystemClassKind.SmartTileNeighbor,
+        targetWorldKind: NeoWorldSystemClassKind.Tile,
+        allowAbstractTarget: true
+      }
+    ];
+  }
+});
+
+// ../src/models/project/internal-record-relation-head-projection.ts
+var init_internal_record_relation_head_projection = __esm({
+  "../src/models/project/internal-record-relation-head-projection.ts"() {
+    "use strict";
+    init_project_version_types();
+  }
+});
+
 // ../src/models/project/index.ts
 var init_project2 = __esm({
   "../src/models/project/index.ts"() {
@@ -29328,6 +30750,9 @@ var init_project2 = __esm({
     init_project_root_members();
     init_project_version_types();
     init_project_migration_types();
+    init_internal_record_relations();
+    init_internal_record_relation_head_projection();
+    init_initial_class_internal_record_relation();
   }
 });
 
@@ -30223,6 +31648,7 @@ var init_projectRecordBuckets = __esm({
       member: "members",
       value: "values",
       class: "classes",
+      "internal-record-relation": "internalRecordRelations",
       enum: "enums",
       interface: "interfaces",
       dialogue: "dialogueRecords",
@@ -30618,6 +32044,7 @@ var init_project_record_migrations = __esm({
       [ProjectRecordKind.Member]: 4,
       [ProjectRecordKind.Value]: 1,
       [ProjectRecordKind.Class]: 1,
+      [ProjectRecordKind.InternalRecordRelation]: 1,
       [ProjectRecordKind.Enum]: 2,
       [ProjectRecordKind.Interface]: 1,
       [ProjectRecordKind.Dialogue]: 4,
@@ -30641,6 +32068,7 @@ var init_project_record_migrations = __esm({
       },
       [ProjectRecordKind.Value]: {},
       [ProjectRecordKind.Class]: {},
+      [ProjectRecordKind.InternalRecordRelation]: {},
       [ProjectRecordKind.Enum]: {
         1: migrateEnumOptionKeyOrder
       },
@@ -31014,6 +32442,7 @@ function assembleProjectDocumentRaw(args) {
     project: null,
     members: [],
     classes: [],
+    internalRecordRelations: [],
     values: [],
     enums: [],
     interfaces: [],
@@ -31074,6 +32503,7 @@ function assembleProjectDocumentRaw(args) {
     project: buckets.project,
     members: buckets.members,
     classes: buckets.classes,
+    internalRecordRelations: buckets.internalRecordRelations,
     values: buckets.values,
     enums: buckets.enums,
     interfaces: buckets.interfaces,
@@ -31121,10 +32551,15 @@ function appendBucketRecord(buckets, recordKind, data) {
   }
   buckets[bucket].push(data);
 }
-function readProjectDocument(value) {
+function readProjectDocument(value, options = {}) {
   if (!isObject2(value)) {
     throw new Error("Convex project document query returned a non-object.");
   }
+  const localizationConfig = options.localizationConfig === "nullable" ? readOptionalNullableField(
+    value,
+    "localizationConfig",
+    isProjectLocalizationConfig
+  ) : readField(value, "localizationConfig", isProjectLocalizationConfig);
   return {
     version: readField(value, "version", isProjectVersion),
     versions: readArrayField(value, "versions", isProjectVersion),
@@ -31149,6 +32584,11 @@ function readProjectDocument(value) {
       isAnyMember
     ),
     classes: readArrayField(value, "classes", isNeoSchemaClass),
+    internalRecordRelations: readOptionalArrayField(
+      value,
+      "internalRecordRelations",
+      isInternalRecordRelation
+    ),
     values: readArrayField(value, "values", isMemberValue),
     enums: readArrayField(value, "enums", isEnum),
     interfaces: readArrayField(value, "interfaces", isNeoInterface),
@@ -31176,11 +32616,7 @@ function readProjectDocument(value) {
       "audioClipTemplates",
       isUnityAudioClipImportSettingsTemplate
     ),
-    localizationConfig: readField(
-      value,
-      "localizationConfig",
-      isProjectLocalizationConfig
-    ),
+    localizationConfig,
     localizationStatuses: readArrayField(
       value,
       "localizationStatuses",
@@ -31221,6 +32657,14 @@ function readField(source, key, isValid) {
     `Convex project document field "${key}" has an invalid shape.`
   );
 }
+function readOptionalNullableField(source, key, isValid) {
+  const value = source[key];
+  if (value === void 0 || value === null) return null;
+  if (isValid(value)) return value;
+  throw new Error(
+    `Convex project document field "${key}" has an invalid shape.`
+  );
+}
 function readArrayField(source, key, isValid) {
   const value = source[key];
   if (!Array.isArray(value)) {
@@ -31371,6 +32815,12 @@ async function fetchProjectDocument(workspace) {
       entries: readRawArray(raw, "localizationStatuses"),
       guard: isProjectedRecord,
       label: "localization status"
+    },
+    {
+      recordKind: "internal-record-relation",
+      entries: readRawArray(raw, "internalRecordRelations"),
+      guard: isProjectedRecord,
+      label: "internal record relation"
     }
   ];
   const records2 = /* @__PURE__ */ new Map();
@@ -32162,6 +33612,565 @@ var init_init = __esm({
   }
 });
 
+// src/commands/history-selection.ts
+async function resolveHistoryScope(options) {
+  const projectSelector = await readHistorySelector({
+    command: options.command,
+    kind: "project",
+    provided: options.projectSelector
+  });
+  const project = await options.resolveProject(projectSelector);
+  console.log(`${sym.info} Project: ${project.name} (${project.id})`);
+  if (!options.requiresVersion) {
+    return { project, version: null };
+  }
+  const versionSelector = await readHistorySelector({
+    command: options.command,
+    kind: "version",
+    provided: options.versionSelector
+  });
+  const version = await options.resolveVersion(project.id, versionSelector);
+  console.log(`${sym.info} Version: ${version.name} (${version.id})`);
+  return { project, version };
+}
+async function readHistorySelector(args) {
+  if (args.provided !== null) return normalizeHistorySelector(args.provided);
+  const flag = args.kind === "project" ? "--project" : "--version";
+  if (!isInteractive()) {
+    throw new Error(
+      `neo history ${args.command} requires ${flag} <id|@latest|@current> outside an interactive terminal.`
+    );
+  }
+  const label = args.kind === "project" ? "Project" : "Version";
+  const value = await promptInput({
+    message: `${label} ID (@latest or @current; Enter for latest)`,
+    nonInteractiveHint: `Pass ${flag} <id|@latest|@current>.`
+  });
+  return normalizeHistorySelector(value);
+}
+function normalizeHistorySelector(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed === "@latest" || trimmed === "@current") {
+    return "@latest";
+  }
+  if (trimmed.startsWith("@")) {
+    throw new Error(
+      `Unknown history selector "${trimmed}". Use a stable ID, @latest, or @current.`
+    );
+  }
+  return trimmed;
+}
+var init_history_selection = __esm({
+  "src/commands/history-selection.ts"() {
+    "use strict";
+    init_ui();
+  }
+});
+
+// src/commands/history-inspect.ts
+function inspectHistoryDataset(dataset) {
+  const brokenReferences = [];
+  const projectSnapshots = new Map(
+    dataset["project-snapshots"].map((snapshot) => [snapshot.id, snapshot])
+  );
+  const projectTransactions = new Set(
+    dataset["project-transactions"].map((transaction) => transaction.id)
+  );
+  const reachableProjectSnapshots = walkAncestors({
+    roots: dataset["project-heads"].map((head) => ({
+      id: head.snapshotId,
+      source: `project head "${head.id}"`
+    })),
+    rows: projectSnapshots,
+    baseId: (snapshot) => snapshot.baseSnapshotId,
+    kind: "project snapshot",
+    brokenReferences
+  });
+  for (const snapshot of projectSnapshots.values()) {
+    if (!projectTransactions.has(snapshot.transactionId)) {
+      brokenReferences.push(
+        `Project snapshot "${snapshot.id}" references missing transaction "${snapshot.transactionId}".`
+      );
+    }
+  }
+  const reachableProjectTransactions = new Set(
+    [...reachableProjectSnapshots].map((id) => projectSnapshots.get(id)?.transactionId).filter(
+      (id) => id !== void 0 && projectTransactions.has(id)
+    )
+  );
+  const wikiSnapshots = new Map(
+    dataset["wiki-snapshots"].map((snapshot) => [snapshot.id, snapshot])
+  );
+  const wikiTransactions = new Set(
+    dataset["wiki-transactions"].map((transaction) => transaction.id)
+  );
+  const wikiDocuments = new Map(
+    dataset["wiki-documents"].map((document) => [document.id, document])
+  );
+  const reachableWikiSnapshots = walkAncestors({
+    roots: dataset["wiki-heads"].map((head) => ({
+      id: head.snapshotId,
+      source: `wiki head "${head.id}"`
+    })),
+    rows: wikiSnapshots,
+    baseId: (snapshot) => snapshot.baseSnapshotId,
+    kind: "wiki snapshot",
+    brokenReferences
+  });
+  const reachableWikiDocuments = walkAncestors({
+    roots: [...reachableWikiSnapshots].flatMap((snapshotId) => {
+      const snapshot = wikiSnapshots.get(snapshotId);
+      return snapshot === void 0 ? [] : [
+        {
+          id: snapshot.yjsDocumentId,
+          source: `wiki snapshot "${snapshot.id}"`
+        }
+      ];
+    }),
+    rows: wikiDocuments,
+    baseId: (document) => document.forkedFromDocumentId,
+    kind: "wiki document",
+    brokenReferences
+  });
+  const reachableWikiTransactions = /* @__PURE__ */ new Set();
+  for (const snapshotId of reachableWikiSnapshots) {
+    const snapshot = wikiSnapshots.get(snapshotId);
+    if (snapshot !== void 0 && wikiTransactions.has(snapshot.transactionId)) {
+      reachableWikiTransactions.add(snapshot.transactionId);
+    }
+  }
+  for (const snapshot of wikiSnapshots.values()) {
+    if (!wikiTransactions.has(snapshot.transactionId)) {
+      brokenReferences.push(
+        `Wiki snapshot "${snapshot.id}" references missing transaction "${snapshot.transactionId}".`
+      );
+    }
+    if (!wikiDocuments.has(snapshot.yjsDocumentId)) {
+      brokenReferences.push(
+        `Wiki snapshot "${snapshot.id}" references missing document "${snapshot.yjsDocumentId}".`
+      );
+    }
+  }
+  let unreachableWikiRevisions = 0;
+  for (const revision of dataset["wiki-revisions"]) {
+    const documentExists = wikiDocuments.has(revision.yjsDocumentId);
+    const transactionExists = wikiTransactions.has(revision.transactionId);
+    if (!documentExists) {
+      brokenReferences.push(
+        `Wiki revision "${revision.id}" references missing document "${revision.yjsDocumentId}".`
+      );
+    }
+    if (!transactionExists) {
+      brokenReferences.push(
+        `Wiki revision "${revision.id}" references missing transaction "${revision.transactionId}".`
+      );
+    }
+    if (transactionExists && reachableWikiDocuments.has(revision.yjsDocumentId)) {
+      reachableWikiTransactions.add(revision.transactionId);
+    } else {
+      unreachableWikiRevisions += 1;
+    }
+  }
+  return {
+    versions: {
+      total: dataset.versions.length,
+      archived: dataset.versions.filter((version) => version.archived).length
+    },
+    projectRecords: {
+      heads: dataset["project-heads"].length,
+      snapshots: projectSnapshots.size,
+      transactions: projectTransactions.size,
+      unreachableSnapshots: projectSnapshots.size - reachableProjectSnapshots.size,
+      unreachableTransactions: projectTransactions.size - reachableProjectTransactions.size,
+      duplicateSemanticSnapshots: duplicateCount(
+        dataset["project-snapshots"],
+        (snapshot) => `${snapshot.recordKind}:${snapshot.recordId}:${snapshot.contentHash}`
+      )
+    },
+    wiki: {
+      heads: dataset["wiki-heads"].length,
+      snapshots: wikiSnapshots.size,
+      transactions: wikiTransactions.size,
+      documents: wikiDocuments.size,
+      revisions: dataset["wiki-revisions"].length,
+      unreachableSnapshots: wikiSnapshots.size - reachableWikiSnapshots.size,
+      unreachableTransactions: wikiTransactions.size - reachableWikiTransactions.size,
+      unreachableDocuments: wikiDocuments.size - reachableWikiDocuments.size,
+      unreachableRevisions: unreachableWikiRevisions,
+      duplicateSemanticSnapshots: duplicateCount(
+        dataset["wiki-snapshots"],
+        (snapshot) => `${snapshot.pageId}:${snapshot.contentHash}`
+      ),
+      duplicateSemanticDocuments: duplicateCount(
+        dataset["wiki-documents"],
+        (document) => `${document.pageId}:${document.contentHash}`
+      )
+    },
+    brokenReferences
+  };
+}
+function walkAncestors(args) {
+  const reachable = /* @__PURE__ */ new Set();
+  const stack = [...args.roots];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (reachable.has(current.id)) continue;
+    const row = args.rows.get(current.id);
+    if (row === void 0) {
+      args.brokenReferences.push(
+        `${current.source} references missing ${args.kind} "${current.id}".`
+      );
+      continue;
+    }
+    reachable.add(current.id);
+    const baseId = args.baseId(row);
+    if (baseId !== null) {
+      stack.push({
+        id: baseId,
+        source: `${args.kind} "${current.id}"`
+      });
+    }
+  }
+  return reachable;
+}
+function duplicateCount(rows, key) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const value = key(row);
+    counts.set(value, (counts.get(value) ?? 0) + 1);
+  }
+  let duplicates = 0;
+  for (const count of counts.values()) {
+    if (count > 1) duplicates += count - 1;
+  }
+  return duplicates;
+}
+var HISTORY_INSPECT_PHASES;
+var init_history_inspect = __esm({
+  "src/commands/history-inspect.ts"() {
+    "use strict";
+    HISTORY_INSPECT_PHASES = [
+      "versions",
+      "project-heads",
+      "project-snapshots",
+      "project-transactions",
+      "wiki-heads",
+      "wiki-snapshots",
+      "wiki-transactions",
+      "wiki-documents",
+      "wiki-revisions"
+    ];
+  }
+});
+
+// src/commands/history.ts
+var history_exports = {};
+__export(history_exports, {
+  resolveHistoryScopeFromServer: () => resolveHistoryScopeFromServer,
+  runHistory: () => runHistory
+});
+async function resolveHistoryScopeFromServer(options) {
+  const convex = await createConvexClientForApi(options.apiBaseUrl);
+  return await resolveHistoryScope({
+    command: options.command,
+    projectSelector: options.projectSelector,
+    versionSelector: options.versionSelector,
+    requiresVersion: options.command === "log" || options.command === "flatten",
+    resolveProject: async (selector) => await convex.query(api2.projectHistory.resolveProjectSelector, {
+      selector
+    }),
+    resolveVersion: async (projectId, selector) => await convex.query(api2.projectHistory.resolveVersionSelector, {
+      projectId,
+      selector
+    })
+  });
+}
+async function runHistory(options) {
+  assertHistoryOptions(options);
+  const convex = await createConvexClientForApi(options.apiBaseUrl);
+  if (options.command === "inspect") {
+    const scope = await resolveScopeWithClient(convex, options);
+    await printHistoryInspection(convex, scope.project.id);
+    return;
+  }
+  if (options.command === "log") {
+    const scope = await resolveScopeWithClient(convex, options);
+    await printVersionLog(convex, scope);
+    return;
+  }
+  if (options.command === "flatten") {
+    const scope = await resolveScopeWithClient(convex, options);
+    if (scope.version === null) {
+      throw new Error("Flatten requires a resolved version.");
+    }
+    const started = await convex.mutation(api2.projectHistory.planFlatten, {
+      projectId: scope.project.id,
+      versionId: scope.version.id
+    });
+    console.log(`${sym.info} Plan: ${started.planId}`);
+    console.log(`${sym.info} Planning run: ${started.runId}`);
+    const plan = await waitForPlan(convex, started.planId);
+    printPlan(plan);
+    return;
+  }
+  if (options.command === "prune") {
+    const scope = await resolveScopeWithClient(convex, options);
+    const started = await convex.mutation(api2.projectHistory.planPrune, {
+      projectId: scope.project.id
+    });
+    console.log(`${sym.info} Plan: ${started.planId}`);
+    console.log(`${sym.info} Planning run: ${started.runId}`);
+    const plan = await waitForPlan(convex, started.planId);
+    printPlan(plan);
+    return;
+  }
+  if (options.command === "apply") {
+    const plan = await convex.query(api2.projectHistory.getPlan, {
+      planId: options.planId
+    });
+    const expectedScope = plan.versionId === null ? plan.projectId : `${plan.projectId}/${plan.versionId}`;
+    let confirmScope = options.confirmScope;
+    if (plan.productionConfirmationRequired && confirmScope === null) {
+      if (!isInteractive()) {
+        throw new Error(
+          `Production history apply requires --confirm-scope ${expectedScope}.`
+        );
+      }
+      confirmScope = await promptInput({
+        message: `Type ${expectedScope} to confirm production history rewrite`,
+        nonInteractiveHint: `Pass --confirm-scope ${expectedScope}.`,
+        validate: (value) => value === expectedScope ? true : `Confirmation must exactly match ${expectedScope}.`
+      });
+    }
+    const started = await convex.mutation(api2.projectHistory.applyPlan, {
+      planId: plan.id,
+      confirmScope
+    });
+    console.log(`${sym.info} Run: ${started.runId}`);
+    console.log(`${sym.info} State: ${started.state}`);
+    return;
+  }
+  if (options.command === "status") {
+    const status = await convex.query(api2.projectHistory.getRunStatus, {
+      runId: options.runId
+    });
+    printRunStatus(status);
+    return;
+  }
+  if (options.command === "resume") {
+    const resumed = await convex.mutation(api2.projectHistory.resumeRun, {
+      runId: options.runId
+    });
+    console.log(`${sym.info} Run: ${resumed.runId}`);
+    console.log(`${sym.info} State: ${resumed.state}`);
+    return;
+  }
+}
+async function resolveScopeWithClient(convex, options) {
+  if (options.command !== "inspect" && options.command !== "log" && options.command !== "prune" && options.command !== "flatten") {
+    throw new Error(`neo history ${options.command} has immutable scope.`);
+  }
+  return await resolveHistoryScope({
+    command: options.command,
+    projectSelector: options.projectSelector,
+    versionSelector: options.versionSelector,
+    requiresVersion: options.command === "log" || options.command === "flatten",
+    resolveProject: async (selector) => await convex.query(api2.projectHistory.resolveProjectSelector, {
+      selector
+    }),
+    resolveVersion: async (projectId, selector) => await convex.query(api2.projectHistory.resolveVersionSelector, {
+      projectId,
+      selector
+    })
+  });
+}
+async function waitForPlan(convex, planId) {
+  let lastState = null;
+  while (true) {
+    const plan = await convex.query(api2.projectHistory.getPlan, { planId });
+    if (plan.state !== lastState) {
+      console.log(`${sym.info} Plan state: ${plan.state}`);
+      lastState = plan.state;
+    }
+    if (plan.state === "sealed") return plan;
+    if (plan.state === "failed") {
+      throw new Error(
+        `History plan "${plan.id}" failed: ${plan.error ?? "unknown error"}`
+      );
+    }
+    await new Promise((resolve6) => setTimeout(resolve6, 500));
+  }
+}
+async function printVersionLog(convex, scope) {
+  if (scope.version === null) {
+    throw new Error("History log requires a resolved version.");
+  }
+  let cursor = null;
+  let count = 0;
+  while (true) {
+    const page = await convex.query(
+      api2.projectVersionHistory.getChangelog,
+      {
+        projectId: scope.project.id,
+        versionId: scope.version.id,
+        paginationOpts: { cursor, numItems: 50 }
+      }
+    );
+    if (page === null) {
+      throw new Error(
+        `Version "${scope.version.id}" no longer exists in project "${scope.project.id}".`
+      );
+    }
+    for (const transaction of page.transactions) {
+      count += 1;
+      console.log(
+        `${transaction.id}  ${new Date(transaction.createdAt).toISOString()}  ${transaction.operation}  ${transaction.summary ?? ""}`.trimEnd()
+      );
+    }
+    if (page.isDone) break;
+    cursor = page.continueCursor;
+  }
+  if (count === 0) console.log("No retained history entries.");
+}
+async function printHistoryInspection(convex, projectId) {
+  const dataset = {
+    versions: [],
+    "project-heads": [],
+    "project-snapshots": [],
+    "project-transactions": [],
+    "wiki-heads": [],
+    "wiki-snapshots": [],
+    "wiki-transactions": [],
+    "wiki-documents": [],
+    "wiki-revisions": []
+  };
+  for (const phase of HISTORY_INSPECT_PHASES) {
+    let cursor = null;
+    while (true) {
+      const page = await convex.query(api2.projectHistory.inspectPage, {
+        projectId,
+        phase,
+        paginationOpts: { cursor, numItems: 100 }
+      });
+      if (page.phase !== phase) {
+        throw new Error(
+          `History inspection requested phase "${phase}" but received "${page.phase}".`
+        );
+      }
+      dataset[phase].push(...page.rows);
+      if (page.isDone) break;
+      cursor = page.continueCursor;
+    }
+  }
+  const report = inspectHistoryDataset(dataset);
+  console.log(
+    `${sym.info} Versions: ${report.versions.total} total, ${report.versions.archived} archived`
+  );
+  console.log(
+    `${sym.info} Project records: ${report.projectRecords.heads} heads, ${report.projectRecords.snapshots} snapshots, ${report.projectRecords.transactions} transactions`
+  );
+  console.log(
+    `${sym.info} Project cleanup candidates: ${report.projectRecords.unreachableSnapshots} unreachable snapshots, ${report.projectRecords.unreachableTransactions} unreachable transactions, ${report.projectRecords.duplicateSemanticSnapshots} duplicate semantic snapshots`
+  );
+  console.log(
+    `${sym.info} Wiki: ${report.wiki.heads} heads, ${report.wiki.snapshots} snapshots, ${report.wiki.transactions} transactions, ${report.wiki.documents} documents, ${report.wiki.revisions} revisions`
+  );
+  console.log(
+    `${sym.info} Wiki cleanup candidates: ${report.wiki.unreachableSnapshots} unreachable snapshots, ${report.wiki.unreachableTransactions} unreachable transactions, ${report.wiki.unreachableDocuments} unreachable documents, ${report.wiki.unreachableRevisions} unreachable revisions`
+  );
+  console.log(
+    `${sym.info} Wiki duplicates: ${report.wiki.duplicateSemanticSnapshots} semantic snapshots, ${report.wiki.duplicateSemanticDocuments} semantic documents`
+  );
+  console.log(
+    `${sym.info} Broken references: ${report.brokenReferences.length}`
+  );
+  for (const broken of report.brokenReferences.slice(0, 20)) {
+    console.log(`  ${broken}`);
+  }
+  if (report.brokenReferences.length > 20) {
+    console.log(
+      `  ... ${report.brokenReferences.length - 20} additional broken references`
+    );
+  }
+}
+function printPlan(plan) {
+  const scope = plan.versionId === null ? plan.projectId : `${plan.projectId}/${plan.versionId}`;
+  console.log(`${sym.info} Scope: ${scope}`);
+  console.log(`${sym.info} Mode: ${plan.mode}`);
+  console.log(
+    `${sym.info} Project records: ${plan.counts.removableSnapshots} snapshots and ${plan.counts.removableTransactions} transactions removable`
+  );
+  if (plan.wikiCounts !== null) {
+    console.log(
+      `${sym.info} Wiki: ${plan.wikiCounts.removableSnapshots} snapshots, ${plan.wikiCounts.removableTransactions} transactions, and ${plan.wikiCounts.removableDocuments} documents removable`
+    );
+  }
+  console.log(
+    `${sym.info} Current baseline: project=${String(plan.compactionCurrent)} wiki=${String(plan.wikiCompactionCurrent)}`
+  );
+  console.log(`Apply with: neo history apply --plan ${plan.id}`);
+}
+function printRunStatus(status) {
+  const scope = status.versionId === null ? status.projectId : `${status.projectId}/${status.versionId}`;
+  console.log(`${sym.info} Run: ${status.runId}`);
+  console.log(`${sym.info} Plan: ${status.planId}`);
+  console.log(`${sym.info} Scope: ${scope}`);
+  console.log(`${sym.info} State: ${status.state} (${status.phase})`);
+  console.log(
+    `${sym.info} Correctness verification: ${status.verified ? "verified" : "pending"}`
+  );
+  if (status.lastError !== null) {
+    console.log(`${sym.info} Error: ${status.lastError}`);
+  }
+}
+function assertHistoryOptions(options) {
+  const planningOrRead = options.command === "inspect" || options.command === "log" || options.command === "prune" || options.command === "flatten";
+  if (planningOrRead) {
+    if (options.planId !== null || options.runId !== null) {
+      throw new Error(
+        `neo history ${options.command} does not accept --plan or --run.`
+      );
+    }
+    if (options.confirmScope !== null) {
+      throw new Error(
+        `neo history ${options.command} does not accept --confirm-scope.`
+      );
+    }
+    if ((options.command === "inspect" || options.command === "prune") && options.versionSelector !== null) {
+      throw new Error(
+        `neo history ${options.command} is project-scoped and does not accept --version.`
+      );
+    }
+    return;
+  }
+  if (options.command === "apply") {
+    if (options.planId === null) {
+      throw new Error("neo history apply requires --plan <plan-id>.");
+    }
+    if (options.runId !== null) {
+      throw new Error("neo history apply does not accept --run.");
+    }
+    return;
+  }
+  if (options.runId === null) {
+    throw new Error(`neo history ${options.command} requires --run <run-id>.`);
+  }
+  if (options.planId !== null || options.confirmScope !== null) {
+    throw new Error(
+      `neo history ${options.command} does not accept --plan or --confirm-scope.`
+    );
+  }
+}
+var init_history = __esm({
+  "src/commands/history.ts"() {
+    "use strict";
+    init_convex();
+    init_ui();
+    init_history_selection();
+    init_history_inspect();
+  }
+});
+
 // src/commands/doctor.ts
 var doctor_exports = {};
 __export(doctor_exports, {
@@ -32464,6 +34473,9 @@ var init_project_version_intents = __esm({
       ClassUpdate: "class.update",
       ClassDelete: "class.delete",
       ClassAddSchemaEntry: "class.add-schema-entry",
+      InternalRecordRelationCreate: "internal-record-relation.create",
+      InternalRecordRelationUpdate: "internal-record-relation.update",
+      InternalRecordRelationDelete: "internal-record-relation.delete",
       EnumCreate: "enum.create",
       EnumUpdate: "enum.update",
       EnumDelete: "enum.delete",
@@ -44574,16 +46586,19 @@ var KNOWN_FLAGS = /* @__PURE__ */ new Set([
   "out",
   "profile",
   "project",
+  "plan",
   "push",
   "replace",
   "reset",
   "returns",
+  "run",
   "save",
   "save-project",
   "server",
   "skip-invalid",
   "status",
   "summary",
+  "confirm-scope",
   "target",
   "template",
   "theirs",
@@ -44681,6 +46696,7 @@ ${h("Branches & releases")}
   merge     ${d("[source] [--dry-run] [--migrate] [--mine|--theirs <kind>:<id>,...]")}
   release   ${d("cut [--bump ...] | publish <ref> | archive <ref> | restore <ref>")}
   channel   ${d("list | create | edit | delete")}
+  history   ${d("inspect | log | prune | flatten | apply | status | resume")}
 
 ${h("Content & scripts")}
   values    ${d("list | get | set | create | delete | ...")}          loc       ${d("locales | list | set | archive | restore | ...")}
@@ -44748,6 +46764,46 @@ ${h("Usage")}
 Neo checks Unity 6000's existing runtime first, then a compatible system
 dotnet. It never downloads or installs a runtime. Set NEO_DOTNET_HOST to use
 an explicit host.
+`;
+  }
+  if (command === "history") {
+    return `${h("neo history")} \u2014 inspect and deliberately rewrite project history
+
+${h("Usage")}
+  neo history inspect ${d("[--project <id|@latest|@current>]")}
+  neo history log ${d("[--project <id|@latest|@current>] [--version <id|@latest|@current>]")}
+  neo history prune ${d("[--project <id|@latest|@current>]")}
+  neo history flatten ${d("[--project <id|@latest|@current>] [--version <id|@latest|@current>]")}
+  neo history apply --plan <plan-id> ${d("[--confirm-scope <project-id>[/<version-id>]]")}
+  neo history status --run <run-id>
+  neo history resume --run <run-id>
+
+${h("Commands")}
+  inspect  ${d("Read-only project history audit; creates no plan.")}
+  log      ${d("Show retained history for exactly one version.")}
+  prune    ${d("Create an immutable plan for rows proven unreachable; writes nothing.")}
+  flatten  ${d("Create an immutable one-version baseline plan; writes nothing.")}
+  apply    ${d("Begin the destructive execution of an immutable plan.")}
+  status   ${d("Report execution phase, result, and correctness verification.")}
+  resume   ${d("Restart a stopped retryable execution.")}
+
+${h("Arguments")}
+  --project <id|@latest|@current>
+            ${d("Stable project ID, or latest authorized project. Blank interactive input uses latest.")}
+  --version <id|@latest|@current>
+            ${d("Stable version ID in the resolved project, or latest unarchived version. Blank interactive input uses latest.")}
+  --plan <id>
+            ${d("Immutable plan returned by prune or flatten.")}
+  --run <id>
+            ${d("Execution returned by apply.")}
+  --confirm-scope <project>[/<version>]
+            ${d("Exact resolved production scope acknowledgement.")}
+
+${h("Selection")}
+  ${d("Project resolution always happens before version resolution. @latest and @current are aliases. apply, status, and resume use immutable plan/run scope and do not accept project or version selectors.")}
+
+There is no --dry-run: prune and flatten are always non-mutating until apply.
+There is no --keep-current: preserving current semantic state defines flatten.
 `;
   }
   return usage();
@@ -44788,6 +46844,30 @@ async function main() {
         });
       }
       return;
+    case "history": {
+      const sub = args.positional[0];
+      if (sub !== "inspect" && sub !== "log" && sub !== "prune" && sub !== "flatten" && sub !== "apply" && sub !== "status" && sub !== "resume") {
+        throw new Error(
+          "neo history requires a subcommand: inspect | log | prune | flatten | apply | status | resume."
+        );
+      }
+      if ((sub === "apply" || sub === "status" || sub === "resume") && (stringFlag(args, "project") !== null || stringFlag(args, "version") !== null)) {
+        throw new Error(
+          `neo history ${sub} derives its immutable scope from the plan or run and does not accept --project or --version.`
+        );
+      }
+      const { runHistory: runHistory2 } = await Promise.resolve().then(() => (init_history(), history_exports));
+      await runHistory2({
+        apiBaseUrl,
+        command: sub,
+        projectSelector: stringFlag(args, "project"),
+        versionSelector: stringFlag(args, "version"),
+        planId: stringFlag(args, "plan"),
+        runId: stringFlag(args, "run"),
+        confirmScope: stringFlag(args, "confirm-scope")
+      });
+      return;
+    }
     case "pull": {
       const workspace = loadWorkspaceForCommand(args);
       const { runPull: runPull2 } = await Promise.resolve().then(() => (init_pull(), pull_exports));