@neocompose/cli 0.38.3 → 0.38.5

package/dist/neo.mjs

@@ -936,7 +936,7 @@ var init_login = __esm({
       "project:release-channel:write",
       "project:release-channel:publish"
     ];
-    sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+    sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
   }
 });
 
@@ -9133,19 +9133,6 @@ function bindConstructorArgumentNames(className, declared, argumentNames, pos) {
     return parameter4.name;
   });
 }
-function callMatchesDeclaredOverloadNames(declared, expression) {
-  if (declared.length === 0) return false;
-  if (callHasPositionalArguments(expression)) return false;
-  const names = expression.args.map(
-    (_, index) => expression.argumentNames?.[index] ?? ""
-  );
-  const callKey = neoScriptArgumentNameSetKey(names);
-  return declared.some(
-    (candidate) => neoScriptArgumentNameSetKey(
-      candidate.parameters.map((parameter4) => parameter4.name)
-    ) === callKey
-  );
-}
 function scopeVariable(name, value, sourceType, writability, ownership, writeRoot, readonlyBinding) {
   return {
     name,
@@ -11827,11 +11814,8 @@ var init_strict_resolver = __esm({
             const declaredTarget = this.project.typeByName.get(className);
             const declared = declaredTarget?.declaredConstructors ?? [];
             const requiredConstructor = neoScriptRequiredConstructor(declaredTarget);
-            if (requiredConstructor === null && !callMatchesDeclaredOverloadNames(declared, expression)) {
-              this.rejectConstructorProjectionInConstructionBody(expression);
-            }
-            const projectionCall = requiredConstructor === null && declaredTarget?.constructorSignature !== void 0 && (expression.argumentNames === void 0 && callHasPositionalArguments(expression) || expression.argumentNames !== void 0 && declaredTarget.constructorSignature.namedProjections !== void 0);
-            if (declared.length > 0 && !projectionCall) {
+            const generatedPositionalCall = requiredConstructor === null && declaredTarget?.constructorSignature !== void 0 && expression.argumentNames === void 0 && callHasPositionalArguments(expression);
+            if (declared.length > 0 && !generatedPositionalCall) {
               return this.resolveDeclaredConstructor(
                 className,
                 expression,
@@ -11840,13 +11824,13 @@ var init_strict_resolver = __esm({
                 expected
               );
             }
-            if (expression.argumentNames && !projectionCall) {
+            if (expression.argumentNames && !generatedPositionalCall) {
               throw new CompileError(
                 "Named constructor arguments require a declaration-aware project source context.",
                 expression.pos
               );
             }
-            if (expression.initializer && expression.initializer.length > 0 && !projectionCall && this.context.storedConstructionReplay !== true) {
+            if (expression.initializer && expression.initializer.length > 0 && !generatedPositionalCall && this.context.storedConstructionReplay !== true) {
               throw new CompileError(
                 "Object initializers are available to project source construction and are not executable NeoScript constructors.",
                 expression.pos
@@ -14089,26 +14073,11 @@ var init_strict_resolver = __esm({
           )
         }));
         const argumentsList2 = expression.args;
-        const namedProjections = signature.namedProjections;
         if (expression.argumentNames !== void 0) {
-          if (namedProjections === void 0) {
-            throw new CompileError(
-              `Class '${className}' exposes no named constructor projection.`,
-              pos
-            );
-          }
-          if (argumentsList2.length !== namedProjections.length) {
-            throw new CompileError(
-              `${className} constructor requires ${namedProjections.length} named argument${namedProjections.length === 1 ? "" : "s"} but got ${argumentsList2.length}.`,
-              pos
-            );
-          }
-          if (expression.argumentNames.length !== argumentsList2.length) {
-            throw new CompileError(
-              `${className} constructor projection requires every argument to be named.`,
-              pos
-            );
-          }
+          throw new CompileError(
+            "Named constructor arguments require a declaration-aware project source context.",
+            pos
+          );
         }
         const requiredCount = signature.parameters.filter(
           (parameter4) => parameter4.required
@@ -14126,30 +14095,10 @@ var init_strict_resolver = __esm({
           );
         }
         const fields = argumentsList2.map((argument2, index) => {
-          const projectionName = expression.argumentNames?.[index];
-          const projection = projectionName === void 0 ? void 0 : namedProjections?.find(
-            (candidate) => candidate.name === projectionName
-          );
-          if (projectionName !== void 0 && projection === void 0) {
-            throw new CompileError(
-              `Class '${className}' has no constructor projection named '${projectionName}'.`,
-              argument2.pos
-            );
-          }
-          if (projection !== void 0 && expression.argumentNames?.findIndex(
-            (candidate) => candidate === projection.name
-          ) !== index) {
-            throw new CompileError(
-              `Constructor argument '${projection.name}' is supplied more than once.`,
-              argument2.pos
-            );
-          }
-          const parameter4 = projection === void 0 ? parameters[index] : parameters.find(
-            (candidate) => candidate.memberId === projection.memberId
-          );
+          const parameter4 = parameters[index];
           if (!parameter4) {
             throw new Error(
-              projection === void 0 ? `NeoScript constructor ${className} lost parameter ${index + 1} after argument-count validation.` : `NeoScript constructor ${className} projection '${projection.name}' names missing member '${projection.memberId}'.`
+              `NeoScript constructor ${className} lost parameter ${index + 1} after argument-count validation.`
             );
           }
           const value = this.resolveExpression(
@@ -14169,16 +14118,6 @@ var init_strict_resolver = __esm({
             valuePointer: value.pointer
           };
         });
-        if (namedProjections !== void 0 && expression.argumentNames !== void 0) {
-          for (const projection of namedProjections) {
-            if (!expression.argumentNames.includes(projection.name)) {
-              throw new CompileError(
-                `${className} constructor is missing named argument '${projection.name}'.`,
-                pos
-              );
-            }
-          }
-        }
         fields.push(
           ...this.resolveCallSiteInitializerFields(schemaClass2, expression, scope)
         );
@@ -14225,22 +14164,6 @@ var init_strict_resolver = __esm({
           typeId: schemaClass2.id
         };
       }
-      /**
-       * P43 §7.1. P29's `new T(id: "…")` projection names a class-default row,
-       * which is exactly the wrong identity inside a construction body: member
-       * initializers have already run, so the body holds its own rows.
-       */
-      rejectConstructorProjectionInConstructionBody(expression) {
-        if (!isNeoScriptConstructionDocumentKind(this.context.kind)) return;
-        const idIndex = (expression.argumentNames ?? []).findIndex(
-          (name) => name === "id"
-        );
-        if (idIndex < 0) return;
-        throw new CompileError(
-          `A constructor projection \`new(id: \u2026)\` names a class-default row, so it cannot be used in a ${this.context.kind} body. Bind the resolved value instead, for example \`Child = iris\`.`,
-          expression.pos
-        );
-      }
       /**
        * P43 §6.1. Construction through the class's author-declared constructors.
        * Arguments are named (§6.1.1 resolves overloads by name set first), and
@@ -19518,7 +19441,7 @@ var init_project_schema_contract_generated = __esm({
   "../packages/neoscript-language/src/project-schema-contract.generated.ts"() {
     "use strict";
     PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION = 3;
-    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.14";
+    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.15";
     PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
     NEO_PROJECT_SOURCE_RECORD_CONTRACT = {
       "recordFields": {
@@ -19588,7 +19511,6 @@ var init_project_schema_contract_generated = __esm({
           "allowedStorageKeys",
           "genericParams",
           "extendsGenericBindings",
-          "constructorProjections",
           "constructorIds",
           "requiredConstructorId",
           "targetMemberId"
@@ -22779,7 +22701,7 @@ function resolveInvokedConstructor(declaration, call, diagnostics) {
     return true;
   }
   if (declaration.constructors.length === 0) {
-    return call.argumentNames.length > 0;
+    return false;
   }
   if (call.argumentNames.length === 0) {
     return declaration.constructors.some(
@@ -35831,7 +35753,6 @@ var init_document_contracts = __esm({
           "allowedStorageKeys",
           "genericParams",
           "extendsGenericBindings",
-          "constructorProjections",
           "constructorIds",
           "requiredConstructorId",
           "targetMemberId"
@@ -35849,7 +35770,6 @@ var init_document_contracts = __esm({
           allowedStorageKeys: "nullIsAbsent",
           genericParams: "nullOrEmptyArrayIsAbsent",
           extendsGenericBindings: "nullOrEmptyObjectIsAbsent",
-          constructorProjections: "nullOrEmptyArrayIsAbsent",
           constructorIds: "nullOrEmptyArrayIsAbsent",
           requiredConstructorId: "nullIsAbsent"
         }
@@ -38739,27 +38659,6 @@ function schemaClassFromDocument(record3, context) {
       selectionSpan: source.selectionSpan
     };
   });
-  const constructorProjections = optionalArray(data.constructorProjections).map(
-    (entry, index) => {
-      const projection = requireRecordValue(
-        entry,
-        record3,
-        `constructorProjections[${index}]`
-      );
-      return {
-        parameterName: requiredStringValue(
-          projection.parameterName,
-          record3,
-          `constructorProjections[${index}].parameterName`
-        ),
-        memberId: requiredStringValue(
-          projection.memberId,
-          record3,
-          `constructorProjections[${index}].memberId`
-        )
-      };
-    }
-  );
   const constructorIds = optionalStringArray(data.constructorIds);
   const requiredConstructorId2 = optionalStringOrNull(
     data.requiredConstructorId
@@ -38790,7 +38689,6 @@ function schemaClassFromDocument(record3, context) {
       "extendsGenericBindings"
     ),
     targetMemberId: optionalStringOrNull(data.targetMemberId),
-    ...constructorProjections.length === 0 ? {} : { constructorProjections },
     ...constructorIds.length === 0 ? {} : { constructorIds },
     ...requiredConstructorId2 === null ? {} : { requiredConstructorId: requiredConstructorId2 }
   };
@@ -38821,7 +38719,6 @@ function schemaClassToDocument(schemaClass2) {
       ...parameter4.constraint === null ? {} : { constraint: parameter4.constraint }
     })),
     extendsGenericBindings: schemaClass2.extendsGenericBindings,
-    constructorProjections: schemaClass2.constructorProjections,
     constructorIds: schemaClass2.constructorIds,
     requiredConstructorId: schemaClass2.requiredConstructorId,
     targetMemberId: schemaClass2.targetMemberId
@@ -40256,7 +40153,6 @@ function assertNeoSchemaClass(value, path) {
     [
       "docsText",
       "isSealed",
-      "constructorProjections",
       "constructorIds",
       "requiredConstructorId",
       "allowedStorageKeys"
@@ -40296,18 +40192,6 @@ function assertNeoSchemaClass(value, path) {
   if (type.requiredConstructorId !== void 0) {
     nonEmptyString(type.requiredConstructorId, `${path}.requiredConstructorId`);
   }
-  if (type.constructorProjections !== void 0) {
-    arrayOf(
-      type.constructorProjections,
-      `${path}.constructorProjections`,
-      assertClassConstructorProjection
-    );
-  }
-}
-function assertClassConstructorProjection(value, path) {
-  const projection = objectAt(value, path, ["parameterName", "memberId"]);
-  nonEmptyString(projection.parameterName, `${path}.parameterName`);
-  nonEmptyString(projection.memberId, `${path}.memberId`);
 }
 function assertGenericParameter(value, path) {
   const parameter4 = objectAt(value, path, [
@@ -44226,6 +44110,18 @@ var init_neoscript = __esm({
   }
 });
 
+// ../src/common/collections.ts
+function indexById2(records2) {
+  const indexed = /* @__PURE__ */ new Map();
+  for (const record3 of records2) indexed.set(record3.id, record3);
+  return indexed;
+}
+var init_collections = __esm({
+  "../src/common/collections.ts"() {
+    "use strict";
+  }
+});
+
 // ../src/models/classes/classes.ts
 function isGenericParamConstraint(value) {
   const v = value;
@@ -44275,23 +44171,20 @@ function isGenericBindingsRecord(value) {
   if (Array.isArray(value)) return false;
   return Object.values(value).every(isGenericBinding);
 }
+function hasRetiredConstructorProjectionsTombstone(value) {
+  return value !== null && typeof value === "object" && Object.hasOwn(value, RETIRED_CONSTRUCTOR_PROJECTIONS_FIELD);
+}
 function isNeoSchemaClassBase(value) {
+  if (hasRetiredConstructorProjectionsTombstone(value)) {
+    return false;
+  }
   const v = value;
   return typeof v?.name === "string" && isValidDocsText(v.docsText) && isClassSchema(v?.schema) && isOptionalSchemaKeyOrder(v?.schemaKeyOrder) && (v.implementsInterfaceIds === void 0 || v.implementsInterfaceIds === null || Array.isArray(v.implementsInterfaceIds) && v.implementsInterfaceIds.every(
     (interfaceId) => typeof interfaceId === "string" && interfaceId.length > 0
-  )) && typeof v?.hiddenInMemberSelector === "boolean" && typeof v?.isAbstract === "boolean" && (v.isSealed === void 0 || typeof v.isSealed === "boolean") && (v.allowedStorage === void 0 || v.allowedStorage === null || isEffectiveMemberStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || v.allowedStorageKeys === null || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.genericParams === void 0 || v.genericParams === null || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || v.extendsGenericBindings === null || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorProjections === void 0 || v.constructorProjections === null || Array.isArray(v.constructorProjections) && v.constructorProjections.every(isNeoClassConstructorProjection) && v.system?.kind === SystemProtectionKind.WorldAuthoring) && (v.constructorIds === void 0 || v.constructorIds === null || Array.isArray(v.constructorIds) && v.constructorIds.every(
+  )) && typeof v?.hiddenInMemberSelector === "boolean" && typeof v?.isAbstract === "boolean" && (v.isSealed === void 0 || typeof v.isSealed === "boolean") && (v.allowedStorage === void 0 || v.allowedStorage === null || isEffectiveMemberStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || v.allowedStorageKeys === null || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.genericParams === void 0 || v.genericParams === null || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || v.extendsGenericBindings === null || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorIds === void 0 || v.constructorIds === null || Array.isArray(v.constructorIds) && v.constructorIds.every(
     (constructorId) => typeof constructorId === "string" && constructorId.length > 0
   ) && new Set(v.constructorIds).size === v.constructorIds.length) && (v.requiredConstructorId === void 0 || v.requiredConstructorId === null || typeof v.requiredConstructorId === "string" && v.requiredConstructorId.length > 0 && (v.constructorIds ?? []).length === 0) && (v.targetMemberId === void 0 || v.targetMemberId === null || typeof v.targetMemberId === "string" && v.targetMemberId.length > 0) && (v.system === void 0 || v.system === null || isSystemMetadata(v.system));
 }
-function isNeoClassConstructorProjection(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const projection = value;
-  return Object.keys(projection).every(
-    (key) => key === "parameterName" || key === "memberId"
-  ) && typeof projection.parameterName === "string" && projection.parameterName.length > 0 && typeof projection.memberId === "string" && projection.memberId.length > 0;
-}
 function resolveAllowedStorage(classId, classes, draft) {
   const visited = /* @__PURE__ */ new Set();
   const lookup = (id2) => draft && draft.id === id2 ? draft : classes.find((candidate) => candidate.id === id2);
@@ -44360,12 +44253,15 @@ function isNeoSchemaClassProps(value) {
 function isNeoSchemaClass(value) {
   return isNeoSchemaClassProps(value);
 }
+var RETIRED_CONSTRUCTOR_PROJECTIONS_FIELD;
 var init_classes = __esm({
   "../src/models/classes/classes.ts"() {
     "use strict";
+    init_collections();
     init_core();
     init_docs_text2();
     init_member_storage();
+    RETIRED_CONSTRUCTOR_PROJECTIONS_FIELD = "constructorProjections";
   }
 });
 
@@ -45549,6 +45445,9 @@ function membersById(members) {
   });
   return byId;
 }
+function classIndexFor(classes) {
+  return classesById(classes);
+}
 function createMergeMemo() {
   const byClasses = /* @__PURE__ */ new WeakMap();
   return (classId, classIndex, memberIndex, compute) => {
@@ -45691,8 +45590,9 @@ function findNearestAncestorSchemaPlacement(ownerClass, schemaKey, classesById2)
 function walkExtendsMemberChain(startId, members, pick, options) {
   const requireKind = options?.requireKind;
   const maxHops = options?.maxHops ?? 16;
-  const byId = membersById(members);
-  let cursor = byId.get(startId);
+  const byId = options?.memberById === void 0 ? membersById(members) : null;
+  const getMember = (id2) => options?.memberById?.(id2) ?? byId?.get(id2) ?? null;
+  let cursor = getMember(startId);
   for (let i = 0; cursor && i < maxHops; i++) {
     if (requireKind !== void 0 && cursor.kind !== requireKind) {
       return void 0;
@@ -45701,7 +45601,7 @@ 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 = byId.get(nextId);
+    cursor = getMember(nextId);
   }
   return void 0;
 }
@@ -48337,6 +48237,14 @@ var init_generics = __esm({
 });
 
 // ../src/models/members/instance-provenance.ts
+function overlayLiteralValueContent(base, override) {
+  const merged = { ...base, ...override };
+  if (!("value" in override) || override.value !== null) return merged;
+  for (const field of LITERAL_INSTANCE_IDENTITY_FIELDS) {
+    if (!Object.hasOwn(override, field)) Reflect.deleteProperty(merged, field);
+  }
+  return merged;
+}
 function pickInstanceProvenance(source) {
   return {
     ...source.constructorArgs === void 0 ? {} : { constructorArgs: source.constructorArgs },
@@ -48355,10 +48263,19 @@ function carriesCompleteConstructionRecipe(value) {
   if (typeof value.instanceVariantId === "string") return true;
   return value.constructorArgs !== void 0;
 }
+var LITERAL_INSTANCE_IDENTITY_FIELDS;
 var init_instance_provenance = __esm({
   "../src/models/members/instance-provenance.ts"() {
     "use strict";
     init_member_kinds();
+    LITERAL_INSTANCE_IDENTITY_FIELDS = [
+      "classId",
+      "constructorArgs",
+      "instanceConstructorId",
+      "instanceVariantId",
+      "instanceVariantRowValueId",
+      "genericBindings"
+    ];
   }
 });
 
@@ -50268,6 +50185,85 @@ function recordStorageKeyDeclaration(sink, valueId, member) {
   if (declaration === STORAGE_KEY_INHERIT) return;
   sink.set(valueId, declaration);
 }
+function createDefaultValueResolutionCache() {
+  return {
+    memberByIdIndex: null,
+    instanceEnvironmentByKey: /* @__PURE__ */ new Map(),
+    materializationPlanByClassAndEnvironment: /* @__PURE__ */ new Map(),
+    resolvedMemberById: /* @__PURE__ */ new Map(),
+    storedSchemaByClassId: /* @__PURE__ */ new Map(),
+    validatedInitializerContainers: /* @__PURE__ */ new WeakSet()
+  };
+}
+function withIndexedDefaultValueDocument(document, options = {}) {
+  const cache = options.cache ?? createDefaultValueResolutionCache();
+  if (cache.memberByIdIndex === null && options.memberById === void 0 && document.memberById === void 0) {
+    cache.memberByIdIndex = new Map(
+      document.members.map((member) => [member.id, member])
+    );
+  }
+  const indexed = {
+    ...document,
+    memberById: (id2) => options.memberById?.(id2) ?? document.memberById?.(id2) ?? cache.memberByIdIndex?.get(id2) ?? null,
+    resolvedMember: (member) => {
+      const memberId = "id" in member ? member.id : void 0;
+      if (typeof memberId !== "string") {
+        return resolveMember2(member, document.members);
+      }
+      const cached = cache.resolvedMemberById.get(memberId);
+      if (cached !== void 0) return cached;
+      const resolved = resolveMember2(member, document.members);
+      cache.resolvedMemberById.set(memberId, resolved);
+      return resolved;
+    },
+    storedInstanceSchema: (classId) => {
+      const cached = cache.storedSchemaByClassId.get(classId);
+      if (cached !== void 0) return cached;
+      const schema = mergeStoredInstanceSchema(
+        classId,
+        document.classes,
+        document.members
+      );
+      cache.storedSchemaByClassId.set(classId, schema);
+      return schema;
+    },
+    instanceEnv: (classId, classArguments2) => {
+      const key = `${classId}:${JSON.stringify(classArguments2 ?? null)}`;
+      const cached = cache.instanceEnvironmentByKey.get(key);
+      if (cached !== void 0) return cached;
+      const environment = resolveInstanceEnv(
+        classId,
+        classArguments2,
+        document.classes
+      );
+      cache.instanceEnvironmentByKey.set(key, environment);
+      return environment;
+    },
+    isInitValueContent: (value) => {
+      if (typeof value !== "object" || value === null) return false;
+      if (cache.validatedInitializerContainers.has(value)) return true;
+      if (!isInitValueContent(value)) return false;
+      cache.validatedInitializerContainers.add(value);
+      return true;
+    },
+    createValueRow: options.createValueRow ?? document.createValueRow
+  };
+  indexed.storedInstanceMaterializationPlan = (classId, environment) => {
+    let byEnvironment = cache.materializationPlanByClassAndEnvironment.get(classId);
+    const cached = byEnvironment?.get(environment);
+    if (cached !== void 0) return cached;
+    const plan = buildDefaultClassMaterializationPlan(
+      indexed,
+      classId,
+      environment
+    );
+    byEnvironment ??= /* @__PURE__ */ new WeakMap();
+    byEnvironment.set(environment, plan);
+    cache.materializationPlanByClassAndEnvironment.set(classId, byEnvironment);
+    return plan;
+  };
+  return indexed;
+}
 function documentHasInitValueContent(document, value) {
   return document.isInitValueContent?.(value) ?? isInitValueContent(value);
 }
@@ -56778,6 +56774,7 @@ var init_common = __esm({
   "../src/common/index.ts"() {
     "use strict";
     init_benchmark();
+    init_collections();
     init_error_message();
     init_retree_input_diagnostics();
   }
@@ -59713,7 +59710,6 @@ function lowerClass(context, declaration) {
       extendsClassId,
       declaration.baseTypes[0].arguments
     ) : base?.extendsGenericBindings ?? {},
-    ...base?.constructorProjections === void 0 ? {} : { constructorProjections: base.constructorProjections },
     // P43 §6.3/§6.4: declaration order is the only ordering state, and a
     // constructor carries no schema key, so it never enters schemaKeyOrder.
     ...declaration.constructors.length === 0 ? {} : {
@@ -63260,8 +63256,7 @@ function classToLanguageType(schemaClass2, context) {
 }
 function constructorSignature(schemaClass2, members, context, genericEnvironment) {
   if (schemaClass2.isAbstract) return {};
-  const projections = inheritedConstructorProjections(schemaClass2, context);
-  if (projections.length === 0 && !isClosedClass(schemaClass2.id, context.vm.classes)) {
+  if (!isClosedClass(schemaClass2.id, context.vm.classes)) {
     return {};
   }
   if (resolveAllowedStorage(schemaClass2.id, context.vm.classes) === "immutable" /* Immutable */) {
@@ -63282,9 +63277,7 @@ function constructorSignature(schemaClass2, members, context, genericEnvironment
             defaultValue: "defaultValue" in resolved ? resolved.defaultValue : void 0
           };
         } catch {
-          return projections.some(
-            (projection) => projection.memberId === memberId
-          ) ? { required: true } : null;
+          return null;
         }
       }
     );
@@ -63310,43 +63303,11 @@ function constructorSignature(schemaClass2, members, context, genericEnvironment
           defaultValue: "defaultValue" in resolved ? resolved.defaultValue : void 0
         };
       } catch {
-        if (projections.some((projection) => projection.memberId === memberId)) {
-          return { required: true };
-        }
         return null;
       }
     }
   );
-  return {
-    constructorSignature: {
-      ...signature,
-      ...projections.length === 0 ? {} : {
-        namedProjections: projections.map((projection) => ({
-          name: projection.parameterName,
-          memberId: projection.memberId
-        }))
-      }
-    }
-  };
-}
-function inheritedConstructorProjections(schemaClass2, context) {
-  const classesById2 = new Map(
-    context.vm.classes.map((candidate) => [candidate.id, candidate])
-  );
-  const projections = [];
-  const claimed = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  let current = schemaClass2;
-  while (current !== void 0 && !visited.has(current.id)) {
-    visited.add(current.id);
-    for (const projection of current.constructorProjections ?? []) {
-      if (claimed.has(projection.parameterName)) continue;
-      claimed.add(projection.parameterName);
-      projections.push(projection);
-    }
-    current = current.extendsClassId ? classesById2.get(current.extendsClassId) : void 0;
-  }
-  return projections;
+  return { constructorSignature: signature };
 }
 function declaredConstructors(schemaClass2, context) {
   const requiredConstructorId2 = schemaClass2.requiredConstructorId;
@@ -64467,7 +64428,7 @@ var init_neoscript_language_context_adapter = __esm({
     init_project_root_members();
     init_project_file_registry();
     init_analyzer_types();
-    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 2;
+    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 3;
     UNKNOWN_TYPE2 = {
       kind: "primitive",
       name: "unknown"
@@ -65932,7 +65893,11 @@ function resolveSemanticOwnerMembersForValues(document, targetValueIds, addition
     }
     return result;
   }
-  const graph = new MaterializedValueGraphContext(document);
+  const graph = new MaterializedValueGraphContext(
+    document,
+    new Map(document.values.map((value) => [value.id, value])),
+    new Map((additionalRoots ?? []).map((root) => [root.valueId, root.member]))
+  );
   const allValueIds = new Set(graph.valuesById.keys());
   const semanticRoots = [
     ...additionalRoots ?? []
@@ -65994,7 +65959,7 @@ function resolveSemanticOwnerMembersForValues(document, targetValueIds, addition
   }
   return result;
 }
-function createTypedValueNormalizer(rows, document, childrenByContainerId, parameterTypesForRow, memberById2, memberTypeInfo) {
+function createTypedValueNormalizer(rows, document, childrenByContainerId, parameterTypesForRow, memberById2, memberTypeInfo, genericEnvironmentForRow) {
   const visiting = /* @__PURE__ */ new Set();
   const normalizeLiteral = (value) => {
     if (Array.isArray(value)) return value.map(normalizeLiteral);
@@ -66047,7 +66012,7 @@ function createTypedValueNormalizer(rows, document, childrenByContainerId, param
       ...typeof row.classId === "string" ? { classId: row.classId } : {},
       ...row.genericBindings === void 0 ? {} : { genericBindings: row.genericBindings },
       value,
-      ...isLiteralValueContent(row) && row.constructorArgs !== void 0 && row.constructorArgs !== null ? {
+      ...carriesSemanticConstructorArguments(row) ? {
         constructorArgs: normalizeConstructorArgs(row.constructorArgs, row)
       } : {}
     };
@@ -66067,18 +66032,24 @@ function createTypedValueNormalizer(rows, document, childrenByContainerId, param
       // the row's payload. Keep those strings literal instead of guessing
       // that UUID-shaped values are further row references.
       value: normalizeLiteral(row.value),
-      ...isLiteralValueContent(row) && row.constructorArgs !== void 0 && row.constructorArgs !== null ? {
+      ...carriesSemanticConstructorArguments(row) ? {
         constructorArgs: normalizeConstructorArgs(row.constructorArgs, row)
       } : {}
     };
     visiting.delete(valueId);
     return normalized;
   };
+  function carriesSemanticConstructorArguments(row) {
+    if (!isLiteralValueContent(row)) return false;
+    const constructorArgs = row.constructorArgs;
+    if (constructorArgs === void 0 || constructorArgs === null) return false;
+    return typeof row.instanceConstructorId === "string" || Object.keys(constructorArgs).length > 0;
+  }
   const normalizeClassValue = (row, typeInfo) => {
     if (!isStringRecord4(row.value)) return normalizeLiteral(row.value);
     const effectiveClassId = row.classId ?? (typeInfo.type === 7 /* Class */ ? typeInfo.classId : void 0);
     if (effectiveClassId === void 0) return normalizeLiteral(row.value);
-    const env = rowGenericEnvironment(document, row);
+    const env = genericEnvironmentForRow(row);
     const merged = mergeStoredInstanceSchema(
       effectiveClassId,
       document.classes,
@@ -66213,8 +66184,12 @@ function collectSoftOwnedConstructorArgumentValueIds(index, ownerValueId, preser
   }
   return collected;
 }
-function rowGenericEnvironment(document, row) {
-  const env = typeof row.classId === "string" ? resolveInstanceEnv(row.classId, void 0, document.classes) : /* @__PURE__ */ new Map();
+function rowGenericEnvironment(document, row, contextualRootMember) {
+  const env = typeof row.classId === "string" ? resolveInstanceEnv(
+    row.classId,
+    contextualRootMember !== void 0 && isMemberClassBase(contextualRootMember) ? contextualRootMember.classArguments : void 0,
+    document.classes
+  ) : /* @__PURE__ */ new Map();
   for (const [paramId, binding] of envFromStamp(row.genericBindings)) {
     env.set(paramId, binding);
   }
@@ -66299,6 +66274,7 @@ var init_constructor_argument_ownership = __esm({
       classesById;
       membersById;
       constructorsById;
+      contextualRootMembersByValueId;
       parameterTypesByValueId = /* @__PURE__ */ new Map();
       settleConstructorParameter;
       aggregateTypeByTargetValueId = /* @__PURE__ */ new Map();
@@ -66306,9 +66282,10 @@ var init_constructor_argument_ownership = __esm({
       ownership;
       constructor(document, rows = new Map(
         document.values.map((value) => [value.id, value])
-      )) {
+      ), contextualRootMembersByValueId = /* @__PURE__ */ new Map()) {
         this.valuesById = rows;
         this.document = { ...document, values: [...rows.values()] };
+        this.contextualRootMembersByValueId = contextualRootMembersByValueId;
         this.classesById = new Map(
           document.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
         );
@@ -66367,7 +66344,7 @@ var init_constructor_argument_ownership = __esm({
         if (constructor2 === void 0 || constructor2.classId !== root.classId) {
           return result;
         }
-        const env = rowGenericEnvironment(this.document, root);
+        const env = this.genericEnvironmentForRow(root);
         for (let index = 0; index < constructor2.argumentTypes.length; index += 1) {
           const parameterId = constructorActionParameterId(constructor2, index);
           const rawTypeInfo = constructor2.argumentTypes[index];
@@ -66427,7 +66404,7 @@ var init_constructor_argument_ownership = __esm({
             ...settled,
             member: substituteMember(
               member,
-              rowGenericEnvironment(this.document, owner),
+              this.genericEnvironmentForRow(owner),
               this.document.members
             )
           };
@@ -66487,7 +66464,8 @@ var init_constructor_argument_ownership = __esm({
             return resolved;
           },
           (memberId) => this.membersById.get(memberId),
-          (member, env) => this.memberTypeInfo(member, env)
+          (member, env) => this.memberTypeInfo(member, env),
+          (row) => this.genericEnvironmentForRow(row)
         );
       }
       ownerForValue(valueId) {
@@ -66577,7 +66555,8 @@ var init_constructor_argument_ownership = __esm({
           this.childrenByContainerId,
           (row) => this.constructorParameterTypes(row),
           (memberId) => this.membersById.get(memberId),
-          (member, env) => this.memberTypeInfo(member, env)
+          (member, env) => this.memberTypeInfo(member, env),
+          (row) => this.genericEnvironmentForRow(row)
         );
         return this.typedNormalizer;
       }
@@ -66599,6 +66578,13 @@ var init_constructor_argument_ownership = __esm({
         }
         return rawTypeInfo;
       }
+      genericEnvironmentForRow(row) {
+        return rowGenericEnvironment(
+          this.document,
+          row,
+          this.contextualRootMembersByValueId.get(row.id)
+        );
+      }
       memberTypeInfo(rawMember, env) {
         try {
           const member = substituteMember(rawMember, env, this.document.members);
@@ -67280,7 +67266,121 @@ function validateInternalRecordRelations(args) {
   });
 }
 function resolveEffectiveClassRelations(args) {
-  const contract = (args.contracts ?? INTERNAL_RECORD_RELATION_KIND_CONTRACTS).find((candidate) => candidate.relationKind === args.relationKind);
+  return createEffectiveClassRelationResolver({
+    classes: args.classes,
+    relations: args.relations,
+    contracts: args.contracts
+  }).resolve(args.relationKind, args.sourceClassId);
+}
+function createEffectiveClassRelationResolver(args) {
+  const contracts = args.contracts ?? INTERNAL_RECORD_RELATION_KIND_CONTRACTS;
+  const contractsByKind = /* @__PURE__ */ new Map();
+  for (const contract of contracts) {
+    contractsByKind.set(contract.relationKind, contract);
+  }
+  const classesById2 = args.classesById ?? classIndexFor(args.classes);
+  const classRelationsByKind = /* @__PURE__ */ new Map();
+  const relationsByIdByKind = /* @__PURE__ */ new Map();
+  const directByKindAndSource = /* @__PURE__ */ new Map();
+  for (const relation of args.relations) {
+    if (relation.sourceRecordKind !== "class" || relation.targetRecordKind !== "class") {
+      continue;
+    }
+    const relations = classRelationsByKind.get(relation.relationKind);
+    if (relations === void 0) {
+      classRelationsByKind.set(relation.relationKind, [relation]);
+    } else relations.push(relation);
+  }
+  const relationById = (relationKind, id2) => {
+    let byId = relationsByIdByKind.get(relationKind);
+    if (byId === void 0) {
+      byId = indexById2(classRelationsByKind.get(relationKind) ?? []);
+      relationsByIdByKind.set(relationKind, byId);
+    }
+    return byId.get(id2);
+  };
+  const ancestryByClassId = /* @__PURE__ */ new Map();
+  const concreteDescendantsByClassId = /* @__PURE__ */ new Map();
+  const childrenByClassId = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of args.classes) {
+    if (schemaClass2.extendsClassId === void 0) continue;
+    const children = childrenByClassId.get(schemaClass2.extendsClassId);
+    if (children === void 0) {
+      childrenByClassId.set(schemaClass2.extendsClassId, [schemaClass2.id]);
+    } else {
+      children.push(schemaClass2.id);
+    }
+  }
+  const ancestry = (classId) => {
+    const cached = ancestryByClassId.get(classId);
+    if (cached !== void 0) return cached;
+    const resolved = classAncestry(classId, classesById2);
+    ancestryByClassId.set(classId, resolved);
+    return resolved;
+  };
+  const concreteDescendants = (classId) => {
+    const cached = concreteDescendantsByClassId.get(classId);
+    if (cached !== void 0) return cached;
+    if (!classesById2.has(classId)) return [];
+    const result = [];
+    const pending = [classId];
+    const visited = /* @__PURE__ */ new Set();
+    while (pending.length > 0) {
+      const candidateId = pending.pop();
+      if (visited.has(candidateId)) {
+        throw new Error(
+          `Class inheritance contains a cycle at "${candidateId}".`
+        );
+      }
+      visited.add(candidateId);
+      const candidate = classesById2.get(candidateId);
+      if (candidate !== void 0 && !candidate.isAbstract) {
+        result.push(candidate.id);
+      }
+      for (const childId of childrenByClassId.get(candidateId) ?? []) {
+        pending.push(childId);
+      }
+    }
+    result.sort((left, right) => left.localeCompare(right));
+    concreteDescendantsByClassId.set(classId, result);
+    return result;
+  };
+  const directClassRelations = (relationKind, sourceClassId) => {
+    let bySource = directByKindAndSource.get(relationKind);
+    if (bySource === void 0) {
+      bySource = /* @__PURE__ */ new Map();
+      for (const relation of classRelationsByKind.get(relationKind) ?? []) {
+        const declarations = bySource.get(relation.sourceRecordId);
+        if (declarations === void 0) {
+          bySource.set(relation.sourceRecordId, [relation]);
+        } else declarations.push(relation);
+      }
+      directByKindAndSource.set(relationKind, bySource);
+    }
+    return bySource.get(sourceClassId) ?? [];
+  };
+  const resolve5 = (relationKind, sourceClassId) => {
+    const contract = contractsByKind.get(relationKind);
+    return resolveEffectiveClassRelationsFromIndex({
+      relationKind,
+      sourceClassId,
+      contract,
+      ancestry,
+      concreteDescendants,
+      directClassRelations
+    });
+  };
+  return {
+    classesById: classesById2,
+    relationById,
+    directClassRelations,
+    classAncestry: ancestry,
+    concreteClassDescendants: concreteDescendants,
+    resolve: resolve5
+  };
+}
+function resolveEffectiveClassRelationsFromIndex(args) {
+  const contract = args.contract;
   if (contract === void 0) {
     throw new Error(`Unknown internal relation kind "${args.relationKind}".`);
   }
@@ -67292,15 +67392,12 @@ function resolveEffectiveClassRelations(args) {
       `Internal relation kind "${args.relationKind}" is not class-to-class.`
     );
   }
-  const classesById2 = new Map(
-    args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
-  );
-  const sourceIds = contract.sourceClassPolicy === "include-descendants" ? classAncestry(args.sourceClassId, classesById2) : [args.sourceClassId];
+  const sourceIds = contract.sourceClassPolicy === "include-descendants" ? args.ancestry(args.sourceClassId) : [args.sourceClassId];
   const sourceDepth = new Map(
     sourceIds.map((sourceId3, index) => [sourceId3, index])
   );
-  const declarations = args.relations.filter(
-    (relation) => relation.relationKind === args.relationKind && relation.sourceRecordKind === "class" && relation.targetRecordKind === "class" && sourceDepth.has(relation.sourceRecordId)
+  const declarations = sourceIds.flatMap(
+    (sourceId3) => args.directClassRelations(args.relationKind, sourceId3)
   );
   if (contract.merge === "nearest-single") {
     const sorted = declarations.sort(
@@ -67322,11 +67419,7 @@ function resolveEffectiveClassRelations(args) {
   const byTarget = /* @__PURE__ */ new Map();
   for (const declaration of declarations) {
     const declarationDepth = sourceDepth.get(declaration.sourceRecordId) ?? 0;
-    const targetIds = contract.targetClassPolicy === "include-descendants" ? concreteClassDescendants(
-      declaration.targetRecordId,
-      args.classes,
-      classesById2
-    ) : [declaration.targetRecordId];
+    const targetIds = contract.targetClassPolicy === "include-descendants" ? args.concreteDescendants(declaration.targetRecordId) : [declaration.targetRecordId];
     for (const targetId of targetIds) {
       const current = byTarget.get(targetId);
       if (current === void 0) {
@@ -67523,12 +67616,6 @@ function classAncestry(classId, classesById2) {
   }
   return result;
 }
-function concreteClassDescendants(classId, classes, classesById2) {
-  if (!classesById2.has(classId)) return [];
-  return classes.filter(
-    (candidate) => !candidate.isAbstract && classAncestry(candidate.id, classesById2).includes(classId)
-  ).map((candidate) => candidate.id).sort((left, right) => left.localeCompare(right));
-}
 function effectiveRelation(relation, targetRecordId, sourceAncestryDepth) {
   return {
     relationKind: relation.relationKind,
@@ -67560,7 +67647,9 @@ var InternalRecordRelationKind, INTERNAL_RECORD_RELATION_KIND_CONTRACTS;
 var init_internal_record_relations = __esm({
   "../src/models/project/internal-record-relations.ts"() {
     "use strict";
+    init_collections();
     init_classes();
+    init_inheritance();
     init_core();
     init_project_version_types();
     InternalRecordRelationKind = {
@@ -67716,6 +67805,7 @@ function makeEvaluatorLookups(members, values, options = {}) {
   const lookups = {
     memberById: (id2) => attrMap.get(id2) ?? null,
     valueById: (id2) => valMap.get(id2) ?? null,
+    hasStoredValueId: (id2) => valMap.has(id2),
     unorderedListEntryIds: (containerValueId) => unorderedListMembership.get(containerValueId) ?? [],
     // An index over a plain row set has no virtual expansion: every row it
     // can answer with is already in `values`.
@@ -67747,9 +67837,20 @@ function evalMemberById(vm, id2) {
 function evalValueById(ctx, id2, runtimeValues, overlayValues) {
   const vm = ctx.vm;
   const runtime = runtimeValues?.get(id2);
-  if (runtime !== void 0) return runtime;
+  if (runtime !== void 0) {
+    if (vm.databaseVM?.hasStoredValueId?.(id2) ?? true) {
+      ctx.valueDependencies?.add(id2);
+    }
+    return runtime;
+  }
   const overlay = overlayValues?.get(id2);
-  if (overlay !== void 0) return overlay;
+  if (overlay !== void 0) {
+    if (vm.databaseVM?.hasStoredValueId?.(id2) ?? true) {
+      ctx.valueDependencies?.add(id2);
+    }
+    return overlay;
+  }
+  ctx.valueDependencies?.add(id2);
   if (vm.databaseVM?.valueById) return vm.databaseVM.valueById(id2);
   return vm.values.find((v) => v.id === id2) ?? null;
 }
@@ -68159,6 +68260,9 @@ function resolveRuntimeReferenceRow(sourceValueId, ctx, withProvenance) {
   if (!withProvenance) return direct;
   const receiver = trackedRowForValueReference(ctx.thisValue, ctx);
   if (receiver === null) return direct;
+  ctx.onUnattributableValueRead?.(
+    `runtime-reference-provenance:${sourceValueId}`
+  );
   const indexes = evaluatorIndexes(ctx);
   const virtualRows = ctx.vm.databaseVM?.virtualInstanceRowsForValue(receiver.id) ?? [];
   if (virtualRows.length > 0) {
@@ -68265,12 +68369,8 @@ function evaluatorResolutionCache(ctx) {
     compiledFunctionByMemberId: /* @__PURE__ */ new Map(),
     compiledGetterByMemberId: /* @__PURE__ */ new Map(),
     compiledSetterByMemberId: /* @__PURE__ */ new Map(),
-    resolvedMemberById: /* @__PURE__ */ new Map(),
-    storedInstanceSchemaByClassId: /* @__PURE__ */ new Map(),
-    instanceEnvByKey: /* @__PURE__ */ new Map(),
+    defaultValueResolutionCache: createDefaultValueResolutionCache(),
     validatedConstructorDescriptorByInfo: /* @__PURE__ */ new WeakMap(),
-    validatedInitValueContents: /* @__PURE__ */ new WeakSet(),
-    storedInstanceMaterializationPlanByClassAndEnv: /* @__PURE__ */ new Map(),
     effectiveStorageResolver: void 0
   };
   resolutionCacheByMembers.set(members, {
@@ -68283,37 +68383,31 @@ function evaluatorResolutionCache(ctx) {
   return cache;
 }
 function cachedResolvedMember(member, ctx) {
-  const memberId = member.id;
-  if (typeof memberId !== "string") {
-    return resolveMember2(member, ctx.vm.members);
-  }
-  const cache = evaluatorResolutionCache(ctx).resolvedMemberById;
-  const cached = cache.get(memberId);
-  if (cached !== void 0) return cached;
-  const resolved = resolveMember2(member, ctx.vm.members);
-  cache.set(memberId, resolved);
-  return resolved;
+  return evaluatorDefaultValueDocument(ctx).resolvedMember(member);
 }
 function cachedStoredInstanceSchema(classId, ctx) {
-  const cache = evaluatorResolutionCache(ctx).storedInstanceSchemaByClassId;
-  const cached = cache.get(classId);
-  if (cached !== void 0) return cached;
-  const merged = mergeStoredInstanceSchema(
+  return evaluatorDefaultValueDocument(ctx).storedInstanceSchema(classId);
+}
+function cachedStoredInstanceMaterializationPlan(classId, instanceEnv, ctx) {
+  return evaluatorDefaultValueDocument(ctx).storedInstanceMaterializationPlan(
     classId,
-    ctx.vm.classes,
-    ctx.vm.members
+    instanceEnv
   );
-  cache.set(classId, merged);
-  return merged;
 }
-function cachedStoredInstanceMaterializationPlan(classId, instanceEnv, ctx) {
-  const cache = evaluatorResolutionCache(
-    ctx
-  ).storedInstanceMaterializationPlanByClassAndEnv;
-  let byEnvironment = cache.get(classId);
-  const cached = byEnvironment?.get(instanceEnv);
-  if (cached !== void 0) return cached;
-  const plan = buildDefaultClassMaterializationPlan(
+function cachedInstanceEnv(classId, classArguments2, ctx) {
+  return evaluatorDefaultValueDocument(ctx).instanceEnv(
+    classId,
+    classArguments2
+  );
+}
+function cachedIsInitValueContent(value, ctx) {
+  return evaluatorDefaultValueDocument(ctx).isInitValueContent(value);
+}
+function evaluatorDefaultValueDocument(ctx) {
+  if (ctx.__defaultValueDocument !== void 0) {
+    return ctx.__defaultValueDocument;
+  }
+  const document = withIndexedDefaultValueDocument(
     {
       project: ctx.vm.project,
       members: ctx.vm.members,
@@ -68322,37 +68416,13 @@ function cachedStoredInstanceMaterializationPlan(classId, instanceEnv, ctx) {
       values: ctx.vm.values,
       memberById: ctx.vm.databaseVM?.memberById,
       valueById: ctx.vm.databaseVM?.valueById,
-      resolvedMember: (member) => cachedResolvedMember(member, ctx),
-      storedInstanceSchema: (nestedClassId) => cachedStoredInstanceSchema(nestedClassId, ctx),
-      instanceEnv: (nestedClassId, classArguments2) => cachedInstanceEnv(nestedClassId, classArguments2, ctx),
-      isInitValueContent: (value) => cachedIsInitValueContent(value, ctx),
       projectFiles: ctx.vm.projectFiles ?? [],
       textureTemplates: ctx.vm.textureTemplates ?? []
     },
-    classId,
-    instanceEnv
+    { cache: evaluatorResolutionCache(ctx).defaultValueResolutionCache }
   );
-  byEnvironment ??= /* @__PURE__ */ new WeakMap();
-  byEnvironment.set(instanceEnv, plan);
-  cache.set(classId, byEnvironment);
-  return plan;
-}
-function cachedInstanceEnv(classId, classArguments2, ctx) {
-  const key = `${classId}:${JSON.stringify(classArguments2 ?? null)}`;
-  const cache = evaluatorResolutionCache(ctx).instanceEnvByKey;
-  const cached = cache.get(key);
-  if (cached !== void 0) return cached;
-  const resolved = resolveInstanceEnv(classId, classArguments2, ctx.vm.classes);
-  cache.set(key, resolved);
-  return resolved;
-}
-function cachedIsInitValueContent(value, ctx) {
-  if (typeof value !== "object" || value === null) return false;
-  const cache = evaluatorResolutionCache(ctx).validatedInitValueContents;
-  if (cache.has(value)) return true;
-  if (!isInitValueContent(value)) return false;
-  cache.add(value);
-  return true;
+  ctx.__defaultValueDocument = document;
+  return document;
 }
 function sessionCreationCheckpoint(ctx) {
   if (ctx.__sessionCreationStrategy === "snapshot") {
@@ -68799,6 +68869,9 @@ function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, r
             }
           }
         }
+        ctx.onUnattributableValueRead?.(
+          `constructor-argument-list:${argumentId}`
+        );
         for (const candidate of evaluatorValues(ctx)) {
           if (candidate.containerId === argumentId) {
             scanCreationDataRow({
@@ -68856,6 +68929,7 @@ function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, r
     if (member !== null && isMemberListBase(member)) {
       const entryMember = evalMemberById(ctx.vm, member.entryMemberId);
       if (member.listKind === "unordered") {
+        ctx.onUnattributableValueRead?.(`constructed-unordered-list:${row.id}`);
         for (const candidate of evaluatorValues(ctx)) {
           if (candidate.containerId === row.id) {
             scanOwnedRow(candidate.id, entryMember);
@@ -69150,6 +69224,11 @@ function parameterDefaultsAsFullArguments(argumentTypes, subject) {
   if (!argumentTypes.every(parameterHasDefault)) return null;
   return fillTrailingParameterDefaults([], argumentTypes, subject);
 }
+function declarationInitializerArgumentValues(argumentTypes, subject, readsConstructorParameter) {
+  const defaults = parameterDefaultsAsFullArguments(argumentTypes, subject);
+  if (defaults !== null) return defaults;
+  return readsConstructorParameter ? [] : argumentTypes.map(() => null);
+}
 function fillCallableCallSiteArguments(args, member, ctx) {
   if (member === null) return args;
   if (member.kind !== 13 /* Function */ && member.kind !== 23 /* NSFunction */) {
@@ -70302,6 +70381,7 @@ function staticBindingTargetId(member, ctx) {
       `Member '${member.name}' is not a static member.`
     );
   }
+  ctx.staticMemberDependencies?.add(member.id);
   const storage = effectiveStaticStorage(member.id, ctx);
   const bindings = storage === "save" /* Save */ ? ctx.__saveStaticBindings : storage === "session" /* Session */ ? ctx.__sessionStaticBindings : void 0;
   if (bindings?.has(member.id)) return bindings.get(member.id) ?? null;
@@ -70349,7 +70429,6 @@ function evalStaticMember(memberId, ctx) {
       `Static member '${member.name}' is bound to missing value '${targetId}'.`
     );
   }
-  ctx.valueDependencies?.add(row.id);
   return row.value;
 }
 function evalPointer(pointer, scope, ctx) {
@@ -70958,6 +71037,7 @@ function delegateClosureLexicalThis(closure, ctx) {
       "Stored NeoDelegate closure has no resolvable value row; lexical this cannot be reconstructed from ownership."
     );
   }
+  ctx.onUnattributableValueRead?.(`delegate-owner-resolution:${closureRow.id}`);
   const owners = [];
   const indexes = evaluatorIndexes(ctx);
   for (const [ancestorId, distance] of evaluatorOwnershipDistances(
@@ -71118,6 +71198,7 @@ function runtimeGenericEnvForValueRow(row, ctx, visited) {
 }
 function runtimeParentGenericEnv(row, ctx, visited) {
   const result = /* @__PURE__ */ new Map();
+  ctx.onUnattributableValueRead?.(`generic-parent-resolution:${row.id}`);
   for (const link of evaluatorParentLinks(evaluatorIndexes(ctx), row.id)) {
     const parent = evalValueById(
       ctx,
@@ -71691,7 +71772,7 @@ function evalKeyOf(keyOf, scope, ctx, optional = false, memberId, onReceiver) {
     if (dispatched.kind === "ok") return dispatched.value;
     if (!dispatched.matchedMember && memberId !== void 0) {
       const member = evalMemberById(ctx.vm, memberId);
-      const defaultValue = readOnlyDeclarationDefault(member, memberId, ctx);
+      const defaultValue = readOnlyDeclarationDefault(member, ctx);
       if (defaultValue.matched) return defaultValue.value;
     }
     if (Object.prototype.hasOwnProperty.call(receiver, k)) {
@@ -71714,8 +71795,6 @@ function dispatchSchemaMember(receiver, schemaKey, ctx) {
   }
   const member = resolveRuntimeSchemaMember(receiver, schemaKey, ctx);
   if (!member) return { kind: "no-info", matchedMember: false };
-  const defaultValue = readOnlyDeclarationDefault(member, member.id, ctx);
-  if (defaultValue.matched) return { kind: "ok", value: defaultValue.value };
   if (member.kind === 10 /* NSProperty */) {
     if (!resolveCompiledGetter(member.id, ctx)) {
       return { kind: "no-info", matchedMember: true };
@@ -71725,6 +71804,8 @@ function dispatchSchemaMember(receiver, schemaKey, ctx) {
       value: dispatchNSGetterById(member.id, receiver, ctx)
     };
   }
+  const defaultValue = readOnlyDeclarationDefault(member, ctx);
+  if (defaultValue.matched) return { kind: "ok", value: defaultValue.value };
   if (!Object.prototype.hasOwnProperty.call(receiver, schemaKey)) {
     const expanded = virtualExpandedRecordForReceiver(receiver, ctx);
     if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, schemaKey)) {
@@ -71756,13 +71837,11 @@ function virtualExpandedRecordForReceiver(receiver, ctx) {
   }
   return record3;
 }
-function readOnlyDeclarationDefault(member, memberId, ctx) {
+function readOnlyDeclarationDefault(member, ctx) {
   const readOnly = member?.isReadOnly;
   if (readOnly !== true) return { matched: false };
   if (member?.defaultValue === void 0 || member.defaultValue === null) {
-    throw new NSGetterRuntimeError(
-      `Read-only member '${member?.name ?? memberId}' has no declaration default.`
-    );
+    return { matched: false };
   }
   let value = member.defaultValue.value;
   if (isMemberString(member) && member.localizable !== false && typeof value === "string") {
@@ -71833,7 +71912,6 @@ function resolveValueIfId(at, ctx) {
     ctx.__valueOverlay
   );
   if (!row) return at;
-  ctx.valueDependencies?.add(row.id);
   const member = memberForValueRow(row, ctx);
   if (member !== null && isMemberListBase(member) && member.listKind === "unordered" && Array.isArray(row.value)) {
     return evaluatorUnorderedListEntryIds(row.id, ctx);
@@ -71850,7 +71928,6 @@ function resolveValueIfIdForMember(at, member, ctx) {
     ctx.__valueOverlay
   );
   if (!row) return at;
-  ctx.valueDependencies?.add(row.id);
   if (isMemberListBase(member) && member.listKind === "unordered" && Array.isArray(row.value)) {
     return evaluatorUnorderedListEntryIds(row.id, ctx);
   }
@@ -71858,6 +71935,7 @@ function resolveValueIfIdForMember(at, member, ctx) {
   return shouldUnwrapSingleLookupValue(member) ? unwrapSingleLookupValue(value, ctx) : value;
 }
 function evaluatorUnorderedListEntryIds(containerValueId, ctx) {
+  ctx.containerDependencies?.add(containerValueId);
   const runtimeRows = [...ctx.__runtimeSessionValues?.values() ?? []];
   const overlayRows = [...ctx.__valueOverlay?.values() ?? []];
   const localRows = [...runtimeRows, ...overlayRows];
@@ -71883,7 +71961,6 @@ function unwrapSingleLookupValue(value, ctx) {
       ctx.__valueOverlay
     );
     if (next) {
-      ctx.valueDependencies?.add(next.id);
       return next.value;
     }
   }
@@ -71924,6 +72001,7 @@ function resolveMemberForValueRow(row, ctx, visited) {
   if (syntheticMemberId !== null) {
     return evalMemberById(ctx.vm, syntheticMemberId);
   }
+  ctx.onUnattributableValueRead?.(`member-owner-resolution:${row.id}`);
   for (const link of evaluatorParentLinks(indexes, row.id)) {
     const parent = evalValueById(
       ctx,
@@ -71988,13 +72066,11 @@ function memberIdFromSyntheticDefaultValueId(valueId) {
   return valueId.slice(prefix.length, -suffix.length);
 }
 function resolveLocalizedTextId(value, ctx) {
+  ctx.localizedTextDependencies?.add(value);
   const mainLocale = ctx.vm.localizationConfig?.mainLocale;
   if (mainLocale === void 0) return value;
-  const text = ctx.vm.localizedTexts?.find(
-    (candidate) => candidate.id === value
-  );
-  if (text === void 0) return value;
-  ctx.localizedTextDependencies?.add(text.id);
+  const text = ctx.vm.databaseVM?.localizedTextById?.(value) ?? ctx.vm.localizedTexts?.find((candidate) => candidate.id === value) ?? null;
+  if (text === null) return value;
   return text.localeValues[mainLocale]?.value ?? "";
 }
 function evalOperation(operation, scope, ctx) {
@@ -73435,6 +73511,7 @@ function bindConstructedDelegateTargets(createdValues, ctx) {
         `NeoDelegate method target '${target.name}' has no declaring Class placement.`
       );
     }
+    ctx.onUnattributableValueRead?.(`constructed-delegate-owner:${row.id}`);
     const matches = [];
     for (const [ancestorId, distance] of evaluatorOwnershipDistances(
       row.id,
@@ -74113,7 +74190,7 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
   return (member, init, sourceValueId) => {
     const memberId = Reflect.get(member, "id");
     const effectiveMemberId = typeof memberId === "string" ? memberId : null;
-    const scopeMemberId = indexes.initializerScopeMemberIds.get(init) ?? effectiveMemberId;
+    const scopeMemberId = indexes.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? effectiveMemberId;
     const compiled = ensureInitializerCompiled({
       init,
       member,
@@ -74182,8 +74259,20 @@ function constructorInitializerIndexes(ctx) {
   ctx.__constructorInitializerIndexes = built;
   return built;
 }
+function constructorById(constructorId, ctx) {
+  if (ctx.__constructorById === void 0) {
+    ctx.__constructorById = new Map(
+      (ctx.vm.constructors ?? []).map((constructor2) => [
+        constructor2.id,
+        constructor2
+      ])
+    );
+  }
+  return ctx.__constructorById.get(constructorId);
+}
 function buildConstructorInitializerIndexes(vm) {
   const initializerScopeMemberIds = /* @__PURE__ */ new WeakMap();
+  const initializerScopeMemberIdsByValueId = /* @__PURE__ */ new Map();
   const initializerByValueId = /* @__PURE__ */ new Map();
   for (const row of vm.values) {
     const initializer = Reflect.get(row, "init");
@@ -74214,8 +74303,12 @@ function buildConstructorInitializerIndexes(vm) {
     );
     if (typeof rootOwnerId === "string") {
       initializerScopeMemberIds.set(initializer, rootOwnerId);
+      initializerScopeMemberIdsByValueId.set(valueId, rootOwnerId);
     }
   }
+  const classById = new Map(
+    vm.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
   const declaringClassIdsByMemberId = /* @__PURE__ */ new Map();
   for (const schemaClass2 of vm.classes) {
     for (const memberId of Object.values(schemaClass2.schema)) {
@@ -74233,6 +74326,8 @@ function buildConstructorInitializerIndexes(vm) {
   }
   return {
     initializerScopeMemberIds,
+    initializerScopeMemberIdsByValueId,
+    classById,
     declaringClassIdsByMemberId,
     memberById: memberById2,
     containerMemberIdByEntryId
@@ -74460,6 +74555,12 @@ function recordConstructorGroupDependency(valueId, destination, ctx) {
 }
 function encodeRequiredConstructorArgument(args) {
   const trackedId = findKnownRowIdByValueReference(args.value, args.ctx);
+  const replayedAggregateId = trackedId === null && args.ctx.storedConstructionReplay === true && typeof args.value === "string" && evalValueById(
+    args.ctx,
+    args.value,
+    args.ctx.__runtimeSessionValues,
+    args.ctx.__valueOverlay
+  ) !== null ? args.value : null;
   const adoptTracked = (id2, suffix) => {
     if (constructorGroupForRow(id2, args.ctx) !== null) {
       assertOwnedValueAttachable(
@@ -74482,18 +74583,20 @@ function encodeRequiredConstructorArgument(args) {
   }
   if (args.typeInfo.type === 7 /* Class */ || args.typeInfo.type === 22 /* Interface */) {
     if (args.value === null || args.value === void 0) return null;
-    if (trackedId === null) {
+    const aggregateId2 = trackedId ?? replayedAggregateId;
+    if (aggregateId2 === null) {
       throw new NSGetterRuntimeError(
         `Constructor aggregate argument '${args.parameterId}' has no backing value row.`
       );
     }
-    return adoptTracked(trackedId, "root");
+    return adoptTracked(aggregateId2, "root");
   }
   if (args.typeInfo.type !== 6 /* List */ && args.typeInfo.type !== 5 /* Dictionary */) {
     return cloneConstructorLiteralValue(args.value);
   }
   if (args.value === null || args.value === void 0) return null;
-  if (trackedId !== null) return adoptTracked(trackedId, "root");
+  const aggregateId = trackedId ?? replayedAggregateId;
+  if (aggregateId !== null) return adoptTracked(aggregateId, "root");
   const collectionType = args.typeInfo;
   const registerRow = (value, containerId) => {
     const row2 = buildNewValue(args.ctx.vm.project.id, { value });
@@ -74601,10 +74704,9 @@ function resolveVariantGraph(selection2, ctx) {
       "Base variant selection has no variant graph."
     );
   }
-  const record3 = (ctx.vm.variants ?? []).find(
-    (candidate) => candidate.id === variantId
-  );
-  if (record3 === void 0) {
+  ctx.variantDependencies?.add(variantId);
+  const record3 = ctx.vm.databaseVM?.variantById?.(variantId) ?? (ctx.vm.variants ?? []).find((candidate) => candidate.id === variantId) ?? null;
+  if (record3 === null) {
     throw new NSGetterRuntimeError(
       `Variant '${variantId}' does not exist in this project.`
     );
@@ -75121,10 +75223,10 @@ function evalVariantApply(info, scope, ctx) {
     graph,
     ctx
   );
-  const applyValueId = graph.root.Apply;
-  if (typeof applyValueId === "string" && applyValueId.length > 0) {
+  const applyValue = graph.root.Apply;
+  if (applyValue !== void 0 && applyValue !== null) {
     invokeVariantClosure({
-      closureValueId: applyValueId,
+      closureValueId: applyValue,
       ctx,
       label: `Variant '${graph.name}' Apply`,
       lexicalThis: null,
@@ -75469,6 +75571,7 @@ function currentOwnedValueAttachments(valueId, ctx) {
       });
     }
   }
+  ctx.onUnattributableValueRead?.(`owned-value-parents:${valueId}`);
   const parentIds = new Set(
     evaluatorParentLinks(indexes, valueId).map((link) => link.parentId)
   );
@@ -75745,6 +75848,9 @@ function cloneConstructorArgumentGraph(args) {
       if (member.listKind === "unordered") {
         clone.value = [];
         const entryEnv2 = envFromStamp(clone.genericBindings);
+        args.ctx.onUnattributableValueRead?.(
+          `constructor-import-list:${source.id}`
+        );
         const entries = evaluatorValues(args.ctx).filter((row) => row.containerId === source.id).sort((left, right) => left.id.localeCompare(right.id));
         for (const entry of entries) {
           cloneRow2(entry, entryMember, entryEnv2, clone.id);
@@ -75875,7 +75981,19 @@ function materializeConstructorArgumentValue(args) {
       args.ctx.vm.members
     );
     const row = registerConstructorArgumentRow(args, []);
-    const sourceEntries = args.member.listKind === "unordered" && trackedValueId !== null ? evaluatorValues(args.ctx).filter((entry) => entry.containerId === trackedValueId).sort((left, right) => left.id.localeCompare(right.id)).map((entry) => entry.value) : args.value;
+    let sourceEntries = args.value;
+    if (args.member.listKind === "unordered" && trackedValueId !== null) {
+      args.ctx.onUnattributableValueRead?.(
+        `constructor-argument-list:${trackedValueId}`
+      );
+      const rows = [];
+      for (const entry of evaluatorValues(args.ctx)) {
+        if (entry.containerId === trackedValueId) rows.push(entry);
+      }
+      rows.sort((left, right) => left.id.localeCompare(right.id));
+      sourceEntries = [];
+      for (const entry of rows) sourceEntries.push(entry.value);
+    }
     const ids = [];
     for (const [index, rawEntry] of sourceEntries.entries()) {
       const entryValue = constructorCollectionEntryValue(
@@ -76072,6 +76190,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
   const active = /* @__PURE__ */ new Set();
   const clonedBySourceId = /* @__PURE__ */ new Map();
   const constructorArgumentReferenceCounts = /* @__PURE__ */ new Map();
+  ctx.onUnattributableValueRead?.(`class-clone:${sourceId3}`);
   for (const candidate of evaluatorValues(ctx)) {
     for (const argument2 of ownedConstructorArgumentValues(candidate, ctx)) {
       constructorArgumentReferenceCounts.set(
@@ -76080,7 +76199,95 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       );
     }
   }
-  const cloneRow2 = (sourceRow, sourceMember, clonedContainerId, sourceTypeInfo) => {
+  function cloneInitializerRow(sourceRow, sourceMember, id2, clonedContainerId, sourceTypeInfo) {
+    if (sourceMember === null) {
+      throw new NSGetterRuntimeError(
+        `Class.Clone cannot evaluate initializer-backed value '${sourceRow.id}' because its owning member could not be resolved.`
+      );
+    }
+    const indexes = constructorInitializerIndexes(ctx);
+    const runtimeMemberId = Reflect.get(sourceMember, "id");
+    const compileMemberId = indexes.initializerScopeMemberIds.get(sourceRow.init) ?? indexes.initializerScopeMemberIdsByValueId.get(sourceRow.id) ?? (typeof runtimeMemberId === "string" ? runtimeMemberId : null);
+    const compiled = ensureInitializerCompiled({
+      init: sourceRow.init,
+      member: sourceMember,
+      initializerCompiler: ctx.vm.initializerCompiler,
+      sourceValueId: sourceRow.id,
+      compileMemberId
+    });
+    const declaringClassId = compileMemberId === null ? void 0 : indexes.declaringClassIdsByMemberId.get(compileMemberId)?.values().next().value;
+    const ownerClass = declaringClassId === void 0 ? void 0 : indexes.classById.get(declaringClassId);
+    const constructorId = ownerClass?.requiredConstructorId;
+    const constructor2 = typeof constructorId === "string" ? constructorById(constructorId, ctx) : void 0;
+    const argumentValues = constructor2 === void 0 ? [] : declarationInitializerArgumentValues(
+      constructor2.argumentTypes,
+      `Class.Clone initializer on '${ownerClass?.name ?? sourceMember.name}'`,
+      compiled.parameters.slice(2).some(
+        (parameter4) => runtimeValueReferencesVariable(
+          compiled.instructions,
+          parameter4.id
+        )
+      )
+    );
+    const initializerCreatedValues = [];
+    const evaluated = evaluateInitializerInContext(
+      sourceRow.init,
+      sourceMember,
+      ctx,
+      initializerCreatedValues,
+      argumentValues,
+      sourceRow.id,
+      compileMemberId
+    );
+    if (evaluated.existingValueRow !== void 0) {
+      const adoptedClone = cloneRow2(
+        evaluated.existingValueRow,
+        sourceMember,
+        clonedContainerId,
+        sourceTypeInfo
+      );
+      clonedBySourceId.set(sourceRow.id, adoptedClone);
+      active.delete(sourceRow.id);
+      return adoptedClone;
+    }
+    const {
+      init: _init,
+      value: _value,
+      classId: _classId,
+      ...sourceEnvelope
+    } = sourceRow;
+    void _init;
+    void _value;
+    void _classId;
+    const clone = {
+      ...sourceEnvelope,
+      id: id2,
+      value: evaluated.value,
+      ...evaluated.classId === null ? {} : { classId: evaluated.classId },
+      ...evaluated.genericBindings === void 0 ? {} : { genericBindings: { ...evaluated.genericBindings } },
+      ...deepClonePlainData(pickInstanceProvenance(evaluated)),
+      containerId: clonedContainerId ?? null
+    };
+    if (evaluated.provisionalRootId !== void 0) {
+      retargetDelegateReceiverValueIds(
+        [clone, ...initializerCreatedValues],
+        evaluated.provisionalRootId,
+        clone.id
+      );
+    }
+    registerRuntimeSessionValue(ctx, clone);
+    clonedBySourceId.set(sourceRow.id, clone);
+    if (typeof clone.value === "object" && clone.value !== null) {
+      ctx.__cloneSourceRowIds ??= /* @__PURE__ */ new WeakMap();
+      ctx.__cloneSourceRowIds.set(clone.value, sourceRow.id);
+    }
+    active.delete(sourceRow.id);
+    if (ctx.__indexes !== void 0) {
+      indexEvaluatorRow(ctx.__indexes, clone);
+    }
+    return clone;
+  }
+  function cloneRow2(sourceRow, sourceMember, clonedContainerId, sourceTypeInfo) {
     if (active.has(sourceRow.id)) {
       throw new NSGetterRuntimeError(
         `Class.Clone found a cycle through owned value '${sourceRow.id}'.`
@@ -76090,6 +76297,15 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
     if (prior !== void 0) return prior;
     active.add(sourceRow.id);
     const id2 = freshCloneValueId();
+    if (isInitValueContent(sourceRow)) {
+      return cloneInitializerRow(
+        sourceRow,
+        sourceMember,
+        id2,
+        clonedContainerId,
+        sourceTypeInfo
+      );
+    }
     const clone = {
       ...sourceRow,
       id: id2,
@@ -76144,6 +76360,9 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
             entryTypeInfo
           ).id;
         });
+        ctx.onUnattributableValueRead?.(
+          `class-clone-unordered-list:${sourceRow.id}`
+        );
         for (const child of evaluatorValues(ctx)) {
           if (child.containerId !== sourceRow.id) continue;
           cloneRow2(child, entryMember, id2, entryTypeInfo);
@@ -76190,7 +76409,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       indexEvaluatorRow(ctx.__indexes, clone);
     }
     return clone;
-  };
+  }
   const rootMember = memberForValueRow(source, ctx);
   const typedSource = source.classId === void 0 ? { ...source, classId: runtimeClassId } : source;
   const clonedRoot = cloneRow2(typedSource, rootMember);
@@ -76442,6 +76661,12 @@ var init_evaluateNSGetter = __esm({
         if (existing !== void 0) return existing;
         const source = this.sourceRowById(id2);
         if (source === void 0) return void 0;
+        if (isInitValueContent(source)) {
+          const clone2 = { ...source, init: { ...source.init } };
+          super.set(id2, clone2);
+          this.materializedRows.push(clone2);
+          return clone2;
+        }
         let value = source.value;
         if (Array.isArray(value)) value = [...value];
         else if (typeof value === "object" && value !== null) value = { ...value };
@@ -76739,26 +76964,31 @@ 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 buildVirtualInstanceMaterializedIndex(args) {
+  const rowsById = new Map(
+    (args.materializedRows ?? args.document.values).map((row) => [row.id, row])
+  );
+  const rows = [...rowsById.values()];
+  return {
+    rows,
+    rowsById,
+    graph: new MaterializedValueGraphContext(
+      { ...args.document, values: rows },
+      rowsById
+    ),
+    unorderedEntryIdsByContainerId: buildUnorderedListMembershipIndex(rows),
+    constructorsById: new Map(
+      (args.document.constructors ?? []).map((constructor2) => [
+        constructor2.id,
+        constructor2
+      ])
+    ),
+    resolveConstructorSettlement: createConstructorSettlementResolver({
+      classes: args.document.classes,
+      constructors: args.document.constructors ?? [],
+      members: args.document.members
+    })
+  };
 }
 function withoutInitializerConstructionFields(init) {
   if (init.compiled === void 0) return init;
@@ -76817,6 +77047,31 @@ function claimVirtualIdentity(args) {
 }
 function expandStoredInstance(args) {
   const recorder = args.readRecorder ?? null;
+  const readTracking = recorder === null ? void 0 : new InitializerReadSet();
+  const trackMaterialization = readTracking === void 0 ? (materialize) => materialize() : (materialize) => {
+    try {
+      return materialize();
+    } finally {
+      for (const valueId of readTracking.valueIds) {
+        recorder?.recordValueRead(valueId);
+      }
+      for (const textId of readTracking.localizedTextIds) {
+        recorder?.recordLocalizedTextRead(textId);
+      }
+      for (const variantId of readTracking.variantIds) {
+        recorder?.recordVariantRead(variantId);
+      }
+      for (const memberId of readTracking.staticMemberIds) {
+        recorder?.recordStaticMemberRead(memberId);
+      }
+      for (const containerId of readTracking.containerIds) {
+        recorder?.recordContainerMembershipRead(containerId);
+      }
+      if (readTracking.hasUnattributableValueRead) {
+        recorder?.recordGlobalRead("initializer-runtime");
+      }
+    }
+  };
   recorder?.recordValueRead(args.instanceRoot.id);
   const rootMember = resolveMember2(args.rootMember, args.document.members);
   if (!isMemberClassBase(rootMember)) {
@@ -76855,25 +77110,6 @@ 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(
@@ -76971,22 +77207,32 @@ function expandStoredInstance(args) {
       code: `virtual-replay:${args.instanceRoot.id}`,
       compiled
     };
-    return materializeInitializerValue({
-      document: args.document,
-      member: replayMember,
-      row: { ...envelope, init },
-      storedConstructionReplay: true,
-      constructionBaselineReplay: fields.length === 0
-    });
+    return trackMaterialization(
+      () => materializeInitializerValue({
+        document: args.document,
+        member: replayMember,
+        row: { ...envelope, init },
+        storedConstructionReplay: true,
+        constructionBaselineReplay: fields.length === 0,
+        ...readTracking === void 0 ? {} : { readTracking },
+        saveStaticBindings: args.saveStaticBindings,
+        sessionStaticBindings: args.sessionStaticBindings
+      })
+    );
   };
   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 }
-    });
+    const built = trackMaterialization(
+      () => materializeMemberDefaultValue({
+        document: args.document,
+        member: replayMember,
+        envelope,
+        ...stampEnv === null ? {} : { genericEnv: stampEnv },
+        ...readTracking === void 0 ? {} : { readTracking },
+        saveStaticBindings: args.saveStaticBindings,
+        sessionStaticBindings: args.sessionStaticBindings
+      })
+    );
     return {
       ...built,
       root: {
@@ -77018,21 +77264,26 @@ function resolveVirtualInstanceGraph(args) {
     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 materializedById = args.materializedIndex?.rowsById ?? new Map(
+    (args.materializedRows ?? args.document.values).map((row) => [
+      row.id,
+      row
+    ])
   );
-  const materializedRows = [...materializedById.values()];
-  const materializedGraph = args.materializedGraph ?? new MaterializedValueGraphContext(
-    { ...args.document, values: materializedRows },
+  const materializedRows = args.materializedIndex?.rows ?? [
+    ...materializedById.values()
+  ];
+  const materializedGraph = args.materializedGraph ?? args.materializedIndex?.graph ?? new MaterializedValueGraphContext(
+    { ...args.document, values: [...materializedRows] },
     materializedById
   );
-  const constructorsById = new Map(
+  const constructorsById = args.materializedIndex?.constructorsById ?? new Map(
     (args.document.constructors ?? []).map((constructor2) => [
       constructor2.id,
       constructor2
     ])
   );
-  const resolveConstructorSettlement = createConstructorSettlementResolver({
+  const resolveConstructorSettlement = args.materializedIndex?.resolveConstructorSettlement ?? createConstructorSettlementResolver({
     classes: args.document.classes,
     constructors: args.document.constructors ?? [],
     members: args.document.members
@@ -77062,7 +77313,7 @@ function resolveVirtualInstanceGraph(args) {
     }
     return result;
   };
-  const materializedUnorderedEntryIdsByContainerId = buildUnorderedListMembershipIndex(materializedRows);
+  const materializedUnorderedEntryIdsByContainerId = args.materializedIndex?.unorderedEntryIdsByContainerId ?? buildUnorderedListMembershipIndex(materializedRows);
   const readMaterializedRow = (valueId) => {
     recorder?.recordValueRead(valueId);
     return materializedById.get(valueId) ?? null;
@@ -77092,8 +77343,7 @@ function resolveVirtualInstanceGraph(args) {
     const materialized = effectiveMaterializedId === null ? null : readMaterializedRow(effectiveMaterializedId);
     const effectiveId = materialized?.id ?? indexed.virtualId;
     const effective = {
-      ...cloneRow(indexed.expandedRow),
-      ...materialized === null ? {} : cloneRow(materialized),
+      ...mergeExpandedAndMaterializedRow(indexed.expandedRow, materialized),
       id: effectiveId,
       // Virtual rows inherit partition and timestamps from the root. Real rows
       // retain their own envelope through the spread above.
@@ -77136,7 +77386,7 @@ function resolveVirtualInstanceGraph(args) {
         const listMember = indexed.member;
         effective.value = [];
         const childPaths = expansion.childPathsByParentPath.get(pathKey) ?? [];
-        recorder?.recordGlobalRead(`unordered-list-membership:${effectiveId}`);
+        recorder?.recordContainerMembershipRead(effectiveId);
         const storedEntryIds = materializedUnorderedEntryIdsByContainerId.get(effectiveId) ?? [];
         const storedEntries = storedEntryIds.flatMap((storedEntryId) => {
           const entry = readMaterializedRow(storedEntryId);
@@ -77309,19 +77559,18 @@ function resolveVirtualInstanceGraph(args) {
     root: rootLocation
   };
 }
+function mergeExpandedAndMaterializedRow(expanded, materialized) {
+  const expandedClone = cloneRow(expanded);
+  if (materialized === null) return expandedClone;
+  const materializedClone = cloneRow(materialized);
+  return isLiteralValueContent(materialized) ? overlayLiteralValueContent(expandedClone, materializedClone) : { ...expandedClone, ...materializedClone };
+}
 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;
 }
@@ -77348,6 +77597,9 @@ function reportFrameResolutionDisagreement(args) {
 }
 function resolvedStoredInstanceRows(args) {
   const rows = new Map(args.document.values.map((row) => [row.id, row]));
+  const materializedIndex = buildVirtualInstanceMaterializedIndex({
+    document: args.document
+  });
   const queue = [{ root: args.instanceRoot, member: args.rootMember }];
   const resolvedRootIds = /* @__PURE__ */ new Set();
   const resolvedFrameByValueId = /* @__PURE__ */ new Map();
@@ -77366,7 +77618,7 @@ function resolvedStoredInstanceRows(args) {
       rootMember: next.member,
       expandedRoot: expanded.root,
       expandedRows: expanded.rows,
-      materializedRows: args.document.values
+      materializedIndex
     });
     for (const [id2, row] of graph.rowsById) {
       const priorFrame = resolvedFrameByValueId.get(id2);
@@ -77940,7 +78192,9 @@ function sparsifyConstructedInstance(args) {
     values: materializedRows
   };
   const materializedGraph = new MaterializedValueGraphContext(
-    constructionDocument
+    constructionDocument,
+    new Map(materializedRows.map((row) => [row.id, row])),
+    /* @__PURE__ */ new Map([[args.constructed.root.id, args.rootMember]])
   );
   const graph = resolveVirtualInstanceGraph({
     document: args.document,
@@ -78706,7 +78960,8 @@ function resolveVariantInstanceGraphForDocument(args) {
   const priorExpanded = expandStoredInstance({
     document,
     instanceRoot: args.priorInstanceRoot,
-    rootMember
+    rootMember,
+    readRecorder: args.readRecorder
   });
   const priorGraph = resolveVirtualInstanceGraph({
     document,
@@ -78714,7 +78969,8 @@ function resolveVariantInstanceGraphForDocument(args) {
     rootMember,
     expandedRoot: priorExpanded.root,
     expandedRows: priorExpanded.rows,
-    materializedRows: [...materializedById.values()]
+    materializedRows: [...materializedById.values()],
+    readRecorder: args.readRecorder
   });
   for (const valueId of args.answeredValueIds) {
     if (!priorGraph.locationsById.has(valueId)) {
@@ -78742,7 +78998,8 @@ function resolveVariantInstanceGraphForDocument(args) {
   const nextExpanded = expandStoredInstance({
     document,
     instanceRoot: args.nextInstanceRoot,
-    rootMember
+    rootMember,
+    readRecorder: args.readRecorder
   });
   const nextGraph = resolveVirtualInstanceGraph({
     document,
@@ -78750,7 +79007,8 @@ function resolveVariantInstanceGraphForDocument(args) {
     rootMember,
     expandedRoot: nextExpanded.root,
     expandedRows: nextExpanded.rows,
-    materializedRows: [...materializedById.values()]
+    materializedRows: [...materializedById.values()],
+    readRecorder: args.readRecorder
   });
   const root = nextGraph.rowsById.get(args.nextInstanceRoot.id);
   if (root === void 0) {
@@ -78788,7 +79046,12 @@ function createHeadlessVirtualInstanceResolver(args) {
     values: document.values
   }).placementByValueId;
   const rawById = new Map(document.values.map((row) => [row.id, row]));
-  const resolverDocumentOnce = () => composeResolverDocument(document, args.resolverLookups());
+  let resolverDocumentCache = null;
+  const resolverDocumentOnce = () => resolverDocumentCache ??= composeResolverDocument(
+    document,
+    args.resolverLookups()
+  );
+  let materializedIndex = null;
   const graphRowsByRootId = /* @__PURE__ */ new Map();
   const graphByValueId = /* @__PURE__ */ new Map();
   const failedRootIds = /* @__PURE__ */ new Set();
@@ -78813,10 +79076,15 @@ function createHeadlessVirtualInstanceResolver(args) {
     }
     try {
       const resolverDocument = resolverDocumentOnce();
+      materializedIndex ??= buildVirtualInstanceMaterializedIndex({
+        document: resolverDocument,
+        materializedRows: document.values
+      });
       const expanded = expandStoredInstance({
         document: resolverDocument,
         instanceRoot,
-        rootMember: member
+        rootMember: member,
+        readRecorder: args.readRecorder
       });
       const graph = resolveVirtualInstanceGraph({
         document: resolverDocument,
@@ -78824,7 +79092,8 @@ function createHeadlessVirtualInstanceResolver(args) {
         rootMember: member,
         expandedRoot: expanded.root,
         expandedRows: expanded.rows,
-        materializedRows: document.values
+        materializedIndex,
+        readRecorder: args.readRecorder
       });
       graphRowsByRootId.set(rootId, graph.rowsById);
       for (const [id2, row] of graph.rowsById) {
@@ -78845,8 +79114,11 @@ function createHeadlessVirtualInstanceResolver(args) {
     }
   };
   const virtualInstanceRowsForValue = (receiverValueId) => {
+    args.readRecorder?.recordValuePlacementRead();
+    args.readRecorder?.recordValueRead(receiverValueId);
     let placement = placements().get(receiverValueId) ?? null;
     while (placement !== null) {
+      args.readRecorder?.recordValueRead(placement.valueId);
       const raw = rawById.get(placement.valueId);
       if (raw !== void 0 && isLiteralValueContent(raw) && isVirtualInstanceRootShape(raw)) {
         return [...expandRoot(placement.valueId, placement.memberId).values()];
@@ -78867,7 +79139,7 @@ function createHeadlessVirtualInstanceResolver(args) {
     }
   };
 }
-var KEPT_ROW_SAMPLE_LIMIT, CORPUS_SCANNING_MEMBER_KINDS, CONSTRUCTOR_TYPE_WALK_DEPTH_LIMIT, VirtualExpansionUnsupportedError, ROOT_PATH, SYNTHETIC_LINEAGE_PREFIXES, resolverDocumentsByDocument;
+var KEPT_ROW_SAMPLE_LIMIT, CORPUS_SCANNING_MEMBER_KINDS, VirtualExpansionUnsupportedError, ROOT_PATH, SYNTHETIC_LINEAGE_PREFIXES, resolverDocumentsByDocument;
 var init_virtual_instance_values = __esm({
   "../src/database/virtual-instance-values.ts"() {
     "use strict";
@@ -78881,6 +79153,7 @@ var init_virtual_instance_values = __esm({
     init_instance_provenance();
     init_unordered_list_membership();
     init_neoscript();
+    init_evaluateInitializer();
     init_init_backed_value_materialization();
     init_constructor_argument_ownership();
     init_constructors2();
@@ -78888,15 +79161,8 @@ var init_virtual_instance_values = __esm({
     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 */
+      18 /* DialogueLookup */
     ]);
-    CONSTRUCTOR_TYPE_WALK_DEPTH_LIMIT = 8;
     VirtualExpansionUnsupportedError = class extends Error {
       constructor(message) {
         super(message);
@@ -78910,24 +79176,74 @@ var init_virtual_instance_values = __esm({
 });
 
 // ../src/view-models/neoscript-evaluator/evaluateInitializer.ts
-function initializerEvaluatorLookups(document) {
-  const key = document.evaluatorCache?.key ?? document;
-  const revision = document.evaluatorCache?.revision;
-  const cached = evaluatorLookupsByDocument.get(key);
-  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
+function initializerEvaluatorCacheKey(document) {
+  return document.evaluatorCache?.key ?? document;
+}
+function initializerEvaluatorCacheRevision(document) {
+  return document.evaluatorCache?.revision;
+}
+function initializerEvaluatorLookups(document, readTracking) {
+  const trackedHeadless = readTracking !== void 0 && document.databaseVM === void 0;
+  const indexKey = initializerEvaluatorCacheKey(document);
+  const lookupKey = document.databaseVM ?? indexKey;
+  const revision = initializerEvaluatorCacheRevision(document);
+  const cached = evaluatorLookupsByDocument.get(lookupKey);
+  if (!trackedHeadless && cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
     return cached.lookups;
   }
-  const indexedLookups = makeEvaluatorLookups(
-    document.members,
-    document.values,
-    {
-      includeValueGraphIndexes: true,
-      constructorInitializerDocument: document
-    }
+  if (document.databaseVM !== void 0) {
+    const databaseVM = document.databaseVM;
+    const lookups2 = {
+      memberById: (id2) => databaseVM.memberById(id2),
+      valueById: (id2) => databaseVM.valueById(id2),
+      localizedTextById: (id2) => databaseVM.localizedTextById?.(id2) ?? null,
+      ...databaseVM.hasStoredValueId === void 0 ? {} : {
+        hasStoredValueId: (id2) => databaseVM.hasStoredValueId?.(id2) ?? false
+      },
+      variantById: (id2) => databaseVM.variantById?.(id2) ?? null,
+      storedValuePlacementForValueId: (id2) => databaseVM.storedValuePlacementForValueId?.(id2) ?? null,
+      unorderedListEntryIds: (containerValueId) => {
+        const resolved = databaseVM.unorderedListEntryIds?.(containerValueId);
+        if (resolved === void 0) {
+          throw new Error(
+            `Evaluator database resolves no unordered-list membership for container "${containerValueId}".`
+          );
+        }
+        return resolved;
+      },
+      virtualInstanceRowsForValue: (receiverValueId) => databaseVM.virtualInstanceRowsForValue(receiverValueId),
+      rowForValueReference: (value) => databaseVM.rowForValueReference?.(value) ?? null,
+      resolveVariantInstanceGraph: (args) => {
+        const resolver = databaseVM.resolveVariantInstanceGraph;
+        if (resolver === void 0) {
+          throw new Error(
+            "Evaluator database has no virtual variant resolver."
+          );
+        }
+        return resolver.call(databaseVM, args);
+      },
+      ...databaseVM.evaluatorIndexes === void 0 ? {} : { evaluatorIndexes: databaseVM.evaluatorIndexes },
+      ...databaseVM.constructorInitializerIndexes === void 0 ? {} : {
+        constructorInitializerIndexes: databaseVM.constructorInitializerIndexes
+      }
+    };
+    evaluatorLookupsByDocument.set(lookupKey, {
+      members: document.members,
+      values: document.values,
+      revision,
+      lookups: lookups2
+    });
+    return lookups2;
+  }
+  const indexedLookups = indexedInitializerEvaluatorLookups(
+    document,
+    indexKey,
+    revision
   );
   const headlessVirtualResolver = document.databaseVM === void 0 ? createHeadlessVirtualInstanceResolver({
     document,
-    resolverLookups: () => lookups
+    resolverLookups: () => lookups,
+    ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) }
   }) : null;
   const lookups = {
     ...indexedLookups,
@@ -78945,11 +79261,13 @@ function initializerEvaluatorLookups(document) {
       resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
         document,
         resolverLookups: lookups,
+        ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) },
         ...args
       })
     } : {
       memberById: (id2) => document.databaseVM?.memberById(id2) ?? null,
       valueById: (id2) => document.databaseVM?.valueById(id2) ?? null,
+      variantById: (id2) => document.databaseVM?.variantById?.(id2) ?? null,
       // The VM's `valueById` answers EXPANDED-first: a collapse-stamped
       // root resolves to a record the VM minted, an object the raw value
       // index has never seen. Reference-identity dispatch (`.Id`, `is`,
@@ -78983,7 +79301,26 @@ function initializerEvaluatorLookups(document) {
       }
     }
   };
-  evaluatorLookupsByDocument.set(key, {
+  if (!trackedHeadless) {
+    evaluatorLookupsByDocument.set(lookupKey, {
+      members: document.members,
+      values: document.values,
+      revision,
+      lookups
+    });
+  }
+  return lookups;
+}
+function indexedInitializerEvaluatorLookups(document, key, revision) {
+  const cached = indexedEvaluatorLookupsByDocument.get(key);
+  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
+    return cached.lookups;
+  }
+  const lookups = makeEvaluatorLookups(document.members, document.values, {
+    includeValueGraphIndexes: true,
+    constructorInitializerDocument: document
+  });
+  indexedEvaluatorLookupsByDocument.set(key, {
     members: document.members,
     values: document.values,
     revision,
@@ -78991,25 +79328,65 @@ function initializerEvaluatorLookups(document) {
   });
   return lookups;
 }
-function buildInitializerRootValueWithLookups(document, lookups) {
+function buildInitializerRootValueWithLookups(document, lookups, tracking) {
   const rootValue = {};
   for (const { root, memberId } of projectRootMembersInDisplayOrder(
     document.project
   )) {
     const member = lookups.memberById(memberId);
-    if (member === null || typeof member.valueId !== "string") {
+    if (member === null) {
+      rootValue[root.key] = null;
+      continue;
+    }
+    tracking?.staticMemberDependencies?.add(member.id);
+    const bindings = root.storage === "save" /* Save */ ? tracking?.saveStaticBindings : root.storage === "session" /* Session */ ? tracking?.sessionStaticBindings : void 0;
+    const boundTarget = staticBindingEntry(bindings, member.id);
+    const targetId = boundTarget.present ? boundTarget.value : member.valueId;
+    if (typeof targetId !== "string") {
       rootValue[root.key] = null;
       continue;
     }
-    rootValue[root.key] = lookups.valueById(member.valueId)?.value ?? null;
+    tracking?.valueDependencies?.add(targetId);
+    rootValue[root.key] = lookups.valueById(targetId)?.value ?? null;
   }
   return rootValue;
 }
+function staticBindingEntry(bindings, memberId) {
+  if (bindings === void 0) return { present: false, value: null };
+  if (isStaticBindingMap(bindings)) {
+    return {
+      present: bindings.has(memberId),
+      value: bindings.get(memberId) ?? null
+    };
+  }
+  return {
+    present: Object.hasOwn(bindings, memberId),
+    value: bindings[memberId] ?? null
+  };
+}
+function isStaticBindingMap(bindings) {
+  return "get" in bindings && typeof bindings.get === "function" && "has" in bindings && typeof bindings.has === "function";
+}
+function virtualReadRecorder(reads) {
+  return {
+    recordValueRead: (id2) => reads.valueIds.add(id2),
+    recordLocalizedTextRead: (id2) => reads.localizedTextIds.add(id2),
+    recordVariantRead: (id2) => reads.variantIds.add(id2),
+    recordStaticMemberRead: (id2) => reads.staticMemberIds.add(id2),
+    recordContainerMembershipRead: (id2) => reads.containerIds.add(id2),
+    recordValuePlacementRead: reads.recordValuePlacementRead,
+    recordGlobalRead: reads.recordUnattributableValueRead
+  };
+}
 function evaluateMemberInitializer(args) {
-  const databaseVM = initializerEvaluatorLookups(args.document);
-  const compileMemberId = databaseVM.constructorInitializerIndexes?.initializerScopeMemberIds.get(
-    args.init
+  const databaseVM = initializerEvaluatorLookups(
+    args.document,
+    args.readTracking
   );
+  const initializerIndexes = databaseVM.constructorInitializerIndexes;
+  const compileMemberId = initializerIndexes?.initializerScopeMemberIds.get(args.init) ?? (args.sourceValueId === null || args.sourceValueId === void 0 ? void 0 : initializerIndexes?.initializerScopeMemberIdsByValueId.get(
+    args.sourceValueId
+  ));
   const compiled = ensureInitializerCompiled({
     init: args.init,
     member: args.member,
@@ -79041,7 +79418,18 @@ function evaluateMemberInitializer(args) {
       initializerCompiler: args.document.initializerCompiler
     },
     thisValue: null,
-    rootValue: buildInitializerRootValueWithLookups(args.document, databaseVM),
+    rootValue: buildInitializerRootValueWithLookups(args.document, databaseVM, {
+      valueDependencies: args.readTracking?.valueIds,
+      staticMemberDependencies: args.readTracking?.staticMemberIds,
+      saveStaticBindings: args.saveStaticBindings,
+      sessionStaticBindings: args.sessionStaticBindings
+    }),
+    valueDependencies: args.readTracking?.valueIds,
+    localizedTextDependencies: args.readTracking?.localizedTextIds,
+    variantDependencies: args.readTracking?.variantIds,
+    containerDependencies: args.readTracking?.containerIds,
+    staticMemberDependencies: args.readTracking?.staticMemberIds,
+    onUnattributableValueRead: args.readTracking?.recordUnattributableValueRead,
     saveStaticBindings: args.saveStaticBindings,
     sessionStaticBindings: args.sessionStaticBindings,
     ...args.storedConstructionReplay === true ? {
@@ -79104,7 +79492,7 @@ function evaluateMemberInitializer(args) {
     }
   };
 }
-var evaluatorLookupsByDocument;
+var evaluatorLookupsByDocument, indexedEvaluatorLookupsByDocument, InitializerReadSet;
 var init_evaluateInitializer = __esm({
   "../src/view-models/neoscript-evaluator/evaluateInitializer.ts"() {
     "use strict";
@@ -79115,6 +79503,23 @@ var init_evaluateInitializer = __esm({
     init_evaluateNSGetter();
     init_virtual_instance_values();
     evaluatorLookupsByDocument = /* @__PURE__ */ new WeakMap();
+    indexedEvaluatorLookupsByDocument = /* @__PURE__ */ new WeakMap();
+    InitializerReadSet = class {
+      valueIds = /* @__PURE__ */ new Set();
+      localizedTextIds = /* @__PURE__ */ new Set();
+      variantIds = /* @__PURE__ */ new Set();
+      containerIds = /* @__PURE__ */ new Set();
+      staticMemberIds = /* @__PURE__ */ new Set();
+      hasValuePlacementRead = false;
+      hasUnattributableValueRead = false;
+      recordUnattributableValueRead = (_reason) => {
+        void _reason;
+        this.hasUnattributableValueRead = true;
+      };
+      recordValuePlacementRead = () => {
+        this.hasValuePlacementRead = true;
+      };
+    };
   }
 });
 
@@ -79130,8 +79535,12 @@ var init_neoscript_evaluator = __esm({
 
 // ../src/database/init-backed-value-materialization.ts
 function declarationInitializerContext(document) {
-  const cached = declarationInitializerContextByDocument.get(document);
-  if (cached !== void 0) return cached;
+  const key = initializerEvaluatorCacheKey(document);
+  const revision = initializerEvaluatorCacheRevision(document);
+  const cached = declarationInitializerContextByDocument.get(key);
+  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
+    return cached.context;
+  }
   const initializerValueIds = new Set(
     document.values.filter(isInitValueContent).map((value) => value.id)
   );
@@ -79146,7 +79555,12 @@ function declarationInitializerContext(document) {
     rootOwners
   );
   const created = { valuesById, rootOwners };
-  declarationInitializerContextByDocument.set(document, created);
+  declarationInitializerContextByDocument.set(key, {
+    members: document.members,
+    values: document.values,
+    revision,
+    context: created
+  });
   return created;
 }
 function evaluateInitializerMaterialization(args) {
@@ -79161,7 +79575,10 @@ function evaluateInitializerMaterialization(args) {
     ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
     ...args.constructionBaselineReplay === true ? { constructionBaselineReplay: true } : {},
     ...args.argumentValues === void 0 ? {} : { argumentValues: args.argumentValues },
-    sourceValueId: args.sourceValueId ?? null
+    sourceValueId: args.sourceValueId ?? null,
+    readTracking: args.readTracking,
+    saveStaticBindings: args.saveStaticBindings,
+    sessionStaticBindings: args.sessionStaticBindings
   });
   return { evaluated, createdValues, storageKeyDeclarations };
 }
@@ -79197,7 +79614,10 @@ function materializeInitializerValue(args) {
     ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
     ...args.constructionBaselineReplay === true ? { constructionBaselineReplay: true } : {},
     ...args.argumentValues === void 0 ? {} : { argumentValues: args.argumentValues },
-    sourceValueId: args.row.id
+    sourceValueId: args.row.id,
+    readTracking: args.readTracking,
+    saveStaticBindings: args.saveStaticBindings,
+    sessionStaticBindings: args.sessionStaticBindings
   });
   const {
     init: _init,
@@ -79205,6 +79625,9 @@ function materializeInitializerValue(args) {
     classId: _classId,
     ...envelope
   } = args.row;
+  void _init;
+  void _value;
+  void _classId;
   const root = {
     ...envelope,
     value: evaluated.value,
@@ -79240,6 +79663,9 @@ function materializeInitializerValue(args) {
 function materializeMemberDefaultValue(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
+  args.readTracking?.recordUnattributableValueRead(
+    `declaration-owner-resolution:${args.envelope.id}`
+  );
   const { valuesById, rootOwners } = declarationInitializerContext(
     args.document
   );
@@ -79260,15 +79686,14 @@ function materializeMemberDefaultValue(args) {
       (candidate) => candidate.id === constructorId
     );
     if (constructor2 === void 0) return [];
-    const defaults = parameterDefaultsAsFullArguments(
-      constructor2.argumentTypes,
-      `Declaration template on '${ownerClass.name}'`
-    );
-    if (defaults !== null) return defaults;
     const parameterNames = new Set(
       constructor2.argumentTypes.map((argument2) => argument2.name)
     );
-    return initializerReferencesAnyIdentifier(init.code, parameterNames) ? [] : constructor2.argumentTypes.map(() => null);
+    return declarationInitializerArgumentValues(
+      constructor2.argumentTypes,
+      `Declaration template on '${ownerClass.name}'`,
+      initializerReferencesAnyIdentifier(init.code, parameterNames)
+    );
   };
   const built = buildDefaultMemberValue({
     document: args.document,
@@ -79290,7 +79715,10 @@ function materializeMemberDefaultValue(args) {
         init,
         sourceValueId ?? null
       ),
-      sourceValueId: sourceValueId ?? null
+      sourceValueId: sourceValueId ?? null,
+      readTracking: args.readTracking,
+      saveStaticBindings: args.saveStaticBindings,
+      sessionStaticBindings: args.sessionStaticBindings
     })
   });
   const interior = createdValues.filter((created) => created.id !== built.id);
@@ -79320,6 +79748,7 @@ var init_init_backed_value_materialization = __esm({
     init_inheritance();
     init_neoscript_evaluator();
     init_evaluateNSGetter();
+    init_evaluateInitializer();
     init_value_row_owner_members();
     init_compile_ns_property();
     declarationInitializerContextByDocument = /* @__PURE__ */ new WeakMap();
@@ -84439,7 +84868,6 @@ function isWorldAnimationStructuralMember(memberId, members) {
 }
 function assertAnimationClipDocumentValid(document) {
   const context = new AnimationValidationContext(document);
-  context.validateConstructorProjections();
   context.validateSegments();
   for (const member of document.members) {
     if (!isMemberClass(member)) continue;
@@ -84458,7 +84886,6 @@ var init_animation_clips = __esm({
     init_inheritance();
     init_generics();
     init_world_system_classes();
-    init_core_types();
     init_member_kinds();
     init_structured_leaf_fields();
     init_effective_storage();
@@ -84501,60 +84928,6 @@ var init_animation_clips = __esm({
       memberById;
       valueById;
       storage;
-      validateConstructorProjections() {
-        for (const schemaClass2 of this.document.classes) {
-          const projections = schemaClass2.constructorProjections ?? [];
-          if (projections.length === 0) continue;
-          if (schemaClass2.system?.kind !== SystemProtectionKind.WorldAuthoring) {
-            throw new Error(
-              `Class "${schemaClass2.name}" can declare constructor projections only when it is a locked world system class.`
-            );
-          }
-          const parameterNames = /* @__PURE__ */ new Set();
-          const memberIds = /* @__PURE__ */ new Set();
-          const effectiveMemberIds = this.effectiveSchemaMemberIds(schemaClass2);
-          for (const projection of projections) {
-            if (parameterNames.has(projection.parameterName)) {
-              throw new Error(
-                `Class "${schemaClass2.name}" has duplicate constructor parameter "${projection.parameterName}".`
-              );
-            }
-            if (memberIds.has(projection.memberId)) {
-              throw new Error(
-                `Class "${schemaClass2.name}" projects multiple constructor parameters onto member "${projection.memberId}".`
-              );
-            }
-            if (!effectiveMemberIds.has(projection.memberId)) {
-              throw new Error(
-                `Class "${schemaClass2.name}" constructor parameter "${projection.parameterName}" references member "${projection.memberId}", which is neither in its schema nor inherited.`
-              );
-            }
-            parameterNames.add(projection.parameterName);
-            memberIds.add(projection.memberId);
-          }
-        }
-      }
-      /**
-       * Every member id a class resolves under a schema key — its own, then each
-       * ancestor's.
-       *
-       * A projection may name an inherited member: P48 §2.1 moved `Child` onto
-       * `NeoAnimationTrackBase`, and `new NeoAnimationChildTrack(id: "…")` still
-       * projects onto that one member from a class that no longer declares it.
-       */
-      effectiveSchemaMemberIds(schemaClass2) {
-        const memberIds = /* @__PURE__ */ new Set();
-        const visited = /* @__PURE__ */ new Set();
-        let current = schemaClass2;
-        while (current !== void 0 && !visited.has(current.id)) {
-          visited.add(current.id);
-          for (const memberId of Object.values(current.schema)) {
-            memberIds.add(memberId);
-          }
-          current = current.extendsClassId === void 0 ? void 0 : this.classById.get(current.extendsClassId);
-        }
-        return memberIds;
-      }
       classHasWorldKind(classId, worldKind) {
         const visited = /* @__PURE__ */ new Set();
         let current = this.classById.get(classId);
@@ -86031,17 +86404,26 @@ function syntheticMember(fields) {
 function variantOwnershipRoots(args) {
   const empty = { roots: [], bindingMembers: [] };
   if (args.variants.length === 0) return empty;
-  const plainVariantClass = args.classes.find(
-    (schemaClass2) => schemaClass2.system?.worldKind === NeoWorldSystemClassKind.Variant
+  const classById = new Map(
+    args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const classByVariantKind = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of args.classes) {
+    const worldKind = schemaClass2.system?.worldKind;
+    if (worldKind !== NeoWorldSystemClassKind.Variant && worldKind !== NeoWorldSystemClassKind.LookupVariant) {
+      continue;
+    }
+    classByVariantKind.set(worldKind, schemaClass2);
+  }
+  const plainVariantClass = classByVariantKind.get(
+    NeoWorldSystemClassKind.Variant
   );
   if (plainVariantClass === void 0) return empty;
   const valueById = new Map(args.values.map((value) => [value.id, value]));
   const folderById = new Map(
     (args.variantFolders ?? []).map((folder) => [folder.id, folder])
   );
-  const memberById2 = new Map(
-    (args.members ?? []).map((member) => [member.id, member])
-  );
+  let memberById2 = null;
   const roots = [];
   const bindingMembers = [];
   for (const variant of args.variants) {
@@ -86049,11 +86431,9 @@ function variantOwnershipRoots(args) {
     if (root === void 0) continue;
     const lookupFolder = variant.folderId == null ? void 0 : folderById.get(variant.folderId);
     const inferredVariantKind = lookupFolder?.binding == null ? NeoWorldSystemClassKind.Variant : NeoWorldSystemClassKind.LookupVariant;
-    const variantClass = args.classes.find(
-      (schemaClass2) => schemaClass2.id === root.classId && (schemaClass2.system?.worldKind === NeoWorldSystemClassKind.Variant || schemaClass2.system?.worldKind === NeoWorldSystemClassKind.LookupVariant)
-    ) ?? args.classes.find(
-      (schemaClass2) => schemaClass2.system?.worldKind === inferredVariantKind
-    ) ?? plainVariantClass;
+    const stampedClass = typeof root.classId === "string" ? classById.get(root.classId) : void 0;
+    const stampedKind = stampedClass?.system?.worldKind;
+    const variantClass = (stampedKind === NeoWorldSystemClassKind.Variant || stampedKind === NeoWorldSystemClassKind.LookupVariant ? stampedClass : void 0) ?? classByVariantKind.get(inferredVariantKind) ?? plainVariantClass;
     const parameterId = variantClass.genericParams?.[0]?.id;
     if (parameterId === void 0) continue;
     const stampedTargetMemberId = readStampedTargetMemberId(root, parameterId);
@@ -86080,7 +86460,12 @@ function variantOwnershipRoots(args) {
       })
     );
     const lookupParameterId = variantClass.genericParams?.[1]?.id;
-    const lookupCollection = lookupFolder?.binding == null ? void 0 : memberById2.get(lookupFolder.binding.collectionMemberId);
+    if (lookupFolder?.binding != null && memberById2 === null) {
+      memberById2 = new Map(
+        (args.members ?? []).map((member) => [member.id, member])
+      );
+    }
+    const lookupCollection = lookupFolder?.binding == null ? void 0 : memberById2?.get(lookupFolder.binding.collectionMemberId);
     const lookupBinding = lookupParameterId !== void 0 && isMemberListBase(lookupCollection) ? {
       [lookupParameterId]: {
         kind: "member",
@@ -86118,15 +86503,38 @@ function withVariantOwnershipRoots(document, variants) {
     classes: document.classes,
     members: document.members
   });
-  if (bindingMembers.length === 0) return { document, roots };
+  const rootMembersByValueId = new Map(
+    roots.map((root) => [root.valueId, root.member])
+  );
+  if (bindingMembers.length === 0) {
+    return { document, roots, rootMembersByValueId };
+  }
   return {
     document: {
       ...document,
       members: [...document.members, ...bindingMembers]
     },
-    roots
+    roots,
+    rootMembersByValueId
   };
 }
+function createVariantMaterializedValueGraphContext(document, variants, rows = new Map(
+  document.values.map((value) => [value.id, value])
+)) {
+  const scopedDocument = {
+    ...document,
+    values: [...rows.values()]
+  };
+  const scope = withVariantOwnershipRoots(
+    scopedDocument,
+    variants.filter((variant) => rows.has(variant.valueId))
+  );
+  return new MaterializedValueGraphContext(
+    scope.document,
+    rows,
+    scope.rootMembersByValueId
+  );
+}
 function collectVariantGraphValueIds(args) {
   const collected = /* @__PURE__ */ new Set();
   if (args.variantIds.size === 0) return collected;
@@ -87860,7 +88268,11 @@ function validateWorldLayerLinkClassTargets(args) {
   }
 }
 function worldLayerLinkTargetDescriptorForClass(classId, classes) {
-  const worldKind = resolveWorldSystemClassKind(classId, classes);
+  return worldLayerLinkTargetDescriptor(
+    resolveWorldSystemClassKind(classId, classes)
+  );
+}
+function worldLayerLinkTargetDescriptor(worldKind) {
   if (worldKind === NeoWorldSystemClassKind.TileLayerLink) {
     return {
       relationKind: InternalRecordRelationKind.WorldTileLayerLinkTarget,
@@ -87882,9 +88294,11 @@ function worldLayerLinkTargetRelations(classId, descriptor, relations) {
 }
 function resolveWorldLayerLinkTarget(args) {
   const label = args.linkLabel ?? `Layer-link class "${args.sourceClassId}"`;
-  const sourceClass = args.classes.find(
-    (candidate) => candidate.id === args.sourceClassId
-  );
+  const relationResolver = args.relationResolver ?? createEffectiveClassRelationResolver({
+    classes: args.classes,
+    relations: args.relations
+  });
+  const sourceClass = relationResolver.classesById.get(args.sourceClassId);
   if (sourceClass === void 0) {
     throw new Error(
       `${label} references missing class "${args.sourceClassId}".`
@@ -87895,21 +88309,18 @@ function resolveWorldLayerLinkTarget(args) {
       `${label} cannot instantiate abstract class "${args.sourceClassId}".`
     );
   }
-  const descriptor = worldLayerLinkTargetDescriptorForClass(
-    args.sourceClassId,
-    args.classes
+  const descriptor = args.worldKindsByClassId === void 0 ? worldLayerLinkTargetDescriptorForClass(args.sourceClassId, args.classes) : worldLayerLinkTargetDescriptor(
+    args.worldKindsByClassId.get(args.sourceClassId) ?? null
   );
   if (descriptor === null) {
     throw new Error(
       `${label} class "${args.sourceClassId}" is not a tile/object layer-link class.`
     );
   }
-  const effective = resolveEffectiveClassRelations({
-    relationKind: descriptor.relationKind,
-    sourceClassId: args.sourceClassId,
-    relations: args.relations,
-    classes: args.classes
-  });
+  const effective = relationResolver.resolve(
+    descriptor.relationKind,
+    args.sourceClassId
+  );
   if (effective.length > 1) {
     throw new Error(
       `${label} class "${args.sourceClassId}" resolves more than one effective target for relation kind "${descriptor.relationKind}".`
@@ -87917,8 +88328,8 @@ function resolveWorldLayerLinkTarget(args) {
   }
   const relationTarget = effective[0] ?? null;
   if (relationTarget !== null) {
-    const declarationClass = args.classes.find(
-      (candidate) => candidate.id === relationTarget.declaredSourceRecordId
+    const declarationClass = relationResolver.classesById.get(
+      relationTarget.declaredSourceRecordId
     );
     if (declarationClass?.system?.worldKind === NeoWorldSystemClassKind.TileLayerLink || declarationClass?.system?.worldKind === NeoWorldSystemClassKind.ObjectLayerLink) {
       throw new Error(
@@ -87932,9 +88343,7 @@ function resolveWorldLayerLinkTarget(args) {
     );
   }
   const targetClassId = relationTarget.targetRecordId;
-  const targetClass = args.classes.find(
-    (candidate) => candidate.id === targetClassId
-  );
+  const targetClass = relationResolver.classesById.get(targetClassId);
   if (targetClass === void 0) {
     throw new Error(`${label} targets missing layer class "${targetClassId}".`);
   }
@@ -87943,10 +88352,7 @@ function resolveWorldLayerLinkTarget(args) {
       `${label} targets abstract layer class "${targetClassId}".`
     );
   }
-  const targetWorldKind = resolveWorldSystemClassKind(
-    targetClass.id,
-    args.classes
-  );
+  const targetWorldKind = args.worldKindsByClassId?.get(targetClass.id) ?? resolveWorldSystemClassKind(targetClass.id, args.classes);
   if (targetWorldKind !== descriptor.targetWorldKind) {
     throw new Error(
       `${label} targets class "${targetClassId}" of world kind "${String(targetWorldKind)}"; expected "${descriptor.targetWorldKind}".`
@@ -88956,6 +89362,11 @@ function readMember(value) {
 function readClass(value) {
   if (!isRecord6(value)) throw new Error("Class record is not an object.");
   if (typeof value.id !== "string") throw new Error("Class id is invalid.");
+  if (hasRetiredConstructorProjectionsTombstone(value)) {
+    throw new Error(
+      `Class "${value.id}" cannot declare retired field "constructorProjections".`
+    );
+  }
   if (typeof value.name !== "string") {
     throw new Error(`Class "${value.id}" name is invalid.`);
   }
@@ -90725,26 +91136,6 @@ function assertOpaqueConstructorValid(declaredConstructor) {
   assertOpaqueConstructorBaseClauseValid(declaredConstructor);
   return argumentTypes;
 }
-function assertOpaqueConstructorProjectionsDisjoint(declaredConstructor, owner) {
-  const projections = owner.constructorProjections;
-  if (projections === void 0 || projections === null) return;
-  if (!Array.isArray(projections)) {
-    throw new Error(`Class "${owner.id}" constructorProjections are invalid.`);
-  }
-  const projected = new Set(
-    projections.filter(
-      (projection) => isRecord6(projection) && typeof projection.parameterName === "string"
-    ).map((projection) => projection.parameterName.toLowerCase())
-  );
-  if (projected.size === 0) return;
-  for (const argument2 of declaredConstructor.argumentTypes) {
-    if (!isRecord6(argument2) || typeof argument2.name !== "string") continue;
-    if (!projected.has(argument2.name.toLowerCase())) continue;
-    throw new Error(
-      `Constructor "${declaredConstructor.id}" declares parameter "${argument2.name}", which is also a constructor projection argument on class "${owner.id}"; a call site could not tell the two apart.`
-    );
-  }
-}
 function assertOpaqueRequiredConstructorValid(schemaClass2, constructorsById) {
   const requiredConstructorId2 = schemaClass2.requiredConstructorId;
   if (requiredConstructorId2 === void 0 || requiredConstructorId2 === null) {
@@ -90813,7 +91204,6 @@ function assertOpaqueConstructorsValid(constructors, classesById2) {
         `Class "${owner.id}" names constructor "${declaredConstructor.id}" as its required constructor and also lists it in constructorIds; the required constructor is not a declared member.`
       );
     }
-    assertOpaqueConstructorProjectionsDisjoint(declaredConstructor, owner);
     const siblings = constructorsByClassId.get(declaredConstructor.classId) ?? [];
     siblings.push(declaredConstructor);
     constructorsByClassId.set(declaredConstructor.classId, siblings);
@@ -91075,6 +91465,7 @@ var init_projectInterfaceValidation = __esm({
     "use strict";
     init_projectVariantValidation();
     init_src();
+    init_classes();
     NEO_OBJECT_WORLD_KIND = "object";
     READ_ONLY_SYNTHETIC_VALUE_ID_PREFIX2 = "__neo_readonly_default:";
     REJECTED_OPAQUE_CONSTRUCTOR_KEYS = [
@@ -94939,7 +95330,10 @@ function attachPreparedValuePlacements(prepared, document) {
     (change) => change.recordKind === "value" && change.operation === "create"
   );
   if (creates.length === 0) return;
-  const materializedGraph = new MaterializedValueGraphContext(document);
+  const materializedGraph = createVariantMaterializedValueGraphContext(
+    document,
+    document.variants ?? []
+  );
   const constructorEdges = [];
   for (const edges of materializedGraph.edgesByOwnerValueId.values()) {
     for (const edge of edges) {
@@ -95010,7 +95404,11 @@ function attachPreparedConstructorAggregateEdges(prepared, document) {
       }
     }
   }
-  const graph = needsGraph ? new MaterializedValueGraphContext(document, changedValueRows) : null;
+  const graph = !needsGraph ? null : createVariantMaterializedValueGraphContext(
+    document,
+    document.variants ?? [],
+    changedValueRows
+  );
   for (const change of valueChanges) {
     change.constructorAggregateEdges = [
       ...graph?.edgesByOwnerValueId.get(change.recordId) ?? []
@@ -95066,13 +95464,16 @@ function materializePreparedInstanceInitializers(args) {
   const existingValueById = new Map(
     args.document.values.map((value) => [value.id, value])
   );
-  let currentGraph = null;
-  const requireCurrentGraph = () => currentGraph ??= new MaterializedValueGraphContext(args.document);
   const rootKinds = /* @__PURE__ */ new Map();
   const materializationScope = withVariantOwnershipRoots(
     compiledDocument,
     compiledDocument.variants ?? []
   );
+  let currentGraph = null;
+  const requireCurrentGraph = () => currentGraph ??= createVariantMaterializedValueGraphContext(
+    materializationScope.document,
+    materializationScope.document.variants ?? []
+  );
   const owners = resolveSemanticOwnerMembersForValues(
     materializationScope.document,
     new Set(sites.keys()),
@@ -95106,7 +95507,11 @@ function materializePreparedInstanceInitializers(args) {
     });
     if (existingConstructedRoot) {
       if (!isLiteralValueContent(materialized.root) || existingRoot.classId !== materialized.root.classId || !replayedCreationDataMatches({
-        currentDocument: args.document,
+        // The synthetic variant binding members are part of the ownership
+        // scope that compiled and evaluated this initializer. Stored replay
+        // closes its generic slot from the same ephemeral member id, so its
+        // expansion must read that scoped document too.
+        currentDocument: materializationScope.document,
         currentGraph: requireCurrentGraph(),
         currentRoot: existingRoot,
         rootMember: member,
@@ -95253,7 +95658,10 @@ function reconcileInitializerMaterializationTransport(args) {
       allServerIds.add(change.recordId);
     }
   }
-  const graph = new MaterializedValueGraphContext(args.document);
+  const graph = createVariantMaterializedValueGraphContext(
+    args.document,
+    args.document.variants ?? []
+  );
   const serverOwners = graph.ownersForValues(allServerIds);
   for (const sourceValueId of serverRootIds) {
     const local = roots.get(sourceValueId);
@@ -95346,12 +95754,14 @@ function constructorArgumentsSemanticallyEqual(args) {
   const replayRows = new Map(args.currentGraph.valuesById);
   replayRows.set(args.replayRoot.id, args.replayRoot);
   for (const row of args.replayCreated) replayRows.set(row.id, row);
-  const currentNormalized = new MaterializedValueGraphContext(
+  const currentNormalized = createVariantMaterializedValueGraphContext(
     args.currentDocument,
+    args.currentDocument.variants ?? [],
     currentRows
   ).normalizeConstructorArguments(args.current, args.currentRoot);
-  const replayNormalized = new MaterializedValueGraphContext(
+  const replayNormalized = createVariantMaterializedValueGraphContext(
     args.currentDocument,
+    args.currentDocument.variants ?? [],
     replayRows
   ).normalizeConstructorArguments(args.replay, args.replayRoot);
   return canonicallyEqual2(currentNormalized, replayNormalized);
@@ -98322,7 +98732,7 @@ function reconcileVariantConstructorArgs(args) {
   const valueById = indexRecordsById(postDocument.values);
   const classById = indexRecordsById(postDocument.classes);
   const memberById2 = indexRecordsById(postDocument.members);
-  const constructorById = indexRecordsById(postDocument.constructors ?? []);
+  const constructorById2 = indexRecordsById(postDocument.constructors ?? []);
   let baseHashByValueId = null;
   for (const variant of variants) {
     const root = valueById.get(variant.valueId);
@@ -98335,7 +98745,7 @@ function reconcileVariantConstructorArgs(args) {
     if (schemaClass2 === void 0) continue;
     const constructorId = schemaClass2.requiredConstructorId;
     if (typeof constructorId !== "string") continue;
-    const constructorRecord = constructorById.get(constructorId);
+    const constructorRecord = constructorById2.get(constructorId);
     if (constructorRecord === void 0) continue;
     if (typeof root.value !== "object" || root.value === null) continue;
     if (Array.isArray(root.value)) continue;
@@ -99508,7 +99918,7 @@ function animationFamilyClasses(document) {
   const classes = new Map(document.classes.map((entry) => [entry.id, entry]));
   const animationKinds = new Set(WORLD_SYSTEM_ANIMATION_KINDS);
   const result = /* @__PURE__ */ new Map();
-  const resolve4 = (classId, visiting) => {
+  const resolve5 = (classId, visiting) => {
     const cached = result.get(classId);
     if (cached !== void 0) return cached;
     if (visiting.has(classId)) return false;
@@ -99520,11 +99930,11 @@ function animationFamilyClasses(document) {
       return true;
     }
     const nextVisiting = new Set(visiting).add(classId);
-    const belongs = typeof schemaClass2.extendsClassId === "string" && resolve4(schemaClass2.extendsClassId, nextVisiting);
+    const belongs = typeof schemaClass2.extendsClassId === "string" && resolve5(schemaClass2.extendsClassId, nextVisiting);
     result.set(classId, belongs);
     return belongs;
   };
-  for (const classId of classes.keys()) resolve4(classId, /* @__PURE__ */ new Set());
+  for (const classId of classes.keys()) resolve5(classId, /* @__PURE__ */ new Set());
   return new Set(
     [...result].flatMap(([classId, belongs]) => belongs ? [classId] : [])
   );
@@ -101351,7 +101761,7 @@ function classBelongsToAnimationFamily(classes, classId) {
 function prospectiveAnimationDocumentV4(records2) {
   const candidates = [...records2];
   const hasAnimationSchema = candidates.some(
-    (record3) => record3.recordKind === "class" && (Array.isArray(record3.data.constructorProjections) || declaresAnimationWorldKind(record3.data.system))
+    (record3) => record3.recordKind === "class" && declaresAnimationWorldKind(record3.data.system)
   );
   if (!hasAnimationSchema) return null;
   const memberRecords = new Map(
@@ -104998,14 +105408,6 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
     const assignmentSlices = objectInitializerSlices(binding.initializer);
     for (const assignment of expression.initializer ?? []) {
       const childMember = classMemberByName(context, classId, assignment.name);
-      if (inheritedLegacyConstructorProjections(
-        context.classes,
-        schemaClass2.id
-      ).some((projection) => projection.memberId === childMember.id)) {
-        throw new Error(
-          `Default value ${binding.label}.${assignment.name} is constructor-projected and must be set through its named constructor argument.`
-        );
-      }
       const childValueMember = recursivePartialMember(member, childMember);
       const childSlice = assignmentSlices.get(assignment.name);
       const existingId = isObjectRecord2(baseBody) ? baseBody[assignment.name] : void 0;
@@ -105645,14 +106047,6 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
         effectiveClass.id,
         assignment.name
       );
-      if (!partial && inheritedLegacyConstructorProjections(
-        context.classes,
-        effectiveClass.id
-      ).some((projection) => projection.memberId === childMember.id)) {
-        throw new Error(
-          `Class value ${path}.${assignment.name} is constructor-projected and must be set through its named constructor argument.`
-        );
-      }
       const childPath = `${path}.${assignment.name}`;
       const childId = lowerSeedChild(
         context,
@@ -106417,14 +106811,6 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
   }
   for (const assignment of expression.initializer ?? []) {
     const childMember = classMemberByName(context, classId, assignment.name);
-    if (!partial && inheritedLegacyConstructorProjections(
-      context.classes,
-      schemaClass2.id
-    ).some((projection) => projection.memberId === childMember.id)) {
-      throw new Error(
-        `Class value ${String(base.id)}.${assignment.name} is constructor-projected and must be set through its named constructor argument.`
-      );
-    }
     const childId = baseBody[assignment.name];
     if (typeof childId !== "string") {
       const symbolId2 = sourceValueSymbol(context, assignment.value);
@@ -106750,24 +107136,10 @@ function classInheritanceChain(classes, classId) {
   }
   return chain;
 }
-function inheritedLegacyConstructorProjections(classes, classId) {
-  const resolved = [];
-  const claimed = /* @__PURE__ */ new Set();
-  for (const schemaClass2 of classInheritanceChain(classes, classId)) {
-    for (const projection of schemaClass2.constructorProjections ?? []) {
-      if (claimed.has(projection.parameterName)) continue;
-      claimed.add(projection.parameterName);
-      resolved.push(projection);
-    }
-  }
-  return resolved;
-}
 function effectiveConstructorProjections(classes, constructors, members, classId) {
   const schemaClass2 = classes.get(classId);
   const requiredId = schemaClass2?.requiredConstructorId;
-  if (schemaClass2 === void 0 || requiredId === void 0) {
-    return inheritedLegacyConstructorProjections(classes, classId);
-  }
+  if (schemaClass2 === void 0 || requiredId === void 0) return [];
   const required2 = constructors.get(requiredId);
   if (required2 === void 0) return [];
   const projected = requiredConstructorProjectionMap(
@@ -107015,7 +107387,10 @@ function inferAnimationChildOverrideLowerEnvironment(context, schemaClass2, expr
     return inherited;
   }
   const parameter4 = schemaClass2.genericParameters[0];
-  const parameterName = schemaClass2.constructorProjections?.[0]?.parameterName ?? requiredConstructorFirstParameterName(context, schemaClass2);
+  const parameterName = requiredConstructorFirstParameterName(
+    context,
+    schemaClass2
+  );
   if (parameter4 === void 0 || parameterName === null) return inherited;
   const argumentIndex = expression.argumentNames?.findIndex(
     (name) => name === parameterName
@@ -110386,8 +110761,157 @@ var init_value_sources = __esm({
   }
 });
 
+// src/project-source/workspace-source-path.ts
+import { existsSync as existsSync3, lstatSync, realpathSync } from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute2, relative, resolve as resolve2, sep } from "node:path";
+function normalizeWorkspaceSourcePath(path) {
+  const normalized = path.replaceAll("\\", "/");
+  if (normalized.length === 0) {
+    throw new Error("Project source path is empty.");
+  }
+  if (normalized.includes("\0")) {
+    throw new Error(
+      `Project source path ${JSON.stringify(path)} contains a null byte.`
+    );
+  }
+  if (isAbsolute2(normalized)) {
+    throw new Error(`Project source path ${JSON.stringify(path)} is absolute.`);
+  }
+  if (/^[A-Za-z]:\//u.test(normalized)) {
+    throw new Error(
+      `Project source path ${JSON.stringify(path)} is a Windows absolute path.`
+    );
+  }
+  const parts = normalized.split("/");
+  for (const part of parts) {
+    if (part === "") {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} contains an empty segment.`
+      );
+    }
+    if (part === ".") {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} contains a current-directory segment.`
+      );
+    }
+    if (part === "..") {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} contains a parent-directory segment.`
+      );
+    }
+  }
+  return normalized;
+}
+function createWorkspaceSourcePathResolver(root) {
+  const rootAbsolute = resolve2(root);
+  const rootReal = realpathSync(rootAbsolute);
+  return (path) => {
+    const normalized = normalizeWorkspaceSourcePath(path);
+    const absolute = resolve2(rootAbsolute, normalized);
+    if (!containsPath(rootAbsolute, absolute)) {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} escapes the workspace.`
+      );
+    }
+    const target = lstatSync(absolute, { throwIfNoEntry: false });
+    if (target?.isSymbolicLink()) {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} targets a symbolic link.`
+      );
+    }
+    let existing = target === void 0 ? dirname4(absolute) : absolute;
+    while (!existsSync3(existing)) existing = dirname4(existing);
+    if (!containsPath(rootReal, realpathSync(existing))) {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} traverses outside the workspace.`
+      );
+    }
+    return absolute;
+  };
+}
+function containsPath(parent, candidate) {
+  const fromParent = relative(parent, candidate);
+  return fromParent === "" || !isAbsolute2(fromParent) && fromParent !== ".." && !fromParent.startsWith(`..${sep}`);
+}
+var init_workspace_source_path = __esm({
+  "src/project-source/workspace-source-path.ts"() {
+    "use strict";
+  }
+});
+
 // src/project-source/project-documents.ts
-function emitProjectDocumentFilesV4(records2) {
+function projectRecordFilesV4(...collections) {
+  const files = /* @__PURE__ */ new Map();
+  for (const records2 of collections) {
+    for (const record3 of records2) {
+      if (record3.file === void 0 || record3.file === null) continue;
+      files.set(`${record3.recordKind}:${record3.recordId}`, record3.file);
+    }
+  }
+  return files;
+}
+function authoredDefinitionPathV4(file, recordFiles) {
+  let path = null;
+  for (const key of file.recordKeys) {
+    const candidate = recordFiles.get(key);
+    if (candidate === void 0) continue;
+    const normalizedCandidate = normalizeWorkspaceSourcePath(candidate);
+    if (neoProjectSourceKind(normalizedCandidate) !== "definition") continue;
+    if (path !== null && path !== normalizedCandidate) return null;
+    path = normalizedCandidate;
+  }
+  return path;
+}
+function retainAuthoredDefinitionGroupingV4(files, recordFiles) {
+  const grouped = /* @__PURE__ */ new Map();
+  const paths = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const authoredPath = authoredDefinitionPathV4(file, recordFiles);
+    const path = authoredPath ?? file.path;
+    const folded = invariantCaseKey(path);
+    const prior = grouped.get(folded);
+    paths.set(file.path, path);
+    if (prior === void 0) {
+      grouped.set(folded, {
+        path,
+        content: [file.content],
+        recordKeys: file.recordKeys.slice(),
+        authored: authoredPath !== null
+      });
+      continue;
+    }
+    if (prior.path !== path) {
+      if (prior.authored && authoredPath !== null) {
+        throw new Error(
+          `Authored record placements have a case-insensitive project source path collision between ${JSON.stringify(prior.path)} and ${JSON.stringify(path)}.`
+        );
+      }
+      if (authoredPath !== null) prior.path = path;
+      else if (!prior.authored) {
+        throw new Error(
+          `Canonical emission has a case-insensitive project source path collision between ${JSON.stringify(prior.path)} and ${JSON.stringify(path)}.`
+        );
+      }
+    }
+    prior.content.push(file.content);
+    for (const key of file.recordKeys) prior.recordKeys.push(key);
+    prior.authored ||= authoredPath !== null;
+    paths.set(file.path, prior.path);
+  }
+  for (const [canonicalPath2, targetPath] of paths) {
+    const finalPath = grouped.get(invariantCaseKey(targetPath))?.path;
+    if (finalPath !== void 0) paths.set(canonicalPath2, finalPath);
+  }
+  return {
+    files: grouped.values().map((file) => ({
+      path: file.path,
+      content: file.content.join("\n"),
+      recordKeys: file.recordKeys
+    })).toArray().sort((left, right) => compareCodePoints(left.path, right.path)),
+    paths
+  };
+}
+function emitProjectDocumentFilesV4(records2, options = {}) {
   const schemaRecords = [];
   for (const record3 of records2.values()) {
     if (record3.deleted || !isSchemaRecordKindV4(record3.recordKind)) continue;
@@ -110417,69 +110941,79 @@ function emitProjectDocumentFilesV4(records2) {
     collectionValuePaths: rootValuePathsByValueId(records2.values()),
     variantInitializers: variantValues.initializers
   });
+  const sourceFiles = baseSource.files.map((file) => {
+    const ownedKeys = [];
+    for (const key of file.recordKeys) {
+      if (key.startsWith("variant:")) {
+        for (const ownedKey of variantValues.recordKeysByVariant.get(
+          key.slice(8)
+        ) ?? []) {
+          ownedKeys.push(ownedKey);
+        }
+        continue;
+      }
+      if (!key.startsWith("member:")) continue;
+      const memberId = key.slice(7);
+      for (const ownedKey of staticValues.recordKeysByMember.get(memberId) ?? []) {
+        ownedKeys.push(ownedKey);
+      }
+      for (const ownedKey of memberDefaults.recordKeysByMember.get(memberId) ?? []) {
+        ownedKeys.push(ownedKey);
+      }
+    }
+    return ownedKeys.length === 0 ? file : { ...file, recordKeys: file.recordKeys.concat(ownedKeys) };
+  });
   const source = {
     ...baseSource,
-    files: baseSource.files.map((file) => {
-      const ownedKeys = file.recordKeys.flatMap((key) => {
-        if (key.startsWith("variant:")) {
-          return [
-            ...variantValues.recordKeysByVariant.get(key.slice(8)) ?? []
-          ];
-        }
-        if (!key.startsWith("member:")) return [];
-        const memberId = key.slice(7);
-        return [
-          ...staticValues.recordKeysByMember.get(memberId) ?? [],
-          ...memberDefaults.recordKeysByMember.get(memberId) ?? []
-        ];
-      });
-      return ownedKeys.length === 0 ? file : { ...file, recordKeys: [...file.recordKeys, ...ownedKeys] };
-    })
+    files: sourceFiles
   };
   const classNames = new IdentifierTable();
   for (const schemaClass2 of manifest.classes) {
     classNames.assign(schemaClass2.id, schemaClass2.name);
   }
-  const migrationFiles = [...records2.values()].filter((record3) => !record3.deleted && record3.recordKind === "migration").map((record3) => {
+  const migrationFiles = records2.values().filter((record3) => !record3.deleted && record3.recordKind === "migration").map((record3) => {
     const emitted = emitMigrationFile(record3, classNames);
     return {
       path: emitted.path,
       content: emitted.content,
       recordKeys: emitted.recordKeys
     };
-  });
+  }).toArray();
   const supplementalFiles = emitSupplementalProjectSourcesV4(records2);
-  const materializedConstructors = new Map([
-    ...staticValues.materializedConstructors,
-    ...memberDefaults.materializedConstructors
-  ]);
-  const materializedConstructorOverrideKeys = new Map([
-    ...staticValues.materializedConstructorOverrideKeys,
-    ...memberDefaults.materializedConstructorOverrideKeys
-  ]);
+  const materializedConstructors = new Map(
+    staticValues.materializedConstructors
+  );
+  for (const [key, value] of memberDefaults.materializedConstructors) {
+    materializedConstructors.set(key, value);
+  }
+  const materializedConstructorOverrideKeys = new Map(
+    staticValues.materializedConstructorOverrideKeys
+  );
+  for (const [
+    key,
+    value
+  ] of memberDefaults.materializedConstructorOverrideKeys) {
+    materializedConstructorOverrideKeys.set(key, value);
+  }
   const rootFile = emitProjectRootSourceV4(
     records2,
     manifest,
     materializedConstructors
   );
   const dialogueFiles = emitDialogueProjectSourcesV4(records2);
-  const files = [
-    ...source.files,
-    ...rootFile ? [rootFile] : [],
-    ...supplementalFiles,
-    ...dialogueFiles,
-    ...migrationFiles
-  ].sort((left, right) => compareCodePoints(left.path, right.path));
-  const recordFiles = new Map(source.recordFiles);
-  for (const file of source.files) {
-    for (const key of file.recordKeys) recordFiles.set(key, file.path);
-  }
-  for (const file of [
-    ...rootFile ? [rootFile] : [],
-    ...supplementalFiles,
-    ...dialogueFiles,
-    ...migrationFiles
-  ]) {
+  const grouped = retainAuthoredDefinitionGroupingV4(
+    [
+      source.files,
+      rootFile === null ? [] : [rootFile],
+      supplementalFiles,
+      dialogueFiles,
+      migrationFiles
+    ].values().flatMap((files2) => files2.values()),
+    options.recordFiles ?? /* @__PURE__ */ new Map()
+  );
+  const files = grouped.files;
+  const recordFiles = /* @__PURE__ */ new Map();
+  for (const file of files) {
     for (const key of file.recordKeys) recordFiles.set(key, file.path);
   }
   for (const recovery of staticMemberOwnershipRecoveries) {
@@ -110517,7 +111051,10 @@ ${errors.map(
     analysis,
     materializedConstructors,
     materializedConstructorOverrideKeys,
-    formAlternates: source.formAlternates,
+    formAlternates: source.formAlternates.map((alternate) => ({
+      ...alternate,
+      path: grouped.paths.get(alternate.path) ?? alternate.path
+    })),
     staticMemberOwnershipRecoveries
   };
 }
@@ -110572,6 +111109,7 @@ var init_project_documents = __esm({
     init_source_diagnostics();
     init_source_format();
     init_static_member_ownership_recovery();
+    init_workspace_source_path();
     PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH = ".neo/project-source-analysis-v4.json";
     SCHEMA_RECORD_KINDS2 = /* @__PURE__ */ new Set([
       "class",
@@ -110593,7 +111131,7 @@ var init_project_documents = __esm({
 // src/project-source/project-document-cache.ts
 import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { createHash as createHash6 } from "node:crypto";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname5, join as join5 } from "node:path";
 function readProjectSourceAnalysisBuildCacheV4(root, sources) {
   try {
     const parsed = JSON.parse(
@@ -110612,12 +111150,12 @@ function readProjectSourceAnalysisBuildCacheV4(root, sources) {
 }
 function writeProjectSourceAnalysisCacheV4(root, analysis, sources) {
   const file = join5(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
-  mkdirSync5(dirname4(file), { recursive: true });
+  mkdirSync5(dirname5(file), { recursive: true });
   writeFileSync5(file, `${JSON.stringify(analysis, null, 2)}
 `, "utf8");
   if (sources === void 0) return;
   const buildFile = join5(root, PROJECT_SOURCE_BUILD_CACHE_PATH);
-  mkdirSync5(dirname4(buildFile), { recursive: true });
+  mkdirSync5(dirname5(buildFile), { recursive: true });
   const temporary = `${buildFile}.${process.pid}.tmp`;
   writeFileSync5(
     temporary,
@@ -110688,7 +111226,7 @@ function readProjectSourceDocumentBuildCacheV1(root, sources) {
 }
 function writeProjectSourceDocumentBuildCacheV1(root, sources, documents) {
   const file = join5(root, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH);
-  mkdirSync5(dirname4(file), { recursive: true });
+  mkdirSync5(dirname5(file), { recursive: true });
   const temporary = `${file}.${process.pid}.tmp`;
   writeFileSync5(
     temporary,
@@ -110754,7 +111292,7 @@ var init_project_document_cache = __esm({
 // src/project-source/project-files.ts
 import { createHash as createHash7 } from "node:crypto";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync6,
   readdirSync,
@@ -110762,7 +111300,7 @@ import {
   rmSync as rmSync2,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { basename, dirname as dirname5, extname, join as join6, relative, sep } from "node:path";
+import { basename, dirname as dirname6, extname, join as join6, relative as relative2, sep as sep2 } from "node:path";
 function lowerProjectFileRegistrySourcesV4(root, state, analysis, options = {}) {
   const templateIds = fileTemplateIdsByName2(analysis);
   const declarations = analysis.files.registries.flatMap(
@@ -110797,12 +111335,12 @@ function lowerProjectFileRegistrySourcesV4(root, state, analysis, options = {})
     const trustedPending = options.trustedPendingFiles?.get(
       declaration.recordId
     );
-    if (base === null && !existsSync3(absolute) && trustedPending === void 0) {
+    if (base === null && !existsSync4(absolute) && trustedPending === void 0) {
       throw new Error(
         `Pending project file ${declaration.symbol} is missing bytes at ${normalizedPath}.`
       );
     }
-    const binary = existsSync3(absolute) ? inspectBinaryFile(absolute, normalizedPath) : trustedPending === void 0 ? null : {
+    const binary = existsSync4(absolute) ? inspectBinaryFile(absolute, normalizedPath) : trustedPending === void 0 ? null : {
       path: normalizedPath,
       kind: declaration.kind,
       mimeType: trustedPending.mimeType,
@@ -110904,7 +111442,7 @@ function inspectProjectBinaryStatusV4(root, state, analysis) {
     const baseState = state[`project-file:${declaration.recordId}`];
     const data = isObjectRecord2(baseState?.data) ? baseState.data : {};
     const absolute = join6(root, declaration.path);
-    const local = existsSync3(absolute) ? inspectBinaryFile(absolute, declaration.path) : null;
+    const local = existsSync4(absolute) ? inspectBinaryFile(absolute, declaration.path) : null;
     const baseSha256 = baseState?.projectBinary?.sha256 ?? normalizeSha256V4(
       data.contentSha256,
       `project-file:${declaration.recordId} metadata`
@@ -110976,9 +111514,9 @@ function discoverProjectBinariesV4(root, explicit, ignoredPaths = []) {
   const candidates = [];
   for (const directory of ["Files/Images", "Files/AudioClips"]) {
     const absoluteDirectory = join6(root, directory);
-    if (!existsSync3(absoluteDirectory)) continue;
+    if (!existsSync4(absoluteDirectory)) continue;
     visitBinaryFiles(absoluteDirectory, (absolute) => {
-      const path = normalizeSlash2(relative(root, absolute));
+      const path = normalizeSlash2(relative2(root, absolute));
       if (!explicitPaths.has(path.toLowerCase())) {
         candidates.push({ stableId: path, path, absolute });
       }
@@ -111026,7 +111564,7 @@ function writeVerifiedBinaryDownloadV4(destination, bytes, expectedSha256) {
       `Downloaded project file checksum ${actual} did not match expected SHA-256 ${expectedSha256}.`
     );
   }
-  mkdirSync6(dirname5(destination), { recursive: true });
+  mkdirSync6(dirname6(destination), { recursive: true });
   const temporary = `${destination}.neo-download-${process.pid}`;
   try {
     writeFileSync6(temporary, bytes);
@@ -111045,7 +111583,7 @@ function writeBinaryConflictArtifactV4(root, fileId, fileName2, bytes, expectedS
     safeFileName2(fileName2)
   );
   writeVerifiedBinaryDownloadV4(destination, bytes, expectedSha256);
-  return normalizeSlash2(relative(root, destination));
+  return normalizeSlash2(relative2(root, destination));
 }
 function fileTemplateIdsByName2(analysis) {
   const templateIds = /* @__PURE__ */ new Map();
@@ -111234,7 +111772,7 @@ function safePathSegment2(value) {
   return value.replace(/[^A-Za-z0-9._-]/g, "_") || "file";
 }
 function normalizeSlash2(value) {
-  return value.split(sep).join("/").replaceAll("\\", "/");
+  return value.split(sep2).join("/").replaceAll("\\", "/");
 }
 var SUPPORTED_BINARY_TYPES, REGISTRY_ENTRY2, assignDeterministicFileSymbols2;
 var init_project_files = __esm({
@@ -111277,12 +111815,12 @@ var init_supplemental_records_file_system = __esm({
 });
 
 // src/project-source/workspace-status.ts
-import { existsSync as existsSync4, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "node:fs";
-import { join as join7, relative as relative2, sep as sep2 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "node:fs";
+import { join as join7, relative as relative3, sep as sep3 } from "node:path";
 function isGitIgnored(scopes, absolutePath, directory) {
   return isNeoGitIgnored(
     scopes.map((scope) => ({
-      relativePath: relative2(scope.root, absolutePath),
+      relativePath: relative3(scope.root, absolutePath),
       matcher: scope.matcher
     })),
     directory
@@ -111290,7 +111828,7 @@ function isGitIgnored(scopes, absolutePath, directory) {
 }
 function addGitIgnoreScope(directory, inherited) {
   const path = join7(directory, ".gitignore");
-  if (!existsSync4(path)) return inherited;
+  if (!existsSync5(path)) return inherited;
   return [
     ...inherited,
     { root: directory, matcher: (0, import_ignore.default)().add(readFileSync7(path, "utf8")) }
@@ -111300,7 +111838,7 @@ function listNeoWorkspaceFilesV1(root) {
   const production = [];
   const specs = [];
   const visit = (directory, inheritedScopes) => {
-    if (!existsSync4(directory)) return;
+    if (!existsSync5(directory)) return;
     const scopes = addGitIgnoreScope(directory, inheritedScopes);
     for (const entry of readdirSync2(directory, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) continue;
@@ -111312,7 +111850,7 @@ function listNeoWorkspaceFilesV1(root) {
         continue;
       }
       if (!entry.isFile() || isGitIgnored(scopes, path, false)) continue;
-      const relativePath = relative2(root, path).split(sep2).join("/");
+      const relativePath = relative3(root, path).split(sep3).join("/");
       const kind = neoProjectSourceKind(relativePath);
       if (kind === null) continue;
       if (kind === "spec") specs.push(path);
@@ -111332,7 +111870,7 @@ function listProjectTestFilesV1(root) {
 }
 function computeWorkspaceStatus2(workspace, options = {}) {
   const virtualSourceFiles = options.virtualSourceFiles ?? listProjectSourceFilesV4(workspace.root).map((path) => ({
-    path: relative2(workspace.root, path).split(sep2).join("/"),
+    path: relative3(workspace.root, path).split(sep3).join("/"),
     content: readFileSync7(path, "utf8")
   }));
   return computeWorkspaceStatus(workspace, {
@@ -112344,7 +112882,7 @@ var init_source_record_comparison = __esm({
 
 // src/project-source/reset.ts
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync8,
   readdirSync as readdirSync3,
@@ -112352,12 +112890,20 @@ import {
   writeFileSync as writeFileSync7,
   statSync
 } from "node:fs";
-import { dirname as dirname6, join as join8 } from "node:path";
+import { dirname as dirname7, join as join8 } from "node:path";
 function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   const emissionRecords = options.regenerateSourceNames ? regenerateDialogueSourceNamesV4(document.records) : document.records;
-  const emitted = emitProjectDocumentFilesV4(emissionRecords);
+  const emitted = emitProjectDocumentFilesV4(emissionRecords, {
+    recordFiles: projectRecordFilesV4(Object.values(workspace.state.records))
+  });
   assertUniqueEmittedPaths2(emitted.files);
-  const previous = managedFilesBeforeReset(workspace.root);
+  const resolveSourcePath = createWorkspaceSourcePathResolver(workspace.root);
+  const trackedSources = trackedProductionSourcesBeforeReset(
+    workspace,
+    resolveSourcePath
+  );
+  const previous = new Set(managedFilesBeforeReset(workspace.root));
+  for (const path of trackedSources) previous.add(path);
   const preservedSpecs = preserveManagedSpecs(workspace.root);
   for (const directory of FORMAT_4_MANAGED_DIRECTORIES) {
     rmSync3(join8(workspace.root, directory), { recursive: true, force: true });
@@ -112369,15 +112915,18 @@ function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   for (const privatePath of LEGACY_PRIVATE_PATHS) {
     rmSync3(join8(workspace.root, privatePath), { recursive: true, force: true });
   }
+  for (const path of trackedSources) {
+    rmSync3(resolveSourcePath(path), { force: true });
+  }
   for (const [path, bytes] of preservedSpecs) {
     const absolute = join8(workspace.root, path);
-    mkdirSync7(dirname6(absolute), { recursive: true });
+    mkdirSync7(dirname7(absolute), { recursive: true });
     writeFileSync7(absolute, bytes);
   }
   for (const file of emitted.files) {
-    const absolute = join8(workspace.root, file.path);
-    mkdirSync7(dirname6(absolute), { recursive: true });
-    if (existsSync5(absolute) && readFileSync8(absolute, "utf8") === file.content) {
+    const absolute = resolveSourcePath(file.path);
+    mkdirSync7(dirname7(absolute), { recursive: true });
+    if (existsSync6(absolute) && readFileSync8(absolute, "utf8") === file.content) {
       continue;
     }
     writeFileSync7(absolute, file.content, "utf8");
@@ -112404,7 +112953,7 @@ function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   workspace.config = { ...workspace.config, formatVersion: 4 };
   writeWorkspaceConfig(workspace.root, workspace.config);
   const removed = [...previous].filter(
-    (file) => !existsSync5(join8(workspace.root, file))
+    (file) => !existsSync6(join8(workspace.root, file))
   ).length;
   return {
     written: emitted.files.length,
@@ -112417,7 +112966,7 @@ function preserveManagedSpecs(root) {
   const specs = /* @__PURE__ */ new Map();
   const visit = (path) => {
     const absolute = join8(root, path);
-    if (!existsSync5(absolute)) return;
+    if (!existsSync6(absolute)) return;
     const entries = readdirSync3(absolute, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
@@ -112432,6 +112981,20 @@ function preserveManagedSpecs(root) {
   for (const directory of FORMAT_4_MANAGED_DIRECTORIES) visit(directory);
   return specs;
 }
+function trackedProductionSourcesBeforeReset(workspace, resolveSourcePath) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const record3 of Object.values(workspace.state.records)) {
+    if (record3.file === void 0) continue;
+    const path = normalizeWorkspaceSourcePath(record3.file);
+    const kind = neoProjectSourceKind(path);
+    if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
+      continue;
+    }
+    const absolute = resolveSourcePath(path);
+    if (existsSync6(absolute)) paths.add(path);
+  }
+  return paths;
+}
 function assertUniqueEmittedPaths2(files) {
   const seen = /* @__PURE__ */ new Map();
   for (const file of files) {
@@ -112451,7 +113014,7 @@ function managedFilesBeforeReset(root) {
     collectFiles(root, directory, files);
   }
   for (const file of LEGACY_ROOT_FILES) {
-    if (existsSync5(join8(root, file))) files.add(file);
+    if (existsSync6(join8(root, file))) files.add(file);
   }
   for (const privatePath of LEGACY_PRIVATE_PATHS) {
     collectFiles(root, privatePath, files);
@@ -112460,7 +113023,7 @@ function managedFilesBeforeReset(root) {
 }
 function collectFiles(root, path, files) {
   const absolute = join8(root, path);
-  if (!existsSync5(absolute)) return;
+  if (!existsSync6(absolute)) return;
   if (statSync(absolute).isFile()) {
     files.add(path);
     return;
@@ -112479,11 +113042,13 @@ var FORMAT_4_MANAGED_DIRECTORIES, LEGACY_ROOT_FILES, LEGACY_PRIVATE_PATHS;
 var init_reset = __esm({
   "src/project-source/reset.ts"() {
     "use strict";
+    init_src();
     init_workspace();
     init_project_documents();
     init_project_document_cache();
     init_materialized_construction_cache();
     init_dialogue_sources();
+    init_workspace_source_path();
     FORMAT_4_MANAGED_DIRECTORIES = [
       "Classes",
       "Interfaces",
@@ -112624,7 +113189,7 @@ var init_http = __esm({
 });
 
 // src/project-source/project-file-pull.ts
-import { existsSync as existsSync6, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync7, rmSync as rmSync4 } from "node:fs";
 import { join as join9 } from "node:path";
 async function pullProjectBinariesV4(args) {
   let client = args.client ?? null;
@@ -112648,7 +113213,7 @@ async function pullProjectBinariesV4(args) {
     const declarationPresent = args.destructive === true || args.localBinaries === void 0 || previous === void 0 || localStatus !== void 0;
     const path = localStatus?.path ?? previous?.projectBinary?.path ?? canonicalProjectBinaryPathV42(record3.data);
     const absolute = join9(args.workspace.root, path);
-    const localDigest = existsSync6(absolute) ? sha256File(absolute) : null;
+    const localDigest = existsSync7(absolute) ? sha256File(absolute) : null;
     const baseDigest = previous?.projectBinary?.sha256 ?? readSha256(previous?.data) ?? null;
     const remoteDigest = requiredSha256(
       record3.data,
@@ -112731,7 +113296,7 @@ async function pullProjectBinariesV4(args) {
     const localStatus = localById.get(previous.recordId);
     const path = localStatus?.path ?? previous.projectBinary?.path ?? canonicalProjectBinaryPathV42(previous.data);
     const absolute = join9(args.workspace.root, path);
-    const localDigest = existsSync6(absolute) ? sha256File(absolute) : null;
+    const localDigest = existsSync7(absolute) ? sha256File(absolute) : null;
     const baseDigest = previous.projectBinary?.sha256 ?? readSha256(previous.data) ?? null;
     const action = planBinaryMergeV4({
       baseDigest,
@@ -112916,10 +113481,10 @@ import {
   mkdirSync as mkdirSync8,
   writeFileSync as writeFileSync8,
   rmSync as rmSync5,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   readFileSync as readFileSync9
 } from "node:fs";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { dirname as dirname8 } from "node:path";
 async function runPull(workspace, options) {
   if (options.reset) {
     await runResetPull(workspace);
@@ -113241,12 +113806,19 @@ async function finishFormat4Pull(args) {
       ([key, record3]) => localRecords.get(key) === record3 ? [] : [key]
     )
   );
-  const localResult = emitProjectDocumentFilesV4(localRecords);
+  const recordFiles = projectRecordFilesV4(
+    Object.values(workspace.state.records),
+    localStatus?.reconstructed.values() ?? []
+  );
+  const localResult = emitProjectDocumentFilesV4(localRecords, {
+    recordFiles
+  });
   for (const recovery of localResult.staticMemberOwnershipRecoveries ?? []) {
     warn(staticMemberOwnershipRecoveryMessage(recovery));
   }
   const serverResult = conflictCount === 0 ? null : emitProjectDocumentFilesV4(
-    buildEmitRecordSet(document, plans, "server")
+    buildEmitRecordSet(document, plans, "server"),
+    { recordFiles }
   );
   const binaries = await pullProjectBinariesV4({
     workspace,
@@ -113285,6 +113857,7 @@ async function finishFormat4Pull(args) {
     const path = localResult.recordFiles.get(key);
     if (path !== void 0) rewritePaths.add(path);
   }
+  const resolveSourcePath = createWorkspaceSourcePathResolver(workspace.root);
   let written = 0;
   for (const path of emittedPaths) {
     const local = localByPath.get(path)?.content;
@@ -113295,9 +113868,9 @@ async function finishFormat4Pull(args) {
       versionId: workspace.config.versionId
     }) : local;
     if (content === void 0) continue;
-    const absolute = join10(workspace.root, path);
-    mkdirSync8(dirname7(absolute), { recursive: true });
-    const existing = existsSync7(absolute) ? readFileSync9(absolute, "utf8") : null;
+    const absolute = resolveSourcePath(path);
+    mkdirSync8(dirname8(absolute), { recursive: true });
+    const existing = existsSync8(absolute) ? readFileSync9(absolute, "utf8") : null;
     if (existing !== null && !rewritePaths.has(path)) continue;
     if (existing !== content) {
       writeFileSync8(absolute, content, "utf8");
@@ -113307,9 +113880,13 @@ async function finishFormat4Pull(args) {
   let removed = 0;
   for (const recordState of Object.values(workspace.state.records)) {
     const previousPath = recordState.file;
-    if (previousPath === void 0 || emittedPaths.has(previousPath)) continue;
-    const absolute = join10(workspace.root, previousPath);
-    if (existsSync7(absolute)) {
+    if (previousPath === void 0) continue;
+    const normalizedPreviousPath = normalizeWorkspaceSourcePath(previousPath);
+    if (emittedPaths.has(normalizedPreviousPath)) {
+      continue;
+    }
+    const absolute = resolveSourcePath(previousPath);
+    if (existsSync8(absolute)) {
       rmSync5(absolute);
       removed += 1;
     }
@@ -113601,6 +114178,7 @@ var init_pull = __esm({
     init_project_documents();
     init_project_document_cache();
     init_materialized_construction_cache();
+    init_workspace_source_path();
     init_project_manifest();
     init_project_documents();
     init_project_file_pull();
@@ -113615,8 +114193,8 @@ var init_exports = {};
 __export(init_exports, {
   runInit: () => runInit
 });
-import { existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join11, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join11, resolve as resolve3 } from "node:path";
 async function runInit(options) {
   let projectId = options.projectId;
   let projects = [];
@@ -113712,8 +114290,8 @@ async function runInit(options) {
       validate: (value) => value.trim().length > 0 ? true : "Directory must not be empty."
     }) : "neo";
   }
-  const root = resolve2(directory);
-  if (existsSync8(join11(root, NEO_CONFIG_FILE))) {
+  const root = resolve3(directory);
+  if (existsSync9(join11(root, NEO_CONFIG_FILE))) {
     throw new Error(`"${join11(root, NEO_CONFIG_FILE)}" already exists.`);
   }
   mkdirSync9(root, { recursive: true });
@@ -113740,7 +114318,7 @@ async function runInit(options) {
 }
 function ensurePrivateStateIgnored(root) {
   const path = join11(root, ".gitignore");
-  const existing = existsSync8(path) ? readFileSync10(path, "utf8") : "";
+  const existing = existsSync9(path) ? readFileSync10(path, "utf8") : "";
   if (existing.split(/\r?\n/u).some((line) => line.trim() === ".neo/" || line.trim() === ".neo")) {
     return;
   }
@@ -114146,7 +114724,7 @@ async function waitForPlan(convex, planId) {
         `History plan "${plan.id}" failed: ${plan.error ?? "unknown error"}`
       );
     }
-    await new Promise((resolve4) => setTimeout(resolve4, 500));
+    await new Promise((resolve5) => setTimeout(resolve5, 500));
   }
 }
 async function printVersionLog(convex, scope) {
@@ -115145,7 +115723,7 @@ var init_save_overlay_resolution = __esm({
 });
 
 // src/commands/push-body-diagnostics.ts
-import { existsSync as existsSync9, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
 import { join as join12 } from "node:path";
 function createNeoScriptBodySourceLocator(workspace, status) {
   const textByFile = /* @__PURE__ */ new Map();
@@ -115169,7 +115747,7 @@ function createNeoScriptBodySourceLocator(workspace, status) {
       const cached = textByFile.get(file);
       if (cached !== void 0) return cached;
       const path = join12(workspace.root, file);
-      const text = existsSync9(path) ? readFileSync11(path, "utf8") : null;
+      const text = existsSync10(path) ? readFileSync11(path, "utf8") : null;
       textByFile.set(file, text);
       return text;
     }
@@ -116971,8 +117549,8 @@ var init_project_source_identity = __esm({
 // src/push-hook.ts
 import { spawn } from "node:child_process";
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync13, readdirSync as readdirSync4 } from "node:fs";
-import { join as join13, relative as relative3, sep as sep3 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync13, readdirSync as readdirSync4 } from "node:fs";
+import { join as join13, relative as relative4, sep as sep4 } from "node:path";
 function fingerprintPushInputs(workspace, options = {}) {
   const paths = /* @__PURE__ */ new Set([
     join13(workspace.root, "neo.json"),
@@ -116981,7 +117559,7 @@ function fingerprintPushInputs(workspace, options = {}) {
     ...workspace.config.unityConfigPath === void 0 ? [] : [join13(workspace.root, workspace.config.unityConfigPath)]
   ]);
   const visitManaged = (directory) => {
-    if (!existsSync10(directory)) return;
+    if (!existsSync11(directory)) return;
     for (const entry of readdirSync4(directory, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) continue;
       const path = join13(directory, entry.name);
@@ -116993,7 +117571,7 @@ function fingerprintPushInputs(workspace, options = {}) {
   visitManaged(join13(workspace.root, "Files", "AudioClips"));
   const hash = createHash9("sha256");
   for (const path of [...paths].sort()) {
-    const name = relative3(workspace.root, path).split(sep3).join("/");
+    const name = relative4(workspace.root, path).split(sep4).join("/");
     hash.update(name);
     hash.update("\0");
     try {
@@ -117420,7 +117998,7 @@ function isRetryableRequestError(error) {
   return RETRYABLE_NETWORK_ERROR_CODES.has(error.cause.code);
 }
 async function waitForRetry(attempt, signal) {
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     const abort = () => {
       clearTimeout(timeout);
       reject(signal.reason);
@@ -117428,7 +118006,7 @@ async function waitForRetry(attempt, signal) {
     const timeout = setTimeout(
       () => {
         signal.removeEventListener("abort", abort);
-        resolve4();
+        resolve5();
       },
       200 * 2 ** (attempt - 1)
     );
@@ -117661,11 +118239,11 @@ import {
   mkdirSync as mkdirSync10,
   writeFileSync as writeFileSync10,
   rmSync as rmSync6,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   readFileSync as readFileSync15,
   statSync as statSync2
 } from "node:fs";
-import { dirname as dirname8, join as join15, relative as relative4, sep as sep4 } from "node:path";
+import { dirname as dirname9, join as join15, relative as relative5, sep as sep5 } from "node:path";
 function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInitializerMaterialization) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
@@ -118206,14 +118784,14 @@ async function waitForPollDelay(delayMs, signal) {
   if (signal.aborted) {
     throw new Error("Project transaction polling was interrupted.");
   }
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     const aborted = () => {
       clearTimeout(timer);
       reject(new Error("Project transaction polling was interrupted."));
     };
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", aborted);
-      resolve4();
+      resolve5();
     }, delayMs);
     signal.addEventListener("abort", aborted, { once: true });
   });
@@ -118965,7 +119543,7 @@ async function prepareLocalCandidateV4(workspace, options = {}) {
   } else {
     const files = listProjectSourceFilesV4(workspace.root).map(
       (absolutePath) => {
-        const path = relative4(workspace.root, absolutePath).split(sep4).join("/");
+        const path = relative5(workspace.root, absolutePath).split(sep5).join("/");
         const kind = neoProjectSourceKind(path);
         if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
           throw new Error(
@@ -119284,7 +119862,12 @@ function createPendingProjectSourceIdentityV4(workspace, status, authoredValueSe
       });
     }
   }
-  const emission = emitProjectDocumentFilesV4(records2);
+  const emission = emitProjectDocumentFilesV4(records2, {
+    recordFiles: projectRecordFilesV4(
+      Object.values(workspace.state.records),
+      status.reconstructed.values()
+    )
+  });
   const files = emission.files.map((file) => {
     const kind = neoProjectSourceKind(file.path);
     if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
@@ -119490,7 +120073,12 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
   const previousState = workspace.state;
   workspace.state = { ...previousState, records: nextRecords };
   try {
-    rewriteFilesFromState(workspace, emitRecords, preservedSourceFiles);
+    rewriteFilesFromState(
+      workspace,
+      emitRecords,
+      preservedSourceFiles,
+      projectRecordFilesV4(localRecords.values())
+    );
     writeWorkspaceState(workspace.root, workspace.state);
   } catch (error) {
     workspace.state = previousState;
@@ -119676,16 +120264,30 @@ function applyPushResult(workspace, result, pendingIdAssignments = /* @__PURE__
   if (!isObjectRecord2(result) || !Array.isArray(result.changedRecords)) {
     throw new Error("Transaction response is missing changedRecords.");
   }
+  const localStatus = computeWorkspaceStatus2(workspace);
   const preservedSourceFiles = materializeAssignedSchemaIdsInAuthoredSource(
     workspace,
     pendingIdAssignments,
-    computeWorkspaceStatus2(workspace).pendingValueIdentitySites
+    localStatus.pendingValueIdentitySites
+  );
+  const replacements = {
+    exact: pendingIdAssignments,
+    embedded: pendingIdAssignments.entries().toArray().sort(([left], [right]) => right.length - left.length)
+  };
+  const localRecords = rewriteReconstructedRecords(
+    localStatus.reconstructed,
+    replacements
   );
   workspace.state.records = foldChangedRecords(
     workspace.state.records,
     result.changedRecords
   );
-  rewriteFilesFromState(workspace, void 0, preservedSourceFiles);
+  rewriteFilesFromState(
+    workspace,
+    void 0,
+    preservedSourceFiles,
+    projectRecordFilesV4(localRecords.values())
+  );
   writeWorkspaceState(workspace.root, workspace.state);
 }
 function authoredMemberFormsByFile(root, alternates) {
@@ -119695,7 +120297,7 @@ function authoredMemberFormsByFile(root, alternates) {
     let existing = contents.get(alternate.path);
     if (existing === void 0) {
       const absolute = join15(root, alternate.path);
-      existing = existsSync11(absolute) ? readFileSync15(absolute, "utf8") : null;
+      existing = existsSync12(absolute) ? readFileSync15(absolute, "utf8") : null;
       contents.set(alternate.path, existing);
     }
     if (existing === null || !existing.includes(alternate.block)) continue;
@@ -119733,14 +120335,14 @@ function fileSystemEntryKey(absolute) {
   if (!hasInode) return `path:${absolute.toLowerCase()}`;
   return `inode:${stats.dev}:${stats.ino}`;
 }
-function deleteSupersededAuthoredFiles(root, authoredPaths, emitted) {
+function deleteSupersededAuthoredFiles(resolveSourcePath, authoredPaths, emitted) {
   const emittedEntries = /* @__PURE__ */ new Set();
   for (const file of emitted) {
-    emittedEntries.add(fileSystemEntryKey(join15(root, file.path)));
+    emittedEntries.add(fileSystemEntryKey(resolveSourcePath(file.path)));
   }
   for (const authoredPath of authoredPaths) {
-    const absolute = join15(root, authoredPath);
-    if (!existsSync11(absolute)) continue;
+    const absolute = resolveSourcePath(authoredPath);
+    if (!existsSync12(absolute)) continue;
     if (emittedEntries.has(fileSystemEntryKey(absolute))) continue;
     rmSync6(absolute);
   }
@@ -119756,8 +120358,8 @@ function rewriteFilesFromState(workspace, records2 = new Map(
       data: recordState.data
     }
   ])
-), preservedSourceFiles = /* @__PURE__ */ new Map()) {
-  const result = emitProjectDocumentFilesV4(records2);
+), preservedSourceFiles = /* @__PURE__ */ new Map(), recordFiles = /* @__PURE__ */ new Map()) {
+  const result = emitProjectDocumentFilesV4(records2, { recordFiles });
   const authoredForms = authoredMemberFormsByFile(
     workspace.root,
     result.formAlternates
@@ -119788,22 +120390,27 @@ function rewriteFilesFromState(workspace, records2 = new Map(
   );
   assertAssignedIdSourceRewriteValid(finalAnalysis);
   writeProjectSourceAnalysisCacheV4(workspace.root, finalAnalysis);
+  const resolveSourcePath = createWorkspaceSourcePathResolver(workspace.root);
   const emittedPaths = new Set(files.map((file) => file.path));
   for (const recordState of Object.values(workspace.state.records)) {
     const previousPath = recordState.file;
-    if (previousPath === void 0 || emittedPaths.has(previousPath)) continue;
-    const absolute = join15(workspace.root, previousPath);
-    if (existsSync11(absolute)) rmSync6(absolute);
+    if (previousPath === void 0) continue;
+    const normalizedPreviousPath = normalizeWorkspaceSourcePath(previousPath);
+    if (emittedPaths.has(normalizedPreviousPath)) {
+      continue;
+    }
+    const absolute = resolveSourcePath(previousPath);
+    if (existsSync12(absolute)) rmSync6(absolute);
   }
   for (const file of files) {
-    const absolute = join15(workspace.root, file.path);
-    mkdirSync10(dirname8(absolute), { recursive: true });
-    const existing = existsSync11(absolute) ? readFileSync15(absolute, "utf8") : null;
+    const absolute = resolveSourcePath(file.path);
+    mkdirSync10(dirname9(absolute), { recursive: true });
+    const existing = existsSync12(absolute) ? readFileSync15(absolute, "utf8") : null;
     if (existing !== file.content)
       writeFileSync10(absolute, file.content, "utf8");
   }
   deleteSupersededAuthoredFiles(
-    workspace.root,
+    resolveSourcePath,
     preservedSourceFiles.keys(),
     files
   );
@@ -119843,7 +120450,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
   if (pendingIdsByUri.size === 0) return /* @__PURE__ */ new Map();
   const inputs = listProjectSourceFilesV4(workspace.root).map(
     (absolutePath) => {
-      const uri = relative4(workspace.root, absolutePath).split(sep4).join("/");
+      const uri = relative5(workspace.root, absolutePath).split(sep5).join("/");
       const kind = neoProjectSourceKind(uri);
       if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
         throw new Error(
@@ -120547,6 +121154,7 @@ var init_push = __esm({
     init_src();
     init_compiler_adapter();
     init_project_source_identity();
+    init_workspace_source_path();
     init_convex();
     init_http();
     init_ui();
@@ -120632,8 +121240,8 @@ var init_registry2 = __esm({
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
-      contractVersion: "3.14",
-      cliVersion: "0.38.3",
+      contractVersion: "3.15",
+      cliVersion: "0.38.5",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120739,7 +121347,6 @@ var init_registry2 = __esm({
             "allowedStorageKeys",
             "genericParams",
             "extendsGenericBindings",
-            "constructorProjections",
             "constructorIds",
             "requiredConstructorId",
             "targetMemberId"
@@ -120757,7 +121364,6 @@ var init_registry2 = __esm({
             allowedStorageKeys: "nullIsAbsent",
             genericParams: "nullOrEmptyArrayIsAbsent",
             extendsGenericBindings: "nullOrEmptyObjectIsAbsent",
-            constructorProjections: "nullOrEmptyArrayIsAbsent",
             constructorIds: "nullOrEmptyArrayIsAbsent",
             requiredConstructorId: "nullIsAbsent"
           }
@@ -121958,11 +122564,11 @@ __export(test_exports, {
 });
 import { createHash as createHash11, randomUUID as randomUUID3 } from "node:crypto";
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync11,
   readdirSync as readdirSync5,
   readFileSync as readFileSync16,
-  realpathSync,
+  realpathSync as realpathSync2,
   renameSync as renameSync5,
   rmSync as rmSync7,
   statSync as statSync3,
@@ -121970,12 +122576,12 @@ import {
 } from "node:fs";
 import {
   basename as basename3,
-  dirname as dirname9,
-  isAbsolute as isAbsolute2,
+  dirname as dirname10,
+  isAbsolute as isAbsolute3,
   join as join16,
-  relative as relative5,
-  resolve as resolve3,
-  sep as sep5
+  relative as relative6,
+  resolve as resolve4,
+  sep as sep6
 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 function isRecord10(value) {
@@ -122161,19 +122767,19 @@ function preparedHookCandidate(workspace) {
     return null;
   }
   try {
-    const directory = realpathSync(configuredDirectory);
-    const cacheRoot = resolve3(
-      realpathSync(workspace.root),
+    const directory = realpathSync2(configuredDirectory);
+    const cacheRoot = resolve4(
+      realpathSync2(workspace.root),
       ".neo",
       "test-build"
     );
-    const pathFromRoot = relative5(cacheRoot, directory);
-    if (isAbsolute2(pathFromRoot)) {
+    const pathFromRoot = relative6(cacheRoot, directory);
+    if (isAbsolute3(pathFromRoot)) {
       throw new NeoTestPreparedCandidateError(
         "NEO_PREPARED_BUILD_DIR must not resolve to an absolute path outside this workspace's .neo/test-build directory."
       );
     }
-    if (pathFromRoot === ".." || pathFromRoot.startsWith(`..${sep5}`)) {
+    if (pathFromRoot === ".." || pathFromRoot.startsWith(`..${sep6}`)) {
       throw new NeoTestPreparedCandidateError(
         "NEO_PREPARED_BUILD_DIR must resolve inside this workspace's .neo/test-build directory."
       );
@@ -122261,7 +122867,7 @@ function cachedTestCandidate(workspace, inputFingerprint) {
     }
     if (typeof parsed.documentSha256 !== "string") return null;
     const documentJson = readFileSync16(
-      join16(dirname9(candidatePath), "document.json"),
+      join16(dirname10(candidatePath), "document.json"),
       "utf8"
     );
     if (createHash11("sha256").update(documentJson).digest("hex") !== parsed.documentSha256) {
@@ -122282,7 +122888,7 @@ function cacheTestCandidate(workspace, inputFingerprint, candidate) {
   const documentJson = JSON.stringify(candidate.document);
   const documentSha256 = createHash11("sha256").update(documentJson).digest("hex");
   const candidatePath = testCandidateCachePath(workspace, inputFingerprint);
-  atomicWrite(join16(dirname9(candidatePath), "document.json"), documentJson);
+  atomicWrite(join16(dirname10(candidatePath), "document.json"), documentJson);
   atomicWrite(
     candidatePath,
     JSON.stringify({
@@ -122299,7 +122905,7 @@ function cacheTestCandidate(workspace, inputFingerprint, candidate) {
 }
 function compileSpec(workspace, document, absolutePath, projectCompilationHash2) {
   const scriptDocument = readDocumentArrays(document);
-  const path = relative5(workspace.root, absolutePath).split(sep5).join("/");
+  const path = relative6(workspace.root, absolutePath).split(sep6).join("/");
   const source = readFileSync16(absolutePath, "utf8");
   const sourceHash = createHash11("sha256").update(source).digest("hex");
   const artifactPath = join16(
@@ -122360,7 +122966,7 @@ function selectedSpecPaths(workspace, selectors) {
   const relativePaths = new Map(
     all.map((absolutePath) => [
       absolutePath,
-      relative5(workspace.root, absolutePath).split(sep5).join("/")
+      relative6(workspace.root, absolutePath).split(sep6).join("/")
     ])
   );
   const normalizedSelectors = selectors.map(
@@ -122368,22 +122974,22 @@ function selectedSpecPaths(workspace, selectors) {
   );
   for (const selector of normalizedSelectors) {
     if (/[*?]/u.test(selector)) continue;
-    if (isAbsolute2(selector)) {
+    if (isAbsolute3(selector)) {
       throw new Error(
         `Spec selector ${JSON.stringify(selector)} must be workspace-relative.`
       );
     }
-    const absolute = resolve3(workspace.root, selector);
-    const workspaceRelative = relative5(workspace.root, absolute);
-    if (workspaceRelative === ".." || workspaceRelative.startsWith(`..${sep5}`)) {
+    const absolute = resolve4(workspace.root, selector);
+    const workspaceRelative = relative6(workspace.root, absolute);
+    if (workspaceRelative === ".." || workspaceRelative.startsWith(`..${sep6}`)) {
       throw new Error(
         `Spec selector ${JSON.stringify(selector)} is outside the workspace.`
       );
     }
-    if (!existsSync12(absolute)) continue;
-    const real = realpathSync(absolute);
-    const realRelative = relative5(workspace.root, real);
-    if (realRelative === ".." || realRelative.startsWith(`..${sep5}`)) {
+    if (!existsSync13(absolute)) continue;
+    const real = realpathSync2(absolute);
+    const realRelative = relative6(workspace.root, real);
+    if (realRelative === ".." || realRelative.startsWith(`..${sep6}`)) {
       throw new Error(
         `Spec selector ${JSON.stringify(selector)} resolves outside the workspace through a symlink.`
       );
@@ -122393,7 +122999,7 @@ function selectedSpecPaths(workspace, selectors) {
         `Spec selector ${JSON.stringify(selector)} is ignored, private, symlinked, or is not a .spec.neo file.`
       );
     }
-    if (statSync3(absolute).isDirectory() && !all.some((path) => path.startsWith(`${absolute}${sep5}`))) {
+    if (statSync3(absolute).isDirectory() && !all.some((path) => path.startsWith(`${absolute}${sep6}`))) {
       throw new Error(
         `Spec selector ${JSON.stringify(selector)} is ignored, private, or contains no eligible .spec.neo files.`
       );
@@ -123126,13 +123732,13 @@ async function executeRegisteredSpec(registered, document, selected, timeoutMs,
   return { tests: results, failures: fileFailures, testDurationMs };
 }
 function atomicWrite(path, content) {
-  mkdirSync11(dirname9(path), { recursive: true });
+  mkdirSync11(dirname10(path), { recursive: true });
   const temporary = `${path}.tmp-${String(process.pid)}-${randomUUID3()}`;
   writeFileSync11(temporary, content, "utf8");
   renameSync5(temporary, path);
 }
 function testBuildFiles(root) {
-  if (!existsSync12(root)) return [];
+  if (!existsSync13(root)) return [];
   const files = [];
   const visit = (directory) => {
     for (const entry of readdirSync5(directory, { withFileTypes: true })) {
@@ -123149,16 +123755,16 @@ function testBuildFiles(root) {
   return files;
 }
 function maintainNeoTestBuildCache(root, maxBytes = TEST_BUILD_CACHE_LIMIT_BYTES, now = Date.now(), protectedDirectory = process.env.NEO_PREPARED_BUILD_DIR) {
-  const resolvedRoot = resolve3(root);
-  const resolvedProtected = protectedDirectory === void 0 ? null : resolve3(protectedDirectory);
+  const resolvedRoot = resolve4(root);
+  const resolvedProtected = protectedDirectory === void 0 ? null : resolve4(protectedDirectory);
   const protectedInsideRoot = resolvedProtected !== null && (() => {
-    const fromRoot = relative5(resolvedRoot, resolvedProtected);
-    return fromRoot === "" || !fromRoot.startsWith(`..${sep5}`) && fromRoot !== ".." && !isAbsolute2(fromRoot);
+    const fromRoot = relative6(resolvedRoot, resolvedProtected);
+    return fromRoot === "" || !fromRoot.startsWith(`..${sep6}`) && fromRoot !== ".." && !isAbsolute3(fromRoot);
   })();
   const isProtected = (path) => {
     if (!protectedInsideRoot || resolvedProtected === null) return false;
-    const fromProtected = relative5(resolvedProtected, resolve3(path));
-    return fromProtected === "" || !fromProtected.startsWith(`..${sep5}`) && fromProtected !== ".." && !isAbsolute2(fromProtected);
+    const fromProtected = relative6(resolvedProtected, resolve4(path));
+    return fromProtected === "" || !fromProtected.startsWith(`..${sep6}`) && fromProtected !== ".." && !isAbsolute3(fromProtected);
   };
   for (const file of testBuildFiles(root)) {
     if (!isProtected(file.path) && basename3(file.path).includes(".tmp-") && now - file.modifiedMs >= ABANDONED_TEMP_MAX_AGE_MS) {
@@ -123302,7 +123908,7 @@ async function runTest(workspace, options, dependencies = {}) {
       throw new NeoTestUsageError(errorMessage2(error));
     }
     selectedFiles = selectedPaths.map(
-      (path) => relative5(workspace.root, path).split(sep5).join("/")
+      (path) => relative6(workspace.root, path).split(sep6).join("/")
     );
     if (selectedPaths.length === 0 && options.passWithNoTests !== true) {
       throw new NeoTestNoTestsError(
@@ -123466,7 +124072,7 @@ async function runTest(workspace, options, dependencies = {}) {
   if (options.outputFile !== null) {
     try {
       atomicWrite(
-        isAbsolute2(options.outputFile) ? options.outputFile : join16(workspace.root, options.outputFile),
+        isAbsolute3(options.outputFile) ? options.outputFile : join16(workspace.root, options.outputFile),
         serialized
       );
     } catch (error) {
@@ -123550,7 +124156,7 @@ async function inspectNeoTestCompilation(workspace, dependencies = {}) {
   if (candidate.document === null) {
     return {
       files: selectedPaths.map(
-        (path) => relative5(workspace.root, path).split(sep5).join("/")
+        (path) => relative6(workspace.root, path).split(sep6).join("/")
       ),
       errors: [
         {
@@ -123571,14 +124177,14 @@ async function inspectNeoTestCompilation(workspace, dependencies = {}) {
       compileSpec(workspace, document, path, compilationHash);
     } catch (error) {
       errors.push({
-        file: relative5(workspace.root, path).split(sep5).join("/"),
+        file: relative6(workspace.root, path).split(sep6).join("/"),
         message: errorMessage2(error)
       });
     }
   }
   return {
     files: selectedPaths.map(
-      (path) => relative5(workspace.root, path).split(sep5).join("/")
+      (path) => relative6(workspace.root, path).split(sep6).join("/")
     ),
     errors
   };
@@ -123677,10 +124283,10 @@ __export(doctor_exports, {
 import {
   constants as fsConstants,
   accessSync,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   readFileSync as readFileSync17
 } from "node:fs";
-import { extname as extname2, isAbsolute as isAbsolute3, join as join17, relative as relative6, sep as sep6 } from "node:path";
+import { extname as extname2, isAbsolute as isAbsolute4, join as join17, relative as relative7, sep as sep7 } from "node:path";
 function inspectNeoDoctor(workspace) {
   const formatCompatible = workspace.config.formatVersion === CURRENT_FORMAT_VERSION;
   const compiler = inspectCompilerContract();
@@ -123797,7 +124403,7 @@ function inspectSourceContract(workspace) {
 }
 function inspectExtensionContract(root) {
   const cachePath = join17(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
-  if (!existsSync13(cachePath)) {
+  if (!existsSync14(cachePath)) {
     return {
       id: NEO_VSCODE_EXTENSION_ID,
       contractVersion: NEO_VSCODE_EXTENSION_CONTRACT_VERSION,
@@ -123860,7 +124466,7 @@ function inspectTrackedBinary(root, record3, errors) {
   const binary = record3.projectBinary;
   if (!binary) return;
   const path = binary.path.replaceAll("\\", "/");
-  if (isAbsolute3(path) || path.split("/").includes("..")) {
+  if (isAbsolute4(path) || path.split("/").includes("..")) {
     errors.push(
       `Project file ${record3.recordId} has unsafe tracked path ${JSON.stringify(binary.path)}.`
     );
@@ -123881,7 +124487,7 @@ function inspectTrackedBinary(root, record3, errors) {
     );
   }
   const absolute = join17(root, path);
-  if (existsSync13(absolute) && !canAccess(absolute, fsConstants.R_OK)) {
+  if (existsSync14(absolute) && !canAccess(absolute, fsConstants.R_OK)) {
     errors.push(`Tracked project file ${path} is not readable.`);
   }
 }
@@ -123906,7 +124512,7 @@ function canAccess(path, mode) {
   }
 }
 function workspacePath(root, path) {
-  return relative6(root, path).split(sep6).join("/");
+  return relative7(root, path).split(sep7).join("/");
 }
 function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
@@ -124022,7 +124628,7 @@ __export(migrate_exports, {
   runMigrate: () => runMigrate
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { existsSync as existsSync14, mkdirSync as mkdirSync12, readdirSync as readdirSync6, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync12, readdirSync as readdirSync6, writeFileSync as writeFileSync12 } from "node:fs";
 import { join as join18 } from "node:path";
 async function runMigrate(workspace, subcommand, positional, targetRef, json, dependencies = {}) {
   if (subcommand === "new") {
@@ -124035,7 +124641,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
     const migrationsDir = join18(workspace.root, "Migrations");
     mkdirSync12(migrationsDir, { recursive: true });
     let nextOrder = 1;
-    if (existsSync14(migrationsDir)) {
+    if (existsSync15(migrationsDir)) {
       for (const entry of readdirSync6(migrationsDir)) {
         const match = /^(\d+)-/.exec(entry);
         if (match !== null) {
@@ -124045,7 +124651,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
     }
     const relPath = migrationFileName(nextOrder, name);
     const absolute = join18(workspace.root, relPath);
-    if (existsSync14(absolute)) {
+    if (existsSync15(absolute)) {
       throw new Error(`"${relPath}" already exists.`);
     }
     const target = targetRef ?? "project";
@@ -125616,7 +126222,7 @@ async function waitForMergeTransaction(args) {
     status = readMergeTransactionStatus(response, status.transactionId);
     if (status.commitStatus === "committed") continue;
     if (status.commitStatus === "failed") continue;
-    await new Promise((resolve4) => setTimeout(resolve4, delayMs));
+    await new Promise((resolve5) => setTimeout(resolve5, delayMs));
     delayMs = Math.min(delayMs * 2, 5e3);
   }
 }
@@ -127360,7 +127966,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.38.3");
+    console.log("0.38.5");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {