@systemfsoftware/stryker-js 10.1.2 → 11.0.0

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

@@ -0,0 +1,456 @@
+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-CMCCQdTd.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-CUpTIyrj.mjs";
+import { Cell, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
+import "effect/Option";
+import * as Result from "effect/Result";
+import * as S from "effect/Schema";
+import * as Effect$1 from "effect/Effect";
+import { Pipeable } from "effect/Pipeable";
+import * as Context from "effect/Context";
+import { Schema } from "effect";
+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 "effect/Exit";
+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/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/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/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/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/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: unique symbol;
+type TypeId = typeof TypeId;
+declare const ClientLayerTypeId: unique symbol;
+interface SpawnedSocketWorker extends Pipeable {
+  readonly [TypeId]: typeof TypeId;
+  readonly [ClientLayerTypeId]: Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
+  readonly pid: number;
+  readonly exited: Effect$1.Effect<never, WorkerExit>;
+}
+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/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/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/Sandbox.handle.d.ts
+interface SandboxHandle {
+  readonly workingDirectory: string;
+  readonly sandboxFileFor: (fileName: string) => Result.Result<string, StrykerError>;
+  readonly originalFileFor: (sandboxFileName: string) => string;
+}
+//#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.cell.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 { ConfigError as $, ReporterWorkerClient as A, ProjectFile as B, WorkerPluginSource as C, TestCoverage as D, IdGeneratorShape as E, WorkerLauncherShape as F, ResolvedModeInput as G, RunEventDrainLive as H, WorkerSpawnParams as I, OutputMode as J, StrykerError as K, SpawnedSocketWorker as L, reporterWorkerFactory as M, spawnReporterWorker as N, REPORTER_EVENT_BATCH_BOUND as O, WorkerLauncher as P, RunIdentityShape as Q, make as R, WorkerPluginDescriptor as S, IdGenerator as T, RunEventStream as U, RunEventDrain as V, makeRunEventStream as W, RunEvents as X, ResolvedMode as Y, RunIdentity as Z, LoadedPlugins as _, StageServices as a, OutOfMemoryError as at, PluginKind as b, DryRunDone as c, WorkerExit as ct, PrepareExecutorArgs as d, ConfigFileInvalidError as et, AnyPluginDescriptor as f, EvaluatorPluginSource as g, EvaluatorPluginDescriptor as h, RunStageServices as i, ChildProcessCrashedError as it, SpawnReporterWorkerParams as j, ReporterStage as k, InstrumentDone as l, AnyWorkerPluginSource as m, RunEnvironmentShape as n, ConfigFileUnreadableError as nt, WiredRunLayer as o, WorkerBootError as ot, AnyWorkerPluginDescriptor as p, ModeSignal as q, EnginePorts as r, ConfigFileUnsupportedError as rt, MutationTestDone as s, WorkerBootTimeoutError as st, RunEnvironment as t, ConfigFileNotFoundError as tt, PrepareDone as u, PluginDescriptor as v, SandboxHandle as w, PluginSource as x, PluginDescriptorOf as y, Project as z };

package/dist/config.d.mts

@@ -1,23 +1,7 @@
-import { K as StrykerOptions, P as PartialStrykerOptions } from "./index-CogNSD0V.mjs";
-import { n as OutputMode } from "./output-mode-CfGHDpi5.mjs";
-//#region src/config/stryker-config.d.ts
-interface ConfigEnv {
-  readonly command: 'run' | 'merge-reports';
-  readonly isDryRun: boolean;
-  readonly mode: OutputMode;
-  readonly isCi: boolean;
-}
-type StrykerConfig = PartialStrykerOptions;
-type StrykerConfigFn = (env: ConfigEnv) => StrykerConfig | Promise<StrykerConfig>;
-type StrykerConfigExport = StrykerConfig | Promise<StrykerConfig> | StrykerConfigFn;
+import { n as mod_d_exports$2 } from "./index-CMCCQdTd.mjs";
+import { a as StrykerConfig, i as Primitive, n as Immutable, o as StrykerConfigExport, r as ImmutablePrimitive, s as StrykerConfigFn, t as ConfigEnv } from "./stryker-config.schema-lr7GMjpY.mjs";
+//#region src/config/mod.d.ts
+export type PartialStrykerOptions = mod_d_exports$2.PartialStrykerOptions;
+export type StrykerOptions = mod_d_exports$2.StrykerOptions;
 //#endregion
-//#region src/config/define-config.d.ts
-export declare function defineConfig(config: StrykerConfig): StrykerConfig;
-export declare function defineConfig(config: Promise<StrykerConfig>): Promise<StrykerConfig>;
-export declare function defineConfig(config: StrykerConfigFn): StrykerConfigFn;
-export declare function defineConfig(config: StrykerConfigExport): StrykerConfigExport;
-//#endregion
-//#region src/config/merge-config.d.ts
-export declare const mergeConfig: (defaults: StrykerConfig, overrides: StrykerConfig) => StrykerConfig;
-//#endregion
-export type { ConfigEnv, PartialStrykerOptions, StrykerConfig, StrykerConfigExport, StrykerConfigFn, StrykerOptions };
+export { type ConfigEnv, type Immutable, type ImmutablePrimitive, type Primitive, StrykerConfig, type StrykerConfigExport, type StrykerConfigFn };

package/dist/config.mjs

@@ -1,7 +1,2 @@
-import { t as mergeConfig } from "./merge-config-CHZWyvVQ.mjs";
-//#region src/config/define-config.ts
-function defineConfig(config) {
-	return config;
-}
-//#endregion
-export { defineConfig, mergeConfig };
+import { t as StrykerConfig } from "./stryker-config.schema-CCnDtVuW.mjs";
+export { StrykerConfig };