@systemfsoftware/stryker-js-mutation-run 1.2.5

package/dist/config/base.mjs

@@ -0,0 +1,47 @@
+import "@systemfsoftware/stryker-js-plugin-api/core";
+//#region src/config/base-preset.ts
+/**
+* Modal Stryker options, inherited via
+* `"extends": "@systemfsoftware/stryker-js-mutation-run/config/base"`.
+*
+* Relative paths below resolve against the working directory of the run that
+* reads them — the consuming package — not against this file.
+*/
+const basePreset = {
+	packageManager: "pnpm",
+	testRunner: "vitest",
+	checkers: ["typescript"],
+	plugins: [
+		"@systemfsoftware/stryker-js-vitest-runner",
+		"@systemfsoftware/stryker-js-typescript-checker",
+		"@systemfsoftware/stryker-plugins/effect-schema-ignorer",
+		"@systemfsoftware/stryker-plugins/workflow-make-ignorer"
+	],
+	reporters: [
+		"progress",
+		"html",
+		"json",
+		"progress-stream"
+	],
+	htmlReporter: { fileName: "reports/mutation-report.html" },
+	jsonReporter: { fileName: "reports/mutation-report.json" },
+	vitest: {
+		configFile: "vitest.config.ts",
+		dir: ".",
+		related: true
+	},
+	typescriptChecker: { prioritizePerformanceOverAccuracy: true },
+	coverageAnalysis: "perTest",
+	incremental: true,
+	incrementalFile: "reports/stryker-incremental.json",
+	ignorePatterns: ["reports", "coverage"],
+	disableBail: true,
+	ignorers: ["effect-schema-declarations"],
+	thresholds: {
+		high: 100,
+		low: 80,
+		break: 100
+	}
+};
+//#endregion
+export { basePreset as default };

package/dist/config/config-resolution.d.mts

@@ -0,0 +1,80 @@
+import "../errors-BkjxkY_S.mjs";
+import { PartialStrykerOptions, StrykerOptions } from "@systemfsoftware/stryker-js-plugin-api/core";
+import { I, Immutable } from "@stryker-mutator/util";
+import { Logger } from "@systemfsoftware/stryker-js-plugin-api/logging";
+//#region src/config/options-validator.d.ts
+/**
+ * The validation document. Its `properties` map names every option the core and
+ * the loaded plugins declare, which is what an unknown-option warning is keyed
+ * on. It is read as DATA only: validation itself runs on `StrykerOptionsSchema`,
+ * the same declaration the defaults come from.
+ */
+type ValidationSchemaDocument = {
+  readonly properties?: unknown;
+  readonly [key: string]: unknown;
+};
+declare class OptionsValidator {
+  private readonly schema;
+  private readonly log;
+  static readonly inject: ["validationSchema", "logger"];
+  constructor(schema: ValidationSchemaDocument, log: Logger);
+  /**
+   * Validates the provided options, throwing an error if something is wrong.
+   * Optionally also warns about excess or unserializable options.
+   * @param options The stryker options to validate
+   * @param mark Wether or not to log warnings on unknown properties or unserializable properties
+   */
+  validate(options: Record<string, unknown>, mark?: boolean): asserts options is StrykerOptions;
+  /**
+   * Hard-fails on config names the rebuild removed (U2-U9): a removed
+   * top-level key (`dashboard`, `eventReporter`) or a removed reporter name
+   * inside `reporters` (`dots`, `event-recorder`, `progress-append-only`,
+   * `dashboard`). Runs ahead of `schemaValidate` because a removed key is
+   * absent from the AJV schema, so schema validation can never see it, and
+   * the warning path (`markExcessOptions`) only fires when `mark` is set and
+   * the `unknownOptions` warning is enabled — a removed key could otherwise
+   * be silently accepted. Only the known-removed names are checked; an
+   * unknown-but-not-removed key keeps its warning-only behaviour.
+   */
+  private validateRemovedSurface;
+  private removeDeprecatedOptions;
+  private static recordOf;
+  private removeStringMutator;
+  private removeMutatorName;
+  private removeTestFramework;
+  private removeTranspilers;
+  private rewriteFiles;
+  private removeJestEnableBail;
+  private removeHtmlReporterBaseDir;
+  private migrateMaxConcurrentTestRunners;
+  private customValidation;
+  /**
+   * Decodes the options against their declaration, then writes the result back
+   * onto the caller's object: the previous engine filled defaults in place and
+   * every caller reads them off the object it passed, so the fill has to land
+   * there rather than in a copy.
+   */
+  private schemaValidate;
+  private throwErrorIfNeeded;
+  private markOptions;
+  private markExcessOptions;
+  private markUnserializableOptions;
+}
+declare const defaultOptions: Immutable<StrykerOptions>;
+//#endregion
+//#region src/config/config-reader.d.ts
+declare class ConfigReader {
+  private readonly log;
+  private readonly validator;
+  static inject: ["logger", "optionsValidator"];
+  constructor(log: Logger, validator: I<OptionsValidator>);
+  readConfig(cliOptions: PartialStrykerOptions): Promise<StrykerOptions>;
+  private loadOptionsFromConfigFile;
+  private findConfigFile;
+  private readJsonConfig;
+  private importJSConfig;
+  private importJSConfigModule;
+  private hasDefaultExport;
+}
+//#endregion
+export { ConfigReader, OptionsValidator, defaultOptions };

package/dist/config/config-resolution.mjs

@@ -0,0 +1,2 @@
+import { d as ConfigReader, n as OptionsValidator, r as defaultOptions } from "../plugins-Nx86IJQW.mjs";
+export { ConfigReader, OptionsValidator, defaultOptions };

package/dist/config/fork-schema.d.mts

@@ -0,0 +1,5 @@
+//#region src/config/fork-schema.d.ts
+/** The fork's option document: `StrykerOptionsSchema` minus the removed surface, plus the fork options. */
+declare const forkCoreSchema: Record<string, unknown>;
+//#endregion
+export { forkCoreSchema };

package/dist/config/fork-schema.mjs

@@ -0,0 +1,2 @@
+import { t as forkCoreSchema } from "../fork-schema-BHuTbRBR.mjs";
+export { forkCoreSchema };

package/dist/errors-BkjxkY_S.d.mts

@@ -0,0 +1,6 @@
+import { StrykerError } from "@stryker-mutator/util";
+//#region src/errors.d.ts
+declare class ConfigError extends StrykerError {}
+declare function retrieveCause(error: unknown): unknown;
+//#endregion
+export { retrieveCause as n, ConfigError as t };

package/dist/errors.d.mts

@@ -0,0 +1,2 @@
+import { n as retrieveCause, t as ConfigError } from "./errors-BkjxkY_S.mjs";
+export { ConfigError, retrieveCause };

package/dist/errors.mjs

@@ -0,0 +1,10 @@
+import { InjectionError } from "typed-inject";
+import { StrykerError } from "@stryker-mutator/util";
+//#region src/errors.ts
+var ConfigError = class extends StrykerError {};
+function retrieveCause(error) {
+	if (error instanceof InjectionError) return error.cause;
+	else return error;
+}
+//#endregion
+export { ConfigError, retrieveCause };

package/dist/exit-classification.d.mts

@@ -0,0 +1,28 @@
+//#region src/exit-classification.d.ts
+/**
+ * The classed process exit codes (R6). The final code is decided once, at
+ * teardown, by the precedence `signal > 4 > 3 > 2 > 1 > 0`; verdict gates
+ * record a pending class instead of writing `process.exitCode` directly.
+ */
+declare enum ExitClass {
+  VerdictFail = 1,
+  ConfigError = 2,
+  RuntimeError = 3,
+  InternalError = 4
+}
+declare function setPendingExitClass(exitClass: ExitClass): void;
+declare function getPendingExitClasses(): ReadonlySet<ExitClass>;
+/**
+ * Resolves the final process exit code (R6): a terminating signal wins over
+ * every pending class and maps to the POSIX `128 + n` convention; otherwise
+ * the highest pending class wins; no signal and no pending class is 0.
+ *
+ * Pure function — unit-tested over the whole precedence matrix.
+ *
+ * @param pending the classes recorded by the verdict gates
+ * @param signal the OS signal number that terminated the run, if any
+ * (SIGINT = 2, SIGTERM = 15, …)
+ */
+declare function resolveExitCode(pending: ReadonlySet<ExitClass>, signal: number | null): number;
+//#endregion
+export { ExitClass, getPendingExitClasses, resolveExitCode, setPendingExitClass };

package/dist/exit-classification.mjs

@@ -0,0 +1,39 @@
+//#region src/exit-classification.ts
+/**
+* The classed process exit codes (R6). The final code is decided once, at
+* teardown, by the precedence `signal > 4 > 3 > 2 > 1 > 0`; verdict gates
+* record a pending class instead of writing `process.exitCode` directly.
+*/
+let ExitClass = /* @__PURE__ */ function(ExitClass) {
+	ExitClass[ExitClass["VerdictFail"] = 1] = "VerdictFail";
+	ExitClass[ExitClass["ConfigError"] = 2] = "ConfigError";
+	ExitClass[ExitClass["RuntimeError"] = 3] = "RuntimeError";
+	ExitClass[ExitClass["InternalError"] = 4] = "InternalError";
+	return ExitClass;
+}({});
+const pendingExitClasses = /* @__PURE__ */ new Set();
+function setPendingExitClass(exitClass) {
+	pendingExitClasses.add(exitClass);
+}
+function getPendingExitClasses() {
+	return pendingExitClasses;
+}
+/**
+* Resolves the final process exit code (R6): a terminating signal wins over
+* every pending class and maps to the POSIX `128 + n` convention; otherwise
+* the highest pending class wins; no signal and no pending class is 0.
+*
+* Pure function — unit-tested over the whole precedence matrix.
+*
+* @param pending the classes recorded by the verdict gates
+* @param signal the OS signal number that terminated the run, if any
+* (SIGINT = 2, SIGTERM = 15, …)
+*/
+function resolveExitCode(pending, signal) {
+	if (signal !== null) return 128 + signal;
+	let code = 0;
+	for (const exitClass of pending) if (exitClass > code) code = exitClass;
+	return code;
+}
+//#endregion
+export { ExitClass, getPendingExitClasses, resolveExitCode, setPendingExitClass };

package/dist/fork-schema-BHuTbRBR.mjs

@@ -0,0 +1,62 @@
+import { StrykerOptionsSchema } from "@systemfsoftware/stryker-js-plugin-api/core";
+import { Effect } from "effect";
+import * as S from "effect/Schema";
+//#region src/config/removed-surface.ts
+/**
+* Config-file names the rebuild removed, mapped to their remediation.
+*
+* Separate module because its two consumers cannot import each other:
+* `options-validator.ts` rejects these names, and `fork-schema.ts` deletes
+* them from the schema so their defaults are never injected. The validator
+* already imports the fork schema, so this cannot live there.
+*
+* Deliberately absent: CI-provider, initializer and dropped-command options
+* (no config-file surface, environment variables and commands only); flags
+* dropped from the CLI that were never config keys (`--files`,
+* `--allowConsoleColors`, `--dashboard.*`), which fail as unknown arguments;
+* and deprecated-but-migrated keys (`files`, `transpilers`, `testFramework`),
+* which `removeDeprecatedOptions` rewrites and which stay soft on purpose.
+*/
+const REMOVED_OPTIONS = {
+	"dots": "the \"dots\" reporter was removed; use \"clear-text\" instead",
+	"event-recorder": "the \"event-recorder\" reporter was removed; use the \"json\" reporter or the machine-mode progress stream for structured output",
+	"progress-append-only": "the \"progress-append-only\" reporter was removed; use \"progress-stream\" instead",
+	"dashboard": "the \"dashboard\" reporter and its options were removed; write the \"json\" or \"html\" report and publish it yourself",
+	"eventReporter": "the event-recorder reporter was removed; remove this option"
+};
+//#endregion
+//#region src/config/fork-schema.schema.ts
+const requireTestContribution = S.NullOr(S.Array(S.String)).pipe(S.annotate({
+	default: [
+		".workflow.property.test.ts",
+		".policy.property.test.ts",
+		".kernel.property.test.ts"
+	],
+	description: "Fail the run when a test file whose name ends with one of these suffixes kills no mutant that another test file does not also kill. Such a file could be deleted without leaving a single mutant alive, so a passing mutation score is no evidence it earns its place. Set to null to disable the check. The gate only applies to file classes the mutation operators can express — workflow, policy, and kernel property tests today; schema refusal tests are gated by refutation adequacy rather than by mutation."
+}), S.withDecodingDefaultKey(Effect.succeed([
+	".workflow.property.test.ts",
+	".policy.property.test.ts",
+	".kernel.property.test.ts"
+])));
+const survivorsPriorReport = S.optionalKey(S.String.pipe(S.annotate({ description: "The path of the prior mutation report a --survivors run admits against and re-tests the survivors of. Defaults to \"reports/mutation-report.json\" when unset. Deliberately has no default: a default would be injected into every resolved options object and written into every report, poisoning the KTD7 marker that identifies a report produced by a survivors run." })));
+const extendsPropertySchema = S.optionalKey(S.String.pipe(S.annotate({ description: "Path to another stryker config file whose options merge underneath this one. Resolved relative to this file. A child scalar or array replaces the inherited value; a child object merges one level deep; a child key set to null deletes the inherited key. Inheritance chains are not rewritten, so an inherited relative path value still resolves against the working directory of the run that reads it." })));
+/**
+* The option document schema, composed from the single `StrykerOptionsSchema`
+* the plugin-api declares. The upstream schema still declares the removed
+* options, several with defaults: AJV injects a default for every declared
+* property, so leaving them here would put `dashboard` and `eventReporter`
+* into the resolved options of runs whose config never mentioned them.
+* Dropping the fields removes the defaults with them.
+*/
+const forkOptionsSchema = S.StructWithRest(S.Struct({
+	...Object.fromEntries(Object.entries(StrykerOptionsSchema.schema.fields).filter(([name]) => !Object.hasOwn(REMOVED_OPTIONS, name))),
+	requireTestContribution,
+	survivorsPriorReport,
+	extends: extendsPropertySchema
+}), [S.Record(S.String, S.Unknown)]);
+//#endregion
+//#region src/config/fork-schema.ts
+/** The fork's option document: `StrykerOptionsSchema` minus the removed surface, plus the fork options. */
+const forkCoreSchema = S.toJsonSchemaDocument(forkOptionsSchema).schema;
+//#endregion
+export { REMOVED_OPTIONS as n, forkCoreSchema as t };

package/dist/incremental-differ-DDVwtXBn.d.mts

@@ -0,0 +1,72 @@
+import { CoverageData, FileDescriptions, Mutant, StrykerOptions, schema } from "@systemfsoftware/stryker-js-plugin-api/core";
+import { I } from "@stryker-mutator/util";
+import { Logger } from "@systemfsoftware/stryker-js-plugin-api/logging";
+import { CompleteDryRunResult, TestResult } from "@systemfsoftware/stryker-js-plugin-api/test-runner";
+//#region src/mutants/diff-statistics-collector.d.ts
+declare class DiffChanges {
+  added: number;
+  removed: number;
+  toString(): string;
+}
+type DiffChange = 'added' | 'removed';
+declare class DiffStatisticsCollector {
+  readonly changesByFile: Map<string, DiffChanges>;
+  readonly total: DiffChanges;
+  count(file: string, change: DiffChange, amount?: number): void;
+  createDetailedReport(): string[];
+  createTotalsReport(): string;
+}
+//#endregion
+//#region src/mutants/test-coverage.d.ts
+declare class TestCoverage {
+  #private;
+  constructor(testsByMutantId: Map<string, Set<TestResult>>, testsById: Map<string, TestResult>, staticCoverage: CoverageData | undefined, hitsByMutantId: Map<string, number>);
+  get testsByMutantId(): ReadonlyMap<string, Set<TestResult>>;
+  get testsById(): ReadonlyMap<string, TestResult>;
+  get hitsByMutantId(): ReadonlyMap<string, number>;
+  get hasCoverage(): boolean;
+  hasStaticCoverage(mutantId: string): boolean;
+  addTest(testResult: TestResult): void;
+  addCoverage(mutantId: string, testIds: string[]): void;
+  forMutant(mutantId: string): ReadonlySet<TestResult> | undefined;
+  static from: typeof testCoverageFrom;
+}
+declare function testCoverageFrom({ tests, mutantCoverage }: CompleteDryRunResult, logger: Logger): TestCoverage;
+//#endregion
+//#region src/mutants/incremental-differ.d.ts
+/**
+ * This class is responsible for calculating the diff between a run and a previous run based on the incremental report.
+ *
+ * Since the ids of tests and mutants can differ across reports (they are only unique within 1 report), this class
+ * identifies mutants and tests by attributes that make them unique:
+ * - Mutant: file name, mutator name, location and replacement
+ * - Test: test name, test file name (if present) and location (if present).
+ *
+ * We're storing these identifiers in local variables (maps and sets) as strings.
+ * We should move to 'records' for these when they come available: https://github.com/tc39/proposal-record-tuple
+ *
+ * A mutant result from the previous run is reused if the following conditions were met:
+ * - The location of the mutant refers to a piece of code that didn't change
+ * - If mutant was killed:
+ *   - The culprit test wasn't changed
+ * - If the mutant survived:
+ *   - No test was added, and the mutant is not static. Static mutants are
+ *     attributed to no test, so no test change can ever invalidate one; reusing
+ *     a non-killed verdict for one would freeze it permanently.
+ *
+ * It uses google's "diff-match-patch" project to calculate the new locations for tests and mutants, see https://github.com/google/diff-match-patch.
+ */
+declare class IncrementalDiffer {
+  private readonly logger;
+  private readonly options;
+  mutantStatisticsCollector: DiffStatisticsCollector | undefined;
+  testStatisticsCollector: DiffStatisticsCollector | undefined;
+  private readonly mutateDescriptionByRelativeFileName;
+  static inject: readonly ["logger", "options", "fileDescriptions"];
+  constructor(logger: Logger, options: StrykerOptions, fileDescriptions: FileDescriptions);
+  private isInMutatedScope;
+  diff(currentMutants: readonly Mutant[], testCoverage: I<TestCoverage>, incrementalReport: schema.MutationTestResult, currentRelativeFiles: Map<string, string>): readonly Mutant[];
+}
+declare function toRelativeNormalizedFileName(fileName: string | undefined): string;
+//#endregion
+export { toRelativeNormalizedFileName as n, IncrementalDiffer as t };