@ingenioz-it/caits 0.7.0 → 0.8.0

package/src/testing/backend/presentationApplication.ts

@@ -1,21 +1,41 @@
 /// <reference path="../../virtual-modules.d.ts" />
 import "virtual:marko-run/__marko-run__router.js";
 import { fetch } from "@marko/run/router";
-import { startBackend } from "../../di/backend.js";
+import { controller, startBackend } from "../../di/backend.js";
 import { bind } from "../../di/Container.js";
+import type { DomainEvent } from "../../DomainEvent.js";
+import { ContextEvents } from "../../messaging/ContextEvents.js";
 import { MessageBus } from "../../messaging/MessageBus.js";
+import { RequestEvents } from "../../messaging/RequestEvents.js";
+import type { TimerController } from "../../messaging/TimerController.js";
 import { FakeMessageBus } from "../shared/FakeMessageBus.js";
 
 /** The real routes and controllers, over a bus that only records: each test says what the application answers. */
 export function startPresentationApplication() {
-  const messageBus = new FakeMessageBus();
+  // The events that the application publishes, as the test says: the controllers that stream hear them, of their request and of their context.
+  const listeners = new Set<(event: DomainEvent) => void>();
+  // They never end: a feed ends when the client of the test leaves.
+  const events: ContextEvents = {
+    subscribe: listener => {
+      listeners.add(listener);
+      return () => { listeners.delete(listener); };
+    },
+    signal: new AbortController().signal
+  };
+  const messageBus = new FakeMessageBus(event => { for (const listener of [...listeners]) listener(event); });
   const reportedErrors: unknown[] = [];
   const reportError = (error: unknown) => { reportedErrors.push(error); };
-  startBackend({ reportError, replace: { shared: [bind(MessageBus).toValue(messageBus)] } });
+  startBackend({ reportError, replace: { shared: [bind(MessageBus).toValue(messageBus), bind(RequestEvents).toValue(events), bind(ContextEvents).toValue(events)] } });
 
   return {
     messageBus,
     reportedErrors,
+    /** Runs one turn of a timer controller, as the kernel does while the server runs, in a request of its own. Gives its rhythm. */
+    async tick(timer: abstract new (...args: never[]) => TimerController<object>): Promise<number> {
+      const turn = controller(timer);
+      await turn.tick();
+      return turn.every;
+    },
     async fetch(request: Request): Promise<Response> {
       const response = await fetch(request, {} as never);
       if (!response) throw new Error(`No route answers ${request.method} ${new URL(request.url).pathname}`);

package/src/testing/backend/presentationScenario.ts

@@ -1,19 +1,39 @@
 import { expect } from "vitest";
+import type { TimerController } from "../../messaging/TimerController.js";
 import type { startPresentationApplication } from "./presentationApplication.js";
 
 type PresentationApplication = ReturnType<typeof startPresentationApplication>;
 
+/** The body of a request, and its type: a form, a text as it is, or JSON. */
+function bodyOf(body: unknown): RequestInit {
+  if (body === undefined) return {};
+  // A form, which fetch sends with its type: multipart/form-data for a FormData, application/x-www-form-urlencoded for URLSearchParams.
+  if (body instanceof FormData || body instanceof URLSearchParams) return { body };
+  return { body: typeof body === "string" ? body : JSON.stringify(body), headers: { "content-type": "application/json" } };
+}
+
 export class PresentationScenario {
   private request: Request | undefined;
+  /** The client of the request: it leaves when the test has read the start of a stream. */
+  private readonly client = new AbortController();
+  private timer: (abstract new (...args: never[]) => TimerController<object>) | undefined;
 
   constructor(private readonly app: PresentationApplication) {}
 
-  /** A request with a body sends it as JSON: a string is the text of the body as it is (`"{not json"`), any other value its JSON. */
-  givenTheRequest(method: string, path: string, body?: unknown): this {
-    this.request = new Request(`http://localhost${path}`, {
-      method,
-      ...(body === undefined ? {} : { body: typeof body === "string" ? body : JSON.stringify(body), headers: { "content-type": "application/json" } })
-    });
+  /**
+   * A request with a body sends it as JSON: a string is the text of the body as it is (`"{not json"`), any other value its JSON. A
+   * FormData is sent as a form, multipart/form-data, with its files, and URLSearchParams as a form of URL encoding. The headers go with
+   * it, over the type that its body gives.
+   */
+  givenTheRequest(method: string, path: string, body?: unknown, headers: Readonly<Record<string, string>> = {}): this {
+    const sent = bodyOf(body);
+    this.request = new Request(`http://localhost${path}`, { method, signal: this.client.signal, ...sent, headers: { ...sent.headers as Record<string, string> | undefined, ...headers } });
+    return this;
+  }
+
+  /** The timer controller whose turn the test runs, instead of a request. */
+  givenTheTimer(timer: abstract new (...args: never[]) => TimerController<object>): this {
+    this.timer = timer;
     return this;
   }
 
@@ -27,12 +47,69 @@ export class PresentationScenario {
     return this;
   }
 
+  /** The events that the application publishes when it receives the last message, before it answers: a stream writes them. */
+  givenTheApplicationPublishes(...events: object[]): this {
+    this.app.messageBus.publishTheLast(events);
+    return this;
+  }
+
+  /** The application never answers the last message: its handler keeps running, while a stream writes what it published. */
+  givenTheApplicationKeepsRunning(): this {
+    this.app.messageBus.keepTheLastRunning();
+    return this;
+  }
+
   givenTheApplicationFails(error: Error): this {
     this.app.messageBus.failTheLast(error);
     return this;
   }
 
-  async expectTheResponseToBe(status: number, body?: unknown, headers: Record<string, string> = {}): Promise<void> {
+  /** Runs one turn of the timer: it runs every `every` milliseconds, sends what the test expects, and reports no error. */
+  async expectTheTurnToRunEvery(every: number): Promise<void> {
+    if (this.timer === undefined) throw new Error("PresentationScenario: call givenTheTimer(...) before expectTheTurnToRunEvery(...).");
+    expect(await this.app.tick(this.timer)).toBe(every);
+    expect(this.app.reportedErrors).toEqual([]);
+    this.app.messageBus.verify();
+  }
+
+  /** Reads the whole stream of the response: its status, its headers (null for a header that it does not have), and its text. */
+  async expectTheStreamToBe(status: number, text: string, headers: Record<string, string | null> = {}): Promise<void> {
+    const response = await this.stream(status, headers);
+    expect(await response.text()).toBe(text);
+    this.app.messageBus.verify();
+  }
+
+  /**
+   * Reads the start of the stream of the response, as long as the text, then the client leaves: the test of a feed, or of a client that
+   * leaves. The signal that went with each DTO aborts then: the handler sees the client leave.
+   */
+  async expectTheStreamToStartWith(status: number, text: string, headers: Record<string, string | null> = {}): Promise<void> {
+    const reader = (await this.stream(status, headers)).body!.getReader();
+    const decoder = new TextDecoder();
+    let read = "";
+    while (read.length < text.length) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      read += decoder.decode(chunk.value, { stream: true });
+    }
+    expect(read.slice(0, text.length)).toBe(text);
+    this.client.abort();
+    await reader.cancel();
+    await new Promise(resolve => { setTimeout(resolve, 0); });
+    this.app.messageBus.verify();
+    this.app.messageBus.verifyLeft();
+  }
+
+  private async stream(status: number, headers: Record<string, string | null>): Promise<Response> {
+    if (this.request === undefined) throw new Error("PresentationScenario: call givenTheRequest(...) before reading its stream.");
+    const response = await this.app.fetch(this.request);
+    expect(response.status).toBe(status);
+    for (const [name, value] of Object.entries(headers)) expect(response.headers.get(name), `header ${name}`).toBe(value);
+    return response;
+  }
+
+  /** Reads the response: its status, its body, and its headers, null for a header that it does not have. */
+  async expectTheResponseToBe(status: number, body?: unknown, headers: Record<string, string | null> = {}): Promise<void> {
     if (this.request === undefined) throw new Error("PresentationScenario: call givenTheRequest(...) before expectTheResponseToBe(...).");
     const response = await this.app.fetch(this.request);
 

package/src/testing/shared/FakeMessageBus.ts

@@ -1,10 +1,15 @@
-import type { MessageBus } from "../../messaging/MessageBus.js";
+import type { MessageBus, Sending } from "../../messaging/MessageBus.js";
 
-type Outcome = { reply: unknown } | { error: Error };
-type Expectation = { message: object; outcome: Outcome | undefined; received: boolean };
+type Outcome = { reply: unknown } | { error: Error } | { pending: true };
+/** A message that the test expects: what the application answers, whether it came, what it publishes, and the signal that went with it. */
+type Expectation = { message: object; outcome: Outcome | undefined; received: boolean; publishes: readonly object[]; signal?: AbortSignal };
+
+/** A matcher of Vitest, as `expect.any(String)` gives it: a field of an expected message that the test cannot know, an id drawn by chance. */
+const isMatcher = (value: object): value is { asymmetricMatch(other: unknown): boolean } => typeof (value as { asymmetricMatch?: unknown }).asymmetricMatch === "function";
 
 function same(left: unknown, right: unknown): boolean {
   if (Object.is(left, right)) return true;
+  if (typeof left === "object" && left !== null && isMatcher(left)) return left.asymmetricMatch(right);
   if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
   if (Object.getPrototypeOf(left) !== Object.getPrototypeOf(right)) return false;
   if (left instanceof Date) return left.getTime() === (right as Date).getTime();
@@ -17,8 +22,21 @@ export class FakeMessageBus implements MessageBus {
   private expectations: Expectation[] = [];
   private unexpected: object[] = [];
 
+  /** What the application publishes when it receives a message: a test of a controller that streams gives where the events go. */
+  constructor(private readonly publish: (event: object) => void = () => {}) {}
+
   expect(message: object): void {
-    this.expectations.push({ message, outcome: undefined, received: false });
+    this.expectations.push({ message, outcome: undefined, received: false, publishes: [] });
+  }
+
+  /** The events that the application publishes when it receives the last message, before it answers. */
+  publishTheLast(events: readonly object[]): void {
+    this.last("publishes").publishes = events;
+  }
+
+  /** The application never answers the last message: its handler keeps running. */
+  keepTheLastRunning(): void {
+    this.last("keeps running").outcome = { pending: true };
   }
 
   replyToTheLast(output: unknown): void {
@@ -29,7 +47,7 @@ export class FakeMessageBus implements MessageBus {
     this.last("fails").outcome = { error };
   }
 
-  send(message: object): Promise<never> {
+  send(message: object, sending: Sending = {}): Promise<never> {
     const expected = this.expectations.find(candidate => !candidate.received && same(candidate.message, message));
     if (!expected) {
       this.unexpected.push(message);
@@ -37,7 +55,10 @@ export class FakeMessageBus implements MessageBus {
       return Promise.reject(new Error(`The application sent a message nobody expected: ${message.constructor.name} ${JSON.stringify(message)} (still expected: ${pending})`));
     }
     expected.received = true;
+    expected.signal = sending.signal;
+    for (const event of expected.publishes) this.publish(event);
     if (!expected.outcome) return Promise.reject(new Error(`Nothing is prepared for the application to be answered: ${message.constructor.name}`));
+    if ("pending" in expected.outcome) return new Promise(() => {});
     return "error" in expected.outcome ? Promise.reject(expected.outcome.error) : Promise.resolve(expected.outcome.reply as never);
   }
 
@@ -50,6 +71,19 @@ export class FakeMessageBus implements MessageBus {
     if (problems.length) throw new Error(problems.join("\n"));
   }
 
+  /**
+   * Once the client left: each message came with the signal of its request, which aborted. Without it, the handler would not see the
+   * client leave.
+   */
+  verifyLeft(): void {
+    const problems = this.expectations.filter(({ received }) => received).flatMap(({ message, signal }) => {
+      const name = `${message.constructor.name} ${JSON.stringify(message)}`;
+      if (!signal) return [`the application sent ${name} without the signal of its request: its handler cannot see the client leave`];
+      return signal.aborted ? [] : [`the signal that went with ${name} did not abort when the client left`];
+    });
+    if (problems.length) throw new Error(problems.join("\n"));
+  }
+
   private last(step: string): Expectation {
     const last = this.expectations.at(-1);
     if (!last) throw new Error(`Say which message is expected before saying how the application ${step}.`);

package/src/vite.js

@@ -5,6 +5,8 @@ import MagicString from "magic-string";
 import { normalizePath, parseSync } from "vite";
 import { declareDependencies } from "./di/declareDependencies.js";
 
+export { adapter } from "./adapter.js";
+
 /** @import { Plugin } from "vite" */
 /** @import { KernelOptions } from "./vite.types.js" */
 

package/src/vite.types.d.ts

@@ -1,3 +1,4 @@
+import type { Adapter } from "@marko/run/vite";
 import type { Plugin } from "vite";
 
 /** The types of vite.js, for the projects: TypeScript reads no types from the JavaScript of a package. Keep them the same as vite.js. */
@@ -12,3 +13,9 @@ export declare function kernel(options?: KernelOptions): Plugin[];
 
 /** Makes @marko/run write the types of the routes whole: `caits check` runs the checks at once, and some of them read these types. */
 export declare function wholeRouteTypes(): Plugin;
+
+/**
+ * The adapter of @marko/run for a CAITS app: the server of `npm start` (the entry that it gives to `npm run build`) and that of `caits dev`
+ * boot the backend, start its timers, and stop it on SIGTERM or SIGINT; `caits dev` boots it again when its code changes.
+ */
+export declare function adapter(): Adapter;

package/template/caits/architecture.mjs

@@ -162,6 +162,9 @@ function listedPackages(layer) {
   };
 }
 
+/** The controllers of the kernel, by what triggers them, and their module: a request, a timer, a request that a stream answers. */
+const KERNEL_CONTROLLERS = /** @type {const} */ ({ Controller: "messaging/Controller", TimerController: "messaging/TimerController", StreamController: "messaging/StreamController" });
+
 /** @type {Rule[]} */
 export const rules = [
   // Kernel: the package @ingenioz-it/caits builds the containers and the controllers
@@ -178,11 +181,11 @@ export const rules = [
   },
   {
     name: "controllers-built-by-kernel",
-    description: "Only the kernel makes a controller, with its dependencies. The other code asks the kernel for a controller, or sends a request through the router.",
+    description: "Only the kernel makes a controller, with its dependencies. The other code asks the kernel for a controller, or sends a request through the router. The AbortController of the platform, which stops a fetch, is not a controller of the app.",
     on: "file",
     check: ({ path, constructed, lines }) => {
       const route = locate(path).kind === "routes";
-      return constructed.flatMap((name, index) => name === null || !/^[A-Z]\w*Controller$/.test(name) ? [] : [at(lines.constructed[index],
+      return constructed.flatMap((name, index) => name === null || name === "AbortController" || !/^[A-Z]\w*Controller$/.test(name) ? [] : [at(lines.constructed[index],
         `This file builds ${name} with \`new\`, but only the kernel builds a controller, with its dependencies. ${route ? `Ask the kernel for it with \`controller(${name})\`, from @ingenioz-it/caits/di/backend.` : "Send the request through the router instead."}`)]);
     }
   },
@@ -461,21 +464,37 @@ export const rules = [
   },
   {
     name: "controller-extends-controller",
-    description: "A controller is an exported class …Controller that extends the Controller of the kernel.",
+    description: "A controller is an exported class …Controller that extends a controller of the kernel: Controller for a request, TimerController for a timer, StreamController for a stream.",
     on: "file",
     check: ({ path, classes }) => {
+      const ofKernel = (/** @type {string | null | undefined} */ parent) => typeof parent === "string" && Object.hasOwn(KERNEL_CONTROLLERS, parent);
       if (!/^src\/backend\/[^/]+\/(?:command|query)\/[^/]+\/[^/]+\.controller\.ts$/.test(path)
-        || classes.some(({ exported, name, extends: parent }) => exported && name !== null && /^\w+Controller$/.test(name) && parent === "Controller")) return;
-      const declared = classes.find(({ name }) => name !== null && /Controller$/.test(name)) ?? classes.find(({ extends: parent }) => parent === "Controller") ?? classes[0];
+        || classes.some(({ exported, name, extends: parent }) => exported && name !== null && /^\w+Controller$/.test(name) && ofKernel(parent))) return;
+      const declared = classes.find(({ name }) => name !== null && /Controller$/.test(name)) ?? classes.find(({ extends: parent }) => ofKernel(parent)) ?? classes[0];
       const expected = declared?.name ? (/Controller$/.test(declared.name) ? declared.name : `${declared.name}Controller`) : "…Controller";
-      const rule = `a controller is an exported class …Controller that extends the Controller of the kernel. Write \`export class ${expected} extends Controller\`, with Controller from @ingenioz-it/caits/messaging/Controller.`;
+      const base = /\.timer\.controller\.ts$/.test(path) ? "TimerController" : /\.stream\.controller\.ts$/.test(path) ? "StreamController" : "Controller";
+      const rule = `a controller is an exported class …Controller that extends a controller of the kernel: Controller for a request, TimerController for a timer, StreamController for a stream. Write \`export class ${expected} extends ${base}\`, with ${base} from @ingenioz-it/caits/${KERNEL_CONTROLLERS[base]}.`;
       if (!declared) return `${fileName(path)} holds no exported class …Controller, but ${rule}`;
       const name = declared.name ?? "Its class";
       if (!declared.exported) return at(declared.line, `${name} is not exported, but ${rule}`);
-      if (declared.extends !== "Controller") return at(declared.line, `${name} extends ${declared.extends ?? "nothing"}, but ${rule}`);
+      if (!ofKernel(declared.extends)) return at(declared.line, `${name} extends ${declared.extends ?? "nothing"}, but ${rule}`);
       return at(declared.line, `${name} does not end with Controller, but ${rule}`);
     }
   },
+  {
+    name: "controllers-read-the-request-of-caits",
+    description: "A controller reads the Request of CAITS, from @ingenioz-it/caits/messaging/Request, which gives the content of the body at each call. The Request of the web, global, reads its body once only: a controller neither names it nor builds a request.",
+    on: "file",
+    check: ({ path, imported, typeReferences, constructed, lines }) => {
+      if (!/^src\/backend\/[^/]+\/(?:command|query)\/[^/]+\/[^/]+\.controller\.ts$/.test(path)) return;
+      const ofCaits = imported.some(({ name, from }) => name === "Request" && from === "@ingenioz-it/caits/messaging/Request");
+      const named = typeReferences.flatMap((name, index) => name === "globalThis.Request" || (name === "Request" && !ofCaits) ? [at(lines.typeReferences[index],
+        `This controller names the Request of the web, which reads its body once only, but a controller reads the Request of CAITS, which gives the content of the body at each call. ${ofCaits ? "Write `Request`, which the file imports from CAITS." : "Import it: `import type { Request } from \"@ingenioz-it/caits/messaging/Request\"`."}`)] : []);
+      const built = constructed.flatMap((name, index) => name !== "Request" ? [] : [at(lines.constructed[index],
+        "This controller builds a Request, but a controller reads the request that CAITS gives to its methods. Remove `new Request(…)`.")]);
+      return [...named, ...built];
+    }
+  },
 
   // Events of the frontend: what its views, its handlers and its context map publish
 

package/template/caits/imports.mjs

@@ -3,12 +3,12 @@
  * Node API (`node:crypto`), or a folder of modules, ending with `/*` (`@ingenioz-it/caits/messaging/*`). A layer without a list imports
  * any package. The imports of the files of the project (`#context/…`, `./…`) are not packages: the other rules check them.
  * The domain holds the business rules: it imports only the primitives of the kernel. The application adds what a use case needs: its
- * handler publishes events. The presentation, the infra, di.ts and the context map have no list.
+ * handler publishes events, and reads the context of its request (its correlation id, and the signal of its client). The presentation, the infra, di.ts and the context map have no list.
  * The project starts from these lists in its quality/imports.mjs.
  */
 const domain = ["@ingenioz-it/caits/Result", "@ingenioz-it/caits/Token", "@ingenioz-it/caits/DomainEvent"];
 
 export const allowed = {
   domain,
-  application: [...domain, "@ingenioz-it/caits/messaging/EventPublisher"]
+  application: [...domain, "@ingenioz-it/caits/messaging/EventPublisher", "@ingenioz-it/caits/di/RequestContext"]
 };

package/template/caits/stryker.mjs

@@ -1,7 +1,14 @@
-/** The mutation tests. Stryker runs `caits mutation-suite` for each mutant: the unit tests, in a private copy of its sandbox. */
+/**
+ * The mutation tests. Stryker runs the unit tests in Vitest, which stays started from one mutant to the next: for each mutant, the tests
+ * that run its code. A counter stops the code of a mutant that loops without end.
+ */
 export default {
-  testRunner: "command",
-  commandRunner: { command: "caits mutation-suite --bail=1 --no-isolate --maxWorkers=1" },
+  testRunner: "vitest",
+  // The tests find the code through the discovery of CAITS too, not only through their imports: the first run runs them all, and tells
+  // which test runs which code. The pool of Vitest by default: a fork of Node for the tests.
+  vitest: { configFile: "quality/vite.config.ts", related: false, pool: "forks" },
+  // A new project has no test yet. As soon as there is code, its mutants have no coverage, and fail the check.
+  allowEmpty: true,
   checkers: ["typescript"],
   tsconfigFile: "quality/caits/tsconfig.mutation.json",
   mutate: ["src/**/*.ts", "!src/**/*.test.ts", "!src/**/*.contract.ts", "!src/**/test.di.ts", "!src/frontend/*/di.ts"],
@@ -13,8 +20,6 @@ export default {
   thresholds: { high: 100, low: 100, break: 100 },
   concurrency: "100%",
   timeoutMS: 15000,
-  coverageAnalysis: "off",
-  // The builds stay out of the sandbox: each suite builds its own (`caits mutation-suite`), and under `caits check`, the end-to-end tests
-  // empty dist/ while Stryker copies the project.
+  // The builds stay out of the sandbox: under `caits check`, the end-to-end tests empty dist/ while Stryker copies the project.
   ignorePatterns: ["reports", "test-results", "playwright-report", "dist", ".marko-run"]
 };

package/template/caits/vite.ts

@@ -1,7 +1,7 @@
 import { fileURLToPath } from "node:url";
 import marko from "@marko/run/vite";
 import { defineConfig } from "vitest/config";
-import { kernel, wholeRouteTypes } from "@ingenioz-it/caits/vite";
+import { adapter, kernel, wholeRouteTypes } from "@ingenioz-it/caits/vite";
 
 /**
  * The folder of the stylesheets of the app. Sass looks in it after the folder of a stylesheet: each stylesheet of the routes loads the
@@ -10,13 +10,21 @@ import { kernel, wholeRouteTypes } from "@ingenioz-it/caits/vite";
  */
 const STYLE_FOLDER = fileURLToPath(new URL("../../src/routes/_frontend/style", import.meta.url));
 
+/**
+ * The build folder. `caits check` runs the checks at once: it gives each one a build folder of its own (CAITS_OUT_DIR), else they empty
+ * the folder of each other. So do the processes of the mutation tests, which Stryker numbers (STRYKER_MUTATOR_WORKER): the Marko plugin
+ * empties the entries of the routes in the build folder, then writes them again, as a test loads a route. Without either, the build goes
+ * in dist/, which `npm start` runs.
+ */
+const worker = process.env.STRYKER_MUTATOR_WORKER;
+const OUT_DIR = worker === undefined ? process.env.CAITS_OUT_DIR || "dist" : `node_modules/.caits/mutation/${worker}`;
+
 export default defineConfig({
-  plugins: [wholeRouteTypes(), marko(), kernel()],
-  // `caits check` runs the checks at once: it gives each one a build folder of its own (CAITS_OUT_DIR), else they empty the folder of
-  // each other. Without it, the build goes in dist/, which `npm start` runs.
+  // The adapter of CAITS: the server of `npm start` and that of `caits dev` boot the backend, start its timers, and stop it on SIGTERM.
+  plugins: [wholeRouteTypes(), marko({ adapter: adapter() }), kernel()],
   // The build keeps the names of the classes: the errors of CAITS name them, and the build would else number a class that has the name
   // of another, as a DTO of the backend and one of the frontend (`No handler takes AddMessageCommand$1`).
-  build: { outDir: process.env.CAITS_OUT_DIR || "dist", rolldownOptions: { output: { keepNames: true } } },
+  build: { outDir: OUT_DIR, rolldownOptions: { output: { keepNames: true } } },
   // The checks write their reports while the development server runs: a report is not a file of the app, and reloads no page. The
   // sandbox of the mutation tests (.stryker-tmp/) copies the project, its tsconfig.json too: the server would empty its cache at each
   // copy, and lose the dependencies that it optimized.

package/quality/mutation-suite.mjs

@@ -1,82 +0,0 @@
-// `caits mutation-suite`: the command that Stryker runs for each mutant. It runs the unit tests from a private copy of the sandbox.
-// Stryker runs many suites at once in a single sandbox, and every Vitest start rewrites the files that the Marko plugin generates
-// (dist/, .marko-run/): suites that run at the same time would fail at random, and a failed run counts as a killed mutant.
-// The copy shares the packages of the sandbox, not the caches that the tools keep beside them (node_modules/.vite/, .vitest-cache/…): the
-// cache of Vite depends on the folder of the project, so each suite would write it again while the others read it.
-import { spawn } from "node:child_process";
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, symlinkSync } from "node:fs";
-import { constants, tmpdir } from "node:os";
-import { join } from "node:path";
-import { painterOf } from "./terminal.mjs";
-
-const ENTRIES = ["src", "test", "quality", "dist", ".marko-run", "package.json", "tsconfig.json"];
-
-/** The report of Vitest, in the copy: Vitest writes it once the tests ran, also when one fails. */
-const REPORT = "vitest-report.json";
-
-/**
- * What the suite prints when the unit tests did not run. Stryker counts the mutant as killed, as for any exit code but 0:
- * `caits mutation-summary` finds these words in the report of Stryker, and does not.
- */
-export const NOT_RUN = "The unit tests did not run";
-
-/** The copies, in the temporary folder: `caits-mutation-<pid of their suite>-<random>`. */
-const COPY = /^caits-mutation-(\d+)-/;
-
-/** @param {string[]} args the options of Vitest, which Stryker gives */
-export async function run(args) {
-  removeOrphans();
-  const sandbox = process.cwd();
-  const copy = mkdtempSync(join(tmpdir(), `caits-mutation-${process.pid}-`));
-  const remove = () => rmSync(copy, { recursive: true, force: true });
-  for (const entry of ENTRIES) {
-    if (existsSync(join(sandbox, entry))) cpSync(join(sandbox, entry), join(copy, entry), { recursive: true });
-  }
-  // The packages and their commands (.bin/). The other entries that start with a dot are the caches and the files of the tools.
-  mkdirSync(join(copy, "node_modules"));
-  for (const entry of readdirSync(join(sandbox, "node_modules"))) {
-    if (!entry.startsWith(".") || entry === ".bin") symlinkSync(join(sandbox, "node_modules", entry), join(copy, "node_modules", entry));
-  }
-
-  // The suite builds in the dist/ of its copy: the build folder that `caits check` gives (CAITS_OUT_DIR) is in node_modules/, which the
-  // suites share.
-  const { CAITS_OUT_DIR: _, ...env } = process.env;
-  const vitest = ["vitest", "run", "--config", "quality/vite.config.ts", "--reporter=dot", "--reporter=json", `--outputFile.json=${REPORT}`, ...args];
-  const suite = spawn("npx", vitest, { cwd: copy, env, stdio: "inherit" });
-  // Ctrl+C and `caits check` stop the suite: the copy goes away with it. The exit code tells the signal: 130 for SIGINT, 143 for SIGTERM.
-  for (const signal of /** @type {const} */ (["SIGINT", "SIGTERM"])) process.on(signal, () => { suite.kill(signal); remove(); process.exit(128 + constants.signals[signal]); });
-  /** @type {number} */
-  const status = await new Promise(resolve => suite.on("close", code => resolve(code ?? 1)));
-  const ran = existsSync(join(copy, REPORT));
-  remove();
-  // Vitest stopped before the tests, on an error of its own or of the system: no test failed, and the mutant is not tested.
-  if (status !== 0 && !ran) console.error(painterOf(process.stderr)("red", `${NOT_RUN}: Vitest stopped before them (exit ${status}). The mutant is not tested.`));
-  return status;
-}
-
-/**
- * Stryker stops a suite that takes too long with SIGKILL, which no code can follow: its copy stays. Each suite removes the copies whose
- * suite no longer runs.
- */
-function removeOrphans() {
-  for (const entry of readdirSync(tmpdir())) {
-    const pid = COPY.exec(entry)?.[1];
-    if (pid === undefined || runs(Number(pid))) continue;
-    try {
-      rmSync(join(tmpdir(), entry), { recursive: true, force: true });
-    } catch {
-      // The copy of another user.
-    }
-  }
-}
-
-/** @param {number} pid */
-function runs(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    // EPERM: the process runs, but belongs to another user.
-    return /** @type {NodeJS.ErrnoException} */ (error).code === "EPERM";
-  }
-}