chore(observability-map): remove dead scanner surface

EntryPoint.calleeTexts, catchRethrows, catchBranches, catchesNarrowly and
LogCall.hasObjectArgument were written by the scanner and read by nothing:
errorClassification reads the per-clause CatchEvidence fields, sensitivity
and triviality read calleeNames, not calleeTexts. Removed the fields, their
derivations, and the tests that asserted them directly; reworded doc
comments that referenced them.

Author: 1stvamp

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

@@ -69,9 +69,10 @@ function calleeName(expr: ts.Expression): string | null {
 }
 
 /**
- * Callee as recorded in `calleeTexts`: the whole path, `prisma.organization.findFirst` rather than
- * `findFirst`. Null when the path runs through something with no name of its own, e.g.
- * `new PromptService().createOverride`, where the caller falls back to the bare name.
+ * The whole callee path of a call, `prisma.organization.findFirst` rather than `findFirst`. Used to
+ * match a call against `LOGGER_CALLEE` and `PARSE_CALLEE`. Null when the path runs through something
+ * with no name of its own, e.g. `new PromptService().createOverride`, where the caller falls back to
+ * the bare name.
  */
 function calleeText(expr: ts.Expression): string | null {
   const target = unwrap(expr);
@@ -92,7 +93,7 @@ function calleeText(expr: ts.Expression): string | null {
 const LOGGER_CALLEE = /(^|\.)(logger|log)\.[A-Za-z_$][\w$]*$/;
 
 /** Property names on the first object-literal argument, e.g. `{ environmentId, error }`. */
-function objectArgumentFields(call: ts.CallExpression): { found: boolean; fields: string[] } {
+function objectArgumentFields(call: ts.CallExpression): string[] {
   for (const arg of call.arguments) {
     const target = unwrap(arg);
     if (!ts.isObjectLiteralExpression(target)) continue;
@@ -101,9 +102,9 @@ function objectArgumentFields(call: ts.CallExpression): { found: boolean; fields
       const name = propertyName(property);
       if (name) fields.push(name);
     }
-    return { found: true, fields };
+    return fields;
   }
-  return { found: false, fields: [] };
+  return [];
 }
 
 /**
@@ -128,8 +129,8 @@ const PARSE_CALLEE = /(^|\.)(parse|safeParse|parseAsync|safeParseAsync|decode)$|
 const PARSE_CONSTRUCTORS = new Set(["URL", "URLSearchParams", "RegExp"]);
 
 /**
- * Whether the guarded region parses something. A `new URL(x)` counts, and has to be read here
- * because constructors are absent from `calleeTexts`.
+ * Whether the guarded region parses something. A `new URL(x)` counts, and has to be read here as a
+ * `ts.isNewExpression`, because the call-callee scan that builds `calleeNames` never sees it.
  */
 function guardsParse(tryBlock: ts.Block): boolean {
   let found = false;
@@ -518,7 +519,6 @@ export function scanFile(fileName: string, source: string): EntryPoint | null {
   let hasTryCatch = false;
   const catches: CatchEvidence[] = [];
   const calleeNames: string[] = [];
-  const calleeTexts: string[] = [];
   const logCalls: LogCall[] = [];
 
   const localFunctions = collectLocalFunctions(sf);
@@ -558,14 +558,11 @@ export function scanFile(fileName: string, source: string): EntryPoint | null {
         if (cn) {
           const text = calleeText(node.expression) ?? cn;
           calleeNames.push(cn);
-          calleeTexts.push(text);
 
           if (LOGGER_CALLEE.test(text)) {
-            const argument = objectArgumentFields(node);
             logCalls.push({
               callee: text,
-              hasObjectArgument: argument.found,
-              fields: argument.fields,
+              fields: objectArgumentFields(node),
               inCatch,
             });
           }
@@ -599,13 +596,8 @@ export function scanFile(fileName: string, source: string): EntryPoint | null {
     actionInitializerCallee: target.actionInitializerCallee,
     importedNames,
     calleeNames,
-    calleeTexts,
     hasTryCatch,
     catches,
-    // Kept as aggregates of `catches` so the checks can migrate one at a time.
-    catchRethrows: catches.some((c) => c.rethrows),
-    catchBranches: catches.some((c) => c.branches),
-    catchesNarrowly: catches.length > 0 && catches.every((c) => c.narrow),
     logCalls,
     statementCount,
   };

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

@@ -17,17 +17,19 @@ export type CatchEvidence = {
   /** The clause contains a `throw`. */
   rethrows: boolean;
   /**
-   * The clause picks what to do from what it caught: an `if`, a `switch`, or a conditional that is
-   * the whole `return`/`throw`. An `instanceof` used only to word a message,
-   * `json({ error: e instanceof Error ? e.message : String(e) })`, does not count: every error
-   * still leaves by the same path.
+   * The clause picks what to do from what it caught: an `if` or `switch` whose condition references
+   * the caught error binding, or a conditional that is the whole `return`/`throw`. `if (retries > 0)`
+   * does not count, and a bindingless `catch { ... }` cannot count at all. An `instanceof` used only
+   * to word a message, `json({ error: e instanceof Error ? e.message : String(e) })`, does not
+   * count either: every error still leaves by the same path.
    */
   branches: boolean;
   /**
    * The guarded region parses something: `JSON.parse`, `request.json()`, a zod `parse`/`safeParse`,
    * a `decode`, or a `new URL`/`URLSearchParams`/`RegExp`. Those three constructors are read here
-   * because constructors never appear in `calleeTexts`; other constructors do not count, or every
-   * `new SomePresenter()` in a try would excuse its catch.
+   * because a `new` expression is not a call, so the call-callee scan that feeds this check never
+   * sees them; other constructors do not count, or every `new SomePresenter()` in a try would excuse
+   * its catch.
    */
   guardsParse: boolean;
   /** Statements in the guarded try block, counted as `statementCount` counts them. */
@@ -38,9 +40,7 @@ export type CatchEvidence = {
 export type LogCall = {
   /** Full callee path, e.g. `logger.error`. */
   callee: string;
-  /** Whether an object literal was passed as an argument. */
-  hasObjectArgument: boolean;
-  /** Property names on that object literal, e.g. `["environmentId", "error"]`. */
+  /** Property names on the first object-literal argument, e.g. `["environmentId", "error"]`. */
   fields: string[];
   /** Whether the call sits inside a catch clause, i.e. on the failure path. */
   inCatch: boolean;
@@ -58,12 +58,6 @@ export type EntryPoint = {
   importedNames: string[];
   /** Names of functions called inside the loader/action bodies, or in a same-file helper they call. */
   calleeNames: string[];
-  /**
-   * The same calls as `calleeNames`, same order and same length, but as the whole callee path:
-   * `prisma.organization.findFirst` where `calleeNames` has `findFirst`. A path that runs through
-   * something unnameable (`new PromptService().createOverride`) falls back to the bare name.
-   */
-  calleeTexts: string[];
   /**
    * Whether a `try` appears in the loader/action bodies, or in a same-file helper they call. Note
    * that this says a `try`, not a catch: a `try`/`finally` sets it while `catches` stays empty and
@@ -72,26 +66,6 @@ export type EntryPoint = {
   hasTryCatch: boolean;
   /** One entry per catch clause in those bodies, in source order. */
   catches: CatchEvidence[];
-  /**
-   * Whether any catch clause in those bodies contains a `throw`. A catch that rethrows has decided
-   * the error is not its to answer, which is a different act from swallowing it. Aggregate of
-   * `catches`, kept so existing consumers keep working.
-   */
-  catchRethrows: boolean;
-  /**
-   * Whether any catch clause in those bodies branches on the error: an `if`, a `switch`, or an
-   * `instanceof`. With `catchRethrows` both false while `hasTryCatch` is true, every catch in the
-   * entry point takes one path out regardless of what was thrown.
-   */
-  catchBranches: boolean;
-  /**
-   * Whether every catch in those bodies guards a specific operation rather than the handler: the
-   * entry point has at least one catch clause, and no try block with a catch holds more than two
-   * statements. The `try { body = await request.json() } catch { 400 }` idiom, which takes one path
-   * out and is still deliberate. False when any catch wraps the bulk of a body, and false when
-   * there is no catch clause at all.
-   */
-  catchesNarrowly: boolean;
   /** Calls to a `logger.*` or `log.*` callee in those bodies, in source order. */
   logCalls: LogCall[];
   /**

internal-packages/observability-map/test/checks.test.ts

@@ -565,9 +565,10 @@ describe("request-context", () => {
     expect(r.status).toBe("fail");
   });
 
-  // Was a known false positive: `new URL()` is a constructor, so the parse was invisible while the
-  // evidence came from `calleeTexts`. `CatchEvidence.guardsParse` covers constructors, so the guard
-  // is legible now and the route is no longer judged as though it kept its failures.
+  // Was a known false positive: `new URL()` is a constructor, so the parse was invisible to the
+  // call-callee scan the evidence used to come from. `CatchEvidence.guardsParse` covers
+  // constructors, so the guard is legible now and the route is no longer judged as though it kept
+  // its failures.
   it("fails a route whose only catch guards a constructor parse", () => {
     const r = run(
       "request-context",