@systemfsoftware/stryker-js 1.0.0 → 3.0.0

package/dist/Run.mjs

@@ -1,2 +1,56 @@
-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 };
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as MutantTested, c as PhaseEntered, d as RunEvent, f as RunFailed, g as VerdictReached, h as RunStarted, i as MutantStatus, l as PlanKnown, m as RunPhase, n as HelpRendered, o as MutationRunPlan, p as RunOutput, r as ModeSignal, s as OutputMode, t as Heartbeat, u as PlanMutationRunCommand } from "./Run.schema-C4m-b9Ki.mjs";
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Result from "effect/Result";
+//#region src/Run.ts
+var Run_exports = /* @__PURE__ */ __exportAll({
+	Heartbeat: () => Heartbeat,
+	HelpRendered: () => HelpRendered,
+	ModeSignal: () => ModeSignal,
+	MutantStatus: () => MutantStatus,
+	MutantTested: () => MutantTested,
+	OutputMode: () => OutputMode,
+	PhaseEntered: () => PhaseEntered,
+	PlanKnown: () => PlanKnown,
+	RunEvent: () => RunEvent,
+	RunEvents: () => RunEvents,
+	RunFailed: () => RunFailed,
+	RunIdentity: () => RunIdentity,
+	RunPhase: () => RunPhase,
+	RunStarted: () => RunStarted,
+	VerdictReached: () => VerdictReached,
+	planMutationRun: () => planMutationRun,
+	runMutationTest: () => runMutationTest,
+	shouldKeepTempDir: () => shouldKeepTempDir
+});
+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 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,
+			mutatorNames: plan.mutatorNames
+		}),
+		exitCode: 0
+	}));
+});
+const shouldKeepTempDir = (exit, cleanTempDir) => Exit.isFailure(exit) && cleanTempDir !== "always";
+//#endregion
+export { Heartbeat, HelpRendered, ModeSignal, MutantStatus, MutantTested, OutputMode, PhaseEntered, PlanKnown, RunEvent, RunEvents, RunFailed, RunIdentity, RunPhase, RunStarted, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir, Run_exports as t };

package/dist/{Run-BcDo-hIC.mjs → Run.schema-C4m-b9Ki.mjs}

@@ -1,9 +1,4 @@
-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 * as Exit from "effect/Exit";
-import * as Result from "effect/Result";
 import { Wire } from "@systemfsoftware/effect-cell-types";
 //#region src/Run.schema.ts
 const RunPhase = S.Literals([
@@ -109,11 +104,6 @@ var HelpRendered = class extends S.TaggedClass()("help", {
 	code: Wire.mint(S.Literals([0])),
 	help: Wire.mint(S.String)
 }) {};
-var ManifestRendered = class extends S.TaggedClass()("manifest", {
-	schemaVersion: Wire.mint(S.String),
-	code: Wire.mint(S.Literals([0])),
-	manifest: Wire.mint(S.String)
-}) {};
 const RunEvent = S.Union([
 	RunStarted,
 	PhaseEntered,
@@ -122,8 +112,7 @@ const RunEvent = S.Union([
 	Heartbeat,
 	VerdictReached,
 	RunFailed,
-	HelpRendered,
-	ManifestRendered
+	HelpRendered
 ]);
 S.TaggedClass()("RunCommand", {
 	cliOptionsJson: S.String,
@@ -147,53 +136,4 @@ var MutationRunPlan = class extends S.TaggedClass()("MutationRunPlan", {
 	mutatorNames: Wire.mint(S.Array(Wire.mint(S.String)))
 }) {};
 //#endregion
-//#region src/Run.ts
-var Run_exports = /* @__PURE__ */ __exportAll({
-	Heartbeat: () => Heartbeat,
-	HelpRendered: () => HelpRendered,
-	ManifestRendered: () => ManifestRendered,
-	ModeSignal: () => ModeSignal,
-	MutantStatus: () => MutantStatus,
-	MutantTested: () => MutantTested,
-	OutputMode: () => OutputMode,
-	PhaseEntered: () => PhaseEntered,
-	PlanKnown: () => PlanKnown,
-	RunEvent: () => RunEvent,
-	RunEvents: () => RunEvents,
-	RunFailed: () => RunFailed,
-	RunIdentity: () => RunIdentity,
-	RunPhase: () => RunPhase,
-	RunStarted: () => RunStarted,
-	VerdictReached: () => VerdictReached,
-	planMutationRun: () => planMutationRun,
-	runMutationTest: () => runMutationTest,
-	shouldKeepTempDir: () => shouldKeepTempDir
-});
-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 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,
-			mutatorNames: plan.mutatorNames
-		}),
-		exitCode: 0
-	}));
-});
-const shouldKeepTempDir = (exit, cleanTempDir) => Exit.isFailure(exit) && cleanTempDir !== "always";
-//#endregion
-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 };
+export { MutantTested as a, PhaseEntered as c, RunEvent as d, RunFailed as f, VerdictReached as g, RunStarted as h, MutantStatus as i, PlanKnown as l, RunPhase as m, HelpRendered as n, MutationRunPlan as o, RunOutput as p, ModeSignal as r, OutputMode as s, Heartbeat as t, PlanMutationRunCommand as u };

package/dist/TestRunner.d.mts

@@ -1,2 +1,2 @@
-import { $ as TimeoutMutantRunResult, A as CompleteDryRunResult, B as MutantRunOptions, F as ErrorMutantRunResult, G as SuccessTestResult, H as Position, I as FailedTestResult, J as TestRunner, K as SurvivedMutantRunResult, L as KilledMutantRunResult, M as DryRunOptions, N as DryRunResult, P as ErrorDryRunResult, Q as TimeoutDryRunResult, R as MutantActivation, U as RunOptions, V as MutantRunResult, W as SkippedTestResult, X as TestRunnerService, Y as TestRunnerCapabilities, at as DryRunStatus, ct as MutantRunOptionsSchema, dt as TestResultSchema, et as testFilesProvided, ft as TestRunnerCapabilitiesSchema, it as DryRunResultSchema, j as CoverageAnalysis, k as BaseTestResult, lt as MutantRunResultSchema, mt as TestStatus, nt as CoverageAnalysisSchema, ot as MutantActivationSchema, pt as TestRunnerFailed, q as TestResult, rt as DryRunOptionsSchema, st as MutantCoverageSchema, tt as toMutantRunResult, ut as MutantRunStatus, z as MutantCoverage } from "./Mutant-BPRJTF8f.mjs";
+import { $ as testFilesProvided, A as CoverageAnalysis, B as MutantRunResult, F as FailedTestResult, G as SurvivedMutantRunResult, H as RunOptions, I as KilledMutantRunResult, J as TestRunnerCapabilities, K as TestResult, L as MutantActivation, M as DryRunResult, N as ErrorDryRunResult, O as BaseTestResult, P as ErrorMutantRunResult, Q as TimeoutMutantRunResult, R as MutantCoverage, U as SkippedTestResult, V as Position, W as SuccessTestResult, Y as TestRunnerService, Z as TimeoutDryRunResult, at as MutantActivationSchema, ct as MutantRunResultSchema, dt as TestRunnerCapabilitiesSchema, et as toMutantRunResult, ft as TestRunnerFailed, it as DryRunStatus, j as DryRunOptions, k as CompleteDryRunResult, lt as MutantRunStatus, nt as DryRunOptionsSchema, ot as MutantCoverageSchema, pt as TestStatus, q as TestRunner, rt as DryRunResultSchema, st as MutantRunOptionsSchema, tt as CoverageAnalysisSchema, ut as TestResultSchema, z as MutantRunOptions } from "./Mutant-Ci25PsWA.mjs";
 export { BaseTestResult, CompleteDryRunResult, CoverageAnalysis, CoverageAnalysisSchema, DryRunOptions, DryRunOptionsSchema, DryRunResult, DryRunResultSchema, DryRunStatus, ErrorDryRunResult, ErrorMutantRunResult, FailedTestResult, KilledMutantRunResult, MutantActivation, MutantActivationSchema, MutantCoverage, MutantCoverageSchema, MutantRunOptions, MutantRunOptionsSchema, MutantRunResult, MutantRunResultSchema, MutantRunStatus, Position, RunOptions, SkippedTestResult, SuccessTestResult, SurvivedMutantRunResult, TestResult, TestResultSchema, TestRunner, TestRunnerCapabilities, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestRunnerService, TestStatus, TimeoutDryRunResult, TimeoutMutantRunResult, testFilesProvided, toMutantRunResult };

package/dist/TestRunner.mjs

@@ -1,2 +1,57 @@
-import { _ as TestStatus, a as CoverageAnalysisSchema, c as DryRunStatus, d as MutantRunOptionsSchema, f as MutantRunResultSchema, g as TestRunnerFailed, h as TestRunnerCapabilitiesSchema, i as toMutantRunResult, l as MutantActivationSchema, m as TestResultSchema, o as DryRunOptionsSchema, p as MutantRunStatus, r as testFilesProvided, s as DryRunResultSchema, t as TestRunner, u as MutantCoverageSchema } from "./TestRunner-DC9U8Unb.mjs";
-export { CoverageAnalysisSchema, DryRunOptionsSchema, DryRunResultSchema, DryRunStatus, MutantActivationSchema, MutantCoverageSchema, MutantRunOptionsSchema, MutantRunResultSchema, MutantRunStatus, TestResultSchema, TestRunner, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestStatus, testFilesProvided, toMutantRunResult };
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as MutantActivationSchema, c as MutantRunResultSchema, d as TestRunnerCapabilitiesSchema, f as TestRunnerFailed, i as DryRunStatus, l as MutantRunStatus, n as DryRunOptionsSchema, o as MutantCoverageSchema, p as TestStatus, r as DryRunResultSchema, s as MutantRunOptionsSchema, t as CoverageAnalysisSchema, u as TestResultSchema } from "./TestRunner.schema-Dy0Wdro2.mjs";
+import * as Context from "effect/Context";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+//#region src/TestRunner.ts
+var TestRunner_exports = /* @__PURE__ */ __exportAll({
+	CoverageAnalysisSchema: () => CoverageAnalysisSchema,
+	DryRunOptionsSchema: () => DryRunOptionsSchema,
+	DryRunResultSchema: () => DryRunResultSchema,
+	DryRunStatus: () => DryRunStatus,
+	MutantActivationSchema: () => MutantActivationSchema,
+	MutantCoverageSchema: () => MutantCoverageSchema,
+	MutantRunOptionsSchema: () => MutantRunOptionsSchema,
+	MutantRunResultSchema: () => MutantRunResultSchema,
+	MutantRunStatus: () => MutantRunStatus,
+	TestResultSchema: () => TestResultSchema,
+	TestRunner: () => TestRunner,
+	TestRunnerCapabilitiesSchema: () => TestRunnerCapabilitiesSchema,
+	TestRunnerFailed: () => TestRunnerFailed,
+	TestStatus: () => TestStatus,
+	testFilesProvided: () => testFilesProvided,
+	toMutantRunResult: () => toMutantRunResult
+});
+function toMutantRunResult(dryRunResult, reportAllKillers) {
+	return Match.value(dryRunResult).pipe(Match.discriminator("status")("complete", (complete) => {
+		const failed = complete.tests.filter((t) => t.status === "failed");
+		const nrOfTests = complete.tests.filter((t) => t.status !== "skipped").length;
+		return Option.match(Option.fromUndefinedOr(failed.at(0)), {
+			onNone: () => ({
+				nrOfTests,
+				status: "survived"
+			}),
+			onSome: (firstFailed) => ({
+				failureMessage: firstFailed.failureMessage,
+				killedBy: Match.value(reportAllKillers).pipe(Match.when(true, () => failed.map((t) => t.id)), Match.when(false, () => [firstFailed.id]), Match.exhaustive),
+				nrOfTests,
+				status: "killed"
+			})
+		});
+	}), Match.discriminator("status")("error", (errored) => ({
+		errorMessage: errored.errorMessage,
+		status: "error"
+	})), Match.discriminator("status")("timeout", (timedOut) => Option.match(Option.fromUndefinedOr(timedOut.reason), {
+		onNone: () => ({ status: "timeout" }),
+		onSome: (reason) => ({
+			reason,
+			status: "timeout"
+		})
+	})), Match.exhaustive);
+}
+var TestRunner = class extends Context.Service()("~@systemfsoftware/stryker-js/TestRunner") {};
+function testFilesProvided(options) {
+	return options.testFiles !== void 0 && options.testFiles.length > 0;
+}
+//#endregion
+export { CoverageAnalysisSchema, DryRunOptionsSchema, DryRunResultSchema, DryRunStatus, MutantActivationSchema, MutantCoverageSchema, MutantRunOptionsSchema, MutantRunResultSchema, MutantRunStatus, TestResultSchema, TestRunner, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestStatus, TestRunner_exports as t, testFilesProvided, toMutantRunResult };

package/dist/{TestRunner-DC9U8Unb.mjs → TestRunner.schema-Dy0Wdro2.mjs}

@@ -1,6 +1,4 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { n as Mutant, r as PositionSchema } from "./Mutant.schema-BTWhFTk4.mjs";
-import * as Context from "effect/Context";
+import { n as Mutant, r as PositionSchema } from "./Mutant.schema-H3r0ho_R.mjs";
 import * as S from "effect/Schema";
 //#region src/TestRunner.schema.ts
 const DryRunStatus = S.Literals([
@@ -118,64 +116,4 @@ var TestRunnerFailed = class extends S.TaggedError()("TestRunnerFailed", {
 	runnerName: S.String
 }) {};
 //#endregion
-//#region src/TestRunner.ts
-var TestRunner_exports = /* @__PURE__ */ __exportAll({
-	CoverageAnalysisSchema: () => CoverageAnalysisSchema,
-	DryRunOptionsSchema: () => DryRunOptionsSchema,
-	DryRunResultSchema: () => DryRunResultSchema,
-	DryRunStatus: () => DryRunStatus,
-	MutantActivationSchema: () => MutantActivationSchema,
-	MutantCoverageSchema: () => MutantCoverageSchema,
-	MutantRunOptionsSchema: () => MutantRunOptionsSchema,
-	MutantRunResultSchema: () => MutantRunResultSchema,
-	MutantRunStatus: () => MutantRunStatus,
-	TestResultSchema: () => TestResultSchema,
-	TestRunner: () => TestRunner,
-	TestRunnerCapabilitiesSchema: () => TestRunnerCapabilitiesSchema,
-	TestRunnerFailed: () => TestRunnerFailed,
-	TestStatus: () => TestStatus,
-	testFilesProvided: () => testFilesProvided,
-	toMutantRunResult: () => toMutantRunResult
-});
-function toMutantRunResult(dryRunResult, reportAllKillers) {
-	switch (dryRunResult.status) {
-		case "timeout":
-			if (dryRunResult.reason === void 0) return { status: "timeout" };
-			return {
-				reason: dryRunResult.reason,
-				status: "timeout"
-			};
-		case "error": return {
-			errorMessage: dryRunResult.errorMessage,
-			status: "error"
-		};
-		case "complete": {
-			const failed = dryRunResult.tests.filter((t) => t.status === "failed");
-			const nrOfTests = dryRunResult.tests.filter((t) => t.status !== "skipped").length;
-			if (failed.length === 0) return {
-				nrOfTests,
-				status: "survived"
-			};
-			const firstFailed = failed.at(0);
-			if (firstFailed === void 0) return {
-				nrOfTests,
-				status: "survived"
-			};
-			let killedBy;
-			if (reportAllKillers) killedBy = failed.map((t) => t.id);
-			else killedBy = [firstFailed.id];
-			return {
-				failureMessage: firstFailed.failureMessage,
-				killedBy,
-				nrOfTests,
-				status: "killed"
-			};
-		}
-	}
-}
-var TestRunner = class extends Context.Service()("~@systemfsoftware/stryker-js/TestRunner") {};
-function testFilesProvided(options) {
-	return options.testFiles !== void 0 && options.testFiles.length > 0;
-}
-//#endregion
-export { TestStatus as _, CoverageAnalysisSchema as a, DryRunStatus as c, MutantRunOptionsSchema as d, MutantRunResultSchema as f, TestRunnerFailed as g, TestRunnerCapabilitiesSchema as h, toMutantRunResult as i, MutantActivationSchema as l, TestResultSchema as m, TestRunner_exports as n, DryRunOptionsSchema as o, MutantRunStatus as p, testFilesProvided as r, DryRunResultSchema as s, TestRunner as t, MutantCoverageSchema as u };
+export { MutantActivationSchema as a, MutantRunResultSchema as c, TestRunnerCapabilitiesSchema as d, TestRunnerFailed as f, DryRunStatus as i, MutantRunStatus as l, DryRunOptionsSchema as n, MutantCoverageSchema as o, TestStatus as p, DryRunResultSchema as r, MutantRunOptionsSchema as s, CoverageAnalysisSchema as t, TestResultSchema as u };

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 { i as Checker_d_exports } from "./Checker-A8o5B3Ub.mjs";
+import { X as TestRunner_d_exports, v as Mutant_d_exports } from "./Mutant-Ci25PsWA.mjs";
 import { r as Ignorer_d_exports } from "./Ignorer-BUY68FZQ.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-BnmGGgWj.mjs";
 import { a as Schema_d_exports } from "./Schema-CXKiLnTu.mjs";
+import { s as Plugin_d_exports } from "./Plugin-CunIOPtw.mjs";
+import { n as Reporter_d_exports } from "./Reporter-BU7qo6MR.mjs";
+import { a as Run_d_exports } from "./Run-CnhaYlAC.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

@@ -1,9 +1,9 @@
 import { n as Checker_exports } from "./Checker-Bq8NXD8d.mjs";
 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-BcDo-hIC.mjs";
+import { t as Plugin_exports } from "./Plugin-DXFdJP1l.mjs";
+import { n as Reporter_exports } from "./Reporter-BWTwlSJf.mjs";
+import { t as Run_exports } from "./Run.mjs";
 import { n as Schema_exports } from "./Schema-CdNkubPi.mjs";
-import { n as TestRunner_exports } from "./TestRunner-DC9U8Unb.mjs";
+import { t as TestRunner_exports } from "./TestRunner.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-DcDAIBQi.mjs";
+import { c as RunConfiguration } from "./Plugin-CunIOPtw.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": "1.0.0",
+  "version": "3.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",
@@ -18,11 +18,11 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "effect": "^4.0.0-rc.112",
-    "mutation-testing-report-schema": "3.7.3",
-    "@systemfsoftware/effect-cell-types": "^6.0.0"
+    "effect": "4.0.0-rc.112",
+    "@systemfsoftware/effect-cell-types": "^6.0.1"
   },
   "devDependencies": {
+    "@effect/vitest": "4.0.0-rc.112",
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
     "@types/node": "^24",
     "oxlint": "^1.77.0",
@@ -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/all": "^1.1.2",
+    "@systemfsoftware/all": "^2.0.0",
+    "@systemfsoftware/effect-schema-law": "^2.0.2",
+    "@systemfsoftware/vitest-config": "^0.1.0",
     "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/vitest-config": "^0.1.0"
+    "@systemfsoftware/effect-schema-vite": "^2.0.3"
   },
   "publishConfig": {
     "access": "public",
@@ -47,12 +47,15 @@
     "./Evaluator": "./dist/Evaluator.mjs",
     "./ExitClass": "./dist/ExitClass.mjs",
     "./Ignorer": "./dist/Ignorer.mjs",
+    "./Metrics": "./dist/Metrics.mjs",
     "./Module": "./dist/Module.mjs",
     "./Mutant": "./dist/Mutant.mjs",
     "./output-file": "./dist/output-file.mjs",
     "./Plugin": "./dist/Plugin.mjs",
     "./provided-options": "./dist/provided-options.mjs",
+    "./Report": "./dist/Report.mjs",
     "./Reporter": "./dist/Reporter.mjs",
+    "./ReporterEvent": "./dist/ReporterEvent.mjs",
     "./Run": "./dist/Run.mjs",
     "./Schema": "./dist/Schema.mjs",
     "./TestRunner": "./dist/TestRunner.mjs",

package/dist/Plugin-Ceh1G8Dz.mjs

@@ -1,117 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { t as Reporter } from "./Reporter-COVWW1my.mjs";
-import * as Context from "effect/Context";
-import * as S from "effect/Schema";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as MutableHashMap from "effect/MutableHashMap";
-import * as Option from "effect/Option";
-//#region src/Plugin.schema.ts
-const PluginKind = S.Literals([
-	"Checker",
-	"TestRunner",
-	"Reporter",
-	"Ignore",
-	"Evaluator"
-]);
-var PluginContribution = class extends S.TaggedClass()("PluginContribution", {
-	kind: PluginKind,
-	name: S.String,
-	layer: S.Unknown
-}) {};
-var Shadowing = class extends S.TaggedClass()("Shadowing", {
-	kind: S.String,
-	name: S.String,
-	shadowedIndex: S.Finite,
-	winnerIndex: S.Finite
-}) {};
-//#endregion
-//#region src/Plugin.ts
-var Plugin_exports = /* @__PURE__ */ __exportAll({
-	PluginContribution: () => PluginContribution,
-	PluginKind: () => PluginKind,
-	RunConfiguration: () => RunConfiguration,
-	SandboxDirectory: () => SandboxDirectory,
-	Shadowing: () => Shadowing,
-	composePlugins: () => composePlugins,
-	declarePlugin: () => declarePlugin
-});
-var RunConfiguration = class extends Context.Service()("~@systemfsoftware/stryker-js/RunConfiguration") {};
-var SandboxDirectory = class extends Context.Service()("~@systemfsoftware/stryker-js/SandboxDirectory") {};
-function declarePlugin(kind, name, layer) {
-	return new PluginContribution({
-		kind,
-		name,
-		layer
-	});
-}
-function foldContributions(contributions) {
-	const resolved = MutableHashMap.empty();
-	const shadowings = [];
-	const lastSeen = MutableHashMap.empty();
-	for (const [index, contribution] of contributions.entries()) {
-		const key = `${contribution.kind}:${contribution.name}`;
-		const previous = MutableHashMap.get(lastSeen, key);
-		if (Option.isSome(previous)) shadowings.push(new Shadowing({
-			kind: String(contribution.kind),
-			name: contribution.name,
-			shadowedIndex: previous.value,
-			winnerIndex: index
-		}));
-		MutableHashMap.set(resolved, key, contribution);
-		MutableHashMap.set(lastSeen, key, index);
-	}
-	return {
-		resolved,
-		shadowings
-	};
-}
-function composePlugins(contributions) {
-	const { resolved, shadowings } = foldContributions(contributions);
-	const allResolved = Array.from(MutableHashMap.values(resolved));
-	const reporterContributions = allResolved.filter((c) => c.kind === "Reporter");
-	const nonReporterLayers = allResolved.filter((c) => c.kind !== "Reporter").map((contribution) => contribution.layer);
-	let broadcastLayer;
-	if (reporterContributions.length > 0) broadcastLayer = Layer.effect(Reporter, Effect.gen(function* () {
-		const config = yield* RunConfiguration;
-		const wantedNames = {};
-		for (const name of config.reporters) wantedNames[name.toLowerCase()] = true;
-		const selected = reporterContributions.filter((c) => c.name.toLowerCase() in wantedNames);
-		const sandboxOption = yield* Effect.serviceOption(SandboxDirectory);
-		const namedReporters = [];
-		for (const contribution of selected) {
-			let buildEffect = Layer.build(contribution.layer).pipe(Effect.provideService(RunConfiguration, config));
-			if (Option.isSome(sandboxOption)) buildEffect = buildEffect.pipe(Effect.provideService(SandboxDirectory, sandboxOption.value));
-			const ctx = yield* buildEffect;
-			const reporter = Context.get(ctx, Reporter);
-			namedReporters.push({
-				name: contribution.name,
-				reporter
-			});
-		}
-		const toEach = (event, call) => Effect.forEach(namedReporters, ({ name, reporter }) => call(reporter).pipe(Effect.catchCause((cause) => Effect.logWarning(`Reporter "${name}" failed handling ${event}`).pipe(Effect.annotateLogs("cause", cause)))), {
-			concurrency: "unbounded",
-			discard: true
-		});
-		return {
-			onDryRunCompleted: (event) => toEach("onDryRunCompleted", (r) => r.onDryRunCompleted(event)),
-			onMutationTestingPlanReady: (event) => toEach("onMutationTestingPlanReady", (r) => r.onMutationTestingPlanReady(event)),
-			onMutantTested: (result) => toEach("onMutantTested", (r) => r.onMutantTested(result)),
-			onMutationTestReportReady: (report, metrics) => toEach("onMutationTestReportReady", (r) => r.onMutationTestReportReady(report, metrics)),
-			wrapUp: toEach("wrapUp", (r) => r.wrapUp)
-		};
-	}));
-	const allLayers = [...nonReporterLayers];
-	if (broadcastLayer !== void 0) allLayers.push(broadcastLayer);
-	if (allLayers.length === 0) return {
-		layer: Option.none(),
-		shadowings
-	};
-	const merged = allLayers.reduce((acc, next) => Layer.merge(acc, next));
-	return {
-		layer: Option.some(merged),
-		shadowings
-	};
-}
-//#endregion
-export { declarePlugin as a, Shadowing as c, composePlugins as i, RunConfiguration as n, PluginContribution as o, SandboxDirectory as r, PluginKind as s, Plugin_exports as t };

package/dist/Reporter-COVWW1my.mjs

@@ -1,33 +0,0 @@
-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";
-//#region src/Reporter.schema.ts
-var ReporterFailed = class extends S.TaggedError()("ReporterFailed", {
-	cause: S.String,
-	event: S.Literals([
-		"onDryRunCompleted",
-		"onMutationTestingPlanReady",
-		"onMutantTested",
-		"onMutationTestReportReady",
-		"wrapUp"
-	]),
-	reporterName: S.String
-}) {};
-//#endregion
-//#region src/Reporter.ts
-var Reporter_exports = /* @__PURE__ */ __exportAll({
-	Reporter: () => Reporter,
-	ReporterFailed: () => ReporterFailed,
-	broadcastReporter: () => broadcastReporter
-});
-var Reporter = class extends Context.Service()("~@systemfsoftware/stryker-js/Reporter") {};
-const broadcastReporter = (reporters) => ({
-	onDryRunCompleted: (event) => Effect.forEach(reporters, (r) => r.reporter.onDryRunCompleted(event), { discard: true }),
-	onMutationTestingPlanReady: (event) => Effect.forEach(reporters, (r) => r.reporter.onMutationTestingPlanReady(event), { discard: true }),
-	onMutantTested: (result) => Effect.forEach(reporters, (r) => r.reporter.onMutantTested(result), { discard: true }),
-	onMutationTestReportReady: (report, metrics) => Effect.forEach(reporters, (r) => r.reporter.onMutationTestReportReady(report, metrics), { discard: true }),
-	wrapUp: Effect.forEach(reporters, (r) => r.reporter.wrapUp, { discard: true }).pipe(Effect.asVoid)
-});
-//#endregion
-export { ReporterFailed as i, Reporter_exports as n, broadcastReporter as r, Reporter as t };

package/dist/Reporter-eZ3M7lO6.d.mts

@@ -1,83 +0,0 @@
-import { S as TestPlan, p as MutantResult } from "./Mutant-BPRJTF8f.mjs";
-import * as Context from "effect/Context";
-import * as S from "effect/Schema";
-import * as schema from "mutation-testing-report-schema/api";
-import * as Effect from "effect/Effect";
-//#region src/Reporter.schema.d.ts
-declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"ReporterFailed", {
-  readonly cause: S.String;
-  readonly event: S.Literals<readonly ["onDryRunCompleted", "onMutationTestingPlanReady", "onMutantTested", "onMutationTestReportReady", "wrapUp"]>;
-  readonly reporterName: S.String;
-}>, import("effect/Cause").YieldableError>;
-declare class ReporterFailed extends ReporterFailed_base {}
-declare namespace Reporter_d_exports {
-  export { CompleteDryRunResultForReporter, DryRunCompletedEvent, Metrics, MetricsResult, MutationTestMetricsResult, MutationTestingPlanReadyEvent, NamedReporter, Reporter, ReporterFailed, ReporterService, RunTiming, TestMetrics, TestRunnerCapabilities, broadcastReporter };
-}
-interface Metrics {
-  readonly pending: number;
-  readonly killed: number;
-  readonly timeout: number;
-  readonly survived: number;
-  readonly noCoverage: number;
-  readonly runtimeErrors: number;
-  readonly compileErrors: number;
-  readonly ignored: number;
-  readonly totalDetected: number;
-  readonly totalUndetected: number;
-  readonly totalInvalid: number;
-  readonly totalValid: number;
-  readonly totalMutants: number;
-  readonly totalCovered: number;
-  readonly mutationScore: number;
-  readonly mutationScoreBasedOnCoveredCode: number;
-}
-interface TestMetrics {
-  readonly total: number;
-  readonly killing: number;
-  readonly covering: number;
-  readonly notCovering: number;
-}
-interface MetricsResult<TMetrics> {
-  readonly name: string;
-  readonly metrics: TMetrics;
-  readonly childResults: readonly MetricsResult<TMetrics>[];
-}
-interface MutationTestMetricsResult {
-  readonly systemUnderTestMetrics: MetricsResult<Metrics>;
-  readonly testMetrics: MetricsResult<TestMetrics> | undefined;
-}
-interface RunTiming {
-  readonly net: number;
-  readonly overhead: number;
-}
-interface CompleteDryRunResultForReporter {
-  readonly tests: readonly unknown[];
-  readonly status: 'complete';
-}
-interface TestRunnerCapabilities {
-  readonly reloadEnvironment: boolean;
-}
-interface DryRunCompletedEvent {
-  readonly result: CompleteDryRunResultForReporter;
-  readonly timing: RunTiming;
-  readonly capabilities: TestRunnerCapabilities;
-}
-interface MutationTestingPlanReadyEvent {
-  readonly mutantPlans: readonly TestPlan[];
-}
-interface ReporterService {
-  readonly onDryRunCompleted: (event: DryRunCompletedEvent) => Effect.Effect<void, ReporterFailed>;
-  readonly onMutationTestingPlanReady: (event: MutationTestingPlanReadyEvent) => Effect.Effect<void, ReporterFailed>;
-  readonly onMutantTested: (result: Readonly<MutantResult>) => Effect.Effect<void, ReporterFailed>;
-  readonly onMutationTestReportReady: (report: Readonly<schema.MutationTestResult>, metrics: Readonly<MutationTestMetricsResult>) => Effect.Effect<void, ReporterFailed>;
-  readonly wrapUp: Effect.Effect<void, ReporterFailed>;
-}
-interface NamedReporter {
-  readonly name: string;
-  readonly reporter: ReporterService;
-}
-declare const Reporter_base: Context.ServiceClass<Reporter, "~@systemfsoftware/stryker-js/Reporter", ReporterService>;
-declare class Reporter extends Reporter_base {}
-declare const broadcastReporter: (reporters: readonly NamedReporter[]) => ReporterService;
-//#endregion
-export { MutationTestMetricsResult as a, Reporter as c, RunTiming as d, TestMetrics as f, ReporterFailed as h, MetricsResult as i, ReporterService as l, broadcastReporter as m, DryRunCompletedEvent as n, MutationTestingPlanReadyEvent as o, TestRunnerCapabilities as p, Metrics as r, NamedReporter as s, CompleteDryRunResultForReporter as t, Reporter_d_exports as u };