fix(observability-map): stop a dead statement blinding the catch walk

catchClauseEvidence raised its exited flag off containsExit, which is true
of a provably dead statement itself, so prepending if (false) { throw e; }
to a deciding clause blinded the walk to the real classification below it:
78 real routes turned pass into a swallow verdict, the same set for all
eleven dead-* corpus spellings. The returns veto had the same defect via
containsReturn, regressing 11 rethrow-only routes from n/a to fail.

The walk's four evidence reads now go through a liveness fold
(literalTruth folding literal guards only) so a dead branch contributes
nothing, while an undecidable guard keeps the containment answer and
refusal stays intact. Real-tree report is byte-identical (global 19,
measured 412); the twelve dead-prepend corpus entries measure falls 0
rises 0 in the mirror direction. New corpus entry dead-if-false-return
covers the returns half at tree scale. containsReturn is deleted: its
only read site is now the live fold.

Author: 1stvamp

internal-packages/observability-map/src/mutations.ts

@@ -665,6 +665,17 @@ export const MUTATIONS: Mutation[] = [
     "splice if (1 === 2) { throw e; } into every catch",
     (e) => `if (1 === 2) { throw ${e}; }`
   ),
+  // The returns half of the dead-prepend family. The eleven entries above put a dead THROW in;
+  // this one puts a dead RETURN in, which used to veto `rethrows` through the containment read
+  // and turn a rethrow-only clause into a swallow verdict on 11 real routes. Same blinding class
+  // as `dead-if-false`, so like that entry it is not additive: it fakes no signal, it used to
+  // destroy real signal.
+  prependToEveryCatch(
+    "dead-if-false-return",
+    "preserving",
+    "splice if (false) { return null; } into every catch",
+    () => `if (false) { return null; }`
+  ),
   prependToEveryCatch(
     "registered-throw",
     "preserving",

internal-packages/observability-map/src/scan.test.ts

@@ -758,6 +758,113 @@ describe("scanFile: catch clause evidence", () => {
     });
   });
 
+  // The mirror of the family above. Each dead spelling earns nothing, and it must also COST
+  // nothing: `containsExit` was true of the dead statement itself, so prepending one raised the
+  // `exited` flag and blinded the walk to the real classification below it, turning a pass into a
+  // swallow verdict on 78 real routes. `containsLiveExit` folds the literal guard and sees no live
+  // exit, so the deciding statements keep their credit. The spellings are the CORPUS spellings
+  // from `dead-*` in `mutations.ts`, not the `DEAD_SHAPES` table's: that table's inner-try twin is
+  // `try { doThing(); } catch { throw e; }`, which is NOT provably dead (`doThing` may throw and
+  // the rethrow then runs), so conservatively raising the flag after it is correct and it gets no
+  // twin here.
+  describe("dead and deferred code prepended to a deciding catch does not blind it", () => {
+    const deciding = (mutation: string) => `
+      export async function loader() {
+        try {
+          return await prisma.thing.findMany();
+        } catch (e) {
+          ${mutation}
+          if (e instanceof Error) { return new Response(null, { status: 400 }); }
+          return new Response(null, { status: 500 });
+        }
+      }
+    `;
+
+    it("decides as a baseline with no mutation", () => {
+      const ep = scanFile("x.ts", deciding(""));
+      expect(ep!.catches[0]!.branches).toBe(true);
+    });
+
+    const DEAD_PREPENDS: Array<[string, string]> = [
+      ["if (false)", "if (false) { throw e; }"],
+      ["while (false)", "while (false) { throw e; }"],
+      ["for (;false;)", "for (;false;) { throw e; }"],
+      ["if (true) else", "if (true) { 0; } else { throw e; }"],
+      ["switch with no matching case", "switch (1) { case 2: throw e; }"],
+      ["an inner try over a literal", "try { 0; } catch { throw e; }"],
+      ["for...of an empty array", "for (const obsMapItem of []) { throw e; }"],
+      ["for...in an empty object", "for (const obsMapKey in {}) { throw e; }"],
+      ["if on an empty string", 'if ("") { throw e; }'],
+      ["if on a negated literal", "if (!true) { throw e; }"],
+      ["if on a constant comparison", "if (1 === 2) { throw e; }"],
+    ];
+
+    for (const [label, shape] of DEAD_PREPENDS) {
+      it(`keeps branches true past a dead throw inside ${label}`, () => {
+        const ep = scanFile("x.ts", deciding(shape));
+        expect(ep!.catches[0]!.branches).toBe(true);
+      });
+    }
+
+    // The composed shape: the dead if wrapped in a bare block, which the walk enters. The block's
+    // own live-exit read has to fold too, or entering it re-raises the flag the fold lowered.
+    it("keeps branches true past a dead throw in a block around an if (false)", () => {
+      const ep = scanFile("x.ts", deciding("{ if (false) { throw e; } }"));
+      expect(ep!.catches[0]!.branches).toBe(true);
+    });
+
+    // The returns half. A dead `return null;` must not veto the rethrow: `containsReturn` saw the
+    // return token inside `if (false)` and turned a rethrow-only clause into a swallow verdict,
+    // which regressed 11 real routes from not-applicable to fail. `dead-if-false-return` in the
+    // mutation corpus is the tree-scale version.
+    it("still sets rethrows past a dead return in an if (false) arm", () => {
+      const ep = scanFile(
+        "x.ts",
+        `export async function loader() {
+           try { return await prisma.thing.findMany(); }
+           catch (e) {
+             if (false) { return null; }
+             throw e;
+           }
+         }`
+      );
+      expect(ep!.catches[0]!.rethrows).toBe(true);
+    });
+
+    // Negative controls: the fold only withholds blindness, it must never withhold refusal.
+    // An always-true guard really can run its throw, so the error test after it stays dead.
+    it("still refuses an error test after an always-true spelling that throws", () => {
+      const ep = scanFile(
+        "x.ts",
+        `export async function loader() {
+           try { return await prisma.thing.findMany(); }
+           catch (e) {
+             if (!false) { throw e; }
+             if (e instanceof Error) { return new Response(null, { status: 400 }); }
+           }
+         }`
+      );
+      expect(ep!.catches[0]!.branches).toBe(false);
+    });
+
+    // The fall-through slice: `case 1` matches and runs on into `case 2`, so the return is live
+    // and vetoes the rethrow. Misreading the slice as dead would blind the returns veto, which is
+    // the direction that hands out credit.
+    it("reads a switch fall-through onto a live return as live", () => {
+      const ep = scanFile(
+        "x.ts",
+        `export async function loader() {
+           try { return await prisma.thing.findMany(); }
+           catch (e) {
+             switch (1) { case 1: 0; case 2: return null; }
+             throw e;
+           }
+         }`
+      );
+      expect(ep!.catches[0]!.rethrows).toBe(false);
+    });
+  });
+
   // S1. The other end of the same problem. `reachableStatements` used to cut the statement list
   // only on a BARE `return`/`throw`, while the walk descended into blocks and `do` bodies, so a
   // `throw e;` written after a nested construct that had already returned was still read as the
@@ -803,8 +910,12 @@ describe("scanFile: catch clause evidence", () => {
     //
     // This asks a weaker question than `definitelyExits` does, and on purpose: "could this have
     // exited", not "must it have". That is why `if (true)`, a labelled block, a `for...of` and a
-    // `while` are all on the list even though none of them is guaranteed to run its body. Nothing
-    // here evaluates a condition, and none of these needs one evaluated.
+    // `while` are all on the list even though none of them is guaranteed to run its body. The flag
+    // is read through `containsLiveExit`, which folds LITERAL guards only, so every wrapper here
+    // still counts: `if (true)` descends its then-arm and finds the return, and a loop guarded by
+    // an identifier keeps the plain containment answer. What the fold withholds is the provably
+    // dead statement raising the flag itself, which is the twin family in `dead and deferred code
+    // prepended to a deciding catch does not blind it`.
     //
     // The ordering is the whole trick and it is easy to get backwards. The flag is raised at the
     // END of each statement, after that statement's own branch check. Raising it first makes every

internal-packages/observability-map/src/scan.ts

@@ -561,15 +561,6 @@ function reachableStatements(statements: readonly ts.Statement[]): readonly ts.S
   return index === -1 ? statements : statements.slice(0, index + 1);
 }
 
-/** Whether the clause returns anywhere at all, nested functions excluded. A clause with a `return`
- * on any path has an exit that is not the throw, so the error does not leave it the way it arrived.
- */
-function containsReturn(node: ts.Node): boolean {
-  if (ts.isFunctionLike(node)) return false;
-  if (ts.isReturnStatement(node)) return true;
-  return ts.forEachChild(node, containsReturn) === true;
-}
-
 /** Whether the tree rooted at `node` contains a `return` or a `throw` of its own, not counting one
  * inside a nested function. What separates an arm that takes the error somewhere from an arm that
  * runs and falls back into the clause's single common exit. */
@@ -579,6 +570,138 @@ function containsExit(node: ts.Node): boolean {
   return ts.forEachChild(node, containsExit) === true;
 }
 
+/**
+ * Literal truthiness of a guard expression: true, false, or null when not decidable from the
+ * token alone. Only literal tokens fold; an identifier, call, bigint, `&&`, `||` or a template
+ * literal with substitutions is always null, so a live guard can never be read as dead. The
+ * always-true side is pinned by `still refuses an error test after an always-true spelling that
+ * throws` and the fall-through slice by `reads a switch fall-through onto a live return as live`.
+ */
+function literalTruth(expr: ts.Expression): boolean | null {
+  const target = unwrap(expr);
+  if (target.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (target.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (target.kind === ts.SyntaxKind.NullKeyword) return false;
+  if (ts.isStringLiteral(target) || ts.isNoSubstitutionTemplateLiteral(target)) {
+    return target.text !== "";
+  }
+  if (ts.isNumericLiteral(target)) return Number(target.text) !== 0;
+  if (ts.isPrefixUnaryExpression(target) && target.operator === ts.SyntaxKind.ExclamationToken) {
+    const inner = literalTruth(target.operand);
+    return inner === null ? null : !inner;
+  }
+  if (ts.isBinaryExpression(target)) {
+    const op = target.operatorToken.kind;
+    if (
+      op === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+      op === ts.SyntaxKind.ExclamationEqualsEqualsToken
+    ) {
+      const left = literalValue(target.left);
+      const right = literalValue(target.right);
+      if (left === undefined || right === undefined) return null;
+      const equal = left === right;
+      return op === ts.SyntaxKind.EqualsEqualsEqualsToken ? equal : !equal;
+    }
+  }
+  return null;
+}
+
+/** The value of a literal token, or undefined when the expression is not a bare literal. */
+function literalValue(expr: ts.Expression): string | number | boolean | null | undefined {
+  const target = unwrap(expr);
+  if (target.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (target.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (target.kind === ts.SyntaxKind.NullKeyword) return null;
+  if (ts.isStringLiteral(target) || ts.isNoSubstitutionTemplateLiteral(target)) return target.text;
+  if (ts.isNumericLiteral(target)) return Number(target.text);
+  return undefined;
+}
+
+/** Whether a try block could throw at all: false only when every statement is an expression
+ * statement over a bare literal, the one shape that provably cannot raise. */
+function tryBlockMayThrow(block: ts.Block): boolean {
+  return !block.statements.every(
+    (s) => ts.isExpressionStatement(s) && literalValue(s.expression) !== undefined
+  );
+}
+
+/**
+ * `containsExit`, minus exits that sit in a provably-untaken branch. `if (false) { throw e; }`
+ * contains an exit and can never run one; treating it as an exit is what let a dead statement
+ * blind the walk to the real classification below it, prepending one to a deciding clause turned
+ * its pass into a swallow verdict on 78 real routes. Folds literal guards only, so an unknown
+ * condition keeps the containsExit answer, which is the direction that refuses credit rather than
+ * inventing it. The mirror twins under `dead and deferred code prepended to a deciding catch does
+ * not blind it` hold the recovered half; the `BRANCH_EXITED` family holds the refusing half.
+ */
+function containsLiveWhere(root: ts.Node, hit: (n: ts.Node) => boolean): boolean {
+  const walk = (node: ts.Node): boolean => {
+    if (ts.isFunctionLike(node)) return false;
+    if (hit(node)) return true;
+    if (ts.isIfStatement(node)) {
+      const truth = literalTruth(node.expression);
+      if (truth === true) return walk(node.thenStatement);
+      if (truth === false) {
+        return node.elseStatement !== undefined && walk(node.elseStatement);
+      }
+      return (
+        walk(node.thenStatement) || (node.elseStatement !== undefined && walk(node.elseStatement))
+      );
+    }
+    if (ts.isWhileStatement(node)) {
+      if (literalTruth(node.expression) === false) return false;
+      return walk(node.statement);
+    }
+    if (ts.isForStatement(node)) {
+      if (node.condition !== undefined && literalTruth(node.condition) === false) return false;
+      return ts.forEachChild(node, walk) === true;
+    }
+    if (ts.isForOfStatement(node) || ts.isForInStatement(node)) {
+      const iterable = unwrap(node.expression);
+      const emptyArray = ts.isArrayLiteralExpression(iterable) && iterable.elements.length === 0;
+      const emptyObject =
+        ts.isForInStatement(node) &&
+        ts.isObjectLiteralExpression(iterable) &&
+        iterable.properties.length === 0;
+      if (emptyArray || emptyObject) return false;
+      return ts.forEachChild(node, walk) === true;
+    }
+    if (ts.isSwitchStatement(node)) {
+      const disc = literalValue(node.expression);
+      const clauses = node.caseBlock.clauses;
+      const allLiteral =
+        disc !== undefined &&
+        clauses.every((c) => ts.isDefaultClause(c) || literalValue(c.expression) !== undefined);
+      if (!allLiteral) return clauses.some((c) => c.statements.some(walk));
+      // Fall-through: from the first matching (or default) clause, every later clause is reachable.
+      let matched = clauses.findIndex(
+        (c) => !ts.isDefaultClause(c) && literalValue(c.expression) === disc
+      );
+      if (matched === -1) matched = clauses.findIndex(ts.isDefaultClause);
+      if (matched === -1) return false;
+      return clauses.slice(matched).some((c) => c.statements.some(walk));
+    }
+    if (ts.isTryStatement(node)) {
+      if (walk(node.tryBlock)) return true;
+      if (node.finallyBlock !== undefined && walk(node.finallyBlock)) return true;
+      if (node.catchClause !== undefined && tryBlockMayThrow(node.tryBlock)) {
+        return walk(node.catchClause.block);
+      }
+      return false;
+    }
+    return ts.forEachChild(node, walk) === true;
+  };
+  return walk(root);
+}
+
+function containsLiveExit(node: ts.Node): boolean {
+  return containsLiveWhere(node, (n) => ts.isReturnStatement(n) || ts.isThrowStatement(n));
+}
+
+function containsLiveReturn(node: ts.Node): boolean {
+  return containsLiveWhere(node, ts.isReturnStatement);
+}
+
 /**
  * Whether an `if`/`switch` sends at least one arm somewhere the others do not go, by returning or
  * throwing from inside it. `if (e instanceof Error) { }` and `if (e instanceof Error) { log(e); }`
@@ -653,6 +776,16 @@ function catchClauseEvidence(clause: ts.CatchClause): {
   // to 19. This ordering leaves the real-tree report
   // and all 240 clauses' evidence byte-identical. The tests are the cases in `dead throw written
   // after something that already exited`.
+  //
+  // Raised off `containsLiveExit`, never `containsExit`. The containment read is true of
+  // `if (false) { throw e; }` itself, so a provably dead statement raised the flag and blinded the
+  // walk to the real classification below it: prepending one to a deciding clause turned its pass
+  // into a swallow verdict on 78 real routes, the same false accusation for all eleven dead
+  // spellings. The liveness fold only ever withholds this blindness; where `literalTruth` cannot
+  // decide, the containment answer stands and refusal is intact. The recovered half is `dead and
+  // deferred code prepended to a deciding catch does not blind it`; the refusing half is the
+  // `BRANCH_EXITED` list plus `still refuses an error test after an always-true spelling that
+  // throws`.
   let exited = false;
   const bindingName = catchBindingName(clause);
 
@@ -682,21 +815,25 @@ function catchClauseEvidence(clause: ts.CatchClause): {
       }
       if (ts.isBlock(statement)) {
         walk(statement.statements);
-        if (containsExit(statement)) exited = true;
+        if (containsLiveExit(statement)) exited = true;
         continue;
       }
       // A `do` body runs before its condition is ever read, so it is on the straight-line path
       // whatever the condition says. The only loop form that is; `definitelyExits` agrees.
       if (ts.isDoStatement(statement)) {
         const body = statement.statement;
         walk(ts.isBlock(body) ? body.statements : [body]);
-        if (containsExit(statement)) exited = true;
+        if (containsLiveExit(statement)) exited = true;
         continue;
       }
       // Any other reachable statement that could return means throwing is not the only way out.
       // Read here rather than over the whole clause so a `return` the walk has already cut as dead
       // does not count, which is what a `do { throw e; } while (false); return null;` produces.
-      if (containsReturn(statement)) returns = true;
+      // The LIVE read, not the containment one: `if (false) { return null; }` holds a return that
+      // can never run, and vetoing the rethrow on it regressed a rethrow-only clause from
+      // not-applicable to fail on 11 real routes. `still sets rethrows past a dead return in an
+      // if (false) arm` is the pin.
+      if (containsLiveReturn(statement)) returns = true;
 
       if (bindingName !== null && !shadowed && !exited) {
         if (
@@ -713,7 +850,7 @@ function catchClauseEvidence(clause: ts.CatchClause): {
         }
       }
 
-      if (containsExit(statement)) exited = true;
+      if (containsLiveExit(statement)) exited = true;
     }
   };
   walk(clause.block.statements);