@roomi-fields/grillhouse 0.0.0-stage → 0.23.1

package/scripts/vitest-config/cibles.mjs

@@ -0,0 +1,207 @@
+// The tests a targeted run names (`npm test -- <paths>`, scripts/tests.mjs), carried to Vitest by
+// the variable `GRILLHOUSE_TESTS` rather than by its command line: the arguments after `--` of a
+// Turborepo run enter the hash of every task of that run, the builds included, while a variable
+// that the `env` of the task `test:vitest` names enters the hash of the tests alone
+// (https://turborepo.dev/docs/reference/configuration#env). Turborepo then plays the tests with
+// what they depend on, each build and each trace hashed by Turborepo itself.
+//
+// - The value is JSON: `arguments`, Vitest's arguments (the paths, absolute, and the options
+//   written `--<name>=<value>`), which Vitest's own parser of its command line (`parseCLI`,
+//   vitest/node) reads; `rejouer`, the moment of a run that plays the tests for real (`--force`),
+//   which only moves the hash; `temoins`, the time witnesses of a pass of `npm run verifier`
+//   (below). The plugin takes the variable out of the environment once read: no
+//   process the tests start receives it.
+// - A plugin of the base configuration (./base.mjs) reads it once the configuration is merged (its
+//   `config` hook; Vitest reads the test options in `configResolved`, after every `config` hook):
+//   the files played are the test files of the configuration's `include` (Vitest's default when
+//   it sets none) that lie under a path named (none named, the configuration's own), as Vitest's filters of its command line take an
+//   absolute path (a file, or a directory ending with « / »); its `exclude` still applies, Vitest's.
+//   A path of another package names none of its files. Each option enters the test configuration
+//   as Vitest merges its command line over it (`exclude` given on the command line is
+//   `cliExclude`, as Vitest's `normalizeCliOptions` names it).
+// - A night test or a time budget bench (HORS_DU_JOUR, the day's exclusions of ./base.mjs) plays
+//   when its own file is named, as Bazel's target tagged `manual` builds when named and never by a
+//   pattern: the day's exclusions of both lift for that run, the include of the configuration
+//   notwithstanding (the night's own include is HORS_DU_JOUR), and the measure of time of the base
+//   configuration applies, its duration reporter giving 75, « à repasser », to a bench that fails
+//   under load. A directory named leaves them out, as the day does.
+// - Without the variable, nothing changes. A run whose paths name no test file plays none, and
+//   fails: the base configuration keeps Vitest's `passWithNoTests: false`.
+// - The time witnesses play alone, as Bazel plays a test tagged `exclusive` after the others, with
+//   nothing beside it: a time witness is a test file that imports the mark of a measure of time
+//   (`import { mesurerAuRepos } from '@roomi-fields/grillhouse/vitest-config/mesure'`, a line of its own,
+//   `estTemoin`). `npm run verifier` (scripts/verifier.mjs) plays its pass with `temoins: 'hors'`
+//   in the value, which leaves every witness of the configuration's `include` out, then a pass of
+//   its own with `temoins: 'seuls'`, which plays the witnesses alone, one file at a time
+//   (`fileParallelism: false`), and passes without one (`passWithNoTests`); a targeted run sets
+//   neither, and a witness named plays there as any test. The witnesses are found under the
+//   configuration's directory (`fichiersTemoins`), node_modules, dist, .git, .turbo and .claude
+//   left out.
+// - The changes since the last green (`GRILLHOUSE_CHANGEMENTS`, ./changements.mjs) restrict the
+//   files played to those Vitest relates to them, the files named themselves kept, or leave every
+//   test when a change lies out of Vitest's graph.
+//
+// This module's top level uses Node alone: scripts/tests.mjs reads its VARIABLE.
+import { globSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { CHANGEMENTS, lireChangements, restreindre } from './changements.mjs';
+
+export const VARIABLE = 'GRILLHOUSE_TESTS';
+// The day's exclusions, which the base configuration (./base.mjs) sets and the night plays
+// (scripts/vitest.nuit.config.mjs): the night tests, too long for the day, and the time budget
+// benches, whose measures move with the load of the day.
+export const NUIT = '**/*.nuit.{test,spec}.?(c|m)[jt]s?(x)';
+export const BUDGET = '**/*.budget.{test,spec}.?(c|m)[jt]s?(x)';
+export const HORS_DU_JOUR = [NUIT, BUDGET];
+// Whether <r>, a path relative to the configuration's directory, is a night test or a bench.
+const horsDuJour = r => HORS_DU_JOUR.some(p => path.matchesGlob(r, p));
+// Vitest's default `include` (its configDefaults).
+const INCLUDE = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
+// The mark of a time witness: the import of `mesurerAuRepos`, on a line of its own, from the
+// package of the base configuration (by its name, or by the path of its file).
+const MARQUE_TEMOIN =
+  /^import\s*\{[^}]*\bmesurerAuRepos\b[^}]*\}\s*from\s*['"][^'"]*vitest-config\/mesure(?:\.mjs)?['"]/m;
+// Whether the text <texte> of a test file is that of a time witness.
+const estTemoin = texte => MARQUE_TEMOIN.test(texte);
+// The directories a search of the witnesses leaves out.
+const HORS_TEMOINS = new Set(['node_modules', 'dist', '.git', '.turbo', '.claude']);
+
+// The time witnesses under <dir>: the test files of <include> (Vitest's default without it), the
+// day's exclusions left out, that `estTemoin`; each path relative to <dir>, sorted.
+export function fichiersTemoins(dir, include = INCLUDE) {
+  const lire = f => {
+    try {
+      return readFileSync(path.join(dir, f), 'utf8');
+    } catch {
+      return '';
+    }
+  };
+  return [
+    ...new Set(
+      globSync(include, { cwd: dir, exclude: d => HORS_TEMOINS.has(path.basename(d)) }).map(f =>
+        f.split(path.sep).join('/')
+      )
+    ),
+  ]
+    .filter(f => !horsDuJour(f) && estTemoin(lire(f)))
+    .sort();
+}
+// The directories a walk under a named directory leaves out, whose files no test configuration
+// plays (the base excludes them).
+const SAUTES = new Set(['node_modules', '.git']);
+// The characters a path escapes to be read by the glob of Vitest as itself.
+const SPECIAUX = /[\\*?[\]{}()!+@|^$]/g;
+
+// The files at <chemin> (absolute): itself when it is a file, the files under it when it is a
+// directory; none when it does not exist.
+function fichiers(chemin) {
+  let stat;
+  try {
+    stat = statSync(chemin);
+  } catch {
+    return [];
+  }
+  if (!stat.isDirectory()) {
+    return [chemin];
+  }
+  return readdirSync(chemin, { withFileTypes: true }).flatMap(e =>
+    e.isDirectory() && SAUTES.has(e.name) ? [] : fichiers(path.join(chemin, e.name))
+  );
+}
+
+// <valeur> merged over <cible> as Vitest merges its command line over the configuration: an object
+// merged key by key, any other value replaced.
+const fusion = (cible, valeur) =>
+  valeur && typeof valeur === 'object' && !Array.isArray(valeur)
+    ? Object.entries(valeur).reduce(
+        (o, [k, v]) => ({ ...o, [k]: fusion(o[k], v) }),
+        cible && typeof cible === 'object' && !Array.isArray(cible) ? cible : {}
+      )
+    : valeur;
+
+// The plugin that restricts a run to the tests <env> names in VARIABLE.
+export const ciblage = (env = process.env, dire = l => process.stdout.write(`${l}\n`)) => ({
+  name: 'grillhouse:cibles',
+  async config(config) {
+    const texte = env[VARIABLE];
+    const changements = env[CHANGEMENTS];
+    delete env[VARIABLE];
+    delete env[CHANGEMENTS];
+    if (!texte && !changements) {
+      return;
+    }
+    const test = (config.test ??= {});
+    // The files a targeted run names themselves, absolute.
+    let nommes = [];
+    if (texte) {
+      nommes = await cibler(config, test, JSON.parse(texte));
+    }
+    const ch = changements ? lireChangements(changements) : null;
+    // A targeted run whose paths name no test file plays none, and fails, as without the changes.
+    if (ch && test.include?.[0] !== `${VARIABLE}-sans-fichier`) {
+      restreindre(test, path.resolve(config.root ?? process.cwd()), ch, nommes, dire);
+    }
+  },
+});
+
+// Applies the value <valeur> of VARIABLE to the configuration <config>, its test options <test>:
+// the files named themselves, absolute.
+async function cibler(config, test, valeur) {
+  const { parseCLI } = await import('vitest/node');
+  const { filter, options } = parseCLI(['vitest', ...(valeur.arguments ?? [])]);
+  let nommes = [];
+  // The time witnesses: left out of the pass, or played alone in their own.
+  if (valeur.temoins === 'hors' || valeur.temoins === 'seuls') {
+    const dir = path.resolve(config.root ?? process.cwd(), test.dir ?? '');
+    const temoins = fichiersTemoins(dir, test.include ?? INCLUDE).map(r =>
+      r.replace(SPECIAUX, '\\$&')
+    );
+    if (valeur.temoins === 'hors') {
+      test.exclude = [...(test.exclude ?? ['**/node_modules/**']), ...temoins];
+    } else {
+      test.include = temoins.length ? temoins : [`${VARIABLE}-sans-temoin`];
+      test.passWithNoTests = true;
+      test.fileParallelism = false;
+    }
+  }
+  if (filter.length) {
+    const dir = path.resolve(config.root ?? process.cwd(), test.dir ?? '');
+    const include = test.include ?? INCLUDE;
+    const chemins = filter.map(f => path.resolve(f.replace(/[\\/]+$/, '')));
+    // The files named themselves, not through a directory.
+    const seuls = new Set(chemins.filter(f => fichiers(f)[0] === f));
+    nommes = [...seuls];
+    const relatif = f => path.relative(dir, f).split(path.sep).join('/');
+    const joues = [...new Set(chemins.flatMap(fichiers))]
+      .filter(f => {
+        const r = relatif(f);
+        if (r.startsWith('../')) {
+          return false;
+        }
+        return horsDuJour(r) ? seuls.has(f) : include.some(p => path.matchesGlob(r, p));
+      })
+      .map(relatif)
+      .sort();
+    // A bench or a night test named itself plays: the day's exclusions of both lift, and the
+    // files under a directory named stay out by the filter above.
+    if (joues.some(horsDuJour) && Array.isArray(test.exclude)) {
+      test.exclude = test.exclude.filter(p => !HORS_DU_JOUR.includes(p));
+    }
+    // No file named: a pattern that matches none, Vitest's « No test files found ».
+    test.include = joues.length
+      ? joues.map(r => r.replace(SPECIAUX, '\\$&'))
+      : [`${VARIABLE}-sans-fichier`];
+  }
+  // parseCLI gives each option under its aliases too (`t`, `test-name-pattern`): its name alone
+  // enters.
+  const { '--': _, color: __, exclude, ...reste } = options;
+  for (const [cle, valeur] of Object.entries(reste)) {
+    if (cle.length > 1 && !cle.includes('-')) {
+      test[cle] = fusion(test[cle], valeur);
+    }
+  }
+  if (exclude !== undefined) {
+    test.cliExclude = [exclude].flat();
+  }
+  return nommes;
+}

package/scripts/vitest-config/duree.reporter.mjs

@@ -0,0 +1,98 @@
+// The duration reporter of the base configuration, beside Vitest's default reporter. At the end of
+// a run with failures, it reads each one:
+//
+// - a failure depends on a duration when it is a delay past (an error « Test timed out in <n>ms. »
+//   or « Hook timed out in <n>ms. », Vitest's own message), a failure of a time budget bench (a
+//   file `*.budget.test.*`, `*.budget.spec.*`), or of a test marked as a measure of time
+//   (`mesurerAuRepos`, ./mesure.mjs); every other failure is a real red;
+// - it took place under load when the CPU pressure (./pression.mjs) was at or above the threshold
+//   at the start or at the end of the test (noted by ./mesure.setup.mjs), or, for a hook or a file
+//   that fails outside of a test, at the start or at the end of the run.
+//
+// When every failure depends on a duration and at least one took place under load, the run is
+// « à repasser »: the exit code becomes 75 (it runs after Vitest set 1, and replaces it). Else
+// Vitest's code stands: a real red, a duration past at rest, an error outside the tests, a pressure
+// that does not read. Each failure of duration is written with the pressure measured and the
+// threshold; a pressure that does not read is said, « pression CPU illisible ».
+import path from 'node:path';
+import { A_REPASSER, ecrirePression, lirePression, SEUIL_PRESSION } from './pression.mjs';
+
+const DELAI = /^(Test|Hook) timed out in \d+ms\./;
+const BANC = /\.budget\.(test|spec)\.(c|m)?[jt]sx?$/;
+
+function* taches(t) {
+  yield t;
+  for (const c of t.tasks ?? []) yield* taches(c);
+}
+const fichierDe = t => {
+  let x = t;
+  while (x && !x.filepath) x = x.suite ?? x.file;
+  return x?.filepath ?? '';
+};
+const nomDe = t => {
+  const noms = [];
+  for (let x = t; x && !x.filepath; x = x.suite) noms.unshift(x.name);
+  return noms.join(' › ');
+};
+
+export default class DureeReporter {
+  onInit() {
+    this.debut = lirePression();
+  }
+
+  onFinished(files = [], errors = []) {
+    const fin = lirePression();
+    const echecs = [];
+    for (const f of files) {
+      for (const t of taches(f)) {
+        const erreurs = t.result?.errors ?? [];
+        if (t.type === 'test' ? t.result?.state === 'fail' : erreurs.length > 0) echecs.push(t);
+      }
+    }
+    if (echecs.length === 0) return;
+    const dire = l => process.stdout.write(`⏱ ${l}\n`);
+    let reels = 0;
+    const pressions = [];
+    for (const t of echecs) {
+      const fichier = fichierDe(t);
+      const erreurs = t.result?.errors ?? [];
+      const cause =
+        t.type === 'test' && t.meta?.mesureDeTemps
+          ? 'mesure de temps'
+          : BANC.test(fichier)
+            ? 'banc de temps'
+            : erreurs.length > 0 && erreurs.every(e => DELAI.test(e.message ?? ''))
+              ? 'délai dépassé'
+              : null;
+      if (!cause) {
+        reels++;
+        continue;
+      }
+      const debut = t.type === 'test' ? (t.meta?.pressionDebut ?? this.debut) : this.debut;
+      const finT = t.type === 'test' ? (t.meta?.pressionFin ?? fin) : fin;
+      pressions.push(debut, finT);
+      const nom = nomDe(t);
+      dire(
+        `${path.relative(process.cwd(), fichier)}${nom ? ` › ${nom}` : ''} : ${cause}, pression CPU ${ecrirePression(debut)} au début, ${ecrirePression(finT)} à la fin (seuil ${SEUIL_PRESSION} %).`
+      );
+    }
+    if (pressions.length === 0) return;
+    if (reels > 0 || errors.length > 0 || process.exitCode !== 1) {
+      dire('un échec ne dépend pas d’une durée : verdict de Vitest.');
+      return;
+    }
+    const lues = pressions.filter(p => p !== null);
+    if (lues.length === 0) {
+      dire('pression CPU illisible (/proc/pressure/cpu) : verdict de Vitest.');
+      return;
+    }
+    if (lues.some(p => p >= SEUIL_PRESSION)) {
+      dire(
+        `à repasser (code ${A_REPASSER}) : chaque échec dépend d’une durée, et au moins un a eu lieu sous charge ; ni vert ni rouge, la mesure se rejoue au repos.`
+      );
+      process.exitCode = A_REPASSER;
+      return;
+    }
+    dire(`échecs de durée au repos (pression CPU sous ${SEUIL_PRESSION} %) : rouge.`);
+  }
+}

package/scripts/vitest-config/machine.setup.mjs

@@ -0,0 +1,14 @@
+// A setup file of the base configuration: the machine of a test file is its own. The file gets a
+// lock of the heavy measure of its own (GRILLHOUSE_VERROU_MACHINE, a file of the temporary
+// directory named after its process and a token, scripts/verrou-de-machine.mjs), which every
+// process it starts inherits: a `npm run verifier` or a circuit that a test plays in a repository
+// of trial neither waits for the lock of the machine nor holds it, and no test writes in the
+// user's cache. A lock already named in the environment stays.
+import { randomUUID } from 'node:crypto';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+process.env.GRILLHOUSE_VERROU_MACHINE ||= path.join(
+  tmpdir(),
+  `grillhouse-mesure-${process.pid}-${randomUUID()}.lock`
+);

package/scripts/vitest-config/mesure.d.ts

@@ -0,0 +1,6 @@
+// The types of ./mesure.mjs, for a strict TypeScript test that imports
+// `@roomi-fields/grillhouse/vitest-config/mesure`.
+import type { TestContext } from 'vitest';
+
+// Marks the test of <ctx> as a measure of time and gives back what <fn> returns.
+export declare function mesurerAuRepos<T>(ctx: TestContext, fn: () => T): T;

package/scripts/vitest-config/mesure.mjs

@@ -0,0 +1,13 @@
+// A test that measures time marks itself, so that its failure under load is « à repasser », not a
+// red (./duree.reporter.mjs):
+//
+//   import { mesurerAuRepos } from '@roomi-fields/grillhouse/vitest-config/mesure';
+//   it('rend en moins de 50 ms', ctx => mesurerAuRepos(ctx, () => { … expect(ms).toBeLessThan(50); }));
+//
+// `mesurerAuRepos(ctx, fn)` marks the test of the context <ctx> as a measure of time and gives back
+// what <fn> returns (a promise as it is, for the test to await). A time budget bench
+// (`*.budget.test.*`) and a delay past need no mark.
+export function mesurerAuRepos(ctx, fn) {
+  ctx.task.meta.mesureDeTemps = true;
+  return fn();
+}

package/scripts/vitest-config/mesure.setup.mjs

@@ -0,0 +1,12 @@
+// The setup file of the base configuration: notes the CPU pressure (./pression.mjs) at the start
+// and at the end of each test in its `task.meta`, which reaches the duration reporter
+// (./duree.reporter.mjs). The end is noted after a delay past too: Vitest plays `afterEach` then.
+import { afterEach, beforeEach } from 'vitest';
+import { lirePression } from './pression.mjs';
+
+beforeEach(({ task }) => {
+  task.meta.pressionDebut = lirePression();
+});
+afterEach(({ task }) => {
+  task.meta.pressionFin = lirePression();
+});

package/scripts/vitest-config/pression.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// The CPU pressure of the machine, the witness of rest for every measure of time: a time witness
+// is measured with the CPU at rest, and a failure that depends on a duration under load is played
+// again at rest (« à repasser »), never taken as a red nor as a green. The model is Bazel's
+// TIMEOUT/FLAKY and CTest's `--repeat after-timeout`: classify, then play again.
+//
+// - The signal is the kernel's pressure stall information, `/proc/pressure/cpu`, line `some`,
+//   field `avg10`: the share of the last ten seconds in which a task waited for a CPU, in %.
+//   GRILLHOUSE_PRESSION_CPU names another file of the same form (the trials write it).
+// - The machine is at rest under SEUIL_PRESSION (25 %); at or above it, it is under load.
+// - A file that does not read (no pressure stall information on the machine) gives null: whoever
+//   reads it says « pression illisible » and leaves the verdict to Vitest.
+// - A_REPASSER, 75, is the exit code of « à repasser » (EX_TEMPFAIL of sysexits.h: try again
+//   later), neither green nor red: the duration reporter of Vitest gives it
+//   (./duree.reporter.mjs), `npm run verifier` reads it (scripts/verifier.mjs), and so do the
+//   integration, the queue and the night.
+//
+//   npx grillhouse pression attendre
+//
+// waits for rest (`attendreLeRepos`, bound 15 min) and exits 0 at rest, 75 at the bound: the night
+// waits so before it plays its time budget benches again (scripts/nuit.sh).
+import { readFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+export const SEUIL_PRESSION = 25;
+export const A_REPASSER = 75;
+export const FICHIER_PRESSION = '/proc/pressure/cpu';
+// The longest wait for rest, and the shortest gap between two lines that say it waits.
+export const BORNE_ATTENTE_MS = 15 * 60_000;
+const ECART_LIGNES_MS = 30_000;
+
+// The pressure `some avg10` of <fichier>, in %, or null when it does not read.
+export function lirePression(fichier = process.env.GRILLHOUSE_PRESSION_CPU || FICHIER_PRESSION) {
+  try {
+    const m = /^some\b.*\bavg10=(\d+(?:\.\d+)?)/m.exec(readFileSync(fichier, 'utf8'));
+    return m ? Number(m[1]) : null;
+  } catch {
+    return null;
+  }
+}
+
+// A pressure written for a line: « 31.2 % », or « illisible ».
+export const ecrirePression = p => (p === null ? 'illisible' : `${p.toFixed(1)} %`);
+
+// Sleeps <ms> milliseconds, the process held.
+export const dormir = ms => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+
+// Waits until the pressure (`lire`) is under the threshold, or until the instant <limite>
+// (`maintenant`, in ms). Says the pressure (`dire`) while it waits, one line per 30 s at most.
+// True at rest, false at the bound; a pressure that does not read ends the wait (true), said.
+export function attendreLeRepos({
+  lire = () => lirePression(),
+  maintenant = () => Date.now(),
+  dormir: dort = dormir,
+  limite,
+  pasMs = 2_000,
+  dire,
+}) {
+  let derniere = -Infinity;
+  for (;;) {
+    const p = lire();
+    if (p === null) {
+      dire('⏳ pression CPU illisible : la relance part sans attendre, verdict de Vitest.');
+      return true;
+    }
+    if (p < SEUIL_PRESSION) return true;
+    const t = maintenant();
+    if (t >= limite) return false;
+    if (t - derniere >= ECART_LIGNES_MS) {
+      const reste = Math.ceil((limite - t) / 60_000);
+      dire(
+        `⏳ pression CPU ${ecrirePression(p)} (seuil ${SEUIL_PRESSION} %) : attente du repos, ${reste} min au plus.`
+      );
+      derniere = t;
+    }
+    dort(Math.min(pasMs, limite - t));
+  }
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
+  if (process.argv[2] !== 'attendre') {
+    process.stderr.write('usage: pression.mjs attendre\n');
+    process.exitCode = 2;
+  } else {
+    const dire = l => process.stdout.write(`${l}\n`);
+    const repos = attendreLeRepos({ limite: Date.now() + BORNE_ATTENTE_MS, dire });
+    if (!repos) dire(`⏳ pas de repos en ${BORNE_ATTENTE_MS / 60_000} min.`);
+    process.exitCode = repos ? 0 : A_REPASSER;
+  }
+}

package/scripts/vitest-config/resultats.mjs

@@ -0,0 +1,23 @@
+// The JSON report of Vitest in the results directory of a run (scripts/resultats.mjs, which reads
+// it): the variable that names that directory, `GRILLHOUSE_RESULTATS`, and the reporter the base
+// configuration adds while it is set (./base.mjs). Without it, Vitest writes no report.
+//
+// - Each run of Vitest writes its report to `<dossier>/vitest/<name>.json`, the name made of the
+//   package directory it runs in and its process: two packages, or the same one twice, never write
+//   the same file.
+// - The variable passes through Turborepo without entering any hash (`globalPassThroughEnv` of the
+//   root's turbo.json, which scripts/turbo-des-paquets.mjs writes and checks).
+import path from 'node:path';
+
+export const RESULTATS = 'GRILLHOUSE_RESULTATS';
+// The subdirectory of the reports of Vitest in a results directory.
+export const VITEST = 'vitest';
+
+// The reporter of the JSON report under <env>'s results directory, as Vitest's `reporters` take
+// it; an empty list without the variable.
+export function rapportJson(env = process.env, dossier = process.cwd()) {
+  const resultats = env[RESULTATS];
+  if (!resultats) return [];
+  const nom = `${dossier.split(path.sep).filter(Boolean).join('-') || 'racine'}-${process.pid}.json`;
+  return [['json', { outputFile: path.join(resultats, VITEST, nom) }]];
+}

package/scripts/vitest-config/resultats.setup.mjs

@@ -0,0 +1,19 @@
+// A setup file of the base configuration: a test file's results are its own, as Bazel gives each
+// test its own outputs directory (TEST_UNDECLARED_OUTPUTS_DIR). While the run names its results
+// directory (`GRILLHOUSE_RESULTATS`, ./resultats.mjs), the file names for every process it starts
+// a directory of its own, `<dossier>/essais/<process>-<token>/`, which no reader of the run reads
+// (scripts/resultats.mjs reads `vitest/`, `sarif/` and `turbo/`): a Vitest, a `npm run verifier`
+// or a circuit that a test plays in a repository of trial writes its results there, and its reds
+// never count in the pass that plays it. The reporters of the run, set up in its main process,
+// keep the run's own directory. Without the variable, nothing changes.
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { RESULTATS } from './resultats.mjs';
+
+if (process.env[RESULTATS]) {
+  process.env[RESULTATS] = path.join(
+    process.env[RESULTATS],
+    'essais',
+    `${process.pid}-${randomUUID()}`
+  );
+}

package/scripts/vitest.nuit.config.mjs

@@ -0,0 +1,26 @@
+// The night tests of a project: the files `*.nuit.test.*` and `*.nuit.spec.*`, too long for the
+// day, and its time budget benches (`*.budget.test.*`, `*.budget.spec.*`), whose measures move with
+// the load of the day; `npm test`, `npm run verifier` and the integration leave them out (the
+// frame's base configuration of the day, the package @roomi-fields/grillhouse/vitest-config, which every day
+// configuration extends, excludes both). The night (scripts/nuit.sh) plays them with this
+// configuration, from the root of its copy (`vitest run --root <copy> --config <this file>`),
+// after a green full pass (`npm run verifier -- --force`) and before the project's night script.
+// It reads no day configuration of the project, whether the project has one at its root or one
+// per package; it takes from the base configuration the common environment (git's settings) and
+// the measure of time: the setup file that notes the CPU pressure of each test and the duration
+// reporter, which gives 75, « à repasser », to a bench that fails under load
+// (scripts/vitest-config/duree.reporter.mjs).
+import base from './vitest-config/base.mjs';
+import { HORS_DU_JOUR } from './vitest-config/cibles.mjs';
+
+export default {
+  test: {
+    env: base.test.env,
+    environment: base.test.environment,
+    reporters: base.test.reporters,
+    setupFiles: base.test.setupFiles,
+    include: HORS_DU_JOUR,
+    exclude: ['**/node_modules/**', '**/dist/**', '**/.git/**'],
+    watch: false,
+  },
+};