@neocompose/cli 0.37.0 → 0.38.0

package/dist/neo.mjs

@@ -41,6 +41,329 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/workspace.ts
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+function recordStateKey(recordKind, recordId) {
+  return `${recordKind}:${recordId}`;
+}
+function findWorkspaceRoot(startDir) {
+  let dir = resolve(startDir);
+  for (; ; ) {
+    if (existsSync(join(dir, NEO_CONFIG_FILE))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readWorkspaceConfig(root) {
+  const raw = readFileSync(join(root, NEO_CONFIG_FILE), "utf8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`"${NEO_CONFIG_FILE}" must contain a JSON object.`);
+  }
+  const config = parsed;
+  if (config.formatVersion === void 0) {
+    throw new Error(
+      `"${NEO_CONFIG_FILE}" is missing required field "formatVersion"; expected ${CURRENT_FORMAT_VERSION}. Recreate this working copy with \`neo init\`.`
+    );
+  }
+  if (config.formatVersion !== CURRENT_FORMAT_VERSION) {
+    throw new Error(
+      `"${NEO_CONFIG_FILE}" field "formatVersion" must be ${CURRENT_FORMAT_VERSION}; received ${JSON.stringify(config.formatVersion)}. Native Neo project source is a clean break; preserve local edits and create a fresh working copy with \`neo init\`.`
+    );
+  }
+  const formatVersion = CURRENT_FORMAT_VERSION;
+  if (typeof config.apiBaseUrl !== "string") {
+    throw new Error(
+      `"${NEO_CONFIG_FILE}" is missing string field "apiBaseUrl".`
+    );
+  }
+  const profile = config.profile === "release" ? "release" : "editor";
+  const convexUrl = typeof config.convexUrl === "string" ? config.convexUrl : void 0;
+  const prePushHook = optionalHook(config, "prePushHook");
+  const prePushDryRunHook = optionalHook(config, "prePushDryRunHook");
+  const test = optionalTestConfig(config.test);
+  if (typeof config.unityConfigPath === "string") {
+    if (config.projectId !== void 0) {
+      throw new Error(
+        `"${NEO_CONFIG_FILE}" sets "unityConfigPath", so "projectId" must be removed \u2014 the Unity config asset is the single source of truth.`
+      );
+    }
+    if (config.versionId !== void 0) {
+      throw new Error(
+        `"${NEO_CONFIG_FILE}" sets "unityConfigPath", so "versionId" must be removed \u2014 the Unity config asset is the single source of truth.`
+      );
+    }
+    const ids = readUnityConfigIds(root, config.unityConfigPath);
+    return {
+      formatVersion,
+      apiBaseUrl: config.apiBaseUrl,
+      projectId: ids.projectId,
+      versionId: ids.versionId,
+      profile,
+      convexUrl,
+      unityConfigPath: config.unityConfigPath,
+      ...prePushHook === void 0 ? {} : { prePushHook },
+      ...prePushDryRunHook === void 0 ? {} : { prePushDryRunHook },
+      ...test === void 0 ? {} : { test }
+    };
+  }
+  if (typeof config.projectId !== "string") {
+    throw new Error(
+      `"${NEO_CONFIG_FILE}" is missing string field "projectId".`
+    );
+  }
+  if (typeof config.versionId !== "string") {
+    throw new Error(
+      `"${NEO_CONFIG_FILE}" is missing string field "versionId".`
+    );
+  }
+  return {
+    formatVersion,
+    apiBaseUrl: config.apiBaseUrl,
+    projectId: config.projectId,
+    versionId: config.versionId,
+    profile,
+    convexUrl,
+    ...prePushHook === void 0 ? {} : { prePushHook },
+    ...prePushDryRunHook === void 0 ? {} : { prePushDryRunHook },
+    ...test === void 0 ? {} : { test }
+  };
+}
+function optionalHook(config, field) {
+  const value = config[field];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(
+      `"${NEO_CONFIG_FILE}" field "${field}" must be a non-empty CLI command.`
+    );
+  }
+  return value;
+}
+function optionalTestConfig(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`"${NEO_CONFIG_FILE}" field "test" must be an object.`);
+  }
+  const config = value;
+  const allowed = /* @__PURE__ */ new Set([
+    "include",
+    "exclude",
+    "timeoutMs",
+    "maxWorkers",
+    "forbidOnly"
+  ]);
+  const unknown = Object.keys(config).find((key) => !allowed.has(key));
+  if (unknown !== void 0) {
+    throw new Error(
+      `"${NEO_CONFIG_FILE}" field "test.${unknown}" is not recognized.`
+    );
+  }
+  const stringArray2 = (field) => {
+    const entry = config[field];
+    if (entry === void 0) return void 0;
+    if (!Array.isArray(entry) || entry.some((item) => typeof item !== "string" || item.length === 0)) {
+      throw new Error(
+        `"${NEO_CONFIG_FILE}" field "test.${field}" must be an array of non-empty strings.`
+      );
+    }
+    return entry;
+  };
+  const positiveInteger = (field) => {
+    const entry = config[field];
+    if (entry === void 0) return void 0;
+    if (typeof entry !== "number" || !Number.isInteger(entry) || entry <= 0) {
+      throw new Error(
+        `"${NEO_CONFIG_FILE}" field "test.${field}" must be a positive integer.`
+      );
+    }
+    return entry;
+  };
+  const include = stringArray2("include");
+  const exclude = stringArray2("exclude");
+  const invalidInclude = include?.find(
+    (pattern) => !pattern.endsWith(".spec.neo")
+  );
+  if (invalidInclude !== void 0) {
+    throw new Error(
+      `"${NEO_CONFIG_FILE}" field "test.include" may select only .spec.neo files; received ${JSON.stringify(invalidInclude)}.`
+    );
+  }
+  const timeoutMs = positiveInteger("timeoutMs");
+  const maxWorkers = positiveInteger("maxWorkers");
+  const forbidOnly = config.forbidOnly;
+  if (forbidOnly !== void 0 && typeof forbidOnly !== "boolean") {
+    throw new Error(
+      `"${NEO_CONFIG_FILE}" field "test.forbidOnly" must be a boolean.`
+    );
+  }
+  return {
+    ...include === void 0 ? {} : { include },
+    ...exclude === void 0 ? {} : { exclude },
+    ...timeoutMs === void 0 ? {} : { timeoutMs },
+    ...maxWorkers === void 0 ? {} : { maxWorkers },
+    ...forbidOnly === void 0 ? {} : { forbidOnly }
+  };
+}
+function writeWorkspaceConfig(root, config) {
+  let persisted = { ...config };
+  if (config.unityConfigPath !== void 0) {
+    const { projectId, versionId, ...rest } = persisted;
+    void projectId;
+    void versionId;
+    persisted = rest;
+    writeUnityConfigVersionId(root, config.unityConfigPath, config.versionId);
+  }
+  writeFileSync(
+    join(root, NEO_CONFIG_FILE),
+    `${JSON.stringify(persisted, null, 2)}
+`,
+    "utf8"
+  );
+}
+function readUnityConfigIds(root, unityConfigPath) {
+  const assetPath = resolve(root, unityConfigPath);
+  if (!existsSync(assetPath)) {
+    throw new Error(
+      `"unityConfigPath" in "${NEO_CONFIG_FILE}" points to "${assetPath}", which does not exist.`
+    );
+  }
+  const content = readFileSync(assetPath, "utf8");
+  const projectId = matchUnityScalarField(content, "projectId");
+  if (projectId === null) {
+    throw new Error(
+      `Unity config asset "${assetPath}" has no "projectId" field.`
+    );
+  }
+  const versionId = matchUnityScalarField(content, "versionId");
+  if (versionId === null) {
+    throw new Error(
+      `Unity config asset "${assetPath}" has no "versionId" field.`
+    );
+  }
+  return { projectId, versionId };
+}
+function writeUnityConfigVersionId(root, unityConfigPath, versionId) {
+  const assetPath = resolve(root, unityConfigPath);
+  if (!existsSync(assetPath)) {
+    throw new Error(
+      `"unityConfigPath" in "${NEO_CONFIG_FILE}" points to "${assetPath}", which does not exist.`
+    );
+  }
+  const content = readFileSync(assetPath, "utf8");
+  const current = matchUnityScalarField(content, "versionId");
+  if (current === null) {
+    throw new Error(
+      `Unity config asset "${assetPath}" has no "versionId" field to update.`
+    );
+  }
+  if (current === versionId) return;
+  const updated = content.replace(
+    /^(\s*versionId:[ \t]*).*$/m,
+    `$1${versionId}`
+  );
+  writeFileSync(assetPath, updated, "utf8");
+}
+function matchUnityScalarField(content, field) {
+  const match = new RegExp(`^\\s*${field}:[ \\t]*(\\S+)[ \\t]*$`, "m").exec(
+    content
+  );
+  return match === null ? null : match[1];
+}
+function readWorkspaceState(root, options = {}) {
+  const statePath = join(root, NEO_STATE_DIR, NEO_STATE_FILE);
+  if (!existsSync(statePath)) {
+    options.onSourceRead?.(null);
+    return { records: {} };
+  }
+  const source = readFileSync(statePath, "utf8");
+  options.onSourceRead?.(source);
+  const parsed = JSON.parse(source);
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`"${statePath}" must contain a JSON object.`);
+  }
+  const state = parsed;
+  if (typeof state.records !== "object" || state.records === null) {
+    throw new Error(`"${statePath}" is missing the "records" object.`);
+  }
+  for (const [key, value] of Object.entries(state.records)) {
+    if (typeof value !== "object" || value === null) {
+      throw new Error(
+        `"${statePath}" record ${JSON.stringify(key)} must be an object.`
+      );
+    }
+    const recordKind = value.recordKind;
+    if (recordKind === "type" || recordKind === "attribute" || key.startsWith("type:") || key.startsWith("attribute:")) {
+      if (options.discardLegacyFormat2State === true) {
+        return { records: {} };
+      }
+      throw new Error(
+        `"${statePath}" contains legacy Class/Member state at ${JSON.stringify(key)}. Cached legacy state cannot be upgraded; preserve any local source you need, then run \`neo pull --reset\` to reconstruct this format-4 working copy from the authoritative server.`
+      );
+    }
+  }
+  return state;
+}
+function writeWorkspaceState(root, state) {
+  const stateDir = join(root, NEO_STATE_DIR);
+  mkdirSync(stateDir, { recursive: true });
+  writeFileSync(
+    join(stateDir, NEO_STATE_FILE),
+    `${JSON.stringify(state, null, 2)}
+`,
+    "utf8"
+  );
+}
+function loadWorkspace(startDir, options = {}) {
+  const root = findWorkspaceRoot(startDir);
+  if (root === null) {
+    throw new Error(
+      `No "${NEO_CONFIG_FILE}" found in "${startDir}" or any parent directory. Run "neo init" first.`
+    );
+  }
+  let stateSourceSha256;
+  const state = readWorkspaceState(root, {
+    discardLegacyFormat2State: options.discardLegacyFormat2State,
+    ...options.fingerprintStateSource === true ? {
+      onSourceRead: (source) => {
+        stateSourceSha256 = createHash("sha256").update(source ?? "<missing>").digest("hex");
+      }
+    } : {}
+  });
+  return {
+    root,
+    config: readWorkspaceConfig(root),
+    state,
+    ...stateSourceSha256 === void 0 ? {} : { stateSourceSha256 }
+  };
+}
+var NEO_CONFIG_FILE, NEO_STATE_DIR, NEO_STATE_FILE, CURRENT_FORMAT_VERSION;
+var init_workspace = __esm({
+  "src/workspace.ts"() {
+    "use strict";
+    NEO_CONFIG_FILE = "neo.json";
+    NEO_STATE_DIR = ".neo";
+    NEO_STATE_FILE = "state.json";
+    CURRENT_FORMAT_VERSION = 4;
+  }
+});
+
+// src/auth-api-base-url.ts
+function resolveAuthApiBaseUrl(options) {
+  if (options.apiOverride !== null) return options.apiOverride;
+  const workspaceRoot = findWorkspaceRoot(options.cwd);
+  if (workspaceRoot === null) return options.defaultApiBaseUrl;
+  return readWorkspaceConfig(workspaceRoot).apiBaseUrl;
+}
+var init_auth_api_base_url = __esm({
+  "src/auth-api-base-url.ts"() {
+    "use strict";
+    init_workspace();
+  }
+});
+
 // src/token-store.ts
 var token_store_exports = {};
 __export(token_store_exports, {
@@ -56,15 +379,15 @@ __export(token_store_exports, {
 });
 import {
   chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
   rmSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
-import { isAbsolute, join } from "node:path";
+import { isAbsolute, join as join2 } from "node:path";
 function credentialsDir() {
   const configHome = process.env[NEO_CONFIG_HOME_ENV_VAR];
   if (configHome !== void 0 && configHome !== "") {
@@ -76,16 +399,16 @@ function credentialsDir() {
     return configHome;
   }
   const xdg = process.env.XDG_CONFIG_HOME;
-  const base = xdg !== void 0 && xdg !== "" ? xdg : join(homedir(), ".config");
-  return join(base, "neo-compose");
+  const base = xdg !== void 0 && xdg !== "" ? xdg : join2(homedir(), ".config");
+  return join2(base, "neo-compose");
 }
 function credentialsPath() {
-  return join(credentialsDir(), "credentials.json");
+  return join2(credentialsDir(), "credentials.json");
 }
 function readCredentialsFile() {
   const path = credentialsPath();
-  if (!existsSync(path)) return { credentials: {} };
-  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  if (!existsSync2(path)) return { credentials: {} };
+  const parsed = JSON.parse(readFileSync2(path, "utf8"));
   if (typeof parsed !== "object" || parsed === null) {
     throw new Error(`Credentials file "${path}" must contain a JSON object.`);
   }
@@ -154,11 +477,11 @@ function saveCredential(credential) {
     keychainAccount(credential.apiBaseUrl),
     credential.token
   );
-  mkdirSync(credentialsDir(), { recursive: true, mode: 448 });
+  mkdirSync2(credentialsDir(), { recursive: true, mode: 448 });
   const file = readCredentialsFile();
   file.credentials[credential.apiBaseUrl] = inKeychain ? { ...credential, token: "" } : credential;
   const path = credentialsPath();
-  writeFileSync(path, `${JSON.stringify(file, null, 2)}
+  writeFileSync2(path, `${JSON.stringify(file, null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
@@ -194,7 +517,7 @@ function deleteCredential(apiBaseUrl) {
     if (Object.keys(file.credentials).length === 0) {
       rmSync(path, { force: true });
     } else {
-      writeFileSync(path, `${JSON.stringify(file, null, 2)}
+      writeFileSync2(path, `${JSON.stringify(file, null, 2)}
 `, {
         encoding: "utf8",
         mode: 384
@@ -361,6 +684,7 @@ async function readStdin() {
   return Buffer.concat(chunks).toString("utf8").trim();
 }
 async function runLogin(options) {
+  console.log(`Authenticating with ${options.apiBaseUrl}.`);
   let profile = options.profile;
   if (profile === null) {
     profile = isInteractive() && !options.tokenStdin ? await promptSelect({
@@ -39355,7 +39679,7 @@ function assertInternalRecordRelationInvariants(manifest) {
   const classes = requireArray(manifest.classes, "$.classes").map(
     (value, index) => requireRecord(value, `$.classes[${index}]`)
   );
-  const classesById = new Map(
+  const classesById2 = new Map(
     classes.map((schemaClass2) => [String(schemaClass2.id), schemaClass2])
   );
   const endpoints = manifestEndpointKeys(manifest, relations);
@@ -39414,10 +39738,10 @@ function assertInternalRecordRelationInvariants(manifest) {
           `${String(relation.relationKind)} requires ${contract.sourceRecordKind}-to-${contract.targetRecordKind} endpoints.`
         );
       }
-      const sourceClass = contract.sourceRecordKind === "class" ? classesById.get(String(relation.sourceRecordId)) : void 0;
-      const targetClass = contract.targetRecordKind === "class" ? classesById.get(String(relation.targetRecordId)) : void 0;
+      const sourceClass = contract.sourceRecordKind === "class" ? classesById2.get(String(relation.sourceRecordId)) : void 0;
+      const targetClass = contract.targetRecordKind === "class" ? classesById2.get(String(relation.targetRecordId)) : void 0;
       if (sourceClass !== void 0) {
-        const actual = effectiveWorldKind2(sourceClass, classesById);
+        const actual = effectiveWorldKind2(sourceClass, classesById2);
         if (actual !== contract.sourceWorldKind) {
           invalid(
             `${path}.sourceRecordId`,
@@ -39426,7 +39750,7 @@ function assertInternalRecordRelationInvariants(manifest) {
         }
       }
       if (targetClass !== void 0) {
-        const actual = effectiveWorldKind2(targetClass, classesById);
+        const actual = effectiveWorldKind2(targetClass, classesById2);
         if (actual !== contract.targetWorldKind) {
           invalid(
             `${path}.targetRecordId`,
@@ -39479,9 +39803,9 @@ function assertInternalRecordRelationInvariants(manifest) {
     }
   }
   assertAcyclicRelationGraph(graph);
-  assertDefaultLayerCompatibility(relations, classesById);
+  assertDefaultLayerCompatibility(relations, classesById2);
 }
-function effectiveWorldKind2(schemaClass2, classesById) {
+function effectiveWorldKind2(schemaClass2, classesById2) {
   const visited = /* @__PURE__ */ new Set();
   let current = schemaClass2;
   while (current !== void 0) {
@@ -39493,7 +39817,7 @@ function effectiveWorldKind2(schemaClass2, classesById) {
       const worldKind = system.worldKind;
       if (typeof worldKind === "string") return worldKind;
     }
-    current = typeof current.extendsClassId === "string" ? classesById.get(current.extendsClassId) : void 0;
+    current = typeof current.extendsClassId === "string" ? classesById2.get(current.extendsClassId) : void 0;
   }
   return null;
 }
@@ -39546,7 +39870,7 @@ function assertAcyclicRelationGraph(graph) {
   };
   for (const node of graph.keys()) visit(node);
 }
-function assertDefaultLayerCompatibility(relations, classesById) {
+function assertDefaultLayerCompatibility(relations, classesById2) {
   const pairs = [
     ["world.tile.default-layer", "world.tile.compatible-layer"],
     ["world.object.default-layer", "world.object.compatible-layer"]
@@ -39557,11 +39881,11 @@ function assertDefaultLayerCompatibility(relations, classesById) {
     )) {
       const sourceAncestors = classAncestorIds(
         String(relation.sourceRecordId),
-        classesById
+        classesById2
       );
       const targetAncestors = classAncestorIds(
         String(relation.targetRecordId),
-        classesById
+        classesById2
       );
       const covered = relations.some(
         (candidate) => candidate.relationKind === compatibleKind && sourceAncestors.includes(String(candidate.sourceRecordId)) && targetAncestors.includes(String(candidate.targetRecordId))
@@ -39575,16 +39899,16 @@ function assertDefaultLayerCompatibility(relations, classesById) {
     }
   }
 }
-function classAncestorIds(classId, classesById) {
+function classAncestorIds(classId, classesById2) {
   const result = [];
   const visited = /* @__PURE__ */ new Set();
-  let current = classesById.get(classId);
+  let current = classesById2.get(classId);
   while (current !== void 0) {
     const id2 = String(current.id);
     if (visited.has(id2)) break;
     visited.add(id2);
     result.push(id2);
-    current = typeof current.extendsClassId === "string" ? classesById.get(current.extendsClassId) : void 0;
+    current = typeof current.extendsClassId === "string" ? classesById2.get(current.extendsClassId) : void 0;
   }
   return result;
 }
@@ -39604,13 +39928,13 @@ function assertStaticMemberInvariants(manifest) {
   const interfaces = requireArray(manifest.interfaces, "$.interfaces").map(
     (value, index) => requireRecord(value, `$.interfaces[${index}]`)
   );
-  const membersById = new Map(
+  const membersById2 = new Map(
     members.map((member) => [String(member.id), member])
   );
   const memberIndexById = new Map(
     members.map((member, index) => [String(member.id), index])
   );
-  const classesById = new Map(
+  const classesById2 = new Map(
     classes.map((schemaClass2) => [String(schemaClass2.id), schemaClass2])
   );
   const classIndexById = new Map(
@@ -39674,7 +39998,7 @@ function assertStaticMemberInvariants(manifest) {
     if (member.kind === "generic") {
       invalid(`${path}.kind`, "a Generic placeholder cannot be static.");
     }
-    const ownerClass = classesById.get(ownerClassId);
+    const ownerClass = classesById2.get(ownerClassId);
     if (ownerClass === void 0) {
       invalid(
         `${path}.owner.classId`,
@@ -39725,7 +40049,7 @@ function assertStaticMemberInvariants(manifest) {
       if (seen.has(id2)) break;
       seen.add(id2);
       chain.push(current);
-      current = typeof current.extendsClassId === "string" ? classesById.get(current.extendsClassId) : void 0;
+      current = typeof current.extendsClassId === "string" ? classesById2.get(current.extendsClassId) : void 0;
     }
     return chain;
   };
@@ -39759,8 +40083,8 @@ function assertStaticMemberInvariants(manifest) {
         (candidate) => typeof candidate === "string"
       );
       if (inheritedMemberId2 === void 0) continue;
-      const local = membersById.get(rawMemberId);
-      const inherited = membersById.get(inheritedMemberId2);
+      const local = membersById2.get(rawMemberId);
+      const inherited = membersById2.get(inheritedMemberId2);
       if (local?.isStatic !== true && inherited?.isStatic !== true) continue;
       invalid(
         `$.classes[${typeIndex}].schema.${schemaKey}`,
@@ -39810,7 +40134,7 @@ function assertStaticMemberInvariants(manifest) {
     for (const key of interfaceMemberKeys(schemaClass2)) {
       const memberId = schema.get(key);
       if (memberId === void 0) continue;
-      if (membersById.get(memberId)?.isStatic !== true) continue;
+      if (membersById2.get(memberId)?.isStatic !== true) continue;
       invalid(
         `$.classes[${typeIndex}].implementsInterfaceIds`,
         `static member ${JSON.stringify(key)} cannot implement an instance interface member.`
@@ -39819,11 +40143,11 @@ function assertStaticMemberInvariants(manifest) {
   }
   for (const member of members) {
     if (member.kind !== "list") continue;
-    const entry = membersById.get(String(member.entryMemberId));
+    const entry = membersById2.get(String(member.entryMemberId));
     if (entry?.kind !== "class" || typeof entry.classId !== "string") {
       continue;
     }
-    const entryType = classesById.get(entry.classId);
+    const entryType = classesById2.get(entry.classId);
     if (entryType === void 0) continue;
     const entrySchema = mergedSchema(entryType);
     for (const index of requireArray(
@@ -39836,7 +40160,7 @@ function assertStaticMemberInvariants(manifest) {
       );
       if (typeof definition2.schemaKey !== "string") continue;
       const indexedMemberId = entrySchema.get(definition2.schemaKey);
-      if (indexedMemberId === void 0 || membersById.get(indexedMemberId)?.isStatic !== true) {
+      if (indexedMemberId === void 0 || membersById2.get(indexedMemberId)?.isStatic !== true) {
         continue;
       }
       const memberIndex = memberIndexById.get(String(member.id)) ?? 0;
@@ -41958,14 +42282,14 @@ var init_v4 = __esm({
 });
 
 // node_modules/uuid/dist-node/sha1.js
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } 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();
+  return createHash2("sha1").update(bytes).digest();
 }
 var sha1_default;
 var init_sha1 = __esm({
@@ -44168,7 +44492,7 @@ var init_structured_leaf_fields = __esm({
         { name: "a", key: "a", type: "unitFloat" }
       ]
     };
-    STRUCTURED_LEAF_PARTIAL_KEY = "$partial";
+    STRUCTURED_LEAF_PARTIAL_KEY = "~partial";
   }
 });
 
@@ -44690,7 +45014,7 @@ function isNSDelegateClosureValue(value) {
 function isNSDelegateValue(value) {
   return isMemberDelegateTarget(value) || isNSDelegateClosureValueDraft(value) || isNSDelegateClosureValue(value);
 }
-function nsDelegateDirectReferenceValueId(value) {
+function nsDelegateDirectReference(value) {
   if (!isNSDelegateClosureValue(value)) return null;
   const instructions = value.action.instructions;
   if (instructions.length !== 1) return null;
@@ -44698,7 +45022,10 @@ function nsDelegateDirectReferenceValueId(value) {
   if (instruction?.type !== "return" /* return */ || instruction.pointer?.type !== "reference" /* reference */) {
     return null;
   }
-  return instruction.pointer.valueId;
+  return {
+    valueId: instruction.pointer.valueId,
+    withProvenance: instruction.pointer.withProvenance === true
+  };
 }
 function isMemberDelegateBase(value) {
   const v = asMemberBaseForKind(value, 25 /* NSDelegate */);
@@ -45178,10 +45505,67 @@ var init_member_kinds = __esm({
 });
 
 // ../src/models/classes/inheritance.ts
+function isIndexCurrent(cached, entries) {
+  if (cached === void 0) return false;
+  if (cached.epoch !== mergedSchemaEpoch) return false;
+  const { snapshot } = cached;
+  if (snapshot.length !== entries.length) return false;
+  for (let i = 0; i < entries.length; i++) {
+    if (snapshot[i] !== entries[i]) return false;
+  }
+  return true;
+}
+function classesById(classes) {
+  const cached = classIndexes.get(classes);
+  if (isIndexCurrent(cached, classes)) return cached.byId;
+  const byId = /* @__PURE__ */ new Map();
+  for (const entry of classes) byId.set(entry.id, entry);
+  classIndexes.set(classes, {
+    snapshot: [...classes],
+    epoch: mergedSchemaEpoch,
+    byId
+  });
+  return byId;
+}
+function membersById(members) {
+  const cached = memberIndexes.get(members);
+  if (isIndexCurrent(cached, members)) return cached.byId;
+  const byId = /* @__PURE__ */ new Map();
+  for (const entry of members) byId.set(entry.id, entry);
+  memberIndexes.set(members, {
+    snapshot: [...members],
+    epoch: mergedSchemaEpoch,
+    byId
+  });
+  return byId;
+}
+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];
+  };
+}
 function resolveInheritanceChain(classId, classes, draft) {
+  return resolveChainFromIndex(classId, classesById(classes), draft);
+}
+function resolveChainFromIndex(classId, index, draft) {
   const chain = [];
   const visited = /* @__PURE__ */ new Set();
-  const lookup = (id2) => draft && draft.id === id2 ? draft : classes.find((t) => t.id === id2);
+  const lookup = (id2) => draft && draft.id === id2 ? draft : index.get(id2);
   let current = lookup(classId);
   while (current) {
     if (visited.has(current.id)) {
@@ -45201,18 +45585,19 @@ function mergeSchemas(chain) {
   const baseFirst = [...chain].reverse();
   const map = /* @__PURE__ */ new Map();
   const order = [];
+  const ordered = /* @__PURE__ */ new Set();
   for (const schemaClass2 of baseFirst) {
     const localKeys = getClassSchemaKeyOrder(schemaClass2);
     if (schemaClass2.schemaKeyOrder !== void 0) {
-      order.splice(
-        0,
-        order.length,
-        ...localKeys,
-        ...order.filter((key) => !localKeys.includes(key))
-      );
+      const localKeySet = new Set(localKeys);
+      const trailing = order.filter((key) => !localKeySet.has(key));
+      order.splice(0, order.length, ...localKeys, ...trailing);
+      for (const key of localKeys) ordered.add(key);
     }
     for (const key of localKeys) {
-      if (!order.includes(key)) order.push(key);
+      if (ordered.has(key)) continue;
+      order.push(key);
+      ordered.add(key);
     }
     for (const [key, memberId] of Object.entries(schemaClass2.schema)) {
       map.set(key, {
@@ -45228,21 +45613,44 @@ function mergeSchemas(chain) {
   });
 }
 function mergeInstanceSurfaceSchema(classId, classes, members) {
-  const membersById = new Map(members.map((member) => [member.id, member]));
-  return mergeSchemas(resolveInheritanceChain(classId, classes)).filter(
-    (entry) => membersById.get(entry.memberId)?.isStatic !== true
+  return instanceSurfaceFromIndexes(
+    classId,
+    classesById(classes),
+    membersById(members)
+  );
+}
+function instanceSurfaceFromIndexes(classId, classIndex, memberIndex) {
+  return instanceSurfaceMemo(
+    classId,
+    classIndex,
+    memberIndex,
+    () => mergeSchemas(resolveChainFromIndex(classId, classIndex)).filter(
+      (entry) => memberIndex.get(entry.memberId)?.isStatic !== true
+    )
   );
 }
 function mergeStoredInstanceSchema(classId, classes, members) {
-  const membersById = new Map(members.map((member) => [member.id, member]));
-  return mergeInstanceSurfaceSchema(classId, classes, members).filter(
-    (entry) => membersById.get(entry.memberId)?.isReadOnly !== true
+  const classIndex = classesById(classes);
+  const memberIndex = membersById(members);
+  return storedInstanceMemo(
+    classId,
+    classIndex,
+    memberIndex,
+    () => instanceSurfaceFromIndexes(classId, classIndex, memberIndex).filter(
+      (entry) => memberIndex.get(entry.memberId)?.isReadOnly !== true
+    )
   );
 }
 function mergeReadOnlyMembers(classId, classes, members) {
-  const membersById = new Map(members.map((member) => [member.id, member]));
-  return mergeInstanceSurfaceSchema(classId, classes, members).filter(
-    (entry) => membersById.get(entry.memberId)?.isReadOnly === true
+  const classIndex = classesById(classes);
+  const memberIndex = membersById(members);
+  return readOnlyMemberMemo(
+    classId,
+    classIndex,
+    memberIndex,
+    () => instanceSurfaceFromIndexes(classId, classIndex, memberIndex).filter(
+      (entry) => memberIndex.get(entry.memberId)?.isReadOnly === true
+    )
   );
 }
 function findSchemaPlacement(memberId, classes) {
@@ -45255,13 +45663,13 @@ function findSchemaPlacement(memberId, classes) {
   }
   return null;
 }
-function findNearestAncestorSchemaPlacement(ownerClass, schemaKey, classesById) {
+function findNearestAncestorSchemaPlacement(ownerClass, schemaKey, classesById2) {
   const visited = /* @__PURE__ */ new Set([ownerClass.id]);
   let ancestorId = ownerClass.extendsClassId;
   while (typeof ancestorId === "string") {
     if (visited.has(ancestorId)) return null;
     visited.add(ancestorId);
-    const ancestor = classesById.get(ancestorId);
+    const ancestor = classesById2.get(ancestorId);
     if (ancestor === void 0) return null;
     if (typeof ancestor.schema[schemaKey] === "string") {
       return { ownerClass: ancestor, schemaKey };
@@ -45273,7 +45681,8 @@ function findNearestAncestorSchemaPlacement(ownerClass, schemaKey, classesById)
 function walkExtendsMemberChain(startId, members, pick, options) {
   const requireKind = options?.requireKind;
   const maxHops = options?.maxHops ?? 16;
-  let cursor = members.find((a) => a.id === startId);
+  const byId = membersById(members);
+  let cursor = byId.get(startId);
   for (let i = 0; cursor && i < maxHops; i++) {
     if (requireKind !== void 0 && cursor.kind !== requireKind) {
       return void 0;
@@ -45282,13 +45691,14 @@ function walkExtendsMemberChain(startId, members, pick, options) {
     if (v !== void 0) return v;
     const nextId = getOptionalString(cursor, "extendsMemberId");
     if (nextId === void 0) return void 0;
-    cursor = members.find((a) => a.id === nextId);
+    cursor = byId.get(nextId);
   }
   return void 0;
 }
 function resolveMember2(member, members) {
   const chain = [];
   const visited = /* @__PURE__ */ new Set();
+  let byId;
   let current = member;
   while (current) {
     const id2 = getOptionalString(current, "id");
@@ -45301,16 +45711,16 @@ function resolveMember2(member, members) {
     chain.push(current);
     if (!isMemberOverrideMarker(current)) break;
     const parentId = current.extendsMemberId;
-    current = members.find((a) => a.id === parentId);
+    current = (byId ??= membersById(members)).get(parentId);
   }
   const tail = chain[chain.length - 1];
   if (!tail || isMemberOverrideMarker(tail)) {
     const startId = getOptionalString(member, "id") ?? "(unknown)";
     throw new UnresolvedMemberInheritanceError(startId);
   }
-  const baseFirst = [...chain].reverse();
+  chain.reverse();
   const merged = {};
-  for (const link of baseFirst) {
+  for (const link of chain) {
     for (const [key, value] of Object.entries(link)) {
       if (value === void 0) continue;
       merged[key] = value;
@@ -45345,7 +45755,7 @@ function descendantClassIds(classId, allClasses) {
   }
   return result;
 }
-var CircularInheritanceError, UnresolvedMemberInheritanceError, mergeInstanceSchema;
+var CircularInheritanceError, UnresolvedMemberInheritanceError, mergedSchemaEpoch, classIndexes, memberIndexes, instanceSurfaceMemo, storedInstanceMemo, readOnlyMemberMemo, staticMemberMemo, mergeInstanceSchema;
 var init_inheritance = __esm({
   "../src/models/classes/inheritance.ts"() {
     "use strict";
@@ -45375,6 +45785,13 @@ var init_inheritance = __esm({
       }
       memberId;
     };
+    mergedSchemaEpoch = 0;
+    classIndexes = /* @__PURE__ */ new WeakMap();
+    memberIndexes = /* @__PURE__ */ new WeakMap();
+    instanceSurfaceMemo = createMergeMemo();
+    storedInstanceMemo = createMergeMemo();
+    readOnlyMemberMemo = createMergeMemo();
+    staticMemberMemo = createMergeMemo();
     mergeInstanceSchema = mergeInstanceSurfaceSchema;
   }
 });
@@ -45414,11 +45831,14 @@ function inSystemRecordNamespaceOf(ownerId, derivedId) {
   }
   return systemRecordId(derivedId);
 }
-var SYSTEM_RECORD_ID_PREFIX2;
+var SYSTEM_RECORD_ID_PREFIX2, RECORD_ID_PATTERN;
 var init_system_record_id = __esm({
   "../src/models/system-record-id.ts"() {
     "use strict";
     SYSTEM_RECORD_ID_PREFIX2 = "system_";
+    RECORD_ID_PATTERN = new RegExp(
+      `^(?:${SYSTEM_RECORD_ID_PREFIX2})?[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`
+    );
   }
 });
 
@@ -47811,7 +48231,7 @@ function constructedSlotArgumentAccepts(args) {
   );
 }
 function isAnimationChildOverrideEntrySlot(slotMember, members) {
-  const membersById = new Map(members.map((member) => [member.id, member]));
+  const membersById2 = new Map(members.map((member) => [member.id, member]));
   const visited = /* @__PURE__ */ new Set();
   let current = slotMember;
   while (current !== void 0) {
@@ -47821,7 +48241,7 @@ function isAnimationChildOverrideEntrySlot(slotMember, members) {
     if (id2 === WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_MEMBER_ID || id2 === WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_ENTRY_MEMBER_ID) {
       return true;
     }
-    current = typeof current.extendsMemberId === "string" ? membersById.get(current.extendsMemberId) : void 0;
+    current = typeof current.extendsMemberId === "string" ? membersById2.get(current.extendsMemberId) : void 0;
   }
   return false;
 }
@@ -47878,12 +48298,13 @@ function carriesCompleteConstructionRecipe(value) {
 var init_instance_provenance = __esm({
   "../src/models/members/instance-provenance.ts"() {
     "use strict";
+    init_member_kinds();
   }
 });
 
 // ../src/models/members/read-only-members.ts
 function assertReadOnlyMembersValid(document) {
-  const membersById = new Map(
+  const membersById2 = new Map(
     document.members.map((member) => [member.id, member])
   );
   const valuesById = new Map(document.values.map((value) => [value.id, value]));
@@ -48017,7 +48438,7 @@ function assertReadOnlyMembersValid(document) {
       assertOwnedSchemaIsImmutable({
         member,
         memberId: member.id,
-        membersById,
+        membersById: membersById2,
         document,
         visitedBindings: /* @__PURE__ */ new Set(),
         label: member.name,
@@ -48028,7 +48449,7 @@ function assertReadOnlyMembersValid(document) {
   }
   const visitedValueIds = /* @__PURE__ */ new Set();
   const inspect = (memberId, body, classId) => {
-    const member = membersById.get(memberId);
+    const member = membersById2.get(memberId);
     if (member === void 0) return;
     const resolved = resolveMember2(member, document.members);
     if (isMemberLookupBase(resolved)) {
@@ -48062,7 +48483,7 @@ function assertReadOnlyMembersValid(document) {
       document.classes,
       document.members
     )) {
-      const childMember = membersById.get(entry.memberId);
+      const childMember = membersById2.get(entry.memberId);
       if (childMember?.isReadOnly === true) {
         if (record3[entry.schemaKey] !== void 0) {
           throw new Error(
@@ -48104,7 +48525,7 @@ function assertReadOnlyMembersValid(document) {
       document.classes,
       document.members
     )) {
-      if (membersById.get(entry.memberId)?.isReadOnly !== true) continue;
+      if (membersById2.get(entry.memberId)?.isReadOnly !== true) continue;
       if (record3[entry.schemaKey] === void 0) continue;
       throw new Error(
         `Class value "${value.id}" contains read-only declaration member "${entry.schemaKey}"; a read-only declaration member cannot have an instance value.`
@@ -61613,7 +62034,7 @@ function variantProjection(context) {
       (folder) => [folder.id, folder]
     )
   );
-  const membersById = new Map(
+  const membersById2 = new Map(
     context.vm.members.map((member) => [member.id, member])
   );
   return variants.map((variant) => ({
@@ -61623,8 +62044,8 @@ function variantProjection(context) {
     folder: variant.folderId === null ? null : pathByFolderId.get(variant.folderId) ?? null,
     ...(() => {
       const folder = variant.folderId === null ? void 0 : foldersById.get(variant.folderId);
-      const collection = folder?.binding == null ? void 0 : membersById.get(folder.binding.collectionMemberId);
-      const entry = isMemberListBase(collection) ? membersById.get(collection.entryMemberId) : void 0;
+      const collection = folder?.binding == null ? void 0 : membersById2.get(folder.binding.collectionMemberId);
+      const entry = isMemberListBase(collection) ? membersById2.get(collection.entryMemberId) : void 0;
       return isMemberClassBase(entry) ? { valueTypeId: entry.classId } : {};
     })()
   }));
@@ -61805,7 +62226,7 @@ function constructorSignature(schemaClass2, members, context, genericEnvironment
   };
 }
 function inheritedConstructorProjections(schemaClass2, context) {
-  const classesById = new Map(
+  const classesById2 = new Map(
     context.vm.classes.map((candidate) => [candidate.id, candidate])
   );
   const projections = [];
@@ -61819,7 +62240,7 @@ function inheritedConstructorProjections(schemaClass2, context) {
       claimed.add(projection.parameterName);
       projections.push(projection);
     }
-    current = current.extendsClassId ? classesById.get(current.extendsClassId) : void 0;
+    current = current.extendsClassId ? classesById2.get(current.extendsClassId) : void 0;
   }
   return projections;
 }
@@ -62958,7 +63379,7 @@ function clearNeoScriptBodyCompileCache() {
 }
 function createNeoScriptCompilationProject(ctx) {
   const members = [...ctx.members];
-  const membersById = new Map(members.map((member) => [member.id, member]));
+  const membersById2 = new Map(members.map((member) => [member.id, member]));
   return createNeoScriptProject({
     vm: {
       project: ctx.project,
@@ -62968,7 +63389,7 @@ function createNeoScriptCompilationProject(ctx) {
       enums: [...ctx.enums],
       interfaces: [...ctx.interfaces ?? []],
       databaseVM: {
-        memberById: (id2) => membersById.get(id2) ?? null
+        memberById: (id2) => membersById2.get(id2) ?? null
       }
     },
     thisClass: null,
@@ -63128,7 +63549,7 @@ function compilationProjectIdentity(project) {
 }
 function createContext(ctx, options) {
   const members = [...ctx.members];
-  const membersById = new Map(members.map((member) => [member.id, member]));
+  const membersById2 = new Map(members.map((member) => [member.id, member]));
   const analyzer = {
     vm: {
       project: ctx.project,
@@ -63138,7 +63559,7 @@ function createContext(ctx, options) {
       enums: [...ctx.enums],
       interfaces: [...ctx.interfaces ?? []],
       databaseVM: {
-        memberById: (id2) => membersById.get(id2) ?? null
+        memberById: (id2) => membersById2.get(id2) ?? null
       }
     },
     thisClass: ctx.thisClass,
@@ -64168,10 +64589,10 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
   const resolved = /* @__PURE__ */ new Map();
   if (targetValueIds.size === 0) return resolved;
   const valuesById = new Map(document.values.map((value) => [value.id, value]));
-  const membersById = new Map(
+  const membersById2 = new Map(
     document.members.map((member) => [member.id, member])
   );
-  const classesById = new Map(
+  const classesById2 = new Map(
     document.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   const storedSchemaByClassId = /* @__PURE__ */ new Map();
@@ -64256,7 +64677,7 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
     if (isMemberClassBase(member)) {
       if (!isRecordValue(body.value)) return;
       const effectiveClassId = body.classId ?? member.classId;
-      const schemaClass2 = classesById.get(effectiveClassId);
+      const schemaClass2 = classesById2.get(effectiveClassId);
       if (schemaClass2 === void 0) return;
       const merged = storedSchema(effectiveClassId);
       const env = member.classArguments === void 0 || member.classArguments === null ? defaultInstanceEnv(effectiveClassId) : resolveInstanceEnv(
@@ -64268,7 +64689,7 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
         if (entry.memberId === null) continue;
         const childValueId = body.value[entry.schemaKey];
         if (childValueId === void 0) continue;
-        const childMember = membersById.get(entry.memberId);
+        const childMember = membersById2.get(entry.memberId);
         if (childMember === void 0) continue;
         const substituted = trySubstituteMember(childMember, env);
         if (substituted === null) continue;
@@ -64278,7 +64699,7 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
     }
     if (isMemberDictionaryBase(member)) {
       if (!isRecordValue(body.value)) return;
-      const entryMemberRecord = membersById.get(member.entryMemberId);
+      const entryMemberRecord = membersById2.get(member.entryMemberId);
       if (entryMemberRecord === void 0) return;
       const entryEnv = overlayStamp(ambientEnv, body.genericBindings);
       const entryMember = trySubstituteMember(entryMemberRecord, entryEnv);
@@ -64289,7 +64710,7 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
       return;
     }
     if (isMemberListBase(member)) {
-      const entryMemberRecord = membersById.get(member.entryMemberId);
+      const entryMemberRecord = membersById2.get(member.entryMemberId);
       if (entryMemberRecord === void 0) return;
       const entryEnv = overlayStamp(ambientEnv, body.genericBindings);
       const entryMember = trySubstituteMember(entryMemberRecord, entryEnv);
@@ -65466,7 +65887,7 @@ function validateInternalRecordRelations(args) {
     }
     endpoints.set(key, candidate);
   }
-  const classesById = new Map(
+  const classesById2 = new Map(
     args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   const relationIds = /* @__PURE__ */ new Set();
@@ -65532,7 +65953,7 @@ function validateInternalRecordRelations(args) {
       contract,
       endpoint: "source",
       recordEndpoint: source,
-      classesById,
+      classesById: classesById2,
       classes: args.classes
     });
     validateWorldEndpoint({
@@ -65540,7 +65961,7 @@ function validateInternalRecordRelations(args) {
       contract,
       endpoint: "target",
       recordEndpoint: target,
-      classesById,
+      classesById: classesById2,
       classes: args.classes
     });
     const edgeKey = [
@@ -65613,10 +66034,10 @@ function resolveEffectiveClassRelations(args) {
       `Internal relation kind "${args.relationKind}" is not class-to-class.`
     );
   }
-  const classesById = new Map(
+  const classesById2 = new Map(
     args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
-  const sourceIds = contract.sourceClassPolicy === "include-descendants" ? classAncestry(args.sourceClassId, classesById) : [args.sourceClassId];
+  const sourceIds = contract.sourceClassPolicy === "include-descendants" ? classAncestry(args.sourceClassId, classesById2) : [args.sourceClassId];
   const sourceDepth = new Map(
     sourceIds.map((sourceId3, index) => [sourceId3, index])
   );
@@ -65646,7 +66067,7 @@ function resolveEffectiveClassRelations(args) {
     const targetIds = contract.targetClassPolicy === "include-descendants" ? concreteClassDescendants(
       declaration.targetRecordId,
       args.classes,
-      classesById
+      classesById2
     ) : [declaration.targetRecordId];
     for (const targetId of targetIds) {
       const current = byTarget.get(targetId);
@@ -65830,7 +66251,7 @@ function validateDefaultLayerCompatibility(args) {
     }
   }
 }
-function classAncestry(classId, classesById) {
+function classAncestry(classId, classesById2) {
   const result = [];
   const visited = /* @__PURE__ */ new Set();
   let currentId = classId;
@@ -65840,14 +66261,14 @@ function classAncestry(classId, classesById) {
     }
     visited.add(currentId);
     result.push(currentId);
-    currentId = classesById.get(currentId)?.extendsClassId;
+    currentId = classesById2.get(currentId)?.extendsClassId;
   }
   return result;
 }
-function concreteClassDescendants(classId, classes, classesById) {
-  if (!classesById.has(classId)) return [];
+function concreteClassDescendants(classId, classes, classesById2) {
+  if (!classesById2.has(classId)) return [];
   return classes.filter(
-    (candidate) => !candidate.isAbstract && classAncestry(candidate.id, classesById).includes(classId)
+    (candidate) => !candidate.isAbstract && classAncestry(candidate.id, classesById2).includes(classId)
   ).map((candidate) => candidate.id).sort((left, right) => left.localeCompare(right));
 }
 function effectiveRelation(relation, targetRecordId, sourceAncestryDepth) {
@@ -66131,6 +66552,7 @@ function buildEvaluatorBaseIndexes(members, values, valueById = new Map(
     rowsBySourceValueId: /* @__PURE__ */ new Map(),
     ownershipRootIdsByRowId: /* @__PURE__ */ new Map(),
     ownershipDistancesByRowId: /* @__PURE__ */ new Map(),
+    reconciledOwnershipRows: /* @__PURE__ */ new WeakSet(),
     ownedValueAttachmentsByValueId: /* @__PURE__ */ new Map(),
     constructorOwnershipDirtyValueIds: /* @__PURE__ */ new Set(),
     memberByRowId: /* @__PURE__ */ new Map()
@@ -66187,6 +66609,9 @@ function evaluatorIndexes(ctx) {
     // runtime/overlay context gets private caches because it shadows edges.
     ownershipRootIdsByRowId: sharedOwnershipCaches?.ownershipRootIdsByRowId ?? /* @__PURE__ */ new Map(),
     ownershipDistancesByRowId: sharedOwnershipCaches?.ownershipDistancesByRowId ?? /* @__PURE__ */ new Map(),
+    // Never shared with a base: reconciliation is decided against THIS
+    // index's shadows and overlay, which a sibling context does not have.
+    reconciledOwnershipRows: /* @__PURE__ */ new WeakSet(),
     ownedValueAttachmentsByValueId: /* @__PURE__ */ new Map(),
     constructorOwnershipDirtyValueIds: /* @__PURE__ */ new Set(),
     memberByRowId: /* @__PURE__ */ new Map()
@@ -66232,6 +66657,10 @@ function indexEvaluatorRow(indexes, row, allowBaseShadow = false, sharedCachesAl
   if (indexes.indexedRowIds.has(row.id) || !allowBaseShadow && indexes.baseIndexedRowIds?.has(row.id) === true) {
     return;
   }
+  if (allowBaseShadow && indexes.baseIndexedRowIds?.has(row.id) === true) {
+    indexes.shadowedBaseRowIds.add(row.id);
+    dropReconciledOwnershipRows(indexes);
+  }
   if (!sharedCachesAlreadyInvalidated) {
     indexes.ownershipRootIdsByRowId.clear();
     indexes.ownershipDistancesByRowId.clear();
@@ -66281,20 +66710,85 @@ function indexEvaluatorRow(indexes, row, allowBaseShadow = false, sharedCachesAl
     }
   }
 }
-function indexEvaluatorRows(indexes, rows, allowBaseShadow = false) {
+function indexEvaluatorRows(indexes, rows, allowBaseShadow = false, liveOverlayRowById) {
   let sharedCachesInvalidated = false;
+  const invalidateSharedCaches = () => {
+    if (sharedCachesInvalidated) return;
+    indexes.ownershipRootIdsByRowId.clear();
+    indexes.ownershipDistancesByRowId.clear();
+    indexes.memberByRowId.clear();
+    sharedCachesInvalidated = true;
+  };
   for (const row of rows) {
     const alreadyIndexed = indexes.indexedRowIds.has(row.id) || !allowBaseShadow && indexes.baseIndexedRowIds?.has(row.id) === true;
-    if (alreadyIndexed) continue;
-    if (!sharedCachesInvalidated) {
-      indexes.ownershipRootIdsByRowId.clear();
-      indexes.ownershipDistancesByRowId.clear();
-      indexes.memberByRowId.clear();
-      sharedCachesInvalidated = true;
+    if (alreadyIndexed) {
+      if (liveOverlayRowById === void 0) continue;
+      if (indexes.reconciledOwnershipRows.has(row)) continue;
+      if (!evaluatorOwnershipEdgesAreComplete(indexes, row)) {
+        invalidateSharedCaches();
+        augmentEvaluatorOwnershipEdges(
+          indexes,
+          row,
+          liveOverlayRowById(row.id)
+        );
+      }
+      indexes.reconciledOwnershipRows.add(row);
+      continue;
     }
+    invalidateSharedCaches();
     indexEvaluatorRow(indexes, row, allowBaseShadow, true);
   }
 }
+function evaluatorOwnershipEdgesAreComplete(indexes, row) {
+  for (const [childId, key] of evaluatorRecordOwnershipEdges(row)) {
+    const links = evaluatorParentLinks(indexes, childId);
+    if (!links.some((link) => link.parentId === row.id && link.key === key)) {
+      return false;
+    }
+  }
+  return true;
+}
+function augmentEvaluatorOwnershipEdges(indexes, row, liveRow) {
+  const liveChildIdsByKey = liveRow === null || liveRow === row ? null : liveEdgeChildIdsByKey(liveRow);
+  for (const [childId, key] of evaluatorRecordOwnershipEdges(row)) {
+    const liveChildIds = liveChildIdsByKey?.get(key);
+    if (liveChildIds !== void 0 && !liveChildIds.has(childId)) continue;
+    const links = evaluatorParentLinks(indexes, childId);
+    if (links.some((link) => link.parentId === row.id && link.key === key)) {
+      continue;
+    }
+    addEvaluatorParentLink(indexes, childId, row.id, key);
+    indexes.ownedValueAttachmentsByValueId.delete(childId);
+    indexes.constructorOwnershipDirtyValueIds.add(childId);
+  }
+}
+function liveEdgeChildIdsByKey(liveRow) {
+  const childIdsByKey = /* @__PURE__ */ new Map();
+  for (const [liveChildId, liveKey] of evaluatorRecordOwnershipEdges(liveRow)) {
+    const bucket = childIdsByKey.get(liveKey);
+    if (bucket === void 0) {
+      childIdsByKey.set(liveKey, /* @__PURE__ */ new Set([liveChildId]));
+      continue;
+    }
+    bucket.add(liveChildId);
+  }
+  return childIdsByKey;
+}
+function evaluatorRecordOwnershipEdges(row) {
+  if (Array.isArray(row.value)) {
+    const edges2 = [];
+    for (const childId of row.value) {
+      if (typeof childId === "string") edges2.push([childId, ""]);
+    }
+    return edges2;
+  }
+  if (typeof row.value !== "object" || row.value === null) return [];
+  const edges = [];
+  for (const [key, childId] of Object.entries(row.value)) {
+    if (typeof childId === "string") edges.push([childId, key]);
+  }
+  return edges;
+}
 function unindexEvaluatorRow(indexes, row) {
   indexes.indexedRowIds.delete(row.id);
   indexes.ownedValueAttachmentsByValueId.delete(row.id);
@@ -66329,6 +66823,10 @@ function unindexEvaluatorRow(indexes, row) {
   indexes.ownershipRootIdsByRowId.clear();
   indexes.ownershipDistancesByRowId.clear();
   indexes.memberByRowId.clear();
+  dropReconciledOwnershipRows(indexes);
+}
+function dropReconciledOwnershipRows(indexes) {
+  indexes.reconciledOwnershipRows = /* @__PURE__ */ new WeakSet();
 }
 function addEvaluatorParentLink(indexes, childId, parentId, key) {
   const links = indexes.parentLinksByChildId.get(childId) ?? [];
@@ -66406,7 +66904,12 @@ function resolveRuntimeReferenceRow(sourceValueId, ctx, withProvenance) {
   const indexes = evaluatorIndexes(ctx);
   const virtualRows = ctx.vm.databaseVM?.virtualInstanceRowsForValue(receiver.id) ?? [];
   if (virtualRows.length > 0) {
-    indexEvaluatorRows(indexes, virtualRows, true);
+    indexEvaluatorRows(
+      indexes,
+      virtualRows,
+      true,
+      (valueId) => ctx.__runtimeSessionValues?.get(valueId) ?? ctx.__valueOverlay?.get(valueId) ?? null
+    );
   }
   const receiverRoots = evaluatorOwnershipRootIds(receiver.id, indexes);
   const matches = evaluatorRowsForSourceValueId(indexes, sourceValueId).filter(
@@ -74701,8 +75204,8 @@ var init_evaluateNSGetter = __esm({
 
 // ../src/models/members/stored-value-placement-index.ts
 function buildStoredValuePlacementIndex(args) {
-  const membersById = /* @__PURE__ */ new Map();
-  for (const member of args.members) membersById.set(member.id, member);
+  const membersById2 = /* @__PURE__ */ new Map();
+  for (const member of args.members) membersById2.set(member.id, member);
   const valuesById = /* @__PURE__ */ new Map();
   const unorderedEntriesByContainerId = /* @__PURE__ */ new Map();
   for (const value of args.values) {
@@ -74740,7 +75243,7 @@ function buildStoredValuePlacementIndex(args) {
   };
   const queue = [];
   for (const root of projectRootMembersInDisplayOrder(args.project)) {
-    const member = membersById.get(root.memberId);
+    const member = membersById2.get(root.memberId);
     if (member === void 0 || typeof member.valueId !== "string") continue;
     queue.push({
       memberId: member.id,
@@ -74779,7 +75282,7 @@ function buildStoredValuePlacementIndex(args) {
     const item = queue[cursor];
     if (item === void 0 || placementByValueId.has(item.valueId)) continue;
     const authoredValue = valuesById.get(item.valueId);
-    const storedMember = membersById.get(item.memberId);
+    const storedMember = membersById2.get(item.memberId);
     if (authoredValue === void 0 || storedMember === void 0) continue;
     const value = args.resolveValue === void 0 ? authoredValue : args.resolveValue(authoredValue);
     if (value === null) continue;
@@ -74793,7 +75296,7 @@ function buildStoredValuePlacementIndex(args) {
       appendPlacement(mutablePlacementsByClassId, classId, placement);
       if (!isStringRecord3(value.value)) continue;
       for (const entry of storedSchema(classId)) {
-        const childMember = membersById.get(entry.memberId);
+        const childMember = membersById2.get(entry.memberId);
         const childValueId = value.value[entry.schemaKey];
         if (childMember === void 0 || typeof childValueId !== "string") {
           continue;
@@ -74811,7 +75314,7 @@ function buildStoredValuePlacementIndex(args) {
     if (!isMemberListBase(member) && !isMemberDictionaryBase(member)) {
       continue;
     }
-    const entryMember = membersById.get(member.entryMemberId);
+    const entryMember = membersById2.get(member.entryMemberId);
     if (entryMember === void 0) continue;
     if (isMemberDictionaryBase(member)) {
       if (!isStringRecord3(value.value)) continue;
@@ -74878,6 +75381,27 @@ var init_stored_value_placement_index = __esm({
 });
 
 // ../src/database/virtual-instance-values.ts
+function firstListInParameterType(typeInfo, depth = 0) {
+  if (typeof typeInfo !== "object" || typeInfo === null) return null;
+  if (depth > CONSTRUCTOR_TYPE_WALK_DEPTH_LIMIT) return "depth-limit";
+  const shape = typeInfo;
+  if (shape.type === 6 /* List */) return "list";
+  const entry = firstListInParameterType(shape.entryTypeInfo, depth + 1);
+  if (entry !== null) return entry;
+  if (Array.isArray(shape.argumentTypes)) {
+    for (const argument2 of shape.argumentTypes) {
+      const nested = firstListInParameterType(argument2, depth + 1);
+      if (nested !== null) return nested;
+    }
+  }
+  return null;
+}
+function constructorBodyIsCorpusFree(constructor2) {
+  if (constructor2.code !== null && constructor2.code.trim() !== "") return false;
+  if ((constructor2.baseArguments ?? []).length > 0) return false;
+  if ((constructor2.baseInitializerFields ?? []).length > 0) return false;
+  return true;
+}
 function withoutInitializerConstructionFields(init) {
   if (init.compiled === void 0) return init;
   const baseline = structuredClone(init);
@@ -74892,6 +75416,28 @@ function withoutInitializerConstructionFields(init) {
   }
   return baseline;
 }
+function derivesContentFromMemberDefault(args) {
+  const member = args.member;
+  if (!isMemberClassBase(member)) return false;
+  if (member.partial === true) return false;
+  const declared = member.defaultValue;
+  if (!isLiteralValueContent(declared)) return false;
+  const record3 = declared.value;
+  if (typeof record3 !== "object" || record3 === null) return false;
+  if (Array.isArray(record3)) return false;
+  if (Object.keys(record3).length === 0) return false;
+  if ((declared.classId ?? member.classId) !== args.effectiveClassId) {
+    return false;
+  }
+  const root = args.instanceRoot;
+  if (typeof root.instanceConstructorId === "string") return false;
+  if (typeof root.instanceVariantId === "string") return false;
+  const storedArgs = root.constructorArgs;
+  if (typeof storedArgs === "object" && storedArgs !== null && Object.keys(storedArgs).length > 0) {
+    return false;
+  }
+  return true;
+}
 function claimVirtualIdentity(args) {
   if (args.fixedVirtualId !== void 0) {
     args.claimedVirtualIds.set(args.fixedVirtualId, args.pathKey);
@@ -74912,6 +75458,8 @@ function claimVirtualIdentity(args) {
   return { sourceIdentity: sourceIdentity3, virtualId };
 }
 function expandStoredInstance(args) {
+  const recorder = args.readRecorder ?? null;
+  recorder?.recordValueRead(args.instanceRoot.id);
   const rootMember = resolveMember2(args.rootMember, args.document.members);
   if (!isMemberClassBase(rootMember)) {
     throw new Error(
@@ -74944,6 +75492,25 @@ function expandStoredInstance(args) {
       `Virtual expansion root "${args.instanceRoot.id}" has no durable overload identity for class "${classId}"; keep this historical graph materialized.`
     );
   }
+  if (recorder !== null && requiredConstructor !== null) {
+    if (!constructorBodyIsCorpusFree(requiredConstructor)) {
+      recorder.recordGlobalRead(
+        `authored-constructor-body:${requiredConstructor.id}`
+      );
+    }
+    for (const typeInfo of requiredConstructor.argumentTypes) {
+      if (firstListInParameterType(typeInfo) === null) continue;
+      recorder.recordGlobalRead(
+        `constructor-argument-list:${requiredConstructor.id}`
+      );
+      break;
+    }
+  }
+  if (recorder !== null && typeof instanceRoot.instanceVariantId === "string") {
+    recorder.recordGlobalRead(
+      `variant-initialize:${instanceRoot.instanceVariantId}`
+    );
+  }
   const storedArgs = instanceRoot.constructorArgs ?? {};
   if (requiredConstructor !== null && instanceRoot.constructorArgs == null) {
     throw new VirtualExpansionUnsupportedError(
@@ -75049,7 +75616,29 @@ function expandStoredInstance(args) {
       constructionBaselineReplay: fields.length === 0
     });
   };
-  const materialized = replay([]);
+  const replayDeclaredDefault = () => {
+    const stampEnv = instanceRoot.genericBindings == null || Object.keys(instanceRoot.genericBindings).length === 0 ? null : envFromStamp(instanceRoot.genericBindings);
+    const built = materializeMemberDefaultValue({
+      document: args.document,
+      member: replayMember,
+      envelope,
+      ...stampEnv === null ? {} : { genericEnv: stampEnv }
+    });
+    return {
+      ...built,
+      root: {
+        ...built.root,
+        classId,
+        instanceConstructorId: recordedConstructorId,
+        constructorArgs: storedArgs
+      }
+    };
+  };
+  const materialized = derivesContentFromMemberDefault({
+    member: replayMember,
+    instanceRoot,
+    effectiveClassId: classId
+  }) ? replayDeclaredDefault() : replay([]);
   const rows = [materialized.root, ...materialized.createdValues];
   assertVirtualExpansionIsLiteral(rows);
   return {
@@ -75060,11 +75649,21 @@ function expandStoredInstance(args) {
 }
 function resolveVirtualInstanceGraph(args) {
   const expansion = indexExpansion(args);
+  const recorder = args.readRecorder ?? null;
+  if (recorder !== null) {
+    recorder.recordValueRead(args.instanceRoot.id);
+    const unattributable = firstUnattributableExpansionMember(expansion);
+    if (unattributable !== null) recorder.recordGlobalRead(unattributable);
+  }
   const materializedById = new Map(
     (args.materializedRows ?? args.document.values).map((row) => [row.id, row])
   );
   const materializedRows = [...materializedById.values()];
   const materializedUnorderedEntryIdsByContainerId = buildUnorderedListMembershipIndex(materializedRows);
+  const readMaterializedRow = (valueId) => {
+    recorder?.recordValueRead(valueId);
+    return materializedById.get(valueId) ?? null;
+  };
   const rowsById = /* @__PURE__ */ new Map();
   const locationsById = /* @__PURE__ */ new Map();
   const locationsByPath = /* @__PURE__ */ new Map();
@@ -75087,7 +75686,7 @@ function resolveVirtualInstanceGraph(args) {
     }
     visiting.add(pathKey);
     const effectiveMaterializedId = materializedId2 ?? (pathKey === ROOT_PATH ? null : indexed.virtualId);
-    const materialized = effectiveMaterializedId === null ? null : materializedById.get(effectiveMaterializedId) ?? null;
+    const materialized = effectiveMaterializedId === null ? null : readMaterializedRow(effectiveMaterializedId);
     const effectiveId = materialized?.id ?? indexed.virtualId;
     const effective = {
       ...cloneRow(indexed.expandedRow),
@@ -75137,26 +75736,21 @@ function resolveVirtualInstanceGraph(args) {
         const listMember = indexed.member;
         effective.value = [];
         const childPaths = expansion.childPathsByParentPath.get(pathKey) ?? [];
-        const storedEntryIds = materialized === null ? [] : materializedUnorderedEntryIdsByContainerId.get(
-          materialized.id
-        ) ?? [];
+        recorder?.recordGlobalRead(`unordered-list-membership:${effectiveId}`);
+        const storedEntryIds = materializedUnorderedEntryIdsByContainerId.get(effectiveId) ?? [];
+        const storedEntries = storedEntryIds.flatMap((storedEntryId) => {
+          const entry = readMaterializedRow(storedEntryId);
+          return entry === null ? [] : [entry];
+        });
+        const resolvedEntryPaths = [];
+        const matchedStoredIds = /* @__PURE__ */ new Set();
         if (materialized === null) {
           for (const childPath of childPaths) {
-            resolvePath(childPath, null, effectiveId);
+            const entry = resolvePath(childPath, null, effectiveId);
+            resolvedEntryPaths.push(childPath);
+            matchedStoredIds.add(entry.id);
           }
         } else {
-          const entryMember = args.document.members.find(
-            (candidate) => candidate.id === listMember.entryMemberId
-          );
-          if (entryMember === void 0) {
-            throw new Error(
-              `Unordered list member "${listMember.name}" references missing entry member "${listMember.entryMemberId}".`
-            );
-          }
-          const storedEntries = storedEntryIds.flatMap((storedEntryId) => {
-            const entry = materializedById.get(storedEntryId);
-            return entry === void 0 ? [] : [entry];
-          });
           const unmatchedChildPaths = [...childPaths];
           const matchedEntries = [];
           const unmatchedStoredEntries = [];
@@ -75179,54 +75773,58 @@ function resolveVirtualInstanceGraph(args) {
             if (childPath === void 0) break;
             matchedEntries.push({ storedEntry, childPath });
           }
-          const resolvedEntryPaths = [];
-          const matchedStoredIds = /* @__PURE__ */ new Set();
           for (const { storedEntry, childPath } of matchedEntries) {
             resolvePath(childPath, storedEntry.id, effectiveId);
             resolvedEntryPaths.push(childPath);
             matchedStoredIds.add(storedEntry.id);
           }
-          let extraIndex = childPaths.length;
-          for (const storedEntry of storedEntries) {
-            if (matchedStoredIds.has(storedEntry.id)) continue;
-            const childPath = appendPath(pathKey, {
-              kind: "list",
-              index: extraIndex
-            });
-            extraIndex += 1;
-            const claimed = claimVirtualIdentity({
-              claimedVirtualIds: expansion.claimedVirtualIds,
-              instanceRootId: args.instanceRoot.id,
-              pathKey: childPath,
-              rawSourceIdentity: storedEntry.sourceValueId ?? storedEntry.id
-            });
-            const effectiveEntry = {
-              ...storedEntry,
-              containerId: effectiveId
-            };
-            const entryLocation = {
-              id: storedEntry.id,
-              instanceRootId: args.instanceRoot.id,
-              pathKey: childPath,
-              sourceIdentity: claimed.sourceIdentity,
-              member: entryMember,
-              memberId: listMember.entryMemberId,
-              parentId: effectiveId,
-              parentSegment: { kind: "list", index: extraIndex - 1 },
-              virtualRow: {
-                ...effectiveEntry,
-                id: claimed.virtualId,
-                sourceValueId: `missing-expansion:${storedEntry.id}`
-              },
-              materializedRow: storedEntry
-            };
-            rowsById.set(effectiveEntry.id, effectiveEntry);
-            locationsById.set(effectiveEntry.id, entryLocation);
-            locationsByPath.set(childPath, entryLocation);
-            resolvedEntryPaths.push(childPath);
+        }
+        let extraIndex = childPaths.length;
+        const entryMember = expansion.membersById.get(listMember.entryMemberId);
+        for (const storedEntry of storedEntries) {
+          if (matchedStoredIds.has(storedEntry.id)) continue;
+          if (entryMember === void 0) {
+            throw new Error(
+              `Unordered list member "${listMember.name}" references missing entry member "${listMember.entryMemberId}".`
+            );
           }
-          childPathsByParentPath.set(pathKey, resolvedEntryPaths);
+          const childPath = appendPath(pathKey, {
+            kind: "list",
+            index: extraIndex
+          });
+          extraIndex += 1;
+          const claimed = claimVirtualIdentity({
+            claimedVirtualIds: expansion.claimedVirtualIds,
+            instanceRootId: args.instanceRoot.id,
+            pathKey: childPath,
+            rawSourceIdentity: storedEntry.sourceValueId ?? storedEntry.id
+          });
+          const effectiveEntry = {
+            ...storedEntry,
+            containerId: effectiveId
+          };
+          const entryLocation = {
+            id: storedEntry.id,
+            instanceRootId: args.instanceRoot.id,
+            pathKey: childPath,
+            sourceIdentity: claimed.sourceIdentity,
+            member: entryMember,
+            memberId: listMember.entryMemberId,
+            parentId: effectiveId,
+            parentSegment: { kind: "list", index: extraIndex - 1 },
+            virtualRow: {
+              ...effectiveEntry,
+              id: claimed.virtualId,
+              sourceValueId: `missing-expansion:${storedEntry.id}`
+            },
+            materializedRow: storedEntry
+          };
+          rowsById.set(effectiveEntry.id, effectiveEntry);
+          locationsById.set(effectiveEntry.id, entryLocation);
+          locationsByPath.set(childPath, entryLocation);
+          resolvedEntryPaths.push(childPath);
         }
+        childPathsByParentPath.set(pathKey, resolvedEntryPaths);
       } else {
         const expandedEntries = Array.isArray(indexed.expandedRow.value) ? indexed.expandedRow.value : [];
         const materializedEntries = materialized !== null && Array.isArray(materialized.value) ? materialized.value : null;
@@ -75311,29 +75909,88 @@ function resolveVirtualInstanceGraph(args) {
     root: rootLocation
   };
 }
+function firstUnattributableExpansionMember(expansion) {
+  for (const node of expansion.nodesByPath.values()) {
+    const member = node.member;
+    if (isMemberListBase(member) && listKindOf(member) === "unordered") {
+      return `unordered-list-member:${node.memberId}`;
+    }
+    if (CORPUS_SCANNING_MEMBER_KINDS.has(member.kind)) {
+      return `corpus-scanning-member-kind:${node.memberId}`;
+    }
+    const declaredDefault = member.defaultValue;
+    if (declaredDefault !== void 0 && declaredDefault !== null && "init" in declaredDefault && declaredDefault.init !== void 0 && declaredDefault.init !== null) {
+      return `authored-initializer-member:${node.memberId}`;
+    }
+  }
+  return null;
+}
+function recordKeysLost(kept, candidate) {
+  if (!isLiteralValueContent(kept)) return [];
+  if (!isLiteralValueContent(candidate)) return [];
+  const keptValue = kept.value;
+  const candidateValue = candidate.value;
+  if (typeof keptValue !== "object" || keptValue === null) return [];
+  if (Array.isArray(keptValue)) return [];
+  if (typeof candidateValue !== "object" || candidateValue === null) return [];
+  if (Array.isArray(candidateValue)) return [];
+  const lost = [];
+  for (const key of Object.keys(keptValue)) {
+    if (Object.hasOwn(candidateValue, key)) continue;
+    lost.push(key);
+  }
+  return lost;
+}
+function reportFrameResolutionDisagreement(args) {
+  console.warn(
+    `Virtual instance frames disagree on value "${args.valueId}": the expansion of root "${args.droppedFrameRootId}" omits ${args.droppedKeys.join(", ")}, which the expansion of root "${args.keptFrameRootId}" resolves. Keeping the wider resolution.`
+  );
+}
 function resolvedStoredInstanceRows(args) {
   const rows = new Map(args.document.values.map((row) => [row.id, row]));
   const queue = [{ root: args.instanceRoot, member: args.rootMember }];
   const resolvedRootIds = /* @__PURE__ */ new Set();
+  const resolvedFrameByValueId = /* @__PURE__ */ new Map();
   while (queue.length > 0) {
     const next = queue.shift();
     if (next === void 0 || resolvedRootIds.has(next.root.id)) continue;
     resolvedRootIds.add(next.root.id);
-    const document = { ...args.document, values: [...rows.values()] };
     const expanded = expandStoredInstance({
-      document,
+      document: args.document,
       instanceRoot: next.root,
       rootMember: next.member
     });
     const graph = resolveVirtualInstanceGraph({
-      document,
+      document: args.document,
       instanceRoot: next.root,
       rootMember: next.member,
       expandedRoot: expanded.root,
       expandedRows: expanded.rows,
-      materializedRows: document.values
+      materializedRows: args.document.values
     });
-    for (const [id2, row] of graph.rowsById) rows.set(id2, row);
+    for (const [id2, row] of graph.rowsById) {
+      const priorFrame = resolvedFrameByValueId.get(id2);
+      if (priorFrame !== void 0 && priorFrame !== next.root.id) {
+        const prior = rows.get(id2);
+        if (prior === void 0) {
+          throw new Error(
+            `Virtual instance frame "${priorFrame}" is recorded as resolving value "${id2}", but no resolved row for it exists.`
+          );
+        }
+        const dropped = recordKeysLost(prior, row);
+        if (dropped.length > 0) {
+          reportFrameResolutionDisagreement({
+            valueId: id2,
+            keptFrameRootId: priorFrame,
+            droppedFrameRootId: next.root.id,
+            droppedKeys: dropped
+          });
+          continue;
+        }
+      }
+      rows.set(id2, row);
+      resolvedFrameByValueId.set(id2, next.root.id);
+    }
     for (const location3 of graph.locationsByPath.values()) {
       const materialized = location3.materializedRow;
       if (materialized === null || materialized.id === next.root.id || resolvedRootIds.has(materialized.id) || !isLiteralValueContent(materialized) || !isMemberClassBase(location3.member) || !isVirtualInstanceRootShape(materialized)) {
@@ -75512,6 +76169,18 @@ function planCollapseVirtualInstance(args) {
     return reproducible;
   };
   const nestedRootIds = args.nestedRootValueIds ?? /* @__PURE__ */ new Set();
+  const ownsChildInterior = (child) => {
+    const stored = child.materializedRow;
+    if (stored === null) return true;
+    if (nestedRootIds.has(stored.id)) return false;
+    if (!isLiteralValueContent(stored)) return true;
+    if (creationProvenanceEqual(stored, child.virtualRow)) return true;
+    if (typeof stored.instanceConstructorId === "string") return false;
+    if (typeof stored.instanceVariantId === "string") return false;
+    const storedArgs = stored.constructorArgs;
+    if (storedArgs != null && Object.keys(storedArgs).length > 0) return false;
+    return !isInitValueContent(child.member.defaultValue);
+  };
   const valuesById = args.valuesById ?? /* @__PURE__ */ new Map();
   const frameDerivedLineages = /* @__PURE__ */ new Set();
   for (const location3 of args.graph.locationsByPath.values()) {
@@ -75634,6 +76303,7 @@ function planCollapseVirtualInstance(args) {
       }
     } else if (isMemberListBase(location3.member)) {
       if (listKindOf(location3.member) === "unordered") {
+        protectedSubtree = true;
         const storedEntries = args.graph.materializedUnorderedEntryIdsByContainerId.get(real.id) ?? [];
         const virtualEntries = args.graph.expandedChildPathsByParentPath.get(location3.pathKey) ?? [];
         const resolvedEntries = args.graph.childPathsByParentPath.get(location3.pathKey) ?? [];
@@ -75658,7 +76328,6 @@ function planCollapseVirtualInstance(args) {
           const facts = compareSubtree(child);
           defaultEqual &&= facts.defaultEqual;
           contentEqual &&= facts.contentEqual;
-          protectedSubtree ||= facts.protected;
         }
         const membershipEqual = semanticEqual(
           resolvedStoredIds.sort(),
@@ -75768,7 +76437,9 @@ function planCollapseVirtualInstance(args) {
         continue;
       }
       next[schemaKey] = child.materializedRow?.id ?? childId;
-      if (isMemberClassBase(child.member)) sparsifyClass(child);
+      if (!isMemberClassBase(child.member)) continue;
+      if (!ownsChildInterior(child)) continue;
+      sparsifyClass(child);
     }
     if (!semanticEqual(stored, next)) {
       updates.push({ valueId: real.id, value: next });
@@ -75963,7 +76634,7 @@ function indexExpansion(args) {
   const nodesByExpandedId = /* @__PURE__ */ new Map();
   const nodesByPath = /* @__PURE__ */ new Map();
   const claimedVirtualIds = /* @__PURE__ */ new Map();
-  const membersById = new Map(
+  const membersById2 = new Map(
     args.document.members.map((member) => [member.id, member])
   );
   const unorderedEntriesByContainerId = buildUnorderedListMembershipIndex(
@@ -76038,7 +76709,7 @@ function indexExpansion(args) {
       );
       for (const entry of schema) {
         const childId = record3[entry.schemaKey];
-        const childMember = membersById.get(entry.memberId);
+        const childMember = membersById2.get(entry.memberId);
         if (typeof childId !== "string" || childMember === void 0) continue;
         const segment = {
           kind: "class",
@@ -76057,7 +76728,7 @@ function indexExpansion(args) {
     }
     if (isMemberListBase(member)) {
       if (listKindOf(member) === "unordered") {
-        const entryMember3 = membersById.get(member.entryMemberId);
+        const entryMember3 = membersById2.get(member.entryMemberId);
         if (entryMember3 === void 0) return;
         (unorderedEntriesByContainerId.get(row.id) ?? []).forEach(
           (childId, index) => {
@@ -76079,7 +76750,7 @@ function indexExpansion(args) {
       if (!Array.isArray(row.value)) {
         return;
       }
-      const entryMember2 = membersById.get(member.entryMemberId);
+      const entryMember2 = membersById2.get(member.entryMemberId);
       if (entryMember2 === void 0) return;
       row.value.forEach((childId, index) => {
         if (typeof childId !== "string") return;
@@ -76096,7 +76767,7 @@ function indexExpansion(args) {
       return;
     }
     if (!isMemberDictionaryBase(member)) return;
-    const entryMember = membersById.get(member.entryMemberId);
+    const entryMember = membersById2.get(member.entryMemberId);
     if (entryMember === void 0) return;
     for (const [key, childId] of Object.entries(stringRecord2(row.value))) {
       const segment = { kind: "dictionary", key };
@@ -76123,7 +76794,8 @@ function indexExpansion(args) {
     nodesByPath,
     rowsByExpandedId,
     childPathsByParentPath,
-    claimedVirtualIds
+    claimedVirtualIds,
+    membersById: membersById2
   };
 }
 function outermostVirtualCollectionBoundary(graph, target) {
@@ -76494,18 +77166,34 @@ function assertVirtualExpansionIsLiteral(rows) {
     }
   }
 }
+function composeResolverDocument(document, resolverLookups) {
+  let byLookups = resolverDocumentsByDocument.get(document);
+  if (byLookups === void 0) {
+    byLookups = /* @__PURE__ */ new WeakMap();
+    resolverDocumentsByDocument.set(document, byLookups);
+  }
+  const memoized = byLookups.get(resolverLookups);
+  if (memoized !== void 0) return memoized;
+  const composed = {
+    ...document,
+    databaseVM: resolverLookups
+  };
+  byLookups.set(resolverLookups, composed);
+  return composed;
+}
 function resolveVariantInstanceGraphForDocument(args) {
   if (!isLiteralValueContent(args.priorInstanceRoot) || !isLiteralValueContent(args.nextInstanceRoot)) {
     throw new Error("ToVariant requires literal instance roots.");
   }
+  const document = composeResolverDocument(args.document, args.resolverLookups);
   const classId = args.nextInstanceRoot.classId ?? args.priorInstanceRoot.classId;
   if (typeof classId !== "string" || classId.length === 0) {
     throw new Error("ToVariant instance root has no concrete class id.");
   }
-  const declaredMember = args.declaredRootMember !== void 0 ? args.declaredRootMember ?? void 0 : variantSwapDeclaredMember(args.document, args.priorInstanceRoot.id);
+  const declaredMember = args.declaredRootMember !== void 0 ? args.declaredRootMember ?? void 0 : variantSwapDeclaredMember(document, args.priorInstanceRoot.id);
   const syntheticRootMember = {
     id: `virtual-instance-root:${args.priorInstanceRoot.id}`,
-    projectId: args.document.project.id,
+    projectId: document.project.id,
     createdAt: args.priorInstanceRoot.createdAt,
     updatedAt: args.priorInstanceRoot.updatedAt,
     name: "Virtual instance root",
@@ -76519,17 +77207,17 @@ function resolveVariantInstanceGraphForDocument(args) {
     isAbstract: false,
     accessModifierKind: "public"
   };
-  const rootMember = declaredMember !== void 0 && isMemberClassBase(resolveMember2(declaredMember, args.document.members)) ? declaredMember : syntheticRootMember;
-  const materializedById = args.materializedRowsById ?? new Map(args.document.values.map((row) => [row.id, row]));
+  const rootMember = declaredMember !== void 0 && isMemberClassBase(resolveMember2(declaredMember, document.members)) ? declaredMember : syntheticRootMember;
+  const materializedById = args.materializedRowsById ?? new Map(document.values.map((row) => [row.id, row]));
   for (const row of args.localRows) materializedById.set(row.id, row);
   materializedById.set(args.priorInstanceRoot.id, args.priorInstanceRoot);
   const priorExpanded = expandStoredInstance({
-    document: args.document,
+    document,
     instanceRoot: args.priorInstanceRoot,
     rootMember
   });
   const priorGraph = resolveVirtualInstanceGraph({
-    document: args.document,
+    document,
     instanceRoot: args.priorInstanceRoot,
     rootMember,
     expandedRoot: priorExpanded.root,
@@ -76560,12 +77248,12 @@ function resolveVariantInstanceGraphForDocument(args) {
   }
   materializedById.set(args.nextInstanceRoot.id, args.nextInstanceRoot);
   const nextExpanded = expandStoredInstance({
-    document: args.document,
+    document,
     instanceRoot: args.nextInstanceRoot,
     rootMember
   });
   const nextGraph = resolveVirtualInstanceGraph({
-    document: args.document,
+    document,
     instanceRoot: args.nextInstanceRoot,
     rootMember,
     expandedRoot: nextExpanded.root,
@@ -76606,6 +77294,7 @@ function createHeadlessVirtualInstanceResolver(args) {
     values: document.values
   }).placementByValueId;
   const rawById = new Map(document.values.map((row) => [row.id, row]));
+  const resolverDocumentOnce = () => composeResolverDocument(document, args.resolverLookups());
   const graphRowsByRootId = /* @__PURE__ */ new Map();
   const graphByValueId = /* @__PURE__ */ new Map();
   const failedRootIds = /* @__PURE__ */ new Set();
@@ -76629,10 +77318,7 @@ function createHeadlessVirtualInstanceResolver(args) {
       return /* @__PURE__ */ new Map();
     }
     try {
-      const resolverDocument = {
-        ...document,
-        databaseVM: args.resolverLookups()
-      };
+      const resolverDocument = resolverDocumentOnce();
       const expanded = expandStoredInstance({
         document: resolverDocument,
         instanceRoot,
@@ -76687,7 +77373,7 @@ function createHeadlessVirtualInstanceResolver(args) {
     }
   };
 }
-var KEPT_ROW_SAMPLE_LIMIT, VirtualExpansionUnsupportedError, ROOT_PATH, SYNTHETIC_LINEAGE_PREFIXES;
+var KEPT_ROW_SAMPLE_LIMIT, CORPUS_SCANNING_MEMBER_KINDS, CONSTRUCTOR_TYPE_WALK_DEPTH_LIMIT, VirtualExpansionUnsupportedError, ROOT_PATH, SYNTHETIC_LINEAGE_PREFIXES, resolverDocumentsByDocument;
 var init_virtual_instance_values = __esm({
   "../src/database/virtual-instance-values.ts"() {
     "use strict";
@@ -76703,6 +77389,17 @@ var init_virtual_instance_values = __esm({
     init_constructor_argument_ownership();
     init_src();
     KEPT_ROW_SAMPLE_LIMIT = 12;
+    CORPUS_SCANNING_MEMBER_KINDS = /* @__PURE__ */ new Set([
+      9 /* Lookup */,
+      18 /* DialogueLookup */,
+      10 /* NSProperty */,
+      23 /* NSFunction */,
+      13 /* Function */,
+      24 /* FunctionRef */,
+      25 /* NSDelegate */,
+      26 /* NSAction */
+    ]);
+    CONSTRUCTOR_TYPE_WALK_DEPTH_LIMIT = 8;
     VirtualExpansionUnsupportedError = class extends Error {
       constructor(message) {
         super(message);
@@ -76711,6 +77408,7 @@ var init_virtual_instance_values = __esm({
     };
     ROOT_PATH = "$";
     SYNTHETIC_LINEAGE_PREFIXES = ["missing-expansion:", "path:"];
+    resolverDocumentsByDocument = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -76748,7 +77446,8 @@ function initializerEvaluatorLookups(document) {
       // resolves against the plain document, with these lookups as the
       // nested resolver.
       resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
-        document: { ...document, databaseVM: lookups },
+        document,
+        resolverLookups: lookups,
         ...args
       })
     } : {
@@ -76938,6 +77637,30 @@ function evaluateInitializerMaterialization(args) {
   });
   return { evaluated, createdValues, storageKeyDeclarations };
 }
+function finalizeMaterializedRoot(args) {
+  for (const created of args.allCreated) {
+    if (created === args.root) continue;
+    if (created.classId === void 0) delete created.classId;
+  }
+  stampCreatedValuesMapKey(args.allCreated, args.mapKey);
+  if (args.supersededRootId !== void 0) {
+    args.storageKeyDeclarations.delete(args.supersededRootId);
+  }
+  args.storageKeyDeclarations.delete(args.root.id);
+  applyDeclaredStorageKeyOverrides({
+    createdValues: args.allCreated,
+    declarationByValueId: args.storageKeyDeclarations,
+    existingParentContextById: /* @__PURE__ */ new Map([
+      [
+        args.root.id,
+        {
+          mapKey: args.mapKey ?? null,
+          classId: args.root.classId ?? void 0
+        }
+      ]
+    ])
+  });
+}
 function materializeInitializerValue(args) {
   const { evaluated, createdValues, storageKeyDeclarations } = evaluateInitializerMaterialization({
     init: args.row.init,
@@ -76965,31 +77688,19 @@ function materializeInitializerValue(args) {
       instanceVariantRowValueId: evaluated.instanceVariantRowValueId
     }
   };
+  const allCreated = [root, ...createdValues];
   if (evaluated.provisionalRootId !== void 0) {
     retargetDelegateReceiverValueIds(
-      [root, ...createdValues],
+      allCreated,
       evaluated.provisionalRootId,
       root.id
     );
   }
-  const allCreated = [root, ...createdValues];
-  for (const created of createdValues) {
-    if (created.classId === void 0) delete created.classId;
-  }
-  stampCreatedValuesMapKey(allCreated, args.row.mapKey);
-  storageKeyDeclarations.delete(root.id);
-  applyDeclaredStorageKeyOverrides({
-    createdValues: allCreated,
-    declarationByValueId: storageKeyDeclarations,
-    existingParentContextById: /* @__PURE__ */ new Map([
-      [
-        root.id,
-        {
-          mapKey: args.row.mapKey ?? null,
-          classId: root.classId ?? void 0
-        }
-      ]
-    ])
+  finalizeMaterializedRoot({
+    root,
+    allCreated,
+    mapKey: args.row.mapKey,
+    storageKeyDeclarations
   });
   return {
     root,
@@ -76997,6 +77708,43 @@ function materializeInitializerValue(args) {
     pinnedRootSchemaKeys: evaluated.pinnedRootSchemaKeys ?? /* @__PURE__ */ new Set()
   };
 }
+function materializeMemberDefaultValue(args) {
+  const createdValues = [];
+  const storageKeyDeclarations = /* @__PURE__ */ new Map();
+  const built = buildDefaultMemberValue({
+    document: args.document,
+    projectId: args.envelope.projectId,
+    member: args.member,
+    createdValues,
+    storageKeyDeclarations,
+    ...args.genericEnv === void 0 ? {} : { genericEnv: args.genericEnv },
+    // A declaration default may itself be init-backed one level down (P43 §2),
+    // and those nested initializers must evaluate against the same document.
+    initEvaluator: (member, init) => evaluateMemberInitializer({
+      init,
+      member,
+      document: args.document,
+      createdValues
+    })
+  });
+  const interior = createdValues.filter((created) => created.id !== built.id);
+  const root = {
+    ...args.envelope,
+    value: built.value,
+    ...built.classId === void 0 ? {} : { classId: built.classId },
+    ...built.genericBindings == null ? {} : { genericBindings: { ...built.genericBindings } }
+  };
+  const allCreated = [root, ...interior];
+  retargetDelegateReceiverValueIds(allCreated, built.id, root.id);
+  finalizeMaterializedRoot({
+    root,
+    allCreated,
+    mapKey: args.envelope.mapKey,
+    storageKeyDeclarations,
+    supersededRootId: built.id
+  });
+  return { root, createdValues: interior, pinnedRootSchemaKeys: /* @__PURE__ */ new Set() };
+}
 var init_init_backed_value_materialization = __esm({
   "../src/database/init-backed-value-materialization.ts"() {
     "use strict";
@@ -78632,315 +79380,6 @@ var init_project_document_read = __esm({
   }
 });
 
-// src/workspace.ts
-import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "node:fs";
-import { dirname, join as join2, resolve } from "node:path";
-function recordStateKey(recordKind, recordId) {
-  return `${recordKind}:${recordId}`;
-}
-function findWorkspaceRoot(startDir) {
-  let dir = resolve(startDir);
-  for (; ; ) {
-    if (existsSync2(join2(dir, NEO_CONFIG_FILE))) return dir;
-    const parent = dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-function readWorkspaceConfig(root) {
-  const raw = readFileSync2(join2(root, NEO_CONFIG_FILE), "utf8");
-  const parsed = JSON.parse(raw);
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`"${NEO_CONFIG_FILE}" must contain a JSON object.`);
-  }
-  const config = parsed;
-  if (config.formatVersion === void 0) {
-    throw new Error(
-      `"${NEO_CONFIG_FILE}" is missing required field "formatVersion"; expected ${CURRENT_FORMAT_VERSION}. Recreate this working copy with \`neo init\`.`
-    );
-  }
-  if (config.formatVersion !== CURRENT_FORMAT_VERSION) {
-    throw new Error(
-      `"${NEO_CONFIG_FILE}" field "formatVersion" must be ${CURRENT_FORMAT_VERSION}; received ${JSON.stringify(config.formatVersion)}. Native Neo project source is a clean break; preserve local edits and create a fresh working copy with \`neo init\`.`
-    );
-  }
-  const formatVersion = CURRENT_FORMAT_VERSION;
-  if (typeof config.apiBaseUrl !== "string") {
-    throw new Error(
-      `"${NEO_CONFIG_FILE}" is missing string field "apiBaseUrl".`
-    );
-  }
-  const profile = config.profile === "release" ? "release" : "editor";
-  const convexUrl = typeof config.convexUrl === "string" ? config.convexUrl : void 0;
-  const prePushHook = optionalHook(config, "prePushHook");
-  const prePushDryRunHook = optionalHook(config, "prePushDryRunHook");
-  const test = optionalTestConfig(config.test);
-  if (typeof config.unityConfigPath === "string") {
-    if (config.projectId !== void 0) {
-      throw new Error(
-        `"${NEO_CONFIG_FILE}" sets "unityConfigPath", so "projectId" must be removed \u2014 the Unity config asset is the single source of truth.`
-      );
-    }
-    if (config.versionId !== void 0) {
-      throw new Error(
-        `"${NEO_CONFIG_FILE}" sets "unityConfigPath", so "versionId" must be removed \u2014 the Unity config asset is the single source of truth.`
-      );
-    }
-    const ids = readUnityConfigIds(root, config.unityConfigPath);
-    return {
-      formatVersion,
-      apiBaseUrl: config.apiBaseUrl,
-      projectId: ids.projectId,
-      versionId: ids.versionId,
-      profile,
-      convexUrl,
-      unityConfigPath: config.unityConfigPath,
-      ...prePushHook === void 0 ? {} : { prePushHook },
-      ...prePushDryRunHook === void 0 ? {} : { prePushDryRunHook },
-      ...test === void 0 ? {} : { test }
-    };
-  }
-  if (typeof config.projectId !== "string") {
-    throw new Error(
-      `"${NEO_CONFIG_FILE}" is missing string field "projectId".`
-    );
-  }
-  if (typeof config.versionId !== "string") {
-    throw new Error(
-      `"${NEO_CONFIG_FILE}" is missing string field "versionId".`
-    );
-  }
-  return {
-    formatVersion,
-    apiBaseUrl: config.apiBaseUrl,
-    projectId: config.projectId,
-    versionId: config.versionId,
-    profile,
-    convexUrl,
-    ...prePushHook === void 0 ? {} : { prePushHook },
-    ...prePushDryRunHook === void 0 ? {} : { prePushDryRunHook },
-    ...test === void 0 ? {} : { test }
-  };
-}
-function optionalHook(config, field) {
-  const value = config[field];
-  if (value === void 0) return void 0;
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(
-      `"${NEO_CONFIG_FILE}" field "${field}" must be a non-empty CLI command.`
-    );
-  }
-  return value;
-}
-function optionalTestConfig(value) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(`"${NEO_CONFIG_FILE}" field "test" must be an object.`);
-  }
-  const config = value;
-  const allowed = /* @__PURE__ */ new Set([
-    "include",
-    "exclude",
-    "timeoutMs",
-    "maxWorkers",
-    "forbidOnly"
-  ]);
-  const unknown = Object.keys(config).find((key) => !allowed.has(key));
-  if (unknown !== void 0) {
-    throw new Error(
-      `"${NEO_CONFIG_FILE}" field "test.${unknown}" is not recognized.`
-    );
-  }
-  const stringArray2 = (field) => {
-    const entry = config[field];
-    if (entry === void 0) return void 0;
-    if (!Array.isArray(entry) || entry.some((item) => typeof item !== "string" || item.length === 0)) {
-      throw new Error(
-        `"${NEO_CONFIG_FILE}" field "test.${field}" must be an array of non-empty strings.`
-      );
-    }
-    return entry;
-  };
-  const positiveInteger = (field) => {
-    const entry = config[field];
-    if (entry === void 0) return void 0;
-    if (typeof entry !== "number" || !Number.isInteger(entry) || entry <= 0) {
-      throw new Error(
-        `"${NEO_CONFIG_FILE}" field "test.${field}" must be a positive integer.`
-      );
-    }
-    return entry;
-  };
-  const include = stringArray2("include");
-  const exclude = stringArray2("exclude");
-  const invalidInclude = include?.find(
-    (pattern) => !pattern.endsWith(".spec.neo")
-  );
-  if (invalidInclude !== void 0) {
-    throw new Error(
-      `"${NEO_CONFIG_FILE}" field "test.include" may select only .spec.neo files; received ${JSON.stringify(invalidInclude)}.`
-    );
-  }
-  const timeoutMs = positiveInteger("timeoutMs");
-  const maxWorkers = positiveInteger("maxWorkers");
-  const forbidOnly = config.forbidOnly;
-  if (forbidOnly !== void 0 && typeof forbidOnly !== "boolean") {
-    throw new Error(
-      `"${NEO_CONFIG_FILE}" field "test.forbidOnly" must be a boolean.`
-    );
-  }
-  return {
-    ...include === void 0 ? {} : { include },
-    ...exclude === void 0 ? {} : { exclude },
-    ...timeoutMs === void 0 ? {} : { timeoutMs },
-    ...maxWorkers === void 0 ? {} : { maxWorkers },
-    ...forbidOnly === void 0 ? {} : { forbidOnly }
-  };
-}
-function writeWorkspaceConfig(root, config) {
-  let persisted = { ...config };
-  if (config.unityConfigPath !== void 0) {
-    const { projectId, versionId, ...rest } = persisted;
-    void projectId;
-    void versionId;
-    persisted = rest;
-    writeUnityConfigVersionId(root, config.unityConfigPath, config.versionId);
-  }
-  writeFileSync2(
-    join2(root, NEO_CONFIG_FILE),
-    `${JSON.stringify(persisted, null, 2)}
-`,
-    "utf8"
-  );
-}
-function readUnityConfigIds(root, unityConfigPath) {
-  const assetPath = resolve(root, unityConfigPath);
-  if (!existsSync2(assetPath)) {
-    throw new Error(
-      `"unityConfigPath" in "${NEO_CONFIG_FILE}" points to "${assetPath}", which does not exist.`
-    );
-  }
-  const content = readFileSync2(assetPath, "utf8");
-  const projectId = matchUnityScalarField(content, "projectId");
-  if (projectId === null) {
-    throw new Error(
-      `Unity config asset "${assetPath}" has no "projectId" field.`
-    );
-  }
-  const versionId = matchUnityScalarField(content, "versionId");
-  if (versionId === null) {
-    throw new Error(
-      `Unity config asset "${assetPath}" has no "versionId" field.`
-    );
-  }
-  return { projectId, versionId };
-}
-function writeUnityConfigVersionId(root, unityConfigPath, versionId) {
-  const assetPath = resolve(root, unityConfigPath);
-  if (!existsSync2(assetPath)) {
-    throw new Error(
-      `"unityConfigPath" in "${NEO_CONFIG_FILE}" points to "${assetPath}", which does not exist.`
-    );
-  }
-  const content = readFileSync2(assetPath, "utf8");
-  const current = matchUnityScalarField(content, "versionId");
-  if (current === null) {
-    throw new Error(
-      `Unity config asset "${assetPath}" has no "versionId" field to update.`
-    );
-  }
-  if (current === versionId) return;
-  const updated = content.replace(
-    /^(\s*versionId:[ \t]*).*$/m,
-    `$1${versionId}`
-  );
-  writeFileSync2(assetPath, updated, "utf8");
-}
-function matchUnityScalarField(content, field) {
-  const match = new RegExp(`^\\s*${field}:[ \\t]*(\\S+)[ \\t]*$`, "m").exec(
-    content
-  );
-  return match === null ? null : match[1];
-}
-function readWorkspaceState(root, options = {}) {
-  const statePath = join2(root, NEO_STATE_DIR, NEO_STATE_FILE);
-  if (!existsSync2(statePath)) {
-    options.onSourceRead?.(null);
-    return { records: {} };
-  }
-  const source = readFileSync2(statePath, "utf8");
-  options.onSourceRead?.(source);
-  const parsed = JSON.parse(source);
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`"${statePath}" must contain a JSON object.`);
-  }
-  const state = parsed;
-  if (typeof state.records !== "object" || state.records === null) {
-    throw new Error(`"${statePath}" is missing the "records" object.`);
-  }
-  for (const [key, value] of Object.entries(state.records)) {
-    if (typeof value !== "object" || value === null) {
-      throw new Error(
-        `"${statePath}" record ${JSON.stringify(key)} must be an object.`
-      );
-    }
-    const recordKind = value.recordKind;
-    if (recordKind === "type" || recordKind === "attribute" || key.startsWith("type:") || key.startsWith("attribute:")) {
-      if (options.discardLegacyFormat2State === true) {
-        return { records: {} };
-      }
-      throw new Error(
-        `"${statePath}" contains legacy Class/Member state at ${JSON.stringify(key)}. Cached legacy state cannot be upgraded; preserve any local source you need, then run \`neo pull --reset\` to reconstruct this format-4 working copy from the authoritative server.`
-      );
-    }
-  }
-  return state;
-}
-function writeWorkspaceState(root, state) {
-  const stateDir = join2(root, NEO_STATE_DIR);
-  mkdirSync2(stateDir, { recursive: true });
-  writeFileSync2(
-    join2(stateDir, NEO_STATE_FILE),
-    `${JSON.stringify(state, null, 2)}
-`,
-    "utf8"
-  );
-}
-function loadWorkspace(startDir, options = {}) {
-  const root = findWorkspaceRoot(startDir);
-  if (root === null) {
-    throw new Error(
-      `No "${NEO_CONFIG_FILE}" found in "${startDir}" or any parent directory. Run "neo init" first.`
-    );
-  }
-  let stateSourceSha256;
-  const state = readWorkspaceState(root, {
-    discardLegacyFormat2State: options.discardLegacyFormat2State,
-    ...options.fingerprintStateSource === true ? {
-      onSourceRead: (source) => {
-        stateSourceSha256 = createHash2("sha256").update(source ?? "<missing>").digest("hex");
-      }
-    } : {}
-  });
-  return {
-    root,
-    config: readWorkspaceConfig(root),
-    state,
-    ...stateSourceSha256 === void 0 ? {} : { stateSourceSha256 }
-  };
-}
-var NEO_CONFIG_FILE, NEO_STATE_DIR, NEO_STATE_FILE, CURRENT_FORMAT_VERSION;
-var init_workspace = __esm({
-  "src/workspace.ts"() {
-    "use strict";
-    NEO_CONFIG_FILE = "neo.json";
-    NEO_STATE_DIR = ".neo";
-    NEO_STATE_FILE = "state.json";
-    CURRENT_FORMAT_VERSION = 4;
-  }
-});
-
 // src/project-sync/value-record-comparison.ts
 function valueRecordComparisonBody(value) {
   if (!isObjectRecord2(value)) return value;
@@ -83049,13 +83488,13 @@ var init_static_member_ownership_recovery = __esm({
 
 // ../src/models/animation/animation-clips.ts
 function isWorldAnimationStructuralMember(memberId, members) {
-  const membersById = new Map(members.map((member) => [member.id, member]));
+  const membersById2 = new Map(members.map((member) => [member.id, member]));
   const visited = /* @__PURE__ */ new Set();
   let currentId = memberId;
   while (currentId !== void 0 && !visited.has(currentId)) {
     if (WORLD_ANIMATION_STRUCTURAL_MEMBER_ROOT_IDS.has(currentId)) return true;
     visited.add(currentId);
-    currentId = membersById.get(currentId)?.extendsMemberId;
+    currentId = membersById2.get(currentId)?.extendsMemberId;
   }
   return false;
 }
@@ -83508,9 +83947,9 @@ var init_animation_clips = __esm({
         if (!isNSDelegateValue(selector)) {
           throw new Error(`${label} must carry a valid NeoDelegate selector.`);
         }
-        const directReferenceId = nsDelegateDirectReferenceValueId(selector);
-        if (directReferenceId === null) return null;
-        const childNode = this.valueById.get(directReferenceId);
+        const directReference = nsDelegateDirectReference(selector);
+        if (directReference === null) return null;
+        const childNode = this.valueById.get(directReference.valueId);
         if (childNode === void 0) {
           throw new Error(`${label} selector did not resolve a stored child row.`);
         }
@@ -83911,7 +84350,7 @@ var init_animation_clips = __esm({
         }
       }
       /**
-       * P42 §1.2/§1.3/§4.4. A `$partial` override row descends one level into a
+       * P42 §1.2/§1.3/§4.4. A `~partial` override row descends one level into a
        * structured leaf's declared fields. The leaf stays the storage unit, so
        * eligibility is evaluated on the enclosing member exactly as a whole-leaf
        * override would be — fields carry no storage of their own and never appear
@@ -84314,8 +84753,8 @@ var init_animation_clips = __esm({
   }
 });
 
-// src/evaluator-lookups.ts
-function cliEvaluatorLookups(document, options = {}) {
+// ../src/database/headless-virtual-instance-lookups.ts
+function headlessVirtualInstanceLookups(document, options = {}) {
   const members = document.members;
   const values = document.values;
   const indexed = makeEvaluatorLookups(
@@ -84346,7 +84785,8 @@ function cliEvaluatorLookups(document, options = {}) {
     // Stored-construction replay evaluates `ToVariant`, and production's
     // variant-constructed placements collapse through exactly this path.
     resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
-      document: { ...document, databaseVM: lookups },
+      document,
+      resolverLookups: lookups,
       ...args
     }),
     // A write to a virtual key must MATERIALIZE it (a pin row at the
@@ -84356,6 +84796,18 @@ function cliEvaluatorLookups(document, options = {}) {
   };
   return lookups;
 }
+var init_headless_virtual_instance_lookups = __esm({
+  "../src/database/headless-virtual-instance-lookups.ts"() {
+    "use strict";
+    init_virtual_instance_values();
+    init_neoscript_evaluator();
+  }
+});
+
+// src/evaluator-lookups.ts
+function cliEvaluatorLookups(document, options = {}) {
+  return headlessVirtualInstanceLookups(document, options);
+}
 function cliEvaluatorReceiverValue(lookups, valueId) {
   if (typeof valueId !== "string") return null;
   return lookups.valueById(valueId)?.value ?? null;
@@ -84363,8 +84815,7 @@ function cliEvaluatorReceiverValue(lookups, valueId) {
 var init_evaluator_lookups = __esm({
   "src/evaluator-lookups.ts"() {
     "use strict";
-    init_virtual_instance_values();
-    init_neoscript_evaluator();
+    init_headless_virtual_instance_lookups();
   }
 });
 
@@ -84433,6 +84884,14 @@ function storedConstructionEmitters(state, manifest) {
       valueId
     };
   };
+  const probedRootIds = /* @__PURE__ */ new Set();
+  const probeRootOnce = (rootValueId, ownedRoot) => {
+    if (probedRootIds.has(rootValueId)) {
+      return /* @__PURE__ */ new Set();
+    }
+    probedRootIds.add(rootValueId);
+    return probe.overrideKeys(ownedRoot);
+  };
   return {
     construction(valueId) {
       const ownedRoot = root(valueId);
@@ -84443,12 +84902,13 @@ function storedConstructionEmitters(state, manifest) {
       const recorded = probe.overrideKeysOf(valueId);
       if (recorded !== void 0) return recorded;
       const ownedRoot = root(valueId);
-      if (ownedRoot !== void 0) return probe.overrideKeys(ownedRoot);
+      if (ownedRoot !== void 0) return probeRootOnce(valueId, ownedRoot);
       const ancestor = nearestOwnedAncestor(valueId, parentByChildId(), owners);
       if (ancestor === null) return void 0;
       const ancestorRoot = root(ancestor);
       if (ancestorRoot === void 0) return void 0;
-      probe.overrideKeys(ancestorRoot);
+      if (probedRootIds.has(ancestor)) return void 0;
+      probeRootOnce(ancestor, ancestorRoot);
       return probe.overrideKeysOf(valueId);
     }
   };
@@ -86547,7 +87007,7 @@ function worldPlacementVariantBindings(args) {
   const foldersById = new Map(
     args.variantFolders.map((folder) => [folder.id, folder])
   );
-  const membersById = new Map(
+  const membersById2 = new Map(
     args.members.map((member) => [member.id, member])
   );
   const valuesById = new Map(args.values.map((value) => [value.id, value]));
@@ -86562,7 +87022,7 @@ function worldPlacementVariantBindings(args) {
     const folder = variant.folderId === null ? null : foldersById.get(variant.folderId) ?? null;
     const binding = folder?.binding ?? null;
     if (binding === null) return { id: variant.id, classId: variant.classId };
-    const collection = membersById.get(binding.collectionMemberId);
+    const collection = membersById2.get(binding.collectionMemberId);
     if (!isMemberListBase(collection)) {
       return {
         id: variant.id,
@@ -86610,7 +87070,7 @@ function lookupCollectionEntryIds(args) {
 function validateWorldContentSidecars(args) {
   const variants = args.variants ?? [];
   const valuesById = new Map(args.values.map((value) => [value.id, value]));
-  const classesById = new Map(
+  const classesById2 = new Map(
     args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   const containedIds = containedValueIdsByContainer(args.values);
@@ -86699,7 +87159,7 @@ function validateWorldContentSidecars(args) {
       assertConcreteWorldClass({
         classId: layerClassId,
         classes: args.classes,
-        classesById,
+        classesById: classesById2,
         expectedKind: expectedLayerKind,
         label: `Layer link value "${linkValue.id}" target`
       });
@@ -86723,7 +87183,7 @@ function validateWorldContentSidecars(args) {
         overrideOwnerByLayerKey.set(layerKey, linkValue.id);
       }
       validateOwnedSparseValue({
-        classesById,
+        classesById: classesById2,
         expectedClassId: layerClassId,
         ownerId: linkValue.id,
         referenceId: layerOverrideValueId,
@@ -86739,7 +87199,7 @@ function validateWorldContentSidecars(args) {
         }
         validateWorldPlacementSidecars({
           classes: args.classes,
-          classesById,
+          classesById: classesById2,
           importedClassIds: isTile ? importedTiles : importedObjects,
           isTile,
           layerClassId,
@@ -86772,12 +87232,12 @@ function validateWorldContentSidecars(args) {
     assertConcreteWorldClass({
       classId: layerClassId,
       classes: args.classes,
-      classesById,
+      classesById: classesById2,
       expectedKind: isTile ? NeoWorldSystemClassKind.TileLayer : NeoWorldSystemClassKind.ObjectLayer,
       label: `Object-composition layer link value "${linkValue.id}" target`
     });
     validateOwnedSparseValue({
-      classesById,
+      classesById: classesById2,
       expectedClassId: layerClassId,
       ownerId: linkValue.id,
       referenceId: optionalNonEmptyString(linkRecord.layerOverrideValueId),
@@ -86803,7 +87263,7 @@ function validateWorldContentSidecars(args) {
       }
       validateWorldPlacementSidecars({
         classes: args.classes,
-        classesById,
+        classesById: classesById2,
         importedClassIds: null,
         isTile,
         layerClassId,
@@ -87017,7 +87477,7 @@ function consumeWorldPlacementSidecarKeys(args) {
   if (worldKind === null) return /* @__PURE__ */ new Set();
   const assetKind = WORLD_PLACEMENT_ASSET_KIND.get(worldKind);
   if (assetKind === void 0) return /* @__PURE__ */ new Set();
-  const classesById = new Map(
+  const classesById2 = new Map(
     args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   const present = /* @__PURE__ */ new Set();
@@ -87035,7 +87495,7 @@ function consumeWorldPlacementSidecarKeys(args) {
     assertConcreteWorldClass({
       classId: assetClassId,
       classes: args.classes,
-      classesById,
+      classesById: classesById2,
       expectedKind: assetKind,
       label: `${args.label} assetClassId`
     });
@@ -87138,12 +87598,12 @@ function readVariantFolderRecord(value) {
   }
   return { id: value.id, classId: value.classId, path: value.path, binding };
 }
-function resolveVariantWorldKind(classId, classesById) {
+function resolveVariantWorldKind(classId, classesById2) {
   const visited = /* @__PURE__ */ new Set();
   let currentId = classId;
   while (currentId !== null && !visited.has(currentId)) {
     visited.add(currentId);
-    const schemaClass2 = classesById.get(currentId);
+    const schemaClass2 = classesById2.get(currentId);
     if (schemaClass2 === void 0) return null;
     const worldKind = schemaClass2.system?.worldKind;
     if (typeof worldKind === "string") return worldKind;
@@ -87151,15 +87611,15 @@ function resolveVariantWorldKind(classId, classesById) {
   }
   return null;
 }
-function isVariantFamilyClassId(classId, classesById) {
-  const worldKind = resolveVariantWorldKind(classId, classesById);
+function isVariantFamilyClassId(classId, classesById2) {
+  const worldKind = resolveVariantWorldKind(classId, classesById2);
   if (worldKind === VARIANT_WORLD_KIND) return true;
   if (worldKind === VARIANT_FOLDER_WORLD_KIND) return true;
   if (worldKind === LOOKUP_VARIANT_WORLD_KIND) return true;
   return worldKind === LOOKUP_VARIANT_FOLDER_WORLD_KIND;
 }
-function variantFamilyLabel(classId, classesById) {
-  const schemaClass2 = classesById.get(classId);
+function variantFamilyLabel(classId, classesById2) {
+  const schemaClass2 = classesById2.get(classId);
   const name = schemaClass2?.name ?? "NeoVariant";
   return `"${name}" (${classId})`;
 }
@@ -87492,12 +87952,12 @@ function assertNoPersistedReadOnlySyntheticLookupId2(value, label) {
 function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function abstractReadOnlyContractAncestor(member, membersById) {
+function abstractReadOnlyContractAncestor(member, membersById2) {
   const visited = /* @__PURE__ */ new Set([member.id]);
   let ancestorId = member.extendsMemberId;
   while (ancestorId !== void 0 && !visited.has(ancestorId)) {
     visited.add(ancestorId);
-    const ancestor = membersById.get(ancestorId);
+    const ancestor = membersById2.get(ancestorId);
     if (ancestor === void 0) return null;
     if (ancestor.isAbstract === true && ancestor.isReadOnly === true) {
       return ancestor;
@@ -87837,13 +88297,13 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
   const members = view.members.map(readMember);
   const classes = view.classes.map(readClass);
   const interfaces = view.interfaces.map(readInterface);
-  const membersById = new Map(members.map((member) => [member.id, member]));
-  const classesById = new Map(
+  const membersById2 = new Map(members.map((member) => [member.id, member]));
+  const classesById2 = new Map(
     classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   for (const schemaClass2 of classes) {
     if (schemaClass2.extendsClassId === void 0) continue;
-    const baseClass = classesById.get(schemaClass2.extendsClassId);
+    const baseClass = classesById2.get(schemaClass2.extendsClassId);
     if (baseClass?.isSealed !== true) continue;
     throw new Error(
       `Class "${schemaClass2.name}" (${schemaClass2.id}) cannot extend sealed class "${baseClass.name}" (${baseClass.id}).`
@@ -87865,31 +88325,31 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
   if (view.constructors !== void 0) {
     assertOpaqueConstructorsValid(
       view.constructors.map(readConstructor),
-      classesById
+      classesById2
     );
   }
   assertNoVariantTypePositions({
     members,
-    classesById,
+    classesById: classesById2,
     constructors: view.constructors?.map(readConstructor),
     interfaces
   });
-  assertNoAuthoredVariantMembers({ membersById, classesById });
+  assertNoAuthoredVariantMembers({ membersById: membersById2, classesById: classesById2 });
   if (view.variants !== void 0 || view.variantFolders !== void 0) {
     assertOpaqueVariantsValid({
       variants: (view.variants ?? []).map(readVariantRecord),
       folders: (view.variantFolders ?? []).map(readVariantFolderRecord),
-      classesById,
+      classesById: classesById2,
       objectWorldKind: NEO_OBJECT_WORLD_KIND,
-      membersById,
+      membersById: membersById2,
       values: view.values
     });
   }
   for (const member of members) {
     assertOpaqueMemberDefaultValueValid(member);
     assertOpaqueParameterDefaultsValid(member);
-    assertOpaqueCallableOverrideValid(member, membersById);
-    assertOpaqueNSFunctionValid(member, membersById);
+    assertOpaqueCallableOverrideValid(member, membersById2);
+    assertOpaqueNSFunctionValid(member, membersById2);
     if (member.isAbstract === true && member.defaultValue != null) {
       throw new Error(
         `Abstract member "${member.name}" (${member.id}) cannot declare a default value. Concrete implementations own their values and defaults.`
@@ -87916,7 +88376,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
   }
   for (const member of members) {
     if (member.entryMemberId === void 0) continue;
-    const entry = membersById.get(member.entryMemberId);
+    const entry = membersById2.get(member.entryMemberId);
     if (entry?.kind === 23) {
       throw new Error(
         `NSFunction "${entry.id}" cannot be a List or Dictionary entry member.`
@@ -87934,7 +88394,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
             `Member "${memberId}" is placed under conflicting keys "${existing.key}" and "${key}".`
           );
         }
-        const member = membersById.get(memberId);
+        const member = membersById2.get(memberId);
         if (member && member.name !== key) {
           throw new Error(
             `Member "${memberId}" name "${member.name}" must match schema key "${key}" on class "${schemaClass2.id}".`
@@ -87978,7 +88438,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
         `Static member "${member.name}" (${member.id}) stores live content through valueId and cannot retain a schema defaultValue seed.`
       );
     }
-    const owner = classesById.get(placements[0].classId);
+    const owner = classesById2.get(placements[0].classId);
     if ((owner?.genericParams?.length ?? 0) > 0) {
       throw new Error(
         `Static member "${member.name}" (${member.id}) cannot be declared on open generic class "${owner?.name}" (${owner?.id}).`
@@ -87997,7 +88457,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
   }
   for (const owner of members) {
     if (owner.entryMemberId !== void 0) {
-      const entry = membersById.get(owner.entryMemberId);
+      const entry = membersById2.get(owner.entryMemberId);
       if (entry?.isStatic === true) {
         throw new Error(
           `Static member "${entry.name}" (${entry.id}) cannot be a List or Dictionary entry template.`
@@ -88006,7 +88466,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     }
     for (const binding of Object.values(owner.classArguments ?? {})) {
       if (binding.kind !== "member") continue;
-      const argument2 = membersById.get(binding.memberId);
+      const argument2 = membersById2.get(binding.memberId);
       if (argument2?.isStatic !== true) continue;
       throw new Error(
         `Static member "${argument2.name}" (${argument2.id}) cannot be a constructed-type binding artifact.`
@@ -88018,7 +88478,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       schemaClass2.extendsGenericBindings ?? {}
     )) {
       if (binding.kind !== "member") continue;
-      const argument2 = membersById.get(binding.memberId);
+      const argument2 = membersById2.get(binding.memberId);
       if (argument2?.isStatic !== true) continue;
       throw new Error(
         `Static member "${argument2.name}" (${argument2.id}) cannot be a generic binding artifact.`
@@ -88060,7 +88520,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
           result.push(neoInterface);
         }
       }
-      current = current.extendsClassId ? classesById.get(current.extendsClassId) : void 0;
+      current = current.extendsClassId ? classesById2.get(current.extendsClassId) : void 0;
     }
     return result;
   };
@@ -88080,11 +88540,11 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
         return invariantTypeInfo({ ...from, required: to.required }, to);
       }
       const seen = /* @__PURE__ */ new Set();
-      let current = classesById.get(from.classId);
+      let current = classesById2.get(from.classId);
       while (current && !seen.has(current.id)) {
         if (current.id === to.classId) return true;
         seen.add(current.id);
-        current = current.extendsClassId ? classesById.get(current.extendsClassId) : void 0;
+        current = current.extendsClassId ? classesById2.get(current.extendsClassId) : void 0;
       }
       return false;
     }
@@ -88092,7 +88552,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       if (typeof from.classId !== "string" || typeof to.interfaceId !== "string") {
         return false;
       }
-      const schemaClass2 = classesById.get(from.classId);
+      const schemaClass2 = classesById2.get(from.classId);
       return schemaClass2 ? implementedClosure(schemaClass2).some(
         (neoInterface) => neoInterface.id === to.interfaceId
       ) : false;
@@ -88194,7 +88654,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     while (current && !seen.has(current.id)) {
       seen.add(current.id);
       chain.push(current);
-      current = current.extendsClassId ? classesById.get(current.extendsClassId) : void 0;
+      current = current.extendsClassId ? classesById2.get(current.extendsClassId) : void 0;
     }
     return Object.assign({}, ...chain.reverse().map((entry) => entry.schema));
   };
@@ -88203,31 +88663,31 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       schemaClass2.schema
     )) {
       const seen = /* @__PURE__ */ new Set();
-      let ancestor = schemaClass2.extendsClassId ? classesById.get(schemaClass2.extendsClassId) : void 0;
+      let ancestor = schemaClass2.extendsClassId ? classesById2.get(schemaClass2.extendsClassId) : void 0;
       while (ancestor && !seen.has(ancestor.id)) {
         seen.add(ancestor.id);
         const inheritedMemberId2 = ancestor.schema[schemaKey];
         if (inheritedMemberId2 !== void 0) {
-          if (membersById.get(localMemberId)?.isStatic === true || membersById.get(inheritedMemberId2)?.isStatic === true) {
+          if (membersById2.get(localMemberId)?.isStatic === true || membersById2.get(inheritedMemberId2)?.isStatic === true) {
             throw new Error(
               `Class "${schemaClass2.name}" cannot redeclare inherited member "${schemaKey}" because static and instance members cannot hide one another.`
             );
           }
           break;
         }
-        ancestor = ancestor.extendsClassId ? classesById.get(ancestor.extendsClassId) : void 0;
+        ancestor = ancestor.extendsClassId ? classesById2.get(ancestor.extendsClassId) : void 0;
       }
     }
   }
   for (const list of members) {
     if (list.kind !== 6 || !Array.isArray(list.indexes)) continue;
-    const entry = typeof list.entryMemberId === "string" ? membersById.get(list.entryMemberId) : void 0;
-    const entryType = entry?.kind === 7 && typeof entry.classId === "string" ? classesById.get(entry.classId) : void 0;
+    const entry = typeof list.entryMemberId === "string" ? membersById2.get(list.entryMemberId) : void 0;
+    const entryType = entry?.kind === 7 && typeof entry.classId === "string" ? classesById2.get(entry.classId) : void 0;
     if (entryType === void 0) continue;
     const schema = mergedSchema(entryType);
     for (const index of list.indexes) {
       const indexedMemberId = schema[index.schemaKey];
-      if (indexedMemberId === void 0 || membersById.get(indexedMemberId)?.isStatic !== true) {
+      if (indexedMemberId === void 0 || membersById2.get(indexedMemberId)?.isStatic !== true) {
         continue;
       }
       throw new Error(
@@ -88248,7 +88708,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       seen.add(current.id);
       chain.push(current);
       if (!current.extendsMemberId) break;
-      current = membersById.get(current.extendsMemberId);
+      current = membersById2.get(current.extendsMemberId);
       if (!current) {
         const leaf = chain[chain.length - 1];
         if (leaf === void 0) {
@@ -88299,7 +88759,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       );
     }
     const ownerContext = placements.map((placement) => {
-      const owner = classesById.get(placement.classId);
+      const owner = classesById2.get(placement.classId);
       return owner === void 0 ? `missing class "${placement.classId}"` : `"${owner.name}" (${owner.id})`;
     }).join(", ");
     const ownerLabel = placements.length === 1 ? `owning class ${ownerContext}` : `owning classes ${ownerContext}`;
@@ -88370,7 +88830,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
               `Read-only member "${member.name}" has an owned Generic member "${inherited.name}" whose parameter "${owned.genericParamId}" is not closed by its default placement; ${ownerLabel}.`
             );
           }
-          const binding = membersById.get(bindingId);
+          const binding = membersById2.get(bindingId);
           if (binding === void 0) {
             throw new Error(
               `Read-only member "${member.name}" has an owned Generic member "${inherited.name}" bound to missing member "${bindingId}"; ${ownerLabel}.`
@@ -88418,7 +88878,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
             `Read-only member "${member.name}" has an owned collection "${owned.name}" without an entry member; ${ownerLabel}.`
           );
         }
-        const entry = membersById.get(owned.entryMemberId);
+        const entry = membersById2.get(owned.entryMemberId);
         if (entry === void 0) {
           throw new Error(
             `Read-only member "${member.name}" has an owned collection entry "${owned.entryMemberId}" that does not exist; ${ownerLabel}.`
@@ -88430,7 +88890,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       if (owned.kind !== 7 || typeof owned.classId !== "string") return;
       const defaultValue = isRecord7(owned.defaultValue) ? owned.defaultValue : null;
       const effectiveClassId = typeof defaultValue?.classId === "string" ? defaultValue.classId : owned.classId;
-      const ownedClass = classesById.get(effectiveClassId);
+      const ownedClass = classesById2.get(effectiveClassId);
       if (ownedClass === void 0) {
         throw new Error(
           `Read-only member "${member.name}" has an owned Class member "${owned.name}" targeting missing class "${effectiveClassId}"; ${ownerLabel}.`
@@ -88463,7 +88923,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
         );
       }
       for (const nestedMemberId of Object.values(mergedSchema(ownedClass))) {
-        const nested = membersById.get(nestedMemberId);
+        const nested = membersById2.get(nestedMemberId);
         if (nested === void 0) {
           throw new Error(
             `Read-only member "${member.name}" has an owned class schema member "${nestedMemberId}" that does not exist; ${ownerLabel}.`
@@ -88473,7 +88933,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       }
     };
     for (const placement of placements) {
-      const placementClass = classesById.get(placement.classId);
+      const placementClass = classesById2.get(placement.classId);
       if (placementClass === void 0) {
         throw new Error(
           `Read-only member "${member.name}" has a placement in missing class "${placement.classId}".`
@@ -88488,7 +88948,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
   }
   for (const member of members) {
     if (member.extendsMemberId === void 0) continue;
-    const contract = abstractReadOnlyContractAncestor(member, membersById);
+    const contract = abstractReadOnlyContractAncestor(member, membersById2);
     if (contract === null || member.isReadOnly === true) continue;
     throw new Error(
       `Member "${member.name}" (${member.id}) must remain read-only because it implements abstract read-only member "${contract.name}" (${contract.id}).`
@@ -88504,7 +88964,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       for (const [schemaKey, memberId] of Object.entries(current.schema)) {
         if (effectiveKeys.has(schemaKey)) continue;
         effectiveKeys.add(schemaKey);
-        const effectiveMember = membersById.get(memberId);
+        const effectiveMember = membersById2.get(memberId);
         if (effectiveMember?.isAbstract !== true || effectiveMember.isReadOnly !== true) {
           continue;
         }
@@ -88512,7 +88972,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
           `Concrete class "${schemaClass2.name}" (${schemaClass2.id}) must implement abstract read-only member "${schemaKey}" with a read-only override.`
         );
       }
-      current = current.extendsClassId === void 0 ? void 0 : classesById.get(current.extendsClassId);
+      current = current.extendsClassId === void 0 ? void 0 : classesById2.get(current.extendsClassId);
     }
   }
   const values = (view.values ?? []).filter(isRecord7);
@@ -88534,7 +88994,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     const inspectChild = (memberId, valueId) => {
       if (typeof valueId !== "string" || visitedValueIds.has(valueId)) return;
       const childValue = valuesById.get(valueId);
-      const childMember = membersById.get(memberId);
+      const childMember = membersById2.get(memberId);
       if (childValue === void 0 || childMember === void 0) return;
       visitedValueIds.add(valueId);
       inspectValueBody(
@@ -88569,12 +89029,12 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     if (inspectedMember.kind !== 7 || !isRecord7(body)) return;
     const effectiveClassId = classId ?? inspectedMember.classId;
     if (typeof effectiveClassId !== "string") return;
-    const schemaClass2 = classesById.get(effectiveClassId);
+    const schemaClass2 = classesById2.get(effectiveClassId);
     if (schemaClass2 === void 0) return;
     for (const [schemaKey, childMemberId] of Object.entries(
       mergedSchema(schemaClass2)
     )) {
-      if (options.validateReadOnlyValueShapes !== false && membersById.get(childMemberId)?.isReadOnly === true) {
+      if (options.validateReadOnlyValueShapes !== false && membersById2.get(childMemberId)?.isReadOnly === true) {
         if (body[schemaKey] !== void 0) {
           throw new Error(
             `Class value for "${effectiveClassId}" contains read-only declaration member "${schemaKey}"; a read-only declaration member cannot have an instance value.`
@@ -88607,7 +89067,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     }
   }
   for (const placed of view.placedValues ?? []) {
-    const member = membersById.get(placed.memberId);
+    const member = membersById2.get(placed.memberId);
     if (member === void 0) {
       throw new Error(
         `Placed value "${placed.valueId}" references missing member "${placed.memberId}".`
@@ -88636,7 +89096,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     while (current && !seen.has(current.id)) {
       seen.add(current.id);
       chain.push(current);
-      current = current.extendsClassId ? classesById.get(current.extendsClassId) : void 0;
+      current = current.extendsClassId ? classesById2.get(current.extendsClassId) : void 0;
     }
     const env = /* @__PURE__ */ new Map();
     for (let declarerIndex = 0; declarerIndex < chain.length; declarerIndex += 1) {
@@ -88663,7 +89123,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     const env = genericEnvForClass(schemaClass2);
     if (resolved.kind === 21 && typeof resolved.genericParamId === "string") {
       const bindingId = env.get(resolved.genericParamId);
-      const binding = bindingId ? membersById.get(bindingId) : void 0;
+      const binding = bindingId ? membersById2.get(bindingId) : void 0;
       if (!binding) return resolved;
       const substituted = {
         ...resolveMember3(binding),
@@ -88703,7 +89163,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
         resolved.classArguments ?? {}
       )) {
         if (binding.kind !== "member") return null;
-        const bindingMember = membersById.get(binding.memberId);
+        const bindingMember = membersById2.get(binding.memberId);
         if (!bindingMember) return null;
         const bindingTypeInfo = memberTypeInfo(
           bindingMember,
@@ -88725,7 +89185,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     }
     if (resolved.kind === 5 || resolved.kind === 6) {
       if (typeof resolved.entryMemberId !== "string") return null;
-      const entry = membersById.get(resolved.entryMemberId);
+      const entry = membersById2.get(resolved.entryMemberId);
       if (!entry) return null;
       const entryTypeInfo = memberTypeInfo(entry, schemaClass2, nextVisiting);
       if (!entryTypeInfo) return null;
@@ -88738,7 +89198,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     }
     if (resolved.kind === 9) {
       if (typeof resolved.collectionMemberId !== "string") return null;
-      const collection = membersById.get(resolved.collectionMemberId);
+      const collection = membersById2.get(resolved.collectionMemberId);
       if (!collection) return null;
       const collectionTypeInfo = memberTypeInfo(
         collection,
@@ -88826,7 +89286,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       const bindingId = genericEnvForClass(schemaClass2).get(
         typeInfo.genericParamId
       );
-      const binding = bindingId ? membersById.get(bindingId) : void 0;
+      const binding = bindingId ? membersById2.get(bindingId) : void 0;
       return binding ? memberTypeInfo(binding, schemaClass2) ?? typeInfo : typeInfo;
     }
     if ((typeInfo.type === 5 || typeInfo.type === 6 || typeInfo.type === 9) && typeInfo.entryTypeInfo !== void 0) {
@@ -88857,7 +89317,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     while (current && !seen.has(current.id)) {
       seen.add(current.id);
       if (current.allowedStorage != null) return current.allowedStorage;
-      current = current.extendsClassId ? classesById.get(current.extendsClassId) : void 0;
+      current = current.extendsClassId ? classesById2.get(current.extendsClassId) : void 0;
     }
     return null;
   };
@@ -88922,7 +89382,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
         );
       }
       if (!canonical || memberId === void 0) continue;
-      const member = membersById.get(memberId);
+      const member = membersById2.get(memberId);
       if (!member) continue;
       if (member.isStatic) {
         throw new Error(
@@ -88956,7 +89416,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     }
   }
 }
-function assertOpaqueCallableOverrideValid(member, membersById) {
+function assertOpaqueCallableOverrideValid(member, membersById2) {
   const parentId = member.extendsMemberId;
   if (typeof parentId !== "string") return;
   const childIsCallable = member.kind === 13 || member.kind === 23;
@@ -88987,7 +89447,7 @@ function assertOpaqueCallableOverrideValid(member, membersById) {
       );
     }
   }
-  const parent = membersById.get(parentId);
+  const parent = membersById2.get(parentId);
   if (parent === void 0) {
     if (childIsCallable) {
       throw new Error(
@@ -89003,7 +89463,7 @@ function assertOpaqueCallableOverrideValid(member, membersById) {
     );
   }
 }
-function resolveOpaqueNSFunctionSignature(member, membersById) {
+function resolveOpaqueNSFunctionSignature(member, membersById2) {
   const seen = /* @__PURE__ */ new Set();
   let cursor = member;
   while (cursor !== void 0) {
@@ -89023,7 +89483,7 @@ function resolveOpaqueNSFunctionSignature(member, membersById) {
     }
     const parentId = cursor.extendsMemberId;
     if (typeof parentId !== "string") return null;
-    cursor = membersById.get(parentId);
+    cursor = membersById2.get(parentId);
   }
   return null;
 }
@@ -89360,7 +89820,7 @@ function assertOpaqueRequiredConstructorValid(schemaClass2, constructorsById) {
     );
   }
 }
-function assertOpaqueConstructorsValid(constructors, classesById) {
+function assertOpaqueConstructorsValid(constructors, classesById2) {
   const constructorsByClassId = /* @__PURE__ */ new Map();
   const constructorsById = /* @__PURE__ */ new Map();
   for (const declaredConstructor of constructors) {
@@ -89372,7 +89832,7 @@ function assertOpaqueConstructorsValid(constructors, classesById) {
     constructorsById.set(declaredConstructor.id, declaredConstructor);
     const argumentTypes = assertOpaqueConstructorValid(declaredConstructor);
     void argumentTypes;
-    const owner = classesById.get(declaredConstructor.classId);
+    const owner = classesById2.get(declaredConstructor.classId);
     if (owner === void 0) {
       throw new Error(
         `Constructor "${declaredConstructor.id}" references missing class "${declaredConstructor.classId}".`
@@ -89395,7 +89855,7 @@ function assertOpaqueConstructorsValid(constructors, classesById) {
     siblings.push(declaredConstructor);
     constructorsByClassId.set(declaredConstructor.classId, siblings);
   }
-  for (const schemaClass2 of classesById.values()) {
+  for (const schemaClass2 of classesById2.values()) {
     assertOpaqueRequiredConstructorValid(schemaClass2, constructorsById);
     const declared = schemaClass2.constructorIds;
     if (declared === void 0 || declared === null) continue;
@@ -89508,7 +89968,7 @@ function assertOpaqueMemberDefaultValueValid(member) {
     );
   }
 }
-function assertOpaqueNSFunctionValid(member, membersById) {
+function assertOpaqueNSFunctionValid(member, membersById2) {
   if (member.kind !== 23) return;
   if (!isOpaqueCallableMemberIdentifier(member.name)) {
     throw new Error(`NSFunction "${member.id}" name is invalid.`);
@@ -89581,7 +90041,7 @@ function assertOpaqueNSFunctionValid(member, membersById) {
       );
     }
     if (member.action !== void 0) {
-      const signature = resolveOpaqueNSFunctionSignature(member, membersById);
+      const signature = resolveOpaqueNSFunctionSignature(member, membersById2);
       if (signature === null) {
         throw new Error(
           `NSFunction override "${member.id}" has no valid inherited signature.`
@@ -89879,8 +90339,8 @@ var init_project_document_value_overlay = __esm({
 // ../src/database/member-access-modifier-validation.ts
 function validateDocumentAccessModifiers(ctx) {
   const errors = [];
-  const membersById = new Map(ctx.members.map((member) => [member.id, member]));
-  const classesById = new Map(
+  const membersById2 = new Map(ctx.members.map((member) => [member.id, member]));
+  const classesById2 = new Map(
     ctx.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   const placementsByMemberId = indexSchemaPlacements(ctx.classes);
@@ -89918,13 +90378,13 @@ function validateDocumentAccessModifiers(ctx) {
     }
     const parentId = member.extendsMemberId;
     if (parentId !== void 0) {
-      const root = resolveChainRoot(member, membersById);
+      const root = resolveChainRoot(member, membersById2);
       if (root !== null && isMemberAccessModifierKind(root.accessModifierKind) && member.accessModifierKind !== root.accessModifierKind) {
         errors.push({
           message: `Override member "${member.name}" (${member.id}) is ${member.accessModifierKind} but its root declaration "${root.name}" (${root.id}) is ${root.accessModifierKind}. Access modifiers change only on the root declaration and cascade to every override.`
         });
       }
-      const parent = membersById.get(parentId);
+      const parent = membersById2.get(parentId);
       if (parent !== void 0 && parent.accessModifierKind === "private") {
         errors.push({
           message: `Member "${member.name}" (${member.id}) cannot override private member "${parent.name}" (${parent.id}).`
@@ -89934,8 +90394,8 @@ function validateDocumentAccessModifiers(ctx) {
     if (isMemberLookupBase(member)) {
       validateLookupTargetAccess({
         lookup: member,
-        membersById,
-        classesById,
+        membersById: membersById2,
+        classesById: classesById2,
         placementsByMemberId,
         errors
       });
@@ -89947,12 +90407,12 @@ function validateDocumentAccessModifiers(ctx) {
       const ancestor = nearestAncestorDeclaration(
         schemaClass2,
         schemaKey,
-        classesById
+        classesById2
       );
       if (ancestor === null) continue;
       const ancestorMemberId = ancestor.schema[schemaKey];
       if (typeof ancestorMemberId !== "string") continue;
-      const ancestorMember = membersById.get(ancestorMemberId);
+      const ancestorMember = membersById2.get(ancestorMemberId);
       if (ancestorMember === void 0) continue;
       if (!isMemberAccessModifierKind(ancestorMember.accessModifierKind)) {
         continue;
@@ -89962,7 +90422,7 @@ function validateDocumentAccessModifiers(ctx) {
           message: `Class "${schemaClass2.name}" (${schemaClass2.id}) cannot redeclare inherited schema key "${schemaKey}" because member "${ancestorMember.name}" (${ancestorMember.id}) on class "${ancestor.name}" (${ancestor.id}) is private.`
         });
       }
-      const localMember = membersById.get(memberId);
+      const localMember = membersById2.get(memberId);
       if (localMember === void 0) continue;
       if (localMember.extendsMemberId !== void 0) continue;
       if (!isMemberAccessModifierKind(localMember.accessModifierKind)) continue;
@@ -89976,7 +90436,7 @@ function validateDocumentAccessModifiers(ctx) {
   for (const schemaClass2 of ctx.classes) {
     validateClassTargetMemberAccess({
       schemaClass: schemaClass2,
-      membersById,
+      membersById: membersById2,
       errors
     });
   }
@@ -89984,7 +90444,7 @@ function validateDocumentAccessModifiers(ctx) {
     validateDialogueRecordMemberReferences({
       record: dialogue,
       recordLabel: describeDialogueRecord(dialogue, "Dialogue"),
-      membersById,
+      membersById: membersById2,
       errors
     });
   }
@@ -89992,7 +90452,7 @@ function validateDocumentAccessModifiers(ctx) {
     validateDialogueRecordMemberReferences({
       record: dialogueGroup,
       recordLabel: describeDialogueRecord(dialogueGroup, "Dialogue group"),
-      membersById,
+      membersById: membersById2,
       errors
     });
   }
@@ -90078,24 +90538,24 @@ function validateLookupTargetAccess(args) {
     });
   }
 }
-function isClassOrDescendant(classId, ancestorClassId, classesById) {
+function isClassOrDescendant(classId, ancestorClassId, classesById2) {
   const seen = /* @__PURE__ */ new Set();
   let cursor = classId;
   while (cursor !== void 0 && !seen.has(cursor)) {
     if (cursor === ancestorClassId) return true;
     seen.add(cursor);
-    cursor = classesById.get(cursor)?.extendsClassId;
+    cursor = classesById2.get(cursor)?.extendsClassId;
   }
   return false;
 }
-function resolveChainRoot(member, membersById) {
+function resolveChainRoot(member, membersById2) {
   const seen = /* @__PURE__ */ new Set();
   let cursor = member;
   while (cursor !== void 0) {
     if (seen.has(cursor.id)) return null;
     seen.add(cursor.id);
     if (cursor.extendsMemberId === void 0) return cursor;
-    cursor = membersById.get(cursor.extendsMemberId);
+    cursor = membersById2.get(cursor.extendsMemberId);
   }
   return null;
 }
@@ -90156,13 +90616,13 @@ function indexNonSchemaPlacements(ctx) {
   }
   return placements;
 }
-function nearestAncestorDeclaration(schemaClass2, schemaKey, classesById) {
+function nearestAncestorDeclaration(schemaClass2, schemaKey, classesById2) {
   const visited = /* @__PURE__ */ new Set([schemaClass2.id]);
   let ancestorId = schemaClass2.extendsClassId;
   while (ancestorId !== void 0) {
     if (visited.has(ancestorId)) return null;
     visited.add(ancestorId);
-    const ancestor = classesById.get(ancestorId);
+    const ancestor = classesById2.get(ancestorId);
     if (ancestor === void 0) return null;
     if (typeof ancestor.schema[schemaKey] === "string") return ancestor;
     ancestorId = ancestor.extendsClassId;
@@ -91389,7 +91849,7 @@ var init_project_version_transaction_types = __esm({
 
 // ../src/database/project-version-relation-sweep-trigger.ts
 function stagedChangesAffectClassRelations(current, changes) {
-  const classesById = new Map(
+  const classesById2 = new Map(
     (current.classes ?? []).map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   const valuesById = new Map(
@@ -91400,7 +91860,7 @@ function stagedChangesAffectClassRelations(current, changes) {
     if (change.recordKind === "class") {
       if (change.operation !== "update") return true;
       if (change.deleted === true) return true;
-      const before2 = classesById.get(change.recordId);
+      const before2 = classesById2.get(change.recordId);
       if (before2 === void 0) return true;
       const after = change.nextData;
       if (!isPlainRecord(after)) return true;
@@ -92581,7 +93041,7 @@ function materializeLocalizableStringWriteChanges(args) {
     owners
   });
   if (unresolvedRootIds.length > 0) {
-    const membersById = new Map(
+    const membersById2 = new Map(
       args.postDocument.members.map((member) => [member.id, member])
     );
     const additionalRoots = [];
@@ -92591,7 +93051,7 @@ function materializeLocalizableStringWriteChanges(args) {
       );
       const memberId = changeMemberId(change);
       if (memberId === null) continue;
-      const member = membersById.get(memberId);
+      const member = membersById2.get(memberId);
       if (member === void 0) continue;
       additionalRoots.push({ member, valueId: rootId });
     }
@@ -93858,7 +94318,7 @@ function remapReadOnlyConversionValueIds(values, memberId, ownerValueId) {
   }
 }
 function collectReadOnlyClassValueSites(document, selectedMemberId) {
-  const membersById = new Map(
+  const membersById2 = new Map(
     document.members.map((member) => [member.id, member])
   );
   const valuesById = new Map(document.values.map((value) => [value.id, value]));
@@ -93873,7 +94333,7 @@ function collectReadOnlyClassValueSites(document, selectedMemberId) {
     if (value === void 0) return;
     const member = resolveMember2(rawMember, document.members);
     if (isMemberListBase(member) || isMemberDictionaryBase(member)) {
-      const entry = membersById.get(member.entryMemberId);
+      const entry = membersById2.get(member.entryMemberId);
       if (entry === void 0) return;
       const childIds = isMemberListBase(member) && listKindOf(member) === "unordered" ? document.values.filter((child) => child.containerId === value.id).map((child) => child.id) : Array.isArray(value.value) ? value.value : isStringValueRecord(value.value) ? Object.values(value.value) : [];
       for (const childId of childIds) visit(entry, childId);
@@ -93906,7 +94366,7 @@ function collectReadOnlyClassValueSites(document, selectedMemberId) {
         }
       }
       const childId = value.value[entry.schemaKey];
-      const childMember = membersById.get(entry.memberId);
+      const childMember = membersById2.get(entry.memberId);
       if (childMember === void 0 || typeof childId !== "string") continue;
       visit(
         substituteMember(childMember, env, document.members),
@@ -93934,7 +94394,7 @@ function collectReadOnlyClassValueSites(document, selectedMemberId) {
   return sites.filter((site) => !site.value.id.startsWith("__default:"));
 }
 function collectValuesReachableWithoutReadOnlyBinding(document, excludedMemberId) {
-  const membersById = new Map(
+  const membersById2 = new Map(
     document.members.map((member) => [member.id, member])
   );
   const valuesById = new Map(document.values.map((value) => [value.id, value]));
@@ -93950,7 +94410,7 @@ function collectValuesReachableWithoutReadOnlyBinding(document, excludedMemberId
       visitBody(childMember, child.value, child.classId ?? void 0, child.id);
     };
     if (isMemberListBase(member)) {
-      const entry = membersById.get(member.entryMemberId);
+      const entry = membersById2.get(member.entryMemberId);
       if (listKindOf(member) === "unordered" && ownerValueId !== void 0) {
         for (const child of document.values) {
           if (child.containerId === ownerValueId) visitChild(entry, child.id);
@@ -93961,7 +94421,7 @@ function collectValuesReachableWithoutReadOnlyBinding(document, excludedMemberId
       return;
     }
     if (isMemberDictionaryBase(member) && isStringValueRecord(body)) {
-      const entry = membersById.get(member.entryMemberId);
+      const entry = membersById2.get(member.entryMemberId);
       for (const childId of Object.values(body)) visitChild(entry, childId);
       return;
     }
@@ -93978,7 +94438,7 @@ function collectValuesReachableWithoutReadOnlyBinding(document, excludedMemberId
       document.members
     )) {
       if (entry.memberId === excludedMemberId) continue;
-      const childMember = membersById.get(entry.memberId);
+      const childMember = membersById2.get(entry.memberId);
       visitChild(
         childMember === void 0 ? void 0 : substituteMember(
           childMember,
@@ -97139,17 +97599,17 @@ var init_reserved_record_id_validation = __esm({
 
 // ../src/database/project-world-reference-graph.ts
 function createWorldReferenceGraph(args) {
-  const classesById = /* @__PURE__ */ new Map();
+  const classesById2 = /* @__PURE__ */ new Map();
   for (const value of args.classes) {
     const schemaClass2 = toWorldReferenceClassRecord(value);
-    if (schemaClass2 !== null) classesById.set(schemaClass2.id, schemaClass2);
+    if (schemaClass2 !== null) classesById2.set(schemaClass2.id, schemaClass2);
   }
   const valuesById = /* @__PURE__ */ new Map();
   for (const value of args.values) {
     const worldValue = toWorldReferenceValueRecord(value);
     if (worldValue !== null) valuesById.set(worldValue.id, worldValue);
   }
-  return { classesById, valuesById };
+  return { classesById: classesById2, valuesById };
 }
 function collectProjectDocumentTileGridReferenceBlockers(args) {
   const blockers = [];
@@ -97263,16 +97723,16 @@ function worldReferenceMergedSchema(graph, classId) {
 function resolveWorldReferenceKind(graph, classId) {
   return resolveWorldKindFromClassMap(classId, graph.classesById);
 }
-function resolveWorldKindFromClassMap(classId, classesById) {
+function resolveWorldKindFromClassMap(classId, classesById2) {
   const visited = /* @__PURE__ */ new Set();
-  let current = classesById.get(classId);
+  let current = classesById2.get(classId);
   while (current !== void 0) {
     if (visited.has(current.id)) return null;
     visited.add(current.id);
     const worldKind = current.system?.worldKind;
     if (typeof worldKind === "string") return worldKind;
     const extendsClassId = current.extendsClassId;
-    current = typeof extendsClassId === "string" ? classesById.get(extendsClassId) : void 0;
+    current = typeof extendsClassId === "string" ? classesById2.get(extendsClassId) : void 0;
   }
   return null;
 }
@@ -97657,7 +98117,7 @@ function assertStagedWorldContentLayerBindingsValid(current, projected, changes)
   });
 }
 function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
-  const classesById = new Map(
+  const classesById2 = new Map(
     current.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   const valuesById = new Map(current.values.map((value) => [value.id, value]));
@@ -97671,7 +98131,7 @@ function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
     if (change.recordKind !== "class") continue;
     if (change.operation !== "update") return true;
     if (change.deleted === true) return true;
-    const before = classesById.get(change.recordId);
+    const before = classesById2.get(change.recordId);
     if (before === void 0) return true;
     const after = change.nextData;
     if (!isPlainRecord(after)) return true;
@@ -97842,7 +98302,7 @@ function assertStagedActionListenersValid(projected, changes) {
     (member) => member.kind === 26 /* NSAction */
   );
   if (actions.length === 0) return;
-  const membersById = new Map(
+  const membersById2 = new Map(
     projected.members.map((member) => [member.id, member])
   );
   const valueIds = new Set(projected.values.map((value) => value.id));
@@ -97870,7 +98330,7 @@ function assertStagedActionListenersValid(projected, changes) {
       if (listeners.length === 0) continue;
       const ownerId = getMemberId(owner);
       if (ownerId === null) continue;
-      const action = membersById.get(ownerId);
+      const action = membersById2.get(ownerId);
       if (action === void 0) continue;
       graded.push({
         listeners,
@@ -97887,7 +98347,7 @@ function assertStagedActionListenersValid(projected, changes) {
       expected,
       owner: entry.label,
       projected,
-      membersById,
+      membersById: membersById2,
       valueIds
     });
   }
@@ -97925,7 +98385,7 @@ function getMemberId(member) {
   return typeof id2 === "string" ? id2 : null;
 }
 function assertActionListenerSetValid(args) {
-  const { expected, owner, projected, membersById, valueIds } = args;
+  const { expected, owner, projected, membersById: membersById2, valueIds } = args;
   const identities = /* @__PURE__ */ new Map();
   args.listeners.forEach((listener, index) => {
     if (!isMemberDelegateTarget(listener)) {
@@ -97946,7 +98406,7 @@ function assertActionListenerSetValid(args) {
         `${owner} listener ${index} names receiver value "${listener.valueId}", which this project version does not contain.`
       );
     }
-    const target = membersById.get(listener.memberId);
+    const target = membersById2.get(listener.memberId);
     if (target === void 0) {
       throw new Error(
         `${owner} listener ${index} names member "${listener.memberId}", which this project version does not contain.`
@@ -98100,7 +98560,7 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
     (member) => member.kind === 27 /* Variant */
   );
   if (variantMembers.length === 0) return;
-  const classesById = new Map(
+  const classesById2 = new Map(
     projected.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   const variantsById = new Map(
@@ -98109,7 +98569,7 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
   const foldersById = new Map(
     (projected.variantFolders ?? []).map((folder) => [folder.id, folder])
   );
-  const membersById = new Map(
+  const membersById2 = new Map(
     projected.members.map((member) => [member.id, member])
   );
   const valuesById = new Map(
@@ -98119,7 +98579,7 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
   for (const member of variantMembers) {
     const declaration = substituteMemberForListenerGrading(member, projected);
     const label = describeVariantMember(member, projected.classes);
-    assertVariantMemberTargetValid({ declaration, label, classesById });
+    assertVariantMemberTargetValid({ declaration, label, classesById: classesById2 });
     const authored = authoredVariantValue(member);
     if (authored !== void 0) {
       graded.push({ value: authored, declaration, label });
@@ -98153,17 +98613,17 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
       value: entry.value,
       declaration: entry.declaration,
       owner: entry.label,
-      classesById,
+      classesById: classesById2,
       variantsById,
       foldersById,
-      membersById,
+      membersById: membersById2,
       valuesById,
       values: projected.values
     });
   }
 }
 function assertVariantMemberTargetValid(args) {
-  const { declaration, label, classesById } = args;
+  const { declaration, label, classesById: classesById2 } = args;
   const target = variantMemberTargetTypeInfo(declaration);
   if (target === null) {
     throw new Error(
@@ -98176,13 +98636,13 @@ function assertVariantMemberTargetValid(args) {
       `${label} declares a target that is neither a class nor a generic parameter. NeoVariant<TTarget> takes a NeoObject-derived class or a NeoObject-constrained parameter.`
     );
   }
-  const targetClass = classesById.get(target.classId);
+  const targetClass = classesById2.get(target.classId);
   if (targetClass === void 0) {
     throw new Error(
       `${label} targets class "${target.classId}", which is not in this project.`
     );
   }
-  if (resolveWorldKindFromClassMap(target.classId, classesById) !== NeoWorldSystemClassKind.Object) {
+  if (resolveWorldKindFromClassMap(target.classId, classesById2) !== NeoWorldSystemClassKind.Object) {
     throw new Error(
       `${label} targets class "${targetClass.name}", which does not derive from NeoObject. Only NeoObject-derived classes declare variants (P67 \xA71).`
     );
@@ -98193,10 +98653,10 @@ function assertVariantReferenceValid(args) {
     value,
     declaration,
     owner,
-    classesById,
+    classesById: classesById2,
     variantsById,
     foldersById,
-    membersById,
+    membersById: membersById2,
     valuesById
   } = args;
   const target = variantMemberTargetTypeInfo(declaration);
@@ -98214,7 +98674,7 @@ function assertVariantReferenceValid(args) {
       `${owner} must store a variant reference: { classId, variantId } where variantId is a variant id or null for the base selection.`
     );
   }
-  const selectedClass = classesById.get(value.classId);
+  const selectedClass = classesById2.get(value.classId);
   if (selectedClass === void 0) {
     throw new Error(
       `${owner} selects class "${value.classId}", which is not in this project.`
@@ -98223,10 +98683,10 @@ function assertVariantReferenceValid(args) {
   if (target.type === 7 /* Class */ && value.classId !== target.classId) {
     const admitted = descendantClassIds(
       target.classId,
-      Array.from(classesById.values())
+      Array.from(classesById2.values())
     );
     if (!admitted.has(value.classId)) {
-      const targetName = classesById.get(target.classId)?.name ?? target.classId;
+      const targetName = classesById2.get(target.classId)?.name ?? target.classId;
       throw new Error(
         `${owner} selects class "${selectedClass.name}", which does not derive from the declared target "${targetName}". A NeoVariant member accepts its target or a subclass of it (P67 \xA76).`
       );
@@ -98251,7 +98711,7 @@ function assertVariantReferenceValid(args) {
     );
   }
   if (variant.classId !== value.classId) {
-    const ownerClassName = classesById.get(variant.classId)?.name ?? variant.classId;
+    const ownerClassName = classesById2.get(variant.classId)?.name ?? variant.classId;
     throw new Error(
       `${owner} selects class "${selectedClass.name}" but names variant "${variant.name}" of "${ownerClassName}". Variant lookup is not virtual, so a variant belongs to exactly one class (P67 \xA74.3).`
     );
@@ -98269,7 +98729,7 @@ function assertVariantReferenceValid(args) {
         `${owner} keeps its lookup row unbound, so rowValueId must be null.`
       );
     }
-    if (declaredValueType.type === 7 /* Class */ && lookupBindingEntryClassId(binding, membersById) !== declaredValueType.classId) {
+    if (declaredValueType.type === 7 /* Class */ && lookupBindingEntryClassId(binding, membersById2) !== declaredValueType.classId) {
       throw new Error(
         `${owner} lookup value type does not match variant folder "${folder?.path ?? ""}".`
       );
@@ -98289,7 +98749,7 @@ function assertVariantReferenceValid(args) {
       `${owner} selects lookup variant "${variant.name}" and must bind one collection row.`
     );
   }
-  const collection = membersById.get(binding.collectionMemberId);
+  const collection = membersById2.get(binding.collectionMemberId);
   const collectionValue = valuesById.get(binding.collectionValueId);
   if (!isMemberListBase(collection) || collectionValue === void 0 || !valuesById.has(value.rowValueId) || !listEntryIdsForValue(collection, collectionValue, args.values).includes(
     value.rowValueId
@@ -98303,10 +98763,10 @@ function variantMemberValueTypeInfo(declaration) {
   const valueType = Reflect.get(declaration, "valueTypeInfo");
   return isNSTypeInfo(valueType) ? valueType : null;
 }
-function lookupBindingEntryClassId(binding, membersById) {
-  const collection = membersById.get(binding.collectionMemberId);
+function lookupBindingEntryClassId(binding, membersById2) {
+  const collection = membersById2.get(binding.collectionMemberId);
   if (!isMemberListBase(collection)) return null;
-  const entry = membersById.get(collection.entryMemberId);
+  const entry = membersById2.get(collection.entryMemberId);
   return isMemberClassBase(entry) ? entry.classId : null;
 }
 function variantMemberTargetTypeInfo(declaration) {
@@ -99161,27 +99621,30 @@ function computeWorkspaceStatus(workspace, options) {
   )) {
     parseErrors.push(new SchemaSourceError(message, "<project-files>", 1, 1));
   }
-  try {
-    const animationRecords = prospectiveAnimationRecords(
-      workspace.state.records,
-      reconstructed3,
-      changes,
-      authoredValueSeeds
-    );
-    validateProspectiveAnimationRecordsV4(
-      animationRecords,
-      animationRecordsFromState(workspace.state.records)
-    );
-  } catch (error) {
-    parseErrors.push(
-      new SchemaSourceError(
-        error instanceof Error ? error.message : String(error),
-        "<animation-clips>",
-        1,
-        1
-      )
-    );
+  if (animationValidationInputsChanged(changes, authoredValueSeeds)) {
+    try {
+      const animationRecords = prospectiveAnimationRecords(
+        workspace.state.records,
+        reconstructed3,
+        changes,
+        authoredValueSeeds
+      );
+      validateProspectiveAnimationRecordsV4(
+        animationRecords,
+        animationRecordsFromState(workspace.state.records)
+      );
+    } catch (error) {
+      parseErrors.push(
+        new SchemaSourceError(
+          error instanceof Error ? error.message : String(error),
+          "<animation-clips>",
+          1,
+          1
+        )
+      );
+    }
   }
+  reportPhase("animation-clip-validation");
   for (const binary of binaryChanges) {
     if (binary.action !== "missing-local") continue;
     parseErrors.push(
@@ -99224,6 +99687,7 @@ function computeWorkspaceStatus(workspace, options) {
       )
     );
   }
+  reportPhase("initializer-materialization");
   return {
     changes,
     conflictedFiles,
@@ -99381,6 +99845,15 @@ function replayAnimationDeclarationInitializersV4(records2, document, fallbackDo
   }
   return { ...document, values: [...values.values()] };
 }
+function animationValidationInputsChanged(changes, seeds) {
+  for (const seed of seeds.values()) {
+    if ((seed.values?.length ?? 0) > 0) return true;
+    if ((seed.bindingMembers?.length ?? 0) > 0) return true;
+  }
+  return changes.some(
+    (change) => PROSPECTIVE_ANIMATION_RECORD_KINDS.has(change.recordKind)
+  );
+}
 function animationRecordsFromState(records2) {
   return Object.values(records2).flatMap((record3) => {
     const data = effectiveRecordData(record3);
@@ -99388,14 +99861,14 @@ function animationRecordsFromState(records2) {
   });
 }
 function classBelongsToAnimationFamily(classes, classId) {
-  const classesById = new Map(
+  const classesById2 = new Map(
     classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
   const visited = /* @__PURE__ */ new Set();
   let currentId = classId;
   while (currentId !== null && !visited.has(currentId)) {
     visited.add(currentId);
-    const schemaClass2 = classesById.get(currentId);
+    const schemaClass2 = classesById2.get(currentId);
     if (schemaClass2 === void 0) return false;
     if (declaresAnimationWorldKind(schemaClass2.system)) return true;
     currentId = schemaClass2.extendsClassId ?? null;
@@ -99627,7 +100100,20 @@ function prospectiveAnimationRecords(base, reconstructed3, changes, seeds) {
           ...seedEnvelope,
           id: seed.valueId,
           memberId,
-          ...seed.init === void 0 ? { value: seed.value, classId: seed.classId } : { init: seed.init }
+          // A seed root's P75 provenance is what makes it a root. Without it
+          // `expandProspectiveAnimationInstances` cannot recognize the row, so
+          // a collapse-stamped seed reached the clip validators as the sparse
+          // graph storage holds rather than the graph the runtime resolves --
+          // every rule stated over a settled track, segment, or child override
+          // passing on a row that does not exist. The descendant rows below
+          // already carry it by spreading the whole seed row; the root is the
+          // one projection that dropped it. Same shape as the push wire record
+          // and the pull emit overlay, both of which use this helper.
+          ...seed.init === void 0 ? {
+            value: seed.value,
+            classId: seed.classId,
+            ...pickInstanceProvenance(seed)
+          } : { init: seed.init }
         }
       });
     }
@@ -99812,6 +100298,7 @@ function summarizeFieldDiff(baseData3, nextData) {
   }
   return lines;
 }
+var ANIMATION_DOCUMENT_RECORD_KINDS, ANIMATION_REPLAY_RECORD_KINDS, PROSPECTIVE_ANIMATION_RECORD_KINDS;
 var init_workspace_status_core = __esm({
   "src/project-source/workspace-status-core.ts"() {
     "use strict";
@@ -99840,6 +100327,7 @@ var init_workspace_status_core = __esm({
     init_members();
     init_value_row_owner_members();
     init_project2();
+    init_project_version_types();
     init_instance_provenance();
     init_evaluator_lookups();
     init_local_initializer_materialization();
@@ -99850,6 +100338,24 @@ var init_workspace_status_core = __esm({
     init_materialized_construction_cache();
     init_project_version_whole_graph_validation();
     init_value_base_desync();
+    ANIMATION_DOCUMENT_RECORD_KINDS = [
+      ProjectRecordKind.Project,
+      ProjectRecordKind.Class,
+      ProjectRecordKind.Constructor,
+      ProjectRecordKind.Member,
+      ProjectRecordKind.Value
+    ];
+    ANIMATION_REPLAY_RECORD_KINDS = [
+      ProjectRecordKind.Enum,
+      ProjectRecordKind.Interface,
+      ProjectRecordKind.ProjectFile,
+      ProjectRecordKind.Variant,
+      ProjectRecordKind.VariantFolder
+    ];
+    PROSPECTIVE_ANIMATION_RECORD_KINDS = /* @__PURE__ */ new Set([
+      ...ANIMATION_DOCUMENT_RECORD_KINDS,
+      ...ANIMATION_REPLAY_RECORD_KINDS
+    ]);
   }
 });
 
@@ -101542,17 +102048,18 @@ function rowBackedDefaultBody(member, isPulledValueRow) {
   const defaultValue = member.defaultValue;
   if (!isObjectRecord2(defaultValue)) return null;
   const body = defaultValue.value;
-  const referencesRows = (children) => children.length > 0 && children.every(
+  const referencesRows = (children) => children.every(
     (child) => typeof child === "string" && isPulledValueRow(child)
   );
   if (member.kind === MEMBER_KIND_CLASS2 && isObjectRecord2(body)) {
-    return referencesRows(Object.values(body)) ? { kind: "class", body } : null;
+    const children = Object.values(body);
+    return children.length > 0 && referencesRows(children) ? { kind: "class", body } : null;
   }
   if (member.kind === MEMBER_KIND_LIST2 && member.listKind !== "unordered" && Array.isArray(body)) {
     const rows = body.filter(
       (child) => typeof child === "string" && isPulledValueRow(child)
     );
-    return rows.length > 0 && rows.length === body.length ? { kind: "list", body: rows } : null;
+    return rows.length === body.length ? { kind: "list", body: rows } : null;
   }
   if (member.kind === MEMBER_KIND_DICTIONARY2 && isObjectRecord2(body)) {
     return referencesRows(Object.values(body)) ? { kind: "dictionary", body } : null;
@@ -102062,15 +102569,16 @@ function indexStructuralStoredIds(context, rootValueId, rootPath) {
       });
       return;
     }
-    if (!isObjectRecord2(body)) return;
     const indexedSchemaKeys = /* @__PURE__ */ new Set();
-    for (const [key, child] of Object.entries(body)) {
-      if (typeof child !== "string") continue;
-      if (context.state[`value:${child}`] === void 0) continue;
-      const childPath = `${path}.${key}`;
-      indexedSchemaKeys.add(key);
-      context.structuralStoredIds.set(childPath, child);
-      visit(child, childPath, depth + 1);
+    if (isObjectRecord2(body)) {
+      for (const [key, child] of Object.entries(body)) {
+        if (typeof child !== "string") continue;
+        if (context.state[`value:${child}`] === void 0) continue;
+        const childPath = `${path}.${key}`;
+        indexedSchemaKeys.add(key);
+        context.structuralStoredIds.set(childPath, child);
+        visit(child, childPath, depth + 1);
+      }
     }
     const constructorArgs = data.constructorArgs;
     const classId = data.classId;
@@ -106548,6 +107056,9 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     const childMember = context.members.get(childMemberId);
     if (childMember === void 0)
       throw new Error(`Class ${name}.${key} has no member record.`);
+    if (emitsAsMemberDefaultDerivedAbsence(context, childMember, childId)) {
+      continue;
+    }
     const replayChildId = replayBody[key];
     if (replayGraph !== null && typeof replayChildId === "string" && materializedValueSubgraphsEqual(
       context,
@@ -106590,6 +107101,20 @@ ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
 ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
 }`;
 }
+function emitsAsMemberDefaultDerivedAbsence(context, member, valueId) {
+  const value = context.values.get(valueId);
+  if (value === void 0) return false;
+  const body = value.value;
+  if (!isObjectRecord2(body)) return false;
+  if (Object.keys(body).length > 0) return false;
+  const effectiveClassId = stringOrNull(value.classId) ?? stringOrNull(member.classId);
+  if (effectiveClassId === null) return false;
+  return derivesContentFromMemberDefault({
+    member,
+    instanceRoot: value,
+    effectiveClassId
+  });
+}
 function memberProjectsConstructorParameter(context, memberId, projectedMemberIds) {
   const visited = /* @__PURE__ */ new Set();
   let current = memberId;
@@ -106745,8 +107270,7 @@ function storedConstructorCallSource(context, schemaClass2, value, className, en
         // re-declared that external graph under the construction, and the
         // emitter then refused the whole pull with a containment cycle on the
         // re-declared row's own children.
-        constructorArgumentBodySchemaKey(value, constructorArgs[key]) !== void 0,
-        settledMember !== void 0
+        constructorArgumentBodySchemaKey(value, constructorArgs[key]) !== void 0
       )}`
     ];
   });
@@ -106847,7 +107371,7 @@ function storedValueConstructor(context, schemaClass2, constructorArgs, recorded
   }
   return selected;
 }
-function storedConstructorArgumentSource(context, type, value, environment, visited, cloneAggregateArguments = false, partial = false, constructorOwnsGraph = false, settlesMember = false) {
+function storedConstructorArgumentSource(context, type, value, environment, visited, cloneAggregateArguments = false, partial = false, constructorOwnsGraph = false) {
   if (value === null) {
     if (!type.nullable) {
       throw new Error("Required constructor argument stores null.");
@@ -106929,7 +107453,7 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         value,
         environment,
         visited,
-        settlesMember,
+        false,
         partial,
         constructorOwnsGraph
       );
@@ -106956,8 +107480,7 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         visited,
         cloneAggregateArguments,
         partial,
-        constructorOwnsGraph,
-        settlesMember
+        constructorOwnsGraph
       );
     }
     case "interface":
@@ -106977,7 +107500,7 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         value,
         environment,
         visited,
-        settlesMember,
+        false,
         false,
         constructorOwnsGraph
       );
@@ -108132,6 +108655,7 @@ var init_value_sources = __esm({
     init_member_kind_type_names();
     init_initializer_replay();
     init_variant_value_graph();
+    init_virtual_instance_values();
     init_variant_selection_source();
     INFERRED_GENERIC_CLASS_PREFIX = "__inferred_class__:";
     MEMBER_KIND_DICTIONARY2 = 5;
@@ -112120,7 +112644,8 @@ function auditProjectIntegrity(workspace) {
       values,
       placements,
       memberIdBySchemaKey
-    })
+    }),
+    ...auditUnprojectedValueRows({ records: records2, values, placements })
   );
   return findings.sort(
     (left, right) => left.recordId.localeCompare(right.recordId)
@@ -112170,10 +112695,108 @@ function auditDanglingLocalizedTexts(args) {
   }
   return findings;
 }
+function auditUnprojectedValueRows(args) {
+  const recordsById2 = /* @__PURE__ */ new Map();
+  const seeds = [];
+  let projectsAnyFile = false;
+  for (const record3 of Object.values(args.records)) {
+    const existing = recordsById2.get(record3.recordId);
+    if (existing === void 0) {
+      recordsById2.set(record3.recordId, [record3]);
+    } else {
+      existing.push(record3);
+    }
+    if (record3.file !== void 0) projectsAnyFile = true;
+    if (record3.recordKind !== "value" || record3.file !== void 0) {
+      seeds.push(record3.recordId);
+    }
+  }
+  if (!projectsAnyFile) return [];
+  const containedByContainer = /* @__PURE__ */ new Map();
+  for (const value of args.values.values()) {
+    if (value.containerId === null) continue;
+    const siblings = containedByContainer.get(value.containerId);
+    if (siblings === void 0) {
+      containedByContainer.set(value.containerId, [value.id]);
+    } else {
+      siblings.push(value.id);
+    }
+  }
+  const reachable = walkRecordGraph({
+    recordsById: recordsById2,
+    containedByContainer,
+    seeds
+  });
+  const findings = [];
+  for (const value of args.values.values()) {
+    if (reachable.has(value.id)) continue;
+    if (args.placements.has(value.id)) continue;
+    const orphaned = walkRecordGraph({
+      recordsById: recordsById2,
+      containedByContainer,
+      seeds: [value.id],
+      excluded: reachable
+    });
+    const orphanedValueIds = [];
+    for (const id2 of orphaned) {
+      if (args.values.has(id2)) orphanedValueIds.push(id2);
+    }
+    findings.push({
+      kind: "unprojected-value-row",
+      recordKind: "value",
+      recordId: value.id,
+      message: `Value "${value.id}" is a pulled row that no emitted file projects and no other record names, so \`neo status\` reads it as CLI-managed loose state and never reports it${orphanedValueIds.length === 1 ? "" : `, along with the ${String(orphanedValueIds.length - 1)} row(s) it owns`}. Restore the declaration that should name it, or delete the rows.`,
+      repair: { valueId: value.id, orphanedValueIds }
+    });
+  }
+  return findings;
+}
+function walkRecordGraph(args) {
+  const reached = /* @__PURE__ */ new Set();
+  const pending = [];
+  const claim = (id2) => {
+    if (args.excluded?.has(id2) === true) return;
+    if (!args.recordsById.has(id2) || reached.has(id2)) return;
+    reached.add(id2);
+    pending.push(id2);
+  };
+  for (const seed of args.seeds) claim(seed);
+  for (let id2 = pending.pop(); id2 !== void 0; id2 = pending.pop()) {
+    for (const record3 of args.recordsById.get(id2) ?? []) {
+      collectRecordIdStrings(record3.data, args.recordsById, claim);
+    }
+    for (const contained of args.containedByContainer.get(id2) ?? []) {
+      claim(contained);
+    }
+  }
+  return reached;
+}
+function collectRecordIdStrings(data, recordsById2, claim) {
+  if (typeof data === "string") {
+    if (recordsById2.has(data)) {
+      claim(data);
+      return;
+    }
+    for (const [embedded] of data.matchAll(EMBEDDED_RECORD_ID)) {
+      if (recordsById2.has(embedded)) claim(embedded);
+      const systemId = `${SYSTEM_RECORD_ID_PREFIX2}${embedded}`;
+      if (recordsById2.has(systemId)) claim(systemId);
+    }
+    return;
+  }
+  if (Array.isArray(data)) {
+    for (const entry of data) {
+      collectRecordIdStrings(entry, recordsById2, claim);
+    }
+    return;
+  }
+  if (!isObjectRecord2(data)) return;
+  for (const entry of Object.values(data)) {
+    collectRecordIdStrings(entry, recordsById2, claim);
+  }
+}
 function isLocalizedTextIdShape(body) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u.test(
-    body
-  );
+  return WHOLE_RECORD_ID.test(body);
 }
 function childStorageKeyDeclaration(args) {
   const { placement } = args;
@@ -112297,14 +112920,18 @@ function normalizePartition(mapKey) {
 function describePartition(mapKey) {
   return mapKey === null ? `"${MAIN_STORAGE_PARTITION}"` : `"${mapKey}"`;
 }
-var UNORDERED_MEMBERSHIP_KEY, MEMBER_KIND_STRING;
+var UNORDERED_MEMBERSHIP_KEY, MEMBER_KIND_STRING, RECORD_ID_PATTERN2, EMBEDDED_RECORD_ID, WHOLE_RECORD_ID;
 var init_project_integrity = __esm({
   "src/project-source/project-integrity.ts"() {
     "use strict";
     init_member_storage_key();
+    init_system_record_id();
     init_projection();
     UNORDERED_MEMBERSHIP_KEY = "(container)";
     MEMBER_KIND_STRING = 3;
+    RECORD_ID_PATTERN2 = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+    EMBEDDED_RECORD_ID = new RegExp(RECORD_ID_PATTERN2, "gu");
+    WHOLE_RECORD_ID = new RegExp(`^${RECORD_ID_PATTERN2}$`, "u");
   }
 });
 
@@ -114380,12 +115007,12 @@ async function runLocalTargetCommand(manifest, target, command, options) {
   );
 }
 function collectLocalCheckAll(manifest, options) {
-  const membersById = new Map(
+  const membersById2 = new Map(
     manifest.members.filter(isLocalScriptMember).map((member) => [member.id, member])
   );
   const analyses = analyzeManifestScripts(manifest);
   const results = analyses.map((analysis) => {
-    const member = membersById.get(analysis.memberId);
+    const member = membersById2.get(analysis.memberId);
     if (member === void 0) {
       throw new Error(
         `Local NeoScript analysis returned an unknown body "${analysis.path}".`
@@ -118300,7 +118927,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.37.0",
+      cliVersion: "0.38.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -125023,7 +125650,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.37.0");
+    console.log("0.38.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -125035,21 +125662,27 @@ async function main() {
     return;
   }
   assertKnownFlags(args);
-  const apiBaseUrl = stringFlag(args, "api") ?? DEFAULT_API_BASE_URL;
+  const apiOverride = stringFlag(args, "api");
+  const apiBaseUrl = apiOverride ?? DEFAULT_API_BASE_URL;
+  const authApiBaseUrl = () => resolveAuthApiBaseUrl({
+    apiOverride,
+    cwd: process.cwd(),
+    defaultApiBaseUrl: DEFAULT_API_BASE_URL
+  });
   switch (args.command) {
     case "login":
       await runLogin({
-        apiBaseUrl,
+        apiBaseUrl: authApiBaseUrl(),
         profile: profileFlag(args),
         tokenStdin: boolFlag(args, "token-stdin"),
         saveProjectId: stringFlag(args, "save-project")
       });
       return;
     case "whoami":
-      await runWhoami(apiBaseUrl);
+      await runWhoami(authApiBaseUrl());
       return;
     case "logout":
-      await runLogout(apiBaseUrl);
+      await runLogout(authApiBaseUrl());
       return;
     case "init":
       {
@@ -125510,6 +126143,7 @@ var DEFAULT_API_BASE_URL;
 var init_main = __esm({
   "src/main.ts"() {
     "use strict";
+    init_auth_api_base_url();
     init_login();
     init_args();
     init_workspace_status();