@neocompose/cli 0.71.4 → 0.72.1

package/dist/test-worker.mjs

@@ -880,10 +880,10 @@ import { parentPort } from "node:worker_threads";
 
 // ../src/models/members/member-storage.ts
 function isMemberStorageKind(value) {
-  return value === 0 /* Inherit */ || value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */ || value === 4 /* Writable */;
+  return value === 0 /* Inherit */ || value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */ || value === 4 /* Writable */ || value === 5 /* User */;
 }
 function isEffectiveMemberStorage(value) {
-  return value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */;
+  return value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */ || value === 5 /* User */;
 }
 function isClassAllowedStorage(value) {
   if (!isMemberStorageKind(value)) return false;
@@ -894,7 +894,7 @@ function childEffectiveStorage(declared, parent) {
     case 0 /* Inherit */:
       return parent;
     case 4 /* Writable */:
-      return parent === 2 /* Save */ ? 2 /* Save */ : 3 /* Session */;
+      return parent === 2 /* Save */ || parent === 5 /* User */ ? parent : 3 /* Session */;
     default:
       return declared;
   }
@@ -1124,6 +1124,176 @@ function memberKindSupportsDistribution(kind) {
   return memberKindSupportsStorage(kind);
 }
 
+// node_modules/uuid/dist-node/regex.js
+var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+
+// node_modules/uuid/dist-node/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default = validate;
+
+// node_modules/uuid/dist-node/parse.js
+function parse(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  let v;
+  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
+}
+var parse_default = parse;
+
+// node_modules/uuid/dist-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// node_modules/uuid/dist-node/rng.js
+var rnds8 = new Uint8Array(16);
+function rng() {
+  return crypto.getRandomValues(rnds8);
+}
+
+// node_modules/uuid/dist-node/v35.js
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str));
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; ++i) {
+    bytes[i] = str.charCodeAt(i);
+  }
+  return bytes;
+}
+var DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+var URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+function v35(version, hash, value, namespace, buf, offset) {
+  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
+  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
+  if (typeof namespace === "string") {
+    namespace = parse_default(namespace);
+  }
+  if (namespace?.length !== 16) {
+    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
+  }
+  let bytes = new Uint8Array(16 + valueBytes.length);
+  bytes.set(namespaceBytes);
+  bytes.set(valueBytes, namespaceBytes.length);
+  bytes = hash(bytes);
+  bytes[6] = bytes[6] & 15 | version;
+  bytes[8] = bytes[8] & 63 | 128;
+  if (buf) {
+    offset ??= 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = bytes[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(bytes);
+}
+
+// node_modules/uuid/dist-node/v4.js
+function v4(options, buf, offset) {
+  if (!buf && !options && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
+function _v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// node_modules/uuid/dist-node/sha1.js
+import { createHash } from "node:crypto";
+function sha1(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === "string") {
+    bytes = Buffer.from(bytes, "utf8");
+  }
+  return createHash("sha1").update(bytes).digest();
+}
+var sha1_default = sha1;
+
+// node_modules/uuid/dist-node/v5.js
+function v5(value, namespace, buf, offset) {
+  return v35(80, sha1_default, value, namespace, buf, offset);
+}
+v5.DNS = DNS;
+v5.URL = URL2;
+var v5_default = v5;
+
+// ../src/models/project/project-root-members.ts
+var PROJECT_ROOTS = [
+  {
+    key: "Assets",
+    choice: "assets",
+    projectField: "rootAssetsMemberId",
+    label: "Assets",
+    storage: 1 /* Immutable */
+  },
+  {
+    key: "Save",
+    choice: "save",
+    projectField: "rootSaveFileMemberId",
+    label: "Save",
+    storage: 2 /* Save */
+  },
+  {
+    key: "Session",
+    choice: "session",
+    projectField: "rootSessionMemberId",
+    label: "Session",
+    storage: 3 /* Session */
+  },
+  {
+    key: "User",
+    choice: "user",
+    projectField: "rootUserMemberId",
+    label: "User",
+    storage: 5 /* User */
+  }
+];
+function projectRootMemberIds(project) {
+  return PROJECT_ROOTS.map((root) => project[root.projectField]);
+}
+function buildRootStorageMap(project) {
+  const map = /* @__PURE__ */ new Map();
+  for (const root of PROJECT_ROOTS) {
+    map.set(project[root.projectField], root.storage);
+  }
+  return map;
+}
+function projectRootMembersInDisplayOrder(project) {
+  return PROJECT_ROOTS.map((root) => ({
+    root,
+    memberId: project[root.projectField]
+  }));
+}
+
 // ../src/models/core/structural-narrow.ts
 function isObject(value) {
   if (typeof value !== "object") return false;
@@ -4889,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;
@@ -4944,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);
@@ -5053,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();
@@ -5133,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);
@@ -5207,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();
@@ -5291,128 +5471,6 @@ function descendantClassIdsInChildIndex(classId, childrenByClassId) {
   return result;
 }
 
-// node_modules/uuid/dist-node/regex.js
-var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
-
-// node_modules/uuid/dist-node/validate.js
-function validate(uuid) {
-  return typeof uuid === "string" && regex_default.test(uuid);
-}
-var validate_default = validate;
-
-// node_modules/uuid/dist-node/parse.js
-function parse(uuid) {
-  if (!validate_default(uuid)) {
-    throw TypeError("Invalid UUID");
-  }
-  let v;
-  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
-}
-var parse_default = parse;
-
-// node_modules/uuid/dist-node/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-// node_modules/uuid/dist-node/rng.js
-var rnds8 = new Uint8Array(16);
-function rng() {
-  return crypto.getRandomValues(rnds8);
-}
-
-// node_modules/uuid/dist-node/v35.js
-function stringToBytes(str) {
-  str = unescape(encodeURIComponent(str));
-  const bytes = new Uint8Array(str.length);
-  for (let i = 0; i < str.length; ++i) {
-    bytes[i] = str.charCodeAt(i);
-  }
-  return bytes;
-}
-var DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
-var URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
-function v35(version, hash, value, namespace, buf, offset) {
-  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
-  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
-  if (typeof namespace === "string") {
-    namespace = parse_default(namespace);
-  }
-  if (namespace?.length !== 16) {
-    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
-  }
-  let bytes = new Uint8Array(16 + valueBytes.length);
-  bytes.set(namespaceBytes);
-  bytes.set(valueBytes, namespaceBytes.length);
-  bytes = hash(bytes);
-  bytes[6] = bytes[6] & 15 | version;
-  bytes[8] = bytes[8] & 63 | 128;
-  if (buf) {
-    offset ??= 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = bytes[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(bytes);
-}
-
-// node_modules/uuid/dist-node/v4.js
-function v4(options, buf, offset) {
-  if (!buf && !options && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return _v4(options, buf, offset);
-}
-function _v4(options, buf, offset) {
-  options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-var v4_default = v4;
-
-// node_modules/uuid/dist-node/sha1.js
-import { createHash } from "node:crypto";
-function sha1(bytes) {
-  if (Array.isArray(bytes)) {
-    bytes = Buffer.from(bytes);
-  } else if (typeof bytes === "string") {
-    bytes = Buffer.from(bytes, "utf8");
-  }
-  return createHash("sha1").update(bytes).digest();
-}
-var sha1_default = sha1;
-
-// node_modules/uuid/dist-node/v5.js
-function v5(value, namespace, buf, offset) {
-  return v35(80, sha1_default, value, namespace, buf, offset);
-}
-v5.DNS = DNS;
-v5.URL = URL2;
-var v5_default = v5;
-
 // ../src/models/system-record-id.ts
 var SYSTEM_RECORD_ID_PREFIX = "system_";
 function isSystemRecordId(id) {
@@ -7440,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;
     }
@@ -7486,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;
@@ -8233,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,
@@ -8240,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) {
@@ -8999,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
     };
@@ -10231,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;
     },
@@ -10260,7 +10333,7 @@ function withIndexedDefaultValueDocument(document2, options = {}) {
     },
     memberDefaultSettlesConstruction: (member, environment) => {
       cache.memberDefaultConstructionChecker ??= createMemberDefaultConstructionChecker({
-        ...document2,
+        ...indexed,
         constructors: document2.constructors ?? []
       });
       return cache.memberDefaultConstructionChecker(member, environment);
@@ -11031,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
   )) {
@@ -11177,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 {
@@ -11753,6 +11828,38 @@ var EffectiveStorageResolver = class {
     (id) => this.schemaIndex.member(id)
   );
   resolving = /* @__PURE__ */ new Set();
+  allowedByClassId = /* @__PURE__ */ new Map();
+  userClasses;
+  /**
+   * `resolveAllowedStorage` over this context, memoized along each extends
+   * chain so a whole-document pass stays O(classes).
+   */
+  allowedStorage(classId) {
+    const cached = this.allowedByClassId.get(classId);
+    if (cached !== void 0) return cached;
+    this.allowedByClassId.set(classId, null);
+    const schemaClass2 = this.schemaIndex.classesById.get(classId);
+    let resolved = null;
+    if (schemaClass2?.allowedStorage != null) {
+      resolved = schemaClass2.allowedStorage;
+    } else if (schemaClass2?.extendsClassId !== void 0) {
+      resolved = this.allowedStorage(schemaClass2.extendsClassId);
+    }
+    this.allowedByClassId.set(classId, resolved);
+    return resolved;
+  }
+  /** P104 §1.3: classes whose resolved `allowedStorage` is `User`. */
+  userClassIds() {
+    if (this.userClasses === void 0) {
+      this.userClasses = /* @__PURE__ */ new Set();
+      for (const schemaClass2 of this.ctx.classes) {
+        if (this.allowedStorage(schemaClass2.id) === 5 /* User */) {
+          this.userClasses.add(schemaClass2.id);
+        }
+      }
+    }
+    return this.userClasses;
+  }
   /** Declared storage of `memberId`, resolved through the extends chain. */
   declaredStorage(memberId) {
     return declaredMemberStorageFromIndex(
@@ -11796,7 +11903,7 @@ var EffectiveStorageResolver = class {
           result.add(declared);
         } else if (isStaticMember(this.schemaIndex.member(memberId))) {
           const declaringClassId = this.schemaIndex.firstSchemaPlacement(memberId)?.ownerClass.id;
-          const constraint = declaringClassId === void 0 ? null : resolveAllowedStorage(declaringClassId, this.ctx.classes);
+          const constraint = declaringClassId === void 0 ? null : this.allowedStorage(declaringClassId);
           result.add(
             childEffectiveStorage(
               declared,
@@ -11899,6 +12006,11 @@ var EffectiveStorageResolver = class {
   member(memberId) {
     return this.schemaIndex.member(memberId);
   }
+  /** `Owner.Member` for a schema member, else the member's own name. */
+  placementLabel(member) {
+    const owner = this.schemaIndex.firstSchemaPlacement(member.id)?.ownerClass;
+    return owner === void 0 ? member.name : `${owner.name}.${member.name}`;
+  }
   buildParentEdges() {
     const addEdge = (childId, parentId) => {
       const existing = this.parentIdsByMemberId.get(childId);
@@ -12831,44 +12943,6 @@ function visitTypedAggregateRowReferences(value, rawType, visitor) {
   }
 }
 
-// ../src/models/project/project-root-members.ts
-var PROJECT_ROOTS = [
-  {
-    key: "Assets",
-    choice: "assets",
-    projectField: "rootAssetsMemberId",
-    label: "Assets",
-    storage: 1 /* Immutable */
-  },
-  {
-    key: "Save",
-    choice: "save",
-    projectField: "rootSaveFileMemberId",
-    label: "Save",
-    storage: 2 /* Save */
-  },
-  {
-    key: "Session",
-    choice: "session",
-    projectField: "rootSessionMemberId",
-    label: "Session",
-    storage: 3 /* Session */
-  }
-];
-function buildRootStorageMap(project) {
-  const map = /* @__PURE__ */ new Map();
-  for (const root of PROJECT_ROOTS) {
-    map.set(project[root.projectField], root.storage);
-  }
-  return map;
-}
-function projectRootMembersInDisplayOrder(project) {
-  return PROJECT_ROOTS.map((root) => ({
-    root,
-    memberId: project[root.projectField]
-  }));
-}
-
 // ../src/runtime/neoscript/initializer-dependencies.ts
 var PendingInitializerDependency = class extends NSGetterRuntimeError {
   constructor(valueId) {
@@ -12955,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(
@@ -13014,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);
@@ -13061,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;
@@ -13080,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;
@@ -13093,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);
       }
@@ -13116,6 +13197,7 @@ function resolveOwnerMembersForValues(document2, targetValueIds, additionalRoots
     );
   }
   for (const root of additionalRoots ?? []) {
+    if (complete) break;
     searchRootMember(
       root.member,
       root.valueId,
@@ -13124,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;
@@ -18751,6 +18835,11 @@ function effectiveStaticStorage(memberId, ctx) {
       `Static member '${memberId}' did not resolve to exactly one effective storage class.`
     );
   }
+  if (storage === 5 /* User */) {
+    throw new NSGetterRuntimeError(
+      `Static member '${memberId}' belongs to a User class. User classes can't declare static stored members.`
+    );
+  }
   return storage;
 }
 function staticBindingTargetId(member, ctx) {
@@ -19503,6 +19592,10 @@ function listenerReceiverOnOwner(memberId, ownerReceiver, ctx) {
   return ownerReceiver;
 }
 function invokeActionListeners(listeners, args, ctx, frame, ownerReceiver, callSiteId) {
+  if (ctx.assertActionInvocable !== void 0) {
+    const ownerRowId = findKnownRowIdByValueReference(ownerReceiver, ctx);
+    if (ownerRowId !== null) ctx.assertActionInvocable(ownerRowId);
+  }
   for (let index = 0; index < listeners.length; index += 1) {
     try {
       invokeDelegateValue(
@@ -21167,17 +21260,9 @@ function classIdForValueRow(row, ctx) {
 function rootMemberForValueRow(row, ctx) {
   if (typeof ctx.rootValue !== "object" || ctx.rootValue === null) return null;
   const rootRecord = ctx.rootValue;
-  const project = ctx.vm.project;
-  if (rootRecord.Assets === row.value) {
-    return evalMemberById(ctx.vm, project.rootAssetsMemberId);
-  }
-  if (rootRecord.Save === row.value) {
-    return evalMemberById(ctx.vm, project.rootSaveFileMemberId);
-  }
-  if (rootRecord.Session === row.value) {
-    return evalMemberById(ctx.vm, project.rootSessionMemberId);
-  }
-  return null;
+  const root = PROJECT_ROOTS.find((root2) => rootRecord[root2.key] === row.value);
+  if (root === void 0) return null;
+  return evalMemberById(ctx.vm, ctx.vm.project[root.projectField]);
 }
 function memberForCustomSchemaValue(classId, schemaKey, ctx) {
   const memberId = cachedMergedSchemaMemberId(classId, schemaKey, ctx);
@@ -21192,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;
@@ -22705,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;
@@ -25824,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,
@@ -26017,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);
         }
       }
     }
@@ -27332,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() {
@@ -27345,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) {
@@ -27354,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)
@@ -27397,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([
   ";",
   ",",
@@ -27546,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) {
@@ -29304,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, {
@@ -29312,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 {
@@ -29815,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,
@@ -29891,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,
@@ -30073,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",
@@ -30512,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;
 }
@@ -30824,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);
@@ -31146,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 };
@@ -31520,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,
@@ -31866,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
@@ -32051,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([
   ["(", ")"],
@@ -33328,6 +33537,136 @@ function isCollectionQueryName(name) {
   return Object.hasOwn(COLLECTION_QUERY_METHODS, name);
 }
 
+// ../packages/neoscript-language/src/project-source-lifecycle-hooks.ts
+var UNITY_LIFECYCLE_INTERFACE_PREFIX = "INeoUnity";
+function isUnityLifecycleInterfaceName(name) {
+  return name.startsWith(UNITY_LIFECYCLE_INTERFACE_PREFIX);
+}
+
+// ../packages/neoscript-language/src/user-safe-types.ts
+var USER_DATA_WRITE_ERROR = "Only User code can change User data. C# changes it through the generated user client.";
+function userUnsafeTypeName(type, project) {
+  return userSafeTypeCheck(project).unsafeName(type);
+}
+var checks = /* @__PURE__ */ new WeakMap();
+function userSafeTypeCheck(project) {
+  let check2 = checks.get(project);
+  if (check2 === void 0) {
+    check2 = new UserSafeTypeCheck(project);
+    checks.set(project, check2);
+  }
+  return check2;
+}
+function userUnsafeTypeMessage(typeName, site) {
+  return `User code can't use \`${typeName}\` in ${site}, because it isn't a User class.`;
+}
+var UserSafeTypeCheck = class {
+  constructor(project) {
+    this.project = project;
+  }
+  project;
+  /** Final interface verdicts. */
+  interfaces = /* @__PURE__ */ new Map();
+  /**
+   * Interfaces whose verdict waits on their cycle (Tarjan's SCC stack),
+   * by stack position. One on the stack reads as safe until its cycle ends.
+   */
+  pending = /* @__PURE__ */ new Map();
+  stack = [];
+  /** The lowest stack position the current interface's check consulted. */
+  lowestConsulted = Infinity;
+  symbolUnsafeName(symbol) {
+    for (const parameter3 of symbol.parameters ?? []) {
+      const name = this.unsafeName(parameter3.type);
+      if (name !== null) return name;
+    }
+    if (symbol.returnType !== void 0) {
+      const name = this.unsafeName(symbol.returnType);
+      if (name !== null) return name;
+    }
+    return this.unsafeName(symbol.type);
+  }
+  unsafeName(type) {
+    switch (type.kind) {
+      case "primitive":
+        return null;
+      case "typeParameter":
+        return type.constraint === void 0 ? null : this.unsafeName(type.constraint);
+      case "list":
+      case "set":
+        return this.unsafeName(type.elementType);
+      case "dictionary":
+        return this.unsafeName(type.keyType) ?? this.unsafeName(type.valueType);
+      case "delegate":
+        return this.firstUnsafe(type.parameterTypes) ?? this.unsafeName(type.returnType);
+      case "action":
+        return this.firstUnsafe(type.parameterTypes);
+      case "named":
+        return this.namedUnsafeName(type.typeId) ?? this.firstUnsafe(type.typeArguments ?? []);
+    }
+  }
+  firstUnsafe(types) {
+    for (const type of types) {
+      const name = this.unsafeName(type);
+      if (name !== null) return name;
+    }
+    return null;
+  }
+  namedUnsafeName(typeId) {
+    const named = this.project.typeById.get(typeId);
+    if (named === void 0) return null;
+    switch (named.kind) {
+      case "enum":
+      case "builtin":
+        return null;
+      case "class":
+        return named.userClass === true ? null : named.name;
+      case "synthetic":
+        return named.name;
+      case "interface":
+        return this.interfaceUnsafeName(named);
+    }
+  }
+  // An interface is unsafe when it reaches an unsafe type, so a cycle alone
+  // proves nothing. Interfaces in one cycle reach each other and share a
+  // verdict, settled once the cycle's first interface finishes; each
+  // interface is scanned once.
+  interfaceUnsafeName(named) {
+    if (isUnityLifecycleInterfaceName(named.name)) return named.name;
+    const cached = this.interfaces.get(named.id);
+    if (cached !== void 0) return cached;
+    const pendingAt = this.pending.get(named.id);
+    if (pendingAt !== void 0) {
+      this.lowestConsulted = Math.min(this.lowestConsulted, pendingAt);
+      return null;
+    }
+    const position = this.stack.length;
+    this.stack.push(named);
+    this.pending.set(named.id, position);
+    const outerLowest = this.lowestConsulted;
+    this.lowestConsulted = Infinity;
+    let unsafe = false;
+    for (const member of named.members) {
+      if (this.symbolUnsafeName(member) === null) continue;
+      unsafe = true;
+      break;
+    }
+    if (unsafe || this.lowestConsulted >= position) {
+      this.settleFrom(position, unsafe);
+      this.lowestConsulted = outerLowest;
+    } else {
+      this.lowestConsulted = Math.min(outerLowest, this.lowestConsulted);
+    }
+    return unsafe ? named.name : null;
+  }
+  settleFrom(position, unsafe) {
+    for (const settled of this.stack.splice(position)) {
+      this.pending.delete(settled.id);
+      this.interfaces.set(settled.id, unsafe ? settled.name : null);
+    }
+  }
+};
+
 // ../packages/neoscript-language/src/tile-conversion.ts
 var NEO_TILE_CONVERT_MEMBER_ID = "system_54ecc5a7-874d-54ed-92f4-38100a4b7465";
 var NEO_TILE_CLASS_ID = "system_d7fa161b-b269-4bf1-9ec9-3aebec67e6e0";
@@ -33503,6 +33842,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
     this.debugPosition = sourcePositionMapper(options.source);
     this.project = projectIndex ?? createProjectIndex(context.project);
+    const lexicalClass = context.declaringType === void 0 ? context.thisClass : context.declaringType;
+    this.userClassCode = lexicalClass?.kind === "named" && this.project.typeById.get(lexicalClass.typeId)?.userClass === true;
+    this.writesUserData = this.userClassCode || context.projectSourceKind === "spec";
     this.listenerParameters = createListenerAnnotationProvider(
       this.project,
       context
@@ -33519,6 +33861,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     const rootSymbol = context.project.roots.find(
       (candidate) => candidate.name === "root"
     );
+    this.rootTypeId = rootSymbol?.type.kind === "named" ? rootSymbol.type.typeId : null;
     this.rootVariable = variable(
       "__root__",
       rootSymbol?.type ?? unknown,
@@ -33574,6 +33917,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   functionControlBoundaries = [];
   debugSource;
   inferredExpressionReturnType;
+  /** P104 §3.1. User class bodies reach only `root.User`. */
+  userClassCode;
+  rootTypeId;
+  /** P104 §3.1. User class and test bodies may write User data. */
+  writesUserData;
   initialScope() {
     const scope = new Scope(null, this.options.onFlowScope !== void 0);
     scope.define(
@@ -35103,6 +35451,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         statement.pos
       );
     }
+    if (writability === "readOnly" /* ReadOnly */ && target.userData) {
+      throw new CompileError(USER_DATA_WRITE_ERROR, statement.pos);
+    }
     if (writability === "readOnly" /* ReadOnly */) {
       throw new CompileError(
         `Cannot assign to a read-only ${this.describe(target.type)} value.`,
@@ -35296,7 +35647,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         statement.pos
       );
     }
-    const writability = observed.writability;
+    const writability = observed.userData ? "runtime" /* Runtime */ : observed.writability;
     if (writability !== "save" /* Save */ && writability !== "session" /* Session */ && writability !== "runtime" /* Runtime */ && writability !== "local" /* Local */) {
       throw new CompileError(
         "OnChanged requires a member whose storage is writable at gameplay runtime.",
@@ -35906,6 +36257,16 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           expression.pos
         );
         const declaredTarget = this.project.typeByName.get(className);
+        if (declaredTarget !== void 0) {
+          this.assertUserSafe(
+            { kind: "named", typeId: declaredTarget.id },
+            "a `new` expression",
+            expression.pos
+          );
+        }
+        if (declaredTarget?.userClass === true && !this.writesUserData && this.context.storedConstructionReplay !== true) {
+          throw new CompileError(USER_DATA_WRITE_ERROR, expression.pos);
+        }
         if (declaredTarget?.kind === "class" && (expression.initializer?.length ?? 0) > 0 && this.context.storedConstructionReplay !== true) {
           return this.resolveExecutableObjectInitializer(
             declaredTarget,
@@ -36899,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.
@@ -37094,7 +37455,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         type: member.type,
         symbol: member,
         ...member.writable ? {
-          writability: member.writability ? toWritability(member.writability) : "setter" /* Setter */
+          writability: member.writability ? toWritability(member.writability, this.writesUserData) : "setter" /* Setter */
         } : {}
       };
     }
@@ -37105,7 +37466,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       },
       type: member.type,
       symbol: member,
-      ...member.writability ? { writability: toWritability(member.writability) } : {}
+      ...member.writability ? {
+        writability: toWritability(member.writability, this.writesUserData)
+      } : {}
     };
   }
   resolveMemberNatural(receiverAst, name, scope, pos, optional2, receiverValue) {
@@ -37175,6 +37538,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
       const staticType = this.project.typeByName.get(receiverAst.name);
       if (staticType && staticType.kind !== "enum") {
+        this.assertUserSafe(
+          { kind: "named", typeId: staticType.id },
+          "a static receiver",
+          pos
+        );
         if (optional2) {
           throw new CompileError(
             `Optional chaining is not valid on type receiver '${staticType.name}'.`,
@@ -37353,6 +37721,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         );
       }
       this.assertMemberAccessible(type, member, pos);
+      if (this.userClassCode && type.id === this.rootTypeId && member.writability !== "user") {
+        throw new CompileError("User code can only read `root.User`.", pos);
+      }
       if (member.static === true) {
         throw new CompileError(
           `Static member '${type.name}.${name}' must be accessed through the type name, not an instance.`,
@@ -37382,12 +37753,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           ...nullPropagating ? { optionalChainType: memberType2 } : {},
           symbol: member,
           ...member.writable ? {
-            writability: member.writability ? toWritability(member.writability) : "setter" /* Setter */
+            writability: member.writability ? toWritability(member.writability, this.writesUserData) : "setter" /* Setter */
           } : {}
         };
       }
       const writability = this.memberWritability(member, receiver);
       const entryWritability = member.lookup ? this.lookupEntryWritability(member, receiver) : void 0;
+      const userData = this.memberUserData(member, receiver);
+      const entryUserData = member.lookup ? this.lookupEntryUserData(member) : false;
       const lookupWire = member.lookup?.multiselect === true && memberType2.kind === "set" ? {
         type: 9 /* Lookup */,
         required: !isNullable(memberType2),
@@ -37409,7 +37782,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         symbol: member,
         ...writability ? { writability } : {},
         ...lookupWire ? { wireType: lookupWire } : {},
-        ...entryWritability ? { entryWritability } : {}
+        ...entryWritability ? { entryWritability } : {},
+        userData,
+        entryUserData
       };
     }
     throw new CompileError(
@@ -37495,20 +37870,33 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   }
   memberWritability(member, receiver) {
     if (member.writability && !member.lookup) {
-      return toWritability(member.writability);
+      return toWritability(member.writability, this.writesUserData);
     }
     if (!member.writable) return void 0;
     if (!member.lookup) {
-      return member.writability ? toWritability(member.writability) : receiver.entryWritability ?? receiver.writability ?? "save" /* Save */;
+      return member.writability ? toWritability(member.writability, this.writesUserData) : receiver.entryWritability ?? receiver.writability ?? "save" /* Save */;
+    }
+    return member.writability ? toWritability(member.writability, this.writesUserData) : receiver.writability ?? "save" /* Save */;
+  }
+  /** Mirrors {@link memberWritability}'s inheritance for P104 User data. */
+  memberUserData(member, receiver) {
+    if (member.writability) return member.writability === "user";
+    if (member.lookup || receiver.entryWritability === void 0) {
+      return receiver.userData === true;
     }
-    return member.writability ? toWritability(member.writability) : receiver.writability ?? "save" /* Save */;
+    return receiver.entryUserData === true;
+  }
+  lookupEntryUserData(member) {
+    if (!member.lookup) return false;
+    const collectionWritability = member.lookup.collectionWritability ?? this.project.symbolById.get(member.lookup.collectionMemberId)?.writability;
+    return collectionWritability === "user";
   }
   lookupEntryWritability(member, receiver) {
     if (!member.lookup) return "readOnly" /* ReadOnly */;
     const target = this.project.symbolById.get(
       member.lookup.collectionMemberId
     );
-    const targetWritability = member.lookup.collectionWritability ? toWritability(member.lookup.collectionWritability) : target?.writability ? toWritability(target.writability) : target?.writable ? "runtime" /* Runtime */ : "readOnly" /* ReadOnly */;
+    const targetWritability = member.lookup.collectionWritability ? toWritability(member.lookup.collectionWritability, this.writesUserData) : target?.writability ? toWritability(target.writability, this.writesUserData) : target?.writable ? "runtime" /* Runtime */ : "readOnly" /* ReadOnly */;
     if (receiver.writability === "immutable" /* Immutable */) {
       if (targetWritability === "save" /* Save */) {
         return "immutableToSaveLookup" /* ImmutableToSaveLookup */;
@@ -37529,7 +37917,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       },
       type: optional2 ? { ...type, nullable: true } : type,
       ...optional2 ? { optionalChainType: type } : {},
-      ...receiver.writability ? { writability: receiver.writability } : {}
+      ...receiver.writability ? { writability: receiver.writability } : {},
+      ...receiver.userData ? { userData: true } : {}
     };
   }
   resolveIndex(receiverAst, indexAst, scope, pos, optional2) {
@@ -37590,7 +37979,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           },
           type: nullPropagating ? { ...receiver.type.elementType, nullable: true } : receiver.type.elementType,
           ...nullPropagating ? { optionalChainType: receiver.type.elementType } : {},
-          ...receiver.writability ? { writability: receiver.writability } : {}
+          ...receiver.writability ? { writability: receiver.writability } : {},
+          ...receiver.userData ? { userData: true } : {}
         };
       }
       keyType = { kind: "primitive", name: "int" };
@@ -37624,7 +38014,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       },
       type: nullPropagating ? { ...valueType, nullable: true } : valueType,
       ...nullPropagating ? { optionalChainType: valueType } : {},
-      ...receiver.writability ? { writability: receiver.writability } : {}
+      ...receiver.writability ? { writability: receiver.writability } : {},
+      ...receiver.userData ? { userData: true } : {}
     };
   }
   resolveDictionaryKey(expectedKey, keyAst, scope, pos, requireNonOptional, dictionaryLiteral = false) {
@@ -37922,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
       );
     }
@@ -38028,6 +38422,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
       const staticType = this.project.typeByName.get(callee.receiver.name);
       if (staticType && staticType.kind !== "enum") {
+        this.assertUserSafe(
+          { kind: "named", typeId: staticType.id },
+          "a static receiver",
+          pos
+        );
         if (callee.optional) {
           throw new CompileError(
             `Optional chaining is not valid on type receiver '${staticType.name}'.`,
@@ -38207,39 +38606,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
     };
   }
-  resolveDelegateCallee(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 === "delegate" ? 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 === "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) {
+  /** 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);
@@ -38247,7 +38615,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         return null;
       }
       const resolved = this.resolveIdentifier(callee.name, scope, callee.pos);
-      return resolved.type.kind === "action" ? resolved : null;
+      return resolved.type.kind === "delegate" || resolved.type.kind === "action" ? resolved : null;
     }
     if (callee.kind !== "member") return null;
     try {
@@ -38259,7 +38627,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         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;
@@ -40176,6 +40544,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
    */
   resolveActionCall(action, actionType, expression, scope) {
     this.assertActionControlAccessible(action, "invoke", expression.pos);
+    if (action.userData && action.writability === "readOnly" /* ReadOnly */) {
+      throw new CompileError(USER_DATA_WRITE_ERROR, expression.pos);
+    }
     if (expression.callee.kind === "member" && expression.callee.optional) {
       throw new CompileError(
         `${this.describe(actionType)} is never null, so optional-chained invocation is not supported.`,
@@ -40236,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(
@@ -40333,6 +40700,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         expression.callee.receiver.name
       );
       if (staticType && staticType.kind !== "enum") {
+        this.assertUserSafe(
+          { kind: "named", typeId: staticType.id },
+          "a static receiver",
+          expression.pos
+        );
         if (expression.callee.optional) {
           throw new CompileError(
             `Optional chaining is not valid on type receiver '${staticType.name}'.`,
@@ -40431,6 +40803,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           pos
         );
       }
+      if (writability === "readOnly" /* ReadOnly */ && receiver.userData) {
+        throw new CompileError(USER_DATA_WRITE_ERROR, pos);
+      }
       throw new CompileError(
         writability === "immutable" /* Immutable */ ? "Cannot mutate a collection whose effective storage is immutable." : "Cannot mutate a read-only collection value.",
         pos
@@ -40525,6 +40900,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
+    if (writability === "readOnly" /* ReadOnly */ && receiver.userData) {
+      throw new CompileError(USER_DATA_WRITE_ERROR, pos);
+    }
     if (writability === "readOnly" /* ReadOnly */) {
       throw new CompileError("Cannot clear a read-only action.", pos);
     }
@@ -40872,7 +41250,17 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     );
   }
   resolveType(type) {
-    return resolveNeoScriptType(type, this.context, this.project);
+    const resolved = resolveNeoScriptType(type, this.context, this.project);
+    this.assertUserSafe(resolved, "a type annotation", type.pos);
+    return resolved;
+  }
+  /** P104 §3.2. User code names only User-safe types. */
+  assertUserSafe(type, site, pos) {
+    if (!this.userClassCode) return;
+    const unsafe = userUnsafeTypeName(type, this.project);
+    if (unsafe !== null) {
+      throw new CompileError(userUnsafeTypeMessage(unsafe, site), pos);
+    }
   }
   /**
    * P43 §7.1. A constructor body builds the value it is handed; every other
@@ -41038,7 +41426,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pointer: { type: "variable" /* Variable */, variableId: symbol.id },
         type: symbol.type,
         symbol,
-        ...symbol.writability ? { writability: toWritability(symbol.writability) } : {}
+        ...symbol.writability ? {
+          writability: toWritability(
+            symbol.writability,
+            this.writesUserData
+          )
+        } : {}
       };
     }
     return literal(symbol.type, null);
@@ -42383,8 +42776,10 @@ function namedPrimitive(name) {
       return null;
   }
 }
-function toWritability(value) {
+function toWritability(value, writesUserData) {
   switch (value) {
+    case "user":
+      return writesUserData ? "runtime" /* Runtime */ : "readOnly" /* ReadOnly */;
     case "save":
       return "save" /* Save */;
     case "session":
@@ -43085,10 +43480,10 @@ function resolvedAllowedStorage(classId, environment) {
   return null;
 }
 function constraintDefaultWritability(allowed) {
-  return allowed === "immutable" || allowed === "save" || allowed === "session" ? allowed : "session";
+  return allowed === "immutable" || allowed === "save" || allowed === "session" || allowed === "user" ? allowed : "session";
 }
 function declaredStorageWritability(storage, staticOwnerClassId, environment) {
-  if (storage === "immutable" || storage === "save" || storage === "session") {
+  if (storage === "immutable" || storage === "save" || storage === "session" || storage === "user") {
     return storage;
   }
   if (storage === "writable") return "runtime";
@@ -43102,12 +43497,13 @@ function staticDefaultWritability(classId, environment) {
 }
 function createRootType(ids, environment) {
   const definitions = [
-    ["Assets", ids.assets, false],
-    ["Save", ids.save, true],
-    ["Session", ids.session, true]
+    ["Assets", ids.assets, false, "immutable"],
+    ["Save", ids.save, true, "save"],
+    ["Session", ids.session, true, "session"],
+    ["User", ids.user, true, "user"]
   ];
   const members = [];
-  for (const [name, memberId, writable] of definitions) {
+  for (const [name, memberId, writable, writability] of definitions) {
     if (!memberId) continue;
     const member = environment.members.get(memberId);
     if (!member) continue;
@@ -43117,7 +43513,7 @@ function createRootType(ids, environment) {
       kind: "property",
       type: memberType(member, environment, /* @__PURE__ */ new Set(), `root.${name}`),
       writable,
-      writability: name === "Assets" ? "immutable" : name === "Session" ? "session" : "save",
+      writability,
       documentation: `Project ${name.toLowerCase()} root (${memberId}).`,
       ...sourceLocation(member.source, environment, `root.${name}.source`)
     });
@@ -43140,7 +43536,8 @@ function inferRootMemberIds(members) {
   return {
     assets: unique("immutable"),
     save: unique("save"),
-    session: unique("session")
+    session: unique("session"),
+    user: unique("user")
   };
 }
 function effectiveMemberWritability(members, classes, roots) {
@@ -43161,7 +43558,7 @@ function effectiveMemberWritability(members, classes, roots) {
     seen.add(memberId);
     const member = memberById.get(memberId);
     if (!member) return null;
-    if (member.storage === "immutable" || member.storage === "save" || member.storage === "session" || member.storage === "writable") {
+    if (member.storage === "immutable" || member.storage === "save" || member.storage === "session" || member.storage === "writable" || member.storage === "user") {
       return member.storage;
     }
     return typeof member.overrideOf === "string" ? declaredStorage(member.overrideOf, seen) : null;
@@ -43229,6 +43626,7 @@ function effectiveMemberWritability(members, classes, roots) {
   if (typeof roots.session === "string") {
     rootStorage.set(roots.session, "session");
   }
+  if (typeof roots.user === "string") rootStorage.set(roots.user, "user");
   for (const [memberId, member] of memberById) {
     const declared = rootStorage.get(memberId) ?? declaredStorage(memberId);
     if (declared === "writable") {
@@ -43300,6 +43698,7 @@ function schemaClass(value, environment, field) {
     ),
     ...value.declarationModifier === "abstract" ? { abstract: true } : {},
     ...value.declarationModifier === "sealed" ? { sealed: true } : {},
+    ...resolvedAllowedStorage(id, environment) === "user" ? { userClass: true } : {},
     ...sourceLocation(value.source, environment, `${field}.source`),
     typeParameters: records(
       value.genericParameters ?? [],
@@ -44804,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;
@@ -44812,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,
@@ -44819,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);
@@ -45033,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(
@@ -45048,7 +45484,8 @@ function classToLanguageType(schemaClass2, context) {
       placement.ownerClassId,
       index,
       context,
-      genericEnvironment
+      genericEnvironment,
+      projectedBase
     );
     if (!symbol) continue;
     names.add(symbol.name);
@@ -45081,6 +45518,7 @@ function classToLanguageType(schemaClass2, context) {
     ...schemaClass2.docsText ? { documentation: schemaClass2.docsText } : {},
     kind: "class",
     abstract: isAbstractClass(schemaClass2),
+    ...resolveAllowedStorage(schemaClass2.id, context.vm.classes) === 5 /* User */ ? { userClass: true } : {},
     location: virtualIdentifierLocation(
       context,
       "Classes",
@@ -45132,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),
@@ -45158,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),
@@ -45210,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;
   }
@@ -45221,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 ? {
@@ -45356,6 +45797,8 @@ function symbolWritability(memberId, context, staticOwnerClassId) {
       return { writability: "session" };
     case 4 /* Writable */:
       return { writability: "runtime" };
+    case 5 /* User */:
+      return { writability: "user" };
   }
 }
 function uniqueEffectiveWritability(memberId, context) {
@@ -45377,6 +45820,8 @@ function uniqueEffectiveWritability(memberId, context) {
       return "save";
     case 3 /* Session */:
       return "session";
+    case 5 /* User */:
+      return "user";
   }
 }
 function interfaceToLanguageType(neoInterface, context) {
@@ -45476,14 +45921,17 @@ function interfaceMemberToSymbol(neoInterface, key, member, context, inherited)
     ...inheritedFrom ? { inheritedFrom } : {}
   };
 }
+var ROOT_WRITABILITY = {
+  [1 /* Immutable */]: "immutable",
+  [2 /* Save */]: "save",
+  [3 /* Session */]: "session",
+  [5 /* User */]: "user"
+};
 function createRootType2(context) {
-  const definitions = [
-    ["Assets", context.vm.project.rootAssetsMemberId],
-    ["Save", context.vm.project.rootSaveFileMemberId],
-    ["Session", context.vm.project.rootSessionMemberId]
-  ];
   const members = [];
-  for (const [index, [name, memberId]] of definitions.entries()) {
+  for (const [index, root] of PROJECT_ROOTS.entries()) {
+    const name = root.key;
+    const memberId = context.vm.project[root.projectField];
     const member = analyzerMemberById(context, memberId);
     if (!member) continue;
     members.push({
@@ -45491,8 +45939,8 @@ function createRootType2(context) {
       name,
       kind: "property",
       type: memberRuntimeType(member, context),
-      writable: name !== "Assets",
-      writability: name === "Assets" ? "immutable" : name === "Session" ? "session" : "save",
+      writable: root.storage !== 1 /* Immutable */,
+      writability: ROOT_WRITABILITY[root.storage],
       documentation: `Project ${name.toLowerCase()} root (${memberId}).`,
       location: virtualIdentifierLocation(
         context,
@@ -45545,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;
     }
@@ -45575,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;
   }
@@ -45827,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;
   }
@@ -46059,9 +46512,7 @@ function projectLanguageVersion(context) {
     `adapter:${NEOSCRIPT_COMPILER_ADAPTER_REVISION}`,
     context.vm.project.id,
     context.vm.project.updatedAt,
-    context.vm.project.rootAssetsMemberId,
-    context.vm.project.rootSaveFileMemberId,
-    context.vm.project.rootSessionMemberId,
+    ...projectRootMemberIds(context.vm.project),
     ...records2.map((record4) => `${record4.id}:${record4.updatedAt}`).sort()
   ].join("|");
 }
@@ -46115,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 {};
   }
@@ -46201,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";
@@ -47037,7 +47488,7 @@ async function restartProjectRead(read) {
 // ../src/models/project/project-types.ts
 function isProject(value) {
   const v = value;
-  return typeof v?.name === "string" && typeof v?.id === "string" && isProjectOwner(v.owner) && isActorIdentifier(v.author) && typeof v?.createdAt === "number" && typeof v?.updatedAt === "number" && typeof v?.rootAssetsMemberId === "string" && typeof v?.rootSaveFileMemberId === "string" && typeof v?.rootSessionMemberId === "string" && isOptionalNullableString2(v.defaultPriorityGroupId) && isOptionalNullableString2(v.defaultTextureTemplateId) && isOptionalNullableString2(v.defaultAudioClipTemplateId) && isProjectExportSettingsOrEmpty(v.exportSettings);
+  return typeof v?.name === "string" && typeof v?.id === "string" && isProjectOwner(v.owner) && isActorIdentifier(v.author) && typeof v?.createdAt === "number" && typeof v?.updatedAt === "number" && typeof v?.rootAssetsMemberId === "string" && typeof v?.rootSaveFileMemberId === "string" && typeof v?.rootSessionMemberId === "string" && typeof v?.rootUserMemberId === "string" && isOptionalNullableString2(v.defaultPriorityGroupId) && isOptionalNullableString2(v.defaultTextureTemplateId) && isOptionalNullableString2(v.defaultAudioClipTemplateId) && isProjectExportSettingsOrEmpty(v.exportSettings);
 }
 function isProjectOwner(value) {
   if (!isActorIdentifier(value)) return false;
@@ -48774,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
@@ -48795,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",
@@ -48816,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",
@@ -48833,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)
   };
 }
@@ -48882,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.`
   );
@@ -48890,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)) {
@@ -48916,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
@@ -49206,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]]);
@@ -51305,7 +51790,9 @@ var commonMemberEntries = {
   defaultValue: nullable(schemaDefaultValueSchema),
   overrideOf: nullableId,
   system: nullable(schemaSystemMetadataSchema),
-  storage: nullable(picklist(["immutable", "save", "session", "writable"])),
+  storage: nullable(
+    picklist(["immutable", "save", "session", "writable", "user"])
+  ),
   distribution: nullable(picklist(["sparse", "packed"])),
   storageKey: nullableId
 };
@@ -51495,7 +51982,8 @@ var MEMBER_STORAGE = [
   "immutable",
   "save",
   "session",
-  "writable"
+  "writable",
+  "user"
 ];
 var MEMBER_DISTRIBUTION = ["sparse", "packed"];
 var STRING_FORMAT = ["localized", "plain"];
@@ -53387,7 +53875,8 @@ var CLASS_ALLOWED_STORAGE = [
   "immutable",
   "save",
   "session",
-  "writable"
+  "writable",
+  "user"
 ];
 var CLASS_SCHEMA_RECORD_ADAPTER = {
   recordKind: "class",
@@ -54143,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,
@@ -54454,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");