sourceverity 1.0.4 → 1.0.5

package/dist/analysis/arrayBounds.d.ts

@@ -1,4 +1,4 @@
-export { isCompleteBoundsExitGuard, isFixedLengthGuardedIndex, isNodeDescendantOf, isParamBoundedCondition, isPositiveBoundsEntryGuard, isStaticArrayLiteralBoundedIndex, normalizeArrayTarget, normalizeIndexExpression, resolveStaticConstArrayLiteral, } from "./arrayBoundsCore.js";
+export { hasArrayMutation, hasMutationBeforeNode, isCompleteBoundsExitGuard, isFixedLengthGuardedIndex, isNodeDescendantOf, isParamBoundedCondition, isPositiveBoundsEntryGuard, isStaticArrayLiteralBoundedIndex, normalizeArrayTarget, normalizeIndexExpression, resolveStaticConstArrayLiteral, } from "./arrayBoundsCore.js";
 export { isFindIndexBoundedIndex, isLoopOrCallbackBoundedIndex, } from "./arrayIterationBounds.js";
 export { isConstructedArrayCardinalityBoundedIndex, isSearchProvenanceBoundedIndex, } from "./arrayConstructionBounds.js";
 //# sourceMappingURL=arrayBounds.d.ts.map

package/dist/analysis/arrayBounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrayBounds.d.ts","sourceRoot":"","sources":["../../src/analysis/arrayBounds.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,EAC1B,gCAAgC,EAChC,oBAAoB,EACpB,wBAAwB,EACxB,8BAA8B,GAC/B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,uBAAuB,EACvB,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,yCAAyC,EACzC,8BAA8B,GAC/B,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"arrayBounds.d.ts","sourceRoot":"","sources":["../../src/analysis/arrayBounds.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,yBAAyB,EACzB,yBAAyB,EACzB,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,EAC1B,gCAAgC,EAChC,oBAAoB,EACpB,wBAAwB,EACxB,8BAA8B,GAC/B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,uBAAuB,EACvB,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,yCAAyC,EACzC,8BAA8B,GAC/B,MAAM,8BAA8B,CAAC"}

package/dist/analysis/arrayBounds.js

@@ -1,4 +1,4 @@
-export { isCompleteBoundsExitGuard, isFixedLengthGuardedIndex, isNodeDescendantOf, isParamBoundedCondition, isPositiveBoundsEntryGuard, isStaticArrayLiteralBoundedIndex, normalizeArrayTarget, normalizeIndexExpression, resolveStaticConstArrayLiteral, } from "./arrayBoundsCore.js";
+export { hasArrayMutation, hasMutationBeforeNode, isCompleteBoundsExitGuard, isFixedLengthGuardedIndex, isNodeDescendantOf, isParamBoundedCondition, isPositiveBoundsEntryGuard, isStaticArrayLiteralBoundedIndex, normalizeArrayTarget, normalizeIndexExpression, resolveStaticConstArrayLiteral, } from "./arrayBoundsCore.js";
 export { isFindIndexBoundedIndex, isLoopOrCallbackBoundedIndex, } from "./arrayIterationBounds.js";
 export { isConstructedArrayCardinalityBoundedIndex, isSearchProvenanceBoundedIndex, } from "./arrayConstructionBounds.js";
 //# sourceMappingURL=arrayBounds.js.map

package/dist/analysis/arrayBounds.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrayBounds.js","sourceRoot":"","sources":["../../src/analysis/arrayBounds.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,EAC1B,gCAAgC,EAChC,oBAAoB,EACpB,wBAAwB,EACxB,8BAA8B,GAC/B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,uBAAuB,EACvB,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,yCAAyC,EACzC,8BAA8B,GAC/B,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"arrayBounds.js","sourceRoot":"","sources":["../../src/analysis/arrayBounds.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,yBAAyB,EACzB,yBAAyB,EACzB,kBAAkB,EAClB,uBAAuB,EACvB,0BAA0B,EAC1B,gCAAgC,EAChC,oBAAoB,EACpB,wBAAwB,EACxB,8BAA8B,GAC/B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,uBAAuB,EACvB,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,yCAAyC,EACzC,8BAA8B,GAC/B,MAAM,8BAA8B,CAAC"}

package/dist/analysis/arrayBoundsCore.d.ts

@@ -26,7 +26,7 @@ declare function normalizeArrayTarget(expr: tsType.Expression, ts: typeof tsType
 /**
  * Checks if a binary condition expression guards an index lower bound (e.g. index === -1 or index < 0).
  */
-declare function isLowerBoundNegativeGuard(cond: tsType.Expression, indexInfo: NormalizedIndex, ts: typeof tsType): boolean;
+declare function isLowerBoundNegativeGuard(cond: tsType.Expression, indexInfo: NormalizedIndex, ts: typeof tsType, checker?: tsType.TypeChecker | undefined): boolean;
 /**
  * Checks if an expression represents `array.length` or `array.length - K`.
  */
@@ -34,7 +34,7 @@ declare function parseArrayLengthOffset(expr: tsType.Expression, arrayInfo: Norm
 /**
  * Checks if an exit condition contains both a lower-bound check and an upper-bound check.
  */
-declare function isCompleteBoundsExitGuard(cond: tsType.Expression, indexInfo: NormalizedIndex, arrayInfo: NormalizedArray, ts: typeof tsType): boolean;
+declare function isCompleteBoundsExitGuard(cond: tsType.Expression, indexInfo: NormalizedIndex, arrayInfo: NormalizedArray, ts: typeof tsType, checker?: tsType.TypeChecker | undefined): boolean;
 /**
  * Checks if an entry condition contains both a lower-bound non-negative check and an upper-bound check against array.length.
  * e.g. `if (i >= 0 && i < array.length - 1)`

package/dist/analysis/arrayBoundsCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrayBoundsCore.d.ts","sourceRoot":"","sources":["../../src/analysis/arrayBoundsCore.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"arrayBoundsCore.d.ts","sourceRoot":"","sources":["../../src/analysis/arrayBoundsCore.ts"],"names":[],"mappings":"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"}

package/dist/analysis/arrayBoundsCore.js

@@ -153,21 +153,41 @@ function normalizeArrayTarget(expr, ts, checker) {
 /**
  * Checks if a binary condition expression guards an index lower bound (e.g. index === -1 or index < 0).
  */
-function isLowerBoundNegativeGuard(cond, indexInfo, ts) {
+function isLowerBoundNegativeGuard(cond, indexInfo, ts, checker) {
     const unwrapped = unwrapExpression(cond, ts);
     if (!ts.isBinaryExpression(unwrapped))
         return false;
     const left = unwrapExpression(unwrapped.left, ts);
     const right = unwrapExpression(unwrapped.right, ts);
     const op = unwrapped.operatorToken.kind;
+    function matchesIndex(ident) {
+        if (!ts.isIdentifier(ident))
+            return false;
+        if (ident.text !== indexInfo.baseText)
+            return false;
+        if (checker && indexInfo.baseSymbol) {
+            let sym = checker.getSymbolAtLocation(ident);
+            if (sym && (sym.flags & ts.SymbolFlags.Alias) !== 0) {
+                try {
+                    sym = checker.getAliasedSymbol(sym);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (sym && sym !== indexInfo.baseSymbol)
+                return false;
+        }
+        return true;
+    }
     // index === -1 or -1 === index
     if (op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-        if (ts.isIdentifier(left) && left.text === indexInfo.baseText) {
+        if (matchesIndex(left)) {
             if (ts.isPrefixUnaryExpression(right) && right.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(right.operand) && right.operand.text === "1") {
                 return true;
             }
         }
-        if (ts.isIdentifier(right) && right.text === indexInfo.baseText) {
+        if (matchesIndex(right)) {
             if (ts.isPrefixUnaryExpression(left) && left.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(left.operand) && left.operand.text === "1") {
                 return true;
             }
@@ -175,13 +195,13 @@ function isLowerBoundNegativeGuard(cond, indexInfo, ts) {
     }
     // index < 0
     if (op === ts.SyntaxKind.LessThanToken) {
-        if (ts.isIdentifier(left) && left.text === indexInfo.baseText && ts.isNumericLiteral(right) && right.text === "0") {
+        if (matchesIndex(left) && ts.isNumericLiteral(right) && right.text === "0") {
             return true;
         }
     }
     // 0 > index
     if (op === ts.SyntaxKind.GreaterThanToken) {
-        if (ts.isNumericLiteral(left) && left.text === "0" && ts.isIdentifier(right) && right.text === indexInfo.baseText) {
+        if (ts.isNumericLiteral(left) && left.text === "0" && matchesIndex(right)) {
             return true;
         }
     }
@@ -346,30 +366,58 @@ function parseExitGuardedLengthCondition(expr, arrayTarget, ts, checker) {
  * Checks if a binary condition expression guards an upper bound against array.length.
  * e.g. `index >= array.length` or `index >= array.length - 1` or `index > array.length - 1`.
  */
-function isUpperBoundLengthGuard(cond, indexInfo, arrayInfo, ts) {
+function isUpperBoundLengthGuard(cond, indexInfo, arrayInfo, ts, checker) {
     const unwrapped = unwrapExpression(cond, ts);
     if (!ts.isBinaryExpression(unwrapped))
         return { isGuard: false, maxAllowedOffset: 0 };
     const left = unwrapExpression(unwrapped.left, ts);
     const right = unwrapExpression(unwrapped.right, ts);
     const op = unwrapped.operatorToken.kind;
+    function matchesIndex(ident) {
+        if (!ts.isIdentifier(ident))
+            return false;
+        if (ident.text !== indexInfo.baseText)
+            return false;
+        if (checker && indexInfo.baseSymbol) {
+            let sym = checker.getSymbolAtLocation(ident);
+            if (sym && (sym.flags & ts.SymbolFlags.Alias) !== 0) {
+                try {
+                    sym = checker.getAliasedSymbol(sym);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (sym && sym !== indexInfo.baseSymbol)
+                return false;
+        }
+        return true;
+    }
     // Pattern: `index >= [length expression]`
-    if (op === ts.SyntaxKind.GreaterThanEqualsToken && ts.isIdentifier(left) && left.text === indexInfo.baseText) {
-        const lengthMinus = parseArrayLengthOffset(right, arrayInfo, ts);
+    if (op === ts.SyntaxKind.GreaterThanEqualsToken && matchesIndex(left)) {
+        const lengthMinus = parseArrayLengthOffset(right, arrayInfo, ts, checker);
+        if (lengthMinus !== undefined) {
+            return { isGuard: true, maxAllowedOffset: lengthMinus };
+        }
+    }
+    // Pattern: `[length expression] <= index`
+    if (op === ts.SyntaxKind.LessThanEqualsToken && matchesIndex(right)) {
+        const lengthMinus = parseArrayLengthOffset(left, arrayInfo, ts, checker);
         if (lengthMinus !== undefined) {
-            // index >= array.length - lengthMinus (exit)
-            // after exit: index < array.length - lengthMinus
-            // => index + offset < array.length is safe if offset <= lengthMinus - (lengthMinus === 0 ? 0 : 0) -> offset < lengthMinus + 1 => offset <= lengthMinus
-            // Specifically: if lengthMinus === 1 (index >= array.length - 1), then index < array.length - 1, so index + 1 < array.length (offset 1 is safe).
-            // If lengthMinus === 0 (index >= array.length), then index < array.length (offset 0 is safe).
             return { isGuard: true, maxAllowedOffset: lengthMinus };
         }
     }
     // Pattern: `index > [length expression]`
-    if (op === ts.SyntaxKind.GreaterThanToken && ts.isIdentifier(left) && left.text === indexInfo.baseText) {
-        const lengthMinus = parseArrayLengthOffset(right, arrayInfo, ts);
+    if (op === ts.SyntaxKind.GreaterThanToken && matchesIndex(left)) {
+        const lengthMinus = parseArrayLengthOffset(right, arrayInfo, ts, checker);
+        if (lengthMinus !== undefined) {
+            return { isGuard: true, maxAllowedOffset: lengthMinus - 1 };
+        }
+    }
+    // Pattern: `[length expression] < index`
+    if (op === ts.SyntaxKind.LessThanToken && matchesIndex(right)) {
+        const lengthMinus = parseArrayLengthOffset(left, arrayInfo, ts, checker);
         if (lengthMinus !== undefined) {
-            // index > array.length - 1 (exit) => index <= array.length - 1 => index < array.length (offset 0 safe)
             return { isGuard: true, maxAllowedOffset: lengthMinus - 1 };
         }
     }
@@ -378,7 +426,7 @@ function isUpperBoundLengthGuard(cond, indexInfo, arrayInfo, ts) {
 /**
  * Checks if an exit condition contains both a lower-bound check and an upper-bound check.
  */
-function isCompleteBoundsExitGuard(cond, indexInfo, arrayInfo, ts) {
+function isCompleteBoundsExitGuard(cond, indexInfo, arrayInfo, ts, checker) {
     // Collect all OR disjuncts: A || B || C
     const disjuncts = [];
     function collectOrs(e) {
@@ -395,10 +443,10 @@ function isCompleteBoundsExitGuard(cond, indexInfo, arrayInfo, ts) {
     let hasLower = false;
     let maxUpperOffset = -1;
     for (const d of disjuncts) {
-        if (isLowerBoundNegativeGuard(d, indexInfo, ts)) {
+        if (isLowerBoundNegativeGuard(d, indexInfo, ts, checker)) {
             hasLower = true;
         }
-        const upper = isUpperBoundLengthGuard(d, indexInfo, arrayInfo, ts);
+        const upper = isUpperBoundLengthGuard(d, indexInfo, arrayInfo, ts, checker);
         if (upper.isGuard) {
             maxUpperOffset = Math.max(maxUpperOffset, upper.maxAllowedOffset);
         }
@@ -549,11 +597,48 @@ function isFixedLengthGuardedIndex(node, operand, ts, checker) {
     if (!arrayTarget)
         return undefined;
     const indexExpr = unwrapExpression(operand.argumentExpression, ts);
-    if (!ts.isNumericLiteral(indexExpr))
-        return undefined;
-    const k = Number(indexExpr.text);
-    if (!Number.isInteger(k) || k < 0)
+    let k;
+    let lastElementOffset;
+    if (ts.isNumericLiteral(indexExpr)) {
+        const num = Number(indexExpr.text);
+        if (Number.isInteger(num) && num >= 0) {
+            k = num;
+        }
+    }
+    else if (ts.isBinaryExpression(indexExpr) && indexExpr.operatorToken.kind === ts.SyntaxKind.MinusToken) {
+        const left = unwrapExpression(indexExpr.left, ts);
+        const right = unwrapExpression(indexExpr.right, ts);
+        if (ts.isPropertyAccessExpression(left) && left.name.text === "length") {
+            const lengthArrayTarget = normalizeArrayTarget(left.expression, ts, checker);
+            if (lengthArrayTarget && arraysMatch(lengthArrayTarget, arrayTarget)) {
+                if (ts.isNumericLiteral(right)) {
+                    const offsetVal = Number(right.text);
+                    if (Number.isInteger(offsetVal) && offsetVal >= 1) {
+                        lastElementOffset = offsetVal;
+                    }
+                }
+            }
+        }
+    }
+    if (k === undefined && lastElementOffset === undefined)
         return undefined;
+    function checkFactSatisfiesBound(fact) {
+        if (lastElementOffset !== undefined) {
+            return fact.minLength >= lastElementOffset && (fact.exactLength === undefined || fact.exactLength >= lastElementOffset);
+        }
+        if (k !== undefined) {
+            const maxAllowed = fact.exactLength ?? fact.minLength;
+            return k < maxAllowed;
+        }
+        return false;
+    }
+    const targetText = arrayTarget.text;
+    function formatEvidence(prefix, exprText, fact) {
+        if (lastElementOffset !== undefined) {
+            return `${prefix} '${exprText}' proves '${targetText}' has length >= ${fact.minLength}, establishing index '${targetText}.length - ${lastElementOffset}' is strictly in-bounds.`;
+        }
+        return `${prefix} '${exprText}' proves '${targetText}' has length ${fact.exactLength !== undefined ? `=== ${fact.exactLength}` : `>= ${fact.minLength}`}, establishing index ${k} is in-bounds.`;
+    }
     // 1. Walk up enclosing AST nodes (if statements, && expressions, ternary expressions)
     let curr = node;
     while (curr.parent &&
@@ -568,15 +653,12 @@ function isFixedLengthGuardedIndex(node, operand, ts, checker) {
                 (ts.isBlock(ifStmt.thenStatement) && ifStmt.thenStatement.statements.includes(curr)) ||
                 isNodeDescendantOf(curr, ifStmt.thenStatement)) {
                 const fact = parseGuardedLengthCondition(ifStmt.expression, arrayTarget, ts, checker);
-                if (fact) {
-                    const maxAllowed = fact.exactLength ?? fact.minLength;
-                    if (k < maxAllowed) {
-                        if (!hasMutationBeforeNode(ifStmt.thenStatement, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
-                            return {
-                                isGuarded: true,
-                                evidence: `Enclosing guard '${ifStmt.expression.getText()}' proves '${arrayTarget.text}' has length ${fact.exactLength !== undefined ? `=== ${fact.exactLength}` : `>= ${fact.minLength}`}, establishing index ${k} is in-bounds.`,
-                            };
-                        }
+                if (fact && checkFactSatisfiesBound(fact)) {
+                    if (!hasMutationBeforeNode(ifStmt.thenStatement, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
+                        return {
+                            isGuarded: true,
+                            evidence: formatEvidence("Enclosing guard", ifStmt.expression.getText(), fact),
+                        };
                     }
                 }
             }
@@ -585,15 +667,12 @@ function isFixedLengthGuardedIndex(node, operand, ts, checker) {
                     (ts.isBlock(ifStmt.elseStatement) && ifStmt.elseStatement.statements.includes(curr)) ||
                     isNodeDescendantOf(curr, ifStmt.elseStatement))) {
                 const fact = parseExitGuardedLengthCondition(ifStmt.expression, arrayTarget, ts, checker);
-                if (fact) {
-                    const maxAllowed = fact.exactLength ?? fact.minLength;
-                    if (k < maxAllowed) {
-                        if (!hasMutationBeforeNode(ifStmt.elseStatement, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
-                            return {
-                                isGuarded: true,
-                                evidence: `Enclosing guard 'else' of '${ifStmt.expression.getText()}' proves '${arrayTarget.text}' has length ${fact.exactLength !== undefined ? `=== ${fact.exactLength}` : `>= ${fact.minLength}`}, establishing index ${k} is in-bounds.`,
-                            };
-                        }
+                if (fact && checkFactSatisfiesBound(fact)) {
+                    if (!hasMutationBeforeNode(ifStmt.elseStatement, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
+                        return {
+                            isGuarded: true,
+                            evidence: formatEvidence("Else branch of guard", ifStmt.expression.getText(), fact),
+                        };
                     }
                 }
             }
@@ -603,15 +682,12 @@ function isFixedLengthGuardedIndex(node, operand, ts, checker) {
             curr.parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken &&
             (curr.parent.right === curr || isNodeDescendantOf(curr, curr.parent.right))) {
             const fact = parseGuardedLengthCondition(curr.parent.left, arrayTarget, ts, checker);
-            if (fact) {
-                const maxAllowed = fact.exactLength ?? fact.minLength;
-                if (k < maxAllowed) {
-                    if (!hasMutationBeforeNode(curr.parent.right, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
-                        return {
-                            isGuarded: true,
-                            evidence: `Logical AND guard '${curr.parent.left.getText()}' proves '${arrayTarget.text}' has length ${fact.exactLength !== undefined ? `=== ${fact.exactLength}` : `>= ${fact.minLength}`}, establishing index ${k} is in-bounds.`,
-                        };
-                    }
+            if (fact && checkFactSatisfiesBound(fact)) {
+                if (!hasMutationBeforeNode(curr.parent.right, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
+                    return {
+                        isGuarded: true,
+                        evidence: formatEvidence("Logical AND guard", curr.parent.left.getText(), fact),
+                    };
                 }
             }
         }
@@ -620,62 +696,60 @@ function isFixedLengthGuardedIndex(node, operand, ts, checker) {
             const condExpr = curr.parent;
             if (condExpr.whenTrue === curr || isNodeDescendantOf(curr, condExpr.whenTrue)) {
                 const fact = parseGuardedLengthCondition(condExpr.condition, arrayTarget, ts, checker);
-                if (fact) {
-                    const maxAllowed = fact.exactLength ?? fact.minLength;
-                    if (k < maxAllowed) {
-                        if (!hasMutationBeforeNode(condExpr.whenTrue, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
-                            return {
-                                isGuarded: true,
-                                evidence: `Ternary guard '${condExpr.condition.getText()}' proves '${arrayTarget.text}' has length ${fact.exactLength !== undefined ? `=== ${fact.exactLength}` : `>= ${fact.minLength}`}, establishing index ${k} is in-bounds.`,
-                            };
-                        }
+                if (fact && checkFactSatisfiesBound(fact)) {
+                    if (!hasMutationBeforeNode(condExpr.whenTrue, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
+                        return {
+                            isGuarded: true,
+                            evidence: formatEvidence("Ternary guard", condExpr.condition.getText(), fact),
+                        };
                     }
                 }
             }
             else if (condExpr.whenFalse === curr || isNodeDescendantOf(curr, condExpr.whenFalse)) {
                 const fact = parseExitGuardedLengthCondition(condExpr.condition, arrayTarget, ts, checker);
-                if (fact) {
-                    const maxAllowed = fact.exactLength ?? fact.minLength;
-                    if (k < maxAllowed) {
-                        if (!hasMutationBeforeNode(condExpr.whenFalse, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
-                            return {
-                                isGuarded: true,
-                                evidence: `Ternary false branch of '${condExpr.condition.getText()}' proves '${arrayTarget.text}' has length ${fact.exactLength !== undefined ? `=== ${fact.exactLength}` : `>= ${fact.minLength}`}, establishing index ${k} is in-bounds.`,
-                            };
-                        }
+                if (fact && checkFactSatisfiesBound(fact)) {
+                    if (!hasMutationBeforeNode(condExpr.whenFalse, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
+                        return {
+                            isGuarded: true,
+                            evidence: formatEvidence("Ternary false branch of", condExpr.condition.getText(), fact),
+                        };
                     }
                 }
             }
         }
         curr = curr.parent;
     }
-    // 2. Check dominating early-exit guards in prior sibling statements
-    let stmt = node;
-    while (stmt.parent &&
-        !ts.isBlock(stmt.parent) &&
-        !ts.isSourceFile(stmt.parent) &&
-        !ts.isCaseClause(stmt.parent) &&
-        !ts.isDefaultClause(stmt.parent)) {
-        stmt = stmt.parent;
-    }
-    const container = stmt.parent;
-    if (container &&
-        (ts.isBlock(container) ||
+    // 2. Check dominating early-exit guards in prior sibling statements and ancestor blocks
+    let childBlockNode = node;
+    while (childBlockNode.parent) {
+        const container = childBlockNode.parent;
+        if (ts.isFunctionDeclaration(container) ||
+            ts.isFunctionExpression(container) ||
+            ts.isArrowFunction(container) ||
+            ts.isMethodDeclaration(container) ||
+            ts.isConstructorDeclaration(container) ||
+            ts.isGetAccessor(container) ||
+            ts.isSetAccessor(container)) {
+            break;
+        }
+        if (ts.isBlock(container) ||
             ts.isSourceFile(container) ||
             ts.isCaseClause(container) ||
-            ts.isDefaultClause(container))) {
-        const statements = container.statements;
-        const targetIndex = statements.indexOf(stmt);
-        if (targetIndex > 0) {
-            for (let i = 0; i < targetIndex; i++) {
-                const prior = statements[i];
-                if (!prior)
-                    continue;
-                if (ts.isIfStatement(prior) && statementExitsControlFlow(prior.thenStatement, ts)) {
-                    const fact = parseExitGuardedLengthCondition(prior.expression, arrayTarget, ts, checker);
-                    if (fact) {
-                        const maxAllowed = fact.exactLength ?? fact.minLength;
-                        if (k < maxAllowed) {
+            ts.isDefaultClause(container)) {
+            let stmtInContainer = childBlockNode;
+            while (stmtInContainer.parent && stmtInContainer.parent !== container) {
+                stmtInContainer = stmtInContainer.parent;
+            }
+            const statements = container.statements;
+            const targetIndex = statements.indexOf(stmtInContainer);
+            if (targetIndex > 0) {
+                for (let i = 0; i < targetIndex; i++) {
+                    const prior = statements[i];
+                    if (!prior)
+                        continue;
+                    if (ts.isIfStatement(prior) && statementExitsControlFlow(prior.thenStatement, ts)) {
+                        const fact = parseExitGuardedLengthCondition(prior.expression, arrayTarget, ts, checker);
+                        if (fact && checkFactSatisfiesBound(fact)) {
                             let hasInterveningMutation = false;
                             for (let m = i + 1; m < targetIndex; m++) {
                                 const s = statements[m];
@@ -685,17 +759,37 @@ function isFixedLengthGuardedIndex(node, operand, ts, checker) {
                                 }
                             }
                             if (!hasInterveningMutation &&
-                                !hasMutationBeforeNode(stmt, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
-                                return {
-                                    isGuarded: true,
-                                    evidence: `Dominating guard '${prior.expression.getText()}' proves '${arrayTarget.text}' has length ${fact.exactLength !== undefined ? `=== ${fact.exactLength}` : `>= ${fact.minLength}`}, establishing index ${k} is in-bounds.`,
-                                };
+                                !hasMutationBeforeNode(stmtInContainer, node, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
+                                // Loop check: if node is inside a loop under container, verify loop body has no mutations
+                                let loopMutated = false;
+                                let loopCheck = node;
+                                while (loopCheck.parent && loopCheck.parent !== container) {
+                                    const lp = loopCheck.parent;
+                                    if (ts.isForStatement(lp) ||
+                                        ts.isForInStatement(lp) ||
+                                        ts.isForOfStatement(lp) ||
+                                        ts.isWhileStatement(lp) ||
+                                        ts.isDoStatement(lp)) {
+                                        if (hasArrayMutation(lp.statement, arrayTarget.text, ts, checker, arrayTarget.symbol)) {
+                                            loopMutated = true;
+                                            break;
+                                        }
+                                    }
+                                    loopCheck = lp;
+                                }
+                                if (!loopMutated) {
+                                    return {
+                                        isGuarded: true,
+                                        evidence: formatEvidence("Dominating guard", prior.expression.getText(), fact),
+                                    };
+                                }
                             }
                         }
                     }
                 }
             }
         }
+        childBlockNode = container;
     }
     return undefined;
 }