@systemfsoftware/stryker-js 10.2.0 → 11.0.0

package/dist/index-tt2EziOT.d.mts

@@ -1,1216 +0,0 @@
-import * as Effect$1 from "effect/Effect";
-import * as Context from "effect/Context";
-import * as Option from "effect/Option";
-import * as S from "effect/Schema";
-import { Schema } from "effect";
-import * as Rpc from "effect/unstable/rpc/Rpc";
-import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
-import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
-import * as HashMap from "effect/HashMap";
-import { YieldableError } from "effect/Cause";
-import { JsonSchema } from "effect/JsonSchema";
-import { StandardSchemaV1 } from "effect/StandardSchema";
-declare namespace index_d_exports$1 {
-  export { Coverage, CoverageData, CoveragePerTestId, ERROR_CODES, EarlyResultPlan, ErrnoException, File_2 as File, FileDescription, FileDescriptions, INSTRUMENTER_CONSTANTS, InstrumentError, InstrumentResult, InstrumenterContext, InstrumenterOptions, InstrumenterOptionsSchema, Location, LocationSchema, Mutant, MutantActivation, MutantActivationSchema, MutantCoverage, MutantEarlyResultPlan, MutantRunOptions, MutantRunOptionsSchema, MutantRunPlan, MutantStatus, MutantStatusSchema, MutantTestCoverage, MutantTestPlan, MutateDescription, MutationRange, OpenEndLocation, OpenEndLocationSchema, ParserOptions, Position, PositionSchema, RunMutantResult, RunOptions, RunOptionsFields, RunPlan, TestPlan, causeText, disableTypeChecks, errorToString, instrument, isErrnoException, isMutant, normalizeFileName };
-}
-declare const causeText: <A = unknown>(cause: A, depth: number) => string | undefined;
-declare interface Coverage {
-  readonly static: CoverageData;
-  readonly perTest: CoveragePerTestId;
-}
-declare type CoverageData = Record<string, number>;
-declare type CoveragePerTestId = Record<string, CoverageData>;
-declare const disableTypeChecks: (file: File_2) => Effect$1.Effect<File_2, InstrumentError>;
-declare interface EarlyResultPlan {
-  readonly plan: 'EarlyResult';
-  readonly mutant: Mutant;
-}
-declare interface ErrnoException extends Error {
-  code?: string;
-  errno?: number;
-  path?: string;
-  syscall?: string;
-}
-declare const ERROR_CODES: Readonly<{
-  NoSuchFileOrDirectory: 'ENOENT';
-}>;
-declare function errorToString<A = unknown>(error: A): string;
-declare interface File_2 extends FileDescription {
-  name: string;
-  content: string;
-}
-declare interface FileDescription {
-  readonly mutate: MutateDescription;
-}
-declare type FileDescriptions = Record<string, FileDescription>;
-declare const instrument: (files: readonly File_2[], options: InstrumenterOptions, basePath?: string) => Effect$1.Effect<InstrumentResult, InstrumentError>;
-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__';
-}>;
-declare interface InstrumenterContext {
-  activeMutant?: string;
-  currentTestId?: string;
-  mutantCoverage?: MutantCoverage;
-  hitCount?: number;
-  hitLimit?: number;
-}
-declare type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
-declare const InstrumenterOptionsSchema: S.Struct<{
-  readonly excludedMutations: S.$Array<S.String>;
-  readonly ignorers: S.$Array<S.Unknown>;
-  readonly noHeader: S.optional<S.Boolean>;
-  readonly optInMutations: S.optional<S.$Array<S.String>>;
-}>;
-declare class InstrumentError extends InstrumentError_base {
-  get message(): string;
-}
-declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
-  readonly message: S.String;
-  readonly cause: S.Defect;
-}>, YieldableError>;
-declare interface InstrumentResult {
-  files: readonly File_2[];
-  mutants: readonly Mutant[];
-}
-declare function isErrnoException(error: unknown): error is ErrnoException;
-declare const isMutant: (value: unknown) => value is Mutant;
-declare type Location = typeof LocationSchema.Type;
-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 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>;
-}>, {}>;
-declare type MutantActivation = typeof MutantActivationSchema.Type;
-declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
-declare interface MutantCoverage {
-  readonly perTest: Record<string, Record<string, number>>;
-  readonly static: Record<string, number>;
-}
-declare type MutantEarlyResultPlan = EarlyResultPlan;
-declare interface MutantRunOptions extends RunOptions {
-  readonly testFilter?: readonly string[];
-  readonly hitLimit?: number;
-  readonly activeMutant: Mutant;
-  readonly sandboxFileName: string;
-  readonly mutantActivation: MutantActivation;
-  readonly reloadEnvironment: boolean;
-}
-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>;
-}>;
-declare type MutantRunPlan = RunPlan;
-declare type MutantStatus = typeof MutantStatusSchema.Type;
-declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-declare type MutantTestCoverage = Mutant & {
-  readonly coveredBy: ReadonlyArray<string> | undefined;
-  readonly static: boolean | undefined;
-};
-declare type MutantTestPlan = TestPlan;
-declare type MutateDescription = ReadonlyArray<MutationRange> | boolean;
-declare interface MutationRange {
-  readonly start: Position;
-  readonly end: Position;
-}
-declare function normalizeFileName(fileName: string): string;
-declare type OpenEndLocation = typeof OpenEndLocationSchema.Type;
-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;
-  }>>;
-}>;
-declare interface ParserOptions {}
-declare type Position = typeof PositionSchema.Type;
-declare const PositionSchema: S.Struct<{
-  readonly line: S.Finite;
-  readonly column: S.Finite;
-}>;
-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;
-};
-declare interface RunOptions {
-  readonly timeout: number;
-  readonly disableBail: boolean;
-}
-declare const RunOptionsFields: {
-  timeout: S.Finite;
-  disableBail: S.Boolean;
-};
-declare interface RunPlan {
-  readonly plan: 'Run';
-  readonly mutant: Mutant;
-  readonly runOptions: MutantRunOptions;
-  readonly netTime: number;
-}
-declare type TestPlan = EarlyResultPlan | RunPlan;
-declare namespace index_d_exports {
-  export { BaseTestResult, BoundaryError, BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, BrandingInformation, BrandingInformationSchema, CheckResult, CheckResultSchema, CheckStatus, Checker, CheckerCheckResult, CheckerCustomConfig, CheckerCustomConfigSchema, CheckerEntryConfig, CheckerEntryConfigSchema, CheckerFailed, CheckerGroupResult, CheckerMutantWire, CheckerRequest, CheckerRpcs, CheckerService, CommandRunnerOptions, CommandRunnerOptionsSchema, CompleteDryRunResult, CoverageAnalysis, CoverageAnalysisMode, CoverageAnalysisMode as CoverageAnalysisModeType, CoverageAnalysisSchema, DeepOptional, Dependencies, DependenciesSchema, DetectedStatus, DryRunCompleted, DryRunOptions, DryRunOptionsSchema, DryRunResult, DryRunResultSchema, DryRunStatus, EXIT_CODE, ErrorDryRunResult, ErrorMutantRunResult, Evaluator, EvaluatorFailed, EvaluatorService, ExitClass, FailedCheckResult, FailedTestResult, FileResult, FileResultDictionary, FileResultDictionarySchema, FileResultSchema, FrameworkInformation, FrameworkInformationSchema, HIT_LIMIT_REASON_PREFIX, InvalidStatus, KilledMutantRunResult, KnownKeys, Location, LocationSchema, LogLevel, LogLevel as LogLevelType, Metrics, MetricsResult, MetricsResultEncoded, MetricsResultSchema, MetricsSchema, MutantActivation, MutantActivationSchema, MutantCoverage, MutantCoverageSchema, MutantResult, MutantResultSchema, MutantRunOptions, MutantRunOptionsSchema, MutantRunResult, MutantRunResultSchema, MutantRunStatus, MutantStatus, MutantStatusSchema, MutantTested, MutationScoreThresholds, MutationScoreThresholdsSchema, MutationTestReportReady, MutationTestResult, MutationTestResultSchema, MutationTestingPlanReady, NonNegativeFinite, NonNegativeInt, OnlyObject, OpenEndLocation, OpenEndLocationSchema, PackageManager, PackageManager as PackageManagerType, PartialStrykerOptions, PassedCheckResult, Percentage, PluginFileUrl, Position, PositionSchema, Primitive, PropagatedTrace, PropertyPathOverloads, RENDERED_OPTION_DEFAULTS, ReportType, ReportType as ReportTypeType, ReporterAck, ReporterDrained, ReporterEvent, ReporterEventBatch, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFactory, ReporterFailed, ReporterInit, ReporterInitOptions, ReporterPlanDescriptor, ReporterPlanDescriptorSchema, ReporterPlanKind, ReporterRpcs, RunOptions, RunTiming, RunTimingSchema, SkippedTestResult, StrykerOptions, StrykerOptionsSchema, SuccessTestResult, SurvivedMutantRunResult, TRACEPARENT_HEADER, TRACESTATE_HEADER, TestDefinition, TestDefinitionSchema, TestFile, TestFileDefinitionDictionary, TestFileDefinitionDictionarySchema, TestFileSchema, TestResult, TestResultSchema, TestRunner, TestRunnerCapabilities, TestRunnerCapabilitiesSchema, TestRunnerConfig, TestRunnerConfigSchema, TestRunnerCustomConfig, TestRunnerCustomConfigSchema, TestRunnerDryRunRequest, TestRunnerFailed, TestRunnerMutantRunRequest, TestRunnerRpcs, TestRunnerService, TestStatus, Thresholds, ThresholdsSchema, TimeoutDryRunResult, TimeoutMutantRunResult, TraceContextMiddleware, TraceContextParts, TraceContextReference, TracedRpc, Traceparent, UndetectedStatus, UntestedStatus, WALL_CLOCK_TIMEOUT_REASON, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawn, WorkerPluginSpawnSchema, formatTraceparent, hitLimitReachedReason, isCustomTestRunner, isHitLimitReason, isNamedTrap, parseTraceparent, propertyPath, strykerCoreSchema, strykerReportBugUrl, testFilesProvided, toMutantRunResult, wallClockTimeoutStopsRun };
-}
-declare interface BaseTestResult {
-  readonly id: string;
-  readonly name: string;
-  readonly timeSpentMs: number;
-  readonly fileName?: string;
-  readonly startPosition?: Position;
-}
-declare type BoundaryError = typeof BoundaryErrorSchema.Type;
-declare const BoundaryErrorSchema: S.Union<readonly [typeof BoundaryPayloadRejected, typeof BoundaryUnrecognizedSignal, typeof TestRunnerFailed, typeof CheckerFailed, typeof ReporterFailed]>;
-declare class BoundaryPayloadRejected extends BoundaryPayloadRejected_base {}
-declare const BoundaryPayloadRejected_base: S.Class<BoundaryPayloadRejected, S.TaggedStruct<"BoundaryPayloadRejected", {
-  readonly pluginName: S.String;
-  readonly method: S.String;
-  readonly cause: S.String;
-}>, YieldableError>;
-declare class BoundaryUnrecognizedSignal extends BoundaryUnrecognizedSignal_base {}
-declare const BoundaryUnrecognizedSignal_base: S.Class<BoundaryUnrecognizedSignal, S.TaggedStruct<"BoundaryUnrecognizedSignal", {
-  readonly pluginName: S.String;
-  readonly method: S.String;
-  readonly signal: S.String;
-}>, YieldableError>;
-declare type BrandingInformation = typeof BrandingInformationSchema.Type;
-declare const BrandingInformationSchema: S.Struct<{
-  readonly homepageUrl: S.String;
-  readonly imageUrl: S.optional<S.String>;
-}>;
-declare class Checker extends Checker_base {}
-declare const Checker_base: Context.ServiceClass<Checker, "@systemfsoftware/stryker-js-plugin-interface/Checker", CheckerService>;
-declare const CheckerCheckResult: S.$Record<S.String, S.Union<readonly [S.Struct<{
-  readonly status: S.Literal<"passed">;
-}>, S.Struct<{
-  readonly status: S.Literal<"compileError">;
-  readonly reason: S.String;
-}>]>>;
-declare type CheckerCustomConfig = typeof CheckerCustomConfigSchema.Type;
-declare const CheckerCustomConfigSchema: S.Struct<{
-  readonly plugin: S.String;
-  readonly nodeArgs: S.optional<S.$Array<S.String>>;
-  readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
-}>;
-declare type CheckerEntryConfig = typeof CheckerEntryConfigSchema.Type;
-declare const CheckerEntryConfigSchema: S.Struct<{
-  readonly plugin: S.String;
-  readonly nodeArgs: S.optional<S.$Array<S.String>>;
-  readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
-}>;
-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>;
-declare const CheckerGroupResult: S.$Array<S.$Array<S.String>>;
-declare const CheckerMutantWire: S.Struct<{
-  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;
-    }>;
-  }>;
-}>;
-declare type CheckerMutantWire = typeof CheckerMutantWire.Type;
-declare const CheckerRequest: S.Struct<{
-  readonly checkerName: S.String;
-  readonly mutants: S.$Array<S.Struct<{
-    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;
-      }>;
-    }>;
-  }>>;
-}>;
-declare type CheckerRequest = typeof CheckerRequest.Type;
-declare const CheckerRpcs: RpcGroup.RpcGroup<TracedRpc<'check', typeof CheckerRequest, typeof CheckerCheckResult, typeof CheckerFailed> | TracedRpc<'group', typeof CheckerRequest, typeof CheckerGroupResult, typeof CheckerFailed>>;
-declare interface CheckerService {
-  readonly init: Effect$1.Effect<void, CheckerFailed>;
-  readonly check: (mutants: readonly CheckerMutantWire[]) => Effect$1.Effect<HashMap.HashMap<string, CheckResult>, CheckerFailed>;
-  readonly group: (mutants: readonly CheckerMutantWire[]) => Effect$1.Effect<readonly (readonly string[])[], CheckerFailed>;
-}
-declare type CheckResult = FailedCheckResult | PassedCheckResult;
-declare const CheckResultSchema: S.Union<readonly [S.Struct<{
-  readonly status: S.Literal<"passed">;
-}>, S.Struct<{
-  readonly status: S.Literal<"compileError">;
-  readonly reason: S.String;
-}>]>;
-declare const CheckStatus: S.Literals<readonly ["passed", "compileError"]>;
-declare type CheckStatus = typeof CheckStatus.Type;
-declare type CommandRunnerOptions = S.Schema.Type<typeof CommandRunnerOptionsSchema>;
-declare const CommandRunnerOptionsSchema: S.StructWithRest<S.Struct<{
-  readonly command: S.withDecodingDefaultKey<S.String, never>;
-}>, readonly [S.$Record<S.String, S.Unknown>]>;
-declare interface CompleteDryRunResult {
-  readonly tests: readonly TestResult[];
-  readonly mutantCoverage?: MutantCoverage;
-  readonly status: 'complete';
-}
-declare type CoverageAnalysis = 'off' | 'all' | 'perTest';
-declare const CoverageAnalysisMode: S.Literals<readonly ["off", "all", "perTest"]>;
-declare type CoverageAnalysisMode = typeof CoverageAnalysisMode.Type;
-declare const CoverageAnalysisSchema: S.Literals<readonly ["off", "all", "perTest"]>;
-/**
- * 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.
- */
-declare type DeepOptional<T, V = unknown> = { -readonly [P in keyof T]?: T[P] extends Record<string, V> ? DeepOptional<T[P], V> | undefined : T[P]; };
-declare type Dependencies = typeof DependenciesSchema.Type;
-declare const DependenciesSchema: S.$Record<S.String, S.String>;
-declare const DetectedStatus: S.Union<readonly [S.Literal<"Killed">, S.Literal<"Timeout">]>;
-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.Int;
-  readonly tests: S.$Array<S.Union<readonly [S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly timeSpentMs: S.Finite;
-    readonly fileName: S.optionalKey<S.String>;
-    readonly startPosition: S.optionalKey<S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
-    }>>;
-    readonly status: S.Literal<"failed">;
-    readonly failureMessage: S.String;
-  }>, S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly timeSpentMs: S.Finite;
-    readonly fileName: S.optionalKey<S.String>;
-    readonly startPosition: S.optionalKey<S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
-    }>>;
-    readonly status: S.Literal<"skipped">;
-  }>, S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly timeSpentMs: S.Finite;
-    readonly fileName: S.optionalKey<S.String>;
-    readonly startPosition: S.optionalKey<S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
-    }>>;
-    readonly status: S.Literal<"success">;
-  }>]>>;
-}>, {}>;
-declare interface DryRunOptions extends RunOptions {
-  readonly coverageAnalysis: CoverageAnalysis;
-  readonly files?: readonly string[];
-  readonly testFiles?: readonly string[];
-}
-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>>;
-}>;
-declare type DryRunResult = CompleteDryRunResult | ErrorDryRunResult | TimeoutDryRunResult;
-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;
-}>]>;
-declare const DryRunStatus: S.Literals<readonly ["complete", "error", "timeout"]>;
-declare type DryRunStatus = typeof DryRunStatus.Type;
-declare interface ErrorDryRunResult {
-  readonly status: 'error';
-  readonly errorMessage: string;
-}
-declare interface ErrorMutantRunResult {
-  readonly status: 'error';
-  readonly errorMessage: string;
-}
-declare class Evaluator extends Evaluator_base {}
-declare const Evaluator_base: Context.ServiceClass<Evaluator, "@systemfsoftware/stryker-js-plugin-interface/Evaluator", EvaluatorService>;
-declare class EvaluatorFailed extends EvaluatorFailed_base {}
-declare const EvaluatorFailed_base: S.Class<EvaluatorFailed, S.TaggedStruct<"EvaluatorFailed", {
-  readonly cause: S.Unknown;
-}>, YieldableError>;
-declare interface EvaluatorService {
-  readonly evaluate: (report: MutationTestResult) => Effect$1.Effect<ExitClass | null, EvaluatorFailed>;
-}
-declare const EXIT_CODE: Record<ExitClass, number>;
-declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
-declare type ExitClass = typeof ExitClass.Type;
-declare interface FailedCheckResult {
-  readonly reason: string;
-  readonly status: 'compileError';
-}
-declare interface FailedTestResult extends BaseTestResult {
-  readonly status: 'failed';
-  readonly failureMessage: string;
-}
-declare type FileResult = typeof FileResultSchema.Type;
-declare type FileResultDictionary = typeof FileResultDictionarySchema.Type;
-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.Int>;
-    readonly duration: S.optional<S.Finite>;
-  }>>;
-}>>;
-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.Int>;
-    readonly duration: S.optional<S.Finite>;
-  }>>;
-}>;
-declare const formatTraceparent: (parts: TraceContextParts) => Traceparent;
-declare type FrameworkInformation = typeof FrameworkInformationSchema.Type;
-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>>;
-}>;
-declare const HIT_LIMIT_REASON_PREFIX = "Hit limit reached";
-declare const hitLimitReachedReason: (count: number, limit: number) => string;
-declare const InvalidStatus: S.Union<readonly [S.Literal<"CompileError">, S.Literal<"RuntimeError">]>;
-declare const isCustomTestRunner: (value: TestRunnerConfig) => value is TestRunnerCustomConfig;
-declare const isHitLimitReason: (reason: string | undefined) => boolean;
-declare const isNamedTrap: (activeMutantId: string, namedTrapId: string | undefined) => boolean;
-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
- */
-declare type KnownKeys<T> = keyof { [P in keyof T as string extends P ? never : number extends P ? never : P]: T[P]; };
-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;
-declare class Metrics extends Metrics_base {
-  get totalDetected(): number;
-  get totalUndetected(): number;
-  get totalCovered(): number;
-  get totalValid(): number;
-  get totalInvalid(): number;
-  get totalMutants(): number;
-  get mutationScore(): number;
-  get mutationScoreBasedOnCoveredCode(): number;
-  static fromMutants(mutants: readonly {
-    readonly status: string;
-  }[]): Metrics;
-}
-declare const Metrics_base: S.Class<Metrics, S.Struct<{
-  readonly pending: S.Int;
-  readonly killed: S.Int;
-  readonly timeout: S.Int;
-  readonly survived: S.Int;
-  readonly noCoverage: S.Int;
-  readonly runtimeErrors: S.Int;
-  readonly compileErrors: S.Int;
-  readonly ignored: S.Int;
-}>, {}>;
-declare interface MetricsResult {
-  readonly name: string;
-  readonly metrics: Metrics;
-  readonly childResults: readonly MetricsResult[];
-}
-declare interface MetricsResultEncoded {
-  readonly name: string;
-  readonly metrics: typeof Metrics.Encoded;
-  readonly childResults: readonly MetricsResultEncoded[];
-}
-declare const MetricsResultSchema: S.Codec<MetricsResult, MetricsResultEncoded>;
-declare const MetricsSchema: typeof Metrics;
-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>;
-}>;
-declare type MutantResult = typeof MutantResultSchema.Type;
-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.Int>;
-  readonly duration: S.optional<S.Finite>;
-}>;
-declare type MutantRunResult = ErrorMutantRunResult | KilledMutantRunResult | SurvivedMutantRunResult | TimeoutMutantRunResult;
-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;
-}>]>;
-declare const MutantRunStatus: S.Literals<readonly ["killed", "survived", "timeout", "error"]>;
-declare type MutantRunStatus = typeof MutantRunStatus.Type;
-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.Int;
-  readonly total: S.Int;
-}>, {}>;
-declare type MutationScoreThresholds = typeof MutationScoreThresholdsSchema.Type;
-declare const MutationScoreThresholdsSchema: S.decodeTo<S.declare<{
-  readonly high: number;
-  readonly low: number;
-  readonly break: number | null;
-}, {
-  readonly high: number;
-  readonly low: number;
-  readonly break: number | null;
-}>, 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, never>;
-declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
-declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S.TaggedStruct<"mutationTestingPlanReady", {
-  readonly total: S.Int;
-  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;
-  }>>;
-}>, {}>;
-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.Int>;
-        readonly duration: S.optional<S.Finite>;
-      }>>;
-    }>>;
-    readonly thresholds: S.decodeTo<S.declare<{
-      readonly high: number;
-      readonly low: number;
-    }, {
-      readonly high: number;
-      readonly low: number;
-    }>, S.Struct<{
-      readonly high: S.Finite;
-      readonly low: S.Finite;
-    }>, never, never>;
-    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.Codec<MetricsResult, MetricsResultEncoded, never, never>;
-}>, {}>;
-declare type MutationTestResult = typeof MutationTestResultSchema.Type;
-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.Int>;
-      readonly duration: S.optional<S.Finite>;
-    }>>;
-  }>>;
-  readonly thresholds: S.decodeTo<S.declare<{
-    readonly high: number;
-    readonly low: number;
-  }, {
-    readonly high: number;
-    readonly low: number;
-  }>, S.Struct<{
-    readonly high: S.Finite;
-    readonly low: S.Finite;
-  }>, never, never>;
-  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>>;
-  }>>;
-}>;
-declare const NonNegativeFinite: S.Finite;
-declare const NonNegativeInt: S.Int;
-declare type OnlyObject<T> = Exclude<T, Primitive>;
-declare const PackageManager: S.Literals<readonly ["npm", "yarn", "pnpm"]>;
-declare type PackageManager = typeof PackageManager.Type;
-declare const parseTraceparent: (value: string) => Option.Option<TraceContextParts>;
-/**
- * The deep-partial input type: when configuring Stryker, every option is
- * optional, including deep properties like `dashboard.project`.
- */
-declare type PartialStrykerOptions = DeepOptional<StrykerOptions>;
-declare interface PassedCheckResult {
-  readonly status: 'passed';
-}
-declare const Percentage: S.Finite;
-declare const PluginFileUrl: S.String;
-declare type Primitive = boolean | number | string | null | undefined;
-declare class PropagatedTrace extends PropagatedTrace_base {}
-declare const PropagatedTrace_base: Context.ServiceClass<PropagatedTrace, "@systemfsoftware/stryker-js-plugin-interface/TraceContextRpc/PropagatedTrace", Option.Option<TraceContextParts>>;
-/**
- * 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>;
-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.
- */
-declare const RENDERED_OPTION_DEFAULTS: {
-  readonly coverageAnalysis: 'perTest';
-  readonly fileLogLevel: 'off';
-  readonly logLevel: 'info';
-  readonly tempDirName: '.stryker-tmp';
-};
-declare const ReporterAck: S.Void;
-declare const ReporterDrained: S.Void;
-declare type ReporterEvent = DryRunCompleted | MutationTestingPlanReady | MutantTested | MutationTestReportReady;
-declare const ReporterEventBatch: S.$Array<S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>>;
-declare type ReporterEventBatch = typeof ReporterEventBatch.Type;
-declare const ReporterEventKind: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
-declare type ReporterEventKind = typeof ReporterEventKind.Type;
-declare const ReporterEventSchema: StandardSchemaV1<typeof ReporterEventUnion['Encoded'], ReporterEvent>;
-declare const ReporterEventUnion: S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>;
-declare type ReporterFactory = (options: StrykerOptions, init: ReporterInit) => (events: AsyncIterable<ReporterEvent>) => Effect$1.Effect<void, ReporterFailed>;
-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>;
-declare interface ReporterInit {
-  readonly traceparent?: string | undefined;
-  readonly tracestate?: string | undefined;
-}
-declare const ReporterInitOptions: S.Struct<{
-  readonly traceparent: S.optionalKey<S.String>;
-  readonly tracestate: S.optionalKey<S.String>;
-}>;
-declare type ReporterInitOptions = typeof ReporterInitOptions.Type;
-declare type ReporterPlanDescriptor = typeof ReporterPlanDescriptorSchema.Type;
-declare const ReporterPlanDescriptorSchema: S.Struct<{
-  readonly mutantId: S.String;
-  readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
-  readonly netTime: S.Finite;
-  readonly reloadEnvironment: S.Boolean;
-}>;
-declare const ReporterPlanKind: S.Literals<readonly ["EarlyResult", "Run"]>;
-declare const ReporterRpcs: RpcGroup.RpcGroup<TracedRpc<'init', typeof ReporterInitOptions, typeof ReporterAck, typeof ReporterFailed> | TracedRpc<'onEventBatch', typeof ReporterEventBatch, typeof ReporterAck, typeof ReporterFailed> | TracedRpc<'flush', Schema.Void, typeof ReporterDrained, typeof ReporterFailed>>;
-declare const ReportType: S.Literals<readonly ["full", "mutationScore"]>;
-declare type ReportType = typeof ReportType.Type;
-declare type RunTiming = typeof RunTimingSchema.Type;
-declare const RunTimingSchema: S.Struct<{
-  readonly net: S.Finite;
-  readonly overhead: S.Finite;
-}>;
-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.
- */
-declare const strykerCoreSchema: JsonSchema;
-/** The decoded type: every defaulted option is present. */
-declare type StrykerOptions = S.Schema.Type<typeof StrykerOptionsSchema>;
-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.Struct<{
-    readonly plugin: S.String;
-    readonly nodeArgs: S.optional<S.$Array<S.String>>;
-    readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
-  }>>, 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>;
-    readonly optInMutations: 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.Union<readonly [S.String, S.Struct<{
-    readonly plugin: S.String;
-    readonly nodeArgs: S.optional<S.$Array<S.String>>;
-    readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
-  }>]>, never>;
-  readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly thresholds: S.withDecodingDefaultKey<S.decodeTo<S.declare<{
-    readonly high: number;
-    readonly low: number;
-    readonly break: number | null;
-  }, {
-    readonly high: number;
-    readonly low: number;
-    readonly break: number | null;
-  }>, 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, 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.
- */
-declare function strykerReportBugUrl(titleSuggestion: string): string;
-declare interface SuccessTestResult extends BaseTestResult {
-  readonly status: 'success';
-}
-declare interface SurvivedMutantRunResult {
-  readonly status: 'survived';
-  readonly nrOfTests: number;
-}
-declare type TestDefinition = typeof TestDefinitionSchema.Type;
-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;
-    }>>;
-  }>>;
-}>;
-declare type TestFile = typeof TestFileSchema.Type;
-declare type TestFileDefinitionDictionary = typeof TestFileDefinitionDictionarySchema.Type;
-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;
-      }>>;
-    }>>;
-  }>>;
-}>>;
-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;
-      }>>;
-    }>>;
-  }>>;
-}>;
-declare function testFilesProvided(options: {
-  readonly testFiles?: readonly string[];
-}): boolean;
-declare type TestResult = FailedTestResult | SkippedTestResult | SuccessTestResult;
-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">;
-}>]>;
-declare class TestRunner extends TestRunner_base {}
-declare const TestRunner_base: Context.ServiceClass<TestRunner, "@systemfsoftware/stryker-js-plugin-interface/TestRunner", TestRunnerService>;
-declare interface TestRunnerCapabilities {
-  readonly reloadEnvironment: boolean;
-}
-declare const TestRunnerCapabilitiesSchema: S.Struct<{
-  readonly reloadEnvironment: S.Boolean;
-}>;
-declare type TestRunnerConfig = typeof TestRunnerConfigSchema.Type;
-declare const TestRunnerConfigSchema: S.Union<readonly [S.String, S.Struct<{
-  readonly plugin: S.String;
-  readonly nodeArgs: S.optional<S.$Array<S.String>>;
-  readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
-}>]>;
-declare type TestRunnerCustomConfig = typeof TestRunnerCustomConfigSchema.Type;
-declare const TestRunnerCustomConfigSchema: S.Struct<{
-  readonly plugin: S.String;
-  readonly nodeArgs: S.optional<S.$Array<S.String>>;
-  readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
-}>;
-declare const TestRunnerDryRunRequest: S.Struct<{
-  readonly options: 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>>;
-  }>;
-}>;
-declare type TestRunnerDryRunRequest = typeof TestRunnerDryRunRequest.Type;
-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>;
-declare const TestRunnerMutantRunRequest: S.Struct<{
-  readonly options: S.Struct<{
-    readonly timeout: S.Finite;
-    readonly disableBail: S.Boolean;
-    readonly activeMutant: 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>;
-  }>;
-}>;
-declare type TestRunnerMutantRunRequest = typeof TestRunnerMutantRunRequest.Type;
-declare const TestRunnerRpcs: RpcGroup.RpcGroup<TracedRpc<'capabilities', Schema.Void, typeof TestRunnerCapabilitiesSchema, typeof TestRunnerFailed> | TracedRpc<'dryRun', typeof TestRunnerDryRunRequest, typeof DryRunResultSchema, typeof TestRunnerFailed> | TracedRpc<'mutantRun', typeof TestRunnerMutantRunRequest, typeof MutantRunResultSchema, typeof TestRunnerFailed>>;
-declare interface TestRunnerService {
-  readonly capabilities: Effect$1.Effect<TestRunnerCapabilities, TestRunnerFailed>;
-  readonly init: Effect$1.Effect<void, TestRunnerFailed>;
-  readonly dryRun: (options: DryRunOptions) => Effect$1.Effect<DryRunResult, TestRunnerFailed>;
-  readonly mutantRun: (options: MutantRunOptions) => Effect$1.Effect<MutantRunResult, TestRunnerFailed>;
-  readonly dispose: Effect$1.Effect<void, TestRunnerFailed>;
-}
-declare const TestStatus: S.Literals<readonly ["success", "failed", "skipped"]>;
-declare type TestStatus = typeof TestStatus.Type;
-declare type Thresholds = typeof ThresholdsSchema.Type;
-declare const ThresholdsSchema: S.decodeTo<S.declare<{
-  readonly high: number;
-  readonly low: number;
-}, {
-  readonly high: number;
-  readonly low: number;
-}>, S.Struct<{
-  readonly high: S.Finite;
-  readonly low: S.Finite;
-}>, never, never>;
-declare interface TimeoutDryRunResult {
-  readonly status: 'timeout';
-  readonly reason?: string;
-}
-declare interface TimeoutMutantRunResult {
-  readonly status: 'timeout';
-  readonly reason?: string;
-}
-declare function toMutantRunResult(dryRunResult: DryRunResult, reportAllKillers: boolean): MutantRunResult;
-declare class TraceContextMiddleware extends TraceContextMiddleware_base {}
-declare const TraceContextMiddleware_base: RpcMiddleware.ServiceClass<TraceContextMiddleware, "@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", typeof PropagatedTrace, Schema.Never, never, never, true>;
-declare interface TraceContextParts {
-  readonly version: string;
-  readonly traceId: string;
-  readonly spanId: string;
-  readonly traceFlags: number;
-  readonly traceState?: string | undefined;
-}
-declare const TraceContextReference: Context.Reference<Option.Option<TraceContextParts>>;
-declare type TracedRpc<Tag extends string, Payload extends Schema.Top = Schema.Void, Success extends Schema.Top = Schema.Void, Error extends Schema.Top = Schema.Never> = Rpc.Rpc<Tag, Payload, Success, Error, typeof TraceContextMiddleware, RpcMiddleware.ApplyServices<typeof TraceContextMiddleware['Identifier'], never>>;
-declare const Traceparent: S.String;
-declare type Traceparent = typeof Traceparent.Type;
-declare const TRACEPARENT_HEADER = "traceparent";
-declare const TRACESTATE_HEADER = "tracestate";
-declare const UndetectedStatus: S.Union<readonly [S.Literal<"Survived">, S.Literal<"NoCoverage">]>;
-declare const UntestedStatus: S.Union<readonly [S.Literal<"Ignored">, S.Literal<"Pending">]>;
-declare const WALL_CLOCK_TIMEOUT_REASON = "wall-clock-timeout";
-declare const wallClockTimeoutStopsRun: (status: string, reason: string | undefined) => boolean;
-declare const WorkerEntryUrl: S.String;
-declare type WorkerEntryUrl = typeof WorkerEntryUrl.Type;
-declare const WorkerPluginKind: S.Literals<readonly ["TestRunner", "Checker", "Reporter"]>;
-declare type WorkerPluginKind = typeof WorkerPluginKind.Type;
-declare type WorkerPluginSpawn = typeof WorkerPluginSpawnSchema.Type;
-declare const WorkerPluginSpawnSchema: S.Struct<{
-  readonly kind: S.Literals<readonly ["TestRunner", "Checker", "Reporter"]>;
-  readonly entrypoint: S.String;
-}>;
-//#endregion
-export { TestRunnerConfigSchema as $, MutationTestReportReady as A, ReporterFactory as B, Metrics as C, RunMutantResult as Ct, MutantResultSchema as D, MutantResult as E, index_d_exports$1 as Et, PassedCheckResult as F, SkippedTestResult as G, ReporterInit as H, ReporterAck as I, SuccessTestResult as J, StrykerOptions as K, ReporterDrained as L, MutationTestResultSchema as M, MutationTestingPlanReady as N, MutantRunResult as O, PartialStrykerOptions as P, TestRunnerConfig as Q, ReporterEvent as R, KilledMutantRunResult as S, PositionSchema as St, MetricsSchema as T, RunPlan as Tt, ReporterInitOptions as U, ReporterFailed as V, ReporterRpcs as W, TestResult as X, SurvivedMutantRunResult as Y, TestRunnerCapabilities as Z, ExitClass as _, MutantStatus as _t, CheckerGroupResult as a, WorkerPluginKind as at, FileResult as b, MutationRange as bt, CheckerRpcs as c, FileDescription as ct, DeepOptional as d, LocationSchema as dt, TestRunnerFailed as et, DryRunCompleted as f, Mutant as ft, ErrorMutantRunResult as g, MutantRunOptions as gt, ErrorDryRunResult as h, MutantCoverage as ht, CheckerFailed as i, TracedRpc as it, MutationTestResult as j, MutantTested as k, CompleteDryRunResult as l, FileDescriptions as lt, DryRunResult as m, MutantActivationSchema as mt, CheckResult as n, TimeoutMutantRunResult as nt, CheckerMutantWire as o, index_d_exports as ot, DryRunOptions as p, MutantActivation as pt, StrykerOptionsSchema as q, CheckerCheckResult as r, TraceContextMiddleware as rt, CheckerRequest as s, CoverageData as st, BaseTestResult as t, TimeoutDryRunResult as tt, CoverageAnalysis as u, Location as ut, FailedCheckResult as v, MutantStatusSchema as vt, MetricsResult as w, RunOptions as wt, FileResultSchema as x, Position as xt, FailedTestResult as y, MutateDescription as yt, ReporterEventBatch as z };