@neocompose/cli 0.22.6 → 0.22.7

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 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

package/dist/neo.mjs

@@ -69928,7 +69928,9 @@ 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,
@@ -69968,13 +69970,24 @@ function materializedInitializerReconciliationFailuresV4(args) {
       }
     }
   }
+  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);
     }
   }
@@ -69982,7 +69995,26 @@ function materializedInitializerReconciliationFailuresV4(args) {
   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) {
@@ -70525,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(
@@ -71593,6 +71630,7 @@ var init_workspace_status_core = __esm({
     init_push_change_intent();
     init_initializer_replay();
     init_compiler_adapter();
+    init_materialized_construction_cache();
     IGNORED_SCHEMA_DIRECTORIES = /* @__PURE__ */ new Set([
       ".git",
       ".neo",
@@ -81868,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,
@@ -81894,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)) {
@@ -82040,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(),
@@ -82145,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) {
@@ -83590,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
           ) : [],
@@ -85781,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,
@@ -85862,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")}
 }`;
@@ -86697,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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.22.6",
+  "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.6 -->
+<!-- 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.6 -->
+<!-- reviewed-through-cli: 0.22.7 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale