@systemfsoftware/stryker-js 5.0.0 → 6.0.0

package/dist/index-BInJWa0x.d.mts

@@ -0,0 +1,1148 @@
+import * as Effect$1 from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Option from "effect/Option";
+import * as Context from "effect/Context";
+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 { Schema } from "effect";
+import { YieldableError } from "effect/Cause";
+import * as HashMap from "effect/HashMap";
+import { StandardSchemaV1 } from "effect/StandardSchema";
+//#region ../stryker-js-instrumenter/dist/Mutant-BYxuyyRL.d.mts
+//#region src/Location.schema.d.ts
+declare const PositionSchema: S.Struct<{
+  readonly line: S.Finite;
+  readonly column: S.Finite;
+}>;
+type Position = typeof PositionSchema.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;
+  }>;
+}>;
+type Location = typeof LocationSchema.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;
+  }>>;
+}>;
+type OpenEndLocation = typeof OpenEndLocationSchema.Type;
+//#endregion
+//#region src/Mutant.schema.d.ts
+declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+type MutantStatus = typeof MutantStatusSchema.Type;
+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 class Mutant extends Mutant_base {}
+declare const RunOptionsFields: {
+  timeout: S.Finite;
+  disableBail: S.Boolean;
+};
+declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
+type MutantActivation = typeof MutantActivationSchema.Type;
+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>;
+}>;
+//#endregion
+//#region src/Mutant.d.ts
+interface MutantCoverage {
+  readonly perTest: Record<string, Record<string, number>>;
+  readonly static: Record<string, number>;
+}
+type CoverageData = Record<string, number>;
+type CoveragePerTestId = Record<string, CoverageData>;
+interface Coverage {
+  readonly static: CoverageData;
+  readonly perTest: CoveragePerTestId;
+}
+interface RunOptions {
+  readonly timeout: number;
+  readonly disableBail: boolean;
+}
+interface MutantRunOptions extends RunOptions {
+  readonly testFilter?: readonly string[];
+  readonly hitLimit?: number;
+  readonly activeMutant: Mutant;
+  readonly sandboxFileName: string;
+  readonly mutantActivation: MutantActivation;
+  readonly reloadEnvironment: boolean;
+}
+interface EarlyResultPlan {
+  readonly plan: 'EarlyResult';
+  readonly mutant: Mutant;
+}
+interface RunPlan {
+  readonly plan: 'Run';
+  readonly mutant: Mutant;
+  readonly runOptions: MutantRunOptions;
+  readonly netTime: number;
+}
+type TestPlan = EarlyResultPlan | RunPlan;
+declare const isMutant: (value: unknown) => value is Mutant;
+type MutantTestCoverage = Mutant & {
+  readonly coveredBy: ReadonlyArray<string> | undefined;
+  readonly static: boolean | undefined;
+};
+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 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__';
+}>;
+interface InstrumenterContext {
+  activeMutant?: string;
+  currentTestId?: string;
+  mutantCoverage?: MutantCoverage;
+  hitCount?: number;
+  hitLimit?: number;
+}
+declare function normalizeFileName(fileName: string): string;
+interface ErrnoException extends Error {
+  code?: string;
+  errno?: number;
+  path?: string;
+  syscall?: string;
+}
+declare function isErrnoException(error: unknown): error is ErrnoException;
+declare function errorToString(error: unknown): string;
+declare const ERROR_CODES: Readonly<{
+  NoSuchFileOrDirectory: 'ENOENT';
+}>;
+interface MutationRange {
+  readonly start: Position;
+  readonly end: Position;
+}
+type MutateDescription = ReadonlyArray<MutationRange> | boolean;
+interface FileDescription {
+  readonly mutate: MutateDescription;
+}
+type FileDescriptions = Record<string, FileDescription>;
+type MutantRunPlan = RunPlan;
+type MutantEarlyResultPlan = EarlyResultPlan;
+type MutantTestPlan = TestPlan;
+declare const causeText: (cause: unknown, depth: number) => string | undefined;
+declare namespace mutants_d_exports {
+  export { Coverage, CoverageData, CoveragePerTestId, ERROR_CODES, EarlyResultPlan, ErrnoException, FileDescription, FileDescriptions, INSTRUMENTER_CONSTANTS, InstrumenterContext, Location, LocationSchema, Mutant, MutantActivation, MutantActivationSchema, MutantCoverage, MutantEarlyResultPlan, MutantRunOptions, MutantRunOptionsSchema, MutantRunPlan, MutantStatus, MutantStatusSchema, MutantTestCoverage, MutantTestPlan, MutateDescription, MutationRange, OpenEndLocation, OpenEndLocationSchema, Position, PositionSchema, RunMutantResult, RunOptions, RunOptionsFields, RunPlan, TestPlan, causeText, errorToString, isErrnoException, isMutant, normalizeFileName };
+}
+declare namespace index_d_exports {
+  export { BaseTestResult, BoundaryError, BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, BrandingInformation, BrandingInformationSchema, CheckResult, CheckResultSchema, CheckStatus, Checker, CheckerCheckResult, CheckerCustomConfig, CheckerCustomConfigSchema, CheckerEntryConfig, CheckerEntryConfigSchema, CheckerFailed, CheckerGroupResult, CheckerRequest, CheckerRpcs, CheckerService, CommandRunnerOptions, CommandRunnerOptionsSchema, CompleteDryRunResult, CoverageAnalysis, CoverageAnalysisMode, CoverageAnalysisMode as CoverageAnalysisModeType, CoverageAnalysisSchema, DeepOptional, Dependencies, DependenciesSchema, DryRunCompleted, DryRunOptions, DryRunOptionsSchema, DryRunResult, DryRunResultSchema, DryRunStatus, EXIT_CODE, ErrorDryRunResult, ErrorMutantRunResult, Evaluator, EvaluatorFailed, EvaluatorService, ExitClass, FailedCheckResult, FailedTestResult, FileResult, FileResultDictionary, FileResultDictionarySchema, FileResultSchema, FrameworkInformation, FrameworkInformationSchema, KilledMutantRunResult, KnownKeys, Location, LocationSchema, LogLevel, LogLevel as LogLevelType, Metrics, MetricsResult, MetricsResultSchema, MetricsSchema, MutantActivation, MutantActivationSchema, MutantCoverage, MutantCoverageSchema, MutantResult, MutantResultSchema, MutantRunOptions, MutantRunOptionsSchema, MutantRunResult, MutantRunResultSchema, MutantRunStatus, MutantStatus, MutantStatusSchema, MutantTested, MutationScoreThresholds, MutationScoreThresholdsSchema, MutationTestReportReady, MutationTestResult, MutationTestResultSchema, MutationTestingPlanReady, OnlyObject, OpenEndLocation, OpenEndLocationSchema, PackageManager, PackageManager as PackageManagerType, PartialStrykerOptions, PassedCheckResult, 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, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawn, WorkerPluginSpawnSchema, formatTraceparent, isCustomTestRunner, parseTraceparent, propertyPath, strykerCoreSchema, strykerReportBugUrl, testFilesProvided, toMutantRunResult };
+}
+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 CheckerRequest: S.Struct<{
+  readonly checkerName: S.String;
+  readonly mutants: S.$Array<typeof Mutant>;
+}>;
+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 Mutant[]) => Effect$1.Effect<HashMap.HashMap<string, CheckResult>, CheckerFailed>;
+  readonly group: (mutants: readonly Mutant[]) => 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> = { -readonly [P in keyof T]?: T[P] extends Record<string, unknown> ? DeepOptional<T[P]> | undefined : T[P]; };
+declare type Dependencies = typeof DependenciesSchema.Type;
+declare const DependenciesSchema: S.$Record<S.String, S.String>;
+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">;
+  }>]>>;
+}>, {}>;
+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.Finite>;
+    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.Finite>;
+    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 isCustomTestRunner: (value: TestRunnerConfig) => value is TestRunnerCustomConfig;
+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 type Metrics = typeof MetricsSchema.Type;
+declare interface MetricsResult {
+  readonly name: string;
+  readonly metrics: Metrics;
+  readonly childResults: readonly MetricsResult[];
+}
+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>>>;
+}>;
+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;
+}>;
+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.Finite>;
+  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.Finite;
+  readonly total: S.Finite;
+}>, {}>;
+declare type MutationScoreThresholds = typeof MutationScoreThresholdsSchema.Type;
+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>;
+}>;
+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;
+  }>>;
+}>, {}>;
+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>>>;
+  }>;
+}>, {}>;
+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.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>>;
+  }>>;
+}>;
+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 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<unknown, 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: Record<string, unknown>;
+/** 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>;
+  }>, 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.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.
+ */
+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: 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 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.Struct<{
+  readonly high: S.Finite;
+  readonly low: S.Finite;
+}>;
+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 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 { WorkerPluginKind as $, ReporterAck as A, StrykerOptions as B, MutantTested as C, MutationTestingPlanReady as D, MutationTestResultSchema as E, ReporterFailed as F, TestRunnerCapabilities as G, SuccessTestResult as H, ReporterInit as I, TestRunnerFailed as J, TestRunnerConfig as K, ReporterInitOptions as L, ReporterEvent as M, ReporterEventBatch as N, PartialStrykerOptions as O, ReporterFactory as P, TracedRpc as Q, ReporterRpcs as R, MutantRunResult as S, RunPlan as St, MutationTestResult as T, SurvivedMutantRunResult as U, StrykerOptionsSchema as V, TestResult as W, TimeoutMutantRunResult as X, TimeoutDryRunResult as Y, TraceContextMiddleware as Z, Metrics as _, MutationRange as _t, DeepOptional as a, FileDescription as at, MutantResult as b, RunMutantResult as bt, DryRunResult as c, LocationSchema as ct, ExitClass as d, MutantActivationSchema as dt, WorkerPluginSpawn as et, FailedCheckResult as f, MutantCoverage as ft, KilledMutantRunResult as g, MutateDescription as gt, FileResultSchema as h, MutantStatusSchema as ht, CoverageAnalysis as i, CoverageData as it, ReporterDrained as j, PassedCheckResult as k, ErrorDryRunResult as l, Mutant as lt, FileResult as m, MutantStatus as mt, CheckResult as n, index_d_exports as nt, DryRunCompleted as o, FileDescriptions as ot, FailedTestResult as p, MutantRunOptions as pt, TestRunnerConfigSchema as q, CompleteDryRunResult as r, mutants_d_exports as rt, DryRunOptions as s, Location as st, BaseTestResult as t, WorkerPluginSpawnSchema as tt, ErrorMutantRunResult as u, MutantActivation as ut, MetricsResult as v, Position as vt, MutationTestReportReady as w, MutantResultSchema as x, RunOptions as xt, MetricsSchema as y, PositionSchema as yt, SkippedTestResult as z };