@systemfsoftware/stryker-js 12.0.0 → 12.1.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @systemfsoftware/stryker-js
 
+## 12.1.0
+
+### Minor Changes
+
+- A piped `stdout` now gets human output, exactly like a terminal. Machine consumers ask for the NDJSON event stream explicitly, with `--json` or `STRYKER_MODE=machine`; `--format text` names the human format, and passing it together with `--json` is a usage error (exit 2). Under `--json`, `stdout` carries wire records and nothing else, while progress status lines and log output stay on `stderr`.
+
+  Every run also writes those wire records to `reports/mutation-stream.jsonl` in human mode too, so a job that shows a readable log still produces the artifact `stryker merge-reports` rebuilds a shard's report from.
+
+  If a script or CI step read NDJSON from a piped run without requesting it, pass `--json` (or set `STRYKER_MODE=machine`) there.
+
+  Custom `RunEventDrain` implementations must accept a required `toStdout` argument in `drainFramed`; pass-throughs can ignore it.
+
+### Patch Changes
+
+- A run whose selected files produce no mutants, for example because no loaded framework claims them, now runs every test in the dry run and finishes with an empty report. With `testRunner: 'vm'` or `'vitest'` it used to fail with "No tests were executed", because the dry run only looked for tests related to those files. The dry run now relates tests only to the files that carry mutants.
+
+- A run whose `mutate` patterns match no file now finishes successfully instead of stopping with an instrument error. It performs the dry run, writes a mutation report with no files, and passes regardless of `thresholds.break`, the same as upstream StrykerJS. A sharded run whose shard receives no file no longer fails.
+
+  `stryker merge-reports` shows `n/a` for a package whose report has no tested mutant, instead of a score of `0.00`.
+
+  Errors reported for the prepare, dry-run, and mutation-testing stages now carry their reason as the error message, so a printed cause no longer shows up as a bare error name.
+
+- `stryker merge-reports` now rebuilds a package's partial report from the mutants recorded in its stream part when the run ended before writing its final report. Earlier versions recognized none of the recorded mutants and reported the package as having no report.
+
+- Mutation runs with `testRunner: 'vm'` finish in about half the time, with the same verdicts. The engine checks mutant groups on every checker process at once, stops the checkers as soon as checking ends, hands their share of `concurrency` to the test runners, and shares a Node compile cache with every worker it starts. The Vitest runner starts the next isolated worker thread while the current test file runs, so each file still gets a fresh thread but no longer waits for one to boot. On a 319-mutant TypeScript project with the TypeScript checker, a run went from 24.9 s to 12.6 s.
+
+- `testRunner: 'vm'` runs Vitest itself on Vitest's isolated `threads` pool instead of an in-process reimplementation, and stays the default `testRunner`. It reports the same test ids, outcomes and per-mutant verdicts as `testRunner: 'vitest'`, so a project whose Vitest config enables browser mode is refused at startup with a message naming `testRunner: 'vitest'`.
+
+  Stryker no longer discovers test files for `vm`: Vitest selects them from your config, as it does for `testRunner: 'vitest'`. A run that loads no test files fails the dry run naming `testFiles`.
+
 ## 12.0.0
 
 ### Major Changes

package/README.md

@@ -2,8 +2,8 @@
 
 The modern mutation testing framework for JavaScript and TypeScript.
 A ground-up, breaking-change fork of `@stryker-mutator/core` built with Effect 4:
-provides the `stryker` executable, in-process `vm` and isolated Vitest runners,
-and the typed `./config` authoring surface.
+provides the `stryker` executable, the `vm` and `vitest` test runners, and the
+typed `./config` authoring surface.
 
 ## Install
 
@@ -54,10 +54,13 @@ pnpm exec stryker run
 
 ## Zero-Plugin Built-in Runners
 
-The `vm` runner is the default: with no `testRunner` and no `testFiles`
-configured, it discovers `*.test` / `*.spec` files itself and runs them. It loads
-your suites through your project's `vitest`, so `vitest` must be installed.
-Set `testFiles` explicitly, or pick one of the runners below, to take control.
+The `vm` runner is the default and needs no plugin packages: `testRunner: 'vm'`
+runs Vitest itself, on Vitest's isolated `threads` pool, through the project's
+own `vitest` install (`vitest` must be installed). With no `testFiles`
+configured, Vitest selects the test files from your config, exactly as
+`vitest run` does. The runner reports the same test ids, outcomes and
+per-mutant verdicts as `vitest run`. Set `testFiles` explicitly, or pick one of
+the runners below, to take control.
 
 ### 1. Shell Command Runner (`testRunner: 'command'`)
 
@@ -75,9 +78,13 @@ export default defineConfig({
 })
 ```
 
-### 2. In-Process `vm` Runner (`testRunner: 'vm'`)
+### 2. The `vm` Runner (`testRunner: 'vm'`)
 
-Runs Vitest suites in-process, in one worker thread per test runner, loading each test file as native ESM through Node's module hooks. No child process and no bundler step. Each file gets its own module state by default; your `vitest.config.*` (environment, setup files, globals, projects) is picked up through your project's `vitest` install. Vitest browser-mode suites are refused with an error naming `testRunner: 'vitest'`; pick the `vitest` runner for those.
+Runs the Vitest runner on Vitest's isolated `threads` pool. Each test file keeps
+Vitest's own per-file isolation, and module mocking, snapshots, environments,
+setup files, projects and custom transforms behave as they do under
+`vitest run`. A Vitest config that enables browser mode is refused with an
+error naming `testRunner: 'vitest'`; pick the `vitest` runner for those.
 
 ```ts
 import { defineConfig } from '@systemfsoftware/stryker-js/config'
@@ -89,6 +96,10 @@ export default defineConfig({
 })
 ```
 
+Suites that need Vitest's `forks` pool (for example `process.chdir`, or native
+addons that are not thread-safe) use `testRunner: 'vitest'` with the
+`@systemfsoftware/stryker-js-vitest-runner` plugin instead.
+
 ## Configuration API (`@systemfsoftware/stryker-js/config`)
 
 The `./config` subpath exports the typed configuration authoring surface, including the `StrykerConfig` type naming the partial options a config file writes: a config annotated `const config: StrykerConfig = defineConfig({ ... })` typechecks and loads.
@@ -143,9 +154,20 @@ pnpm exec stryker run --incremental
 pnpm exec stryker run --concurrency 4
 
 # Merge partial mutation reports from parallel CI shards
-pnpm exec stryker merge-reports --output reports/mutation/mutation.json "reports/shards/*.json"
+pnpm exec stryker merge-reports --parts reports/shards --out reports/mutation
 ```
 
+## Output Modes
+
+Human output is the default, whether or not `stdout` is a terminal. A machine consumer opts into the NDJSON event stream explicitly:
+
+```bash
+pnpm exec stryker run --json                # wire records on stdout, diagnostics on stderr
+STRYKER_MODE=machine pnpm exec stryker run  # the same, named by environment
+```
+
+`--format text` names the human format explicitly; `--json` together with `--format text` is a usage error (exit 2). Under `--json`, `stdout` carries wire records and nothing else — progress lines and log output stay on `stderr`. Every run also writes the same records to `reports/mutation-stream.jsonl` (`--progressStreamFile`) in both modes, which is the artifact `stryker merge-reports` rebuilds a shard's partial report from.
+
 ## Programmatic API
 
 ### Effect 4 Native Interface

package/dist/{Run.schema-BxsyHwHr.mjs → Run.schema-BaK_pxuK.mjs}

@@ -7233,6 +7233,10 @@ const Percentage = S.Finite.pipe(S.check(S.isBetween({
 	minimum: 0,
 	maximum: 100
 })));
+const MutationScore = S.TaggedUnion({
+	Scored: { percentage: Percentage },
+	Unscored: {}
+});
 var Metrics = class Metrics extends S.Class("Metrics")({
 	pending: NonNegativeInt,
 	killed: NonNegativeInt,
@@ -7262,10 +7266,10 @@ var Metrics = class Metrics extends S.Class("Metrics")({
 		return this.totalValid + this.totalInvalid + this.ignored + this.pending;
 	}
 	get mutationScore() {
-		return Math.min(100, Math.max(0, this.totalDetected / this.totalValid * 100));
+		return scoreOf(this.totalDetected, this.totalValid);
 	}
 	get mutationScoreBasedOnCoveredCode() {
-		return Math.min(100, Math.max(0, this.totalDetected / this.totalCovered * 100));
+		return scoreOf(this.totalDetected, this.totalCovered);
 	}
 	static fromMutants(mutants) {
 		return Metrics.make({
@@ -7281,6 +7285,10 @@ var Metrics = class Metrics extends S.Class("Metrics")({
 	}
 };
 const metricCountOf = (mutants, status) => mutants.filter((mutant) => mutant.status === status).length;
+const scoreOf = (detected, counted) => Boolean$1$1.match(counted > 0, {
+	onTrue: () => MutationScore.cases.Scored.make({ percentage: detected / counted * 100 }),
+	onFalse: () => MutationScore.cases.Unscored.make({})
+});
 const MetricsSchema = Metrics;
 const MetricsResultSchema = S.Struct({
 	name: S.String,
@@ -7890,6 +7898,7 @@ var Report_exports = /* @__PURE__ */ __exportAll$1({
 	MetricsResultSchema: () => MetricsResultSchema,
 	MetricsSchema: () => MetricsSchema,
 	MutantResultSchema: () => MutantResultSchema,
+	MutationScore: () => MutationScore,
 	MutationTestResultSchema: () => MutationTestResultSchema,
 	NonNegativeFinite: () => NonNegativeFinite,
 	NonNegativeInt: () => NonNegativeInt,
@@ -8256,6 +8265,10 @@ const STAGE_PRESENTATION = {
 var PrepareError = class extends S.TaggedError()("PrepareError", {
 	stage: S.Literal("prepare"),
 	reason: S.String
-}) {};
+}) {
+	get message() {
+		return this.reason;
+	}
+};
 //#endregion
 export { Plugin_exports as A, RunReadError as C, VerdictReached as D, SkippedReported as E, ErrorText_exports as F, Format_exports as I, Instrument_exports as L, Reporter_exports as M, TestRunner_exports as N, Checker_exports as O, Trace_exports as P, Mutant_exports as R, RunPhase as S, SkippedFileRow as T, PluginsReported as _, FormatRegistryRow as a, RunFailed as b, Heartbeat as c, MutationRunPlan as d, OutputMode as f, PluginFailureReason as g, PlanMutationRunCommand as h, FormatRegistryResolved as i, Report_exports as j, Options_exports as k, HelpRendered as l, PlanKnown as m, StageError as n, FrameworkContributionRow as o, PhaseEntered as p, FormatClaimShadowingRow as r, FrameworkModuleRow as s, PrepareError as t, ModeSignal as u, RunDecodeError as v, RunStarted as w, RunMutantTested as x, RunEvent as y };

package/dist/{Run.schema-D43Nx5kI.d.mts → Run.schema-BnUKGQjA.d.mts}

@@ -1,4 +1,4 @@
-import { i as mod_d_exports$4, r as mod_d_exports$3 } from "./index-f-U3oZaJ.mjs";
+import { i as mod_d_exports$4, r as mod_d_exports$3 } from "./index-CKd1sAni.mjs";
 import * as S from "effect/Schema";
 //#region src/run-event.schema.d.ts
 declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
@@ -240,6 +240,8 @@ declare const PrepareError_base: S.Class<PrepareError, S.TaggedStruct<"PrepareEr
   readonly stage: S.Literal<"prepare">;
   readonly reason: S.String;
 }>, import("effect/Cause").YieldableError>;
-declare class PrepareError extends PrepareError_base {}
+declare class PrepareError extends PrepareError_base {
+  get message(): string;
+}
 //#endregion
 export { VerdictReached as A, RunReadError as C, SkippedReported as D, SkippedFileRow as E, VerdictCounts as O, RunPhase as S, RunTerminalEvent as T, PluginsReported as _, FormatRegistryRow as a, RunFailed as b, Heartbeat as c, MutationRunPlan as d, OutputMode as f, PluginFailureReason as g, PlanMutationRunCommand as h, FormatRegistryResolved as i, VerdictThresholds as j, VerdictMutant as k, HelpRendered as l, PlanKnown as m, StageError as n, FrameworkContributionRow as o, PhaseEntered as p, FormatClaimShadowingRow as r, FrameworkModuleRow as s, PrepareError as t, ModeSignal as u, RunDecodeError as v, RunStarted as w, RunMutantTested as x, RunEvent as y };

package/dist/{RunEnvironment.service-pCzdC0Sy.d.mts → RunEnvironment.service-BaTBH0mI.d.mts}

@@ -1,5 +1,5 @@
-import { a as mod_d_exports$5, c as mod_d_exports$2, d as Ignorer, i as mod_d_exports$4, l as mod_d_exports$3$1, n as mod_d_exports$2$1, o as mod_d_exports$6, r as mod_d_exports$3, s as mod_d_exports$1, t as mod_d_exports, u as Framework } from "./index-f-U3oZaJ.mjs";
-import { A as VerdictReached, D as SkippedReported, _ as PluginsReported, b as RunFailed, c as Heartbeat, i as FormatRegistryResolved, l as HelpRendered, m as PlanKnown, p as PhaseEntered, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-D43Nx5kI.mjs";
+import { a as mod_d_exports$5, c as mod_d_exports$2, d as Ignorer, i as mod_d_exports$4, l as mod_d_exports$3$1, n as mod_d_exports$2$1, o as mod_d_exports$6, r as mod_d_exports$3, s as mod_d_exports$1, t as mod_d_exports, u as Framework } from "./index-CKd1sAni.mjs";
+import { A as VerdictReached, D as SkippedReported, _ as PluginsReported, b as RunFailed, c as Heartbeat, i as FormatRegistryResolved, l as HelpRendered, m as PlanKnown, p as PhaseEntered, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-BnUKGQjA.mjs";
 import { Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import "effect/Option";
 import "effect/Result";
@@ -125,7 +125,7 @@ interface ResolvedModeInput {
 }
 //#endregion
 //#region src/run-event-stream.service.d.ts
-type FramedDrain = (framed: Stream.Stream<string, never, never>) => Effect$1.Effect<void, never, never>;
+type FramedDrain = (framed: Stream.Stream<string, never, never>, toStdout: boolean) => Effect$1.Effect<void, never, never>;
 interface RunEventDrainShape {
   readonly drainFramed: FramedDrain;
   readonly setProgressStreamFile: (fileName: string) => Effect$1.Effect<void, never, never>;

package/dist/config.d.mts

@@ -1,5 +1,5 @@
-import { n as mod_d_exports$2 } from "./index-f-U3oZaJ.mjs";
-import { a as StrykerConfig, i as Primitive, n as Immutable, o as StrykerConfigExport, r as ImmutablePrimitive, s as StrykerConfigFn, t as ConfigEnv } from "./stryker-config.schema-GS_4_5gX.mjs";
+import { n as mod_d_exports$2 } from "./index-CKd1sAni.mjs";
+import { a as StrykerConfig, i as Primitive, n as Immutable, o as StrykerConfigExport, r as ImmutablePrimitive, s as StrykerConfigFn, t as ConfigEnv } from "./stryker-config.schema-VVxHqsAv.mjs";
 //#region src/config/define-config.d.ts
 export declare function defineConfig(config: StrykerConfig): StrykerConfig;
 export declare function defineConfig(config: Promise<StrykerConfig>): Promise<StrykerConfig>;

package/dist/events.d.mts

@@ -1,2 +1,2 @@
-import { A as VerdictReached, C as RunReadError, D as SkippedReported, E as SkippedFileRow, O as VerdictCounts, S as RunPhase, _ as PluginsReported, a as FormatRegistryRow, b as RunFailed, c as Heartbeat, d as MutationRunPlan, f as OutputMode, g as PluginFailureReason, h as PlanMutationRunCommand, i as FormatRegistryResolved, j as VerdictThresholds, k as VerdictMutant, l as HelpRendered, m as PlanKnown, n as StageError, o as FrameworkContributionRow, p as PhaseEntered, r as FormatClaimShadowingRow, s as FrameworkModuleRow, t as PrepareError, u as ModeSignal, v as RunDecodeError, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-D43Nx5kI.mjs";
+import { A as VerdictReached, C as RunReadError, D as SkippedReported, E as SkippedFileRow, O as VerdictCounts, S as RunPhase, _ as PluginsReported, a as FormatRegistryRow, b as RunFailed, c as Heartbeat, d as MutationRunPlan, f as OutputMode, g as PluginFailureReason, h as PlanMutationRunCommand, i as FormatRegistryResolved, j as VerdictThresholds, k as VerdictMutant, l as HelpRendered, m as PlanKnown, n as StageError, o as FrameworkContributionRow, p as PhaseEntered, r as FormatClaimShadowingRow, s as FrameworkModuleRow, t as PrepareError, u as ModeSignal, v as RunDecodeError, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-BnUKGQjA.mjs";
 export { FormatClaimShadowingRow, FormatRegistryResolved, FormatRegistryRow, FrameworkContributionRow, FrameworkModuleRow, Heartbeat, HelpRendered, ModeSignal, MutationRunPlan, OutputMode, PhaseEntered, PlanKnown, PlanMutationRunCommand, PluginFailureReason, PluginsReported, PrepareError, RunDecodeError, RunEvent, RunFailed, RunMutantTested, RunPhase, RunReadError, RunStarted, SkippedFileRow, SkippedReported, StageError, type VerdictCounts, type VerdictMutant, VerdictReached, type VerdictThresholds };

package/dist/events.mjs

@@ -1,2 +1,2 @@
-import { C as RunReadError, D as VerdictReached, E as SkippedReported, S as RunPhase, T as SkippedFileRow, _ as PluginsReported, a as FormatRegistryRow, b as RunFailed, c as Heartbeat, d as MutationRunPlan, f as OutputMode, g as PluginFailureReason, h as PlanMutationRunCommand, i as FormatRegistryResolved, l as HelpRendered, m as PlanKnown, n as StageError, o as FrameworkContributionRow, p as PhaseEntered, r as FormatClaimShadowingRow, s as FrameworkModuleRow, t as PrepareError, u as ModeSignal, v as RunDecodeError, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-BxsyHwHr.mjs";
+import { C as RunReadError, D as VerdictReached, E as SkippedReported, S as RunPhase, T as SkippedFileRow, _ as PluginsReported, a as FormatRegistryRow, b as RunFailed, c as Heartbeat, d as MutationRunPlan, f as OutputMode, g as PluginFailureReason, h as PlanMutationRunCommand, i as FormatRegistryResolved, l as HelpRendered, m as PlanKnown, n as StageError, o as FrameworkContributionRow, p as PhaseEntered, r as FormatClaimShadowingRow, s as FrameworkModuleRow, t as PrepareError, u as ModeSignal, v as RunDecodeError, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-BaK_pxuK.mjs";
 export { FormatClaimShadowingRow, FormatRegistryResolved, FormatRegistryRow, FrameworkContributionRow, FrameworkModuleRow, Heartbeat, HelpRendered, ModeSignal, MutationRunPlan, OutputMode, PhaseEntered, PlanKnown, PlanMutationRunCommand, PluginFailureReason, PluginsReported, PrepareError, RunDecodeError, RunEvent, RunFailed, RunMutantTested, RunPhase, RunReadError, RunStarted, SkippedFileRow, SkippedReported, StageError, VerdictReached };