@systemfsoftware/stryker-js 2.0.0 → 3.0.0

package/dist/ReporterEvent.mjs

@@ -0,0 +1,58 @@
+import { t as LocationSchema } from "./Mutant.schema-H3r0ho_R.mjs";
+import { MutationTestResultSchema } from "./Report.mjs";
+import { t as MetricsResultSchema } from "./Metrics.schema-DZdoc46X.mjs";
+import { i as MutantStatus } from "./Run.schema-C4m-b9Ki.mjs";
+import { d as TestRunnerCapabilitiesSchema, u as TestResultSchema } from "./TestRunner.schema-Dy0Wdro2.mjs";
+import * as S from "effect/Schema";
+import { Wire } from "@systemfsoftware/effect-cell-types";
+//#region src/ReporterEvent.schema.ts
+const ReporterEventKind = S.Literals([
+	"dryRunCompleted",
+	"mutationTestingPlanReady",
+	"mutantTested",
+	"mutationTestReportReady"
+]);
+const RunTimingSchema = Wire.wire({
+	net: Wire.mint(S.Finite),
+	overhead: Wire.mint(S.Finite)
+});
+const ReporterPlanKind = S.Literals(["EarlyResult", "Run"]);
+const ReporterPlanDescriptorSchema = Wire.wire({
+	mutantId: Wire.mint(S.String),
+	plan: Wire.mint(ReporterPlanKind),
+	netTime: Wire.mint(S.Finite),
+	reloadEnvironment: Wire.mint(S.Boolean)
+});
+var DryRunCompleted = class extends S.TaggedClass()("dryRunCompleted", {
+	timing: RunTimingSchema,
+	capabilities: TestRunnerCapabilitiesSchema,
+	testCount: Wire.mint(S.Finite),
+	tests: S.Array(TestResultSchema)
+}) {};
+var MutationTestingPlanReady = class extends S.TaggedClass()("mutationTestingPlanReady", {
+	total: Wire.mint(S.Finite),
+	plans: S.Array(ReporterPlanDescriptorSchema)
+}) {};
+var MutantTested = class extends S.TaggedClass()("mutantTested", {
+	id: Wire.mint(S.String),
+	status: MutantStatus,
+	file: Wire.mint(S.String),
+	location: LocationSchema,
+	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 MutationTestReportReady = class extends S.TaggedClass()("mutationTestReportReady", {
+	report: MutationTestResultSchema,
+	metrics: MetricsResultSchema
+}) {};
+const ReporterEventUnion = S.Union([
+	DryRunCompleted,
+	MutationTestingPlanReady,
+	MutantTested,
+	MutationTestReportReady
+]);
+const ReporterEventSchema = S.toStandardSchemaV1(ReporterEventUnion);
+//#endregion
+export { DryRunCompleted, MutantTested, MutationTestReportReady, MutationTestingPlanReady, ReporterEventKind, ReporterEventSchema, ReporterEventUnion };

package/dist/ReporterEvent.schema-Db6r_euv.d.mts

@@ -0,0 +1,190 @@
+import { n as MetricsResult } from "./Metrics.schema-BaVd6rXs.mjs";
+import { m as StrykerOptions } from "./Schema-CXKiLnTu.mjs";
+import * as S from "effect/Schema";
+import { Wire } from "@systemfsoftware/effect-cell-types";
+import { StandardSchemaV1 } from "effect/StandardSchema";
+//#region src/ReporterEvent.schema.d.ts
+declare const ReporterEventKind: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
+type ReporterEventKind = typeof ReporterEventKind.Type;
+declare const RunTimingSchema: S.Struct<{
+  net: S.Finite & Wire.Mark;
+  overhead: S.Finite & Wire.Mark;
+}> & Wire.Mark;
+type RunTiming = typeof RunTimingSchema.Type;
+declare const ReporterPlanDescriptorSchema: S.Struct<{
+  mutantId: S.String & Wire.Mark;
+  plan: S.Literals<readonly ["EarlyResult", "Run"]> & Wire.Mark;
+  netTime: S.Finite & Wire.Mark;
+  reloadEnvironment: S.Boolean & Wire.Mark;
+}> & Wire.Mark;
+type ReporterPlanDescriptor = typeof ReporterPlanDescriptorSchema.Type;
+declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dryRunCompleted", {
+  readonly timing: S.Struct<{
+    net: S.Finite & Wire.Mark;
+    overhead: S.Finite & Wire.Mark;
+  }> & Wire.Mark;
+  readonly capabilities: S.Struct<{
+    readonly reloadEnvironment: S.Boolean;
+  }>;
+  readonly testCount: S.Finite & Wire.Mark;
+  readonly tests: S.$Array<S.Union<readonly [S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>>;
+    readonly status: S.Literal<"failed">;
+    readonly failureMessage: S.String;
+  }>, S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>>;
+    readonly status: S.Literal<"skipped">;
+  }>, S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>>;
+    readonly status: S.Literal<"success">;
+  }>]>>;
+}>, {}>;
+declare class DryRunCompleted extends DryRunCompleted_base {}
+declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S.TaggedStruct<"mutationTestingPlanReady", {
+  readonly total: S.Finite & Wire.Mark;
+  readonly plans: S.$Array<S.Struct<{
+    mutantId: S.String & Wire.Mark;
+    plan: S.Literals<readonly ["EarlyResult", "Run"]> & Wire.Mark;
+    netTime: S.Finite & Wire.Mark;
+    reloadEnvironment: S.Boolean & Wire.Mark;
+  }> & Wire.Mark>;
+}>, {}>;
+declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
+declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTested", {
+  readonly id: S.String & Wire.Mark;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
+  readonly file: S.String & Wire.Mark;
+  readonly location: S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+  }>;
+  readonly mutator: S.String & Wire.Mark;
+  readonly replacement: S.NullOr<S.String & Wire.Mark> & Wire.Mark;
+  readonly completed: S.Finite & Wire.Mark;
+  readonly total: S.Finite & Wire.Mark;
+}>, {}>;
+declare class MutantTested extends MutantTested_base {}
+declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.TaggedStruct<"mutationTestReportReady", {
+  readonly report: S.Struct<{
+    readonly schemaVersion: S.String;
+    readonly files: S.$Record<S.String, S.Struct<{
+      readonly language: S.String;
+      readonly source: S.String;
+      readonly mutants: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly mutatorName: S.String;
+        readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+        readonly location: S.Struct<{
+          readonly start: S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+          }>;
+          readonly end: S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+          }>;
+        }>;
+        readonly replacement: S.optional<S.String>;
+        readonly description: S.optional<S.String>;
+        readonly statusReason: S.optional<S.String>;
+        readonly static: S.optional<S.Boolean>;
+        readonly coveredBy: S.optional<S.$Array<S.String>>;
+        readonly killedBy: S.optional<S.$Array<S.String>>;
+        readonly testsCompleted: S.optional<S.Finite>;
+        readonly duration: S.optional<S.Finite>;
+      }>>;
+    }>>;
+    readonly thresholds: S.Struct<{
+      readonly high: S.Finite;
+      readonly low: S.Finite;
+    }>;
+    readonly config: S.optional<S.$Record<S.String, S.Unknown>>;
+    readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
+      readonly source: S.optional<S.String>;
+      readonly tests: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly name: S.String;
+        readonly location: S.optional<S.Struct<{
+          readonly start: S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+          }>;
+          readonly end: S.optional<S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+          }>>;
+        }>>;
+      }>>;
+    }>>>;
+    readonly projectRoot: S.optional<S.String>;
+    readonly framework: S.optional<S.Struct<{
+      readonly name: S.String;
+      readonly version: S.optional<S.String>;
+      readonly branding: S.optional<S.Struct<{
+        readonly homepageUrl: S.String;
+        readonly imageUrl: S.optional<S.String>;
+      }>>;
+      readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
+    }>>;
+  }>;
+  readonly metrics: S.Struct<{
+    readonly name: S.String;
+    readonly metrics: S.Struct<{
+      readonly pending: S.Finite;
+      readonly killed: S.Finite;
+      readonly timeout: S.Finite;
+      readonly survived: S.Finite;
+      readonly noCoverage: S.Finite;
+      readonly runtimeErrors: S.Finite;
+      readonly compileErrors: S.Finite;
+      readonly ignored: S.Finite;
+      readonly totalDetected: S.Finite;
+      readonly totalUndetected: S.Finite;
+      readonly totalInvalid: S.Finite;
+      readonly totalValid: S.Finite;
+      readonly totalMutants: S.Finite;
+      readonly totalCovered: S.Finite;
+      readonly mutationScore: S.Finite;
+      readonly mutationScoreBasedOnCoveredCode: S.Finite;
+    }>;
+    readonly childResults: S.$Array<S.suspend<S.Codec<MetricsResult, MetricsResult, never, never>>>;
+  }>;
+}>, {}>;
+declare class MutationTestReportReady extends MutationTestReportReady_base {}
+declare const ReporterEventUnion: S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>;
+type ReporterEvent = DryRunCompleted | MutationTestingPlanReady | MutantTested | MutationTestReportReady;
+declare const ReporterEventSchema: StandardSchemaV1<unknown, ReporterEvent>;
+interface ReporterInit {
+  readonly traceparent?: string | undefined;
+  readonly tracestate?: string | undefined;
+}
+type ReporterFactory = (options: StrykerOptions, init: ReporterInit) => (events: AsyncIterable<ReporterEvent>) => Promise<void>;
+//#endregion
+export { ReporterEvent as a, ReporterEventUnion as c, ReporterPlanDescriptor as d, RunTiming as f, MutationTestingPlanReady as i, ReporterFactory as l, MutantTested as n, ReporterEventKind as o, MutationTestReportReady as r, ReporterEventSchema as s, DryRunCompleted as t, ReporterInit as u };

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

@@ -1,8 +1,8 @@
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
+import { Wire } from "@systemfsoftware/effect-cell-types";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
-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
@@ -126,15 +126,9 @@ declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
   readonly help: S.String & Wire.Mark;
 }>, {}>;
 declare class HelpRendered extends HelpRendered_base {}
-declare const ManifestRendered_base: S.Class<ManifestRendered, S.TaggedStruct<"manifest", {
-  readonly schemaVersion: S.String & Wire.Mark;
-  readonly code: S.Literals<readonly [0]> & Wire.Mark;
-  readonly manifest: S.String & Wire.Mark;
-}>, {}>;
-declare class ManifestRendered extends ManifestRendered_base {}
-declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof MutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered, typeof ManifestRendered]>;
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof MutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
 type RunEvent = typeof RunEvent.Type;
-type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered | ManifestRendered;
+type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
 declare const RunCommand_base: S.Class<RunCommand, S.TaggedStruct<"RunCommand", {
   readonly cliOptionsJson: S.String;
   readonly targetMutatePatterns: S.$Array<S.String>;
@@ -158,10 +152,10 @@ declare const MutationRunPlan_base: S.Class<MutationRunPlan, S.TaggedStruct<"Mut
 }>, {}>;
 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, planMutationRun, runMutationTest, shouldKeepTempDir };
+  export { Heartbeat, HelpRendered, Location, 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>>>;
+declare const RunEvents_base: Context.ServiceClass<RunEvents, "~@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | MutantTested | PhaseEntered | PlanKnown | RunFailed | RunStarted | VerdictReached, Cause.Done<void>>>;
 declare class RunEvents extends RunEvents_base {}
 interface RunIdentityShape {
   readonly runId: string;
@@ -176,4 +170,4 @@ interface MutationRunIo {
 declare const runMutationTest: (io: MutationRunIo, command: RunCommand) => Effect.Effect<void, S.SchemaError, RunIdentity>;
 declare const shouldKeepTempDir: (exit: Exit.Exit<void, unknown>, cleanTempDir: 'always' | boolean) => boolean;
 //#endregion
-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 };
+export { RunTerminalEvent as C, RunStarted as S, PlanKnown as _, Run_d_exports as a, RunFailed as b, shouldKeepTempDir as c, Location as d, ModeSignal as f, PhaseEntered as g, OutputMode as h, RunIdentityShape as i, Heartbeat as l, MutantTested as m, RunEvents as n, planMutationRun as o, MutantStatus as p, RunIdentity as r, runMutationTest as s, MutationRunIo as t, HelpRendered as u, Position as v, VerdictReached as w, RunPhase as x, RunEvent as y };

package/dist/Run.d.mts

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