@neocompose/cli 0.72.1 → 0.72.4

package/dist/neo.mjs

@@ -20567,11 +20567,12 @@ var init_local_values = __esm({
     init_formatter();
     init_workspace_source_path();
     init_executable_parser();
+    init_source_text();
     init_language_spec();
     init_lower_support();
     LocalValueBindingsV4 = class {
       definitions = /* @__PURE__ */ new Map();
-      expressions = /* @__PURE__ */ new Map();
+      initializers = /* @__PURE__ */ new Map();
       owners = /* @__PURE__ */ new Map();
       /** Static members whose initializer is a bare local name, by that name. */
       ownerMembers = /* @__PURE__ */ new Map();
@@ -20608,7 +20609,7 @@ var init_local_values = __esm({
             owners.set(valueId, source.label);
             this.owners.set(global.name, owners);
           }
-          text = global.initializer;
+          text = step.text;
           expression = step.expression;
           source = {
             ...source,
@@ -20627,7 +20628,28 @@ var init_local_values = __esm({
         let last = null;
         for (const step of this.chain(name)) last = step;
         if (last === null) return null;
-        return { expression: last.expression, text: last.global.initializer };
+        return { expression: last.expression, text: last.text };
+      }
+      initializer(global) {
+        const cached = this.initializers.get(global.name);
+        if (cached) return cached;
+        let text = global.initializer;
+        let expression = parseExpression(text);
+        let construction = expression;
+        while (construction.kind === "annotated")
+          construction = construction.expression;
+        if (construction.kind === "new" && construction.className === null) {
+          const offset = new SourceText(text).offsetAt({
+            line: construction.pos.line - 1,
+            character: construction.pos.column - 1
+          }) + 3;
+          const type = typeText({ ...global.type, nullable: false });
+          text = `${text.slice(0, offset)} ${type}${text.slice(offset)}`;
+          expression = parseExpression(text);
+        }
+        const prepared = { global, expression, text };
+        this.initializers.set(global.name, prepared);
+        return prepared;
       }
       /** Each local an alias chain starting at `name` passes through, in order. */
       *chain(name) {
@@ -20637,9 +20659,9 @@ var init_local_values = __esm({
           if (visited.has(global.name))
             throw new Error(`Local initializer cycle reaches ${global.name}.`);
           visited.add(global.name);
-          const expression = this.expressions.get(global.name) ?? parseExpression(global.initializer);
-          this.expressions.set(global.name, expression);
-          yield { global, expression };
+          const prepared = this.initializer(global);
+          const { expression } = prepared;
+          yield prepared;
           global = expression.kind === "ident" ? this.definitions.get(expression.name) : void 0;
         }
       }
@@ -20685,7 +20707,7 @@ var init_local_values = __esm({
         const placements = [];
         for (const [name, definition2] of this.definitions) {
           const valueIds = this.owners.get(name)?.keys().toArray() ?? [];
-          const expression = this.expressions.get(name) ?? parseExpression(definition2.initializer);
+          const expression = this.initializers.get(name)?.expression ?? parseExpression(definition2.initializer);
           placements.push({
             name,
             type: typeText(definition2.type),
@@ -28282,6 +28304,20 @@ var init_collection_query = __esm({
 function neoScriptArgumentNameSetKey(names) {
   return [...names].map((name) => name.toLowerCase()).sort().join(",");
 }
+function neoScriptParameterByName(parameters, name) {
+  let indexes3 = parameterNameIndexes.get(parameters);
+  if (!indexes3) {
+    const built = /* @__PURE__ */ new Map();
+    for (let index2 = 0; index2 < parameters.length; index2++) {
+      const key = parameters[index2].name.toLowerCase();
+      if (!built.has(key)) built.set(key, index2);
+    }
+    indexes3 = built;
+    parameterNameIndexes.set(parameters, indexes3);
+  }
+  const index = indexes3.get(name.toLowerCase());
+  return index === void 0 ? void 0 : parameters[index];
+}
 function neoScriptCallMatchesParameters(suppliedNames, parameters) {
   const supplied = new Set(suppliedNames.map((name) => name.toLowerCase()));
   const declared = new Set(
@@ -28542,10 +28578,12 @@ function describeParameter(parameter4) {
   const defaulted = parameter4.defaultValue === void 0 ? "" : ` = ${parameter4.defaultValue.displayText}`;
   return `${parameter4.name}${nullability}${defaulted}`;
 }
+var parameterNameIndexes;
 var init_declared_constructors = __esm({
   "../packages/neoscript-language/src/declared-constructors.ts"() {
     "use strict";
     init_project2();
+    parameterNameIndexes = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -28879,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;
 }
@@ -29208,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,
@@ -29232,7 +29276,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "varDecl") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.init,
         roots,
         locals,
@@ -29246,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,
@@ -29256,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),
@@ -29268,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 {
@@ -29285,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,
@@ -29306,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,
@@ -29321,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,
@@ -29339,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,
@@ -29362,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,
@@ -29375,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,
@@ -29383,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,
@@ -29398,7 +29432,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "exprStmt") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.expr,
         roots,
         locals,
@@ -29408,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,
@@ -29452,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,
@@ -29466,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,
@@ -29502,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,
@@ -29519,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,
@@ -29533,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,
@@ -29554,7 +29558,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       return;
     case "unary":
     case "force":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -29562,7 +29566,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "is":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -29570,7 +29574,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "lambda":
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         expression.body,
         roots,
         /* @__PURE__ */ new Set([
@@ -30564,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;
       }
@@ -30597,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);
@@ -31154,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),
@@ -31185,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);
@@ -31426,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
@@ -32298,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)) {
@@ -32521,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);
             }
           }
@@ -33142,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)
             };
@@ -33854,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") {
@@ -35304,6 +35325,7 @@ var init_strict_resolver = __esm({
             (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
           );
           if (member) {
+            this.validateFunctionReceiver(receiver, callee.name, optional2, pos);
             if (type !== void 0) this.assertMemberAccessible(type, member, pos);
             if (member.static === true) {
               throw new CompileError(
@@ -36452,12 +36474,10 @@ var init_strict_resolver = __esm({
       callableSignatureForReceiver(symbol, receiver) {
         let parameters = symbol.parameters ?? [];
         let returnType = symbol.returnType ?? symbol.type;
-        if (this.context.projectSourceKind !== "spec" && !(receiver?.kind === "instance" && receiver.dispatch === "base")) {
-          return { parameters, returnType };
-        }
         if (receiver?.kind !== "instance") return { parameters, returnType };
         const receiverType = receiver.expression.type;
         if (receiverType.kind !== "named") return { parameters, returnType };
+        if (!receiverType.typeArguments?.length) return { parameters, returnType };
         const declaring = this.project.typeById.get(receiverType.typeId);
         if (declaring === void 0) return { parameters, returnType };
         parameters = parameters.map((parameter4) => ({
@@ -37361,6 +37381,21 @@ var init_strict_resolver = __esm({
           callSiteId: this.nextCallSite(expression.pos)
         };
       }
+      validateFunctionReceiver(receiver, name, optional2, pos) {
+        if (optional2 && !isNullable(receiver.type)) {
+          throw new CompileError(
+            `\`?.\` requires an optional receiver; got ${this.describe(receiver.type)}`,
+            pos
+          );
+        }
+        const receiverType = receiver.optionalChainType ?? receiver.type;
+        if (!optional2 && isNullable(receiverType)) {
+          throw new CompileError(
+            `Function '${name}' is called on ${this.describe(receiverType)}, which may be null. Use optional chaining, force-unwrapping, or a null check before calling it.`,
+            pos
+          );
+        }
+      }
       resolveFunctionStatement(expression, scope) {
         if (expression.kind !== "call") return null;
         const receiverValue = this.callReceiver(expression.callee, scope);
@@ -37524,12 +37559,19 @@ var init_strict_resolver = __esm({
           }
         }
         const receiver = receiverValue();
-        if (receiver.type.kind !== "named") return null;
-        const type = this.project.typeById.get(receiver.type.typeId);
+        const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+        if (memberReceiverType.kind !== "named") return null;
+        const type = this.project.typeById.get(memberReceiverType.typeId);
         const symbol = type?.members.find(
           (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === memberName
         );
         if (!symbol) return null;
+        this.validateFunctionReceiver(
+          receiver,
+          memberName,
+          expression.callee.optional === true,
+          expression.pos
+        );
         if (type !== void 0) {
           this.assertMemberAccessible(type, symbol, expression.pos);
         }
@@ -37542,7 +37584,10 @@ var init_strict_resolver = __esm({
         this.validateCallableInContext(symbol, expression.pos);
         const resolved = this.resolveCallableArguments(
           symbol,
-          { kind: "instance", expression: receiver },
+          {
+            kind: "instance",
+            expression: memberReceiverType === receiver.type ? receiver : { ...receiver, type: memberReceiverType }
+          },
           expression.args,
           scope,
           expression.pos
@@ -42576,6 +42621,7 @@ function createEnvironment(documents, project) {
     project,
     projectIndex: createProjectIndex(project),
     listenerResolvers: /* @__PURE__ */ new Map(),
+    assignability: /* @__PURE__ */ new Map(),
     enums,
     types,
     globals,
@@ -43854,13 +43900,19 @@ function validateExpression(expression, expected, scope, environment, uri, range
     );
     return;
   }
-  if (expected && expression.kind !== "contextualEnum" && !isReferenceCall(expression)) {
+  if (expected && expression.kind !== "contextualEnum" && expression.kind !== "annotated" && !isReferenceCall(expression)) {
     const actual = inferExpressionType(expression, scope, environment);
-    if (actual && !semanticTypesAssignable(actual, expected)) {
+    const explicitConstruction = expression.kind === "new" && expression.className !== null && expected.name !== "Partial";
+    const assignable = actual === void 0 || (explicitConstruction ? constructionTypesAssignable(actual, expected, scope, environment) : semanticTypesAssignable(actual, expected));
+    if (actual && !assignable) {
       pushDiagnostic(
         diagnostics,
         uri,
-        anchor ? anchorSpan(anchor, expression.pos, 1) : range2,
+        anchor ? anchorSpan(
+          anchor,
+          expression.pos,
+          expression.kind === "new" ? 3 : 1
+        ) : range2,
         "project-expression-type-mismatch",
         `Expected ${describeType(expected)} but received ${describeType(actual)}.`
       );
@@ -44005,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,
@@ -44016,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,
@@ -44134,23 +44186,26 @@ function validateExpression(expression, expected, scope, environment, uri, range
         }))
       );
     }
-    const fields = declaration?.members.filter(
-      (member) => member.kind === "field" && !member.modifiers.includes("static")
-    ) ?? [];
-    const overload = declaration && declaration.constructors.length > 0 ? matchingDeclaredConstructor(declaration, expression.argumentNames) : null;
+    const parameters = declaration.headerParameters ?? matchingDeclaredConstructor(declaration, siteArgumentNames)?.parameters;
+    const fields = [];
+    const fieldsByName = /* @__PURE__ */ new Map();
+    if (declaration.headerParameters === void 0 && declaration.constructors.length === 0) {
+      for (const member of declaration.members) {
+        if (member.kind !== "field" || member.modifiers.includes("static"))
+          continue;
+        fields.push(member);
+        fieldsByName.set(member.name, member);
+      }
+    }
     expression.args.forEach((argument2, index) => {
       const authoredName = expression.argumentNames?.[index];
       const named = declaration.name === NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME ? authoredName ?? NEO_LOOKUP_VARIANT_FOLDER_CONSTRUCTOR_ARGUMENTS[index]?.name : authoredName;
       if (declaration.name === NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME && named === "collection") {
         return;
       }
-      const parameter4 = named ? (declaration.headerParameters ?? []).find(
-        (candidate) => candidate.name === named
-      ) ?? overload?.parameters.find((candidate) => candidate.name === named) : void 0;
+      const parameter4 = named && parameters ? neoScriptParameterByName(parameters, named) : parameters?.[index];
       const variantMember = named === void 0 || named === null ? void 0 : variantSite === null ? void 0 : NEO_VARIANT_MEMBER_ARGUMENTS.get(named);
-      const field = named ? fields.find(
-        (candidate) => candidate.name === (variantMember ?? named)
-      ) : fields[index];
+      const field = named ? fieldsByName.get(variantMember ?? named) : fields[index];
       const expectedType = parameter4?.type ?? field?.type;
       const expectedSemanticType = declaration.name === NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME && named === "collectionValue" ? { name: "string" } : expectedType ? substituteSemanticType(semanticType(expectedType), siteBindings) : void 0;
       validateExpression(
@@ -44450,6 +44505,41 @@ function commonSemanticAssignableType(left, right) {
   if (semanticTypesAssignable(right, left)) return left;
   return void 0;
 }
+function constructionTypesAssignable(actual, expected, scope, environment) {
+  if (actual.name === expected.name && !actual.arguments?.length && !expected.arguments?.length)
+    return true;
+  const owner = scope.get("this")?.name ?? "";
+  const key = `${owner}:${describeType(actual)}>${describeType(expected)}`;
+  const cached = environment.assignability.get(key);
+  if (cached !== void 0) return cached;
+  const declaration = environment.projectIndex.typeByName.get(owner);
+  const context = {
+    project: environment.project,
+    kind: "initializerExpression",
+    ...declaration ? { declaringType: { kind: "named", typeId: declaration.id } } : {}
+  };
+  const pos = { line: 1, column: 1 };
+  let assignable = true;
+  try {
+    assignable = isNeoScriptTypeAssignable(
+      resolveNeoScriptType(
+        semanticAst(actual, pos),
+        context,
+        environment.projectIndex
+      ),
+      resolveNeoScriptType(
+        semanticAst(expected, pos),
+        context,
+        environment.projectIndex
+      ),
+      environment.projectIndex
+    );
+  } catch (error) {
+    if (!(error instanceof CompileError)) throw error;
+  }
+  environment.assignability.set(key, assignable);
+  return assignable;
+}
 function semanticNumericRank(name) {
   if (name === "int") return 0;
   if (name === "float") return 1;
@@ -44599,11 +44689,24 @@ function inferExpressionType(expression, scope, environment) {
   if (expression.kind === "litString" || expression.kind === "litInterp" || expression.kind === "litTripleString")
     return primitiveType("string");
   if (expression.kind === "new")
-    return expression.className ? { name: expression.className } : void 0;
+    return expression.className ? {
+      name: expression.className,
+      ...expression.typeArguments ? { arguments: expression.typeArguments.map(semanticAstType) } : {}
+    } : void 0;
   if (expression.kind === "force") {
     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,
@@ -44874,14 +44977,19 @@ function classExtends(actual, expected, environment, visited) {
   );
 }
 function matchingDeclaredConstructor(declaration, argumentNames) {
-  const names = (argumentNames ?? []).filter(
-    (name) => name !== null
-  );
-  const key = [...names].map((name) => name.toLowerCase()).sort().join(",");
-  const matches = declaration.constructors.filter(
-    (constructor2) => constructor2.parameters.map((parameter4) => parameter4.name.toLowerCase()).sort().join(",") === key
+  if (declaration.constructors.length === 1)
+    return declaration.constructors[0] ?? null;
+  if (argumentNames.some((name) => name === null)) return null;
+  const names = argumentNames.filter((name) => name !== null);
+  const resolution = resolveNeoScriptNamedOverload(
+    declaration.constructors,
+    names,
+    (constructor2) => constructor2.parameters.map((parameter4) => ({
+      name: parameter4.name,
+      defaulted: parameter4.defaultValue !== void 0
+    }))
   );
-  return matches.length === 1 ? matches[0] ?? null : null;
+  return resolution.kind === "resolved" ? resolution.overload : null;
 }
 function semanticType(type) {
   return {
@@ -45230,6 +45338,7 @@ var init_project_source_semantics = __esm({
     init_strict_compile_error();
     init_executable_parser();
     init_project_source_construction_diagnostics();
+    init_declared_constructors();
     init_project_source_variants();
     init_language_spec();
     init_project_source_settlement();
@@ -50866,7 +50975,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.72.1",
+      cliVersion: "0.72.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -110681,7 +110790,8 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
       continue;
     const key = `${change.recordKind}:${change.recordId}`;
     const base = baseScriptRecords.get(key);
-    if (base && canonicallyEqual2(
+    if (base && // Rollout-tolerated bodies still need recompilation before reuse.
+    firstRejectedNeoScriptCompiledBody(base, null) === null && !hasPendingNeoScriptDerivation(change.recordKind, base) && canonicallyEqual2(
       authoredScriptRecord(change.recordKind, base),
       authoredScriptRecord(change.recordKind, change.nextData)
     ))
@@ -110733,12 +110843,14 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
         if (kind === "member")
           remappedMembers.set(record7.id, {
             ...moved,
-            ...stripClientDerivedBodies("member", record7)
+            createdAt: record7.createdAt,
+            updatedAt: record7.updatedAt
           });
         else
           remappedConstructors.set(record7.id, {
             ...moved,
-            ...stripConstructorDerivedBodies(record7)
+            createdAt: record7.createdAt,
+            updatedAt: record7.updatedAt
           });
       }
     }
@@ -114517,6 +114629,7 @@ var init_project_version_schema_commit = __esm({
   "../src/database/project-version-schema-commit.ts"() {
     "use strict";
     init_dialogue_logic_compile_pure();
+    init_neoscript_compiler_revision();
     init_neoscript_source_catalog();
     init_prepared_collection_bindings();
     init_stored_closure_captures();
@@ -124897,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,
@@ -126165,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,
@@ -126565,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);
@@ -127812,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();
@@ -127820,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;
@@ -127885,7 +128036,7 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
       schemaClass2,
       expression,
       base,
-      baseBody,
+      body,
       body,
       source,
       environment,
@@ -127955,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];
   {
@@ -127963,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;
       }
@@ -127975,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
       );
     }
@@ -128075,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) {
@@ -128130,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") {
@@ -128275,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) {
@@ -138573,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;
@@ -138605,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 };
@@ -138988,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();
@@ -140199,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() ?? []) {
@@ -140290,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,
@@ -148410,6 +148606,14 @@ function projectCompletions(analysis, document, position) {
       }))
     };
   }
+  const contextualEnum = projectContextualEnumCompletions(
+    analysis,
+    document,
+    position
+  );
+  if (contextualEnum) {
+    return { isIncomplete: false, items: contextualEnum };
+  }
   const constructorFields = projectConstructorArgumentCompletions(
     analysis,
     document,
@@ -148436,14 +148640,6 @@ function projectCompletions(analysis, document, position) {
   if (initializerMembers) {
     return { isIncomplete: false, items: initializerMembers };
   }
-  const contextualEnum = projectContextualEnumCompletions(
-    analysis,
-    document,
-    position
-  );
-  if (contextualEnum) {
-    return { isIncomplete: false, items: contextualEnum };
-  }
   return projectFallbackCompletions(analysis, document, position);
 }
 function projectListenerContext(analysis, document, position) {
@@ -149775,11 +149971,19 @@ function projectCallArguments(tokens, openIndex, delimiterEnds) {
       result.push({
         start: token.range.start,
         named: token.kind === "identifier" && tokens[index + 1]?.text === ":",
+        name: token.kind === "identifier" && tokens[index + 1]?.text === ":" ? token.text : null,
         ...token.kind === "identifier" && (tokens[index + 1]?.text === "," || tokens[index + 1]?.text === ")") ? { identifier: token.text } : {}
       });
       atArgumentStart = false;
     }
-    if (token.text === "(" || token.text === "[" || token.text === "{") {
+    if (token.text === "new" && tokens[index + 2]?.text === "<") {
+      let depth = 0;
+      index += 2;
+      for (; index < tokens.length; index++) {
+        if (tokens[index].text === "<") depth++;
+        else if (tokens[index].text === ">" && --depth === 0) break;
+      }
+    } else if (token.text === "(" || token.text === "[" || token.text === "{") {
       index = delimiterEnds.get(index) ?? tokens.length;
     }
   }
@@ -150387,6 +150591,7 @@ function indexConstructionSites(analysis, document, root) {
   while (end < allTokens.length && positionCompare(allTokens[end].range.start, root.range.end) <= 0)
     end++;
   const tokens = allTokens.slice(start, end).filter((token) => token.kind !== "comment" && token.kind !== "eof");
+  let delimiterEnds;
   const language = listenerSourceContext(analysis, document, root.range.start);
   const resolveSourceType = (type) => {
     if (!type) return null;
@@ -150427,15 +150632,17 @@ function indexConstructionSites(analysis, document, root) {
         const declaration = language.project.typeById.get(frame.typeRef.typeId);
         if (!declaration) return null;
         const constructors = declaration.declaredConstructors;
-        const parameters = constructors?.length === 1 ? constructors[0]?.parameters : declaration.constructorSignature?.parameters;
-        const parameter4 = frame.argumentName ? parameters?.find(
-          (candidate) => candidate.name === frame.argumentName
-        ) : parameters?.[frame.argumentIndex];
-        frame.expectedTypeRef = parameter4 ? substituteTypeParameters(
-          "type" in parameter4 ? parameter4.type : parameter4.valueType,
-          frame.typeRef,
-          declaration
-        ) : fieldType(frame.typeRef, frame.argumentName);
+        const parameters = constructors?.length ? constructors[frame.constructorIndex]?.parameters : declaration.constructorSignature?.parameters;
+        const parameter4 = frame.argumentName ? parameters && neoScriptParameterByName(parameters, frame.argumentName) : parameters?.[frame.argumentIndex];
+        if (parameter4) {
+          frame.expectedTypeRef = substituteTypeParameters(
+            "type" in parameter4 ? parameter4.type : parameter4.valueType,
+            frame.typeRef,
+            declaration
+          );
+        } else if (!constructors?.length) {
+          frame.expectedTypeRef = fieldType(frame.typeRef, frame.argumentName);
+        }
         return frame.expectedTypeRef;
       }
     }
@@ -150458,14 +150665,16 @@ function indexConstructionSites(analysis, document, root) {
   const objects = [];
   const snapshot = () => {
     const expected = expectedType();
+    const resolvedExpected = expectedTypeRef();
+    const expectedTypeName = resolvedExpected?.kind === "named" ? language.project.typeById.get(resolvedExpected.typeId)?.name ?? expected?.name : expected?.name;
     const innermost = stack.at(-1);
     const directly = innermost?.kind === "object" ? innermost : null;
     const keys = directly?.keys ?? [];
     const keyCount = keys.length;
     return {
       expectedType: expected,
-      expectedTypeRef: expectedTypeRef(),
-      expectedTypeName: expected?.name ?? null,
+      expectedTypeRef: resolvedExpected,
+      expectedTypeName: expectedTypeName ?? null,
       enclosingTypeName: objects.at(-1)?.typeName ?? null,
       initializerTypeName: directly?.typeName ?? null,
       get initializerKeys() {
@@ -150581,8 +150790,20 @@ function indexConstructionSites(analysis, document, root) {
     }
     if (token.text === "(") {
       if (sawNew) {
+        const declaration = pendingNewTypeName ? findTypeDeclaration(analysis, pendingNewTypeName) : null;
+        let constructorIndex = 0;
+        if (declaration?.kind === "class" && declaration.constructors.length > 1) {
+          const names = projectCallArguments(
+            tokens,
+            index,
+            delimiterEnds ??= projectDelimiterEnds(tokens)
+          ).map((argument2) => argument2.name);
+          const constructor2 = matchingDeclaredConstructor(declaration, names);
+          constructorIndex = constructor2 ? declaration.constructors.indexOf(constructor2) : -1;
+        }
         stack.push({
           kind: "call",
+          constructorIndex,
           typeName: pendingNewTypeName,
           typeRef: pendingNewTypeRef,
           argumentIndex: 0,
@@ -150669,6 +150890,14 @@ function constructorArgumentType(analysis, frame) {
   if (!declaration || declaration.kind === "global" || declaration.kind === "enum") {
     return null;
   }
+  if (declaration.kind === "class") {
+    const parameters = declaration.headerParameters ?? declaration.constructors[frame.constructorIndex]?.parameters;
+    if (parameters) {
+      const parameter4 = frame.argumentName === null ? parameters[frame.argumentIndex] : neoScriptParameterByName(parameters, frame.argumentName);
+      return parameter4?.type ?? null;
+    }
+    if (declaration.constructors.length > 0) return null;
+  }
   const fields = declarationFields(declaration);
   if (frame.argumentName !== null) {
     return fields.assignableByName.get(frame.argumentName)?.type ?? null;
@@ -150925,6 +151154,7 @@ var init_project_source_language_features = __esm({
     init_project_listener_annotations();
     init_strict_resolver();
     init_type_substitution();
+    init_declared_constructors();
     init_executable_parser();
     init_strict_compile_error();
     init_analyzer();
@@ -190289,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.1");
+    console.log("0.72.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {