@codyswann/lisa 4.44.0 → 4.44.1

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/nightly-e2e-guard-behavior-certificate.js

@@ -34,9 +34,9 @@ export const NIGHTLY_E2E_GUARD_BEHAVIOR_CERTIFICATES = Object.freeze({
     }),
     dfd2fef680de5ef03e63075e8a61c62ca4d95cdfdff6201939b79c748d3397f6: Object.freeze({
         contractVersion: "1.9.0",
-        packageVersions: Object.freeze(["4.44.0"]),
+        packageVersions: Object.freeze(["4.44.1"]),
         provenances: Object.freeze([
-            "workspace package @codyswann/lisa@4.44.0 (typescript/copy-overwrite/scripts/check-nightly-e2e-health.mjs)",
+            "workspace package @codyswann/lisa@4.44.1 (typescript/copy-overwrite/scripts/check-nightly-e2e-health.mjs)",
         ]),
     }),
 });

package/dist/core/upstream-evidence-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upstream-evidence-manifest.d.ts","sourceRoot":"","sources":["../../src/core/upstream-evidence-manifest.ts"],"names":[],"mappings":"AACA,iFAAiF;AACjF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwkFpE,CAAC;AAEL,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAy0QjE,CAAC;AAEL,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAk6I/D,CAAC"}
+{"version":3,"file":"upstream-evidence-manifest.d.ts","sourceRoot":"","sources":["../../src/core/upstream-evidence-manifest.ts"],"names":[],"mappings":"AACA,iFAAiF;AACjF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwkFpE,CAAC;AAEL,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CA00QjE,CAAC;AAEL,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAk6I/D,CAAC"}

package/dist/core/upstream-evidence-manifest.js

@@ -8494,6 +8494,7 @@ export const UPSTREAM_SURFACE_MANIFEST = Object.freeze({
     "tests/unit/config/coderabbit-labeling-scope.test.ts": true,
     "tests/unit/config/conflict-prover-consumer-layouts.test.ts": true,
     "tests/unit/config/coverage-include-guard.test.ts": true,
+    "tests/unit/config/coverage-publish-reclaim.test.ts": true,
     "tests/unit/config/coverage-scratch-isolation.test.ts": true,
     "tests/unit/config/coverage-unit-scope-thresholds.test.ts": true,
     "tests/unit/config/coverage-unit-script-runner-parity.test.ts": true,