@systemfsoftware/stryker-js-cli 4.0.2 → 5.0.0

package/dist/node-D-ynY_kk.mjs

@@ -0,0 +1,105 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
+import { ChildProcessCrashedError, WorkerEntries, WorkerLauncher } from "@systemfsoftware/stryker-js-engine";
+import * as FileSystem from "effect/FileSystem";
+import * as Match from "effect/Match";
+import * as Path from "effect/Path";
+import { NodeFileSystem, NodePath, NodeSocket } from "@effect/platform-node";
+import { Module } from "@systemfsoftware/stryker-js/Module";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+//#region src/platform/node.ts
+const makeModuleRequire = (nodeModule, filename) => {
+	const requireFrom = nodeModule.createRequire(filename);
+	const requireFn = (request) => requireFrom(request);
+	requireFn.resolve = (request, options) => {
+		if (options === void 0) return requireFrom.resolve(request);
+		return requireFrom.resolve(request, { paths: [...options.paths ?? []] });
+	};
+	return requireFn;
+};
+/**
+* The Node implementation of the {@link Module} port: every call routes
+* through the runtime's own `node:module` via `process.getBuiltinModule`, so
+* this package imports no host builtins and the import ban holds here too.
+*/
+const nodeModuleLayer = Layer.effect(Module, Effect.sync(() => {
+	const nodeModule = process.getBuiltinModule("node:module");
+	return {
+		createRequire: (filename) => makeModuleRequire(nodeModule, filename),
+		isBuiltin: (moduleName) => nodeModule.isBuiltin(moduleName)
+	};
+}));
+/**
+* The worker entries this package's own build emits. The engine spawns by
+* address; this process package knows its dist layout and hands the
+* addresses in.
+*/
+const workerEntriesLayer = Layer.succeed(WorkerEntries, {
+	checkerWorkerUrl: new URL("./workers/checker-worker.mjs", import.meta.url),
+	testRunnerWorkerUrl: new URL("./workers/child-process-test-runner-worker.mjs", import.meta.url)
+});
+/**
+* The Node worker launcher: spawn a worker child with this runtime's
+* executable, host the RPC server's address as a `net` `path` endpoint (a
+* socket file in the worker directory on POSIX, a same-user named pipe on
+* Windows), and connect the NDJSON protocol client over `NodeSocket`.
+*/
+const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	return { spawn: (params) => Effect.gen(function* () {
+		const workerDir = yield* fs.makeTempDirectoryScoped({ prefix: params.tempDirPrefix });
+		const socketPath = Match.value(process.platform).pipe(Match.when("win32", () => `\\\\.\\pipe\\stryker-worker-${globalThis.crypto.randomUUID()}`), Match.orElse(() => path.join(workerDir, "worker.sock")));
+		yield* fs.writeFileString(path.join(workerDir, "options.json"), params.optionsJson);
+		const entryPath = yield* path.fromFileUrl(params.entryUrl);
+		const handle = yield* ChildProcess.make(process.execPath, [...params.execArgv, entryPath], {
+			cwd: params.workingDirectory,
+			extendEnv: true,
+			env: {
+				STRYKER_WORKER_DIR: workerDir,
+				STRYKER_SOCKET: socketPath
+			},
+			stderr: "inherit"
+		}).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
+		const clientLayer = RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(Layer.provide(NodeSocket.layerNet({ path: socketPath })), Layer.provide(RpcSerialization.layerNdjson));
+		const exited = handle.exitCode.pipe(Effect.orDie, Effect.flatMap((exitCode) => Effect.fail(new ChildProcessCrashedError({
+			pid: Number(handle.pid),
+			exit: {
+				_tag: "Code",
+				code: exitCode
+			},
+			cause: "worker exited before it accepted the RPC connection"
+		}))));
+		return {
+			pid: Number(handle.pid),
+			clientLayer,
+			exited
+		};
+	}).pipe(Effect.catch((error) => {
+		if (error instanceof ChildProcessCrashedError) return Effect.fail(error);
+		return Effect.fail(new ChildProcessCrashedError({
+			pid: 0,
+			exit: {
+				_tag: "Code",
+				code: 1
+			},
+			cause: "worker spawn failed"
+		}));
+	})) };
+}));
+const nodeFsPathLayer = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer);
+const nodeSpawnerLayer = NodeChildProcessSpawner.layer.pipe(Layer.provide(nodeFsPathLayer));
+const nodeBase = Layer.merge(nodeFsPathLayer, nodeSpawnerLayer);
+/**
+* Every port the engine requires, provided from this runtime: the file
+* system, the path service, the module loader, the child-process spawner,
+* the worker launcher, and this build's worker entry addresses.
+*/
+const nodePlatformLayer = Layer.mergeAll(nodeModuleLayer, workerEntriesLayer, nodeWorkerLauncherLayer.pipe(Layer.provide(nodeBase)), nodeBase);
+//#endregion
+export { nodePlatformLayer as n, nodeModuleLayer as t };

package/dist/worker-runtime-CT5LMMgY.mjs

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Cause from "effect/Cause";
+//#region src/workers/worker-runtime.ts
+const workerSocketPath = (label) => {
+	const socketPath = process.env["STRYKER_SOCKET"];
+	if (socketPath === void 0) {
+		process.stderr.write(`${label}: STRYKER_SOCKET is not set\n`);
+		process.exit(1);
+	}
+	return socketPath;
+};
+const launchWorker = (main, label) => {
+	Effect.runFork(Layer.launch(main).pipe(Effect.tapCause((cause) => Effect.sync(() => {
+		process.stderr.write(`${label}: ${Cause.pretty(cause)}\n`);
+		process.exitCode = 1;
+	}))));
+};
+//#endregion
+export { workerSocketPath as n, launchWorker as t };

package/dist/workers/checker-worker.mjs

@@ -0,0 +1,53 @@
+import { t as nodeModuleLayer } from "../node-D-ynY_kk.mjs";
+import { n as workerSocketPath, t as launchWorker } from "../worker-runtime-CT5LMMgY.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import { NodeFileSystem, NodePath, NodeSocketServer } from "@effect/platform-node";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import { Checker, CheckerFailed } from "@systemfsoftware/stryker-js/Checker";
+import { RunConfiguration, SandboxDirectory } from "@systemfsoftware/stryker-js/Plugin";
+import * as HashMap from "effect/HashMap";
+import * as RpcServer from "effect/unstable/rpc/RpcServer";
+import { CheckerRpcs, create, decodeWorkerOptions, loadPlugins } from "@systemfsoftware/stryker-js-engine/worker";
+//#region src/workers/Checker.worker.ts
+const buildChecker = (contribution, options) => Checker.pipe(Effect.provide(contribution.layer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(RunConfiguration, options), Layer.succeed(SandboxDirectory, process.cwd()), NodeFileSystem.layer, NodePath.layer, nodeModuleLayer)))));
+const mutantIdsOf = (mutants) => mutants.map((mutant) => mutant.id);
+const readWorkerOptions = Effect.gen(function* () {
+	const workerDir = process.env["STRYKER_WORKER_DIR"] ?? (yield* Effect.die(/* @__PURE__ */ new Error("STRYKER_WORKER_DIR is not set")));
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const raw = yield* fs.readFileString(path.join(workerDir, "options.json"));
+	return yield* decodeWorkerOptions(raw);
+});
+const CheckerHandlers = CheckerRpcs.toLayer(Effect.gen(function* () {
+	const options = yield* readWorkerOptions;
+	const loaded = yield* loadPlugins(options.plugins, process.cwd());
+	const checkers = HashMap.fromIterable(yield* Effect.forEach(options.checkers, (name) => Effect.gen(function* () {
+		const contribution = yield* create(loaded.pluginsByKind, "Checker", name);
+		const checker = yield* buildChecker(contribution, options);
+		yield* checker.init;
+		return [name, checker];
+	}), {
+		concurrency: "unbounded",
+		discard: false
+	}));
+	const resolve = (checkerName, mutants) => Option.match(HashMap.get(checkers, checkerName), {
+		onNone: () => Effect.fail(new CheckerFailed({
+			cause: `Checker ${checkerName} does not exist`,
+			checkerName,
+			mutantIds: mutantIdsOf(mutants)
+		})),
+		onSome: (checker) => Effect.succeed(checker)
+	});
+	return {
+		check: ({ checkerName, mutants }) => resolve(checkerName, mutants).pipe(Effect.flatMap((checker) => checker.check([...mutants])), Effect.map((resultMap) => Object.fromEntries(resultMap))),
+		group: ({ checkerName, mutants }) => resolve(checkerName, mutants).pipe(Effect.flatMap((checker) => checker.group([...mutants])))
+	};
+})).pipe(Layer.provide(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)));
+const MainLayer = RpcServer.layer(CheckerRpcs).pipe(Layer.provide(CheckerHandlers), Layer.provide(RpcServer.layerProtocolSocketServer), Layer.provide(RpcSerialization.layerNdjson), Layer.provide(NodeSocketServer.layer({ path: workerSocketPath("checker worker") })), Layer.provide(nodeModuleLayer));
+launchWorker(MainLayer, "checker worker");
+//#endregion
+export {};

package/dist/workers/child-process-test-runner-worker.mjs

@@ -0,0 +1,67 @@
+import { t as nodeModuleLayer } from "../node-D-ynY_kk.mjs";
+import { n as workerSocketPath, t as launchWorker } from "../worker-runtime-CT5LMMgY.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { errorToString } from "@systemfsoftware/stryker-js/Mutant";
+import * as Cause from "effect/Cause";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { NodeFileSystem, NodePath, NodeSocketServer } from "@effect/platform-node";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import { RunConfiguration, SandboxDirectory } from "@systemfsoftware/stryker-js/Plugin";
+import * as RpcServer from "effect/unstable/rpc/RpcServer";
+import { MutantCoverageSchema, TestRunnerRpcs, create, decodeWorkerOptions, loadPlugins } from "@systemfsoftware/stryker-js-engine/worker";
+import { TestRunner, TestRunnerFailed } from "@systemfsoftware/stryker-js/TestRunner";
+import { Schema } from "effect";
+//#region src/workers/child-process-test-runner-worker.ts
+const withCoverage = (result, options) => Effect.gen(function* () {
+	if (result.status === "error") return {
+		...result,
+		errorMessage: errorToString(result.errorMessage)
+	};
+	if (result.status !== "complete") return result;
+	if (result.mutantCoverage !== void 0) return result;
+	if (options.coverageAnalysis === "off") return result;
+	const decoded = yield* Schema.decodeUnknownEffect(Schema.optional(MutantCoverageSchema))(globalThis.__mutantCoverage__).pipe(Effect.orElseSucceed(() => void 0));
+	if (decoded === void 0) return result;
+	return {
+		...result,
+		mutantCoverage: decoded
+	};
+});
+const normalizeMutantRun = (result) => {
+	if (result.status === "error") return {
+		...result,
+		errorMessage: errorToString(result.errorMessage)
+	};
+	return result;
+};
+const readWorkerOptions = Effect.gen(function* () {
+	const workerDir = process.env["STRYKER_WORKER_DIR"] ?? (yield* Effect.die(/* @__PURE__ */ new Error("STRYKER_WORKER_DIR is not set")));
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const raw = yield* fs.readFileString(path.join(workerDir, "options.json"));
+	return yield* decodeWorkerOptions(raw);
+});
+const TestRunnerHandlers = TestRunnerRpcs.toLayer(Effect.gen(function* () {
+	const options = yield* readWorkerOptions;
+	const runnerName = options.testRunner;
+	const failed = (phase) => (cause) => Effect.fail(new TestRunnerFailed({
+		cause: Cause.pretty(cause),
+		phase,
+		runnerName
+	}));
+	const loaded = yield* loadPlugins(options.plugins, process.cwd()).pipe(Effect.catchCause(failed("init")));
+	const underlying = yield* create(loaded.pluginsByKind, "TestRunner", runnerName).pipe(Effect.flatMap((contribution) => TestRunner.pipe(Effect.provide(contribution.layer))), Effect.provide(Layer.merge(Layer.succeed(RunConfiguration, options), Layer.succeed(SandboxDirectory, process.cwd()))), Effect.catchCause(failed("init")));
+	yield* underlying.init.pipe(Effect.catchCause(failed("init")));
+	yield* Effect.addFinalizer(() => underlying.dispose.pipe(Effect.ignore));
+	return {
+		capabilities: () => underlying.capabilities.pipe(Effect.catchCause(failed("capabilities"))),
+		dryRun: ({ options: runOptions }) => underlying.dryRun(runOptions).pipe(Effect.flatMap((result) => withCoverage(result, runOptions)), Effect.catchCause(failed("dryRun"))),
+		mutantRun: ({ options: runOptions }) => underlying.mutantRun(runOptions).pipe(Effect.map(normalizeMutantRun), Effect.catchCause(failed("mutantRun")))
+	};
+})).pipe(Layer.provide(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)));
+const MainLayer = RpcServer.layer(TestRunnerRpcs).pipe(Layer.provide(TestRunnerHandlers), Layer.provide(RpcServer.layerProtocolSocketServer), Layer.provide(RpcSerialization.layerNdjson), Layer.provide(NodeSocketServer.layer({ path: workerSocketPath("test runner worker") })), Layer.provide(nodeModuleLayer));
+launchWorker(MainLayer, "test runner worker");
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-cli",
-  "version": "4.0.2",
+  "version": "5.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -18,32 +18,33 @@
     "@effect/platform-node-shared": "^4.0.0-rc.112",
     "@noble/hashes": "1.8.0",
     "effect": "^4.0.0-rc.112",
-    "@systemfsoftware/effect-cell-types": "^5.0.2",
-    "@systemfsoftware/stryker-js-html-reporter": "^0.1.1",
-    "@systemfsoftware/stryker-js": "^0.1.1",
-    "@systemfsoftware/stryker-js-platform-node": "^0.1.2"
+    "@systemfsoftware/effect-cell-types": "^6.0.0",
+    "@systemfsoftware/stryker-js-engine": "^0.2.0",
+    "@systemfsoftware/stryker-js": "^1.0.0",
+    "@systemfsoftware/stryker-js-html-reporter": "^1.0.0"
   },
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
     "@types/node": "^24",
     "@vitest/coverage-v8": "^4",
+    "mutation-testing-report-schema": "3.7.3",
     "oxlint": "^1.77.0",
     "rimraf": "^6.1.3",
     "testcontainers": "^12.1.0",
     "tsdown": "^0.22.14",
     "vite-tsconfig-paths": "^6.1.1",
     "vitest": "^4",
-    "@systemfsoftware/all": "^1.0.2",
+    "@systemfsoftware/all": "^1.1.2",
     "@systemfsoftware/effect-gherkin-spec": "^4.0.0",
     "@systemfsoftware/effect-schema-law": "^2.0.1",
     "@systemfsoftware/effect-schema-vite": "^2.0.2",
-    "@systemfsoftware/stryker-js-typescript-checker": "^3.0.2",
-    "@systemfsoftware/stryker-js-vitest-runner": "^2.0.2",
-    "@systemfsoftware/stryker-test-contribution": "^1.1.1",
-    "@systemfsoftware/stryker-plugins": "^2.0.0",
-    "@systemfsoftware/oxlint-config": "^0.1.0",
+    "@systemfsoftware/stryker-js-typescript-checker": "^4.0.0",
+    "@systemfsoftware/stryker-js-vitest-runner": "^3.0.0",
+    "@systemfsoftware/stryker-plugins": "^2.0.2",
+    "@systemfsoftware/stryker-test-contribution": "^1.1.3",
+    "@systemfsoftware/vitest-config": "^0.1.0",
     "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/vitest-config": "^0.1.0"
+    "@systemfsoftware/oxlint-config": "^0.1.0"
   },
   "engines": {
     "node": ">=20.0.0"