@lariocpt/flawless-react 0.0.0-stage → 0.3.0

package/src/analyse/extractStaticText.ts

@@ -0,0 +1,212 @@
+import ts from "typescript";
+import { findDisclosures } from "./extractDisclosures.ts";
+import { emptyEnv, initialRenderExpression, type RenderEnv, reachability } from "./renderPath.ts";
+
+const MAX_TEXTS = 8;
+const MIN_LENGTH = 2;
+/** Separators and icon glyphs — "·", "→", "—" — are decoration, not copy. */
+const PUNCTUATION_ONLY = /^[\p{P}\p{S}\s]+$/u;
+
+/**
+ * Literal copy a component renders unconditionally, ready to be asserted on
+ * with Testing-Library's getByText.
+ *
+ * Everything here exists to keep a false positive out of a generated spec: text
+ * that only sometimes renders (a ternary branch, a `.map` row, a guard path)
+ * produces a spec that fails on someone's CI for no reason, which is worse than
+ * emitting no assertion at all. Purely syntactic — no type checker.
+ */
+export function extractStaticText(bodyNode: ts.Node, env: RenderEnv = emptyEnv()): string[] {
+  // The JSX this component renders FIRST, which is not always the tail return —
+  // a guard we can decide points somewhere else entirely.
+  const initial = initialRenderExpression(bodyNode, env);
+  if (!initial) return [];
+  const root = initial.expr;
+  if (!ts.isJsxElement(root) && !ts.isJsxSelfClosingElement(root) && !ts.isJsxFragment(root)) {
+    return [];
+  }
+
+  const found: string[] = [];
+  // Disclosure content is the purest form of "text that only sometimes
+  // renders": a Radix Dialog/Menu/Popover Content subtree is not in the DOM
+  // until its trigger is clicked, and asserting on it straight after render
+  // reddens every static-content test (ConfirmModal's "Cancel"/"Confirm").
+  // The interaction tests open the disclosure themselves; static copy does
+  // not get that step, so gated subtrees are skipped outright.
+  const gated = new Set<ts.Node>();
+  for (const d of findDisclosures(root)) for (const n of d.gated) gated.add(n);
+  const visit = (n: ts.Node): void => {
+    if (gated.has(n)) return;
+    const text = literalText(n);
+    if (
+      text !== undefined &&
+      reachability(n, root, initial.scope) === "yes" &&
+      !underJsxAttribute(n, root) &&
+      isSoleRenderedChild(n)
+    ) {
+      found.push(text);
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(root);
+
+  return normalise(found);
+}
+
+/** JSX text, or an expression container holding nothing but a string literal. */
+function literalText(n: ts.Node): string | undefined {
+  if (ts.isJsxText(n)) return decodeJsxEntities(n.text);
+  if (ts.isJsxExpression(n) && n.expression) {
+    const expr = n.expression;
+    // A string literal inside an expression container is plain JS: the JSX
+    // compiler does not decode entities in it, so nothing to decode here.
+    if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
+  }
+  return undefined;
+}
+
+const JSX_ENTITIES: Record<string, string> = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\u00a0",
+  ensp: "\u2002",
+  emsp: "\u2003",
+  thinsp: "\u2009",
+  shy: "\u00ad",
+  mdash: "\u2014",
+  ndash: "\u2013",
+  hellip: "\u2026",
+  bull: "\u2022",
+  middot: "\u00b7",
+  times: "\u00d7",
+  laquo: "\u00ab",
+  raquo: "\u00bb",
+  ldquo: "\u201c",
+  rdquo: "\u201d",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+};
+
+/**
+ * JSX text carries HTML entities; the compiler decodes them before React ever
+ * sees the string. An extractor that keeps the raw `couldn&apos;t` generates a
+ * getByText("couldn&apos;t") that can never match the DOM's "couldn't".
+ * (&amp; must be replaced last, or `&amp;amp;` decodes twice.)
+ */
+function decodeJsxEntities(text: string): string {
+  if (!text.includes("&")) return text;
+  return text
+    .replace(/&#(\d+);/g, (_, code: string) => String.fromCodePoint(Number(code)))
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, hex: string) =>
+      String.fromCodePoint(Number.parseInt(hex, 16)),
+    )
+    .replace(/&([a-zA-Z]+);/g, (whole, name: string) => JSX_ENTITIES[name] ?? whole);
+}
+
+/**
+ * aria-label / title / placeholder text is not the element's text content, so
+ * getByText will never find it. reachability has nothing to say about this —
+ * the attribute IS rendered, just not as copy.
+ */
+function underJsxAttribute(node: ts.Node, root: ts.Node): boolean {
+  for (let p = node.parent; p && p !== root; p = p.parent) {
+    if (ts.isJsxAttribute(p)) return true;
+  }
+  return false;
+}
+
+/**
+ * getByText matches an element's WHOLE normalised text content, so a text node
+ * is only assertable when it is its parent element's only rendered child. In
+ * `<p>From <em>Asha</em></p>` the DOM holds no element whose text is "From" —
+ * the <p> reads "From Asha" — so asserting on "From" fails at runtime; only
+ * "Asha", the sole child of <em>, is safe to emit.
+ */
+function isSoleRenderedChild(node: ts.Node): boolean {
+  const parent = node.parent;
+  if (!parent || !ts.isJsxElement(parent)) return false;
+  const rendered = parent.children.filter((child) => !isLayoutWhitespace(child));
+  return rendered.length === 1 && rendered[0] === node;
+}
+
+/** Indentation between JSX children; React drops it, so it is not a sibling. */
+function isLayoutWhitespace(child: ts.JsxChild): boolean {
+  return ts.isJsxText(child) && child.text.trim() === "";
+}
+
+function normalise(found: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const value of found) {
+    const text = value.replace(/\s+/g, " ").trim();
+    if (text.length < MIN_LENGTH) continue;
+    if (PUNCTUATION_ONLY.test(text)) continue;
+    // A brace survived into the literal (`{"{count} items"}`), meaning the copy
+    // is a template the runtime fills in — the rendered text differs.
+    if (text.includes("{") || text.includes("}")) continue;
+    if (seen.has(text)) continue;
+    seen.add(text);
+    out.push(text);
+    if (out.length === MAX_TEXTS) break;
+  }
+  return out;
+}
+
+/**
+ * Literal copy in the branch an error boundary renders once it has caught.
+ *
+ * extractStaticText walks the INITIAL render, and an error boundary has none —
+ * its render branches on `this.state`, which is exactly why the whole component
+ * refuses. But this branch is not undecidable in the way the others are: React's
+ * own contract says getDerivedStateFromError puts the component into that state,
+ * so a spec reaches it by rendering a child that throws.
+ *
+ * The branch is the consequent of the first `if` whose condition reads
+ * `this.state`. Anything else — a guard on props, a loading flag — is not the
+ * error branch and is left alone.
+ */
+export function errorFallbackText(renderBody: ts.Node): string[] {
+  let branch: ts.Node | undefined;
+  const find = (n: ts.Node): void => {
+    if (branch) return;
+    if (ts.isIfStatement(n) && readsThisState(n.expression)) {
+      branch = n.thenStatement;
+      return;
+    }
+    ts.forEachChild(n, find);
+  };
+  find(renderBody);
+  if (!branch) return [];
+  const out: string[] = [];
+  const collect = (n: ts.Node): void => {
+    if (ts.isJsxText(n)) {
+      const t = decodeJsxEntities(n.text).trim();
+      if (t) out.push(t);
+    }
+    ts.forEachChild(n, collect);
+  };
+  collect(branch);
+  return [...new Set(out)];
+}
+
+/** `this.state` / `this.state.x` anywhere in an expression. */
+function readsThisState(expr: ts.Expression): boolean {
+  let found = false;
+  const walk = (n: ts.Node): void => {
+    if (found) return;
+    if (
+      ts.isPropertyAccessExpression(n) &&
+      n.expression.kind === ts.SyntaxKind.ThisKeyword &&
+      n.name.text === "state"
+    ) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(n, walk);
+  };
+  walk(expr);
+  return found;
+}

package/src/analyse/extractVariants.ts

@@ -0,0 +1,186 @@
+import ts from "typescript";
+import type { PropValue, SourcePosition } from "../types.ts";
+import type { ImportBinding } from "./parseFile.ts";
+import { posOf } from "./pos.ts";
+
+/**
+ * `cva()` / `tv()` variant tables read straight from the source.
+ *
+ * This is the highest-value inference for shadcn-style codebases: a component
+ * typed `VariantProps<typeof buttonVariants>` has no discoverable props at all
+ * without it, but the variant keys and their option names are sitting in a
+ * plain object literal one declaration above.
+ *
+ * Option values ARE read, but only to compare them with each other. They are
+ * Tailwind class strings, and cn()/tailwind-merge drops base classes that a
+ * later variant conflicts with — verified against the real DOM — so asserting a
+ * specific token is a false-failure waiting to happen. What IS sound is that two
+ * options whose class strings differ must render differently.
+ */
+
+export interface VariantDefinition {
+  /** Local const name: "buttonVariants". */
+  name: string;
+  factory: "cva" | "tv";
+  /** key → literal options, in source order. */
+  options: Record<string, PropValue[]>;
+  /** From defaultVariants. */
+  defaults: Record<string, PropValue>;
+  keyPositions: Record<string, SourcePosition>;
+  /** key → option → its class string, for distinctness checks only. */
+  classes: Record<string, Record<string, string>>;
+  pos: SourcePosition;
+}
+
+const FACTORY_SPECIFIER: Record<string, "cva" | "tv"> = {
+  "class-variance-authority": "cva",
+  "tailwind-variants": "tv",
+};
+
+/** Beyond these a config is machine-generated and reading it is guessing. */
+const MAX_KEYS = 12;
+const MAX_OPTIONS_PER_KEY = 24;
+
+/** Top-level cva()/tv() consts declared in `sf`, keyed by local const name. */
+export function extractVariantDefs(
+  sf: ts.SourceFile,
+  imports: Map<string, ImportBinding>,
+): Map<string, VariantDefinition> {
+  const out = new Map<string, VariantDefinition>();
+
+  for (const stmt of sf.statements) {
+    if (!ts.isVariableStatement(stmt)) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name)) continue;
+      const init = decl.initializer;
+      if (!init || !ts.isCallExpression(init)) continue;
+
+      // Provenance: the callee must actually be cva/tv from its real package.
+      // Alias-safe — `import { cva as classes }` keeps importedName "cva".
+      if (!ts.isIdentifier(init.expression)) continue;
+      const binding = imports.get(init.expression.text);
+      if (!binding) continue;
+      const factory = FACTORY_SPECIFIER[binding.specifier];
+      if (!factory) continue;
+      const importedName = binding.importedName ?? init.expression.text;
+      if (factory === "cva" && importedName !== "cva") continue;
+      if (factory === "tv" && importedName !== "tv") continue;
+
+      // cva(base, config) vs tv(config)
+      const configArg = factory === "cva" ? init.arguments[1] : init.arguments[0];
+      if (!configArg || !ts.isObjectLiteralExpression(configArg)) continue;
+
+      const def = readConfig(decl.name.text, factory, configArg, sf, posOf(decl, sf));
+      if (def) out.set(decl.name.text, def);
+    }
+  }
+  return out;
+}
+
+function readConfig(
+  name: string,
+  factory: "cva" | "tv",
+  config: ts.ObjectLiteralExpression,
+  sf: ts.SourceFile,
+  pos: SourcePosition,
+): VariantDefinition | undefined {
+  let variantsObj: ts.ObjectLiteralExpression | undefined;
+  let defaultsObj: ts.ObjectLiteralExpression | undefined;
+
+  for (const p of config.properties) {
+    if (!ts.isPropertyAssignment(p)) continue;
+    const key = propertyName(p.name);
+    // A tv() slots config changes the option-value shape and the prop
+    // semantics entirely — bail on the whole definition rather than guess.
+    if (key === "slots") return undefined;
+    if (key === "variants" && ts.isObjectLiteralExpression(p.initializer)) {
+      variantsObj = p.initializer;
+    }
+    if (key === "defaultVariants" && ts.isObjectLiteralExpression(p.initializer)) {
+      defaultsObj = p.initializer;
+    }
+  }
+  if (!variantsObj) return undefined;
+
+  const options: Record<string, PropValue[]> = {};
+  const keyPositions: Record<string, SourcePosition> = {};
+  const classes: Record<string, Record<string, string>> = {};
+
+  for (const prop of variantsObj.properties) {
+    if (Object.keys(options).length >= MAX_KEYS) break;
+    // A spread or computed key means we cannot know the full option set for
+    // that key — skip the key, keep the rest.
+    if (!ts.isPropertyAssignment(prop)) continue;
+    const key = propertyName(prop.name);
+    if (!key) continue;
+    if (!ts.isObjectLiteralExpression(prop.initializer)) continue;
+
+    const names: string[] = [];
+    const classFor: Record<string, string> = {};
+    let poisoned = false;
+    for (const opt of prop.initializer.properties) {
+      if (!ts.isPropertyAssignment(opt) && !ts.isShorthandPropertyAssignment(opt)) {
+        poisoned = true;
+        break;
+      }
+      const optName = propertyName(opt.name);
+      if (!optName) {
+        poisoned = true;
+        break;
+      }
+      names.push(optName);
+      if (ts.isPropertyAssignment(opt)) {
+        const cls = literalValue(opt.initializer);
+        if (typeof cls === "string") classFor[optName] = cls.replace(/\s+/g, " ").trim();
+      }
+    }
+    if (poisoned || names.length === 0) continue;
+    if (names.length > MAX_OPTIONS_PER_KEY) continue;
+
+    options[key] = asOptionValues(names);
+    keyPositions[key] = posOf(prop, sf);
+    classes[key] = classFor;
+  }
+
+  if (Object.keys(options).length === 0) return undefined;
+
+  const defaults: Record<string, PropValue> = {};
+  for (const p of defaultsObj?.properties ?? []) {
+    if (!ts.isPropertyAssignment(p)) continue;
+    const key = propertyName(p.name);
+    if (!key || !(key in options)) continue;
+    const v = literalValue(p.initializer);
+    if (v !== undefined) defaults[key] = v;
+  }
+
+  return { name, factory, options, defaults, keyPositions, classes, pos };
+}
+
+/** A key whose options are exactly true/false is a real boolean prop. */
+function asOptionValues(names: string[]): PropValue[] {
+  const isBoolean = names.every((n) => n === "true" || n === "false");
+  if (isBoolean) {
+    const seen = new Set(names);
+    const out: PropValue[] = [];
+    if (seen.has("true")) out.push(true);
+    if (seen.has("false")) out.push(false);
+    return out;
+  }
+  return names;
+}
+
+function propertyName(name: ts.PropertyName): string | undefined {
+  if (ts.isIdentifier(name)) return name.text;
+  // "icon-xs" and friends are string literals, and they are real option names.
+  if (ts.isStringLiteral(name)) return name.text;
+  if (ts.isNumericLiteral(name)) return name.text;
+  return undefined;
+}
+
+function literalValue(node: ts.Expression): PropValue | undefined {
+  if (ts.isStringLiteral(node)) return node.text;
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (ts.isNumericLiteral(node)) return Number(node.text);
+  return undefined;
+}

package/src/analyse/harvestApiEndpoints.ts

@@ -0,0 +1,284 @@
+import ts from "typescript";
+import type { FetchCallInfo } from "../types.ts";
+import { parseUrlArg, readMethod } from "./extractFetchCalls.ts";
+import type { ImportBinding } from "./parseFile.ts";
+import { posOf } from "./pos.ts";
+import { hookCalleeName } from "./refs.ts";
+import type { ModuleResolver } from "./resolveModule.ts";
+import { exportedFunctions } from "./serverActionReturns.ts";
+import { findExportedDecl, type SourceFileCache } from "./sourceCache.ts";
+
+/**
+ * Endpoints a component reaches through the app's OWN fetch wrapper, resolved
+ * one hop — the harvest the load task needs on React Native and could never get
+ * from `extractFetchCalls`.
+ *
+ * A React Native screen never writes `fetch()`: it calls a named api function
+ * (`listBuildings()`) imported from `lib/api`, whose body calls a module-local
+ * wrapper with a literal path (`apiFetch("/api/buildings")`), and the wrapper is
+ * the only thing that touches `fetch`. So `fetchCalls` is empty on every screen
+ * (0 endpoints on the whole dogfood app), and the endpoint URL lives two hops
+ * away: screen → api function → apiFetch.
+ *
+ * This reads exactly that chain, and no deeper:
+ *
+ *   1. the screen CALLS an imported name (imported-but-uncalled is dead, and
+ *      load-testing an endpoint the screen never hits would be a fiction);
+ *   2. the name resolves — through barrels — to an exported function whose body
+ *      calls a module-LOCAL fetch wrapper with a string-literal or template
+ *      path;
+ *   3. the wrapper is proven to be one: its single `fetch()` addresses one of
+ *      its own parameters. A function merely NAMED apiFetch is not trusted; a
+ *      helper that happens to take a string is not mistaken for the client.
+ *
+ * Anything it cannot see it drops rather than guesses: a call mediated by a
+ * store, a path built from a non-literal, a wrapper two modules deep. A missing
+ * endpoint costs a pipe; a wrong one measures a URL the app never requests.
+ */
+export function harvestApiEndpoints(
+  bodyNode: ts.Node,
+  sourceFile: ts.SourceFile,
+  imports: Map<string, ImportBinding>,
+  file: string,
+  resolver: ModuleResolver,
+  cache: SourceFileCache,
+): FetchCallInfo[] {
+  // Every imported name the component actually invokes, with the call node for
+  // its position (imported-but-uncalled contributes nothing).
+  const invoked = new Map<string, ts.CallExpression>();
+  const visit = (n: ts.Node): void => {
+    if (ts.isCallExpression(n) && ts.isIdentifier(n.expression)) {
+      const name = n.expression.text;
+      if (imports.has(name) && !invoked.has(name)) invoked.set(name, n);
+    }
+    ts.forEachChild(n, visit);
+  };
+  ts.forEachChild(bodyNode, visit);
+
+  const out: FetchCallInfo[] = [];
+  const seen = new Set<string>();
+  for (const [local, callNode] of invoked) {
+    const binding = imports.get(local);
+    if (!binding || binding.isTypeOnly || binding.kind === "namespace") continue;
+    // Default-imported api clients exist, but the named-export idiom is the one
+    // every RN app uses and the only one worth the resolution cost until a
+    // real default-exported client turns up to measure against.
+    if (binding.kind === "default") continue;
+    const target = resolver.resolve(binding.specifier, file);
+    if (!target) continue;
+    const wanted = binding.importedName ?? local;
+    const located = findExportedDecl(
+      target,
+      wanted,
+      cache,
+      resolver,
+      (sf, name) => new Map(exportedFunctions(sf)).get(name),
+      true,
+    );
+    if (!located) continue;
+    const endpoint = wrapperCallIn(located.decl, located.sf);
+    if (!endpoint) continue;
+    const key = `${endpoint.method} ${endpoint.template}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({
+      urlTemplate: endpoint.template,
+      holes: endpoint.holes,
+      method: endpoint.method,
+      // The screen's own call site, not the api-module declaration: the endpoint
+      // is a fact about THIS component, and its position is where the component
+      // asks for it.
+      pos: posOf(callNode, sourceFile),
+      inEffect: isInsideEffect(callNode, bodyNode),
+    });
+  }
+  return out;
+}
+
+const EFFECT_HOOKS = new Set(["useEffect", "useLayoutEffect", "useFocusEffect"]);
+
+function isInsideEffect(call: ts.Node, bodyNode: ts.Node): boolean {
+  let cur: ts.Node | undefined = call.parent;
+  while (cur && cur !== bodyNode) {
+    if (ts.isCallExpression(cur)) {
+      const name = hookCalleeName(cur.expression);
+      if (name && EFFECT_HOOKS.has(name)) return true;
+    }
+    cur = cur.parent;
+  }
+  return false;
+}
+
+interface WrapperEndpoint {
+  template: string;
+  holes: string[];
+  method: string;
+}
+
+/**
+ * Drop everything from the first NON-path interpolation onward, keeping the
+ * base endpoint.
+ *
+ * A path parameter always follows a `/`: `/api/buildings/${id}` →
+ * `…/buildings/:id`. A query string built inline — `…/invoices${scope ?
+ * "?scope=mine" : ""}` — produces a hole glued straight onto the previous
+ * segment (`…/invoices:q`), which is not a path parameter and cannot be filled
+ * from params.json. The base path IS the load target: the query is an optional
+ * filter, and load-testing `…/invoices` is exactly right. So the template is
+ * truncated at that hole and the hole dropped.
+ *
+ * A query is never part of the load target, literal or interpolated: its
+ * values come from runtime state the pipe cannot carry. The template is cut at
+ * the first `?` on every path through this function — which is also what
+ * clears the edge the truncation alone left behind: a path parameter BEFORE an
+ * inline query (`/things/${id}?tab=${t}` → `/things/:id?tab=:t`) used to ship
+ * a dangling `?tab=` the app never requests, because the truncation cut after
+ * the `?` it had already passed.
+ */
+function pathOnly(template: string, holes: string[]): { template: string; holes: string[] } {
+  const stripQuery = (t: string): string => {
+    const at = t.indexOf("?");
+    return at < 0 ? t : t.slice(0, at);
+  };
+  const kept: string[] = [];
+  let cursor = 0;
+  for (const hole of holes) {
+    const at = template.indexOf(`:${hole}`, cursor);
+    if (at < 0) {
+      kept.push(hole);
+      continue;
+    }
+    if (template[at - 1] !== "/") {
+      const base = stripQuery(template.slice(0, at)).replace(/\/$/, "");
+      return { template: base, holes: kept };
+    }
+    kept.push(hole);
+    cursor = at + hole.length + 1;
+  }
+  return { template: stripQuery(template), holes: kept };
+}
+
+/**
+ * The endpoint an api function declares: the first call in its body to a
+ * module-local fetch wrapper, with a literal/template path. undefined when the
+ * body calls no wrapper, or calls one with a non-literal path (a joined URL, a
+ * variable) — which the harvest cannot turn into a pipe honestly.
+ */
+function wrapperCallIn(fn: FnLike, sf: ts.SourceFile): WrapperEndpoint | undefined {
+  const wrappers = fetchWrappersOf(sf);
+  if (wrappers.size === 0) return undefined;
+  const body = fn.body;
+  if (!body) return undefined;
+
+  let found: WrapperEndpoint | undefined;
+  const visit = (n: ts.Node): void => {
+    if (found) return;
+    if (
+      ts.isCallExpression(n) &&
+      ts.isIdentifier(n.expression) &&
+      wrappers.has(n.expression.text)
+    ) {
+      const urlArg = n.arguments[0];
+      const parsed = urlArg ? parseUrlArg(urlArg) : undefined;
+      if (parsed) {
+        const norm = pathOnly(parsed.template, parsed.holes);
+        found = { template: norm.template, holes: norm.holes, method: readMethod(n.arguments[1]) };
+        return;
+      }
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(body);
+  return found;
+}
+
+type FnLike =
+  | ts.FunctionDeclaration
+  | ts.ArrowFunction
+  | ts.FunctionExpression
+  | { body?: ts.Node };
+
+const WRAPPER_CACHE = new WeakMap<ts.SourceFile, Set<string>>();
+
+/**
+ * The names of the module-local functions that ARE fetch wrappers: a function
+ * whose body performs a `fetch()` whose URL argument references one of the
+ * function's own parameters (`apiFetch(path) => fetch(\`${BASE}${path}\`)`).
+ *
+ * Structural, never by name: the point is to trust `apiFetch` because it wraps
+ * fetch, not because of what it is called — an app's client may be `request`,
+ * `http`, `call`. A function that takes a string and does something else is not
+ * a client, and its literal-string callers are not endpoints.
+ */
+function fetchWrappersOf(sf: ts.SourceFile): Set<string> {
+  const cached = WRAPPER_CACHE.get(sf);
+  if (cached) return cached;
+  const names = new Set<string>();
+  for (const [name, fn] of localFunctions(sf)) {
+    if (isFetchWrapper(fn)) names.add(name);
+  }
+  WRAPPER_CACHE.set(sf, names);
+  return names;
+}
+
+/** name → function node for every top-level function-ish declaration, exported
+ *  or not — the wrapper is almost always a NON-exported module-local. */
+function localFunctions(sf: ts.SourceFile): Map<string, FnLike> {
+  const out = new Map<string, FnLike>();
+  for (const stmt of sf.statements) {
+    if (ts.isFunctionDeclaration(stmt) && stmt.name) {
+      out.set(stmt.name.text, stmt);
+    } else if (ts.isVariableStatement(stmt)) {
+      for (const d of stmt.declarationList.declarations) {
+        if (!ts.isIdentifier(d.name) || !d.initializer) continue;
+        if (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer)) {
+          out.set(d.name.text, d.initializer);
+        }
+      }
+    }
+  }
+  return out;
+}
+
+function isFetchWrapper(fn: FnLike): boolean {
+  const params = paramNames(fn);
+  if (params.size === 0) return false;
+  const body = fn.body;
+  if (!body) return false;
+  let wraps = false;
+  const visit = (n: ts.Node): void => {
+    if (wraps) return;
+    if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === "fetch") {
+      const urlArg = n.arguments[0];
+      if (urlArg && referencesAnyParam(urlArg, params)) wraps = true;
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(body);
+  return wraps;
+}
+
+function paramNames(fn: FnLike): Set<string> {
+  const names = new Set<string>();
+  const params = (fn as ts.FunctionLikeDeclarationBase).parameters;
+  if (!params) return names;
+  for (const p of params) {
+    if (ts.isIdentifier(p.name)) names.add(p.name.text);
+  }
+  return names;
+}
+
+function referencesAnyParam(node: ts.Node, params: Set<string>): boolean {
+  let hit = false;
+  const visit = (n: ts.Node): void => {
+    if (hit) return;
+    if (ts.isIdentifier(n) && params.has(n.text)) {
+      hit = true;
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(node);
+  return hit;
+}