@systemfsoftware/stryker-js 0.2.0 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,157 @@
 # @systemfsoftware/stryker-js
 
+## 2.0.0
+
+### Major Changes
+
+- The packages are renamed. `plugin-api` is now `@systemfsoftware/stryker-js`, the
+  language every plugin is written against. `mutation-run` is split: the run
+  itself is `@systemfsoftware/stryker-js-engine`
+  (host-neutral, no Node on its manifest) and the Node process entries are
+  `@systemfsoftware/stryker-js-cli`, which owns the worker files and the runtime
+  gate. `mutation-report` is now `@systemfsoftware/stryker-js-html-reporter`.
+  `@systemfsoftware/stryker-js-platform-node` is never published — do not install
+  it. Install the new names and change your imports.
+
+  Options types moved. `StrykerOptions`, `PartialStrykerOptions` and `LogLevel` are
+  imported from the `Schema` export; `Mutant`, `MutantStatus`, `Position` and
+  `Location` from the `Mutant` export. Point a config's `extends` at the language
+  package's `Schema` export.
+
+  `MutantStatus` accepts one spelling per outcome: `Killed`, `Survived`,
+  `NoCoverage`, `Timeout`, `CompileError`, `RuntimeError`, `Ignored` and `Pending`.
+  The lowercase and abbreviated forms — `killed`, `timedOut`, `noCoverage` and the
+  rest — are gone. A comparison against a removed spelling never matched the value
+  the reporter actually produced, so check any status comparison you wrote.
+
+  Statuses, plugin kinds, exit classes and AST formats are string literal unions
+  rather than enums, so read them as their string values. Member access such as
+  `ExitClass.VerdictFail` no longer resolves.
+
+  A plugin no longer receives a logger, and the logger port is gone. Plugins log
+  through Effect, and the host decides where that output goes.
+
+  The bundled base preset is gone. A config inherits from the language package's
+  `Schema` export and states the thresholds, reporters and plugins it wants; you no
+  longer silently inherit a package manager, a plugin list or a break threshold.
+
+- An evaluator now answers with the verdict it reached instead of failing to
+  report one.
+
+  `Evaluator.evaluate` returns `ExitClass | null` on the success channel: the
+  class the run should end in, or `null` for nothing to report. `ExitClass` is
+  exported from `@systemfsoftware/stryker-js/evaluate`. The error
+  channel is for the evaluator itself breaking — a report it cannot read, a
+  decision it cannot reach.
+
+  Previously the only way to report a failed gate was to fail, which a caller
+  could not tell apart from the evaluator crashing, so neither the exit code nor
+  the message could distinguish them. If you wrote an evaluator that failed to
+  signal a verdict, return the class instead.
+
+  A run's verdict is now the most severe class anyone reported — the score against
+  your `break` threshold, plus every evaluator's answer.
+
+- Plugins are written against Effect instead of Promise.
+
+  `Checker`, `TestRunner`, `Reporter`, `Ignorer` and `Evaluator` are capability services whose operations return an `Effect`. Provide your plugin as a `Layer` through `declarePlugin`; the class, factory and value declarations are gone, along with the `typed-inject` dependency. Implement the operations that were optional — return `Effect.void` where there is nothing to do, and one group per mutant from `group` if you have no grouping opinion.
+
+  Each capability fails with a tagged error. Outcomes are not failures: a killed mutant, a survivor and a compile error in the code under test are successful results.
+
+  Read the sandbox path from `SandboxDirectory`. `commonTokens`, `tokens` and the plugin context types are removed. `determineHitLimitReached` returns an `Option`.
+
+### Minor Changes
+
+- `RENDERED_OPTION_DEFAULTS` is exported from the `core` entry point. It carries
+  the four option defaults that appear in human-readable help text, so a tool
+  printing "the default is X" reads the same value the option schema applies
+  instead of restating it.
+
+- The shared helpers package is gone. Nothing installs it any more, and the
+  handful of helpers worth sharing now live in the plugin contract next to the
+  types they serve:
+
+  - `strykerReportBugUrl`, `normalizeFileName`, `propertyPath`, `errorToString`
+    and `isErrnoException` from `@systemfsoftware/stryker-js/core`
+  - `noopLogger` from `@systemfsoftware/stryker-js/logging`
+  - `testFilesProvided` from `@systemfsoftware/stryker-js/test-runner`
+
+  If you imported any of those, change the specifier. Everything else it exported
+  had no consumer and is removed: use `Predicate.isNotNullish` from Effect in place
+  of `notEmpty`, and `RegExp.escape` in place of `escapeRegExp`.
+
+- Checker and test-runner workers now talk over Effect's own worker RPC, and every
+  call they exchange is a declared operation with a declared result.
+
+  Before, the parent and its workers spoke a protocol written by hand: messages were
+  newline-delimited JSON, arguments were typed as "any JSON value", and each method
+  was reached by name through a proxy. Nothing checked that a payload was one the far
+  end could serve, so a value it could not read was refused after it arrived, and a
+  call whose message never landed was waited on anyway.
+
+  The six operations that cross that boundary — a checker's `check` and `group`, a
+  runner's `capabilities`, `dryRun` and `mutantRun` — now each name what they take
+  and what they return, and the options a worker starts from are sent once when it
+  starts rather than as a first method call. A payload that does not fit is refused
+  where it is built, and a worker that cannot answer fails the call that was waiting.
+
+  The two worker entry points are no longer importable subpaths of this package.
+  They were only ever spawned as processes, and the paths resolved to TypeScript
+  sources that could not be executed.
+
+### Patch Changes
+
+- A mutation run that is killed mid-way keeps every completed mutant: the JSONL progress stream is flushed after each result, and incremental mode writes remembered verdicts as they finish so the next run continues instead of starting over.
+
+  Remembered killed mutants still name the tests that killed them, so a resumed run's report matches a complete run.
+
+  The progress stream path is progressStreamFile (default reports/mutation-stream.jsonl) and can be set in config or with --progressStreamFile.
+
+- New version is published through npm trusted publishing, so it carries a provenance attestation you can verify.
+
+- Peer Effect requirement advances to 4.0.0-rc.112. No API changes.
+
+- An oversized message between the runner and a worker now fails the run with a
+  reason instead of exhausting memory. Each side of the connection reads frames
+  up to 16 MiB, which leaves headroom over the largest legitimate payload — a dry
+  run carrying per-test coverage — and a frame past the limit fails the calls
+  waiting on it rather than growing until the process dies.
+
+- Each of these packages now has a README, so its registry page says what the package is, how
+  to install it, and what to import or register — previously the page was blank. The lint
+  plugins show the configuration line that enables what they recommend.
+
+  `@systemfsoftware/stryker-js-html-reporter` also carries its licence text
+
+- These packages no longer install dependencies they never imported, so installing them pulls less into your tree.
+
+  `tslib` is gone from all six. The mutation runner additionally stops installing `lodash.groupby`, `semver` and `source-map`, and the command line interface stops installing `@effect/platform-node-shared`. Nothing exported changes.
+
+- Published packages no longer carry build artifacts left over from earlier builds. One package was shipping about a megabyte of bundled test-runner internals this way.
+
+- The closing verdict line carries its findings again. It had shrunk to the score alone, so a consumer reading the stream could no longer see the score limits the run was held to, where the report was written, or which mutants survived — the survivors were reported while the run was in flight and then absent from the summary that closes it.
+
+  The verdict now states the thresholds, the report path, and every surviving mutant with its file, position, mutator and replacement.
+
+## 1.0.0
+
+### Major Changes
+
+- The console log threshold is now scoped to the run that set it. Two runs in one
+  process no longer share it, so a run that lowers its own level can no longer
+  quieten another run happening alongside it.
+
+  `setEngineLogLevel` is removed. The level travels with the run.
+
+- `runMutationTest` now requires the run-identity services to be provided by the caller; the effect names them in its requirements channel.
+
+- The public Run subpath's shouldKeepTempDir now accepts any failure channel instead of only S.SchemaError; the runMutationTest signature and event surface are unchanged
+
+### Patch Changes
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@6.0.0
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -2,7 +2,7 @@
 
 The mutation-testing language — the plugin kinds, capability ports, and schemas
 a mutation run is built from, with no platform. The Node host that runs a
-mutation test lives in `@systemfsoftware/stryker-js-platform-node`.
+mutation test lives in `@systemfsoftware/stryker-js-engine`.
 
 ## Install
 
@@ -29,4 +29,4 @@ Each concept module is an enumerated specifier:
 
 ## License
 
-Apache-2.0. Part of [systemfsoftware](https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/testing/mutation/stryker-js/stryker-js#readme).
+Apache-2.0. Part of [systemfsoftware](https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/stryker-js/stryker-js#readme).

package/dist/{Evaluator-DLVXUcVj.d.mts → Evaluator-RZBS4oeh.d.mts}

@@ -1,4 +1,4 @@
-import { t as ExitClass } from "./ExitClass.schema-BmCUn2Sm.mjs";
+import { r as ExitClass } from "./ExitClass.schema-BmOIK5zT.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as schema from "mutation-testing-report-schema/api";

package/dist/Evaluator.d.mts

@@ -1,3 +1,3 @@
-import { n as EvaluatorService, r as EvaluatorFailed, t as Evaluator } from "./Evaluator-DLVXUcVj.mjs";
-import { t as ExitClass } from "./ExitClass.schema-BmCUn2Sm.mjs";
+import { n as EvaluatorService, r as EvaluatorFailed, t as Evaluator } from "./Evaluator-RZBS4oeh.mjs";
+import { r as ExitClass } from "./ExitClass.schema-BmOIK5zT.mjs";
 export { Evaluator, EvaluatorFailed, EvaluatorService, type ExitClass };

package/dist/ExitClass.d.mts

@@ -1,8 +1,9 @@
-import { t as ExitClass } from "./ExitClass.schema-BmCUn2Sm.mjs";
+import { n as ClassifyExitDecision, r as ExitClass, t as ClassifyExitCommand } from "./ExitClass.schema-BmOIK5zT.mjs";
 //#region src/ExitClass.d.ts
 declare const EXIT_CODE: Record<ExitClass, number>;
 declare function verdictExitClass(score: number | null, breakingThreshold: number | null): ExitClass | null;
 declare function highestExitClass(pending: Iterable<ExitClass>): ExitClass | null;
 declare function resolveExitCode(pending: Iterable<ExitClass>, signal: number | null): number;
+declare const classifyExit: (command: ClassifyExitCommand) => ClassifyExitDecision;
 //#endregion
-export { EXIT_CODE, ExitClass, highestExitClass, resolveExitCode, verdictExitClass };
+export { EXIT_CODE, ExitClass, classifyExit, highestExitClass, resolveExitCode, verdictExitClass };

package/dist/ExitClass.mjs

@@ -1,4 +1,5 @@
 import * as S from "effect/Schema";
+import * as Match from "effect/Match";
 //#region src/ExitClass.schema.ts
 const ExitClass = S.Literals([
 	"VerdictFail",
@@ -6,6 +7,16 @@ const ExitClass = S.Literals([
 	"RuntimeError",
 	"InternalError"
 ]);
+S.TaggedClass()("ClassifyExitCommand", {
+	pending: S.Array(ExitClass),
+	signal: S.NullOr(S.Number),
+	score: S.NullOr(S.Number),
+	breakingThreshold: S.NullOr(S.Number)
+});
+var ClassifyExitDecision = class extends S.TaggedClass()("ClassifyExitDecision", {
+	highestClass: S.NullOr(ExitClass),
+	verdictClass: S.NullOr(ExitClass)
+}) {};
 //#endregion
 //#region src/ExitClass.ts
 const EXIT_CODE = {
@@ -30,5 +41,30 @@ function resolveExitCode(pending, signal) {
 	if (highest === null) return 0;
 	return EXIT_CODE[highest];
 }
+const deriveVerdict = (score, breakingThreshold) => {
+	if (score === null || breakingThreshold === null) return null;
+	if (score < breakingThreshold) return "VerdictFail";
+	return null;
+};
+const rank = (value) => Match.value(value).pipe(Match.when("InternalError", () => 4), Match.when("RuntimeError", () => 3), Match.when("ConfigError", () => 2), Match.when("VerdictFail", () => 1), Match.exhaustive);
+const withVerdict = (pending, verdict) => {
+	if (verdict === null) return pending;
+	if (pending.includes(verdict)) return pending;
+	return [...pending, verdict];
+};
+const highestOf = (values) => values.reduce((acc, cur) => {
+	if (acc === null) return cur;
+	if (rank(cur) > rank(acc)) return cur;
+	return acc;
+}, null);
+const classifyExit = (command) => {
+	const verdictClass = deriveVerdict(command.score, command.breakingThreshold);
+	const pendingWithVerdict = withVerdict(command.pending, verdictClass);
+	const highestClass = highestOf(pendingWithVerdict);
+	return ClassifyExitDecision.make({
+		highestClass,
+		verdictClass
+	});
+};
 //#endregion
-export { EXIT_CODE, ExitClass, highestExitClass, resolveExitCode, verdictExitClass };
+export { EXIT_CODE, ExitClass, classifyExit, highestExitClass, resolveExitCode, verdictExitClass };

package/dist/ExitClass.schema-BmOIK5zT.d.mts

@@ -0,0 +1,18 @@
+import * as S from "effect/Schema";
+//#region src/ExitClass.schema.d.ts
+declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
+type ExitClass = typeof ExitClass.Type;
+declare const ClassifyExitCommand_base: S.Class<ClassifyExitCommand, S.TaggedStruct<"ClassifyExitCommand", {
+  readonly pending: S.$Array<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
+  readonly signal: S.NullOr<S.Number>;
+  readonly score: S.NullOr<S.Number>;
+  readonly breakingThreshold: S.NullOr<S.Number>;
+}>, {}>;
+declare class ClassifyExitCommand extends ClassifyExitCommand_base {}
+declare const ClassifyExitDecision_base: S.Class<ClassifyExitDecision, S.TaggedStruct<"ClassifyExitDecision", {
+  readonly highestClass: S.NullOr<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
+  readonly verdictClass: S.NullOr<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
+}>, {}>;
+declare class ClassifyExitDecision extends ClassifyExitDecision_base {}
+//#endregion
+export { ClassifyExitDecision as n, ExitClass as r, ClassifyExitCommand as t };

package/dist/{Module-DUBk7gl2.d.mts → Module-DHKEMAFI.d.mts}

@@ -20,9 +20,9 @@ declare const Module_base: Context.ServiceClass<Module, "@systemfsoftware/stryke
  * feature code may use: `createRequire` and `isBuiltin`. Resolving a
  * specifier against a project directory, importing a plugin, and asking
  * whether a name is a builtin all go through this one tag; no feature module
- * touches the host module API. The Node implementation ships in
- * `@systemfsoftware/stryker-js-platform-node`; tests substitute a layer
- * returning fixed paths.
+ * touches the host module API. The Node implementation ships in the
+ * composition-root package (`@systemfsoftware/stryker-js-cli`); tests that do
+ * not need real plugin resolution substitute a layer returning fixed paths.
  *
  * @since 2.0.0
  */

package/dist/Module.d.mts

@@ -1,2 +1,2 @@
-import { n as ModuleRequire, t as Module } from "./Module-DUBk7gl2.mjs";
+import { n as ModuleRequire, t as Module } from "./Module-DHKEMAFI.mjs";
 export { Module, ModuleRequire };

package/dist/Module.mjs

@@ -5,9 +5,9 @@ import * as Context from "effect/Context";
 * feature code may use: `createRequire` and `isBuiltin`. Resolving a
 * specifier against a project directory, importing a plugin, and asking
 * whether a name is a builtin all go through this one tag; no feature module
-* touches the host module API. The Node implementation ships in
-* `@systemfsoftware/stryker-js-platform-node`; tests substitute a layer
-* returning fixed paths.
+* touches the host module API. The Node implementation ships in the
+* composition-root package (`@systemfsoftware/stryker-js-cli`); tests that do
+* not need real plugin resolution substitute a layer returning fixed paths.
 *
 * @since 2.0.0
 */

package/dist/{Plugin-HR2dbiT7.d.mts → Plugin-DcDAIBQi.d.mts}

@@ -1,8 +1,8 @@
 import { n as Checker } from "./Checker-DYgIIEai.mjs";
 import { J as TestRunner } from "./Mutant-BPRJTF8f.mjs";
-import { t as Evaluator } from "./Evaluator-DLVXUcVj.mjs";
+import { t as Evaluator } from "./Evaluator-RZBS4oeh.mjs";
 import { t as Ignorer } from "./Ignorer-BUY68FZQ.mjs";
-import { t as Module } from "./Module-DUBk7gl2.mjs";
+import { t as Module } from "./Module-DHKEMAFI.mjs";
 import { c as Reporter } from "./Reporter-eZ3M7lO6.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";

package/dist/Plugin.d.mts

@@ -1,2 +1,2 @@
-import { a as PluginEnvironment, c as RunConfiguration, d as declarePlugin, f as PluginContribution, i as MergedPluginServices, l as SandboxDirectory, m as Shadowing, n as ComposedPlugins, o as PluginInterfaces, p as PluginKind, r as ContributionOf, t as AnyPluginContribution, u as composePlugins } from "./Plugin-HR2dbiT7.mjs";
+import { a as PluginEnvironment, c as RunConfiguration, d as declarePlugin, f as PluginContribution, i as MergedPluginServices, l as SandboxDirectory, m as Shadowing, n as ComposedPlugins, o as PluginInterfaces, p as PluginKind, r as ContributionOf, t as AnyPluginContribution, u as composePlugins } from "./Plugin-DcDAIBQi.mjs";
 export { AnyPluginContribution, ComposedPlugins, ContributionOf, MergedPluginServices, PluginContribution, PluginEnvironment, PluginInterfaces, PluginKind, RunConfiguration, SandboxDirectory, Shadowing, composePlugins, declarePlugin };

package/dist/{Run-lXratlN7.mjs → Run-BcDo-hIC.mjs}

@@ -2,10 +2,9 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as Effect from "effect/Effect";
-import { Cell, Wire, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Exit from "effect/Exit";
-import { pipe } from "effect/Function";
 import * as Result from "effect/Result";
+import { Wire } from "@systemfsoftware/effect-cell-types";
 //#region src/Run.schema.ts
 const RunPhase = S.Literals([
 	"prepare",
@@ -137,8 +136,6 @@ var RunOutput = class extends S.TaggedClass()("RunOutput", {
 S.TaggedError()("RunDecodeError", { message: S.String });
 S.TaggedError()("RunReadError", { message: S.String });
 S.TaggedError()("RunWriteError", { message: S.String });
-//#endregion
-//#region src/Run.workflow.ts
 var PlanMutationRunCommand = class extends S.TaggedClass()("PlanMutationRunCommand", {
 	configMutatePatterns: Wire.mint(S.Array(Wire.mint(S.String))),
 	configMutatorNames: Wire.mint(S.Array(Wire.mint(S.String))),
@@ -149,27 +146,6 @@ var MutationRunPlan = class extends S.TaggedClass()("MutationRunPlan", {
 	mutatePatterns: Wire.mint(S.Array(Wire.mint(S.String))),
 	mutatorNames: Wire.mint(S.Array(Wire.mint(S.String)))
 }) {};
-S.TaggedError()("PlanMutationRunError", {
-	message: S.String,
-	detail: S.String
-});
-const selectMutatePatterns = (target, fallback) => {
-	if (target.length > 0) return [...target];
-	return [...fallback];
-};
-const selectMutatorNames = (available, fallback) => {
-	if (available.length > 0) return [...available];
-	return [...fallback];
-};
-const decidePlan = (command) => {
-	const mutatePatterns = selectMutatePatterns(command.targetMutatePatterns, command.configMutatePatterns);
-	const mutatorNames = selectMutatorNames(command.availableMutators, command.configMutatorNames);
-	return Result.succeed(MutationRunPlan.make({
-		mutatePatterns,
-		mutatorNames
-	}));
-};
-const planMutationRun = Workflow.make(PlanMutationRunCommand, (command) => decidePlan(command));
 //#endregion
 //#region src/Run.ts
 var Run_exports = /* @__PURE__ */ __exportAll({
@@ -189,37 +165,35 @@ var Run_exports = /* @__PURE__ */ __exportAll({
 	RunPhase: () => RunPhase,
 	RunStarted: () => RunStarted,
 	VerdictReached: () => VerdictReached,
+	planMutationRun: () => planMutationRun,
 	runMutationTest: () => runMutationTest,
 	shouldKeepTempDir: () => shouldKeepTempDir
 });
-/**
-* Where a run's events go.
-*
-* The error channel carries `Cause.Done`, the graceful completion signal: a finished run
-* ends the queue, and `Stream.fromQueue` excludes `Done` from its own error channel, so the
-* consumer sees end-of-stream. Interrupting the queue instead would end it with an
-* interrupt cause, and joining the drain would then re-raise that into the caller and lose
-* the exit code the run had already decided.
-*/
+const firstNonEmpty = (preferred, fallback) => {
+	if (preferred.length > 0) return [...preferred];
+	return [...fallback];
+};
+const planMutationRun = (command) => MutationRunPlan.make({
+	mutatePatterns: firstNonEmpty(command.targetMutatePatterns, command.configMutatePatterns),
+	mutatorNames: firstNonEmpty(command.availableMutators, command.configMutatorNames)
+});
 var RunEvents = class extends Context.Service()("~@systemfsoftware/stryker-js/RunEvents") {};
 var RunIdentity = class extends Context.Service()("~@systemfsoftware/stryker-js/RunIdentity") {};
-const mutationRunDescription = (io, services) => pipe(Cell.read((command) => Effect.provideContext(io.read(command), services)), Cell.decode((raw) => S.decodeUnknownResult(PlanMutationRunCommand)(raw)), Cell.decide(planMutationRun), Cell.encode((outcome) => Result.match(outcome, {
-	onFailure: (error) => new RunOutput({
-		verdictJson: JSON.stringify({ error: error.message }),
-		exitCode: 1
-	}),
-	onSuccess: (plan) => new RunOutput({
+const runMutationTest = (io, command) => Effect.gen(function* () {
+	const raw = yield* io.read(command);
+	const planCommand = yield* Result.match(S.decodeUnknownResult(PlanMutationRunCommand)(raw), {
+		onFailure: (error) => Effect.fail(error),
+		onSuccess: (decoded) => Effect.succeed(decoded)
+	});
+	const plan = planMutationRun(planCommand);
+	return yield* io.write(new RunOutput({
 		verdictJson: JSON.stringify({
 			mutate: plan.mutatePatterns,
-			mutators: plan.mutatorNames
+			mutatorNames: plan.mutatorNames
 		}),
 		exitCode: 0
-	})
-})), Cell.write((output) => Effect.provideContext(io.write(output), services)));
-const runMutationTest = (io, command) => Effect.gen(function* () {
-	const services = yield* Effect.context();
-	return yield* Cell.apply(mutationRunDescription(io, services), command);
+	}));
 });
 const shouldKeepTempDir = (exit, cleanTempDir) => Exit.isFailure(exit) && cleanTempDir !== "always";
 //#endregion
-export { RunPhase as _, shouldKeepTempDir as a, ManifestRendered as c, MutantTested as d, OutputMode as f, RunFailed as g, RunEvent as h, runMutationTest as i, ModeSignal as l, PlanKnown as m, RunIdentity as n, Heartbeat as o, PhaseEntered as p, Run_exports as r, HelpRendered as s, RunEvents as t, MutantStatus as u, RunStarted as v, VerdictReached as y };
+export { RunFailed as _, runMutationTest as a, VerdictReached as b, HelpRendered as c, MutantStatus as d, MutantTested as f, RunEvent as g, PlanKnown as h, planMutationRun as i, ManifestRendered as l, PhaseEntered as m, RunIdentity as n, shouldKeepTempDir as o, OutputMode as p, Run_exports as r, Heartbeat as s, RunEvents as t, ModeSignal as u, RunPhase as v, RunStarted as y };

package/dist/{Run-BudLsVwF.d.mts → Run-BnmGGgWj.d.mts}

@@ -1,9 +1,8 @@
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as Effect from "effect/Effect";
-import { Wire, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Exit from "effect/Exit";
-import "effect/Result";
+import { Wire } from "@systemfsoftware/effect-cell-types";
 import * as Cause from "effect/Cause";
 import * as Queue from "effect/Queue";
 //#region src/Run.schema.d.ts
@@ -146,26 +145,23 @@ declare const RunOutput_base: S.Class<RunOutput, S.TaggedStruct<"RunOutput", {
   readonly exitCode: S.Finite;
 }>, {}>;
 declare class RunOutput extends RunOutput_base {}
-//#endregion
-//#region src/Run.workflow.d.ts
-declare const PlanMutationRunError_base: S.Class<PlanMutationRunError, S.TaggedStruct<"PlanMutationRunError", {
-  readonly message: S.String;
-  readonly detail: S.String;
-}>, import("effect/Cause").YieldableError>;
-declare class PlanMutationRunError extends PlanMutationRunError_base {}
+declare const PlanMutationRunCommand_base: S.Class<PlanMutationRunCommand, S.TaggedStruct<"PlanMutationRunCommand", {
+  readonly configMutatePatterns: S.$Array<S.String & Wire.Mark> & Wire.Mark;
+  readonly configMutatorNames: S.$Array<S.String & Wire.Mark> & Wire.Mark;
+  readonly targetMutatePatterns: S.$Array<S.String & Wire.Mark> & Wire.Mark;
+  readonly availableMutators: S.$Array<S.String & Wire.Mark> & Wire.Mark;
+}>, {}>;
+declare class PlanMutationRunCommand extends PlanMutationRunCommand_base {}
+declare const MutationRunPlan_base: S.Class<MutationRunPlan, S.TaggedStruct<"MutationRunPlan", {
+  readonly mutatePatterns: S.$Array<S.String & Wire.Mark> & Wire.Mark;
+  readonly mutatorNames: S.$Array<S.String & Wire.Mark> & Wire.Mark;
+}>, {}>;
+declare class MutationRunPlan extends MutationRunPlan_base {}
 declare namespace Run_d_exports {
-  export { Heartbeat, HelpRendered, Location, ManifestRendered, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, Position, RunEvent, RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, RunTerminalEvent, VerdictReached, runMutationTest, shouldKeepTempDir };
+  export { Heartbeat, HelpRendered, Location, ManifestRendered, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, Position, RunEvent, RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, RunTerminalEvent, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir };
 }
+declare const planMutationRun: (command: PlanMutationRunCommand) => MutationRunPlan;
 declare const RunEvents_base: Context.ServiceClass<RunEvents, "~@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | ManifestRendered | MutantTested | PhaseEntered | PlanKnown | RunFailed | RunStarted | VerdictReached, Cause.Done<void>>>;
-/**
- * Where a run's events go.
- *
- * The error channel carries `Cause.Done`, the graceful completion signal: a finished run
- * ends the queue, and `Stream.fromQueue` excludes `Done` from its own error channel, so the
- * consumer sees end-of-stream. Interrupting the queue instead would end it with an
- * interrupt cause, and joining the drain would then re-raise that into the caller and lose
- * the exit code the run had already decided.
- */
 declare class RunEvents extends RunEvents_base {}
 interface RunIdentityShape {
   readonly runId: string;
@@ -178,6 +174,6 @@ interface MutationRunIo {
   readonly write: (output: RunOutput) => Effect.Effect<void, S.SchemaError, RunIdentity>;
 }
 declare const runMutationTest: (io: MutationRunIo, command: RunCommand) => Effect.Effect<void, S.SchemaError, RunIdentity>;
-declare const shouldKeepTempDir: (exit: Exit.Exit<void, PlanMutationRunError | S.SchemaError>, cleanTempDir: 'always' | boolean) => boolean;
+declare const shouldKeepTempDir: (exit: Exit.Exit<void, unknown>, cleanTempDir: 'always' | boolean) => boolean;
 //#endregion
-export { RunTerminalEvent as C, RunStarted as S, PlanKnown as _, Run_d_exports as a, RunFailed as b, Heartbeat as c, ManifestRendered as d, ModeSignal as f, PhaseEntered as g, OutputMode as h, RunIdentityShape as i, HelpRendered as l, MutantTested as m, RunEvents as n, runMutationTest as o, MutantStatus as p, RunIdentity as r, shouldKeepTempDir as s, MutationRunIo as t, Location as u, Position as v, VerdictReached as w, RunPhase as x, RunEvent as y };
+export { RunStarted as C, RunPhase as S, VerdictReached as T, PhaseEntered as _, Run_d_exports as a, RunEvent as b, shouldKeepTempDir as c, Location as d, ManifestRendered as f, OutputMode as g, MutantTested as h, RunIdentityShape as i, Heartbeat as l, MutantStatus as m, RunEvents as n, planMutationRun as o, ModeSignal as p, RunIdentity as r, runMutationTest as s, MutationRunIo as t, HelpRendered as u, PlanKnown as v, RunTerminalEvent as w, RunFailed as x, Position as y };

package/dist/Run.d.mts

@@ -1,2 +1,2 @@
-import { C as RunTerminalEvent, S as RunStarted, _ as PlanKnown, b as RunFailed, c as Heartbeat, d as ManifestRendered, f as ModeSignal, g as PhaseEntered, h as OutputMode, i as RunIdentityShape, l as HelpRendered, m as MutantTested, n as RunEvents, o as runMutationTest, p as MutantStatus, r as RunIdentity, s as shouldKeepTempDir, t as MutationRunIo, u as Location, v as Position, w as VerdictReached, x as RunPhase, y as RunEvent } from "./Run-BudLsVwF.mjs";
-export { Heartbeat, HelpRendered, type Location, ManifestRendered, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, type Position, RunEvent, type RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, type RunTerminalEvent, VerdictReached, runMutationTest, shouldKeepTempDir };
+import { C as RunStarted, S as RunPhase, T as VerdictReached, _ as PhaseEntered, b as RunEvent, c as shouldKeepTempDir, d as Location, f as ManifestRendered, g as OutputMode, h as MutantTested, i as RunIdentityShape, l as Heartbeat, m as MutantStatus, n as RunEvents, o as planMutationRun, p as ModeSignal, r as RunIdentity, s as runMutationTest, t as MutationRunIo, u as HelpRendered, v as PlanKnown, w as RunTerminalEvent, x as RunFailed, y as Position } from "./Run-BnmGGgWj.mjs";
+export { Heartbeat, HelpRendered, type Location, ManifestRendered, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, type Position, RunEvent, type RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, type RunTerminalEvent, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir };

package/dist/Run.mjs

@@ -1,2 +1,2 @@
-import { _ as RunPhase, a as shouldKeepTempDir, c as ManifestRendered, d as MutantTested, f as OutputMode, g as RunFailed, h as RunEvent, i as runMutationTest, l as ModeSignal, m as PlanKnown, n as RunIdentity, o as Heartbeat, p as PhaseEntered, s as HelpRendered, t as RunEvents, u as MutantStatus, v as RunStarted, y as VerdictReached } from "./Run-lXratlN7.mjs";
-export { Heartbeat, HelpRendered, ManifestRendered, ModeSignal, MutantStatus, MutantTested, OutputMode, PhaseEntered, PlanKnown, RunEvent, RunEvents, RunFailed, RunIdentity, RunPhase, RunStarted, VerdictReached, runMutationTest, shouldKeepTempDir };
+import { _ as RunFailed, a as runMutationTest, b as VerdictReached, c as HelpRendered, d as MutantStatus, f as MutantTested, g as RunEvent, h as PlanKnown, i as planMutationRun, l as ManifestRendered, m as PhaseEntered, n as RunIdentity, o as shouldKeepTempDir, p as OutputMode, s as Heartbeat, t as RunEvents, u as ModeSignal, v as RunPhase, y as RunStarted } from "./Run-BcDo-hIC.mjs";
+export { Heartbeat, HelpRendered, ManifestRendered, ModeSignal, MutantStatus, MutantTested, OutputMode, PhaseEntered, PlanKnown, RunEvent, RunEvents, RunFailed, RunIdentity, RunPhase, RunStarted, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir };

package/dist/{Schema-BAKDG_jC.mjs → Schema-CdNkubPi.mjs}

@@ -103,12 +103,14 @@ const WarningOptions = openStruct({
 	unserializableOptions: defaulted(Wire.mint(S.Boolean), true),
 	slow: defaulted(Wire.mint(S.Boolean), true)
 });
+const ConcurrencyCount = Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isGreaterThanOrEqualTo(1))));
+const ConcurrencyPercent = Wire.mint(Wire.mint(S.String).pipe(S.check(S.isPattern(/^(100|[1-9]?[0-9])%$/))));
 const StrykerOptionsSchema = S.StructWithRest(S.Struct({
 	allowConsoleColors: defaulted(Wire.mint(S.Boolean), true),
 	buildCommand: S.optional(Wire.mint(S.String)),
 	checkers: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
 	checkerNodeArgs: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
-	concurrency: S.optional(Wire.mint(S.Union([Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isGreaterThanOrEqualTo(1)))), Wire.mint(Wire.mint(S.String).pipe(S.check(S.isPattern(/^(100|[1-9]?[0-9])%$/))))]))),
+	concurrency: S.optional(Wire.mint(S.Union([ConcurrencyCount, ConcurrencyPercent]))),
 	commandRunner: defaulted(CommandRunnerOptionsSchema, { command: "npm test" }),
 	coverageAnalysis: defaulted(CoverageAnalysisMode, RENDERED_OPTION_DEFAULTS$1.coverageAnalysis),
 	clearTextReporter: defaulted(ClearTextReporterOptions, {

package/dist/Schema.mjs

@@ -1,2 +1,2 @@
-import { a as strykerReportBugUrl, c as PackageManager, i as strykerCoreSchema, l as ReportType, o as CoverageAnalysisMode, r as propertyPath, s as LogLevel, t as RENDERED_OPTION_DEFAULTS, u as StrykerOptionsSchema } from "./Schema-BAKDG_jC.mjs";
+import { a as strykerReportBugUrl, c as PackageManager, i as strykerCoreSchema, l as ReportType, o as CoverageAnalysisMode, r as propertyPath, s as LogLevel, t as RENDERED_OPTION_DEFAULTS, u as StrykerOptionsSchema } from "./Schema-CdNkubPi.mjs";
 export { CoverageAnalysisMode, LogLevel, PackageManager, RENDERED_OPTION_DEFAULTS, ReportType, StrykerOptionsSchema, propertyPath, strykerCoreSchema, strykerReportBugUrl };

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 import { i as Checker_d_exports } from "./Checker-DYgIIEai.mjs";
 import { Z as TestRunner_d_exports, v as Mutant_d_exports } from "./Mutant-BPRJTF8f.mjs";
 import { r as Ignorer_d_exports } from "./Ignorer-BUY68FZQ.mjs";
-import { s as Plugin_d_exports } from "./Plugin-HR2dbiT7.mjs";
+import { s as Plugin_d_exports } from "./Plugin-DcDAIBQi.mjs";
 import { u as Reporter_d_exports } from "./Reporter-eZ3M7lO6.mjs";
-import { a as Run_d_exports } from "./Run-BudLsVwF.mjs";
+import { a as Run_d_exports } from "./Run-BnmGGgWj.mjs";
 import { a as Schema_d_exports } from "./Schema-CXKiLnTu.mjs";
 export { Checker_d_exports as Checker, Ignorer_d_exports as Ignorer, Mutant_d_exports as Mutant, Plugin_d_exports as Plugin, Reporter_d_exports as Reporter, Run_d_exports as Run, Schema_d_exports as Schema, TestRunner_d_exports as TestRunner };

package/dist/index.mjs

@@ -3,7 +3,7 @@ import { t as Ignorer_exports } from "./Ignorer.mjs";
 import { t as Mutant_exports } from "./Mutant.mjs";
 import { t as Plugin_exports } from "./Plugin-Ceh1G8Dz.mjs";
 import { n as Reporter_exports } from "./Reporter-COVWW1my.mjs";
-import { r as Run_exports } from "./Run-lXratlN7.mjs";
-import { n as Schema_exports } from "./Schema-BAKDG_jC.mjs";
+import { r as Run_exports } from "./Run-BcDo-hIC.mjs";
+import { n as Schema_exports } from "./Schema-CdNkubPi.mjs";
 import { n as TestRunner_exports } from "./TestRunner-DC9U8Unb.mjs";
 export { Checker_exports as Checker, Ignorer_exports as Ignorer, Mutant_exports as Mutant, Plugin_exports as Plugin, Reporter_exports as Reporter, Run_exports as Run, Schema_exports as Schema, TestRunner_exports as TestRunner };

package/dist/provided-options.d.mts

@@ -1,4 +1,4 @@
-import { c as RunConfiguration } from "./Plugin-HR2dbiT7.mjs";
+import { c as RunConfiguration } from "./Plugin-DcDAIBQi.mjs";
 //#region src/provided-options.d.ts
 /**
  * The run's options exactly as the `RunConfiguration` service hands them over.

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@systemfsoftware/stryker-js",
-  "version": "0.2.0",
+  "version": "2.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
-    "directory": "packages/testing/mutation/stryker-js/stryker-js"
+    "directory": "packages/stryker-js/stryker-js"
   },
-  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/testing/mutation/stryker-js/stryker-js#readme",
+  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/stryker-js/stryker-js#readme",
   "bugs": "https://github.com/systemfsoftware/systemfsoftware/issues",
   "description": "The mutation-testing language — concept modules, no platform.",
   "type": "module",
@@ -20,7 +20,7 @@
   "dependencies": {
     "effect": "^4.0.0-rc.112",
     "mutation-testing-report-schema": "3.7.3",
-    "@systemfsoftware/effect-cell-types": "^5.0.2"
+    "@systemfsoftware/effect-cell-types": "^6.0.1"
   },
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
@@ -31,11 +31,11 @@
     "tsdown": "^0.22.14",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/effect-schema-law": "^2.0.1",
-    "@systemfsoftware/effect-schema-vite": "^2.0.2",
-    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@systemfsoftware/all": "^1.1.3",
+    "@systemfsoftware/effect-schema-vite": "^2.0.3",
     "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/all": "^1.1.0"
+    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@systemfsoftware/effect-schema-law": "^2.0.2"
   },
   "publishConfig": {
     "access": "public",

package/dist/ExitClass.schema-BmCUn2Sm.d.mts

@@ -1,6 +0,0 @@
-import * as S from "effect/Schema";
-//#region src/ExitClass.schema.d.ts
-declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
-type ExitClass = typeof ExitClass.Type;
-//#endregion
-export { ExitClass as t };