@neocompose/cli 0.61.3 → 0.61.4

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.61.4] - 2026-10-01
+
+- Narrow implicit instance members after null and type checks just like their `this.Member` spelling, including nested conditions, assignments, and loop invalidation.
+- Keep symbol rename scoped to resolved references in test files, including declarations without an assigned ID.
+
 ## [0.61.3] - 2026-10-01
 
 - Resolve `collectionValue: Reference(root.Assets.Quests.Daily)` through construction defaults, including classes and empty collections declared in the same push. Preparation creates the required rows and associations together; no preliminary push or manually assigned value IDs are needed.

package/dist/neo.mjs

@@ -5112,8 +5112,8 @@ function pathRoot(path) {
   const dot = path.indexOf(".");
   return dot === -1 ? path : path.slice(0, dot);
 }
-function factsFromIsCheck(expression, whenTrue) {
-  const path = canonicalPath(expression.operand);
+function factsFromIsCheck(expression, whenTrue, pathOf) {
+  const path = pathOf(expression.operand);
   const nullCheck = expression.type.kind === "primitive" && expression.type.name === "null";
   if (path === null && (!whenTrue || nullCheck || !expression.bindingName)) {
     return [];
@@ -5137,58 +5137,72 @@ function extractNullCheckSide(expression) {
   if (!leftNull && !rightNull) return null;
   return leftNull ? expression.right : expression.left;
 }
-function factsWhenTrue(expression) {
-  if (expression.kind === "is") return factsFromIsCheck(expression, true);
+function pathsAfterBindings(pathOf, facts) {
+  const bindings = new Set(
+    facts.flatMap((fact) => fact.bindingName ? [fact.bindingName] : [])
+  );
+  if (bindings.size === 0) return pathOf;
+  return (expression) => {
+    const path = canonicalPath(expression);
+    return path !== null && bindings.has(pathRoot(path)) ? path : pathOf(expression);
+  };
+}
+function factsWhenTrue(expression, pathOf) {
+  if (expression.kind === "is")
+    return factsFromIsCheck(expression, true, pathOf);
   if (expression.kind === "binary") {
     if (expression.op === "&&") {
+      const left = factsWhenTrue(expression.left, pathOf);
       return [
-        ...factsWhenTrue(expression.left),
-        ...factsWhenTrue(expression.right)
+        ...left,
+        ...factsWhenTrue(expression.right, pathsAfterBindings(pathOf, left))
       ];
     }
     if (expression.op === "||") {
       return mergeFactSets([
-        factsWhenTrue(expression.left),
-        factsWhenTrue(expression.right)
+        factsWhenTrue(expression.left, pathOf),
+        factsWhenTrue(expression.right, pathOf)
       ]);
     }
     if (expression.op === "==" || expression.op === "!=") {
       const value = extractNullCheckSide(expression);
-      const path2 = value ? canonicalPath(value) : null;
+      const path2 = value ? pathOf(value) : null;
       return value && path2 ? [{ expression: value, path: path2, nullValue: expression.op === "==" }] : [];
     }
   }
   if (expression.kind === "unary" && expression.op === "!") {
-    return factsWhenFalse(expression.operand);
+    return factsWhenFalse(expression.operand, pathOf);
   }
-  const path = canonicalPath(expression);
+  const path = pathOf(expression);
   return path && (expression.kind === "ident" || expression.kind === "member") ? [{ expression, path, nullValue: false, loose: true }] : [];
 }
-function factsWhenFalse(expression) {
-  if (expression.kind === "is") return factsFromIsCheck(expression, false);
+function factsWhenFalse(expression, pathOf) {
+  if (expression.kind === "is")
+    return factsFromIsCheck(expression, false, pathOf);
   if (expression.kind === "binary") {
     if (expression.op === "||") {
+      const left = factsWhenFalse(expression.left, pathOf);
       return [
-        ...factsWhenFalse(expression.left),
-        ...factsWhenFalse(expression.right)
+        ...left,
+        ...factsWhenFalse(expression.right, pathsAfterBindings(pathOf, left))
       ];
     }
     if (expression.op === "&&") {
       return mergeFactSets([
-        factsWhenFalse(expression.left),
-        factsWhenFalse(expression.right)
+        factsWhenFalse(expression.left, pathOf),
+        factsWhenFalse(expression.right, pathOf)
       ]);
     }
     if (expression.op === "==" || expression.op === "!=") {
       const value = extractNullCheckSide(expression);
-      const path2 = value ? canonicalPath(value) : null;
+      const path2 = value ? pathOf(value) : null;
       return value && path2 ? [{ expression: value, path: path2, nullValue: expression.op !== "==" }] : [];
     }
   }
   if (expression.kind === "unary" && expression.op === "!") {
-    return factsWhenTrue(expression.operand);
+    return factsWhenTrue(expression.operand, pathOf);
   }
-  const path = canonicalPath(expression);
+  const path = pathOf(expression);
   return path && (expression.kind === "ident" || expression.kind === "member") ? [{ expression, path, nullValue: true, loose: true }] : [];
 }
 function mergeFactSets(sets) {
@@ -5350,156 +5364,440 @@ function scopeVariable(name, value, sourceType, writability, ownership, writeRoo
     ...readonlyBinding ? { readonlyBinding } : {}
   };
 }
-function invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, outerScope, statements) {
-  for (const rootName of collectAssignedPathRoots(statements)) {
-    const outerEntry = outerScope.lookup(rootName);
-    if (outerEntry) {
-      loopEntryScope.hideInheritedNarrowing(outerEntry);
+function statementFlow(statements, cache) {
+  const cached = cache.get(statements);
+  if (cached) return cached;
+  const flow = /* @__PURE__ */ new Set(["fallthrough"]);
+  for (const statement of statements) {
+    if (!flow.delete("fallthrough")) break;
+    let next;
+    switch (statement.kind) {
+      case "return":
+      case "throw":
+        next = /* @__PURE__ */ new Set(["exit"]);
+        break;
+      case "break":
+        next = /* @__PURE__ */ new Set(["break"]);
+        break;
+      case "continue":
+        next = /* @__PURE__ */ new Set(["continue"]);
+        break;
+      case "if":
+        next = new Set(statementFlow(statement.elseBody ?? [], cache));
+        for (const branch of statement.branches)
+          for (const outcome of statementFlow(branch.body, cache))
+            next.add(outcome);
+        break;
+      case "try":
+        next = new Set(statementFlow(statement.body, cache));
+        for (const clause of statement.catches)
+          for (const outcome of statementFlow(clause.body, cache))
+            next.add(outcome);
+        break;
+      case "switch":
+        next = /* @__PURE__ */ new Set();
+        if (!statement.sections.some(
+          (section) => section.labels.some((label) => label.kind === "default")
+        )) {
+          next.add("fallthrough");
+        }
+        for (const section of statement.sections)
+          for (const outcome of statementFlow(section.body, cache))
+            next.add(outcome);
+        if (next.delete("break")) next.add("fallthrough");
+        break;
+      case "doWhile":
+        next = new Set(statementFlow(statement.body, cache));
+        if (next.delete("break")) next.add("fallthrough");
+        if (next.delete("continue")) next.add("fallthrough");
+        break;
+      default:
+        next = /* @__PURE__ */ new Set(["fallthrough"]);
+        break;
     }
+    for (const outcome of next) flow.add(outcome);
   }
+  cache.set(statements, flow);
+  return flow;
+}
+function localsWithBindings(locals, expression, whenTrue) {
+  const facts = whenTrue ? factsWhenTrue(expression, canonicalPath) : factsWhenFalse(expression, canonicalPath);
+  return /* @__PURE__ */ new Set([
+    ...locals,
+    ...facts.flatMap((fact) => fact.bindingName ? [fact.bindingName] : [])
+  ]);
 }
-function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set()) {
+function collectAssignedPathRoots(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) roots.add(pathRoot(assignedPath));
-      collectAssignedPathRootsInExpression(statement.target, roots);
+      if (assignedPath && !locals.has(pathRoot(assignedPath))) {
+        roots.add(pathRoot(assignedPath));
+      }
+      collectAssignedPathRootsInExpression(
+        statement.target,
+        roots,
+        locals,
+        flowCache
+      );
       if (statement.value)
-        collectAssignedPathRootsInExpression(statement.value, roots);
+        collectAssignedPathRootsInExpression(
+          statement.value,
+          roots,
+          locals,
+          flowCache
+        );
       continue;
     }
     if (statement.kind === "varDecl") {
-      collectAssignedPathRootsInExpression(statement.init, roots);
+      collectAssignedPathRootsInExpression(
+        statement.init,
+        roots,
+        locals,
+        flowCache
+      );
+      locals.add(statement.name);
       continue;
     }
     if (statement.kind === "if") {
+      let falseLocals = locals;
+      const falseFacts = [];
+      const fallthroughFacts = [];
       for (const branch of statement.branches) {
-        collectAssignedPathRootsInExpression(branch.cond, roots);
-        collectAssignedPathRoots(branch.body, roots);
+        collectAssignedPathRootsInExpression(
+          branch.cond,
+          roots,
+          falseLocals,
+          flowCache
+        );
+        const branchFacts = [
+          ...falseFacts,
+          ...factsWhenTrue(branch.cond, canonicalPath)
+        ];
+        collectAssignedPathRoots(
+          branch.body,
+          roots,
+          localsWithBindings(falseLocals, branch.cond, true),
+          flowCache
+        );
+        if (statementFlow(branch.body, flowCache).has("fallthrough"))
+          fallthroughFacts.push(branchFacts);
+        falseFacts.push(...factsWhenFalse(branch.cond, canonicalPath));
+        falseLocals = localsWithBindings(falseLocals, branch.cond, false);
       }
       if (statement.elseBody) {
-        collectAssignedPathRoots(statement.elseBody, roots);
+        collectAssignedPathRoots(
+          statement.elseBody,
+          roots,
+          falseLocals,
+          flowCache
+        );
+        if (statementFlow(statement.elseBody, flowCache).has("fallthrough"))
+          fallthroughFacts.push(falseFacts);
+      } else {
+        fallthroughFacts.push(falseFacts);
+      }
+      for (const fact of mergeFactSets(fallthroughFacts)) {
+        if (fact.bindingName) locals.add(fact.bindingName);
       }
       continue;
     }
     if (statement.kind === "try") {
-      collectAssignedPathRoots(statement.body, roots);
+      collectAssignedPathRoots(statement.body, roots, locals, flowCache);
       for (const clause of statement.catches) {
+        const catchLocals = /* @__PURE__ */ new Set([...locals, clause.name]);
         if (clause.filter) {
-          collectAssignedPathRootsInExpression(clause.filter, roots);
+          collectAssignedPathRootsInExpression(
+            clause.filter,
+            roots,
+            catchLocals,
+            flowCache
+          );
         }
-        collectAssignedPathRoots(clause.body, roots);
+        collectAssignedPathRoots(
+          clause.body,
+          roots,
+          clause.filter ? localsWithBindings(catchLocals, clause.filter, true) : catchLocals,
+          flowCache
+        );
       }
       continue;
     }
     if (statement.kind === "while" || statement.kind === "doWhile") {
-      collectAssignedPathRootsInExpression(statement.condition, roots);
-      collectAssignedPathRoots(statement.body, roots);
+      collectAssignedPathRootsInExpression(
+        statement.condition,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRoots(
+        statement.body,
+        roots,
+        statement.kind === "while" ? localsWithBindings(locals, statement.condition, true) : locals,
+        flowCache
+      );
       continue;
     }
     if (statement.kind === "for") {
-      collectAssignedPathRootsInExpression(statement.initializer.init, roots);
-      collectAssignedPathRootsInExpression(statement.condition, roots);
-      collectAssignedPathRoots([statement.iterator], roots);
-      collectAssignedPathRoots(statement.body, roots);
+      collectAssignedPathRootsInExpression(
+        statement.initializer.init,
+        roots,
+        locals,
+        flowCache
+      );
+      const loopLocals = /* @__PURE__ */ new Set([...locals, statement.initializer.name]);
+      collectAssignedPathRootsInExpression(
+        statement.condition,
+        roots,
+        loopLocals,
+        flowCache
+      );
+      const iterationLocals = localsWithBindings(
+        loopLocals,
+        statement.condition,
+        true
+      );
+      collectAssignedPathRoots(
+        [statement.iterator],
+        roots,
+        iterationLocals,
+        flowCache
+      );
+      collectAssignedPathRoots(
+        statement.body,
+        roots,
+        iterationLocals,
+        flowCache
+      );
       continue;
     }
     if (statement.kind === "forEach") {
-      collectAssignedPathRootsInExpression(statement.collection, roots);
-      collectAssignedPathRoots(statement.body, roots);
+      collectAssignedPathRootsInExpression(
+        statement.collection,
+        roots,
+        locals,
+        flowCache
+      );
+      const loopLocals = /* @__PURE__ */ new Set([...locals, statement.name]);
+      if (statement.key) loopLocals.add(statement.key.name);
+      collectAssignedPathRoots(statement.body, roots, loopLocals, flowCache);
       continue;
     }
     if (statement.kind === "switch") {
-      collectAssignedPathRootsInExpression(statement.selector, roots);
+      collectAssignedPathRootsInExpression(
+        statement.selector,
+        roots,
+        locals,
+        flowCache
+      );
       for (const section of statement.sections) {
         for (const label of section.labels) {
           if (label.kind === "case") {
-            collectAssignedPathRootsInExpression(label.expression, roots);
+            collectAssignedPathRootsInExpression(
+              label.expression,
+              roots,
+              locals,
+              flowCache
+            );
           }
         }
-        collectAssignedPathRoots(section.body, roots);
+        collectAssignedPathRoots(section.body, roots, locals, flowCache);
       }
       continue;
     }
     if (statement.kind === "return" || statement.kind === "throw") {
       if (statement.expr)
-        collectAssignedPathRootsInExpression(statement.expr, roots);
+        collectAssignedPathRootsInExpression(
+          statement.expr,
+          roots,
+          locals,
+          flowCache
+        );
       continue;
     }
     if (statement.kind === "exprStmt") {
-      collectAssignedPathRootsInExpression(statement.expr, roots);
+      collectAssignedPathRootsInExpression(
+        statement.expr,
+        roots,
+        locals,
+        flowCache
+      );
     }
   }
   return roots;
 }
-function collectAssignedPathRootsInExpression(expression, roots) {
+function collectAssignedPathRootsInExpression(expression, roots, locals, flowCache) {
   switch (expression.kind) {
     case "litInterp":
       for (const part of expression.parts) {
         if (part.kind === "expr") {
-          collectAssignedPathRootsInExpression(part.expr, roots);
+          collectAssignedPathRootsInExpression(
+            part.expr,
+            roots,
+            locals,
+            flowCache
+          );
         }
       }
       return;
     case "litList":
       for (const element of expression.elements) {
-        collectAssignedPathRootsInExpression(element, roots);
+        collectAssignedPathRootsInExpression(element, roots, locals, flowCache);
       }
       return;
     case "litDict":
       for (const entry of expression.entries) {
-        collectAssignedPathRootsInExpression(entry.key, roots);
-        collectAssignedPathRootsInExpression(entry.value, roots);
+        collectAssignedPathRootsInExpression(
+          entry.key,
+          roots,
+          locals,
+          flowCache
+        );
+        collectAssignedPathRootsInExpression(
+          entry.value,
+          roots,
+          locals,
+          flowCache
+        );
       }
       return;
     case "member":
-      collectAssignedPathRootsInExpression(expression.receiver, roots);
+      collectAssignedPathRootsInExpression(
+        expression.receiver,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "index":
-      collectAssignedPathRootsInExpression(expression.receiver, roots);
-      collectAssignedPathRootsInExpression(expression.index, roots);
+      collectAssignedPathRootsInExpression(
+        expression.receiver,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRootsInExpression(
+        expression.index,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "call":
-      collectAssignedPathRootsInExpression(expression.callee, roots);
+      collectAssignedPathRootsInExpression(
+        expression.callee,
+        roots,
+        locals,
+        flowCache
+      );
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(argument2, roots);
+        collectAssignedPathRootsInExpression(
+          argument2,
+          roots,
+          locals,
+          flowCache
+        );
       }
       return;
     case "new":
       for (const argument2 of expression.args) {
-        collectAssignedPathRootsInExpression(argument2, roots);
+        collectAssignedPathRootsInExpression(
+          argument2,
+          roots,
+          locals,
+          flowCache
+        );
       }
       for (const initializer of expression.initializer ?? []) {
-        collectAssignedPathRootsInExpression(initializer.value, roots);
+        collectAssignedPathRootsInExpression(
+          initializer.value,
+          roots,
+          locals,
+          flowCache
+        );
       }
       return;
     case "annotated":
       for (const annotation2 of expression.annotations) {
         for (const argument2 of annotation2.args) {
-          collectAssignedPathRootsInExpression(argument2, roots);
+          collectAssignedPathRootsInExpression(
+            argument2,
+            roots,
+            locals,
+            flowCache
+          );
         }
       }
-      collectAssignedPathRootsInExpression(expression.expression, roots);
+      collectAssignedPathRootsInExpression(
+        expression.expression,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "binary":
     case "coalesce":
-      collectAssignedPathRootsInExpression(expression.left, roots);
-      collectAssignedPathRootsInExpression(expression.right, roots);
+      collectAssignedPathRootsInExpression(
+        expression.left,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRootsInExpression(
+        expression.right,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "conditional":
-      collectAssignedPathRootsInExpression(expression.condition, roots);
-      collectAssignedPathRootsInExpression(expression.whenTrue, roots);
-      collectAssignedPathRootsInExpression(expression.whenFalse, roots);
+      collectAssignedPathRootsInExpression(
+        expression.condition,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRootsInExpression(
+        expression.whenTrue,
+        roots,
+        locals,
+        flowCache
+      );
+      collectAssignedPathRootsInExpression(
+        expression.whenFalse,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "unary":
     case "force":
-      collectAssignedPathRootsInExpression(expression.operand, roots);
+      collectAssignedPathRootsInExpression(
+        expression.operand,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "is":
-      collectAssignedPathRootsInExpression(expression.operand, roots);
+      collectAssignedPathRootsInExpression(
+        expression.operand,
+        roots,
+        locals,
+        flowCache
+      );
       return;
     case "lambda":
-      collectAssignedPathRoots(expression.body, roots);
+      collectAssignedPathRoots(
+        expression.body,
+        roots,
+        /* @__PURE__ */ new Set([
+          ...locals,
+          ...expression.params.map((parameter4) => parameter4.name)
+        ]),
+        flowCache
+      );
       return;
     case "litNull":
     case "litBool":
@@ -6846,16 +7144,18 @@ var init_strict_resolver = __esm({
               const child = new Scope(scope);
               const branchFacts = [
                 ...cumulativeFalseFacts,
-                ...factsWhenTrue(branch.cond)
+                ...this.conditionFacts(branch.cond, scope, true)
               ];
-              this.applyFactsToScope(scope, child, branchFacts);
+              this.applyFactsToScope(child, branchFacts);
               const instructions = this.resolveStatements(branch.body, child);
               if (!instructionsTerminate(instructions)) {
                 branchExitFacts.push(branchFacts);
                 branchExitNarrowings.push(new Map(child.narrowedPaths));
                 branchExitOwnershipScopes.push(child);
               }
-              cumulativeFalseFacts.push(...factsWhenFalse(branch.cond));
+              cumulativeFalseFacts.push(
+                ...this.conditionFacts(branch.cond, scope, false)
+              );
               return {
                 expression: pointerToBooleanExpression(condition.pointer),
                 instructions
@@ -6864,7 +7164,7 @@ var init_strict_resolver = __esm({
             let otherwise = null;
             if (statement.elseBody) {
               const elseScope = new Scope(scope);
-              this.applyFactsToScope(scope, elseScope, cumulativeFalseFacts);
+              this.applyFactsToScope(elseScope, cumulativeFalseFacts);
               otherwise = this.resolveStatements(statement.elseBody, elseScope);
               if (!instructionsTerminate(otherwise)) {
                 branchExitFacts.push([...cumulativeFalseFacts]);
@@ -6873,7 +7173,7 @@ var init_strict_resolver = __esm({
               }
             } else {
               const noBranchScope = new Scope(scope);
-              this.applyFactsToScope(scope, noBranchScope, cumulativeFalseFacts);
+              this.applyFactsToScope(noBranchScope, cumulativeFalseFacts);
               branchExitFacts.push([...cumulativeFalseFacts]);
               branchExitNarrowings.push(new Map(noBranchScope.narrowedPaths));
               branchExitOwnershipScopes.push(noBranchScope);
@@ -6891,7 +7191,6 @@ var init_strict_resolver = __esm({
             }
             mergeBranchOwnership(scope, branchExitOwnershipScopes);
             this.applyFactsToScope(
-              scope,
               scope,
               mergeFactSets(branchExitFacts),
               "bindings-only"
@@ -7001,10 +7300,11 @@ var init_strict_resolver = __esm({
           case "while":
           case "doWhile": {
             const loopScope = new Scope(scope);
-            invalidateLoopEntryNarrowingsAssignedBy(
+            this.invalidateLoopEntryNarrowingsAssignedBy(
               loopScope,
               scope,
-              statement.body
+              statement.body,
+              statement.kind === "while" ? localsWithBindings(/* @__PURE__ */ new Set(), statement.condition, true) : /* @__PURE__ */ new Set()
             );
             const iterationScope = new Scope(loopScope);
             let condition;
@@ -7013,8 +7313,8 @@ var init_strict_resolver = __esm({
                 this.resolveExpression(statement.condition, loopScope),
                 statement.condition.pos
               );
-              this.applyFactsToScope(loopScope, iterationScope, [
-                ...factsWhenTrue(statement.condition)
+              this.applyFactsToScope(iterationScope, [
+                ...this.conditionFacts(statement.condition, loopScope, true)
               ]);
             }
             const bodyScope = new Scope(iterationScope);
@@ -7051,15 +7351,19 @@ var init_strict_resolver = __esm({
               );
             }
             const normalExitScope = new Scope(nextConditionScope);
-            this.applyFactsToScope(nextConditionScope, normalExitScope, [
-              ...factsWhenFalse(statement.condition)
+            this.applyFactsToScope(normalExitScope, [
+              ...this.conditionFacts(
+                statement.condition,
+                nextConditionScope,
+                false
+              )
             ]);
             const effectScopes = nextConditionEffects.length > 0 ? [nextConditionScope] : [];
             const exitNarrowings = nextConditionEffects.length > 0 ? [normalExitScope.effectiveNarrowedPaths()] : [];
             if (statement.kind === "while") {
               const initialExitScope = new Scope(loopScope);
-              this.applyFactsToScope(loopScope, initialExitScope, [
-                ...factsWhenFalse(statement.condition)
+              this.applyFactsToScope(initialExitScope, [
+                ...this.conditionFacts(statement.condition, loopScope, false)
               ]);
               effectScopes.push(loopScope);
               exitNarrowings.push(initialExitScope.effectiveNarrowedPaths());
@@ -7087,17 +7391,30 @@ var init_strict_resolver = __esm({
               );
             }
             const loopEntryScope = new Scope(loopScope);
-            invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, scope, [
-              ...statement.body,
-              statement.iterator
-            ]);
+            const conditionLocals = localsWithBindings(
+              /* @__PURE__ */ new Set(),
+              statement.condition,
+              true
+            );
+            this.invalidateLoopEntryNarrowingsAssignedBy(
+              loopEntryScope,
+              loopScope,
+              statement.body,
+              conditionLocals
+            );
+            this.invalidateLoopEntryNarrowingsAssignedBy(
+              loopEntryScope,
+              loopScope,
+              [statement.iterator],
+              conditionLocals
+            );
             const condition = this.toBool(
               this.resolveExpression(statement.condition, loopEntryScope),
               statement.condition.pos
             );
             const iterationScope = new Scope(loopEntryScope);
-            this.applyFactsToScope(loopEntryScope, iterationScope, [
-              ...factsWhenTrue(statement.condition)
+            this.applyFactsToScope(iterationScope, [
+              ...this.conditionFacts(statement.condition, loopEntryScope, true)
             ]);
             const bodyScope = new Scope(iterationScope);
             const loopFlow = {
@@ -7133,8 +7450,8 @@ var init_strict_resolver = __esm({
               );
             }
             const initialConditionFalseScope = new Scope(loopScope);
-            this.applyFactsToScope(loopScope, initialConditionFalseScope, [
-              ...factsWhenFalse(statement.condition)
+            this.applyFactsToScope(initialConditionFalseScope, [
+              ...this.conditionFacts(statement.condition, loopScope, false)
             ]);
             const effectScopes = [loopScope];
             const normalExitScopes = [initialConditionFalseScope];
@@ -7145,11 +7462,13 @@ var init_strict_resolver = __esm({
               ]);
               effectScopes.push(postIterationScope);
               const subsequentConditionFalseScope = new Scope(postIterationScope);
-              this.applyFactsToScope(
-                postIterationScope,
-                subsequentConditionFalseScope,
-                [...factsWhenFalse(statement.condition)]
-              );
+              this.applyFactsToScope(subsequentConditionFalseScope, [
+                ...this.conditionFacts(
+                  statement.condition,
+                  postIterationScope,
+                  false
+                )
+              ]);
               normalExitScopes.push(subsequentConditionFalseScope);
             }
             this.mergeLoopEffects(scope, effectScopes, loopFlow.breakEffects);
@@ -7269,9 +7588,9 @@ var init_strict_resolver = __esm({
               });
             }
             const iterationScope = new Scope(loopScope);
-            invalidateLoopEntryNarrowingsAssignedBy(
+            this.invalidateLoopEntryNarrowingsAssignedBy(
               iterationScope,
-              scope,
+              loopScope,
               statement.body
             );
             const bodyScope = new Scope(iterationScope);
@@ -7563,8 +7882,8 @@ var init_strict_resolver = __esm({
         }
         const bodyScope = new Scope(catchScope);
         if (clause.filter) {
-          this.applyFactsToScope(catchScope, bodyScope, [
-            ...factsWhenTrue(clause.filter)
+          this.applyFactsToScope(bodyScope, [
+            ...this.conditionFacts(clause.filter, catchScope, true)
           ]);
         }
         const catchPointer = {
@@ -7857,7 +8176,10 @@ var init_strict_resolver = __esm({
             value.writability ?? "runtime" /* Runtime */
           );
         }
-        const assignedPath = canonicalPath(statement.target);
+        const assignedPath = this.narrowingPath(
+          canonicalPath(statement.target),
+          scope
+        );
         if (assignedPath) {
           const rootEntry = scope.lookup(pathRoot(assignedPath));
           if (rootEntry) {
@@ -7896,7 +8218,20 @@ var init_strict_resolver = __esm({
        * lookup `resolveMember` performs before it overlays a narrowed type.
        */
       assignmentStorageType(targetAst, resolvedTarget, local, scope) {
-        if (targetAst.kind === "ident") return local?.type ?? resolvedTarget.type;
+        if (targetAst.kind === "ident") {
+          if (local) return local.type;
+          const path = this.narrowingPath(targetAst.name, scope);
+          if (path === `this.${targetAst.name}`) {
+            return this.resolveMemberNatural(
+              { kind: "ident", name: "this", pos: targetAst.pos },
+              targetAst.name,
+              scope,
+              targetAst.pos,
+              false
+            ).type;
+          }
+          return resolvedTarget.type;
+        }
         if (targetAst.kind !== "member") return resolvedTarget.type;
         return this.resolveMemberNatural(
           targetAst.receiver,
@@ -7957,7 +8292,10 @@ var init_strict_resolver = __esm({
           actionType,
           scope
         );
-        const assignedPath = canonicalPath(statement.target);
+        const assignedPath = this.narrowingPath(
+          canonicalPath(statement.target),
+          scope
+        );
         if (assignedPath) {
           const rootEntry = scope.lookup(pathRoot(assignedPath));
           if (rootEntry) {
@@ -9108,11 +9446,42 @@ var init_strict_resolver = __esm({
           pos
         );
       }
-      applyFactsToScope(outerScope, targetScope, facts, mode = "all") {
+      narrowingPath(path, scope) {
+        if (path === null) return null;
+        const root = pathRoot(path);
+        if (scope.lookup(root)) return path;
+        if (this.context.project.globals.some((symbol) => symbol.name === root)) {
+          return path;
+        }
+        const implicit = this.implicitMember(root);
+        return implicit && implicit.symbol.static !== true ? `this.${path}` : path;
+      }
+      conditionFacts(expression, scope, whenTrue) {
+        const pathOf = (value) => this.narrowingPath(canonicalPath(value), scope);
+        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.
+       */
+      invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, outerScope, statements, locals = /* @__PURE__ */ new Set()) {
+        for (const rootName of collectAssignedPathRoots(
+          statements,
+          /* @__PURE__ */ new Set(),
+          locals
+        )) {
+          const path = this.narrowingPath(rootName, outerScope);
+          const outerEntry = path === null ? null : outerScope.lookup(pathRoot(path));
+          if (outerEntry) loopEntryScope.hideInheritedNarrowing(outerEntry);
+        }
+      }
+      applyFactsToScope(targetScope, facts, mode = "all") {
         for (const fact of facts) {
           if (mode === "bindings-only" && !fact.bindingName) continue;
-          const natural = this.resolveExpression(fact.expression, outerScope);
-          const rootEntry = fact.path === null ? null : outerScope.lookup(pathRoot(fact.path));
+          const natural = this.resolveExpression(fact.expression, targetScope);
+          const rootEntry = fact.path === null ? null : targetScope.lookup(pathRoot(fact.path));
           if (fact.nullValue) {
             if (fact.path === null || rootEntry === null) continue;
             if (fact.loose === true && natural.type.kind === "primitive" && (natural.type.name === "string" || natural.type.name === "int" || natural.type.name === "float" || natural.type.name === "bool")) {
@@ -9418,7 +9787,10 @@ var init_strict_resolver = __esm({
           optional2
         );
         if (!optional2) {
-          const receiverPath = canonicalPath(receiverAst);
+          const receiverPath = this.narrowingPath(
+            canonicalPath(receiverAst),
+            scope
+          );
           if (receiverPath) {
             const rootEntry = scope.lookup(pathRoot(receiverPath));
             if (rootEntry) {
@@ -12507,7 +12879,10 @@ var init_strict_resolver = __esm({
           scope,
           true
         );
-        const path = canonicalPath(expression.callee.receiver);
+        const path = this.narrowingPath(
+          canonicalPath(expression.callee.receiver),
+          scope
+        );
         if (path) {
           const rootEntry = scope.lookup(pathRoot(path));
           if (rootEntry) scope.invalidate(rootEntry);
@@ -12568,15 +12943,13 @@ var init_strict_resolver = __esm({
         );
         const trueScope = new Scope(scope);
         this.applyFactsToScope(
-          scope,
           trueScope,
-          factsWhenTrue(expression.condition)
+          this.conditionFacts(expression.condition, scope, true)
         );
         const falseScope = new Scope(scope);
         this.applyFactsToScope(
-          scope,
           falseScope,
-          factsWhenFalse(expression.condition)
+          this.conditionFacts(expression.condition, scope, false)
         );
         let whenTrue;
         let whenFalse;
@@ -12658,9 +13031,8 @@ var init_strict_resolver = __esm({
         if (expression.op === "&&" || expression.op === "||") {
           rightScope = new Scope(scope);
           this.applyFactsToScope(
-            scope,
             rightScope,
-            expression.op === "&&" ? factsWhenTrue(expression.left) : factsWhenFalse(expression.left)
+            expression.op === "&&" ? this.conditionFacts(expression.left, scope, true) : this.conditionFacts(expression.left, scope, false)
           );
         }
         const right = preResolvedRight ?? this.resolveExpression(expression.right, rightScope, left.type);
@@ -35212,9 +35584,14 @@ var init_service = __esm({
           if (state.context.projectSourceKind !== "spec") continue;
           const snapshot = this.scriptSnapshot(state);
           for (const candidate of snapshot.parsed.references) {
-            if (resolveReferenceSymbolId(snapshot, candidate) !== declaration.id) {
-              continue;
-            }
+            if (candidate.name !== declaration.name) continue;
+            const symbolId = resolveReferenceSymbolId(snapshot, candidate);
+            if (symbolId === null) continue;
+            const matches = declaration.id !== null ? symbolId === declaration.id : sameLocationInList(
+              declaration.location,
+              definition(snapshot, candidate.range.start)
+            );
+            if (!matches) continue;
             locations.push({ uri: state.document.uri, range: candidate.range });
           }
         }
@@ -146022,7 +146399,7 @@ var init_registry2 = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.61.3",
+      cliVersion: "0.61.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -154702,7 +155079,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.61.3");
+    console.log("0.61.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

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

package/skills/neocompose-cli/SKILL.md

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

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

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

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

@@ -158,6 +158,11 @@ chain, so `config.Hat?.Head.Idle.Down.Frames` safely returns null when `Hat` is
 null. A descendant that is itself nullable still needs its own `?.`, `??`, `!`,
 or narrowing guard before the next access.
 
+Inside an instance body, `Member` and `this.Member` share null and type-check
+narrowing. A local or parameter named `Member` shadows the implicit member;
+`this.Member` still names the instance field. Reassigning a narrowed path to a
+nullable value clears its non-null fact.
+
 Treat lookup-return values with the same nullable narrowing rules.
 
 Runtime declaration patterns follow the possible runtime type, not only the