@systemfsoftware/stryker-js 3.0.2 → 5.0.0

package/dist/ReporterEvent.schema-BhtyYCZo.d.mts

@@ -1,189 +0,0 @@
-import { n as MetricsResult } from "./Metrics.schema-BaVd6rXs.mjs";
-import { m as StrykerOptions } from "./Schema-4oCWQ0P0.mjs";
-import * as S from "effect/Schema";
-import { StandardSchemaV1 } from "effect/StandardSchema";
-//#region src/ReporterEvent.schema.d.ts
-declare const ReporterEventKind: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
-type ReporterEventKind = typeof ReporterEventKind.Type;
-declare const RunTimingSchema: S.Struct<{
-  readonly net: S.Finite;
-  readonly overhead: S.Finite;
-}>;
-type RunTiming = typeof RunTimingSchema.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;
-}>;
-type ReporterPlanDescriptor = typeof ReporterPlanDescriptorSchema.Type;
-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 class DryRunCompleted extends DryRunCompleted_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 MutationTestingPlanReady extends MutationTestingPlanReady_base {}
-declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTested", {
-  readonly id: S.String;
-  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "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 class MutantTested extends MutantTested_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 class MutationTestReportReady extends MutationTestReportReady_base {}
-declare const ReporterEventUnion: S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>;
-type ReporterEvent = DryRunCompleted | MutationTestingPlanReady | MutantTested | MutationTestReportReady;
-declare const ReporterEventSchema: StandardSchemaV1<unknown, ReporterEvent>;
-interface ReporterInit {
-  readonly traceparent?: string | undefined;
-  readonly tracestate?: string | undefined;
-}
-type ReporterFactory = (options: StrykerOptions, init: ReporterInit) => (events: AsyncIterable<ReporterEvent>) => Promise<void>;
-//#endregion
-export { ReporterEvent as a, ReporterEventUnion as c, ReporterPlanDescriptor as d, RunTiming as f, MutationTestingPlanReady as i, ReporterFactory as l, MutantTested as n, ReporterEventKind as o, MutationTestReportReady as r, ReporterEventSchema as s, DryRunCompleted as t, ReporterInit as u };

package/dist/Run-BUpNSmcM.d.mts

@@ -1,172 +0,0 @@
-import * as Context from "effect/Context";
-import * as S from "effect/Schema";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Cause from "effect/Cause";
-import * as Queue from "effect/Queue";
-//#region src/Run.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 MutantStatus: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
-type MutantStatus = typeof MutantStatus.Type;
-declare const Position: S.Struct<{
-  readonly line: S.Finite;
-  readonly column: S.Finite;
-}>;
-declare const 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;
-  }>;
-}>;
-type Location = typeof Location.Type;
-type Position = typeof Position.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.Finite;
-}>, {}>;
-declare class PlanKnown extends PlanKnown_base {}
-declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutant", {
-  readonly id: S.String;
-  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "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 class MutantTested extends MutantTested_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>;
-}>, {}>;
-declare class Heartbeat extends Heartbeat_base {}
-declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
-  readonly schemaVersion: S.String;
-  readonly runId: S.String;
-  readonly mode: S.Literals<readonly ["human", "machine"]>;
-  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
-  readonly score: S.NullOr<S.Finite>;
-  readonly thresholds: S.Struct<{
-    readonly high: S.Finite;
-    readonly low: S.Finite;
-    readonly break: S.NullOr<S.Finite>;
-  }>;
-  readonly reportFile: S.NullOr<S.String>;
-  readonly counts: S.Struct<{
-    readonly killed: S.Finite;
-    readonly timeout: S.Finite;
-    readonly survived: S.Finite;
-    readonly noCoverage: S.Finite;
-    readonly runtimeErrors: S.Finite;
-    readonly compileErrors: S.Finite;
-    readonly ignored: S.Finite;
-    readonly pending: S.Finite;
-  }>;
-  readonly mutants: S.$Array<S.Struct<{
-    readonly id: S.String;
-    readonly file: S.String;
-    readonly location: S.Struct<{
-      readonly start: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-      }>;
-      readonly end: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-      }>;
-    }>;
-    readonly mutator: S.String;
-    readonly replacement: S.NullOr<S.String>;
-    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "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 MutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
-type RunEvent = typeof RunEvent.Type;
-type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
-declare const RunCommand_base: S.Class<RunCommand, S.TaggedStruct<"RunCommand", {
-  readonly cliOptionsJson: S.String;
-  readonly targetMutatePatterns: S.$Array<S.String>;
-}>, {}>;
-declare class RunCommand extends RunCommand_base {}
-declare const RunOutput_base: S.Class<RunOutput, S.TaggedStruct<"RunOutput", {
-  readonly verdictJson: S.String;
-  readonly exitCode: S.Finite;
-}>, {}>;
-declare class RunOutput extends RunOutput_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 {}
-declare namespace Run_d_exports {
-  export { Heartbeat, HelpRendered, Location, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, Position, RunEvent, RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, RunTerminalEvent, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir };
-}
-declare const planMutationRun: (command: PlanMutationRunCommand) => MutationRunPlan;
-declare const RunEvents_base: Context.ServiceClass<RunEvents, "~@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | MutantTested | PhaseEntered | PlanKnown | RunFailed | RunStarted | VerdictReached, Cause.Done<void>>>;
-declare class RunEvents extends RunEvents_base {}
-interface RunIdentityShape {
-  readonly runId: string;
-  readonly basePath: string;
-}
-declare const RunIdentity_base: Context.ServiceClass<RunIdentity, "~@systemfsoftware/stryker-js/RunIdentity", RunIdentityShape>;
-declare class RunIdentity extends RunIdentity_base {}
-interface MutationRunIo {
-  readonly read: (command: RunCommand) => Effect.Effect<unknown, S.SchemaError, RunIdentity>;
-  readonly write: (output: RunOutput) => Effect.Effect<void, S.SchemaError, RunIdentity>;
-}
-declare const runMutationTest: (io: MutationRunIo, command: RunCommand) => Effect.Effect<void, S.SchemaError, RunIdentity>;
-declare const shouldKeepTempDir: (exit: Exit.Exit<void, unknown>, cleanTempDir: 'always' | boolean) => boolean;
-//#endregion
-export { RunTerminalEvent as C, RunStarted as S, PlanKnown as _, Run_d_exports as a, RunFailed as b, shouldKeepTempDir as c, Location as d, ModeSignal as f, PhaseEntered as g, OutputMode as h, RunIdentityShape as i, Heartbeat as l, MutantTested as m, RunEvents as n, planMutationRun as o, MutantStatus as p, RunIdentity as r, runMutationTest as s, MutationRunIo as t, HelpRendered as u, Position as v, VerdictReached as w, RunPhase as x, RunEvent as y };

package/dist/Run.d.mts

@@ -1,2 +0,0 @@
-import { C as RunTerminalEvent, S as RunStarted, _ as PlanKnown, b as RunFailed, c as shouldKeepTempDir, d as Location, f as ModeSignal, g as PhaseEntered, h as OutputMode, i as RunIdentityShape, l as Heartbeat, m as MutantTested, n as RunEvents, o as planMutationRun, p as MutantStatus, r as RunIdentity, s as runMutationTest, t as MutationRunIo, u as HelpRendered, v as Position, w as VerdictReached, x as RunPhase, y as RunEvent } from "./Run-BUpNSmcM.mjs";
-export { Heartbeat, HelpRendered, type Location, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, type Position, RunEvent, type RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, type RunTerminalEvent, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir };

package/dist/Run.mjs

@@ -1,56 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as MutantTested, c as PhaseEntered, d as RunEvent, f as RunFailed, g as VerdictReached, h as RunStarted, i as MutantStatus, l as PlanKnown, m as RunPhase, n as HelpRendered, o as MutationRunPlan, p as RunOutput, r as ModeSignal, s as OutputMode, t as Heartbeat, u as PlanMutationRunCommand } from "./Run.schema-DZve3k2m.mjs";
-import * as Context from "effect/Context";
-import * as S from "effect/Schema";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Result from "effect/Result";
-//#region src/Run.ts
-var Run_exports = /* @__PURE__ */ __exportAll({
-	Heartbeat: () => Heartbeat,
-	HelpRendered: () => HelpRendered,
-	ModeSignal: () => ModeSignal,
-	MutantStatus: () => MutantStatus,
-	MutantTested: () => MutantTested,
-	OutputMode: () => OutputMode,
-	PhaseEntered: () => PhaseEntered,
-	PlanKnown: () => PlanKnown,
-	RunEvent: () => RunEvent,
-	RunEvents: () => RunEvents,
-	RunFailed: () => RunFailed,
-	RunIdentity: () => RunIdentity,
-	RunPhase: () => RunPhase,
-	RunStarted: () => RunStarted,
-	VerdictReached: () => VerdictReached,
-	planMutationRun: () => planMutationRun,
-	runMutationTest: () => runMutationTest,
-	shouldKeepTempDir: () => shouldKeepTempDir
-});
-const firstNonEmpty = (preferred, fallback) => {
-	if (preferred.length > 0) return [...preferred];
-	return [...fallback];
-};
-const planMutationRun = (command) => MutationRunPlan.make({
-	mutatePatterns: firstNonEmpty(command.targetMutatePatterns, command.configMutatePatterns),
-	mutatorNames: firstNonEmpty(command.availableMutators, command.configMutatorNames)
-});
-var RunEvents = class extends Context.Service()("~@systemfsoftware/stryker-js/RunEvents") {};
-var RunIdentity = class extends Context.Service()("~@systemfsoftware/stryker-js/RunIdentity") {};
-const runMutationTest = (io, command) => Effect.gen(function* () {
-	const raw = yield* io.read(command);
-	const planCommand = yield* Result.match(S.decodeUnknownResult(PlanMutationRunCommand)(raw), {
-		onFailure: (error) => Effect.fail(error),
-		onSuccess: (decoded) => Effect.succeed(decoded)
-	});
-	const plan = planMutationRun(planCommand);
-	return yield* io.write(new RunOutput({
-		verdictJson: JSON.stringify({
-			mutate: plan.mutatePatterns,
-			mutatorNames: plan.mutatorNames
-		}),
-		exitCode: 0
-	}));
-});
-const shouldKeepTempDir = (exit, cleanTempDir) => Exit.isFailure(exit) && cleanTempDir !== "always";
-//#endregion
-export { Heartbeat, HelpRendered, ModeSignal, MutantStatus, MutantTested, OutputMode, PhaseEntered, PlanKnown, RunEvent, RunEvents, RunFailed, RunIdentity, RunPhase, RunStarted, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir, Run_exports as t };

package/dist/Run.schema-DZve3k2m.mjs

@@ -1,138 +0,0 @@
-import * as S from "effect/Schema";
-//#region src/Run.schema.ts
-const RunPhase = S.Literals([
-	"prepare",
-	"instrument",
-	"dry-run",
-	"mutation-test"
-]);
-const OutputMode = S.Literals(["human", "machine"]);
-const ModeSignal = S.Literals([
-	"flag",
-	"env",
-	"tty",
-	"agent",
-	"tool"
-]);
-const MutantStatus = S.Literals([
-	"Killed",
-	"Survived",
-	"NoCoverage",
-	"Timeout",
-	"CompileError",
-	"RuntimeError",
-	"Ignored",
-	"Pending"
-]);
-const Position = S.Struct({
-	line: S.Finite,
-	column: S.Finite
-});
-const Location = S.Struct({
-	start: Position,
-	end: Position
-});
-var RunStarted = class extends S.TaggedClass()("stream", {
-	schemaVersion: S.String,
-	runId: S.String,
-	mode: OutputMode,
-	signal: ModeSignal
-}) {};
-var PhaseEntered = class extends S.TaggedClass()("phase", {
-	phase: RunPhase,
-	elapsedMs: S.Finite
-}) {};
-var PlanKnown = class extends S.TaggedClass()("plan", { total: S.Finite }) {};
-var MutantTested = class extends S.TaggedClass()("mutant", {
-	id: S.String,
-	status: MutantStatus,
-	file: S.String,
-	location: Location,
-	mutator: S.String,
-	replacement: S.NullOr(S.String),
-	completed: S.Finite,
-	total: S.Finite
-}) {};
-var Heartbeat = class extends S.TaggedClass()("tick", {
-	elapsedMs: S.Finite,
-	completed: S.Finite,
-	total: S.NullOr(S.Finite)
-}) {};
-const VerdictThresholds = S.Struct({
-	high: S.Finite,
-	low: S.Finite,
-	break: S.NullOr(S.Finite)
-});
-const VerdictMutant = S.Struct({
-	id: S.String,
-	file: S.String,
-	location: Location,
-	mutator: S.String,
-	replacement: S.NullOr(S.String),
-	status: MutantStatus
-});
-const VerdictCounts = S.Struct({
-	killed: S.Finite,
-	timeout: S.Finite,
-	survived: S.Finite,
-	noCoverage: S.Finite,
-	runtimeErrors: S.Finite,
-	compileErrors: S.Finite,
-	ignored: S.Finite,
-	pending: S.Finite
-});
-var VerdictReached = class extends S.TaggedClass()("verdict", {
-	schemaVersion: S.String,
-	runId: S.String,
-	mode: OutputMode,
-	signal: ModeSignal,
-	score: S.NullOr(S.Finite),
-	thresholds: VerdictThresholds,
-	reportFile: S.NullOr(S.String),
-	counts: VerdictCounts,
-	mutants: S.Array(VerdictMutant)
-}) {};
-var RunFailed = class extends S.TaggedClass()("error", {
-	schemaVersion: S.String,
-	code: S.Finite,
-	error: S.String,
-	remediation: S.String
-}) {};
-var HelpRendered = class extends S.TaggedClass()("help", {
-	schemaVersion: S.String,
-	code: S.Literals([0]),
-	help: S.String
-}) {};
-const RunEvent = S.Union([
-	RunStarted,
-	PhaseEntered,
-	PlanKnown,
-	MutantTested,
-	Heartbeat,
-	VerdictReached,
-	RunFailed,
-	HelpRendered
-]);
-S.TaggedClass()("RunCommand", {
-	cliOptionsJson: S.String,
-	targetMutatePatterns: S.Array(S.String)
-});
-var RunOutput = class extends S.TaggedClass()("RunOutput", {
-	verdictJson: S.String,
-	exitCode: S.Finite
-}) {};
-S.TaggedError()("RunDecodeError", { message: S.String });
-S.TaggedError()("RunReadError", { message: S.String });
-S.TaggedError()("RunWriteError", { message: S.String });
-var PlanMutationRunCommand = class extends S.TaggedClass()("PlanMutationRunCommand", {
-	configMutatePatterns: S.Array(S.String),
-	configMutatorNames: S.Array(S.String),
-	targetMutatePatterns: S.Array(S.String),
-	availableMutators: S.Array(S.String)
-}) {};
-var MutationRunPlan = class extends S.TaggedClass()("MutationRunPlan", {
-	mutatePatterns: S.Array(S.String),
-	mutatorNames: S.Array(S.String)
-}) {};
-//#endregion
-export { MutantTested as a, PhaseEntered as c, RunEvent as d, RunFailed as f, VerdictReached as g, RunStarted as h, MutantStatus as i, PlanKnown as l, RunPhase as m, HelpRendered as n, MutationRunPlan as o, RunOutput as p, ModeSignal as r, OutputMode as s, Heartbeat as t, PlanMutationRunCommand as u };