@neocompose/cli 0.72.2 → 0.72.4

package/dist/neo.mjs

@@ -28917,12 +28917,18 @@ function identPathSegments(expression) {
   if (receiver === null) return null;
   return [...receiver, expression.name];
 }
-function receiverNarrowings(path, rootEntry, scope) {
+function unaffectedNarrowings(path, rootEntry, scope) {
   const facts = [];
-  for (let dot = path.indexOf("."); dot !== -1; dot = path.indexOf(".", dot + 1)) {
-    const prefix = path.slice(0, dot);
-    const type = scope.lookupNarrowedType(prefix, rootEntry);
-    if (type !== null) facts.push([prefix, type]);
+  const prefix = `${path}.`;
+  const dot = path.lastIndexOf(".");
+  if (dot === -1) return facts;
+  const member = path.slice(dot);
+  for (const [candidate, narrowed] of scope.effectiveNarrowedPaths()) {
+    if (narrowed.rootEntry !== rootEntry) continue;
+    if (candidate === path || candidate.startsWith(prefix)) continue;
+    if (candidate.endsWith(member) || candidate.includes(`${member}.`))
+      continue;
+    facts.push([candidate, narrowed.type]);
   }
   return facts;
 }
@@ -29246,22 +29252,22 @@ function localsWithBindings(locals, expression, whenTrue) {
     ...facts.flatMap((fact) => fact.bindingName ? [fact.bindingName] : [])
   ]);
 }
-function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(), inheritedLocals = /* @__PURE__ */ new Set(), flowCache = /* @__PURE__ */ new WeakMap()) {
+function collectAssignedPaths(statements, roots = /* @__PURE__ */ new Set(), inheritedLocals = /* @__PURE__ */ new Set(), flowCache = /* @__PURE__ */ new WeakMap()) {
   const locals = new Set(inheritedLocals);
   for (const statement of statements) {
     if (statement.kind === "assign") {
       const assignedPath = canonicalPath(statement.target);
       if (assignedPath && !locals.has(pathRoot(assignedPath))) {
-        roots.add(pathRoot(assignedPath));
+        roots.add(assignedPath);
       }
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.target,
         roots,
         locals,
         flowCache
       );
       if (statement.value)
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           statement.value,
           roots,
           locals,
@@ -29270,7 +29276,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "varDecl") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.init,
         roots,
         locals,
@@ -29284,7 +29290,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       const falseFacts = [];
       const fallthroughFacts = [];
       for (const branch of statement.branches) {
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           branch.cond,
           roots,
           falseLocals,
@@ -29294,7 +29300,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
           ...falseFacts,
           ...factsWhenTrue(branch.cond, canonicalPath)
         ];
-        collectAssignedPathRoots(
+        collectAssignedPaths(
           branch.body,
           roots,
           localsWithBindings(falseLocals, branch.cond, true),
@@ -29306,12 +29312,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
         falseLocals = localsWithBindings(falseLocals, branch.cond, false);
       }
       if (statement.elseBody) {
-        collectAssignedPathRoots(
-          statement.elseBody,
-          roots,
-          falseLocals,
-          flowCache
-        );
+        collectAssignedPaths(statement.elseBody, roots, falseLocals, flowCache);
         if (statementFlow(statement.elseBody, flowCache).has("fallthrough"))
           fallthroughFacts.push(falseFacts);
       } else {
@@ -29323,18 +29324,18 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "try") {
-      collectAssignedPathRoots(statement.body, roots, locals, flowCache);
+      collectAssignedPaths(statement.body, roots, locals, flowCache);
       for (const clause of statement.catches) {
         const catchLocals = /* @__PURE__ */ new Set([...locals, clause.name]);
         if (clause.filter) {
-          collectAssignedPathRootsInExpression(
+          collectAssignedPathsInExpression(
             clause.filter,
             roots,
             catchLocals,
             flowCache
           );
         }
-        collectAssignedPathRoots(
+        collectAssignedPaths(
           clause.body,
           roots,
           clause.filter ? localsWithBindings(catchLocals, clause.filter, true) : catchLocals,
@@ -29344,13 +29345,13 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "while" || statement.kind === "doWhile") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.condition,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         statement.body,
         roots,
         statement.kind === "while" ? localsWithBindings(locals, statement.condition, true) : locals,
@@ -29359,14 +29360,14 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "for") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.initializer.init,
         roots,
         locals,
         flowCache
       );
       const loopLocals = /* @__PURE__ */ new Set([...locals, statement.initializer.name]);
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.condition,
         roots,
         loopLocals,
@@ -29377,22 +29378,17 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
         statement.condition,
         true
       );
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         [statement.iterator],
         roots,
         iterationLocals,
         flowCache
       );
-      collectAssignedPathRoots(
-        statement.body,
-        roots,
-        iterationLocals,
-        flowCache
-      );
+      collectAssignedPaths(statement.body, roots, iterationLocals, flowCache);
       continue;
     }
     if (statement.kind === "forEach") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.collection,
         roots,
         locals,
@@ -29400,11 +29396,11 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       );
       const loopLocals = /* @__PURE__ */ new Set([...locals, statement.name]);
       if (statement.key) loopLocals.add(statement.key.name);
-      collectAssignedPathRoots(statement.body, roots, loopLocals, flowCache);
+      collectAssignedPaths(statement.body, roots, loopLocals, flowCache);
       continue;
     }
     if (statement.kind === "switch") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.selector,
         roots,
         locals,
@@ -29413,7 +29409,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       for (const section of statement.sections) {
         for (const label of section.labels) {
           if (label.kind === "case") {
-            collectAssignedPathRootsInExpression(
+            collectAssignedPathsInExpression(
               label.expression,
               roots,
               locals,
@@ -29421,13 +29417,13 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
             );
           }
         }
-        collectAssignedPathRoots(section.body, roots, locals, flowCache);
+        collectAssignedPaths(section.body, roots, locals, flowCache);
       }
       continue;
     }
     if (statement.kind === "return" || statement.kind === "throw") {
       if (statement.expr)
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           statement.expr,
           roots,
           locals,
@@ -29436,7 +29432,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "exprStmt") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.expr,
         roots,
         locals,
@@ -29446,43 +29442,28 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
   }
   return roots;
 }
-function collectAssignedPathRootsInExpression(expression, roots, locals, flowCache) {
+function collectAssignedPathsInExpression(expression, roots, locals, flowCache) {
   switch (expression.kind) {
     case "litInterp":
       for (const part of expression.parts) {
         if (part.kind === "expr") {
-          collectAssignedPathRootsInExpression(
-            part.expr,
-            roots,
-            locals,
-            flowCache
-          );
+          collectAssignedPathsInExpression(part.expr, roots, locals, flowCache);
         }
       }
       return;
     case "litList":
       for (const element of expression.elements) {
-        collectAssignedPathRootsInExpression(element, roots, locals, flowCache);
+        collectAssignedPathsInExpression(element, roots, locals, flowCache);
       }
       return;
     case "litDict":
       for (const entry of expression.entries) {
-        collectAssignedPathRootsInExpression(
-          entry.key,
-          roots,
-          locals,
-          flowCache
-        );
-        collectAssignedPathRootsInExpression(
-          entry.value,
-          roots,
-          locals,
-          flowCache
-        );
+        collectAssignedPathsInExpression(entry.key, roots, locals, flowCache);
+        collectAssignedPathsInExpression(entry.value, roots, locals, flowCache);
       }
       return;
     case "member":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.receiver,
         roots,
         locals,
@@ -29490,13 +29471,13 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "index":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.receiver,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.index,
         roots,
         locals,
@@ -29504,32 +29485,22 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "call":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.callee,
         roots,
         locals,
         flowCache
       );
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(
-          argument2,
-          roots,
-          locals,
-          flowCache
-        );
+        collectAssignedPathsInExpression(argument2, roots, locals, flowCache);
       }
       return;
     case "new":
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(
-          argument2,
-          roots,
-          locals,
-          flowCache
-        );
+        collectAssignedPathsInExpression(argument2, roots, locals, flowCache);
       }
       for (const initializer of expression.initializer ?? []) {
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           initializer.value,
           roots,
           locals,
@@ -29540,15 +29511,10 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
     case "annotated":
       for (const annotation2 of expression.annotations) {
         for (const argument2 of annotation2.args) {
-          collectAssignedPathRootsInExpression(
-            argument2,
-            roots,
-            locals,
-            flowCache
-          );
+          collectAssignedPathsInExpression(argument2, roots, locals, flowCache);
         }
       }
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.expression,
         roots,
         locals,
@@ -29557,13 +29523,13 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       return;
     case "binary":
     case "coalesce":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.left,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.right,
         roots,
         locals,
@@ -29571,19 +29537,19 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "conditional":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.condition,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.whenTrue,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.whenFalse,
         roots,
         locals,
@@ -29592,7 +29558,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       return;
     case "unary":
     case "force":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -29600,7 +29566,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "is":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -29608,7 +29574,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "lambda":
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         expression.body,
         roots,
         /* @__PURE__ */ new Set([
@@ -30602,14 +30568,17 @@ var init_strict_resolver = __esm({
         return this.invalidatedRoots;
       }
       effectiveNarrowedPaths() {
-        const effective = this.parent ? new Map(this.parent.effectiveNarrowedPaths()) : /* @__PURE__ */ new Map();
-        for (const invalidated of this.invalidatedRoots) {
-          for (const [path, narrowed] of effective) {
-            if (narrowed.rootEntry === invalidated) effective.delete(path);
+        const effective = new Map(this.narrowedPaths);
+        const invalidated = new Set(this.invalidatedRoots);
+        for (const root of this.hiddenNarrowingRoots) invalidated.add(root);
+        for (let current = this.parent; current; current = current.parent) {
+          for (const [path, narrowed] of current.narrowedPaths) {
+            if (!effective.has(path) && !invalidated.has(narrowed.rootEntry)) {
+              effective.set(path, narrowed);
+            }
           }
-        }
-        for (const [path, narrowed] of this.narrowedPaths) {
-          effective.set(path, narrowed);
+          for (const root of current.invalidatedRoots) invalidated.add(root);
+          for (const root of current.hiddenNarrowingRoots) invalidated.add(root);
         }
         return effective;
       }
@@ -30635,6 +30604,9 @@ var init_strict_resolver = __esm({
       hideInheritedNarrowing(rootEntry) {
         this.hiddenNarrowingRoots.add(rootEntry);
         this.updatePatternType(rootEntry, rootEntry.type);
+        for (const [path, narrowed] of this.narrowedPaths) {
+          if (narrowed.rootEntry === rootEntry) this.narrowedPaths.delete(path);
+        }
       }
       invalidate(rootEntry) {
         this.invalidatedRoots.add(rootEntry);
@@ -31192,24 +31164,26 @@ var init_strict_resolver = __esm({
             const branchExitNarrowings = [];
             const branchExitOwnershipScopes = [];
             const branches = statement.branches.map((branch) => {
+              const conditionScope = new Scope(scope);
+              this.applyFactsToScope(conditionScope, cumulativeFalseFacts);
               const condition = this.toBool(
-                this.resolveExpression(branch.cond, scope),
+                this.resolveExpression(branch.cond, conditionScope),
                 branch.cond.pos
               );
               const child2 = new Scope(scope);
               const branchFacts = [
                 ...cumulativeFalseFacts,
-                ...this.conditionFacts(branch.cond, scope, true)
+                ...this.conditionFacts(branch.cond, conditionScope, true)
               ];
               this.applyFactsToScope(child2, branchFacts);
               const instructions = this.resolveStatements(branch.body, child2);
               if (!instructionsTerminate(instructions)) {
                 branchExitFacts.push(branchFacts);
-                branchExitNarrowings.push(new Map(child2.narrowedPaths));
+                branchExitNarrowings.push(child2.effectiveNarrowedPaths());
                 branchExitOwnershipScopes.push(child2);
               }
               cumulativeFalseFacts.push(
-                ...this.conditionFacts(branch.cond, scope, false)
+                ...this.conditionFacts(branch.cond, conditionScope, false)
               );
               return {
                 expression: pointerToBooleanExpression(condition.pointer),
@@ -31223,14 +31197,14 @@ var init_strict_resolver = __esm({
               otherwise = this.resolveStatements(statement.elseBody, elseScope);
               if (!instructionsTerminate(otherwise)) {
                 branchExitFacts.push([...cumulativeFalseFacts]);
-                branchExitNarrowings.push(new Map(elseScope.narrowedPaths));
+                branchExitNarrowings.push(elseScope.effectiveNarrowedPaths());
                 branchExitOwnershipScopes.push(elseScope);
               }
             } else {
               const noBranchScope = new Scope(scope);
               this.applyFactsToScope(noBranchScope, cumulativeFalseFacts);
               branchExitFacts.push([...cumulativeFalseFacts]);
-              branchExitNarrowings.push(new Map(noBranchScope.narrowedPaths));
+              branchExitNarrowings.push(noBranchScope.effectiveNarrowedPaths());
               branchExitOwnershipScopes.push(noBranchScope);
             }
             mergeBranchInvalidations(scope, branchExitOwnershipScopes);
@@ -31464,12 +31438,15 @@ var init_strict_resolver = __esm({
               statement.body,
               conditionLocals
             );
-            this.invalidateLoopEntryNarrowingsAssignedBy(
-              loopEntryScope,
-              loopScope,
-              [statement.iterator],
-              conditionLocals
-            );
+            const bodyFlow = statementFlow(statement.body, /* @__PURE__ */ new WeakMap());
+            if (bodyFlow.has("fallthrough") || bodyFlow.has("continue")) {
+              this.invalidateLoopEntryNarrowingsAssignedBy(
+                loopEntryScope,
+                loopScope,
+                [statement.iterator],
+                conditionLocals
+              );
+            }
             const condition = this.toBool(
               this.resolveExpression(statement.condition, loopEntryScope),
               statement.condition.pos
@@ -32336,13 +32313,13 @@ var init_strict_resolver = __esm({
         if (assignedPath) {
           const rootEntry = scope.lookup(pathRoot(assignedPath));
           if (rootEntry) {
-            const receiverFacts = receiverNarrowings(
+            const retainedFacts = unaffectedNarrowings(
               assignedPath,
               rootEntry,
               scope
             );
             scope.invalidate(rootEntry);
-            for (const [path, type] of receiverFacts) {
+            for (const [path, type] of retainedFacts) {
               scope.narrow(path, rootEntry, type);
             }
             if (statement.op === "=" && !isNullable(value.type)) {
@@ -32559,13 +32536,13 @@ var init_strict_resolver = __esm({
         if (assignedPath) {
           const rootEntry = scope.lookup(pathRoot(assignedPath));
           if (rootEntry) {
-            const receiverFacts = receiverNarrowings(
+            const retainedFacts = unaffectedNarrowings(
               assignedPath,
               rootEntry,
               scope
             );
             scope.invalidate(rootEntry);
-            for (const [path, type] of receiverFacts) {
+            for (const [path, type] of retainedFacts) {
               scope.narrow(path, rootEntry, type);
             }
           }
@@ -33180,18 +33157,19 @@ var init_strict_resolver = __esm({
           case "coalesce": {
             const left = this.resolveExpression(expression.left, scope);
             const leftOptional = { ...left.type, nullable: true };
+            const nullLeft = isNull(left.type);
             const right = this.resolveExpression(
               expression.right,
               scope,
-              leftOptional
+              nullLeft ? expected : leftOptional
             );
-            if (!isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
+            if (!nullLeft && !isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
               throw new CompileError(
                 `\`??\` right operand ${this.describe(right.type)} is not assignable to ${this.describe(leftOptional)}`,
                 expression.pos
               );
             }
-            const resultType = {
+            const resultType = nullLeft ? right.type : {
               ...left.type,
               nullable: isNullable(left.type) && isNullable(right.type)
             };
@@ -33892,20 +33870,25 @@ var init_strict_resolver = __esm({
         return whenTrue ? factsWhenTrue(expression, pathOf) : factsWhenFalse(expression, pathOf);
       }
       /**
-       * A loop body is resolved once but can execute repeatedly. Any narrowing rooted
-       * in an outer binding that the body or iterator may write is therefore stale
-       * at a later iteration entry. Invalidate those roots before resolving the
-       * shared iteration so only the loop's own condition can narrow them again.
+       * A loop body is resolved once but can execute repeatedly. Hide facts about
+       * paths it may replace before resolving the shared iteration; unrelated facts
+       * still hold, and the loop condition can narrow the written paths again.
        */
       invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, outerScope, statements, locals = /* @__PURE__ */ new Set()) {
-        for (const rootName of collectAssignedPathRoots(
+        for (const assignedPath of collectAssignedPaths(
           statements,
           /* @__PURE__ */ new Set(),
           locals
         )) {
-          const path = this.narrowingPath(rootName, outerScope);
+          const path = this.narrowingPath(assignedPath, outerScope);
           const outerEntry = path === null ? null : outerScope.lookup(pathRoot(path));
-          if (outerEntry) loopEntryScope.hideInheritedNarrowing(outerEntry);
+          if (outerEntry && path !== null) {
+            const retained = unaffectedNarrowings(path, outerEntry, loopEntryScope);
+            loopEntryScope.hideInheritedNarrowing(outerEntry);
+            for (const [retainedPath, type] of retained) {
+              loopEntryScope.narrow(retainedPath, outerEntry, type);
+            }
+          }
         }
       }
       applyFactsToScope(targetScope, facts, mode = "all") {
@@ -44074,7 +44057,7 @@ function validateExpression(expression, expected, scope, environment, uri, range
   if (expression.kind === "coalesce") {
     validateExpression(
       expression.left,
-      expected,
+      expected ? { ...expected, nullable: true } : void 0,
       scope,
       environment,
       uri,
@@ -44085,7 +44068,7 @@ function validateExpression(expression, expected, scope, environment, uri, range
     const left = inferExpressionType(expression.left, scope, environment);
     validateExpression(
       expression.right,
-      left ?? expected,
+      left && left.name !== "null" ? { ...left, nullable: true } : expected,
       scope,
       environment,
       uri,
@@ -44714,6 +44697,16 @@ function inferExpressionType(expression, scope, environment) {
     const operand = inferExpressionType(expression.operand, scope, environment);
     return operand ? { ...operand, nullable: false } : void 0;
   }
+  if (expression.kind === "coalesce") {
+    const left = inferExpressionType(expression.left, scope, environment);
+    const right = inferExpressionType(expression.right, scope, environment);
+    if (left?.name === "null") return right;
+    if (!left || !right) return void 0;
+    return {
+      ...left,
+      nullable: left.nullable === true && right.nullable === true
+    };
+  }
   if (expression.kind === "index") {
     const receiver = inferExpressionType(
       expression.receiver,
@@ -50982,7 +50975,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.72.2",
+      cliVersion: "0.72.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -125017,6 +125010,7 @@ function buildValueLowerContext(state, manifest, options = {}) {
     localizationConversionValueIds: registry.localizationConversionValueIds,
     loweredMemberIdByValueId: /* @__PURE__ */ new Map(),
     storedClassSchemaMemberIds: /* @__PURE__ */ new Map(),
+    renamedSchemaKeys: /* @__PURE__ */ new Map(),
     ordinaryMoveFields: /* @__PURE__ */ new Map(),
     pendingBindingMembersByClassId: registry.pendingBindingMembersByClassId,
     declaredConstructors: declaredConstructorIndex,
@@ -126285,7 +126279,11 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
       environment,
       binding.label
     );
-    const baseBody = backed.body;
+    const baseBody = retainedStoredClassBody(
+      context,
+      currentClassId,
+      backed.body
+    );
     const body = {};
     lowerConstructorProjections(
       context,
@@ -126685,12 +126683,43 @@ function pendingSeedGraphRows(args) {
 function retainedStoredClassBody(context, storedClassId, baseBody) {
   const storedMemberIds = storedClassSchemaMemberIds(context, storedClassId);
   const body = {};
+  const renames = renamedSchemaKeys(context, storedClassId);
   for (const [key, childId] of Object.entries(baseBody)) {
     if (storedMemberRemoved(context, storedMemberIds, key)) continue;
-    body[key] = childId;
+    body[renames.get(key) ?? key] = childId;
   }
   return body;
 }
+function renamedSchemaKeys(context, classId) {
+  const cached = context.renamedSchemaKeys.get(classId);
+  if (cached !== void 0) return cached;
+  const currentMembers = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of classInheritanceChain(context.classes, classId)) {
+    for (const [key, memberId] of Object.entries(schemaClass2.schema)) {
+      if (!currentMembers.has(key)) currentMembers.set(key, memberId);
+    }
+  }
+  const renamed = schemaKeyRenamesByMemberId(
+    storedClassSchemaMemberIds(context, classId),
+    currentMembers
+  );
+  context.renamedSchemaKeys.set(classId, renamed);
+  return renamed;
+}
+function schemaKeyRenamesByMemberId(before, after) {
+  const currentKeys = /* @__PURE__ */ new Map();
+  for (const [key, memberId] of after) {
+    if (memberId !== null && !currentKeys.has(memberId))
+      currentKeys.set(memberId, key);
+  }
+  const renamed = /* @__PURE__ */ new Map();
+  for (const [key, memberId] of before) {
+    const currentKey = memberId === null ? void 0 : currentKeys.get(memberId);
+    if (currentKey !== void 0 && currentKey !== key)
+      renamed.set(key, currentKey);
+  }
+  return renamed;
+}
 function storedMemberRemoved(context, storedMemberIds, key) {
   const storedMemberId = storedMemberIds.get(key);
   return storedMemberId !== void 0 && !context.members.has(storedMemberId);
@@ -127932,7 +127961,7 @@ function lowerValueBody(context, member, expression, base, source, environment,
       );
   }
 }
-function authoredResetSchemaKeys(context, base, baseBody, expression, partial) {
+function authoredResetSchemaKeys(context, base, baseBody, expression, partial, classId) {
   if (partial) return /* @__PURE__ */ new Set();
   if (expression.kind !== "new") return /* @__PURE__ */ new Set();
   if (typeof base.id !== "string") return /* @__PURE__ */ new Set();
@@ -127940,15 +127969,17 @@ function authoredResetSchemaKeys(context, base, baseBody, expression, partial) {
     (expression.initializer ?? []).map((assignment) => assignment.name)
   );
   const expressions = context.materializedConstructorExpressions;
+  const renames = renamedSchemaKeys(context, classId);
   if (Object.keys(baseBody).every(
-    (key) => authored.has(key) || expressions.declaresSchemaKey?.(key) === false
+    (key) => authored.has(renames.get(key) ?? key) || expressions.declaresSchemaKey?.(key) === false
   )) {
     return /* @__PURE__ */ new Set();
   }
   const canonicalOverrideKeys = expressions.overrideSchemaKeys?.(base.id);
   if (canonicalOverrideKeys === void 0) return /* @__PURE__ */ new Set();
   const resets = /* @__PURE__ */ new Set();
-  for (const schemaKey of canonicalOverrideKeys) {
+  for (const storedKey of canonicalOverrideKeys) {
+    const schemaKey = renames.get(storedKey) ?? storedKey;
     if (!authored.has(schemaKey)) resets.add(schemaKey);
   }
   return resets;
@@ -128005,7 +128036,7 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
       schemaClass2,
       expression,
       base,
-      baseBody,
+      body,
       body,
       source,
       environment,
@@ -128075,7 +128106,8 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
     base,
     baseBody,
     expression,
-    partial
+    partial,
+    currentClassId
   );
   for (const schemaKey of resetSchemaKeys) delete body[schemaKey];
   {
@@ -128083,10 +128115,12 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
       (expression.initializer ?? []).map((assignment) => assignment.name)
     );
     const storedMemberIds = storedClassSchemaMemberIds(context, currentClassId);
-    for (const [schemaKey, childId] of Object.entries(baseBody)) {
+    const renames = renamedSchemaKeys(context, currentClassId);
+    for (const [storedKey, childId] of Object.entries(baseBody)) {
+      const schemaKey = renames.get(storedKey) ?? storedKey;
       if (typeof childId !== "string") continue;
       if (resetSchemaKeys.has(schemaKey)) continue;
-      if (storedMemberRemoved(context, storedMemberIds, schemaKey)) continue;
+      if (storedMemberRemoved(context, storedMemberIds, storedKey)) continue;
       if (materializedConstruction === "lower" && authoredKeys.has(schemaKey)) {
         continue;
       }
@@ -128095,7 +128129,7 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
         childId,
         source.source,
         /* @__PURE__ */ new Set(),
-        memberById(context, storedMemberIds.get(schemaKey)),
+        memberById(context, storedMemberIds.get(storedKey)),
         environment
       );
     }
@@ -128195,14 +128229,18 @@ function retainStoredValueSubgraph(context, valueId, source, visited, member, en
   visited.add(valueId);
   const state = context.state[`value:${valueId}`];
   if (state === void 0 || !isObjectRecord2(state.data)) return;
-  addReconstructed(
-    context,
-    "value",
-    valueId,
-    valueFileFields(state.data),
-    source,
-    { retained: true }
-  );
+  const storedClassId = stringOrNull2(state.data.classId);
+  const fields = valueFileFields(state.data);
+  if (storedClassId !== null && isObjectRecord2(state.data.value) && renamedSchemaKeys(context, storedClassId).size > 0) {
+    fields.value = retainedStoredClassBody(
+      context,
+      storedClassId,
+      state.data.value
+    );
+  }
+  addReconstructed(context, "value", valueId, fields, source, {
+    retained: true
+  });
   const rawOwningMember = member ?? storedRowPlacementMember(context, valueId);
   const owningMember = rawOwningMember === null ? null : resolveGenericSchemaMember(context, rawOwningMember, environment);
   if (owningMember?.kind === "string" && owningMember.localizable) {
@@ -128250,7 +128288,6 @@ function retainStoredValueSubgraph(context, valueId, source, visited, member, en
     for (const entry of Object.values(value)) collect(entry, childMember);
   };
   const body = state.data.value;
-  const storedClassId = stringOrNull2(state.data.classId);
   let childEnvironment = environment;
   if (storedClassId !== null) {
     if (owningMember?.kind === "class") {
@@ -128395,13 +128432,14 @@ function classProjectsEveryStoredConstructorRow(context, classId, argumentCount,
   if (projections2.length === 0 || projections2.length !== argumentCount) {
     return false;
   }
+  const body = renamedSchemaKeys(context, classId).size === 0 ? storedBody : retainedStoredClassBody(context, classId, storedBody);
   return projections2.every((projection) => {
     const schemaKey = inheritedProjectionSchemaKey(
       context.classes,
       classId,
       projection.memberId
     );
-    return schemaKey !== null && typeof storedBody[schemaKey] === "string";
+    return schemaKey !== null && typeof body[schemaKey] === "string";
   });
 }
 function requiredConstructorProjectionMap(classes, constructors, members, classId, visited) {
@@ -138693,7 +138731,7 @@ function materializedInitializerReconciliationFailuresV4(args) {
       continue;
     }
     assertPulledConstructorsCompiled(replayDocument, replayContext);
-    currentRows ??= new Map(currentDocument.values.map((row) => [row.id, row]));
+    currentRows ??= storedRowsWithRenamedKeys(currentDocument, replayDocument);
     currentReader ??= new EffectiveValueReader(replayDocument, currentRows);
     const replay = replayRows.get(reconciliation.valueId);
     const replayArgs = replay !== void 0 && isLiteralValueContent(replay) ? replay.constructorArgs : void 0;
@@ -138725,6 +138763,41 @@ function materializedInitializerReconciliationFailuresV4(args) {
   }
   return failures;
 }
+function storedRowsWithRenamedKeys(before, after) {
+  const renamesByClass = /* @__PURE__ */ new Map();
+  const rows = /* @__PURE__ */ new Map();
+  for (const row of before.values) {
+    let renamed = row;
+    if (typeof row.classId === "string" && isObjectRecord2(row.value)) {
+      const classId = row.classId;
+      let renames = renamesByClass.get(classId);
+      if (renames === void 0) {
+        const entries = (document) => mergeInstanceSurfaceSchema(
+          classId,
+          document.classes,
+          document.members
+        ).map((entry) => [entry.schemaKey, entry.memberId]);
+        renames = schemaKeyRenamesByMemberId(entries(before), entries(after));
+        renamesByClass.set(row.classId, renames);
+      }
+      if (renames.size > 0) {
+        const value = {};
+        let collision = false;
+        for (const [key, child2] of Object.entries(row.value)) {
+          const target = renames.get(key) ?? key;
+          if (target !== key && Object.hasOwn(row.value, target) && !renames.has(target)) {
+            collision = true;
+            break;
+          }
+          value[target] = child2;
+        }
+        if (!collision) renamed = { ...row, value };
+      }
+    }
+    rows.set(row.id, renamed);
+  }
+  return rows;
+}
 function withoutSharedArguments(stored, replayed) {
   const storedRest = { ...stored };
   const replayedRest = { ...replayed };
@@ -139108,6 +139181,7 @@ var init_local_initializer_materialization = __esm({
     init_variant_value_graph();
     init_members();
     init_member_value_id();
+    init_inheritance();
     init_effective_value_reader();
     init_virtual_instance_values();
     init_value_graph();
@@ -140319,33 +140393,35 @@ function computeWorkspaceStatus(workspace, options) {
       )
     );
   }
-  try {
-    parseErrors.push(
-      ...materializedInitializerReconciliationFailuresV4({
-        workspace,
-        changes,
-        authoredValueSeeds,
-        reconciliations: valueLowerRegistry.initializerReconciliations,
-        canonicalConstructions: valueLowerRegistry.materializedConstructorExpressions,
-        localizedTextDependencies,
-        manifest,
-        analysis: projectAnalysisV4,
-        forceRecompile: options.forceRecompile,
-        useBuildCaches: options.useBuildCaches,
-        sourceTextByUri: new Map(
-          sourceEntries.map((entry) => [entry.relPath, entry.source])
+  if (!parseErrors.some(isBlockingSchemaSourceError)) {
+    try {
+      parseErrors.push(
+        ...materializedInitializerReconciliationFailuresV4({
+          workspace,
+          changes,
+          authoredValueSeeds,
+          reconciliations: valueLowerRegistry.initializerReconciliations,
+          canonicalConstructions: valueLowerRegistry.materializedConstructorExpressions,
+          localizedTextDependencies,
+          manifest,
+          analysis: projectAnalysisV4,
+          forceRecompile: options.forceRecompile,
+          useBuildCaches: options.useBuildCaches,
+          sourceTextByUri: new Map(
+            sourceEntries.map((entry) => [entry.relPath, entry.source])
+          )
+        })
+      );
+    } catch (error) {
+      parseErrors.push(
+        error instanceof SchemaSourceError ? error : new SchemaSourceError(
+          error instanceof Error ? error.message : String(error),
+          "<initializer-materialization>",
+          1,
+          1
         )
-      })
-    );
-  } catch (error) {
-    parseErrors.push(
-      error instanceof SchemaSourceError ? error : new SchemaSourceError(
-        error instanceof Error ? error.message : String(error),
-        "<initializer-materialization>",
-        1,
-        1
-      )
-    );
+      );
+    }
   }
   reportPhase("initializer-reconciliation", "Checking project files\u2026");
   for (const fileId of options.trustedPendingProjectFiles?.keys() ?? []) {
@@ -140410,7 +140486,7 @@ function computeWorkspaceStatus(workspace, options) {
   )) {
     parseErrors.push(new SchemaSourceError(message, "<project-files>", 1, 1));
   }
-  if (animationValidationInputsChanged(changes, authoredValueSeeds)) {
+  if (!parseErrors.some(isBlockingSchemaSourceError) && animationValidationInputsChanged(changes, authoredValueSeeds)) {
     try {
       const animationRecords = prospectiveAnimationRecords(
         workspace.state.records,
@@ -190443,7 +190519,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.72.2");
+    console.log("0.72.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {