@neocompose/cli 0.72.1 → 0.72.4

package/dist/test-worker.mjs

@@ -33780,14 +33780,17 @@ var Scope = class {
     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;
   }
@@ -33813,6 +33816,9 @@ var Scope = class {
   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);
@@ -34370,24 +34376,26 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         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 child = new Scope(scope);
           const branchFacts = [
             ...cumulativeFalseFacts,
-            ...this.conditionFacts(branch.cond, scope, true)
+            ...this.conditionFacts(branch.cond, conditionScope, true)
           ];
           this.applyFactsToScope(child, branchFacts);
           const instructions = this.resolveStatements(branch.body, child);
           if (!instructionsTerminate(instructions)) {
             branchExitFacts.push(branchFacts);
-            branchExitNarrowings.push(new Map(child.narrowedPaths));
+            branchExitNarrowings.push(child.effectiveNarrowedPaths());
             branchExitOwnershipScopes.push(child);
           }
           cumulativeFalseFacts.push(
-            ...this.conditionFacts(branch.cond, scope, false)
+            ...this.conditionFacts(branch.cond, conditionScope, false)
           );
           return {
             expression: pointerToBooleanExpression(condition.pointer),
@@ -34401,14 +34409,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           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);
@@ -34642,12 +34650,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           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
@@ -35514,13 +35525,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     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)) {
@@ -35737,13 +35748,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     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);
         }
       }
@@ -36358,18 +36369,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       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)
         };
@@ -37070,20 +37082,25 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     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") {
@@ -38520,6 +38537,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         (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(
@@ -39668,12 +39686,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   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((parameter3) => ({
@@ -40577,6 +40593,21 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       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);
@@ -40740,12 +40771,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
     }
     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);
     }
@@ -40758,7 +40796,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     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
@@ -41479,12 +41520,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;
 }
@@ -41808,22 +41855,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,
@@ -41832,7 +41879,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "varDecl") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.init,
         roots,
         locals,
@@ -41846,7 +41893,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       const falseFacts = [];
       const fallthroughFacts = [];
       for (const branch of statement.branches) {
-        collectAssignedPathRootsInExpression(
+        collectAssignedPathsInExpression(
           branch.cond,
           roots,
           falseLocals,
@@ -41856,7 +41903,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
           ...falseFacts,
           ...factsWhenTrue(branch.cond, canonicalPath)
         ];
-        collectAssignedPathRoots(
+        collectAssignedPaths(
           branch.body,
           roots,
           localsWithBindings(falseLocals, branch.cond, true),
@@ -41868,12 +41915,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 {
@@ -41885,18 +41927,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,
@@ -41906,13 +41948,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,
@@ -41921,14 +41963,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,
@@ -41939,22 +41981,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,
@@ -41962,11 +41999,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,
@@ -41975,7 +42012,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,
@@ -41983,13 +42020,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,
@@ -41998,7 +42035,7 @@ function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set(),
       continue;
     }
     if (statement.kind === "exprStmt") {
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         statement.expr,
         roots,
         locals,
@@ -42008,43 +42045,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,
@@ -42052,13 +42074,13 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "index":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.receiver,
         roots,
         locals,
         flowCache
       );
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.index,
         roots,
         locals,
@@ -42066,32 +42088,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,
@@ -42102,15 +42114,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,
@@ -42119,13 +42126,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,
@@ -42133,19 +42140,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,
@@ -42154,7 +42161,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       return;
     case "unary":
     case "force":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -42162,7 +42169,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "is":
-      collectAssignedPathRootsInExpression(
+      collectAssignedPathsInExpression(
         expression.operand,
         roots,
         locals,
@@ -42170,7 +42177,7 @@ function collectAssignedPathRootsInExpression(expression, roots, locals, flowCac
       );
       return;
     case "lambda":
-      collectAssignedPathRoots(
+      collectAssignedPaths(
         expression.body,
         roots,
         /* @__PURE__ */ new Set([
@@ -54634,7 +54641,7 @@ var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.72.1",
+  cliVersion: "0.72.4",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {