@systemfsoftware/stryker-js 9.0.0 → 10.0.1

package/dist/index.d.mts

@@ -28,6 +28,7 @@ import { Schema } from 'effect';
 import * as Scope from 'effect/Scope';
 import * as Socket from 'effect/unstable/socket/Socket';
 import * as Stdio from 'effect/Stdio';
+import * as Stream from 'effect/Stream';
 import { YieldableError } from 'effect/Cause';
 
 declare interface AccessorProperty$1 extends Span$1 {
@@ -374,8 +375,8 @@ export declare type CheckerRequest = typeof CheckerRequest.Type;
  * which lets the retry combinator prove it handles every one of them.
  */
 export declare interface CheckerResourceService {
-    readonly check: (checkerName: string, mutants: readonly CheckerMutantWire[]) => Effect.Effect<Record<string, CheckResult>, CheckerCrash>;
-    readonly group: (checkerName: string, mutants: readonly CheckerMutantWire[]) => Effect.Effect<readonly (readonly string[])[], CheckerCrash>;
+    readonly check: (checkerName: string, mutants: readonly CheckerMutantWire[]) => Effect.Effect<Record<string, CheckResult>, CheckerCrash | CheckerFailed>;
+    readonly group: (checkerName: string, mutants: readonly CheckerMutantWire[]) => Effect.Effect<readonly (readonly string[])[], CheckerCrash | CheckerFailed>;
 }
 
 export declare const checkerRpcFailures: Metric.Counter<number>;
@@ -390,7 +391,7 @@ declare const CheckerSkippedRequested_base: S.Class<CheckerSkippedRequested, S.T
     readonly missingIds: S.$Array<S.String>;
 }>, YieldableError>;
 
-export declare const checkGroupedPlans: (checker: CheckerResourceService, checkerName: string, plans: readonly RunPlan[]) => Effect.Effect<readonly (readonly [RunPlan, CheckResult])[], CheckerCrash | CheckerContractBroken>;
+export declare const checkGroupedPlans: (checker: CheckerResourceService, checkerName: string, plans: readonly RunPlan[]) => Effect.Effect<readonly (readonly [RunPlan, CheckResult])[], CheckerCrash | CheckerFailed | CheckerContractBroken>;
 
 export declare type CheckResult = FailedCheckResult | PassedCheckResult;
 
@@ -592,7 +593,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;
@@ -711,7 +712,7 @@ declare interface ExportSpecifier extends Span$1 {
     parent?: Node$1;
 }
 
-declare type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | MetaProperty$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
+declare type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | MetaProperty$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
 
 declare interface ExpressionStatement$1 extends Span$1 {
     type: "ExpressionStatement";
@@ -823,7 +824,7 @@ export 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>;
     }>>;
 }>;
@@ -900,11 +901,19 @@ export declare const forkOptionsSchema: 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>;
@@ -930,7 +939,7 @@ declare type FormalParameter = {
 declare interface FormalParameterRest extends Span$1 {
     type: "RestElement";
     argument: BindingPattern$1;
-    decorators?: [];
+    decorators?: Array<Decorator$1>;
     optional?: boolean;
     typeAnnotation?: TSTypeAnnotation$1 | null;
     value?: null;
@@ -959,6 +968,8 @@ declare type ForStatementInit = VariableDeclaration$1 | Expression$1;
 
 declare type ForStatementLeft = VariableDeclaration$1 | AssignmentTarget;
 
+declare type FramedDrain = (framed: Stream.Stream<string, never, never>) => Effect.Effect<void, never, never>;
+
 declare interface Function$1 extends Span$1 {
     type: FunctionType;
     id: BindingIdentifier$1 | null;
@@ -993,8 +1004,8 @@ export declare class Heartbeat extends Heartbeat_base {}
 
 declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
     readonly elapsedMs: S.Finite;
-    readonly completed: S.Finite;
-    readonly total: S.NullOr<S.Finite>;
+    readonly completed: S.Int;
+    readonly total: S.NullOr<S.Int>;
 }>, {}>;
 
 export declare class HelpRendered extends HelpRendered_base {}
@@ -1375,6 +1386,8 @@ declare interface LogicalExpression$1 extends Span$1 {
 
 declare type LogicalOperator = "||" | "&&" | "??";
 
+export declare const makeRunEventStream: (resolved: ResolvedModeInput) => Effect.Effect<RunEventStream, never, Stdio.Stdio | RunEventDrain>;
+
 export declare const makeRunLayer: (env: RunEnvironmentShape, events?: Queue.Queue<RunEvent, Cause.Done>) => Layer.Layer<RunStageServices, never, EnginePorts>;
 
 export declare const makeWorkerClient: <Rpcs extends Rpc.Any>(params: WorkerClientParams<Rpcs>) => Effect.Effect<RpcClient.RpcClient<Rpcs, RpcClientError>, WorkerBootError, Scope.Scope | WorkerLauncher>;
@@ -1423,7 +1436,30 @@ declare type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
 
 declare type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
 
-export declare type Metrics = typeof MetricsSchema.Type;
+export 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;
+}>, {}>;
 
 export declare interface MetricsResult {
     readonly name: string;
@@ -1431,24 +1467,13 @@ export declare interface MetricsResult {
     readonly childResults: readonly MetricsResult[];
 }
 
-export declare const MetricsSchema: S.Struct<{
-    readonly pending: S.Finite;
-    readonly killed: S.Finite;
-    readonly timeout: S.Finite;
-    readonly survived: S.Finite;
-    readonly noCoverage: S.Finite;
-    readonly runtimeErrors: S.Finite;
-    readonly compileErrors: S.Finite;
-    readonly ignored: S.Finite;
-    readonly totalDetected: S.Finite;
-    readonly totalUndetected: S.Finite;
-    readonly totalInvalid: S.Finite;
-    readonly totalValid: S.Finite;
-    readonly totalMutants: S.Finite;
-    readonly totalCovered: S.Finite;
-    readonly mutationScore: S.Finite;
-    readonly mutationScoreBasedOnCoveredCode: S.Finite;
-}>;
+declare interface MetricsResultEncoded {
+    readonly name: string;
+    readonly metrics: typeof Metrics.Encoded;
+    readonly childResults: readonly MetricsResultEncoded[];
+}
+
+export declare const MetricsSchema: typeof Metrics;
 
 export declare type ModeSignal = 'flag' | 'env' | 'tty' | 'agent' | 'tool';
 
@@ -1514,7 +1539,7 @@ export 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>;
 }>;
 
@@ -1551,8 +1576,8 @@ 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;
 }>, {}>;
 
 export declare type MutateDescription = ReadonlyArray<MutationRange> | boolean;
@@ -1572,7 +1597,7 @@ export declare interface MutationTestDone {
 export 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"]>;
@@ -1609,14 +1634,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>;
@@ -1646,28 +1677,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>;
 }>, {}>;
 
 export declare type MutationTestResult = typeof MutationTestResultSchema.Type;
@@ -1697,14 +1707,20 @@ export 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>;
@@ -1847,7 +1863,7 @@ declare const PhaseEntered_base: S.Class<PhaseEntered, S.TaggedStruct<"phase", {
 export declare class PlanKnown extends PlanKnown_base {}
 
 declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
-    readonly total: S.Finite;
+    readonly total: S.Int;
 }>, {}>;
 
 export declare type PluginDescriptor<K extends PluginKind = PluginKind> = PluginDescriptorOf<K>;
@@ -2055,6 +2071,11 @@ export declare interface ResolvedMode {
     readonly stdoutIsTTY: boolean;
 }
 
+export declare interface ResolvedModeInput {
+    readonly mode: 'machine' | 'human';
+    readonly signal: 'flag' | 'env' | 'tty' | 'agent' | 'tool';
+}
+
 export declare function resolveExitCode(pending: Iterable<ExitClass>, signal: number | null): number;
 
 declare interface ReturnStatement$1 extends Span$1 {
@@ -2082,10 +2103,35 @@ export declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof Phase
 
 export declare type RunEvent = typeof RunEvent.Type;
 
+export declare class RunEventDrain extends RunEventDrain_base {}
+
+declare const RunEventDrain_base: Context.ServiceClass<RunEventDrain, "@systemfsoftware/stryker-js/run-event-stream/RunEventDrain", RunEventDrainShape>;
+
+export declare const RunEventDrainLive: Layer.Layer<RunEventDrain, never, Stdio.Stdio>;
+
+declare interface RunEventDrainShape {
+    readonly drainFramed: FramedDrain;
+    readonly setProgressStreamFile: (fileName: string) => Effect.Effect<void, never, never>;
+}
+
 export declare class RunEvents extends RunEvents_base {}
 
 declare const RunEvents_base: Context.ServiceClass<RunEvents, "@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | PhaseEntered | PlanKnown | RunFailed | RunMutantTested | RunStarted | VerdictReached, Cause.Done<void>>>;
 
+export declare interface RunEventStream {
+    readonly queue: Queue.Queue<RunEvent, Cause.Done>;
+    readonly runId: string;
+    readonly startedAt: number;
+    readonly isOpen: Effect.Effect<boolean, never, never>;
+    readonly ensureOpen: (openResolved: ResolvedModeInput) => Effect.Effect<void, never, never>;
+    readonly open: Effect.Effect<void, never, never>;
+    readonly closeAndDrain: Effect.Effect<void, never, never>;
+}
+
+export declare const RunEventWireLine: S.decodeTo<S.fromJsonString<S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>>, S.String, never, never>;
+
+export declare type RunEventWireLine = typeof RunEventWireLine.Type;
+
 export declare class RunFailed extends RunFailed_base {}
 
 declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
@@ -2131,8 +2177,8 @@ declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mut
     }>;
     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;
 }>, {}>;
 
 export declare interface RunOptions {
@@ -2164,6 +2210,8 @@ declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
 
 export declare type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
 
+export { S }
+
 export declare interface SandboxHandle {
     readonly workingDirectory: string;
     readonly sandboxFileFor: (fileName: string) => string;
@@ -2325,11 +2373,19 @@ export 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>;
@@ -3089,16 +3145,7 @@ declare interface VariableDeclarator$1 extends Span$1 {
 
 export declare const VERDICT_ENVELOPE_SCHEMA_VERSION = "1.1";
 
-export declare interface VerdictCounts {
-    readonly killed: number;
-    readonly timeout: number;
-    readonly survived: number;
-    readonly noCoverage: number;
-    readonly runtimeErrors: number;
-    readonly compileErrors: number;
-    readonly ignored: number;
-    readonly pending: number;
-}
+export declare type VerdictCounts = Metrics;
 
 export declare interface VerdictEnvelope {
     readonly schemaVersion: string;
@@ -3107,7 +3154,7 @@ export declare interface VerdictEnvelope {
     readonly signal: ModeSignal;
     readonly score: number | null;
     readonly thresholds: VerdictThresholds;
-    readonly counts: VerdictCounts;
+    readonly counts: Metrics;
     readonly reportFile: string | null;
     readonly mutants: readonly VerdictMutant[];
 }
@@ -3131,22 +3178,21 @@ declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdi
     readonly mode: S.Literals<readonly ["human", "machine"]>;
     readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
     readonly score: S.NullOr<S.Finite>;
-    readonly thresholds: S.Struct<{
+    readonly 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: S.Struct<{
-        readonly killed: S.Finite;
-        readonly timeout: S.Finite;
-        readonly survived: S.Finite;
-        readonly noCoverage: S.Finite;
-        readonly runtimeErrors: S.Finite;
-        readonly compileErrors: S.Finite;
-        readonly ignored: S.Finite;
-        readonly pending: S.Finite;
-    }>;
+    readonly counts: typeof Metrics;
     readonly mutants: S.$Array<S.Struct<{
         readonly id: S.String;
         readonly file: S.String;

package/dist/index.mjs

@@ -1,2 +1,3 @@
-import { $ as StrykerError, $t as FileResultSchema, A as describeErrors, At as RunStarted, B as WorkerLauncher, Bt as defaultOptions, C as strykerVersion, Ct as Heartbeat, D as reporterWorkerFactory, Dt as RunFailed, E as REPORTER_EVENT_BATCH_BOUND, Et as PlanKnown, F as mergeConfigs, Ft as verdictExitClass, G as ChildProcessCrashedError, Gt as CheckerCheckResult, H as makeWorkerClient, Ht as isModuleSpecifier, I as readConfig, It as CONFIG_SYNTAX_HELP, J as VmRunner, Jt as CheckerMutantWire, K as OutOfMemoryError, Kt as CheckerFailed, L as validateOptions, Lt as SUPPORTED_CONFIG_FILE_NAMES, M as importModule, Mt as EXIT_CODE, N as initialExtendsStepState, Nt as highestExitClass, O as spawnReporterWorker, Ot as RunMutantTested, P as loadConfigCell, Pt as resolveExitCode, Q as vmTestRunner, Qt as ExitClass, R as buildTestRunner, Rt as createDefaultOptions, S as matchesFile, St as RunIdentity, T as RunEnvironment, Tt as PhaseEntered, U as IdGenerator, Ut as isWarningEnabled, V as connectRetry, Vt as findUnserializables, W as classifyWorkerExit, Wt as optionsPath, X as vmRunnerCapabilities, Xt as CheckerRpcs, Y as isVmRunner, Yt as CheckerRequest, Z as vmRunnerName, Zt as DryRunCompleted, _ as checkerProcessCrashes, _n as MutantStatusSchema, _t as forkOptionsSchema, a as shouldKeepTempDir, an as MutationTestingPlanReady, at as ConfigFileUnsupportedError, b as CheckerSkippedRequested, bt as StageError, c as buildVerdictEnvelope, cn as ReporterEventBatch, ct as ExtendsStepRead, d as calculateMetrics, dn as StrykerOptionsSchema, dt as ExtendsStepStateSchema, en as MetricsSchema, et as ConfigDocumentSchema, f as countMutants, fn as TestRunnerConfigSchema, ft as ImportedModuleSchema, g as checkerMutantsSkipped, gn as MutantActivationSchema, gt as extendsPropertySchema, h as checkerMutantsChecked, hn as LocationSchema, ht as ReadConfigCommand, i as mutationTestCell, in as MutationTestResultSchema, it as ConfigFileUnreadableError, j as forkCoreSchema, jt as VerdictReached, k as decideExtendsStep, kt as RunPhase, l as generateRunId, ln as ReporterInitOptions, lt as ExtendsStepRefused, m as checkerDuration, mn as WorkerPluginKind, mt as MergeResult, n as RUN_EVENTS_QUEUE_BOUND, nn as MutantTested, nt as ConfigFileInvalidError, o as ACTIONABLE_STATUSES, on as ReporterAck, ot as ExtendsStepDocumentSchema, p as checkGroupedPlans, pn as TraceContextMiddleware, pt as MergeCommand, q as WorkerBootTimeoutError, qt as CheckerGroupResult, r as makeRunLayer, rn as MutationTestReportReady, rt as ConfigFileNotFoundError, s as VERDICT_ENVELOPE_SCHEMA_VERSION, sn as ReporterDrained, st as ExtendsStepDone, t as strykerCell, tn as MutantResultSchema, tt as ConfigError, u as isActionableStatus, un as ReporterRpcs, ut as ExtendsStepResolve, v as checkerRpcFailures, vn as PositionSchema, vt as survivorsPriorReport, w as IncrementalReportSchema, wt as HelpRendered, x as createFileMatcher, xt as RunEvents, y as CheckerAnsweredUnrequested, yt as toRelativeNormalizedFileName, z as isCommandRunner, zt as deepFreeze } from "./src-BQuaL-fB.mjs";
-export { ACTIONABLE_STATUSES, CONFIG_SYNTAX_HELP, CheckerAnsweredUnrequested, CheckerCheckResult, CheckerFailed, CheckerGroupResult, CheckerMutantWire, CheckerRequest, CheckerRpcs, CheckerSkippedRequested, ChildProcessCrashedError, ConfigDocumentSchema, ConfigError, ConfigFileInvalidError, ConfigFileNotFoundError, ConfigFileUnreadableError, ConfigFileUnsupportedError, DryRunCompleted, EXIT_CODE, ExitClass, ExtendsStepDocumentSchema, ExtendsStepDone, ExtendsStepRead, ExtendsStepRefused, ExtendsStepResolve, ExtendsStepStateSchema, FileResultSchema, Heartbeat, HelpRendered, IdGenerator, ImportedModuleSchema, IncrementalReportSchema, LocationSchema, MergeCommand, MergeResult, MetricsSchema, MutantActivationSchema, MutantResultSchema, MutantStatusSchema, MutantTested, MutationTestReportReady, MutationTestResultSchema, MutationTestingPlanReady, OutOfMemoryError, PhaseEntered, PlanKnown, PositionSchema, REPORTER_EVENT_BATCH_BOUND, RUN_EVENTS_QUEUE_BOUND, ReadConfigCommand, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterInitOptions, ReporterRpcs, RunEnvironment, RunEvents, RunFailed, RunIdentity, RunMutantTested, RunPhase, RunStarted, SUPPORTED_CONFIG_FILE_NAMES, StageError, StrykerError, StrykerOptionsSchema, TestRunnerConfigSchema, TraceContextMiddleware, VERDICT_ENVELOPE_SCHEMA_VERSION, VerdictReached, VmRunner, WorkerBootTimeoutError, WorkerLauncher, WorkerPluginKind, buildTestRunner, buildVerdictEnvelope, calculateMetrics, checkGroupedPlans, checkerDuration, checkerMutantsChecked, checkerMutantsSkipped, checkerProcessCrashes, checkerRpcFailures, classifyWorkerExit, connectRetry, countMutants, createDefaultOptions, createFileMatcher, decideExtendsStep, deepFreeze, defaultOptions, describeErrors, extendsPropertySchema, findUnserializables, forkCoreSchema, forkOptionsSchema, generateRunId, highestExitClass, importModule, initialExtendsStepState, isActionableStatus, isCommandRunner, isModuleSpecifier, isVmRunner, isWarningEnabled, loadConfigCell, makeRunLayer, makeWorkerClient, matchesFile, mergeConfigs, mutationTestCell, optionsPath, readConfig, reporterWorkerFactory, resolveExitCode, shouldKeepTempDir, spawnReporterWorker, strykerCell, strykerVersion, survivorsPriorReport, toRelativeNormalizedFileName, validateOptions, verdictExitClass, vmRunnerCapabilities, vmRunnerName, vmTestRunner };
+import { $ as WorkerPluginKind, A as MetricsSchema, B as ReporterEventBatch, C as CheckerRequest, D as FileResultSchema, E as ExitClass, F as MutationTestingPlanReady, H as ReporterInitOptions, M as MutantTested, N as MutationTestReportReady, P as MutationTestResultSchema, R as ReporterAck, S as CheckerMutantWire, T as DryRunCompleted, U as ReporterRpcs, W as StrykerOptionsSchema, X as TraceContextMiddleware, _ as RunStarted, at as LocationSchema, b as CheckerFailed, c as PhaseEntered, ct as MutantStatusSchema, h as RunPhase, i as HelpRendered, j as MutantResultSchema, l as PlanKnown, lt as PositionSchema, m as RunMutantTested, n as StageError, p as RunFailed, q as TestRunnerConfigSchema, r as Heartbeat, st as MutantActivationSchema, v as VerdictReached, w as CheckerRpcs, x as CheckerGroupResult, y as CheckerCheckResult, z as ReporterDrained } from "./Run.schema-CgVfoOfk.mjs";
+import { $ as validateOptions, A as strykerVersion, At as MergeResult, B as optionsPath, C as checkerMutantsSkipped, Ct as ExtendsStepDone, D as CheckerSkippedRequested, Dt as ExtendsStepStateSchema, E as CheckerAnsweredUnrequested, Et as ExtendsStepResolve, F as deepFreeze, Ft as toRelativeNormalizedFileName, G as decideExtendsStep, H as REPORTER_EVENT_BATCH_BOUND, I as defaultOptions, It as RunEvents, J as importModule, K as describeErrors, L as findUnserializables, Lt as RunIdentity, M as CONFIG_SYNTAX_HELP, Mt as extendsPropertySchema, N as SUPPORTED_CONFIG_FILE_NAMES, Nt as forkOptionsSchema, O as createFileMatcher, Ot as ImportedModuleSchema, P as createDefaultOptions, Pt as survivorsPriorReport, Q as readConfig, R as isModuleSpecifier, Rt as RunEventWireLine, S as checkerMutantsChecked, St as ExtendsStepDocumentSchema, T as checkerRpcFailures, Tt as ExtendsStepRefused, U as reporterWorkerFactory, V as RunEnvironment, W as spawnReporterWorker, X as loadConfigCell, Y as initialExtendsStepState, Z as mergeConfigs, _ as verdictExitClass, _t as ConfigError, a as RUN_EVENTS_QUEUE_BOUND, at as IdGenerator, b as checkGroupedPlans, bt as ConfigFileUnreadableError, c as shouldKeepTempDir, ct as OutOfMemoryError, d as buildVerdictEnvelope, dt as isVmRunner, et as buildTestRunner, f as generateRunId, ft as vmRunnerCapabilities, g as resolveExitCode, gt as ConfigDocumentSchema, h as highestExitClass, ht as StrykerError, i as makeRunEventStream, it as makeWorkerClient, j as IncrementalReportSchema, jt as ReadConfigCommand, k as matchesFile, kt as MergeCommand, l as ACTIONABLE_STATUSES, lt as WorkerBootTimeoutError, m as EXIT_CODE, mt as vmTestRunner, n as RunEventDrain, nt as WorkerLauncher, o as makeRunLayer, ot as classifyWorkerExit, p as isActionableStatus, pt as vmRunnerName, q as forkCoreSchema, r as RunEventDrainLive, rt as connectRetry, s as mutationTestCell, st as ChildProcessCrashedError, t as strykerCell, tt as isCommandRunner, u as VERDICT_ENVELOPE_SCHEMA_VERSION, ut as VmRunner, v as calculateMetrics, vt as ConfigFileInvalidError, w as checkerProcessCrashes, wt as ExtendsStepRead, x as checkerDuration, xt as ConfigFileUnsupportedError, y as countMutants, yt as ConfigFileNotFoundError, z as isWarningEnabled, zt as S } from "./src-CMHnl87m.mjs";
+export { ACTIONABLE_STATUSES, CONFIG_SYNTAX_HELP, CheckerAnsweredUnrequested, CheckerCheckResult, CheckerFailed, CheckerGroupResult, CheckerMutantWire, CheckerRequest, CheckerRpcs, CheckerSkippedRequested, ChildProcessCrashedError, ConfigDocumentSchema, ConfigError, ConfigFileInvalidError, ConfigFileNotFoundError, ConfigFileUnreadableError, ConfigFileUnsupportedError, DryRunCompleted, EXIT_CODE, ExitClass, ExtendsStepDocumentSchema, ExtendsStepDone, ExtendsStepRead, ExtendsStepRefused, ExtendsStepResolve, ExtendsStepStateSchema, FileResultSchema, Heartbeat, HelpRendered, IdGenerator, ImportedModuleSchema, IncrementalReportSchema, LocationSchema, MergeCommand, MergeResult, MetricsSchema, MutantActivationSchema, MutantResultSchema, MutantStatusSchema, MutantTested, MutationTestReportReady, MutationTestResultSchema, MutationTestingPlanReady, OutOfMemoryError, PhaseEntered, PlanKnown, PositionSchema, REPORTER_EVENT_BATCH_BOUND, RUN_EVENTS_QUEUE_BOUND, ReadConfigCommand, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterInitOptions, ReporterRpcs, RunEnvironment, RunEventDrain, RunEventDrainLive, RunEventWireLine, RunEvents, RunFailed, RunIdentity, RunMutantTested, RunPhase, RunStarted, S, SUPPORTED_CONFIG_FILE_NAMES, StageError, StrykerError, StrykerOptionsSchema, TestRunnerConfigSchema, TraceContextMiddleware, VERDICT_ENVELOPE_SCHEMA_VERSION, VerdictReached, VmRunner, WorkerBootTimeoutError, WorkerLauncher, WorkerPluginKind, buildTestRunner, buildVerdictEnvelope, calculateMetrics, checkGroupedPlans, checkerDuration, checkerMutantsChecked, checkerMutantsSkipped, checkerProcessCrashes, checkerRpcFailures, classifyWorkerExit, connectRetry, countMutants, createDefaultOptions, createFileMatcher, decideExtendsStep, deepFreeze, defaultOptions, describeErrors, extendsPropertySchema, findUnserializables, forkCoreSchema, forkOptionsSchema, generateRunId, highestExitClass, importModule, initialExtendsStepState, isActionableStatus, isCommandRunner, isModuleSpecifier, isVmRunner, isWarningEnabled, loadConfigCell, makeRunEventStream, makeRunLayer, makeWorkerClient, matchesFile, mergeConfigs, mutationTestCell, optionsPath, readConfig, reporterWorkerFactory, resolveExitCode, shouldKeepTempDir, spawnReporterWorker, strykerCell, strykerVersion, survivorsPriorReport, toRelativeNormalizedFileName, validateOptions, verdictExitClass, vmRunnerCapabilities, vmRunnerName, vmTestRunner };