@codyswann/lisa 4.44.0 → 4.45.0

package/all/copy-overwrite/scripts/lib/gate-failure-diagnosis.mjs

@@ -29,8 +29,8 @@
  * measurement when the suite that produced it finished.
  * @module lib/gate-failure-diagnosis
  */
-import { readFileSync } from "node:fs";
-import { availableParallelism, loadavg } from "node:os";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { availableParallelism, loadavg, tmpdir } from "node:os";
 
 /** Default load-average source for {@link machineLoad}. */
 const osLoadavg = () => loadavg();
@@ -288,13 +288,10 @@ const TAIL_LINES = 3;
  * @param {string[]} items Every item found.
  * @returns {string[]} At most `MAX_EVIDENCE + 1` lines.
  */
-function capped(items) {
+function capped(items, limit = MAX_EVIDENCE) {
   const unique = [...new Set(items)];
-  if (unique.length <= MAX_EVIDENCE) return unique;
-  return [
-    ...unique.slice(0, MAX_EVIDENCE),
-    `…and ${unique.length - MAX_EVIDENCE} more`,
-  ];
+  if (unique.length <= limit) return unique;
+  return [...unique.slice(0, limit), `…and ${unique.length - limit} more`];
 }
 
 /**
@@ -349,18 +346,37 @@ function tailLines(output) {
 
 /**
  * A timeout verdict, worded so it can never be mistaken for a coverage miss.
+ *
+ * Carries the shared temp root's population, because a blown wall-clock budget
+ * is the one signature that gives no hint of its own cause. A saturated
+ * platform temp root makes every `mkdtemp` on the box slow, and the lane that
+ * pays is whichever one happened to create fixtures — so it presents as a
+ * single flaky-looking test in a suite that has nothing to do with the
+ * producer. The reading is attached here and nowhere else for that reason: on
+ * an assertion failure or a coverage miss it would be noise.
  * @param {{count: number, budgets: number[]}} timeouts What was found.
  * @param {string[]} suites Suites the output named as failing.
+ * @param {TempRootReading|null} [tempRoot] The temp root's population at
+ *   diagnosis time. Omitted or null when it could not be read.
  * @returns {Diagnosis} The verdict.
  */
-function timeoutVerdict(timeouts, suites) {
+function timeoutVerdict(timeouts, suites, tempRoot) {
   const budget = Math.max(...timeouts.budgets);
+  // Reserve the temp-root line's slot BEFORE capping the suites, so this
+  // verdict carries the same MAX_EVIDENCE + 1 ceiling as every other one.
+  // Appending after the cap made this the only verdict that could reach
+  // MAX_EVIDENCE + 2, and the cap test could not see it because that test
+  // suppresses the reading.
+  const tempEvidence = tempRootEvidence(tempRoot ?? null);
   return {
     kind: DIAGNOSIS.TIMEOUT,
     summary:
       `${timeouts.count} test(s)/hook(s) exceeded the ${budget}ms budget, ` +
       `so the suite did not finish — this is NOT a coverage shortfall`,
-    evidence: capped(suites),
+    evidence: [
+      ...capped(suites, MAX_EVIDENCE - tempEvidence.length),
+      ...tempEvidence,
+    ],
   };
 }
 
@@ -627,6 +643,102 @@ function loadEvidence(load) {
       ];
 }
 
+/**
+ * List the platform temp root's direct children.
+ *
+ * Deliberately NOT recursive. The cost being measured is the width of one
+ * directory — what `mkdtemp` and every `readdir` on that path must walk — and
+ * descending into tens of thousands of entries to diagnose a failure would
+ * itself be the expensive operation this line exists to warn about.
+ * @returns {string[]} Direct children of the platform temp root.
+ */
+function defaultTempRootEntries() {
+  return readdirSync(tmpdir());
+}
+
+/**
+ * Read the platform temp root's own inode size.
+ * @returns {number} Size in bytes of the directory inode itself.
+ */
+function defaultTempRootInodeBytes() {
+  return statSync(tmpdir()).size;
+}
+
+/**
+ * How crowded the shared platform temp root is, or `null` when unreadable.
+ * @typedef {object} TempRootReading
+ * @property {number} entries Direct children of the platform temp root.
+ * @property {number} inodeBytes Size of the directory's own inode.
+ */
+
+/**
+ * Measure the shared platform temp root.
+ *
+ * Both numbers are taken because they answer different questions and only one
+ * of them is repairable by deleting things. The ENTRY COUNT is the current
+ * population. The INODE SIZE is what that population did to the directory, and
+ * a directory inode does not shrink when its entries are removed — so a root
+ * that once held tens of thousands of names stays expensive to walk after a
+ * prune, and a report that showed only the count would say "cleaned up" about
+ * a directory that is still slow.
+ *
+ * Injected for the same reason {@link machineLoad} is: a test must be able to
+ * state a population rather than inherit whatever the test machine's temp root
+ * happened to contain, which is shared with every other process on the box.
+ * @param {() => string[]} [readEntries] Lists the temp root's children.
+ * @param {() => number} [readInodeBytes] Reads the temp root's own inode size.
+ * @returns {TempRootReading|null} The reading, or null when either source fails.
+ */
+export function tempRootPopulation(
+  readEntries = defaultTempRootEntries,
+  readInodeBytes = defaultTempRootInodeBytes
+) {
+  try {
+    const entries = readEntries().length;
+    const inodeBytes = readInodeBytes();
+    if (!Number.isFinite(entries) || !Number.isFinite(inodeBytes)) return null;
+    return { entries, inodeBytes };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Turn a temp-root reading into the line that lets an operator rule crowding
+ * in or out.
+ *
+ * REPORTS, NEVER JUDGES — and that is a measured decision rather than caution.
+ * A crowded platform temp root makes `mkdtemp` pathologically slow, which
+ * surfaces as one slow test in an unrelated lane and never as "the filesystem
+ * is the problem", so the number belongs beside a timeout. But the threshold
+ * at which it starts costing anything is NOT KNOWN: 16.5k entries measured at
+ * a 1.0x `mkdtemp` penalty against a nested directory — i.e. none at all — on
+ * the same platform where ~46k was reported harmful. Nothing measured in
+ * between.
+ *
+ * Guessing a boundary in that gap would produce a detector that fires on the
+ * ordinary state of a busy workstation, and a check that cries wolf on a
+ * healthy machine is worse than no check: it trains its own readers to skip
+ * the line. So this prints what it saw and names both calibration points,
+ * leaving the reader to decide — and accumulates the evidence a later change
+ * can set a real threshold from.
+ * @param {TempRootReading|null} tempRoot The reading, or null when unavailable.
+ * @returns {string[]} Zero or one evidence line.
+ */
+function tempRootEvidence(tempRoot) {
+  if (tempRoot === null) return [];
+  const kb = Math.round(tempRoot.inodeBytes / 1024);
+  return [
+    `shared temp root at diagnosis: ${tempRoot.entries} entries, ` +
+      `${kb} KB directory inode. A crowded platform temp root slows every ` +
+      `mkdtemp on the box and shows up as one slow test in an unrelated ` +
+      `lane, so this is a candidate cause to rule in or out — not a verdict. ` +
+      `No threshold is asserted because none is known: ~16.5k entries ` +
+      `measured NO penalty and ~46k was reported harmful, with nothing ` +
+      `measured between. The inode size is the part a prune does not fix.`,
+  ];
+}
+
 /**
  * Runnable work per core above which the box is treated as saturated.
  *
@@ -707,7 +819,7 @@ function emptyTranscriptVerdict() {
  * @param {LoadReading|null} load The machine's load at diagnosis time.
  * @returns {object} What the failure was, before it is attributed.
  */
-function classify(output, code, load, read) {
+function classify(output, code, load, read, tempRoot) {
   if (wasKilled(code)) return killedVerdict(code ?? null, load);
 
   if (typeof output !== "string") return unavailableVerdict();
@@ -754,7 +866,16 @@ function classify(output, code, load, read) {
   const failures = findFailures(output);
   const misses = findThresholdMisses(output);
 
-  if (timeouts.count > 0) return timeoutVerdict(timeouts, failures.suites);
+  if (timeouts.count > 0)
+    return timeoutVerdict(
+      timeouts,
+      failures.suites,
+      // Resolved HERE and nowhere else: this is the only consumer, and it is
+      // the last point at which `undefined` (measure it) and `null` (suppress
+      // it) are still distinguishable. Do not "simplify" this to `??` — that
+      // collapses the two and makes every suppressed test read the real box.
+      tempRoot === undefined ? tempRootPopulation() : tempRoot
+    );
 
   if ((failures.tally ?? 0) > 0 || failures.suites.length > 0) {
     const count = failures.tally ?? failures.suites.length;
@@ -1067,14 +1188,35 @@ function findTerminatedComments(output, read) {
  * @param {(path: string) => string|null} [read] Reads a source file the
  *   transcript named, returning null when it cannot be read. Defaults to the
  *   real filesystem; injected by tests so a fixture needs no files on disk.
+ * @param {TempRootReading|null} [tempRoot] The shared temp root's population,
+ *   for a timeout's evidence line. OMIT to measure this machine — but the
+ *   measurement is taken lazily, only on the timeout path that consumes it.
+ *   Pass `null` to suppress the line, or a fixed reading to make output
+ *   deterministic.
+ *
+ *   This is deliberately NOT a default parameter. A default is evaluated on
+ *   every call that omits the argument, so `tempRoot = tempRootPopulation()`
+ *   ran a `readdirSync` plus a `statSync` over the shared temp root for every
+ *   assertion failure, coverage miss and kill — none of which use the reading.
+ *   On a box whose temp root holds tens of thousands of entries that is not
+ *   free, and the irony is total: this was added by the change about temp-root
+ *   churn. Nothing in the suite could catch it, because cost is not asserted.
+ *
+ *   Making the default lazier does NOT work, and that is the trap: a default
+ *   parameter cannot distinguish OMITTED from EXPLICITLY NULL, because both
+ *   arrive as `undefined`/`null` at different points and only `undefined`
+ *   triggers a default. `null` is the documented suppression that keeps test
+ *   output deterministic, so it must survive. Hence the resolution moved to
+ *   the single consuming call site, where the two are still distinguishable.
  * @returns {Diagnosis} What the failure was, and whose it was.
  */
 export function diagnoseFailure(
   output,
   code,
   load = machineLoad(),
-  read = readSourceFile
+  read = readSourceFile,
+  tempRoot
 ) {
-  const verdict = classify(output, code, load, read);
+  const verdict = classify(output, code, load, read, tempRoot);
   return { ...verdict, proves: ATTRIBUTION[verdict.kind] ?? null };
 }

package/dist/configs/vitest/coverage-reports-directory.d.ts

@@ -30,6 +30,76 @@ export declare const COVERAGE_REPORTS_DIR_ENV = "LISA_COVERAGE_REPORTS_DIR";
  * @returns Root-relative path, POSIX-separated as Vitest's own default is.
  */
 export declare function coverageRunDirectory(owner: number, startedAt: number, suffix: string): string;
+/**
+ * Publish one finished run's artifacts to the stable directory, then drop it.
+ *
+ * ## Why isolation alone is not enough
+ *
+ * `reportsDirectory` is the only lever the provider offers, so isolating the
+ * scratch necessarily moves the REPORTS with it. An unpinned run therefore
+ * writes `coverage/.runs/<run>/lcov.info` and never writes `coverage/lcov.info`
+ * again.
+ *
+ * A project upgrading to that behaviour does not get a missing-file error. Its
+ * Sonar keeps reading **the file left there before the upgrade**, indefinitely,
+ * and reports a coverage number that has quietly stopped moving — a wrong value
+ * that looks like a real one, which is the same failure isolation removed from
+ * concurrent runs, relocated one layer out to consumers.
+ *
+ * ## Why this is safe where a mid-run shared directory is not
+ *
+ * Ordering. The provider runs `reportCoverage` -> `generateReports` ->
+ * `cleanAfterRun`, and this runs later still, at process exit. It therefore
+ * moves COMPLETED files, never files a writer is partway through — which is
+ * precisely the distinction that makes the shared-directory `rm` destructive
+ * and this move benign.
+ *
+ * Two concurrent runs publishing together is last-writer-wins per file, and can
+ * leave `lcov.info` from one beside `index.html` from another. That cost is
+ * accepted deliberately: each run still reported its own correct number, and
+ * nothing here can delete a directory another run is writing into.
+ * @param directory - Reports directory as {@link coverageReportsDirectory} returned it
+ * @param expectedName - The run-directory basename this process minted
+ * @returns True when this run's own directory was published and removed
+ */
+export declare function publishCoverageRunDirectory(directory: string, expectedName: string): boolean;
+/**
+ * Remove a run directory this process minted, and nothing else.
+ *
+ * The fallback when publishing could not happen, and the guard is the same one:
+ * the basename must be the name this process generated, so a mis-wired caller
+ * removes nothing rather than removing a directory another run is writing into.
+ * @param directory - Reports directory as {@link coverageReportsDirectory} returned it
+ * @param expectedName - The run-directory basename this process minted
+ * @returns True when the path was this run's own
+ */
+export declare function removeOwnCoverageRunDirectory(directory: string, expectedName: string): boolean;
+/**
+ * Remove run directories belonging to runs that are no longer alive.
+ *
+ * Publishing happens at process exit, so an ordinary run leaves nothing behind.
+ * A run that is `SIGKILL`ed does — and on a contended machine that is routine
+ * rather than exceptional, so without this `coverage/.runs/` accrues one
+ * directory per killed run with nothing ever removing them.
+ *
+ * ## Why liveness is legitimate here and not in a lock
+ *
+ * Reclaiming an abandoned directory is not adjudicating ownership of a
+ * contended resource, and the asymmetry is what makes it safe: a false KEEP is
+ * inert debris, and a false REMOVE is impossible, because a live run's own pid
+ * always probes alive. The lock this module refuses has the opposite asymmetry
+ * — there, a wrong answer releases a lock somebody is holding.
+ *
+ * It introduces no second authority. {@link parseRunRootName} and
+ * {@link isProcessAlive} are the scratch namespace's existing parser and
+ * liveness probe, and these directories are named by {@link runRootName}, so
+ * that parser reads them unchanged. Anything it does not recognise is left
+ * alone.
+ * @param runsRoot - Directory holding the run directories
+ * @param alive - Liveness probe; defaults to the shared one
+ * @returns Basenames of the directories removed
+ */
+export declare function reclaimAbandonedCoverageRunDirectories(runsRoot?: string, alive?: (owner: number) => boolean): readonly string[];
 /**
  * Resolves the coverage reports directory for this run.
  * @param environment - Environment to read; defaults to this process's.

package/dist/configs/vitest/coverage-reports-directory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coverage-reports-directory.d.ts","sourceRoot":"","sources":["../../../src/configs/vitest/coverage-reports-directory.ts"],"names":[],"mappings":"AAiEA;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,UAAU,CAAC;AAEzC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,8BAA8B,CAAC;AAKpE;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,MAAM,CAER;AAYD;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,GAAE,MAAM,CAAC,UAAgB,GACnC,MAAM,CAUR;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD"}
+{"version":3,"file":"coverage-reports-directory.d.ts","sourceRoot":"","sources":["../../../src/configs/vitest/coverage-reports-directory.ts"],"names":[],"mappings":"AAuEA;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,UAAU,CAAC;AAEzC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,8BAA8B,CAAC;AAkBpE;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,OAAO,CAyBT;AAED;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,OAAO,CAWT;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sCAAsC,CACpD,QAAQ,GAAE,MAAoD,EAC9D,KAAK,GAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAwB,GACjD,SAAS,MAAM,EAAE,CAenB;AAYD;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,GAAE,MAAM,CAAC,UAAgB,GACnC,MAAM,CAcR;AAkCD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,IAAI,IAAI,CAGpD"}

package/dist/configs/vitest/coverage-reports-directory.js

@@ -59,8 +59,11 @@
  * @module configs/vitest/coverage-reports-directory
  */
 import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { env, pid } from "node:process";
-import { runRootName } from "./scratch-namespace-authority.js";
+import { parseRunRootName, runRootName, } from "./scratch-namespace-authority.js";
+import { isProcessAlive } from "./scratch-sweep.js";
 /**
  * Directory under `coverage/` holding one run's isolated output.
  *
@@ -84,6 +87,17 @@ export const COVERAGE_RUNS_DIR = ".runs";
 export const COVERAGE_REPORTS_DIR_ENV = "LISA_COVERAGE_REPORTS_DIR";
 /** Bytes of randomness disambiguating two runs started in the same millisecond. */
 const SUFFIX_BYTES = 4;
+/** The stable directory a checkout's coverage artifacts are read from. */
+const COVERAGE_BASE = "coverage";
+/**
+ * The provider's own scratch subdirectory, named so it is never published.
+ *
+ * `cleanAfterRun` removes it before the process exits, so in practice it is
+ * already gone by the time anything publishes. Skipping it explicitly means a
+ * run killed between report generation and exit cannot copy a half-written
+ * `coverage-<n>.json` up to the stable path, where another run would read it.
+ */
+const COVERAGE_SCRATCH_DIR = ".tmp";
 /**
  * Builds the relative reports directory for one run.
  *
@@ -97,6 +111,134 @@ const SUFFIX_BYTES = 4;
 export function coverageRunDirectory(owner, startedAt, suffix) {
     return `coverage/${COVERAGE_RUNS_DIR}/${runRootName(owner, startedAt, suffix)}`;
 }
+/**
+ * Publish one finished run's artifacts to the stable directory, then drop it.
+ *
+ * ## Why isolation alone is not enough
+ *
+ * `reportsDirectory` is the only lever the provider offers, so isolating the
+ * scratch necessarily moves the REPORTS with it. An unpinned run therefore
+ * writes `coverage/.runs/<run>/lcov.info` and never writes `coverage/lcov.info`
+ * again.
+ *
+ * A project upgrading to that behaviour does not get a missing-file error. Its
+ * Sonar keeps reading **the file left there before the upgrade**, indefinitely,
+ * and reports a coverage number that has quietly stopped moving — a wrong value
+ * that looks like a real one, which is the same failure isolation removed from
+ * concurrent runs, relocated one layer out to consumers.
+ *
+ * ## Why this is safe where a mid-run shared directory is not
+ *
+ * Ordering. The provider runs `reportCoverage` -> `generateReports` ->
+ * `cleanAfterRun`, and this runs later still, at process exit. It therefore
+ * moves COMPLETED files, never files a writer is partway through — which is
+ * precisely the distinction that makes the shared-directory `rm` destructive
+ * and this move benign.
+ *
+ * Two concurrent runs publishing together is last-writer-wins per file, and can
+ * leave `lcov.info` from one beside `index.html` from another. That cost is
+ * accepted deliberately: each run still reported its own correct number, and
+ * nothing here can delete a directory another run is writing into.
+ * @param directory - Reports directory as {@link coverageReportsDirectory} returned it
+ * @param expectedName - The run-directory basename this process minted
+ * @returns True when this run's own directory was published and removed
+ */
+export function publishCoverageRunDirectory(directory, expectedName) {
+    if (path.basename(directory) !== expectedName)
+        return false;
+    const from = path.resolve(process.cwd(), directory);
+    // Two levels up from `<base>/coverage/.runs/<run>` is `<base>/coverage`.
+    // Derived from the run directory rather than from `process.cwd()` so the
+    // pair travels together: a caller that states one has stated both, and a
+    // test can exercise this against a temporary tree without changing
+    // directory.
+    const stable = path.dirname(path.dirname(from));
+    try {
+        if (!fs.existsSync(from))
+            return false;
+        for (const entry of fs.readdirSync(from)) {
+            if (entry === COVERAGE_SCRATCH_DIR)
+                continue;
+            const target = path.join(stable, entry);
+            fs.rmSync(target, { recursive: true, force: true });
+            fs.renameSync(path.join(from, entry), target);
+        }
+        fs.rmSync(from, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        // Best effort. A run that cannot publish its artifacts has still measured
+        // and reported its coverage correctly, and failing over it would turn a
+        // tidiness problem into the red gate this module exists to prevent.
+        return false;
+    }
+}
+/**
+ * Remove a run directory this process minted, and nothing else.
+ *
+ * The fallback when publishing could not happen, and the guard is the same one:
+ * the basename must be the name this process generated, so a mis-wired caller
+ * removes nothing rather than removing a directory another run is writing into.
+ * @param directory - Reports directory as {@link coverageReportsDirectory} returned it
+ * @param expectedName - The run-directory basename this process minted
+ * @returns True when the path was this run's own
+ */
+export function removeOwnCoverageRunDirectory(directory, expectedName) {
+    if (path.basename(directory) !== expectedName)
+        return false;
+    try {
+        fs.rmSync(path.resolve(process.cwd(), directory), {
+            recursive: true,
+            force: true,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove run directories belonging to runs that are no longer alive.
+ *
+ * Publishing happens at process exit, so an ordinary run leaves nothing behind.
+ * A run that is `SIGKILL`ed does — and on a contended machine that is routine
+ * rather than exceptional, so without this `coverage/.runs/` accrues one
+ * directory per killed run with nothing ever removing them.
+ *
+ * ## Why liveness is legitimate here and not in a lock
+ *
+ * Reclaiming an abandoned directory is not adjudicating ownership of a
+ * contended resource, and the asymmetry is what makes it safe: a false KEEP is
+ * inert debris, and a false REMOVE is impossible, because a live run's own pid
+ * always probes alive. The lock this module refuses has the opposite asymmetry
+ * — there, a wrong answer releases a lock somebody is holding.
+ *
+ * It introduces no second authority. {@link parseRunRootName} and
+ * {@link isProcessAlive} are the scratch namespace's existing parser and
+ * liveness probe, and these directories are named by {@link runRootName}, so
+ * that parser reads them unchanged. Anything it does not recognise is left
+ * alone.
+ * @param runsRoot - Directory holding the run directories
+ * @param alive - Liveness probe; defaults to the shared one
+ * @returns Basenames of the directories removed
+ */
+export function reclaimAbandonedCoverageRunDirectories(runsRoot = path.join(COVERAGE_BASE, COVERAGE_RUNS_DIR), alive = isProcessAlive) {
+    const root = path.resolve(process.cwd(), runsRoot);
+    try {
+        const abandoned = fs.readdirSync(root).filter(name => {
+            const owner = parseRunRootName(name);
+            return owner !== undefined && !alive(owner.pid);
+        });
+        for (const name of abandoned)
+            fs.rmSync(path.join(root, name), { recursive: true, force: true });
+        return abandoned;
+    }
+    catch {
+        // An absent or unreadable runs directory is not an error: nothing to
+        // reclaim is the ordinary state on a checkout that has never run coverage.
+        return [];
+    }
+}
 /**
  * The path this process's coverage output belongs in.
  *
@@ -115,9 +257,44 @@ export function coverageReportsDirectory(environment = env) {
     const override = environment[COVERAGE_REPORTS_DIR_ENV];
     if (override !== undefined && override.trim() !== "")
         return override;
-    pinned.current ??= coverageRunDirectory(pid, Date.now(), randomBytes(SUFFIX_BYTES).toString("hex"));
+    if (pinned.current === undefined) {
+        const name = runRootName(pid, Date.now(), randomBytes(SUFFIX_BYTES).toString("hex"));
+        pinned.current = `${COVERAGE_BASE}/${COVERAGE_RUNS_DIR}/${name}`;
+        registerRunLifecycle(pinned.current, name);
+    }
     return pinned.current;
 }
+/**
+ * Whether this process has already armed its reclaim and publish steps.
+ *
+ * Field named `current` to match {@link pinned}, and not by accident: the
+ * project's `functional/immutable-data` rule permits mutation only through
+ * `*.current`, `*.value` and `*.displayName`. Renaming it makes the file
+ * stop linting.
+ */
+const lifecycle = { current: false };
+/**
+ * Reclaim abandoned directories now, and publish this run's own at exit.
+ *
+ * Armed once per process, from the same place the directory is minted, so the
+ * two cannot disagree about which run they belong to. A pinned run never
+ * reaches here: the pinned directory belongs to whoever set the pin, and is
+ * left exactly as it was found.
+ * @param directory - This run's reports directory
+ * @param name - Its basename, which is the ownership proof both steps check
+ */
+function registerRunLifecycle(directory, name) {
+    if (lifecycle.current)
+        return;
+    lifecycle.current = true;
+    // Before minting anything of our own: this run's directory does not exist
+    // yet and its pid is alive regardless, so it can never be its own victim.
+    reclaimAbandonedCoverageRunDirectories();
+    process.once("exit", () => {
+        if (!publishCoverageRunDirectory(directory, name))
+            removeOwnCoverageRunDirectory(directory, name);
+    });
+}
 /**
  * Discards the memoized value.
  *
@@ -127,5 +304,6 @@ export function coverageReportsDirectory(environment = env) {
  */
 export function resetCoverageReportsDirectory() {
     pinned.current = undefined;
+    lifecycle.current = false;
 }
 //# sourceMappingURL=coverage-reports-directory.js.map

package/dist/configs/vitest/coverage-reports-directory.js.map

@@ -1 +1 @@
-{"version":3,"file":"coverage-reports-directory.js","sourceRoot":"","sources":["../../../src/configs/vitest/coverage-reports-directory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAExC,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,OAAO,CAAC;AAEzC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,2BAA2B,CAAC;AAEpE,mFAAmF;AACnF,MAAM,YAAY,GAAG,CAAC,CAAC;AAEvB;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAa,EACb,SAAiB,EACjB,MAAc;IAEd,OAAO,YAAY,iBAAiB,IAAI,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,CAAC;AAClF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,GAAoC,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;AAEvE;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CACtC,cAAiC,GAAG;IAEpC,MAAM,QAAQ,GAAG,WAAW,CAAC,wBAAwB,CAAC,CAAC;IACvD,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,QAAQ,CAAC;IAEtE,MAAM,CAAC,OAAO,KAAK,oBAAoB,CACrC,GAAG,EACH,IAAI,CAAC,GAAG,EAAE,EACV,WAAW,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAC1C,CAAC;IACF,OAAO,MAAM,CAAC,OAAO,CAAC;AACxB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,6BAA6B;IAC3C,MAAM,CAAC,OAAO,GAAG,SAAS,CAAC;AAC7B,CAAC"}
+{"version":3,"file":"coverage-reports-directory.js","sourceRoot":"","sources":["../../../src/configs/vitest/coverage-reports-directory.ts"],"names":[],"mappings":"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"}

package/dist/core/lisa-owned-hash-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA+jCjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAk+BjC,CAAC"}
+{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAikCjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAo+BjC,CAAC"}

package/dist/core/lisa-owned-hash-ledger.js

@@ -358,8 +358,10 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "041094be579c3aefdf9f7b384e24ca23cd860c984c9094ffeb55b1542829bc39",
         "28600bd3ce643d80aefcc696c4e9607f83410ab926738d9baa7db694d78563ea",
         "3e9a5911c9b4b4f3c0dd6aef4ecc7accb762edf6e62eea66252248f7c02684f4",
+        "43dc203de647ebdcd0e3e1878240423e3895b588372002c79ffed3348e4f08a3",
         "4503ddbe7bd54cd553db2b5952972d5319d6b6eb39a258b7c58577b61c7e7ce7",
         "503b51e9239411d07ce6b51dbe2b3079bb12e94bf7c0310e76247af19ff667e6",
+        "5d0aee00b95dba43cae499f338358ad4b0286f869c993508c1146448e92bd777",
         "6742cc12ea14fc99b7bef31ff03df68d5c4610b56fad43107790372e6d777eb1",
         "6b72a6a71078c838fdb0531e74898a5e36d942cad424b20480e2cd370b5264eb",
         "7ffcd3f6a0595ae26c697bb0f77044b8a100200985774ad7059ebc3dc2e6bedd",
@@ -1440,8 +1442,10 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "041094be579c3aefdf9f7b384e24ca23cd860c984c9094ffeb55b1542829bc39",
         "28600bd3ce643d80aefcc696c4e9607f83410ab926738d9baa7db694d78563ea",
         "3e9a5911c9b4b4f3c0dd6aef4ecc7accb762edf6e62eea66252248f7c02684f4",
+        "43dc203de647ebdcd0e3e1878240423e3895b588372002c79ffed3348e4f08a3",
         "4503ddbe7bd54cd553db2b5952972d5319d6b6eb39a258b7c58577b61c7e7ce7",
         "503b51e9239411d07ce6b51dbe2b3079bb12e94bf7c0310e76247af19ff667e6",
+        "5d0aee00b95dba43cae499f338358ad4b0286f869c993508c1146448e92bd777",
         "6742cc12ea14fc99b7bef31ff03df68d5c4610b56fad43107790372e6d777eb1",
         "7ffcd3f6a0595ae26c697bb0f77044b8a100200985774ad7059ebc3dc2e6bedd",
         "9bce79d2cdcf709be40fee1bec469796bee2bb06a4cd38b11905677b97c12bc3",