@videlic/connect 0.1.1 → 0.1.7

package/evidence.mjs

@@ -0,0 +1,3005 @@
+// Managed by @videlic/connect — do not edit by hand.
+//
+// The client's half of the EvidenceBundle (spec-v3 §3.7): what the repository
+// on the developer's disk looks like from where the session ran.
+//
+// WHY THIS IS A SECOND FILE AND NOT A DEPENDENCY. The spec says "the graph via
+// `import-extract` as an npm dependency". It cannot be: `install.mjs` copies
+// the hook to `~/.claude/videlic-hook.mjs` with `copyFileSync`, and the
+// installed hook is a lone file with no `node_modules` anywhere near it — an
+// `import` of a package would throw on every Stop on every machine. The
+// extractor's home, `@ao/analyzers`, is `private: true` and has never been on
+// npm either. So the hook grows a second copied file instead, and the drift
+// that a second copy invites is answered the only way that actually works: a
+// test runs THIS code and the stand's TypeScript over the same real
+// repository — all 24 043 paths of it — and fails on the first disagreement.
+//
+// Everything here is a port, not a rewrite. Each function below is the twin of
+// a named function in the analyzers package, and where a regex looks odd it is
+// odd there too, for a reason recorded there. Read them together or not at all:
+//
+//   extractModuleEdges / maskModuleSource   packages/analyzers/src/engines/module-edges.ts
+//   isTestPath / expectedTestPaths   packages/analyzers/src/observe/test-paths.ts
+//   isGraphSource / selectEvidence   packages/analyzers/src/eval/replay/git-source.ts
+//   buildEvidence                    packages/analyzers/src/eval/replay/git-source.ts
+//
+// NOTHING HERE IS ALLOWED TO THROW ON A DEVELOPER'S MACHINE. A bundle is a
+// nice-to-have that arrives after the session is already captured; a collector
+// that crashed would cost the capture nothing and the developer a stack trace
+// on their terminal, which is a bad trade at any quality of evidence.
+
+import { execFileSync } from "node:child_process";
+import { accessSync, constants, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/** The producer's own version, stamped on every bundle. Identity, not evidence. */
+export const EVIDENCE_V = 1;
+
+/** The graph format — `EVIDENCE_GRAPH_FORMAT` in `@ao/types`, whose docblock says why a reader needs it. */
+export const EVIDENCE_GRAPH_FORMAT = 2;
+
+// ───────────────────────────── module edges ─────────────────────────────
+//
+// The twin of packages/analyzers/src/engines/module-edges.ts, whose docblock
+// defines what each edge kind means, what an absent edge does NOT mean, and
+// why this is a lexer and not a regex over comment-stripped text. Between the
+// two markers below is that file with its type annotations DELETED by range
+// — not a rewrite, not a port by hand — and `client-parity.test.ts`
+// regenerates it from the TypeScript and compares it byte for byte. A change
+// made here and not there fails that test before it reaches anyone's disk.
+
+// BEGIN module-edges.ts, types deleted
+/**
+ * A TypeScript declaration file by TypeScript's own rule (`isDeclarationFileName`):
+ * `.d.ts`, `.d.mts`, `.d.cts`, and the `allowArbitraryExtensions` kind
+ * (`button.d.css.ts`), case as written — nothing in it ever executes. A
+ * `.d.tsx` or `.D.TS` is a module the runner transforms and runs.
+ */
+const DECLARATION_FILE = /\.d\.(?:[cm]?ts|[^./]+\.ts)$/;
+const JSX_FILE = /\.(?:[cm]?jsx?|tsx)$/i;
+const TYPESCRIPT_FILE = /\.[cm]?tsx?$/i;
+const SCRIPT_FILE = /\.c?js$/i;
+
+export function isDeclarationFile(path) {
+  return DECLARATION_FILE.test(path);
+}
+
+export function moduleEdgeOptions(path) {
+  return { declaration: isDeclarationFile(path), jsx: JSX_FILE.test(path), typescript: TYPESCRIPT_FILE.test(path), script: SCRIPT_FILE.test(path) };
+}
+
+/**
+ * Every module reference in a source text, deduplicated by (specifier, kind)
+ * in order of first appearance.
+ */
+export function extractModuleEdges(content, opts = {}, report) {
+  if (report) report.doubtAt = -1;
+  if (!content) return [];
+  const { code, topLevel, doubtAt, exprStarts } = lexModule(content, !!opts.jsx, !!opts.typescript, !!opts.script);
+  if (report) report.doubtAt = doubtAt;
+  // `end`: where the specifier ends — what the doubt is measured against, so a
+  // statement whose keyword precedes the doubt and whose specifier follows it
+  // is on the doubtful side.
+  const found = [];
+  const dynamics = [];
+  const aliases = new Set();
+  /** Where each static `import`/`export … from` statement lies — its bindings name a runner without using it. */
+  const statements = [];
+  /** Runner names this file binds to something of its own (`import vi from "./vi.json"`). */
+  const ownNames = new Set();
+  /** Names a runner may have been imported under from a module that is not one (`import { vi as v } from "./test-utils"`). */
+  const mockAliases = new Set();
+
+  KEYWORD.lastIndex = 0;
+  for (let m = KEYWORD.exec(code); m; m = KEYWORD.exec(code)) {
+    const word = m[0];
+    const at = m.index;
+    const after = at + word.length;
+    if (!standsAlone(code, at, after)) continue;
+    if (word === "require") {
+      const open = skipSpace(code, after);
+      if (code[open] !== "(") continue;
+      const lit = readLiteral(content, code, skipSpace(code, open + 1), true);
+      if (!lit || code[skipSpace(code, lit.end)] !== ")") continue;
+      // `import x = require("x")` is a declaration: at the top of the module
+      // or not at all (inside `declare module` it is a type's business). The
+      // text before is read up to its last significant character, so no
+      // comment, however long, stands between the `=` and what it belongs to.
+      const equals = importEqualsBefore(code, at);
+      if (equals && !topLevel.has(equals.importAt)) continue;
+      found.push({ at, end: lit.end, specifier: lit.value, kind: equals?.typeOnly ? "type-only" : "require" });
+      // A runner module REQUIRED hands its objects over under names this file
+      // chooses (`const { jest: j } = require("@jest/globals")`).
+      if (RUNNER_MODULES.has(lit.value)) found.push({ at, specifier: "(a runner module by require)", kind: "mocked-unknown" });
+      continue;
+    }
+    const next = skipSpace(code, after);
+    if (word === "import" && code[next] === "(") {
+      const lit = readLiteral(content, code, skipSpace(code, next + 1), true);
+      if (!lit) continue;
+      const close = skipSpace(code, lit.end);
+      // `import("./x" + y)` names no module; `import("./x", { with: … })` does.
+      if (code[close] !== ")" && code[close] !== ",") continue;
+      const end = code[close] === ")" ? close : matchClose(code, next);
+      const member = end >= 0 ? memberAfter(code, end + 1) : null;
+      const dynKind = opts.typescript ? typescriptImportCall(contextBefore(code, at, exprStarts), member) : "dynamic";
+      dynamics.push({ at, end: lit.end, specifier: lit.value, kind: dynKind });
+      // A type (`typeof import("vitest")`) hands nothing over at run time.
+      if (RUNNER_MODULES.has(lit.value) && dynKind !== "type-only") found.push({ at, specifier: "(a runner module by import())", kind: "mocked-unknown" });
+      continue;
+    }
+    if (word === "import" && code[next] === ".") continue; // import.meta
+    // A declaration lives at the top of a module and nowhere else.
+    if (!topLevel.has(at)) continue;
+    const stmt = scanStatement(content, code, word, after);
+    if (!stmt) continue;
+    found.push({ at, end: stmt.end, specifier: stmt.specifier, kind: stmt.typeOnly ? "type-only" : stmt.deferred ? "uncertain" : "import" });
+    statements.push([at, stmt.end]);
+    const toks = stmt.tokens;
+    if (word === "export") {
+      // A re-export binds nothing here — and of a runner module, it hands the
+      // runner on to whoever imports this file.
+      if (RUNNER_MODULES.has(stmt.specifier) && !stmt.typeOnly) found.push({ at, specifier: "(a runner module handed on)", kind: "mocked-unknown" });
+    } else if (RUNNER_MODULES.has(stmt.specifier)) {
+      for (const a of runnerAliases(toks)) aliases.add(a);
+      // Its objects under a name we do not follow: `import * as vt`, a default
+      // import — except node:test's, which is the `test` function itself
+      // (its `mock.module` is read by the mock call above).
+      const def = /^[A-Za-z_$][\w$]*$/.test(toks[0] ?? "") && toks[0] !== "type" && toks[0] !== "typeof";
+      if (!stmt.typeOnly && (toks.includes("*") || (def && stmt.specifier !== "node:test"))) {
+        found.push({ at, specifier: "(a runner module under a name we do not follow)", kind: "mocked-unknown" });
+      }
+    } else {
+      for (let k = 0; k < toks.length; k++) {
+        const t = toks[k];
+        if (!RUNNER_OBJECTS.has(t)) continue;
+        // `vi as v` from any module: `v` may be the runner a helper handed on,
+        // so a mock call through it is a mock; the file binds `v`, not `vi`.
+        if (toks[k + 1] === "as") {
+          const local = toks[k + 2];
+          if (local && /^[A-Za-z_$][\w$]*$/.test(local)) mockAliases.add(local);
+          continue;
+        }
+        // …and a local binding of the name itself is this file's own.
+        ownNames.add(t);
+      }
+    }
+  }
+
+  // Mocks, before the dynamic imports are kept: `vi.mock(import("./x"))`
+  // holds a dynamic import that is not one.
+  const claimed = new Set();
+  /** Where each recorded mock call's receiver starts. */
+  const mockAt = new Set();
+  const calls = [MOCK_CALL];
+  const callNames = new Set([...aliases, ...mockAliases]);
+  if (callNames.size > 0) {
+    const names = [...callNames].map((a) => a.replace(/\$/g, "\\$")).join("|");
+    calls.push(new RegExp(`(?<![\\w$.])(?:${names})\\s*\\.\\s*(?:mock|doMock|setMock|unstable_mockModule|module)(?=\\s*[<(])`, "g"));
+  }
+  for (const rx of calls) {
+    rx.lastIndex = 0;
+    for (let m = rx.exec(code); m; m = rx.exec(code)) {
+      let p = skipSpace(code, m.index + m[0].length);
+      if (code[p] === "<") {
+        p = skipTypeArguments(code, p);
+        if (p < 0) {
+          // A mock call whose type arguments we cannot read past is still a mock call.
+          found.push({ at: m.index, specifier: "<type arguments>", kind: "mocked-unknown" });
+          mockAt.add(m.index);
+          continue;
+        }
+        p = skipSpace(code, p);
+      }
+      if (code[p] !== "(") continue;
+      const target = mockTarget(content, code, p + 1);
+      if (target.claimed != null) claimed.add(target.claimed);
+      found.push({ at: m.index, specifier: target.specifier, kind: target.kind });
+      mockAt.add(m.index);
+    }
+  }
+  AUTOMOCK.lastIndex = 0;
+  for (let m = AUTOMOCK.exec(code); m; m = AUTOMOCK.exec(code)) {
+    found.push({ at: m.index, specifier: "jest.enableAutomock", kind: "mocked-unknown" });
+    mockAt.add(m.index);
+  }
+
+  // A RUNNER OBJECT REACHED ANY OTHER WAY. A mock is recorded above only as a
+  // direct call on the runner's own name. The same method reached otherwise —
+  // `jest.mock?.(…)`, `(jest.mock)(…)`, `jest.mock.call(jest, …)`, `const m =
+  // jest.mock`, `jest[k](…)`, or the object itself handed on (`const j =
+  // jest`, `{ mock } = jest`, `helper(vi)`) — replaces a module just as well
+  // and would leave no edge, in a setup file or a helper whose text a reader
+  // never has (V7 review, 27.09). So every other reference to a runner object
+  // is a mock we cannot aim. What stays silent: a member that is not a mock
+  // method (`jest.fn`, `vi.spyOn`, `jest.Mock` as a type), a key (`{ vi: … }`,
+  // a locale table), and the import statement that names it.
+  //
+  // A NAME THE FILE BINDS ITSELF is not the runner — an import from any other
+  // module (medusa's locale table imports `vi` from `./vi.json`), a `const`,
+  // `let`, `var`, `function` or `class` of that name — and a parameter of that
+  // name is that parameter (`.map((v, vi) => …)`). Without that, one locale
+  // file, which no runner names as a test, would veto every file of the
+  // repository.
+  DECLARES_RUNNER_NAME.lastIndex = 0;
+  for (let m = DECLARES_RUNNER_NAME.exec(code); m; m = DECLARES_RUNNER_NAME.exec(code)) ownNames.add(m[1]);
+  const runnerNames = [...[...RUNNER_OBJECTS].filter((n) => !ownNames.has(n)), ...[...aliases].filter((a) => a !== "mock")].map((a) => a.replace(/\$/g, "\\$"));
+  const runnerRef = runnerNames.length ? new RegExp(`(?<![\\w$.])(?:${runnerNames.join("|")})(?![\\w$])`, "g") : null;
+  const reached = (at, len, bare) => {
+    if (statements.some(([a, b]) => at >= a && at < b)) return false;
+    if (mockAt.has(at)) return false;
+    if (bare && isParameter(code, at, len)) return false;
+    // A label a `break`/`continue` jumps to.
+    // On the same line only: across one, ASI ends the `break` and the name is a statement of its own.
+    if (bare && /(?<![\w$.])(?:break|continue)[ \t]+$/.test(code.slice(Math.max(0, at - 40), at))) return false;
+    // A name in a type — `namespace jest {`, `typeof vi`, an interface — runs nothing.
+    if (TYPE_BEFORE.test(code.slice(Math.max(0, at - 48), at))) return false;
+    const p = skipSpace(code, at + len);
+    // A name followed by `:` is a key (`{ vi: … }`, a locale table), a
+    // member or parameter annotated with a type (`vi: string`, `(vi: T)`,
+    // `vi?: T`) or a label — none of them the runner — except where it ENDS
+    // an expression the grammar reads as a value: a ternary's branch
+    // (`cond ? () => vi : x`) or a `case`.
+    const colon = code[p] === ":" ? p : code[p] === "?" && code[skipSpace(code, p + 1)] === ":" ? skipSpace(code, p + 1) : -1;
+    if (bare && colon >= 0 && code[colon + 1] !== ":" && !endsBranchOrCase(code, at)) return false;
+    if (code[p] === "." && code[p + 1] !== ".") {
+      const member = /^\s*([A-Za-z_$][\w$]*)/.exec(code.slice(p + 1, p + 200));
+      if (member && !MOCK_METHOD_NAMES.has(member[1])) return false;
+    }
+    return true;
+  };
+  for (let m = runnerRef?.exec(code); m && runnerRef; m = runnerRef.exec(code)) {
+    if (reached(m.index, m[0].length, true)) found.push({ at: m.index, specifier: "(a runner object reached another way)", kind: "mocked-unknown" });
+  }
+  // The global object under the names this file gives it (`const g =
+  // globalThis as unknown as Record<string, any>`): one step, a declaration
+  // whose whole value is the global object behind casts.
+  const globals = ["globalThis", "global", "window", "self"];
+  GLOBAL_ALIAS.lastIndex = 0;
+  for (let m = GLOBAL_ALIAS.exec(code); m; m = GLOBAL_ALIAS.exec(code)) {
+    if (/^(?:\s*\)|\s*!|\s+as\s+[^;\n=]*)*\s*(?:;|\n|$)/.test(code.slice(m.index + m[0].length))) globals.push(m[1]);
+  }
+  const globalAlt = `(?:${globals.map((g) => g.replace(/\$/g, "\\$")).join("|")}|import\\s*\\.\\s*meta)`;
+  const holdsGlobal = new RegExp(`(?<![\\w$.])${globalAlt}(?![\\w$])`);
+  // …and the same objects as members of the global object or `import.meta`
+  // (`const m = globalThis.vi`, `(globalThis as any).vi`, `import.meta.jest`, `g.vi`).
+  const globalRunner = new RegExp(`(?:(?<![\\w$.])${globalAlt}|\\))\\s*\\??\\.\\s*(jest|vi|vitest)(?![\\w$])`, "g");
+  for (let m = globalRunner.exec(code); m; m = globalRunner.exec(code)) {
+    const at = m.index + m[0].length - m[1].length;
+    if (reached(at, m[1].length, false)) found.push({ at, specifier: "(a runner object reached another way)", kind: "mocked-unknown" });
+  }
+  const inStatement = (at) => statements.some(([a, b]) => at >= a && at < b);
+  if (RUNNER_NAME.test(content)) {
+    // …taken apart from it (`const { vi: m } = globalThis`, `{ a, vi: { doMock } } =
+    // (globalThis as any)`): EVERY runner name in the pattern is looked at,
+    // and one that is code (not prose in a comment, not a string value) or a
+    // quoted key is the runner. The pattern and the global object behind it
+    // are read on the mask, where a comment between them is space.
+    const tail = new RegExp(`^\\s*(?::[^=;]*)?=(?![=>])\\s*(?:\\(\\s*)*(?:<[^>]*>\\s*)?(?:\\(\\s*)*${globalAlt}(?![\\w$])`);
+    BRACES.lastIndex = 0;
+    for (let m = BRACES.exec(code); m; m = BRACES.exec(code)) {
+      if (!tail.test(code.slice(m.index + m[0].length))) continue;
+      NAME_IN_PATTERN.lastIndex = 0;
+      const body = content.slice(m.index, m.index + m[0].length);
+      for (let n = NAME_IN_PATTERN.exec(body); n; n = NAME_IN_PATTERN.exec(body)) {
+        const at = m.index + n.index;
+        const isCode = n[1] ? code[at] === n[1] && /^\s*:/.test(code.slice(at + n[0].length)) : code.slice(at, at + n[0].length) === n[0];
+        if (isCode && !inStatement(at)) {
+          found.push({ at, specifier: "(a runner object reached another way)", kind: "mocked-unknown" });
+          break;
+        }
+      }
+    }
+    // …or read off it by a string key (`(globalThis as any)["vi"]`,
+    // `global!["jest"]`, `globalThis?.self["vi"]`) — an index only after an
+    // expression (after anything else it opens an array), and not in a type
+    // (`typeof globalThis["vi"]`).
+    RUNNER_BY_STRING_KEY.lastIndex = 0;
+    for (let m = RUNNER_BY_STRING_KEY.exec(content); m; m = RUNNER_BY_STRING_KEY.exec(content)) {
+      if (code[m.index] !== content[m.index] || !indexes(code, m.index)) continue;
+      const r = receiverOf(code, m.index);
+      if (!holdsGlobal.test(code.slice(r, m.index)) || /(?<![\w$.])typeof\s*$/.test(code.slice(Math.max(0, r - 12), r))) continue;
+      if (!inStatement(m.index)) found.push({ at: m.index, specifier: "(a runner object reached another way)", kind: "mocked-unknown" });
+    }
+  }
+  // An identifier spelled with a unicode escape (`\u006aest.mock`) is the
+  // runner to the runtime and nothing to this lexer.
+  if (/\\u(?:[0-9a-fA-F]{4}|\{)/.test(code)) found.push({ at: code.search(/\\u(?:[0-9a-fA-F]{4}|\{)/), specifier: "(an escaped identifier)", kind: "mocked-unknown" });
+  for (const d of dynamics) {
+    if (!claimed.has(d.at)) found.push({ at: d.at, end: d.end, specifier: d.specifier, kind: d.kind });
+  }
+  // A module-replacing library replaces modules we cannot name from here.
+  for (const f of [...found]) {
+    if (f.kind === "type-only" || f.kind === "mocked" || f.kind === "mocked-unknown") continue;
+    const root = packageRoot(f.specifier);
+    if (MODULE_REPLACERS.has(root)) found.push({ at: f.at, specifier: root, kind: "mocked-unknown" });
+  }
+
+  // Past the lexer's first consequential guess a mock call may sit in text the
+  // guess re-paired into a string, and then no mock edge above was published
+  // for it. A reader must not read a doubted file as mock-free, so the file
+  // says what it cannot rule out: when the raw text past the doubt mentions a
+  // mock at all, a `mocked-unknown` — a veto on every witness through this
+  // file (V7 review, 27.09: a setup file doubted at `of / t` hid its
+  // `jest.mock`). Measured on the doubted files of videlic and medusa: only
+  // the two vendored `.yarn` bundles mention one, and those are not graph
+  // sources.
+  if (doubtAt >= 0 && DOUBT_MENTIONS_MOCK.test(content.slice(doubtAt))) found.push({ at: doubtAt, specifier: "(text past the doubt)", kind: "mocked-unknown" });
+
+  found.sort((a, b) => a.at - b.at);
+  // Past the lexer's first consequential guess, no load is a load: it may be
+  // one, it may be text the guess exposed. It is published as `uncertain` —
+  // no witness stands on it, and no claim that a module did NOT run may
+  // ignore it. A veto or a type costs no witness it should not, and stays.
+  if (doubtAt >= 0) for (const f of found) if ((f.end ?? f.at) >= doubtAt && LOADS.has(f.kind)) f.kind = "uncertain";
+  const seen = new Set();
+  const out = [];
+  for (const f of found) {
+    const kind = opts.declaration && (LOADS.has(f.kind) || f.kind === "uncertain") ? "type-only" : f.kind;
+    if (!f.specifier) continue;
+    // Nothing in a declaration file runs, a mock included.
+    if (opts.declaration && (kind === "mocked" || kind === "mocked-unknown")) continue;
+    const key = `${kind}\0${f.specifier}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ specifier: f.specifier, kind });
+  }
+  return out;
+}
+
+/**
+ * Where the lexer first had to guess in a way that decides what is code —
+ * the offset past which a file publishes no load — or `-1`. For measuring the
+ * cost of that rule, and for a reader that wants to say why an edge is absent.
+ */
+export function moduleDoubt(content, opts = {}) {
+  return content ? lexModule(content, !!opts.jsx, !!opts.typescript, !!opts.script).doubtAt : -1;
+}
+
+/** The mask alone — what the scanners read. */
+export function maskModuleSource(src, opts = {}) {
+  return lexModule(src, !!opts.jsx, !!opts.typescript, !!opts.script).code;
+}
+
+// None of these can match inside a string or a comment: the mask has neither.
+// Word boundaries are checked by hand (`standsAlone`) because a regex's `\w`
+// is ASCII and an identifier is not.
+const KEYWORD = /import|export|require/g;
+const MOCK_CALL =
+  /(?<![\w$])(?:(?:vi|jest|vitest|sb)\s*\.\s*(?:mock|doMock|setMock|unstable_mockModule)|mock\s*\.\s*module)(?=\s*[<(])/g;
+/** Every module mocked at once, with no call per module to see. */
+const AUTOMOCK = /(?<![\w$])jest\s*\.\s*(?:enableAutomock|autoMockOn)\s*\(/g;
+/** A runner object's methods that replace a module. */
+const MOCK_METHOD_NAMES = new Set(["mock", "doMock", "setMock", "unstable_mockModule", "enableAutomock", "autoMockOn", "module"]);
+/** The runner objects a test file sees as globals. */
+const RUNNER_OBJECTS = new Set(["jest", "vi", "vitest"]);
+const DECLARES_RUNNER_NAME = /(?<![\w$.])(?:const|let|var|function|class)\s+(jest|vi|vitest)(?![\w$])/g;
+/** A runner object as a member of the global object, `import.meta`, or a parenthesised value. */
+/**
+ * Words after which a name is a type's, not a value's. A declaration keyword
+ * takes its name on the same line — `let type\nvi.mock(…)` is `type;` and then
+ * the runner — while `typeof` reads across one.
+ */
+const TYPE_BEFORE = /(?:(?<![\w$.])(?:(?:namespace|module|interface|type|enum|declare)[ \t]+|typeof\s+))$/;
+const RUNNER_NAME = /(?<![\w$])(?:jest|vi|vitest)(?![\w$])/;
+/** A `{ … }` with at most one level inside: a destructuring pattern, or any block. */
+const BRACES = /\{(?:[^{}]|\{[^{}]*\})*\}/g;
+/** A runner name standing where a pattern's key or shorthand stands; group 1 its quote. */
+const NAME_IN_PATTERN = /(?<![\w$.])(["'`]?)(?:jest|vi|vitest)\1(?=\s*[:,}])/g;
+const RUNNER_BY_STRING_KEY = /\[\s*(["'`])(?:jest|vi|vitest)\1\s*\]/g;
+/** `const g = globalThis` (behind parentheses and casts); what follows is checked separately. */
+const GLOBAL_ALIAS = /(?<![\w$.])(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=;\n]*)?=\s*(?:\(\s*)*(?:<[^>]*>\s*)?(?:\(\s*)*(?:globalThis|global|window|self)(?![\w$])/g;
+
+/**
+ * Is the name at `at` a parameter being declared — `vi => …`, `(v, vi) =>`,
+ * `function f(vi) {` — rather than the runner used? A simple parameter list
+ * (names and commas) closed by `)` and followed by `=>` or a body.
+ */
+function isParameter(code, at, len) {
+  const after = skipSpace(code, at + len);
+  if (code.startsWith("=>", after)) return true;
+  let b = at - 1;
+  while (b >= 0 && /[\s\w$,]/.test(code[b])) b--;
+  if (code[b] !== "(") return false;
+  // `with (jest) {`, `if (vi) {`: a value in parentheses, not a parameter list.
+  if (/(?<![\w$.])(?:with|if|while|switch|for)\s*$/.test(code.slice(Math.max(0, b - 12), b))) return false;
+  let f = at + len;
+  while (f < code.length && /[\s\w$,]/.test(code[f])) f++;
+  if (code[f] !== ")") return false;
+  const next = skipSpace(code, f + 1);
+  return code.startsWith("=>", next) || code[next] === "{";
+}
+/** `typeof ` immediately before an `import(`. */
+const TYPEOF_BEFORE = /(?<![\w$.])typeof$/;
+/**
+ * Other places only a TYPE can stand, immediately before an `import(`: the
+ * right side of a type alias (`type M = import("./x")`), after a type
+ * operator (`keyof`, `as`, `satisfies`, `extends`, `infer`, `is`,
+ * `readonly`, `unique`), a type argument, a union or intersection member (`<`,
+ * `|`, `&` — at runtime a promise compared or or-ed with something is not code
+ * anyone writes; `&&` and `||` are).
+ */
+const TYPE_POSITION_BEFORE =
+  /(?:(?<![\w$.])type\s+[A-Za-z_$][\w$]*\s*(?:<[^;]*>)?\s*=|(?<![\w$.])(?:keyof|as|satisfies|extends|infer|is|readonly|unique)|<|(?<![|&])[|&])\s*$/;
+/** Where an `import(…)` can only be a value, whatever lies between: awaited, voided, or the start of a statement. */
+const VALUE_BEFORE = /(?:(?<![\w$.])(?:await|void)|[;{}])$/;
+/** …and where only on the same line: a line end after `return` is a return of nothing, and the `import()` below it never runs. */
+const SAME_LINE_VALUE_BEFORE = /(?<![\w$.])(?:return|yield|throw)$/;
+/** The kinds that say a module RAN. */
+const LOADS = new Set(["import", "require", "dynamic"]);
+
+/**
+ * The code before `at` up to and including its last significant character,
+ * whether a line end lies between that character and `at`, and whether there
+ * is anything significant before `at` at all. Read up to 64 KB back, so a long
+ * comment or a blanked string cannot erase what precedes it — a fixed window
+ * over the mask did, and a type after a long comment read as a load.
+ */
+function contextBefore(
+  code,
+  at,
+  exprStarts,
+) {
+  let k = at - 1;
+  const stop = Math.max(0, at - 65_536);
+  // Stepping back over the blank where a `${` or a JSX `{` opened: what is
+  // before that blank is not before this expression.
+  const opened = () => exprStarts?.get(k + 1);
+  while (k >= stop && isSpace(code[k]) && !opened()) k--;
+  const expr = opened();
+  const lineEnd = /[\n\r\u2028\u2029]/.test(code.slice(Math.max(0, k + 1), at));
+  if (expr) return { before: "", from: at, lineEnd, atStart: false, expr };
+  if (k < stop) return { before: "", from: at, lineEnd, atStart: k < 0 };
+  const from = Math.max(0, k - 199);
+  return { before: code.slice(from, k + 1), from, lineEnd, atStart: false };
+}
+
+/**
+ * `import x = ` or `import type x = ` ending at the `=` that stands last
+ * before `at` — read back over any white space and blanked comment, however
+ * long — or `null`.
+ */
+function importEqualsBefore(code, at) {
+  const stop = Math.max(0, at - 65_536);
+  let k = at - 1;
+  const back = () => {
+    while (k >= stop && isSpace(code[k])) k--;
+  };
+  const word = () => {
+    const end = k + 1;
+    while (k >= stop && isIdentChar(code[k])) k--;
+    return code.slice(k + 1, end);
+  };
+  back();
+  if (code[k] !== "=") return null;
+  k--;
+  back();
+  if (!word()) return null;
+  back();
+  let w = word();
+  let typeOnly = false;
+  if (w === "type") {
+    typeOnly = true;
+    back();
+    w = word();
+  }
+  if (w !== "import" || isIdentChar(code[k]) || code[k] === ".") return null;
+  return { importAt: k + 1, typeOnly };
+}
+
+/**
+ * What a TypeScript `import(…)` is, from the code before it and the member
+ * read off it.
+ *
+ * In TypeScript an `import(…)` is a TYPE in more places than any list of them
+ * — `Record<K, import("./x")>`, `[import("./x")]`, a generic default, a
+ * function type's return, `import("./x").then` as a type's qualified name —
+ * and a VALUE in others that look the same (`{ load: import("./x") }`,
+ * `() => import("./x")`). So: a type where a type is certain (after `typeof`,
+ * a type operator, a type alias's `=`, `<`, `|`, `&`, or with a member no
+ * Promise has); a load where a value is certain (awaited, voided; returned,
+ * yielded or thrown on the same line; a statement of its own; a Promise
+ * member CALLED — `.then(…)`, since nothing in a type is called); and
+ * `uncertain` everywhere else — which is not "never runs", and must not be
+ * read as it.
+ */
+function typescriptImportCall(
+  ctx,
+  member,
+) {
+  if (member != null && !PROMISE_MEMBERS.has(member.name)) return "type-only";
+  // Right inside a `${`: a template literal's value, or a template literal
+  // TYPE's — the mask cannot say which. Right inside a JSX `{`: a value.
+  if (ctx.expr === "tpl") return member?.call ? "dynamic" : "uncertain";
+  if (ctx.expr === "jsx") return "dynamic";
+  if (TYPEOF_BEFORE.test(ctx.before) || TYPE_POSITION_BEFORE.test(ctx.before)) return "type-only";
+  if (member != null && member.call) return "dynamic";
+  if (ctx.atStart || VALUE_BEFORE.test(ctx.before) || (!ctx.lineEnd && SAME_LINE_VALUE_BEFORE.test(ctx.before))) return "dynamic";
+  if (ctx.lineEnd && startsStatementAfterLineEnd(ctx.before)) return "dynamic";
+  return "uncertain";
+}
+
+/**
+ * A line end between the end of a value and `import(`: nothing continues a
+ * value into `import(…)`, so a new statement starts there (`… = Prism` then
+ * `import("prismjs/…")` on the next line, in medusa). Not after a backtick —
+ * in the mask it may be a template's OPENING — and not after a keyword that
+ * expects more (`typeof`, `in`) or ends the flow (`return` above an
+ * `import()` that never runs).
+ */
+function startsStatementAfterLineEnd(before) {
+  const last = before[before.length - 1];
+  if (last === undefined || !/[\w$)\]'"]/.test(last)) return false;
+  if (!/[\w$]/.test(last)) return true;
+  const word = /([A-Za-z_$][\w$]*)$/.exec(before)?.[1];
+  return word === undefined || !CONTINUING_WORDS.has(word);
+}
+const CONTINUING_WORDS = new Set([
+  "return", "yield", "typeof", "in", "of", "instanceof", "new", "delete", "void", "throw", "case", "await", "default",
+  "extends", "keyof", "as", "satisfies", "infer", "is", "readonly", "unique", "else", "do",
+]);
+/** Members of a Promise, which is what `import(…)` is in code. */
+const PROMISE_MEMBERS = new Set(["then", "catch", "finally"]);
+/** The modules a mock-bearing object is imported from, under a name of the test's choosing. */
+const RUNNER_MODULES = new Set(["vitest", "@jest/globals", "node:test", "bun:test"]);
+const RUNNER_MOCKERS = new Set(["vi", "vitest", "jest", "mock"]);
+/** Libraries that replace modules by a mechanism of their own. */
+const MODULE_REPLACERS = new Set(["proxyquire", "esmock", "testdouble", "mock-require", "rewiremock", "quibble", "mockery", "rewire"]);
+/** Raw text that could be a mock call or a module replacer — what a doubted file cannot rule out. */
+const DOUBT_MENTIONS_MOCK = new RegExp(`mock|${[...MODULE_REPLACERS].join("|")}`, "i");
+
+function isSpace(c) {
+  if (c === undefined) return false;
+  if (c === " " || c === "\n" || c === "\t" || c === "\r" || c === "\f" || c === "\v") return true;
+  return c.charCodeAt(0) >= 128 && /\s/.test(c);
+}
+
+/**
+ * Where the expression that `[` at `at` indexes begins: back over `!`, `?.`,
+ * a parenthesised group (a cast: `(globalThis as Record<string, unknown>)`)
+ * and a dotted name.
+ */
+function receiverOf(code, at) {
+  let q = at - 1;
+  for (;;) {
+    while (q >= 0 && /\s/.test(code[q])) q--;
+    if (code[q] === "!" || (code[q] === "." && code[q - 1] === "?")) {
+      q -= code[q] === "!" ? 1 : 2;
+      continue;
+    }
+    if (code[q] === "?" && code[q + 1] === ".") {
+      q--;
+      continue;
+    }
+    if (code[q] === ")" || code[q] === "]") {
+      const close = code[q];
+      const open = close === ")" ? "(" : "[";
+      let depth = 0;
+      for (; q >= 0; q--) {
+        if (code[q] === close) depth++;
+        else if (code[q] === open && --depth === 0) break;
+      }
+      q--;
+      continue;
+    }
+    if (q >= 0 && /[\w$.]/.test(code[q])) {
+      while (q >= 0 && /[\w$.]/.test(code[q])) q--;
+      // A name ends the walk unless it is a member of what stands before it
+      // (`f().vi`): `typeof globalThis` is two words, not one receiver.
+      if (code[q + 1] === ".") continue;
+      return q + 1;
+    }
+    return q + 1;
+  }
+}
+
+/** Is the `[` at `at` an index into the expression before it, rather than an array? */
+function indexes(code, at) {
+  let q = at - 1;
+  while (q >= 0 && /\s/.test(code[q])) q--;
+  const ch = code[q];
+  if (ch === ")" || ch === "]" || ch === "." || ch === "}" || ch === "!") return true;
+  if (ch == null || !/[\w$]/.test(ch)) return false;
+  let w = q;
+  while (w > 0 && /[\w$]/.test(code[w - 1])) w--;
+  return !/^(?:return|typeof|in|of|case|yield|await|void|delete|throw|new|else|do|instanceof)$/.test(code.slice(w, q + 1));
+}
+
+/**
+ * Does the name at `at` end an expression that is a ternary's branch or a
+ * `case`'s value? Walked back at the name's own bracket depth: a `?` that
+ * opens a conditional (not `?.`, `??`, or an optional member's `?:`) or the
+ * word `case` says yes; `{`, `(`, `[` opening the name's depth, `,` or `;`
+ * say it stands where a key, a parameter, a member or a label stands.
+ */
+function endsBranchOrCase(code, at) {
+  let depth = 0;
+  for (let q = at - 1, steps = 0; ; q--, steps++) {
+    // The file's start is a statement's: a label. A walk too long to finish
+    // says yes — the safe side.
+    if (q < 0) return false;
+    if (steps >= 8_000) return true;
+    const ch = code[q];
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth++;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") {
+      if (depth === 0) return false;
+      depth--;
+      continue;
+    }
+    if (depth > 0) continue;
+    if (ch === "," || ch === ";") return false;
+    // A line end that ended a statement or a member (semicolon-free code): the
+    // line before ends in a name, a literal or a closing bracket, and the one
+    // after does not open with an operator that would continue it.
+    if (ch === "\n") {
+      const next = code[skipSpace(code, q + 1)] ?? "";
+      let pq = q - 1;
+      while (pq >= 0 && /\s/.test(code[pq])) pq--;
+      const prev = code[pq] ?? "";
+      // A word ending the line that is an operator (`a instanceof`, `x in`,
+      // `await`) continues it, as does a line opening with one; a `>` that
+      // closes a type's `<` on its own line ends it (`Promise<Remote>`).
+      const lineStart = code.lastIndexOf("\n", pq) + 1;
+      const lastWord = /[\w$]+$/.exec(code.slice(lineStart, pq + 1))?.[0] ?? "";
+      const operatorWord = /^(?:instanceof|in|of|await|typeof|void|new|delete|as|satisfies|keyof|yield|return|throw|case|extends)$/.test(lastWord);
+      const opensWithOperator = /^(?:in|instanceof|as|satisfies)\b/.test(code.slice(skipSpace(code, q + 1)));
+      const closesType = prev === ">" && code[pq - 1] !== "=" && code.slice(lineStart, pq).includes("<");
+      if (!/[?:+\-*/%&|^.,=<>!([`]/.test(next) && !opensWithOperator && ((/[\w$)\]}"'`]/.test(prev) && !operatorWord) || closesType)) return false;
+      continue;
+    }
+    if (ch === "?") {
+      if (code[q + 1] === "." || code[q + 1] === "?" || code[q - 1] === "?") continue;
+      if (code[skipSpace(code, q + 1)] === ":") continue;
+      return true;
+    }
+    if (ch === "e" && code.slice(q - 3, q + 1) === "case" && !/[\w$]/.test(code[q - 4] ?? "") && !/[\w$]/.test(code[q + 1] ?? "")) return true;
+  }
+}
+
+function skipSpace(code, p) {
+  while (p < code.length && isSpace(code[p])) p++;
+  return p;
+}
+
+/** A character that can continue an identifier. Anything outside ASCII that is not a space counts, which only ever makes a name longer. */
+function isIdentChar(c) {
+  if (c === undefined) return false;
+  const k = c.charCodeAt(0);
+  if ((k >= 48 && k <= 57) || (k >= 65 && k <= 90) || (k >= 97 && k <= 122) || k === 36 || k === 95) return true;
+  return k >= 128 && !/\s/.test(c);
+}
+
+function startsWord(code, p, word) {
+  return code.startsWith(word, p) && !isIdentChar(code[p + word.length]);
+}
+
+/**
+ * A keyword that is a keyword: not the tail of a longer name (`reimport`,
+ * `λrequire`), not a private name (`this.#import`), not a property
+ * (`obj.require(…)`, `obj . import(…)`, `obj./*c*\/import(…)` — the mask has
+ * blanked the comment). A spread (`...require("x")`) is a call.
+ */
+function standsAlone(code, at, after) {
+  if (isIdentChar(code[after])) return false;
+  const b = code[at - 1];
+  if (b !== undefined && (isIdentChar(b) || b === "#")) return false;
+  let k = at - 1;
+  while (k >= 0 && isSpace(code[k])) k--;
+  // One dot is a property; three are a spread; `1..import` is a number's
+  // property, and two dots are that.
+  return !(code[k] === "." && !(code[k - 1] === "." && code[k - 2] === "."));
+}
+
+/**
+ * The `.Name` right after `import(…)`, and whether it is called, or `null`. A
+ * Promise member CALLED (`.then(…)`) is the load being used; any other name is
+ * a type position — at runtime the property of a Promise named `Name` is
+ * `undefined`, and in a type `import("./x").then` is a qualified name.
+ */
+function memberAfter(code, p) {
+  p = skipSpace(code, p);
+  if (code[p] !== ".") return null;
+  p = skipSpace(code, p + 1);
+  let q = p;
+  while (q < code.length && isIdentChar(code[q])) q++;
+  // Called on the same line: across a line end, `(` may start the next statement.
+  const open = skipSpace(code, q);
+  return q > p ? { name: code.slice(p, q), call: code[open] === "(" && !/[\n\r\u2028\u2029]/.test(code.slice(q, open)) } : null;
+}
+
+/** The `)` that closes the `(` at `open`, over the mask; `-1` when there is none close by. */
+function matchClose(code, open) {
+  let depth = 0;
+  const stop = Math.min(code.length, open + 4_000);
+  for (let j = open; j < stop; j++) {
+    const c = code[j];
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") {
+      depth--;
+      if (depth === 0) return c === ")" ? j : -1;
+      if (depth < 0) return -1;
+    }
+  }
+  return -1;
+}
+
+/** Past `<…>` type arguments at `p` — `vi.mock<typeof import("./x")>(…)` — or `-1`. An arrow's `=>` inside does not close them. */
+function skipTypeArguments(code, p) {
+  let depth = 0;
+  const stop = Math.min(code.length, p + 2_000);
+  for (let j = p; j < stop; j++) {
+    const c = code[j];
+    if (c === "<") depth++;
+    else if (c === ">" && code[j - 1] !== "=") {
+      depth--;
+      if (depth === 0) return j + 1;
+    }
+  }
+  return -1;
+}
+
+/**
+ * The literal whose opening delimiter sits at `p` in the mask, read back from
+ * the source. `null` when there is none, when it is a template with a `${…}`
+ * in it (that names no module), or when templates are not allowed there —
+ * a static `import … from` takes a quoted string and nothing else.
+ */
+function readLiteral(src, code, p, templates) {
+  const q = code[p];
+  if (q !== '"' && q !== "'" && !(templates && q === "`")) return null;
+  for (let j = p + 1; j < src.length; j++) {
+    const c = src[j];
+    if (c === "\\") {
+      j += src[j + 1] === "\r" && src[j + 2] === "\n" ? 2 : 1;
+      continue;
+    }
+    if (q === "`" && c === "$" && src[j + 1] === "{") return null;
+    if (c === q) return { value: src.slice(p + 1, j), end: j + 1 };
+    if (c === "\n" && q !== "`") return null;
+  }
+  return null;
+}
+
+/** Is the next thing after `q` the end of an argument? */
+function argumentEnds(code, q) {
+  const c = code[skipSpace(code, q)];
+  return c === ")" || c === ",";
+}
+
+/**
+ * What a mock call replaces, from just inside its `(`: a literal, an
+ * `import("x")`, a `require.resolve("x")` — or, for anything else, the
+ * argument's own text under `mocked-unknown`, because a mock we cannot aim is
+ * still a mock.
+ */
+function mockTarget(src, code, p) {
+  p = skipSpace(code, p);
+  const lit = readLiteral(src, code, p, true);
+  if (lit && argumentEnds(code, lit.end)) return { specifier: lit.value, kind: "mocked" };
+  if (startsWord(code, p, "import")) {
+    const open = skipSpace(code, p + "import".length);
+    if (code[open] === "(") {
+      const l = readLiteral(src, code, skipSpace(code, open + 1), true);
+      if (l) {
+        const close = skipSpace(code, l.end);
+        if (code[close] === ")" && argumentEnds(code, close + 1)) return { specifier: l.value, kind: "mocked", claimed: p };
+      }
+    }
+  }
+  const resolve = /^require\s*\.\s*resolve\s*\(/.exec(code.slice(p, p + 40));
+  if (resolve) {
+    const l = readLiteral(src, code, skipSpace(code, p + resolve[0].length), true);
+    if (l) {
+      const close = skipSpace(code, l.end);
+      if (code[close] === ")" && argumentEnds(code, close + 1)) return { specifier: l.value, kind: "mocked" };
+    }
+  }
+  return { specifier: argumentText(code, p), kind: "mocked-unknown" };
+}
+
+/**
+ * The argument starting at `p`, up to its `,` or `)`, whitespace collapsed,
+ * at most 120 characters — read from the MASK, so a string's body or a
+ * comment (where a credential would be) never travels, only the code's shape:
+ * `modPath`, `" " + name`.
+ */
+function argumentText(code, p) {
+  let depth = 0;
+  let j = p;
+  const stop = Math.min(code.length, p + 500);
+  for (; j < stop; j++) {
+    const c = code[j];
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") {
+      if (depth === 0) break;
+      depth--;
+    } else if (c === "," && depth === 0) break;
+  }
+  const text = code.slice(p, j).replace(/\s+/g, " ").trim().slice(0, 120);
+  return text || "?";
+}
+
+/** `@scope/name/sub` → `@scope/name`; `name/sub` → `name`. */
+function packageRoot(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+
+/** `import { vi as v, mock as m } from "vitest"` → `v`, `m`. */
+function runnerAliases(tokens) {
+  const out = [];
+  for (let k = 0; k + 2 < tokens.length; k++) {
+    if (RUNNER_MOCKERS.has(tokens[k]) && tokens[k + 1] === "as" && /^[A-Za-z_$][\w$]*$/.test(tokens[k + 2])) out.push(tokens[k + 2]);
+  }
+  return out;
+}
+
+/**
+ * A static `import … from "x"`, `import "x"` or `export … from "x"` starting
+ * right after its keyword — or `null` when what follows is not one.
+ *
+ * Only the grammar of import bindings may stand between the keyword and
+ * `from`. Anything else — `=`, `(`, `:`, `;`, another `import` or `export` —
+ * ends the attempt, so a declaration (`export const`, `export function`,
+ * `export type X = …`) is never paired with a clause further down. That is
+ * what the keyword-anchored regex of #992 got wrong in code without
+ * semicolons: `export const C = f({…})\nexport type { P } from "./x"` gave
+ * `./x` the kind of the first statement.
+ */
+/**
+ * What an `export` starting with these can never be: a re-export `from` a
+ * module. Only for `export`: `import async from "async"` is a default binding
+ * that happens to be spelled like a keyword.
+ */
+const NOT_A_CLAUSE = new Set(["default", "enum", "class", "const", "let", "var", "function", "async", "abstract", "declare", "interface", "namespace", "module", "global"]);
+
+function scanStatement(
+  src,
+  code,
+  word,
+  p,
+) {
+  const tokens = [];
+  let braces = 0;
+  for (;;) {
+    p = skipSpace(code, p);
+    if (p >= code.length) return null;
+    const c = code[p];
+    if (c === '"' || c === "'") {
+      const lit = readLiteral(src, code, p, false);
+      if (!lit) return null;
+      // `import "./register"` — a module loaded for its effects.
+      if (word === "import" && tokens.length === 0) return { specifier: lit.value, end: lit.end, typeOnly: false, deferred: false, tokens };
+      // `import { "a-b" as ab } from "./x"` — a quoted name, inside braces only.
+      if (braces === 0) return null;
+      tokens.push('"');
+      p = lit.end;
+      continue;
+    }
+    if (isIdentChar(c)) {
+      let q = p;
+      while (q < code.length && isIdentChar(code[q])) q++;
+      const name = code.slice(p, q);
+      if (name === "import" || name === "export") return null;
+      if (name === "from" && braces === 0 && !(word === "export" && NOT_A_CLAUSE.has(tokens[0] ?? ""))) {
+        const at = skipSpace(code, q);
+        if (code[at] === '"' || code[at] === "'") {
+          const lit = readLiteral(src, code, at, false);
+          // `import defer * as ns` evaluates the module on first use — maybe never.
+          const deferred = tokens[0] === "defer" && tokens[1] === "*";
+          return lit ? { specifier: lit.value, end: lit.end, typeOnly: bindingsAreTypeOnly(tokens), deferred, tokens } : null;
+        }
+      }
+      tokens.push(name);
+      p = q;
+      continue;
+    }
+    if (c === "{") braces++;
+    else if (c === "}") {
+      if (--braces < 0) return null;
+    } else if (c !== "," && c !== "*") return null;
+    tokens.push(c);
+    p++;
+  }
+}
+
+/**
+ * Does this statement leave the module unrun, by its syntax alone?
+ *
+ * `import type X`, `import type { … }`, `import type * as ns`, `export type
+ * { … }`, `export type *`, Flow's `import typeof X` do; so does a source-phase
+ * `import source x`, which fetches the module and never evaluates it.
+ * `import type from "./x"` does NOT — that is a default binding named `type` —
+ * and neither does `import type, { a }`. Braces with nothing outside them are
+ * type-only when EVERY binding carries `type`; a single value binding, a
+ * default or a namespace loads the module. `{ type as foo }` is a value
+ * binding named `type`, renamed.
+ */
+function bindingsAreTypeOnly(tokens) {
+  if ((tokens[0] === "type" || tokens[0] === "typeof") && tokens.length >= 2 && tokens[1] !== ",") return true;
+  if (tokens[0] === "source" && tokens.length === 2 && tokens[1] !== "," && tokens[1] !== "{" && tokens[1] !== "*") return true;
+  if (tokens[0] !== "{" || tokens[tokens.length - 1] !== "}") return false;
+  const groups = [[]];
+  for (const t of tokens.slice(1, -1)) {
+    if (t === "{" || t === "}") return false;
+    if (t === ",") groups.push([]);
+    else groups[groups.length - 1].push(t);
+  }
+  const named = groups.filter((g) => g.length > 0);
+  return named.length > 0 && named.every((g) => (g[0] === "type" || g[0] === "typeof") && g.length >= 2 && !(g.length === 3 && g[1] === "as"));
+}
+
+// ───────────────────────────────── the mask ─────────────────────────────────
+
+/** Keywords after which a `/` starts a regex, and a `<` a JSX element. */
+const EXPRESSION_AFTER_WORD = new Set([
+  "return", "typeof", "instanceof", "in", "of", "new", "delete", "void", "throw",
+  "case", "do", "else", "yield", "await", "default", "break", "continue", "debugger",
+]);
+/**
+ * Of those, the ones that can also be an identifier — `of` in `for (const of
+ * of list)`, `await` and `yield` outside async functions and generators — so
+ * a `/` after them is a guess like one after `)`.
+ */
+const AMBIGUOUS_WORDS = new Set(["of", "await", "yield"]);
+/** Keywords whose `( … )` is a condition, after which a `/` starts a regex: `if (x) /re/.test(y)`. */
+const CONDITION_WORDS = new Set(["if", "while", "for", "with"]);
+
+/** Spaces for everything but line terminators, which keep their place: ASI and "same line" read them. */
+function blank(s) {
+  return /[\n\r\u2028\u2029]/.test(s) ? s.replace(/[^\n\r\u2028\u2029]/g, " ") : " ".repeat(s.length);
+}
+
+/** Is the character at `at` preceded by an ODD number of backslashes? */
+function isEscaped(src, at) {
+  let back = 0;
+  for (let k = at - 1; k >= 0 && src[k] === "\\"; k--) back++;
+  return back % 2 === 1;
+}
+
+/** JavaScript's line terminators. A `//` comment and a regex end at any of them; a quoted string at the first two. */
+function isLineEnd(c) {
+  return c === "\n" || c === "\r" || c === "\u2028" || c === "\u2029";
+}
+
+/** Only white space between the start of this line and `at`. */
+function lineStartsAt(src, at) {
+  for (let k = at - 1; k >= 0 && !isLineEnd(src[k]); k--) if (!isSpace(src[k])) return false;
+  return true;
+}
+
+/**
+ * Past balanced `<…>` starting at `p` in the SOURCE — a JSX element's type
+ * arguments, which run over lines, hold object types with `;` between their
+ * members (`<Table<{ id: string; label: string }>`, as Prettier prints them)
+ * and string types that may hold a `>` (`<Select<"a>b">`) — or `-1`. A `;`
+ * outside every brace ends a statement, not a type.
+ */
+function skipAngles(src, p) {
+  let depth = 0;
+  let braces = 0;
+  const stop = Math.min(src.length, p + 1_000);
+  for (let j = p; j < stop; j++) {
+    const c = src[j];
+    if (c === '"' || c === "'" || c === "`") {
+      const close = src.indexOf(c, j + 1);
+      if (close < 0 || close >= stop) return -1;
+      j = close;
+    } else if (c === "{") braces++;
+    else if (c === "}") braces--;
+    else if (c === "<") depth++;
+    else if (c === ">" && src[j - 1] !== "=") {
+      if (--depth === 0) return braces === 0 ? j + 1 : -1;
+    } else if (c === ";" && braces === 0) return -1;
+  }
+  return -1;
+}
+
+/**
+ * Where a regex starting at the `/` at `at` would end, or `-1` — the same
+ * scan as the lexer's, without its memo and bounded, because it only asks
+ * whether a guess matters: a regex literal a thousand characters long is not
+ * worth the time to read twice.
+ */
+function probeRegex(src, at) {
+  let cls = false;
+  const stop = Math.min(src.length, at + 1_000);
+  for (let j = at + 1; j < stop; j++) {
+    const s = src[j];
+    if (isLineEnd(s)) return -1;
+    if (s === "\\") {
+      j++;
+      continue;
+    }
+    if (s === "[") cls = true;
+    else if (s === "]") cls = false;
+    else if (s === "/" && !cls) return j + 1;
+  }
+  return -1;
+}
+
+/** A numeric literal, from its first digit: `0x1F`, `1_000n`, `1.`, `1.5e-3`. */
+const NUMBER = /0[xXbBoO][\da-fA-F_]*n?|\d[\d_]*\.?[\d_]*(?:[eE][+-]?[\d_]+)?n?/y;
+
+/**
+ * How many JSX attempts a file may roll back. Past it, JSX is not lexed for
+ * the rest of the file — and the point it stopped is the file's doubt, so no
+ * load after it is published.
+ */
+const JSX_ROLLBACKS = 64;
+
+/**
+ * The source with everything that is not code turned into spaces, the offsets
+ * of the `import`/`export` keywords that stand at the top of the module, and
+ * the first offset where the lexer had to GUESS in a way that decides what is
+ * code — `doubtAt`, `-1` when it never did.
+ *
+ * A terminated quoted string keeps its quotes, so the scanner can find it and
+ * read it back from the source; an unterminated one (a line end before the
+ * closing quote — JavaScript ends it there, and a diff fragment is full of
+ * them) is blanked whole. A template keeps its backticks and its `${…}`
+ * expressions, which are code and are lexed as code, nested templates
+ * included; its text, and the `${` and `}` around each expression, are
+ * blanked. JSX — where the file can hold it — is blanked whole except the code
+ * inside its `{…}`: tag names and their type arguments, attributes, attribute
+ * strings (which have no escapes and may span lines), element-valued
+ * attributes, and text, where an apostrophe is prose and not a quote.
+ *
+ * THE DOUBT. A lexer without a parser guesses, and a wrong guess about a
+ * quote or a backtick does not stay local: it re-pairs every delimiter after
+ * it, and text becomes code. Every guess that can do that is recorded, and
+ * the first one's offset is `doubtAt`:
+ *   · a JSX attempt rolled back — its attribute strings (no escapes) and text
+ *     (an apostrophe is prose) are re-read as code;
+ *   · a `<` where an expression starts, in a file that can hold JSX, that is
+ *     not read as JSX on anything but TypeScript's own rule — a type alias's
+ *     right side, an interface body and `<T>(…)` are probably type
+ *     parameters, and probably is a guess; a `<` at a line start after a value
+ *     (JSX after ASI, or a comparison continuing);
+ *   · the rollback budget running out, after which JSX is not lexed at all;
+ *   · a `/` after `)`, `}`, a word that can be a name (`of`, `await`,
+ *     `yield`) or at a line start after a value, where the regex reading
+ *     would close on the same line — both readings are possible, and each
+ *     can re-pair what follows (the division reading re-lexes the would-be
+ *     closing `/`);
+ *   · a merge conflict's markers;
+ *   · a closing bracket that closes nothing open;
+ *   · an HTML-like comment in a `.js`/`.cjs` (a script's comment, a module's
+ *     operators).
+ * Past `doubtAt` the extractor publishes no load — only `uncertain`.
+ */
+function lexModule(
+  src,
+  jsx,
+  typescript,
+  script,
+) {
+  const n = src.length;
+  const parts = [];
+  let emitted = 0;
+  const hide = (from, to) => {
+    if (to <= from) return;
+    if (from > emitted) parts.push(src.slice(emitted, from));
+    parts.push(blank(src.slice(from, to)));
+    emitted = to;
+  };
+
+  let stack = [];
+  const topLevel = new Set();
+  let doubtAt = -1;
+  const doubt = (at) => {
+    if (doubtAt < 0 || at < doubtAt) doubtAt = at;
+  };
+  // What came before a `/` or a `<`: nothing yet, a punctuator, a word, a
+  // closing bracket, or a value. Only the last three make them operators.
+  let prev = "start";
+  let prevWord = "";
+  // The closing bracket just read, if the last token was one: `)` and `}` are
+  // where a `/` could honestly be either.
+  let closer = "";
+  // How many `.` tokens in a row came last (comments and spaces between do
+  // not count): one makes the next word a property, three are a spread.
+  let dots = 0;
+  // A line terminator since the last token — in white space or inside a
+  // comment — which is what ASI reads. `lineStartsAt` looks at the text of
+  // the line and a comment before the token defeats it.
+  let brokeLine = false;
+  // Where the code of each `${…}` and each JSX `{…}` starts: the mask blanks
+  // their openers, and what stands right after one is not after whatever
+  // came before the blank.
+  const exprStarts = new Map();
+  // The last three code tokens — words as themselves, anything else as its
+  // first character — so `type F = <T>(…)` can be told from the text, where
+  // a comment saying `// type X =` would have told it wrong.
+  const hist = [];
+  const saw = (t) => {
+    hist.push(t);
+    if (hist.length > 3) hist.shift();
+  };
+  // A regex scan that ran into a line end without closing: no `/` before that
+  // line end opens one, or a line of unclosed classes would be scanned once
+  // per slash.
+  let noRegexUntil = -1;
+  // JSX: blanked from `hideFrom` until code resumes; one snapshot per
+  // outermost element, restored when the element turns out not to be one.
+  let jsxOn = jsx;
+  let rollbacks = 0;
+  let hideFrom = -1;
+  let notJsxAt = -1;
+  let snap = null;
+
+  let i = 0;
+  const expressionStarts = () => prev === "start" || prev === "punct" || (prev === "word" && EXPRESSION_AFTER_WORD.has(prevWord));
+  const valueBefore = () => prev === "value" || prev === "close" || (prev === "word" && !EXPRESSION_AFTER_WORD.has(prevWord));
+  const inJsx = () => stack.some((f) => f.k === "jsx");
+
+  /** Where a regex starting at `/` at `at` would end on its line, or `-1` with `noRegexUntil` set. */
+  const regexEnd = (at) => {
+    let cls = false;
+    for (let j = at + 1; j < n; j++) {
+      const s = src[j];
+      if (isLineEnd(s)) {
+        noRegexUntil = j;
+        return -1;
+      }
+      if (s === "\\") {
+        j++;
+        continue;
+      }
+      if (s === "[") cls = true;
+      else if (s === "]") cls = false;
+      else if (s === "/" && !cls) {
+        j++;
+        while (j < n && isIdentChar(src[j])) j++; // flags
+        return j;
+      }
+    }
+    noRegexUntil = n;
+    return -1;
+  };
+
+  /**
+   * Scan template text from `j`: where it ends (just past the closing
+   * backtick), where a `${` expression starts (just past the brace), or — for
+   * a template that never closes — the end of the input.
+   */
+  const templateText = (j) => {
+    for (; j < n; j++) {
+      const c = src[j];
+      if (c === "\\") {
+        j++;
+        continue;
+      }
+      if (c === "`") return { end: j + 1, to: "close" };
+      if (c === "$" && src[j + 1] === "{") return { end: j + 2, to: "expr" };
+    }
+    return { end: n, to: "eof" };
+  };
+  /**
+   * Blank template text from `from` (the opening backtick, or the `}` that
+   * closed an expression) and step past it. The opening backtick stays — it is
+   * what a scanner reads a plain template back by — the closing one stays so
+   * the pair still reads as one token, and a template that never closes is
+   * blanked to the end, backtick and all, so no lone backtick is left to pair
+   * with anything.
+   */
+  const template = (from, keepFirst) => {
+    const t = templateText(from + 1);
+    const start = keepFirst ? from + 1 : from;
+    if (t.to === "eof") hide(keepFirst ? from : start, n);
+    else hide(start, t.to === "close" ? t.end - 1 : t.end);
+    if (t.to === "expr") {
+      stack.push({ k: "tpl" });
+      exprStarts.set(t.end, "tpl");
+      prev = "start";
+    } else prev = "value";
+    closer = "";
+    brokeLine = false;
+    i = t.end;
+  };
+
+  /** An identifier-ish JSX name at `j` (`div`, `Foo.Bar`, `svg:rect`, `data-x`), or `""`. */
+  const jsxName = (j) => {
+    let q = j;
+    while (q < n && (isIdentChar(src[q]) || src[q] === "." || src[q] === ":" || src[q] === "-")) q++;
+    return src.slice(j, q);
+  };
+
+  /**
+   * An element's opening at `j` (just past its `<`): a fragment, or a name
+   * with — in TypeScript — its type arguments. Returns where the tag's body
+   * starts, or `-1` when this is not an element.
+   */
+  const openElement = (j) => {
+    j = skipSpace(src, j);
+    if (src[j] === ">") {
+      stack.push({ k: "jsx", name: "", open: false });
+      if (snap) snap.children = true;
+      return j + 1;
+    }
+    const name = jsxName(j);
+    if (!name || /^[\d.:-]/.test(name)) return -1;
+    let k = j + name.length;
+    if (typescript && src[skipSpace(src, k)] === "<") {
+      k = skipAngles(src, skipSpace(src, k));
+      if (k < 0) return -1;
+    }
+    stack.push({ k: "jsx", name, open: true });
+    return k;
+  };
+
+  /** Undo the outermost JSX attempt: the `<` that began it is an operator after all. */
+  const rollback = (ranToEnd) => {
+    const s = snap;
+    // A rollback re-reads what it lexed as JSX — attribute strings that have
+    // no escapes, text with an apostrophe — as code: from here on, what is
+    // code is a guess.
+    void ranToEnd;
+    doubt(s.i);
+    i = s.i;
+    emitted = s.emitted;
+    parts.length = s.parts;
+    stack = s.stack.slice();
+    prev = s.prev;
+    prevWord = s.prevWord;
+    closer = s.closer;
+    dots = s.dots;
+    noRegexUntil = s.noRegexUntil;
+    hideFrom = -1;
+    notJsxAt = s.i;
+    snap = null;
+    if (++rollbacks >= JSX_ROLLBACKS) {
+      jsxOn = false;
+      doubt(s.i);
+    }
+  };
+
+  /** An element closed: back to its parent (children, or a tag it is an attribute of), or to code. */
+  const elementClosed = () => {
+    stack.pop();
+    if (inJsx() && stack[stack.length - 1].k === "jsx") return;
+    if (hideFrom >= 0) hide(hideFrom, i);
+    hideFrom = -1;
+    prev = "value";
+    closer = "";
+    dots = 0;
+    if (!inJsx()) snap = null;
+  };
+
+  if (src.startsWith("#!", src.charCodeAt(0) === 0xfeff ? 1 : 0)) {
+    let nl = 0;
+    while (nl < n && !isLineEnd(src[nl])) nl++;
+    i = nl;
+    hide(0, i);
+  }
+
+  for (;;) {
+    while (i < n) {
+      const top = stack[stack.length - 1];
+
+      // ── JSX: a tag and its attributes
+      if (top && top.k === "jsx" && top.open) {
+        const c = src[i];
+        if (isSpace(c)) {
+          i++;
+          continue;
+        }
+        if (c === "/" && src[skipSpace(src, i + 1)] === ">") {
+          i = skipSpace(src, i + 1) + 1;
+          elementClosed();
+          continue;
+        }
+        if (c === ">") {
+          top.open = false;
+          if (snap) snap.children = true;
+          i++;
+          continue;
+        }
+        if (c === "{") {
+          hide(hideFrom, i + 1);
+          hideFrom = -1;
+          stack.push({ k: "jsxexpr" });
+          exprStarts.set(i + 1, "jsx");
+          prev = "start";
+          closer = "";
+          dots = 0;
+          brokeLine = false;
+          i++;
+          continue;
+        }
+        if (c === "/" && (src[i + 1] === "*" || src[i + 1] === "/")) {
+          if (src[i + 1] === "*") {
+            const end = src.indexOf("*/", i + 2);
+            i = end < 0 ? n : end + 2;
+          } else {
+            while (i < n && !isLineEnd(src[i])) i++;
+          }
+          continue;
+        }
+        if (isIdentChar(c)) {
+          i += Math.max(1, jsxName(i).length);
+          const eq = skipSpace(src, i);
+          if (src[eq] !== "=") continue;
+          const v = skipSpace(src, eq + 1);
+          const q = src[v];
+          if (q === '"' || q === "'") {
+            const close = src.indexOf(q, v + 1);
+            if (close < 0) {
+              rollback(true);
+              continue;
+            }
+            i = close + 1;
+            continue;
+          }
+          if (q === "<") {
+            // An element as the value: `icon=<Info />`.
+            const k = openElement(v + 1);
+            if (k < 0) {
+              rollback(false);
+              continue;
+            }
+            i = k;
+            continue;
+          }
+          i = v; // `{…}` is read on the next turn; anything else fails there
+          continue;
+        }
+        rollback(false);
+        continue;
+      }
+
+      // ── JSX: children
+      if (top && top.k === "jsx") {
+        const c = src[i];
+        if (c === "{") {
+          hide(hideFrom, i + 1);
+          hideFrom = -1;
+          stack.push({ k: "jsxexpr" });
+          exprStarts.set(i + 1, "jsx");
+          prev = "start";
+          closer = "";
+          dots = 0;
+          brokeLine = false;
+          i++;
+          continue;
+        }
+        if (c === "<") {
+          const j = skipSpace(src, i + 1);
+          if (src[j] === "/") {
+            const k = skipSpace(src, j + 1);
+            const name = jsxName(k);
+            const gt = skipSpace(src, k + name.length);
+            if (src[gt] !== ">" || name !== top.name) {
+              rollback(true);
+              continue;
+            }
+            i = gt + 1;
+            elementClosed();
+            continue;
+          }
+          const k = openElement(i + 1);
+          if (k >= 0) {
+            i = k;
+            continue;
+          }
+        }
+        i++;
+        continue;
+      }
+
+      // ── code
+      const c = src[i];
+      const next = src[i + 1];
+
+      if (isSpace(c)) {
+        if (isLineEnd(c)) brokeLine = true;
+        i++;
+        continue;
+      }
+
+      if (c === "/" && next === "/" && !isEscaped(src, i)) {
+        let j = i;
+        while (j < n && !isLineEnd(src[j])) j++;
+        hide(i, j);
+        i = j;
+        continue;
+      }
+      if (c === "/" && next === "*" && !isEscaped(src, i)) {
+        const close = src.indexOf("*/", i + 2);
+        const j = close < 0 ? n : close + 2;
+        if (/[\n\r\u2028\u2029]/.test(src.slice(i, j))) brokeLine = true;
+        hide(i, j);
+        i = j;
+        continue;
+      }
+      // HTML-like comments: a script's comment, a module's operators. Only a
+      // JavaScript file that is not declared a module can be a script, and
+      // which one it is we cannot tell from here — so it is a guess.
+      if (script && ((c === "<" && src.startsWith("<!--", i)) || (c === "-" && src.startsWith("-->", i) && lineStartsAt(src, i)))) {
+        doubt(i);
+        let j = i;
+        while (j < n && !isLineEnd(src[j])) j++;
+        hide(i, j);
+        i = j;
+        continue;
+      }
+
+      // Every token from here on is code: it either IS a dot or ends a run of
+      // them, and it is a closing bracket or it ends what one said.
+      const property = dots === 1;
+      dots = c === "." ? dots + 1 : 0;
+      const after = closer;
+      closer = "";
+      const newLine = brokeLine;
+      brokeLine = false;
+
+      if (c === '"' || c === "'") {
+        let j = i + 1;
+        let terminated = false;
+        for (; j < n; j++) {
+          const s = src[j];
+          if (s === "\\") {
+            j += src[j + 1] === "\r" && src[j + 2] === "\n" ? 2 : 1;
+            continue;
+          }
+          if (s === c) {
+            terminated = true;
+            break;
+          }
+          if (s === "\n" || s === "\r") break;
+        }
+        if (terminated) {
+          if (j > i + 1) hide(i + 1, j);
+          i = j + 1;
+        } else {
+          hide(i, j);
+          i = j;
+        }
+        prev = "value";
+        saw('"');
+        continue;
+      }
+
+      if (c === "`") {
+        saw("`");
+        template(i, true);
+        continue;
+      }
+
+      if (c === "}" && top && (top.k === "tpl" || top.k === "jsxexpr")) {
+        stack.pop();
+        if (top.k === "tpl") template(i, false);
+        else {
+          // Back into the JSX that holds this expression; the brace is JSX.
+          hideFrom = i;
+          i++;
+        }
+        continue;
+      }
+
+      if (c === "/") {
+        // After `)`, `}` or a word that may be a name, a `/` can honestly be
+        // either. When the span a regex would take holds anything that pairs
+        // or nests — a quote, a backtick, a bracket — or ends against a `*` or
+        // a `/`, the two readings lex the rest differently, and whichever we
+        // take is a guess.
+        // A `/` at the start of a line after a value is the same guess: it
+        // divides if the line above continues, and starts a regex if ASI ended
+        // it (`let quote` then `/['"]/.test(src)`).
+        //
+        // When both readings are possible — the regex would close on this
+        // line — the one we take is a guess, whatever the span holds: the
+        // regex reading hides what the span holds, and the division reading
+        // re-lexes the would-be regex's closing `/`, which can open a regex or
+        // a `//` of its own. Two review rounds found a new way each time the
+        // guess was excused by what the span contained.
+        const afterLineEnd = valueBefore() && newLine;
+        if ((after === ")" || after === "}" || afterLineEnd || (prev === "word" && AMBIGUOUS_WORDS.has(prevWord))) && i >= noRegexUntil) {
+          if (probeRegex(src, i) > 0) doubt(i);
+        }
+        if (expressionStarts() && i >= noRegexUntil) {
+          const end = regexEnd(i);
+          if (end > 0) {
+            hide(i, end);
+            i = end;
+            prev = "value";
+            saw("/");
+            continue;
+          }
+        }
+        prev = "punct";
+        i++;
+        continue;
+      }
+
+      // A merge conflict's markers: TypeScript reads one side as trivia, we
+      // read both. Either side may be the one that runs.
+      if ((c === "<" || c === "=" || c === ">" || c === "|") && /^(?:<{7}|={7}|>{7}|\|{7})/.test(src.slice(i, i + 7)) && lineStartsAt(src, i)) {
+        doubt(i);
+      }
+
+      // `<<`, `<=`, `<<=` are operators, whatever came before them.
+      if (c === "<" && (next === "<" || next === "=")) {
+        i += next === "<" && src[i + 2] === "=" ? 3 : 2;
+        prev = "punct";
+        continue;
+      }
+
+      // At the start of a line after a value, a `<` continues a comparison — or
+      // ASI ended the line and an element starts (`let el` then `<p>…`). We
+      // read the comparison; when an element could start there, it is a guess.
+      if (c === "<" && jsxOn && valueBefore() && newLine) {
+        const j = skipSpace(src, i + 1);
+        if (src[j] === ">" || jsxName(j) !== "") doubt(i);
+      }
+
+      if (c === "<" && jsxOn && i !== notJsxAt && expressionStarts()) {
+        const j = skipSpace(src, i + 1);
+        const name = src[j] === ">" ? "" : jsxName(j);
+        // `<T,>(…) =>` and `<T extends U>(…) =>` are a generic arrow's type
+        // parameters — TypeScript itself tells them from JSX this way, so
+        // that is knowledge. `type F = <T>(x: T) => T` and a signature's
+        // `<T>(` are read as type parameters too, but by a guess.
+        const aliasRight = hist.length === 3 && hist[0] === "type" && /^[A-Za-z_$][\w$]*$/.test(hist[1]) && hist[2] === "=";
+        // Inside the body of an `interface` or a `type X = { … }` every `<` is
+        // a type's.
+        const inTypeBody = top !== undefined && top.k === "brace" && top.type === true;
+        // TypeScript's own rule, read off the characters: `<T,` or `<T extends
+        // U` — an `extends` followed by a type, not by `>`, `=` or `/`, which
+        // TypeScript reads as JSX. That is knowledge. What the token history
+        // says (a type alias's right side, an interface body) is only likely:
+        // a template's `${type}`, a JSX `{type}`, ASI after a field named
+        // `type` all fooled it.
+        const certainlyGeneric =
+          typescript && name !== "" && /^\s*(?:,|extends\s+[^\s>=/])/.test(src.slice(j + name.length, j + name.length + 16));
+        const likelyGeneric =
+          typescript &&
+          name !== "" &&
+          (aliasRight || inTypeBody || (/^[A-Z][A-Za-z0-9]?$/.test(name) && /^\s*>\s*\(/.test(src.slice(j + name.length, j + name.length + 8))));
+        if (!certainlyGeneric && !likelyGeneric) {
+          const depthBefore = stack.length;
+          const k = openElement(i + 1);
+          if (k >= 0) {
+            if (!snap) {
+              snap = { i, emitted, parts: parts.length, stack: stack.slice(0, depthBefore), prev, prevWord, closer: after, dots: 0, noRegexUntil, children: false };
+            }
+            const opened = stack[stack.length - 1];
+            if (opened.k === "jsx" && !opened.open) snap.children = true;
+            hideFrom = i;
+            i = k;
+            continue;
+          }
+        }
+        // A `<` where an expression starts, in a file that can hold JSX, that
+        // we do not read as JSX: unless TypeScript's own rule said so, that
+        // is a guess, and the text after it is lexed as code on its strength.
+        if (!certainlyGeneric) doubt(i);
+      }
+
+      // A private name (`this.#new`) is a name, whatever it spells.
+      if (c === "#" && isIdentChar(next)) {
+        let j = i + 1;
+        while (j < n && isIdentChar(src[j])) j++;
+        prev = "word";
+        prevWord = "";
+        i = j;
+        continue;
+      }
+
+      // A number, with its dot: `1./2` is one, divided, and `1..x` is its property.
+      if (c >= "0" && c <= "9") {
+        NUMBER.lastIndex = i;
+        const m = NUMBER.exec(src);
+        let j = m ? i + m[0].length : i + 1;
+        while (j < n && isIdentChar(src[j])) j++;
+        prev = "value";
+        saw("0");
+        i = j;
+        continue;
+      }
+
+      if (isIdentChar(c)) {
+        let j = i + 1;
+        while (j < n && isIdentChar(src[j])) j++;
+        if (property) {
+          // `size.new / 2` divides: a keyword spelled as a property is a name.
+          prev = "word";
+          prevWord = "";
+        } else {
+          prev = "word";
+          prevWord = src.slice(i, j);
+          if (stack.length === 0 && (prevWord === "import" || prevWord === "export")) topLevel.add(i);
+        }
+        saw(property ? "." + src.slice(i, j) : src.slice(i, j));
+        i = j;
+        continue;
+      }
+
+      // `i++ / 2` and `total! / n`: postfix operators end a value.
+      if ((c === "+" || c === "-") && next === c && valueBefore() && !newLine) {
+        i += 2;
+        prev = "value";
+        continue;
+      }
+      // A `!` after a value on its line is TypeScript's non-null (`x !` too) —
+      // in JavaScript nothing else could stand there.
+      if (c === "!" && next !== "=" && valueBefore() && !newLine) {
+        i++;
+        prev = "value";
+        continue;
+      }
+
+      let nextPrev = "punct";
+      if (c === "{") {
+        // The body of `interface I {`, of `type T = {`, or a type literal inside one.
+        // A property is recorded as `.name`, so `net.interface` and `props.type`
+        // cannot pass for the keywords; the name must be an identifier, so
+        // `acc[type] = {` and `{ interface: {` cannot either.
+        const ident = (t) => t !== undefined && /^[A-Za-z_$][\w$]*$/.test(t);
+        const typeBody =
+          typescript &&
+          ((hist.length >= 2 && hist[hist.length - 2] === "interface" && ident(hist[hist.length - 1])) ||
+            (hist.length === 3 && hist[0] === "type" && ident(hist[1]) && hist[2] === "=") ||
+            (top !== undefined && top.k === "brace" && top.type === true));
+        stack.push({ k: "brace", type: typeBody });
+      }
+      else if (c === "(") {
+        const condition = prev === "word" && (CONDITION_WORDS.has(prevWord) || (prevWord === "await" && hist[hist.length - 2] === "for"));
+        stack.push({ k: "paren", condition });
+      }
+      else if (c === "[") stack.push({ k: "bracket" });
+      else if (c === "}" || c === ")" || c === "]") {
+        const want = c === "}" ? "brace" : c === ")" ? "paren" : "bracket";
+        const condition = top !== undefined && top.k === "paren" && top.condition;
+        if (top && top.k === want) {
+          stack.pop();
+          // A closing paren or bracket ends a value — except the paren of a
+          // condition, after which a statement (and a regex) can start.
+          if (c !== "}") nextPrev = condition ? "punct" : "close";
+        } else {
+          // Closes nothing that is open: somewhere before this, a guess went wrong.
+          doubt(i);
+          if (c !== "}") nextPrev = "close";
+        }
+        // After a condition's `)` a `/` is known to open a regex; after any
+        // other `)` or a `}` it is a guess.
+        closer = condition ? "" : c;
+      }
+      saw(c);
+      // A closing brace ends a block as often as an object, and a regex after a
+      // block is the likelier reading.
+      prev = nextPrev;
+      i++;
+    }
+    // The end of the input inside a JSX element: it never closed, so it was
+    // never JSX. Read the `<` as an operator and go on from there.
+    if (snap) {
+      rollback(true);
+      continue;
+    }
+    if (hideFrom >= 0) hide(hideFrom, n);
+    break;
+  }
+  if (emitted < n) parts.push(src.slice(emitted));
+  return { code: parts.join(""), topLevel, doubtAt, exprStarts };
+}
+// END module-edges.ts
+
+// ───────────────────────────── path classification ─────────────────────────────
+
+const TEST_FILE_RX = [
+  /\.test\.(?:ts|tsx|js|jsx|mjs|cjs)$/i,
+  /\.spec\.(?:ts|tsx|js|jsx|mjs|cjs)$/i,
+  /_test\.(?:py|go|rb|rs|dart)$/i,
+  /(?:^|\/)test_[^/]+\.(?:py|go|rb|rs)$/i,
+  /Tests?\.(?:swift|kt|kts|java|cs)$/,
+  /Spec\.(?:kt|kts|scala|groovy)$/,
+];
+
+const TEST_DIR_RX = [/(?:^|\/)__tests__\//i, /(?:^|\/)tests?\//i, /(?:^|\/)specs?\//i];
+
+export function isTestPath(path) {
+  if (!path) return false;
+  if (TEST_FILE_RX.some((rx) => rx.test(path))) return true;
+  if (TEST_DIR_RX.some((rx) => rx.test(path))) return true;
+  return false;
+}
+
+const TEST_EXT = ["ts", "tsx", "js", "jsx", "mjs", "cjs", "py", "go", "rs", "rb"];
+
+/**
+ * The test files the product's own pairing rule expects for a source path.
+ *
+ * Every branch here was added by a live report getting it wrong — a Ruby file
+ * asked for `tally.test.rb`, a pytest module whose `tests/` peer was invisible,
+ * a monorepo package whose integration tests mirror `src/` one directory over.
+ * The list is not tidy and must not be tidied on this side alone.
+ */
+export function expectedTestPaths(sourcePath) {
+  if (!sourcePath || isTestPath(sourcePath)) return [];
+  const dir = sourcePath.includes("/") ? sourcePath.slice(0, sourcePath.lastIndexOf("/")) : "";
+  const base = sourcePath.includes("/") ? sourcePath.slice(sourcePath.lastIndexOf("/") + 1) : sourcePath;
+  const ext = base.includes(".") ? base.slice(base.lastIndexOf(".") + 1) : "";
+  const stem = base.includes(".") ? base.slice(0, base.lastIndexOf(".")) : base;
+
+  if (!ext || !TEST_EXT.includes(ext)) return [];
+
+  const candidates = [];
+  const join_ = (parts) => parts.filter(Boolean).join("/");
+
+  candidates.push(join_([dir, `${stem}.test.${ext}`]));
+  candidates.push(join_([dir, `${stem}.spec.${ext}`]));
+  candidates.push(join_([dir, "__tests__", `${stem}.test.${ext}`]));
+  candidates.push(join_([dir, "__tests__", `${stem}.spec.${ext}`]));
+  candidates.push(join_([dir, "__tests__", `${stem}.${ext}`]));
+
+  if (ext === "py") candidates.push(join_([dir, `test_${stem}.py`]));
+  if (ext === "go" || ext === "rs") candidates.push(join_([dir, `${stem}_test.${ext}`]));
+
+  if (ext === "py") {
+    candidates.push(join_([dir, "tests", `test_${stem}.py`]));
+    candidates.push(join_([dir, "tests", `${stem}_test.py`]));
+    candidates.push(join_([dir, "test", `test_${stem}.py`]));
+  }
+
+  if (ext === "rb") {
+    candidates.push(join_([dir, `${stem}_test.rb`]));
+    candidates.push(join_([dir, `${stem}_spec.rb`]));
+    candidates.push(join_([dir, "test", `${stem}_test.rb`]));
+    candidates.push(join_([dir, "spec", `${stem}_spec.rb`]));
+    const up = dir.includes("/") ? dir.slice(0, dir.lastIndexOf("/")) : "";
+    candidates.push(join_([up, "test", `${stem}_test.rb`]));
+    candidates.push(join_([up, "spec", `${stem}_spec.rb`]));
+  }
+
+  if (sourcePath.includes("/src/")) {
+    candidates.push(sourcePath.replace("/src/", "/tests/").replace(`.${ext}`, `.test.${ext}`));
+    candidates.push(sourcePath.replace("/src/", "/__tests__/").replace(`.${ext}`, `.test.${ext}`));
+  }
+
+  const srcAt = sourcePath.indexOf("/src/");
+  if (srcAt >= 0 || sourcePath.startsWith("src/")) {
+    const pkg = srcAt >= 0 ? sourcePath.slice(0, srcAt) : "";
+    const afterSrc = srcAt >= 0 ? sourcePath.slice(srcAt + 5) : sourcePath.slice(4);
+    const restDir = afterSrc.includes("/") ? afterSrc.slice(0, afterSrc.lastIndexOf("/")) : "";
+    const under = join_([pkg, "integration-tests", "__tests__", restDir]);
+    candidates.push(`${under}/${stem}/index.spec.${ext}`);
+    candidates.push(`${under}/${stem}.spec.${ext}`);
+    candidates.push(`${under}/${stem}.test.${ext}`);
+  }
+
+  return Array.from(new Set(candidates));
+}
+
+const SOURCE_EXT = /\.(?:[cm]?[jt]sx?)$/;
+const EXCLUDED_DIR = /(?:^|\/)(?:node_modules|dist|build|\.next|coverage|\.turbo|\.yarn)(?:\/|$)/;
+
+export function isGraphSource(path) {
+  return SOURCE_EXT.test(path) && !EXCLUDED_DIR.test(path);
+}
+
+/**
+ * WHICH paths a bundle carries. Every manifest and source file for the graph
+ * and the package map; the changed files and the tests paired to them for
+ * `contents`. A stem match across the whole repository would pull in every
+ * `index.spec.ts` in it for one changed `index.ts`.
+ */
+export function selectEvidence(treePaths, changedPaths) {
+  const tree = [...treePaths].sort();
+  const manifests = tree.filter((p) => /(?:^|\/)package\.json$/.test(p) && !EXCLUDED_DIR.test(p));
+  const sources = tree.filter(isGraphSource);
+  const changed = changedPaths.filter((p) => treePaths.has(p)).sort();
+  const pairedTests = [
+    ...new Set(changed.flatMap((p) => expectedTestPaths(p).filter((t) => treePaths.has(t) && !changed.includes(t)))),
+  ].sort();
+  return { manifests, sources, changed, pairedTests };
+}
+
+// ───────────────────────────────── the bundle ─────────────────────────────────
+
+/** `MANIFEST_FIELD_MAX_DEPTH` / `MANIFEST_FIELD_MAX_BYTES` in `@ao/types`, whose docblock says why. */
+export const MANIFEST_FIELD_MAX_DEPTH = 32;
+export const MANIFEST_FIELD_MAX_BYTES = 65_536;
+
+/** The twin of `manifestFieldFits` in `@ao/types`: iterative, so a hostile depth cannot overflow the check itself. */
+export function manifestFieldFits(v) {
+  const stack = [[v, 1]];
+  while (stack.length > 0) {
+    const [x, d] = stack.pop();
+    if (x === null || typeof x !== "object") continue;
+    if (d > MANIFEST_FIELD_MAX_DEPTH) return false;
+    for (const child of Object.values(x)) stack.push([child, d + 1]);
+  }
+  return JSON.stringify(v ?? null).length <= MANIFEST_FIELD_MAX_BYTES;
+}
+
+/** The twin of `manifestName` in git-source.ts. */
+export function manifestName(body) {
+  if (!body) return null;
+  try {
+    const name = JSON.parse(body.charCodeAt(0) === 0xfeff ? body.slice(1) : body)?.name;
+    return typeof name === "string" && name ? name : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * One manifest as the bundle carries it — the twin of `readManifest` in
+ * git-source.ts, which says why an unreadable one is still listed.
+ */
+export function readManifest(path, body) {
+  const dir = path.slice(0, -"package.json".length).replace(/\/$/, "");
+  const none = { dir, readable: false, name: null, main: null, module: null, types: null, exports: null, imports: null };
+  if (!body) return none;
+  let json;
+  try {
+    json = JSON.parse(body.charCodeAt(0) === 0xfeff ? body.slice(1) : body);
+  } catch {
+    return none;
+  }
+  if (!json || typeof json !== "object" || Array.isArray(json)) return none;
+  if (!manifestFieldFits(json.exports) || !manifestFieldFits(json.imports)) return none;
+  const str = (v) => (typeof v === "string" && v ? v : null);
+  return {
+    dir,
+    readable: true,
+    name: str(json.name),
+    main: str(json.main),
+    module: str(json.module),
+    types: str(json.types) ?? str(json.typings),
+    exports: json.exports === undefined ? null : json.exports,
+    imports: json.imports === undefined ? null : json.imports,
+  };
+}
+
+/**
+ * The bundle from a tree and a way to read its files — the twin of the stand's
+ * `buildEvidence`, down to the sort orders, because the sort orders ARE the
+ * bytes that `bundleHash` hashes.
+ *
+ * `sent` is DERIVED here and a literal there, and that difference is the point
+ * of this file: the stand reads a commit and never runs out of time, a hook
+ * has a budget and a repository that may have no manifests at all.
+ *
+ * The caller says which sections to BUILD (`want`) and why the others are
+ * missing (`absences`); it never says what was sent. That used to be an input,
+ * and it made the one shape the server refuses representable — `sent.graph:
+ * true` beside `graph: {edges: []}` after a budget ran out mid-read.
+ * `sentAgreesWithBody` then 400s the WHOLE body at the door, losing the tree
+ * with it, and the only trace is a line in a local log while the review has
+ * already paid its wait. Derived, that bundle cannot be written down at all.
+ */
+export function buildEvidence(input) {
+  const sel = selectEvidence(input.tree.paths, input.changedPaths);
+  const want = input.want ?? { tree: true, graph: true, packageMap: true, contents: true };
+  const wanted = [
+    ...new Set([
+      ...(want.packageMap ? sel.manifests : []),
+      ...(want.graph ? sel.sources : []),
+      ...(want.contents ? [...sel.changed, ...sel.pairedTests] : []),
+    ]),
+  ].sort();
+  const read = input.read(wanted);
+
+  // Everything actually produced. A section is in here or it is not sent —
+  // there is no third state, and no way to say one and mean the other.
+  const built = {};
+  if (want.tree !== false) built.tree = { paths: [...input.tree.paths].sort(), truncated: input.tree.truncated };
+
+  const packageMap = {};
+  const manifests = [];
+  if (want.packageMap) {
+    for (const m of sel.manifests) {
+      const body = read.get(m);
+      const manifest = readManifest(m, body);
+      manifests.push(manifest);
+      const name = manifest.name ?? manifestName(body);
+      if (name) packageMap[name] = manifest.dir;
+    }
+  }
+
+  const edges = [];
+  const doubted = [];
+  if (want.graph) {
+    const report = { doubtAt: -1 };
+    for (const s of sel.sources) {
+      const body = read.get(s);
+      // A source we could not read is not a source with no edges: the reader
+      // must not take it for a mock-free file. One that holds a NUL byte is still
+      // text — agents write U+0000 into template literals — and is lexed; one
+      // whose NUL stands in CODE, outside every string and comment (an MPEG-TS
+      // video fixture named `.ts`), cannot parse: no runner can load it, so it
+      // neither loads nor replaces.
+      if (body == null) {
+        doubted.push(s);
+        continue;
+      }
+      if (body.includes("\0") && maskModuleSource(body, moduleEdgeOptions(s)).includes("\0")) continue;
+      if (!body) continue;
+      for (const ref of extractModuleEdges(body, moduleEdgeOptions(s), report)) edges.push([s, ref.specifier, ref.kind]);
+      if (report.doubtAt >= 0) doubted.push(s);
+    }
+    edges.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : a[2] < b[2] ? -1 : a[2] > b[2] ? 1 : 0));
+  }
+
+  if (want.graph) built.graph = { format: EVIDENCE_GRAPH_FORMAT, edges, doubted };
+  if (want.packageMap) {
+    built.packageMap = Object.fromEntries(Object.entries(packageMap).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+    built.manifests = manifests.sort((a, b) => (a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0));
+  }
+  if (want.contents) {
+    const contents = {};
+    for (const p of [...sel.changed, ...sel.pairedTests].sort()) {
+      const body = read.get(p);
+      contents[p] = body != null && !body.includes("\0") ? body : null;
+    }
+    built.contents = contents;
+  }
+
+  // The selections, given rather than collected — the runners ran before this
+  // function was called, because reaching one is the only part of the bundle
+  // the two producers do differently. `normaliseListTests` is what they share:
+  // the sort that makes the bytes repeatable, the refusal of a non-zero exit,
+  // and `undefined` for "nothing survived" so the section is absent rather
+  // than an empty promise.
+  const listTests = normaliseListTests(input.listTests);
+  if (want.listTests !== false && listTests) built.listTests = listTests;
+
+  // `sent` is DERIVED from what was built, never accepted from the caller.
+  //
+  // It used to be an input, and that made the one shape the server refuses
+  // representable: a caller could promise three sections, the budget could run
+  // out mid-read, and the rebuilt bundle would carry `sent.graph === true`
+  // beside `graph: {edges: []}`. `sentAgreesWithBody` then 400s the whole
+  // body at the door — losing the tree, which is the one section the no-App
+  // path actually needs — and the only trace is a line in a local log while
+  // the review has already paid its 30 s wait. Derived, the disagreement
+  // cannot be written down.
+  const absent = (k) => input.absences?.[k] ?? "not-collected";
+  const sent = {
+    tree: "tree" in built ? true : absent("tree"),
+    graph: "graph" in built ? true : absent("graph"),
+    packageMap: "packageMap" in built ? true : absent("packageMap"),
+    contents: "contents" in built ? true : absent("contents"),
+    listTests: "listTests" in built ? true : absent("listTests"),
+    rerun: absent("rerun"),
+  };
+  return {
+    v: EVIDENCE_V,
+    producer: "client",
+    ...(input.clientVersion ? { clientVersion: input.clientVersion } : {}),
+    collectedAt: input.collectedAt,
+    head: input.head,
+    ...(input.rootAbs ? { rootAbs: input.rootAbs } : {}),
+    defaultBranch: input.defaultBranch ?? null,
+    porcelainClean: input.porcelainClean,
+    sent,
+    // A budget names itself only when it actually cost a section, because the
+    // server checks that pair in both directions.
+    partial: Object.values(sent).some((v) => v === "time-budget" || v === "size-cap")
+      ? (input.partial ?? null)
+      : null,
+    ...built,
+  };
+}
+
+/**
+ * The selections that are worth sending, in an order that is the same twice.
+ * The twin of `git-source.ts`'s function of the same name, and the parity test
+ * runs both over the same input.
+ *
+ * ORDER IS BYTES. `bundleHash` keys `(conversation_id, bundle_hash)`, which is
+ * what a second Stop on an unchanged tree dedupes on, and `canonicalEvidence`
+ * blanks only `at`. Neither jest nor vitest promises an order, so without the
+ * sort the same repository would hash differently twice and the review would
+ * pay for an analysis of evidence it already held.
+ *
+ * A NON-ZERO EXIT IS NOT A SELECTION. The runner said it could not answer; what
+ * it printed before saying so is whatever it got through, and a completeness
+ * claim built on that is the one thing this section must never license.
+ */
+export function normaliseListTests(entries) {
+  if (!entries?.length) return undefined;
+  const kept = entries
+    .filter((e) => e.exitCode === 0)
+    .map((e) => ({ ...e, files: [...new Set(e.files)].sort() }))
+    .sort((a, b) =>
+      a.cwd < b.cwd ? -1 : a.cwd > b.cwd ? 1 : a.command < b.command ? -1 : a.command > b.command ? 1 : 0,
+    );
+  return kept.length ? kept : undefined;
+}
+
+// ───────────────────────────────── collection ─────────────────────────────────
+
+/** The budget the whole collection lives inside. Measured, not guessed — see `collectEvidence`. */
+export const COLLECT_BUDGET_MS = 20_000;
+
+/**
+ * The slice of the collection the runners may have between them, and what one
+ * of them may have alone.
+ *
+ * MEASURED on `~/medusa` with its dependencies installed:
+ *
+ *   jest --listTests, repository root        1 063 ms   (460 files)
+ *   jest --listTests, one package              580 ms   (3 files)
+ *   vitest list --filesOnly, root              568 ms   (1 594 files)
+ *   vitest list --filesOnly, one package       668 ms   (21 files)
+ *   vitest list, root, NO --filesOnly        74 260 ms   exit 1
+ *
+ * The last line is why `--filesOnly` is not a detail. Without it `vitest list`
+ * IMPORTS every file it finds in order to print the test names inside them —
+ * which is both the wrong answer (names, not files) and a minute and a
+ * quarter of somebody's laptop, ending in a non-zero exit because a monorepo
+ * root sweeps in jest-only suites and half-configured doc sites. With it,
+ * nothing is imported at all.
+ *
+ * The per-command ceiling is between five and ten times the slowest thing
+ * measured, and the total is a third of the collection: a repository slower
+ * than medusa may cost us a selection, and must not be able to cost us the
+ * tree.
+ */
+export const LIST_TESTS_BUDGET_MS = 7_000;
+const LIST_TESTS_PER_COMMAND_MS = 6_000;
+
+/**
+ * How many distinct runner invocations the session may ask for.
+ *
+ * A session runs the same command over and over — F3 ran one command seven
+ * times, T1 fourteen — so identical invocations collapse to one question long
+ * before this bites. What it bounds is a session that ran genuinely different
+ * commands in genuinely different packages, where each one is a separate
+ * process start.
+ */
+const LIST_TESTS_MAX_COMMANDS = 4;
+
+/** How many paths a tree may carry before we stop listing and say so. */
+export const TREE_CAP = 200_000;
+
+/** The bundle body we refuse to build rather than send. Well under the server's 32 MiB. */
+export const BODY_CAP_BYTES = 24_000_000;
+
+/**
+ * `git`, resolved to an absolute path on Windows before it is spawned.
+ *
+ * `hook.mjs` already carries `resolveTool` for this and the reason is not
+ * cosmetic: on Windows `execFileSync` with a bare name searches the CURRENT
+ * DIRECTORY first, so a repository containing a `git.exe` — a fixture, a
+ * vendored binary, a file an attacker put there — would be run instead of the
+ * real one, inside a process holding the developer's API key. This file was
+ * written with the bare name and re-opened that hole; it resolves the same way
+ * the hook does, and falls back to the bare name only where resolution is not
+ * a question (POSIX).
+ */
+const GIT = resolveGit();
+
+function resolveGit() {
+  if (process.platform !== "win32") return "git";
+  const exts = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean);
+  for (const dir of (process.env.PATH ?? "").split(";").filter(Boolean)) {
+    for (const ext of exts) {
+      const candidate = join(dir, `git${ext}`);
+      try {
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+        /* keep looking */
+      }
+    }
+  }
+  return "git";
+}
+
+function git(root, args, timeoutMs) {
+  return execFileSync(GIT, ["-C", root, ...args], {
+    encoding: "utf8",
+    timeout: timeoutMs,
+    maxBuffer: 1 << 28,
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true,
+  });
+}
+
+/**
+ * The repository's own idea of its default branch, read locally.
+ *
+ * `git symbolic-ref refs/remotes/origin/HEAD` is the only answer that is a
+ * FACT rather than a guess: it is what the remote said when the clone was made
+ * or `set-head` was last run. Measured at 9.5 ms on a 24 000-file repository —
+ * the cheapest fact in this file, and the one the server otherwise pays a
+ * GitHub API call for and, with no App installation, cannot get at all.
+ *
+ * `null` when the ref is missing, which is common enough to be ordinary: a
+ * clone made with `--single-branch`, a worktree, a repository with no `origin`.
+ * A null must travel as a null — the server's own fallback chain already ends
+ * in a guess that says it is one, and a client inventing "main" here would
+ * turn that honest guess into a false fact about somebody's repository.
+ */
+export function defaultBranchOf(root, timeoutMs) {
+  try {
+    const ref = git(root, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], timeoutMs).trim();
+    if (!ref) return null;
+    const slash = ref.indexOf("/");
+    return slash < 0 ? ref : ref.slice(slash + 1);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The paths this session changed, as the client can know them.
+ *
+ * The stand takes them from the pull request's `merge-base(base, head)..head`.
+ * A hook at Stop has no pull request base to ask about, so it asks the same
+ * question of the same merge-base against the repository's own default branch,
+ * which is what the pull request will be opened against in all but the unusual
+ * case. Where the two disagree the bundle's `contents` covers a different set
+ * of files than the server's diff calls changed — nothing here can prevent
+ * that, and it is why the bundle carries `head` for the server to check.
+ *
+ * Uncommitted work is deliberately NOT included. `porcelainClean` already says
+ * the tree is not the commit, and a changed-path list that mixed committed and
+ * uncommitted files would make `head` a lie about its own contents.
+ */
+export function changedPathsOf(root, defaultBranch, timeoutMs) {
+  if (!defaultBranch) return [];
+  try {
+    const base = git(root, ["merge-base", `origin/${defaultBranch}`, "HEAD"], timeoutMs).trim();
+    if (!base) return [];
+    const out = git(root, ["diff", "--name-only", "-z", `${base}..HEAD`], timeoutMs);
+    return out.split("\0").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// ──────────────────────────── the runner's own selection ────────────────────────────
+//
+// WHAT THIS DOES THAT NOTHING HERE DID BEFORE: it starts a program out of the
+// developer's repository. `jest --listTests` evaluates `jest.config.js` — 71 of
+// them in medusa — and `vitest list --filesOnly` evaluates a vite config. That
+// is repository code, and until now the collector only ever READ files.
+//
+// The reason it is nevertheless the right trade, stated rather than assumed:
+// every command asked here is a command THIS SESSION ALREADY RAN, minus the
+// execution. The developer typed it or their agent did, on this machine, in
+// this directory, and the tests themselves ran. Asking the same runner the
+// weaker question — which files would you select — adds no capability the
+// session did not already exercise.
+//
+// What it does NOT do, each a deliberate refusal:
+//   · no shell, ever — `execFileSync` with an argv array, so a `;` or a `$(…)`
+//     inside a session's command line is an argument and not a command;
+//   · no `npx`, which may reach the network and install;
+//   · no script alias (`npm test`, `yarn test:integration`) — the body of a
+//     script is not ours to read, and `yarn foo --listTests` passes a flag to
+//     something that may simply run the whole suite. T2 of the corpus is
+//     exactly this shape, and it gets nothing;
+//   · no bare command name — the binary is resolved to an absolute path under
+//     the repository's own `node_modules`, for the reason `hook.mjs` gives at
+//     `resolveTool`: on Windows a child's working directory is searched before
+//     PATH, and this child's working directory is a repository.
+
+/** Runner binaries we know how to ask, and how to ask them. */
+/**
+ * A line that could be a path a runner printed: an optional drive or leading
+ * slash, segments, and an extension a test file can have. Deliberately narrow
+ * — the two runners we ask print nothing else, so anything wider would be
+ * admitting text we have no reason to admit.
+ */
+const LIST_LINE_RX = /^(?:[A-Za-z]:)?[\w./@$~+-]+\.(?:[cm]?[jt]sx?|py|rb|go|rs)$/;
+
+const RUNNERS = {
+  jest: { listedBy: "jest-listTests", argv: (args) => [...args, "--listTests"] },
+  // `list` is a SUBCOMMAND and replaces `run`; `--filesOnly` is what keeps it
+  // from importing every file it finds — measured at 74 s and a non-zero exit
+  // without it, 0.57 s with it.
+  vitest: { listedBy: "vitest-list", argv: (args) => ["list", "--filesOnly", ...args.filter((a) => a !== "run")] },
+};
+
+/** Tokens of one command line, quotes kept whole, quotes then stripped. */
+function shellWords(segment) {
+  return (segment.match(/"[^"]*"|'[^']*'|\S+/g) ?? []).map((t) =>
+    (t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'")) ? t.slice(1, -1) : t,
+  );
+}
+
+/**
+ * Which runner a token names, if any.
+ *
+ * A path is read by its LAST segment so `../../../node_modules/.bin/vitest`
+ * and `node_modules/.bin/jest` are recognised — the two spellings the corpus
+ * actually uses — while `jest.config.js` is not a runner and neither is a
+ * directory called `jest`.
+ */
+function runnerOfToken(token) {
+  const base = token.slice(token.lastIndexOf("/") + 1);
+  return base === "jest" || base === "vitest" ? base : null;
+}
+
+// Shell plumbing, not runner arguments — and the two shapes are told apart,
+// which they were not.
+//
+//   `2>&1`, `>&2`  a redirect whose target is a FILE DESCRIPTOR, written in
+//                  the token itself. Nothing follows it.
+//   `>`, `2>`, `>>`, `&>`, `<`   a bare operator whose target is the NEXT
+//                  token, which is a filename and not an argument.
+//   `>out.log`, `2>/dev/null`    operator and target in one token.
+//
+// One pattern matched all three and skipped the next token for the first two
+// alike, so `jest 2>&1 --forceExit` lost `--forceExit` and the runner was
+// asked a different question from the one the session ran.
+const FD_REDIRECT_RX = /^&?\d*[<>]{1,2}&\d+$/;
+const BARE_REDIRECT_RX = /^&?\d*[<>]{1,2}$/;
+const REDIRECT_WITH_TARGET_RX = /^&?\d*[<>]{1,2}\S+$/;
+
+function withoutRedirects(words) {
+  const out = [];
+  for (let i = 0; i < words.length; i++) {
+    const w = words[i];
+    if (FD_REDIRECT_RX.test(w)) continue;
+    if (BARE_REDIRECT_RX.test(w)) {
+      i += 1; // the filename is the next token
+      continue;
+    }
+    if (REDIRECT_WITH_TARGET_RX.test(w)) continue;
+    out.push(w);
+  }
+  return out;
+}
+
+/**
+ * The runner invocations on one command line, with the directory each was
+ * asked from.
+ *
+ * `from` is where the shell STARTED — the transcript stamps a `cwd` on every
+ * entry and it moves as the session moves — and `cd` walks from there.
+ * Measured, and the size of the mistake is the reason both halves are needed:
+ * `jest --listTests` answers 460 files at medusa's root and 5 one package
+ * down, and of the corpus's runs, some carry a `cd` on the line while others
+ * were simply started somewhere else. A selection taken in the wrong directory
+ * is not a worse answer to the question — it is a confident answer to a
+ * different one, which occasionally, by accident, has the right number of
+ * files in it.
+ *
+ * Segments split on the operators that START a new command. A `|` ends the
+ * runner's arguments, which is the point: `jest x | tail -20` is the corpus's
+ * most common shape and the `tail` is not part of the question.
+ *
+ * A `cd` we cannot compute (`cd -`, `cd $VAR`, `cd ~`) or one that leaves the
+ * repository abandons the whole LINE rather than guessing, because everything
+ * after it is somewhere we cannot name.
+ */
+export function runnerInvocations(commandLine, from = "", root = null) {
+  if (typeof commandLine !== "string" || !commandLine) return [];
+  // A HEREDOC BODY IS NOT A COMMAND. `cat > notes.md <<EOF` followed by a line
+  // reading `npx jest --config /tmp/x.js` is one command writing a file, and
+  // the text inside it was never run by anything. Split on newlines — which
+  // every other shape here needs — and that text becomes an invocation we
+  // would go and perform, with arguments nobody chose, breaking the one claim
+  // this whole capability rests on: that we ask only what the session already
+  // ran. The body cannot be told from the command around it without a shell
+  // parser, so a line carrying a heredoc gives up all of its invocations.
+  if (/<<-?\s*['"\\]?\w/.test(commandLine)) return [];
+
+  const out = [];
+  let dir = from;
+  for (const raw of commandLine.split(/\n|&&|\|\||;|\||\$\(|`/)) {
+    // A SEGMENT WITH AN ODD QUOTE IS HALF A STRING. The split above is blind
+    // to quoting, so `jest -t "a | b"` breaks in the middle of an argument and
+    // leaves `-t "a` behind — a different question, asked confidently. The
+    // whole LINE goes, because the other half of that string is in another
+    // segment and no part of it can be trusted.
+    if (((raw.match(/"/g) ?? []).length % 2) || ((raw.match(/'/g) ?? []).length % 2)) return [];
+    const words = withoutRedirects(shellWords(raw.trim()));
+    if (!words.length) continue;
+
+    // `(cd pkg && jest …)` — the group's paren rides on the first word, so
+    // without this the `cd` is not a `cd` and the runner is asked from
+    // wherever the shell was standing. `replayableCommandOf` strips the same
+    // paren on the other side, for the same reason.
+    if (words[0] === "(") words.shift();
+    else if (words[0]?.startsWith("(")) words[0] = words[0].slice(1);
+    if (!words.length) continue;
+
+    if (words[0] === "cd") {
+      const target = words[1];
+      if (!target || /^[-~$]/.test(target)) return [];
+      // An ABSOLUTE `cd` is ordinary here and perfectly computable — `cd
+      // /Users/x/medusa/packages/core/js-sdk && yarn jest …` is M2's own
+      // command line, and M2 is the one session of the corpus the stand can
+      // reproduce at all. It needs the repository root to become a repository
+      // path; without one there is nothing to measure it against, and a
+      // destination we cannot name abandons the line.
+      if (target.startsWith("/") || /^[A-Za-z]:/.test(target)) {
+        const rel = root ? relativeTo(root, target) : null;
+        if (rel == null) return [];
+        dir = rel;
+        continue;
+      }
+      dir = normaliseDir(dir ? `${dir}/${target}` : target);
+      if (dir == null) return []; // climbed out of the repository
+      continue;
+    }
+
+    // Leading env assignments (`TZ=UTC jest …`) and the wrappers that are not
+    // the command. `npx` and `yarn` are dropped on purpose: they are ways to
+    // REACH a runner, and we reach it ourselves, from `node_modules/.bin`. A
+    // wrapper followed by something that is not a runner — `yarn test`,
+    // `yarn test:integration:http` — is a SCRIPT, whose body we cannot read,
+    // and it falls through to nothing rather than to a guess.
+    let i = 0;
+    let scoped = false;
+    while (i < words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[i])) i++;
+    while (i < words.length && ["sudo", "command", "env", "time", "npx", "yarn", "pnpm", "bunx", "exec"].includes(words[i])) {
+      i++;
+      // A FLAG ON THE WRAPPER IS NOT NOISE. `pnpm --filter @scope/pkg jest`
+      // and `yarn --cwd packages/app jest` decide WHICH package the runner
+      // runs in, and we drop the flag and then ask the runner from the
+      // directory the shell was standing in — a different question with a
+      // different answer. We cannot reproduce it and must not pretend to.
+      while (i < words.length && words[i].startsWith("-")) {
+        scoped = true;
+        i += words[i].includes("=") ? 1 : 2;
+      }
+    }
+    if (i >= words.length || scoped) continue;
+
+    const runner = runnerOfToken(words[i]);
+    if (!runner) continue;
+    // …and the group's CLOSING paren rides on the last argument the same way
+    // its opener rode on the first: `(cd pkg && jest a)` leaves `a)`.
+    const args = words.slice(i + 1);
+    const last = args.length - 1;
+    if (last >= 0 && args[last].endsWith(")") && !args[last].includes("(")) args[last] = args[last].slice(0, -1);
+    out.push({ runner, dir, args: args.filter(Boolean) });
+  }
+  return out;
+}
+
+/** `a/./b`, `a/b/../c` and a trailing slash collapsed; a path that climbs out is refused. */
+function normaliseDir(dir) {
+  const parts = [];
+  for (const seg of dir.split("/")) {
+    if (!seg || seg === ".") continue;
+    if (seg === "..") {
+      if (!parts.length) return null;
+      parts.pop();
+      continue;
+    }
+    parts.push(seg);
+  }
+  return parts.join("/");
+}
+
+/**
+ * Every Bash command line the session ran that could name a runner, newest
+ * first, each with the directory the shell was standing in when it ran.
+ *
+ * The same walk `hook.mjs` already does for the pull-request receipt, over the
+ * same `tool_use` blocks — plus the entry's own `cwd`, which Claude Code
+ * stamps on every line and MOVES as the session moves. Measured on a corpus
+ * transcript: one entry reads `/Users/admin/medusa`, the next
+ * `/Users/admin/medusa/packages/core/js-sdk`. Without it, a command with no
+ * `cd` of its own would be asked at the repository root, which is a different
+ * question with a different answer.
+ *
+ * Newest first because a session's last runs are the ones a verdict is about,
+ * and the cap cuts the tail rather than the head.
+ */
+export function commandsFromTranscript(sessionData) {
+  if (typeof sessionData !== "string" || !sessionData) return [];
+  const out = [];
+  // `tool_use` and its `tool_result` are different transcript ENTRIES, so a
+  // command waits here until its own result says it ran.
+  const pending = new Map();
+  for (const line of sessionData.split("\n")) {
+    // Cheap prefilter before JSON.parse over megabytes: only a line that names
+    // a runner, or answers one, can matter. A result carries the id of the
+    // call it answers and none of the words, so `tool_result` earns its own
+    // clause rather than riding on the runner's name.
+    if (!line || (!line.includes("jest") && !line.includes("vitest") && !line.includes("tool_result"))) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue; // a tail-truncated transcript starts mid-object
+    }
+    const content = entry?.message?.content;
+    if (!Array.isArray(content)) continue;
+    const cwd = typeof entry.cwd === "string" ? entry.cwd : null;
+    for (const block of content) {
+      if (block?.type === "tool_use") {
+        const command = block.input?.command;
+        if (typeof command === "string" && command) pending.set(block.id, { command, cwd });
+        continue;
+      }
+      // A TOOL CALL IS NOT A COMMAND THE SESSION RAN UNTIL IT RAN.
+      //
+      // The whole licence for starting a runner out of somebody's repository
+      // is that this session already ran this command; a call the developer
+      // DENIED, or one the tool refused, was never run, and asking its runner
+      // would be us running something on their machine that they did not.
+      // Claude Code files the denial as an errored `tool_result`, which is
+      // the same shape `prFromSessionReceipt` already reads for its own
+      // reason.
+      if (block?.type === "tool_result" && block.is_error !== true) {
+        const seen = pending.get(block.tool_use_id);
+        if (seen) out.push(seen);
+      }
+    }
+  }
+  return out.reverse();
+}
+
+/**
+ * The distinct runner questions this session raises, newest first.
+ *
+ * De-duplicated by runner, directory and argument list, because a session runs
+ * the same command over and over — seven times in F3, fourteen in T1 — and
+ * each repetition is the same question with the same answer.
+ *
+ * A command whose recorded directory is outside the repository is dropped
+ * rather than asked at the root: the agent was somewhere else, and a selection
+ * from here would describe a tree it never looked at.
+ */
+export function listTestsPlan(entries, root) {
+  const seen = new Set();
+  const plan = [];
+  for (const e of entries) {
+    const line = typeof e === "string" ? e : e.command;
+    const cwd = typeof e === "string" ? null : e.cwd;
+    let from = "";
+    if (cwd) {
+      const rel = relativeTo(root, cwd);
+      if (rel == null) continue;
+      from = rel;
+    }
+    for (const inv of runnerInvocations(line, from, root)) {
+      if (inv.dir == null) continue;
+      const key = `${inv.runner}${inv.dir}${inv.args.join("")}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      plan.push({ ...inv, command: line.trim() });
+    }
+  }
+  return plan;
+}
+
+/**
+ * The runner binary for a directory, resolved to an absolute path inside the
+ * repository and nowhere else.
+ *
+ * Walks up from the directory the command ran in, exactly as Node's own
+ * resolution does, and stops at the repository root: a runner found above the
+ * root is a global install, and a bundle must not be able to describe a
+ * repository through a tool that is not part of it.
+ */
+export function runnerBinary(root, dir, runner) {
+  const exts = process.platform === "win32" ? [".cmd", ".CMD", ".exe", ".EXE", ""] : [""];
+  let at = dir;
+  for (;;) {
+    for (const ext of exts) {
+      const candidate = join(root, at, "node_modules", ".bin", `${runner}${ext}`);
+      try {
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+        /* keep walking up */
+      }
+    }
+    if (!at) return null;
+    const slash = at.lastIndexOf("/");
+    at = slash < 0 ? "" : at.slice(0, slash);
+  }
+}
+
+/**
+ * One runner, one question, one answer — or nothing.
+ *
+ * `files` come back in two shapes and both are resolved HERE, where the
+ * directory they were printed in is known: jest prints absolute paths, vitest
+ * prints paths relative to its own root, which is the directory it was started
+ * in. Repo-relative is the only spelling that travels, and a path that does not
+ * land inside the repository is dropped — a selection naming somebody's disk is
+ * not evidence about this repository.
+ *
+ * A path that is dropped takes the WHOLE selection with it. A short list is
+ * indistinguishable from a complete one, and completeness is the only thing
+ * this section is for.
+ */
+export function askRunner(input) {
+  const { root, plan, timeoutMs, now } = input;
+  const bin = runnerBinary(root, plan.dir, plan.runner);
+  if (!bin) return { ok: false, reason: "tool-missing" };
+  const spec = RUNNERS[plan.runner];
+  const cwd = plan.dir ? join(root, plan.dir) : root;
+  const at = new Date(now()).toISOString();
+
+  let stdout;
+  let exitCode = 0;
+  try {
+    stdout = execFileSync(bin, spec.argv(plan.args), {
+      cwd,
+      encoding: "utf8",
+      timeout: timeoutMs,
+      maxBuffer: 1 << 26,
+      // stdin closed so a runner that decides to prompt cannot hang a detached
+      // process nobody is watching; stderr discarded because it is the
+      // repository's own noise and we only publish the answer.
+      stdio: ["ignore", "pipe", "ignore"],
+      // SIGTERM is a REQUEST. A runner that installs a handler and ignores it
+      // keeps a detached process nobody is watching alive past every budget
+      // here; `execFileSync`'s timeout only promises to ask. This is a listing
+      // that must not outlive its own ceiling, so it is not asked.
+      killSignal: "SIGKILL",
+      windowsHide: true,
+      // The runner must not decide it is interactive, and must not colour the
+      // paths we are about to parse.
+      env: { ...process.env, CI: "1", NO_COLOR: "1", FORCE_COLOR: "0" },
+    });
+  } catch (e) {
+    // A non-zero exit, a timeout or a signal. `status` is null for a signal,
+    // which is not a zero and must not become one.
+    exitCode = typeof e?.status === "number" ? e.status : 1;
+    if (exitCode === 0) exitCode = 1;
+    stdout = typeof e?.stdout === "string" ? e.stdout : "";
+  }
+
+  // EVERY LINE MUST BE A PATH, or this is not a file list.
+  //
+  // Nothing here knows what the runner printed. A deprecation notice, a
+  // progress line, an experimental-warning banner — any of them, read as a
+  // path, becomes a "file" in the bundle: unbounded text the redactor does not
+  // touch (it masks `command`, never `files`), and a count that the gate's
+  // agreement with `declaredTotal` is then measured against. Both jest's
+  // `--listTests` and vitest's `list --filesOnly` print paths and nothing else
+  // — measured — so a line that is not one means the output is not the output
+  // we think we are reading, and the whole list goes rather than the line.
+  const files = [];
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (!LIST_LINE_RX.test(line)) return { ok: false, reason: "unreadable-output" };
+    const abs = line.startsWith("/") || /^[A-Za-z]:[\\/]/.test(line);
+    const joined = abs ? line : plan.dir ? `${plan.dir}/${line}` : line;
+    const rel = abs ? relativeTo(root, line) : normaliseDir(joined);
+    // Not inside the repository, or a spelling we could not normalise. Either
+    // way the list we are holding is not the list the runner printed.
+    if (!rel) return { ok: false, reason: "off-repo" };
+    files.push(rel);
+  }
+
+  return {
+    ok: true,
+    entry: {
+      // THE RUNNER SEGMENT, not the line it sat on.
+      //
+      // The line is what the reader matches a selection to a RUN by, and one
+      // line can hold two runs: `jest a && jest b` is two invocations, and the
+      // corpus has exactly that shape (M1 chains two jest calls in one Bash
+      // call). Sending the line would give both entries an identical
+      // (directory, command) key, and the gate would then pick between them by
+      // timestamp — stamping one run with the other one's file list, which is
+      // a false witness built out of nothing but a shell operator.
+      command: `${plan.runner} ${plan.args.join(" ")}`.trim(),
+      runner: plan.runner,
+      listedBy: spec.listedBy,
+      cwd: plan.dir,
+      cwdAbs: cwd,
+      head: "",
+      exitCode,
+      files,
+      at,
+    },
+  };
+}
+
+/** `path` under `root`, repo-relative — or null when it is not under it at all. */
+function relativeTo(root, path) {
+  const r = root.replace(/\/+$/, "");
+  const p = path.replace(/\\/g, "/");
+  const base = r.replace(/\\/g, "/");
+  if (p === base) return "";
+  if (!p.startsWith(`${base}/`)) return null;
+  return p.slice(base.length + 1);
+}
+
+/**
+ * Ask every runner the session used, inside a budget, and hand back what they
+ * said.
+ *
+ * `head` is re-read after each answer and stamped on it, rather than copied
+ * from the bundle. Collection is not instantaneous and a developer's hands do
+ * not stop during it; a commit landing between `git rev-parse HEAD` at the top
+ * of the collection and a runner answering at the bottom would leave the bundle
+ * claiming a selection of a tree it is not about, with nothing to show for it.
+ */
+export function collectListTests(input) {
+  const { root, plan, budgetMs, now, headOf } = input;
+  const started = now();
+  const entries = [];
+  let tooLate = false;
+  let onlyToolMissing = true;
+  for (const p of plan.slice(0, LIST_TESTS_MAX_COMMANDS)) {
+    const left = budgetMs - (now() - started);
+    if (left <= 0) {
+      tooLate = true;
+      break;
+    }
+    const r = askRunner({ root, plan: p, timeoutMs: Math.min(LIST_TESTS_PER_COMMAND_MS, left), now });
+    if (!r.ok) {
+      if (r.reason !== "tool-missing") onlyToolMissing = false;
+      continue;
+    }
+    // A RUNNER THAT COULD NOT ANSWER IS NOT AN ENTRY. It was filtered at the
+    // door and at the build, and filtering it here as well is what keeps
+    // `sent.listTests` and the collector's own log saying the same thing: an
+    // entry that survives to `buildEvidence` and is dropped there leaves the
+    // section absent for the reason `collectListTests` had already decided was
+    // `null`.
+    if (r.entry.exitCode !== 0) {
+      onlyToolMissing = false;
+      continue;
+    }
+    // …and a head we could not read drops the ENTRY, never the bundle. The
+    // door validates `head` as a sha, so an empty one 400s the WHOLE body —
+    // tree included, the one section the no-App path cannot work without —
+    // over a `git rev-parse` that blinked. That is the exact trade E1 spent a
+    // rebuild to avoid, and it must not come back through a new section.
+    // Charged against the SAME sub-budget: `headOf` is a `git rev-parse` with
+    // its own timeout, once per entry, and four of them outside the ceiling
+    // would put this block past the collection budget it is supposed to live
+    // inside. A budget gone by now is the CLOCK's doing and says so — an
+    // answer we threw away for time must not be filed as one we never asked
+    // for.
+    if (budgetMs - (now() - started) <= 0) {
+      tooLate = true;
+      break;
+    }
+    const head = headOf();
+    if (!head) {
+      onlyToolMissing = false;
+      continue;
+    }
+    entries.push({ ...r.entry, head });
+  }
+  if (entries.length) return { entries, absence: null };
+  // WHY there is nothing, in the vocabulary the registry counts. Each member is
+  // a different debt and the ledger cannot tell a limit from a gap if two of
+  // them are spelled the same way:
+  //
+  //   `not-applicable`  the repository asks no such question — the session ran
+  //                     no runner we can reach at all;
+  //   `time-budget`     we ran out before we could ask, and `partial` says so;
+  //   `tool-missing`    the runner is genuinely not on this machine;
+  //   `not-collected`   we asked and could not use the answer. It is the
+  //                     weakest thing we can say and the only honest one: the
+  //                     tool WAS there, so `tool-missing` would be false, and
+  //                     the question DID arise, so `not-applicable` would be
+  //                     too. There is no member for "it answered and the answer
+  //                     named another repository", and inventing one on the
+  //                     wire to say it would be a vocabulary nobody reads yet.
+  if (!plan.length) return { entries: [], absence: "not-applicable" };
+  if (tooLate) return { entries: [], absence: "time-budget" };
+  return { entries: [], absence: onlyToolMissing ? "tool-missing" : "not-collected" };
+}
+
+/**
+ * Collect the bundle from a working tree, inside a budget, saying honestly
+ * which sections the budget cost.
+ *
+ * MEASURED on `~/medusa` (24 043 paths, 11 923 source files, 47 MB of text),
+ * warm cache, so the budget is a number rather than a hope:
+ *
+ *   rev-parse ×2                 19 ms
+ *   status --porcelain          330 ms
+ *   ls-files                     15 ms
+ *   symbolic-ref origin/HEAD      9 ms
+ *   merge-base + diff            18 ms
+ *   read every source file      213 ms warm / 769 ms cold
+ *   extractModuleEdges over them 652 ms warm / 837 ms first (38 079 edges)
+ *   whole bundle                 1 240-1 530 ms · 6.33 MB, 0.39 MB gzipped
+ *
+ * (Measured 27.09 on the graph format 2 lexer — JSX, the doubt rule, the
+ * mocks, `uncertain`. The graph before `EVIDENCE_GRAPH_FORMAT`, relative specifiers only,
+ * was 18 657 edges and a 4.18 MB bundle in 940 ms: every package specifier,
+ * the kinds that do not load, and a lexer that knows JSX cost 2.1 MB and
+ * about 0.2 s.)
+ *
+ * The budget is twenty times that, because the repository on the next machine
+ * is not this one and a spinning disk is not this disk. It is not the ceiling
+ * that matters anyway: the Stop hook itself is killed by Claude Code at 600 s
+ * (measured — see `hook.mjs`), and this runs in a DETACHED process that
+ * outlives the hook entirely, so the only thing the budget protects is the
+ * developer's laptop, not the capture.
+ *
+ * The order is deliberate. The tree is first because it is nearly free and
+ * because it alone unlocks `ranFiles` on a session with no App. The graph is
+ * last of the expensive three because it is the one V7 needs and the one that
+ * can be re-asked on the next Stop; losing it costs a capability, not a fact.
+ */
+export function collectEvidence(opts) {
+  const { clientVersion } = opts;
+  const budgetMs = opts.budgetMs ?? COLLECT_BUDGET_MS;
+  const startedAt = opts.now ? opts.now() : Date.now();
+  const spent = () => (opts.now ? opts.now() : Date.now()) - startedAt;
+  const left = () => budgetMs - spent();
+  // Every git call is bounded by what remains, never by the whole budget: a
+  // single blocked call must not be able to spend the time the rest needs.
+  // Each git call gets what remains, but never less than a floor — and the
+  // floor is generous on purpose. A previous call that ran long would
+  // otherwise leave the next one a second, and `git status --porcelain` alone
+  // was measured at 330 ms on a 24 000-file repository; on a cold cache or a
+  // network filesystem a one-second ceiling turns an ordinary read into a
+  // timeout, which discards the whole collection rather than a section.
+  const gitTimeout = () => Math.max(5_000, left());
+
+  // THE ROOT IS RESOLVED, NOT ASSUMED, and it is the first thing done.
+  //
+  // Claude Code is routinely launched inside a package of a monorepo, and
+  // `git ls-files` from there lists that subtree with paths relative to IT.
+  // Every path in the bundle would then be in a different namespace from every
+  // path the server knows, and nothing downstream could tell: the tree would
+  // simply never contain the files the report asks about, and `ranFiles` would
+  // read `unreadable` forever for a reason no log would name. The stand hit
+  // exactly this, in the test written to catch it.
+  let root;
+  try {
+    root = git(opts.root, ["rev-parse", "--show-toplevel"], gitTimeout()).trim() || opts.root;
+  } catch {
+    root = opts.root;
+  }
+
+  let head;
+  let porcelainClean;
+  let treePaths;
+  try {
+    head = git(root, ["rev-parse", "HEAD"], gitTimeout()).trim();
+    porcelainClean = diskIsTheCommit(root, gitTimeout());
+    treePaths = git(root, ["ls-files", "-z"], gitTimeout()).split("\0").filter(Boolean);
+  } catch (e) {
+    // No head, no tree, no bundle. A repository we cannot read at all is not a
+    // partial bundle — it is no bundle, and the caller says nothing rather than
+    // sending an empty one that would read as "the repository is empty".
+    return { bundle: null, reason: `git: ${e?.message ?? e}`, spentMs: spent() };
+  }
+
+  const truncated = treePaths.length > TREE_CAP;
+  if (truncated) treePaths = treePaths.slice(0, TREE_CAP);
+  const tree = { paths: new Set(treePaths), truncated };
+
+  const defaultBranch = opts.defaultBranch ?? defaultBranchOf(root, gitTimeout());
+  const changedPaths = opts.changedPaths ?? changedPathsOf(root, defaultBranch, gitTimeout());
+  // A clone with no `refs/remotes/origin/HEAD` — `--single-branch`, a
+  // worktree, no origin — gives no merge-base and therefore no changed paths.
+  // `contents` would then be `{}` MARKED SENT, and the registry would count a
+  // `contents`-closed gap as ours to answer on a section that describes
+  // nothing. The question does not arise; say so.
+  const changedKnown = changedPaths.length > 0 || (defaultBranch != null && opts.changedPaths !== undefined);
+
+  const base = {
+    head,
+    // Where the tree sits on this disk — what a reader places a run's
+    // directory against (never the directory the session was launched in).
+    rootAbs: root,
+    defaultBranch,
+    porcelainClean,
+    collectedAt: new Date(startedAt).toISOString(),
+    clientVersion,
+    tree,
+    changedPaths,
+  };
+
+  // Every file is read once: a rebuild (the size cap below) takes what the
+  // first build read rather than reading the repository again past a budget
+  // that is already spent.
+  const readCache = new Map();
+  let readCut = false;
+  const read = (paths) => {
+    const out = new Map();
+    for (const p of paths) {
+      if (readCache.has(p)) {
+        out.set(p, readCache.get(p));
+        continue;
+      }
+      // A read that runs past the budget stops reading, and SAYS so. The
+      // caller then rebuilds WITHOUT the sections this read fed, so nothing is
+      // ever built out of half a repository — a section whose silence is our
+      // clock rather than the repository's is worse than no section at all. A
+      // graph missing the file that holds a mock loses a veto; a manifest
+      // never read would travel as `readable: false`, a fact about a file we
+      // did not look at.
+      if (left() <= 0) {
+        readCut = true;
+        break;
+      }
+      let v;
+      try {
+        // A NUL byte is kept: buildEvidence decides what it means (lexed for
+        // the graph, not carried as contents) — one rule for both producers.
+        v = readFileSync(join(root, p)).toString("utf8");
+      } catch {
+        v = null;
+      }
+      readCache.set(p, v);
+      out.set(p, v);
+    }
+    return out;
+  };
+
+  // `rerun` is E3's. It is `not-collected` because we did not attempt it — a
+  // different fact from running out of time, and it must not be spelled the
+  // same way.
+  const absences = { listTests: "not-collected", rerun: "not-collected" };
+
+  // ── the runners' own selections, BEFORE the file read.
+  //
+  // Ordered ahead of the expensive three for one reason: a read of eleven
+  // thousand files that overruns would otherwise starve a question worth under
+  // a second, and the selection is the only section here that cannot be asked
+  // again later — it is about a tree that is already moving. The graph can be
+  // re-asked on the next Stop; a selection of a commit the developer has since
+  // left cannot.
+  //
+  // It has its own sub-budget so the ordering cannot be turned round: a
+  // repository whose runner hangs costs a selection, never the tree.
+  let listTests;
+  let listTestsRanOut = false;
+  if (opts.testCommands !== undefined) {
+    const nowFn = opts.now ?? Date.now;
+    const r = collectListTests({
+      root,
+      plan: listTestsPlan(opts.testCommands, root),
+      budgetMs: Math.max(0, Math.min(LIST_TESTS_BUDGET_MS, left())),
+      now: nowFn,
+      // Re-read, not copied: see `EvidenceListTests.head`. A failure to read it
+      // leaves the field empty, and an entry with no head is one the reader
+      // refuses — which is the right way round for a fact about which commit
+      // an answer is about.
+      headOf: () => {
+        try {
+          return git(root, ["rev-parse", "HEAD"], 5_000).trim();
+        } catch {
+          return "";
+        }
+      },
+    });
+    if (r.entries.length) listTests = r.entries;
+    else {
+      absences.listTests = r.absence ?? "not-collected";
+      // A SECTION THE CLOCK COST MUST HAVE A CLOCK TO POINT AT. The door
+      // checks the pair in both directions: a section marked `time-budget`
+      // beside a `partial` of `null` is refused, and the refusal is of the
+      // WHOLE body — the tree with it. E1 spent a rebuild removing exactly
+      // that trade and this section must not re-open it through its own
+      // sub-budget, which can run out while the collection's has not.
+      listTestsRanOut = r.absence === "time-budget";
+    }
+  }
+
+  // Attempt everything the budget has not already taken off the table. The
+  // tree is free by now (it is in hand) and is the section the no-App path
+  // cannot do without, so it is never given up.
+  const enough = left() > 0;
+  const want = { tree: true, graph: enough, packageMap: enough, contents: enough && changedKnown };
+  if (!enough) for (const k of ["graph", "packageMap", "contents"]) absences[k] = "time-budget";
+  else if (!changedKnown) absences.contents = "not-applicable";
+
+  // `listTests` rides in `base` rather than in `want`, and the difference is
+  // the rebuild below. Every rebuild writes a FRESH `want` literal, so a
+  // section gated on `want` is dropped by any literal that forgets to name it
+  // — silently, because `sent` is derived and would simply stop saying `true`.
+  // A selection already in hand costs nothing to carry and has no relationship
+  // to the clock that cut the file read, so it survives every rebuild by
+  // construction instead of by remembering.
+  const build = (w, a, partial) =>
+    buildEvidence({
+      ...base,
+      listTests,
+      read: w.graph || w.packageMap || w.contents ? read : () => new Map(),
+      want: w,
+      absences: a,
+      partial,
+    });
+
+  let partial =
+    enough && !listTestsRanOut ? null : { reason: "time-budget", budgetMs, spentMs: spent() };
+  let bundle;
+  try {
+    bundle = build(want, absences, partial);
+  } catch (e) {
+    return { bundle: null, reason: `build: ${e?.message ?? e}`, spentMs: spent() };
+  }
+
+  // The budget may have run out DURING the read. Rebuild without the three it
+  // fed rather than ship sections that describe a repository we stopped
+  // reading — and note that `sent` is derived, so the rebuilt bundle says
+  // `time-budget` for exactly those three and stays coherent at the door.
+  //
+  // Whatever set `partial` first. It used to be asked only when `partial` was
+  // still null, so a runner that had already spent the selection's sub-budget
+  // let a half-read graph and half-read manifests ship as `sent: true`
+  // (review of ENG-87, reproduced with an injected clock).
+  if (readCut) {
+    for (const k of ["graph", "packageMap", "contents"]) absences[k] = "time-budget";
+    partial = { reason: "time-budget", budgetMs, spentMs: spent() };
+    want.graph = want.packageMap = want.contents = false;
+    bundle = build({ tree: true, graph: false, packageMap: false, contents: false }, absences, partial);
+  }
+
+  // Over the cap, the sections go in order of size — the graph is the whole
+  // repository, the manifests can carry verbatim `exports`, the contents are a
+  // handful of files — and the reason names the one that was cut. A budget that
+  // already cut something keeps its own reason in `partial`; the door accepts
+  // two budgets cutting two sections.
+  const serialise = () => {
+    try {
+      return JSON.stringify(bundle);
+    } catch {
+      return null;
+    }
+  };
+  let body = serialise();
+  // Largest first: one changed file of 30 MB must cost `contents`, not the
+  // graph and the package map before it.
+  const weight = (k) => {
+    try {
+      return JSON.stringify(k === "packageMap" ? [bundle.packageMap, bundle.manifests] : bundle[k] ?? null).length;
+    } catch {
+      return Infinity;
+    }
+  };
+  for (const k of ["graph", "packageMap", "contents"].sort((a, b) => weight(b) - weight(a))) {
+    if (body != null && Buffer.byteLength(body) <= BODY_CAP_BYTES) break;
+    if (!want[k]) continue;
+    want[k] = false;
+    absences[k] = "size-cap";
+    partial = partial ?? { reason: "size-cap", budgetMs, spentMs: spent() };
+    bundle = build({ ...want }, absences, partial);
+    body = serialise();
+  }
+  if (body == null) return { bundle: null, reason: "serialise: the bundle could not be written as JSON", spentMs: spent() };
+  if (Buffer.byteLength(body) > BODY_CAP_BYTES) {
+    return { bundle: null, reason: "size-cap: tree alone is over the cap", spentMs: spent() };
+  }
+
+  // THE DISK MAY HAVE MOVED WHILE WE READ IT. `head` and `porcelainClean` were
+  // asked before the runners and the file read — seconds on a large
+  // repository, while the developer's next turn may already be editing — and
+  // the graph, the contents and the selections were read from the disk, not
+  // from the commit. Asked again after the last read: a bundle whose disk
+  // stopped being its commit on the way says so, and the server then holds
+  // none of it against the commit (a mock deleted from a test file mid-read
+  // would otherwise ship as a mock-free test of a commit that has one).
+  if (bundle.porcelainClean) {
+    let still = false;
+    try {
+      still = git(root, ["rev-parse", "HEAD"], gitTimeout()).trim() === head && diskIsTheCommit(root, gitTimeout());
+    } catch {
+      still = false;
+    }
+    if (!still) bundle = { ...bundle, porcelainClean: false };
+  }
+
+  return { bundle, reason: null, spentMs: spent(), defaultBranch, bytes: Buffer.byteLength(body) };
+}
+
+/**
+ * CLEAN MEANS THE DISK IS THE COMMIT, whatever the developer's git config
+ * says to show. Plain `git status --porcelain` obeys
+ * `status.showUntrackedFiles=no` (an untracked `cart.js` beside `cart.ts`
+ * vanishes) and never reports a file flagged `assume-unchanged` or
+ * `skip-worktree`, however much it differs from HEAD. A witness stands on this
+ * answer being true (V7 review, 27.09), so both are asked explicitly. Throws
+ * when git does; the caller decides what an unreadable repository means.
+ */
+function diskIsTheCommit(root, timeoutMs) {
+  if (git(root, ["status", "--porcelain", "--untracked-files=normal", "--ignore-submodules=none"], timeoutMs).trim() !== "") return false;
+  return !git(root, ["ls-files", "-v"], timeoutMs)
+    .split("\n")
+    .some((l) => /^[a-zS] /.test(l));
+}