@systemfsoftware/stryker-js 9.0.0 → 10.0.1

package/dist/{mutation-test.cell-BTa-up9u.d.mts → mutation-test.cell-Dp6QiuRg.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-D_mcApox.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-t292QQGe.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 {}
@@ -525,7 +410,7 @@ declare interface ExportSpecifier extends Span$1 {
   exportKind?: ImportOrExportKind;
   parent?: Node$1;
 }
-declare type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | MetaProperty$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
+declare type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | MetaProperty$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
 declare interface ExpressionStatement$1 extends Span$1 {
   type: "ExpressionStatement";
   expression: Expression$1;
@@ -545,7 +430,7 @@ declare type FormalParameter = {
 declare interface FormalParameterRest extends Span$1 {
   type: "RestElement";
   argument: BindingPattern$1;
-  decorators?: [];
+  decorators?: Array<Decorator$1>;
   optional?: boolean;
   typeAnnotation?: TSTypeAnnotation$1 | null;
   value?: null;
@@ -1731,11 +1616,19 @@ declare const forkOptionsSchema: S.StructWithRest<S.Struct<{
     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 thresholds: S.withDecodingDefaultKey<S.decodeTo<S.declare<{
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+  }, {
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+  }>, 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>;
+  }>, never, never>, never>;
   readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
   readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
   readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
@@ -1861,4 +1754,4 @@ interface MutationTestDone {
   readonly verdict: ExitClass | null;
 }
 //#endregion
-export { PluginKind as $, ExtendsStepDocument as A, makeWorkerClient as At, MergeResult as B, ConfigError as C, WorkerBootError as Ct, ConfigFileUnsupportedError as D, WorkerLauncherShape as Dt, ConfigFileUnreadableError as E, WorkerLauncher as Et, ExtendsStepResolve as F, AnyPluginDescriptor as G, extendsPropertySchema as H, ExtendsStepState as I, EvaluatorPluginDescriptor as J, AnyWorkerPluginDescriptor as K, ExtendsStepStateSchema as L, ExtendsStepDone as M, OutOfMemoryError as Mt, ExtendsStepRead as N, WorkerBootTimeoutError as Nt, ExtendsRefusalReason as O, WorkerSpawnParams as Ot, ExtendsStepRefused as P, StageError as Pt, PluginDescriptorOf as Q, ImportedModuleSchema as R, ConfigDocumentSchema as S, SpawnedSocketWorker as St, ConfigFileNotFoundError as T, WorkerExit as Tt, forkOptionsSchema as U, ReadConfigCommand as V, survivorsPriorReport as W, LoadedPlugins as X, EvaluatorPluginSource as Y, PluginDescriptor as Z, ReporterStage as _, RunMutantTested as _t, WiredRunLayer as a, IdGeneratorShape as at, reporterWorkerFactory as b, RunTerminalEvent as bt, PrepareDone as c, RunEvents as ct, RunEnvironmentShape as d, Heartbeat as dt, PluginSource as et, SandboxHandle as f, HelpRendered as ft, REPORTER_EVENT_BATCH_BOUND as g, RunFailed as gt, ProjectFile as h, RunEvent as ht, StageServices as i, IdGenerator as it, ExtendsStepDocumentSchema as j, ChildProcessCrashedError as jt, ExtendsStepDecision as k, connectRetry as kt, PrepareExecutorArgs as l, RunIdentity as lt, Project as m, PlanKnown as mt, EnginePorts as n, WorkerPluginSource as nt, DryRunDone as o, classifyWorkerExit as ot, StrykerError as p, PhaseEntered 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, RunPhase as vt, ConfigFileInvalidError as w, WorkerClientParams as wt, spawnReporterWorker as x, VerdictReached as xt, SpawnReporterWorkerParams as y, RunStarted as yt, MergeCommand 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-BTa-up9u.mjs";
+import { P as PartialStrykerOptions } from "./index-D_mcApox.mjs";
+import { t as MutationTestDone } from "./mutation-test.cell-Dp6QiuRg.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-BQuaL-fB.mjs";
+import { t as strykerCell } from "./src-CMHnl87m.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";