@descryy/runtime-test-runner 0.4.12 → 0.4.14

package/dist/test-runner-collector.js

@@ -99,9 +99,16 @@
  * works and is faster while iterating on one file.
  */
 import { fileURLToPath } from "node:url";
-import { spawnProcess, tokenizeCommand } from "@descryy/runtime-controller";
-import { LineSplitter } from "@descryy/runtime-backend-observation";
+import { buildChildEnvironment } from "./child-environment.js";
+import { NO_SANDBOX_DISCLOSURES, spawnProcess, tokenizeCommand } from "@descryy/runtime-controller";
+import { GapResynchronizer, LineSplitter } from "@descryy/runtime-backend-observation";
+import { armRunTimeout, resolveRunTimeout } from "./run-timeout.js";
 import { COLLECTOR_VERSION } from "./collector-version.js";
+import { beginCoverageCapture } from "./coverage-capture.js";
+import { unavailableCoverage, withCoverageDirectoryAllowed } from "./executed-coverage.js";
+import { createGoTestCollector } from "./go-test.js";
+import { locateWrapperEnvironment, unwrapRunnerCommand, wrappedSpawnArgs } from "./runner-wrappers.js";
+import { planVitestRun, vitestLocationDegradations } from "./vitest-version.js";
 /**
  * The version of the NDJSON envelope every reporter speaks (RT-130).
  *
@@ -381,10 +388,11 @@ const PROFILES = [
                 ? "command already configures --reporter -- this collector needs to own the reporter to observe structured events, and co-existing safely with an unknown one is not attempted. Remove the existing --reporter flag."
                 : null;
         },
-        // `--includeTaskLocation` is the counterpart of Jest's
-        // `--testLocationInResults`, and silent in exactly the same way:
-        // measured, without it every `testCase.location` is `undefined`.
-        withReporterFlags: (args) => [...args, `--reporter=${VITEST_REPORTER_MODULE_PATH}`, "--includeTaskLocation"],
+        withReporterFlags: (args, options) => [
+            ...args,
+            `--reporter=${VITEST_REPORTER_MODULE_PATH}`,
+            ...(options?.vitestTaskLocation === true ? ["--includeTaskLocation"] : []),
+        ],
     },
     {
         kind: "junit",
@@ -614,10 +622,6 @@ const PROFILES = [
 export function supportedRunnerExamples() {
     return PROFILES.map((profile) => profile.declaredAs);
 }
-/** `true` for the one command shape neither `discoverRunner` nor `matchRunner` will ever match to a profile — see `discoverRunner`'s own npx comment for why unwrapping it is not attempted. */
-function isNpxWrapped(baseName) {
-    return baseName === "npx" || baseName === "npx.cmd";
-}
 /** The one place `discoverRunner` and `matchRunner` both ask "which profile matches this command" — a shared call so the two can never drift apart the way the hardcoded refusal list once did (B4). */
 function findMatchingProfile(baseName, args) {
     return PROFILES.find((candidate) => candidate.matches(baseName, args));
@@ -664,10 +668,11 @@ export function matchRunner(rawCommand) {
     const tokenized = tokenizeCommand(rawCommand);
     if (!tokenized.ok)
         return null;
-    const { command, args } = tokenized;
-    const baseName = command.split(/[\\/]/).pop() ?? command;
-    if (isNpxWrapped(baseName))
+    const unwrapped = unwrapRunnerCommand(tokenized.command, tokenized.args);
+    if (unwrapped.kind === "refused")
         return null;
+    const { command, args } = unwrapped.kind === "wrapped" ? unwrapped.inner : tokenized;
+    const baseName = command.split(/[\\/]/).pop() ?? command;
     const profile = findMatchingProfile(baseName, args);
     return profile === undefined ? null : { kind: profile.kind, declaredAs: profile.declaredAs };
 }
@@ -687,23 +692,16 @@ export function discoverRunner(rawCommand) {
     if (!tokenized.ok) {
         return { ok: false, reason: tokenized.reason };
     }
-    const { command, args } = tokenized;
+    // **A wrapper (`uv run`, `npx`, `poetry run`, ...) is split by its declared grammar**
+    // (`runner-wrappers.ts`), never guessed: a flag the grammar does not know is refused by
+    // name, since whether it takes a value decides which token is the runner. The profile then
+    // matches the runner's own command exactly as it would a bare one.
+    const unwrapped = unwrapRunnerCommand(tokenized.command, tokenized.args);
+    if (unwrapped.kind === "refused")
+        return { ok: false, reason: unwrapped.reason };
+    const { command, args } = unwrapped.kind === "wrapped" ? unwrapped.inner : tokenized;
+    const wrapper = unwrapped.kind === "wrapped" ? unwrapped.wrapper : undefined;
     const baseName = command.split(/[\\/]/).pop() ?? command;
-    // **`npx jest` is refused by name, not supported and not lumped in with
-    // an unrecognised command.** Unwrapping it means deciding which tokens
-    // belong to npx and which to the runner, and `npx -p vitest@4 vitest run`
-    // makes that genuinely ambiguous -- a wrong split silently drops a flag
-    // the caller wrote. The runner's own binary is one path away
-    // (`node_modules/.bin/jest`), so the refusal names the fix rather than
-    // guessing at one.
-    if (isNpxWrapped(baseName)) {
-        return {
-            ok: false,
-            reason: `"${rawCommand}" runs the runner through npx, whose own arguments cannot be told apart from the runner's ` +
-                "without guessing (`npx -p vitest@4 vitest run`). Declare the runner binary directly -- e.g. " +
-                "`node_modules/.bin/jest ...` or `node_modules/.bin/vitest run ...`.",
-        };
-    }
     const profile = findMatchingProfile(baseName, args);
     if (profile === undefined) {
         return {
@@ -719,10 +717,10 @@ export function discoverRunner(rawCommand) {
     if (refusal !== null) {
         return { ok: false, reason: refusal };
     }
-    return { ok: true, kind: profile.kind, command, args };
+    return { ok: true, kind: profile.kind, command, args, ...(wrapper === undefined ? {} : { wrapper }) };
 }
-export function reporterFlagsFor(kind, args) {
-    return PROFILES.find((profile) => profile.kind === kind).withReporterFlags(args);
+export function reporterFlagsFor(kind, args, options) {
+    return PROFILES.find((profile) => profile.kind === kind).withReporterFlags(args, options);
 }
 /** `{}` for every profile that has no `reporterEnv` — `start()`'s merge then adds nothing. */
 export function reporterEnvFor(kind, args) {
@@ -824,65 +822,15 @@ function unittestSkipReason(outcome) {
         return "disabled";
     return null;
 }
-/**
- * Parses CPython's own `unittest.runner.TextTestResult` verbose (`-v`)
- * output into the same `NodeTestEvent` shape every other profile's reporter
- * emits as real NDJSON -- so `createEventTranslator` never has to know this
- * event did not arrive as JSON. See the file-level doc comment ("unittest is
- * the one profile...") for why a reporter is not possible here at all.
- *
- * **Measured directly against a real `python -m unittest -v` run**, not
- * assumed from documentation:
- *
- * ```
- * test_pass (test_sample.TestSample.test_pass) ... ok
- * test_fail (test_sample.TestSample.test_fail) ... FAIL
- * test_error (test_sample.TestSample.test_error) ... ERROR
- * test_skip (test_sample.TestSample.test_skip) ... skipped 'not ready'
- * test_xfail (test_sample.TestSample.test_xfail) ... expected failure
- * test_xpass (test_sample.TestSample.test_xpass) ... unexpected success
- * ```
- *
- * and, for a test with a docstring, split across two lines instead of one
- * (`getDescription` returns `"%s\n%s" % (str(test), doc_first_line)` when a
- * docstring is present, `str(test)` alone otherwise):
- *
- * ```
- * test_with_doc (test_doc.TestDoc.test_with_doc)
- * This is a docstring. ... ok
- * ```
- *
- * A header-only line is trusted for at most one line of lookahead: whatever
- * arrives next either completes it (a docstring's first line, ending in
- * ` ... <outcome>`) or does not, and either way the header is then
- * discarded -- never left pending indefinitely waiting for a continuation
- * that a stray print from the test body or an unrecognised outcome word
- * might otherwise be mistaken for. A line the parser cannot place at all
- * (the `======`/`----` banners, a traceback body, `Ran N tests...`, `OK`,
- * `FAILED (...)`, or the test process's own stdout) is silently ignored --
- * the same "unparseable output is ordinary and expected" rule every
- * NDJSON-based profile already applies to its own noise.
- *
- * **What this deliberately does not attempt.** unittest's per-test line
- * carries a qualified name only, never a file or line number -- those
- * appear solely in the traceback section printed after every test in the
- * run has already finished, under a `======`-delimited header repeating the
- * test's own description. Re-associating that traceback with the correct
- * earlier result, reliably, across a run with many tests (some sharing a
- * class or method name across modules), is exactly the kind of inference
- * precision-over-recall exists to forbid -- so no attempt is made, every
- * `sourceLocation` this parser produces is null, and every FAILED/ERROR
- * carries no `error` detail either, rather than one guessed from prose.
- * `expected failure`/`unexpected success` fold into `TEST_SKIPPED`/
- * `TEST_PASSED` respectively -- the same choice the pytest reporter already
- * made for `xfail`/`xpass`, not a new one invented here. An outcome word
- * this parser has never measured (a future CPython addition) still gets a
- * `TEST_STARTED` -- the test did start -- but no paired result, on the same
- * "report nothing rather than guess" rule.
- */
+const UNITTEST_RAN_TRAILER = /^Ran (\d+) tests? in \S+s?$/;
+const UNITTEST_STATUS_TRAILER = /^(OK|FAILED)(?: \(.*\))?$/;
 export function createUnittestResultParser() {
     let pendingHeader = null;
+    let resultLines = 0;
+    let declaredCount = null;
+    let sawStatusTrailer = false;
     function eventsFor(header, outcome) {
+        resultLines += 1;
         const start = { type: "test:start", data: { name: header.name, qualifiedName: header.qualifiedName } };
         const skipReason = unittestSkipReason(outcome);
         if (skipReason !== null) {
@@ -897,7 +845,21 @@ export function createUnittestResultParser() {
         return [start];
     }
     return {
+        finish() {
+            if (declaredCount === null || !sawStatusTrailer) {
+                return { reconciled: false, reason: "the run printed no complete `Ran N tests` and OK/FAILED trailer (it was cut short, or the output is not unittest's), so the per-test lines could not be reconciled against the runner's own count" };
+            }
+            if (declaredCount !== resultLines) {
+                return { reconciled: false, reason: `unittest reported ${String(declaredCount)} test(s) but ${String(resultLines)} per-test result line(s) were parsed, so some lines were missed or printed by the code under test` };
+            }
+            return { reconciled: true, reason: null };
+        },
         feed(line) {
+            const ran = UNITTEST_RAN_TRAILER.exec(line);
+            if (ran !== null)
+                declaredCount = Number(ran[1]);
+            else if (declaredCount !== null && UNITTEST_STATUS_TRAILER.test(line))
+                sawStatusTrailer = true;
             const direct = UNITTEST_RESULT_LINE.exec(line);
             if (direct !== null) {
                 pendingHeader = null;
@@ -1097,35 +1059,72 @@ export function createEventTranslator(emit, service, processId) {
     }
     return { handle, flush, coverage: () => ({ testsObserved, idsPresent, notRun }) };
 }
+export function runnerOutputGapReason(droppedChars) {
+    return (`${String(droppedChars)} characters of the test runner's output were dropped before they could be read; ` +
+        "any test result printed in that span was not observed, so the results reported for this run are incomplete.");
+}
+export function reportRunnerOutputGap(emit, details) {
+    emit({
+        timestamp: new Date().toISOString(),
+        source: "test-runner",
+        service: details.service,
+        process: details.processId,
+        traceId: null,
+        requestId: null,
+        correlationId: null,
+        graphNodeId: null,
+        stackTrace: null,
+        confidence: 1,
+        redactionStatus: "pending-redaction",
+        collectorVersion: COLLECTOR_VERSION,
+        eventType: "COLLECTOR_ERROR",
+        payload: { collector: details.collector, reason: runnerOutputGapReason(details.droppedChars), droppedChars: details.droppedChars },
+        sourceLocation: null,
+    });
+}
 /**
- * Feeds complete NDJSON lines from `managed`'s growing output buffer to
+ * Feeds complete NDJSON lines from `managed`'s output to
  * `onLine`, exactly once each, as they arrive -- streaming-first, not
  * batched until the process exits. A narrower, single-purpose relative of
- * `orchestrator`'s `createPollingProcessOutputSource` (same buffer-growth
- * assumption, same "ends only once the process is finished AND the buffer
+ * `orchestrator`'s `createPollingProcessOutputSource` (same cursor read and
+ * gap handling, same "ends only once the process is finished AND the buffer
  * stopped growing" ordering) rather than a shared dependency on it: this
  * collector only ever needs complete lines fed to a callback, not the
  * general `ProcessOutputSource` shape, and taking a dependency on
  * `@descryy/runtime-orchestrator` -- the assembly layer -- from a collector
  * would invert the direction every other package in this repo depends in.
  */
-export async function pumpLines(managed, onLine, pollIntervalMs = 20) {
+export async function pumpLines(managed, onLine, options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? 20;
     const splitter = new LineSplitter();
-    let consumed = 0;
+    const resync = new GapResynchronizer();
+    let cursor = 0;
     let finished = false;
     void managed.waitForExit().then(() => {
         finished = true;
     });
+    function reportGap() {
+        const gap = resync.take();
+        if (gap !== null)
+            options.onGap?.(gap.droppedChars);
+    }
     for (;;) {
-        const whole = managed.readOutput();
-        if (whole.length > consumed) {
-            const chunk = whole.slice(consumed);
-            consumed = whole.length;
-            for (const line of splitter.push(chunk)) {
+        const exitedBeforeRead = finished;
+        const read = managed.readOutputFrom(cursor);
+        const advanced = read.cursor !== cursor || read.droppedChars > 0;
+        cursor = read.cursor;
+        resync.recordGap(read.droppedChars, splitter);
+        if (advanced) {
+            const lines = splitter.push(resync.admit(read.text));
+            if (lines.length > 0)
+                reportGap();
+            for (const line of lines) {
                 onLine(line);
             }
+            continue;
         }
-        if (finished && whole.length === consumed) {
+        if (exitedBeforeRead) {
+            reportGap();
             for (const line of splitter.flush()) {
                 onLine(line);
             }
@@ -1150,27 +1149,116 @@ function computeCapabilities() {
         externalServiceObservation: status,
     };
 }
+function isGoTestCommand(rawCommand) {
+    const tokenized = tokenizeCommand(rawCommand);
+    if (!tokenized.ok)
+        return false;
+    const name = tokenized.command.split(/[\\/]/).pop() ?? tokenized.command;
+    return (name === "go" || name === "go.exe") && tokenized.args.includes("test");
+}
+const IN_PROCESS_REPORTER_RUNNERS = new Set(["jest", "vitest", "playwright", "pytest", "rspec", "minitest", "phpunit", "junit", "xunit"]);
+function resultTestimonyDisclosures(kind) {
+    if (kind === "unittest") {
+        return ["unittest results are parsed from the runner's text output, not a structured report; the code under test can print lines that look like results, so they are testimony of the run, reconciled only against unittest's own `Ran N tests` count."];
+    }
+    if (IN_PROCESS_REPORTER_RUNNERS.has(kind)) {
+        return [`${kind} results arrive on the same output stream as the code under test; a test that prints reporter-shaped lines could forge them, so treat them as testimony of the run, not proof.`];
+    }
+    return [];
+}
 export function createTestRunnerCollector(options) {
+    if (isGoTestCommand(options.configuration.command)) {
+        const { command, cwd, filesystemPolicy, networkPolicy } = options.configuration;
+        return createGoTestCollector({
+            command,
+            cwd,
+            ...(options.service === undefined ? {} : { service: options.service }),
+            ...(filesystemPolicy === undefined ? {} : { filesystemPolicy }),
+            ...(networkPolicy === undefined ? {} : { networkPolicy }),
+            ...(options.configuration.collectCoverage === true ? { collectCoverage: true } : {}),
+            ...(options.configuration.timeoutMs === undefined ? {} : { timeoutMs: options.configuration.timeoutMs }),
+            ...(options.inheritHostEnvironment === undefined ? {} : { inheritHostEnvironment: options.inheritHostEnvironment }),
+            ...(options.passthroughEnvironmentNames === undefined ? {} : { passthroughEnvironmentNames: options.passthroughEnvironmentNames }),
+        });
+    }
+    const collectCoverage = options.configuration.collectCoverage === true;
+    let coverage = unavailableCoverage(collectCoverage ? "no run has completed (it has not started, was refused, or is still running)" : "coverage collection was not requested (collectCoverage is not true)");
+    let coverageCapture = null;
     const capabilities = computeCapabilities();
     let context = null;
     let managed = null;
     let completion = Promise.resolve();
     let translator = null;
     let exitInfo = null;
+    let wrapperDisclosureList = [];
+    let wrapperCleanup = null;
+    let timeoutGuard = null;
+    let vitestPlan = null;
+    const locationTally = { results: 0, withoutLocation: 0 };
+    const runWrapperCleanup = () => {
+        const cleanup = wrapperCleanup;
+        wrapperCleanup = null;
+        if (cleanup === null)
+            return;
+        try {
+            cleanup();
+        }
+        catch (error) {
+            console.error(`[test-runner-collector] removing the per-run wrapper cache failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
     return {
         collectorId: "test-runner-collector",
         async start(ctx) {
             context = ctx;
+            const timeout = resolveRunTimeout(options.configuration.timeoutMs);
+            if (!timeout.ok)
+                return { available: false, reason: timeout.reason };
             const discovery = discoverRunner(options.configuration.command);
             if (!discovery.ok) {
                 return { available: false, reason: discovery.reason };
             }
+            // A wrapper's environment is found before anything is spawned, and the run is refused --
+            // naming the command that prepares it -- when there is none: creating one is an install.
+            let wrapperEnv = {};
+            let filesystemPolicy = options.configuration.filesystemPolicy;
+            if (discovery.wrapper !== undefined) {
+                const located = locateWrapperEnvironment(discovery.wrapper, options.configuration.cwd, process.env, discovery.command);
+                if (!located.ok)
+                    return { available: false, reason: located.reason };
+                wrapperEnv = located.env;
+                wrapperDisclosureList = located.disclosures;
+                wrapperCleanup = located.cleanup ?? null;
+                if (filesystemPolicy !== undefined) {
+                    filesystemPolicy = { ...filesystemPolicy, readOnlyRoots: [...(filesystemPolicy.readOnlyRoots ?? []), ...located.readOnlyRoots] };
+                }
+            }
+            const childEnvironment = buildChildEnvironment({
+                ...(options.inheritHostEnvironment === undefined ? {} : { inheritHostEnvironment: options.inheritHostEnvironment }),
+                ...(options.passthroughEnvironmentNames === undefined ? {} : { passthroughNames: options.passthroughEnvironmentNames }),
+            });
+            if (childEnvironment.disclosure !== null)
+                wrapperDisclosureList = [...wrapperDisclosureList, childEnvironment.disclosure];
+            wrapperDisclosureList = [...wrapperDisclosureList, ...resultTestimonyDisclosures(discovery.kind)];
+            vitestPlan = discovery.kind === "vitest" ? planVitestRun(options.configuration.cwd) : null;
+            const runnerArgs = reporterFlagsFor(discovery.kind, discovery.args, vitestPlan === null ? undefined : { vitestTaskLocation: vitestPlan.taskLocationFlag });
+            if (collectCoverage) {
+                const begun = beginCoverageCapture(discovery.kind, options.configuration.cwd);
+                if (begun.ok) {
+                    coverageCapture = begun.capture;
+                    if (filesystemPolicy !== undefined)
+                        filesystemPolicy = withCoverageDirectoryAllowed(filesystemPolicy, begun.capture.directory);
+                }
+                else {
+                    coverage = unavailableCoverage(begun.reason);
+                }
+            }
             const processId = `test-runner-${Date.now()}`;
             try {
                 managed = spawnProcess({
                     processId,
-                    command: discovery.command,
-                    args: reporterFlagsFor(discovery.kind, discovery.args),
+                    command: discovery.wrapper?.command ?? discovery.command,
+                    args: discovery.wrapper === undefined ? runnerArgs : wrappedSpawnArgs(discovery.wrapper, discovery.command, runnerArgs),
                     cwd: options.configuration.cwd,
                     // `NODE_TEST_CONTEXT` (set by node's own `--test` on itself, inherited
                     // by every child process unless cleared) is load-bearing here, and it
@@ -1190,7 +1278,7 @@ export function createTestRunnerCollector(options) {
                     // `reporterEnvFor` adds nothing for every runner but pytest, whose
                     // plugin is loaded by importable name and needs `PYTHONPATH` to
                     // resolve it (see `RunnerProfile.reporterEnv`'s own doc comment).
-                    env: { NODE_TEST_CONTEXT: undefined, ...reporterEnvFor(discovery.kind, discovery.args) },
+                    env: { ...childEnvironment.env, NODE_TEST_CONTEXT: undefined, ...reporterEnvFor(discovery.kind, discovery.args), ...wrapperEnv, ...coverageCapture?.environment },
                     // §21 execution boundary, threaded through exactly like
                     // `ExecutionController.run()`'s own spawn site -- absent means
                     // unconstrained, same as there. Unlike that site, this collector
@@ -1200,11 +1288,17 @@ export function createTestRunnerCollector(options) {
                     // unconstrained when a declared policy can't be enforced -- caught
                     // below and reported the same honest way `discoverRunner` failures
                     // already are, per `Collector.start()`'s "never throw" contract.
-                    ...(options.configuration.filesystemPolicy === undefined ? {} : { filesystemPolicy: options.configuration.filesystemPolicy }),
+                    ...(filesystemPolicy === undefined ? {} : { filesystemPolicy }),
                     ...(options.configuration.networkPolicy === undefined ? {} : { networkPolicy: options.configuration.networkPolicy }),
                 });
             }
             catch (err) {
+                if (coverageCapture !== null) {
+                    coverageCapture.dispose();
+                    coverageCapture = null;
+                    coverage = unavailableCoverage("the runner did not start");
+                }
+                runWrapperCleanup();
                 return { available: false, reason: err instanceof Error ? err.message : String(err) };
             }
             // Attached independently of `pumpLines`' own `waitForExit()` -- a
@@ -1213,6 +1307,13 @@ export function createTestRunnerCollector(options) {
             void managed.waitForExit().then((info) => {
                 exitInfo = info;
             });
+            timeoutGuard = armRunTimeout(managed, {
+                runner: discovery.kind,
+                timeoutMs: timeout.timeoutMs,
+                emit: ctx.emit,
+                service: options.service ?? null,
+                processId,
+            });
             translator = createEventTranslator(context.emit, options.service, processId);
             const activeTranslator = translator;
             const gate = createEnvelopeGate();
@@ -1238,15 +1339,14 @@ export function createTestRunnerCollector(options) {
             // **unittest never speaks the NDJSON envelope** (see this file's own
             // top doc comment): there is no reporter to gate, only a text parser.
             // Every other profile shares the one JSON-envelope path below.
-            const onLine = discovery.kind === "unittest"
-                ? (() => {
-                    const unittestParser = createUnittestResultParser();
-                    return (line) => {
-                        for (const event of unittestParser.feed(line)) {
-                            activeTranslator.handle(event);
-                        }
-                    };
-                })()
+            const activeCapture = coverageCapture;
+            const unittestParser = discovery.kind === "unittest" ? createUnittestResultParser() : null;
+            const onLine = unittestParser !== null
+                ? (line) => {
+                    for (const event of unittestParser.feed(line)) {
+                        activeTranslator.handle(event);
+                    }
+                }
                 : (line) => {
                     if (line.trim() === "")
                         return;
@@ -1283,9 +1383,20 @@ export function createTestRunnerCollector(options) {
                     }
                     if (verdict.kind !== "event")
                         return;
+                    if (vitestPlan !== null && (parsed.type === "test:pass" || parsed.type === "test:fail")) {
+                        locationTally.results++;
+                        if (typeof parsed.data.line !== "number")
+                            locationTally.withoutLocation++;
+                    }
+                    if (typeof parsed.data.file === "string")
+                        activeCapture?.observeTestFile(parsed.data.file);
                     activeTranslator.handle(parsed);
                 };
-            completion = pumpLines(managed, onLine).then(() => {
+            completion = pumpLines(managed, onLine, {
+                onGap: (droppedChars) => {
+                    reportRunnerOutputGap(ctx.emit, { collector: "test-runner", service: options.service ?? null, processId, droppedChars });
+                },
+            }).then(() => {
                 // The very last test's result has no "next test:start" or
                 // no-`file` diagnostic to flush it -- node's own suite-level
                 // summary diagnostics almost always follow, but relying on that
@@ -1293,16 +1404,37 @@ export function createTestRunnerCollector(options) {
                 // unusual stream (the process killed mid-run, `stop()` called
                 // early) leaves the last real result buffered and never emitted.
                 activeTranslator.flush();
+                if (unittestParser !== null) {
+                    const reconciliation = unittestParser.finish();
+                    if (!reconciliation.reconciled)
+                        reportEnvelopeError(`unittest results are read from text and could not be reconciled: ${reconciliation.reason ?? "unknown"}`);
+                }
+                if (activeCapture !== null) {
+                    try {
+                        coverage = activeCapture.collect();
+                    }
+                    catch (error) {
+                        coverage = unavailableCoverage(`coverage data could not be read: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    finally {
+                        activeCapture.dispose();
+                    }
+                }
             });
             return { available: true };
         },
         async stop() {
+            timeoutGuard?.cancel();
             if (managed !== null) {
                 await managed.kill();
             }
             await completion;
+            runWrapperCleanup();
             context = null;
         },
+        timedOut() {
+            return timeoutGuard?.timedOut() ?? false;
+        },
         capabilities() {
             return capabilities;
         },
@@ -1315,6 +1447,26 @@ export function createTestRunnerCollector(options) {
         processExit() {
             return exitInfo;
         },
+        wrapperDisclosures() {
+            return wrapperDisclosureList;
+        },
+        degradations() {
+            return vitestLocationDegradations(vitestPlan, locationTally);
+        },
+        sandboxDisclosures() {
+            return managed?.sandboxDisclosures() ?? NO_SANDBOX_DISCLOSURES;
+        },
+        executedCoverage() {
+            return coverage;
+        },
+        outputTail(maxBytes = 8192) {
+            // Combined stdout+stderr, as the process wrote it. Raw: the caller redacts before it is
+            // shown to anyone, since only the caller knows which secret values were in the environment.
+            if (managed === null)
+                return null;
+            const whole = managed.readOutput();
+            return whole.length <= maxBytes ? whole : whole.slice(whole.length - maxBytes);
+        },
     };
 }
 //# sourceMappingURL=test-runner-collector.js.map