@systemfsoftware/stryker-js 8.0.0 → 10.0.0

package/dist/{mutation-test.cell-Ch-QUquW.d.mts → mutation-test.cell-m9T-X2Qx.d.mts}

@@ -1,44 +1,32 @@
-import { $ as TestResult, Et as RunMutantResult, L as PartialStrykerOptions, P as MutationTestResult, St as MutateDescription, U as ReporterFactory, Y as StrykerOptions, b as ExitClass, ct as WorkerPluginKind, dt as FileDescription, f as CompleteDryRunResult, ft as FileDescriptions, ht as Mutant, q as ReporterRpcs, r as ResolvedMode, ut as CoverageData } from "./output-mode-CE6VNHfH.mjs";
+import { B as ReporterFactory, Ct as RunMutantResult, K as StrykerOptions, P as PartialStrykerOptions, W as ReporterRpcs, X as TestResult, _ as ExitClass, at as WorkerPluginKind, ct as FileDescription, ft as Mutant, j as MutationTestResult, l as CompleteDryRunResult, lt as FileDescriptions, st as CoverageData, yt as MutateDescription } from "./index-DnAm4mSL.mjs";
+import { r as ResolvedMode } from "./output-mode-CfGHDpi5.mjs";
+import { _ as RunStarted, c as PhaseEntered, i as HelpRendered, l as PlanKnown, m as RunMutantTested, p as RunFailed, r as Heartbeat, x as VerdictReached } from "./Run.schema-BBKIZ81u.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 "effect/Option";
-import { Schema } from "effect";
 import * as Context from "effect/Context";
-import * as Rpc from "effect/unstable/rpc/Rpc";
-import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
 import * as Layer from "effect/Layer";
+import "effect/Option";
 import * as Queue from "effect/Queue";
 import "effect/Result";
-import * as Cause from "effect/Cause";
+import * as S from "effect/Schema";
+import { Cell } from "@systemfsoftware/effect-cell-types";
+import { Schema } from "effect";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
 import * as Scope from "effect/Scope";
 import * as EffectDuration from "effect/Duration";
 import * as MutableHashMap from "effect/MutableHashMap";
 import * as MutableHashSet from "effect/MutableHashSet";
 import * as HashMap from "effect/HashMap";
+import * as Cause from "effect/Cause";
 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/Run.schema.d.ts
-declare const TypeId: '~stryker/mutation-run/StageError';
-declare const StageError_base: S.Class<StageError, S.TaggedStruct<"StageError", {
-  readonly stage: S.Literals<readonly ["prepare", "instrument", "dryRun", "dryRunNoTests", "mutationTest"]>;
-  readonly reason: S.String;
-  readonly cause: S.optional<S.Defect>;
-  readonly command: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
-declare class StageError extends StageError_base {
-  readonly [TypeId]: "~stryker/mutation-run/StageError";
-  get exitClass(): ExitClass;
-  get message(): string;
-}
-//#endregion
 //#region src/Worker.schema.d.ts
 declare const ChildProcessCrashedError_base: Schema.Class<ChildProcessCrashedError, Schema.TaggedStruct<"ChildProcessCrashedError", {
   readonly pid: Schema.Int;
@@ -98,109 +86,6 @@ interface WorkerClientParams<Rpcs extends Rpc.Any> extends WorkerSpawnParams {
 }
 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 {}
@@ -1777,59 +1662,6 @@ interface SpawnReporterWorkerParams {
 }
 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;
@@ -1914,4 +1746,4 @@ interface MutationTestDone {
   readonly verdict: ExitClass | null;
 }
 //#endregion
-export { PluginDescriptorOf as $, ExtendsStepDecision as A, connectRetry as At, MergeCommand as B, ConfigDocumentSchema as C, SpawnedSocketWorker as Ct, ConfigFileUnreadableError as D, WorkerLauncher as Dt, ConfigFileNotFoundError as E, WorkerExit as Et, ExtendsStepRefused as F, StageError as Ft, survivorsPriorReport as G, ReadConfigCommand as H, ExtendsStepResolve as I, AnyWorkerPluginSource as J, AnyPluginDescriptor as K, ExtendsStepState as L, ExtendsStepDocumentSchema as M, ChildProcessCrashedError as Mt, ExtendsStepDone as N, OutOfMemoryError as Nt, ConfigFileUnsupportedError as O, WorkerLauncherShape as Ot, ExtendsStepRead as P, WorkerBootTimeoutError as Pt, PluginDescriptor as Q, ExtendsStepStateSchema as R, spawnReporterWorker as S, VerdictReached as St, ConfigFileInvalidError as T, WorkerClientParams as Tt, extendsPropertySchema as U, MergeResult as V, forkOptionsSchema as W, EvaluatorPluginSource as X, EvaluatorPluginDescriptor as Y, LoadedPlugins as Z, REPORTER_EVENT_BATCH_BOUND as _, RunFailed as _t, WiredRunLayer as a, IdGenerator as at, SpawnReporterWorkerParams as b, RunStarted as bt, PrepareDone as c, TestCoverage as ct, RunEnvironmentShape as d, RunIdentityShape as dt, PluginKind as et, SandboxHandle as f, Heartbeat as ft, IncrementalReportSchema as g, RunEvent as gt, ProjectFile as h, PlanKnown as ht, StageServices as i, Ignorer as it, ExtendsStepDocument as j, makeWorkerClient as jt, ExtendsRefusalReason as k, WorkerSpawnParams as kt, PrepareExecutorArgs as l, RunEvents as lt, Project as m, PhaseEntered as mt, EnginePorts as n, WorkerPluginDescriptor as nt, DryRunDone as o, IdGeneratorShape as ot, StrykerError as p, HelpRendered as pt, AnyWorkerPluginDescriptor as q, RunStageServices as r, WorkerPluginSource as rt, InstrumentDone as s, classifyWorkerExit as st, MutationTestDone as t, PluginSource as tt, RunEnvironment as u, RunIdentity as ut, ReporterStage as v, RunMutantTested as vt, ConfigError as w, WorkerBootError as wt, reporterWorkerFactory as x, RunTerminalEvent as xt, ReporterWorkerClient as y, RunPhase as yt, ImportedModuleSchema as z };
+export { PluginKind as $, ExtendsStepDocument as A, MergeResult as B, ConfigError as C, ConfigFileUnsupportedError as D, ConfigFileUnreadableError as E, ExtendsStepResolve as F, AnyPluginDescriptor as G, extendsPropertySchema as H, ExtendsStepState as I, EvaluatorPluginDescriptor as J, AnyWorkerPluginDescriptor as K, ExtendsStepStateSchema as L, ExtendsStepDone as M, ExtendsStepRead as N, ExtendsRefusalReason as O, ExtendsStepRefused as P, PluginDescriptorOf as Q, ImportedModuleSchema as R, ConfigDocumentSchema as S, WorkerBootTimeoutError as St, ConfigFileNotFoundError as T, forkOptionsSchema as U, ReadConfigCommand as V, survivorsPriorReport as W, LoadedPlugins as X, EvaluatorPluginSource as Y, PluginDescriptor as Z, ReporterStage as _, WorkerSpawnParams as _t, WiredRunLayer as a, IdGeneratorShape as at, reporterWorkerFactory as b, ChildProcessCrashedError as bt, PrepareDone as c, RunEvents as ct, RunEnvironmentShape as d, SpawnedSocketWorker as dt, PluginSource as et, SandboxHandle as f, WorkerBootError as ft, REPORTER_EVENT_BATCH_BOUND as g, WorkerLauncherShape as gt, ProjectFile as h, WorkerLauncher as ht, StageServices as i, IdGenerator as it, ExtendsStepDocumentSchema as j, ExtendsStepDecision as k, PrepareExecutorArgs as l, RunIdentity as lt, Project as m, WorkerExit as mt, EnginePorts as n, WorkerPluginSource as nt, DryRunDone as o, classifyWorkerExit as ot, StrykerError as p, WorkerClientParams as pt, AnyWorkerPluginSource as q, RunStageServices as r, Ignorer as rt, InstrumentDone as s, TestCoverage as st, MutationTestDone as t, WorkerPluginDescriptor as tt, RunEnvironment as u, RunIdentityShape as ut, ReporterWorkerClient as v, connectRetry as vt, ConfigFileInvalidError as w, spawnReporterWorker as x, OutOfMemoryError as xt, SpawnReporterWorkerParams as y, makeWorkerClient as yt, MergeCommand as z };

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

@@ -0,0 +1,17 @@
+//#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 };

package/dist/promises.d.mts

@@ -1,5 +1,5 @@
-import { L as PartialStrykerOptions } from "./output-mode-CE6VNHfH.mjs";
-import { t as MutationTestDone } from "./mutation-test.cell-Ch-QUquW.mjs";
+import { P as PartialStrykerOptions } from "./index-DnAm4mSL.mjs";
+import { t as MutationTestDone } from "./mutation-test.cell-m9T-X2Qx.mjs";
 //#region src/promises/index.d.ts
 export declare const run: (options: PartialStrykerOptions, targetMutatePatterns?: readonly string[]) => Promise<MutationTestDone>;
 //#endregion

package/dist/promises.mjs

@@ -1,4 +1,4 @@
-import { t as strykerCell } from "./src-WMC3thmX.mjs";
+import { t as strykerCell } from "./src-Bu4i-Lt2.mjs";
 import * as Layer from "effect/Layer";
 import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
 import * as NodePath from "@effect/platform-node-shared/NodePath";