@systemfsoftware/stryker-js 2.0.0 → 3.0.1

package/dist/Run.schema-DZve3k2m.mjs

@@ -0,0 +1,138 @@
+import * as S from "effect/Schema";
+//#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 = S.Struct({
+	line: S.Finite,
+	column: S.Finite
+});
+const Location = S.Struct({
+	start: Position,
+	end: Position
+});
+var RunStarted = class extends S.TaggedClass()("stream", {
+	schemaVersion: S.String,
+	runId: S.String,
+	mode: OutputMode,
+	signal: ModeSignal
+}) {};
+var PhaseEntered = class extends S.TaggedClass()("phase", {
+	phase: RunPhase,
+	elapsedMs: S.Finite
+}) {};
+var PlanKnown = class extends S.TaggedClass()("plan", { total: S.Finite }) {};
+var MutantTested = class extends S.TaggedClass()("mutant", {
+	id: S.String,
+	status: MutantStatus,
+	file: S.String,
+	location: Location,
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
+	completed: S.Finite,
+	total: S.Finite
+}) {};
+var Heartbeat = class extends S.TaggedClass()("tick", {
+	elapsedMs: S.Finite,
+	completed: S.Finite,
+	total: S.NullOr(S.Finite)
+}) {};
+const VerdictThresholds = S.Struct({
+	high: S.Finite,
+	low: S.Finite,
+	break: S.NullOr(S.Finite)
+});
+const VerdictMutant = S.Struct({
+	id: S.String,
+	file: S.String,
+	location: Location,
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
+	status: MutantStatus
+});
+const VerdictCounts = S.Struct({
+	killed: S.Finite,
+	timeout: S.Finite,
+	survived: S.Finite,
+	noCoverage: S.Finite,
+	runtimeErrors: S.Finite,
+	compileErrors: S.Finite,
+	ignored: S.Finite,
+	pending: S.Finite
+});
+var VerdictReached = class extends S.TaggedClass()("verdict", {
+	schemaVersion: S.String,
+	runId: S.String,
+	mode: OutputMode,
+	signal: ModeSignal,
+	score: S.NullOr(S.Finite),
+	thresholds: VerdictThresholds,
+	reportFile: S.NullOr(S.String),
+	counts: VerdictCounts,
+	mutants: S.Array(VerdictMutant)
+}) {};
+var RunFailed = class extends S.TaggedClass()("error", {
+	schemaVersion: S.String,
+	code: S.Finite,
+	error: S.String,
+	remediation: S.String
+}) {};
+var HelpRendered = class extends S.TaggedClass()("help", {
+	schemaVersion: S.String,
+	code: S.Literals([0]),
+	help: S.String
+}) {};
+const RunEvent = S.Union([
+	RunStarted,
+	PhaseEntered,
+	PlanKnown,
+	MutantTested,
+	Heartbeat,
+	VerdictReached,
+	RunFailed,
+	HelpRendered
+]);
+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: S.Array(S.String),
+	configMutatorNames: S.Array(S.String),
+	targetMutatePatterns: S.Array(S.String),
+	availableMutators: S.Array(S.String)
+}) {};
+var MutationRunPlan = class extends S.TaggedClass()("MutationRunPlan", {
+	mutatePatterns: S.Array(S.String),
+	mutatorNames: S.Array(S.String)
+}) {};
+//#endregion
+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/{Schema-CXKiLnTu.d.mts → Schema-4oCWQ0P0.d.mts}

@@ -1,5 +1,4 @@
 import * as S from "effect/Schema";
-import { Wire } from "@systemfsoftware/effect-cell-types";
 //#region src/Schema.schema.d.ts
 declare const LogLevel: S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>;
 declare const CoverageAnalysisMode: S.Literals<readonly ["off", "all", "perTest"]>;
@@ -11,76 +10,76 @@ type CoverageAnalysisMode = typeof CoverageAnalysisMode.Type;
 type ReportType = typeof ReportType.Type;
 type PackageManager = typeof PackageManager.Type;
 declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
-  readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly buildCommand: S.optional<S.String & Wire.Mark>;
-  readonly checkers: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly concurrency: S.optional<S.Union<readonly [S.Finite & Wire.Mark, S.String & Wire.Mark]> & Wire.Mark>;
+  readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly buildCommand: S.optional<S.String>;
+  readonly checkers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly concurrency: S.optional<S.Union<readonly [S.Finite, S.String]>>;
   readonly commandRunner: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
-    readonly command: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  }> & Wire.Mark, readonly [S.$Record<S.String & Wire.Mark, S.Unknown & Wire.Mark> & Wire.Mark]>, never> & Wire.Mark;
-  readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never> & Wire.Mark;
+    readonly command: S.withDecodingDefaultKey<S.String, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+  readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never>;
   readonly clearTextReporter: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
-    readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly logTests: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-    readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  }> & Wire.Mark, readonly [S.$Record<S.String & Wire.Mark, S.Unknown & Wire.Mark> & Wire.Mark]>, never> & Wire.Mark;
-  readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly incremental: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly incrementalFile: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly force: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never> & Wire.Mark;
-  readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never> & Wire.Mark;
-  readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
+    readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly logTests: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+  readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+  readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+  readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
   readonly mutator: S.withDecodingDefaultKey<S.Struct<{
-    excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  }>, never> & Wire.Mark;
+    readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  }>, never>;
   readonly packageManager: S.optional<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
-  readonly plugins: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
+  readonly plugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
   readonly htmlReporter: S.withDecodingDefaultKey<S.Struct<{
-    fileName: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  }>, never> & Wire.Mark;
+    readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+  }>, never>;
   readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
-    fileName: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  }>, never> & Wire.Mark;
-  readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean & Wire.Mark, S.String & Wire.Mark]>, never> & Wire.Mark;
-  readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly tempDirName: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never> & Wire.Mark;
-  readonly testRunner: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
+    readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+  }>, never>;
+  readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.String]>, never>;
+  readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly tempDirName: S.withDecodingDefaultKey<S.String, never>;
+  readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never>;
+  readonly testRunner: S.withDecodingDefaultKey<S.String, never>;
+  readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
   readonly thresholds: S.withDecodingDefaultKey<S.Struct<{
-    readonly high: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-    readonly low: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-    readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite & Wire.Mark>, never> & Wire.Mark;
-  }>, never> & Wire.Mark;
-  readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean & Wire.Mark, S.StructWithRest<S.Struct<{
-    readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly slow: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  }> & Wire.Mark, readonly [S.$Record<S.String & Wire.Mark, S.Unknown & Wire.Mark> & Wire.Mark]> & Wire.Mark]>, never> & Wire.Mark;
-  readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
+    readonly high: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly low: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
+  }>, never>;
+  readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never>;
+  readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.StructWithRest<S.Struct<{
+    readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly slow: S.withDecodingDefaultKey<S.Boolean, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>]>, never>;
+  readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
 }>, readonly [S.$Record<S.String, S.Unknown>]>;
 /** The decoded type: every defaulted option is present. */
 type StrykerOptions = S.Schema.Type<typeof StrykerOptionsSchema>;

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

@@ -1,6 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import * as S from "effect/Schema";
-import { Wire } from "@systemfsoftware/effect-cell-types";
 import { Effect } from "effect";
 //#region src/Schema.schema.ts
 const RENDERED_OPTION_DEFAULTS$1 = {
@@ -34,7 +33,7 @@ const RENDERED_OPTION_DEFAULTS$1 = {
 * separate engine that happened not to inject them.
 */
 /** Open object: fixed fields plus an index signature accepting arbitrary plugin keys. */
-const openStruct = (fields) => Wire.mint(S.StructWithRest(Wire.wire(fields), [Wire.mint(S.Record(Wire.mint(S.String), Wire.mint(S.Unknown)))]));
+const openStruct = (fields) => S.StructWithRest(S.Struct(fields), [S.Record(S.String, S.Unknown)]);
 /**
 * Field that decodes to a value but defaults when the key is absent.
 *
@@ -50,8 +49,7 @@ const openStruct = (fields) => Wire.mint(S.StructWithRest(Wire.wire(fields), [Wi
 */
 const defaulted = (schema, defaultValue) => {
 	const annotated = schema.annotate({ default: defaultValue });
-	const withDefault = S.withDecodingDefaultKey(Effect.succeed(defaultValue))(annotated);
-	return Wire.mint(withDefault);
+	return S.withDecodingDefaultKey(Effect.succeed(defaultValue))(annotated);
 };
 const LogLevel = S.Literals([
 	"off",
@@ -74,43 +72,43 @@ const PackageManager = S.Literals([
 	"pnpm"
 ]);
 /** 0–100 percentage used by the mutation-score thresholds. */
-const Percentage = Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isBetween({
+const Percentage = S.Finite.pipe(S.check(S.isBetween({
 	minimum: 0,
 	maximum: 100
-}))));
-const CommandRunnerOptionsSchema = openStruct({ command: defaulted(Wire.mint(S.String), "npm test") });
+})));
+const CommandRunnerOptionsSchema = openStruct({ command: defaulted(S.String, "npm test") });
 const ClearTextReporterOptions = openStruct({
-	allowColor: defaulted(Wire.mint(S.Boolean), true),
-	allowEmojis: defaulted(Wire.mint(S.Boolean), false),
-	logTests: defaulted(Wire.mint(S.Boolean), true),
-	maxTestsToLog: defaulted(Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isGreaterThanOrEqualTo(0)))), 3),
-	reportTests: defaulted(Wire.mint(S.Boolean), true),
-	reportMutants: defaulted(Wire.mint(S.Boolean), true),
-	reportScoreTable: defaulted(Wire.mint(S.Boolean), true),
-	skipFull: defaulted(Wire.mint(S.Boolean), false)
+	allowColor: defaulted(S.Boolean, true),
+	allowEmojis: defaulted(S.Boolean, false),
+	logTests: defaulted(S.Boolean, true),
+	maxTestsToLog: defaulted(S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))), 3),
+	reportTests: defaulted(S.Boolean, true),
+	reportMutants: defaulted(S.Boolean, true),
+	reportScoreTable: defaulted(S.Boolean, true),
+	skipFull: defaulted(S.Boolean, false)
 });
-const HtmlReporterOptions = Wire.wire({ fileName: defaulted(Wire.mint(S.String), "reports/mutation/mutation.html") });
-const JsonReporterOptions = Wire.wire({ fileName: defaulted(Wire.mint(S.String), "reports/mutation/mutation.json") });
+const HtmlReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.html") });
+const JsonReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.json") });
 const MutationScoreThresholdsSchema = S.Struct({
 	high: defaulted(Percentage, 80),
 	low: defaulted(Percentage, 60),
 	break: defaulted(S.NullOr(Percentage), null)
 });
-const MutatorDescriptor = Wire.wire({ excludedMutations: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []) });
+const MutatorDescriptor = S.Struct({ excludedMutations: defaulted(S.Array(S.String), []) });
 const WarningOptions = openStruct({
-	unknownOptions: defaulted(Wire.mint(S.Boolean), true),
-	preprocessorErrors: defaulted(Wire.mint(S.Boolean), true),
-	unserializableOptions: defaulted(Wire.mint(S.Boolean), true),
-	slow: defaulted(Wire.mint(S.Boolean), true)
+	unknownOptions: defaulted(S.Boolean, true),
+	preprocessorErrors: defaulted(S.Boolean, true),
+	unserializableOptions: defaulted(S.Boolean, true),
+	slow: defaulted(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 ConcurrencyCount = S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(1)));
+const ConcurrencyPercent = 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([ConcurrencyCount, ConcurrencyPercent]))),
+	allowConsoleColors: defaulted(S.Boolean, true),
+	buildCommand: S.optional(S.String),
+	checkers: defaulted(S.Array(S.String), []),
+	checkerNodeArgs: defaulted(S.Array(S.String), []),
+	concurrency: S.optional(S.Union([ConcurrencyCount, ConcurrencyPercent])),
 	commandRunner: defaulted(CommandRunnerOptionsSchema, { command: "npm test" }),
 	coverageAnalysis: defaulted(CoverageAnalysisMode, RENDERED_OPTION_DEFAULTS$1.coverageAnalysis),
 	clearTextReporter: defaulted(ClearTextReporterOptions, {
@@ -123,54 +121,54 @@ const StrykerOptionsSchema = S.StructWithRest(S.Struct({
 		reportScoreTable: true,
 		skipFull: false
 	}),
-	dryRunOnly: defaulted(Wire.mint(S.Boolean), false),
-	ignorePatterns: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
-	ignoreStatic: defaulted(Wire.mint(S.Boolean), false),
-	incremental: defaulted(Wire.mint(S.Boolean), false),
-	incrementalFile: defaulted(Wire.mint(S.String), "reports/stryker-incremental.json"),
-	progressStreamFile: defaulted(Wire.mint(S.String), "reports/mutation-stream.jsonl"),
-	force: defaulted(Wire.mint(S.Boolean), false),
+	dryRunOnly: defaulted(S.Boolean, false),
+	ignorePatterns: defaulted(S.Array(S.String), []),
+	ignoreStatic: defaulted(S.Boolean, false),
+	incremental: defaulted(S.Boolean, false),
+	incrementalFile: defaulted(S.String, "reports/stryker-incremental.json"),
+	progressStreamFile: defaulted(S.String, "reports/mutation-stream.jsonl"),
+	force: defaulted(S.Boolean, false),
 	fileLogLevel: defaulted(LogLevel, RENDERED_OPTION_DEFAULTS$1.fileLogLevel),
-	inPlace: defaulted(Wire.mint(S.Boolean), false),
+	inPlace: defaulted(S.Boolean, false),
 	logLevel: defaulted(LogLevel, RENDERED_OPTION_DEFAULTS$1.logLevel),
-	maxConcurrentTestRunners: defaulted(Wire.mint(S.Finite), 9007199254740991),
-	maxTestRunnerReuse: defaulted(Wire.mint(S.Finite), 0),
-	mutate: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), ["{src,lib}/**/!(*.+(s|S)pec|*.+(t|T)est).+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)", "!{src,lib}/**/__tests__/**/*.+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)"]),
+	maxConcurrentTestRunners: defaulted(S.Finite, 9007199254740991),
+	maxTestRunnerReuse: defaulted(S.Finite, 0),
+	mutate: defaulted(S.Array(S.String), ["{src,lib}/**/!(*.+(s|S)pec|*.+(t|T)est).+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)", "!{src,lib}/**/__tests__/**/*.+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)"]),
 	mutator: defaulted(MutatorDescriptor, { excludedMutations: [] }),
 	packageManager: S.optional(PackageManager),
-	plugins: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), ["@systemfsoftware/stryker-js-*"]),
-	appendPlugins: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
-	reporters: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), [
+	plugins: defaulted(S.Array(S.String), ["@systemfsoftware/stryker-js-*"]),
+	appendPlugins: defaulted(S.Array(S.String), []),
+	reporters: defaulted(S.Array(S.String), [
 		"clear-text",
 		"progress",
 		"html"
 	]),
 	htmlReporter: defaulted(HtmlReporterOptions, { fileName: "reports/mutation/mutation.html" }),
 	jsonReporter: defaulted(JsonReporterOptions, { fileName: "reports/mutation/mutation.json" }),
-	disableTypeChecks: defaulted(Wire.mint(S.Union([Wire.mint(S.Boolean), Wire.mint(S.String)])), true),
-	symlinkNodeModules: defaulted(Wire.mint(S.Boolean), true),
-	tempDirName: defaulted(Wire.mint(S.String), RENDERED_OPTION_DEFAULTS$1.tempDirName),
+	disableTypeChecks: defaulted(S.Union([S.Boolean, S.String]), true),
+	symlinkNodeModules: defaulted(S.Boolean, true),
+	tempDirName: defaulted(S.String, RENDERED_OPTION_DEFAULTS$1.tempDirName),
 	cleanTempDir: defaulted(S.Literals([
 		"always",
 		false,
 		true
 	]), true),
-	testRunner: defaulted(Wire.mint(S.String), "command"),
-	testRunnerNodeArgs: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
+	testRunner: defaulted(S.String, "command"),
+	testRunnerNodeArgs: defaulted(S.Array(S.String), []),
 	thresholds: defaulted(MutationScoreThresholdsSchema, {
 		high: 80,
 		low: 60,
 		break: null
 	}),
-	timeoutFactor: defaulted(Wire.mint(S.Finite), 1.5),
-	timeoutMS: defaulted(Wire.mint(S.Finite), 5e3),
-	dryRunTimeoutMinutes: defaulted(Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isGreaterThanOrEqualTo(0)))), 5),
-	tsconfigFile: defaulted(Wire.mint(S.String), "tsconfig.json"),
-	warnings: defaulted(Wire.mint(S.Union([Wire.mint(S.Boolean), WarningOptions])), true),
-	disableBail: defaulted(Wire.mint(S.Boolean), false),
-	allowEmpty: defaulted(Wire.mint(S.Boolean), false),
-	ignorers: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
-	testFiles: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), [])
+	timeoutFactor: defaulted(S.Finite, 1.5),
+	timeoutMS: defaulted(S.Finite, 5e3),
+	dryRunTimeoutMinutes: defaulted(S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))), 5),
+	tsconfigFile: defaulted(S.String, "tsconfig.json"),
+	warnings: defaulted(S.Union([S.Boolean, WarningOptions]), true),
+	disableBail: defaulted(S.Boolean, false),
+	allowEmpty: defaulted(S.Boolean, false),
+	ignorers: defaulted(S.Array(S.String), []),
+	testFiles: defaulted(S.Array(S.String), [])
 }), [S.Record(S.String, S.Unknown)]);
 //#endregion
 //#region src/Schema.ts

package/dist/Schema.d.mts

@@ -1,2 +1,2 @@
-import { c as strykerReportBugUrl, d as PackageManager, f as PartialStrykerOptions, h as StrykerOptionsSchema, i as RENDERED_OPTION_DEFAULTS, l as CoverageAnalysisMode, m as StrykerOptions, n as Primitive, o as propertyPath, p as ReportType, r as PropertyPathOverloads, s as strykerCoreSchema, t as KnownKeys, u as LogLevel } from "./Schema-CXKiLnTu.mjs";
+import { c as strykerReportBugUrl, d as PackageManager, f as PartialStrykerOptions, h as StrykerOptionsSchema, i as RENDERED_OPTION_DEFAULTS, l as CoverageAnalysisMode, m as StrykerOptions, n as Primitive, o as propertyPath, p as ReportType, r as PropertyPathOverloads, s as strykerCoreSchema, t as KnownKeys, u as LogLevel } from "./Schema-4oCWQ0P0.mjs";
 export { CoverageAnalysisMode, type CoverageAnalysisMode as CoverageAnalysisModeType, KnownKeys, LogLevel, type LogLevel as LogLevelType, PackageManager, type PackageManager as PackageManagerType, type PartialStrykerOptions, Primitive, PropertyPathOverloads, RENDERED_OPTION_DEFAULTS, ReportType, type ReportType as ReportTypeType, type StrykerOptions, StrykerOptionsSchema, propertyPath, strykerCoreSchema, strykerReportBugUrl };

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-CdNkubPi.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-CMKdWMUN.mjs";
 export { CoverageAnalysisMode, LogLevel, PackageManager, RENDERED_OPTION_DEFAULTS, ReportType, StrykerOptionsSchema, propertyPath, strykerCoreSchema, strykerReportBugUrl };

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 };