@descryy/runtime-test-runner 0.0.0

package/dist/jest-reporter.js

@@ -0,0 +1,110 @@
+/**
+ * A **Jest** custom reporter (`--reporters=<path to this file's compiled
+ * output>`), emitting the same NDJSON envelope `reporter.ts` emits for
+ * `node:test`.
+ *
+ * ## Why one envelope and three reporters, rather than three collectors
+ *
+ * The per-runner knowledge is *what its own structured API calls things*,
+ * and that knowledge only exists inside the runner's own process, where the
+ * API is. So each runner gets a reporter that speaks its API and writes the
+ * one shape `test-runner-collector.ts` already reads —
+ * `{type: "test:start"|"test:pass"|"test:fail", data: {...}}`, node:test's
+ * own event names, kept as the envelope because it was first and renaming
+ * them would churn a working translator for nothing.
+ *
+ * `createEventTranslator` therefore needed **no per-runner branch**: no
+ * `if (runner === "jest")` anywhere above this file, which is the same
+ * boundary rule the IR has. Everything Jest-specific is here.
+ *
+ * ## What Jest gives that node:test does not, and vice versa
+ *
+ * `testCaseResult.ancestorTitles` is the real `describe()` chain, so
+ * `qualifiedName` is exact rather than reconstructed — node:test forced
+ * `SuiteStack` to rebuild it from `nesting` because its events carry only
+ * the innermost title (RT-076). Emitting it directly is why the translator
+ * prefers a supplied `qualifiedName` over its own reconstruction.
+ *
+ * **Jest's own `fullName` is the same space-joined string** and is used
+ * here in preference to re-joining, since it is what Jest itself
+ * considers the test's full name. It matches `adapter-typescript`'s
+ * TEST_CASE convention (`[...suite, title].join(" ")`) exactly — verified
+ * against a real run, not assumed. Vitest's `fullName` does **not** (it
+ * joins with `" > "`), which is why `vitest-reporter.ts` rebuilds it and
+ * this one does not.
+ *
+ * **`onTestCaseStart` carries no location** — measured. Only
+ * `onTestCaseResult` does, and only when `--testLocationInResults` is
+ * passed. So TEST_STARTED for Jest has a `file` but null `line`/`column`,
+ * where node:test's has all three. Disclosed rather than filled in.
+ *
+ * ## `--testLocationInResults` is load-bearing, and its absence is silent
+ *
+ * Measured directly: without it, `testCaseResult.location` is `undefined`
+ * on every result. The collector still runs, still emits every event, and
+ * every one silently has no line or column — the same shape as RT-073's
+ * reporter-flag ordering bug, where the failure was "no error, wrong
+ * output". `withReporterFlags` injects it; it is not left to the caller.
+ */
+function write(type, data) {
+    // stdout, one JSON value per line — the collector ignores any line that
+    // is not JSON, so Jest's own progress output (which goes to stderr
+    // anyway) can never be mistaken for an event.
+    process.stdout.write(JSON.stringify({ type, data }) + "\n");
+}
+// **The envelope declaration, emitted at module load** — before any test
+// runs, because the runner imports this reporter during its own start-up.
+// A stdout write is correct here (unlike node:test's reporter, which is a
+// stream transform and must yield instead), since this reporter already
+// writes every event the same way (RT-130).
+write("descry:envelope", { version: 1 });
+export default class DescryJestReporter {
+    onTestCaseStart(test, info) {
+        write("test:start", {
+            name: info.title,
+            qualifiedName: info.fullName,
+            file: test.path,
+            line: null,
+            column: null,
+        });
+    }
+    onTestCaseResult(test, result) {
+        // **`skipped` and `todo` are not results and must not be reported as
+        // passes.** Jest reports a `test.todo` with `status: "todo"` and omits
+        // a `test.skip` from `onTestCaseResult` entirely (both measured), so
+        // the `skip` flag below is set for statuses Jest *can* report and a
+        // `.skip`'d test produces no event from this reporter at all. That is
+        // Jest's own coverage limit, not this reporter declining to look: it
+        // is why `traceCoverage().notRun` is a floor rather than a total for
+        // Jest, and why the tests assert a bound rather than an equality.
+        //
+        // The translator turns these into `TEST_SKIPPED` (RT-124) — its own
+        // event, carrying this location and qualified name, not a counter.
+        write(result.status === "failed" ? "test:fail" : "test:pass", {
+            name: result.title,
+            qualifiedName: result.fullName,
+            file: test.path,
+            line: result.location?.line ?? null,
+            column: result.location?.column ?? null,
+            skip: result.status === "skipped" || result.status === "pending" || result.status === "disabled",
+            todo: result.status === "todo",
+            // Jest names the one it can report: `todo` is a declared absence.
+            // The `skipped`/`pending`/`disabled` statuses are switched-off tests,
+            // and a `.skip`'d one never reaches this callback at all (measured),
+            // so no value here is a guess about a test Jest declined to describe.
+            ...(result.status === "todo" ? { skipReason: "not-implemented" } : { skipReason: "disabled" }),
+            details: {
+                duration_ms: result.duration ?? null,
+                // Jest hands failures over as formatted strings, not as the live
+                // Error objects node:test's reporter carries. `failureDetails` is
+                // the structured half when the matcher provided one; both are
+                // passed through verbatim rather than parsed, because parsing a
+                // matcher's prose is exactly what this seam exists to avoid.
+                error: result.status === "failed"
+                    ? { failureType: "test", messages: result.failureMessages, details: result.failureDetails ?? null }
+                    : null,
+            },
+        });
+    }
+}
+//# sourceMappingURL=jest-reporter.js.map

package/dist/jest-reporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest-reporter.js","sourceRoot":"","sources":["../src/jest-reporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAoBH,SAAS,KAAK,CAAC,IAAY,EAAE,IAAa;IACxC,wEAAwE;IACxE,mEAAmE;IACnE,8CAA8C;IAC9C,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;AAC9D,CAAC;AAED,yEAAyE;AACzE,0EAA0E;AAC1E,0EAA0E;AAC1E,wEAAwE;AACxE,4CAA4C;AAC5C,KAAK,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;AAEzC,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACrC,eAAe,CAAC,IAAc,EAAE,IAA2B;QACzD,KAAK,CAAC,YAAY,EAAE;YAClB,IAAI,EAAE,IAAI,CAAC,KAAK;YAChB,aAAa,EAAE,IAAI,CAAC,QAAQ;YAC5B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI;YACV,MAAM,EAAE,IAAI;SACb,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB,CAAC,IAAc,EAAE,MAA0B;QACzD,qEAAqE;QACrE,uEAAuE;QACvE,qEAAqE;QACrE,oEAAoE;QACpE,sEAAsE;QACtE,qEAAqE;QACrE,qEAAqE;QACrE,kEAAkE;QAClE,EAAE;QACF,oEAAoE;QACpE,mEAAmE;QACnE,KAAK,CAAC,MAAM,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,EAAE;YAC5D,IAAI,EAAE,MAAM,CAAC,KAAK;YAClB,aAAa,EAAE,MAAM,CAAC,QAAQ;YAC9B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,IAAI,IAAI,IAAI;YACnC,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,IAAI,IAAI;YACvC,IAAI,EAAE,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;YAChG,IAAI,EAAE,MAAM,CAAC,MAAM,KAAK,MAAM;YAC9B,kEAAkE;YAClE,sEAAsE;YACtE,qEAAqE;YACrE,sEAAsE;YACtE,GAAG,CAAC,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC,CAAE,EAAE,UAAU,EAAE,iBAAiB,EAAY,CAAC,CAAC,CAAE,EAAE,UAAU,EAAE,UAAU,EAAY,CAAC;YACpH,OAAO,EAAE;gBACP,WAAW,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;gBACpC,iEAAiE;gBACjE,kEAAkE;gBAClE,8DAA8D;gBAC9D,gEAAgE;gBAChE,6DAA6D;gBAC7D,KAAK,EACH,MAAM,CAAC,MAAM,KAAK,QAAQ;oBACxB,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,eAAe,EAAE,OAAO,EAAE,MAAM,CAAC,cAAc,IAAI,IAAI,EAAE;oBACnG,CAAC,CAAC,IAAI;aACX;SACF,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/playwright-reporter.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Playwright Test's reporter, the fifth runner on this seam (RT-184).
+ *
+ * Playwright is the **only** runner measured here that supplies source
+ * locations with no flag at all. Jest needs `--testLocationInResults`,
+ * Vitest `--includeTaskLocation`, .NET
+ * `RunConfiguration.CollectSourceInformation=true`; `go test` and
+ * `swift test --xunit-output` cannot supply them under any flag (RT-136,
+ * RT-141). `TestCase.location` is `{file, line, column}` and is always
+ * populated. So this profile injects a reporter and nothing else.
+ *
+ * ## Two shapes no other runner on this seam has
+ *
+ * **1. A test may declare the outcome it expects.** `test.fail()` runs the
+ * body and its *failure* is the declared outcome — measured:
+ * `status: "failed"`, `expectedStatus: "failed"`. Mapping status alone
+ * would report a working, deliberately-failing test as a problem, which is
+ * the false-positive direction and the more expensive one. The rule is a
+ * comparison, not a lookup: **the outcome matched what was declared, or it
+ * did not.**
+ *
+ * **2. `skip` and `fixme` are distinguishable; a declared skip and a
+ * runtime one are not.** `test.annotations` carries `{type: "fixme"}` for
+ * `test.fixme()` — unambiguous, a developer switched it off. But
+ * `{type: "skip"}` is emitted *identically* for a declared `test.skip(...)`
+ * and for a `test.skip(condition)` evaluated inside a running body
+ * (measured, both `ann: ["skip"]`). Those are different facts about
+ * coverage — switched off versus ran and hit a precondition — and this
+ * runner cannot separate them.
+ *
+ * So `fixme` reports `disabled` and `skip` reports **`unspecified`**. That
+ * value now has three independent producers — Vitest (RT-129), .NET's
+ * `TestOutcome.Skipped` (Lane A's RT-099) and this — each arriving because
+ * a runner collapses two facts rather than because the vocabulary lacked a
+ * word. Reading `disabled` off an annotation *named* skip would have been
+ * the plausible mistake here, and it would state that a developer turned
+ * off a test that ran real code.
+ */
+interface PlaywrightLocation {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+}
+interface PlaywrightSuite {
+    readonly type: string;
+    readonly title: string;
+    readonly parent?: PlaywrightSuite;
+}
+interface PlaywrightTestCase {
+    readonly title: string;
+    readonly location: PlaywrightLocation;
+    readonly expectedStatus: string;
+    readonly annotations: readonly {
+        readonly type: string;
+    }[];
+    readonly parent?: PlaywrightSuite;
+}
+interface PlaywrightResult {
+    readonly status: string;
+    readonly duration: number;
+    readonly errors: readonly unknown[];
+}
+export default class DescryPlaywrightReporter {
+    onTestEnd(test: PlaywrightTestCase, result: PlaywrightResult): void;
+}
+export {};
+//# sourceMappingURL=playwright-reporter.d.ts.map

package/dist/playwright-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-reporter.d.ts","sourceRoot":"","sources":["../src/playwright-reporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAIH,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,eAAe;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;CACnC;AAED,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3D,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;CACnC;AAED,UAAU,gBAAgB;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;CACrC;AA+BD,MAAM,CAAC,OAAO,OAAO,wBAAwB;IAC3C,SAAS,CAAC,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI;CA0BpE"}

package/dist/playwright-reporter.js

@@ -0,0 +1,93 @@
+/**
+ * Playwright Test's reporter, the fifth runner on this seam (RT-184).
+ *
+ * Playwright is the **only** runner measured here that supplies source
+ * locations with no flag at all. Jest needs `--testLocationInResults`,
+ * Vitest `--includeTaskLocation`, .NET
+ * `RunConfiguration.CollectSourceInformation=true`; `go test` and
+ * `swift test --xunit-output` cannot supply them under any flag (RT-136,
+ * RT-141). `TestCase.location` is `{file, line, column}` and is always
+ * populated. So this profile injects a reporter and nothing else.
+ *
+ * ## Two shapes no other runner on this seam has
+ *
+ * **1. A test may declare the outcome it expects.** `test.fail()` runs the
+ * body and its *failure* is the declared outcome — measured:
+ * `status: "failed"`, `expectedStatus: "failed"`. Mapping status alone
+ * would report a working, deliberately-failing test as a problem, which is
+ * the false-positive direction and the more expensive one. The rule is a
+ * comparison, not a lookup: **the outcome matched what was declared, or it
+ * did not.**
+ *
+ * **2. `skip` and `fixme` are distinguishable; a declared skip and a
+ * runtime one are not.** `test.annotations` carries `{type: "fixme"}` for
+ * `test.fixme()` — unambiguous, a developer switched it off. But
+ * `{type: "skip"}` is emitted *identically* for a declared `test.skip(...)`
+ * and for a `test.skip(condition)` evaluated inside a running body
+ * (measured, both `ann: ["skip"]`). Those are different facts about
+ * coverage — switched off versus ran and hit a precondition — and this
+ * runner cannot separate them.
+ *
+ * So `fixme` reports `disabled` and `skip` reports **`unspecified`**. That
+ * value now has three independent producers — Vitest (RT-129), .NET's
+ * `TestOutcome.Skipped` (Lane A's RT-099) and this — each arriving because
+ * a runner collapses two facts rather than because the vocabulary lacked a
+ * word. Reading `disabled` off an annotation *named* skip would have been
+ * the plausible mistake here, and it would state that a developer turned
+ * off a test that ran real code.
+ */
+const ENVELOPE_VERSION = 1;
+function write(type, data) {
+    process.stdout.write(JSON.stringify({ type, data }) + "\n");
+}
+write("descry:envelope", { version: ENVELOPE_VERSION });
+/**
+ * The `describe()` chain, and **only** that chain.
+ *
+ * `titlePath()` returns `["", "invoices.spec.js", "invoice deletion", "runs
+ * normally"]` — the project name (empty unless projects are configured) and
+ * the file title sit in front of it. Slicing a fixed number of entries off
+ * would silently take the first `describe` instead once a project is named.
+ * `suite.type` is Playwright's own discriminator (`root`/`project`/`file`/
+ * `describe`, measured), so the walk stops on a type rather than a count.
+ */
+function qualify(test) {
+    const groups = [];
+    for (let suite = test.parent; suite !== undefined; suite = suite.parent) {
+        if (suite.type !== "describe")
+            break;
+        groups.unshift(suite.title);
+    }
+    return [...groups, test.title].join(" ");
+}
+function skipReasonOf(test) {
+    return test.annotations.some((a) => a.type === "fixme") ? "disabled" : "unspecified";
+}
+export default class DescryPlaywrightReporter {
+    onTestEnd(test, result) {
+        const skipped = result.status === "skipped";
+        // The comparison, not a lookup: `test.fail()` declares failure as the
+        // expected outcome, and a run that matches its declaration is not a
+        // problem to report.
+        const asDeclared = result.status === test.expectedStatus;
+        write(skipped || asDeclared ? "test:pass" : "test:fail", {
+            name: test.title,
+            qualifiedName: qualify(test),
+            file: test.location.file,
+            line: test.location.line,
+            column: test.location.column,
+            skip: skipped,
+            todo: false,
+            ...(skipped ? { skipReason: skipReasonOf(test) } : {}),
+            details: {
+                duration_ms: result.duration,
+                // Passed through verbatim, like Vitest's: Playwright's errors are
+                // already plain serialisable objects carrying `message`, `stack`
+                // and a matcher's `snippet`, and copying named fields would discard
+                // whichever ones this code did not think to name (RT-123).
+                error: asDeclared || skipped ? null : { failureType: "test", errors: result.errors },
+            },
+        });
+    }
+}
+//# sourceMappingURL=playwright-reporter.js.map

package/dist/playwright-reporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-reporter.js","sourceRoot":"","sources":["../src/playwright-reporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,MAAM,gBAAgB,GAAG,CAAC,CAAC;AA4B3B,SAAS,KAAK,CAAC,IAAY,EAAE,IAAa;IACxC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;AAC9D,CAAC;AAED,KAAK,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAExD;;;;;;;;;GASG;AACH,SAAS,OAAO,CAAC,IAAwB;IACvC,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,KAAK,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QACxE,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU;YAAE,MAAM;QACrC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IACD,OAAO,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC3C,CAAC;AAED,SAAS,YAAY,CAAC,IAAwB;IAC5C,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,aAAa,CAAC;AACvF,CAAC;AAED,MAAM,CAAC,OAAO,OAAO,wBAAwB;IAC3C,SAAS,CAAC,IAAwB,EAAE,MAAwB;QAC1D,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,KAAK,SAAS,CAAC;QAC5C,sEAAsE;QACtE,oEAAoE;QACpE,qBAAqB;QACrB,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,KAAK,IAAI,CAAC,cAAc,CAAC;QAEzD,KAAK,CAAC,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,EAAE;YACvD,IAAI,EAAE,IAAI,CAAC,KAAK;YAChB,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC;YAC5B,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI;YACxB,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI;YACxB,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM;YAC5B,IAAI,EAAE,OAAO;YACb,IAAI,EAAE,KAAK;YACX,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACtD,OAAO,EAAE;gBACP,WAAW,EAAE,MAAM,CAAC,QAAQ;gBAC5B,kEAAkE;gBAClE,iEAAiE;gBACjE,oEAAoE;gBACpE,2DAA2D;gBAC3D,KAAK,EAAE,UAAU,IAAI,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;aACrF;SACF,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/reporter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A `node:test` custom reporter (Node's own reporter API — loaded via
+ * `--test-reporter=<path to this file's compiled output>`), never TAP.
+ *
+ * TAP is a text format meant for a human or a line-oriented parser to read;
+ * scraping it would mean re-deriving structure (which line is a test name,
+ * which is a diagnostic, which YAML block belongs to which result) that
+ * Node's own reporter stream already hands over as real objects —
+ * `test:start` / `test:pass` / `test:fail`, each with `name`, `file`,
+ * `line`, `column`, and for a failure the real `error` (assertion message,
+ * `code`, `cause`), never printed prose to re-parse. This reporter's only
+ * job is turning that object stream into one JSON value per line on
+ * stdout, so `test-runner-collector.ts` can `JSON.parse` each line instead
+ * of pattern-matching text — the same reason RT-072's own benchmark lesson
+ * exists ("scraping prose measures the prose").
+ *
+ * Loaded as a standalone file by a *spawned* `node --test` process, whose
+ * own cwd may be anywhere — `test-runner-collector.ts` references this
+ * module's compiled path absolutely (`new URL("./reporter.js",
+ * import.meta.url)`), never by bare specifier, so it resolves regardless of
+ * the target application's own `node_modules`.
+ */
+interface ReporterEvent {
+    readonly type: string;
+    readonly data: {
+        readonly details?: {
+            readonly type?: string;
+        };
+        readonly skip?: boolean;
+        readonly todo?: boolean;
+    };
+}
+export default function ndjsonReporter(source: AsyncIterable<ReporterEvent>): AsyncGenerator<string>;
+export {};
+//# sourceMappingURL=reporter.d.ts.map

package/dist/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../src/reporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,UAAU,aAAa;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;YAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACpH;AAqCD,wBAA+B,cAAc,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CAe1G"}

package/dist/reporter.js

@@ -0,0 +1,74 @@
+/**
+ * A `node:test` custom reporter (Node's own reporter API — loaded via
+ * `--test-reporter=<path to this file's compiled output>`), never TAP.
+ *
+ * TAP is a text format meant for a human or a line-oriented parser to read;
+ * scraping it would mean re-deriving structure (which line is a test name,
+ * which is a diagnostic, which YAML block belongs to which result) that
+ * Node's own reporter stream already hands over as real objects —
+ * `test:start` / `test:pass` / `test:fail`, each with `name`, `file`,
+ * `line`, `column`, and for a failure the real `error` (assertion message,
+ * `code`, `cause`), never printed prose to re-parse. This reporter's only
+ * job is turning that object stream into one JSON value per line on
+ * stdout, so `test-runner-collector.ts` can `JSON.parse` each line instead
+ * of pattern-matching text — the same reason RT-072's own benchmark lesson
+ * exists ("scraping prose measures the prose").
+ *
+ * Loaded as a standalone file by a *spawned* `node --test` process, whose
+ * own cwd may be anywhere — `test-runner-collector.ts` references this
+ * module's compiled path absolutely (`new URL("./reporter.js",
+ * import.meta.url)`), never by bare specifier, so it resolves regardless of
+ * the target application's own `node_modules`.
+ */
+/**
+ * **`describe()` blocks emit their own `test:pass`, and node:test says so
+ * itself** — `data.details.type` is `"suite"` for a container and `"test"`
+ * for a real test case (measured; the field's presence is the
+ * discriminator, not a heuristic on nesting or naming).
+ *
+ * That distinction has to survive into the envelope, because it is
+ * node:test-specific and Jest's and Vitest's reporters never see a
+ * container at all — their per-test callbacks only fire for test cases. So
+ * the flag is set here, where the runner-specific knowledge is, and the
+ * translator applies one runner-agnostic rule to it.
+ *
+ * The event itself is still forwarded whole: a suite's `test:fail` is a
+ * real failure (a `before`/`after` hook threw) and dropping it here would
+ * lose the only signal that a whole block never ran. Which of the two the
+ * translator emits is its decision, not this reporter's.
+ */
+/**
+ * **node:test tells `skip` and `todo` apart, and RT-124 threw that away.**
+ * Both became one `TEST_SKIPPED` with no way to recover which — "switched
+ * off" and "never written" are different facts about coverage, and the
+ * distinction was dropped silently by the change whose subject was not
+ * dropping distinctions silently. `skipReason` is set here rather than
+ * derived in the translator because only a reporter knows what its runner
+ * can distinguish (RT-129).
+ *
+ * `todo` wins when both flags are set: `test.todo()` is the stronger claim
+ * (there is nothing to run) and node marks a todo as skipped as well.
+ */
+function skipReasonOf(data) {
+    if (data?.todo === true)
+        return "not-implemented";
+    if (data?.skip === true)
+        return "disabled";
+    return undefined;
+}
+export default async function* ndjsonReporter(source) {
+    // **Declared before the first event, not written to stdout.** This
+    // reporter is a stream transform: its yielded values *are* the output, so
+    // a `process.stdout.write` here would race the stream it is supposed to
+    // precede. Yielding first is the same guarantee by construction (RT-130).
+    yield JSON.stringify({ type: "descry:envelope", data: { version: 1 } }) + "\n";
+    for await (const event of source) {
+        const isSuite = event.data?.details?.type === "suite";
+        const skipReason = skipReasonOf(event.data);
+        const data = isSuite || skipReason !== undefined
+            ? { ...event.data, ...(isSuite ? { isSuite: true } : {}), ...(skipReason === undefined ? {} : { skipReason }) }
+            : event.data;
+        yield JSON.stringify(data === event.data ? event : { ...event, data }) + "\n";
+    }
+}
+//# sourceMappingURL=reporter.js.map

package/dist/reporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.js","sourceRoot":"","sources":["../src/reporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAOH;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;;;;;GAWG;AACH,SAAS,YAAY,CAAC,IAA2B;IAC/C,IAAI,IAAI,EAAE,IAAI,KAAK,IAAI;QAAE,OAAO,iBAAiB,CAAC;IAClD,IAAI,IAAI,EAAE,IAAI,KAAK,IAAI;QAAE,OAAO,UAAU,CAAC;IAC3C,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,CAAC,OAAO,CAAC,KAAK,SAAS,CAAC,CAAC,cAAc,CAAC,MAAoC;IAChF,mEAAmE;IACnE,0EAA0E;IAC1E,wEAAwE;IACxE,0EAA0E;IAC1E,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC;IAC/E,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACjC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,KAAK,OAAO,CAAC;QACtD,MAAM,UAAU,GAAG,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC5C,MAAM,IAAI,GACR,OAAO,IAAI,UAAU,KAAK,SAAS;YACjC,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE;YAC/G,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;QACjB,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IAChF,CAAC;AACH,CAAC"}

package/dist/swift-xctest.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Swift's XCTest half of §17, observed through a custom `XCTestObservation`
+ * hooked directly into the test process, in-process and streaming — not
+ * `swift test --xunit-output`'s end-of-run artifact (RT-181), which on
+ * Swift 6.1.2/Linux covers swift-testing only and silently reports a
+ * smaller, clean-looking run for one where twice as many tests ran and half
+ * of them failed. This closes the "real path... a different piece of work
+ * from consuming an artifact" RT-181 named but did not build.
+ *
+ * ## Why this is not a seventh `PROFILES` entry in `test-runner-collector.ts`
+ *
+ * Every runner on that seam is one spawn: inject a reporter flag, run the
+ * command as given. XCTest on Linux has no such flag. SwiftPM's generated
+ * test entry point (`runner.swift`, rebuilt fresh every build — not
+ * something a caller can edit) calls `XCTMain(__allDiscoveredTests())` with
+ * no `observers:` argument at all, even though the symbol accepts one and
+ * `swift test`'s own template privately builds — but never wires up — an
+ * `XCTestObservation` conformer of its own (`SwiftPMXCTestObserver`,
+ * confirmed dead: never instantiated, and its `testOutputPath` file never
+ * appears even under `--parallel`). So there is no flag to inject.
+ *
+ * What Linux *does* still honor is `Tests/LinuxMain.swift` — SwiftPM's
+ * pre-automatic-discovery entry point. Measured directly: when present, it
+ * replaces the generated runner outright (`swift test` skips building the
+ * `*PackageDiscoveredTests` module entirely when it exists), and a plain
+ * `XCTestObservationCenter.shared.addTestObserver(...)` call inside it
+ * genuinely receives every callback, streamed in real time, interleaved
+ * with the runner's own console output — not collected after the process
+ * exits.
+ *
+ * So this collector runs in two passes: build the tests once to discover
+ * them (`--dump-tests-json`, a real flag on the built `.xctest` binary,
+ * needing no `LinuxMain.swift` of its own — the discovery build uses
+ * SwiftPM's ordinary automatic discovery), generate a `LinuxMain.swift`
+ * naming every discovered class and method, then spawn `swift test` for
+ * real, which rebuilds against the generated file and runs it.
+ *
+ * ## The trade-off this creates, disclosed rather than hidden
+ *
+ * `Tests/LinuxMain.swift`'s presence does not just replace the XCTest
+ * dispatch, it removes the swift-testing one too. Measured directly: a
+ * package with both an XCTest method and a swift-testing `@Test` function,
+ * with no `LinuxMain.swift`, runs both — `swift test` invokes the built
+ * binary twice, once per `--testing-library` value. With a
+ * `LinuxMain.swift` present — ours or anyone's — the `@Test` function does
+ * not run at all: not skipped, not reported, simply never invoked; not
+ * even its banner line prints. So this collector observes the XCTest half
+ * in real time and *stops covering swift-testing while it is active* — the
+ * mirror image of RT-181's gap, not a fix for both halves at once.
+ * `stop()` removes the generated file afterward so an unattended
+ * `swift test` reverts to normal dual-framework discovery once this
+ * collector is done.
+ *
+ * ## The generated file is never a guess at the user's code
+ *
+ * Every class and method name comes from `--dump-tests-json` against a real
+ * build of the real target — the same build-time-derived source SwiftPM's
+ * own automatic discovery already trusts, not a scrape of source text. No
+ * `allTests` needs to exist anywhere in the user's own code; the generated
+ * file adds its own `__descryAllTests` extension per class instead, so a
+ * project that already declares a legacy `allTests` is never collided with.
+ *
+ * **Known limitation, disclosed rather than silently mishandled:** two test
+ * classes of the same bare name in two different modules of the same
+ * package produce two `extension <Name>` blocks that collide. Real, and not
+ * solved here — `discoverClasses` still returns both, and the generated
+ * file fails to compile rather than silently picking one, which is the
+ * refuse-rather-than-guess the rest of this codebase holds to.
+ */
+import type { Collector } from "@descryy/runtime-contracts";
+import { type TraceCoverage } from "./test-runner-collector.ts";
+export interface SwiftTestDump {
+    readonly name: string;
+    readonly tests?: readonly SwiftTestDump[];
+}
+export interface DiscoveredSwiftClass {
+    readonly module: string;
+    readonly className: string;
+    readonly methods: readonly string[];
+}
+/**
+ * `--dump-tests-json`'s tree has no explicit node kind — a class is
+ * recognised structurally, as a node whose every child is itself a leaf (a
+ * bare `{"name": "testFoo"}` with no `tests` of its own, which is exactly
+ * the shape a test *method* has and a bundle/suite container never does).
+ * Anything else — the root, `"debug.xctest"`, a suite — is a container and
+ * is recursed into instead.
+ *
+ * A node whose name carries no `.` (so not `Module.Class`) is skipped
+ * rather than guessed at — `--dump-tests-json`'s own class names are always
+ * qualified this way in every build observed, and a bare name reaching here
+ * would mean this method's own structural assumption is wrong for that
+ * node, which is worth surfacing as a dropped class rather than papering
+ * over with an invented module.
+ */
+export declare function discoverClasses(dump: SwiftTestDump): DiscoveredSwiftClass[];
+/** Present at the top of every file this module writes — never anything a human authored. `stop()` refuses to delete a `Tests/LinuxMain.swift` that lacks it. */
+export declare const GENERATED_MARKER = "// Generated by @descryy/runtime-test-runner's swift-xctest observer -- safe to delete, regenerated on every observed run.";
+/** Pure: builds `Tests/LinuxMain.swift`'s full text from the classes `discoverClasses` found. No filesystem access. */
+export declare function generateLinuxMain(classes: readonly DiscoveredSwiftClass[]): string;
+export type SwiftDiscoveryResult = {
+    readonly ok: true;
+    readonly classes: readonly DiscoveredSwiftClass[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/**
+ * Builds the tests once (ordinary automatic discovery — no `LinuxMain.swift`
+ * involved yet) and reads back `--dump-tests-json` from the resulting
+ * binary. A pre-existing Descry-generated `LinuxMain.swift` is removed
+ * first: left in place, this build would use last run's stale class list
+ * rather than discovering fresh, and could fail outright if a module it
+ * names has since been removed.
+ */
+export declare function discoverSwiftTests(packageRoot: string): SwiftDiscoveryResult;
+/** Writes the generated file. Refuses (rather than overwrites) if a non-Descry `Tests/LinuxMain.swift` has appeared since `discoverSwiftTests` ran. */
+export declare function writeLinuxMain(packageRoot: string, classes: readonly DiscoveredSwiftClass[]): void;
+/** Removes a Descry-generated `Tests/LinuxMain.swift`, and only one — never a file this module did not write. */
+export declare function removeGeneratedLinuxMain(packageRoot: string): void;
+export interface SwiftXCTestCollectorOptions {
+    readonly packageRoot: string;
+    /** Joins emitted Evidence back to a named service, same convention as every other collector. Omit for a standalone test run with no corresponding service. */
+    readonly service?: string;
+}
+export interface SwiftXCTestCollector extends Collector {
+    waitForCompletion(): Promise<void>;
+    traceCoverage(): TraceCoverage;
+}
+/**
+ * The two-pass XCTest collector. `start()` does the discover-then-generate
+ * work before spawning anything a caller would recognise as "the test run"
+ * — genuinely slower to become `available` than the single-spawn runners on
+ * this seam, and that latency is the cost of there being no reporter flag
+ * to inject instead.
+ */
+export declare function createSwiftXCTestCollector(options: SwiftXCTestCollectorOptions): SwiftXCTestCollector;
+//# sourceMappingURL=swift-xctest.d.ts.map

package/dist/swift-xctest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift-xctest.d.ts","sourceRoot":"","sources":["../src/swift-xctest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAiE,MAAM,4BAA4B,CAAC;AAE3H,OAAO,EAAyE,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAGvI,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CAC3C;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,oBAAoB,EAAE,CAkB3E;AAED,iKAAiK;AACjK,eAAO,MAAM,gBAAgB,+HAA+H,CAAC;AA6C7J,uHAAuH;AACvH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,oBAAoB,EAAE,GAAG,MAAM,CA2BlF;AAoBD,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,oBAAoB,EAAE,CAAA;CAAE,GACxE;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,oBAAoB,CAyC5E;AAED,uJAAuJ;AACvJ,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,oBAAoB,EAAE,GAAG,IAAI,CAMlG;AAED,iHAAiH;AACjH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAKlE;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,8JAA8J;IAC9J,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAmBD,MAAM,WAAW,oBAAqB,SAAQ,SAAS;IACrD,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,aAAa,IAAI,aAAa,CAAC;CAChC;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,2BAA2B,GAAG,oBAAoB,CAsGrG"}