@neocompose/cli 0.22.5 → 0.22.7

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.22.7] - 2026-08-05
+
+### Fixed
+
+- Pull and reset cache canonical required-constructor calls reconstructed from
+  legacy materialized rows that predate durable constructor arguments.
+- A pull followed by status or push remains a semantic no-op for projected
+  animation track and generic segment-frame rows, while later constructor edits
+  are still detected normally.
+
+## [0.22.6] - 2026-08-05
+
+### Fixed
+
+- Normal pull ignores compiler-derived NeoScript body differences and clears
+  stale conflict bookkeeping when authored source already matches Production.
+- Required-constructor replay compiles nested generic initializer rows without
+  mutating authored source payloads, including immutable animation defaults.
+- Large constructor replays reuse project indexes and an immutable persisted
+  snapshot, keeping Neowyn push dry-runs in seconds rather than minutes.
+
 ## [0.22.5] - 2026-08-04
 
 ### Fixed

package/dist/neo.mjs

@@ -40934,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,
@@ -41292,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(
@@ -54223,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;
     };
   }
 });
@@ -55356,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) {
@@ -55520,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
@@ -56528,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;
   }
@@ -56537,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)) {
@@ -56845,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(
@@ -56854,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 */) {
@@ -59089,7 +59124,7 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
       `Cannot construct abstract Class '${schemaClass2.name}'.`
     );
   }
-  const replaySlot = ctx.__storedConstructionReplaySlot;
+  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,
@@ -59938,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 : "");
@@ -59952,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(
@@ -59973,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) {
@@ -60094,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`);
@@ -61547,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 = {
@@ -69864,14 +69928,16 @@ function materializedInitializerReconciliationFailuresV4(args) {
     [...args.reconciliations.values()].map((entry) => [entry.valueId, entry])
   );
   const candidateValueIds = new Set(
-    [...reconciliationByValueId.values()].filter((reconciliation) => reconciliation.storedConstructorArgs !== null).map((reconciliation) => reconciliation.valueId)
+    [...reconciliationByValueId.values()].filter(
+      (reconciliation) => reconciliation.storedConstructorArgs !== null || reconciliation.requiresCanonicalConstruction === true
+    ).map((reconciliation) => reconciliation.valueId)
   );
   const candidateOwners = resolveOwnerMembersForValues(
     document,
     candidateValueIds
   );
   const currentRecords = reconciliationRecords(args.workspace, []);
-  const cachedExpressions = readMaterializedConstructionBuildCacheV1(
+  const cachedExpressions = args.useBuildCaches === false ? null : readMaterializedConstructionBuildCacheV1(
     args.workspace.root,
     args.workspace.state
   );
@@ -69895,28 +69961,60 @@ 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 authoredConstructionChangedByValueId = /* @__PURE__ */ new Map();
   const replayableValueIds = /* @__PURE__ */ new Set();
   for (const valueId of candidateValueIds) {
     const reconciliation = reconciliationByValueId.get(valueId);
     const owner = candidateOwners.get(valueId);
     if (reconciliation === void 0 || owner === void 0) continue;
-    const authoredConstructionChanged = args.manifest !== void 0 && canonicalExpressions.get(valueId) !== constructorExpressionSlice(reconciliation.code);
-    if (authoredConstructionChanged || recompileTargets.valueIds.has(valueId)) {
+    const canonicalExpression = canonicalExpressions.get(valueId);
+    if (args.manifest !== void 0 && canonicalExpression === void 0) {
+      throw new Error(
+        `Cannot reconcile stored construction for value "${valueId}": its canonical pulled constructor expression is unavailable.`
+      );
+    }
+    const authoredConstructionChanged = args.manifest !== void 0 && canonicalExpression !== constructorExpressionSlice(reconciliation.code);
+    authoredConstructionChangedByValueId.set(
+      valueId,
+      authoredConstructionChanged
+    );
+    if (reconciliation.storedConstructorArgs !== null && (authoredConstructionChanged || recompileTargets.valueIds.has(valueId))) {
       replayableValueIds.add(valueId);
     }
   }
   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;
+    if (reconciliation.storedConstructorArgs === null) {
+      if (reconciliation.requiresCanonicalConstruction !== true) continue;
+      if (authoredConstructionChangedByValueId.get(reconciliation.valueId) !== true) {
+        continue;
+      }
+      const position2 = composeReferenceSitePosition(
+        reconciliation.site,
+        args.sourceTextByUri
+      );
+      failures.push(
+        new SchemaSourceError(
+          `construction-arguments-conflict: Value "${reconciliation.valueId}" is already materialized without durable constructor arguments, and this construction no longer matches its pulled canonical projection. Delete and recreate the value to change its construction.`,
+          position2.file,
+          position2.line,
+          position2.column,
+          "construction-arguments-conflict"
+        )
+      );
+      continue;
+    }
     if (!replayableValueIds.has(reconciliation.valueId)) continue;
     const owner = owners.get(reconciliation.valueId);
     if (owner === void 0) {
@@ -70253,6 +70351,7 @@ var init_local_initializer_materialization = __esm({
     init_value_row_owner_members();
     init_neo_script_recompile_scope();
     init_neoscript_build_cache();
+    init_compiler_adapter();
   }
 });
 
@@ -70458,7 +70557,12 @@ function computeWorkspaceStatus(workspace, options) {
     seeds: /* @__PURE__ */ new Map()
   };
   let projectAnalysisV4 = null;
-  const valueLowerRegistry = createValueLowerRegistryV4();
+  const valueLowerRegistry = createValueLowerRegistryV4({
+    materializedConstructorExpressions: options.useBuildCaches === false ? /* @__PURE__ */ new Map() : readMaterializedConstructionBuildCacheV1(
+      workspace.root,
+      workspace.state
+    ) ?? /* @__PURE__ */ new Map()
+  });
   try {
     if (!baseManifest) {
       throw new Error(
@@ -70891,6 +70995,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])
         )
@@ -70961,13 +71066,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(
@@ -71035,17 +71142,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 }] : [];
@@ -71072,7 +71181,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);
@@ -71085,26 +71211,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(
@@ -71116,6 +71250,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])
@@ -71489,6 +71629,8 @@ var init_workspace_status_core = __esm({
     init_local_initializer_materialization();
     init_push_change_intent();
     init_initializer_replay();
+    init_compiler_adapter();
+    init_materialized_construction_cache();
     IGNORED_SCHEMA_DIRECTORIES = /* @__PURE__ */ new Set([
       ".git",
       ".neo",
@@ -71539,6 +71681,7 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
   }
   const status = computeWorkspaceStatus(workspace, {
     skipProjectBinaryInspection: true,
+    useBuildCaches: false,
     writeProjectAnalysisCache: () => void 0,
     trustedPendingProjectFiles,
     virtualSourceFiles: args.files,
@@ -75076,13 +75219,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,
@@ -77266,6 +77410,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) {
@@ -77273,6 +77420,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,
@@ -77287,7 +77436,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) {
@@ -81330,8 +81480,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) {
@@ -81384,7 +81548,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(
@@ -81407,15 +81571,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,
-        args.compilationProject
-      );
-      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(
@@ -81425,7 +81598,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,
@@ -81433,7 +81654,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 });
@@ -81492,7 +81714,10 @@ function compilePulledMemberInitializerBodyV4(document, memberId, compilationPro
 }
 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" }
   );
 }
@@ -81523,6 +81748,7 @@ function replayWorkspace(records2) {
     state: { records: stateRecords }
   };
 }
+var pulledValueInitializerCompilationSites;
 var init_initializer_replay = __esm({
   "src/project-source/initializer-replay.ts"() {
     "use strict";
@@ -81530,11 +81756,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();
   }
 });
 
@@ -81677,11 +81906,20 @@ function emitStoredConstructorExpression(context, member, valueId) {
     value,
     instanceGenericEnvironment(context, classId, resolvedMember, void 0)
   );
-  const targetValueIds = animationConstructorProjectionTargetValueIds(
+  if (!isObjectRecord2(value.value)) {
+    throw new Error(
+      `Stored materialized value ${valueId} has no Class body to project.`
+    );
+  }
+  const hasStoredConstruction = isObjectRecord2(value.constructorArgs);
+  const projection = hasStoredConstruction ? null : constructorProjectionSource(
     context,
     classId,
-    value
+    value.value,
+    /* @__PURE__ */ new Set([valueId]),
+    storedEnvironment
   );
+  const targetValueIds = projection?.targetValueIds ?? animationConstructorProjectionTargetValueIds(context, classId, value);
   const environment = inferAnimationChildOverrideEmitEnvironment(
     context,
     classId,
@@ -81703,12 +81941,13 @@ function emitStoredConstructorExpression(context, member, valueId) {
     /* @__PURE__ */ new Set([valueId]),
     false
   );
-  if (constructor2 === null) {
+  if (constructor2 !== null) return constructor2;
+  if (projection === null || projection.arguments.length === 0 && schemaClass2.requiredConstructorId === void 0) {
     throw new Error(
       `Stored materialized value ${valueId} has no constructor arguments.`
     );
   }
-  return constructor2;
+  return projection.arguments.length === 0 ? `new ${className}()` : constructorCallSource(`new ${className}`, projection.arguments);
 }
 function animationConstructorProjectionTargetValueIds(context, classId, value) {
   if (context.manifestClasses.get(classId)?.system?.worldKind !== "animationChildOverride" || !isObjectRecord2(value.value)) {
@@ -81849,8 +82088,9 @@ function qualifiedProjectFileSymbolsV4(records2) {
   }
   return result;
 }
-function createValueLowerRegistryV4() {
+function createValueLowerRegistryV4(options = {}) {
   return {
+    materializedConstructorExpressions: options.materializedConstructorExpressions ?? /* @__PURE__ */ new Map(),
     pendingValues: /* @__PURE__ */ new Map(),
     pendingLocalizedTexts: /* @__PURE__ */ new Map(),
     pendingBindingMembersByClassId: /* @__PURE__ */ new Map(),
@@ -81954,7 +82194,8 @@ function buildValueLowerContext(state, manifest, options = {}) {
     referenceObligations: registry.referenceObligations,
     loweringFailures: registry.loweringFailures,
     pendingValueIdentitySites: registry.pendingValueIdentitySites,
-    initializerReconciliations: registry.initializerReconciliations
+    initializerReconciliations: registry.initializerReconciliations,
+    materializedConstructorExpressions: registry.materializedConstructorExpressions
   };
 }
 function indexMemberOverrides(members) {
@@ -83399,20 +83640,28 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
     }
     indexInitAuthoredRowIds(context, code, source.label);
     const storedConstructorArgs = isObjectRecord2(base.constructorArgs) ? base.constructorArgs : null;
-    const materializedPlainClass = resolvedMember.kind === "class" && isObjectRecord2(base.value) && context.classes.get(
+    const materializedClass = resolvedMember.kind === "class" && isObjectRecord2(base.value);
+    const materializedPlainClass = materializedClass && context.classes.get(
       typeof base.classId === "string" ? base.classId : resolvedMember.classId
     )?.requiredConstructorId === void 0;
-    if (storedConstructorArgs !== null || materializedPlainClass) {
+    const requiresCanonicalConstruction = storedConstructorArgs === null && materializedClass && !materializedPlainClass;
+    const canonicalConstruction = context.materializedConstructorExpressions.get(expectedValueId);
+    const authoredConstruction = constructorExpressionSlice(code);
+    const canonicalConstructionMatches = canonicalConstruction !== void 0 && canonicalConstruction === authoredConstruction;
+    const canonicalConstructionMissing = requiresCanonicalConstruction && canonicalConstruction === void 0;
+    const preserveRequiredStoredConstruction = requiresCanonicalConstruction && source.purpose === "stored";
+    if (storedConstructorArgs !== null || materializedPlainClass || canonicalConstructionMatches || canonicalConstructionMissing || preserveRequiredStoredConstruction) {
       if (resolvedMember.kind !== "class") {
         throw new Error(
           `Value ${expectedValueId} stores constructor arguments but its declared member ${resolvedMember.name} is not a Class.`
         );
       }
-      if (source.purpose === "stored") {
+      if (source.purpose === "stored" || canonicalConstructionMissing) {
         context.initializerReconciliations.set(expectedValueId, {
           valueId: expectedValueId,
           code,
           storedConstructorArgs: storedConstructorArgs === null ? null : structuredClone(storedConstructorArgs),
+          ...requiresCanonicalConstruction ? { requiresCanonicalConstruction: true } : {},
           settleFields: expression.kind === "new" ? (expression.initializer ?? []).map(
             (assignment) => assignment.name
           ) : [],
@@ -85590,9 +85839,6 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
       { cause: error }
     );
   }
-  if (storedConstruction !== null && typeof value.id === "string") {
-    context.materializedConstructors.set(value.id, storedConstruction);
-  }
   const replayConstruction = storedConstruction === null ? null : storedConstructorCallSource(
     context,
     schemaClass2,
@@ -85671,6 +85917,9 @@ ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
 }`;
   }
   const constructor2 = storedConstruction !== null ? storedConstruction : projection.arguments.length > 0 ? constructorCallSource(`new ${name}`, projection.arguments) : targetTyped ? "new()" : `new ${name}()`;
+  if (typeof value.id === "string" && (storedConstruction !== null || projection.arguments.length > 0 || schemaClass2.requiredConstructorId !== void 0)) {
+    context.materializedConstructors.set(value.id, constructor2);
+  }
   return fields.length === 0 ? constructor2 : `${storedConstruction !== null || projection.arguments.length > 0 ? constructor2 : targetTyped ? "new()" : `new ${name}`} {
 ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
 }`;
@@ -86506,16 +86755,22 @@ function instanceGenericEnvironment(context, classId, member, outerEnvironment)
   const bindings = classGenericBindings(context.manifestClasses, classId);
   const memberId = stringField3(member, "id");
   const manifestMember = context.manifestMembers.get(memberId);
-  if (manifestMember?.kind === "class") {
-    for (const [genericParamId, argument2] of Object.entries(
-      manifestMember.classArguments
+  const rawClassArguments = isObjectRecord2(member.classArguments) ? member.classArguments : null;
+  const classArguments2 = rawClassArguments ?? (manifestMember?.kind === "class" ? manifestMember.classArguments : null);
+  if (classArguments2 !== null) {
+    for (const [genericParamId, rawArgument] of Object.entries(
+      classArguments2
     )) {
+      const argument2 = isObjectRecord2(rawArgument) ? rawArgument : null;
       if (bindings.get(genericParamId)?.kind === "member") continue;
-      if (argument2.kind === "member") {
-        bindings.set(genericParamId, argument2);
+      if (argument2?.kind === "member" && typeof argument2.memberId === "string") {
+        bindings.set(genericParamId, {
+          kind: "member",
+          memberId: argument2.memberId
+        });
         continue;
       }
-      const outerMemberId = outerEnvironment?.get(argument2.genericParamId);
+      const outerMemberId = argument2?.kind === "generic" && typeof argument2.genericParamId === "string" ? outerEnvironment?.get(argument2.genericParamId) : void 0;
       if (outerMemberId !== void 0) {
         bindings.set(genericParamId, {
           kind: "member",
@@ -89234,6 +89489,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) {
@@ -89326,10 +89585,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) {
@@ -89338,7 +89598,8 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
           serverRecord.recordKind,
           baseState.data,
           serverRecord.data,
-          local
+          local,
+          mainLocale
         ).merged,
         serverHash: baseState.contentHash,
         serverData: baseState.data,
@@ -89360,7 +89621,8 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
       serverRecord.recordKind,
       baseState.data,
       serverRecord.data,
-      localSide
+      localSide,
+      mainLocale
     );
     if (locallyDeleted || conflictFields.length > 0) {
       conflictCount += 1;
@@ -89393,10 +89655,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;
       }
@@ -89857,6 +90120,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"
@@ -89864,11 +90151,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.22.5",
+  "version": "0.22.7",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.22.5 -->
+<!-- reviewed-through-cli: 0.22.7 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -78,7 +78,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.22.5 -->
+<!-- reviewed-through-cli: 0.22.7 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale