mandrel 2.59.0 → 2.61.0

package/.agents/scripts/lib/pinned-override-resolve.js

@@ -1,212 +0,0 @@
-/**
- * pinned-override-resolve.js — resolve a documented override, and score its note.
- *
- * The reading half of `pinned-override-notes.js` next door: how an
- * `overrides` entry resolves to the range it actually imposes, and which
- * findings that range earns against the note describing it. The audit loop
- * stays there; everything a single note is judged by lives here.
- *
- * Pure: no filesystem, no npm, no network. The caller supplies the parsed
- * package document.
- */
-
-/**
- * npm's own reference syntax inside an `overrides` block: `"js-yaml": "$js-yaml"`
- * means "whatever `dependencies.js-yaml` says". It is the sanctioned way to
- * express the lockstep coupling these notes describe, so reading it as a
- * literal range — which is what a bare string compare does — flagged the fix as
- * the defect: `"$js-yaml" !== "^4.3.2"` produced a `lockstep` finding against a
- * pair that npm guarantees can never split, and a `stale-note` against a note
- * quoting the range actually in force.
- */
-const OVERRIDE_REFERENCE = /^\$(.*)$/;
-
-/**
- * A semver **range**, not only a caret/tilde one. The old pattern required a
- * `^` or `~` prefix, so a note describing an exact pin (`"1.2.3"`) quoted a
- * version the matcher could not see: `quoted` came back empty, the staleness
- * check short-circuits on an empty list, and the note was silently exempt from
- * the guarantee it exists to provide.
- */
-const SEMVER_RANGE = /(?:[\^~]|>=?|<=?|=)?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/g;
-
-/**
- * Extract every semver range that appears literally in a note's prose.
- *
- * Deliberately permissive about the surrounding words — a note is prose, and
- * pinning its phrasing would make it unwritable. What matters is only that
- * the range it quotes is the range in force.
- *
- * Not exported: it is an implementation detail of the audit below, and its
- * behaviour is observable through that — a note quoting only bare versions
- * yields no `stale-note`, a note quoting a mismatched range yields one.
- *
- * @param {string} text
- * @returns {string[]}
- */
-function quotedRanges(text) {
-  if (typeof text !== 'string') return [];
-  return [...text.matchAll(SEMVER_RANGE)].map((m) => m[0]);
-}
-
-/**
- * Look a dotted note key up in the `overrides` tree.
- *
- * An `overrides` value may be a nested object — `{"foo": {"bar": "1.2.3"}}`
- * scopes the `bar` override to `foo`'s subtree — so `overrides.foo.bar` names a
- * real pin two levels down. The exact key is tried first at every level,
- * because package names legitimately contain dots (`lodash.merge`), and only
- * then is the key split.
- *
- * @param {unknown} node
- * @param {string} dottedName
- * @returns {{ found: boolean, value?: unknown }}
- */
-function lookupOverride(node, dottedName) {
-  if (!node || typeof node !== 'object') return { found: false };
-  if (Object.hasOwn(node, dottedName)) {
-    return { found: true, value: node[dottedName] };
-  }
-  const parts = dottedName.split('.');
-  for (let i = 1; i < parts.length; i += 1) {
-    const child = node[parts.slice(0, i).join('.')];
-    const hit = lookupOverride(child, parts.slice(i).join('.'));
-    if (hit.found) return hit;
-  }
-  return { found: false };
-}
-
-/**
- * Resolve the range a documented override actually imposes.
- *
- * @param {object} params
- * @returns {{ kind: 'missing'|'pinned'|'reference'|'unsupported', range?: string,
- *   raw?: unknown, referenced?: string, detail?: string }}
- */
-export function resolvePin({ overrides, dependencies, name }) {
-  const hit = lookupOverride(overrides, name);
-  if (!hit.found) return { kind: 'missing' };
-  if (typeof hit.value !== 'string') {
-    return {
-      kind: 'unsupported',
-      raw: hit.value,
-      detail:
-        'resolves to a nested override object rather than a range. Key the note at the leaf ' +
-        '(e.g. "overrides.<parent>.<name>") so the range it describes is the one checked.',
-    };
-  }
-  const reference = OVERRIDE_REFERENCE.exec(hit.value);
-  return reference
-    ? resolveReference({
-        raw: hit.value,
-        target: reference[1] || name,
-        dependencies,
-      })
-    : { kind: 'pinned', range: hit.value };
-}
-
-/**
- * Resolve npm's `"$name"` reference to the direct range it points at.
- *
- * @param {{ raw: string, target: string, dependencies: object }} params
- * @returns {{ kind: 'reference'|'unsupported', range?: string, raw?: string,
- *   referenced: string, detail?: string }}
- */
-function resolveReference({ raw, target, dependencies }) {
-  const direct = dependencies[target];
-  if (typeof direct !== 'string') {
-    return {
-      kind: 'unsupported',
-      raw,
-      referenced: target,
-      detail: `references "${raw}", but dependencies.${target} does not exist, so npm has nothing to resolve the override to.`,
-    };
-  }
-  return { kind: 'reference', range: direct, referenced: target };
-}
-
-/**
- * Score one documented override against its note. Split out of the loop above
- * so each finding's rationale sits next to the condition that raises it.
- *
- * @param {{ key: string, name: string, text: unknown, resolved: object,
- *   direct: string|undefined }} params
- * @returns {Array<{ kind: string, name: string, detail: string }>}
- */
-export function scoreNote({ key, name, text, resolved, direct }) {
-  const refusal = refuseNote({ key, name, resolved });
-  if (refusal) return [refusal];
-  return [
-    ...scoreLockstep({ name, resolved, direct }),
-    ...scoreStaleness({ key, name, text, range: resolved.range }),
-  ];
-}
-
-/**
- * The two ways a note names nothing checkable: the pin is gone, or the key
- * resolves to something that is not a range. They are deliberately different
- * findings — telling an author to "delete the note or restore the pin" when the
- * pin is right there, one level down, is wrong advice.
- *
- * @param {{ key: string, name: string, resolved: object }} params
- * @returns {{ kind: string, name: string, detail: string }|null}
- */
-function refuseNote({ key, name, resolved }) {
-  if (resolved.kind === 'missing') {
-    return {
-      kind: 'orphan-note',
-      name,
-      detail: `"//"["${key}"] documents an override that no longer exists in the overrides block. Delete the note or restore the pin — a safety note for a pin nobody has is read as though the pin were still there.`,
-    };
-  }
-  if (resolved.kind === 'unsupported') {
-    return {
-      kind: 'unsupported-shape',
-      name,
-      detail: `"//"["${key}"] ${resolved.detail}`,
-    };
-  }
-  return null;
-}
-
-/**
- * Does the override range still agree with the direct one? A `$name` override
- * IS `dependencies[name]`, so npm cannot split the pair the note is warning
- * about and there is nothing to compare.
- *
- * @param {{ name: string, resolved: object, direct: string|undefined }} params
- * @returns {Array<object>}
- */
-function scoreLockstep({ name, resolved, direct }) {
-  const split =
-    resolved.kind === 'pinned' &&
-    typeof direct === 'string' &&
-    direct !== resolved.range;
-  if (!split) return [];
-  return [
-    {
-      kind: 'lockstep',
-      name,
-      detail: `overrides.${name} is "${resolved.range}" but dependencies.${name} is "${direct}". The "//" note declares these move in lockstep; a split gives the direct and transitive resolutions different floors. npm's own "$${name}" reference is the way to make the split impossible.`,
-    },
-  ];
-}
-
-/**
- * Does the note still state the range in force? A note quoting no range at all
- * is not scored: prose that names no version cannot go stale.
- *
- * @param {{ key: string, name: string, text: unknown, range: string }} params
- * @returns {Array<object>}
- */
-function scoreStaleness({ key, name, text, range }) {
-  const quoted = quotedRanges(text);
-  if (quoted.length === 0 || quoted.includes(range)) return [];
-  return [
-    {
-      kind: 'stale-note',
-      name,
-      detail: `"//"["${key}"] quotes ${quoted.map((q) => `"${q}"`).join(', ')} but the range in force is "${range}". The note is what tells the next author whether a bump is safe, so it must state the version it is describing.`,
-    },
-  ];
-}

package/.agents/scripts/lib/test-isolate/cli-options.js

@@ -1,93 +0,0 @@
-/**
- * lib/test-isolate/cli-options.js — argv → options for the `test-isolate` CLI.
- *
- * Story #5316: this lived inside `.agents/scripts/test-isolate.js`, a file no
- * test imports, so it scored the CRAP formula's untested maximum (210 at
- * cyclomatic 14 and 0% coverage) and carried the tree's `test-isolate.js`
- * cyclomatic breach row. It sits here beside `list-files.js`, `parse-tap.js`
- * and `runner.js` for the same reason they do: the CLI shell is unreachable
- * from a test, and everything reachable belongs under `lib/`.
- *
- * The long `else if` ladder it replaces was cyclomatic 14, above the repo's
- * must-fix ceiling of 12. Dispatching through two flag tables is the same
- * parse — same precedence, same tolerance for a value-taking flag that ends
- * the argv — at roughly half the branch count.
- */
-
-/**
- * Flags that consume the following argv entry as a number, keyed by the
- * option each one sets.
- */
-const NUMERIC_FLAGS = {
-  '--workers': 'workers',
-  '--max-bisect-depth': 'maxBisectDepth',
-  '--max-bisect-targets': 'maxBisectTargets',
-  '--suite-concurrency': 'suiteConcurrency',
-};
-
-/** Flags that are their own value. */
-const BOOLEAN_FLAGS = {
-  '--json': 'json',
-  '--quiet': 'quiet',
-};
-
-/**
- * Defaults every parse starts from. Deliberately module-private: nothing in
- * production reads it, and exporting it so a test could assert against it
- * would both make that test tautological and land a test-only export on the
- * `dead-exports:production` ratchet.
- */
-function defaultOptions() {
-  return {
-    pattern: undefined,
-    workers: undefined,
-    maxBisectDepth: 8,
-    maxBisectTargets: 5,
-    suiteConcurrency: 8,
-    json: false,
-    quiet: false,
-  };
-}
-
-/**
- * Parse the `test-isolate` CLI's argv.
- *
- * Precedence, unchanged from the ladder this replaces:
- *   - a known numeric flag consumes the next entry, but only when there IS a
- *     next entry — a trailing `--workers` is ignored rather than setting NaN;
- *   - a known boolean flag sets its option;
- *   - the FIRST non-flag argument becomes the pattern, and later ones are
- *     ignored;
- *   - anything else is ignored, so an unknown `--flag` is never mistaken for
- *     the pattern.
- *
- * @param {string[]} [argv]
- * @returns {{
- *   pattern: string|undefined,
- *   workers: number|undefined,
- *   maxBisectDepth: number,
- *   maxBisectTargets: number,
- *   suiteConcurrency: number,
- *   json: boolean,
- *   quiet: boolean,
- * }}
- */
-export function parseIsolateArgv(argv = []) {
-  const options = defaultOptions();
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    const numericKey = NUMERIC_FLAGS[arg];
-    if (numericKey && argv[i + 1]) {
-      options[numericKey] = Number(argv[i + 1]);
-      i += 1;
-      continue;
-    }
-    const booleanKey = BOOLEAN_FLAGS[arg];
-    if (booleanKey) {
-      options[booleanKey] = true;
-      continue;
-    }
-    if (!arg.startsWith('--') && !options.pattern) options.pattern = arg;
-  }
-  return options;
-}

package/.agents/scripts/lib/test-isolate/env-snapshot-loader.js

@@ -1,52 +0,0 @@
-/* node:coverage ignore file */
-/**
- * Preload module for `test-isolate`. Snapshots `process.env` at module load
- * time and writes a diff envelope to the file named in
- * `TEST_ISOLATE_ENV_OUT` when the process exits. Used to surface env-var
- * mutations a test made and failed to restore.
- */
-
-import fs from 'node:fs';
-
-const OUT_PATH = process.env.TEST_ISOLATE_ENV_OUT;
-if (OUT_PATH) {
-  const beforeSnapshot = { ...process.env };
-  // NODE_OPTIONS propagates this loader into every node process spawned
-  // beneath the runner (including node:test's per-file child workers). We
-  // write to a per-pid sidecar file so the parent runner can pick the
-  // child's diff and ignore its own empty one.
-  const pidPath = `${OUT_PATH}.${process.pid}.json`;
-  process.on('exit', () => {
-    try {
-      const after = process.env;
-      const added = [];
-      const removed = [];
-      const changed = [];
-      const IGNORE = new Set([
-        'TEST_ISOLATE_ENV_OUT',
-        // NODE_OPTIONS is rewritten by the parent's spawn; ignore it so
-        // the loader doesn't flag itself as a leak.
-        'NODE_OPTIONS',
-      ]);
-      for (const key of Object.keys(after)) {
-        if (IGNORE.has(key)) continue;
-        if (!(key in beforeSnapshot)) added.push(key);
-        else if (beforeSnapshot[key] !== after[key]) changed.push(key);
-      }
-      for (const key of Object.keys(beforeSnapshot)) {
-        if (IGNORE.has(key)) continue;
-        if (!(key in after)) removed.push(key);
-      }
-      if (added.length === 0 && removed.length === 0 && changed.length === 0) {
-        return;
-      }
-      fs.writeFileSync(
-        pidPath,
-        JSON.stringify({ added, removed, changed }),
-        'utf8',
-      );
-    } catch {
-      // Best-effort — do not interfere with the host process exit.
-    }
-  });
-}

package/.agents/scripts/lib/test-isolate/list-files.js

@@ -1,90 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import picomatch from 'picomatch';
-
-/**
- * Walk a directory and return repo-relative `*.test.js` paths (forward
- * slashes). Skips `node_modules`, `.worktrees`, and dot-prefixed dirs.
- *
- * @param {string} root
- * @param {typeof fs} [fsLike]
- * @returns {string[]}
- */
-export function walkTestFiles(root, fsLike = fs) {
-  const out = [];
-  walk(root, '');
-  return out.sort();
-
-  function walk(dir, prefix) {
-    if (!fsLike.existsSync(dir)) return;
-    for (const ent of fsLike.readdirSync(dir, { withFileTypes: true })) {
-      const name = ent.name;
-      if (
-        name === 'node_modules' ||
-        name === '.worktrees' ||
-        name.startsWith('.')
-      ) {
-        continue;
-      }
-      const abs = path.join(dir, name);
-      const rel = prefix ? `${prefix}/${name}` : name;
-      if (ent.isDirectory()) {
-        walk(abs, rel);
-      } else if (name.endsWith('.test.js')) {
-        out.push(rel.replace(/\\/g, '/'));
-      }
-    }
-  }
-}
-
-/**
- * Resolve the user's pattern to a sorted list of repo-relative test file
- * paths. Patterns may be:
- *
- * - a glob (`tests/**\/*.test.js`, `tests/lib/foo*.test.js`)
- * - an explicit file path (absolute or repo-relative)
- * - a directory (walked for `*.test.js` descendants)
- * - omitted (defaults to `tests/**\/*.test.js`)
- *
- * @param {object} opts
- * @param {string} [opts.pattern]
- * @param {string} opts.repoRoot
- * @param {string[]} [opts.allFiles] Override the discovered file list for tests.
- * @param {typeof fs} [opts.fsLike]
- * @returns {string[]}
- */
-export function resolveTestFiles({ pattern, repoRoot, allFiles, fsLike = fs }) {
-  const discoverAll = () => allFiles ?? walkTestFiles(repoRoot, fsLike);
-
-  if (!pattern || pattern === 'tests/**/*.test.js') {
-    return discoverAll().filter((f) => f.startsWith('tests/'));
-  }
-
-  // Absolute path → relativize.
-  let target = pattern.replace(/\\/g, '/');
-  if (path.isAbsolute(target)) {
-    target = path.relative(repoRoot, path.resolve(target)).replace(/\\/g, '/');
-  }
-
-  // Directory → walk it for *.test.js files.
-  const absTarget = path.resolve(repoRoot, target);
-  if (fsLike.existsSync(absTarget)) {
-    const stat = fsLike.statSync(absTarget);
-    if (stat.isDirectory()) {
-      return walkTestFiles(absTarget, fsLike)
-        .map((rel) =>
-          path
-            .relative(repoRoot, path.join(absTarget, rel))
-            .replace(/\\/g, '/'),
-        )
-        .filter((f) => f.endsWith('.test.js'));
-    }
-    if (stat.isFile() && target.endsWith('.test.js')) {
-      return [target];
-    }
-  }
-
-  // Glob → filter the universe.
-  const isMatch = picomatch(target, { dot: true });
-  return discoverAll().filter((f) => isMatch(f));
-}

package/.agents/scripts/lib/test-isolate/parse-tap.js

@@ -1,75 +0,0 @@
-/**
- * Minimal TAP parser specialised for `node --test --test-reporter tap` output.
- * Extracts top-level subtests (file-level) pass/fail. The Node test runner
- * emits one top-level `# Subtest: <path>` per file followed eventually by
- * `ok N - <path>` or `not ok N - <path>` at indent depth 0.
- *
- * Returns a Map keyed by the subtest name, value `'pass' | 'fail'`. Failures
- * collect the failing leaf-test names for diagnostic surfacing.
- *
- * @typedef {{ status: 'pass' | 'fail', failingTests: string[] }} TopLevelResult
- *
- * @param {string} tapText
- * @returns {Map<string, TopLevelResult>}
- */
-export function parseSuiteTap(tapText) {
-  const out = new Map();
-  const lines = tapText.replace(/\r\n/g, '\n').split('\n');
-  let currentTop = null;
-  const failingLeavesByTop = new Map();
-
-  for (const line of lines) {
-    const subtestMatch = line.match(/^(\s*)# Subtest:\s*(.+)$/);
-    if (subtestMatch) {
-      const indent = subtestMatch[1].length;
-      if (indent === 0) {
-        currentTop = subtestMatch[2].trim();
-        if (!failingLeavesByTop.has(currentTop)) {
-          failingLeavesByTop.set(currentTop, []);
-        }
-      }
-      continue;
-    }
-    const resultMatch = line.match(/^(\s*)(ok|not ok)\s+\d+\s+-\s+(.+)$/);
-    if (!resultMatch) continue;
-    const indent = resultMatch[1].length;
-    const verdict = resultMatch[2];
-    const name = resultMatch[3].trim();
-
-    if (indent === 0) {
-      const status = verdict === 'ok' ? 'pass' : 'fail';
-      const failing = failingLeavesByTop.get(name) ?? [];
-      out.set(name, { status, failingTests: failing });
-      continue;
-    }
-    if (verdict === 'not ok' && currentTop) {
-      const arr = failingLeavesByTop.get(currentTop);
-      if (arr) arr.push(name);
-    }
-  }
-  return out;
-}
-
-/**
- * Parse a single-file `node --test` TAP run and return whether the file as a
- * whole passed plus the list of failing leaf-test names. The single-file run
- * has no top-level file subtest wrapper, so we look at the `# tests`/`# pass`
- * footer plus the deepest `not ok` entries.
- *
- * @param {string} tapText
- * @param {number} exitCode
- * @returns {{ status: 'pass' | 'fail', failingTests: string[] }}
- */
-export function parseSingleFileTap(tapText, exitCode) {
-  const lines = tapText.replace(/\r\n/g, '\n').split('\n');
-  const failing = [];
-  for (const line of lines) {
-    const m = line.match(/^(\s*)not ok\s+\d+\s+-\s+(.+)$/);
-    if (!m) continue;
-    failing.push(m[2].trim());
-  }
-  return {
-    status: exitCode === 0 ? 'pass' : 'fail',
-    failingTests: failing,
-  };
-}

package/.agents/scripts/lib/test-isolate/progress-log.js

@@ -1,45 +0,0 @@
-/**
- * lib/test-isolate/progress-log.js — the `onProgress` sink for a
- * `diagnoseIsolation` run.
- *
- * Story #5316: this was an anonymous arrow inlined into `runTestIsolate`'s
- * argument list, which is exactly why it scored CRAP 72 (cyclomatic 8 at 0%
- * coverage) under a name — `<anon runTestIsolate/(stage,payload)#0>` — that no
- * test could address. As a named factory it is a plain table lookup.
- */
-
-/** How many bisection suspects are named inline before eliding the rest. */
-const SUSPECT_PREVIEW = 3;
-
-/**
- * Per-stage line formatters. A stage with no entry here is ignored, which is
- * what the `else if` ladder this replaces did by falling off the end — so a
- * new stage emitted by the runner stays silent rather than throwing.
- */
-const STAGE_LINES = {
-  'isolated:start': (p) => `[test-isolate] isolated phase: ${p.count} file(s)`,
-  'isolated:done': () => '[test-isolate] isolated phase: done',
-  'suite:start': (p) => `[test-isolate] suite phase: ${p.count} file(s)`,
-  'suite:done': () => '[test-isolate] suite phase: done',
-  'bisect:start': (p) => `[test-isolate] bisecting flipper: ${p.target}`,
-  'bisect:done': (p) => {
-    const list = p.suspects.slice(0, SUSPECT_PREVIEW).join(', ');
-    const hidden = p.suspects.length - SUSPECT_PREVIEW;
-    const more = hidden > 0 ? ` (+${hidden} more)` : '';
-    return `[test-isolate]   suspects: ${list}${more}`;
-  },
-};
-
-/**
- * Build the progress callback `diagnoseIsolation` calls as each phase starts
- * and finishes.
- *
- * @param {(line: string) => void} onLog
- * @returns {(stage: string, payload: object) => void}
- */
-export function createProgressLogger(onLog) {
-  return (stage, payload) => {
-    const format = STAGE_LINES[stage];
-    if (format) onLog(format(payload ?? {}));
-  };
-}

package/.agents/scripts/lib/test-isolate/render-report.js

@@ -1,97 +0,0 @@
-/**
- * lib/test-isolate/render-report.js — the human-readable `test-isolate` report.
- *
- * Story #5316: extracted verbatim from `.agents/scripts/test-isolate.js`,
- * where no test could reach it (CRAP 72 at cyclomatic 8, 0% coverage). Pure
- * string building — no I/O, no clock — so the whole surface is assertable.
- *
- * The three sections it renders are split into helpers so each is
- * independently readable and none of them alone approaches the cyclomatic
- * ceiling; `renderReport` is left as the composition.
- */
-
-/**
- * The flipper section: files that passed alone and failed in the suite, plus
- * the bisection suspects for each.
- *
- * @param {string[]} lines Accumulator, appended in place.
- * @param {import('./runner.js').IsolateReport} report
- */
-function pushFlipperSection(lines, report) {
-  if (report.flippers.length === 0) {
-    lines.push('✓ No flippers detected — every file that passed alone');
-    lines.push('  also passed in the full suite run.');
-    return;
-  }
-  lines.push(`✗ ${report.flippers.length} flipper(s) detected:`);
-  for (const f of report.flippers) lines.push(`  - ${f}`);
-  lines.push('');
-  if (report.bisections.length === 0) return;
-  lines.push('Likely polluters (bisection suspects):');
-  for (const b of report.bisections) {
-    const tag = b.inconclusive ? ' [inconclusive]' : '';
-    lines.push(`  ${b.file}${tag}`);
-    for (const s of b.suspects) lines.push(`    ← ${s}`);
-  }
-}
-
-/**
- * One env-mutating file's added/removed/changed summary. Empty parts are
- * omitted, so a file that only added a var reads as `added=[...]` alone.
- *
- * @param {{added: string[], removed: string[], changed: string[]}} envDiff
- * @returns {string}
- */
-function formatEnvDiff(envDiff) {
-  const parts = [];
-  if (envDiff.added.length > 0)
-    parts.push(`added=[${envDiff.added.join(', ')}]`);
-  if (envDiff.removed.length > 0) {
-    parts.push(`removed=[${envDiff.removed.join(', ')}]`);
-  }
-  if (envDiff.changed.length > 0) {
-    parts.push(`changed=[${envDiff.changed.join(', ')}]`);
-  }
-  return parts.join(' ');
-}
-
-/**
- * The env-leak section: files whose process exited with `process.env` still
- * mutated, called out even when no failure cascade has manifested yet.
- *
- * @param {string[]} lines Accumulator, appended in place.
- * @param {import('./runner.js').IsolateReport} report
- */
-function pushEnvSection(lines, report) {
-  if (report.envMutators.length === 0) {
-    lines.push('✓ No env-var leaks detected across isolated runs.');
-    return;
-  }
-  lines.push(
-    `⚠ ${report.envMutators.length} file(s) left process.env mutated:`,
-  );
-  for (const m of report.envMutators) {
-    lines.push(`  ${m.file}`);
-    lines.push(`    ${formatEnvDiff(m.envDiff)}`);
-  }
-}
-
-/**
- * Render the diagnostic report as text.
- *
- * @param {import('./runner.js').IsolateReport} report
- * @returns {string}
- */
-export function renderReport(report) {
-  const lines = [];
-  lines.push('');
-  lines.push('=== test-isolate diagnostic report ===');
-  lines.push(`Files scanned:  ${report.files.length}`);
-  lines.push(`Wall duration:  ${(report.durationMs / 1000).toFixed(1)}s`);
-  lines.push('');
-  pushFlipperSection(lines, report);
-  lines.push('');
-  pushEnvSection(lines, report);
-  lines.push('');
-  return lines.join('\n');
-}