@neocompose/cli 0.38.3 → 0.38.4

package/dist/neo.mjs

@@ -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, [
@@ -44275,23 +44159,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 +44241,14 @@ 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_core();
     init_docs_text2();
     init_member_storage();
+    RETIRED_CONSTRUCTOR_PROJECTIONS_FIELD = "constructorProjections";
   }
 });
 
@@ -50268,6 +50151,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);
 }
@@ -59713,7 +59675,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 +63221,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 +63242,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 +63268,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 +64393,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 +65858,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 +65924,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 +65977,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 +65997,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 +66149,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 +66239,7 @@ var init_constructor_argument_ownership = __esm({
       classesById;
       membersById;
       constructorsById;
+      contextualRootMembersByValueId;
       parameterTypesByValueId = /* @__PURE__ */ new Map();
       settleConstructorParameter;
       aggregateTypeByTargetValueId = /* @__PURE__ */ new Map();
@@ -66306,9 +66247,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 +66309,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 +66369,7 @@ var init_constructor_argument_ownership = __esm({
             ...settled,
             member: substituteMember(
               member,
-              rowGenericEnvironment(this.document, owner),
+              this.genericEnvironmentForRow(owner),
               this.document.members
             )
           };
@@ -66487,7 +66429,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 +66520,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 +66543,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);
@@ -68265,12 +68216,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 +68230,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 +68263,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") {
@@ -71691,7 +71608,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 +71631,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 +71640,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 +71673,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") {
@@ -74113,7 +74028,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,
@@ -74184,6 +74099,7 @@ function constructorInitializerIndexes(ctx) {
 }
 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,6 +74130,7 @@ function buildConstructorInitializerIndexes(vm) {
     );
     if (typeof rootOwnerId === "string") {
       initializerScopeMemberIds.set(initializer, rootOwnerId);
+      initializerScopeMemberIdsByValueId.set(valueId, rootOwnerId);
     }
   }
   const declaringClassIdsByMemberId = /* @__PURE__ */ new Map();
@@ -74233,6 +74150,7 @@ function buildConstructorInitializerIndexes(vm) {
   }
   return {
     initializerScopeMemberIds,
+    initializerScopeMemberIdsByValueId,
     declaringClassIdsByMemberId,
     memberById: memberById2,
     containerMemberIdByEntryId
@@ -74460,6 +74378,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 +74406,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 });
@@ -75121,10 +75047,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,
@@ -76739,6 +76665,32 @@ var init_stored_value_placement_index = __esm({
 });
 
 // ../src/database/virtual-instance-values.ts
+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 firstListInParameterType(typeInfo, depth = 0) {
   if (typeof typeInfo !== "object" || typeInfo === null) return null;
   if (depth > CONSTRUCTOR_TYPE_WALK_DEPTH_LIMIT) return "depth-limit";
@@ -77018,21 +76970,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 +77019,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;
@@ -77348,6 +77305,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 +77326,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 +77900,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,
@@ -78788,7 +78750,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,6 +78780,10 @@ function createHeadlessVirtualInstanceResolver(args) {
     }
     try {
       const resolverDocument = resolverDocumentOnce();
+      materializedIndex ??= buildVirtualInstanceMaterializedIndex({
+        document: resolverDocument,
+        materializedRows: document.values
+      });
       const expanded = expandStoredInstance({
         document: resolverDocument,
         instanceRoot,
@@ -78824,7 +78795,7 @@ function createHeadlessVirtualInstanceResolver(args) {
         rootMember: member,
         expandedRoot: expanded.root,
         expandedRows: expanded.rows,
-        materializedRows: document.values
+        materializedIndex
       });
       graphRowsByRootId.set(rootId, graph.rowsById);
       for (const [id2, row] of graph.rowsById) {
@@ -79007,9 +78978,10 @@ function buildInitializerRootValueWithLookups(document, lookups) {
 }
 function evaluateMemberInitializer(args) {
   const databaseVM = initializerEvaluatorLookups(args.document);
-  const compileMemberId = databaseVM.constructorInitializerIndexes?.initializerScopeMemberIds.get(
-    args.init
-  );
+  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,
@@ -84439,7 +84411,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 +84429,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 +84471,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 +85947,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 +85974,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 +86003,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,14 +86046,37 @@ 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();
@@ -88956,6 +88907,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 +90681,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 +90749,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 +91010,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 +94875,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 +94949,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 +95009,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 +95052,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 +95203,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 +95299,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);
@@ -101351,7 +101306,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 +104953,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 +105592,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 +106356,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 +106681,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 +106932,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
@@ -120632,8 +120552,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.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120739,7 +120659,6 @@ var init_registry2 = __esm({
             "allowedStorageKeys",
             "genericParams",
             "extendsGenericBindings",
-            "constructorProjections",
             "constructorIds",
             "requiredConstructorId",
             "targetMemberId"
@@ -120757,7 +120676,6 @@ var init_registry2 = __esm({
             allowedStorageKeys: "nullIsAbsent",
             genericParams: "nullOrEmptyArrayIsAbsent",
             extendsGenericBindings: "nullOrEmptyObjectIsAbsent",
-            constructorProjections: "nullOrEmptyArrayIsAbsent",
             constructorIds: "nullOrEmptyArrayIsAbsent",
             requiredConstructorId: "nullIsAbsent"
           }
@@ -127360,7 +127278,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.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {