@systemfsoftware/stryker-js 3.0.2 → 4.0.0

package/dist/index.d.mts

@@ -1,8 +1,1603 @@
-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 { a as Schema_d_exports } from "./Schema-4oCWQ0P0.mjs";
-import { s as Plugin_d_exports } from "./Plugin-BtItMchw.mjs";
-import { n as Reporter_d_exports } from "./Reporter-C7ysGxqX.mjs";
-import { a as Run_d_exports } from "./Run-BUpNSmcM.mjs";
-export { Checker_d_exports as Checker, Ignorer_d_exports as Ignorer, Mutant_d_exports as Mutant, Plugin_d_exports as Plugin, Reporter_d_exports as Reporter, Run_d_exports as Run, Schema_d_exports as Schema, TestRunner_d_exports as TestRunner };
+import * as Cause from 'effect/Cause';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as FileSystem from 'effect/FileSystem';
+import * as HashMap from 'effect/HashMap';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Path from 'effect/Path';
+import * as Queue from 'effect/Queue';
+import * as S from 'effect/Schema';
+import { StandardSchemaV1 } from 'effect/StandardSchema';
+import { YieldableError } from 'effect/Cause';
+
+export declare type AnyPluginContribution = { [K in PluginKind]: PluginContribution<K>; }[PluginKind];
+
+export declare interface BaseTestResult {
+    readonly id: string;
+    readonly name: string;
+    readonly timeSpentMs: number;
+    readonly fileName?: string;
+    readonly startPosition?: Position;
+}
+
+export declare type BrandingInformation = typeof BrandingInformationSchema.Type;
+
+export declare const BrandingInformationSchema: S.Struct<{
+    readonly homepageUrl: S.String;
+    readonly imageUrl: S.optional<S.String>;
+}>;
+
+export declare const calculateMetrics: (files: Readonly<Record<string, FileResult>>) => MetricsResult;
+
+export declare const causeText: (cause: unknown, depth: number) => string | undefined;
+
+export declare class Checker extends Checker_base {}
+
+declare const Checker_base: Context.ServiceClass<Checker, "~@systemfsoftware/stryker-js/Checker", CheckerService>;
+
+export declare class CheckerFailed extends CheckerFailed_base {}
+
+declare const CheckerFailed_base: S.Class<CheckerFailed, S.TaggedStruct<"CheckerFailed", {
+    readonly cause: S.String;
+    readonly checkerName: S.String;
+    readonly mutantIds: S.$Array<S.String>;
+}>, YieldableError>;
+
+export declare interface CheckerService {
+    readonly init: Effect.Effect<void, CheckerFailed>;
+    readonly check: (mutants: readonly Mutant[]) => Effect.Effect<HashMap.HashMap<string, CheckResult>, CheckerFailed>;
+    readonly group: (mutants: readonly Mutant[]) => Effect.Effect<readonly (readonly string[])[], CheckerFailed>;
+}
+
+export declare type CheckResult = FailedCheckResult | PassedCheckResult;
+
+export declare const CheckResultSchema: S.Union<readonly [S.Struct<{
+    readonly status: S.Literal<"passed">;
+}>, S.Struct<{
+    readonly status: S.Literal<"compileError">;
+    readonly reason: S.String;
+}>]>;
+
+export declare const CheckStatus: S.Literals<readonly ["passed", "compileError"]>;
+
+export declare type CheckStatus = typeof CheckStatus.Type;
+
+export declare const classifyExit: (command: ClassifyExitCommand) => ClassifyExitDecision;
+
+export declare class ClassifyExitCommand extends ClassifyExitCommand_base {}
+
+declare const ClassifyExitCommand_base: S.Class<ClassifyExitCommand, S.TaggedStruct<"ClassifyExitCommand", {
+    readonly pending: S.$Array<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
+    readonly signal: S.NullOr<S.Number>;
+    readonly score: S.NullOr<S.Number>;
+    readonly breakingThreshold: S.NullOr<S.Number>;
+}>, {}>;
+
+export declare class ClassifyExitDecision extends ClassifyExitDecision_base {}
+
+declare const ClassifyExitDecision_base: S.Class<ClassifyExitDecision, S.TaggedStruct<"ClassifyExitDecision", {
+    readonly highestClass: S.NullOr<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
+    readonly verdictClass: S.NullOr<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
+}>, {}>;
+
+export declare type CommandRunnerOptions = S.Schema.Type<typeof CommandRunnerOptionsSchema>;
+
+export declare const CommandRunnerOptionsSchema: S.StructWithRest<S.Struct<{
+    readonly command: S.withDecodingDefaultKey<S.String, never>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+
+export declare interface CompleteDryRunResult {
+    readonly tests: readonly TestResult[];
+    readonly mutantCoverage?: MutantCoverage;
+    readonly status: 'complete';
+}
+
+export declare interface ComposedPlugins {
+    readonly layer: Option.Option<Layer.Layer<MergedPluginServices, never, PluginEnvironment>>;
+    readonly reporterFactories: readonly SelectedReporterFactory[];
+    readonly shadowings: readonly Shadowing[];
+}
+
+export declare function composePlugins(contributions: readonly AnyPluginContribution[]): ComposedPlugins;
+
+export declare type ContributionOf<K extends PluginKind> = Extract<AnyPluginContribution, {
+    readonly kind: K;
+}>;
+
+export declare const countMutants: (mutants: readonly MutantResult[]) => Metrics;
+
+export declare interface Coverage {
+    readonly static: CoverageData;
+    readonly perTest: CoveragePerTestId;
+}
+
+export declare type CoverageAnalysis = 'off' | 'all' | 'perTest';
+
+declare const CoverageAnalysisMode: S.Literals<readonly ["off", "all", "perTest"]>;
+
+declare type CoverageAnalysisMode = typeof CoverageAnalysisMode.Type;
+export { CoverageAnalysisMode }
+export { CoverageAnalysisMode as CoverageAnalysisModeType }
+
+export declare const CoverageAnalysisSchema: S.Literals<readonly ["off", "all", "perTest"]>;
+
+export declare type CoverageData = Record<string, number>;
+
+export declare type CoveragePerTestId = Record<string, CoverageData>;
+
+export declare function declarePlugin(kind: 'Reporter', name: string, make: ReporterFactory): PluginContribution<'Reporter'>;
+
+export declare function declarePlugin<K extends PluginLayerKind>(kind: K, name: string, layer: Layer.Layer<PluginInterfaces[K], never, PluginEnvironment>): PluginContribution<K>;
+
+/**
+ * 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.
+ */
+export declare type DeepOptional<T> = { -readonly [P in keyof T]?: T[P] extends Record<string, unknown> ? DeepOptional<T[P]> | undefined : T[P]; };
+
+export declare type Dependencies = typeof DependenciesSchema.Type;
+
+export declare const DependenciesSchema: S.$Record<S.String, S.String>;
+
+export declare class DryRunCompleted extends DryRunCompleted_base {}
+
+declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dryRunCompleted", {
+    readonly timing: S.Struct<{
+        readonly net: S.Finite;
+        readonly overhead: S.Finite;
+    }>;
+    readonly capabilities: S.Struct<{
+        readonly reloadEnvironment: S.Boolean;
+    }>;
+    readonly testCount: S.Finite;
+    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">;
+    }>]>>;
+}>, {}>;
+
+export declare interface DryRunOptions extends RunOptions {
+    readonly coverageAnalysis: CoverageAnalysis;
+    readonly files?: readonly string[];
+    readonly testFiles?: readonly string[];
+}
+
+export declare const DryRunOptionsSchema: S.Struct<{
+    readonly timeout: S.Finite;
+    readonly disableBail: S.Boolean;
+    readonly coverageAnalysis: S.Literals<readonly ["off", "all", "perTest"]>;
+    readonly files: S.optionalKey<S.$Array<S.String>>;
+    readonly testFiles: S.optionalKey<S.$Array<S.String>>;
+}>;
+
+export declare type DryRunResult = CompleteDryRunResult | ErrorDryRunResult | TimeoutDryRunResult;
+
+export declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
+    readonly status: S.Literal<"complete">;
+    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">;
+    }>]>>;
+    readonly mutantCoverage: S.optionalKey<S.Struct<{
+        readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
+        readonly static: S.$Record<S.String, S.Finite>;
+    }>>;
+}>, S.Struct<{
+    readonly status: S.Literal<"timeout">;
+    readonly reason: S.optionalKey<S.String>;
+}>, S.Struct<{
+    readonly status: S.Literal<"error">;
+    readonly errorMessage: S.String;
+}>]>;
+
+export declare const DryRunStatus: S.Literals<readonly ["complete", "error", "timeout"]>;
+
+export declare type DryRunStatus = typeof DryRunStatus.Type;
+
+export declare interface EarlyResultPlan {
+    readonly plan: 'EarlyResult';
+    readonly mutant: Mutant;
+}
+
+export declare interface ErrnoException extends Error {
+    code?: string;
+    errno?: number;
+    path?: string;
+    syscall?: string;
+}
+
+export declare const ERROR_CODES: Readonly<{
+    NoSuchFileOrDirectory: 'ENOENT';
+}>;
+
+export declare interface ErrorDryRunResult {
+    readonly status: 'error';
+    readonly errorMessage: string;
+}
+
+export declare interface ErrorMutantRunResult {
+    readonly status: 'error';
+    readonly errorMessage: string;
+}
+
+export declare function errorToString(error: unknown): string;
+
+export declare class Evaluator extends Evaluator_base {}
+
+declare const Evaluator_base: Context.ServiceClass<Evaluator, "~@systemfsoftware/stryker-js/Evaluator", EvaluatorService>;
+
+export declare class EvaluatorFailed extends EvaluatorFailed_base {}
+
+declare const EvaluatorFailed_base: S.Class<EvaluatorFailed, S.TaggedStruct<"EvaluatorFailed", {
+    readonly cause: S.Unknown;
+}>, YieldableError>;
+
+export declare interface EvaluatorService {
+    readonly evaluate: (report: MutationTestResult) => Effect.Effect<ExitClass | null, EvaluatorFailed>;
+}
+
+export declare const EXIT_CODE: Record<ExitClass, number>;
+
+export declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
+
+export declare type ExitClass = typeof ExitClass.Type;
+
+export declare interface FailedCheckResult {
+    readonly reason: string;
+    readonly status: 'compileError';
+}
+
+export declare interface FailedTestResult extends BaseTestResult {
+    readonly status: 'failed';
+    readonly failureMessage: string;
+}
+
+export declare interface FileDescription {
+    readonly mutate: MutateDescription;
+}
+
+export declare type FileDescriptions = Record<string, FileDescription>;
+
+export declare type FileResult = typeof FileResultSchema.Type;
+
+export declare type FileResultDictionary = typeof FileResultDictionarySchema.Type;
+
+export declare const FileResultDictionarySchema: 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>;
+    }>>;
+}>>;
+
+export declare const FileResultSchema: 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>;
+    }>>;
+}>;
+
+export declare type FrameworkInformation = typeof FrameworkInformationSchema.Type;
+
+export declare const FrameworkInformationSchema: 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>>;
+}>;
+
+export declare class Heartbeat extends Heartbeat_base {}
+
+declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
+    readonly elapsedMs: S.Finite;
+    readonly completed: S.Finite;
+    readonly total: S.NullOr<S.Finite>;
+}>, {}>;
+
+export declare class HelpRendered extends HelpRendered_base {}
+
+declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
+    readonly schemaVersion: S.String;
+    readonly code: S.Literals<readonly [0]>;
+    readonly help: S.String;
+}>, {}>;
+
+export declare function highestExitClass(pending: Iterable<ExitClass>): ExitClass | null;
+
+export declare class Ignorer extends Ignorer_base {}
+
+declare const Ignorer_base: Context.ServiceClass<Ignorer, "~@systemfsoftware/stryker-js/Ignorer", IgnorerService>;
+
+export declare interface IgnorerService {
+    readonly shouldIgnore: (path: NodePath) => Option.Option<string>;
+}
+
+export declare const INSTRUMENTER_CONSTANTS: Readonly<{
+    NAMESPACE: '__stryker__';
+    MUTATION_COVERAGE_OBJECT: 'mutantCoverage';
+    ACTIVE_MUTANT: 'activeMutant';
+    CURRENT_TEST_ID: 'currentTestId';
+    HIT_COUNT: 'hitCount';
+    HIT_LIMIT: 'hitLimit';
+    ACTIVE_MUTANT_ENV_VARIABLE: '__STRYKER_ACTIVE_MUTANT__';
+}>;
+
+export declare interface InstrumenterContext {
+    activeMutant?: string;
+    currentTestId?: string;
+    mutantCoverage?: MutantCoverage;
+    hitCount?: number;
+    hitLimit?: number;
+}
+
+export declare function isErrnoException(error: unknown): error is ErrnoException;
+
+export declare const isMutant: (value: unknown) => value is Mutant;
+
+export declare interface KilledMutantRunResult {
+    readonly status: 'killed';
+    readonly killedBy: readonly string[];
+    readonly failureMessage: string;
+    readonly nrOfTests: number;
+}
+
+/**
+ * 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
+ */
+export declare type KnownKeys<T> = keyof { [P in keyof T as string extends P ? never : number extends P ? never : P]: T[P]; };
+
+export declare type Location = typeof LocationSchema.Type;
+
+export declare const LocationSchema: 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;
+    }>;
+}>;
+
+declare const LogLevel: S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>;
+
+/** The generated module exported these as TypeScript types; consumers still name them that way. */
+declare type LogLevel = typeof LogLevel.Type;
+export { LogLevel }
+export { LogLevel as LogLevelType }
+
+export declare type MergedPluginServices = Checker & Ignorer & TestRunner;
+
+export declare type Metrics = typeof MetricsSchema.Type;
+
+export declare interface MetricsResult {
+    readonly name: string;
+    readonly metrics: Metrics;
+    readonly childResults: readonly MetricsResult[];
+}
+
+export declare const MetricsResultSchema: 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>>>;
+}>;
+
+export declare const MetricsSchema: 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;
+}>;
+
+export declare const ModeSignal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+
+export declare type ModeSignal = typeof ModeSignal.Type;
+
+/**
+ * Port over the host module loader, shaped as the subset of `node:module`
+ * feature code may use: `createRequire` and `isBuiltin`. Resolving a
+ * specifier against a project directory, importing a plugin, and asking
+ * whether a name is a builtin all go through this one tag; no feature module
+ * touches the host module API. The Node implementation ships in the
+ * composition-root package (`@systemfsoftware/stryker-js-cli`); tests that do
+ * not need real plugin resolution substitute a layer returning fixed paths.
+ *
+ * @since 2.0.0
+ */
+export declare class Module extends Module_base {}
+
+declare const Module_base: Context.ServiceClass<Module, "@systemfsoftware/stryker-js/Module", {
+    readonly createRequire: (filename: string | URL) => ModuleRequire;
+    readonly isBuiltin: (moduleName: string) => boolean;
+}>;
+
+/**
+ * The subset of `node:module`'s `createRequire` result this port certifies: a
+ * require function bound to one path, plus its resolution. Calling it loads
+ * the specifier exactly as a module evaluated next to that path would.
+ */
+export declare interface ModuleRequire {
+    (request: string): unknown;
+    resolve(request: string, options?: {
+        readonly paths?: readonly string[];
+    }): string;
+}
+
+export declare class Mutant extends Mutant_base {}
+
+declare const Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
+    readonly id: S.NonEmptyString;
+    readonly fileName: S.NonEmptyString;
+    readonly mutatorName: S.NonEmptyString;
+    readonly replacement: S.String;
+    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 status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
+    readonly statusReason: S.optional<S.String>;
+    readonly coveredBy: S.optional<S.$Array<S.String>>;
+    readonly static: S.optional<S.Boolean>;
+    readonly testsCompleted: S.optional<S.Finite>;
+    readonly description: S.optional<S.String>;
+}>, {}>;
+
+export declare type MutantActivation = 'runtime' | 'static';
+
+export declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
+
+export declare interface MutantCoverage {
+    readonly perTest: Record<string, Record<string, number>>;
+    readonly static: Record<string, number>;
+}
+
+export declare const MutantCoverageSchema: S.Struct<{
+    readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
+    readonly static: S.$Record<S.String, S.Finite>;
+}>;
+
+export declare type MutantResult = typeof MutantResultSchema.Type;
+
+export declare const MutantResultSchema: 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>;
+}>;
+
+export declare interface MutantRunOptions extends RunOptions {
+    readonly testFilter?: readonly string[];
+    readonly hitLimit?: number;
+    readonly activeMutant: Mutant;
+    readonly sandboxFileName: string;
+    readonly mutantActivation: MutantActivation;
+    readonly reloadEnvironment: boolean;
+}
+
+export declare const MutantRunOptionsSchema: S.Struct<{
+    readonly timeout: S.Finite;
+    readonly disableBail: S.Boolean;
+    readonly activeMutant: typeof Mutant;
+    readonly sandboxFileName: S.String;
+    readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
+    readonly reloadEnvironment: S.Boolean;
+    readonly testFilter: S.optionalKey<S.$Array<S.String>>;
+    readonly hitLimit: S.optionalKey<S.Finite>;
+}>;
+
+export declare type MutantRunPlan = RunPlan;
+
+export declare type MutantRunResult = ErrorMutantRunResult | KilledMutantRunResult | SurvivedMutantRunResult | TimeoutMutantRunResult;
+
+export declare const MutantRunResultSchema: S.Union<readonly [S.Struct<{
+    readonly status: S.Literal<"killed">;
+    readonly killedBy: S.$Array<S.String>;
+    readonly failureMessage: S.String;
+    readonly nrOfTests: S.Finite;
+}>, S.Struct<{
+    readonly status: S.Literal<"survived">;
+    readonly nrOfTests: S.Finite;
+}>, S.Struct<{
+    readonly status: S.Literal<"timeout">;
+    readonly reason: S.optionalKey<S.String>;
+}>, S.Struct<{
+    readonly status: S.Literal<"error">;
+    readonly errorMessage: S.String;
+}>]>;
+
+export declare const MutantRunStatus: S.Literals<readonly ["killed", "survived", "timeout", "error"]>;
+
+export declare type MutantRunStatus = typeof MutantRunStatus.Type;
+
+export declare type MutantStatus = typeof MutantStatusSchema.Type;
+
+export declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+
+export declare type MutantTestCoverage = Mutant & {
+    readonly coveredBy: ReadonlyArray<string> | undefined;
+    readonly static: boolean | undefined;
+};
+
+export declare class MutantTested extends MutantTested_base {}
+
+declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTested", {
+    readonly id: S.String;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    readonly file: S.String;
+    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;
+    readonly replacement: S.NullOr<S.String>;
+    readonly completed: S.Finite;
+    readonly total: S.Finite;
+}>, {}>;
+
+export declare type MutateDescription = ReadonlyArray<MutationRange> | boolean;
+
+export declare interface MutationRange {
+    readonly start: Position;
+    readonly end: Position;
+}
+
+export declare interface MutationRunIo {
+    readonly read: (command: RunCommand) => Effect.Effect<unknown, S.SchemaError, RunIdentity>;
+    readonly write: (output: RunOutput) => Effect.Effect<void, S.SchemaError, RunIdentity>;
+}
+
+export declare class MutationRunPlan extends MutationRunPlan_base {}
+
+declare const MutationRunPlan_base: S.Class<MutationRunPlan, S.TaggedStruct<"MutationRunPlan", {
+    readonly mutatePatterns: S.$Array<S.String>;
+    readonly mutatorNames: S.$Array<S.String>;
+}>, {}>;
+
+export declare type MutationScoreThresholds = typeof MutationScoreThresholdsSchema.Type;
+
+export declare const MutationScoreThresholdsSchema: S.Struct<{
+    readonly high: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly low: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
+}>;
+
+export declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
+
+declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S.TaggedStruct<"mutationTestingPlanReady", {
+    readonly total: S.Finite;
+    readonly plans: S.$Array<S.Struct<{
+        readonly mutantId: S.String;
+        readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
+        readonly netTime: S.Finite;
+        readonly reloadEnvironment: S.Boolean;
+    }>>;
+}>, {}>;
+
+export declare class MutationTestReportReady extends MutationTestReportReady_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>>>;
+    }>;
+}>, {}>;
+
+export declare type MutationTestResult = typeof MutationTestResultSchema.Type;
+
+export declare const MutationTestResultSchema: 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>>;
+    }>>;
+}>;
+
+export declare interface NodePath {
+    readonly node: unknown;
+    readonly parentPath?: NodePath | null;
+    isObjectExpression(): boolean;
+    isCallExpression(): boolean;
+    isClassProperty(): boolean;
+    isClassPrivateProperty(): boolean;
+    isClassAccessorProperty(): boolean;
+}
+
+export declare function normalizeFileName(fileName: string): string;
+
+export declare type OnlyObject<T> = Exclude<T, Primitive>;
+
+export declare type OpenEndLocation = typeof OpenEndLocationSchema.Type;
+
+export declare const OpenEndLocationSchema: 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;
+    }>>;
+}>;
+
+export declare const OutputMode: S.Literals<readonly ["human", "machine"]>;
+
+export declare type OutputMode = typeof OutputMode.Type;
+
+declare const PackageManager: S.Literals<readonly ["npm", "yarn", "pnpm"]>;
+
+declare type PackageManager = typeof PackageManager.Type;
+export { PackageManager }
+export { PackageManager as PackageManagerType }
+
+/**
+ * The deep-partial input type: when configuring Stryker, every option is
+ * optional, including deep properties like `dashboard.project`.
+ */
+export declare type PartialStrykerOptions = DeepOptional<StrykerOptions>;
+
+export declare interface PassedCheckResult {
+    readonly status: 'passed';
+}
+
+export declare class PhaseEntered extends PhaseEntered_base {}
+
+declare const PhaseEntered_base: S.Class<PhaseEntered, S.TaggedStruct<"phase", {
+    readonly phase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+    readonly elapsedMs: S.Finite;
+}>, {}>;
+
+export declare class PlanKnown extends PlanKnown_base {}
+
+declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
+    readonly total: S.Finite;
+}>, {}>;
+
+export declare const planMutationRun: (command: PlanMutationRunCommand) => MutationRunPlan;
+
+export declare class PlanMutationRunCommand extends PlanMutationRunCommand_base {}
+
+declare const PlanMutationRunCommand_base: S.Class<PlanMutationRunCommand, S.TaggedStruct<"PlanMutationRunCommand", {
+    readonly configMutatePatterns: S.$Array<S.String>;
+    readonly configMutatorNames: S.$Array<S.String>;
+    readonly targetMutatePatterns: S.$Array<S.String>;
+    readonly availableMutators: S.$Array<S.String>;
+}>, {}>;
+
+export declare type PluginContribution<K extends PluginKind = PluginKind> = K extends 'Reporter' ? PluginReporterContribution : PluginLayerContribution<Extract<K, PluginLayerKind>>;
+
+export declare type PluginEnvironment = RunConfiguration | SandboxDirectory | FileSystem.FileSystem | Module | Path.Path;
+
+export declare interface PluginInterfaces {
+    Checker: Checker;
+    TestRunner: TestRunner;
+    Ignore: Ignorer;
+    Evaluator: Evaluator;
+}
+
+export declare const PluginKind: S.Literals<readonly ["Checker", "TestRunner", "Reporter", "Ignore", "Evaluator"]>;
+
+export declare type PluginKind = typeof PluginKind.Type;
+
+export declare class PluginLayerContribution<K extends PluginLayerKind = PluginLayerKind> extends PluginLayerContribution_base {
+    readonly kind: K;
+    readonly name: string;
+    readonly layer: Layer.Layer<PluginInterfaces[K], never, PluginEnvironment>;
+}
+
+declare const PluginLayerContribution_base: S.Class<PluginLayerContribution<"Checker" | "Evaluator" | "Ignore" | "TestRunner">, S.TaggedStruct<"PluginContribution", {
+    readonly kind: S.Literals<readonly ["Checker", "TestRunner", "Ignore", "Evaluator"]>;
+    readonly name: S.String;
+    readonly layer: S.Unknown;
+}>, {}>;
+
+export declare const PluginLayerKind: S.Literals<readonly ["Checker", "TestRunner", "Ignore", "Evaluator"]>;
+
+export declare type PluginLayerKind = typeof PluginLayerKind.Type;
+
+export declare class PluginReporterContribution extends PluginReporterContribution_base {
+    readonly kind: 'Reporter';
+    readonly name: string;
+    readonly make: ReporterFactory;
+}
+
+declare const PluginReporterContribution_base: S.Class<PluginReporterContribution, S.TaggedStruct<"PluginContribution", {
+    readonly kind: S.Literals<readonly ["Checker", "TestRunner", "Reporter", "Ignore", "Evaluator"]>;
+    readonly name: S.String;
+    readonly make: S.Unknown;
+}>, {}>;
+
+export declare type Position = typeof PositionSchema.Type;
+
+export declare const PositionSchema: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+}>;
+
+export declare type Primitive = boolean | number | string | null | undefined;
+
+/**
+ * Given a base type, allows type safe access to the name of a property.
+ * @param prop - The property name
+ */
+export declare function propertyPath<T>(): PropertyPathOverloads<T>;
+
+export declare 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;
+}
+
+/**
+ * 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.
+ */
+export declare const RENDERED_OPTION_DEFAULTS: {
+    readonly coverageAnalysis: 'perTest';
+    readonly fileLogLevel: 'off';
+    readonly logLevel: 'info';
+    readonly tempDirName: '.stryker-tmp';
+};
+
+export declare type ReporterEvent = DryRunCompleted | MutationTestingPlanReady | MutantTested | MutationTestReportReady;
+
+export declare const ReporterEventKind: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
+
+export declare type ReporterEventKind = typeof ReporterEventKind.Type;
+
+export declare const ReporterEventSchema: StandardSchemaV1<unknown, ReporterEvent>;
+
+export declare const ReporterEventUnion: S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>;
+
+export declare type ReporterFactory = (options: StrykerOptions, init: ReporterInit) => (events: AsyncIterable<ReporterEvent>) => Promise<void>;
+
+export declare class ReporterFailed extends ReporterFailed_base {}
+
+declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"ReporterFailed", {
+    readonly cause: S.String;
+    readonly event: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
+    readonly reporterName: S.String;
+}>, YieldableError>;
+
+export declare interface ReporterInit {
+    readonly traceparent?: string | undefined;
+    readonly tracestate?: string | undefined;
+}
+
+export declare type ReporterPlanDescriptor = typeof ReporterPlanDescriptorSchema.Type;
+
+export declare const ReporterPlanDescriptorSchema: S.Struct<{
+    readonly mutantId: S.String;
+    readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
+    readonly netTime: S.Finite;
+    readonly reloadEnvironment: S.Boolean;
+}>;
+
+export declare const ReporterPlanKind: S.Literals<readonly ["EarlyResult", "Run"]>;
+
+export declare const ReportTypeType: S.Literals<readonly ["full", "mutationScore"]>;
+
+export declare type ReportTypeType = typeof ReportTypeType.Type;
+
+export declare function resolveExitCode(pending: Iterable<ExitClass>, signal: number | null): number;
+
+export declare class RunCommand extends RunCommand_base {}
+
+declare const RunCommand_base: S.Class<RunCommand, S.TaggedStruct<"RunCommand", {
+    readonly cliOptionsJson: S.String;
+    readonly targetMutatePatterns: S.$Array<S.String>;
+}>, {}>;
+
+export declare class RunConfiguration extends RunConfiguration_base {}
+
+declare const RunConfiguration_base: Context.ServiceClass<RunConfiguration, "~@systemfsoftware/stryker-js/RunConfiguration", {
+    readonly [x: string]: unknown;
+    readonly allowConsoleColors: boolean;
+    readonly buildCommand?: string | undefined;
+    readonly checkers: readonly string[];
+    readonly checkerNodeArgs: readonly string[];
+    readonly concurrency?: string | number | undefined;
+    readonly commandRunner: {
+        readonly [x: string]: unknown;
+        readonly command: string;
+    };
+    readonly coverageAnalysis: "all" | "off" | "perTest";
+    readonly clearTextReporter: {
+        readonly [x: string]: unknown;
+        readonly allowColor: boolean;
+        readonly allowEmojis: boolean;
+        readonly logTests: boolean;
+        readonly maxTestsToLog: number;
+        readonly reportTests: boolean;
+        readonly reportMutants: boolean;
+        readonly reportScoreTable: boolean;
+        readonly skipFull: boolean;
+    };
+    readonly dryRunOnly: boolean;
+    readonly ignorePatterns: readonly string[];
+    readonly ignoreStatic: boolean;
+    readonly incremental: boolean;
+    readonly incrementalFile: string;
+    readonly progressStreamFile: string;
+    readonly force: boolean;
+    readonly fileLogLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
+    readonly inPlace: boolean;
+    readonly logLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
+    readonly maxConcurrentTestRunners: number;
+    readonly maxTestRunnerReuse: number;
+    readonly mutate: readonly string[];
+    readonly mutator: {
+        readonly excludedMutations: readonly string[];
+    };
+    readonly packageManager?: "npm" | "pnpm" | "yarn" | undefined;
+    readonly plugins: readonly string[];
+    readonly appendPlugins: readonly string[];
+    readonly reporters: readonly string[];
+    readonly htmlReporter: {
+        readonly fileName: string;
+    };
+    readonly jsonReporter: {
+        readonly fileName: string;
+    };
+    readonly disableTypeChecks: string | boolean;
+    readonly symlinkNodeModules: boolean;
+    readonly tempDirName: string;
+    readonly cleanTempDir: "always" | boolean;
+    readonly testRunner: string;
+    readonly testRunnerNodeArgs: readonly string[];
+    readonly thresholds: {
+        readonly high: number;
+        readonly low: number;
+        readonly break: number | null;
+    };
+    readonly timeoutFactor: number;
+    readonly timeoutMS: number;
+    readonly dryRunTimeoutMinutes: number;
+    readonly tsconfigFile: string;
+    readonly warnings: boolean | {
+        readonly [x: string]: unknown;
+        readonly unknownOptions: boolean;
+        readonly preprocessorErrors: boolean;
+        readonly unserializableOptions: boolean;
+        readonly slow: boolean;
+    };
+    readonly disableBail: boolean;
+    readonly allowEmpty: boolean;
+    readonly ignorers: readonly string[];
+    readonly testFiles: readonly string[];
+}>;
+
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
+
+declare type RunEvent = typeof RunEvent.Type;
+export { RunEvent }
+export { RunEvent as RunEventType }
+
+export declare class RunEvents extends RunEvents_base {}
+
+declare const RunEvents_base: Context.ServiceClass<RunEvents, "~@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | PhaseEntered | PlanKnown | RunFailed | RunMutantTested | RunStarted | VerdictReached, Cause.Done<void>>>;
+
+export declare class RunFailed extends RunFailed_base {}
+
+declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
+    readonly schemaVersion: S.String;
+    readonly code: S.Finite;
+    readonly error: S.String;
+    readonly remediation: S.String;
+}>, {}>;
+
+export declare class RunIdentity extends RunIdentity_base {}
+
+declare const RunIdentity_base: Context.ServiceClass<RunIdentity, "~@systemfsoftware/stryker-js/RunIdentity", RunIdentityShape>;
+
+export declare interface RunIdentityShape {
+    readonly runId: string;
+    readonly basePath: string;
+}
+
+export declare type RunMutantResult = Mutant & {
+    readonly status: MutantStatus;
+    readonly statusReason?: string | undefined;
+    readonly testsCompleted?: number | undefined;
+    readonly killedBy?: readonly string[] | undefined;
+    readonly coveredBy?: readonly string[] | undefined;
+    readonly static?: boolean | undefined;
+};
+
+export declare class RunMutantTested extends RunMutantTested_base {}
+
+declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mutant", {
+    readonly id: S.String;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    readonly file: S.String;
+    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;
+    readonly replacement: S.NullOr<S.String>;
+    readonly completed: S.Finite;
+    readonly total: S.Finite;
+}>, {}>;
+
+export declare const runMutationTest: (io: MutationRunIo, command: RunCommand) => Effect.Effect<void, S.SchemaError, RunIdentity>;
+
+export declare interface RunOptions {
+    readonly timeout: number;
+    readonly disableBail: boolean;
+}
+
+export declare class RunOutput extends RunOutput_base {}
+
+declare const RunOutput_base: S.Class<RunOutput, S.TaggedStruct<"RunOutput", {
+    readonly verdictJson: S.String;
+    readonly exitCode: S.Finite;
+}>, {}>;
+
+export declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+
+export declare type RunPhase = typeof RunPhase.Type;
+
+export declare interface RunPlan {
+    readonly plan: 'Run';
+    readonly mutant: Mutant;
+    readonly runOptions: MutantRunOptions;
+    readonly netTime: number;
+}
+
+export declare class RunStarted extends RunStarted_base {}
+
+declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
+    readonly schemaVersion: S.String;
+    readonly runId: S.String;
+    readonly mode: S.Literals<readonly ["human", "machine"]>;
+    readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+}>, {}>;
+
+export declare type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
+
+export declare type RunTiming = typeof RunTimingSchema.Type;
+
+export declare const RunTimingSchema: S.Struct<{
+    readonly net: S.Finite;
+    readonly overhead: S.Finite;
+}>;
+
+export declare class SandboxDirectory extends SandboxDirectory_base {}
+
+declare const SandboxDirectory_base: Context.ServiceClass<SandboxDirectory, "~@systemfsoftware/stryker-js/SandboxDirectory", string>;
+
+export declare interface SelectedReporterFactory {
+    readonly name: string;
+    readonly make: ReporterFactory;
+}
+
+export declare class Shadowing extends Shadowing_base {}
+
+declare const Shadowing_base: S.Class<Shadowing, S.TaggedStruct<"Shadowing", {
+    readonly kind: S.String;
+    readonly name: S.String;
+    readonly shadowedIndex: S.Finite;
+    readonly winnerIndex: S.Finite;
+}>, {}>;
+
+export declare const shouldKeepTempDir: (exit: Exit.Exit<void, unknown>, cleanTempDir: 'always' | boolean) => boolean;
+
+export declare interface SkippedTestResult extends BaseTestResult {
+    readonly status: 'skipped';
+}
+
+/**
+ * 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.
+ */
+export declare const strykerCoreSchema: Record<string, unknown>;
+
+/** The decoded type: every defaulted option is present. */
+export declare type StrykerOptions = S.Schema.Type<typeof StrykerOptionsSchema>;
+
+export declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
+    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>;
+    }>, 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>;
+        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<{
+        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>, 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<{
+        readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+    }>, never>;
+    readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
+        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>;
+        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>]>;
+
+/**
+ * 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.
+ */
+export declare function strykerReportBugUrl(titleSuggestion: string): string;
+
+export declare interface SuccessTestResult extends BaseTestResult {
+    readonly status: 'success';
+}
+
+export declare interface SurvivedMutantRunResult {
+    readonly status: 'survived';
+    readonly nrOfTests: number;
+}
+
+export declare type TestDefinition = typeof TestDefinitionSchema.Type;
+
+export declare const TestDefinitionSchema: 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;
+        }>>;
+    }>>;
+}>;
+
+export declare type TestFile = typeof TestFileSchema.Type;
+
+export declare type TestFileDefinitionDictionary = typeof TestFileDefinitionDictionarySchema.Type;
+
+export declare const TestFileDefinitionDictionarySchema: 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;
+            }>>;
+        }>>;
+    }>>;
+}>>;
+
+export declare const TestFileSchema: 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;
+            }>>;
+        }>>;
+    }>>;
+}>;
+
+export declare function testFilesProvided(options: {
+    readonly testFiles?: readonly string[];
+}): boolean;
+
+export declare type TestPlan = EarlyResultPlan | RunPlan;
+
+export declare type TestResult = FailedTestResult | SkippedTestResult | SuccessTestResult;
+
+export declare const TestResultSchema: 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">;
+}>]>;
+
+export declare class TestRunner extends TestRunner_base {}
+
+declare const TestRunner_base: Context.ServiceClass<TestRunner, "~@systemfsoftware/stryker-js/TestRunner", TestRunnerService>;
+
+export declare interface TestRunnerCapabilities {
+    readonly reloadEnvironment: boolean;
+}
+
+export declare const TestRunnerCapabilitiesSchema: S.Struct<{
+    readonly reloadEnvironment: S.Boolean;
+}>;
+
+export declare class TestRunnerFailed extends TestRunnerFailed_base {}
+
+declare const TestRunnerFailed_base: S.Class<TestRunnerFailed, S.TaggedStruct<"TestRunnerFailed", {
+    readonly cause: S.String;
+    readonly phase: S.Literals<readonly ["capabilities", "dispose", "dryRun", "init", "mutantRun"]>;
+    readonly runnerName: S.String;
+}>, YieldableError>;
+
+export declare interface TestRunnerService {
+    readonly capabilities: Effect.Effect<TestRunnerCapabilities, TestRunnerFailed>;
+    readonly init: Effect.Effect<void, TestRunnerFailed>;
+    readonly dryRun: (options: DryRunOptions) => Effect.Effect<DryRunResult, TestRunnerFailed>;
+    readonly mutantRun: (options: MutantRunOptions) => Effect.Effect<MutantRunResult, TestRunnerFailed>;
+    readonly dispose: Effect.Effect<void, TestRunnerFailed>;
+}
+
+export declare const TestStatus: S.Literals<readonly ["success", "failed", "skipped"]>;
+
+export declare type TestStatus = typeof TestStatus.Type;
+
+export declare type Thresholds = typeof ThresholdsSchema.Type;
+
+export declare const ThresholdsSchema: S.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+}>;
+
+export declare interface TimeoutDryRunResult {
+    readonly status: 'timeout';
+    readonly reason?: string;
+}
+
+export declare interface TimeoutMutantRunResult {
+    readonly status: 'timeout';
+    readonly reason?: string;
+}
+
+export declare function toMutantRunResult(dryRunResult: DryRunResult, reportAllKillers: boolean): MutantRunResult;
+
+export declare function verdictExitClass(score: number | null, breakingThreshold: number | null): ExitClass | null;
+
+export declare class VerdictReached extends VerdictReached_base {}
+
+declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
+    readonly schemaVersion: S.String;
+    readonly runId: S.String;
+    readonly mode: S.Literals<readonly ["human", "machine"]>;
+    readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+    readonly score: S.NullOr<S.Finite>;
+    readonly thresholds: S.Struct<{
+        readonly high: S.Finite;
+        readonly low: S.Finite;
+        readonly break: S.NullOr<S.Finite>;
+    }>;
+    readonly reportFile: S.NullOr<S.String>;
+    readonly counts: S.Struct<{
+        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 pending: S.Finite;
+    }>;
+    readonly mutants: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly file: S.String;
+        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;
+        readonly replacement: S.NullOr<S.String>;
+        readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    }>>;
+}>, {}>;
+
+export { }