@descryy/runtime-test-runner 0.0.0

package/dist/test-runner-collector.js

@@ -0,0 +1,1014 @@
+/**
+ * §17's test-runner observation: **`node:test` (RT-073), Jest and Vitest
+ * (RT-123)**, each observed through that runner's own structured reporter
+ * API rather than TAP, a JSON summary file, or any other printed format.
+ *
+ * ## Three reporters, one envelope, no per-runner branch below this line
+ *
+ * The per-runner knowledge is *what a runner's own API calls things*, and
+ * that only exists inside the runner's process. So each runner gets a
+ * reporter that speaks its API (`reporter.ts`, `jest-reporter.ts`,
+ * `vitest-reporter.ts`) and writes one shared NDJSON envelope — node:test's
+ * own event and field names, kept because they were first. Everything from
+ * `createEventTranslator` down is runner-agnostic, the same boundary rule
+ * the IR has. The only per-runner logic is `PROFILES` below: how a command
+ * is recognised, what it is refused for, and which flags are injected.
+ *
+ * ## The defect a second runner exposed in code that had already shipped
+ *
+ * A `test.skip` emits **`test:pass` carrying `skip: true`** on node:test,
+ * and the translator mapped every `test:pass` to TEST_PASSED — so a
+ * skipped test was evidence of a passing one, the shape this checklist
+ * exists to ban, invisible because every fixture was fully-running. They
+ * are counted now, not emitted; see `TraceCoverage.notRun`.
+ *
+ * The node:test notes below still describe what this file's node path
+ * does, unchanged.
+ *
+ * `test:start` / `test:pass` / `test:fail` translate directly into
+ * `TEST_STARTED` / `TEST_PASSED` / `TEST_FAILED` Evidence, with the real
+ * `file`/`line`/`column` Node's own reporter stream already carries —
+ * `reliability: "self-contained"`, the same class a Python traceback or
+ * Ruby backtrace gets, since this came from the runtime's own captured
+ * state, not derivation.
+ *
+ * **Discovery is declared, never inferred** (RT-032's own precedent):
+ * `discoverRunner` refuses a command that names none of the three runners
+ * it observes, rather than sniffing `package.json`/lockfiles to guess which
+ * runner a project uses. Also refuses a command that already carries its
+ * own `--test-reporter` — safely co-existing with an unknown pre-existing
+ * reporter configuration (matching destinations positionally, possibly
+ * conflicting output) is real complexity this collector does not attempt
+ * to get right blindly; a caller who wants both gets an honest refusal
+ * naming why, not a best-effort guess.
+ *
+ * **Trace capture (RT-074): declared, via `TestContext.diagnostic()`, not
+ * inferred from anything.** A test that makes a backend call and wants its
+ * TEST_PASSED/TEST_FAILED evidence to correlate with that call's backend
+ * evidence calls `t.diagnostic("requestId: <the id it used>")` (and/or
+ * `traceId: ...`) — a real node:test API, surfaced as its own
+ * `test:diagnostic` reporter event, distinguishable from suite-level
+ * summary diagnostics by carrying the same `file`/`line` as the test
+ * itself. Nothing here guesses a request id from timing or proximity; a
+ * test that says nothing gets `requestId: null`, same as before.
+ *
+ * **TEST_CASE graph mapping (RT-076): `payload.qualifiedName`, not
+ * `payload.name`, is what a real graph resolves against.** node:test's own
+ * events carry only a test's innermost title; `adapter-typescript`'s
+ * TEST_CASE node name is the full `describe()` chain, space-joined ahead
+ * of the title. `SuiteStack` (below) reconstructs that chain purely from
+ * the reporter stream this collector already reads. `graphNodeId` on
+ * emitted evidence is still always null here, same as every other
+ * collector — `graph-mapping.ts`'s `resolveObservedTestCase` is what a
+ * caller holding both the store and the graph driver uses to resolve and
+ * attribute it, after `write()`, the same way `vertical-slice` already
+ * does for every other evidence type.
+ *
+ * **A note for whoever next mutation-tests this file (RT-080).** This
+ * package's own tests import `@descryy/runtime-test-runner` by package
+ * name, resolving through `exports` to `dist/` — not `../src/*.ts`
+ * directly. Mutating this file and re-running with a bare `node --test
+ * <file>` proves nothing: the compiled `dist/` is untouched and the
+ * mutation is never in the code path actually executed, an inert check
+ * that reads as a passing safety net. Always rebuild between mutate and
+ * run — `npm test` at the repo root does this automatically (`npm run
+ * build && node --test ...`); a scoped `npx tsc -b packages/test-runner`
+ * before a scoped `node --test packages/test-runner/test/*.test.ts` also
+ * 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 { COLLECTOR_VERSION } from "./collector-version.js";
+/**
+ * The version of the NDJSON envelope every reporter speaks (RT-130).
+ *
+ * ## Why a version, and why now rather than when it first hurts
+ *
+ * The three reporters that exist today are TypeScript in this package,
+ * compiled by the same `tsc -b` as the translator — so they cannot drift
+ * from it without the build saying so. **The JUnit listener will not be**:
+ * it is a Java source built by a separate step, and a compiled artifact
+ * that still runs while the envelope moves underneath it produces *wrong
+ * events*, not a build error.
+ *
+ * That is the failure the placement argument was really about. Wiring a
+ * build step can only tell you a file did not compile; it cannot tell you
+ * the thing that *did* compile is no longer telling the truth. A version
+ * in the stream can, at the moment it would otherwise be believed.
+ *
+ * **Landed before the first out-of-band reporter exists, deliberately.** A
+ * version added afterwards has nothing to check on the transition it was
+ * added for: the first listener would speak an unversioned envelope, and
+ * the absence-is-an-error rule below could not be turned on without
+ * breaking it.
+ *
+ * Bump this only when the envelope's *meaning* changes for an existing
+ * field. Adding an optional field a reporter may omit — `skipReason`,
+ * `isSuite`, `qualifiedName` — is not a bump: an older reporter that never
+ * sets it is still telling the truth, and the translator already has a
+ * documented answer for its absence.
+ */
+export const ENVELOPE_VERSION = 1;
+/** The handshake line every reporter emits before its first event. */
+export const ENVELOPE_HANDSHAKE_TYPE = "descry:envelope";
+/**
+ * The envelope gate, a function of its own because the case it exists for
+ * **cannot be reached end to end** (RT-130).
+ *
+ * Measured: node:test redirects a test's stdout — the patched
+ * `process.stdout.write` and the raw fd alike — and re-emits its output as
+ * a `test:stdout` event. So a fixture cannot put a stale handshake on the
+ * wire, and there is no way to drive the mismatch path through a real
+ * `node --test` run. That is a genuine safety property of the design (a
+ * test's own `console.log` can never be mistaken for a reporter line) and
+ * simultaneously the reason this logic is a pure function with its own
+ * tests rather than four lines inside `start()`.
+ *
+ * Stated rather than left as a coverage gap: the wiring is asserted end to
+ * end — a real run declares version 1, produces no `COLLECTOR_ERROR`, and
+ * the handshake never becomes an event — and the refusal is asserted here.
+ */
+export function createEnvelopeGate() {
+    let seen = false;
+    let refused = false;
+    return {
+        inspect(parsed, isEvent) {
+            const declared = envelopeVersionOf(parsed);
+            if (declared !== null) {
+                if (declared !== ENVELOPE_VERSION && !refused) {
+                    refused = true;
+                    return {
+                        kind: "refuse",
+                        reason: `reporter declared envelope version ${declared}; this collector speaks ${ENVELOPE_VERSION}. ` +
+                            "A reporter built out of band — a compiled listener rather than this package's TypeScript — can run " +
+                            "against a moved envelope with no build failing, which is the case this check exists for.",
+                    };
+                }
+                seen = true;
+                return { kind: "handshake" };
+            }
+            if (!isEvent || refused)
+                return { kind: "ignore" };
+            if (!seen) {
+                refused = true;
+                return {
+                    kind: "refuse",
+                    reason: "a reporter event arrived before any envelope declaration. A reporter that never declares one is older " +
+                        `than envelope ${ENVELOPE_VERSION}, and its events cannot be read as this version's.`,
+                };
+            }
+            return { kind: "event" };
+        },
+    };
+}
+/** The declared envelope version of a handshake line, or null for any other line. */
+function envelopeVersionOf(parsed) {
+    if (typeof parsed !== "object" || parsed === null)
+        return null;
+    const line = parsed;
+    if (line.type !== ENVELOPE_HANDSHAKE_TYPE)
+        return null;
+    // A handshake whose version is not a number is a broken reporter, not a
+    // missing one -- reported as version -1 so it fails the equality check
+    // and produces the mismatch error rather than being ignored as noise.
+    return typeof line.data?.version === "number" ? line.data.version : -1;
+}
+const REPORTER_MODULE_PATH = fileURLToPath(new URL("./reporter.js", import.meta.url));
+const JEST_REPORTER_MODULE_PATH = fileURLToPath(new URL("./jest-reporter.js", import.meta.url));
+const VITEST_REPORTER_MODULE_PATH = fileURLToPath(new URL("./vitest-reporter.js", import.meta.url));
+const PLAYWRIGHT_REPORTER_MODULE_PATH = fileURLToPath(new URL("./playwright-reporter.js", import.meta.url));
+/**
+ * **JUnit has no reporter flag.** `DescryJUnitListener` is discovered by
+ * `ServiceLoader` from a `META-INF/services` entry, so this profile's job is
+ * to put the listener's classes on the launcher's `--class-path`, not to
+ * inject an argv flag the way the other three do (RT-137).
+ *
+ * Computed from `import.meta.url` like the other reporter paths rather than
+ * imported from `reporters/junit/build.mjs`: that file is outside this
+ * package's `rootDir`, so a static import would not compile. The duplication
+ * is guarded by a test asserting this equals the build's own
+ * `LISTENER_CLASSPATH` — a red test rather than a silent drift if either
+ * side moves.
+ */
+const JUNIT_LISTENER_CLASSPATH = fileURLToPath(new URL("../reporters/junit/classes", import.meta.url));
+/** `:` everywhere but Windows, where the JVM splits a classpath on `;`. */
+const JUNIT_CLASSPATH_SEPARATOR = process.platform === "win32" ? ";" : ":";
+/**
+ * **The .NET logger is loaded by friendly name from an adapter path**, so
+ * this profile injects two flags and one RunSettings entry rather than a
+ * reporter module (RT-139). Recomputed from `import.meta.url` for the same
+ * `rootDir` reason as JUnit's, and guarded by the same equality test.
+ */
+const XUNIT_ADAPTER_PATH = fileURLToPath(new URL("../reporters/xunit/bin/Release/netstandard2.0", import.meta.url));
+const XUNIT_LOGGER_NAME = "descry";
+/**
+ * **pytest loads a plugin by importable name, not by path** (RT-107), so
+ * this is a `PYTHONPATH` entry, not a reporter module the way node:test's,
+ * Jest's and Vitest's are. Computed from `import.meta.url` for the same
+ * `rootDir` reason JUnit's and xUnit's paths are.
+ */
+const PYTEST_PLUGIN_DIR = fileURLToPath(new URL("../reporters/pytest", import.meta.url));
+const PYTEST_PLUGIN_MODULE = "descry_pytest_plugin";
+const PYTHONPATH_SEPARATOR = process.platform === "win32" ? ";" : ":";
+/**
+ * RSpec's formatter is loaded the same way Jest's/Vitest's reporter modules
+ * are — a path handed straight to the runner's own loading flag — so unlike
+ * pytest this needs no `reporterEnv`.
+ */
+const RSPEC_FORMATTER_PATH = fileURLToPath(new URL("../reporters/rspec/descry_rspec_formatter.rb", import.meta.url));
+const RSPEC_FORMATTER_CLASS = "DescryRSpecFormatter";
+/**
+ * **PHPUnit's extension is registered by class name, and the class must
+ * already be declared when `--extension` is processed** (RT-109's own
+ * fixture proves this: its `bootstrap.php` requires the file before
+ * PHPUnit's `<extensions>` block runs). `--bootstrap <file>` runs after
+ * PHPUnit's own autoloading is live — unlike `-d auto_prepend_file`, which
+ * runs before it and was measured to fatal on `implements Extension` not
+ * yet being defined. Verified directly: `php <phar> --no-configuration
+ * --bootstrap <this file> --extension DescryPhpUnitExtension <test file>`
+ * emits a full, real envelope with no project config file at all.
+ */
+const PHPUNIT_EXTENSION_PATH = fileURLToPath(new URL("../reporters/phpunit/DescryPhpUnitExtension.php", import.meta.url));
+const PHPUNIT_EXTENSION_CLASS = "DescryPhpUnitExtension";
+/**
+ * Minitest's reporter is loaded the same way RSpec's formatter is — a path
+ * handed straight to `-r` — so like RSpec, and unlike pytest, this needs no
+ * `reporterEnv`.
+ */
+const MINITEST_REPORTER_PATH = fileURLToPath(new URL("../reporters/minitest/descry_minitest_reporter.rb", import.meta.url));
+/**
+ * **The only real, caller-declared signal Minitest has** (RT-minitest-
+ * discovery-is-not-argv-disambiguable.md). Minitest has no dedicated binary
+ * and no distinguishing flag — `ruby test/foo_test.rb` is indistinguishable
+ * by argv alone from any other Ruby script; the file's own `require
+ * "minitest/autorun"` line is invisible to a collector that only reads the
+ * command, and reading the file to check would be exactly the sniffing
+ * RT-032 forbids. An explicit `-r minitest/autorun` on the command line is
+ * different in kind: it is the caller declaring, in argv, the same fact the
+ * bare-file form only states inside the file. Ruby accepts a `-r` library
+ * name either as its own token or concatenated (`-rminitest/autorun`); both
+ * are checked, since a caller who wrote either spelling declared the same
+ * thing.
+ */
+function declaresRequire(args, library) {
+    return args.some((arg, index) => (arg === "-r" && args[index + 1] === library) || arg === `-r${library}`);
+}
+/**
+ * `dotnet test` ends argv parsing at the first bare `--`: everything after
+ * it is RunSettings, and a second `--` is an argument rather than a second
+ * section.
+ *
+ * **So flags and settings cannot both be appended.** The first version of
+ * this profile appended `--logger descry` to the end of a command that
+ * already had a `--`, which handed the logger name to VSTest as a *setting*
+ * — a run that would have started, found no logger, and produced no events
+ * while looking entirely healthy. Caught by the test written for the
+ * setting, not by review.
+ */
+function withDotnetArgs(args, flags, settings) {
+    const separator = args.indexOf("--");
+    const argv = separator === -1 ? args : args.slice(0, separator);
+    const existing = separator === -1 ? [] : args.slice(separator + 1);
+    const allSettings = [...existing, ...settings];
+    return allSettings.length === 0 ? [...argv, ...flags] : [...argv, ...flags, "--", ...allSettings];
+}
+/** Where the classpath VALUE sits in argv, for `--class-path V`, `--class-path=V`, `--classpath` and `-cp`. */
+function classPathArg(args) {
+    const NAMES = ["--class-path", "--classpath", "-cp"];
+    for (const [index, arg] of args.entries()) {
+        if (NAMES.includes(arg))
+            return index + 1 < args.length ? { index: index + 1, inline: false } : null;
+        if (NAMES.some((n) => arg.startsWith(`${n}=`)))
+            return { index, inline: true };
+    }
+    return null;
+}
+const hasFlag = (args, flag) => args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+/**
+ * **Where the reporter flags land in argv is load-bearing for node, not
+ * cosmetic.** Measured while building RT-073: `node --test sample.test.mjs
+ * --test-reporter=... --test-reporter-destination=...` silently falls back
+ * to the default TAP reporter -- once node's `--test` argument parser sees
+ * a positional file argument, anything after it stops being read as a
+ * flag. `node --test --test-reporter=... --test-reporter-destination=...
+ * sample.test.mjs` works. `discoverRunner` only guarantees `--test` is
+ * present *somewhere* in `args`, not that it is the last flag before any
+ * file arguments (a caller may pass `node --test --concurrency=4
+ * some.test.mjs`, and the reporter flags need to land after `--test` but
+ * still before `some.test.mjs`) -- so this inserts them immediately after
+ * the `--test` token specifically, not at the end of the array.
+ *
+ * Jest and Vitest both use full CLI parsers (yargs / cac) that read flags
+ * anywhere, so theirs are appended. That is a real difference between the
+ * three and is why this is per-runner rather than one shared rule.
+ */
+export function withReporterFlags(args) {
+    const testIndex = args.indexOf("--test");
+    const before = args.slice(0, testIndex + 1);
+    const after = args.slice(testIndex + 1);
+    return [...before, `--test-reporter=${REPORTER_MODULE_PATH}`, "--test-reporter-destination=stdout", ...after];
+}
+const PROFILES = [
+    {
+        kind: "node:test",
+        // Matched on the executable alone, with `--test` checked in `refuse`
+        // rather than here. Matching on both would make `node server.mjs` fall
+        // through to the generic "names no runner" message, which is true and
+        // useless -- the specific "you gave me node without --test" is the one
+        // a caller can act on.
+        matches: (baseName) => baseName === "node" || baseName === "node.exe",
+        refuse: (args) => {
+            if (!args.includes("--test")) {
+                return "command does not include --test -- this collector only observes node's own built-in test runner (node --test ...), never a different one inferred from the command shape.";
+            }
+            return hasFlag(args, "--test-reporter")
+                ? "command already configures --test-reporter -- this collector needs to own the reporter to observe structured events, and safely co-existing with an unknown existing reporter configuration is not attempted. Remove the existing --test-reporter/--test-reporter-destination flags."
+                : null;
+        },
+        withReporterFlags,
+    },
+    {
+        kind: "jest",
+        matches: (baseName) => baseName === "jest" || baseName === "jest.js",
+        refuse: (args) => hasFlag(args, "--reporters")
+            ? "command already configures --reporters -- this collector needs to own the reporter to observe structured events, and Jest's --reporters REPLACES the default set rather than adding to it, so co-existing safely with an unknown one is not attempted. Remove the existing --reporters flag."
+            : null,
+        // `--testLocationInResults` is not optional decoration: measured,
+        // without it every `testCaseResult.location` is `undefined` and every
+        // emitted event silently carries no line or column.
+        withReporterFlags: (args) => [...args, `--reporters=${JEST_REPORTER_MODULE_PATH}`, "--testLocationInResults"],
+    },
+    {
+        kind: "vitest",
+        matches: (baseName) => baseName === "vitest" || baseName === "vitest.js",
+        refuse: (args) => {
+            // **Vitest defaults to WATCH mode**, and a watching runner never
+            // exits -- `pumpLines` would poll a live buffer until the observation
+            // window closed and the process was killed, reporting whatever
+            // partial run it had seen. Refused by name rather than "fixed" by
+            // injecting `run`, because silently changing what a declared command
+            // does is the guessing this seam exists to avoid.
+            if (!args.includes("run") && !hasFlag(args, "--run")) {
+                return "command does not include `run` -- `vitest` alone starts WATCH mode, which never exits, so this collector would observe a partial run and report it as a complete one. Declare `vitest run ...` explicitly rather than have this collector rewrite the command.";
+            }
+            return hasFlag(args, "--reporter")
+                ? "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"],
+    },
+    {
+        kind: "junit",
+        // `java` alone, with the specifics in `refuse` — the node:test
+        // precedent. `java -jar app.jar` is an ordinary command and the useful
+        // answer for it is "that is not the console launcher", not the generic
+        // "names no runner this collector observes".
+        matches: (baseName) => baseName === "java" || baseName === "java.exe",
+        refuse: (args) => {
+            const isConsoleLauncher = args.some((a) => /junit-platform-console-standalone.*\.jar$/.test(a)) ||
+                args.includes("org.junit.platform.console.ConsoleLauncher");
+            if (!isConsoleLauncher) {
+                return "command runs `java` but does not name the JUnit Platform Console Launcher — this collector observes JUnit through that launcher (java -jar junit-platform-console-standalone-<version>.jar execute ...), never a JVM process inferred from the command shape.";
+            }
+            if (classPathArg(args) === null) {
+                return ("command has no --class-path to extend, and this collector will not add one. The listener is ServiceLoader-discovered from the classpath, so it must join an existing one; " +
+                    "introducing the first --class-path would change how the launcher resolves the tests themselves rather than adding to it. Declare --class-path explicitly.");
+            }
+            return null;
+        },
+        // **Appended to the existing value, never passed as a second flag.** A
+        // second --class-path does not merge, it replaces — which would take
+        // the caller's own test classes off the path and report zero tests
+        // found: a green run that observed nothing.
+        withReporterFlags: (args) => {
+            const found = classPathArg(args);
+            if (found === null)
+                return args;
+            const next = [...args];
+            next[found.index] = `${next[found.index]}${JUNIT_CLASSPATH_SEPARATOR}${JUNIT_LISTENER_CLASSPATH}`;
+            return next;
+        },
+    },
+    {
+        kind: "playwright",
+        matches: (baseName) => baseName === "playwright" || baseName === "playwright.js",
+        refuse: (args) => {
+            // `playwright` alone is the CLI (codegen, install, show-report); only
+            // `test` runs tests. Named rather than left to the generic message,
+            // the node:test precedent.
+            if (!args.includes("test")) {
+                return "command runs `playwright` but not `playwright test` — this collector observes the Playwright *test runner*, not the CLI's other subcommands (codegen, install, show-report).";
+            }
+            if (hasFlag(args, "--reporter")) {
+                return "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.";
+            }
+            return null;
+        },
+        // **No location flag, and that is the finding.** Playwright is the only
+        // runner on this seam that populates `TestCase.location` unasked
+        // (RT-144); every other one either needs a flag or cannot do it at all.
+        withReporterFlags: (args) => [...args, `--reporter=${PLAYWRIGHT_REPORTER_MODULE_PATH}`],
+    },
+    {
+        kind: "xunit",
+        matches: (baseName) => baseName === "dotnet" || baseName === "dotnet.exe",
+        refuse: (args) => {
+            if (args[0] !== "test") {
+                return "command runs `dotnet` but not `dotnet test` — this collector observes .NET tests through the VSTest logger interface, never a dotnet subcommand inferred from the command shape.";
+            }
+            if (hasFlag(args, "--logger")) {
+                return "command already configures --logger — this collector needs to own the logger to observe structured events, and co-existing safely with an unknown one is not attempted. Remove the existing --logger flag.";
+            }
+            if (hasFlag(args, "--test-adapter-path")) {
+                return "command already configures --test-adapter-path — the logger is loaded from that path, so a second one would decide which logger is found. Remove the existing --test-adapter-path flag.";
+            }
+            // Not silently left alone: if the caller has already declared this
+            // setting we cannot know whether they set it false, and a false value
+            // empties `TestCase.CodeFilePath` — every event silently carrying no
+            // location, which is Jest's `--testLocationInResults` failure exactly
+            // (RT-123) and invisible in a green run.
+            if (args.some((a) => a.includes("RunConfiguration.CollectSourceInformation"))) {
+                return "command already declares RunConfiguration.CollectSourceInformation — this collector must own it, because a false value empties TestCase.CodeFilePath and every emitted event then silently carries no source location. Remove it.";
+            }
+            return null;
+        },
+        withReporterFlags: (args) => withDotnetArgs(args, ["--logger", XUNIT_LOGGER_NAME, "--test-adapter-path", XUNIT_ADAPTER_PATH], ["RunConfiguration.CollectSourceInformation=true"]),
+    },
+    {
+        kind: "pytest",
+        // `pytest ...` directly, or `python -m pytest ...` (and the `python3`/
+        // `.exe` spellings) — the node:test precedent of matching the
+        // interpreter and checking the invocation shape in `refuse`, since
+        // `python -m pytest` and `python other_script.py` share an executable.
+        matches: (baseName, args) => baseName === "pytest" ||
+            baseName === "pytest.exe" ||
+            ((baseName === "python" || baseName === "python3" || baseName === "python.exe") &&
+                args[0] === "-m" &&
+                args[1] === "pytest"),
+        refuse: (args) => hasFlag(args, "-p")
+            ? "command already configures -p (a plugin) -- this collector needs to own the reporter plugin to observe structured events, and co-existing safely with an unknown existing one is not attempted. Remove the existing -p flag."
+            : null,
+        withReporterFlags: (args) => [...args, "-p", PYTEST_PLUGIN_MODULE],
+        // Prepended so the caller's own PYTHONPATH (if any) still resolves —
+        // this only needs to ADD the plugin's directory, never replace what a
+        // caller already declared.
+        reporterEnv: () => ({
+            PYTHONPATH: [PYTEST_PLUGIN_DIR, process.env["PYTHONPATH"]].filter((v) => Boolean(v)).join(PYTHONPATH_SEPARATOR),
+        }),
+    },
+    {
+        kind: "rspec",
+        // `rspec ...` directly, or `ruby <path/to/rspec> ...` — RSpec's own
+        // installed binary is itself a Ruby script, and some environments (this
+        // one included — see rspec-reporter.test.ts) invoke it through an
+        // explicit `ruby` interpreter rather than relying on its shebang. Told
+        // apart from an arbitrary `ruby script.rb` the same way pytest's `python
+        // -m pytest` is told apart from `python other_script.py`: by the
+        // declared script name, never by sniffing its contents.
+        matches: (baseName, args) => baseName === "rspec" || ((baseName === "ruby" || baseName === "ruby.exe") && /(^|[\\/])rspec$/.test(args[0] ?? "")),
+        refuse: (args) => hasFlag(args, "-f") || hasFlag(args, "--format")
+            ? "command already configures -f/--format -- this collector needs to own the formatter to observe structured events, and co-existing safely with an unknown existing one is not attempted. Remove the existing -f/--format flag."
+            : null,
+        // `-r` is additive in RSpec (each use adds a require, never replaces),
+        // so unlike `-f` it is always safe to add ours alongside whatever the
+        // caller already declared.
+        withReporterFlags: (args) => [...args, "-r", RSPEC_FORMATTER_PATH, "-f", RSPEC_FORMATTER_CLASS],
+    },
+    {
+        kind: "phpunit",
+        // `phpunit ...` directly (the composer-installed binary, itself a PHP
+        // script with a shebang), or `php <path/to/phpunit-or-.phar> ...` — the
+        // same dual shape as rspec's, for the same reason: some environments
+        // invoke it through an explicit `php` interpreter (this repo's own
+        // phpunit-reporter.test.ts does, against the pinned phar) rather than
+        // relying on the shebang.
+        // The pinned phar this repo's own reporter test runs is
+        // `phpunit-11.5.56.phar`, not a bare `phpunit.phar` — Composer's
+        // installed binary and the project's own downloaded phars are both
+        // routinely version-suffixed, so the match allows an optional
+        // `-<version>` between the name and the extension.
+        matches: (baseName, args) => baseName === "phpunit" ||
+            ((baseName === "php" || baseName === "php.exe") && /(^|[\\/])phpunit(-[^\\/]*)?(\.phar)?$/.test(args[0] ?? "")),
+        refuse: (args) => {
+            if (hasFlag(args, "--bootstrap")) {
+                return "command already configures --bootstrap -- this collector needs to own the bootstrap to register its extension, and PHPUnit accepts only one. Remove the existing --bootstrap flag.";
+            }
+            if (hasFlag(args, "--extension") || args.includes("--no-extensions")) {
+                return "command already configures --extension/--no-extensions -- this collector needs to register its own extension to observe structured events, and co-existing safely with an unknown existing configuration is not attempted. Remove the existing flag.";
+            }
+            return null;
+        },
+        // **`--bootstrap` before `--extension`, not the other way round** — the
+        // extension class must already be `require`-d (which `--bootstrap`
+        // does) before PHPUnit resolves the class name `--extension` names.
+        // Verified directly against the real phar; see the constant's own
+        // comment for the command.
+        withReporterFlags: (args) => [...args, "--bootstrap", PHPUNIT_EXTENSION_PATH, "--extension", PHPUNIT_EXTENSION_CLASS],
+    },
+    {
+        kind: "minitest",
+        // The interpreter alone is not enough — every `ruby <file>` command
+        // shares it, tests and non-tests alike. `declaresRequire` is what
+        // actually distinguishes a Minitest invocation, so it is checked here in
+        // `matches` rather than deferred to `refuse`, unlike every other profile
+        // on this seam where the executable name alone is sufficient signal.
+        matches: (baseName, args) => (baseName === "ruby" || baseName === "ruby.exe") && declaresRequire(args, "minitest/autorun"),
+        // `-r` is additive in Ruby (each use adds a require, never replaces),
+        // the same fact RSpec's own profile relies on, so there is nothing for
+        // a second `-r` to conflict with.
+        refuse: () => null,
+        // **Inserted right after the caller's own declared `-r`, never
+        // appended.** Unlike `rspec`'s own binary, which parses its flags with
+        // a full option parser regardless of position, `ruby` the interpreter
+        // stops reading flags at the first positional argument — the test
+        // file. Appending at the end (measured: `ruby -r minitest/autorun
+        // <file> -r <reporter>`) hands `-r <reporter>` to the *script* as
+        // `ARGV`, which Minitest's own option parser then rejects outright
+        // (`invalid option: -r`) rather than loading it — the same insertion-
+        // point lesson `node --test`'s own profile already learned, for the
+        // same reason: a positional argument ends flag parsing.
+        withReporterFlags: (args) => {
+            const index = args.findIndex((arg, i) => (arg === "-r" && args[i + 1] === "minitest/autorun") || arg === "-rminitest/autorun");
+            const insertAt = args[index] === "-r" ? index + 2 : index + 1;
+            return [...args.slice(0, insertAt), "-r", MINITEST_REPORTER_PATH, ...args.slice(insertAt)];
+        },
+    },
+];
+/**
+ * Exported on its own so a caller can validate a configured command before
+ * ever attempting to spawn it — the same "refuse atomically before anything
+ * is spawned" shape `validateServicesConfiguration` already established.
+ *
+ * **Declared, never inferred** (RT-032's precedent): this reads the command
+ * the caller wrote and nothing else. It does not open `package.json`, a
+ * lockfile, or a config file to guess which runner a project uses, and a
+ * command it does not recognise gets a named refusal rather than a
+ * best-effort guess.
+ */
+export function discoverRunner(rawCommand) {
+    const tokenized = tokenizeCommand(rawCommand);
+    if (!tokenized.ok) {
+        return { ok: false, reason: tokenized.reason };
+    }
+    const { command, args } = tokenized;
+    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 (baseName === "npx" || baseName === "npx.cmd") {
+        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 = PROFILES.find((candidate) => candidate.matches(baseName, args));
+    if (profile === undefined) {
+        return {
+            ok: false,
+            reason: `"${rawCommand}" names no runner this collector observes. Supported, and each declared explicitly: ` +
+                `\`node ... --test ...\`, \`jest ...\`, \`vitest run ...\`. ` +
+                "A command is never matched by sniffing package.json or a lockfile.",
+        };
+    }
+    const refusal = profile.refuse(args);
+    if (refusal !== null) {
+        return { ok: false, reason: refusal };
+    }
+    return { ok: true, kind: profile.kind, command, args };
+}
+export function reporterFlagsFor(kind, args) {
+    return PROFILES.find((profile) => profile.kind === kind).withReporterFlags(args);
+}
+/** `{}` for every profile that has no `reporterEnv` — `start()`'s merge then adds nothing. */
+export function reporterEnvFor(kind, args) {
+    const profile = PROFILES.find((candidate) => candidate.kind === kind);
+    return profile.reporterEnv?.(args) ?? {};
+}
+export function isNodeTestEvent(value) {
+    return typeof value === "object" && value !== null && "type" in value && "data" in value;
+}
+function sourceLocationOf(data) {
+    return {
+        file: data.file ?? null,
+        line: data.line ?? null,
+        column: data.column ?? null,
+        functionName: null,
+        reliability: "self-contained",
+        resolvedVia: null,
+    };
+}
+/**
+ * §17's "TEST_CASE graph mapping" (RT-076) found a real mismatch before it
+ * ever reached graph-correlator: `adapter-typescript`'s TEST_CASE node
+ * `name` is `[...suite, title].join(" ")` -- the full `describe()` chain,
+ * space-joined, ahead of the test's own title. node:test's own reporter
+ * events do NOT do this: a nested test's `test:pass`/`test:fail` carries
+ * only its own innermost title (`"deletes an invoice"`), never
+ * `"invoice deletion deletes an invoice"` -- confirmed directly against a
+ * real `describe()`/`it()` file before assuming otherwise. A naive
+ * `resolveTestCaseNode(driver, { testName: event.data.name, ... }, repo)`
+ * would silently `not-found` every nested test while looking correct for
+ * every *top-level* one (this package's own earlier fixtures happened to
+ * have none nested, which is exactly how this would have shipped unnoticed).
+ *
+ * `describe`/`suite` blocks fire their own `test:start`/`test:pass` events
+ * too, at one nesting level shallower than what they contain (also
+ * confirmed directly, two levels deep) -- so the ancestor chain is
+ * reconstructable purely from the stream this collector already reads,
+ * with no new node:test API. `SuiteStack` tracks it: on every `test:start`,
+ * truncate to the reported `nesting` (a same-or-shallower start means any
+ * deeper siblings from a previous branch are done) then record the name at
+ * that depth. `qualify(nesting, name)` joins everything shallower with the
+ * given name -- matching the adapter's own convention exactly, so a
+ * caller doing graph resolution uses `payload.qualifiedName`, never
+ * `payload.name` (which stays the plain, human-readable title).
+ */
+class SuiteStack {
+    #names = [];
+    observeStart(nesting, name) {
+        this.#names.length = nesting;
+        this.#names[nesting] = name;
+    }
+    qualify(nesting, name) {
+        return [...this.#names.slice(0, nesting), name].join(" ");
+    }
+}
+/**
+ * The one convention `t.diagnostic()` messages are read for: a test author
+ * writing exactly `requestId: <value>` or `traceId: <value>` (case-
+ * sensitive on the key, matching the Evidence field names exactly, so a
+ * typo is a miss rather than a silent near-match). Anything else --
+ * `t.diagnostic()` is a general-purpose node:test API, not exclusively
+ * this collector's -- is ignored, not treated as malformed input.
+ */
+function parseCorrelationDiagnostic(message) {
+    const match = /^(requestId|traceId):\s*(.+)$/.exec(message.trim());
+    if (match === null)
+        return null;
+    const [, kind, value] = match;
+    if (kind === undefined || value === undefined || value.trim() === "")
+        return null;
+    return { kind: kind, value: value.trim() };
+}
+export function createEventTranslator(emit, service, processId) {
+    let pending = null;
+    let testsObserved = 0;
+    let idsPresent = 0;
+    let notRun = 0;
+    const suiteStack = new SuiteStack();
+    function flush() {
+        if (pending === null)
+            return;
+        const { eventType, name, qualifiedName, durationMs, error, location, requestId, traceId, skipReason } = pending;
+        pending = null;
+        // `testsObserved` counts results that represent a test that RAN.
+        // Folding skips into it would make "3 of 40 correlated" a ratio over a
+        // denominator that includes tests which could not have correlated
+        // with anything — the exact overclaim RT-074 added the denominator to
+        // prevent, one level along.
+        if (eventType === "TEST_SKIPPED")
+            notRun++;
+        else
+            testsObserved++;
+        if (requestId !== null || traceId !== null)
+            idsPresent++;
+        emit({
+            timestamp: new Date().toISOString(),
+            source: "test-runner",
+            service: service ?? null,
+            process: processId,
+            traceId,
+            requestId,
+            correlationId: null,
+            graphNodeId: null,
+            stackTrace: null,
+            confidence: 1,
+            redactionStatus: "pending-redaction",
+            collectorVersion: COLLECTOR_VERSION,
+            eventType,
+            payload: eventType === "TEST_FAILED"
+                ? { name, qualifiedName, durationMs, error }
+                : eventType === "TEST_SKIPPED"
+                    ? // `durationMs` is null for a skip by construction and carrying it
+                        // would invite a consumer to average it in. `skipReason` replaces
+                        // it: the one thing there is to say about a test that did not run.
+                        { name, qualifiedName, skipReason: skipReason ?? "unspecified" }
+                    : { name, qualifiedName, durationMs },
+            sourceLocation: location,
+        });
+    }
+    function handle(event) {
+        const { data } = event;
+        const name = data.name ?? "(unnamed test)";
+        const nesting = data.nesting ?? 0;
+        switch (event.type) {
+            case "test:start": {
+                flush(); // whatever was pending belongs to the PREVIOUS test -- nothing more can merge into it now
+                // Recorded BEFORE emitting: a describe/suite's own test:start is
+                // itself an ancestor for whatever test:start events nest under it
+                // next, and the stack has to reflect that by the time they arrive.
+                suiteStack.observeStart(nesting, name);
+                emit({
+                    timestamp: new Date().toISOString(),
+                    source: "test-runner",
+                    service: service ?? null,
+                    process: processId,
+                    traceId: null,
+                    requestId: null,
+                    correlationId: null,
+                    graphNodeId: null,
+                    stackTrace: null,
+                    confidence: 1,
+                    redactionStatus: "pending-redaction",
+                    collectorVersion: COLLECTOR_VERSION,
+                    eventType: "TEST_STARTED",
+                    payload: { name, qualifiedName: data.qualifiedName ?? suiteStack.qualify(nesting, name) },
+                    sourceLocation: sourceLocationOf(data),
+                });
+                return;
+            }
+            case "test:pass":
+            case "test:fail":
+                flush(); // safety: should already be null here, but never silently drop a prior pending result
+                // **A `describe()` block that passed is not a test that passed.**
+                // node:test emits `test:pass` for a container as well as for each
+                // test inside it (measured), so a three-test file with one
+                // `describe()` reported four passes — inflating the pass count and
+                // inflating RT-074's own denominator, the number added precisely so
+                // "3 of 40 correlated" could not overclaim. It would also resolve
+                // to a `TEST_CASE` node that no adapter mints, since adapters mint
+                // them for tests and not for containers.
+                //
+                // A suite's **failure** is kept: it means a `before`/`after` hook
+                // threw, which is a real failure and the only signal that a whole
+                // block never ran. Suppressing that to make the rule symmetrical
+                // would trade an overcount for a silence.
+                if (data.isSuite === true && event.type === "test:pass")
+                    return;
+                // **A test that did not run is not a pass.** Emitted as its own
+                // `TEST_SKIPPED` (RT-124) rather than counted-and-discarded, which
+                // is what RT-123 shipped: a bare counter carries no
+                // `sourceLocation`, no `qualifiedName` and no graph node, so "the
+                // function you changed has a test and it is disabled" could not be
+                // expressed at all. `notRun` is kept as the denominator.
+                //
+                // Held rather than emitted immediately, exactly like a pass or a
+                // failure, so a `t.diagnostic()` on a skipped test still merges —
+                // node:test emits diagnostics after the result for skipped tests
+                // too, and a separate emit path here would be a second shape that
+                // could drift from the one above.
+                if (data.skip === true || data.todo === true) {
+                    pending = {
+                        eventType: "TEST_SKIPPED",
+                        name,
+                        qualifiedName: data.qualifiedName ?? suiteStack.qualify(nesting, name),
+                        durationMs: null,
+                        error: null,
+                        location: sourceLocationOf(data),
+                        requestId: null,
+                        traceId: null,
+                        // Passed through, never derived. A translator that inferred
+                        // `disabled` from `skip === true` would state it for Vitest,
+                        // which sets that flag for `.todo` as well and cannot tell them
+                        // apart — a false fact manufactured by the layer whose job is
+                        // to be runner-agnostic.
+                        skipReason: data.skipReason ?? "unspecified",
+                    };
+                    return;
+                }
+                pending = {
+                    eventType: event.type === "test:pass" ? "TEST_PASSED" : "TEST_FAILED",
+                    name,
+                    // A reporter that can name the full chain itself is believed over
+                    // this collector's reconstruction of it. `SuiteStack` exists
+                    // because node:test's events carry only the innermost title;
+                    // Jest and Vitest carry the chain, and re-deriving it from
+                    // `nesting` when the runner already said so would be a second
+                    // source of truth that can disagree.
+                    qualifiedName: data.qualifiedName ?? suiteStack.qualify(nesting, name),
+                    durationMs: data.details?.duration_ms ?? null,
+                    error: event.type === "test:fail" ? (data.details?.error ?? null) : null,
+                    location: sourceLocationOf(data),
+                    requestId: null,
+                    traceId: null,
+                };
+                return;
+            case "test:diagnostic": {
+                if (data.file === undefined) {
+                    // A suite-level summary line ("tests 3", "pass 1", ...) -- these
+                    // never carry a file, and their arrival means every per-test
+                    // diagnostic for this file has already been seen.
+                    flush();
+                    return;
+                }
+                if (pending === null || data.message === undefined)
+                    return;
+                const parsed = parseCorrelationDiagnostic(data.message);
+                if (parsed === null)
+                    return;
+                pending[parsed.kind] = parsed.value;
+                return;
+            }
+            default:
+                // test:enqueue/dequeue/complete/plan -- not yet translated.
+                // `test:complete` in particular duplicates pass/fail and also
+                // wraps the whole file as its own pseudo-test; deliberately not
+                // read, so the file-level wrapper never becomes a fourth,
+                // unasked-for TEST_* event.
+                return;
+        }
+    }
+    return { handle, flush, coverage: () => ({ testsObserved, idsPresent, notRun }) };
+}
+/**
+ * Feeds complete NDJSON lines from `managed`'s growing output buffer 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
+ * 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) {
+    const splitter = new LineSplitter();
+    let consumed = 0;
+    let finished = false;
+    void managed.waitForExit().then(() => {
+        finished = true;
+    });
+    for (;;) {
+        const whole = managed.readOutput();
+        if (whole.length > consumed) {
+            const chunk = whole.slice(consumed);
+            consumed = whole.length;
+            for (const line of splitter.push(chunk)) {
+                onLine(line);
+            }
+        }
+        if (finished && whole.length === consumed) {
+            for (const line of splitter.flush()) {
+                onLine(line);
+            }
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+}
+function computeCapabilities() {
+    const reason = "TestRunnerCollector observes test-runner events (started/passed/failed) only -- the capability model has no field for that yet.";
+    const status = { availability: "unavailable", reason };
+    return {
+        domObservation: status,
+        consoleObservation: status,
+        networkObservation: status,
+        backendLogAccess: status,
+        distributedTrace: status,
+        sourceMapping: { availability: "available", reason: null },
+        stackCapture: status,
+        processLifecycle: status,
+        databaseObservation: status,
+        externalServiceObservation: status,
+    };
+}
+export function createTestRunnerCollector(options) {
+    const capabilities = computeCapabilities();
+    let context = null;
+    let managed = null;
+    let completion = Promise.resolve();
+    let translator = null;
+    return {
+        collectorId: "test-runner-collector",
+        async start(ctx) {
+            context = ctx;
+            const discovery = discoverRunner(options.configuration.command);
+            if (!discovery.ok) {
+                return { available: false, reason: discovery.reason };
+            }
+            const processId = `test-runner-${Date.now()}`;
+            managed = spawnProcess({
+                processId,
+                command: discovery.command,
+                args: reporterFlagsFor(discovery.kind, discovery.args),
+                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
+                // took a real, silent, empty-output failure to find: when this
+                // collector's own test suite -- itself running under `node --test`
+                // -- spawns a NESTED `node --test` child, the child sees this env var
+                // inherited from the parent and behaves as though it is a
+                // sub-process of an existing test run, producing NO stdout at all
+                // regardless of --test-reporter. `undefined` here removes the
+                // inherited key (spawnProcess's env merge, like child_process.spawn
+                // itself, drops undefined-valued keys rather than stringifying
+                // them) so a spawned runner always starts as its own independent,
+                // top-level `node --test` invocation -- which is what it actually
+                // is, whether or not this collector's own process happens to be
+                // running under a test runner too.
+                //
+                // `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) },
+            });
+            translator = createEventTranslator(context.emit, options.service, processId);
+            const activeTranslator = translator;
+            const gate = createEnvelopeGate();
+            const reportEnvelopeError = (reason) => {
+                ctx.emit({
+                    timestamp: new Date().toISOString(),
+                    source: "test-runner",
+                    service: options.service ?? null,
+                    process: processId,
+                    traceId: null,
+                    requestId: null,
+                    correlationId: null,
+                    graphNodeId: null,
+                    stackTrace: null,
+                    confidence: 1,
+                    redactionStatus: "pending-redaction",
+                    collectorVersion: COLLECTOR_VERSION,
+                    eventType: "COLLECTOR_ERROR",
+                    payload: { collector: "test-runner", reason },
+                    sourceLocation: null,
+                });
+            };
+            completion = pumpLines(managed, (line) => {
+                if (line.trim() === "")
+                    return;
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    // A non-JSON line on stdout means something other than this
+                    // collector's own reporter wrote it (e.g. the process under
+                    // test's own console.log) -- ignored rather than treated as a
+                    // parse failure of the reporter stream itself, which is a real,
+                    // expected, ordinary case for any real test suite.
+                    return;
+                }
+                // **The handshake, checked before anything is believed.** A
+                // reporter declares which envelope it speaks; a mismatch, or an
+                // event arriving with no declaration at all, means what follows
+                // cannot be trusted to mean what this translator will read it as.
+                // COLLECTOR_ERROR and then silence, never confident wrong evidence.
+                // The gate sees every line, not only translatable ones: a
+                // handshake is not a `NodeTestEvent` and would otherwise be
+                // dropped as noise before it could be read.
+                if (!isNodeTestEvent(parsed)) {
+                    const noise = gate.inspect(parsed, false);
+                    if (noise.kind === "refuse")
+                        reportEnvelopeError(noise.reason);
+                    return;
+                }
+                const verdict = gate.inspect(parsed, true);
+                if (verdict.kind === "refuse") {
+                    reportEnvelopeError(verdict.reason);
+                    return;
+                }
+                if (verdict.kind !== "event")
+                    return;
+                activeTranslator.handle(parsed);
+            }).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
+                // rather than flushing explicitly here would mean a truncated or
+                // unusual stream (the process killed mid-run, `stop()` called
+                // early) leaves the last real result buffered and never emitted.
+                activeTranslator.flush();
+            });
+            return { available: true };
+        },
+        async stop() {
+            if (managed !== null) {
+                await managed.kill();
+            }
+            await completion;
+            context = null;
+        },
+        capabilities() {
+            return capabilities;
+        },
+        async waitForCompletion() {
+            await completion;
+        },
+        traceCoverage() {
+            return translator?.coverage() ?? { testsObserved: 0, idsPresent: 0, notRun: 0 };
+        },
+    };
+}
+//# sourceMappingURL=test-runner-collector.js.map