@systemfsoftware/stryker-js 0.1.1 → 1.0.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @systemfsoftware/stryker-js
 
+## 1.0.0
+
+### Major Changes
+
+- The console log threshold is now scoped to the run that set it. Two runs in one
+  process no longer share it, so a run that lowers its own level can no longer
+  quieten another run happening alongside it.
+
+  `setEngineLogLevel` is removed. The level travels with the run.
+
+- `runMutationTest` now requires the run-identity services to be provided by the caller; the effect names them in its requirements channel.
+
+- The public Run subpath's shouldKeepTempDir now accepts any failure channel instead of only S.SchemaError; the runMutationTest signature and event surface are unchanged
+
+### Patch Changes
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@6.0.0
+
+## 0.2.0
+
+### Minor Changes
+
+- Plugin code can now ask for the module-loader service instead of touching the host module API: it exposes the same `createRequire`/`isBuiltin` surface as the host module module, and the Node engine supplies it automatically. Plugins that declare their environment through the engine's plugin declaration get the service without extra wiring; upgrades should move the engine and its plugins in the same release.
+
+### Patch Changes
+
+- Refreshed builds on the platform-services dependency graph; the packages no longer reach for host builtins directly. No CLI flags or option names change.
+
 ## 0.1.1
 
 ### Patch Changes

package/README.md

@@ -2,7 +2,7 @@
 
 The mutation-testing language — the plugin kinds, capability ports, and schemas
 a mutation run is built from, with no platform. The Node host that runs a
-mutation test lives in `@systemfsoftware/stryker-js-platform-node`.
+mutation test lives in `@systemfsoftware/stryker-js-engine`.
 
 ## Install
 

package/dist/{Evaluator-DLVXUcVj.d.mts → Evaluator-RZBS4oeh.d.mts}

@@ -1,4 +1,4 @@
-import { t as ExitClass } from "./ExitClass.schema-BmCUn2Sm.mjs";
+import { r as ExitClass } from "./ExitClass.schema-BmOIK5zT.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as schema from "mutation-testing-report-schema/api";

package/dist/Evaluator.d.mts

@@ -1,3 +1,3 @@
-import { n as EvaluatorService, r as EvaluatorFailed, t as Evaluator } from "./Evaluator-DLVXUcVj.mjs";
-import { t as ExitClass } from "./ExitClass.schema-BmCUn2Sm.mjs";
+import { n as EvaluatorService, r as EvaluatorFailed, t as Evaluator } from "./Evaluator-RZBS4oeh.mjs";
+import { r as ExitClass } from "./ExitClass.schema-BmOIK5zT.mjs";
 export { Evaluator, EvaluatorFailed, EvaluatorService, type ExitClass };

package/dist/ExitClass.d.mts

@@ -1,8 +1,9 @@
-import { t as ExitClass } from "./ExitClass.schema-BmCUn2Sm.mjs";
+import { n as ClassifyExitDecision, r as ExitClass, t as ClassifyExitCommand } from "./ExitClass.schema-BmOIK5zT.mjs";
 //#region src/ExitClass.d.ts
 declare const EXIT_CODE: Record<ExitClass, number>;
 declare function verdictExitClass(score: number | null, breakingThreshold: number | null): ExitClass | null;
 declare function highestExitClass(pending: Iterable<ExitClass>): ExitClass | null;
 declare function resolveExitCode(pending: Iterable<ExitClass>, signal: number | null): number;
+declare const classifyExit: (command: ClassifyExitCommand) => ClassifyExitDecision;
 //#endregion
-export { EXIT_CODE, ExitClass, highestExitClass, resolveExitCode, verdictExitClass };
+export { EXIT_CODE, ExitClass, classifyExit, highestExitClass, resolveExitCode, verdictExitClass };

package/dist/ExitClass.mjs

@@ -1,4 +1,5 @@
 import * as S from "effect/Schema";
+import * as Match from "effect/Match";
 //#region src/ExitClass.schema.ts
 const ExitClass = S.Literals([
 	"VerdictFail",
@@ -6,6 +7,16 @@ const ExitClass = S.Literals([
 	"RuntimeError",
 	"InternalError"
 ]);
+S.TaggedClass()("ClassifyExitCommand", {
+	pending: S.Array(ExitClass),
+	signal: S.NullOr(S.Number),
+	score: S.NullOr(S.Number),
+	breakingThreshold: S.NullOr(S.Number)
+});
+var ClassifyExitDecision = class extends S.TaggedClass()("ClassifyExitDecision", {
+	highestClass: S.NullOr(ExitClass),
+	verdictClass: S.NullOr(ExitClass)
+}) {};
 //#endregion
 //#region src/ExitClass.ts
 const EXIT_CODE = {
@@ -30,5 +41,30 @@ function resolveExitCode(pending, signal) {
 	if (highest === null) return 0;
 	return EXIT_CODE[highest];
 }
+const deriveVerdict = (score, breakingThreshold) => {
+	if (score === null || breakingThreshold === null) return null;
+	if (score < breakingThreshold) return "VerdictFail";
+	return null;
+};
+const rank = (value) => Match.value(value).pipe(Match.when("InternalError", () => 4), Match.when("RuntimeError", () => 3), Match.when("ConfigError", () => 2), Match.when("VerdictFail", () => 1), Match.exhaustive);
+const withVerdict = (pending, verdict) => {
+	if (verdict === null) return pending;
+	if (pending.includes(verdict)) return pending;
+	return [...pending, verdict];
+};
+const highestOf = (values) => values.reduce((acc, cur) => {
+	if (acc === null) return cur;
+	if (rank(cur) > rank(acc)) return cur;
+	return acc;
+}, null);
+const classifyExit = (command) => {
+	const verdictClass = deriveVerdict(command.score, command.breakingThreshold);
+	const pendingWithVerdict = withVerdict(command.pending, verdictClass);
+	const highestClass = highestOf(pendingWithVerdict);
+	return ClassifyExitDecision.make({
+		highestClass,
+		verdictClass
+	});
+};
 //#endregion
-export { EXIT_CODE, ExitClass, highestExitClass, resolveExitCode, verdictExitClass };
+export { EXIT_CODE, ExitClass, classifyExit, highestExitClass, resolveExitCode, verdictExitClass };

package/dist/ExitClass.schema-BmOIK5zT.d.mts

@@ -0,0 +1,18 @@
+import * as S from "effect/Schema";
+//#region src/ExitClass.schema.d.ts
+declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
+type ExitClass = typeof ExitClass.Type;
+declare const ClassifyExitCommand_base: S.Class<ClassifyExitCommand, S.TaggedStruct<"ClassifyExitCommand", {
+  readonly pending: S.$Array<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
+  readonly signal: S.NullOr<S.Number>;
+  readonly score: S.NullOr<S.Number>;
+  readonly breakingThreshold: S.NullOr<S.Number>;
+}>, {}>;
+declare class ClassifyExitCommand extends ClassifyExitCommand_base {}
+declare const ClassifyExitDecision_base: S.Class<ClassifyExitDecision, S.TaggedStruct<"ClassifyExitDecision", {
+  readonly highestClass: S.NullOr<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
+  readonly verdictClass: S.NullOr<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
+}>, {}>;
+declare class ClassifyExitDecision extends ClassifyExitDecision_base {}
+//#endregion
+export { ClassifyExitDecision as n, ExitClass as r, ClassifyExitCommand as t };

package/dist/Module-DHKEMAFI.d.mts

@@ -0,0 +1,31 @@
+import * as Context from "effect/Context";
+//#region src/Module.d.ts
+/**
+ * The subset of `node:module`'s `createRequire` result this port certifies: a
+ * require function bound to one path, plus its resolution. Calling it loads
+ * the specifier exactly as a module evaluated next to that path would.
+ */
+interface ModuleRequire {
+  (request: string): unknown;
+  resolve(request: string, options?: {
+    readonly paths?: readonly string[];
+  }): string;
+}
+declare const Module_base: Context.ServiceClass<Module, "@systemfsoftware/stryker-js/Module", {
+  readonly createRequire: (filename: string | URL) => ModuleRequire;
+  readonly isBuiltin: (moduleName: string) => boolean;
+}>;
+/**
+ * Port over the host module loader, shaped as the subset of `node:module`
+ * feature code may use: `createRequire` and `isBuiltin`. Resolving a
+ * specifier against a project directory, importing a plugin, and asking
+ * whether a name is a builtin all go through this one tag; no feature module
+ * touches the host module API. The Node implementation ships in the
+ * composition-root package (`@systemfsoftware/stryker-js-cli`); tests that do
+ * not need real plugin resolution substitute a layer returning fixed paths.
+ *
+ * @since 2.0.0
+ */
+declare class Module extends Module_base {}
+//#endregion
+export { ModuleRequire as n, Module as t };

package/dist/Module.d.mts

@@ -0,0 +1,2 @@
+import { n as ModuleRequire, t as Module } from "./Module-DHKEMAFI.mjs";
+export { Module, ModuleRequire };

package/dist/Module.mjs

@@ -0,0 +1,16 @@
+import * as Context from "effect/Context";
+//#region src/Module.ts
+/**
+* Port over the host module loader, shaped as the subset of `node:module`
+* feature code may use: `createRequire` and `isBuiltin`. Resolving a
+* specifier against a project directory, importing a plugin, and asking
+* whether a name is a builtin all go through this one tag; no feature module
+* touches the host module API. The Node implementation ships in the
+* composition-root package (`@systemfsoftware/stryker-js-cli`); tests that do
+* not need real plugin resolution substitute a layer returning fixed paths.
+*
+* @since 2.0.0
+*/
+var Module = class extends Context.Service()("@systemfsoftware/stryker-js/Module") {};
+//#endregion
+export { Module };

package/dist/{Plugin-DypwaPHd.d.mts → Plugin-DcDAIBQi.d.mts}

@@ -1,7 +1,8 @@
 import { n as Checker } from "./Checker-DYgIIEai.mjs";
 import { J as TestRunner } from "./Mutant-BPRJTF8f.mjs";
-import { t as Evaluator } from "./Evaluator-DLVXUcVj.mjs";
+import { t as Evaluator } from "./Evaluator-RZBS4oeh.mjs";
 import { t as Ignorer } from "./Ignorer-BUY68FZQ.mjs";
+import { t as Module } from "./Module-DHKEMAFI.mjs";
 import { c as Reporter } from "./Reporter-eZ3M7lO6.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
@@ -118,7 +119,7 @@ interface PluginInterfaces {
   Ignore: Ignorer;
   Evaluator: Evaluator;
 }
-type PluginEnvironment = RunConfiguration | SandboxDirectory | FileSystem.FileSystem | Path.Path;
+type PluginEnvironment = RunConfiguration | SandboxDirectory | FileSystem.FileSystem | Module | Path.Path;
 type AnyPluginContribution = { [K in PluginKind]: PluginContribution<K>; }[PluginKind];
 type ContributionOf<K extends PluginKind> = Extract<AnyPluginContribution, {
   readonly kind: K;

package/dist/Plugin.d.mts

@@ -1,2 +1,2 @@
-import { a as PluginEnvironment, c as RunConfiguration, d as declarePlugin, f as PluginContribution, i as MergedPluginServices, l as SandboxDirectory, m as Shadowing, n as ComposedPlugins, o as PluginInterfaces, p as PluginKind, r as ContributionOf, t as AnyPluginContribution, u as composePlugins } from "./Plugin-DypwaPHd.mjs";
+import { a as PluginEnvironment, c as RunConfiguration, d as declarePlugin, f as PluginContribution, i as MergedPluginServices, l as SandboxDirectory, m as Shadowing, n as ComposedPlugins, o as PluginInterfaces, p as PluginKind, r as ContributionOf, t as AnyPluginContribution, u as composePlugins } from "./Plugin-DcDAIBQi.mjs";
 export { AnyPluginContribution, ComposedPlugins, ContributionOf, MergedPluginServices, PluginContribution, PluginEnvironment, PluginInterfaces, PluginKind, RunConfiguration, SandboxDirectory, Shadowing, composePlugins, declarePlugin };

package/dist/{Run-lXratlN7.mjs → Run-BcDo-hIC.mjs}

@@ -2,10 +2,9 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as Effect from "effect/Effect";
-import { Cell, Wire, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Exit from "effect/Exit";
-import { pipe } from "effect/Function";
 import * as Result from "effect/Result";
+import { Wire } from "@systemfsoftware/effect-cell-types";
 //#region src/Run.schema.ts
 const RunPhase = S.Literals([
 	"prepare",
@@ -137,8 +136,6 @@ var RunOutput = class extends S.TaggedClass()("RunOutput", {
 S.TaggedError()("RunDecodeError", { message: S.String });
 S.TaggedError()("RunReadError", { message: S.String });
 S.TaggedError()("RunWriteError", { message: S.String });
-//#endregion
-//#region src/Run.workflow.ts
 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))),
@@ -149,27 +146,6 @@ 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)))
 }) {};
-S.TaggedError()("PlanMutationRunError", {
-	message: S.String,
-	detail: S.String
-});
-const selectMutatePatterns = (target, fallback) => {
-	if (target.length > 0) return [...target];
-	return [...fallback];
-};
-const selectMutatorNames = (available, fallback) => {
-	if (available.length > 0) return [...available];
-	return [...fallback];
-};
-const decidePlan = (command) => {
-	const mutatePatterns = selectMutatePatterns(command.targetMutatePatterns, command.configMutatePatterns);
-	const mutatorNames = selectMutatorNames(command.availableMutators, command.configMutatorNames);
-	return Result.succeed(MutationRunPlan.make({
-		mutatePatterns,
-		mutatorNames
-	}));
-};
-const planMutationRun = Workflow.make(PlanMutationRunCommand, (command) => decidePlan(command));
 //#endregion
 //#region src/Run.ts
 var Run_exports = /* @__PURE__ */ __exportAll({
@@ -189,37 +165,35 @@ var Run_exports = /* @__PURE__ */ __exportAll({
 	RunPhase: () => RunPhase,
 	RunStarted: () => RunStarted,
 	VerdictReached: () => VerdictReached,
+	planMutationRun: () => planMutationRun,
 	runMutationTest: () => runMutationTest,
 	shouldKeepTempDir: () => shouldKeepTempDir
 });
-/**
-* Where a run's events go.
-*
-* The error channel carries `Cause.Done`, the graceful completion signal: a finished run
-* ends the queue, and `Stream.fromQueue` excludes `Done` from its own error channel, so the
-* consumer sees end-of-stream. Interrupting the queue instead would end it with an
-* interrupt cause, and joining the drain would then re-raise that into the caller and lose
-* the exit code the run had already decided.
-*/
+const firstNonEmpty = (preferred, fallback) => {
+	if (preferred.length > 0) return [...preferred];
+	return [...fallback];
+};
+const planMutationRun = (command) => MutationRunPlan.make({
+	mutatePatterns: firstNonEmpty(command.targetMutatePatterns, command.configMutatePatterns),
+	mutatorNames: firstNonEmpty(command.availableMutators, command.configMutatorNames)
+});
 var RunEvents = class extends Context.Service()("~@systemfsoftware/stryker-js/RunEvents") {};
 var RunIdentity = class extends Context.Service()("~@systemfsoftware/stryker-js/RunIdentity") {};
-const mutationRunDescription = (io, services) => pipe(Cell.read((command) => Effect.provideContext(io.read(command), services)), Cell.decode((raw) => S.decodeUnknownResult(PlanMutationRunCommand)(raw)), Cell.decide(planMutationRun), Cell.encode((outcome) => Result.match(outcome, {
-	onFailure: (error) => new RunOutput({
-		verdictJson: JSON.stringify({ error: error.message }),
-		exitCode: 1
-	}),
-	onSuccess: (plan) => new RunOutput({
+const runMutationTest = (io, command) => Effect.gen(function* () {
+	const raw = yield* io.read(command);
+	const planCommand = yield* Result.match(S.decodeUnknownResult(PlanMutationRunCommand)(raw), {
+		onFailure: (error) => Effect.fail(error),
+		onSuccess: (decoded) => Effect.succeed(decoded)
+	});
+	const plan = planMutationRun(planCommand);
+	return yield* io.write(new RunOutput({
 		verdictJson: JSON.stringify({
 			mutate: plan.mutatePatterns,
-			mutators: plan.mutatorNames
+			mutatorNames: plan.mutatorNames
 		}),
 		exitCode: 0
-	})
-})), Cell.write((output) => Effect.provideContext(io.write(output), services)));
-const runMutationTest = (io, command) => Effect.gen(function* () {
-	const services = yield* Effect.context();
-	return yield* Cell.apply(mutationRunDescription(io, services), command);
+	}));
 });
 const shouldKeepTempDir = (exit, cleanTempDir) => Exit.isFailure(exit) && cleanTempDir !== "always";
 //#endregion
-export { RunPhase as _, shouldKeepTempDir as a, ManifestRendered as c, MutantTested as d, OutputMode as f, RunFailed as g, RunEvent as h, runMutationTest as i, ModeSignal as l, PlanKnown as m, RunIdentity as n, Heartbeat as o, PhaseEntered as p, Run_exports as r, HelpRendered as s, RunEvents as t, MutantStatus as u, RunStarted as v, VerdictReached as y };
+export { RunFailed as _, runMutationTest as a, VerdictReached as b, HelpRendered as c, MutantStatus as d, MutantTested as f, RunEvent as g, PlanKnown as h, planMutationRun as i, ManifestRendered as l, PhaseEntered as m, RunIdentity as n, shouldKeepTempDir as o, OutputMode as p, Run_exports as r, Heartbeat as s, RunEvents as t, ModeSignal as u, RunPhase as v, RunStarted as y };

package/dist/{Run-BudLsVwF.d.mts → Run-BnmGGgWj.d.mts}

@@ -1,9 +1,8 @@
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as Effect from "effect/Effect";
-import { Wire, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Exit from "effect/Exit";
-import "effect/Result";
+import { Wire } from "@systemfsoftware/effect-cell-types";
 import * as Cause from "effect/Cause";
 import * as Queue from "effect/Queue";
 //#region src/Run.schema.d.ts
@@ -146,26 +145,23 @@ declare const RunOutput_base: S.Class<RunOutput, S.TaggedStruct<"RunOutput", {
   readonly exitCode: S.Finite;
 }>, {}>;
 declare class RunOutput extends RunOutput_base {}
-//#endregion
-//#region src/Run.workflow.d.ts
-declare const PlanMutationRunError_base: S.Class<PlanMutationRunError, S.TaggedStruct<"PlanMutationRunError", {
-  readonly message: S.String;
-  readonly detail: S.String;
-}>, import("effect/Cause").YieldableError>;
-declare class PlanMutationRunError extends PlanMutationRunError_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;
+}>, {}>;
+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;
+}>, {}>;
+declare class MutationRunPlan extends MutationRunPlan_base {}
 declare namespace Run_d_exports {
-  export { Heartbeat, HelpRendered, Location, ManifestRendered, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, Position, RunEvent, RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, RunTerminalEvent, VerdictReached, runMutationTest, shouldKeepTempDir };
+  export { Heartbeat, HelpRendered, Location, ManifestRendered, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, Position, RunEvent, RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, RunTerminalEvent, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir };
 }
+declare const planMutationRun: (command: PlanMutationRunCommand) => MutationRunPlan;
 declare const RunEvents_base: Context.ServiceClass<RunEvents, "~@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | ManifestRendered | MutantTested | PhaseEntered | PlanKnown | RunFailed | RunStarted | VerdictReached, Cause.Done<void>>>;
-/**
- * Where a run's events go.
- *
- * The error channel carries `Cause.Done`, the graceful completion signal: a finished run
- * ends the queue, and `Stream.fromQueue` excludes `Done` from its own error channel, so the
- * consumer sees end-of-stream. Interrupting the queue instead would end it with an
- * interrupt cause, and joining the drain would then re-raise that into the caller and lose
- * the exit code the run had already decided.
- */
 declare class RunEvents extends RunEvents_base {}
 interface RunIdentityShape {
   readonly runId: string;
@@ -178,6 +174,6 @@ interface MutationRunIo {
   readonly write: (output: RunOutput) => Effect.Effect<void, S.SchemaError, RunIdentity>;
 }
 declare const runMutationTest: (io: MutationRunIo, command: RunCommand) => Effect.Effect<void, S.SchemaError, RunIdentity>;
-declare const shouldKeepTempDir: (exit: Exit.Exit<void, PlanMutationRunError | S.SchemaError>, cleanTempDir: 'always' | boolean) => boolean;
+declare const shouldKeepTempDir: (exit: Exit.Exit<void, unknown>, cleanTempDir: 'always' | boolean) => boolean;
 //#endregion
-export { RunTerminalEvent as C, RunStarted as S, PlanKnown as _, Run_d_exports as a, RunFailed as b, Heartbeat as c, ManifestRendered as d, ModeSignal as f, PhaseEntered as g, OutputMode as h, RunIdentityShape as i, HelpRendered as l, MutantTested as m, RunEvents as n, runMutationTest as o, MutantStatus as p, RunIdentity as r, shouldKeepTempDir as s, MutationRunIo as t, Location as u, Position as v, VerdictReached as w, RunPhase as x, RunEvent as y };
+export { RunStarted as C, RunPhase as S, VerdictReached as T, PhaseEntered as _, Run_d_exports as a, RunEvent as b, shouldKeepTempDir as c, Location as d, ManifestRendered as f, OutputMode as g, MutantTested as h, RunIdentityShape as i, Heartbeat as l, MutantStatus as m, RunEvents as n, planMutationRun as o, ModeSignal as p, RunIdentity as r, runMutationTest as s, MutationRunIo as t, HelpRendered as u, PlanKnown as v, RunTerminalEvent as w, RunFailed as x, Position as y };

package/dist/Run.d.mts

@@ -1,2 +1,2 @@
-import { C as RunTerminalEvent, S as RunStarted, _ as PlanKnown, b as RunFailed, c as Heartbeat, d as ManifestRendered, f as ModeSignal, g as PhaseEntered, h as OutputMode, i as RunIdentityShape, l as HelpRendered, m as MutantTested, n as RunEvents, o as runMutationTest, p as MutantStatus, r as RunIdentity, s as shouldKeepTempDir, t as MutationRunIo, u as Location, v as Position, w as VerdictReached, x as RunPhase, y as RunEvent } from "./Run-BudLsVwF.mjs";
-export { Heartbeat, HelpRendered, type Location, ManifestRendered, ModeSignal, MutantStatus, MutantTested, MutationRunIo, OutputMode, PhaseEntered, PlanKnown, type Position, RunEvent, type RunEvent as RunEventType, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunPhase, RunStarted, type RunTerminalEvent, VerdictReached, runMutationTest, shouldKeepTempDir };
+import { C as RunStarted, S as RunPhase, T as VerdictReached, _ as PhaseEntered, b as RunEvent, c as shouldKeepTempDir, d as Location, f as ManifestRendered, g as OutputMode, h as MutantTested, i as RunIdentityShape, l as Heartbeat, m as MutantStatus, n as RunEvents, o as planMutationRun, p as ModeSignal, r as RunIdentity, s as runMutationTest, t as MutationRunIo, u as HelpRendered, v as PlanKnown, w as RunTerminalEvent, x as RunFailed, y as Position } from "./Run-BnmGGgWj.mjs";
+export { Heartbeat, HelpRendered, type Location, ManifestRendered, 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,2 +1,2 @@
-import { _ as RunPhase, a as shouldKeepTempDir, c as ManifestRendered, d as MutantTested, f as OutputMode, g as RunFailed, h as RunEvent, i as runMutationTest, l as ModeSignal, m as PlanKnown, n as RunIdentity, o as Heartbeat, p as PhaseEntered, s as HelpRendered, t as RunEvents, u as MutantStatus, v as RunStarted, y as VerdictReached } from "./Run-lXratlN7.mjs";
-export { Heartbeat, HelpRendered, ManifestRendered, ModeSignal, MutantStatus, MutantTested, OutputMode, PhaseEntered, PlanKnown, RunEvent, RunEvents, RunFailed, RunIdentity, RunPhase, RunStarted, VerdictReached, runMutationTest, shouldKeepTempDir };
+import { _ as RunFailed, a as runMutationTest, b as VerdictReached, c as HelpRendered, d as MutantStatus, f as MutantTested, g as RunEvent, h as PlanKnown, i as planMutationRun, l as ManifestRendered, m as PhaseEntered, n as RunIdentity, o as shouldKeepTempDir, p as OutputMode, s as Heartbeat, t as RunEvents, u as ModeSignal, v as RunPhase, y as RunStarted } from "./Run-BcDo-hIC.mjs";
+export { Heartbeat, HelpRendered, ManifestRendered, ModeSignal, MutantStatus, MutantTested, OutputMode, PhaseEntered, PlanKnown, RunEvent, RunEvents, RunFailed, RunIdentity, RunPhase, RunStarted, VerdictReached, planMutationRun, runMutationTest, shouldKeepTempDir };

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

@@ -103,12 +103,14 @@ const WarningOptions = openStruct({
 	unserializableOptions: defaulted(Wire.mint(S.Boolean), true),
 	slow: defaulted(Wire.mint(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 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([Wire.mint(Wire.mint(S.Finite).pipe(S.check(S.isGreaterThanOrEqualTo(1)))), Wire.mint(Wire.mint(S.String).pipe(S.check(S.isPattern(/^(100|[1-9]?[0-9])%$/))))]))),
+	concurrency: S.optional(Wire.mint(S.Union([ConcurrencyCount, ConcurrencyPercent]))),
 	commandRunner: defaulted(CommandRunnerOptionsSchema, { command: "npm test" }),
 	coverageAnalysis: defaulted(CoverageAnalysisMode, RENDERED_OPTION_DEFAULTS$1.coverageAnalysis),
 	clearTextReporter: defaulted(ClearTextReporterOptions, {

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-BAKDG_jC.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-CdNkubPi.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-DYgIIEai.mjs";
 import { Z as TestRunner_d_exports, v as Mutant_d_exports } from "./Mutant-BPRJTF8f.mjs";
 import { r as Ignorer_d_exports } from "./Ignorer-BUY68FZQ.mjs";
-import { s as Plugin_d_exports } from "./Plugin-DypwaPHd.mjs";
+import { s as Plugin_d_exports } from "./Plugin-DcDAIBQi.mjs";
 import { u as Reporter_d_exports } from "./Reporter-eZ3M7lO6.mjs";
-import { a as Run_d_exports } from "./Run-BudLsVwF.mjs";
+import { a as Run_d_exports } from "./Run-BnmGGgWj.mjs";
 import { a as Schema_d_exports } from "./Schema-CXKiLnTu.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

@@ -3,7 +3,7 @@ import { t as Ignorer_exports } from "./Ignorer.mjs";
 import { t as Mutant_exports } from "./Mutant.mjs";
 import { t as Plugin_exports } from "./Plugin-Ceh1G8Dz.mjs";
 import { n as Reporter_exports } from "./Reporter-COVWW1my.mjs";
-import { r as Run_exports } from "./Run-lXratlN7.mjs";
-import { n as Schema_exports } from "./Schema-BAKDG_jC.mjs";
+import { r as Run_exports } from "./Run-BcDo-hIC.mjs";
+import { n as Schema_exports } from "./Schema-CdNkubPi.mjs";
 import { n as TestRunner_exports } from "./TestRunner-DC9U8Unb.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-DypwaPHd.mjs";
+import { c as RunConfiguration } from "./Plugin-DcDAIBQi.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": "0.1.1",
+  "version": "1.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -20,7 +20,7 @@
   "dependencies": {
     "effect": "^4.0.0-rc.112",
     "mutation-testing-report-schema": "3.7.3",
-    "@systemfsoftware/effect-cell-types": "^5.0.2"
+    "@systemfsoftware/effect-cell-types": "^6.0.0"
   },
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
@@ -31,10 +31,10 @@
     "tsdown": "^0.22.14",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/all": "^1.0.2",
-    "@systemfsoftware/tsconfig": "^1.3.3",
     "@systemfsoftware/effect-schema-law": "^2.0.1",
     "@systemfsoftware/effect-schema-vite": "^2.0.2",
+    "@systemfsoftware/all": "^1.1.2",
+    "@systemfsoftware/tsconfig": "^1.3.3",
     "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "publishConfig": {
@@ -47,6 +47,7 @@
     "./Evaluator": "./dist/Evaluator.mjs",
     "./ExitClass": "./dist/ExitClass.mjs",
     "./Ignorer": "./dist/Ignorer.mjs",
+    "./Module": "./dist/Module.mjs",
     "./Mutant": "./dist/Mutant.mjs",
     "./output-file": "./dist/output-file.mjs",
     "./Plugin": "./dist/Plugin.mjs",

package/dist/ExitClass.schema-BmCUn2Sm.d.mts

@@ -1,6 +0,0 @@
-import * as S from "effect/Schema";
-//#region src/ExitClass.schema.d.ts
-declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
-type ExitClass = typeof ExitClass.Type;
-//#endregion
-export { ExitClass as t };