vouchington-tooling 0.20.0 → 0.22.0

package/dist/vitest-diagnostics/vitest-fork-exit-records.d.mts

@@ -0,0 +1,26 @@
+export type ForkExitRecordMode = 'exit' | 'uncaught' | 'unhandled' | `signal:${NodeJS.Signals}`;
+export type ForkExitSentinelRecord = {
+    kind: 'start';
+    pid: number;
+} | {
+    kind: 'exit';
+    pid: number;
+    project: string;
+    module: string;
+    mode: ForkExitRecordMode;
+    code: number;
+    errorMessage?: string;
+    errorStack?: string;
+};
+export declare function writeForkExitRecord(directory: string, record: ForkExitSentinelRecord): void;
+export declare function readForkExitRecords(dir: string): ForkExitSentinelRecord[];
+export declare function clearForkExitRecords(dir: string): void;
+export interface ForkExitRecordSummary {
+    startedPidCount: number;
+    exitRecords: Extract<ForkExitSentinelRecord, {
+        kind: 'exit';
+    }>[];
+    forksWithoutExitSentinel: number;
+}
+export declare function summarizeForkExitRecords(records: ForkExitSentinelRecord[]): ForkExitRecordSummary;
+export declare function formatForkExitSentinelSection(summary: ForkExitRecordSummary): string[];

package/dist/vitest-diagnostics/vitest-fork-exit-records.mjs

@@ -0,0 +1,161 @@
+// Each fork writes start and exit records to its own `<pid>.jsonl` file. A start without an exit
+// identifies a death before the sentinel handler ran. Synchronous writes avoid async pipe loss.
+import { closeSync, constants, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, unlinkSync, writeSync, } from 'node:fs';
+import { join } from 'node:path';
+import { sanitizeInlineErrorMessage } from './vitest-fork-exit-error-detail.mjs';
+const recordFileFds = new Map();
+function recordFileDescriptor(directory) {
+    const cached = recordFileFds.get(directory);
+    if (cached !== undefined)
+        return cached;
+    try {
+        mkdirSync(directory, { recursive: true });
+        if (!lstatSync(directory).isDirectory())
+            return null;
+        const fd = openSync(join(directory, `${process.pid}.jsonl`), constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW, 0o600);
+        recordFileFds.set(directory, fd);
+        return fd;
+    }
+    catch {
+        // Best-effort: a read-only or missing directory must not turn attribution into a crash. The
+        // fd-2 [vitest-fork-exit] line stays the primary signal; this file is a durable supplement.
+        return null;
+    }
+}
+export function writeForkExitRecord(directory, record) {
+    const fd = recordFileDescriptor(directory);
+    if (fd === null)
+        return;
+    try {
+        writeSync(fd, `${JSON.stringify(record)}\n`);
+    }
+    catch {
+        // Same best-effort rationale as recordFileDescriptor() above.
+    }
+}
+export function readForkExitRecords(dir) {
+    const records = [];
+    for (const filename of recordFileNames(dir)) {
+        parseRecordLines(readFileSafely(join(dir, filename)), records);
+    }
+    return records;
+}
+export function clearForkExitRecords(dir) {
+    const fd = recordFileFds.get(dir);
+    if (fd !== undefined) {
+        closeSync(fd);
+        recordFileFds.delete(dir);
+    }
+    for (const filename of recordFileNames(dir)) {
+        try {
+            const path = join(dir, filename);
+            if (lstatSync(path).isFile())
+                unlinkSync(path);
+        }
+        catch {
+            // A concurrently exiting worker may have removed its file already.
+        }
+    }
+}
+function recordFileNames(dir) {
+    try {
+        if (!lstatSync(dir).isDirectory())
+            return [];
+        return readdirSync(dir).filter((name) => /^\d+\.jsonl$/.test(name));
+    }
+    catch {
+        return [];
+    }
+}
+export function summarizeForkExitRecords(records) {
+    const startedPids = new Set();
+    const exitRecordsByPid = new Map();
+    for (const record of records) {
+        if (record.kind === 'start')
+            startedPids.add(record.pid);
+        else
+            exitRecordsByPid.set(record.pid, record);
+    }
+    const forksWithoutExitSentinel = [...startedPids].filter((pid) => !exitRecordsByPid.has(pid)).length;
+    return {
+        startedPidCount: startedPids.size,
+        exitRecords: [...exitRecordsByPid.values()],
+        forksWithoutExitSentinel,
+    };
+}
+const MAX_SENTINEL_EXIT_RECORDS = 20;
+// Consumed by vitest-worker-exit-diagnostics-reporter.mts's onTestRunEnd — kept here rather than
+// there so the record shape and its presentation stay next to each other.
+export function formatForkExitSentinelSection(summary) {
+    const lines = [
+        `forks started: ${summary.startedPidCount}`,
+        `forks without an exit sentinel: ${summary.forksWithoutExitSentinel}`,
+        'sentinel exit records:',
+    ];
+    if (summary.exitRecords.length === 0) {
+        lines.push('  (none recorded)');
+        return lines;
+    }
+    for (const record of summary.exitRecords.slice(0, MAX_SENTINEL_EXIT_RECORDS)) {
+        lines.push(`  - pid=${record.pid} project=${sanitizeInlineErrorMessage(record.project)} module=${sanitizeInlineErrorMessage(record.module)} mode=${record.mode} code=${record.code}`);
+        // sanitizeInlineErrorMessage collapses the record's raw, unbounded message to one line: this
+        // report is written straight into a test log, so a raw multi-line Error.message could forge
+        // fresh physical lines that a line-anchored log predicate reads as real output.
+        if (record.errorMessage)
+            lines.push(`    error: ${sanitizeInlineErrorMessage(record.errorMessage)}`);
+        if (record.errorStack)
+            lines.push(`    stack: ${sanitizeInlineErrorMessage(record.errorStack.slice(0, 500))}`);
+    }
+    if (summary.exitRecords.length > MAX_SENTINEL_EXIT_RECORDS) {
+        lines.push(`  ... ${summary.exitRecords.length - MAX_SENTINEL_EXIT_RECORDS} more`);
+    }
+    return lines;
+}
+function readFileSafely(path) {
+    try {
+        const stat = lstatSync(path);
+        if (!stat.isFile() || stat.size > 1024 * 1024)
+            return '';
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function parseRecordLines(content, into) {
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const record = JSON.parse(line);
+            if (isForkExitRecord(record))
+                into.push(record);
+        }
+        catch {
+            // A torn trailing line from a fork still mid-write when this is read; skip it rather than
+            // fail the whole roll-up over one partial record.
+        }
+    }
+}
+function isForkExitRecord(value) {
+    if (!isRecord(value))
+        return false;
+    if (!Number.isSafeInteger(value.pid) || value.pid <= 0)
+        return false;
+    if (value.kind === 'start')
+        return true;
+    return (value.kind === 'exit' &&
+        typeof value.project === 'string' &&
+        typeof value.module === 'string' &&
+        typeof value.mode === 'string' &&
+        (value.mode === 'exit' ||
+            value.mode === 'uncaught' ||
+            value.mode === 'unhandled' ||
+            /^signal:SIG[A-Z0-9]+$/.test(value.mode)) &&
+        Number.isSafeInteger(value.code) &&
+        (value.errorMessage === undefined || typeof value.errorMessage === 'string') &&
+        (value.errorStack === undefined || typeof value.errorStack === 'string'));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/vitest-diagnostics/vitest-fork-exit-sentinel.d.mts

@@ -0,0 +1,14 @@
+declare global {
+    namespace NodeJS {
+        interface Process {
+            reallyExit(code?: number): never;
+        }
+    }
+}
+export type ForkExitSentinelOptions = {
+    recordDirectory: string;
+};
+export declare function setCurrentForkExitModule(modulePath: string | null): void;
+export declare function setCurrentForkExitProject(projectName: string | undefined): void;
+export declare function formatPercent(part: number, whole: number): string;
+export declare function registerForkExitSentinel(options: ForkExitSentinelOptions): void;

package/dist/vitest-diagnostics/vitest-fork-exit-sentinel.mjs

@@ -0,0 +1,131 @@
+// Registers, inside a Vitest fork, the last line of defense for naming how that fork died.
+//
+// The parent-side worker-exit error may lack the child's exit code and signal. This module writes
+// one synchronous line from inside the dying fork before the parent reports its failure.
+//
+// Every write goes through `writeSync(2, …)` rather than `process.stderr.write` — the async stderr
+// pipe may lose data on an abrupt kill. A synchronous fd-2 write survives everything short of
+// SIGKILL/SIGSEGV/a hard V8 abort — and the *absence* of this line for a fork Vitest reports as
+// unexpectedly exited is itself the diagnostic: it proves a handler-unreachable death.
+import { writeSync } from 'node:fs';
+import { constants as osConstants } from 'node:os';
+import { getHeapStatistics } from 'node:v8';
+import { MAX_RECORDED_ERROR_STACK_CHARS, sanitizeInlineErrorMessage, toErrorDetail, } from './vitest-fork-exit-error-detail.mjs';
+import { writeForkExitRecord } from './vitest-fork-exit-records.mjs';
+const SENTINEL_REGISTERED = Symbol.for('vouchington-tooling.vitest-fork-exit-sentinel.registered');
+let currentModule = null;
+// isolate: false lets one fork run files from multiple projects. Track the current project per test.
+let currentProject = 'unknown';
+// Called from the setup file's beforeEach/afterEach so a mid-test death attributes to the file
+// and project that were running, and a between-tests death (e.g. pool teardown) reports
+// module=none.
+export function setCurrentForkExitModule(modulePath) {
+    currentModule = modulePath;
+}
+export function setCurrentForkExitProject(projectName) {
+    currentProject = projectName ?? 'unknown';
+}
+function formatBytes(bytes) {
+    return (bytes / 1024 / 1024).toFixed(1);
+}
+export function formatPercent(part, whole) {
+    return whole > 0 ? ((part / whole) * 100).toFixed(1) : '0.0';
+}
+function writeForkExitLine(directory, mode, code, error) {
+    const memory = process.memoryUsage();
+    const heapLimitBytes = getHeapStatistics().heap_size_limit;
+    const errorDetail = mode === 'uncaught' || mode === 'unhandled' ? toErrorDetail(error) : undefined;
+    const fields = [
+        '[vitest-fork-exit]',
+        `pid=${process.pid}`,
+        `project=${currentProject}`,
+        `module=${currentModule ?? 'none'}`,
+        `mode=${mode}`,
+        `code=${code}`,
+        `heapUsedMB=${formatBytes(memory.heapUsed)}`,
+        `heapLimitMB=${formatBytes(heapLimitBytes)}`,
+        `heapPctOfLimit=${formatPercent(memory.heapUsed, heapLimitBytes)}`,
+        `rssMB=${formatBytes(memory.rss)}`,
+        `uptimeMs=${Math.round(process.uptime() * 1000)}`,
+    ];
+    if (errorDetail)
+        fields.push(`errorMessage=${sanitizeInlineErrorMessage(errorDetail.message)}`);
+    writeSync(2, `${fields.join(' ')}\n`);
+    // Durable file twin (see vitest-fork-exit-records.mts) — the roll-up in
+    // vitest-worker-exit-diagnostics-reporter.mts reads this back from the main process, which
+    // cannot see the stderr line above at all (it's piped straight to the job's raw log output, not
+    // through Vitest's onUserConsoleLog channel). Carries the full message and stack, unlike the
+    // bounded single-line fd-2 field above.
+    writeForkExitRecord(directory, {
+        kind: 'exit',
+        pid: process.pid,
+        project: currentProject,
+        module: currentModule ?? 'none',
+        mode,
+        code,
+        ...(errorDetail
+            ? {
+                errorMessage: errorDetail.message,
+                ...(errorDetail.stack
+                    ? { errorStack: errorDetail.stack.slice(0, MAX_RECORDED_ERROR_STACK_CHARS) }
+                    : {}),
+            }
+            : {}),
+    });
+}
+// Idempotent: multiple setup files across multiple projects may import this module inside the
+// same fork (isolate: false reuses one fork across many files), and process.on listeners must
+// only be attached once.
+export function registerForkExitSentinel(options) {
+    const directory = options.recordDirectory;
+    if (!directory)
+        throw new Error('recordDirectory is required');
+    if (globalThis[SENTINEL_REGISTERED]) {
+        if (globalThis[SENTINEL_REGISTERED] !== directory) {
+            throw new Error('Fork exit sentinel is already registered with a different directory');
+        }
+        return;
+    }
+    // Turns a future Node major removing this internal (see the module header comment) into an
+    // immediate, attributable failure instead of a silent one: without it, every handler below would
+    // throw when it tries to call reallyExit(), cascading into Vitest's own uncaughtException
+    // listener and producing an untraceable crash rather than a clear cause.
+    if (typeof process.reallyExit !== 'function') {
+        throw new Error('process.reallyExit is unavailable — the Node version may have removed this internal API. ' +
+            'The fork-exit sentinel cannot terminate forks without it.');
+    }
+    // Records that this fork started, independent of how it ends — see vitest-fork-exit-records.mts
+    // for why this is the only way to count forks that die before writing anything else.
+    writeForkExitRecord(directory, { kind: 'start', pid: process.pid });
+    globalThis[SENTINEL_REGISTERED] = directory;
+    // The normal path: every fork's process eventually exits, whether the pool recycles it or the
+    // run ends. On a fully green run this is the only line these forks ever write.
+    process.on('exit', (code) => {
+        writeForkExitLine(directory, 'exit', code);
+    });
+    // Preserve default crash semantics (non-zero exit) — this only adds attribution, it must not
+    // turn a real crash into a silently-swallowed one. reallyExit(1), not exit(1): see the module
+    // header comment — process.exit() is unusable here, and reallyExit's silence on the 'exit'
+    // event is exactly right since the line for this death is already written above.
+    process.on('uncaughtException', (error) => {
+        writeForkExitLine(directory, 'uncaught', 1, error);
+        process.reallyExit(1);
+    });
+    process.on('unhandledRejection', (reason) => {
+        writeForkExitLine(directory, 'unhandled', 1, reason);
+        process.reallyExit(1);
+    });
+    const trapSignal = (signal) => {
+        process.on(signal, () => {
+            // 128+n mirrors POSIX/shell exit-code convention for a signal death, so the recorded
+            // code stays interpretable even though we're now exiting deliberately rather than by
+            // the raw signal.
+            const code = 128 + osConstants.signals[signal];
+            writeForkExitLine(directory, `signal:${signal}`, code);
+            process.reallyExit(code);
+        });
+    };
+    trapSignal('SIGTERM');
+    trapSignal('SIGINT');
+    trapSignal('SIGHUP');
+}

package/dist/vitest-diagnostics/vitest-fork-leak-detection.d.mts

@@ -0,0 +1,26 @@
+export { formatForkLeakDiagnostics } from './vitest-fork-leak-diagnostics.mts';
+import { type ForkLeakGrowthStep } from './vitest-fork-leak-episode.mts';
+export declare const WARMUP_CHECKPOINTS = 5;
+export declare const LEAK_THRESHOLD = 4;
+export declare const SUSTAINED_CHECKPOINTS = 5;
+export type ForkLeakVerdict = {
+    type: string;
+    baseline: number;
+    current: number;
+    streak: number;
+    growthCheckpoints: number;
+    requiredGrowthCheckpoints: number;
+    detectedInFile: string | null;
+    suspectedGrowth: ForkLeakGrowthStep | null;
+};
+export type ForkLeakDetectorOptions = {
+    trackedTypes?: ReadonlySet<string>;
+    warmupCheckpoints?: number;
+    leakThreshold?: number;
+    sustainedCheckpoints?: number;
+};
+export type ForkLeakDetector = {
+    record(counts: ReadonlyMap<string, number>, testFile?: string | null): ForkLeakVerdict[];
+};
+export declare function waitForResourceCloseCallbacks(): Promise<void>;
+export declare function createForkLeakDetector(options?: ForkLeakDetectorOptions): ForkLeakDetector;

package/dist/vitest-diagnostics/vitest-fork-leak-detection.mjs

@@ -0,0 +1,96 @@
+// Fork-side growth-delta leak detector for Vitest's reused forks pool.
+// It spans setup-file resets with one episode per type and stable candidate plateau.
+// Episodes combine new high-water marks with rolling samples for transient-high recovery.
+export { formatForkLeakDiagnostics } from './vitest-fork-leak-diagnostics.mjs';
+import { createForkLeakEpisode, findForkLeakEpisodeEvidence, recordForkLeakEpisode, setForkLeakCandidate, takeConfirmedForkLeakCandidate, } from './vitest-fork-leak-episode.mjs';
+const realSetTimeout = globalThis.setTimeout;
+const PERSISTENT_HANDLE_TYPES = new Set([
+    'TCPSocketWrap',
+    'TCPServerWrap',
+    'PipeWrap',
+    'TLSWrap',
+    'UDPWrap',
+    'FSEvent',
+    'StatWatcher',
+    'ProcessWrap',
+    'MessagePortData',
+]);
+export const WARMUP_CHECKPOINTS = 5;
+export const LEAK_THRESHOLD = 4;
+export const SUSTAINED_CHECKPOINTS = 5;
+export function waitForResourceCloseCallbacks() {
+    return new Promise((resolve) => realSetTimeout(resolve, 0));
+}
+// Baselines live (no static list to go stale) and flags at most once per type, so a confirmed
+// leak fails the test it's detected in without cascading into every subsequent test in the fork.
+export function createForkLeakDetector(options = {}) {
+    const trackedTypes = options.trackedTypes ?? PERSISTENT_HANDLE_TYPES;
+    const warmupCheckpoints = options.warmupCheckpoints ?? WARMUP_CHECKPOINTS;
+    const leakThreshold = options.leakThreshold ?? LEAK_THRESHOLD;
+    const sustainedCheckpoints = options.sustainedCheckpoints ?? SUSTAINED_CHECKPOINTS;
+    const requiredGrowthCheckpoints = growthCheckpointRequirement(sustainedCheckpoints);
+    const baseline = new Map();
+    const previousCounts = new Map();
+    const episodes = new Map();
+    const reported = new Set();
+    let checkpoint = 0;
+    return {
+        record(counts, testFile = null) {
+            checkpoint += 1;
+            const verdicts = [];
+            for (const type of trackedTypes) {
+                const current = counts.get(type) ?? 0;
+                const previous = previousCounts.get(type) ?? current;
+                previousCounts.set(type, current);
+                if (checkpoint <= warmupCheckpoints) {
+                    baseline.set(type, Math.max(baseline.get(type) ?? 0, current));
+                    episodes.delete(type);
+                    continue;
+                }
+                const base = baseline.get(type);
+                if (current <= base + leakThreshold) {
+                    episodes.delete(type);
+                    continue;
+                }
+                let episode = episodes.get(type);
+                if (!episode) {
+                    episode = createForkLeakEpisode(base, previous, current, testFile);
+                    episodes.set(type, episode);
+                }
+                else {
+                    recordForkLeakEpisode(episode, previous, current, testFile, sustainedCheckpoints);
+                }
+                const confirmedEvidence = takeConfirmedForkLeakCandidate(episode, previous, current, testFile, sustainedCheckpoints);
+                if (confirmedEvidence) {
+                    if (!reported.has(type)) {
+                        reported.add(type);
+                        verdicts.push({
+                            type,
+                            baseline: base,
+                            current,
+                            streak: confirmedEvidence.age,
+                            growthCheckpoints: confirmedEvidence.growthCheckpoints,
+                            requiredGrowthCheckpoints,
+                            detectedInFile: testFile,
+                            suspectedGrowth: confirmedEvidence.suspectedGrowth,
+                        });
+                    }
+                    episodes.delete(type);
+                }
+                else {
+                    const evidence = findForkLeakEpisodeEvidence(episode, current, sustainedCheckpoints, requiredGrowthCheckpoints);
+                    for (const signal of evidence)
+                        setForkLeakCandidate(episode, signal);
+                    if (episode.plateauCheckpoints >= sustainedCheckpoints) {
+                        baseline.set(type, episode.plateauCandidate);
+                        episodes.delete(type);
+                    }
+                }
+            }
+            return verdicts;
+        },
+    };
+}
+function growthCheckpointRequirement(sustainedCheckpoints) {
+    return Math.floor(sustainedCheckpoints / 2) + 1;
+}

package/dist/vitest-diagnostics/vitest-fork-leak-diagnostics.d.mts

@@ -0,0 +1,3 @@
+import type { ForkLeakVerdict } from './vitest-fork-leak-detection.mts';
+/** Formats a bounded, single-line verdict for a test failure or diagnostic log. */
+export declare function formatForkLeakDiagnostics(verdict: ForkLeakVerdict): string;

package/dist/vitest-diagnostics/vitest-fork-leak-diagnostics.mjs

@@ -0,0 +1,14 @@
+/** Formats a bounded, single-line verdict for a test failure or diagnostic log. */
+export function formatForkLeakDiagnostics(verdict) {
+    const growth = verdict.suspectedGrowth;
+    const file = growth?.testFile ?? verdict.detectedInFile ?? 'unknown';
+    return [
+        `[vitest-fork-leak] type=${verdict.type}`,
+        `baseline=${verdict.baseline}`,
+        `current=${verdict.current}`,
+        `streak=${verdict.streak}`,
+        `growth=${verdict.growthCheckpoints}/${verdict.requiredGrowthCheckpoints}`,
+        `file=${file.replace(/\s+/g, ' ').slice(0, 240)}`,
+        `delta=${growth?.delta ?? 0}`,
+    ].join(' ');
+}

package/dist/vitest-diagnostics/vitest-fork-leak-episode.d.mts

@@ -0,0 +1,37 @@
+export type ForkLeakGrowthStep = {
+    testFile: string | null;
+    previous: number;
+    current: number;
+    delta: number;
+};
+type ForkLeakSample = ForkLeakGrowthStep;
+type ForkLeakEvidenceKind = 'primary' | 'rolling';
+export type ForkLeakEpisode = {
+    baseline: number;
+    start: number;
+    highWater: number;
+    age: number;
+    growthCheckpoints: number;
+    largestGrowthStep: ForkLeakGrowthStep | null;
+    plateauCandidate: number;
+    plateauCheckpoints: number;
+    samples: ForkLeakSample[];
+    pendingCandidate: ForkLeakCandidate | null;
+    rejectedHighWater: Record<ForkLeakEvidenceKind, number>;
+};
+export type ForkLeakEpisodeEvidence = {
+    kind: ForkLeakEvidenceKind;
+    age: number;
+    growthCheckpoints: number;
+    highWater: number;
+    suspectedGrowth: ForkLeakGrowthStep | null;
+};
+type ForkLeakCandidate = ForkLeakEpisodeEvidence & {
+    createdAt: number;
+};
+export declare function createForkLeakEpisode(baseline: number, previous: number, current: number, testFile: string | null): ForkLeakEpisode;
+export declare function recordForkLeakEpisode(episode: ForkLeakEpisode, previous: number, current: number, testFile: string | null, sustainedCheckpoints: number): void;
+export declare function findForkLeakEpisodeEvidence(episode: ForkLeakEpisode, current: number, sustainedCheckpoints: number, requiredGrowthCheckpoints: number): ForkLeakEpisodeEvidence[];
+export declare function takeConfirmedForkLeakCandidate(episode: ForkLeakEpisode, previous: number, current: number, testFile: string | null, sustainedCheckpoints: number): ForkLeakEpisodeEvidence | null;
+export declare function setForkLeakCandidate(episode: ForkLeakEpisode, evidence: ForkLeakEpisodeEvidence): void;
+export {};

package/dist/vitest-diagnostics/vitest-fork-leak-episode.mjs

@@ -0,0 +1,118 @@
+export function createForkLeakEpisode(baseline, previous, current, testFile) {
+    const sample = makeSample(previous, current, testFile);
+    return {
+        baseline,
+        start: current,
+        highWater: current,
+        age: 1,
+        growthCheckpoints: sample.delta > 0 ? 1 : 0,
+        largestGrowthStep: sample.delta > 0 ? sample : null,
+        plateauCandidate: current,
+        plateauCheckpoints: 0,
+        samples: [sample],
+        pendingCandidate: null,
+        rejectedHighWater: { primary: Number.NEGATIVE_INFINITY, rolling: Number.NEGATIVE_INFINITY },
+    };
+}
+export function recordForkLeakEpisode(episode, previous, current, testFile, sustainedCheckpoints) {
+    episode.age += 1;
+    const sample = makeSample(previous, current, testFile);
+    episode.samples.push(sample);
+    if (episode.samples.length > sustainedCheckpoints)
+        episode.samples.shift();
+    if (current === episode.plateauCandidate) {
+        episode.plateauCheckpoints += 1;
+    }
+    else {
+        episode.plateauCandidate = current;
+        episode.plateauCheckpoints = 0;
+    }
+    if (current > episode.highWater) {
+        episode.highWater = current;
+        episode.growthCheckpoints += 1;
+        if (!episode.largestGrowthStep || sample.delta > episode.largestGrowthStep.delta) {
+            episode.largestGrowthStep = sample;
+        }
+    }
+}
+export function findForkLeakEpisodeEvidence(episode, current, sustainedCheckpoints, requiredGrowthCheckpoints) {
+    const evidence = [];
+    if (episode.age >= sustainedCheckpoints &&
+        episode.growthCheckpoints >= requiredGrowthCheckpoints &&
+        current > episode.start) {
+        evidence.push({
+            kind: 'primary',
+            age: episode.age,
+            growthCheckpoints: episode.growthCheckpoints,
+            highWater: episode.highWater,
+            suspectedGrowth: episode.largestGrowthStep,
+        });
+    }
+    const rollingEvidence = findRollingEvidence(episode.samples, current, sustainedCheckpoints, requiredGrowthCheckpoints);
+    if (rollingEvidence)
+        evidence.push(rollingEvidence);
+    return evidence;
+}
+export function takeConfirmedForkLeakCandidate(episode, previous, current, testFile, sustainedCheckpoints) {
+    const candidate = episode.pendingCandidate;
+    if (!candidate)
+        return null;
+    if (episode.age - candidate.createdAt > sustainedCheckpoints) {
+        episode.rejectedHighWater[candidate.kind] = Math.max(episode.rejectedHighWater[candidate.kind], candidate.highWater);
+        episode.pendingCandidate = null;
+        return null;
+    }
+    if (current <= candidate.highWater)
+        return null;
+    episode.pendingCandidate = null;
+    const delta = current - previous;
+    const confirmation = delta > 0 ? { testFile, previous, current, delta } : null;
+    return {
+        ...candidate,
+        suspectedGrowth: confirmation &&
+            (!candidate.suspectedGrowth || confirmation.delta > candidate.suspectedGrowth.delta)
+            ? confirmation
+            : candidate.suspectedGrowth,
+    };
+}
+export function setForkLeakCandidate(episode, evidence) {
+    if (evidence.highWater <= episode.rejectedHighWater[evidence.kind])
+        return;
+    const candidate = episode.pendingCandidate;
+    if (candidate?.kind === 'primary' && evidence.kind === 'rolling') {
+        episode.rejectedHighWater.primary = Math.max(episode.rejectedHighWater.primary, candidate.highWater);
+    }
+    if (!candidate ||
+        (candidate.kind === 'primary' &&
+            evidence.kind === 'rolling' &&
+            evidence.highWater < candidate.highWater) ||
+        (candidate.kind === evidence.kind && evidence.highWater > candidate.highWater)) {
+        episode.pendingCandidate = { ...evidence, createdAt: episode.age };
+    }
+}
+function findRollingEvidence(samples, current, sustainedCheckpoints, requiredGrowthCheckpoints) {
+    if (samples.length !== sustainedCheckpoints || current <= samples[0].current)
+        return null;
+    const positiveSamples = [];
+    let highWater = Number.NEGATIVE_INFINITY;
+    for (const sample of samples) {
+        if (sample.current <= highWater)
+            continue;
+        highWater = sample.current;
+        if (sample.delta > 0)
+            positiveSamples.push(sample);
+    }
+    if (positiveSamples.length < requiredGrowthCheckpoints)
+        return null;
+    const suspectedGrowth = positiveSamples.reduce((largest, sample) => (!largest || sample.delta > largest.delta ? sample : largest), null);
+    return {
+        kind: 'rolling',
+        age: sustainedCheckpoints,
+        growthCheckpoints: positiveSamples.length,
+        highWater,
+        suspectedGrowth,
+    };
+}
+function makeSample(previous, current, testFile) {
+    return { testFile, previous, current, delta: current - previous };
+}

package/dist/vitest-diagnostics/vitest-worker-exit-diagnostics-errors.d.mts

@@ -0,0 +1,2 @@
+export declare function collectStringValues(value: unknown, seen?: Set<unknown>): string[];
+export declare function serializeDiagnosticsError(error: unknown, seen?: Set<unknown>): Record<string, unknown>;