@systemfsoftware/stryker-js 9.0.0 → 10.0.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @systemfsoftware/stryker-js
 
+## 10.0.0
+
+### Major Changes
+
+- The machine-mode event stream now tags every event document with `_tag` (previously `kind`), matching the `RunEvent` schema tags. The wire line schema `RunEventWireLine` is exported, so consumers can decode machine-mode stdout lines with the same schema the CLI encodes them with. The event stream's composition surface is now public: `makeRunEventStream`, `RunEventStream`, `RunEventDrain`, `RunEventDrainLive`, and `ResolvedModeInput`.
+
+  Consumers parsing machine-mode stdout must read the `_tag` field instead of `kind`.
+
+### Patch Changes
+
+- A checker that fails now fails mutation testing with that checker's cause, instead of crashing with an empty error. The TypeScript checker type-checks each mutant, so compile errors appear in the report. Verdict counts are non-negative integers; `Metrics` is a class you can build from mutant statuses; a threshold `low` may not exceed `high`.
+
 ## 9.0.0
 
 ### Major Changes

package/dist/Run.schema-BBKIZ81u.d.mts

@@ -0,0 +1,165 @@
+import { C as Metrics, _ as ExitClass } from "./index-DnAm4mSL.mjs";
+import * as S from "effect/Schema";
+//#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 OutputMode: S.Literals<readonly ["human", "machine"]>;
+type OutputMode = typeof OutputMode.Type;
+declare const ModeSignal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+type ModeSignal = typeof ModeSignal.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.Int;
+}>, {}>;
+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.Int;
+  readonly total: S.Int;
+}>, {}>;
+declare class RunMutantTested extends RunMutantTested_base {}
+declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
+  readonly elapsedMs: S.Finite;
+  readonly completed: S.Int;
+  readonly total: S.NullOr<S.Int>;
+}>, {}>;
+declare class Heartbeat extends Heartbeat_base {}
+declare const VerdictThresholds: S.Struct<{
+  readonly high: S.Finite;
+  readonly low: S.Finite;
+  readonly break: S.NullOr<S.Finite>;
+}>;
+type VerdictThresholds = typeof VerdictThresholds.Type;
+declare const VerdictMutant: 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"]>;
+}>;
+type VerdictMutant = typeof VerdictMutant.Type;
+type VerdictCounts = Metrics;
+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: typeof 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 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;
+declare const RunDecodeError_base: S.Class<RunDecodeError, S.TaggedStruct<"RunDecodeError", {
+  readonly message: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RunDecodeError extends RunDecodeError_base {}
+declare const RunReadError_base: S.Class<RunReadError, S.TaggedStruct<"RunReadError", {
+  readonly message: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RunReadError extends RunReadError_base {}
+declare const PlanMutationRunCommand_base: S.Class<PlanMutationRunCommand, S.TaggedStruct<"PlanMutationRunCommand", {
+  readonly configMutatePatterns: S.$Array<S.String>;
+  readonly configMutatorNames: S.$Array<S.String>;
+  readonly targetMutatePatterns: S.$Array<S.String>;
+  readonly availableMutators: S.$Array<S.String>;
+}>, {}>;
+declare class PlanMutationRunCommand extends PlanMutationRunCommand_base {}
+declare const MutationRunPlan_base: S.Class<MutationRunPlan, S.TaggedStruct<"MutationRunPlan", {
+  readonly mutatePatterns: S.$Array<S.String>;
+  readonly mutatorNames: S.$Array<S.String>;
+}>, {}>;
+declare class MutationRunPlan extends MutationRunPlan_base {}
+//#endregion
+//#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;
+}
+declare const PrepareError_base: S.Class<PrepareError, S.TaggedStruct<"PrepareError", {
+  readonly stage: S.Literal<"prepare">;
+  readonly reason: S.String;
+}>, 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 };