@systemfsoftware/stryker-js 0.1.0

package/dist/Plugin-ZYNaWrl7.d.mts

@@ -0,0 +1,134 @@
+import { n as Checker } from "./Checker-DYgIIEai.mjs";
+import { J as TestRunner } from "./Mutant-BPRJTF8f.mjs";
+import { t as Evaluator } from "./Evaluator-DLVXUcVj.mjs";
+import { t as Ignorer } from "./Ignorer-BUY68FZQ.mjs";
+import { c as Reporter } from "./Reporter-eZ3M7lO6.mjs";
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+//#region src/Plugin.schema.d.ts
+declare const PluginKind: S.Literals<readonly ["Checker", "TestRunner", "Reporter", "Ignore", "Evaluator"]>;
+type PluginKind = typeof PluginKind.Type;
+declare const PluginContribution_base: S.Class<PluginContribution<"Checker" | "Evaluator" | "Ignore" | "Reporter" | "TestRunner">, S.TaggedStruct<"PluginContribution", {
+  readonly kind: S.Literals<readonly ["Checker", "TestRunner", "Reporter", "Ignore", "Evaluator"]>;
+  readonly name: S.String;
+  readonly layer: S.Unknown;
+}>, {}>;
+declare class PluginContribution<K extends PluginKind = PluginKind> extends PluginContribution_base {
+  readonly kind: K;
+  readonly name: string;
+  readonly layer: Layer.Layer<PluginInterfaces[K], never, PluginEnvironment>;
+}
+declare const Shadowing_base: S.Class<Shadowing, S.TaggedStruct<"Shadowing", {
+  readonly kind: S.String;
+  readonly name: S.String;
+  readonly shadowedIndex: S.Finite;
+  readonly winnerIndex: S.Finite;
+}>, {}>;
+declare class Shadowing extends Shadowing_base {}
+declare namespace Plugin_d_exports {
+  export { AnyPluginContribution, ComposedPlugins, ContributionOf, MergedPluginServices, PluginContribution, PluginEnvironment, PluginInterfaces, PluginKind, RunConfiguration, SandboxDirectory, Shadowing, composePlugins, declarePlugin };
+}
+declare const RunConfiguration_base: Context.ServiceClass<RunConfiguration, "~@systemfsoftware/stryker-js/RunConfiguration", {
+  readonly [x: string]: unknown;
+  readonly allowConsoleColors: boolean;
+  readonly buildCommand?: string | undefined;
+  readonly checkers: readonly string[];
+  readonly checkerNodeArgs: readonly string[];
+  readonly concurrency?: string | number | undefined;
+  readonly commandRunner: {
+    readonly [x: string]: unknown;
+    readonly command: string;
+  };
+  readonly coverageAnalysis: "all" | "off" | "perTest";
+  readonly clearTextReporter: {
+    readonly [x: string]: unknown;
+    readonly allowColor: boolean;
+    readonly allowEmojis: boolean;
+    readonly logTests: boolean;
+    readonly maxTestsToLog: number;
+    readonly reportTests: boolean;
+    readonly reportMutants: boolean;
+    readonly reportScoreTable: boolean;
+    readonly skipFull: boolean;
+  };
+  readonly dryRunOnly: boolean;
+  readonly ignorePatterns: readonly string[];
+  readonly ignoreStatic: boolean;
+  readonly incremental: boolean;
+  readonly incrementalFile: string;
+  readonly force: boolean;
+  readonly fileLogLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
+  readonly inPlace: boolean;
+  readonly logLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
+  readonly maxConcurrentTestRunners: number;
+  readonly maxTestRunnerReuse: number;
+  readonly mutate: readonly string[];
+  readonly mutator: {
+    readonly plugins: readonly (string | readonly unknown[])[] | null;
+    readonly excludedMutations: readonly string[];
+  };
+  readonly packageManager?: "npm" | "pnpm" | "yarn" | undefined;
+  readonly plugins: readonly string[];
+  readonly appendPlugins: readonly string[];
+  readonly reporters: readonly string[];
+  readonly htmlReporter: {
+    readonly fileName: string;
+  };
+  readonly jsonReporter: {
+    readonly fileName: string;
+  };
+  readonly disableTypeChecks: string | boolean;
+  readonly symlinkNodeModules: boolean;
+  readonly tempDirName: string;
+  readonly cleanTempDir: "always" | boolean;
+  readonly testRunner: string;
+  readonly testRunnerNodeArgs: readonly string[];
+  readonly thresholds: {
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+  };
+  readonly timeoutFactor: number;
+  readonly timeoutMS: number;
+  readonly dryRunTimeoutMinutes: number;
+  readonly tsconfigFile: string;
+  readonly warnings: boolean | {
+    readonly [x: string]: unknown;
+    readonly unknownOptions: boolean;
+    readonly preprocessorErrors: boolean;
+    readonly unserializableOptions: boolean;
+    readonly slow: boolean;
+  };
+  readonly disableBail: boolean;
+  readonly allowEmpty: boolean;
+  readonly ignorers: readonly string[];
+  readonly testFiles: readonly string[];
+}>;
+declare class RunConfiguration extends RunConfiguration_base {}
+declare const SandboxDirectory_base: Context.ServiceClass<SandboxDirectory, "~@systemfsoftware/stryker-js/SandboxDirectory", string>;
+declare class SandboxDirectory extends SandboxDirectory_base {}
+interface PluginInterfaces {
+  Checker: Checker;
+  TestRunner: TestRunner;
+  Reporter: Reporter;
+  Ignore: Ignorer;
+  Evaluator: Evaluator;
+}
+type PluginEnvironment = RunConfiguration | SandboxDirectory | FileSystem.FileSystem | Path.Path;
+type AnyPluginContribution = { [K in PluginKind]: PluginContribution<K>; }[PluginKind];
+type ContributionOf<K extends PluginKind> = Extract<AnyPluginContribution, {
+  readonly kind: K;
+}>;
+declare function declarePlugin<K extends PluginKind>(kind: K, name: string, layer: Layer.Layer<PluginInterfaces[K], never, PluginEnvironment>): PluginContribution<K>;
+type MergedPluginServices = Checker & Ignorer & Reporter & TestRunner;
+interface ComposedPlugins {
+  readonly layer: Option.Option<Layer.Layer<MergedPluginServices, never, PluginEnvironment>>;
+  readonly shadowings: readonly Shadowing[];
+}
+declare function composePlugins(contributions: readonly AnyPluginContribution[]): ComposedPlugins;
+//#endregion
+export { PluginEnvironment as a, RunConfiguration as c, declarePlugin as d, PluginContribution as f, MergedPluginServices as i, SandboxDirectory as l, Shadowing as m, ComposedPlugins as n, PluginInterfaces as o, PluginKind as p, ContributionOf as r, Plugin_d_exports as s, AnyPluginContribution as t, composePlugins as u };

package/dist/Plugin.d.mts

@@ -0,0 +1,2 @@
+import { a as PluginEnvironment, c as RunConfiguration, d as declarePlugin, f as PluginContribution, i as MergedPluginServices, l as SandboxDirectory, m as Shadowing, n as ComposedPlugins, o as PluginInterfaces, p as PluginKind, r as ContributionOf, t as AnyPluginContribution, u as composePlugins } from "./Plugin-ZYNaWrl7.mjs";
+export { AnyPluginContribution, ComposedPlugins, ContributionOf, MergedPluginServices, PluginContribution, PluginEnvironment, PluginInterfaces, PluginKind, RunConfiguration, SandboxDirectory, Shadowing, composePlugins, declarePlugin };

package/dist/Plugin.mjs

@@ -0,0 +1,2 @@
+import { a as declarePlugin, c as Shadowing, i as composePlugins, n as RunConfiguration, o as PluginContribution, r as SandboxDirectory, s as PluginKind } from "./Plugin-Ceh1G8Dz.mjs";
+export { PluginContribution, PluginKind, RunConfiguration, SandboxDirectory, Shadowing, composePlugins, declarePlugin };

package/dist/Reporter-COVWW1my.mjs

@@ -0,0 +1,33 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
+import * as Effect from "effect/Effect";
+//#region src/Reporter.schema.ts
+var ReporterFailed = class extends S.TaggedError()("ReporterFailed", {
+	cause: S.String,
+	event: S.Literals([
+		"onDryRunCompleted",
+		"onMutationTestingPlanReady",
+		"onMutantTested",
+		"onMutationTestReportReady",
+		"wrapUp"
+	]),
+	reporterName: S.String
+}) {};
+//#endregion
+//#region src/Reporter.ts
+var Reporter_exports = /* @__PURE__ */ __exportAll({
+	Reporter: () => Reporter,
+	ReporterFailed: () => ReporterFailed,
+	broadcastReporter: () => broadcastReporter
+});
+var Reporter = class extends Context.Service()("~@systemfsoftware/stryker-js/Reporter") {};
+const broadcastReporter = (reporters) => ({
+	onDryRunCompleted: (event) => Effect.forEach(reporters, (r) => r.reporter.onDryRunCompleted(event), { discard: true }),
+	onMutationTestingPlanReady: (event) => Effect.forEach(reporters, (r) => r.reporter.onMutationTestingPlanReady(event), { discard: true }),
+	onMutantTested: (result) => Effect.forEach(reporters, (r) => r.reporter.onMutantTested(result), { discard: true }),
+	onMutationTestReportReady: (report, metrics) => Effect.forEach(reporters, (r) => r.reporter.onMutationTestReportReady(report, metrics), { discard: true }),
+	wrapUp: Effect.forEach(reporters, (r) => r.reporter.wrapUp, { discard: true }).pipe(Effect.asVoid)
+});
+//#endregion
+export { ReporterFailed as i, Reporter_exports as n, broadcastReporter as r, Reporter as t };

package/dist/Reporter-eZ3M7lO6.d.mts

@@ -0,0 +1,83 @@
+import { S as TestPlan, p as MutantResult } from "./Mutant-BPRJTF8f.mjs";
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
+import * as schema from "mutation-testing-report-schema/api";
+import * as Effect from "effect/Effect";
+//#region src/Reporter.schema.d.ts
+declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"ReporterFailed", {
+  readonly cause: S.String;
+  readonly event: S.Literals<readonly ["onDryRunCompleted", "onMutationTestingPlanReady", "onMutantTested", "onMutationTestReportReady", "wrapUp"]>;
+  readonly reporterName: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ReporterFailed extends ReporterFailed_base {}
+declare namespace Reporter_d_exports {
+  export { CompleteDryRunResultForReporter, DryRunCompletedEvent, Metrics, MetricsResult, MutationTestMetricsResult, MutationTestingPlanReadyEvent, NamedReporter, Reporter, ReporterFailed, ReporterService, RunTiming, TestMetrics, TestRunnerCapabilities, broadcastReporter };
+}
+interface Metrics {
+  readonly pending: number;
+  readonly killed: number;
+  readonly timeout: number;
+  readonly survived: number;
+  readonly noCoverage: number;
+  readonly runtimeErrors: number;
+  readonly compileErrors: number;
+  readonly ignored: number;
+  readonly totalDetected: number;
+  readonly totalUndetected: number;
+  readonly totalInvalid: number;
+  readonly totalValid: number;
+  readonly totalMutants: number;
+  readonly totalCovered: number;
+  readonly mutationScore: number;
+  readonly mutationScoreBasedOnCoveredCode: number;
+}
+interface TestMetrics {
+  readonly total: number;
+  readonly killing: number;
+  readonly covering: number;
+  readonly notCovering: number;
+}
+interface MetricsResult<TMetrics> {
+  readonly name: string;
+  readonly metrics: TMetrics;
+  readonly childResults: readonly MetricsResult<TMetrics>[];
+}
+interface MutationTestMetricsResult {
+  readonly systemUnderTestMetrics: MetricsResult<Metrics>;
+  readonly testMetrics: MetricsResult<TestMetrics> | undefined;
+}
+interface RunTiming {
+  readonly net: number;
+  readonly overhead: number;
+}
+interface CompleteDryRunResultForReporter {
+  readonly tests: readonly unknown[];
+  readonly status: 'complete';
+}
+interface TestRunnerCapabilities {
+  readonly reloadEnvironment: boolean;
+}
+interface DryRunCompletedEvent {
+  readonly result: CompleteDryRunResultForReporter;
+  readonly timing: RunTiming;
+  readonly capabilities: TestRunnerCapabilities;
+}
+interface MutationTestingPlanReadyEvent {
+  readonly mutantPlans: readonly TestPlan[];
+}
+interface ReporterService {
+  readonly onDryRunCompleted: (event: DryRunCompletedEvent) => Effect.Effect<void, ReporterFailed>;
+  readonly onMutationTestingPlanReady: (event: MutationTestingPlanReadyEvent) => Effect.Effect<void, ReporterFailed>;
+  readonly onMutantTested: (result: Readonly<MutantResult>) => Effect.Effect<void, ReporterFailed>;
+  readonly onMutationTestReportReady: (report: Readonly<schema.MutationTestResult>, metrics: Readonly<MutationTestMetricsResult>) => Effect.Effect<void, ReporterFailed>;
+  readonly wrapUp: Effect.Effect<void, ReporterFailed>;
+}
+interface NamedReporter {
+  readonly name: string;
+  readonly reporter: ReporterService;
+}
+declare const Reporter_base: Context.ServiceClass<Reporter, "~@systemfsoftware/stryker-js/Reporter", ReporterService>;
+declare class Reporter extends Reporter_base {}
+declare const broadcastReporter: (reporters: readonly NamedReporter[]) => ReporterService;
+//#endregion
+export { MutationTestMetricsResult as a, Reporter as c, RunTiming as d, TestMetrics as f, ReporterFailed as h, MetricsResult as i, ReporterService as l, broadcastReporter as m, DryRunCompletedEvent as n, MutationTestingPlanReadyEvent as o, TestRunnerCapabilities as p, Metrics as r, NamedReporter as s, CompleteDryRunResultForReporter as t, Reporter_d_exports as u };

package/dist/Reporter.d.mts

@@ -0,0 +1,2 @@
+import { a as MutationTestMetricsResult, c as Reporter, d as RunTiming, f as TestMetrics, h as ReporterFailed, i as MetricsResult, l as ReporterService, m as broadcastReporter, n as DryRunCompletedEvent, o as MutationTestingPlanReadyEvent, p as TestRunnerCapabilities, r as Metrics, s as NamedReporter, t as CompleteDryRunResultForReporter } from "./Reporter-eZ3M7lO6.mjs";
+export { CompleteDryRunResultForReporter, DryRunCompletedEvent, Metrics, MetricsResult, MutationTestMetricsResult, MutationTestingPlanReadyEvent, NamedReporter, Reporter, ReporterFailed, ReporterService, RunTiming, TestMetrics, TestRunnerCapabilities, broadcastReporter };

package/dist/Reporter.mjs

@@ -0,0 +1,2 @@
+import { i as ReporterFailed, r as broadcastReporter, t as Reporter } from "./Reporter-COVWW1my.mjs";
+export { Reporter, ReporterFailed, broadcastReporter };

package/dist/Run-BudLsVwF.d.mts

@@ -0,0 +1,183 @@
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { Wire, Workflow } from "@systemfsoftware/effect-cell-types";
+import * as Exit from "effect/Exit";
+import "effect/Result";
+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<{
+  line: S.Finite & Wire.Mark;
+  column: S.Finite & Wire.Mark;
+}> & Wire.Mark;
+declare const Location: S.Struct<{
+  start: S.Struct<{
+    line: S.Finite & Wire.Mark;
+    column: S.Finite & Wire.Mark;
+  }> & Wire.Mark;
+  end: S.Struct<{
+    line: S.Finite & Wire.Mark;
+    column: S.Finite & Wire.Mark;
+  }> & Wire.Mark;
+}> & Wire.Mark;
+type Location = typeof Location.Type;
+type Position = typeof Position.Type;
+declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
+  readonly schemaVersion: S.String & Wire.Mark;
+  readonly runId: S.String & Wire.Mark;
+  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 & Wire.Mark;
+}>, {}>;
+declare class PhaseEntered extends PhaseEntered_base {}
+declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
+  readonly total: S.Finite & Wire.Mark;
+}>, {}>;
+declare class PlanKnown extends PlanKnown_base {}
+declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutant", {
+  readonly id: S.String & Wire.Mark;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
+  readonly file: S.String & Wire.Mark;
+  readonly location: S.Struct<{
+    start: S.Struct<{
+      line: S.Finite & Wire.Mark;
+      column: S.Finite & Wire.Mark;
+    }> & Wire.Mark;
+    end: S.Struct<{
+      line: S.Finite & Wire.Mark;
+      column: S.Finite & Wire.Mark;
+    }> & Wire.Mark;
+  }> & Wire.Mark;
+  readonly mutator: S.String & Wire.Mark;
+  readonly replacement: S.NullOr<S.String & Wire.Mark> & Wire.Mark;
+  readonly completed: S.Finite & Wire.Mark;
+  readonly total: S.Finite & Wire.Mark;
+}>, {}>;
+declare class MutantTested extends MutantTested_base {}
+declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
+  readonly elapsedMs: S.Finite & Wire.Mark;
+  readonly completed: S.Finite & Wire.Mark;
+  readonly total: S.NullOr<S.Finite & Wire.Mark> & Wire.Mark;
+}>, {}>;
+declare class Heartbeat extends Heartbeat_base {}
+declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
+  readonly schemaVersion: S.String & Wire.Mark;
+  readonly runId: S.String & Wire.Mark;
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+  readonly score: S.NullOr<S.Finite & Wire.Mark> & Wire.Mark;
+  readonly thresholds: S.Struct<{
+    high: S.Finite & Wire.Mark;
+    low: S.Finite & Wire.Mark;
+    break: S.NullOr<S.Finite & Wire.Mark> & Wire.Mark;
+  }> & Wire.Mark;
+  readonly reportFile: S.NullOr<S.String & Wire.Mark> & Wire.Mark;
+  readonly counts: S.Struct<{
+    killed: S.Finite & Wire.Mark;
+    timeout: S.Finite & Wire.Mark;
+    survived: S.Finite & Wire.Mark;
+    noCoverage: S.Finite & Wire.Mark;
+    runtimeErrors: S.Finite & Wire.Mark;
+    compileErrors: S.Finite & Wire.Mark;
+    ignored: S.Finite & Wire.Mark;
+    pending: S.Finite & Wire.Mark;
+  }> & Wire.Mark;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String & Wire.Mark;
+    readonly file: S.String & Wire.Mark;
+    readonly location: S.Struct<{
+      start: S.Struct<{
+        line: S.Finite & Wire.Mark;
+        column: S.Finite & Wire.Mark;
+      }> & Wire.Mark;
+      end: S.Struct<{
+        line: S.Finite & Wire.Mark;
+        column: S.Finite & Wire.Mark;
+      }> & Wire.Mark;
+    }> & Wire.Mark;
+    readonly mutator: S.String & Wire.Mark;
+    readonly replacement: S.NullOr<S.String & Wire.Mark> & Wire.Mark;
+    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 & Wire.Mark;
+  readonly code: S.Finite & Wire.Mark;
+  readonly error: S.String & Wire.Mark;
+  readonly remediation: S.String & Wire.Mark;
+}>, {}>;
+declare class RunFailed extends RunFailed_base {}
+declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
+  readonly schemaVersion: S.String & Wire.Mark;
+  readonly code: S.Literals<readonly [0]> & Wire.Mark;
+  readonly help: S.String & Wire.Mark;
+}>, {}>;
+declare class HelpRendered extends HelpRendered_base {}
+declare const ManifestRendered_base: S.Class<ManifestRendered, S.TaggedStruct<"manifest", {
+  readonly schemaVersion: S.String & Wire.Mark;
+  readonly code: S.Literals<readonly [0]> & Wire.Mark;
+  readonly manifest: S.String & Wire.Mark;
+}>, {}>;
+declare class ManifestRendered extends ManifestRendered_base {}
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof MutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered, typeof ManifestRendered]>;
+type RunEvent = typeof RunEvent.Type;
+type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered | ManifestRendered;
+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 {}
+//#endregion
+//#region src/Run.workflow.d.ts
+declare const PlanMutationRunError_base: S.Class<PlanMutationRunError, S.TaggedStruct<"PlanMutationRunError", {
+  readonly message: S.String;
+  readonly detail: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class PlanMutationRunError extends PlanMutationRunError_base {}
+declare namespace Run_d_exports {
+  export { Heartbeat, HelpRendered, Location, ManifestRendered, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, Position, RunEvent, RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, RunTerminalEvent, VerdictReached, runMutationTest, shouldKeepTempDir };
+}
+declare const RunEvents_base: Context.ServiceClass<RunEvents, "~@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | ManifestRendered | MutantTested | PhaseEntered | PlanKnown | RunFailed | RunStarted | VerdictReached, Cause.Done<void>>>;
+/**
+ * Where a run's events go.
+ *
+ * The error channel carries `Cause.Done`, the graceful completion signal: a finished run
+ * ends the queue, and `Stream.fromQueue` excludes `Done` from its own error channel, so the
+ * consumer sees end-of-stream. Interrupting the queue instead would end it with an
+ * interrupt cause, and joining the drain would then re-raise that into the caller and lose
+ * the exit code the run had already decided.
+ */
+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, PlanMutationRunError | S.SchemaError>, cleanTempDir: 'always' | boolean) => boolean;
+//#endregion
+export { RunTerminalEvent as C, RunStarted as S, PlanKnown as _, Run_d_exports as a, RunFailed as b, Heartbeat as c, ManifestRendered as d, ModeSignal as f, PhaseEntered as g, OutputMode as h, RunIdentityShape as i, HelpRendered as l, MutantTested as m, RunEvents as n, runMutationTest as o, MutantStatus as p, RunIdentity as r, shouldKeepTempDir as s, MutationRunIo as t, Location as u, Position as v, VerdictReached as w, RunPhase as x, RunEvent as y };

package/dist/Run-lXratlN7.mjs

@@ -0,0 +1,225 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { Cell, Wire, Workflow } from "@systemfsoftware/effect-cell-types";
+import * as Exit from "effect/Exit";
+import { pipe } from "effect/Function";
+import * as Result from "effect/Result";
+//#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 = Wire.wire({
+	line: Wire.mint(S.Finite),
+	column: Wire.mint(S.Finite)
+});
+const Location = Wire.wire({
+	start: Position,
+	end: Position
+});
+var RunStarted = class extends S.TaggedClass()("stream", {
+	schemaVersion: Wire.mint(S.String),
+	runId: Wire.mint(S.String),
+	mode: OutputMode,
+	signal: ModeSignal
+}) {};
+var PhaseEntered = class extends S.TaggedClass()("phase", {
+	phase: RunPhase,
+	elapsedMs: Wire.mint(S.Finite)
+}) {};
+var PlanKnown = class extends S.TaggedClass()("plan", { total: Wire.mint(S.Finite) }) {};
+var MutantTested = class extends S.TaggedClass()("mutant", {
+	id: Wire.mint(S.String),
+	status: MutantStatus,
+	file: Wire.mint(S.String),
+	location: Location,
+	mutator: Wire.mint(S.String),
+	replacement: Wire.mint(S.NullOr(Wire.mint(S.String))),
+	completed: Wire.mint(S.Finite),
+	total: Wire.mint(S.Finite)
+}) {};
+var Heartbeat = class extends S.TaggedClass()("tick", {
+	elapsedMs: Wire.mint(S.Finite),
+	completed: Wire.mint(S.Finite),
+	total: Wire.mint(S.NullOr(Wire.mint(S.Finite)))
+}) {};
+const VerdictThresholds = Wire.wire({
+	high: Wire.mint(S.Finite),
+	low: Wire.mint(S.Finite),
+	break: Wire.mint(S.NullOr(Wire.mint(S.Finite)))
+});
+const VerdictMutant = S.Struct({
+	id: Wire.mint(S.String),
+	file: Wire.mint(S.String),
+	location: Location,
+	mutator: Wire.mint(S.String),
+	replacement: Wire.mint(S.NullOr(Wire.mint(S.String))),
+	status: MutantStatus
+});
+const VerdictCounts = Wire.wire({
+	killed: Wire.mint(S.Finite),
+	timeout: Wire.mint(S.Finite),
+	survived: Wire.mint(S.Finite),
+	noCoverage: Wire.mint(S.Finite),
+	runtimeErrors: Wire.mint(S.Finite),
+	compileErrors: Wire.mint(S.Finite),
+	ignored: Wire.mint(S.Finite),
+	pending: Wire.mint(S.Finite)
+});
+var VerdictReached = class extends S.TaggedClass()("verdict", {
+	schemaVersion: Wire.mint(S.String),
+	runId: Wire.mint(S.String),
+	mode: OutputMode,
+	signal: ModeSignal,
+	score: Wire.mint(S.NullOr(Wire.mint(S.Finite))),
+	thresholds: VerdictThresholds,
+	reportFile: Wire.mint(S.NullOr(Wire.mint(S.String))),
+	counts: VerdictCounts,
+	mutants: S.Array(VerdictMutant)
+}) {};
+var RunFailed = class extends S.TaggedClass()("error", {
+	schemaVersion: Wire.mint(S.String),
+	code: Wire.mint(S.Finite),
+	error: Wire.mint(S.String),
+	remediation: Wire.mint(S.String)
+}) {};
+var HelpRendered = class extends S.TaggedClass()("help", {
+	schemaVersion: Wire.mint(S.String),
+	code: Wire.mint(S.Literals([0])),
+	help: Wire.mint(S.String)
+}) {};
+var ManifestRendered = class extends S.TaggedClass()("manifest", {
+	schemaVersion: Wire.mint(S.String),
+	code: Wire.mint(S.Literals([0])),
+	manifest: Wire.mint(S.String)
+}) {};
+const RunEvent = S.Union([
+	RunStarted,
+	PhaseEntered,
+	PlanKnown,
+	MutantTested,
+	Heartbeat,
+	VerdictReached,
+	RunFailed,
+	HelpRendered,
+	ManifestRendered
+]);
+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 });
+//#endregion
+//#region src/Run.workflow.ts
+var PlanMutationRunCommand = class extends S.TaggedClass()("PlanMutationRunCommand", {
+	configMutatePatterns: Wire.mint(S.Array(Wire.mint(S.String))),
+	configMutatorNames: Wire.mint(S.Array(Wire.mint(S.String))),
+	targetMutatePatterns: Wire.mint(S.Array(Wire.mint(S.String))),
+	availableMutators: Wire.mint(S.Array(Wire.mint(S.String)))
+}) {};
+var MutationRunPlan = class extends S.TaggedClass()("MutationRunPlan", {
+	mutatePatterns: Wire.mint(S.Array(Wire.mint(S.String))),
+	mutatorNames: Wire.mint(S.Array(Wire.mint(S.String)))
+}) {};
+S.TaggedError()("PlanMutationRunError", {
+	message: S.String,
+	detail: S.String
+});
+const selectMutatePatterns = (target, fallback) => {
+	if (target.length > 0) return [...target];
+	return [...fallback];
+};
+const selectMutatorNames = (available, fallback) => {
+	if (available.length > 0) return [...available];
+	return [...fallback];
+};
+const decidePlan = (command) => {
+	const mutatePatterns = selectMutatePatterns(command.targetMutatePatterns, command.configMutatePatterns);
+	const mutatorNames = selectMutatorNames(command.availableMutators, command.configMutatorNames);
+	return Result.succeed(MutationRunPlan.make({
+		mutatePatterns,
+		mutatorNames
+	}));
+};
+const planMutationRun = Workflow.make(PlanMutationRunCommand, (command) => decidePlan(command));
+//#endregion
+//#region src/Run.ts
+var Run_exports = /* @__PURE__ */ __exportAll({
+	Heartbeat: () => Heartbeat,
+	HelpRendered: () => HelpRendered,
+	ManifestRendered: () => ManifestRendered,
+	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,
+	runMutationTest: () => runMutationTest,
+	shouldKeepTempDir: () => shouldKeepTempDir
+});
+/**
+* Where a run's events go.
+*
+* The error channel carries `Cause.Done`, the graceful completion signal: a finished run
+* ends the queue, and `Stream.fromQueue` excludes `Done` from its own error channel, so the
+* consumer sees end-of-stream. Interrupting the queue instead would end it with an
+* interrupt cause, and joining the drain would then re-raise that into the caller and lose
+* the exit code the run had already decided.
+*/
+var RunEvents = class extends Context.Service()("~@systemfsoftware/stryker-js/RunEvents") {};
+var RunIdentity = class extends Context.Service()("~@systemfsoftware/stryker-js/RunIdentity") {};
+const mutationRunDescription = (io, services) => pipe(Cell.read((command) => Effect.provideContext(io.read(command), services)), Cell.decode((raw) => S.decodeUnknownResult(PlanMutationRunCommand)(raw)), Cell.decide(planMutationRun), Cell.encode((outcome) => Result.match(outcome, {
+	onFailure: (error) => new RunOutput({
+		verdictJson: JSON.stringify({ error: error.message }),
+		exitCode: 1
+	}),
+	onSuccess: (plan) => new RunOutput({
+		verdictJson: JSON.stringify({
+			mutate: plan.mutatePatterns,
+			mutators: plan.mutatorNames
+		}),
+		exitCode: 0
+	})
+})), Cell.write((output) => Effect.provideContext(io.write(output), services)));
+const runMutationTest = (io, command) => Effect.gen(function* () {
+	const services = yield* Effect.context();
+	return yield* Cell.apply(mutationRunDescription(io, services), command);
+});
+const shouldKeepTempDir = (exit, cleanTempDir) => Exit.isFailure(exit) && cleanTempDir !== "always";
+//#endregion
+export { RunPhase as _, shouldKeepTempDir as a, ManifestRendered as c, MutantTested as d, OutputMode as f, RunFailed as g, RunEvent as h, runMutationTest as i, ModeSignal as l, PlanKnown as m, RunIdentity as n, Heartbeat as o, PhaseEntered as p, Run_exports as r, HelpRendered as s, RunEvents as t, MutantStatus as u, RunStarted as v, VerdictReached as y };