@systemfsoftware/stryker-js 3.0.0 → 3.0.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @systemfsoftware/stryker-js
 
+## 3.0.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@7.0.0
+
 ## 3.0.0
 
 ### Major Changes

package/dist/{Plugin-CunIOPtw.d.mts → Plugin-BtItMchw.d.mts}

@@ -3,7 +3,7 @@ import { q as TestRunner } from "./Mutant-Ci25PsWA.mjs";
 import { t as Evaluator } from "./Evaluator-CnAN8-pZ.mjs";
 import { t as Ignorer } from "./Ignorer-BUY68FZQ.mjs";
 import { t as Module } from "./Module-DHKEMAFI.mjs";
-import { l as ReporterFactory } from "./ReporterEvent.schema-Db6r_euv.mjs";
+import { l as ReporterFactory } from "./ReporterEvent.schema-BhtyYCZo.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as Option from "effect/Option";

package/dist/Plugin.d.mts

@@ -1,2 +1,2 @@
-import { _ as PluginReporterContribution, a as PluginEnvironment, c as RunConfiguration, d as composePlugins, f as declarePlugin, g as PluginLayerKind, h as PluginLayerContribution, i as MergedPluginServices, l as SandboxDirectory, m as PluginKind, n as ComposedPlugins, o as PluginInterfaces, p as PluginContribution, r as ContributionOf, t as AnyPluginContribution, u as SelectedReporterFactory, v as Shadowing } from "./Plugin-CunIOPtw.mjs";
+import { _ as PluginReporterContribution, a as PluginEnvironment, c as RunConfiguration, d as composePlugins, f as declarePlugin, g as PluginLayerKind, h as PluginLayerContribution, i as MergedPluginServices, l as SandboxDirectory, m as PluginKind, n as ComposedPlugins, o as PluginInterfaces, p as PluginContribution, r as ContributionOf, t as AnyPluginContribution, u as SelectedReporterFactory, v as Shadowing } from "./Plugin-BtItMchw.mjs";
 export { AnyPluginContribution, ComposedPlugins, ContributionOf, MergedPluginServices, type PluginContribution, PluginEnvironment, PluginInterfaces, PluginKind, PluginLayerContribution, type PluginLayerKind, PluginReporterContribution, RunConfiguration, SandboxDirectory, SelectedReporterFactory, Shadowing, composePlugins, declarePlugin };

package/dist/{Reporter-BU7qo6MR.d.mts → Reporter-C7ysGxqX.d.mts}

@@ -1,5 +1,5 @@
 import { n as MetricsResult, t as Metrics } from "./Metrics.schema-BaVd6rXs.mjs";
-import { a as ReporterEvent, c as ReporterEventUnion, d as ReporterPlanDescriptor, f as RunTiming, i as MutationTestingPlanReady, l as ReporterFactory, n as MutantTested, o as ReporterEventKind, r as MutationTestReportReady, s as ReporterEventSchema, t as DryRunCompleted, u as ReporterInit } from "./ReporterEvent.schema-Db6r_euv.mjs";
+import { a as ReporterEvent, c as ReporterEventUnion, d as ReporterPlanDescriptor, f as RunTiming, i as MutationTestingPlanReady, l as ReporterFactory, n as MutantTested, o as ReporterEventKind, r as MutationTestReportReady, s as ReporterEventSchema, t as DryRunCompleted, u as ReporterInit } from "./ReporterEvent.schema-BhtyYCZo.mjs";
 import * as S from "effect/Schema";
 //#region src/Reporter.schema.d.ts
 declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"ReporterFailed", {

package/dist/Reporter.d.mts

@@ -1,4 +1,4 @@
 import { n as MetricsResult, t as Metrics } from "./Metrics.schema-BaVd6rXs.mjs";
-import { a as ReporterEvent, c as ReporterEventUnion, d as ReporterPlanDescriptor, f as RunTiming, i as MutationTestingPlanReady, l as ReporterFactory, n as MutantTested, o as ReporterEventKind, r as MutationTestReportReady, s as ReporterEventSchema, t as DryRunCompleted, u as ReporterInit } from "./ReporterEvent.schema-Db6r_euv.mjs";
-import { r as ReporterFailed, t as REPORTER_SCHEMA_VERSION } from "./Reporter-BU7qo6MR.mjs";
+import { a as ReporterEvent, c as ReporterEventUnion, d as ReporterPlanDescriptor, f as RunTiming, i as MutationTestingPlanReady, l as ReporterFactory, n as MutantTested, o as ReporterEventKind, r as MutationTestReportReady, s as ReporterEventSchema, t as DryRunCompleted, u as ReporterInit } from "./ReporterEvent.schema-BhtyYCZo.mjs";
+import { r as ReporterFailed, t as REPORTER_SCHEMA_VERSION } from "./Reporter-C7ysGxqX.mjs";
 export { DryRunCompleted, type Metrics, type MetricsResult, MutantTested, MutationTestReportReady, MutationTestingPlanReady, REPORTER_SCHEMA_VERSION, type ReporterEvent, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, type ReporterFactory, ReporterFailed, type ReporterInit, type ReporterPlanDescriptor, type RunTiming };

package/dist/ReporterEvent.d.mts

@@ -1,2 +1,2 @@
-import { a as ReporterEvent, c as ReporterEventUnion, d as ReporterPlanDescriptor, f as RunTiming, i as MutationTestingPlanReady, l as ReporterFactory, n as MutantTested, o as ReporterEventKind, r as MutationTestReportReady, s as ReporterEventSchema, t as DryRunCompleted, u as ReporterInit } from "./ReporterEvent.schema-Db6r_euv.mjs";
+import { a as ReporterEvent, c as ReporterEventUnion, d as ReporterPlanDescriptor, f as RunTiming, i as MutationTestingPlanReady, l as ReporterFactory, n as MutantTested, o as ReporterEventKind, r as MutationTestReportReady, s as ReporterEventSchema, t as DryRunCompleted, u as ReporterInit } from "./ReporterEvent.schema-BhtyYCZo.mjs";
 export { DryRunCompleted, MutantTested, MutationTestReportReady, MutationTestingPlanReady, ReporterEvent, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFactory, ReporterInit, ReporterPlanDescriptor, RunTiming };

package/dist/ReporterEvent.mjs

@@ -1,10 +1,9 @@
 import { t as LocationSchema } from "./Mutant.schema-H3r0ho_R.mjs";
 import { MutationTestResultSchema } from "./Report.mjs";
 import { t as MetricsResultSchema } from "./Metrics.schema-DZdoc46X.mjs";
-import { i as MutantStatus } from "./Run.schema-C4m-b9Ki.mjs";
+import { i as MutantStatus } from "./Run.schema-DZve3k2m.mjs";
 import { d as TestRunnerCapabilitiesSchema, u as TestResultSchema } from "./TestRunner.schema-Dy0Wdro2.mjs";
 import * as S from "effect/Schema";
-import { Wire } from "@systemfsoftware/effect-cell-types";
 //#region src/ReporterEvent.schema.ts
 const ReporterEventKind = S.Literals([
 	"dryRunCompleted",
@@ -12,36 +11,36 @@ const ReporterEventKind = S.Literals([
 	"mutantTested",
 	"mutationTestReportReady"
 ]);
-const RunTimingSchema = Wire.wire({
-	net: Wire.mint(S.Finite),
-	overhead: Wire.mint(S.Finite)
+const RunTimingSchema = S.Struct({
+	net: S.Finite,
+	overhead: S.Finite
 });
 const ReporterPlanKind = S.Literals(["EarlyResult", "Run"]);
-const ReporterPlanDescriptorSchema = Wire.wire({
-	mutantId: Wire.mint(S.String),
-	plan: Wire.mint(ReporterPlanKind),
-	netTime: Wire.mint(S.Finite),
-	reloadEnvironment: Wire.mint(S.Boolean)
+const ReporterPlanDescriptorSchema = S.Struct({
+	mutantId: S.String,
+	plan: ReporterPlanKind,
+	netTime: S.Finite,
+	reloadEnvironment: S.Boolean
 });
 var DryRunCompleted = class extends S.TaggedClass()("dryRunCompleted", {
 	timing: RunTimingSchema,
 	capabilities: TestRunnerCapabilitiesSchema,
-	testCount: Wire.mint(S.Finite),
+	testCount: S.Finite,
 	tests: S.Array(TestResultSchema)
 }) {};
 var MutationTestingPlanReady = class extends S.TaggedClass()("mutationTestingPlanReady", {
-	total: Wire.mint(S.Finite),
+	total: S.Finite,
 	plans: S.Array(ReporterPlanDescriptorSchema)
 }) {};
 var MutantTested = class extends S.TaggedClass()("mutantTested", {
-	id: Wire.mint(S.String),
+	id: S.String,
 	status: MutantStatus,
-	file: Wire.mint(S.String),
+	file: S.String,
 	location: LocationSchema,
-	mutator: Wire.mint(S.String),
-	replacement: Wire.mint(S.NullOr(Wire.mint(S.String))),
-	completed: Wire.mint(S.Finite),
-	total: Wire.mint(S.Finite)
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
+	completed: S.Finite,
+	total: S.Finite
 }) {};
 var MutationTestReportReady = class extends S.TaggedClass()("mutationTestReportReady", {
 	report: MutationTestResultSchema,

package/dist/{ReporterEvent.schema-Db6r_euv.d.mts → ReporterEvent.schema-BhtyYCZo.d.mts}

@@ -1,32 +1,31 @@
 import { n as MetricsResult } from "./Metrics.schema-BaVd6rXs.mjs";
-import { m as StrykerOptions } from "./Schema-CXKiLnTu.mjs";
+import { m as StrykerOptions } from "./Schema-4oCWQ0P0.mjs";
 import * as S from "effect/Schema";
-import { Wire } from "@systemfsoftware/effect-cell-types";
 import { StandardSchemaV1 } from "effect/StandardSchema";
 //#region src/ReporterEvent.schema.d.ts
 declare const ReporterEventKind: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
 type ReporterEventKind = typeof ReporterEventKind.Type;
 declare const RunTimingSchema: S.Struct<{
-  net: S.Finite & Wire.Mark;
-  overhead: S.Finite & Wire.Mark;
-}> & Wire.Mark;
+  readonly net: S.Finite;
+  readonly overhead: S.Finite;
+}>;
 type RunTiming = typeof RunTimingSchema.Type;
 declare const ReporterPlanDescriptorSchema: S.Struct<{
-  mutantId: S.String & Wire.Mark;
-  plan: S.Literals<readonly ["EarlyResult", "Run"]> & Wire.Mark;
-  netTime: S.Finite & Wire.Mark;
-  reloadEnvironment: S.Boolean & Wire.Mark;
-}> & Wire.Mark;
+  readonly mutantId: S.String;
+  readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
+  readonly netTime: S.Finite;
+  readonly reloadEnvironment: S.Boolean;
+}>;
 type ReporterPlanDescriptor = typeof ReporterPlanDescriptorSchema.Type;
 declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dryRunCompleted", {
   readonly timing: S.Struct<{
-    net: S.Finite & Wire.Mark;
-    overhead: S.Finite & Wire.Mark;
-  }> & Wire.Mark;
+    readonly net: S.Finite;
+    readonly overhead: S.Finite;
+  }>;
   readonly capabilities: S.Struct<{
     readonly reloadEnvironment: S.Boolean;
   }>;
-  readonly testCount: S.Finite & Wire.Mark;
+  readonly testCount: S.Finite;
   readonly tests: S.$Array<S.Union<readonly [S.Struct<{
     readonly id: S.String;
     readonly name: S.String;
@@ -62,19 +61,19 @@ declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dry
 }>, {}>;
 declare class DryRunCompleted extends DryRunCompleted_base {}
 declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S.TaggedStruct<"mutationTestingPlanReady", {
-  readonly total: S.Finite & Wire.Mark;
+  readonly total: S.Finite;
   readonly plans: S.$Array<S.Struct<{
-    mutantId: S.String & Wire.Mark;
-    plan: S.Literals<readonly ["EarlyResult", "Run"]> & Wire.Mark;
-    netTime: S.Finite & Wire.Mark;
-    reloadEnvironment: S.Boolean & Wire.Mark;
-  }> & Wire.Mark>;
+    readonly mutantId: S.String;
+    readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
+    readonly netTime: S.Finite;
+    readonly reloadEnvironment: S.Boolean;
+  }>>;
 }>, {}>;
 declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
 declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTested", {
-  readonly id: S.String & Wire.Mark;
+  readonly id: S.String;
   readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
-  readonly file: S.String & Wire.Mark;
+  readonly file: S.String;
   readonly location: S.Struct<{
     readonly start: S.Struct<{
       readonly line: S.Finite;
@@ -85,10 +84,10 @@ declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTes
       readonly column: S.Finite;
     }>;
   }>;
-  readonly mutator: S.String & Wire.Mark;
-  readonly replacement: S.NullOr<S.String & Wire.Mark> & Wire.Mark;
-  readonly completed: S.Finite & Wire.Mark;
-  readonly total: S.Finite & Wire.Mark;
+  readonly mutator: S.String;
+  readonly replacement: S.NullOr<S.String>;
+  readonly completed: S.Finite;
+  readonly total: S.Finite;
 }>, {}>;
 declare class MutantTested extends MutantTested_base {}
 declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.TaggedStruct<"mutationTestReportReady", {

package/dist/{Run-CnhaYlAC.d.mts → Run-BUpNSmcM.d.mts}

@@ -1,6 +1,5 @@
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
-import { Wire } from "@systemfsoftware/effect-cell-types";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Cause from "effect/Cause";
@@ -15,115 +14,115 @@ type ModeSignal = typeof ModeSignal.Type;
 declare const MutantStatus: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
 type MutantStatus = typeof MutantStatus.Type;
 declare const Position: S.Struct<{
-  line: S.Finite & Wire.Mark;
-  column: S.Finite & Wire.Mark;
-}> & Wire.Mark;
+  readonly line: S.Finite;
+  readonly column: S.Finite;
+}>;
 declare const Location: S.Struct<{
-  start: S.Struct<{
-    line: S.Finite & Wire.Mark;
-    column: S.Finite & Wire.Mark;
-  }> & Wire.Mark;
-  end: S.Struct<{
-    line: S.Finite & Wire.Mark;
-    column: S.Finite & Wire.Mark;
-  }> & Wire.Mark;
-}> & Wire.Mark;
+  readonly start: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>;
+  readonly end: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>;
+}>;
 type Location = typeof Location.Type;
 type Position = typeof Position.Type;
 declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
-  readonly schemaVersion: S.String & Wire.Mark;
-  readonly runId: S.String & Wire.Mark;
+  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 & Wire.Mark;
+  readonly elapsedMs: S.Finite;
 }>, {}>;
 declare class PhaseEntered extends PhaseEntered_base {}
 declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
-  readonly total: S.Finite & Wire.Mark;
+  readonly total: S.Finite;
 }>, {}>;
 declare class PlanKnown extends PlanKnown_base {}
 declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutant", {
-  readonly id: S.String & Wire.Mark;
+  readonly id: S.String;
   readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
-  readonly file: S.String & Wire.Mark;
+  readonly file: S.String;
   readonly location: S.Struct<{
-    start: S.Struct<{
-      line: S.Finite & Wire.Mark;
-      column: S.Finite & Wire.Mark;
-    }> & Wire.Mark;
-    end: S.Struct<{
-      line: S.Finite & Wire.Mark;
-      column: S.Finite & Wire.Mark;
-    }> & Wire.Mark;
-  }> & Wire.Mark;
-  readonly mutator: S.String & Wire.Mark;
-  readonly replacement: S.NullOr<S.String & Wire.Mark> & Wire.Mark;
-  readonly completed: S.Finite & Wire.Mark;
-  readonly total: S.Finite & Wire.Mark;
+    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 MutantTested extends MutantTested_base {}
 declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
-  readonly elapsedMs: S.Finite & Wire.Mark;
-  readonly completed: S.Finite & Wire.Mark;
-  readonly total: S.NullOr<S.Finite & Wire.Mark> & Wire.Mark;
+  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 & Wire.Mark;
-  readonly runId: S.String & Wire.Mark;
+  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 & Wire.Mark> & Wire.Mark;
+  readonly score: S.NullOr<S.Finite>;
   readonly thresholds: S.Struct<{
-    high: S.Finite & Wire.Mark;
-    low: S.Finite & Wire.Mark;
-    break: S.NullOr<S.Finite & Wire.Mark> & Wire.Mark;
-  }> & Wire.Mark;
-  readonly reportFile: S.NullOr<S.String & Wire.Mark> & Wire.Mark;
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+    readonly break: S.NullOr<S.Finite>;
+  }>;
+  readonly reportFile: S.NullOr<S.String>;
   readonly counts: S.Struct<{
-    killed: S.Finite & Wire.Mark;
-    timeout: S.Finite & Wire.Mark;
-    survived: S.Finite & Wire.Mark;
-    noCoverage: S.Finite & Wire.Mark;
-    runtimeErrors: S.Finite & Wire.Mark;
-    compileErrors: S.Finite & Wire.Mark;
-    ignored: S.Finite & Wire.Mark;
-    pending: S.Finite & Wire.Mark;
-  }> & Wire.Mark;
+    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 & Wire.Mark;
-    readonly file: S.String & Wire.Mark;
+    readonly id: S.String;
+    readonly file: S.String;
     readonly location: S.Struct<{
-      start: S.Struct<{
-        line: S.Finite & Wire.Mark;
-        column: S.Finite & Wire.Mark;
-      }> & Wire.Mark;
-      end: S.Struct<{
-        line: S.Finite & Wire.Mark;
-        column: S.Finite & Wire.Mark;
-      }> & Wire.Mark;
-    }> & Wire.Mark;
-    readonly mutator: S.String & Wire.Mark;
-    readonly replacement: S.NullOr<S.String & Wire.Mark> & Wire.Mark;
+      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", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
   }>>;
 }>, {}>;
 declare class VerdictReached extends VerdictReached_base {}
 declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
-  readonly schemaVersion: S.String & Wire.Mark;
-  readonly code: S.Finite & Wire.Mark;
-  readonly error: S.String & Wire.Mark;
-  readonly remediation: S.String & Wire.Mark;
+  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 & Wire.Mark;
-  readonly code: S.Literals<readonly [0]> & Wire.Mark;
-  readonly help: S.String & Wire.Mark;
+  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 MutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
@@ -140,15 +139,15 @@ declare const RunOutput_base: S.Class<RunOutput, S.TaggedStruct<"RunOutput", {
 }>, {}>;
 declare class RunOutput extends RunOutput_base {}
 declare const PlanMutationRunCommand_base: S.Class<PlanMutationRunCommand, S.TaggedStruct<"PlanMutationRunCommand", {
-  readonly configMutatePatterns: S.$Array<S.String & Wire.Mark> & Wire.Mark;
-  readonly configMutatorNames: S.$Array<S.String & Wire.Mark> & Wire.Mark;
-  readonly targetMutatePatterns: S.$Array<S.String & Wire.Mark> & Wire.Mark;
-  readonly availableMutators: S.$Array<S.String & Wire.Mark> & Wire.Mark;
+  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 & Wire.Mark> & Wire.Mark;
-  readonly mutatorNames: S.$Array<S.String & Wire.Mark> & Wire.Mark;
+  readonly mutatePatterns: S.$Array<S.String>;
+  readonly mutatorNames: S.$Array<S.String>;
 }>, {}>;
 declare class MutationRunPlan extends MutationRunPlan_base {}
 declare namespace Run_d_exports {

package/dist/Run.d.mts

@@ -1,2 +1,2 @@
-import { C as RunTerminalEvent, S as RunStarted, _ as PlanKnown, b as RunFailed, c as shouldKeepTempDir, d as Location, f as ModeSignal, g as PhaseEntered, h as OutputMode, i as RunIdentityShape, l as Heartbeat, m as MutantTested, n as RunEvents, o as planMutationRun, p as MutantStatus, r as RunIdentity, s as runMutationTest, t as MutationRunIo, u as HelpRendered, v as Position, w as VerdictReached, x as RunPhase, y as RunEvent } from "./Run-CnhaYlAC.mjs";
+import { C as RunTerminalEvent, S as RunStarted, _ as PlanKnown, b as RunFailed, c as shouldKeepTempDir, d as Location, f as ModeSignal, g as PhaseEntered, h as OutputMode, i as RunIdentityShape, l as Heartbeat, m as MutantTested, n as RunEvents, o as planMutationRun, p as MutantStatus, r as RunIdentity, s as runMutationTest, t as MutationRunIo, u as HelpRendered, v as Position, w as VerdictReached, x as RunPhase, y as RunEvent } from "./Run-BUpNSmcM.mjs";
 export { Heartbeat, HelpRendered, type Location, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, type Position, RunEvent, type RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, type RunTerminalEvent, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir };

package/dist/Run.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as MutantTested, c as PhaseEntered, d as RunEvent, f as RunFailed, g as VerdictReached, h as RunStarted, i as MutantStatus, l as PlanKnown, m as RunPhase, n as HelpRendered, o as MutationRunPlan, p as RunOutput, r as ModeSignal, s as OutputMode, t as Heartbeat, u as PlanMutationRunCommand } from "./Run.schema-C4m-b9Ki.mjs";
+import { a as MutantTested, c as PhaseEntered, d as RunEvent, f as RunFailed, g as VerdictReached, h as RunStarted, i as MutantStatus, l as PlanKnown, m as RunPhase, n as HelpRendered, o as MutationRunPlan, p as RunOutput, r as ModeSignal, s as OutputMode, t as Heartbeat, u as PlanMutationRunCommand } from "./Run.schema-DZve3k2m.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as Effect from "effect/Effect";

package/dist/{Run.schema-C4m-b9Ki.mjs → Run.schema-DZve3k2m.mjs}

@@ -1,5 +1,4 @@
 import * as S from "effect/Schema";
-import { Wire } from "@systemfsoftware/effect-cell-types";
 //#region src/Run.schema.ts
 const RunPhase = S.Literals([
 	"prepare",
@@ -25,84 +24,84 @@ const MutantStatus = S.Literals([
 	"Ignored",
 	"Pending"
 ]);
-const Position = Wire.wire({
-	line: Wire.mint(S.Finite),
-	column: Wire.mint(S.Finite)
+const Position = S.Struct({
+	line: S.Finite,
+	column: S.Finite
 });
-const Location = Wire.wire({
+const Location = S.Struct({
 	start: Position,
 	end: Position
 });
 var RunStarted = class extends S.TaggedClass()("stream", {
-	schemaVersion: Wire.mint(S.String),
-	runId: Wire.mint(S.String),
+	schemaVersion: S.String,
+	runId: S.String,
 	mode: OutputMode,
 	signal: ModeSignal
 }) {};
 var PhaseEntered = class extends S.TaggedClass()("phase", {
 	phase: RunPhase,
-	elapsedMs: Wire.mint(S.Finite)
+	elapsedMs: S.Finite
 }) {};
-var PlanKnown = class extends S.TaggedClass()("plan", { total: Wire.mint(S.Finite) }) {};
+var PlanKnown = class extends S.TaggedClass()("plan", { total: S.Finite }) {};
 var MutantTested = class extends S.TaggedClass()("mutant", {
-	id: Wire.mint(S.String),
+	id: S.String,
 	status: MutantStatus,
-	file: Wire.mint(S.String),
+	file: S.String,
 	location: Location,
-	mutator: Wire.mint(S.String),
-	replacement: Wire.mint(S.NullOr(Wire.mint(S.String))),
-	completed: Wire.mint(S.Finite),
-	total: Wire.mint(S.Finite)
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
+	completed: S.Finite,
+	total: S.Finite
 }) {};
 var Heartbeat = class extends S.TaggedClass()("tick", {
-	elapsedMs: Wire.mint(S.Finite),
-	completed: Wire.mint(S.Finite),
-	total: Wire.mint(S.NullOr(Wire.mint(S.Finite)))
+	elapsedMs: S.Finite,
+	completed: S.Finite,
+	total: S.NullOr(S.Finite)
 }) {};
-const VerdictThresholds = Wire.wire({
-	high: Wire.mint(S.Finite),
-	low: Wire.mint(S.Finite),
-	break: Wire.mint(S.NullOr(Wire.mint(S.Finite)))
+const VerdictThresholds = S.Struct({
+	high: S.Finite,
+	low: S.Finite,
+	break: S.NullOr(S.Finite)
 });
 const VerdictMutant = S.Struct({
-	id: Wire.mint(S.String),
-	file: Wire.mint(S.String),
+	id: S.String,
+	file: S.String,
 	location: Location,
-	mutator: Wire.mint(S.String),
-	replacement: Wire.mint(S.NullOr(Wire.mint(S.String))),
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
 	status: MutantStatus
 });
-const VerdictCounts = Wire.wire({
-	killed: Wire.mint(S.Finite),
-	timeout: Wire.mint(S.Finite),
-	survived: Wire.mint(S.Finite),
-	noCoverage: Wire.mint(S.Finite),
-	runtimeErrors: Wire.mint(S.Finite),
-	compileErrors: Wire.mint(S.Finite),
-	ignored: Wire.mint(S.Finite),
-	pending: Wire.mint(S.Finite)
+const VerdictCounts = S.Struct({
+	killed: S.Finite,
+	timeout: S.Finite,
+	survived: S.Finite,
+	noCoverage: S.Finite,
+	runtimeErrors: S.Finite,
+	compileErrors: S.Finite,
+	ignored: S.Finite,
+	pending: S.Finite
 });
 var VerdictReached = class extends S.TaggedClass()("verdict", {
-	schemaVersion: Wire.mint(S.String),
-	runId: Wire.mint(S.String),
+	schemaVersion: S.String,
+	runId: S.String,
 	mode: OutputMode,
 	signal: ModeSignal,
-	score: Wire.mint(S.NullOr(Wire.mint(S.Finite))),
+	score: S.NullOr(S.Finite),
 	thresholds: VerdictThresholds,
-	reportFile: Wire.mint(S.NullOr(Wire.mint(S.String))),
+	reportFile: S.NullOr(S.String),
 	counts: VerdictCounts,
 	mutants: S.Array(VerdictMutant)
 }) {};
 var RunFailed = class extends S.TaggedClass()("error", {
-	schemaVersion: Wire.mint(S.String),
-	code: Wire.mint(S.Finite),
-	error: Wire.mint(S.String),
-	remediation: Wire.mint(S.String)
+	schemaVersion: S.String,
+	code: S.Finite,
+	error: S.String,
+	remediation: S.String
 }) {};
 var HelpRendered = class extends S.TaggedClass()("help", {
-	schemaVersion: Wire.mint(S.String),
-	code: Wire.mint(S.Literals([0])),
-	help: Wire.mint(S.String)
+	schemaVersion: S.String,
+	code: S.Literals([0]),
+	help: S.String
 }) {};
 const RunEvent = S.Union([
 	RunStarted,
@@ -126,14 +125,14 @@ S.TaggedError()("RunDecodeError", { message: S.String });
 S.TaggedError()("RunReadError", { message: S.String });
 S.TaggedError()("RunWriteError", { message: S.String });
 var PlanMutationRunCommand = class extends S.TaggedClass()("PlanMutationRunCommand", {
-	configMutatePatterns: Wire.mint(S.Array(Wire.mint(S.String))),
-	configMutatorNames: Wire.mint(S.Array(Wire.mint(S.String))),
-	targetMutatePatterns: Wire.mint(S.Array(Wire.mint(S.String))),
-	availableMutators: Wire.mint(S.Array(Wire.mint(S.String)))
+	configMutatePatterns: S.Array(S.String),
+	configMutatorNames: S.Array(S.String),
+	targetMutatePatterns: S.Array(S.String),
+	availableMutators: S.Array(S.String)
 }) {};
 var MutationRunPlan = class extends S.TaggedClass()("MutationRunPlan", {
-	mutatePatterns: Wire.mint(S.Array(Wire.mint(S.String))),
-	mutatorNames: Wire.mint(S.Array(Wire.mint(S.String)))
+	mutatePatterns: S.Array(S.String),
+	mutatorNames: S.Array(S.String)
 }) {};
 //#endregion
 export { MutantTested as a, PhaseEntered as c, RunEvent as d, RunFailed as f, VerdictReached as g, RunStarted as h, MutantStatus as i, PlanKnown as l, RunPhase as m, HelpRendered as n, MutationRunPlan as o, RunOutput as p, ModeSignal as r, OutputMode as s, Heartbeat as t, PlanMutationRunCommand as u };

package/dist/{Schema-CXKiLnTu.d.mts → Schema-4oCWQ0P0.d.mts}

@@ -1,5 +1,4 @@
 import * as S from "effect/Schema";
-import { Wire } from "@systemfsoftware/effect-cell-types";
 //#region src/Schema.schema.d.ts
 declare const LogLevel: S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>;
 declare const CoverageAnalysisMode: S.Literals<readonly ["off", "all", "perTest"]>;
@@ -11,76 +10,76 @@ type CoverageAnalysisMode = typeof CoverageAnalysisMode.Type;
 type ReportType = typeof ReportType.Type;
 type PackageManager = typeof PackageManager.Type;
 declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
-  readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly buildCommand: S.optional<S.String & Wire.Mark>;
-  readonly checkers: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly concurrency: S.optional<S.Union<readonly [S.Finite & Wire.Mark, S.String & Wire.Mark]> & Wire.Mark>;
+  readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly buildCommand: S.optional<S.String>;
+  readonly checkers: S.withDecodingDefaultKey<S.$Array<S.String>, 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> & Wire.Mark;
-  }> & Wire.Mark, readonly [S.$Record<S.String & Wire.Mark, S.Unknown & Wire.Mark> & Wire.Mark]>, never> & Wire.Mark;
-  readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never> & Wire.Mark;
+    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> & Wire.Mark;
-    readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly logTests: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-    readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  }> & Wire.Mark, readonly [S.$Record<S.String & Wire.Mark, S.Unknown & Wire.Mark> & Wire.Mark]>, never> & Wire.Mark;
-  readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly incremental: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly incrementalFile: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly force: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never> & Wire.Mark;
-  readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never> & Wire.Mark;
-  readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
+    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<{
-    excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  }>, never> & Wire.Mark;
+    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 & Wire.Mark>, never> & Wire.Mark;
-  readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
+  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<{
-    fileName: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  }>, never> & Wire.Mark;
+    readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+  }>, never>;
   readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
-    fileName: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  }>, never> & Wire.Mark;
-  readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean & Wire.Mark, S.String & Wire.Mark]>, never> & Wire.Mark;
-  readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly tempDirName: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never> & Wire.Mark;
-  readonly testRunner: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
+    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.String, never>;
+  readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
   readonly thresholds: S.withDecodingDefaultKey<S.Struct<{
-    readonly high: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-    readonly low: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-    readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite & Wire.Mark>, never> & Wire.Mark;
-  }>, never> & Wire.Mark;
-  readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never> & Wire.Mark;
-  readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never> & Wire.Mark;
-  readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean & Wire.Mark, S.StructWithRest<S.Struct<{
-    readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-    readonly slow: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  }> & Wire.Mark, readonly [S.$Record<S.String & Wire.Mark, S.Unknown & Wire.Mark> & Wire.Mark]> & Wire.Mark]>, never> & Wire.Mark;
-  readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never> & Wire.Mark;
-  readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
-  readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String & Wire.Mark>, never> & Wire.Mark;
+    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 [S.$Record<S.String, S.Unknown>]>;
 /** The decoded type: every defaulted option is present. */
 type StrykerOptions = S.Schema.Type<typeof StrykerOptionsSchema>;

package/dist/{Schema-CdNkubPi.mjs → Schema-CMKdWMUN.mjs}

@@ -1,6 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import * as S from "effect/Schema";
-import { Wire } from "@systemfsoftware/effect-cell-types";
 import { Effect } from "effect";
 //#region src/Schema.schema.ts
 const RENDERED_OPTION_DEFAULTS$1 = {
@@ -34,7 +33,7 @@ const RENDERED_OPTION_DEFAULTS$1 = {
 * separate engine that happened not to inject them.
 */
 /** Open object: fixed fields plus an index signature accepting arbitrary plugin keys. */
-const openStruct = (fields) => Wire.mint(S.StructWithRest(Wire.wire(fields), [Wire.mint(S.Record(Wire.mint(S.String), Wire.mint(S.Unknown)))]));
+const openStruct = (fields) => S.StructWithRest(S.Struct(fields), [S.Record(S.String, S.Unknown)]);
 /**
 * Field that decodes to a value but defaults when the key is absent.
 *
@@ -50,8 +49,7 @@ const openStruct = (fields) => Wire.mint(S.StructWithRest(Wire.wire(fields), [Wi
 */
 const defaulted = (schema, defaultValue) => {
 	const annotated = schema.annotate({ default: defaultValue });
-	const withDefault = S.withDecodingDefaultKey(Effect.succeed(defaultValue))(annotated);
-	return Wire.mint(withDefault);
+	return S.withDecodingDefaultKey(Effect.succeed(defaultValue))(annotated);
 };
 const LogLevel = S.Literals([
 	"off",
@@ -74,43 +72,43 @@ const PackageManager = S.Literals([
 	"pnpm"
 ]);
 /** 0–100 percentage used by the mutation-score thresholds. */
-const Percentage = Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isBetween({
+const Percentage = S.Finite.pipe(S.check(S.isBetween({
 	minimum: 0,
 	maximum: 100
-}))));
-const CommandRunnerOptionsSchema = openStruct({ command: defaulted(Wire.mint(S.String), "npm test") });
+})));
+const CommandRunnerOptionsSchema = openStruct({ command: defaulted(S.String, "npm test") });
 const ClearTextReporterOptions = openStruct({
-	allowColor: defaulted(Wire.mint(S.Boolean), true),
-	allowEmojis: defaulted(Wire.mint(S.Boolean), false),
-	logTests: defaulted(Wire.mint(S.Boolean), true),
-	maxTestsToLog: defaulted(Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isGreaterThanOrEqualTo(0)))), 3),
-	reportTests: defaulted(Wire.mint(S.Boolean), true),
-	reportMutants: defaulted(Wire.mint(S.Boolean), true),
-	reportScoreTable: defaulted(Wire.mint(S.Boolean), true),
-	skipFull: defaulted(Wire.mint(S.Boolean), false)
+	allowColor: defaulted(S.Boolean, true),
+	allowEmojis: defaulted(S.Boolean, false),
+	logTests: defaulted(S.Boolean, true),
+	maxTestsToLog: defaulted(S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))), 3),
+	reportTests: defaulted(S.Boolean, true),
+	reportMutants: defaulted(S.Boolean, true),
+	reportScoreTable: defaulted(S.Boolean, true),
+	skipFull: defaulted(S.Boolean, false)
 });
-const HtmlReporterOptions = Wire.wire({ fileName: defaulted(Wire.mint(S.String), "reports/mutation/mutation.html") });
-const JsonReporterOptions = Wire.wire({ fileName: defaulted(Wire.mint(S.String), "reports/mutation/mutation.json") });
+const HtmlReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.html") });
+const JsonReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.json") });
 const MutationScoreThresholdsSchema = S.Struct({
 	high: defaulted(Percentage, 80),
 	low: defaulted(Percentage, 60),
 	break: defaulted(S.NullOr(Percentage), null)
 });
-const MutatorDescriptor = Wire.wire({ excludedMutations: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []) });
+const MutatorDescriptor = S.Struct({ excludedMutations: defaulted(S.Array(S.String), []) });
 const WarningOptions = openStruct({
-	unknownOptions: defaulted(Wire.mint(S.Boolean), true),
-	preprocessorErrors: defaulted(Wire.mint(S.Boolean), true),
-	unserializableOptions: defaulted(Wire.mint(S.Boolean), true),
-	slow: defaulted(Wire.mint(S.Boolean), true)
+	unknownOptions: defaulted(S.Boolean, true),
+	preprocessorErrors: defaulted(S.Boolean, true),
+	unserializableOptions: defaulted(S.Boolean, true),
+	slow: defaulted(S.Boolean, true)
 });
-const ConcurrencyCount = Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isGreaterThanOrEqualTo(1))));
-const ConcurrencyPercent = Wire.mint(Wire.mint(S.String).pipe(S.check(S.isPattern(/^(100|[1-9]?[0-9])%$/))));
+const ConcurrencyCount = S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(1)));
+const ConcurrencyPercent = S.String.pipe(S.check(S.isPattern(/^(100|[1-9]?[0-9])%$/)));
 const StrykerOptionsSchema = S.StructWithRest(S.Struct({
-	allowConsoleColors: defaulted(Wire.mint(S.Boolean), true),
-	buildCommand: S.optional(Wire.mint(S.String)),
-	checkers: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
-	checkerNodeArgs: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
-	concurrency: S.optional(Wire.mint(S.Union([ConcurrencyCount, ConcurrencyPercent]))),
+	allowConsoleColors: defaulted(S.Boolean, true),
+	buildCommand: S.optional(S.String),
+	checkers: defaulted(S.Array(S.String), []),
+	checkerNodeArgs: defaulted(S.Array(S.String), []),
+	concurrency: S.optional(S.Union([ConcurrencyCount, ConcurrencyPercent])),
 	commandRunner: defaulted(CommandRunnerOptionsSchema, { command: "npm test" }),
 	coverageAnalysis: defaulted(CoverageAnalysisMode, RENDERED_OPTION_DEFAULTS$1.coverageAnalysis),
 	clearTextReporter: defaulted(ClearTextReporterOptions, {
@@ -123,54 +121,54 @@ const StrykerOptionsSchema = S.StructWithRest(S.Struct({
 		reportScoreTable: true,
 		skipFull: false
 	}),
-	dryRunOnly: defaulted(Wire.mint(S.Boolean), false),
-	ignorePatterns: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
-	ignoreStatic: defaulted(Wire.mint(S.Boolean), false),
-	incremental: defaulted(Wire.mint(S.Boolean), false),
-	incrementalFile: defaulted(Wire.mint(S.String), "reports/stryker-incremental.json"),
-	progressStreamFile: defaulted(Wire.mint(S.String), "reports/mutation-stream.jsonl"),
-	force: defaulted(Wire.mint(S.Boolean), false),
+	dryRunOnly: defaulted(S.Boolean, false),
+	ignorePatterns: defaulted(S.Array(S.String), []),
+	ignoreStatic: defaulted(S.Boolean, false),
+	incremental: defaulted(S.Boolean, false),
+	incrementalFile: defaulted(S.String, "reports/stryker-incremental.json"),
+	progressStreamFile: defaulted(S.String, "reports/mutation-stream.jsonl"),
+	force: defaulted(S.Boolean, false),
 	fileLogLevel: defaulted(LogLevel, RENDERED_OPTION_DEFAULTS$1.fileLogLevel),
-	inPlace: defaulted(Wire.mint(S.Boolean), false),
+	inPlace: defaulted(S.Boolean, false),
 	logLevel: defaulted(LogLevel, RENDERED_OPTION_DEFAULTS$1.logLevel),
-	maxConcurrentTestRunners: defaulted(Wire.mint(S.Finite), 9007199254740991),
-	maxTestRunnerReuse: defaulted(Wire.mint(S.Finite), 0),
-	mutate: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), ["{src,lib}/**/!(*.+(s|S)pec|*.+(t|T)est).+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)", "!{src,lib}/**/__tests__/**/*.+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)"]),
+	maxConcurrentTestRunners: defaulted(S.Finite, 9007199254740991),
+	maxTestRunnerReuse: defaulted(S.Finite, 0),
+	mutate: defaulted(S.Array(S.String), ["{src,lib}/**/!(*.+(s|S)pec|*.+(t|T)est).+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)", "!{src,lib}/**/__tests__/**/*.+(cjs|mjs|js|ts|mts|cts|jsx|tsx|html|vue|svelte)"]),
 	mutator: defaulted(MutatorDescriptor, { excludedMutations: [] }),
 	packageManager: S.optional(PackageManager),
-	plugins: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), ["@systemfsoftware/stryker-js-*"]),
-	appendPlugins: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
-	reporters: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), [
+	plugins: defaulted(S.Array(S.String), ["@systemfsoftware/stryker-js-*"]),
+	appendPlugins: defaulted(S.Array(S.String), []),
+	reporters: defaulted(S.Array(S.String), [
 		"clear-text",
 		"progress",
 		"html"
 	]),
 	htmlReporter: defaulted(HtmlReporterOptions, { fileName: "reports/mutation/mutation.html" }),
 	jsonReporter: defaulted(JsonReporterOptions, { fileName: "reports/mutation/mutation.json" }),
-	disableTypeChecks: defaulted(Wire.mint(S.Union([Wire.mint(S.Boolean), Wire.mint(S.String)])), true),
-	symlinkNodeModules: defaulted(Wire.mint(S.Boolean), true),
-	tempDirName: defaulted(Wire.mint(S.String), RENDERED_OPTION_DEFAULTS$1.tempDirName),
+	disableTypeChecks: defaulted(S.Union([S.Boolean, S.String]), true),
+	symlinkNodeModules: defaulted(S.Boolean, true),
+	tempDirName: defaulted(S.String, RENDERED_OPTION_DEFAULTS$1.tempDirName),
 	cleanTempDir: defaulted(S.Literals([
 		"always",
 		false,
 		true
 	]), true),
-	testRunner: defaulted(Wire.mint(S.String), "command"),
-	testRunnerNodeArgs: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
+	testRunner: defaulted(S.String, "command"),
+	testRunnerNodeArgs: defaulted(S.Array(S.String), []),
 	thresholds: defaulted(MutationScoreThresholdsSchema, {
 		high: 80,
 		low: 60,
 		break: null
 	}),
-	timeoutFactor: defaulted(Wire.mint(S.Finite), 1.5),
-	timeoutMS: defaulted(Wire.mint(S.Finite), 5e3),
-	dryRunTimeoutMinutes: defaulted(Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isGreaterThanOrEqualTo(0)))), 5),
-	tsconfigFile: defaulted(Wire.mint(S.String), "tsconfig.json"),
-	warnings: defaulted(Wire.mint(S.Union([Wire.mint(S.Boolean), WarningOptions])), true),
-	disableBail: defaulted(Wire.mint(S.Boolean), false),
-	allowEmpty: defaulted(Wire.mint(S.Boolean), false),
-	ignorers: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), []),
-	testFiles: defaulted(Wire.mint(S.Array(Wire.mint(S.String))), [])
+	timeoutFactor: defaulted(S.Finite, 1.5),
+	timeoutMS: defaulted(S.Finite, 5e3),
+	dryRunTimeoutMinutes: defaulted(S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0))), 5),
+	tsconfigFile: defaulted(S.String, "tsconfig.json"),
+	warnings: defaulted(S.Union([S.Boolean, WarningOptions]), true),
+	disableBail: defaulted(S.Boolean, false),
+	allowEmpty: defaulted(S.Boolean, false),
+	ignorers: defaulted(S.Array(S.String), []),
+	testFiles: defaulted(S.Array(S.String), [])
 }), [S.Record(S.String, S.Unknown)]);
 //#endregion
 //#region src/Schema.ts

package/dist/Schema.d.mts

@@ -1,2 +1,2 @@
-import { c as strykerReportBugUrl, d as PackageManager, f as PartialStrykerOptions, h as StrykerOptionsSchema, i as RENDERED_OPTION_DEFAULTS, l as CoverageAnalysisMode, m as StrykerOptions, n as Primitive, o as propertyPath, p as ReportType, r as PropertyPathOverloads, s as strykerCoreSchema, t as KnownKeys, u as LogLevel } from "./Schema-CXKiLnTu.mjs";
+import { c as strykerReportBugUrl, d as PackageManager, f as PartialStrykerOptions, h as StrykerOptionsSchema, i as RENDERED_OPTION_DEFAULTS, l as CoverageAnalysisMode, m as StrykerOptions, n as Primitive, o as propertyPath, p as ReportType, r as PropertyPathOverloads, s as strykerCoreSchema, t as KnownKeys, u as LogLevel } from "./Schema-4oCWQ0P0.mjs";
 export { CoverageAnalysisMode, type CoverageAnalysisMode as CoverageAnalysisModeType, KnownKeys, LogLevel, type LogLevel as LogLevelType, PackageManager, type PackageManager as PackageManagerType, type PartialStrykerOptions, Primitive, PropertyPathOverloads, RENDERED_OPTION_DEFAULTS, ReportType, type ReportType as ReportTypeType, type StrykerOptions, StrykerOptionsSchema, propertyPath, strykerCoreSchema, strykerReportBugUrl };

package/dist/Schema.mjs

@@ -1,2 +1,2 @@
-import { a as strykerReportBugUrl, c as PackageManager, i as strykerCoreSchema, l as ReportType, o as CoverageAnalysisMode, r as propertyPath, s as LogLevel, t as RENDERED_OPTION_DEFAULTS, u as StrykerOptionsSchema } from "./Schema-CdNkubPi.mjs";
+import { a as strykerReportBugUrl, c as PackageManager, i as strykerCoreSchema, l as ReportType, o as CoverageAnalysisMode, r as propertyPath, s as LogLevel, t as RENDERED_OPTION_DEFAULTS, u as StrykerOptionsSchema } from "./Schema-CMKdWMUN.mjs";
 export { CoverageAnalysisMode, LogLevel, PackageManager, RENDERED_OPTION_DEFAULTS, ReportType, StrykerOptionsSchema, propertyPath, strykerCoreSchema, strykerReportBugUrl };

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 import { i as Checker_d_exports } from "./Checker-A8o5B3Ub.mjs";
 import { X as TestRunner_d_exports, v as Mutant_d_exports } from "./Mutant-Ci25PsWA.mjs";
 import { r as Ignorer_d_exports } from "./Ignorer-BUY68FZQ.mjs";
-import { a as Schema_d_exports } from "./Schema-CXKiLnTu.mjs";
-import { s as Plugin_d_exports } from "./Plugin-CunIOPtw.mjs";
-import { n as Reporter_d_exports } from "./Reporter-BU7qo6MR.mjs";
-import { a as Run_d_exports } from "./Run-CnhaYlAC.mjs";
+import { a as Schema_d_exports } from "./Schema-4oCWQ0P0.mjs";
+import { s as Plugin_d_exports } from "./Plugin-BtItMchw.mjs";
+import { n as Reporter_d_exports } from "./Reporter-C7ysGxqX.mjs";
+import { a as Run_d_exports } from "./Run-BUpNSmcM.mjs";
 export { Checker_d_exports as Checker, Ignorer_d_exports as Ignorer, Mutant_d_exports as Mutant, Plugin_d_exports as Plugin, Reporter_d_exports as Reporter, Run_d_exports as Run, Schema_d_exports as Schema, TestRunner_d_exports as TestRunner };

package/dist/index.mjs

@@ -4,6 +4,6 @@ import { t as Mutant_exports } from "./Mutant.mjs";
 import { t as Plugin_exports } from "./Plugin-DXFdJP1l.mjs";
 import { n as Reporter_exports } from "./Reporter-BWTwlSJf.mjs";
 import { t as Run_exports } from "./Run.mjs";
-import { n as Schema_exports } from "./Schema-CdNkubPi.mjs";
+import { n as Schema_exports } from "./Schema-CMKdWMUN.mjs";
 import { t as TestRunner_exports } from "./TestRunner.mjs";
 export { Checker_exports as Checker, Ignorer_exports as Ignorer, Mutant_exports as Mutant, Plugin_exports as Plugin, Reporter_exports as Reporter, Run_exports as Run, Schema_exports as Schema, TestRunner_exports as TestRunner };

package/dist/provided-options.d.mts

@@ -1,4 +1,4 @@
-import { c as RunConfiguration } from "./Plugin-CunIOPtw.mjs";
+import { c as RunConfiguration } from "./Plugin-BtItMchw.mjs";
 //#region src/provided-options.d.ts
 /**
  * The run's options exactly as the `RunConfiguration` service hands them over.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -19,7 +19,7 @@
   },
   "dependencies": {
     "effect": "4.0.0-rc.112",
-    "@systemfsoftware/effect-cell-types": "^6.0.1"
+    "@systemfsoftware/effect-cell-types": "^7.0.0"
   },
   "devDependencies": {
     "@effect/vitest": "4.0.0-rc.112",
@@ -32,10 +32,10 @@
     "typescript": "^7",
     "vitest": "^4",
     "@systemfsoftware/all": "^2.0.0",
-    "@systemfsoftware/effect-schema-law": "^2.0.2",
-    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@systemfsoftware/effect-schema-law": "^2.1.0",
     "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/effect-schema-vite": "^2.0.3"
+    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@systemfsoftware/effect-schema-vite": "^2.1.0"
   },
   "publishConfig": {
     "access": "public",