@systemfsoftware/stryker-js 2.0.0 → 3.0.1

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 { a as Schema_d_exports } from "./Schema-4oCWQ0P0.mjs";
+import { s as Plugin_d_exports } from "./Plugin-BtItMchw.mjs";
+import { n as Reporter_d_exports } from "./Reporter-C7ysGxqX.mjs";
+import { a as Run_d_exports } from "./Run-BUpNSmcM.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 { n as Schema_exports } from "./Schema-CdNkubPi.mjs";
-import { n as TestRunner_exports } from "./TestRunner-DC9U8Unb.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-CMKdWMUN.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-BtItMchw.mjs";
 //#region src/provided-options.d.ts
 /**
  * The run's options exactly as the `RunConfiguration` service hands them over.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -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.1"
+    "effect": "4.0.0-rc.112",
+    "@systemfsoftware/effect-cell-types": "^7.0.0"
   },
   "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/all": "^1.1.3",
-    "@systemfsoftware/effect-schema-vite": "^2.0.3",
+    "@systemfsoftware/all": "^2.0.0",
+    "@systemfsoftware/effect-schema-law": "^2.1.0",
     "@systemfsoftware/tsconfig": "^1.3.3",
     "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/effect-schema-law": "^2.0.2"
+    "@systemfsoftware/effect-schema-vite": "^2.1.0"
   },
   "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 };

package/dist/Run-BcDo-hIC.mjs

@@ -1,199 +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";
-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([
-	"prepare",
-	"instrument",
-	"dry-run",
-	"mutation-test"
-]);
-const OutputMode = S.Literals(["human", "machine"]);
-const ModeSignal = S.Literals([
-	"flag",
-	"env",
-	"tty",
-	"agent",
-	"tool"
-]);
-const MutantStatus = S.Literals([
-	"Killed",
-	"Survived",
-	"NoCoverage",
-	"Timeout",
-	"CompileError",
-	"RuntimeError",
-	"Ignored",
-	"Pending"
-]);
-const Position = Wire.wire({
-	line: Wire.mint(S.Finite),
-	column: Wire.mint(S.Finite)
-});
-const Location = Wire.wire({
-	start: Position,
-	end: Position
-});
-var RunStarted = class extends S.TaggedClass()("stream", {
-	schemaVersion: Wire.mint(S.String),
-	runId: Wire.mint(S.String),
-	mode: OutputMode,
-	signal: ModeSignal
-}) {};
-var PhaseEntered = class extends S.TaggedClass()("phase", {
-	phase: RunPhase,
-	elapsedMs: Wire.mint(S.Finite)
-}) {};
-var PlanKnown = class extends S.TaggedClass()("plan", { total: Wire.mint(S.Finite) }) {};
-var MutantTested = class extends S.TaggedClass()("mutant", {
-	id: Wire.mint(S.String),
-	status: MutantStatus,
-	file: Wire.mint(S.String),
-	location: Location,
-	mutator: Wire.mint(S.String),
-	replacement: Wire.mint(S.NullOr(Wire.mint(S.String))),
-	completed: Wire.mint(S.Finite),
-	total: Wire.mint(S.Finite)
-}) {};
-var Heartbeat = class extends S.TaggedClass()("tick", {
-	elapsedMs: Wire.mint(S.Finite),
-	completed: Wire.mint(S.Finite),
-	total: Wire.mint(S.NullOr(Wire.mint(S.Finite)))
-}) {};
-const VerdictThresholds = Wire.wire({
-	high: Wire.mint(S.Finite),
-	low: Wire.mint(S.Finite),
-	break: Wire.mint(S.NullOr(Wire.mint(S.Finite)))
-});
-const VerdictMutant = S.Struct({
-	id: Wire.mint(S.String),
-	file: Wire.mint(S.String),
-	location: Location,
-	mutator: Wire.mint(S.String),
-	replacement: Wire.mint(S.NullOr(Wire.mint(S.String))),
-	status: MutantStatus
-});
-const VerdictCounts = Wire.wire({
-	killed: Wire.mint(S.Finite),
-	timeout: Wire.mint(S.Finite),
-	survived: Wire.mint(S.Finite),
-	noCoverage: Wire.mint(S.Finite),
-	runtimeErrors: Wire.mint(S.Finite),
-	compileErrors: Wire.mint(S.Finite),
-	ignored: Wire.mint(S.Finite),
-	pending: Wire.mint(S.Finite)
-});
-var VerdictReached = class extends S.TaggedClass()("verdict", {
-	schemaVersion: Wire.mint(S.String),
-	runId: Wire.mint(S.String),
-	mode: OutputMode,
-	signal: ModeSignal,
-	score: Wire.mint(S.NullOr(Wire.mint(S.Finite))),
-	thresholds: VerdictThresholds,
-	reportFile: Wire.mint(S.NullOr(Wire.mint(S.String))),
-	counts: VerdictCounts,
-	mutants: S.Array(VerdictMutant)
-}) {};
-var RunFailed = class extends S.TaggedClass()("error", {
-	schemaVersion: Wire.mint(S.String),
-	code: Wire.mint(S.Finite),
-	error: Wire.mint(S.String),
-	remediation: Wire.mint(S.String)
-}) {};
-var HelpRendered = class extends S.TaggedClass()("help", {
-	schemaVersion: Wire.mint(S.String),
-	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,
-	PlanKnown,
-	MutantTested,
-	Heartbeat,
-	VerdictReached,
-	RunFailed,
-	HelpRendered,
-	ManifestRendered
-]);
-S.TaggedClass()("RunCommand", {
-	cliOptionsJson: S.String,
-	targetMutatePatterns: S.Array(S.String)
-});
-var RunOutput = class extends S.TaggedClass()("RunOutput", {
-	verdictJson: S.String,
-	exitCode: S.Finite
-}) {};
-S.TaggedError()("RunDecodeError", { message: S.String });
-S.TaggedError()("RunReadError", { message: S.String });
-S.TaggedError()("RunWriteError", { message: S.String });
-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))),
-	targetMutatePatterns: Wire.mint(S.Array(Wire.mint(S.String))),
-	availableMutators: Wire.mint(S.Array(Wire.mint(S.String)))
-}) {};
-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)))
-}) {};
-//#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 };