@systemfsoftware/stryker-js 0.1.0

package/dist/Run.d.mts

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

package/dist/Run.mjs

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

package/dist/Schema-C7nahULg.mjs

@@ -0,0 +1,249 @@
+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 = {
+	coverageAnalysis: "perTest",
+	fileLogLevel: "off",
+	logLevel: "info",
+	tempDirName: ".stryker-tmp"
+};
+/**
+* The Stryker option set, declared as ONE Effect Schema.
+*
+* Replaces the vendored `schema/stryker-core.json` codegen chain
+* (`tasks/generate-stryker-core.mjs` → `src-generated/stryker-core.ts`): every
+* option name, type, optionality and default is preserved, and
+* `strykerCoreSchema` is the JSON Schema document **derived** from
+* `StrykerOptionsSchema` (no file read).
+*
+* Layering mirrors the original document:
+* - objects without `additionalProperties: false` there (the option set
+*   itself, `commandRunner`, `clearTextReporter`, `warnings`) are open here —
+*   `S.StructWithRest` with a `Record<string, unknown>` index keeps arbitrary
+*   plugin-proposed keys and makes the decoded type carry
+*   `[k: string]: unknown`;
+* - objects with `additionalProperties: false` (`htmlReporter`, `jsonReporter`,
+*   `thresholds`, `mutator`) are closed here.
+*
+* `dashboard` and `eventReporter` are absent: the reporters they configured were
+* removed, and the removed-option check rejects both names. Declaring them here
+* with defaults meant the default option set carried two options the very next
+* validation step refused - invisible only while the defaults were filled by a
+* 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)))]));
+/**
+* Field that decodes to a value but defaults when the key is absent.
+*
+* The default is typed by the schema's ENCODED side, which is what
+* `withDecodingDefaultKey` consumes: a whole-object option can therefore default
+* to `{}` exactly when every field inside it carries its own default, and
+* the compiler decides that rather than the author asserting it.
+*
+* The annotation is applied to the schema BEFORE the default transform wraps it.
+* Annotating the wrapper instead leaves `default` off the derived JSON Schema
+* document, so a consumer filling defaults from that document (ajv
+* `useDefaults`) silently injects nothing.
+*/
+const defaulted = (schema, defaultValue) => {
+	const annotated = schema.annotate({ default: defaultValue });
+	const withDefault = S.withDecodingDefaultKey(Effect.succeed(defaultValue))(annotated);
+	return Wire.mint(withDefault);
+};
+const LogLevel = S.Literals([
+	"off",
+	"fatal",
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace"
+]);
+const CoverageAnalysisMode = S.Literals([
+	"off",
+	"all",
+	"perTest"
+]);
+const ReportType = S.Literals(["full", "mutationScore"]);
+const PackageManager = S.Literals([
+	"npm",
+	"yarn",
+	"pnpm"
+]);
+/** 0–100 percentage used by the mutation-score thresholds. */
+const Percentage = Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isBetween({
+	minimum: 0,
+	maximum: 100
+}))));
+const CommandRunnerOptionsSchema = openStruct({ command: defaulted(Wire.mint(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)
+});
+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 MutationScoreThresholdsSchema = S.Struct({
+	high: defaulted(Percentage, 80),
+	low: defaulted(Percentage, 60),
+	break: defaulted(S.NullOr(Percentage), null)
+});
+const MutatorDescriptor = Wire.wire({
+	plugins: defaulted(Wire.mint(S.NullOr(Wire.mint(S.Array(Wire.mint(S.Union([Wire.mint(S.String), Wire.mint(S.Array(Wire.mint(S.Unknown)))])))))), null),
+	excludedMutations: defaulted(Wire.mint(S.Array(Wire.mint(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)
+});
+const StrykerOptionsSchema = S.StructWithRest(S.Struct({
+	allowConsoleColors: defaulted(Wire.mint(S.Boolean), true),
+	buildCommand: S.optional(Wire.mint(S.String)),
+	checkers: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
+	checkerNodeArgs: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
+	concurrency: S.optional(Wire.mint(S.Union([Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isGreaterThanOrEqualTo(1)))), Wire.mint(Wire.mint(S.String).pipe(S.check(S.isPattern(/^(100|[1-9]?[0-9])%$/))))]))),
+	commandRunner: defaulted(CommandRunnerOptionsSchema, { command: "npm test" }),
+	coverageAnalysis: defaulted(CoverageAnalysisMode, RENDERED_OPTION_DEFAULTS$1.coverageAnalysis),
+	clearTextReporter: defaulted(ClearTextReporterOptions, {
+		allowColor: true,
+		allowEmojis: false,
+		logTests: true,
+		maxTestsToLog: 3,
+		reportTests: true,
+		reportMutants: true,
+		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"),
+	force: defaulted(Wire.mint(S.Boolean), false),
+	fileLogLevel: defaulted(LogLevel, RENDERED_OPTION_DEFAULTS$1.fileLogLevel),
+	inPlace: defaulted(Wire.mint(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)"]),
+	mutator: defaulted(MutatorDescriptor, {
+		plugins: null,
+		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))), [
+		"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),
+	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))), []),
+	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))), [])
+}), [S.Record(S.String, S.Unknown)]);
+//#endregion
+//#region src/Schema.ts
+var Schema_exports = /* @__PURE__ */ __exportAll({
+	CoverageAnalysisMode: () => CoverageAnalysisMode,
+	LogLevel: () => LogLevel,
+	PackageManager: () => PackageManager,
+	RENDERED_OPTION_DEFAULTS: () => RENDERED_OPTION_DEFAULTS,
+	ReportType: () => ReportType,
+	StrykerOptionsSchema: () => StrykerOptionsSchema,
+	propertyPath: () => propertyPath,
+	strykerCoreSchema: () => strykerCoreSchema,
+	strykerReportBugUrl: () => strykerReportBugUrl
+});
+/**
+* The four option defaults a human reads about in help text.
+*
+* `Schema.schema.ts` declares every default, and a CLI that wants to
+* name one in a `--help` description must read it from here rather than type
+* the literal a second time: a restated default drifts the moment the schema
+* moves, and no gate compares a help string against a schema annotation.
+*
+* Only these four are here because only these four are rendered. A default
+* nobody prints has one declaration site already, which is the schema.
+*/
+const RENDERED_OPTION_DEFAULTS = {
+	coverageAnalysis: "perTest",
+	fileLogLevel: "off",
+	logLevel: "info",
+	tempDirName: ".stryker-tmp"
+};
+/**
+* Given a base type, allows type safe access to the name of a property.
+* @param prop The property name
+*/
+function propertyPath() {
+	const fn = (...args) => args.join(".");
+	return fn;
+}
+/**
+* Creates a URL to the page where a consumer can report a bug against this
+* project.
+*
+* The tracker is ours. The ported original addressed the upstream StrykerJS
+* repository, along with its label and issue-template parameters, so every bug
+* a consumer filed from a Stryker run arrived at a project that does not own
+* this code (`REPO-O1`) and prefilled a template that does not exist here.
+*
+* @param titleSuggestion The title to be prefilled in.
+*/
+function strykerReportBugUrl(titleSuggestion) {
+	return `https://github.com/systemfsoftware/systemfsoftware/issues/new?title=${encodeURIComponent(titleSuggestion)}`;
+}
+/**
+* The JSON Schema document derived from `StrykerOptionsSchema`, self-contained.
+*
+* It lives beside the schema module rather than inside it because it is a *use*
+* of that schema, not a declaration of one: `S.toJsonSchemaDocument` consumes a
+* schema and returns a plain document. Keeping uses out of a `*.schema.ts` is
+* what lets a tool read every exported schema in a package and trust that each
+* one is a schema - the generated law suite does exactly that, and a document
+* handed to `toEncoded` takes the whole suite down with it.
+*/
+const strykerCoreSchema = (() => {
+	const { schema, definitions } = S.toJsonSchemaDocument(StrykerOptionsSchema);
+	if (Object.keys(definitions).length === 0) return schema;
+	return {
+		...schema,
+		definitions
+	};
+})();
+//#endregion
+export { strykerReportBugUrl as a, PackageManager as c, strykerCoreSchema as i, ReportType as l, Schema_exports as n, CoverageAnalysisMode as o, propertyPath as r, LogLevel as s, RENDERED_OPTION_DEFAULTS as t, StrykerOptionsSchema as u };

package/dist/Schema-Df2kA6F7.d.mts

@@ -0,0 +1,159 @@
+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"]>;
+declare const ReportType: S.Literals<readonly ["full", "mutationScore"]>;
+declare const PackageManager: S.Literals<readonly ["npm", "yarn", "pnpm"]>;
+/** The generated module exported these as TypeScript types; consumers still name them that way. */
+type LogLevel = typeof LogLevel.Type;
+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 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 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 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 mutator: S.withDecodingDefaultKey<S.Struct<{
+    plugins: S.withDecodingDefaultKey<S.NullOr<S.$Array<S.Union<readonly [S.String & Wire.Mark, S.$Array<S.Unknown & Wire.Mark> & Wire.Mark]> & Wire.Mark> & Wire.Mark>, never> & Wire.Mark;
+    excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
+  }>, never> & Wire.Mark;
+  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 htmlReporter: S.withDecodingDefaultKey<S.Struct<{
+    fileName: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
+  }>, never> & Wire.Mark;
+  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 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 [S.$Record<S.String, S.Unknown>]>;
+/** The decoded type: every defaulted option is present. */
+type StrykerOptions = S.Schema.Type<typeof StrykerOptionsSchema>;
+/**
+ * The deep-partial input type: when configuring Stryker, every option is
+ * optional, including deep properties like `dashboard.project`.
+ */
+type PartialStrykerOptions = DeepOptional<StrykerOptions>;
+/**
+ * Every option optional, all the way down, and mutable: this is the type a
+ * caller CONSTRUCTS by assignment, so `readonly` is stripped. The decoded
+ * `StrykerOptions` keeps it - that side is read, never built.
+ */
+type DeepOptional<T> = { -readonly [P in keyof T]?: T[P] extends Record<string, unknown> ? DeepOptional<T[P]> | undefined : T[P]; };
+declare namespace Schema_d_exports {
+  export { CoverageAnalysisMode, CoverageAnalysisMode as CoverageAnalysisModeType, KnownKeys, LogLevel, LogLevel as LogLevelType, PackageManager, PackageManager as PackageManagerType, PartialStrykerOptions, Primitive, PropertyPathOverloads, RENDERED_OPTION_DEFAULTS, ReportType, ReportType as ReportTypeType, StrykerOptions, StrykerOptionsSchema, propertyPath, strykerCoreSchema, strykerReportBugUrl };
+}
+/**
+ * The four option defaults a human reads about in help text.
+ *
+ * `Schema.schema.ts` declares every default, and a CLI that wants to
+ * name one in a `--help` description must read it from here rather than type
+ * the literal a second time: a restated default drifts the moment the schema
+ * moves, and no gate compares a help string against a schema annotation.
+ *
+ * Only these four are here because only these four are rendered. A default
+ * nobody prints has one declaration site already, which is the schema.
+ */
+declare const RENDERED_OPTION_DEFAULTS: {
+  readonly coverageAnalysis: 'perTest';
+  readonly fileLogLevel: 'off';
+  readonly logLevel: 'info';
+  readonly tempDirName: '.stryker-tmp';
+};
+type Primitive = boolean | number | string | null | undefined;
+/**
+ * Known keys filters out the index signature from the keys of a type
+ * @see https://stackoverflow.com/questions/51465182/typescript-remove-index-signature-using-mapped-types
+ */
+type KnownKeys<T> = keyof { [P in keyof T as string extends P ? never : number extends P ? never : P]: T[P]; };
+type OnlyObject<T> = Exclude<T, Primitive>;
+interface PropertyPathOverloads<T> {
+  (key: KnownKeys<T>): string;
+  <TProp1 extends KnownKeys<T>>(key: TProp1, key2: KnownKeys<OnlyObject<T[TProp1]>>): string;
+  <TProp1 extends KnownKeys<T>, TProp2 extends KnownKeys<OnlyObject<T[TProp1]>>>(key: TProp1, key2: TProp2, key3: KnownKeys<OnlyObject<OnlyObject<T[TProp1]>[TProp2]>>): string;
+}
+/**
+ * Given a base type, allows type safe access to the name of a property.
+ * @param prop The property name
+ */
+declare function propertyPath<T>(): PropertyPathOverloads<T>;
+/**
+ * Creates a URL to the page where a consumer can report a bug against this
+ * project.
+ *
+ * The tracker is ours. The ported original addressed the upstream StrykerJS
+ * repository, along with its label and issue-template parameters, so every bug
+ * a consumer filed from a Stryker run arrived at a project that does not own
+ * this code (`REPO-O1`) and prefilled a template that does not exist here.
+ *
+ * @param titleSuggestion The title to be prefilled in.
+ */
+declare function strykerReportBugUrl(titleSuggestion: string): string;
+/**
+ * The JSON Schema document derived from `StrykerOptionsSchema`, self-contained.
+ *
+ * It lives beside the schema module rather than inside it because it is a *use*
+ * of that schema, not a declaration of one: `S.toJsonSchemaDocument` consumes a
+ * schema and returns a plain document. Keeping uses out of a `*.schema.ts` is
+ * what lets a tool read every exported schema in a package and trust that each
+ * one is a schema - the generated law suite does exactly that, and a document
+ * handed to `toEncoded` takes the whole suite down with it.
+ */
+declare const strykerCoreSchema: Record<string, unknown>;
+//#endregion
+export { Schema_d_exports as a, strykerReportBugUrl as c, PackageManager as d, PartialStrykerOptions as f, StrykerOptionsSchema as h, RENDERED_OPTION_DEFAULTS as i, CoverageAnalysisMode as l, StrykerOptions as m, Primitive as n, propertyPath as o, ReportType as p, PropertyPathOverloads as r, strykerCoreSchema as s, KnownKeys as t, LogLevel as u };

package/dist/Schema.d.mts

@@ -0,0 +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-Df2kA6F7.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

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

package/dist/TestRunner-DC9U8Unb.mjs

@@ -0,0 +1,181 @@
+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 * as S from "effect/Schema";
+//#region src/TestRunner.schema.ts
+const DryRunStatus = S.Literals([
+	"complete",
+	"error",
+	"timeout"
+]);
+const TestStatus = S.Literals([
+	"success",
+	"failed",
+	"skipped"
+]);
+const MutantRunStatus = S.Literals([
+	"killed",
+	"survived",
+	"timeout",
+	"error"
+]);
+const TestResultBase = {
+	id: S.String,
+	name: S.String,
+	timeSpentMs: S.Finite,
+	fileName: S.optionalKey(S.String),
+	startPosition: S.optionalKey(PositionSchema)
+};
+const TestResultSchema = S.Union([
+	S.Struct({
+		...TestResultBase,
+		status: S.Literal("failed"),
+		failureMessage: S.String
+	}),
+	S.Struct({
+		...TestResultBase,
+		status: S.Literal("skipped")
+	}),
+	S.Struct({
+		...TestResultBase,
+		status: S.Literal("success")
+	})
+]);
+const MutantCoverageSchema = S.Struct({
+	perTest: S.Record(S.String, S.Record(S.String, S.Finite)),
+	static: S.Record(S.String, S.Finite)
+});
+const DryRunResultSchema = S.Union([
+	S.Struct({
+		status: S.Literal("complete"),
+		tests: S.Array(TestResultSchema),
+		mutantCoverage: S.optionalKey(MutantCoverageSchema)
+	}),
+	S.Struct({
+		status: S.Literal("timeout"),
+		reason: S.optionalKey(S.String)
+	}),
+	S.Struct({
+		status: S.Literal("error"),
+		errorMessage: S.String
+	})
+]);
+const MutantRunResultSchema = S.Union([
+	S.Struct({
+		status: S.Literal("killed"),
+		killedBy: S.Array(S.String),
+		failureMessage: S.String,
+		nrOfTests: S.Finite
+	}),
+	S.Struct({
+		status: S.Literal("survived"),
+		nrOfTests: S.Finite
+	}),
+	S.Struct({
+		status: S.Literal("timeout"),
+		reason: S.optionalKey(S.String)
+	}),
+	S.Struct({
+		status: S.Literal("error"),
+		errorMessage: S.String
+	})
+]);
+const CoverageAnalysisSchema = S.Literals([
+	"off",
+	"all",
+	"perTest"
+]);
+const RunOptionsFields = {
+	timeout: S.Finite,
+	disableBail: S.Boolean
+};
+const DryRunOptionsSchema = S.Struct({
+	...RunOptionsFields,
+	coverageAnalysis: CoverageAnalysisSchema,
+	files: S.optionalKey(S.Array(S.String)),
+	testFiles: S.optionalKey(S.Array(S.String))
+});
+const MutantActivationSchema = S.Literals(["runtime", "static"]);
+const MutantRunOptionsSchema = S.Struct({
+	...RunOptionsFields,
+	activeMutant: Mutant,
+	sandboxFileName: S.String,
+	mutantActivation: MutantActivationSchema,
+	reloadEnvironment: S.Boolean,
+	testFilter: S.optionalKey(S.Array(S.String)),
+	hitLimit: S.optionalKey(S.Finite)
+});
+const TestRunnerCapabilitiesSchema = S.Struct({ reloadEnvironment: S.Boolean });
+var TestRunnerFailed = class extends S.TaggedError()("TestRunnerFailed", {
+	cause: S.String,
+	phase: S.Literals([
+		"capabilities",
+		"dispose",
+		"dryRun",
+		"init",
+		"mutantRun"
+	]),
+	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 };

package/dist/TestRunner.d.mts

@@ -0,0 +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";
+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

@@ -0,0 +1,2 @@
+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 };

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+import { i as Checker_d_exports } from "./Checker-DYgIIEai.mjs";
+import { Z as TestRunner_d_exports, v as Mutant_d_exports } from "./Mutant-BPRJTF8f.mjs";
+import { r as Ignorer_d_exports } from "./Ignorer-BUY68FZQ.mjs";
+import { s as Plugin_d_exports } from "./Plugin-ZYNaWrl7.mjs";
+import { u as Reporter_d_exports } from "./Reporter-eZ3M7lO6.mjs";
+import { a as Run_d_exports } from "./Run-BudLsVwF.mjs";
+import { a as Schema_d_exports } from "./Schema-Df2kA6F7.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

@@ -0,0 +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-lXratlN7.mjs";
+import { n as Schema_exports } from "./Schema-C7nahULg.mjs";
+import { n as TestRunner_exports } from "./TestRunner-DC9U8Unb.mjs";
+export { Checker_exports as Checker, Ignorer_exports as Ignorer, Mutant_exports as Mutant, Plugin_exports as Plugin, Reporter_exports as Reporter, Run_exports as Run, Schema_exports as Schema, TestRunner_exports as TestRunner };

package/dist/output-file.d.mts

@@ -0,0 +1,8 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { PlatformError } from "effect/PlatformError";
+//#region src/output-file.d.ts
+declare const writeOutputFile: (fs: FileSystem.FileSystem, path: Path.Path, fileName: string, content: string) => Effect.Effect<void, PlatformError, never>;
+//#endregion
+export { writeOutputFile };

package/dist/output-file.mjs

@@ -0,0 +1,8 @@
+import * as Effect from "effect/Effect";
+//#region src/output-file.ts
+const writeOutputFile = (fs, path, fileName, content) => Effect.gen(function* () {
+	yield* fs.makeDirectory(path.dirname(fileName), { recursive: true });
+	yield* fs.writeFileString(fileName, content);
+});
+//#endregion
+export { writeOutputFile };