@systemfsoftware/stryker-js 9.0.0 → 10.0.1

package/dist/Run.schema-t292QQGe.d.mts

@@ -0,0 +1,173 @@
+import { C as Metrics, _ as ExitClass } from "./index-D_mcApox.mjs";
+import * as S from "effect/Schema";
+//#region src/RunEvent.schema.d.ts
+declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+type RunPhase = typeof RunPhase.Type;
+declare const OutputMode: S.Literals<readonly ["human", "machine"]>;
+type OutputMode = typeof OutputMode.Type;
+declare const ModeSignal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+type ModeSignal = typeof ModeSignal.Type;
+declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
+  readonly schemaVersion: S.String;
+  readonly runId: S.String;
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+}>, {}>;
+declare class RunStarted extends RunStarted_base {}
+declare const PhaseEntered_base: S.Class<PhaseEntered, S.TaggedStruct<"phase", {
+  readonly phase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+  readonly elapsedMs: S.Finite;
+}>, {}>;
+declare class PhaseEntered extends PhaseEntered_base {}
+declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
+  readonly total: S.Int;
+}>, {}>;
+declare class PlanKnown extends PlanKnown_base {}
+declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mutant", {
+  readonly id: S.String;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly file: S.String;
+  readonly location: S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+  }>;
+  readonly mutator: S.String;
+  readonly replacement: S.NullOr<S.String>;
+  readonly completed: S.Int;
+  readonly total: S.Int;
+}>, {}>;
+declare class RunMutantTested extends RunMutantTested_base {}
+declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
+  readonly elapsedMs: S.Finite;
+  readonly completed: S.Int;
+  readonly total: S.NullOr<S.Int>;
+}>, {}>;
+declare class Heartbeat extends Heartbeat_base {}
+declare const VerdictThresholdsValuesSchema: S.Struct<{
+  readonly high: S.Finite;
+  readonly low: S.Finite;
+  readonly break: S.NullOr<S.Finite>;
+}>;
+type VerdictThresholds = typeof VerdictThresholdsValuesSchema.Type;
+declare const VerdictMutant: S.Struct<{
+  readonly id: S.String;
+  readonly file: S.String;
+  readonly location: S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+  }>;
+  readonly mutator: S.String;
+  readonly replacement: S.NullOr<S.String>;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+}>;
+type VerdictMutant = typeof VerdictMutant.Type;
+type VerdictCounts = Metrics;
+declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
+  readonly schemaVersion: S.String;
+  readonly runId: S.String;
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+  readonly score: S.NullOr<S.Finite>;
+  readonly thresholds: S.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.Finite;
+    readonly low: S.Finite;
+    readonly break: S.NullOr<S.Finite>;
+  }>, never, never>;
+  readonly reportFile: S.NullOr<S.String>;
+  readonly counts: typeof Metrics;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly file: S.String;
+    readonly location: S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+      readonly end: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+    }>;
+    readonly mutator: S.String;
+    readonly replacement: S.NullOr<S.String>;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  }>>;
+}>, {}>;
+declare class VerdictReached extends VerdictReached_base {}
+declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
+  readonly schemaVersion: S.String;
+  readonly code: S.Finite;
+  readonly error: S.String;
+  readonly remediation: S.String;
+}>, {}>;
+declare class RunFailed extends RunFailed_base {}
+declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
+  readonly schemaVersion: S.String;
+  readonly code: S.Literals<readonly [0]>;
+  readonly help: S.String;
+}>, {}>;
+declare class HelpRendered extends HelpRendered_base {}
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
+type RunEvent = typeof RunEvent.Type;
+type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
+declare const RunDecodeError_base: S.Class<RunDecodeError, S.TaggedStruct<"RunDecodeError", {
+  readonly message: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RunDecodeError extends RunDecodeError_base {}
+declare const RunReadError_base: S.Class<RunReadError, S.TaggedStruct<"RunReadError", {
+  readonly message: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RunReadError extends RunReadError_base {}
+declare const PlanMutationRunCommand_base: S.Class<PlanMutationRunCommand, S.TaggedStruct<"PlanMutationRunCommand", {
+  readonly configMutatePatterns: S.$Array<S.String>;
+  readonly configMutatorNames: S.$Array<S.String>;
+  readonly targetMutatePatterns: S.$Array<S.String>;
+  readonly availableMutators: S.$Array<S.String>;
+}>, {}>;
+declare class PlanMutationRunCommand extends PlanMutationRunCommand_base {}
+declare const MutationRunPlan_base: S.Class<MutationRunPlan, S.TaggedStruct<"MutationRunPlan", {
+  readonly mutatePatterns: S.$Array<S.String>;
+  readonly mutatorNames: S.$Array<S.String>;
+}>, {}>;
+declare class MutationRunPlan extends MutationRunPlan_base {}
+//#endregion
+//#region src/Run.schema.d.ts
+declare const TypeId: '~stryker/mutation-run/StageError';
+declare const StageError_base: S.Class<StageError, S.TaggedStruct<"StageError", {
+  readonly stage: S.Literals<readonly ["prepare", "instrument", "dryRun", "dryRunNoTests", "mutationTest"]>;
+  readonly reason: S.String;
+  readonly cause: S.optional<S.Defect>;
+  readonly command: S.optional<S.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class StageError extends StageError_base {
+  readonly [TypeId]: "~stryker/mutation-run/StageError";
+  get exitClass(): ExitClass;
+  get message(): string;
+}
+declare const PrepareError_base: S.Class<PrepareError, S.TaggedStruct<"PrepareError", {
+  readonly stage: S.Literal<"prepare">;
+  readonly reason: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class PrepareError extends PrepareError_base {}
+//#endregion
+export { VerdictThresholds as S, RunStarted as _, ModeSignal as a, VerdictMutant as b, PhaseEntered as c, RunDecodeError as d, RunEvent as f, RunReadError as g, RunPhase as h, HelpRendered as i, PlanKnown as l, RunMutantTested as m, StageError as n, MutationRunPlan as o, RunFailed as p, Heartbeat as r, OutputMode as s, PrepareError as t, PlanMutationRunCommand as u, RunTerminalEvent as v, VerdictReached as x, VerdictCounts as y };

package/dist/config.d.mts

@@ -1,4 +1,5 @@
-import { L as PartialStrykerOptions, Y as StrykerOptions, n as OutputMode } from "./output-mode-CE6VNHfH.mjs";
+import { K as StrykerOptions, P as PartialStrykerOptions } from "./index-D_mcApox.mjs";
+import { n as OutputMode } from "./output-mode-CfGHDpi5.mjs";
 //#region src/config/stryker-config.d.ts
 interface ConfigEnv {
   readonly command: 'run' | 'merge-reports';

package/dist/events.d.mts

@@ -0,0 +1,2 @@
+import { S as VerdictThresholds, _ as RunStarted, a as ModeSignal, b as VerdictMutant, c as PhaseEntered, d as RunDecodeError, f as RunEvent, g as RunReadError, h as RunPhase, i as HelpRendered, l as PlanKnown, m as RunMutantTested, n as StageError, o as MutationRunPlan, p as RunFailed, r as Heartbeat, s as OutputMode, t as PrepareError, u as PlanMutationRunCommand, x as VerdictReached, y as VerdictCounts } from "./Run.schema-t292QQGe.mjs";
+export { Heartbeat, HelpRendered, ModeSignal, MutationRunPlan, OutputMode, PhaseEntered, PlanKnown, PlanMutationRunCommand, PrepareError, RunDecodeError, RunEvent, RunFailed, RunMutantTested, RunPhase, RunReadError, RunStarted, StageError, type VerdictCounts, type VerdictMutant, VerdictReached, type VerdictThresholds };

package/dist/events.mjs

@@ -0,0 +1,2 @@
+import { _ as RunStarted, a as ModeSignal, c as PhaseEntered, d as RunDecodeError, f as RunEvent, g as RunReadError, h as RunPhase, i as HelpRendered, l as PlanKnown, m as RunMutantTested, n as StageError, o as MutationRunPlan, p as RunFailed, r as Heartbeat, s as OutputMode, t as PrepareError, u as PlanMutationRunCommand, v as VerdictReached } from "./Run.schema-CgVfoOfk.mjs";
+export { Heartbeat, HelpRendered, ModeSignal, MutationRunPlan, OutputMode, PhaseEntered, PlanKnown, PlanMutationRunCommand, PrepareError, RunDecodeError, RunEvent, RunFailed, RunMutantTested, RunPhase, RunReadError, RunStarted, StageError, VerdictReached };

package/dist/{getMachineId-bsd-C6bLIaiv.mjs → getMachineId-bsd-DGLFi8Ia.mjs}

@@ -1,5 +1,5 @@
 import { a as __require, o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 import { t as require_execAsync } from "./execAsync-DdCu5QLN.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.11.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-bsd.js
 var require_getMachineId_bsd = /* @__PURE__ */ __commonJSMin(((exports) => {

package/dist/{getMachineId-bsd-CXSiHDga.mjs → getMachineId-bsd-YZILidse.mjs}

@@ -1,5 +1,5 @@
 import { a as __require, o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 import { t as require_execAsync } from "./execAsync-CfPZgJSD.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.2.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-bsd.js
 var require_getMachineId_bsd = /* @__PURE__ */ __commonJSMin(((exports) => {

package/dist/{getMachineId-darwin-DPZ0kdKD.mjs → getMachineId-darwin-B_CgClId.mjs}

@@ -1,5 +1,5 @@
 import { o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 import { t as require_execAsync } from "./execAsync-CfPZgJSD.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.2.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-darwin.js
 var require_getMachineId_darwin = /* @__PURE__ */ __commonJSMin(((exports) => {

package/dist/{getMachineId-darwin-D3cIKeqx.mjs → getMachineId-darwin-Bfwczd9V.mjs}

@@ -1,5 +1,5 @@
 import { o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 import { t as require_execAsync } from "./execAsync-DdCu5QLN.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.11.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-darwin.js
 var require_getMachineId_darwin = /* @__PURE__ */ __commonJSMin(((exports) => {

package/dist/{getMachineId-linux-Ci8OVJU0.mjs → getMachineId-linux-CPAE174r.mjs}

@@ -1,5 +1,5 @@
 import { a as __require, o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.11.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-linux.js
 var require_getMachineId_linux = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{getMachineId-linux-CQwLSlZk.mjs → getMachineId-linux-DprzjpT3.mjs}

@@ -1,5 +1,5 @@
 import { a as __require, o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.2.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-linux.js
 var require_getMachineId_linux = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{getMachineId-unsupported-PX0hnW6X.mjs → getMachineId-unsupported-Ce9f061A.mjs}

@@ -1,5 +1,5 @@
 import { o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.2.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-unsupported.js
 var require_getMachineId_unsupported = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{getMachineId-unsupported-_ExL3Avl.mjs → getMachineId-unsupported-j7fStyPQ.mjs}

@@ -1,5 +1,5 @@
 import { o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.11.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-unsupported.js
 var require_getMachineId_unsupported = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{getMachineId-win-D9Tb0p7w.mjs → getMachineId-win-DETv1PQd.mjs}

@@ -1,5 +1,5 @@
 import { a as __require, o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 import { t as require_execAsync } from "./execAsync-CfPZgJSD.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.2.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-win.js
 var require_getMachineId_win = /* @__PURE__ */ __commonJSMin(((exports) => {

package/dist/{getMachineId-win-BCsS9pC_.mjs → getMachineId-win-ZJtT3h1l.mjs}

@@ -1,5 +1,5 @@
 import { a as __require, o as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-Dr7-SnC6.mjs";
-import { i as init_esm, r as esm_exports } from "./main.mjs";
+import { n as init_esm, t as esm_exports } from "./main.mjs";
 import { t as require_execAsync } from "./execAsync-DdCu5QLN.mjs";
 //#region ../../node_modules/.pnpm/@opentelemetry+resources@2.11.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-win.js
 var require_getMachineId_win = /* @__PURE__ */ __commonJSMin(((exports) => {

package/dist/{output-mode-CE6VNHfH.d.mts → index-D_mcApox.d.mts}

@@ -1,13 +1,13 @@
 import * as Effect$1 from "effect/Effect";
-import * as S from "effect/Schema";
+import * as Context from "effect/Context";
 import * as Option from "effect/Option";
+import * as S from "effect/Schema";
 import { Schema } from "effect";
-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 { YieldableError } from "effect/Cause";
 import * as HashMap from "effect/HashMap";
+import { YieldableError } from "effect/Cause";
 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 };
@@ -192,7 +192,7 @@ declare interface RunPlan {
 }
 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, 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 };
+  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, 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, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawn, WorkerPluginSpawnSchema, formatTraceparent, isCustomTestRunner, parseTraceparent, propertyPath, strykerCoreSchema, strykerReportBugUrl, testFilesProvided, toMutantRunResult };
 }
 declare interface BaseTestResult {
   readonly id: string;
@@ -320,6 +320,7 @@ declare const CoverageAnalysisSchema: S.Literals<readonly ["off", "all", "perTes
 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 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<{
@@ -329,7 +330,7 @@ declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dry
   readonly capabilities: S.Struct<{
     readonly reloadEnvironment: S.Boolean;
   }>;
-  readonly testCount: S.Finite;
+  readonly testCount: S.Int;
   readonly tests: S.$Array<S.Union<readonly [S.Struct<{
     readonly id: S.String;
     readonly name: S.String;
@@ -476,7 +477,7 @@ declare const FileResultDictionarySchema: S.$Record<S.String, S.Struct<{
     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 testsCompleted: S.optional<S.Int>;
     readonly duration: S.optional<S.Finite>;
   }>>;
 }>>;
@@ -503,7 +504,7 @@ declare const FileResultSchema: S.Struct<{
     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 testsCompleted: S.optional<S.Int>;
     readonly duration: S.optional<S.Finite>;
   }>>;
 }>;
@@ -518,6 +519,7 @@ declare const FrameworkInformationSchema: S.Struct<{
   }>>;
   readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
 }>;
+declare const InvalidStatus: S.Union<readonly [S.Literal<"CompileError">, S.Literal<"RuntimeError">]>;
 declare const isCustomTestRunner: (value: TestRunnerConfig) => value is TestRunnerCustomConfig;
 declare interface KilledMutantRunResult {
   readonly status: 'killed';
@@ -533,52 +535,41 @@ declare type KnownKeys<T> = keyof { [P in keyof T as string extends P ? never :
 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 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 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 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>;
@@ -604,7 +595,7 @@ declare const MutantResultSchema: S.Struct<{
   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 testsCompleted: S.optional<S.Int>;
   readonly duration: S.optional<S.Finite>;
 }>;
 declare type MutantRunResult = ErrorMutantRunResult | KilledMutantRunResult | SurvivedMutantRunResult | TimeoutMutantRunResult;
@@ -642,18 +633,26 @@ declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTes
   }>;
   readonly mutator: S.String;
   readonly replacement: S.NullOr<S.String>;
-  readonly completed: S.Finite;
-  readonly total: S.Finite;
+  readonly completed: S.Int;
+  readonly total: S.Int;
 }>, {}>;
 declare type MutationScoreThresholds = typeof MutationScoreThresholdsSchema.Type;
-declare const MutationScoreThresholdsSchema: S.Struct<{
+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.Finite;
+  readonly total: S.Int;
   readonly plans: S.$Array<S.Struct<{
     readonly mutantId: S.String;
     readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
@@ -688,14 +687,20 @@ declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.T
         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 testsCompleted: S.optional<S.Int>;
         readonly duration: S.optional<S.Finite>;
       }>>;
     }>>;
-    readonly thresholds: S.Struct<{
+    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>;
@@ -725,28 +730,7 @@ declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.T
       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>>>;
-  }>;
+  readonly metrics: S.Codec<MetricsResult, MetricsResultEncoded, never, never>;
 }>, {}>;
 declare type MutationTestResult = typeof MutationTestResultSchema.Type;
 declare const MutationTestResultSchema: S.Struct<{
@@ -774,14 +758,20 @@ declare const MutationTestResultSchema: S.Struct<{
       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 testsCompleted: S.optional<S.Int>;
       readonly duration: S.optional<S.Finite>;
     }>>;
   }>>;
-  readonly thresholds: S.Struct<{
+  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>;
@@ -811,6 +801,8 @@ declare const MutationTestResultSchema: S.Struct<{
     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;
@@ -823,6 +815,7 @@ 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 {}
@@ -971,11 +964,19 @@ declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
     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 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>, never>;
   readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
   readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
   readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
@@ -1157,10 +1158,16 @@ declare interface TestRunnerService {
 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<{
+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;
@@ -1185,6 +1192,8 @@ 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 WorkerEntryUrl: S.String;
 declare type WorkerEntryUrl = typeof WorkerEntryUrl.Type;
 declare const WorkerPluginKind: S.Literals<readonly ["TestRunner", "Checker", "Reporter"]>;
@@ -1195,20 +1204,4 @@ declare const WorkerPluginSpawnSchema: S.Struct<{
   readonly entrypoint: S.String;
 }>;
 //#endregion
-//#region src/output-mode.d.ts
-/**
- * Mode type vocabulary shared with the CLI package. Runtime resolution
- * (`resolveMode`) and gate functions (`isProgressEnabled`, `isColorEnabled`)
- * live in the CLI; the `ResolvedMode` fields (`mode`, `signal`,
- * `stdoutIsTTY`) ride along in `VerdictEnvelope` (`verdict-envelope.ts`),
- * so the types stay where the data does.
- */
-type OutputMode = 'human' | 'machine';
-type ModeSignal = 'flag' | 'env' | 'tty' | 'agent' | 'tool';
-interface ResolvedMode {
-  readonly mode: OutputMode;
-  readonly signal: ModeSignal;
-  readonly stdoutIsTTY: boolean;
-}
-//#endregion
-export { TestResult as $, MutantResultSchema as A, ReporterDrained as B, FileResult as C, MutationRange as Ct, MetricsResult as D, RunOptions as Dt, Metrics as E, RunMutantResult as Et, MutationTestResultSchema as F, ReporterInit as G, ReporterEventBatch as H, MutationTestingPlanReady as I, SkippedTestResult as J, ReporterInitOptions as K, PartialStrykerOptions as L, MutantTested as M, MutationTestReportReady as N, MetricsSchema as O, RunPlan as Ot, MutationTestResult as P, SurvivedMutantRunResult as Q, PassedCheckResult as R, FailedTestResult as S, MutateDescription as St, KilledMutantRunResult as T, PositionSchema as Tt, ReporterFactory as U, ReporterEvent as V, ReporterFailed as W, StrykerOptionsSchema as X, StrykerOptions as Y, SuccessTestResult as Z, DryRunResult as _, MutantActivationSchema as _t, CheckResult as a, TimeoutMutantRunResult as at, ExitClass as b, MutantStatus as bt, CheckerGroupResult as c, WorkerPluginKind as ct, CheckerRpcs as d, FileDescription as dt, TestRunnerCapabilities as et, CompleteDryRunResult as f, FileDescriptions as ft, DryRunOptions as g, MutantActivation as gt, DryRunCompleted as h, Mutant as ht, BaseTestResult as i, TimeoutDryRunResult as it, MutantRunResult as j, MutantResult as k, index_d_exports$1 as kt, CheckerMutantWire as l, index_d_exports as lt, DeepOptional as m, LocationSchema as mt, OutputMode as n, TestRunnerConfigSchema as nt, CheckerCheckResult as o, TraceContextMiddleware as ot, CoverageAnalysis as p, Location as pt, ReporterRpcs as q, ResolvedMode as r, TestRunnerFailed as rt, CheckerFailed as s, TracedRpc as st, ModeSignal as t, TestRunnerConfig as tt, CheckerRequest as u, CoverageData as ut, ErrorDryRunResult as v, MutantCoverage as vt, FileResultSchema as w, Position as wt, FailedCheckResult as x, MutantStatusSchema as xt, ErrorMutantRunResult as y, MutantRunOptions as yt, ReporterAck as z };
+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 };