@neocompose/cli 0.72.0 → 0.72.1

package/dist/test-worker.mjs

@@ -5059,6 +5059,7 @@ var ProjectSchemaIndex = class {
    */
   resolvedMembers = /* @__PURE__ */ new WeakMap();
   ancestryByClassId = /* @__PURE__ */ new Map();
+  effectivePlacementsByClassId = /* @__PURE__ */ new Map();
   ancestorIdsByClassId = /* @__PURE__ */ new Map();
   get classes() {
     return this.source.classes;
@@ -5114,12 +5115,19 @@ var ProjectSchemaIndex = class {
     return chain;
   }
   effectiveSchemaPlacement(classId, schemaKey) {
-    for (const ownerClass of this.inheritanceChain(classId)) {
-      if (typeof ownerClass.schema[schemaKey] === "string") {
-        return { ownerClass, schemaKey };
+    let placements = this.effectivePlacementsByClassId.get(classId);
+    if (placements === void 0) {
+      const flattened = /* @__PURE__ */ new Map();
+      for (const ownerClass of this.inheritanceChain(classId)) {
+        for (const key of Object.keys(ownerClass.schema)) {
+          if (!flattened.has(key) && typeof ownerClass.schema[key] === "string")
+            flattened.set(key, { ownerClass, schemaKey: key });
+        }
       }
+      this.effectivePlacementsByClassId.set(classId, flattened);
+      placements = flattened;
     }
-    return null;
+    return placements.get(schemaKey) ?? null;
   }
   effectiveMemberId(classId, schemaKey) {
     const placement = this.effectiveSchemaPlacement(classId, schemaKey);
@@ -5223,33 +5231,12 @@ function classIndexFor(classes) {
 function memberIndexFor(members) {
   return projectSchemaIndexFor({ classes: NO_CLASSES, members }).membersById;
 }
-function createMergeMemo() {
-  const byClasses = /* @__PURE__ */ new WeakMap();
-  return (classId, classIndex, memberIndex, compute) => {
-    let byMembers = byClasses.get(classIndex);
-    if (byMembers === void 0) {
-      byMembers = /* @__PURE__ */ new WeakMap();
-      byClasses.set(classIndex, byMembers);
-    }
-    let byClassId = byMembers.get(memberIndex);
-    if (byClassId === void 0) {
-      byClassId = /* @__PURE__ */ new Map();
-      byMembers.set(memberIndex, byClassId);
-    }
-    const cached = byClassId.get(classId);
-    if (cached !== void 0) return [...cached];
-    const computed = compute();
-    byClassId.set(classId, computed);
-    return [...computed];
-  };
-}
-var instanceSurfaceMemo = createMergeMemo();
-var storedInstanceMemo = createMergeMemo();
-var readOnlyMemberMemo = createMergeMemo();
-var staticMemberMemo = createMergeMemo();
 function resolveInheritanceChain(classId, classes, draft) {
   return [...indexClasses(classes).inheritanceChain(classId, draft)];
 }
+function resolveInheritanceChainFromIndex(classId, classIndex, draft) {
+  return resolveChainFromIndex(classId, classIndex, draft);
+}
 function resolveChainFromIndex(classId, index, draft) {
   const chain = [];
   const visited = /* @__PURE__ */ new Set();
@@ -5303,50 +5290,70 @@ function mergeSchemas(chain) {
   }
   return merged;
 }
-function mergeInstanceSurfaceSchema(classId, classes, members) {
-  return instanceSurfaceFromIndex(classId, indexSchema(classes, members));
-}
-function mergeInstanceSurfaceSchemaFromIndexes(classId, classIndex, memberIndex) {
-  return instanceSurfaceFromIndexes(classId, classIndex, memberIndex);
+var resolvedClassSchemas = /* @__PURE__ */ new WeakMap();
+function resolvedClassSchemaFromIndexes(classId, classIndex, memberIndex) {
+  let byMembers = resolvedClassSchemas.get(classIndex);
+  if (byMembers === void 0) {
+    byMembers = /* @__PURE__ */ new WeakMap();
+    resolvedClassSchemas.set(classIndex, byMembers);
+  }
+  let byClass = byMembers.get(memberIndex);
+  if (byClass === void 0) {
+    byClass = /* @__PURE__ */ new Map();
+    byMembers.set(memberIndex, byClass);
+  }
+  const cached = byClass.get(classId);
+  if (cached !== void 0) return cached;
+  const chain = resolveChainFromIndex(classId, classIndex);
+  const surface = [];
+  const stored = [];
+  const readOnly = [];
+  const statics = [];
+  const surfaceByKey = /* @__PURE__ */ new Map();
+  const storedByKey = /* @__PURE__ */ new Map();
+  for (const entry of mergeSchemas(chain)) {
+    const member = memberIndex.get(entry.memberId);
+    if (member !== void 0 && isStaticMember(member)) {
+      statics.push({ ...entry, declaringClassId: entry.ownerClassId });
+      continue;
+    }
+    surface.push(entry);
+    surfaceByKey.set(entry.schemaKey, entry);
+    if (member !== void 0 && isReadOnlyMember(member)) readOnly.push(entry);
+    else {
+      stored.push(entry);
+      storedByKey.set(entry.schemaKey, entry);
+    }
+  }
+  const node = {
+    surface,
+    stored,
+    readOnly,
+    statics,
+    surfaceByKey,
+    storedByKey
+  };
+  byClass.set(classId, node);
+  return node;
 }
-function instanceSurfaceFromIndex(classId, index) {
-  return instanceSurfaceFromIndexes(
+function resolvedClassSchema(classId, classes, members) {
+  const index = indexSchema(classes, members);
+  return resolvedClassSchemaFromIndexes(
     classId,
     index.classesById,
     index.membersById
   );
 }
-function instanceSurfaceFromIndexes(classId, classIndex, memberIndex) {
-  return instanceSurfaceMemo(classId, classIndex, memberIndex, () => {
-    const instanceEntries = [];
-    for (const entry of mergeSchemas(
-      resolveChainFromIndex(classId, classIndex)
-    )) {
-      const member = memberIndex.get(entry.memberId);
-      if (member === void 0 || !isStaticMember(member)) {
-        instanceEntries.push(entry);
-      }
-    }
-    return instanceEntries;
-  });
+function mergeInstanceSurfaceSchema(classId, classes, members) {
+  return [...resolvedClassSchema(classId, classes, members).surface];
+}
+function mergeInstanceSurfaceSchemaFromIndexes(classId, classIndex, memberIndex) {
+  return [
+    ...resolvedClassSchemaFromIndexes(classId, classIndex, memberIndex).surface
+  ];
 }
 function mergeStoredInstanceSchema(classId, classes, members) {
-  const index = indexSchema(classes, members);
-  return storedInstanceMemo(
-    classId,
-    index.classesById,
-    index.membersById,
-    () => {
-      const storedEntries = [];
-      for (const entry of instanceSurfaceFromIndex(classId, index)) {
-        const member = index.member(entry.memberId);
-        if (member === void 0 || !isReadOnlyMember(member)) {
-          storedEntries.push(entry);
-        }
-      }
-      return storedEntries;
-    }
-  );
+  return [...resolvedClassSchema(classId, classes, members).stored];
 }
 function findSchemaPlacement(memberId, classes) {
   return indexClasses(classes).firstSchemaPlacement(memberId);
@@ -5377,6 +5384,9 @@ function resolveMember(member, members) {
   index.resolvedMembers.set(member, resolved);
   return resolved;
 }
+function resolveMemberFromIndex(member, memberIndex) {
+  return resolveMemberWithIndex(member, () => memberIndex);
+}
 function resolveMemberWithIndex(member, memberIndex) {
   const chain = [];
   const visited = /* @__PURE__ */ new Set();
@@ -7488,8 +7498,9 @@ function clonePlain(value, path, visiting) {
       );
     }
     const clone = {};
-    for (const [key, entry] of Object.entries(value)) {
-      const child = clonePlain(entry, `${path}.${key}`, visiting);
+    const record4 = value;
+    for (const key of Object.keys(record4)) {
+      const child = clonePlain(record4[key], `${path}.${key}`, visiting);
       if (key === "__proto__") setOwnField(clone, key, child);
       else clone[key] = child;
     }
@@ -7534,15 +7545,27 @@ var WORLD_SYSTEM_SCHEMA_FIELD_SITES_BY_MEMBER_ID = new Map(
 );
 
 // ../src/models/classes/generics.ts
+var genericBindingsByClassIndex = /* @__PURE__ */ new WeakMap();
 function resolveGenericEnv(classId, classes, draft) {
-  const chain = resolveInheritanceChain(classId, classes, draft);
-  const env = /* @__PURE__ */ new Map();
-  for (let i = 0; i < chain.length; i++) {
-    for (const param of chain[i].genericParams ?? []) {
-      env.set(param.id, resolveParamAtChainIndex(chain, i, param.id));
+  const index = classIndexFor(classes);
+  let byClass = genericBindingsByClassIndex.get(index);
+  let bindings = draft === void 0 ? byClass?.get(classId) : void 0;
+  if (bindings === void 0) {
+    const chain = resolveInheritanceChainFromIndex(classId, index, draft);
+    const env = /* @__PURE__ */ new Map();
+    for (let i = 0; i < chain.length; i++) {
+      for (const param of chain[i].genericParams ?? []) {
+        env.set(param.id, resolveParamAtChainIndex(chain, i, param.id));
+      }
+    }
+    bindings = [...env];
+    if (draft === void 0) {
+      byClass ??= /* @__PURE__ */ new Map();
+      byClass.set(classId, bindings);
+      genericBindingsByClassIndex.set(index, byClass);
     }
   }
-  return env;
+  return new Map(bindings.map(([id, entry]) => [id, { ...entry }]));
 }
 function resolveParamAtChainIndex(chain, declarerIndex, paramId) {
   let cursor = paramId;
@@ -8281,6 +8304,9 @@ function buildUnorderedListMembershipIndex(values) {
 // ../src/models/members/member-value-id.ts
 var NEO_MEMBER_VALUE_NAMESPACE = "7f2b9c14-58d6-5a07-b3e1-4c9d0a6f8b25";
 var NEO_VIRTUAL_VALUE_NAMESPACE = "3e8ca0b3-e3f1-5d5f-bf2f-6ab5ee3896d0";
+var virtualNamespaceBytes = parse_default(NEO_VIRTUAL_VALUE_NAMESPACE);
+var virtualIdentityEncoder = new TextEncoder();
+var SURROGATE_CODE_UNIT = /[\ud800-\udfff]/;
 function derivedMemberValueId(memberId) {
   return inSystemRecordNamespaceOf(
     memberId,
@@ -8288,12 +8314,11 @@ function derivedMemberValueId(memberId) {
   );
 }
 function virtualValueId(instanceRootId, sourceIdentity2) {
+  const identity = `${withoutSystemRecordIdPrefix(instanceRootId)}:${sourceIdentity2}`;
+  const bytes = SURROGATE_CODE_UNIT.test(identity) ? identity : virtualIdentityEncoder.encode(identity);
   return inSystemRecordNamespaceOf(
     instanceRootId,
-    v5_default(
-      `${withoutSystemRecordIdPrefix(instanceRootId)}:${sourceIdentity2}`,
-      NEO_VIRTUAL_VALUE_NAMESPACE
-    )
+    v5_default(bytes, virtualNamespaceBytes)
   );
 }
 function virtualSourceIdentityHead(sourceIdentity2) {
@@ -9047,7 +9072,7 @@ function constructionMembers(classId, context) {
         raw,
         env,
         document2.members,
-        resolveMember(raw, document2.members)
+        document2.resolvedMember?.(raw) ?? resolveMember(raw, document2.members)
       ),
       id: raw.id
     };
@@ -10279,11 +10304,11 @@ function withIndexedDefaultValueDocument(document2, options = {}) {
     storedInstanceSchema: (classId) => {
       const cached = cache.storedSchemaByClassId.get(classId);
       if (cached !== void 0) return cached;
-      const schema = mergeStoredInstanceSchema(
+      const schema = resolvedClassSchema(
         classId,
         document2.classes,
         document2.members
-      );
+      ).stored;
       cache.storedSchemaByClassId.set(classId, schema);
       return schema;
     },
@@ -10308,7 +10333,7 @@ function withIndexedDefaultValueDocument(document2, options = {}) {
     },
     memberDefaultSettlesConstruction: (member, environment) => {
       cache.memberDefaultConstructionChecker ??= createMemberDefaultConstructionChecker({
-        ...document2,
+        ...indexed,
         constructors: document2.constructors ?? []
       });
       return cache.memberDefaultConstructionChecker(member, environment);
@@ -11079,7 +11104,9 @@ function cloneDefaultValueForMemberCore(args, sourceValue) {
       members: args.document.members,
       constructors: args.document.constructors ?? [],
       values: args.document.values,
-      valueById: args.document.valueById
+      valueById: args.document.valueById,
+      memberById: args.document.memberById,
+      resolvedMember: args.document.resolvedMember
     },
     args.genericEnv
   )) {
@@ -11225,9 +11252,9 @@ function formatDefaultReferenceLocation(memberName, key) {
   return `${memberName}[${key}]`;
 }
 function getSchemaEntryMap(document2, classId) {
-  return new Map(
-    (document2.storedInstanceSchema?.(classId) ?? mergeStoredInstanceSchema(classId, document2.classes, document2.members)).map((entry) => [entry.schemaKey, entry])
-  );
+  const node = resolvedClassSchema(classId, document2.classes, document2.members);
+  const entries = document2.storedInstanceSchema?.(classId);
+  return entries === void 0 || entries === node.stored ? node.storedByKey : new Map(entries.map((entry) => [entry.schemaKey, entry]));
 }
 function cloneMemberValueBase(body) {
   return {
@@ -13002,6 +13029,7 @@ function isRecordValue(value) {
 }
 function resolveOwnerMembersForValues(document2, targetValueIds, additionalRoots, rootOwners, rootKinds, traversalExtension) {
   const resolved = /* @__PURE__ */ new Map();
+  let complete = false;
   if (targetValueIds.size === 0) return resolved;
   const valuesById = new Map(document2.values.map((value) => [value.id, value]));
   const membersById = new Map(
@@ -13061,7 +13089,9 @@ function resolveOwnerMembersForValues(document2, targetValueIds, additionalRoots
       resolved.set(valueId, member);
       rootOwners?.set(valueId, rootOwner);
       rootKinds?.set(valueId, rootKind);
+      complete = traversalExtension === void 0 && resolved.size === targetValueIds.size;
     }
+    if (complete) return;
     if (visited.has(valueId)) return;
     visited.add(valueId);
     const value = valuesById.get(valueId);
@@ -13108,6 +13138,7 @@ function resolveOwnerMembersForValues(document2, targetValueIds, additionalRoots
       );
       const env = overlayStamp(instanceEnv, body.genericBindings);
       for (const entry of merged) {
+        if (complete) break;
         if (entry.memberId === null) continue;
         const childValueId = body.value[entry.schemaKey];
         if (childValueId === void 0) continue;
@@ -13127,6 +13158,7 @@ function resolveOwnerMembersForValues(document2, targetValueIds, additionalRoots
       const entryMember = trySubstituteMember(entryMemberRecord, entryEnv);
       if (entryMember === null) return;
       for (const childValueId of Object.values(body.value)) {
+        if (complete) break;
         searchRow(entryMember, childValueId, rootOwner, entryEnv, rootKind);
       }
       return;
@@ -13140,12 +13172,14 @@ function resolveOwnerMembersForValues(document2, targetValueIds, additionalRoots
       if (listKindOf(member) === 1 /* Unordered */) {
         if (body.id === null) return;
         for (const row of rowsByContainerId.get(body.id) ?? []) {
+          if (complete) break;
           searchRow(entryMember, row.id, rootOwner, entryEnv, rootKind);
         }
         return;
       }
       if (!Array.isArray(body.value)) return;
       for (const childValueId of body.value) {
+        if (complete) break;
         if (typeof childValueId !== "string") continue;
         searchRow(entryMember, childValueId, rootOwner, entryEnv, rootKind);
       }
@@ -13163,6 +13197,7 @@ function resolveOwnerMembersForValues(document2, targetValueIds, additionalRoots
     );
   }
   for (const root of additionalRoots ?? []) {
+    if (complete) break;
     searchRootMember(
       root.member,
       root.valueId,
@@ -13171,10 +13206,12 @@ function resolveOwnerMembersForValues(document2, targetValueIds, additionalRoots
     );
   }
   for (const member of document2.members) {
+    if (complete) break;
     if (typeof member.valueId !== "string") continue;
     searchRootMember(member, member.valueId, "instance");
   }
   for (const member of document2.members) {
+    if (complete) break;
     const defaultBody = member.defaultValue;
     if (defaultBody === void 0) continue;
     if (defaultBody === null) continue;
@@ -21240,6 +21277,7 @@ function memberIdFromSyntheticDefaultValueId(valueId) {
 }
 function resolveLocalizedTextId(value, ctx) {
   ctx.localizedTextDependencies?.add(value);
+  ctx.vm.localizedTextDependencies?.add(value);
   const mainLocale = ctx.vm.localizationConfig?.mainLocale;
   if (mainLocale === void 0) return value;
   const text = ctx.vm.databaseVM?.localizedTextById?.(value) ?? ctx.vm.localizedTexts?.find((candidate) => candidate.id === value) ?? null;
@@ -22753,11 +22791,12 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
   return cacheDescriptor({ schemaClass: schemaClass2, fields, instanceEnv, classArguments: classArguments2 });
 }
 function assertConstructorFieldSlotWritable(args) {
-  const surfaceEntry = mergeInstanceSurfaceSchema(
+  const index = evaluatorSchemaIndex(args.ctx);
+  const surfaceEntry = resolvedClassSchemaFromIndexes(
     args.settledClassId,
-    args.ctx.vm.classes,
-    args.ctx.vm.members
-  ).find((entry) => entry.schemaKey === args.schemaKey);
+    index.classesById,
+    index.membersById
+  ).surfaceByKey.get(args.schemaKey);
   if (surfaceEntry === void 0) return;
   if (isReadOnlyMember(evalMemberById(args.ctx.vm, surfaceEntry.memberId)) !== true) {
     return;
@@ -25872,12 +25911,25 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
   const active = /* @__PURE__ */ new Set();
   const clonedBySourceId = /* @__PURE__ */ new Map();
   ctx.onUnattributableValueRead?.(`class-clone:${sourceId}`);
-  const constructorArgumentCandidates = evaluatorValues(ctx);
+  const priorRuntimeRows = [...ctx.__runtimeSessionValues.values()];
+  const priorOverlayRows = [...ctx.__valueOverlay?.values() ?? []];
+  const priorPersistedRows = ctx.__valueOverlay instanceof LazyValueOverlay ? ctx.__valueOverlay.sourceRowsSnapshot() : ctx.vm.values;
+  const priorRemovedIds = new Set(ctx.__removedValueIds);
   let constructorArgumentReferenceCounts = null;
   function constructorArgumentReferenceCount(valueId) {
     if (constructorArgumentReferenceCounts === null) {
       constructorArgumentReferenceCounts = /* @__PURE__ */ new Map();
-      for (const candidate of constructorArgumentCandidates) {
+      const shadowedIds = /* @__PURE__ */ new Set();
+      const candidates = [];
+      for (const row of [...priorRuntimeRows, ...priorOverlayRows]) {
+        shadowedIds.add(row.id);
+        if (!priorRemovedIds.has(row.id)) candidates.push(row);
+      }
+      for (const row of priorPersistedRows) {
+        if (!shadowedIds.has(row.id) && !priorRemovedIds.has(row.id))
+          candidates.push(row);
+      }
+      for (const candidate of candidates) {
         for (const argument2 of ownedConstructorArgumentValues(candidate, ctx)) {
           constructorArgumentReferenceCounts.set(
             argument2.id,
@@ -26065,9 +26117,18 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
           ).id;
         });
         ctx.onUnattributableValueRead?.(containerEntriesRead(sourceRow.id));
-        for (const child of evaluatorValues(ctx)) {
-          if (child.containerId !== sourceRow.id) continue;
-          cloneRow2(child, entryMember, id, entryTypeInfo);
+        for (const childId of evaluatorUnorderedListEntryIds(
+          sourceRow.id,
+          ctx
+        )) {
+          if (typeof childId !== "string") continue;
+          const child = evalValueById(
+            ctx,
+            childId,
+            ctx.__runtimeSessionValues,
+            ctx.__valueOverlay
+          );
+          if (child !== null) cloneRow2(child, entryMember, id, entryTypeInfo);
         }
       }
     }
@@ -27380,12 +27441,12 @@ function collectReturnStatements(statements) {
 var SourceText = class {
   text;
   lineStarts;
+  #lastPositionLine = 0;
   constructor(text) {
     this.text = text;
     const starts = [0];
-    for (let index = 0; index < text.length; index++) {
-      if (text.charCodeAt(index) === 10) starts.push(index + 1);
-    }
+    for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1))
+      starts.push(index + 1);
     this.lineStarts = starts;
   }
   get lineCount() {
@@ -27393,6 +27454,11 @@ var SourceText = class {
   }
   positionAt(rawOffset) {
     const offset = clamp(rawOffset, 0, this.text.length);
+    const previousLine = this.#lastPositionLine;
+    const previousStart = this.lineStarts[previousLine];
+    const nextStart = this.lineStarts[previousLine + 1];
+    if (offset >= previousStart && (nextStart === void 0 || offset < nextStart))
+      return { line: previousLine, character: offset - previousStart };
     let low = 0;
     let high = this.lineStarts.length;
     while (low < high) {
@@ -27402,6 +27468,7 @@ var SourceText = class {
       else low = middle + 1;
     }
     const line = Math.max(0, low - 1);
+    this.#lastPositionLine = line;
     return {
       line,
       character: offset - (this.lineStarts[line] ?? 0)
@@ -27445,6 +27512,13 @@ var TYPE_SET = /* @__PURE__ */ new Set([
 var OPERATORS = [...NEOSCRIPT_OPERATORS].sort(
   (left, right) => right.length - left.length
 );
+var OPERATORS_BY_FIRST_CHARACTER = /* @__PURE__ */ new Map();
+for (const operator of OPERATORS) {
+  const first = operator[0];
+  const candidates = OPERATORS_BY_FIRST_CHARACTER.get(first) ?? [];
+  candidates.push(operator);
+  OPERATORS_BY_FIRST_CHARACTER.set(first, candidates);
+}
 var PUNCTUATION = /* @__PURE__ */ new Set([
   ";",
   ",",
@@ -27594,7 +27668,7 @@ function lex(sourceValue) {
         emit(makeToken(kind, start, cursor));
         continue;
       }
-      const operator = OPERATORS.find(
+      const operator = OPERATORS_BY_FIRST_CHARACTER.get(char)?.find(
         (candidate) => sourceValue.startsWith(candidate, cursor)
       );
       if (operator) {
@@ -29352,7 +29426,7 @@ function asASTBinaryOp(text) {
 }
 function grammarTokens(lexed, start, end) {
   const lexicalError = lexed.diagnostics.find(
-    (diagnostic) => diagnostic.severity === "error" && lexed.source.offsetAt(diagnostic.range.start) >= start && lexed.source.offsetAt(diagnostic.range.start) <= end
+    (diagnostic) => diagnostic.severity === "error" && lexed.source.offsetAt(diagnostic.range.start) >= start && lexed.source.offsetAt(diagnostic.range.start) < end
   );
   if (lexicalError) {
     throw new CompileError(lexicalError.message, {
@@ -29360,12 +29434,22 @@ function grammarTokens(lexed, start, end) {
       column: lexicalError.range.start.character + 1
     });
   }
-  return [
-    ...lexed.roots.filter(
-      (token) => token.kind !== "comment" && token.kind !== "eof" && token.start >= start && token.end <= end
-    ),
-    eofToken(end, lexed.source.positionAt(end))
-  ];
+  let low = 0;
+  let high = lexed.roots.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (lexed.roots[middle].start < start) low = middle + 1;
+    else high = middle;
+  }
+  const tokens = [];
+  for (let index = low; index < lexed.roots.length; index++) {
+    const token = lexed.roots[index];
+    if (token.start > end) break;
+    if (token.kind !== "comment" && token.kind !== "eof" && token.end <= end)
+      tokens.push(token);
+  }
+  tokens.push(eofToken(end, lexed.source.positionAt(end)));
+  return tokens;
 }
 function eofToken(offset, position) {
   return {
@@ -29863,61 +29947,11 @@ function expandStoredInstance(args) {
       `Virtual expansion root "${args.instanceRoot.id}" is missing required constructor arguments.`
     );
   }
-  const constructorArguments = requiredConstructor === null ? [] : requiredConstructor.argumentTypes.flatMap((typeInfo, index) => {
-    const parameterId = constructorActionParameterId(
-      requiredConstructor,
-      index
-    );
-    if (!Object.hasOwn(storedArgs, parameterId)) {
-      if (!typeInfo.required) return [];
-      throw new VirtualExpansionUnsupportedError(
-        `Virtual expansion root "${args.instanceRoot.id}" is missing creation data for constructor parameter "${typeInfo.name}" (${parameterId}).`
-      );
-    }
-    return [
-      {
-        name: typeInfo.name,
-        valuePointer: storedArgumentPointer(
-          storedArgs[parameterId],
-          typeInfo
-        )
-      }
-    ];
-  });
-  const constructionPointer = (fields = []) => typeof instanceRoot.instanceVariantId === "string" ? {
-    type: "function" /* function */,
-    function: {
-      type: "variantInitialize" /* variantInitialize */,
-      info: {
-        variantPointer: {
-          type: "variant" /* variant */,
-          classId,
-          variantId: instanceRoot.instanceVariantId,
-          rowValueId: instanceRoot.instanceVariantRowValueId ?? null
-        },
-        schemaClassInfo: {
-          type: 7 /* Class */,
-          required: true,
-          classId
-        }
-      }
-    }
-  } : {
-    type: "function" /* function */,
-    function: {
-      type: "declaredConstructor" /* declaredConstructor */,
-      info: {
-        schemaClassInfo: {
-          type: 7 /* Class */,
-          required: true,
-          classId
-        },
-        constructorId: recordedConstructorId,
-        args: constructorArguments,
-        fields
-      }
-    }
-  };
+  const constructorArguments = storedConstructorReplayArguments(
+    requiredConstructor,
+    storedArgs,
+    instanceRoot.id
+  );
   const {
     value: _value,
     classId: _classId,
@@ -29939,21 +29973,15 @@ function expandStoredInstance(args) {
   );
   const replayMember = closedRootMember === rootMember ? rootMember : { ...closedRootMember, classId };
   const replay = (fields) => {
-    const compiled = {
-      compilerRevision: NEOSCRIPT_COMPILER_REVISION,
-      parameters: evaluatorEnvelopeParameters(),
-      instructions: [
-        {
-          type: "return" /* return */,
-          pointer: constructionPointer(fields)
-        }
-      ],
-      typeInfo: { type: 7 /* Class */, required: true, classId }
-    };
-    const init = {
-      code: `virtual-replay:${args.instanceRoot.id}`,
-      compiled
-    };
+    const init = storedConstructorReplayInitializer({
+      classId,
+      constructorId: recordedConstructorId,
+      arguments: constructorArguments,
+      fields,
+      variantId: instanceRoot.instanceVariantId,
+      variantRowValueId: instanceRoot.instanceVariantRowValueId,
+      code: `virtual-replay:${args.instanceRoot.id}`
+    });
     return trackMaterialization(
       () => materializeInitializerValue({
         evaluateInitializer: args.evaluateInitializer,
@@ -30121,11 +30149,11 @@ function resolveVirtualInstanceGraph(args) {
       const classId = effective.classId ?? indexed.member.classId;
       const constructedChildren = materialized === null ? /* @__PURE__ */ new Map() : settledAggregateChildren(materialized, classId, pathKey);
       const effectiveRecord = {};
-      const schema = mergeStoredInstanceSchema(
+      const schema = resolvedClassSchema(
         classId,
         args.document.classes,
         args.document.members
-      );
+      ).stored;
       for (const entry of schema) {
         const childPath = appendVirtualValuePath(pathKey, {
           kind: "class",
@@ -30560,10 +30588,10 @@ function resolveVirtualInstanceGraph(args) {
   };
 }
 function mergeExpandedAndMaterializedRow(expanded, materialized) {
-  const expandedClone = cloneRow(expanded);
-  if (materialized === null) return expandedClone;
-  const materializedClone = cloneRow(materialized);
-  const merged = isLiteralValueContent(materialized) ? overlayLiteralValueContent(expandedClone, materializedClone) : { ...expandedClone, ...materializedClone };
+  if (materialized === null) return cloneRow(expanded);
+  const merged = cloneRow(
+    isLiteralValueContent(materialized) ? overlayLiteralValueContent(expanded, materialized) : { ...expanded, ...materialized }
+  );
   if (merged.sourceValueId === materialized.id) delete merged.sourceValueId;
   return merged;
 }
@@ -30872,11 +30900,11 @@ function indexExpansion(args) {
           instanceEnv.set(paramId, { kind: "member", memberId });
         }
       }
-      const schema = mergeStoredInstanceSchema(
+      const schema = resolvedClassSchema(
         classId,
         args.document.classes,
         args.document.members
-      );
+      ).stored;
       for (const entry of schema) {
         const childId = record4[entry.schemaKey];
         const childMember = membersById.get(entry.memberId);
@@ -31194,6 +31222,69 @@ function canonicalJson(value) {
   }
   return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
 }
+function storedConstructorReplayArguments(constructor, storedArgs, rootId) {
+  return constructor === null ? [] : constructor.argumentTypes.flatMap((typeInfo, index) => {
+    const parameterId = constructorActionParameterId(constructor, index);
+    if (!Object.hasOwn(storedArgs, parameterId)) {
+      if (!typeInfo.required) return [];
+      throw new VirtualExpansionUnsupportedError(
+        `Virtual expansion root "${rootId}" is missing creation data for constructor parameter "${typeInfo.name}" (${parameterId}).`
+      );
+    }
+    return [
+      {
+        name: typeInfo.name,
+        valuePointer: storedArgumentPointer(
+          storedArgs[parameterId],
+          typeInfo
+        )
+      }
+    ];
+  });
+}
+function storedConstructorReplayInitializer(args) {
+  const schemaClassInfo = {
+    type: 7 /* Class */,
+    required: true,
+    classId: args.classId,
+    ...args.typeArguments === void 0 ? {} : { typeArguments: args.typeArguments }
+  };
+  const pointer = typeof args.variantId === "string" ? {
+    type: "function" /* function */,
+    function: {
+      type: "variantInitialize" /* variantInitialize */,
+      info: {
+        variantPointer: {
+          type: "variant" /* variant */,
+          classId: args.classId,
+          variantId: args.variantId,
+          rowValueId: args.variantRowValueId ?? null
+        },
+        schemaClassInfo
+      }
+    }
+  } : {
+    type: "function" /* function */,
+    function: {
+      type: "declaredConstructor" /* declaredConstructor */,
+      info: {
+        schemaClassInfo,
+        constructorId: args.constructorId,
+        args: args.arguments,
+        fields: args.fields ?? []
+      }
+    }
+  };
+  return {
+    code: args.code,
+    compiled: {
+      compilerRevision: NEOSCRIPT_COMPILER_REVISION,
+      parameters: evaluatorEnvelopeParameters(),
+      instructions: [{ type: "return" /* return */, pointer }],
+      typeInfo: schemaClassInfo
+    }
+  };
+}
 function storedArgumentPointer(value, typeInfo) {
   if ((typeInfo.type === 7 /* Class */ || typeInfo.type === 22 /* Interface */ || typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */) && typeof value === "string") {
     return { type: "reference" /* reference */, valueId: value };
@@ -31568,6 +31659,11 @@ function createHeadlessVirtualInstanceResolver(args) {
     return knownGraph === void 0 ? emptyRows : expandRoot(knownGraph.instanceRootId, void 0);
   };
   return {
+    storedClassGraph: (rootId, member) => {
+      expandRoot(rootId, member);
+      const graph = graphByValueId.get(rootId);
+      return graph?.instanceRootId === rootId ? graph : null;
+    },
     virtualInstanceRowsForValue,
     valueById: (id) => expandedRowById.get(id) ?? null,
     rowForValueReference: (value) => expandedRowByRecord.get(value) ?? null,
@@ -31914,6 +32010,7 @@ function evaluateMemberInitializer(args) {
       interfaces: args.document.interfaces,
       localizedTexts: args.document.localizedTexts,
       localizationConfig: args.document.localizationConfig,
+      localizedTextDependencies: args.document.localizedTextDependencies,
       // P67 §4: `Variants.X.Initialize()` and the P75 variant-construction
       // replay both resolve the graph through `ctx.vm.variants`; omitting
       // these made every variant-constructed instance refuse with
@@ -32099,6 +32196,70 @@ function headlessVirtualInstanceLookups(document2, options = {}) {
   return lookups;
 }
 
+// ../src/common/immutable-json.ts
+var immutable = /* @__PURE__ */ new WeakSet();
+function isFrozenJsonData(value) {
+  return immutable.has(value);
+}
+function memoizeFrozenJsonGuard(isValid) {
+  const accepted = /* @__PURE__ */ new WeakSet();
+  return (value) => {
+    if (value === null || typeof value !== "object" || !isFrozenJsonData(value))
+      return isValid(value);
+    if (accepted.has(value)) return true;
+    if (!isValid(value)) return false;
+    accepted.add(value);
+    return true;
+  };
+}
+
+// ../packages/manifest/src/value-comparison.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../src/database/canonical-json.ts
+function canonicalJsonStringify(value) {
+  return JSON.stringify(toCanonicalJsonValue(value));
+}
+function toCanonicalJsonValue(value) {
+  if (value === null) return null;
+  if (value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Cannot canonicalize a non-finite number.");
+    }
+    return value;
+  }
+  if (typeof value === "bigint") {
+    throw new Error("Cannot canonicalize bigint values.");
+  }
+  if (typeof value === "symbol") {
+    throw new Error("Cannot canonicalize symbol values.");
+  }
+  if (typeof value === "function") {
+    throw new Error("Cannot canonicalize function values.");
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      const canonicalItem = toCanonicalJsonValue(item);
+      if (canonicalItem === void 0) return null;
+      return canonicalItem;
+    });
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  const canonicalObject = {};
+  for (const [key, entryValue] of entries) {
+    const canonicalValue = toCanonicalJsonValue(entryValue);
+    if (canonicalValue === void 0) continue;
+    canonicalObject[key] = canonicalValue;
+  }
+  return canonicalObject;
+}
+
 // ../packages/neoscript-language/src/syntax-index.ts
 var OPEN_TO_CLOSE = /* @__PURE__ */ new Map([
   ["(", ")"],
@@ -37099,7 +37260,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   /**
    * P67 §4.1/§4.2 — `<variant>.Initialize()` and `<source>.ToVariant(<variant>)`.
    *
-   * Checked before {@link resolveDelegateCallee} deliberately. The variant
+   * Checked before {@link resolveCallableValueCallee} deliberately. The variant
    * graph really does carry an `Initialize` member of delegate type, so the
    * ordinary delegate path would resolve `.Initialize()` and run step 1 of the
    * construction path while silently skipping Overrides and ChildOverrides.
@@ -38152,20 +38313,23 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       receiverValue
     );
     if (variantCall !== null) return variantCall;
-    const delegate = this.resolveDelegateCallee(callee, scope, receiverValue);
-    if (delegate !== null) {
+    const callable2 = this.resolveCallableValueCallee(
+      callee,
+      scope,
+      receiverValue
+    );
+    if (callable2?.type.kind === "delegate") {
       return this.resolveDelegateCall(
-        delegate,
+        callable2,
         argumentsList2,
         scope,
         pos,
         callee.kind === "member" && callee.optional === true
       );
     }
-    const action = this.resolveActionCallee(callee, scope, receiverValue);
-    if (action !== null) {
+    if (callable2?.type.kind === "action") {
       throw new CompileError(
-        `${this.describe(action.type)} is void and cannot be used as a value; call it as a statement instead.`,
+        `${this.describe(callable2.type)} is void and cannot be used as a value; call it as a statement instead.`,
         pos
       );
     }
@@ -38442,7 +38606,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
     };
   }
-  resolveDelegateCallee(callee, scope, receiverValue) {
+  /** Classify callable values once before falling back to ordinary methods. */
+  resolveCallableValueCallee(callee, scope, receiverValue) {
     if (callee.kind === "ident") {
       const scoped = scope.lookup(callee.name);
       const implicit = this.implicitMember(callee.name);
@@ -38450,7 +38615,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         return null;
       }
       const resolved = this.resolveIdentifier(callee.name, scope, callee.pos);
-      return resolved.type.kind === "delegate" ? resolved : null;
+      return resolved.type.kind === "delegate" || resolved.type.kind === "action" ? resolved : null;
     }
     if (callee.kind !== "member") return null;
     try {
@@ -38462,39 +38627,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         callee.optional === true,
         receiverValue
       );
-      return resolved.type.kind === "delegate" ? resolved : null;
-    } catch (error) {
-      if (error instanceof CompileError) return null;
-      throw error;
-    }
-  }
-  /**
-   * The action-typed sibling of {@link resolveDelegateCallee}. Kept separate
-   * so an action never leaks into the delegate call path: an action is
-   * statement-only, and its two call sites want opposite outcomes — the
-   * statement path compiles it, the expression path rejects it.
-   */
-  resolveActionCallee(callee, scope, receiverValue) {
-    if (callee.kind === "ident") {
-      const scoped = scope.lookup(callee.name);
-      const implicit = this.implicitMember(callee.name);
-      if (scoped === null && (implicit === null || implicit.symbol.kind === "function" || implicit.symbol.kind === "method")) {
-        return null;
-      }
-      const resolved = this.resolveIdentifier(callee.name, scope, callee.pos);
-      return resolved.type.kind === "action" ? resolved : null;
-    }
-    if (callee.kind !== "member") return null;
-    try {
-      const resolved = this.resolveMember(
-        callee.receiver,
-        callee.name,
-        scope,
-        callee.pos,
-        callee.optional === true,
-        receiverValue
-      );
-      return resolved.type.kind === "action" ? resolved : null;
+      return resolved.type.kind === "delegate" || resolved.type.kind === "action" ? resolved : null;
     } catch (error) {
       if (error instanceof CompileError) return null;
       throw error;
@@ -40474,19 +40607,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         throw new Error("Base call did not produce a function call.");
       return result.pointer;
     }
-    const action = this.resolveActionCallee(
+    const callable2 = this.resolveCallableValueCallee(
       expression.callee,
       scope,
       receiverValue
     );
-    if (action?.type.kind === "action") {
-      return this.resolveActionCall(action, action.type, expression, scope);
+    if (callable2?.type.kind === "action") {
+      return this.resolveActionCall(callable2, callable2.type, expression, scope);
     }
-    const delegate = this.resolveDelegateCallee(
-      expression.callee,
-      scope,
-      receiverValue
-    );
+    const delegate = callable2;
     if (delegate?.type.kind === "delegate") {
       const delegateType = delegate.type;
       requireArgCount(
@@ -45074,6 +45203,15 @@ function analyzerMemberById(context, id) {
   }
   return analyzerSchemaIndex(context).member(id) ?? null;
 }
+function resolveAnalyzerMember(context, member) {
+  const index = activeSchemaIndexByContext.get(context);
+  if (index === void 0) return resolveMember(member, context.vm.members);
+  const cached = index.resolvedMembers.get(member);
+  if (cached !== void 0) return cached;
+  const resolved = resolveMemberFromIndex(member, index.membersById);
+  index.resolvedMembers.set(member, resolved);
+  return resolved;
+}
 
 // ../src/runtime/neoscript/neoscript-language-context-adapter.ts
 var NEOSCRIPT_COMPILER_ADAPTER_REVISION = 5;
@@ -45082,6 +45220,31 @@ var UNKNOWN_TYPE = {
   name: "unknown"
 };
 var storageResolverByContext = /* @__PURE__ */ new WeakMap();
+var dialogueProjects = /* @__PURE__ */ new WeakMap();
+function withDialogueContextType(project, context) {
+  if (!context.dialogueContext) return project;
+  let contexts = dialogueProjects.get(project);
+  if (contexts === void 0) {
+    contexts = /* @__PURE__ */ new Map();
+    dialogueProjects.set(project, contexts);
+  }
+  const dialogueType = createDialogueContextType(context);
+  const key = JSON.stringify(dialogueType);
+  let scoped = contexts.get(key);
+  if (scoped === void 0) {
+    scoped = {
+      ...project,
+      types: [
+        ...project.types.filter(
+          (type) => type.id !== AnalyzerDialogueContextClassId
+        ),
+        dialogueType
+      ]
+    };
+    contexts.set(key, scoped);
+  }
+  return scoped;
+}
 function createNeoScriptDocumentContext(context, projectOverride) {
   return withAnalyzerSchemaIndex(
     context,
@@ -45089,7 +45252,7 @@ function createNeoScriptDocumentContext(context, projectOverride) {
   );
 }
 function createNeoScriptDocumentContextInScope(context, projectOverride) {
-  const project = projectOverride ?? createNeoScriptProject(context);
+  const project = projectOverride === void 0 ? createNeoScriptProject(context) : withDialogueContextType(projectOverride, context);
   const documentKind = context.scriptKind ?? "getter";
   const thisClass = context.thisClass ? namedType(context.thisClass.id, true) : void 0;
   const baseClass = overrideBaseClass(context);
@@ -45303,12 +45466,15 @@ function classToLanguageType(schemaClass2, context) {
     const record4 = analyzerMemberById(context, placement.memberId);
     if (!record4) continue;
     let projectedRecord = record4;
+    let projectedBase;
     try {
       projectedRecord = substituteMember(
         record4,
         genericEnvironment,
-        context.vm.members
+        context.vm.members,
+        resolveAnalyzerMember(context, record4)
       );
+      projectedBase = projectedRecord;
     } catch {
     }
     const symbol = memberToSymbol(
@@ -45318,7 +45484,8 @@ function classToLanguageType(schemaClass2, context) {
       placement.ownerClassId,
       index,
       context,
-      genericEnvironment
+      genericEnvironment,
+      projectedBase
     );
     if (!symbol) continue;
     names.add(symbol.name);
@@ -45403,7 +45570,8 @@ function constructorSignature(schemaClass2, members, context, genericEnvironment
           const resolved = substituteMember(
             record4,
             genericEnvironment,
-            context.vm.members
+            context.vm.members,
+            resolveAnalyzerMember(context, record4)
           );
           return {
             required: isRequiredMember(resolved),
@@ -45429,7 +45597,8 @@ function constructorSignature(schemaClass2, members, context, genericEnvironment
         const resolved = substituteMember(
           record4,
           genericEnvironment,
-          context.vm.members
+          context.vm.members,
+          resolveAnalyzerMember(context, record4)
         );
         return {
           required: isRequiredMember(resolved),
@@ -45481,10 +45650,10 @@ function canonicalMemberId(id, context) {
   }
   return resolve(id);
 }
-function memberToSymbol(record4, schemaKey, containingClass, ownerClassId, index, context, genericEnvironment) {
+function memberToSymbol(record4, schemaKey, containingClass, ownerClassId, index, context, genericEnvironment, projectedBase) {
   let resolved;
   try {
-    resolved = resolveMember(record4, context.vm.members);
+    resolved = projectedBase ?? resolveAnalyzerMember(context, record4);
   } catch {
     return null;
   }
@@ -45492,7 +45661,8 @@ function memberToSymbol(record4, schemaKey, containingClass, ownerClassId, index
     record4,
     context,
     /* @__PURE__ */ new Set(),
-    genericEnvironment
+    genericEnvironment,
+    resolved
   );
   const owner = analyzerSchemaIndex(context).class(ownerClassId);
   const inheritedFrom = owner && owner.id !== containingClass.id ? {
@@ -45823,7 +45993,7 @@ function createListIndexes(context) {
   for (const record4 of context.vm.members) {
     let resolved;
     try {
-      resolved = resolveMember(record4, context.vm.members);
+      resolved = resolveAnalyzerMember(context, record4);
     } catch {
       continue;
     }
@@ -45853,12 +46023,12 @@ function createListIndexes(context) {
   }
   return result;
 }
-function memberRuntimeType(record4, context, seen = /* @__PURE__ */ new Set(), genericEnvironment) {
+function memberRuntimeType(record4, context, seen = /* @__PURE__ */ new Set(), genericEnvironment, projectedBase) {
   if (seen.has(record4.id)) return UNKNOWN_TYPE;
   const nextSeen = new Set(seen).add(record4.id);
   let member;
   try {
-    member = resolveMember(record4, context.vm.members);
+    member = projectedBase ?? resolveAnalyzerMember(context, record4);
   } catch {
     return UNKNOWN_TYPE;
   }
@@ -46105,7 +46275,12 @@ function classArguments(member, context, seen, genericEnvironment) {
 function substituteForGenericEnvironment(member, environment, context) {
   if (!environment) return member;
   try {
-    return substituteMember(member, environment, context.vm.members);
+    return substituteMember(
+      member,
+      environment,
+      context.vm.members,
+      resolveAnalyzerMember(context, member)
+    );
   } catch {
     return member;
   }
@@ -46391,7 +46566,7 @@ function scriptDefinitionLocations2(memberId, context) {
   if (!record4) return {};
   let resolved;
   try {
-    resolved = resolveMember(record4, context.vm.members);
+    resolved = resolveAnalyzerMember(context, record4);
   } catch {
     return {};
   }
@@ -46477,7 +46652,7 @@ function virtualNeoSchemaClassHeader(schemaClass2, context) {
   return `public ${isAbstractClass(schemaClass2) ? "abstract " : ""}partial class ${virtualCSharpIdentifier(schemaClass2.name)}${genericParameters}${inheritance}${constraints.join("")} // Neo class ${schemaClass2.id}`;
 }
 function virtualConstraintMemberType(member, context) {
-  const resolved = resolveMember(member, context.vm.members);
+  const resolved = resolveAnalyzerMember(context, member);
   switch (resolved.kind) {
     case 1 /* Bool */:
       return "bool";
@@ -49050,18 +49225,18 @@ function readProjectDocument(value, options = {}) {
     "localizationConfig",
     isProjectLocalizationConfig
   ) : readField(value, "localizationConfig", isProjectLocalizationConfig);
-  const storedValues = readArrayField(value, "values", isMemberValue);
+  const storedValues = readDocumentArrayField(value, "values", isMemberValue);
   const valueBuckets = options.values === "stored" ? { values: storedValues } : projectDocumentValueBuckets(storedValues);
   return {
     version: readField(value, "version", isProjectVersion),
-    versions: readArrayField(value, "versions", isProjectVersion),
+    versions: readDocumentArrayField(value, "versions", isProjectVersion),
     versionStatus: readField(value, "versionStatus", isProjectVersionStatus),
-    versionStatuses: readArrayField(
+    versionStatuses: readDocumentArrayField(
       value,
       "versionStatuses",
       isProjectVersionStatus
     ),
-    releaseChannels: readArrayField(
+    releaseChannels: readDocumentArrayField(
       value,
       "releaseChannels",
       isProjectReleaseChannel
@@ -49071,7 +49246,7 @@ function readProjectDocument(value, options = {}) {
       value,
       options.members === "authored-or-compiled" ? isAnyMemberAuthoredOrCompiled : isAnyMember
     ),
-    classes: readArrayField(value, "classes", isNeoSchemaClass),
+    classes: readDocumentArrayField(value, "classes", isNeoSchemaClass),
     constructors: readOptionalArrayField(
       value,
       "constructors",
@@ -49092,13 +49267,13 @@ function readProjectDocument(value, options = {}) {
     // Retain the physical bucket after expansion for write-path comparisons.
     values: valueBuckets.values,
     ...valueBuckets.physicalValues === void 0 ? {} : { physicalValues: valueBuckets.physicalValues },
-    enums: readArrayField(
+    enums: readDocumentArrayField(
       value,
       "enums",
       options.identities === "prospective" ? isProspectiveEnum : isEnum
     ),
-    interfaces: readArrayField(value, "interfaces", isNeoInterface),
-    ...options.dialogues === "omit" ? {} : { dialogues: readArrayField(value, "dialogues", isDialogue) },
+    interfaces: readDocumentArrayField(value, "interfaces", isNeoInterface),
+    ...options.dialogues === "omit" ? {} : { dialogues: readDocumentArrayField(value, "dialogues", isDialogue) },
     dialogueRecords: readOptionalArrayField(
       value,
       "dialogueRecords",
@@ -49109,26 +49284,38 @@ function readProjectDocument(value, options = {}) {
       "dialogueNodes",
       isDialogueNodeRecord
     ),
-    dialogueGroups: readArrayField(value, "dialogueGroups", isAnyDialogueGroup),
-    priorityGroups: readArrayField(value, "priorityGroups", isPriorityGroup),
-    projectFiles: readArrayField(value, "projectFiles", isProjectFile),
-    textureTemplates: readArrayField(
+    dialogueGroups: readDocumentArrayField(
+      value,
+      "dialogueGroups",
+      isAnyDialogueGroup
+    ),
+    priorityGroups: readDocumentArrayField(
+      value,
+      "priorityGroups",
+      isPriorityGroup
+    ),
+    projectFiles: readDocumentArrayField(value, "projectFiles", isProjectFile),
+    textureTemplates: readDocumentArrayField(
       value,
       "textureTemplates",
       isUnityTexture2DImportSettingsTemplate
     ),
-    audioClipTemplates: readArrayField(
+    audioClipTemplates: readDocumentArrayField(
       value,
       "audioClipTemplates",
       isUnityAudioClipImportSettingsTemplate
     ),
     localizationConfig,
-    localizationStatuses: readArrayField(
+    localizationStatuses: readDocumentArrayField(
       value,
       "localizationStatuses",
       isLocalizationStatus
     ),
-    localizedTexts: readArrayField(value, "localizedTexts", isLocalizedText),
+    localizedTexts: readDocumentArrayField(
+      value,
+      "localizedTexts",
+      isLocalizedText
+    ),
     migrations: readOptionalArrayField(value, "migrations", isProjectMigration)
   };
 }
@@ -49158,7 +49345,7 @@ function isHashHead(value) {
 }
 function readField(source, key, isValid) {
   const value = source[key];
-  if (isValid(value)) return value;
+  if (frozenRecordGuard(isValid)(value)) return value;
   throw new Error(
     `Convex project document field "${key}" has an invalid shape.`
   );
@@ -49166,11 +49353,23 @@ function readField(source, key, isValid) {
 function readOptionalNullableField(source, key, isValid) {
   const value = source[key];
   if (value === void 0 || value === null) return null;
-  if (isValid(value)) return value;
+  if (frozenRecordGuard(isValid)(value)) return value;
   throw new Error(
     `Convex project document field "${key}" has an invalid shape.`
   );
 }
+var frozenRecordGuards = /* @__PURE__ */ new WeakMap();
+function frozenRecordGuard(isValid) {
+  let guard = frozenRecordGuards.get(isValid);
+  if (guard === void 0) {
+    guard = memoizeFrozenJsonGuard(isValid);
+    frozenRecordGuards.set(isValid, guard);
+  }
+  return guard;
+}
+function readDocumentArrayField(source, key, isValid) {
+  return readArrayField(source, key, frozenRecordGuard(isValid));
+}
 function readArrayField(source, key, isValid) {
   const value = source[key];
   if (!Array.isArray(value)) {
@@ -49192,10 +49391,10 @@ function describeRejectedCompilerRevision(value) {
 }
 function readOptionalArrayField(source, key, isValid) {
   if (!Object.prototype.hasOwnProperty.call(source, key)) return [];
-  return readArrayField(source, key, isValid);
+  return readDocumentArrayField(source, key, isValid);
 }
 function readStoredMembersField(source, isValid = isAnyMember) {
-  return readArrayField(
+  return readDocumentArrayField(
     source,
     "members",
     isValid
@@ -49482,10 +49681,20 @@ var WORLD_LAYER_LINK_KINDS = /* @__PURE__ */ new Set([
   NeoWorldSystemClassKind.ObjectLayerLink
 ]);
 
-// ../packages/manifest/src/value-comparison.ts
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+// ../src/database/project-snapshot-derived-edges.ts
+var REFERENCE_ID_PAYLOAD = canonicalJsonStringify({
+  referenceKind: "record-id"
+});
+var REFERENCE_NAME_PAYLOAD = canonicalJsonStringify({
+  referenceKind: "type-name"
+});
+var CONSTRUCTED_CLASS_PAYLOAD = canonicalJsonStringify({
+  referenceKind: "constructed-class-id"
+});
+var BODY_CHILD_PAYLOAD = canonicalJsonStringify({
+  relation: "body-child",
+  depth: 1
+});
 
 // ../src/models/project/world-content-sidecar-validation.ts
 var WORLD_PLACEMENT_ASSET_KIND = /* @__PURE__ */ new Map([[NeoWorldSystemClassKind.Object, NeoWorldSystemClassKind.Object]]);
@@ -54423,6 +54632,1442 @@ var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
   "world.object-layer-link.target"
 ]);
 
+// ../packages/manifest/schema-contract/registry.mjs
+var PROJECT_SCHEMA_CONTRACT = Object.freeze({
+  cliVersion: "0.72.1",
+  projectFileUploadBatchSize: 32,
+  documentRecords: {
+    member: {
+      authored: [
+        "id",
+        "name",
+        "docsText",
+        "kind",
+        "requirement",
+        "mutability",
+        "modifier",
+        "access",
+        "defaultValue",
+        "extendsMemberId",
+        "system",
+        "storage",
+        "storageKey",
+        // Deliberately carries no normalization rule (P76 §1): absence is the
+        // canonical automatic setting and explicit ordinal 0 is an explicit
+        // `.Sparse`, so `absentMeansDefault` would collapse the two states
+        // that the whole contract exists to keep apart.
+        "distribution",
+        "minValue",
+        "maxValue",
+        "decimalPoints",
+        "format",
+        "searchBy",
+        "entryMemberId",
+        "keyKind",
+        "keyEnumId",
+        "listKind",
+        "indexes",
+        "columnSettings",
+        "classId",
+        "payload",
+        "schemaKeyOrder",
+        "classArguments",
+        "enumId",
+        "selection",
+        "collectionMemberId",
+        "collectionValueId",
+        "declaredTypeInfo",
+        "targetTypeInfo",
+        "valueTypeInfo",
+        "dialogueGroupId",
+        "code",
+        "setterCode",
+        "returnTypeInfo",
+        "argumentTypes",
+        "dispatch",
+        "bodyMode",
+        // P97 §1.1. No normalization rule, like `distribution`: absence means
+        // unset (a declaration resolves to `.None`, an override inherits) and
+        // explicit ordinal 0 is an authored `.None` that stops inheritance.
+        "effect",
+        "uiAction",
+        "templateId",
+        "genericParamId"
+      ],
+      derived: ["valueId", "getter", "setter", "action"],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: {
+        requirement: { kind: "absentMeansDefault", defaultValue: 0 },
+        mutability: { kind: "absentMeansDefault", defaultValue: 0 },
+        modifier: { kind: "absentMeansDefault", defaultValue: 0 },
+        access: { kind: "absentMeansDefault", defaultValue: 0 },
+        defaultValue: "nullIsAbsentOnFullMember",
+        extendsMemberId: "nullIsAbsent",
+        system: "nullIsAbsent",
+        storage: { kind: "absentMeansDefault", defaultValue: 0 },
+        storageKey: "nullOrEmptyStringIsAbsentOnFullMember",
+        minValue: "nullIsAbsentOnFullMember",
+        maxValue: "nullIsAbsentOnFullMember",
+        decimalPoints: "nullIsAbsentOnFullMember",
+        format: { kind: "absentMeansDefault", defaultValue: 0 },
+        searchBy: { kind: "absentMeansDefault", defaultValue: 0 },
+        keyEnumId: "nullIsAbsent",
+        keyKind: { kind: "absentMeansDefault", defaultValue: 0 },
+        listKind: { kind: "absentMeansDefault", defaultValue: 0 },
+        indexes: "nullOrEmptyArrayIsAbsentOnFullMember",
+        columnSettings: "nullOrEmptyArrayIsAbsentOnFullMember",
+        schemaKeyOrder: "nullIsAbsentOnFullMember",
+        classArguments: "nullOrEmptyObjectIsAbsentOnFullMember",
+        payload: { kind: "absentMeansDefault", defaultValue: 0 },
+        selection: { kind: "absentMeansDefault", defaultValue: 0 },
+        collectionValueId: "nullIsAbsentOnFullMember",
+        declaredTypeInfo: "nullIsAbsentOnFullMember",
+        targetTypeInfo: "nullIsAbsentOnFullMember",
+        valueTypeInfo: "nullIsAbsentOnFullMember",
+        dialogueGroupId: "nullIsAbsentOnFullMember",
+        code: "nullIsAbsentOnFullMember",
+        templateId: "nullIsAbsentOnFullMember",
+        setterCode: "nullIsAbsentOnFullMember",
+        dispatch: { kind: "absentMeansDefault", defaultValue: 0 },
+        bodyMode: { kind: "absentMeansDefault", defaultValue: 0 },
+        uiAction: "nullIsAbsentOnFullMember"
+      }
+    },
+    class: {
+      authored: [
+        "id",
+        "name",
+        "docsText",
+        "schema",
+        "schemaKeyOrder",
+        "extendsClassId",
+        "implementsInterfaceIds",
+        "uiVisibility",
+        "modifier",
+        "system",
+        "allowedStorage",
+        "allowedStorageKeys",
+        "genericParams",
+        "extendsGenericBindings",
+        "constructorIds",
+        "requiredConstructorId",
+        "targetMemberId"
+      ],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: {
+        uiVisibility: { kind: "absentMeansDefault", defaultValue: 0 },
+        modifier: { kind: "absentMeansDefault", defaultValue: 0 },
+        targetMemberId: "nullIsAbsent",
+        schemaKeyOrder: "nullIsAbsent",
+        extendsClassId: "nullIsAbsent",
+        implementsInterfaceIds: "nullOrEmptyArrayIsAbsent",
+        system: "nullIsAbsent",
+        allowedStorage: { kind: "absentMeansDefault", defaultValue: 0 },
+        allowedStorageKeys: "nullIsAbsent",
+        genericParams: "nullOrEmptyArrayIsAbsent",
+        extendsGenericBindings: "nullOrEmptyObjectIsAbsent",
+        constructorIds: "nullOrEmptyArrayIsAbsent",
+        requiredConstructorId: "nullIsAbsent"
+      }
+    },
+    constructor: {
+      authored: [
+        "id",
+        "classId",
+        "argumentTypes",
+        "code",
+        "baseArguments",
+        "baseInitializerFields",
+        "docsText"
+      ],
+      derived: [
+        "action",
+        "compiledBaseArguments",
+        "compiledBaseInitializerFields"
+      ],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      // `code` is deliberately un-normalized. P49 §1.2 gives it three states —
+      // a body, `""` for a declared-but-empty body, and `null` for a class
+      // header that declares no `init` block — and the last two must stay
+      // distinct in the canonical form or `neo pull` cannot tell
+      // `class Foo { init { } }` from `class Foo()`. `nullIsAbsent` would keep
+      // them distinct too, but it drops the field from the written record
+      // (`composeDocumentRecord` writes the normalized authored half), which
+      // would make the persisted shape disagree with the domain model's
+      // required `code: string | null`. Leaving it plain means exactly two
+      // spellings of an empty body reach storage, never three.
+      normalization: {
+        baseArguments: "nullOrEmptyArrayIsAbsent",
+        baseInitializerFields: "nullOrEmptyArrayIsAbsent"
+      }
+    },
+    variant: {
+      // P67 §2.1. A variant record names its class, its scope, and the root row
+      // of the value graph it owns. The delegates themselves are value rows, so
+      // the compiled `action` IR the server derives lives there, not here —
+      // which is why this record has no derived half at all.
+      authored: ["id", "classId", "name", "folderId", "valueId"],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      // `folderId` is always written: null is the class root folder, and a
+      // missing field would make "root" and "corrupt" the same shape.
+      normalization: { folderId: "missingIsNull" }
+    },
+    "variant-folder": {
+      // P67 §3.3. A folder's whole content is its path, which is what lets a
+      // rename be a one-record edit that orphans nothing.
+      authored: ["id", "classId", "path", "binding"],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: { binding: "nullIsAbsent" }
+    },
+    interface: {
+      authored: [
+        "id",
+        "name",
+        "docsText",
+        "members",
+        "memberKeyOrder",
+        "extendsInterfaceIds",
+        "system"
+      ],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: {
+        memberKeyOrder: "nullOrEmptyArrayIsAbsent",
+        extendsInterfaceIds: "nullOrEmptyArrayIsAbsent",
+        system: "nullIsAbsent"
+      }
+    },
+    enum: {
+      authored: [
+        "id",
+        "name",
+        "docsText",
+        "options",
+        "optionKeyOrder",
+        "system"
+      ],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: { system: "nullIsAbsent" }
+    },
+    "unity-texture-template": {
+      authored: [
+        "id",
+        "name",
+        "type",
+        "textureType",
+        "textureShape",
+        "sRGBTexture",
+        "alphaSource",
+        "alphaIsTransparency",
+        "nonPowerOfTwoScale",
+        "ignorePngGamma",
+        "readWriteEnabled",
+        "virtualTextureOnly",
+        "generateMipMaps",
+        "borderMipMaps",
+        "mipMapFiltering",
+        "mipMapsPreserveCoverage",
+        "alphaCutoffValue",
+        "fadeOutMipMaps",
+        "mipMapFadeDistanceStart",
+        "mipMapFadeDistanceEnd",
+        "anisoLevel",
+        "wrapMode",
+        "wrapModeU",
+        "wrapModeV",
+        "filterMode",
+        "maxTextureSize",
+        "resizeAlgorithm",
+        "textureCompression",
+        "compressionQuality",
+        "crunchedCompression",
+        "platformSettings",
+        "spriteSettings",
+        "normalMapSettings",
+        "cookieSettings",
+        "singleChannelSettings",
+        "swizzle"
+      ],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: {
+        wrapModeU: "missingIsNull",
+        wrapModeV: "missingIsNull",
+        spriteSettings: "missingIsNull",
+        normalMapSettings: "missingIsNull",
+        cookieSettings: "missingIsNull",
+        singleChannelSettings: "missingIsNull",
+        swizzle: "missingIsNull"
+      }
+    },
+    "unity-audio-clip-template": {
+      authored: [
+        "id",
+        "name",
+        "forceToMono",
+        "normalize",
+        "loadInBackground",
+        "ambisonic",
+        "loadType",
+        "compressionFormat",
+        "quality",
+        "sampleRateSetting",
+        "overrideSampleRate",
+        "preloadAudioData"
+      ],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: { overrideSampleRate: "missingIsNull" }
+    },
+    "localization-config": {
+      authored: [
+        "id",
+        "mainLocale",
+        "supportedLocales",
+        "sortedStatusIds",
+        "mainLocaleDefaultStatusId"
+      ],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: {}
+    },
+    "localization-status": {
+      authored: [
+        "id",
+        "slug",
+        "name",
+        "description",
+        "color",
+        "emoji",
+        "archivedAt",
+        "transitionRules",
+        "transitionToStatusIdOnEditText",
+        "transitionToWhenSourceBecomesStatusId",
+        "system"
+      ],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: {
+        description: "missingIsNull",
+        color: "missingIsNull",
+        emoji: "missingIsNull",
+        archivedAt: "missingIsNull",
+        transitionRules: "missingIsNull",
+        transitionToStatusIdOnEditText: "missingIsNull",
+        transitionToWhenSourceBecomesStatusId: "missingIsNull",
+        system: "nullIsAbsent"
+      }
+    },
+    "internal-record-relation": {
+      authored: [
+        "id",
+        "relationKind",
+        "sourceRecordKind",
+        "sourceRecordId",
+        "targetRecordKind",
+        "targetRecordId",
+        "orderKey"
+      ],
+      derived: [],
+      volatile: ["projectId", "createdAt", "updatedAt"],
+      normalization: { orderKey: "nullIsAbsent" }
+    }
+  },
+  sdkDeclarations: {
+    attributes: {
+      enums: {
+        NeoStorage: [
+          "Inherit",
+          "Immutable",
+          "Save",
+          "Session",
+          "Writable",
+          "User"
+        ],
+        NeoAllowedStorage: [
+          "Any",
+          "Immutable",
+          "Save",
+          "Session",
+          "Writable",
+          "User"
+        ],
+        NeoListKind: ["Ordered", "Unordered"],
+        NeoDictionaryKeyKind: ["String", "Enum"],
+        NeoClassVisibility: ["Visible", "Hidden"],
+        NeoSubtreeDistribution: ["Sparse", "Packed"],
+        NeoStringFormat: ["Localized", "Plain"],
+        NeoMemberSearchBy: ["None", "MemberKey"],
+        NeoListIndexKind: ["Bucket", "Unique"],
+        NeoColumnVisibility: ["Visible", "Hidden"],
+        NeoColumnPin: ["None", "Leading"],
+        NeoColumnOverflow: ["Clip", "Wrap"],
+        NeoFileKind: ["Sprite", "Audio"],
+        NeoEffectKind: ["None", "Auto"]
+      },
+      markers: {
+        NeoSchemaClassAttribute: {
+          targets: ["Class"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [
+            { type: "string?", name: "Id", access: "get" },
+            { type: "string?", name: "Name", access: "set" },
+            {
+              type: "NeoClassVisibility",
+              name: "Visibility",
+              access: "set",
+              default: "NeoClassVisibility.Visible"
+            },
+            {
+              type: "NeoAllowedStorage",
+              name: "AllowedStorage",
+              access: "set",
+              default: "NeoAllowedStorage.Any"
+            },
+            { type: "string[]?", name: "AllowedStorageKeys", access: "set" }
+          ]
+        },
+        NeoInterfaceAttribute: {
+          targets: ["Interface"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [
+            { type: "string?", name: "Id", access: "get" },
+            { type: "string?", name: "Name", access: "set" }
+          ]
+        },
+        NeoEnumAttribute: {
+          targets: ["Enum"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [
+            { type: "string?", name: "Id", access: "get" },
+            { type: "string?", name: "Name", access: "set" }
+          ]
+        },
+        NeoIdAttribute: {
+          targets: ["GenericParameter"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [{ type: "string?", name: "Id", access: "get" }]
+        },
+        NeoMemberAttribute: {
+          targets: ["Property", "Method"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [
+            { type: "string?", name: "Id", access: "get" },
+            { type: "string?", name: "Key", access: "set" },
+            { type: "string?", name: "Name", access: "set" },
+            {
+              type: "NeoStorage",
+              name: "Storage",
+              access: "set",
+              default: "NeoStorage.Inherit"
+            },
+            { type: "string?", name: "StorageKey", access: "set" },
+            { type: "int", name: "Order", access: "set", default: "-1" }
+          ]
+        },
+        NeoSystemAttribute: {
+          targets: ["Class", "Interface", "Enum", "Property", "Method"],
+          constructor: [
+            {
+              type: "NeoSystemProtectionKind",
+              name: "kind",
+              assigns: "Kind"
+            }
+          ],
+          properties: [
+            {
+              type: "NeoSystemProtectionKind",
+              name: "Kind",
+              access: "get"
+            },
+            {
+              type: "NeoWorldKind",
+              name: "WorldKind",
+              access: "set",
+              default: "NeoWorldKind.None"
+            }
+          ]
+        },
+        NeoTextAttribute: {
+          targets: ["Property"],
+          properties: [
+            {
+              type: "NeoStringFormat",
+              name: "Format",
+              access: "set",
+              default: "NeoStringFormat.Localized"
+            },
+            {
+              type: "NeoMemberSearchBy",
+              name: "SearchBy",
+              access: "set",
+              default: "NeoMemberSearchBy.None"
+            }
+          ]
+        },
+        NeoNullAttribute: { targets: ["Property"], properties: [] },
+        NeoNumberAttribute: {
+          targets: ["Property"],
+          properties: [
+            {
+              type: "double",
+              name: "Min",
+              access: "set",
+              default: "double.NaN"
+            },
+            {
+              type: "double",
+              name: "Max",
+              access: "set",
+              default: "double.NaN"
+            },
+            { type: "string?", name: "DecimalMin", access: "set" },
+            { type: "string?", name: "DecimalMax", access: "set" },
+            {
+              type: "int",
+              name: "DecimalPoints",
+              access: "set",
+              default: "-1"
+            }
+          ]
+        },
+        NeoDictionaryAttribute: {
+          targets: ["Property"],
+          properties: [
+            {
+              type: "NeoDictionaryKeyKind",
+              name: "KeyKind",
+              access: "set",
+              default: "NeoDictionaryKeyKind.String"
+            },
+            { type: "Type?", name: "KeyEnum", access: "set" }
+          ]
+        },
+        NeoListAttribute: {
+          targets: ["Property"],
+          properties: [
+            {
+              type: "NeoListKind",
+              name: "Kind",
+              access: "set",
+              default: "NeoListKind.Ordered"
+            }
+          ]
+        },
+        NeoEntriesAttribute: {
+          targets: ["Class", "Property"],
+          constructor: [
+            { type: "string", name: "settings", assigns: "Settings" }
+          ],
+          properties: [{ type: "string", name: "Settings", access: "get" }]
+        },
+        NeoSchemaOrderAttribute: {
+          targets: ["Class", "Property"],
+          constructor: [
+            {
+              type: "string[]",
+              name: "members",
+              modifier: "params",
+              assigns: "Members"
+            }
+          ],
+          properties: [{ type: "string[]", name: "Members", access: "get" }]
+        },
+        NeoIndexAttribute: {
+          targets: ["Property"],
+          allowMultiple: true,
+          constructor: [{ type: "string", name: "member", assigns: "Member" }],
+          properties: [
+            { type: "string", name: "Member", access: "get" },
+            {
+              type: "NeoListIndexKind",
+              name: "Kind",
+              access: "set",
+              default: "NeoListIndexKind.Bucket"
+            }
+          ]
+        },
+        NeoColumnAttribute: {
+          targets: ["Property"],
+          allowMultiple: true,
+          constructor: [{ type: "string", name: "member", assigns: "Member" }],
+          properties: [
+            { type: "string", name: "Member", access: "get" },
+            { type: "int", name: "Width", access: "set", default: "-1" },
+            {
+              type: "NeoColumnVisibility",
+              name: "Visibility",
+              access: "set",
+              default: "NeoColumnVisibility.Visible"
+            },
+            {
+              type: "NeoColumnPin",
+              name: "Pin",
+              access: "set",
+              default: "NeoColumnPin.None"
+            },
+            {
+              type: "NeoColumnOverflow",
+              name: "Overflow",
+              access: "set",
+              default: "NeoColumnOverflow.Clip"
+            }
+          ]
+        },
+        NeoLookupAttribute: {
+          targets: ["Property"],
+          constructor: [
+            {
+              type: "string",
+              name: "collectionMember",
+              assigns: "CollectionMember"
+            }
+          ],
+          properties: [
+            { type: "string", name: "CollectionMember", access: "get" },
+            { type: "string?", name: "CollectionValueMember", access: "set" }
+          ]
+        },
+        NeoDialogueAttribute: {
+          targets: ["Property"],
+          properties: [{ type: "string?", name: "Group", access: "set" }]
+        },
+        NeoFileAttribute: {
+          targets: ["Property"],
+          constructor: [{ type: "NeoFileKind", name: "kind", assigns: "Kind" }],
+          properties: [
+            { type: "NeoFileKind", name: "Kind", access: "get" },
+            { type: "Type?", name: "Template", access: "set" }
+          ]
+        },
+        NeoComputedAttribute: { targets: ["Property"], properties: [] },
+        NeoScriptAttribute: { targets: ["Method"], properties: [] },
+        NeoFunctionAttribute: { targets: ["Method"], properties: [] },
+        NeoEnumOptionAttribute: {
+          targets: ["Field"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [
+            { type: "string?", name: "Id", access: "get" },
+            { type: "string?", name: "Key", access: "set" },
+            { type: "string?", name: "Text", access: "set" }
+          ]
+        },
+        NeoTextureTemplateAttribute: {
+          targets: ["Class", "Property"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [{ type: "string?", name: "Id", access: "get" }]
+        },
+        NeoAudioTemplateAttribute: {
+          targets: ["Class", "Property"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [{ type: "string?", name: "Id", access: "get" }]
+        },
+        NeoLocalizationAttribute: {
+          targets: ["Class", "Property"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [{ type: "string?", name: "Id", access: "get" }]
+        },
+        NeoLocalizationStatusAttribute: {
+          targets: ["Class", "Property"],
+          constructor: [
+            { type: "string?", name: "id", default: "null", assigns: "Id" }
+          ],
+          properties: [{ type: "string?", name: "Id", access: "get" }]
+        },
+        NeoRegistryAttribute: { targets: ["Class"], properties: [] },
+        NeoRelationConfigurationAttribute: {
+          targets: ["Class"],
+          properties: []
+        }
+      }
+    },
+    settings: {
+      enums: {
+        NeoProjectRecordKind: [
+          "Project",
+          "Member",
+          "Value",
+          "Class",
+          "InternalRecordRelation",
+          "Enum",
+          "Interface",
+          "Dialogue",
+          "DialogueNode",
+          "DialogueGroup",
+          "PriorityGroup",
+          "ProjectFile",
+          "UnityTextureTemplate",
+          "UnityAudioClipTemplate",
+          "LocalizationConfig",
+          "LocalizationStatus",
+          "LocalizedText",
+          "Migration"
+        ],
+        NeoEntryKind: [
+          "Null",
+          "Boolean",
+          "Integer",
+          "String",
+          "Float",
+          "Decimal",
+          "Vector2",
+          "Vector2Int",
+          "Vector3",
+          "Vector3Int",
+          "Color",
+          "Dictionary",
+          "List",
+          "Class",
+          "Enum",
+          "Lookup",
+          "DialogueLookup",
+          "Sprite",
+          "Audio",
+          "Generic"
+        ],
+        NeoSystemProtectionKind: [
+          "WorldAuthoring",
+          "DialogueMemorySchema",
+          "DialogueMemoryContainer",
+          "DialoguePriorityDefault",
+          "PolicyImmutable",
+          "PolicyDeleteBlocked",
+          "ScriptRuntime"
+        ],
+        NeoMemberRequirement: ["Optional", "Required"],
+        NeoMemberMutability: ["Mutable", "ReadOnly"],
+        NeoMemberModifier: ["Virtual", "Sealed", "Abstract", "Static"],
+        NeoMemberAccess: ["Public", "Protected", "Private"],
+        NeoMemberSelection: ["Single", "Multi"],
+        NeoFunctionDispatch: ["Synchronous", "Asynchronous"],
+        NeoMemberPayload: ["Full", "Partial"],
+        NeoFunctionLogicMode: ["UI"],
+        NeoWorldKind: [
+          "CellPattern",
+          "None",
+          "TileGrid",
+          "TileLayer",
+          "ObjectLayer",
+          "Tile",
+          "ObjectBase",
+          "LayerGroupBase",
+          "SpriteObject",
+          "Object",
+          "TileLayerLink",
+          "ObjectLayerLink",
+          "PlacementTile",
+          "ObjectCollider",
+          "SortingGroup",
+          "SortingLayer",
+          "SmartTile",
+          "SmartTileRule",
+          "SmartTileNeighbor",
+          "AnimationClip",
+          "AnimationFrame",
+          "AnimationChildOverride",
+          "AnimationFrameBase",
+          "AnimationSegmentFrame",
+          "AnimationSegment",
+          "SpriteAnimationSegment",
+          "AnimationTrack",
+          "AnimationChildTrack",
+          "AnimationSegmentTrack",
+          "SpriteAnimationSegmentTrack",
+          "Variant",
+          "VariantFolder",
+          "LookupVariant",
+          "LookupVariantFolder"
+        ],
+        NeoTextureType: [
+          "Default",
+          "NormalMap",
+          "EditorGuiAndLegacyGui",
+          "Sprite",
+          "Cursor",
+          "Cookie",
+          "Lightmap",
+          "SingleChannel"
+        ],
+        NeoSpriteMode: ["Single", "Multiple", "Polygon"],
+        NeoSpriteMeshType: ["FullRect", "Tight"],
+        NeoSpriteAlignment: [
+          "Center",
+          "TopLeft",
+          "TopCenter",
+          "TopRight",
+          "LeftCenter",
+          "RightCenter",
+          "BottomLeft",
+          "BottomCenter",
+          "BottomRight",
+          "Custom"
+        ],
+        NeoTextureWrapMode: [
+          "Repeat",
+          "Clamp",
+          "Mirror",
+          "MirrorOnce",
+          "PerAxis"
+        ],
+        NeoTextureFilterMode: ["Point", "Bilinear", "Trilinear"],
+        NeoTextureCompression: [
+          "None",
+          "LowQuality",
+          "NormalQuality",
+          "HighQuality"
+        ],
+        NeoTextureFormat: [
+          "Automatic",
+          "RgbaCompressedDxt5Bc3",
+          "RgbCompressedDxt1Bc1",
+          "Rgba32Bit",
+          "Rgb24Bit"
+        ],
+        NeoAlphaSource: ["None", "InputTextureAlpha", "FromGrayScale"],
+        NeoNonPowerOfTwoScale: ["None", "ToNearest", "ToLarger", "ToSmaller"],
+        NeoNormalMapFiltering: ["Sharp", "Smooth"],
+        NeoCookieLightType: ["Spot", "Directional", "Point"],
+        NeoSingleChannelComponent: ["Alpha", "Red"],
+        NeoTextureSwizzle: ["Red", "Green", "Blue", "Alpha", "Zero", "One"],
+        NeoMipMapFiltering: ["Box", "Kaiser"],
+        NeoTextureResizeAlgorithm: ["Mitchell", "Bilinear"],
+        NeoAudioLoadType: [
+          "DecompressOnLoad",
+          "CompressedInMemory",
+          "Streaming"
+        ],
+        NeoAudioCompressionFormat: ["Pcm", "Adpcm", "Vorbis"],
+        NeoAudioSampleRate: [
+          "PreserveSampleRate",
+          "OptimizeSampleRate",
+          "OverrideSampleRate"
+        ]
+      },
+      classes: {
+        NeoClassRelationDefinition: {
+          constructors: [
+            [{ type: "Type", name: "target", assigns: "Target" }],
+            [
+              { type: "string?", name: "id", assigns: "Id" },
+              { type: "Type", name: "target", assigns: "Target" }
+            ]
+          ],
+          properties: [
+            { type: "string?", name: "Id" },
+            { type: "Type", name: "Target", default: "typeof(object)" }
+          ]
+        },
+        NeoGridRelationSettings: [
+          {
+            type: "List<NeoClassRelationDefinition>",
+            name: "TileImports",
+            default: "new List<NeoClassRelationDefinition>()"
+          },
+          {
+            type: "List<NeoClassRelationDefinition>",
+            name: "ObjectImports",
+            default: "new List<NeoClassRelationDefinition>()"
+          },
+          {
+            type: "List<NeoClassRelationDefinition>",
+            name: "TileLayers",
+            default: "new List<NeoClassRelationDefinition>()"
+          },
+          {
+            type: "List<NeoClassRelationDefinition>",
+            name: "ObjectLayers",
+            default: "new List<NeoClassRelationDefinition>()"
+          }
+        ],
+        NeoTileRelationSettings: [
+          {
+            type: "List<NeoClassRelationDefinition>",
+            name: "CompatibleLayers",
+            default: "new List<NeoClassRelationDefinition>()"
+          },
+          { type: "NeoClassRelationDefinition?", name: "DefaultLayer" }
+        ],
+        NeoObjectRelationSettings: [
+          {
+            type: "List<NeoClassRelationDefinition>",
+            name: "CompatibleLayers",
+            default: "new List<NeoClassRelationDefinition>()"
+          },
+          { type: "NeoClassRelationDefinition?", name: "DefaultLayer" }
+        ],
+        NeoTileLayerLinkRelationSettings: [
+          { type: "NeoClassRelationDefinition?", name: "TargetLayer" }
+        ],
+        NeoObjectLayerLinkRelationSettings: [
+          { type: "NeoClassRelationDefinition?", name: "TargetLayer" }
+        ],
+        NeoEntrySettings: [
+          { type: "string?", name: "Id" },
+          { type: "string", name: "Path", default: "string.Empty" },
+          { type: "NeoEntryKind", name: "Kind" },
+          {
+            type: "NeoMemberRequirement",
+            name: "Requirement",
+            default: "NeoMemberRequirement.Optional"
+          },
+          {
+            type: "NeoMemberMutability",
+            name: "Mutability",
+            default: "NeoMemberMutability.Mutable"
+          },
+          {
+            type: "NeoMemberModifier",
+            name: "Modifier",
+            default: "NeoMemberModifier.Virtual"
+          },
+          {
+            type: "NeoMemberAccess",
+            name: "Access",
+            default: "NeoMemberAccess.Public"
+          },
+          { type: "NeoMemberReference?", name: "Overrides" },
+          {
+            type: "NeoStorage",
+            name: "Storage",
+            default: "NeoStorage.Inherit"
+          },
+          { type: "string?", name: "StorageKey" },
+          { type: "NeoValueSettings?", name: "Default" },
+          { type: "NeoTextSettings?", name: "Text" },
+          { type: "NeoNumberSettings?", name: "Number" },
+          { type: "NeoDictionarySettings?", name: "Dictionary" },
+          { type: "NeoListSettings?", name: "List" },
+          { type: "NeoLookupSettings?", name: "Lookup" },
+          { type: "NeoDialogueSettings?", name: "Dialogue" },
+          { type: "NeoFileSettings?", name: "File" },
+          { type: "NeoClassSettings?", name: "Class" },
+          { type: "NeoEnumSettings?", name: "Enum" },
+          { type: "NeoGenericSettings?", name: "Generic" },
+          { type: "NeoSystemSettings?", name: "System" },
+          {
+            type: "IReadOnlyList<NeoEntrySettings>",
+            name: "Entries",
+            default: "new List<NeoEntrySettings>()"
+          }
+        ],
+        NeoValueSettings: [
+          { type: "bool", name: "IsNull" },
+          { type: "Type?", name: "ConcreteType" },
+          { type: "bool?", name: "Boolean" },
+          { type: "long?", name: "Integer" },
+          { type: "double?", name: "Number" },
+          { type: "string?", name: "Text" },
+          { type: "decimal?", name: "Decimal" },
+          { type: "NeoVector2?", name: "Vector2" },
+          { type: "NeoVector2Int?", name: "Vector2Int" },
+          { type: "NeoVector3?", name: "Vector3" },
+          { type: "NeoVector3Int?", name: "Vector3Int" },
+          { type: "NeoColor?", name: "Color" },
+          { type: "NeoSprite?", name: "Sprite" },
+          { type: "NeoAudio?", name: "Audio" },
+          { type: "NeoDialogue?", name: "Dialogue" },
+          { type: "NeoReferenceSettings?", name: "Reference" },
+          { type: "string?", name: "EnumOption" },
+          { type: "IReadOnlyList<NeoValueSettings>?", name: "List" },
+          {
+            type: "IReadOnlyDictionary<string, NeoValueSettings>?",
+            name: "Dictionary"
+          },
+          {
+            type: "IReadOnlyDictionary<string, NeoValueSettings>?",
+            name: "Object"
+          }
+        ],
+        NeoReferenceSettings: [
+          { type: "Type", name: "Type", default: "typeof(object)" },
+          { type: "string", name: "Id", default: "string.Empty" }
+        ],
+        NeoTextSettings: [
+          {
+            type: "NeoStringFormat",
+            name: "Format",
+            default: "NeoStringFormat.Localized"
+          },
+          {
+            type: "NeoMemberSearchBy",
+            name: "SearchBy",
+            default: "NeoMemberSearchBy.None"
+          }
+        ],
+        NeoNumberSettings: [
+          { type: "double?", name: "Min" },
+          { type: "double?", name: "Max" },
+          { type: "string?", name: "DecimalMin" },
+          { type: "string?", name: "DecimalMax" },
+          { type: "int?", name: "DecimalPoints" }
+        ],
+        NeoFunctionSettings: [{ type: "NeoFunctionLogicMode", name: "Logic" }],
+        NeoDictionarySettings: [
+          { type: "NeoDictionaryKeyKind", name: "KeyKind" },
+          { type: "Type?", name: "KeyEnum" }
+        ],
+        NeoClassSettings: [
+          { type: "Type", name: "Type", default: "typeof(object)" },
+          { type: "IReadOnlyList<string>?", name: "SchemaOrder" },
+          {
+            type: "IReadOnlyDictionary<string, NeoGenericBindingSettings>?",
+            name: "TypeArguments"
+          }
+        ],
+        NeoGenericBindingSettings: [
+          { type: "string", name: "Parameter", default: "string.Empty" },
+          { type: "string?", name: "GenericParameter" },
+          { type: "NeoEntrySettings?", name: "Member" }
+        ],
+        NeoEnumSettings: [
+          { type: "Type", name: "Enum", default: "typeof(object)" },
+          {
+            type: "NeoMemberSelection",
+            name: "Selection",
+            default: "NeoMemberSelection.Single"
+          }
+        ],
+        NeoGenericSettings: [
+          { type: "string", name: "Parameter", default: "string.Empty" }
+        ],
+        NeoLookupSettings: [
+          { type: "string", name: "CollectionMember", default: "string.Empty" },
+          { type: "string?", name: "CollectionValueMember" },
+          {
+            type: "NeoMemberSelection",
+            name: "Selection",
+            default: "NeoMemberSelection.Single"
+          }
+        ],
+        /**
+         * Class-level settings. `TargetMember` names the member of another
+         * class this class writes — schema metadata rather than row data, the
+         * same shape `NeoLookupSettings.CollectionMember` uses to name a
+         * collection.
+         */
+        NeoClassSchemaSettings: [
+          { type: "string", name: "TargetMember", default: "string.Empty" }
+        ],
+        NeoDialogueSettings: [
+          { type: "string?", name: "Group" },
+          {
+            type: "NeoMemberSelection",
+            name: "Selection",
+            default: "NeoMemberSelection.Single"
+          }
+        ],
+        NeoFileSettings: [
+          { type: "NeoFileKind", name: "Kind" },
+          { type: "Type?", name: "Template" }
+        ],
+        NeoSystemSettings: [
+          {
+            type: "NeoSystemProtectionKind",
+            name: "Kind",
+            default: "NeoSystemProtectionKind.WorldAuthoring"
+          },
+          { type: "NeoWorldKind?", name: "WorldKind" }
+        ],
+        NeoListSettings: [
+          { type: "NeoListKind", name: "Kind", default: "NeoListKind.Ordered" },
+          {
+            type: "IReadOnlyList<NeoListIndexSettings>",
+            name: "Indexes",
+            default: "new List<NeoListIndexSettings>()"
+          },
+          {
+            type: "IReadOnlyList<NeoListColumnSettings>",
+            name: "Columns",
+            default: "new List<NeoListColumnSettings>()"
+          }
+        ],
+        NeoListIndexSettings: [
+          { type: "string", name: "Member", default: "string.Empty" },
+          {
+            type: "NeoListIndexKind",
+            name: "Kind",
+            default: "NeoListIndexKind.Bucket"
+          }
+        ],
+        NeoListColumnSettings: [
+          { type: "string", name: "Member", default: "string.Empty" },
+          { type: "int?", name: "Width" },
+          {
+            type: "NeoColumnVisibility",
+            name: "Visibility",
+            default: "NeoColumnVisibility.Visible"
+          },
+          {
+            type: "NeoColumnPin",
+            name: "Pin",
+            default: "NeoColumnPin.None"
+          },
+          {
+            type: "NeoColumnOverflow",
+            name: "Overflow",
+            default: "NeoColumnOverflow.Clip"
+          }
+        ],
+        NeoTextureTemplateSettings: [
+          { type: "string", name: "Name", default: "string.Empty" },
+          {
+            type: "NeoTextureType",
+            name: "TextureType",
+            default: "NeoTextureType.Sprite"
+          },
+          { type: "bool", name: "SrgbTexture", default: "true" },
+          {
+            type: "NeoAlphaSource",
+            name: "AlphaSource",
+            default: "NeoAlphaSource.InputTextureAlpha"
+          },
+          { type: "bool", name: "AlphaIsTransparency", default: "true" },
+          { type: "NeoNonPowerOfTwoScale", name: "NonPowerOfTwoScale" },
+          { type: "bool", name: "IgnorePngGamma" },
+          { type: "bool", name: "ReadWriteEnabled" },
+          { type: "bool", name: "VirtualTextureOnly" },
+          { type: "bool", name: "GenerateMipMaps" },
+          { type: "bool", name: "BorderMipMaps" },
+          { type: "NeoMipMapFiltering", name: "MipMapFiltering" },
+          { type: "bool", name: "MipMapsPreserveCoverage" },
+          { type: "double", name: "AlphaCutoffValue", default: "0.5" },
+          { type: "bool", name: "FadeOutMipMaps" },
+          { type: "int", name: "MipMapFadeDistanceStart", default: "1" },
+          { type: "int", name: "MipMapFadeDistanceEnd", default: "3" },
+          { type: "int", name: "AnisoLevel", default: "1" },
+          {
+            type: "NeoTextureWrapMode",
+            name: "WrapMode",
+            default: "NeoTextureWrapMode.Clamp"
+          },
+          { type: "NeoTextureWrapMode?", name: "WrapModeU" },
+          { type: "NeoTextureWrapMode?", name: "WrapModeV" },
+          {
+            type: "NeoTextureFilterMode",
+            name: "FilterMode",
+            default: "NeoTextureFilterMode.Point"
+          },
+          { type: "int", name: "MaxTextureSize", default: "2048" },
+          { type: "NeoTextureResizeAlgorithm", name: "ResizeAlgorithm" },
+          { type: "NeoTextureCompression", name: "TextureCompression" },
+          { type: "int", name: "CompressionQuality", default: "50" },
+          { type: "bool", name: "CrunchedCompression" },
+          {
+            type: "NeoTexturePlatformSettings",
+            name: "Platforms",
+            default: "new()"
+          },
+          { type: "NeoSpriteSettings?", name: "Sprite" },
+          { type: "NeoNormalMapSettings?", name: "NormalMap" },
+          { type: "NeoCookieSettings?", name: "Cookie" },
+          { type: "NeoSingleChannelSettings?", name: "SingleChannel" },
+          { type: "NeoSwizzleSettings?", name: "Swizzle" }
+        ],
+        NeoTexturePlatformSettings: [
+          {
+            type: "NeoTexturePlatformEntry",
+            name: "Default",
+            default: "new()"
+          },
+          {
+            type: "NeoTexturePlatformEntry",
+            name: "Standalone",
+            default: "new()"
+          },
+          { type: "NeoTexturePlatformEntry", name: "Web", default: "new()" }
+        ],
+        NeoTexturePlatformEntry: [
+          { type: "bool", name: "Override" },
+          { type: "int", name: "MaxTextureSize", default: "2048" },
+          { type: "NeoTextureResizeAlgorithm", name: "ResizeAlgorithm" },
+          { type: "NeoTextureFormat", name: "Format" },
+          { type: "NeoTextureCompression", name: "TextureCompression" },
+          { type: "bool", name: "CrunchedCompression" },
+          { type: "int", name: "CompressionQuality", default: "50" }
+        ],
+        NeoSpriteSettings: [
+          {
+            type: "NeoSpriteMode",
+            name: "Mode",
+            default: "NeoSpriteMode.Multiple"
+          },
+          { type: "double", name: "PixelsPerUnit", default: "100" },
+          {
+            type: "NeoSpriteMeshType",
+            name: "MeshType",
+            default: "NeoSpriteMeshType.Tight"
+          },
+          { type: "int", name: "ExtrudeEdges", default: "1" },
+          { type: "NeoSpriteAlignment", name: "PivotAlignment" },
+          { type: "NeoVector2", name: "Pivot", default: "new(0.5, 0.5)" },
+          { type: "bool", name: "GeneratePhysicsShape", default: "true" },
+          { type: "NeoSpriteSliceSettings?", name: "Slice" }
+        ],
+        NeoSpriteSliceSettings: [
+          { type: "NeoVector2", name: "PixelSize" },
+          { type: "NeoVector2", name: "Offset" },
+          { type: "NeoVector2", name: "Padding" },
+          { type: "bool", name: "KeepEmptyRects" },
+          { type: "NeoSpriteAlignment", name: "PivotAlignment" },
+          { type: "NeoVector2", name: "Pivot" },
+          { type: "NeoVector4", name: "Border" },
+          { type: "string", name: "NamingPattern", default: '"{0}"' },
+          { type: "int", name: "NamingStartIndex" },
+          { type: "bool", name: "ColumnMajor" }
+        ],
+        NeoNormalMapSettings: [
+          { type: "bool", name: "CreateFromGrayscale" },
+          { type: "double", name: "Bumpiness", default: "0.25" },
+          {
+            type: "NeoNormalMapFiltering",
+            name: "Filtering",
+            default: "NeoNormalMapFiltering.Smooth"
+          },
+          { type: "bool", name: "FlipGreenChannel" }
+        ],
+        NeoCookieSettings: [{ type: "NeoCookieLightType", name: "LightType" }],
+        NeoSingleChannelSettings: [
+          { type: "NeoSingleChannelComponent", name: "Component" }
+        ],
+        NeoSwizzleSettings: [
+          {
+            type: "NeoTextureSwizzle",
+            name: "R",
+            default: "NeoTextureSwizzle.Red"
+          },
+          {
+            type: "NeoTextureSwizzle",
+            name: "G",
+            default: "NeoTextureSwizzle.Green"
+          },
+          {
+            type: "NeoTextureSwizzle",
+            name: "B",
+            default: "NeoTextureSwizzle.Blue"
+          },
+          {
+            type: "NeoTextureSwizzle",
+            name: "A",
+            default: "NeoTextureSwizzle.Alpha"
+          }
+        ],
+        NeoAudioTemplateSettings: [
+          { type: "string", name: "Name", default: "string.Empty" },
+          { type: "bool", name: "ForceToMono" },
+          { type: "bool", name: "Normalize" },
+          { type: "bool", name: "LoadInBackground" },
+          { type: "bool", name: "Ambisonic" },
+          { type: "NeoAudioLoadType", name: "LoadType" },
+          {
+            type: "NeoAudioCompressionFormat",
+            name: "CompressionFormat",
+            default: "NeoAudioCompressionFormat.Vorbis"
+          },
+          { type: "double", name: "Quality", default: "1" },
+          { type: "NeoAudioSampleRate", name: "SampleRate" },
+          { type: "int?", name: "OverrideSampleRate" },
+          { type: "bool", name: "PreloadAudioData", default: "true" }
+        ],
+        NeoLocalizationSettings: [
+          { type: "string", name: "MainLocale", default: '"en-US"' },
+          {
+            type: "IReadOnlyList<NeoLocaleSettings>",
+            name: "Locales",
+            default: "new List<NeoLocaleSettings>()"
+          },
+          {
+            type: "IReadOnlyList<string>",
+            name: "StatusIds",
+            default: "new List<string>()"
+          },
+          {
+            type: "string",
+            name: "MainLocaleDefaultStatus",
+            default: "string.Empty"
+          }
+        ],
+        NeoLocaleSettings: [
+          { type: "string", name: "Locale", default: "string.Empty" },
+          { type: "string?", name: "SourceLocale" },
+          { type: "string?", name: "Name" },
+          { type: "int", name: "Order" },
+          { type: "long?", name: "ArchivedAt" }
+        ],
+        NeoLocalizationStatusSettings: [
+          { type: "string", name: "Slug", default: "string.Empty" },
+          { type: "string", name: "Name", default: "string.Empty" },
+          { type: "string?", name: "Description" },
+          { type: "string?", name: "Color" },
+          { type: "string?", name: "Emoji" },
+          { type: "long?", name: "ArchivedAt" },
+          { type: "IReadOnlyList<string>?", name: "TransitionRules" },
+          { type: "string?", name: "TransitionOnTextEdit" },
+          { type: "string?", name: "TransitionWhenSourceBecomes" },
+          { type: "NeoSystemSettings?", name: "System" }
+        ]
+      },
+      records: {
+        NeoProjectRecordReference: {
+          kind: "readonly record struct",
+          catalog: true,
+          parameters: [
+            { type: "NeoProjectRecordKind", name: "Kind" },
+            { type: "string", name: "Id" }
+          ]
+        },
+        NeoInternalRecordRelationDefinition: {
+          kind: "sealed record",
+          catalog: true,
+          parameters: [
+            { type: "string?", name: "Id" },
+            { type: "string", name: "RelationKind" },
+            { type: "NeoProjectRecordReference", name: "Source" },
+            { type: "NeoProjectRecordReference", name: "Target" }
+          ]
+        },
+        NeoVector2: {
+          kind: "readonly record struct",
+          parameters: [
+            { type: "double", name: "X" },
+            { type: "double", name: "Y" }
+          ]
+        },
+        NeoVector2Int: {
+          kind: "readonly record struct",
+          parameters: [
+            { type: "int", name: "X" },
+            { type: "int", name: "Y" }
+          ]
+        },
+        NeoVector3: {
+          kind: "readonly record struct",
+          parameters: [
+            { type: "double", name: "X" },
+            { type: "double", name: "Y" },
+            { type: "double", name: "Z" }
+          ]
+        },
+        NeoVector3Int: {
+          kind: "readonly record struct",
+          parameters: [
+            { type: "int", name: "X" },
+            { type: "int", name: "Y" },
+            { type: "int", name: "Z" }
+          ]
+        },
+        NeoVector4: {
+          kind: "readonly record struct",
+          parameters: [
+            { type: "double", name: "X" },
+            { type: "double", name: "Y" },
+            { type: "double", name: "Z" },
+            { type: "double", name: "W" }
+          ]
+        },
+        NeoColor: {
+          kind: "readonly record struct",
+          parameters: [
+            { type: "double", name: "R" },
+            { type: "double", name: "G" },
+            { type: "double", name: "B" },
+            { type: "double", name: "A" }
+          ]
+        },
+        NeoSprite: {
+          kind: "sealed record",
+          parameters: [
+            { type: "string", name: "FileId" },
+            { type: "int", name: "SliceIndex" }
+          ]
+        },
+        NeoAudio: {
+          kind: "sealed record",
+          parameters: [{ type: "string", name: "FileId" }]
+        },
+        NeoDialogue: {
+          kind: "sealed record",
+          parameters: [{ type: "string", name: "DialogueId" }]
+        },
+        "NeoLookup<T>": {
+          kind: "sealed record",
+          parameters: [{ type: "string", name: "ValueId" }]
+        },
+        NeoMemberReference: {
+          kind: "readonly record struct",
+          parameters: [{ type: "string", name: "Id" }]
+        }
+      },
+      intrinsics: {
+        Neo: [
+          {
+            typeParameters: "<T>",
+            returnType: "T",
+            name: "Ref",
+            parameters: [{ type: "string", name: "id" }],
+            expression: "default!"
+          },
+          {
+            typeParameters: "<T>",
+            returnType: "NeoLookup<T>",
+            name: "Lookup",
+            parameters: [{ type: "string", name: "id" }],
+            expression: "new(id)"
+          },
+          {
+            returnType: "NeoDialogue",
+            name: "Dialogue",
+            parameters: [{ type: "string", name: "id" }],
+            expression: "new(id)"
+          },
+          {
+            returnType: "NeoSprite",
+            name: "Sprite",
+            parameters: [
+              { type: "string", name: "fileId" },
+              { type: "int", name: "sliceIndex", default: "0" }
+            ],
+            expression: "new(fileId, sliceIndex)"
+          },
+          {
+            returnType: "NeoAudio",
+            name: "Audio",
+            parameters: [{ type: "string", name: "fileId" }],
+            expression: "new(fileId)"
+          },
+          {
+            returnType: "NeoMemberReference",
+            name: "Member",
+            parameters: [{ type: "string", name: "id" }],
+            expression: "new(id)"
+          }
+        ]
+      }
+    }
+  }
+});
+
 // src/project-source/workspace-status-core.ts
 var ANIMATION_DOCUMENT_RECORD_KINDS = [
   ProjectRecordKind.Project,
@@ -54734,6 +56379,16 @@ var WORLD_OBJECT_CONTRACT_WORLD_KINDS = /* @__PURE__ */ new Set([
   NeoWorldSystemClassKind.SpriteObject
 ]);
 
+// ../src/models/exports/unity-codegen-revision.ts
+var UNITY_CODEGEN_REVISION = "45a0847addd4616acfc29f142556dcb2e0a27daae14d6aa456430228e66dbc07";
+
+// src/export-cache.ts
+var CACHE_BUILD = JSON.stringify([
+  PROJECT_SCHEMA_CONTRACT.cliVersion,
+  NEOSCRIPT_COMPILER_REVISION,
+  UNITY_CODEGEN_REVISION
+]);
+
 // src/export-state.ts
 import { join } from "node:path";
 var EXPORT_STATE_FILE = join(".neo", "export.json");