@systemfsoftware/stryker-js 6.1.0 → 8.0.0

package/dist/mutation-test.cell-Cw1ZzDnb.d.mts

@@ -1,561 +0,0 @@
-import { B as StrykerOptions, O as PartialStrykerOptions, P as ReporterFactory, R as ReporterRpcs, T as MutationTestResult, W as TestResult, at as FileDescription, bt as RunMutantResult, d as ExitClass, gt as MutateDescription, it as CoverageData, lt as Mutant, ot as FileDescriptions, r as CompleteDryRunResult } from "./index-BInJWa0x.mjs";
-import { r as ResolvedMode } from "./output-mode-CfGHDpi5.mjs";
-import { b as Ignorer, o as LoadedPlugins } from "./Plugins-DF95m9KO.mjs";
-import * as Effect$1 from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import * as Stdio from "effect/Stdio";
-import { Cell } from "@systemfsoftware/effect-cell-types";
-import * as S from "effect/Schema";
-import * as Context from "effect/Context";
-import * as Rpc from "effect/unstable/rpc/Rpc";
-import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
-import { Schema } from "effect";
-import * as Layer from "effect/Layer";
-import * as Queue from "effect/Queue";
-import "effect/Result";
-import * as Cause from "effect/Cause";
-import { YieldableError } from "effect/Cause";
-import * as Scope from "effect/Scope";
-import * as Duration from "effect/Duration";
-import * as MutableHashMap from "effect/MutableHashMap";
-import * as MutableHashSet from "effect/MutableHashSet";
-import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
-import * as RpcClient from "effect/unstable/rpc/RpcClient";
-import * as Schedule from "effect/Schedule";
-import { PlatformError } from "effect/PlatformError";
-import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
-import * as Socket from "effect/unstable/socket/Socket";
-//#region src/Worker.schema.d.ts
-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.String;
-  }>]>;
-  readonly cause: Schema.optional<Schema.String>;
-}>, import("effect/Cause").YieldableError>;
-/**
- * The child process hosting a worker ended when it was not supposed to.
- */
-declare class ChildProcessCrashedError extends ChildProcessCrashedError_base {
-  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 exitClass: 'RuntimeError';
-}
-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/WorkerLauncher.d.ts
-declare const connectRetry: Schedule.Schedule<import("effect/Duration").Duration, unknown, never, never>;
-type WorkerExit = ChildProcessCrashedError | OutOfMemoryError;
-interface SpawnedSocketWorker {
-  readonly pid: number;
-  readonly clientLayer: Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
-  readonly exited: Effect$1.Effect<never, WorkerExit>;
-}
-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", WorkerLauncherShape>;
-declare class WorkerLauncher extends WorkerLauncher_base {}
-type WorkerBootError = WorkerExit | WorkerBootTimeoutError;
-interface WorkerClientParams<Rpcs extends Rpc.Any> extends WorkerSpawnParams {
-  readonly rpcs: RpcGroup.RpcGroup<Rpcs>;
-}
-declare const makeWorkerClient: <Rpcs extends Rpc.Any>(params: WorkerClientParams<Rpcs>) => Effect$1.Effect<RpcClient.RpcClient<Rpcs, RpcClientError>, WorkerBootError, Scope.Scope | WorkerLauncher>;
-//#endregion
-//#region src/RunEvent.schema.d.ts
-declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
-type RunPhase = typeof RunPhase.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 RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mutant", {
-  readonly id: S.String;
-  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "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 RunMutantTested extends RunMutantTested_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", "CompileError", "RuntimeError", "Timeout", "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 RunMutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
-type RunEvent = typeof RunEvent.Type;
-type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
-//#endregion
-//#region src/RunEvents.d.ts
-declare const RunEvents_base: Context.ServiceClass<RunEvents, "@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | PhaseEntered | PlanKnown | RunFailed | RunMutantTested | 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/RunEvents/RunIdentity", RunIdentityShape>;
-declare class RunIdentity extends RunIdentity_base {}
-//#endregion
-//#region src/Mutants.d.ts
-interface TestCoverage {
-  readonly testsByMutantId: MutableHashMap.MutableHashMap<string, MutableHashSet.MutableHashSet<TestResult>>;
-  readonly testsById: MutableHashMap.MutableHashMap<string, TestResult>;
-  readonly staticCoverage: CoverageData | undefined;
-  readonly hitsByMutantId: MutableHashMap.MutableHashMap<string, number>;
-}
-//#endregion
-//#region src/Worker.d.ts
-interface IdGeneratorShape {
-  readonly next: Effect$1.Effect<number>;
-}
-declare const IdGenerator_base: Context.ServiceClass<IdGenerator, "@systemfsoftware/stryker-js/Worker/IdGenerator", IdGeneratorShape>;
-declare class IdGenerator extends IdGenerator_base {}
-declare const classifyWorkerExit: (pid: number, exitCode: number) => ChildProcessCrashedError | OutOfMemoryError;
-//#endregion
-//#region src/Config.schema.d.ts
-declare const ConfigDocumentSchema: S.$Record<S.String, S.Unknown>;
-declare const ImportedModuleSchema: S.Struct<{
-  readonly default: S.optional<S.Unknown>;
-}>;
-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';
-}
-declare const ReadConfigCommand_base: S.Class<ReadConfigCommand, S.TaggedStruct<"ReadConfigCommand", {
-  readonly cliOptions: S.$Record<S.String, S.Unknown>;
-  readonly basePath: S.String;
-}>, {}>;
-declare class ReadConfigCommand extends ReadConfigCommand_base {}
-declare const MergeCommand_base: S.Class<MergeCommand, S.TaggedStruct<"MergeCommand", {
-  readonly base: S.$Record<S.String, S.Unknown>;
-  readonly overrides: S.$Record<S.String, S.Unknown>;
-}>, {}>;
-declare class MergeCommand extends MergeCommand_base {}
-declare const MergeResult_base: S.Class<MergeResult, S.TaggedStruct<"MergeResult", {
-  readonly merged: S.$Record<S.String, S.Unknown>;
-}>, {}>;
-declare class MergeResult extends MergeResult_base {}
-declare const ExtendsStepDocumentSchema: S.Struct<{
-  readonly path: S.String;
-  readonly options: S.$Record<S.String, S.Unknown>;
-}>;
-type ExtendsStepDocument = typeof ExtendsStepDocumentSchema.Type;
-declare const ExtendsStepStateSchema: S.Struct<{
-  readonly visited: S.$Array<S.String>;
-  readonly documents: S.$Array<S.Struct<{
-    readonly path: S.String;
-    readonly options: S.$Record<S.String, S.Unknown>;
-  }>>;
-}>;
-type ExtendsStepState = typeof ExtendsStepStateSchema.Type;
-type ExtendsRefusalReason = 'cycle' | 'non-string-extends';
-declare const ExtendsStepDone_base: S.Class<ExtendsStepDone, S.TaggedStruct<"done", {
-  readonly options: S.$Record<S.String, S.Unknown>;
-}>, {}>;
-declare class ExtendsStepDone extends ExtendsStepDone_base {}
-declare const ExtendsStepRead_base: S.Class<ExtendsStepRead, S.TaggedStruct<"read", {
-  readonly path: S.String;
-  readonly state: S.Struct<{
-    readonly visited: S.$Array<S.String>;
-    readonly documents: S.$Array<S.Struct<{
-      readonly path: S.String;
-      readonly options: S.$Record<S.String, S.Unknown>;
-    }>>;
-  }>;
-}>, {}>;
-declare class ExtendsStepRead extends ExtendsStepRead_base {}
-declare const ExtendsStepResolve_base: S.Class<ExtendsStepResolve, S.TaggedStruct<"resolve", {
-  readonly specifier: S.String;
-  readonly state: S.Struct<{
-    readonly visited: S.$Array<S.String>;
-    readonly documents: S.$Array<S.Struct<{
-      readonly path: S.String;
-      readonly options: S.$Record<S.String, S.Unknown>;
-    }>>;
-  }>;
-}>, {}>;
-declare class ExtendsStepResolve extends ExtendsStepResolve_base {}
-declare const ExtendsStepRefused_base: S.Class<ExtendsStepRefused, S.TaggedStruct<"refused", {
-  readonly reason: S.Literals<readonly ["cycle", "non-string-extends"]>;
-  readonly file: S.String;
-}>, {}>;
-declare class ExtendsStepRefused extends ExtendsStepRefused_base {}
-type ExtendsStepDecision = ExtendsStepDone | ExtendsStepRead | ExtendsStepResolve | ExtendsStepRefused;
-declare const survivorsPriorReport: S.optionalKey<S.String>;
-declare const extendsPropertySchema: S.optionalKey<S.String>;
-declare const forkOptionsSchema: S.StructWithRest<S.Struct<{
-  readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
-  readonly buildCommand: S.optional<S.String>;
-  readonly checkers: S.withDecodingDefaultKey<S.$Array<S.Struct<{
-    readonly plugin: S.String;
-    readonly nodeArgs: S.optional<S.$Array<S.String>>;
-    readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
-  }>>, never>;
-  readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly concurrency: S.optional<S.Union<readonly [S.Finite, S.String]>>;
-  readonly commandRunner: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
-    readonly command: S.withDecodingDefaultKey<S.String, never>;
-  }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
-  readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never>;
-  readonly clearTextReporter: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
-    readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly logTests: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never>;
-  }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
-  readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never>;
-  readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
-  readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
-  readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
-  readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
-  readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
-  readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
-  readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
-  readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
-  readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never>;
-  readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never>;
-  readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly mutator: S.withDecodingDefaultKey<S.Struct<{
-    readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  }>, never>;
-  readonly packageManager: S.optional<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
-  readonly plugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly htmlReporter: S.withDecodingDefaultKey<S.Struct<{
-    readonly fileName: S.withDecodingDefaultKey<S.String, never>;
-  }>, never>;
-  readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
-    readonly fileName: S.withDecodingDefaultKey<S.String, never>;
-  }>, never>;
-  readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.String]>, never>;
-  readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never>;
-  readonly tempDirName: S.withDecodingDefaultKey<S.String, never>;
-  readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never>;
-  readonly testRunner: S.withDecodingDefaultKey<S.Union<readonly [S.String, S.Struct<{
-    readonly plugin: S.String;
-    readonly nodeArgs: S.optional<S.$Array<S.String>>;
-    readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
-  }>]>, never>;
-  readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly thresholds: S.withDecodingDefaultKey<S.Struct<{
-    readonly high: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly low: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
-  }>, never>;
-  readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
-  readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
-  readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
-  readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never>;
-  readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.StructWithRest<S.Struct<{
-    readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly slow: S.withDecodingDefaultKey<S.Boolean, never>;
-  }>, readonly [S.$Record<S.String, S.Unknown>]>]>, never>;
-  readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never>;
-  readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never>;
-  readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly survivorsPriorReport: S.optionalKey<S.String>;
-  readonly extends: S.optionalKey<S.String>;
-}>, readonly [S.$Record<S.String, S.Unknown>]>;
-//#endregion
-//#region src/ReporterStream.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 ReporterRpcs>, RpcClientError>;
-declare const reporterWorkerFactory: (client: ReporterWorkerClient) => ReporterFactory;
-interface SpawnReporterWorkerParams {
-  readonly entrypoint: string;
-  readonly projectBasePath: string;
-  readonly execArgv: readonly string[];
-  readonly options: StrykerOptions;
-  readonly tempDirPrefix: string;
-}
-declare const spawnReporterWorker: (params: SpawnReporterWorkerParams) => Effect$1.Effect<ReporterWorkerClient, WorkerBootError, Scope.Scope | WorkerLauncher>;
-//#endregion
-//#region src/IncrementalReport.schema.d.ts
-declare const IncrementalReportSchema: S.StructWithRest<S.Struct<{
-  readonly schemaVersion: S.String;
-  readonly thresholds: S.Struct<{
-    readonly high: S.Finite;
-    readonly low: S.Finite;
-  }>;
-  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 replacement: 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 status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
-      readonly killedBy: S.optional<S.$Array<S.String>>;
-      readonly coveredBy: S.optional<S.$Array<S.String>>;
-      readonly static: S.optional<S.Boolean>;
-      readonly statusReason: S.optional<S.String>;
-      readonly testsCompleted: S.optional<S.Finite>;
-      readonly description: S.optional<S.String>;
-      readonly duration: S.optional<S.Finite>;
-    }>>;
-  }>>;
-  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 [S.$Record<S.String, S.Unknown>]>;
-//#endregion
-//#region src/Project.d.ts
-interface ProjectFile extends FileDescription {
-  readonly name: string;
-  readonly mutate: MutateDescription;
-  readonly content: string | undefined;
-  readonly originalContent: string | undefined;
-}
-interface Project {
-  readonly fileDescriptions: FileDescriptions;
-  readonly incrementalReport: MutationTestResult | undefined;
-  readonly testFiles: readonly string[];
-  readonly files: MutableHashMap.MutableHashMap<string, ProjectFile>;
-  readonly filesToMutate: MutableHashMap.MutableHashMap<string, ProjectFile>;
-}
-//#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.d.ts
-interface SandboxHandle {
-  readonly workingDirectory: string;
-  readonly sandboxFileFor: (fileName: string) => string;
-  readonly originalFileFor: (sandboxFileName: string) => string;
-}
-//#endregion
-//#region src/run/RunEnvironment.d.ts
-interface RunEnvironmentShape {
-  readonly runId: string;
-  readonly resolvedMode: ResolvedMode;
-  readonly runStartedAt: number;
-  readonly basePath: string;
-  readonly builtinReporters: Readonly<Record<string, ReporterFactory>>;
-  readonly allowConsoleColors: boolean;
-}
-declare const RunEnvironment_base: Context.ServiceClass<RunEnvironment, "@systemfsoftware/stryker-js/run/RunEnvironment", RunEnvironmentShape>;
-declare class RunEnvironment extends RunEnvironment_base {}
-//#endregion
-//#region src/run/prepare.cell.d.ts
-interface PrepareDone {
-  readonly project: Project;
-  readonly loadedPlugins: LoadedPlugins;
-  readonly ignorers: readonly Ignorer[];
-  readonly options: StrykerOptions;
-  readonly temporaryDirectoryPath: string;
-  readonly reporterStage: ReporterStage;
-}
-interface PrepareExecutorArgs {
-  cliOptions: PartialStrykerOptions;
-  targetMutatePatterns: string[] | undefined;
-}
-//#endregion
-//#region src/run/instrument.cell.d.ts
-interface InstrumentDone extends PrepareDone {
-  readonly mutants: readonly 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: CompleteDryRunResult;
-  readonly testCoverage: TestCoverage;
-  readonly timeOverhead: Duration.Duration;
-}
-//#endregion
-//#region src/run/StageServices.d.ts
-type StageServices = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | IdGenerator | Path.Path | RunEnvironment | RunEvents | Scope.Scope | Stdio.Stdio | WorkerLauncher;
-type EnginePorts = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Stdio.Stdio | WorkerLauncher;
-type RunStageServices = RunEnvironment | RunEvents | IdGenerator | Scope.Scope;
-type WiredRunLayer = Layer.Layer<RunStageServices | EnginePorts, never, never>;
-//#endregion
-//#region src/run/mutation-test.cell.d.ts
-interface MutationTestDone {
-  readonly results: readonly RunMutantResult[];
-  readonly verdict: ExitClass | null;
-}
-//#endregion
-export { Heartbeat as $, ExtendsStepDecision as A, MergeCommand as B, ConfigDocumentSchema as C, ConfigFileUnreadableError as D, ConfigFileNotFoundError as E, ExtendsStepRefused as F, survivorsPriorReport as G, ReadConfigCommand as H, ExtendsStepResolve as I, classifyWorkerExit as J, IdGenerator as K, ExtendsStepState as L, ExtendsStepDocumentSchema as M, ExtendsStepDone as N, ConfigFileUnsupportedError as O, ExtendsStepRead as P, RunIdentityShape as Q, ExtendsStepStateSchema as R, spawnReporterWorker as S, ConfigFileInvalidError as T, extendsPropertySchema as U, MergeResult as V, forkOptionsSchema as W, RunEvents as X, TestCoverage as Y, RunIdentity as Z, REPORTER_EVENT_BATCH_BOUND as _, connectRetry as _t, WiredRunLayer as a, RunMutantTested as at, SpawnReporterWorkerParams as b, OutOfMemoryError as bt, PrepareDone as c, RunTerminalEvent as ct, RunEnvironmentShape as d, WorkerBootError as dt, HelpRendered as et, SandboxHandle as f, WorkerClientParams as ft, IncrementalReportSchema as g, WorkerSpawnParams as gt, ProjectFile as h, WorkerLauncherShape as ht, StageServices as i, RunFailed as it, ExtendsStepDocument as j, ExtendsRefusalReason as k, PrepareExecutorArgs as l, VerdictReached as lt, Project as m, WorkerLauncher as mt, EnginePorts as n, PlanKnown as nt, DryRunDone as o, RunPhase as ot, StrykerError as p, WorkerExit as pt, IdGeneratorShape as q, RunStageServices as r, RunEvent as rt, InstrumentDone as s, RunStarted as st, MutationTestDone as t, PhaseEntered as tt, RunEnvironment as u, SpawnedSocketWorker as ut, ReporterStage as v, makeWorkerClient as vt, ConfigError as w, reporterWorkerFactory as x, WorkerBootTimeoutError as xt, ReporterWorkerClient as y, ChildProcessCrashedError as yt, ImportedModuleSchema as z };

package/dist/output-mode-CfGHDpi5.d.mts

@@ -1,17 +0,0 @@
-//#region src/output-mode.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
-export { OutputMode as n, ResolvedMode as r, ModeSignal as t };