@neocompose/cli 0.22.4 → 0.22.6

package/dist/neo.mjs

@@ -8954,7 +8954,8 @@ var init_strict_resolver = __esm({
                 className,
                 expression,
                 scope,
-                expression.pos
+                expression.pos,
+                expected
               );
             }
             if (expression.argumentNames && !projectionCall) {
@@ -10588,7 +10589,7 @@ var init_strict_resolver = __esm({
        * the call site's initializer block is carried through to be applied last
        * (§6.1 step 4).
        */
-      resolveDeclaredConstructor(className, expression, scope, pos) {
+      resolveDeclaredConstructor(className, expression, scope, pos, expected) {
         const schemaClass2 = this.project.typeByName.get(className);
         if (!schemaClass2 || schemaClass2.kind !== "class") {
           throw new CompileError(
@@ -10608,7 +10609,24 @@ var init_strict_resolver = __esm({
             pos
           );
         }
-        const declared = schemaClass2.declaredConstructors ?? [];
+        const targetType = this.constructorTargetType(
+          schemaClass2,
+          expression,
+          expected
+        );
+        const declared = (schemaClass2.declaredConstructors ?? []).map(
+          (constructor2) => ({
+            ...constructor2,
+            parameters: constructor2.parameters.map((parameter3) => ({
+              ...parameter3,
+              type: substituteTypeParameters(
+                parameter3.type,
+                targetType,
+                schemaClass2
+              )
+            }))
+          })
+        );
         const argumentNames = expression.args.map(
           (_, index) => expression.argumentNames?.[index] ?? null
         );
@@ -10649,10 +10667,7 @@ var init_strict_resolver = __esm({
           expression,
           scope
         );
-        const classType = {
-          kind: "named",
-          typeId: schemaClass2.id
-        };
+        const classType = targetType;
         const schemaClassInfo = toWireType(classType, this.project);
         if (schemaClassInfo.type !== 7 /* Class */) {
           throw new Error(
@@ -38855,8 +38870,145 @@ function substituteMember(member, env, members) {
     };
     return substituted;
   }
+  if (isMemberDelegateBase(resolved)) {
+    const returnTypeInfo = substituteNestedTypeInfo(
+      resolved.returnTypeInfo,
+      env,
+      members
+    );
+    let argumentsChanged = false;
+    const argumentTypes = resolved.argumentTypes.map((argument2) => {
+      const substituted2 = substituteNestedTypeInfo(argument2, env, members);
+      if (substituted2 === argument2) return argument2;
+      argumentsChanged = true;
+      return { ...substituted2, name: argument2.name };
+    });
+    if (returnTypeInfo === resolved.returnTypeInfo && !argumentsChanged) {
+      return resolved;
+    }
+    const substituted = {
+      ...resolved,
+      returnTypeInfo,
+      argumentTypes
+    };
+    return substituted;
+  }
   return resolved;
 }
+function substituteNestedTypeInfo(typeInfo, env, members) {
+  if (typeInfo.type === 21 /* Generic */) {
+    const entry = env.get(typeInfo.genericParamId);
+    if (entry === void 0) {
+      throw new Error(
+        `substituteMember: callable type references generic param "${typeInfo.genericParamId}", which is not present in the binding environment.`
+      );
+    }
+    if (entry.kind === "unbound") return typeInfo;
+    const binding = members.find(
+      (candidate) => candidate.id === entry.memberId
+    );
+    if (binding === void 0) {
+      throw new Error(
+        `substituteMember: callable type binding member "${entry.memberId}" for generic param "${typeInfo.genericParamId}" does not exist in the document.`
+      );
+    }
+    return genericBindingTypeInfo(binding, env, members);
+  }
+  if (typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
+    return {
+      ...typeInfo,
+      entryTypeInfo: substituteNestedTypeInfo(
+        typeInfo.entryTypeInfo,
+        env,
+        members
+      )
+    };
+  }
+  if (typeInfo.type === 7 /* Class */) {
+    const typeArguments = typeInfo.typeArguments;
+    if (typeArguments === void 0) return typeInfo;
+    return {
+      ...typeInfo,
+      typeArguments: Object.fromEntries(
+        Object.entries(typeArguments).map(([parameterId, argument2]) => [
+          parameterId,
+          substituteNestedTypeInfo(argument2, env, members)
+        ])
+      )
+    };
+  }
+  if (typeInfo.type === 25 /* NSDelegate */) {
+    return {
+      ...typeInfo,
+      returnTypeInfo: substituteNestedTypeInfo(
+        typeInfo.returnTypeInfo,
+        env,
+        members
+      ),
+      argumentTypes: typeInfo.argumentTypes.map(
+        (argument2) => substituteNestedTypeInfo(argument2, env, members)
+      )
+    };
+  }
+  return typeInfo;
+}
+function genericBindingTypeInfo(rawMember, env, members) {
+  return typeInfoFromArgumentSignature(
+    typeArgumentSignatureOfMember(rawMember, env, members)
+  );
+}
+function typeInfoFromArgumentSignature(signature) {
+  if (signature.type === 7 /* Class */) {
+    const classSignature = signature;
+    return {
+      type: 7 /* Class */,
+      required: classSignature.required,
+      classId: classSignature.classId,
+      ...Object.keys(classSignature.args).length === 0 ? {} : {
+        typeArguments: Object.fromEntries(
+          Object.entries(classSignature.args).map(
+            ([parameterId, argument2]) => [
+              parameterId,
+              typeInfoFromArgumentSignature(argument2)
+            ]
+          )
+        )
+      }
+    };
+  }
+  if (signature.type === 8 /* Enum */) {
+    const enumSignature = signature;
+    return {
+      type: 8 /* Enum */,
+      required: enumSignature.required,
+      enumId: enumSignature.enumId
+    };
+  }
+  if (signature.type === 6 /* List */) {
+    const listSignature = signature;
+    return {
+      type: 6 /* List */,
+      required: listSignature.required,
+      entryTypeInfo: typeInfoFromArgumentSignature(listSignature.entry)
+    };
+  }
+  if (signature.type === 5 /* Dictionary */) {
+    const dictionarySignature = signature;
+    return {
+      type: 5 /* Dictionary */,
+      required: dictionarySignature.required,
+      entryTypeInfo: typeInfoFromArgumentSignature(dictionarySignature.entry),
+      ...dictionarySignature.keyEnumId === void 0 ? {} : { keyEnumId: dictionarySignature.keyEnumId }
+    };
+  }
+  const typeInfo = { type: signature.type, required: signature.required };
+  if (!isNSTypeInfo(typeInfo)) {
+    throw new Error(
+      `substituteMember: generic binding kind ${signature.type} cannot appear in a NeoScript callable type.`
+    );
+  }
+  return typeInfo;
+}
 function resolveTerminalBinding(genericParamId, slotName, env, members) {
   const entry = env.get(genericParamId);
   if (entry === void 0) {
@@ -39137,6 +39289,7 @@ var init_generics = __esm({
   "../src/models/classes/generics.ts"() {
     "use strict";
     init_member_kinds();
+    init_neoscript();
     init_world_system_classes();
     init_structural_narrow();
     init_inheritance();
@@ -40781,7 +40934,11 @@ function evaluateLiteralContainer(args) {
       `Cannot materialize member "${args.member.name}": its value is a NeoScript initializer, which this builder cannot evaluate. Supply an initEvaluator.`
     );
   }
-  const evaluated = args.initEvaluator(args.member, body.init);
+  const evaluated = args.initEvaluator(
+    args.member,
+    body.init,
+    args.sourceValueId
+  );
   return {
     literal: {
       value: evaluated.value,
@@ -41139,7 +41296,8 @@ function cloneDefaultValueForMember(args) {
     const evaluated = evaluateLiteralContainer({
       body: sourceValue,
       member,
-      initEvaluator: args.initEvaluator
+      initEvaluator: args.initEvaluator,
+      sourceValueId: args.sourceValueId
     });
     if (evaluated === void 0) {
       throw new Error(
@@ -54070,14 +54228,18 @@ var init_NSGetterRuntimeError = __esm({
       }
     };
     UncompiledInitializerRuntimeError = class extends NSGetterRuntimeError {
-      constructor(memberId, memberName) {
+      constructor(memberId, memberName, initializer = null, valueId = null) {
         super(
           `Initializer for '${memberName}' has no compiled body; push the project so the server compiles it.`
         );
         this.memberId = memberId;
+        this.initializer = initializer;
+        this.valueId = valueId;
         this.name = "UncompiledInitializerRuntimeError";
       }
       memberId;
+      initializer;
+      valueId;
     };
   }
 });
@@ -55203,6 +55365,14 @@ function trackedRowForValueReference(value, ctx) {
   const indexes = evaluatorIndexes(ctx);
   return indexes.rowByValueReference.get(value) ?? indexes.baseRowByValueReference?.get(value) ?? null;
 }
+function assertStoredReplayMutableValue(value, ctx, label) {
+  if (ctx.storedConstructionReplay !== true) return;
+  const row = trackedRowForValueReference(value, ctx);
+  if (row === null || ctx.__runtimeSessionValues?.has(row.id) === true) return;
+  throw new NSGetterRuntimeError(
+    `Stored construction replay cannot mutate persisted ${label}.`
+  );
+}
 function pushConstructionFrame(ctx, label) {
   const state = ctx.__executionState;
   if (state === void 0) {
@@ -55367,7 +55537,7 @@ function withEvaluationRuntime(ctx, writes) {
   if (ctx.__runtimeSessionValues !== void 0 && ctx.__executionState !== void 0 && ctx.__valueOverlay !== void 0) {
     return ctx;
   }
-  const overlay = ctx.__valueOverlay ?? buildValueOverlay(ctx.vm);
+  const overlay = ctx.__valueOverlay ?? (ctx.storedConstructionReplay === true ? /* @__PURE__ */ new Map() : buildValueOverlay(ctx.vm));
   const referenceRemap = ctx.__runtimeReferenceRemap ?? /* @__PURE__ */ new Map();
   const runtimeReferences = runtimeSessionValueReferences(
     ctx.__runtimeSessionValues
@@ -56375,6 +56545,11 @@ function evalInstructions(instructions, scope, ctx, options) {
 }
 function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx) {
   if (target.type === "staticMember" /* staticMember */) {
+    if (ctx.storedConstructionReplay === true) {
+      throw new NSGetterRuntimeError(
+        "Stored construction replay cannot assign persisted static values."
+      );
+    }
     applyOverlayStaticAssignment(target.memberId, value, ctx);
     return;
   }
@@ -56384,6 +56559,7 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx) {
     );
   }
   const receiver = evalPointer(target.keyOf.pointer, scope, ctx);
+  assertStoredReplayMutableValue(receiver, ctx, "assignment target");
   const key = evalPointer(target.keyOf.key, scope, ctx);
   const referenceValueId = targetTypeInfo.type === 7 /* Class */ || targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 5 /* Dictionary */ ? findKnownRowIdByValueReference(value, ctx) : null;
   if (Array.isArray(receiver)) {
@@ -56692,6 +56868,11 @@ function resolveCompiledSetter(memberId, ctx) {
 }
 function evalCollectionMutationInstruction(ins, scope, ctx, options) {
   if (ins.target.pointer.type === "staticMember" /* staticMember */) {
+    if (ctx.storedConstructionReplay === true) {
+      throw new NSGetterRuntimeError(
+        "Stored construction replay cannot mutate persisted static collections."
+      );
+    }
     const member = evalMemberById(ctx.vm, ins.target.pointer.memberId);
     if (member === null) {
       throw new NSGetterRuntimeError(
@@ -56701,6 +56882,13 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     writableStaticBindingMap(member, ctx);
   }
   const targetValue = evalPointer(ins.target.pointer, scope, ctx);
+  if (ins.target.pointer.type !== "variable" /* variable */) {
+    assertStoredReplayMutableValue(
+      targetValue,
+      ctx,
+      "collection mutation target"
+    );
+  }
   const args = ins.args.map((arg) => evalPointer(arg, scope, ctx));
   const isLookupSet = ins.target.typeInfo.type === 9 /* Lookup */;
   if (ins.mutation === "Add" /* Add */) {
@@ -58936,7 +59124,14 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
       `Cannot construct abstract Class '${schemaClass2.name}'.`
     );
   }
-  if (!isClosedClass(classId, ctx.vm.classes)) {
+  const replaySlot = ctx.__storedConstructionReplayNestedSlots?.toReversed().find((slot) => slot.classId === classId) ?? ctx.__storedConstructionReplaySlot;
+  const classArguments2 = replaySlot?.classId === classId ? replaySlot.classArguments : void 0;
+  const instanceEnv = resolveInstanceEnv(
+    classId,
+    classArguments2,
+    ctx.vm.classes
+  );
+  if (firstUnboundParamId(instanceEnv) !== null) {
     throw new NSGetterRuntimeError(
       `Cannot construct open generic Class '${schemaClass2.name}'.`
     );
@@ -58961,7 +59156,6 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
   const schemaByKey = new Map(
     mergedSchema.map((entry) => [entry.schemaKey, entry])
   );
-  const instanceEnv = resolveInstanceEnv(classId, void 0, ctx.vm.classes);
   const seenSchemaKeys = /* @__PURE__ */ new Set();
   const seenMemberIds = /* @__PURE__ */ new Set();
   const fields = [];
@@ -59012,7 +59206,7 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
     );
   }
   if (!requireEveryRequiredField) {
-    return { schemaClass: schemaClass2, fields, instanceEnv };
+    return { schemaClass: schemaClass2, fields, instanceEnv, classArguments: classArguments2 };
   }
   for (const entry of mergedSchema) {
     const rawMember = evalMemberById(ctx.vm, entry.memberId);
@@ -59035,7 +59229,7 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
       );
     }
   }
-  return { schemaClass: schemaClass2, fields, instanceEnv };
+  return { schemaClass: schemaClass2, fields, instanceEnv, classArguments: classArguments2 };
 }
 function assertConstructorFieldSlotWritable(args) {
   const surfaceEntry = mergeInstanceSchema(
@@ -59118,11 +59312,12 @@ function evaluateConstructorFields(descriptor, scope, ctx) {
     return { validated, value };
   });
 }
-function syntheticConstructorMember(schemaClass2) {
+function syntheticConstructorMember(schemaClass2, classArguments2) {
   return {
     name: `new ${schemaClass2.name}`,
     kind: 7 /* Class */,
     classId: schemaClass2.id,
+    ...classArguments2 === void 0 ? {} : { classArguments: classArguments2 },
     locked: false,
     required: true,
     isStatic: false,
@@ -59353,7 +59548,10 @@ function constructClassValueWithinFrame(descriptor, scope, ctx) {
   const schemaClass2 = descriptor.schemaClass;
   const classId = schemaClass2.id;
   const supplied = evaluateConstructorFields(descriptor, scope, ctx);
-  const syntheticMember = syntheticConstructorMember(schemaClass2);
+  const syntheticMember = syntheticConstructorMember(
+    schemaClass2,
+    descriptor.classArguments
+  );
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
   let root;
@@ -59775,9 +59973,41 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
     }
     return null;
   };
-  return (member, init) => {
+  return (member, init, sourceValueId) => {
+    const evaluate = (argumentValues = []) => {
+      if (ctx.storedConstructionReplay !== true || !isMemberClassBase(member) || Object.keys(member.classArguments ?? {}).length === 0) {
+        return evaluateInitializerInContext(
+          init,
+          member,
+          ctx,
+          createdValues,
+          argumentValues,
+          sourceValueId ?? null
+        );
+      }
+      const previousSlots = ctx.__storedConstructionReplayNestedSlots;
+      ctx.__storedConstructionReplayNestedSlots = [
+        ...previousSlots ?? [],
+        {
+          classId: member.classId,
+          classArguments: member.classArguments ?? {}
+        }
+      ];
+      try {
+        return evaluateInitializerInContext(
+          init,
+          member,
+          ctx,
+          createdValues,
+          argumentValues,
+          sourceValueId ?? null
+        );
+      } finally {
+        ctx.__storedConstructionReplayNestedSlots = previousSlots;
+      }
+    };
     if (init.compiled === void 0) {
-      return evaluateInitializerInContext(init, member, ctx, createdValues);
+      return evaluate();
     }
     const memberId = Reflect.get(member, "id");
     const scopeMemberId = indexes.initializerScopeMemberIds.get(init) ?? (typeof memberId === "string" ? memberId : "");
@@ -59789,12 +60019,12 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
           `Member initializer '${member.name}' has ${expectedArgumentCount} constructor parameter(s), but its declaring class scope could not be resolved.`
         );
       }
-      return evaluateInitializerInContext(init, member, ctx, createdValues);
+      return evaluate();
     }
     const scopedArguments = argumentScopes.valuesByClassId.get(ownerClassId);
     if (scopedArguments === void 0) {
       if (expectedArgumentCount === 0) {
-        return evaluateInitializerInContext(init, member, ctx, createdValues);
+        return evaluate();
       }
       if (argumentScopes.missingScopeReason === "no-constructor") {
         throw new NSGetterRuntimeError(
@@ -59810,13 +60040,7 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
         `Member initializer '${member.name}' on '${ownerClassId}' expected ${expectedArgumentCount} constructor argument(s), got ${scopedArguments.length}.`
       );
     }
-    return evaluateInitializerInContext(
-      init,
-      member,
-      ctx,
-      createdValues,
-      scopedArguments
-    );
+    return evaluate(scopedArguments);
   };
 }
 function constructorInitializerIndexes(ctx) {
@@ -59931,14 +60155,16 @@ function runtimeValueReferencesVariable(value, variableId, visited = /* @__PURE_
     (child) => runtimeValueReferencesVariable(child, variableId, visited)
   );
 }
-function evaluateInitializerInContext(init, member, ctx, createdValues, argumentValues = []) {
+function evaluateInitializerInContext(init, member, ctx, createdValues, argumentValues = [], sourceValueId = null) {
   ctx.__constructedArgumentsByValue ??= /* @__PURE__ */ new WeakMap();
   const compiled = init.compiled;
   if (compiled === void 0) {
     const memberId = Reflect.get(member, "id");
     throw new UncompiledInitializerRuntimeError(
       typeof memberId === "string" ? memberId : null,
-      member.name
+      member.name,
+      init,
+      sourceValueId
     );
   }
   const closeFrame = pushConstructionFrame(ctx, `${member.name} initializer`);
@@ -60137,7 +60363,10 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
         textureTemplates: ctx.vm.textureTemplates ?? []
       },
       projectId: ctx.vm.project.id,
-      member: syntheticConstructorMember(schemaClass2),
+      member: syntheticConstructorMember(
+        schemaClass2,
+        descriptor.classArguments
+      ),
       topLevelClassId: classId,
       createdValues,
       storageKeyDeclarations,
@@ -61381,7 +61610,8 @@ function evaluateMemberInitializer(args) {
   if (compiled === void 0) {
     throw new UncompiledInitializerRuntimeError(
       typeof Reflect.get(args.member, "id") === "string" ? Reflect.get(args.member, "id") : null,
-      args.member.name
+      args.member.name,
+      args.init
     );
   }
   const ctx = {
@@ -61403,7 +61633,15 @@ function evaluateMemberInitializer(args) {
     rootValue: buildInitializerRootValue(args.document),
     saveStaticBindings: args.saveStaticBindings,
     sessionStaticBindings: args.sessionStaticBindings,
-    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
+    ...args.storedConstructionReplay === true ? {
+      storedConstructionReplay: true,
+      ...isMemberClassBase(args.member) ? {
+        __storedConstructionReplaySlot: {
+          classId: args.member.classId,
+          classArguments: args.member.classArguments ?? {}
+        }
+      } : {}
+    } : {},
     __constructedArgumentsByValue: /* @__PURE__ */ new WeakMap(),
     __createdStorageKeyDeclarations: args.storageKeyDeclarations ?? /* @__PURE__ */ new Map()
   };
@@ -61426,6 +61664,7 @@ var evaluatorLookupsByDocument;
 var init_evaluateInitializer = __esm({
   "../src/view-models/neoscript-evaluator/evaluateInitializer.ts"() {
     "use strict";
+    init_members();
     init_project2();
     init_NSGetterRuntimeError();
     init_evaluateNSGetter();
@@ -69696,7 +69935,7 @@ function materializedInitializerReconciliationFailuresV4(args) {
     candidateValueIds
   );
   const currentRecords = reconciliationRecords(args.workspace, []);
-  const cachedExpressions = readMaterializedConstructionBuildCacheV1(
+  const cachedExpressions = args.useBuildCaches === false ? null : readMaterializedConstructionBuildCacheV1(
     args.workspace.root,
     args.workspace.state
   );
@@ -69720,11 +69959,13 @@ function materializedInitializerReconciliationFailuresV4(args) {
       )) {
         canonicalExpressions.set(valueId, expression);
       }
-      writeMaterializedConstructionBuildCacheV1(
-        args.workspace.root,
-        args.workspace.state,
-        canonicalExpressions
-      );
+      if (args.useBuildCaches !== false) {
+        writeMaterializedConstructionBuildCacheV1(
+          args.workspace.root,
+          args.workspace.state,
+          canonicalExpressions
+        );
+      }
     }
   }
   const replayableValueIds = /* @__PURE__ */ new Set();
@@ -69738,7 +69979,7 @@ function materializedInitializerReconciliationFailuresV4(args) {
     }
   }
   const owners = resolveOwnerMembersForValues(document, replayableValueIds);
-  const compilationProject = replayableValueIds.size === 0 ? void 0 : loadOrBuildNeoScriptProjectV1(args.workspace.root, document);
+  const compilationProject = replayableValueIds.size === 0 ? void 0 : args.useBuildCaches === false ? createNeoScriptCompilationProject(document) : loadOrBuildNeoScriptProjectV1(args.workspace.root, document);
   const failures = [];
   for (const reconciliation of args.reconciliations.values()) {
     if (reconciliation.storedConstructorArgs === null) continue;
@@ -70078,6 +70319,7 @@ var init_local_initializer_materialization = __esm({
     init_value_row_owner_members();
     init_neo_script_recompile_scope();
     init_neoscript_build_cache();
+    init_compiler_adapter();
   }
 });
 
@@ -70716,6 +70958,7 @@ function computeWorkspaceStatus(workspace, options) {
         reconciliations: valueLowerRegistry.initializerReconciliations,
         manifest,
         forceRecompile: options.forceRecompile,
+        useBuildCaches: options.useBuildCaches,
         sourceTextByUri: new Map(
           sourceEntries.map((entry) => [entry.relPath, entry.source])
         )
@@ -70786,13 +71029,15 @@ function computeWorkspaceStatus(workspace, options) {
     parseErrors.push(new SchemaSourceError(message, "<project-files>", 1, 1));
   }
   try {
+    const animationRecords = prospectiveAnimationRecords(
+      workspace.state.records,
+      reconstructed3,
+      changes,
+      authoredValueSeeds
+    );
     validateProspectiveAnimationRecordsV4(
-      prospectiveAnimationRecords(
-        workspace.state.records,
-        reconstructed3,
-        changes,
-        authoredValueSeeds
-      )
+      animationRecords,
+      animationRecordsFromState(workspace.state.records)
     );
   } catch (error) {
     parseErrors.push(
@@ -70860,17 +71105,19 @@ function computeWorkspaceStatus(workspace, options) {
     )
   };
 }
-function validateProspectiveAnimationRecordsV4(records2) {
+function validateProspectiveAnimationRecordsV4(records2, fallbackRecords = []) {
   const candidates = [...records2];
   const document = prospectiveAnimationDocumentV4(candidates);
   if (document === null) return;
+  const fallbackDocument = prospectiveAnimationDocumentV4(fallbackRecords);
   const replayed = replayAnimationDeclarationInitializersV4(
     candidates,
-    document
+    document,
+    fallbackDocument
   );
   assertAnimationClipDocumentValid(replayed);
 }
-function replayAnimationDeclarationInitializersV4(records2, document) {
+function replayAnimationDeclarationInitializersV4(records2, document, fallbackDocument) {
   const initializers = document.values.flatMap((row) => {
     const init = Reflect.get(row, "init");
     return isObjectRecord2(init) && typeof init.code === "string" ? [{ row, code: init.code }] : [];
@@ -70897,7 +71144,24 @@ function replayAnimationDeclarationInitializersV4(records2, document) {
       data: record3.data
     });
   }
-  const values = new Map(document.values.map((row) => [row.id, row]));
+  const replayDocument = readPulledProjectDocumentV4(pulled);
+  const compilationProject = createNeoScriptCompilationProject({
+    project: replayDocument.project,
+    projectFiles: replayDocument.projectFiles,
+    members: replayDocument.members,
+    classes: replayDocument.classes,
+    enums: replayDocument.enums,
+    interfaces: replayDocument.interfaces,
+    constructors: replayDocument.constructors ?? []
+  });
+  let documentBodiesCompiled = false;
+  const fallbackValues = new Map(
+    (fallbackDocument?.values ?? []).map((row) => [row.id, row])
+  );
+  const values = new Map([
+    ...fallbackValues,
+    ...document.values.map((row) => [row.id, row])
+  ]);
   for (const { row, code } of initializers) {
     if (rootKinds.get(row.id) !== "declaration") continue;
     const owner = owners.get(row.id);
@@ -70910,26 +71174,34 @@ function replayAnimationDeclarationInitializersV4(records2, document) {
     const rootOwner = rootOwners.get(row.id);
     const rootOwnerId = Reflect.get(rootOwner ?? {}, "id");
     const initializerOwnerClass = typeof rootOwnerId !== "string" ? null : findSchemaPlacement(rootOwnerId, document.classes)?.ownerClass ?? null;
+    const evaluate = initializerOwnerClass?.requiredConstructorId === void 0 || initializerOwnerClass.requiredConstructorId === null;
     let replay;
     try {
       replay = replayStoredConstructionV4({
         records: pulled,
+        document: replayDocument,
         valueId: row.id,
         code,
         member: owner,
-        compileDocumentBodies: true,
+        compileDocumentBodies: !documentBodiesCompiled,
+        compilationProject,
         initializerOwnerClass,
         // A parameterized declaration is a template. Its arguments exist only
         // at concrete construction sites, so validate the authored body here
         // without fabricating values for the class header parameters.
-        evaluate: initializerOwnerClass?.requiredConstructorId === void 0 || initializerOwnerClass.requiredConstructorId === null
+        evaluate
       });
+      documentBodiesCompiled = true;
     } catch (error) {
       throw new Error(
         `Animation declaration replay failed for value "${row.id}": ${error instanceof Error ? error.message : String(error)}`,
         { cause: error }
       );
     }
+    if (!evaluate) {
+      const fallback = fallbackValues.get(row.id);
+      if (fallback !== void 0) values.set(row.id, fallback);
+    }
     for (const [id2, value] of replay) {
       if (!isMemberValue(value)) {
         throw new Error(
@@ -70941,6 +71213,12 @@ function replayAnimationDeclarationInitializersV4(records2, document) {
   }
   return { ...document, values: [...values.values()] };
 }
+function animationRecordsFromState(records2) {
+  return Object.values(records2).flatMap((record3) => {
+    const data = record3.conflictServerHash !== void 0 && isObjectRecord2(record3.conflictServerData) ? record3.conflictServerData : record3.data;
+    return isObjectRecord2(data) ? [{ recordKind: record3.recordKind, data }] : [];
+  });
+}
 function classBelongsToAnimationFamily(classes, classId) {
   const classesById = new Map(
     classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
@@ -71314,6 +71592,7 @@ var init_workspace_status_core = __esm({
     init_local_initializer_materialization();
     init_push_change_intent();
     init_initializer_replay();
+    init_compiler_adapter();
     IGNORED_SCHEMA_DIRECTORIES = /* @__PURE__ */ new Set([
       ".git",
       ".neo",
@@ -71364,6 +71643,7 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
   }
   const status = computeWorkspaceStatus(workspace, {
     skipProjectBinaryInspection: true,
+    useBuildCaches: false,
     writeProjectAnalysisCache: () => void 0,
     trustedPendingProjectFiles,
     virtualSourceFiles: args.files,
@@ -74901,13 +75181,14 @@ function materializePreparedInstanceInitializers(args) {
         `Value "${valueId}" carries an initializer but no instance ownership path resolves its declared member.`
       );
     }
+    const existingRoot = existingValueById.get(valueId);
+    const existingConstructedRoot = existingRoot !== void 0 && isLiteralValueContent(existingRoot) && (typeof existingRoot.classId === "string" || existingRoot.constructorArgs !== void 0 && existingRoot.constructorArgs !== null);
     const materialized = materializeInitializerValue({
       document: compiledDocument,
       member,
-      row: site.row
+      row: site.row,
+      ...existingConstructedRoot ? { storedConstructionReplay: true } : {}
     });
-    const existingRoot = existingValueById.get(valueId);
-    const existingConstructedRoot = existingRoot !== void 0 && isLiteralValueContent(existingRoot) && (typeof existingRoot.classId === "string" || existingRoot.constructorArgs !== void 0 && existingRoot.constructorArgs !== null);
     if (existingConstructedRoot) {
       if (!isLiteralValueContent(materialized.root) || existingRoot.classId !== materialized.root.classId || !replayedCreationDataMatches({
         currentDocument: args.document,
@@ -77091,6 +77372,9 @@ function prepareServerOwnedValueInitializerBodies(args) {
     void 0,
     rootOwnerByValueId
   );
+  const currentValueById = new Map(
+    args.document.values.map((value) => [value.id, value])
+  );
   const compileOne = (document, row) => {
     const member = ownerByValueId.get(row.id);
     if (member === void 0) {
@@ -77098,6 +77382,8 @@ function prepareServerOwnedValueInitializerBodies(args) {
         `Value "${row.id}" carries an initializer but no member in this project version stores it, so its declared type is unknown.`
       );
     }
+    const currentValue = currentValueById.get(row.id);
+    const replaysStoredConstruction = isLiteralValueContent(currentValue) && (typeof currentValue.classId === "string" || currentValue.constructorArgs !== void 0);
     compileValueRowInitializerBody({
       project: document.project,
       projectFiles: document.projectFiles,
@@ -77112,7 +77398,8 @@ function prepareServerOwnedValueInitializerBodies(args) {
       initializerOwnerClass: findSchemaPlacement(
         rootOwnerByValueId.get(row.id)?.id ?? "",
         document.classes
-      )?.ownerClass ?? null
+      )?.ownerClass ?? null,
+      ...replaysStoredConstruction ? { storedConstructionReplay: true } : {}
     });
   };
   for (const [index, row] of explicitRows) {
@@ -77210,22 +77497,29 @@ function prepareServerOwnedDelegateValueBodies(args) {
         `Value "${row.id}" carries a NeoDelegate closure but no NeoDelegate member in this project version stores it.`
       );
     }
-    row.value = compileDelegateClosureValue(row.value.code, {
-      project: document.project,
-      projectFiles: document.projectFiles,
-      members: document.members,
-      classes: document.classes,
-      enums: document.enums,
-      interfaces: document.interfaces,
-      constructors: document.constructors ?? [],
-      thisClass: findSchemaPlacement(
-        rootOwnerByValueId.get(row.id)?.id ?? "",
-        document.classes
-      )?.ownerClass ?? null,
-      returnTypeInfo: member.returnTypeInfo,
-      argumentTypes: member.argumentTypes,
-      name: `${member.name} value`
-    });
+    const rootOwner = rootOwnerByValueId.get(row.id);
+    const thisClass = findSchemaPlacement(rootOwner?.id ?? "", document.classes)?.ownerClass ?? null;
+    try {
+      row.value = compileDelegateClosureValue(row.value.code, {
+        project: document.project,
+        projectFiles: document.projectFiles,
+        members: document.members,
+        classes: document.classes,
+        enums: document.enums,
+        interfaces: document.interfaces,
+        constructors: document.constructors ?? [],
+        thisClass,
+        returnTypeInfo: member.returnTypeInfo,
+        argumentTypes: member.argumentTypes,
+        name: `${member.name} value`
+      });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Value "${row.id}" NeoDelegate closure failed under member "${member.name}" (${getOptionalString(member, "id") ?? "unknown"}), root owner "${rootOwner?.name ?? "unknown"}" (${getOptionalString(rootOwner, "id") ?? "unknown"}), lexical class "${thisClass?.name ?? "none"}" (${thisClass?.id ?? "none"}), and return type ${canonicalJsonStringify(member.returnTypeInfo)}: ${detail}`,
+        { cause: error }
+      );
+    }
   };
   for (const [index, row] of explicitRows) {
     const compiled = { ...row, value: { ...row.value } };
@@ -77780,6 +78074,7 @@ var init_project_version_schema_commit = __esm({
     init_members();
     init_inheritance();
     init_generics();
+    init_core();
     init_world_content_sidecar_validation();
     init_project_document_value_overlay();
     init_project2();
@@ -81147,8 +81442,22 @@ var init_server_preparation_preflight = __esm({
 // src/project-source/initializer-replay.ts
 function replayStoredConstructionV4(args) {
   const document = args.document ?? readPulledProjectDocumentV4(args.records);
+  const compilationProject = args.compilationProject ?? (args.compileDocumentBodies === true ? createNeoScriptCompilationProject({
+    project: document.project,
+    projectFiles: document.projectFiles,
+    members: document.members,
+    classes: document.classes,
+    enums: document.enums,
+    interfaces: document.interfaces,
+    constructors: document.constructors ?? []
+  }) : void 0);
   if (args.compileDocumentBodies === true) {
-    compilePulledProjectDocumentBodiesV4(document);
+    if (compilationProject === void 0) {
+      throw new Error(
+        "Construction replay cannot compile document bodies without a compiler project."
+      );
+    }
+    compilePulledProjectDocumentBodiesV4(document, compilationProject);
   }
   const root = document.values.find((value) => value.id === args.valueId);
   if (root === void 0) {
@@ -81201,7 +81510,7 @@ function replayStoredConstructionV4(args) {
     // header parameters that are in lexical scope at their source site.
     initializerOwnerClass: args.initializerOwnerClass ?? null,
     storedConstructionReplay: true,
-    ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject }
+    ...compilationProject === void 0 ? {} : { compilationProject }
   });
   if (!isMemberValue(candidate) || !isInitValueContent(candidate)) {
     throw new Error(
@@ -81224,11 +81533,24 @@ function replayStoredConstructionV4(args) {
       });
       break;
     } catch (error) {
-      if (!(error instanceof UncompiledInitializerRuntimeError) || error.memberId === null || compiledDependencies.has(error.memberId)) {
+      const dependencyKey = error instanceof UncompiledInitializerRuntimeError && error.valueId !== null ? error.valueId : error instanceof UncompiledInitializerRuntimeError && error.initializer !== null ? error.initializer : error instanceof UncompiledInitializerRuntimeError ? error.memberId : null;
+      if (!(error instanceof UncompiledInitializerRuntimeError) || error.memberId === null || dependencyKey === null || compiledDependencies.has(dependencyKey)) {
         throw error;
       }
-      compilePulledMemberInitializerBodyV4(document, error.memberId);
-      compiledDependencies.add(error.memberId);
+      if (error.valueId !== null) {
+        compilePulledValueInitializerBodyV4(
+          document,
+          error.valueId,
+          compilationProject
+        );
+      } else {
+        compilePulledMemberInitializerBodyV4(
+          document,
+          error.memberId,
+          compilationProject
+        );
+      }
+      compiledDependencies.add(dependencyKey);
     }
   }
   return new Map(
@@ -81238,7 +81560,55 @@ function replayStoredConstructionV4(args) {
     ])
   );
 }
-function compilePulledProjectDocumentBodiesV4(document) {
+function valueInitializerCompilationSites(document) {
+  const cached = pulledValueInitializerCompilationSites.get(document);
+  if (cached !== void 0) return cached;
+  const rows = document.values.filter(isInitValueContent);
+  const rootOwners = /* @__PURE__ */ new Map();
+  const owners = resolveOwnerMembersForValues(
+    document,
+    new Set(rows.map((row) => row.id)),
+    void 0,
+    rootOwners
+  );
+  const sites = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const member = owners.get(row.id);
+    if (member === void 0) continue;
+    const rootOwnerId = Reflect.get(rootOwners.get(row.id) ?? {}, "id");
+    sites.set(row.id, {
+      row,
+      member,
+      ownerClass: typeof rootOwnerId !== "string" ? null : findSchemaPlacement(rootOwnerId, document.classes)?.ownerClass ?? null
+    });
+  }
+  pulledValueInitializerCompilationSites.set(document, sites);
+  return sites;
+}
+function compilePulledValueInitializerBodyV4(document, valueId, compilationProject) {
+  const site = valueInitializerCompilationSites(document).get(valueId);
+  if (site === void 0) {
+    throw new Error(
+      "Cannot compile initializer dependency because its source value row is unresolved."
+    );
+  }
+  compileValueRowInitializerBody({
+    project: document.project,
+    projectFiles: document.projectFiles,
+    members: document.members,
+    classes: document.classes,
+    enums: document.enums,
+    interfaces: document.interfaces,
+    constructors: document.constructors ?? [],
+    member: site.member,
+    valueRow: site.row,
+    valueId: String(Reflect.get(site.row, "id")),
+    initializerOwnerClass: site.ownerClass,
+    storedConstructionReplay: true,
+    ...compilationProject === void 0 ? {} : { compilationProject }
+  });
+}
+function compilePulledProjectDocumentBodiesV4(document, compilationProject) {
   const compileArgs = {
     project: document.project,
     projectFiles: document.projectFiles,
@@ -81246,7 +81616,8 @@ function compilePulledProjectDocumentBodiesV4(document) {
     classes: document.classes,
     enums: document.enums,
     interfaces: document.interfaces,
-    constructors: document.constructors ?? []
+    constructors: document.constructors ?? [],
+    compilationProject
   };
   for (const constructor2 of compileArgs.constructors) {
     compileConstructorRecord({ ...compileArgs, constructor: constructor2 });
@@ -81277,7 +81648,7 @@ function assertPulledConstructorsCompiled(document) {
     );
   }
 }
-function compilePulledMemberInitializerBodyV4(document, memberId) {
+function compilePulledMemberInitializerBodyV4(document, memberId, compilationProject) {
   const compileArgs = {
     project: document.project,
     projectFiles: document.projectFiles,
@@ -81299,12 +81670,16 @@ function compilePulledMemberInitializerBodyV4(document, memberId) {
   compileMemberInitializerBody({
     ...compileArgs,
     member,
-    thisClass
+    thisClass,
+    ...compilationProject === void 0 ? {} : { compilationProject }
   });
 }
 function readPulledProjectDocumentV4(records2) {
   return readProjectDocument(
-    pulledProjectDocumentRaw(replayWorkspace(records2)),
+    // Replay compilation mutates authored `init` envelopes with transient IR.
+    // Keep that evaluator-local: the input records are also the source commit
+    // payload, where compiled bodies are deliberately absent.
+    structuredClone(pulledProjectDocumentRaw(replayWorkspace(records2))),
     { constructors: "authored-or-compiled" }
   );
 }
@@ -81335,6 +81710,7 @@ function replayWorkspace(records2) {
     state: { records: stateRecords }
   };
 }
+var pulledValueInitializerCompilationSites;
 var init_initializer_replay = __esm({
   "src/project-source/initializer-replay.ts"() {
     "use strict";
@@ -81342,11 +81718,14 @@ var init_initializer_replay = __esm({
     init_compile_ns_property();
     init_init_backed_value_materialization();
     init_value_row_owner_members();
+    init_inheritance();
     init_project_document_read();
     init_server_preparation_preflight();
     init_projection();
     init_constructors2();
     init_neoscript_evaluator();
+    init_compiler_adapter();
+    pulledValueInitializerCompilationSites = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -81373,10 +81752,13 @@ function buildValueEmitContext(records2, manifest) {
   const symbolsByValueId = staticSymbols(classes, members);
   let document;
   const readDocument = () => document ??= readPulledProjectDocumentV4(records2);
+  let compilationProject;
+  const readCompilationProject = () => compilationProject ??= createNeoScriptCompilationProject(readDocument());
   let materializedGraph;
   return {
     records: records2,
     readDocument,
+    readCompilationProject,
     readMaterializedGraph: () => {
       if (materializedGraph !== void 0) return materializedGraph;
       materializedGraph = new MaterializedValueGraphContext(
@@ -81524,8 +81906,10 @@ function animationConstructorProjectionTargetValueIds(context, classId, value) {
     return [];
   }
   const targetIds = [];
-  for (const projection of inheritedConstructorProjections2(
+  for (const projection of effectiveConstructorProjections(
     context.manifestClasses,
+    context.manifestConstructors,
+    context.manifestMembers,
     classId
   )) {
     const schemaKey = inheritedProjectionSchemaKey(
@@ -82503,9 +82887,10 @@ 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 (inheritedConstructorProjections2(context.classes, schemaClass2.id).some(
-        (projection) => projection.memberId === childMember.id
-      )) {
+      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.`
         );
@@ -82916,7 +83301,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
         effectiveClass.id,
         assignment.name
       );
-      if (inheritedConstructorProjections2(
+      if (inheritedLegacyConstructorProjections(
         context.classes,
         effectiveClass.id
       ).some((projection) => projection.memberId === childMember.id)) {
@@ -83419,9 +83804,10 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
   }
   for (const assignment of expression.initializer ?? []) {
     const childMember = classMemberByName(context, classId, assignment.name);
-    if (inheritedConstructorProjections2(context.classes, schemaClass2.id).some(
-      (projection) => projection.memberId === childMember.id
-    )) {
+    if (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.`
       );
@@ -83601,7 +83987,7 @@ function classInheritanceChain(classes, classId) {
   }
   return chain;
 }
-function inheritedConstructorProjections2(classes, classId) {
+function inheritedLegacyConstructorProjections(classes, classId) {
   const resolved = [];
   const claimed = /* @__PURE__ */ new Set();
   for (const schemaClass2 of classInheritanceChain(classes, classId)) {
@@ -83613,6 +83999,67 @@ function inheritedConstructorProjections2(classes, classId) {
   }
   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);
+  }
+  const required2 = constructors.get(requiredId);
+  if (required2 === void 0) return [];
+  const projected = requiredConstructorProjectionMap(
+    classes,
+    constructors,
+    members,
+    classId,
+    /* @__PURE__ */ new Set()
+  );
+  if (required2.arguments.some((parameter3) => !projected.has(parameter3.name))) {
+    return [];
+  }
+  return required2.arguments.map((parameter3) => ({
+    parameterName: parameter3.name,
+    memberId: projected.get(parameter3.name)
+  }));
+}
+function requiredConstructorProjectionMap(classes, constructors, members, classId, visited) {
+  if (visited.has(classId)) return /* @__PURE__ */ new Map();
+  const schemaClass2 = classes.get(classId);
+  const requiredId = schemaClass2?.requiredConstructorId;
+  const required2 = requiredId === void 0 ? void 0 : constructors.get(requiredId);
+  if (schemaClass2 === void 0 || required2 === void 0) return /* @__PURE__ */ new Map();
+  const result = /* @__PURE__ */ new Map();
+  for (const memberId of Object.values(schemaClass2.schema)) {
+    const initializer = members.get(memberId)?.defaultValue;
+    if (initializer === null || initializer === void 0 || !("init" in initializer)) {
+      continue;
+    }
+    const parameterName = initializer.init.code.trim();
+    if (required2.arguments.some((parameter3) => parameter3.name === parameterName)) {
+      result.set(parameterName, memberId);
+    }
+  }
+  const baseClassId = schemaClass2.extendsClassId;
+  if (baseClassId === null) return result;
+  const base = requiredConstructorProjectionMap(
+    classes,
+    constructors,
+    members,
+    baseClassId,
+    /* @__PURE__ */ new Set([...visited, classId])
+  );
+  for (const forwarded of required2.baseArguments ?? []) {
+    const sourceName = forwarded.code.trim();
+    if (!required2.arguments.some((parameter3) => parameter3.name === sourceName)) {
+      continue;
+    }
+    const memberId = base.get(forwarded.name);
+    if (memberId !== void 0 && !result.has(sourceName)) {
+      result.set(sourceName, memberId);
+    }
+  }
+  return result;
+}
 function inheritedProjectionSchemaKey(classes, classId, memberId) {
   for (const schemaClass2 of classInheritanceChain(classes, classId)) {
     for (const [schemaKey, declared] of Object.entries(schemaClass2.schema)) {
@@ -83622,8 +84069,10 @@ function inheritedProjectionSchemaKey(classes, classId, memberId) {
   return null;
 }
 function resolveConstructorProjectionArguments(context, schemaClass2, expression, ownerValueId, environment, source) {
-  const projections = inheritedConstructorProjections2(
+  const projections = effectiveConstructorProjections(
     context.classes,
+    context.manifestConstructors,
+    context.members,
     schemaClass2.id
   );
   const signature = describeProjectedConstructor(schemaClass2.name, projections);
@@ -85277,13 +85726,37 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
   if (!isObjectRecord2(value.value))
     return targetTyped ? "new()" : `new ${classValueTypeName(context, classId, member, storedEnvironment)}()`;
   const schema = isObjectRecord2(schemaClass2.schema) ? schemaClass2.schema : {};
-  const projection = constructorProjectionSource(
-    context,
-    classId,
-    value.value,
-    visited,
-    storedEnvironment
-  );
+  const hasStoredConstruction = isObjectRecord2(value.constructorArgs);
+  let projection;
+  try {
+    projection = hasStoredConstruction ? {
+      arguments: [],
+      memberIds: new Set(
+        effectiveConstructorProjections(
+          context.manifestClasses,
+          context.manifestConstructors,
+          context.manifestMembers,
+          classId
+        ).map((entry) => entry.memberId)
+      ),
+      targetValueIds: animationConstructorProjectionTargetValueIds(
+        context,
+        classId,
+        value
+      )
+    } : constructorProjectionSource(
+      context,
+      classId,
+      value.value,
+      visited,
+      storedEnvironment
+    );
+  } catch (error) {
+    throw new Error(
+      `Constructor projection for value "${String(value.id ?? "unknown")}" of class "${schemaClass2.name}" cannot be emitted: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
   const environment = inferAnimationChildOverrideEmitEnvironment(
     context,
     classId,
@@ -85291,15 +85764,23 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     storedEnvironment
   );
   const name = classValueTypeName(context, classId, member, environment);
-  const storedConstruction = storedConstructorCallSource(
-    context,
-    schemaClass2,
-    value,
-    name,
-    environment,
-    visited,
-    targetTyped
-  );
+  let storedConstruction;
+  try {
+    storedConstruction = storedConstructorCallSource(
+      context,
+      schemaClass2,
+      value,
+      name,
+      environment,
+      visited,
+      targetTyped
+    );
+  } catch (error) {
+    throw new Error(
+      `Stored construction for value "${String(value.id ?? "unknown")}" of class "${name}" cannot be emitted: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
   if (storedConstruction !== null && typeof value.id === "string") {
     context.materializedConstructors.set(value.id, storedConstruction);
   }
@@ -85317,7 +85798,7 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     context,
     value.id,
     replayConstruction,
-    member
+    concreteClassMemberForReplay(member, environment)
   );
   const replayRoot = replayRows === null || typeof value.id !== "string" ? void 0 : replayRows.get(value.id);
   const replayGraph = replayRows === null || typeof value.id !== "string" ? null : context.readMaterializedGraph().withRowOverrides(
@@ -85403,11 +85884,27 @@ function storedConstructionReplayRows(context, valueId, code, member) {
     document: context.readDocument(),
     valueId,
     code,
-    member
+    member,
+    compilationProject: context.readCompilationProject()
   });
   context.constructionReplays.set(valueId, replay);
   return replay;
 }
+function concreteClassMemberForReplay(member, environment) {
+  if (numberField(member, "kind") !== 7 /* Class */) return member;
+  const classArguments2 = isObjectRecord2(member.classArguments) ? member.classArguments : {};
+  let changed = false;
+  const concreteArguments = Object.fromEntries(
+    Object.entries(classArguments2).map(([genericParamId, binding]) => {
+      const forwardedParamId = isObjectRecord2(binding) && binding.kind === "generic" && typeof binding.genericParamId === "string" ? binding.genericParamId : null;
+      const bindingMemberId = environment.get(genericParamId) ?? (forwardedParamId === null ? void 0 : environment.get(forwardedParamId));
+      if (bindingMemberId === void 0) return [genericParamId, binding];
+      changed = true;
+      return [genericParamId, { kind: "member", memberId: bindingMemberId }];
+    })
+  );
+  return changed ? { ...member, classArguments: concreteArguments } : member;
+}
 function materializedValueSubgraphsEqual(context, currentGraph, replayGraph, currentId, replayId, member, environment) {
   const resolvedMember = resolveGenericValueMember(
     context,
@@ -85579,8 +86076,30 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         false
       );
     }
+    case "generic": {
+      const bindingId = environment.get(type.genericParamId);
+      const inferredClassId = inferredGenericClassId(bindingId);
+      const resolvedType = inferredClassId === null ? bindingId === void 0 ? null : schemaTypeForBindingMember(context, bindingId, environment) : {
+        kind: "class",
+        nullable: type.nullable,
+        classId: inferredClassId,
+        classArguments: {}
+      };
+      if (resolvedType === null) {
+        throw new Error(
+          `Stored Generic constructor argument cannot resolve parameter ${type.genericParamId}.`
+        );
+      }
+      return storedConstructorArgumentSource(
+        context,
+        { ...resolvedType, nullable: type.nullable || resolvedType.nullable },
+        value,
+        environment,
+        visited,
+        cloneAggregateArguments
+      );
+    }
     case "interface":
-    case "generic":
     case "list":
     case "dictionary":
       if (typeof value !== "string") {
@@ -85631,6 +86150,147 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
       );
   }
 }
+function schemaTypeForBindingMember(context, memberId, environment, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(memberId)) {
+    throw new Error(
+      `Stored constructor argument generic binding contains a member cycle at ${memberId}.`
+    );
+  }
+  const member = context.manifestMembers.get(memberId);
+  if (member === void 0) {
+    throw new Error(
+      `Stored constructor argument generic binding names missing member ${memberId}.`
+    );
+  }
+  const nullable = !member.required;
+  const nextVisited = /* @__PURE__ */ new Set([...visited, memberId]);
+  switch (member.kind) {
+    case "null":
+    case "bool":
+    case "int":
+    case "string":
+    case "float":
+    case "decimal":
+    case "sprite":
+    case "audio":
+    case "vector2":
+    case "vector2Int":
+    case "vector3":
+    case "vector3Int":
+    case "color":
+      return { kind: member.kind, nullable };
+    case "class":
+      return {
+        kind: "class",
+        nullable,
+        classId: member.classId,
+        classArguments: Object.fromEntries(
+          Object.entries(member.classArguments).map(
+            ([parameterId, binding]) => [
+              parameterId,
+              binding.kind === "member" ? schemaTypeForBindingMember(
+                context,
+                binding.memberId,
+                environment,
+                nextVisited
+              ) : schemaTypeForBindingMember(
+                context,
+                requiredGenericBindingMemberId(
+                  environment,
+                  binding.genericParamId
+                ),
+                environment,
+                nextVisited
+              )
+            ]
+          )
+        )
+      };
+    case "enum":
+      return { kind: "enum", nullable, enumId: member.enumId };
+    case "list":
+      return {
+        kind: "list",
+        nullable,
+        entryType: schemaTypeForBindingMember(
+          context,
+          member.entryMemberId,
+          environment,
+          nextVisited
+        ),
+        listMemberId: member.id,
+        readOnly: member.isReadOnly
+      };
+    case "dictionary":
+      return {
+        kind: "dictionary",
+        nullable,
+        entryType: schemaTypeForBindingMember(
+          context,
+          member.entryMemberId,
+          environment,
+          nextVisited
+        ),
+        keyEnumId: member.key.kind === "enum" ? member.key.enumId : null,
+        readOnly: member.isReadOnly
+      };
+    case "lookup": {
+      if (member.declaredType !== null) {
+        return { ...member.declaredType, nullable };
+      }
+      const collection = context.manifestMembers.get(member.collectionMemberId);
+      if (collection?.kind !== "list" && collection?.kind !== "dictionary") {
+        throw new Error(
+          `Stored constructor argument Lookup binding ${member.id} has no collection entry type.`
+        );
+      }
+      return {
+        kind: "lookup",
+        nullable,
+        entryType: schemaTypeForBindingMember(
+          context,
+          collection.entryMemberId,
+          environment,
+          nextVisited
+        ),
+        collectionMemberId: member.collectionMemberId,
+        collectionValueId: member.collectionValueId
+      };
+    }
+    case "dialogueLookup":
+      return { kind: "dialogueLookup", nullable };
+    case "delegate":
+      return {
+        kind: "delegate",
+        nullable,
+        returnType: member.returnType,
+        argumentTypes: member.arguments.map((argument2) => argument2.type)
+      };
+    case "generic":
+      return schemaTypeForBindingMember(
+        context,
+        requiredGenericBindingMemberId(environment, member.genericParamId),
+        environment,
+        nextVisited
+      );
+    case "computed":
+    case "function":
+    case "scriptFunction":
+    case "functionRef":
+      throw new Error(
+        `Stored constructor argument cannot use ${member.kind} member ${member.id} as a generic type binding.`
+      );
+  }
+}
+function requiredGenericBindingMemberId(environment, genericParamId) {
+  const bindingId = environment.get(genericParamId);
+  if (bindingId === void 0 || inferredGenericClassId(bindingId) !== null) {
+    throw new Error(
+      `Stored constructor argument cannot resolve generic binding ${genericParamId} to a member.`
+    );
+  }
+  return bindingId;
+}
 function storedAggregateCloneSource(context, type, valueId, environment) {
   if (!context.values.has(valueId)) {
     throw new Error(
@@ -85930,8 +86590,10 @@ function manifestMemberTypeName(context, member) {
   return fixedSourceTypeNameForKind(member.kind) ?? member.kind;
 }
 function constructorProjectionSource(context, classId, body, visited, environment) {
-  const projections = inheritedConstructorProjections2(
+  const projections = effectiveConstructorProjections(
     context.manifestClasses,
+    context.manifestConstructors,
+    context.manifestMembers,
     classId
   );
   const argumentsValue = [];
@@ -86525,6 +87187,7 @@ var init_value_sources = __esm({
     init_member_value_id();
     init_members();
     init_compile_ns_property();
+    init_compile();
     init_constructor_argument_ownership();
     init_structured_leaf_source();
     init_member_kind_type_names();
@@ -88762,6 +89425,10 @@ async function runPull(workspace, options) {
 async function runNormalPull(workspace, options, progress) {
   const destructive = options.force;
   const hasBaseline = Object.keys(workspace.state.records).length > 0;
+  const mainLocale = workspaceMainLocale(workspace.state.records);
+  if (acceptSourceEquivalentConflictBases(workspace, mainLocale) > 0) {
+    writeWorkspaceState(workspace.root, workspace.state);
+  }
   let localByKey = /* @__PURE__ */ new Map();
   let localStatus = null;
   if (hasBaseline && !destructive) {
@@ -88854,10 +89521,11 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
       continue;
     }
     const serverChanged = serverRecord.contentHash !== baseState.contentHash;
-    const localChanged = local !== void 0 && baseState.file !== void 0 && !authoredRecordsSemanticallyEqual(
+    const localChanged = local !== void 0 && baseState.file !== void 0 && !sourceAuthoredRecordsSemanticallyEqual(
       serverRecord.recordKind,
       local,
-      baseState.data
+      baseState.data,
+      mainLocale
     );
     const locallyDeleted = hasBaseline && baseState.file !== void 0 && local === void 0;
     if (!serverChanged) {
@@ -88866,7 +89534,8 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
           serverRecord.recordKind,
           baseState.data,
           serverRecord.data,
-          local
+          local,
+          mainLocale
         ).merged,
         serverHash: baseState.contentHash,
         serverData: baseState.data,
@@ -88888,7 +89557,8 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
       serverRecord.recordKind,
       baseState.data,
       serverRecord.data,
-      localSide
+      localSide,
+      mainLocale
     );
     if (locallyDeleted || conflictFields.length > 0) {
       conflictCount += 1;
@@ -88921,10 +89591,11 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     if (baseState !== void 0 && !document.records.has(key)) {
       const binary = localBinaryById.get(baseState.recordId);
       const binaryChanged = binary !== void 0 && binary.action !== "unchanged" && binary.action !== "converged";
-      if (authoredRecordsSemanticallyEqual(
+      if (sourceAuthoredRecordsSemanticallyEqual(
         baseState.recordKind,
         local,
-        baseState.data
+        baseState.data,
+        mainLocale
       ) && !binaryChanged) {
         continue;
       }
@@ -89385,6 +90056,30 @@ function sourceComparableRecord(recordKind, value, mainLocale) {
   }
   return result;
 }
+function acceptSourceEquivalentConflictBases(workspace, mainLocale) {
+  let accepted = 0;
+  for (const [key, record3] of Object.entries(workspace.state.records)) {
+    if (typeof record3.conflictServerHash !== "string") continue;
+    if (!sourceAuthoredRecordsSemanticallyEqual(
+      record3.recordKind,
+      record3.data,
+      record3.conflictServerData,
+      mainLocale
+    )) {
+      continue;
+    }
+    const next = {
+      ...record3,
+      contentHash: record3.conflictServerHash,
+      data: record3.conflictServerData
+    };
+    delete next.conflictServerHash;
+    delete next.conflictServerData;
+    workspace.state.records[key] = next;
+    accepted += 1;
+  }
+  return accepted;
+}
 function workspaceMainLocale(records2) {
   const config = Object.values(records2).find(
     (record3) => record3.recordKind === "localization-config"
@@ -89392,11 +90087,27 @@ function workspaceMainLocale(records2) {
   const data = config?.data;
   return isObjectRecord2(data) && typeof data.mainLocale === "string" ? data.mainLocale : "en-US";
 }
-function authoredRecordsSemanticallyEqual(recordKind, left, right) {
-  return isSchemaRecordKindV4(recordKind) ? schemaDocumentAuthoredSemanticallyEqual(recordKind, left, right) : canonicallyEqual(left, right);
+function mergeProjectDocumentRecord(recordKind, base, server, local, mainLocale) {
+  if (isSchemaRecordKindV4(recordKind)) {
+    return mergeSchemaDocumentRecord(recordKind, base, server, local);
+  }
+  return threeWayMergeRecord(base, server, local, {
+    recursive: true,
+    comparison: {
+      base: sourceComparableObjectRecord(recordKind, base, mainLocale),
+      server: sourceComparableObjectRecord(recordKind, server, mainLocale),
+      local: sourceComparableObjectRecord(recordKind, local, mainLocale)
+    }
+  });
 }
-function mergeProjectDocumentRecord(recordKind, base, server, local) {
-  return isSchemaRecordKindV4(recordKind) ? mergeSchemaDocumentRecord(recordKind, base, server, local) : threeWayMergeRecord(base, server, local, { recursive: true });
+function sourceComparableObjectRecord(recordKind, value, mainLocale) {
+  const comparable = sourceComparableRecord(recordKind, value, mainLocale);
+  if (!isObjectRecord2(comparable)) {
+    throw new Error(
+      `Cannot merge ${recordKind} record because its source-comparable payload is not an object.`
+    );
+  }
+  return comparable;
 }
 function buildEmitRecordSet(document, plans, side) {
   const records2 = /* @__PURE__ */ new Map();