@systemfsoftware/stryker-js 10.2.0 → 12.0.0

package/dist/{Run.schema-B-Pi3bCB.d.mts → Run.schema-D43Nx5kI.d.mts}

@@ -1,6 +1,6 @@
-import { C as Metrics, _ as ExitClass } from "./index-tt2EziOT.mjs";
+import { i as mod_d_exports$4, r as mod_d_exports$3 } from "./index-f-U3oZaJ.mjs";
 import * as S from "effect/Schema";
-//#region src/RunEvent.schema.d.ts
+//#region src/run-event.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"]>;
@@ -29,12 +29,12 @@ declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mut
   readonly file: S.String;
   readonly location: S.Struct<{
     readonly start: S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
+      readonly line: S.Int;
+      readonly column: S.Int;
     }>;
     readonly end: S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
+      readonly line: S.Int;
+      readonly column: S.Int;
     }>;
   }>;
   readonly mutator: S.String;
@@ -60,12 +60,12 @@ declare const VerdictMutant: S.Struct<{
   readonly file: S.String;
   readonly location: S.Struct<{
     readonly start: S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
+      readonly line: S.Int;
+      readonly column: S.Int;
     }>;
     readonly end: S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
+      readonly line: S.Int;
+      readonly column: S.Int;
     }>;
   }>;
   readonly mutator: S.String;
@@ -73,7 +73,7 @@ declare const VerdictMutant: S.Struct<{
   readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
 }>;
 type VerdictMutant = typeof VerdictMutant.Type;
-type VerdictCounts = Metrics;
+type VerdictCounts = mod_d_exports$4.Metrics;
 declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
   readonly schemaVersion: S.String;
   readonly runId: S.String;
@@ -94,18 +94,18 @@ declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdi
     readonly break: S.NullOr<S.Finite>;
   }>, never, never>;
   readonly reportFile: S.NullOr<S.String>;
-  readonly counts: typeof Metrics;
+  readonly counts: typeof mod_d_exports$4.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 line: S.Int;
+        readonly column: S.Int;
       }>;
       readonly end: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
+        readonly line: S.Int;
+        readonly column: S.Int;
       }>;
     }>;
     readonly mutator: S.String;
@@ -114,11 +114,81 @@ declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdi
   }>>;
 }>, {}>;
 declare class VerdictReached extends VerdictReached_base {}
+declare const FrameworkContributionRow: S.Struct<{
+  readonly name: S.String;
+  readonly formatId: S.String;
+  readonly extensions: S.$Array<S.String>;
+}>;
+type FrameworkContributionRow = typeof FrameworkContributionRow.Type;
+declare const FrameworkModuleRow: S.Struct<{
+  readonly moduleName: S.String;
+  readonly contributions: S.$Array<S.Struct<{
+    readonly name: S.String;
+    readonly formatId: S.String;
+    readonly extensions: S.$Array<S.String>;
+  }>>;
+}>;
+type FrameworkModuleRow = typeof FrameworkModuleRow.Type;
+declare const FormatClaimShadowingRow: S.Struct<{
+  readonly extension: S.String;
+  readonly winner: S.String;
+  readonly loser: S.String;
+}>;
+type FormatClaimShadowingRow = typeof FormatClaimShadowingRow.Type;
+declare const PluginsReported_base: S.Class<PluginsReported, S.TaggedStruct<"plugins", {
+  readonly modules: S.$Array<S.Struct<{
+    readonly moduleName: S.String;
+    readonly contributions: S.$Array<S.Struct<{
+      readonly name: S.String;
+      readonly formatId: S.String;
+      readonly extensions: S.$Array<S.String>;
+    }>>;
+  }>>;
+  readonly shadowings: S.$Array<S.Struct<{
+    readonly extension: S.String;
+    readonly winner: S.String;
+    readonly loser: S.String;
+  }>>;
+}>, {}>;
+declare class PluginsReported extends PluginsReported_base {}
+declare const FormatRegistryRow: S.Struct<{
+  readonly extension: S.String;
+  readonly formatId: S.String;
+  readonly ownerModule: S.String;
+  readonly language: S.String;
+}>;
+type FormatRegistryRow = typeof FormatRegistryRow.Type;
+declare const FormatRegistryResolved_base: S.Class<FormatRegistryResolved, S.TaggedStruct<"formats", {
+  readonly rows: S.$Array<S.Struct<{
+    readonly extension: S.String;
+    readonly formatId: S.String;
+    readonly ownerModule: S.String;
+    readonly language: S.String;
+  }>>;
+}>, {}>;
+declare class FormatRegistryResolved extends FormatRegistryResolved_base {}
+declare const SkippedFileRow: S.Struct<{
+  readonly file: S.String;
+  readonly extension: S.String;
+  readonly reason: S.String;
+}>;
+type SkippedFileRow = typeof SkippedFileRow.Type;
+declare const SkippedReported_base: S.Class<SkippedReported, S.TaggedStruct<"skipped", {
+  readonly files: S.$Array<S.Struct<{
+    readonly file: S.String;
+    readonly extension: S.String;
+    readonly reason: S.String;
+  }>>;
+}>, {}>;
+declare class SkippedReported extends SkippedReported_base {}
+declare const PluginFailureReason: S.Literals<readonly ["PeerMissing", "PeerVersionUnsupported", "PeerUnrecognized", "InvalidContribution", "ImportFailed"]>;
+type PluginFailureReason = typeof PluginFailureReason.Type;
 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;
+  readonly reason: S.NullOr<S.Literals<readonly ["PeerMissing", "PeerVersionUnsupported", "PeerUnrecognized", "InvalidContribution", "ImportFailed"]>>;
 }>, {}>;
 declare class RunFailed extends RunFailed_base {}
 declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
@@ -127,7 +197,9 @@ declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
   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]>;
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
+  QUEUE_BOUND: number;
+};
 type RunEvent = typeof RunEvent.Type;
 type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
 declare const RunDecodeError_base: S.Class<RunDecodeError, S.TaggedStruct<"RunDecodeError", {
@@ -161,7 +233,7 @@ declare const StageError_base: S.Class<StageError, S.TaggedStruct<"StageError",
 }>, import("effect/Cause").YieldableError>;
 declare class StageError extends StageError_base {
   readonly [TypeId]: "~stryker/mutation-run/StageError";
-  get exitClass(): ExitClass;
+  get exitClass(): mod_d_exports$3.ExitClass;
   get message(): string;
 }
 declare const PrepareError_base: S.Class<PrepareError, S.TaggedStruct<"PrepareError", {
@@ -170,4 +242,4 @@ declare const PrepareError_base: S.Class<PrepareError, S.TaggedStruct<"PrepareEr
 }>, 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 };
+export { VerdictReached as A, RunReadError as C, SkippedReported as D, SkippedFileRow as E, VerdictCounts as O, RunPhase as S, RunTerminalEvent as T, PluginsReported as _, FormatRegistryRow as a, RunFailed as b, Heartbeat as c, MutationRunPlan as d, OutputMode as f, PluginFailureReason as g, PlanMutationRunCommand as h, FormatRegistryResolved as i, VerdictThresholds as j, VerdictMutant as k, HelpRendered as l, PlanKnown as m, StageError as n, FrameworkContributionRow as o, PhaseEntered as p, FormatClaimShadowingRow as r, FrameworkModuleRow as s, PrepareError as t, ModeSignal as u, RunDecodeError as v, RunStarted as w, RunMutantTested as x, RunEvent as y };

package/dist/RunEnvironment.service-pCzdC0Sy.d.mts

@@ -0,0 +1,464 @@
+import { a as mod_d_exports$5, c as mod_d_exports$2, d as Ignorer, i as mod_d_exports$4, l as mod_d_exports$3$1, n as mod_d_exports$2$1, o as mod_d_exports$6, r as mod_d_exports$3, s as mod_d_exports$1, t as mod_d_exports, u as Framework } from "./index-f-U3oZaJ.mjs";
+import { A as VerdictReached, D as SkippedReported, _ as PluginsReported, b as RunFailed, c as Heartbeat, i as FormatRegistryResolved, l as HelpRendered, m as PlanKnown, p as PhaseEntered, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-D43Nx5kI.mjs";
+import { Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
+import "effect/Option";
+import "effect/Result";
+import * as S from "effect/Schema";
+import * as Effect$1 from "effect/Effect";
+import * as Context from "effect/Context";
+import { Schema } from "effect";
+import "effect/Exit";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import * as Cause from "effect/Cause";
+import * as Path from "effect/Path";
+import * as FileSystem from "effect/FileSystem";
+import * as Stream from "effect/Stream";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import * as EffectDuration from "effect/Duration";
+import * as Layer from "effect/Layer";
+import * as Queue from "effect/Queue";
+import * as Scope from "effect/Scope";
+import * as HashMap from "effect/HashMap";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as Stdio from "effect/Stdio";
+import * as MutableHashSet from "effect/MutableHashSet";
+import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import * as Socket from "effect/unstable/socket/Socket";
+import { PlatformError } from "effect/PlatformError";
+import "effect/Console";
+import "effect/Runtime";
+//#region src/Worker.schema.d.ts
+/**
+ * The child process hosting a worker ended when it was not supposed to.
+ */
+declare const WorkerExitTypeId: unique symbol;
+type WorkerExitTypeId = typeof WorkerExitTypeId;
+declare const ChildProcessCrashedError_base: Schema.Class<ChildProcessCrashedError, Schema.TaggedStruct<"ChildProcessCrashedError", {
+  readonly pid: Schema.Int;
+  readonly exit: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literals<readonly ["Code"]>;
+    readonly code: Schema.Int;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literals<readonly ["Signal"]>;
+    readonly signal: Schema.NonEmptyString;
+  }>]>;
+  readonly cause: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class ChildProcessCrashedError extends ChildProcessCrashedError_base {
+  readonly [WorkerExitTypeId]: symbol;
+  readonly exitClass: 'InternalError';
+}
+declare const OutOfMemoryError_base: Schema.Class<OutOfMemoryError, Schema.TaggedStruct<"OutOfMemoryError", {
+  readonly pid: Schema.Int;
+  readonly exitCode: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class OutOfMemoryError extends OutOfMemoryError_base {
+  readonly [WorkerExitTypeId]: symbol;
+  readonly exitClass: 'RuntimeError';
+}
+type WorkerExit = ChildProcessCrashedError | OutOfMemoryError;
+type WorkerBootError = WorkerExit | WorkerBootTimeoutError;
+declare const WorkerBootTimeoutError_base: Schema.Class<WorkerBootTimeoutError, Schema.TaggedStruct<"WorkerBootTimeoutError", {
+  readonly pid: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class WorkerBootTimeoutError extends WorkerBootTimeoutError_base {
+  readonly exitClass: 'InternalError';
+}
+//#endregion
+//#region src/ConfigError.schema.d.ts
+declare const ConfigFileNotFoundError_base: S.Class<ConfigFileNotFoundError, S.TaggedStruct<"ConfigFileNotFoundError", {
+  readonly file: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
+  readonly exitClass: 'ConfigError';
+}
+declare const ConfigFileUnsupportedError_base: S.Class<ConfigFileUnsupportedError, S.TaggedStruct<"ConfigFileUnsupportedError", {
+  readonly file: S.String;
+  readonly hint: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileUnsupportedError extends ConfigFileUnsupportedError_base {
+  readonly exitClass: 'ConfigError';
+  get message(): string;
+}
+declare const ConfigFileUnreadableError_base: S.Class<ConfigFileUnreadableError, S.TaggedStruct<"ConfigFileUnreadableError", {
+  readonly file: S.String;
+  readonly cause: S.Unknown;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileUnreadableError extends ConfigFileUnreadableError_base {
+  readonly exitClass: 'ConfigError';
+}
+declare const ConfigFileInvalidError_base: S.Class<ConfigFileInvalidError, S.TaggedStruct<"ConfigFileInvalidError", {
+  readonly file: S.String;
+  readonly cause: S.Unknown;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileInvalidError extends ConfigFileInvalidError_base {
+  readonly exitClass: 'ConfigError';
+}
+declare const ConfigError_base: S.Class<ConfigError, S.TaggedStruct<"ConfigError", {
+  readonly message: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigError extends ConfigError_base {
+  readonly exitClass: 'ConfigError';
+}
+//#endregion
+//#region src/output-mode.schema.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
+//#region src/frame-run-event.workflow.d.ts
+interface ResolvedModeInput {
+  readonly mode: 'machine' | 'human';
+  readonly signal: 'flag' | 'env' | 'tty' | 'agent' | 'tool';
+}
+//#endregion
+//#region src/run-event-stream.service.d.ts
+type FramedDrain = (framed: Stream.Stream<string, never, never>) => Effect$1.Effect<void, never, never>;
+interface RunEventDrainShape {
+  readonly drainFramed: FramedDrain;
+  readonly setProgressStreamFile: (fileName: string) => Effect$1.Effect<void, never, never>;
+}
+declare const RunEventDrain_base: Context.ServiceClass<RunEventDrain, "@systemfsoftware/stryker-js/run-event-stream.service/RunEventDrain", RunEventDrainShape>;
+declare class RunEventDrain extends RunEventDrain_base {
+  static readonly layer: Layer.Layer<RunEventDrain, never, Stdio.Stdio>;
+  static readonly DefaultProgressStreamFile = "reports/mutation-stream.jsonl";
+  static readonly fileLayer: Layer.Layer<RunEventDrain, never, Stdio.Stdio | FileSystem.FileSystem | Path.Path>;
+}
+declare const RunEventDrainLive: Layer.Layer<RunEventDrain, never, Stdio.Stdio>;
+interface RunEventStream {
+  readonly queue: Queue.Queue<RunEvent, Cause.Done>;
+  readonly runId: string;
+  readonly startedAt: number;
+  readonly isOpen: Effect$1.Effect<boolean, never, never>;
+  readonly ensureOpen: (openResolved: ResolvedModeInput) => Effect$1.Effect<void, never, never>;
+  readonly open: Effect$1.Effect<void, never, never>;
+  readonly closeAndDrain: Effect$1.Effect<void, never, never>;
+}
+declare const makeRunEventStream: (resolved: ResolvedModeInput) => Effect$1.Effect<{
+  queue: Queue.Queue<FormatRegistryResolved | Heartbeat | HelpRendered | PhaseEntered | PlanKnown | PluginsReported | RunFailed | RunMutantTested | RunStarted | SkippedReported | VerdictReached, Cause.Done<void>>;
+  runId: string;
+  startedAt: number;
+  isOpen: Effect$1.Effect<boolean, never, never>;
+  ensureOpen: (openResolved: ResolvedModeInput) => Effect$1.Effect<void, never, never>;
+  open: Effect$1.Effect<void, never, never>;
+  closeAndDrain: Effect$1.Effect<void, never, never>;
+}, never, RunEventDrain | Stdio.Stdio>;
+//#endregion
+//#region src/run-events.service.d.ts
+declare const RunEvents_base: Context.ServiceClass<RunEvents, "@systemfsoftware/stryker-js/run-events.service/RunEvents", Queue.Queue<FormatRegistryResolved | Heartbeat | HelpRendered | PhaseEntered | PlanKnown | PluginsReported | RunFailed | RunMutantTested | RunStarted | SkippedReported | 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/run-events.service/RunIdentity", RunIdentityShape>;
+declare class RunIdentity extends RunIdentity_base {}
+//#endregion
+//#region src/Project.schema.d.ts
+interface ProjectFile extends mod_d_exports$2.FileDescription {
+  readonly name: string;
+  readonly mutate: mod_d_exports$2.MutateDescription;
+  readonly content: string | undefined;
+  readonly originalContent: string | undefined;
+}
+interface Project {
+  readonly fileDescriptions: mod_d_exports$2.FileDescriptions;
+  readonly incrementalReport: mod_d_exports$4.MutationTestResult | undefined;
+  readonly testFiles: readonly string[];
+  readonly files: MutableHashMap.MutableHashMap<string, ProjectFile>;
+  readonly filesToMutate: MutableHashMap.MutableHashMap<string, ProjectFile>;
+}
+//#endregion
+//#region src/project-files.service.d.ts
+type ContentPair = readonly [ProjectFile, string];
+type PathPair = readonly [string, string];
+interface InPlaceTarget {
+  readonly backupDirectory: string;
+  readonly basePath: string;
+}
+interface SandboxTarget {
+  readonly workingDirectory: string;
+  readonly basePath: string;
+}
+interface ProjectFilesShape {
+  readonly read: (file: ProjectFile) => Effect$1.Effect<string, PlatformError>;
+  readonly readAll: (files: Iterable<ProjectFile>) => Effect$1.Effect<readonly ContentPair[], PlatformError>;
+  readonly readAllOriginal: (files: Iterable<ProjectFile>) => Effect$1.Effect<readonly ContentPair[], PlatformError>;
+  readonly writeAllInPlace: (files: Iterable<readonly [string, ProjectFile]>, target: InPlaceTarget) => Effect$1.Effect<readonly PathPair[], PlatformError>;
+  readonly writeAllToSandbox: (files: Iterable<readonly [string, ProjectFile]>, target: SandboxTarget) => Effect$1.Effect<readonly PathPair[], PlatformError>;
+}
+declare const ProjectFiles_base: Context.ServiceClass<ProjectFiles, "@systemfsoftware/stryker-js/project-files.service/ProjectFiles", ProjectFilesShape>;
+declare class ProjectFiles extends ProjectFiles_base {
+  static readonly layer: Layer.Layer<ProjectFiles, never, FileSystem.FileSystem | Path.Path>;
+}
+//#endregion
+//#region src/spawned-socket-worker.handle.d.ts
+declare const TypeId$1: unique symbol;
+type TypeId$1 = typeof TypeId$1;
+interface SpawnedSocketWorkerSlot {
+  readonly clientLayer: Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
+}
+declare const SpawnedSocketWorker: Handle.Definition<typeof TypeId$1, {
+  readonly pid: number;
+  readonly exited: Effect$1.Effect<never, WorkerExit>;
+}, SpawnedSocketWorkerSlot, never>;
+type SpawnedSocketWorker = Handle.Of<typeof SpawnedSocketWorker>;
+declare const make: (worker: {
+  readonly pid: number;
+  readonly clientLayer: Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
+  readonly exited: Effect$1.Effect<never, WorkerExit>;
+}) => SpawnedSocketWorker;
+//#endregion
+//#region src/WorkerLauncher.service.d.ts
+interface WorkerSpawnParams {
+  readonly entrypoint: string;
+  readonly workingDirectory: string;
+  readonly execArgv: readonly string[];
+  readonly optionsJson: string;
+  readonly tempDirPrefix: string;
+  readonly env?: Readonly<Record<string, string>> | undefined;
+}
+interface WorkerLauncherShape {
+  readonly spawn: (params: WorkerSpawnParams) => Effect$1.Effect<SpawnedSocketWorker, ChildProcessCrashedError, Scope.Scope>;
+}
+declare const WorkerLauncher_base: Context.ServiceClass<WorkerLauncher, "@systemfsoftware/stryker-js/WorkerLauncher.service/WorkerLauncher", WorkerLauncherShape>;
+declare class WorkerLauncher extends WorkerLauncher_base {}
+//#endregion
+//#region src/reporter-stream.service.d.ts
+declare const ReporterStageTypeId: unique symbol;
+/**
+ * An attached reporter stage, opaque at the engine boundary: the published
+ * phase types carry this handle so the attachment machinery (queues, fibers,
+ * the state latch) never reaches an adopter's compiler. Constructed only by
+ * `attachReporterFactories`.
+ */
+interface ReporterStage {
+  readonly [ReporterStageTypeId]: typeof ReporterStageTypeId;
+}
+declare const REPORTER_EVENT_BATCH_BOUND = 128;
+type ReporterWorkerClient = RpcClient.RpcClient<RpcGroup.Rpcs<typeof mod_d_exports$3.ReporterRpcs>, RpcClientError>;
+declare const reporterWorkerFactory: (client: ReporterWorkerClient) => mod_d_exports$5.ReporterFactory;
+interface SpawnReporterWorkerParams {
+  readonly entrypoint: string;
+  readonly projectBasePath: string;
+  readonly execArgv: readonly string[];
+  readonly options: mod_d_exports$2$1.StrykerOptions;
+  readonly tempDirPrefix: string;
+}
+declare const spawnReporterWorker: (params: SpawnReporterWorkerParams) => Effect$1.Effect<ReporterWorkerClient, WorkerBootError, Scope.Scope | WorkerLauncher>;
+//#endregion
+//#region src/TestRunner.schema.d.ts
+type PooledTestRunnerError = mod_d_exports$6.TestRunnerFailed | ChildProcessCrashedError | OutOfMemoryError;
+//#endregion
+//#region src/Worker.service.d.ts
+interface IdGeneratorShape {
+  readonly next: Effect$1.Effect<number>;
+}
+declare const IdGenerator_base: Context.ServiceClass<IdGenerator, "@systemfsoftware/stryker-js/Worker.service/IdGenerator", IdGeneratorShape>;
+declare class IdGenerator extends IdGenerator_base {
+  static readonly layer: Layer.Layer<IdGenerator, never, never>;
+}
+//#endregion
+//#region src/test-coverage.schema.d.ts
+interface TestCoverage {
+  readonly testsByMutantId: MutableHashMap.MutableHashMap<string, MutableHashSet.MutableHashSet<mod_d_exports$6.TestResult>>;
+  readonly testsById: MutableHashMap.MutableHashMap<string, mod_d_exports$6.TestResult>;
+  readonly staticCoverage: mod_d_exports$3$1.CoverageData | undefined;
+  readonly hitsByMutantId: MutableHashMap.MutableHashMap<string, number>;
+}
+//#endregion
+//#region src/stryker-error.schema.d.ts
+declare const StrykerError_base: Schema.Class<StrykerError, Schema.TaggedStruct<"StrykerError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+declare class StrykerError extends StrykerError_base {}
+//#endregion
+//#region src/Sandbox.handle.d.ts
+declare const TypeId: unique symbol;
+type TypeId = typeof TypeId;
+declare const SandboxHandle: Handle.Definition<typeof TypeId, {
+  readonly workingDirectory: string;
+}, {
+  readonly fileMap: Map<string, string>;
+  readonly basePath: string;
+  readonly pathService: Path.Path;
+}, never>;
+type SandboxHandle = Handle.Of<typeof SandboxHandle>;
+//#endregion
+//#region src/Plugins.schema.d.ts
+type PluginKind = mod_d_exports$3.WorkerPluginKind | 'Evaluator';
+interface WorkerPluginDescriptor<K extends mod_d_exports$3.WorkerPluginKind = mod_d_exports$3.WorkerPluginKind> {
+  readonly kind: K;
+  readonly name: string;
+  readonly workerEntry: string;
+}
+interface EvaluatorPluginDescriptor {
+  readonly kind: 'Evaluator';
+  readonly name: string;
+}
+type AnyWorkerPluginDescriptor = { [K in mod_d_exports$3.WorkerPluginKind]: WorkerPluginDescriptor<K>; }[mod_d_exports$3.WorkerPluginKind];
+type AnyPluginDescriptor = AnyWorkerPluginDescriptor | EvaluatorPluginDescriptor;
+type PluginDescriptorOf<K extends PluginKind> = Extract<AnyPluginDescriptor, {
+  readonly kind: K;
+}>;
+type PluginDescriptor<K extends PluginKind = PluginKind> = PluginDescriptorOf<K>;
+interface WorkerPluginSource<K extends mod_d_exports$3.WorkerPluginKind = mod_d_exports$3.WorkerPluginKind> {
+  readonly kind: K;
+  readonly name: string;
+  readonly modulePath: string;
+  readonly workerEntry: string;
+}
+interface EvaluatorPluginSource {
+  readonly kind: 'Evaluator';
+  readonly name: string;
+  readonly modulePath: string;
+}
+type AnyWorkerPluginSource = { [K in mod_d_exports$3.WorkerPluginKind]: WorkerPluginSource<K>; }[mod_d_exports$3.WorkerPluginKind];
+type PluginSource = AnyWorkerPluginSource | EvaluatorPluginSource;
+interface LoadedPlugins<A = unknown> {
+  readonly schemaContributions: readonly Record<string, A>[];
+  readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
+  readonly pluginModulePaths: readonly string[];
+  readonly pluginSources: readonly PluginSource[];
+  readonly ignorers: readonly Ignorer[];
+  readonly frameworks: readonly {
+    readonly moduleName: string;
+    readonly framework: Framework;
+  }[];
+}
+//#endregion
+//#region src/reporter-output.service.d.ts
+type OutputChannel = 'stdout' | 'stderr';
+interface ReporterOutputShape {
+  readonly write: (channel: OutputChannel, chunks: readonly string[]) => Effect$1.Effect<void, PlatformError>;
+}
+declare const ReporterOutput_base: Context.ServiceClass<ReporterOutput, "@systemfsoftware/stryker-js/reporter-output.service/ReporterOutput", ReporterOutputShape>;
+declare class ReporterOutput extends ReporterOutput_base {
+  static readonly layer: Layer.Layer<ReporterOutput, never, Stdio.Stdio>;
+}
+//#endregion
+//#region src/reporter.service.d.ts
+interface ReporterShape {
+  readonly builtin: Readonly<Record<string, mod_d_exports$5.ReporterFactory>>;
+}
+declare const Reporter_base: Context.ServiceClass<Reporter, "@systemfsoftware/stryker-js/reporter.service/Reporter", ReporterShape>;
+declare class Reporter extends Reporter_base {
+  static readonly layer: Layer.Layer<Reporter, never, ReporterOutput | FileSystem.FileSystem | Path.Path>;
+}
+//#endregion
+//#region src/run/explain-file-skip.workflow.d.ts
+declare const FrameworkClaimant: S.Struct<{
+  readonly package: S.String;
+  readonly extensions: S.$Array<S.String>;
+}>;
+type FrameworkClaimant = S.Schema.Type<typeof FrameworkClaimant>;
+//#endregion
+//#region src/run/prepare.cell.d.ts
+interface PrepareDone {
+  readonly project: Project;
+  readonly loadedPlugins: LoadedPlugins;
+  readonly ignorers: readonly Ignorer[];
+  readonly formatRegistry: mod_d_exports$1.FormatRegistry;
+  readonly options: mod_d_exports$2$1.StrykerOptions;
+  readonly temporaryDirectoryPath: string;
+  readonly reporterStage: ReporterStage;
+  readonly frameworkClaimants: readonly FrameworkClaimant[];
+}
+interface PrepareExecutorArgs {
+  cliOptions: mod_d_exports$2$1.PartialStrykerOptions;
+  targetMutatePatterns: string[] | undefined;
+}
+//#endregion
+//#region src/run/instrument.cell.d.ts
+interface InstrumentDone extends PrepareDone {
+  readonly mutants: readonly mod_d_exports$3$1.Mutant[];
+  readonly sandbox: SandboxHandle;
+  readonly concurrency: {
+    readonly testRunners: number;
+    readonly checkers: number;
+  };
+}
+//#endregion
+//#region src/run/dry-run.cell.d.ts
+interface DryRunDone extends InstrumentDone {
+  readonly dryRunResult: mod_d_exports$6.CompleteDryRunResult;
+  readonly testCoverage: TestCoverage;
+  readonly timeOverhead: EffectDuration.Duration;
+}
+//#endregion
+//#region src/run/mutation-test.parts.d.ts
+interface MutationTestDone {
+  readonly results: readonly mod_d_exports$3$1.RunMutantResult[];
+  readonly verdict: mod_d_exports$3.ExitClass | null;
+}
+//#endregion
+//#region src/mutation-reporting.service.d.ts
+interface MutationReportingInput {
+  readonly results: readonly mod_d_exports$3$1.RunMutantResult[];
+  readonly options: mod_d_exports$2$1.StrykerOptions;
+  readonly project: Project;
+  readonly testCoverage: TestCoverage;
+  readonly runId: string;
+  readonly resolvedMode: ResolvedMode;
+  readonly basePath: string;
+  readonly reporterStage: ReporterStage;
+  readonly formatRegistry: mod_d_exports$1.FormatRegistry;
+}
+interface MutationReportingService {
+  readonly reportCheckFailure: (mutant: mod_d_exports$3$1.MutantTestCoverage, result: Exclude<mod_d_exports.CheckResult, mod_d_exports.PassedCheckResult>) => Effect$1.Effect<mod_d_exports$3$1.RunMutantResult>;
+  readonly reportMutantRunResult: (mutant: mod_d_exports$3$1.MutantTestCoverage, result: mod_d_exports$6.MutantRunResult) => Effect$1.Effect<mod_d_exports$3$1.RunMutantResult>;
+  readonly reportAll: (input: MutationReportingInput) => Effect$1.Effect<MutationTestDone, PlatformError>;
+  readonly checkpoint: (input: MutationReportingInput) => Effect$1.Effect<void, PlatformError>;
+}
+declare const MutationReporting_base: Context.ServiceClass<MutationReporting, "@systemfsoftware/stryker-js/mutation-reporting.service/MutationReporting", MutationReportingService>;
+declare class MutationReporting extends MutationReporting_base {
+  static readonly layer: Layer.Layer<MutationReporting, never, FileSystem.FileSystem | Path.Path | RunEvents | ProjectFiles>;
+}
+//#endregion
+//#region src/run/StageServices.service.d.ts
+type StageServices = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | IdGenerator | MutationReporting | Path.Path | ProjectFiles | Reporter | RunEnvironment | RunEvents | Scope.Scope | Stdio.Stdio | WorkerLauncher;
+type EnginePorts = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Stdio.Stdio | WorkerLauncher;
+type RunStageServices = ProjectFiles | Reporter | RunEnvironment | RunEvents | IdGenerator | MutationReporting | Scope.Scope;
+type WiredRunLayer = Layer.Layer<RunStageServices | EnginePorts, never, never>;
+//#endregion
+//#region src/run/RunEnvironment.service.d.ts
+interface RunEnvironmentShape {
+  readonly runId: string;
+  readonly resolvedMode: ResolvedMode;
+  readonly runStartedAt: number;
+  readonly basePath: string;
+  readonly builtinReporters: Readonly<Record<string, mod_d_exports$5.ReporterFactory>>;
+  readonly allowConsoleColors: boolean;
+}
+declare const RunEnvironment_base: Context.ServiceClass<RunEnvironment, "@systemfsoftware/stryker-js/run/RunEnvironment.service/RunEnvironment", RunEnvironmentShape>;
+declare class RunEnvironment extends RunEnvironment_base {
+  static readonly stage: {
+    (env: RunEnvironmentShape, events?: Queue.Queue<RunEvent, Cause.Done>): Layer.Layer<RunStageServices, never, EnginePorts>;
+    (events?: Queue.Queue<RunEvent, Cause.Done>): (env: RunEnvironmentShape) => Layer.Layer<RunStageServices, never, EnginePorts>;
+  };
+  static readonly forStream: {
+    (mode: ResolvedMode, stream: RunEventStream, host: {
+      readonly noColor?: string | undefined;
+      readonly builtinReporters: Readonly<Record<string, mod_d_exports$5.ReporterFactory>>;
+    }): Effect$1.Effect<RunEnvironmentShape, PlatformError, FileSystem.FileSystem>;
+    (stream: RunEventStream, host: {
+      readonly noColor?: string | undefined;
+      readonly builtinReporters: Readonly<Record<string, mod_d_exports$5.ReporterFactory>>;
+    }): (mode: ResolvedMode) => Effect$1.Effect<RunEnvironmentShape, PlatformError, FileSystem.FileSystem>;
+  };
+}
+//#endregion
+export { ResolvedMode as $, REPORTER_EVENT_BATCH_BOUND as A, make as B, WorkerPluginSource as C, IdGenerator as D, TestCoverage as E, spawnReporterWorker as F, RunIdentityShape as G, ProjectFile as H, WorkerLauncher as I, RunEventStream as J, RunEventDrain as K, WorkerLauncherShape as L, ReporterWorkerClient as M, SpawnReporterWorkerParams as N, IdGeneratorShape as O, reporterWorkerFactory as P, OutputMode as Q, WorkerSpawnParams as R, WorkerPluginDescriptor as S, StrykerError as T, RunEvents as U, Project as V, RunIdentity as W, ResolvedModeInput as X, makeRunEventStream as Y, ModeSignal as Z, LoadedPlugins as _, StageServices as a, ChildProcessCrashedError as at, PluginKind as b, DryRunDone as c, WorkerBootTimeoutError as ct, PrepareExecutorArgs as d, ConfigError as et, AnyPluginDescriptor as f, EvaluatorPluginSource as g, EvaluatorPluginDescriptor as h, RunStageServices as i, ConfigFileUnsupportedError as it, ReporterStage as j, PooledTestRunnerError as k, InstrumentDone as l, WorkerExit as lt, AnyWorkerPluginSource as m, RunEnvironmentShape as n, ConfigFileNotFoundError as nt, WiredRunLayer as o, OutOfMemoryError as ot, AnyWorkerPluginDescriptor as p, RunEventDrainLive as q, EnginePorts as r, ConfigFileUnreadableError as rt, MutationTestDone as s, WorkerBootError as st, RunEnvironment as t, ConfigFileInvalidError as tt, PrepareDone as u, PluginDescriptor as v, SandboxHandle as w, PluginSource as x, PluginDescriptorOf as y, SpawnedSocketWorker as z };