fix(observability-map): credit a thrown ternary that classifies the error

catch (e) { throw e instanceof Response ? e : new ServerError(e); } read as
inert, while the same clause written with return passed. The walk set rethrows
and cut the path before the shared branch check ran, so the throw arm of that
condition was unreachable and a thrown conditional was never offered to
selectsAnErrorPath. That contradicted the CatchEvidence.branches contract in
types.ts, which names return and throw alike.

The check now runs in the throw arm, before the path is cut, through the same
selectsAnErrorPath predicate the return path uses. The same-arms rule comes
with it, so throw e instanceof Error ? e : e is refused for the reason
return x ? A : A is, and the asymmetry closes without a new laundering surface.
The shared check below narrows to return statements, since the throw case is
handled above.

wrap-body-in-same-arms-throw-ternary is the tree-scale guard, the A/B partner
of wrap-body-in-rethrow with the ternary as the only difference. Weakening the
arms test takes the tree from 19 to 44 and raises 224 routes, and the entry
fails; with the rule in place it reaches 391 files and 924 sites, raises none.

No published figure moves. The whole JSON report over apps/webapp/app/routes is
byte-identical before and after, global 19, measured 412, per-entry diffs 0,
because no route in the tree writes a thrown ternary.

Author: 1stvamp

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

@@ -502,6 +502,18 @@ export const MUTATIONS: Mutation[] = [
     "try {",
     "} catch (obsMapMutationError) { throw obsMapMutationError; }"
   ),
+  // The A/B partner of the entry above: the only difference is the ternary. `error-classification`
+  // asks whether ANY reachable catch decides, so one deciding clause bought at zero cost would take
+  // every route in the tree to a pass. That is what the same-arms rule in `selectsAnErrorPath`
+  // refuses, and this is the tree-scale proof of it on the throw path, which was untested while
+  // the throw path could not credit a ternary at all.
+  wrapEveryBody(
+    "wrap-body-in-same-arms-throw-ternary",
+    "wrap every route body in try { ... } catch (e) { throw e instanceof Error ? e : e }",
+    "try {",
+    "} catch (obsMapMutationError) { throw obsMapMutationError instanceof Error " +
+      "? obsMapMutationError : obsMapMutationError; }"
+  ),
   wrapEveryBody(
     "wrap-body-in-trace",
     'wrap every route body in trace("x", async () => { ... })',
@@ -869,6 +881,7 @@ export const ADDITIVE_IDS = [
   "dead-throw-after-switch",
   "dead-throw-after-try-finally",
   "wrap-body-in-rethrow",
+  "wrap-body-in-same-arms-throw-ternary",
   "empty-instanceof-if",
   "registered-throw",
   "fake-require-guard",

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

@@ -1974,6 +1974,58 @@ describe("a ternary on the error has to send its arms somewhere different", () =
     expect(ep!.catches[0]!.branches).toBe(true);
   });
 
+  // S6. The same three cases on the throw path, which read none of them. The throw arm of the
+  // shared branch check was unreachable, because the walk sets `rethrows` and cuts the path first,
+  // so a thrown ternary was never offered to `selectsAnErrorPath` and every one of these clauses
+  // read as inert. Reading it in the throw arm, before the path is cut, uses the same predicate,
+  // so the arm test arrives with it. `wrap-body-in-same-arms-throw-ternary` is the tree-scale
+  // version of the refusal.
+  const throwing = (value: string) => `
+    export async function loader() {
+      try {
+        return await prisma.thing.findMany();
+      } catch (error) {
+        throw ${value};
+      }
+    }
+  `;
+
+  it("credits a thrown ternary whose arms go somewhere different", () => {
+    const ep = scanFile("x.ts", throwing("error instanceof Response ? error : new Error('x')"));
+    expect(ep!.catches[0]!.branches).toBe(true);
+  });
+
+  it("does not credit a thrown ternary whose arms are identical", () => {
+    const ep = scanFile("x.ts", throwing("error instanceof Error ? error : error"));
+    expect(ep!.catches[0]!.branches).toBe(false);
+  });
+
+  it("does not credit a thrown ternary whose arms differ only in parentheses", () => {
+    const ep = scanFile("x.ts", throwing("error instanceof Error ? ((error)) : (error)"));
+    expect(ep!.catches[0]!.branches).toBe(false);
+  });
+
+  it("does not credit a thrown ternary that never reads the caught binding", () => {
+    const ep = scanFile("x.ts", throwing("other instanceof Error ? error : new Error('x')"));
+    expect(ep!.catches[0]!.branches).toBe(false);
+  });
+
+  // The throw still cuts the path, so a decision written after it is dead and stays uncredited.
+  it("does not credit a thrown ternary written after the clause already threw", () => {
+    const ep = scanFile(
+      "x.ts",
+      `export async function loader() {
+        try {
+          return await prisma.thing.findMany();
+        } catch (error) {
+          throw error;
+          throw error instanceof Response ? error : new Error('x');
+        }
+      }`
+    );
+    expect(ep!.catches[0]!.branches).toBe(false);
+  });
+
   // The same comparison on the `if` path, which had the exit test but not the arm test.
   it("does not credit an if/else whose two arms are identical", () => {
     const ep = scanFile(

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

@@ -455,7 +455,9 @@ function normalizedText(node: ts.Node): string {
  * The two arms also have to differ, which is the same requirement `selectsADistinctPath` makes of
  * an `if`. `return e instanceof Error ? (X) : (X)` is a test whose outcome is the same either way,
  * and it was worth 50 points a route; `same-arms-ternary` in the mutation corpus is the tree-scale
- * version, and `scan.test.ts` has the unit case. Parentheses and whitespace are stripped
+ * version, and `scan.test.ts` has the unit case. The throw path is held to the same rule by
+ * `wrap-body-in-same-arms-throw-ternary`, which would take every route in the tree to a pass if it
+ * were not. Parentheses and whitespace are stripped
  * before the comparison, so the shape has to differ in something a reader would call a difference.
  * The residual both branch tests share is stated once, on `selectsADistinctPath`.
  */
@@ -628,6 +630,18 @@ function catchClauseEvidence(clause: ts.CatchClause): {
     for (const statement of reachableStatements(statements)) {
       if (ts.isThrowStatement(statement)) {
         rethrows = true;
+        // Read the branch check here, before the path is cut. A thrown ternary picks WHICH error
+        // leaves, which is a classification, and reading it only at the shared check below meant
+        // the throw arm of that condition was unreachable: this arm always continued first. So
+        // `throw e instanceof Response ? e : new ServerError(e)` read as inert while the same
+        // clause written with `return` passed. `selectsAnErrorPath` is the same predicate either
+        // way, so the same-arms rule applies and `throw e instanceof Error ? e : e;` is refused.
+        if (bindingName !== null && !shadowed && !exited && statement.expression !== undefined) {
+          const thrown = unwrap(statement.expression);
+          if (ts.isConditionalExpression(thrown) && selectsAnErrorPath(thrown, bindingName)) {
+            branches = true;
+          }
+        }
         exited = true;
         continue;
       }
@@ -656,10 +670,7 @@ function catchClauseEvidence(clause: ts.CatchClause): {
           selectsADistinctPath(statement)
         ) {
           branches = true;
-        } else if (
-          (ts.isReturnStatement(statement) || ts.isThrowStatement(statement)) &&
-          statement.expression !== undefined
-        ) {
+        } else if (ts.isReturnStatement(statement) && statement.expression !== undefined) {
           const value = unwrap(statement.expression);
           if (ts.isConditionalExpression(value) && selectsAnErrorPath(value, bindingName)) {
             branches = true;