@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/test-stale-check.js

@@ -1,396 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/*
- * Stale-build preflight for `fireforge test`.
- *
- * Without this preflight, an operator who edits engine chrome / packaged
- * resources (`jar.mn` entries, `.xhtml`/`.mjs`/`.css` under chrome trees,
- * pref files) and then runs `fireforge test <path>` only discovers the build
- * is stale after xpcshell / mach test starts and errors out with
- * `NS_ERROR_FILE_NOT_FOUND` against a `chrome://browser/content/…` URI,
- * which reads as a test bug rather than a rebuild prompt. Scaffolding a new
- * top-level chrome document plus an xpcshell test is the canonical case: the
- * test file exists, the manifests are registered, but `dist/` still holds
- * the pre-edit bundle and chrome URIs resolve to nothing.
- *
- * This preflight diffs engine HEAD (or workdir) against the last-build
- * baseline (`.fireforge/last-build.json`), filters to paths that imply
- * packaging, and returns a compact summary. `fireforge test` prints a
- * warning up-front so the operator sees "you edited X, Y, Z since the last
- * build, rerun with `--build` to refresh" before mach test launches.
- * Detection stays advisory (warn-only) because a fork that rebuilds
- * out-of-band (a separate `./mach build` invocation, an IDE plugin) can
- * legitimately have a fresh `dist/` with no FireForge-recorded baseline
- * update.
- */
-import { stat } from 'node:fs/promises';
-import { join, relative } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { verbose, warn } from '../utils/logger.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { isPackageablePath, isXpcomManifestPath } from './build-audit.js';
-import { readBuildBaseline } from './build-baseline.js';
-import { hashEngineFile } from './coverage-extend.js';
-import { isTestManifestPath } from './coverage-records.js';
-import { collectChangedEnginePaths, dropPathsMatchingFingerprints } from './engine-changes.js';
-import { readLinkedAt } from './launchable-build.js';
-import { isCompiledSourcePath } from './negative-control-compiled.js';
-import { formatStaleExemptions, partitionStaleCandidates, } from './test-stale-exempt.js';
-/** Cap on the number of changed paths rendered inline. */
-const STALE_PATHS_LIMIT = 10;
-/**
- * Probes the engine tree for packageable changes since the last successful
- * `fireforge build`. Returns a summary the `fireforge test` handler renders
- * as an up-front warning when `--build` was not passed. The probe never
- * refuses a malformed persisted baseline. Git failures and a missing baseline
- * degrade to `stale: false` because they provide no comparison anchor.
- *
- * @param projectRoot Root directory of the project.
- * @param engineDir Path to the engine directory.
- */
-export async function checkStaleBuildForTest(projectRoot, engineDir) {
-    const baseline = await readBuildBaseline(projectRoot, 'refuse');
-    if (!baseline) {
-        return { stale: false, changedPaths: [], truncated: 0, baseline: undefined };
-    }
-    const changed = await collectChangedEnginePaths(engineDir, baseline, 'Stale-build preflight');
-    let packageable = changed.filter((path) => isPackageablePath(path)).sort();
-    // Content-hash comparison: when the baseline carries a fingerprint set,
-    // fold each candidate path through a live re-hash and drop paths whose
-    // current content matches the baseline. Baselines without
-    // `packageableFingerprints` fall through to the path-only comparison,
-    // where every workdir-dirty packageable path reports as stale.
-    //
-    // This matters because a project with imported patches plus
-    // Furnace-applied components always has a persistent workdir diff against
-    // HEAD, so `git diff --name-only HEAD` returns that diff on every build
-    // and the stale check fires immediately after a successful one. The
-    // fingerprints capture "these files had this content when the build ran".
-    // A path stays stale only when its live hash diverges.
-    packageable = await dropPathsMatchingFingerprints(engineDir, packageable, baseline.packageableFingerprints);
-    // Edits the runtime already serves (symlinked into the objdir, or test
-    // files `mach test` restages at dispatch) cannot make the packaging stale.
-    const { stale, exempt } = await partitionStaleCandidates(engineDir, packageable);
-    if (stale.length === 0) {
-        return { stale: false, changedPaths: [], truncated: 0, baseline, exempt };
-    }
-    const head = stale.slice(0, STALE_PATHS_LIMIT);
-    const truncated = Math.max(0, stale.length - head.length);
-    return { stale: true, changedPaths: head, truncated, baseline, exempt };
-}
-/**
- * Formats a human-readable warning body from a {@link StaleBuildResult}.
- * Kept separate from the probe so test code can assert on the structured
- * result without matching the rendered copy.
- */
-export function formatStaleBuildWarning(result) {
-    const tail = result.truncated > 0 ? `, … (+${result.truncated} more)` : '';
-    const list = result.changedPaths.join(', ') + tail;
-    const exempt = result.exempt ?? [];
-    const exemptLine = exempt.length > 0
-        ? `\nNot counted as stale, because the runtime already serves them: ${formatStaleExemptions(exempt)}.`
-        : '';
-    return (`Engine tree has changed since the last successful fireforge build (${list}).\n` +
-        'The current obj-*/dist/ bundle may not reflect those edits. If your test reads ' +
-        'packaged chrome / jar.mn resources, rerun with "fireforge test --build" (or ' +
-        '"fireforge build --ui") first. Passing --build skips this check.' +
-        exemptLine);
-}
-/**
- * Path segments whose compiled sources never reach the binary under test
- * (gtests, cppunittests, CI config YAML): an edit there must not make the
- * browser read as stale.
- */
-const NON_RUNTIME_SEGMENTS = new Set(['test', 'tests', 'gtest', 'testing', 'taskcluster']);
-/**
- * Changed compiled sources (C++, Rust, IDL, WebIDL, IPDL, StaticPrefList
- * YAML, …) whose mtime is newer than the launchable build's last link.
- * `mach build faster` compiles none of them, so such a run tests the
- * binary from before the edit, which reads as a failed fix rather than a
- * stale build. Candidates are the engine paths changed since the baseline
- * plus every workdir edit; a fork's persistent patch diff is older than any
- * build that followed it, so only genuine post-build edits remain.
- * Returns undefined when there is nothing to compare against (no
- * launchable binary).
- *
- * @param engineDir - Absolute engine directory
- * @param baseline - Last-build baseline, when one exists
- * @param launchablePath - Engine-relative launchable binary path
- */
-export async function findCompiledSourcesNewerThanBinary(engineDir, baseline, launchablePath) {
-    if (launchablePath === undefined)
-        return undefined;
-    const linked = await readLinkedAt(engineDir, launchablePath);
-    if (linked === undefined)
-        return undefined;
-    const changed = await collectChangedEnginePaths(engineDir, baseline, 'Stale-compiled preflight');
-    const candidates = changed.filter((path) => isCompiledSourcePath(path) &&
-        !path.split('/').some((segment) => NON_RUNTIME_SEGMENTS.has(segment)));
-    const paths = [];
-    for (const path of candidates) {
-        try {
-            const { mtimeMs } = await stat(join(engineDir, path));
-            if (mtimeMs > linked.mtimeMs)
-                paths.push(path);
-        }
-        catch {
-            // A deleted source cannot be newer than anything; the build that
-            // drops it is the stale-build check's business.
-        }
-    }
-    return {
-        paths: paths.sort(),
-        linkedPath: normalizePathSlashes(relative(engineDir, linked.path)),
-        linkedAt: new Date(linked.mtimeMs),
-    };
-}
-/**
- * The `stale-compiled` refusal (or, under `--allow-stale-build`, warning).
- *
- * @param result - A non-empty {@link StaleCompiledResult}
- */
-export function formatStaleCompiledRefusal(result) {
-    const head = result.paths.slice(0, STALE_PATHS_LIMIT).map((path) => `engine/${path}`);
-    const truncated = result.paths.length - head.length;
-    const list = head.join(', ') + (truncated > 0 ? `, … (+${truncated} more)` : '');
-    return (`Compiled sources changed after the binary under test was linked ` +
-        `(engine/${result.linkedPath}, ${result.linkedAt.toISOString()}): ${list}.\n` +
-        'The run would test the binary from before those edits, so a red reads as a failed fix ' +
-        'and a green proves nothing about them. Run "fireforge build" first, or rerun with ' +
-        '"fireforge test --build", which escalates to a full mach build when compiled sources ' +
-        'changed. --allow-stale-build turns this refusal into a warning.');
-}
-/**
- * The notice that explains why a `test --build` pre-test build escalated
- * to a full `mach build` for stale compiled sources.
- *
- * @param result - A non-empty {@link StaleCompiledResult}
- */
-export function formatStaleCompiledBuildNotice(result) {
-    const head = result.paths.slice(0, STALE_PATHS_LIMIT).map((path) => `engine/${path}`);
-    const truncated = result.paths.length - head.length;
-    return (`Compiled sources changed after the binary was linked (${head.join(', ')}` +
-        `${truncated > 0 ? `, … (+${truncated} more)` : ''}); escalating this pre-test build to a ` +
-        'full mach build, since mach build faster compiles nothing.');
-}
-/**
- * Sentinel returned by {@link findUncoveredRequestPaths} when a full-suite
- * request (no paths) is checked against a scoped coverage record.
- */
-export const FULL_SUITE_REQUEST = '(entire suite)';
-/**
- * Compares the requested test paths against the packaged runtime's coverage
- * claim recorded in the baseline. Returns the requested paths the recorded
- * packaging does not cover: the runs that would dispatch against missing
- * `_tests/` support fixtures and hang rather than fail.
- *
- * Coverage semantics: an absent claim and `'full'` cover everything. A
- * scoped list covers a request path when the request equals a covered entry
- * or sits beneath it. A file claim never widens to its containing directory:
- * sibling files can belong to different manifests or harnesses, and a dot in
- * a directory name does not make it a file. Both sides are normalized to forward
- * slashes so Windows-style CLI input cannot defeat the prefix rule (baseline
- * paths are POSIX by convention). A request with no paths is a full-suite
- * run and is never covered by a scoped list, so the
- * {@link FULL_SUITE_REQUEST} sentinel is returned and the refusal can name
- * it.
- */
-export function findUncoveredRequestPaths(coverage, requestedPaths) {
-    if (coverage === undefined || coverage === 'full') {
-        return [];
-    }
-    const covered = coverage.map(normalizeCoveragePath).filter((p) => p.length > 0);
-    if (requestedPaths.length === 0) {
-        return [FULL_SUITE_REQUEST];
-    }
-    return requestedPaths.filter((requested) => {
-        const path = normalizeCoveragePath(requested);
-        return !covered.some((c) => path === c || path.startsWith(`${c}/`));
-    });
-}
-/** Normalizes a path for coverage comparison: forward slashes, no trailing slash. */
-function normalizeCoveragePath(path) {
-    return normalizePathSlashes(path.trim()).replace(/\/+$/, '');
-}
-/**
- * Test manifests changed since the recorded build that sit in (or above)
- * the directory of an uncovered request path, i.e. the manifests that
- * explain why this run needs coverage the build never claimed.
- *
- * Best-effort: a probe failure returns an empty list, so the refusal
- * degrades to exactly its previous text rather than failing differently.
- *
- * @param engineDir - Absolute engine directory
- * @param baseline - Last successful build's baseline
- * @param uncovered - Uncovered request paths from
- *   {@link findUncoveredRequestPaths}
- * @returns Engine-relative manifest paths, capped at
- *   {@link STALE_PATHS_LIMIT}
- */
-export async function findChangedTestManifestsForPaths(engineDir, baseline, uncovered) {
-    let changed;
-    try {
-        changed = await collectChangedEnginePaths(engineDir, baseline, 'Coverage refusal');
-    }
-    catch (error) {
-        verbose(`Coverage refusal: manifest probe failed — ${toError(error).message}`);
-        return [];
-    }
-    const requestDirs = uncovered.filter((p) => p !== FULL_SUITE_REQUEST).map(normalizeCoveragePath);
-    const hits = changed.filter((path) => {
-        if (!isTestManifestPath(path))
-            return false;
-        const dir = path.slice(0, Math.max(0, path.lastIndexOf('/')));
-        return requestDirs.some((req) => req === dir || req.startsWith(`${dir}/`));
-    });
-    return hits.slice(0, STALE_PATHS_LIMIT);
-}
-/** The refusal's sentence naming who wrote the coverage record. */
-function formatCoverageHolder(detail) {
-    if (detail.recorder === undefined && detail.recordedBy === undefined)
-        return '';
-    const what = detail.recordedBy !== undefined ? `"${detail.recordedBy}"` : 'a build';
-    const when = detail.builtAt !== undefined ? ` at ${detail.builtAt}` : '';
-    const recorder = detail.recorder;
-    const who = recorder === undefined
-        ? ''
-        : ` (pid ${recorder.pid}${detail.recorderAlive === true ? ', still running' : ''}` +
-            (recorder.sessionId !== undefined ? `, session ${recorder.sessionId}` : '') +
-            `, invocation ${recorder.invocationId})`;
-    return ` The current record was written by ${what}${when}${who}.`;
-}
-/**
- * Formats the refusal shown when a non-`--build` run requests paths the
- * packaged runtime's scoped `test --build` coverage does not include. It is
- * enforced on every such run, with or without `--allow-stale-build`. Kept
- * separate from the matcher so tests can pin structure and copy
- * independently (same split as {@link formatStaleBuildWarning}).
- *
- * @param uncovered - Request paths the recorded packaging does not cover
- * @param coverage - The recorded scoped coverage claim
- * @param changedManifests - Test manifests changed since the recorded
- *   build that explain an uncovered path (from
- *   {@link findChangedTestManifestsForPaths}). Omitted or empty renders
- *   nothing
- * @param detail - See {@link CoverageRefusalDetail}
- */
-export function formatTestCoverageRefusal(uncovered, coverage, changedManifests = [], detail = {}) {
-    const cap = (paths) => {
-        const head = paths.slice(0, STALE_PATHS_LIMIT);
-        const truncated = paths.length - head.length;
-        return head.join(', ') + (truncated > 0 ? `, … (+${truncated} more)` : '');
-    };
-    const rebuildTargets = uncovered.filter((p) => p !== FULL_SUITE_REQUEST);
-    // Per-path retention is the default, so rebuilding only the uncovered
-    // paths costs no one else's claim. Saying so is what keeps a
-    // peer from rebuilding everything "to be safe".
-    const keepHint = rebuildTargets.length > 0
-        ? ' That scoped build keeps every other recorded path whose own staging inputs (manifest directory and the fixtures its manifest names) and engine/mozconfig are unchanged.'
-        : '';
-    const rebuildHint = rebuildTargets.length > 0
-        ? `Rerun "fireforge test --build ${rebuildTargets.slice(0, STALE_PATHS_LIMIT).join(' ')}" to package them (or "fireforge test --build-only ..." to package without running), or run "fireforge build" for full coverage.${keepHint}`
-        : 'Run "fireforge build" (or a path-less "fireforge test --build") for full coverage first.';
-    // Why this run needs new coverage, when a changed manifest explains it: a
-    // manifest that gained an entry is not covered by a build claim recorded
-    // for other paths, and a browser-chrome claim never covers xpcshell.
-    const manifestLine = changedManifests.length > 0
-        ? ` This run needs coverage the recorded build never claimed because a test manifest changed since it: ${changedManifests.map((m) => `engine/${m}`).join(', ')} — a manifest that gained an entry stages new support fixtures, and a claim recorded for other paths (or another harness) does not cover them.`
-        : '';
-    const affected = Object.entries(detail.changedInputs ?? {}).filter(([, files]) => files.length > 0);
-    const affectedLine = affected.length > 0
-        ? ` Staging inputs changed since the full build this record carries forward: ${affected.map(([path, files]) => `${path} (${cap(files)})`).join('; ')}.`
-        : '';
-    const scope = detail.carriesFullAnchor
-        ? `${cap(coverage)}, plus earlier full coverage for paths whose own staging inputs are unchanged`
-        : cap(coverage);
-    return (`The packaged test runtime was produced by a scoped "fireforge test --build" covering only: ${scope}.\n` +
-        `The requested run needs ${cap(uncovered)}, which that packaging does not cover — support ` +
-        'fixtures for those manifests may be missing from obj-*/_tests/, and the run can hang ' +
-        `rather than fail.${formatCoverageHolder(detail)}${affectedLine}${manifestLine} ${rebuildHint} ` +
-        '(--allow-stale-build does not bypass this check — it accepts stale content, not missing coverage.)');
-}
-/**
- * Probes whether any `components.conf` changed since the last full
- * `fireforge build`, i.e. since the compiled StaticComponents table was
- * last regenerated. `components.conf` entries bake into compiled code. A
- * scoped `test --build` packages the file but the child process resolves the
- * old table and fails with `NS_ERROR_MALFORMED_URI` that reads as a test
- * bug.
- *
- * The diff anchors to the baseline's `staticComponentsBaseline` (the last
- * full build's engine HEAD SHA), not the baseline's own `engineHeadSha`,
- * which a scoped `test --build` advances. Dirty candidates are hash-checked
- * against the anchor's fingerprints so only genuine content divergence
- * counts. No baseline or no anchor means fresh. Never throws: the probes it
- * composes degrade to verbose lines and empty results on git failure,
- * matching {@link checkStaleBuildForTest}.
- */
-export async function checkStaticComponentsStale(engineDir, baseline) {
-    const anchor = baseline?.staticComponentsBaseline;
-    if (baseline === undefined || anchor === undefined) {
-        return { stale: false, changedManifests: [] };
-    }
-    const changed = await collectChangedEnginePaths(engineDir, { ...baseline, engineHeadSha: anchor.engineHeadSha }, 'Static-components preflight');
-    const changedManifests = [];
-    for (const path of changed.filter((p) => isXpcomManifestPath(p))) {
-        const recorded = anchor.fingerprints[path];
-        const live = await hashEngineFile(engineDir, path);
-        if (recorded === undefined || live === undefined || recorded !== live) {
-            changedManifests.push(path);
-        }
-    }
-    return { stale: changedManifests.length > 0, changedManifests };
-}
-/**
- * Formats the refusal shown when a run would dispatch against a stale
- * compiled StaticComponents table. Same probe/copy split as
- * {@link formatStaleBuildWarning} so tests can pin structure and wording
- * independently.
- */
-export function formatStaticComponentsRefusal(changedManifests) {
-    const head = changedManifests.slice(0, STALE_PATHS_LIMIT);
-    const truncated = changedManifests.length - head.length;
-    const list = head.join(', ') + (truncated > 0 ? `, … (+${truncated} more)` : '');
-    return (`The compiled StaticComponents table is stale: ${list} changed since the last full "fireforge build".\n` +
-        'components.conf registrations are baked into compiled code that only a FULL build ' +
-        'regenerates — a scoped "fireforge test --build" repackages files but the child process ' +
-        'resolves the old component table and fails with NS_ERROR_MALFORMED_URI that reads as a ' +
-        'test bug. Run "fireforge build" first. (--allow-stale-build does not bypass this check — ' +
-        'it accepts stale packaged content, not a stale compiled registration. Pass ' +
-        '--allow-stale-components only if you rebuilt out-of-band and accept the risk.)');
-}
-/**
- * Formats the post-mutation advisory printed by `fireforge reset` /
- * `fireforge import` when `components.conf` diverged from the last full
- * build. Same probe as {@link formatStaticComponentsRefusal},
- * different moment: this fires at mutation time so the operator learns a
- * full build is needed before the next gate run refuses.
- */
-export function formatPostMutationStaticComponentsWarning(changedManifests) {
-    const head = changedManifests.slice(0, STALE_PATHS_LIMIT);
-    const truncated = changedManifests.length - head.length;
-    const list = head.join(', ') + (truncated > 0 ? `, … (+${truncated} more)` : '');
-    return (`components.conf changed relative to the last full "fireforge build": ${list}.\n` +
-        'The compiled StaticComponents table in obj-* no longer matches the tree, so the next ' +
-        '"fireforge test" will require a full "fireforge build" first — a scoped ' +
-        '"fireforge test --build" cannot regenerate the compiled table.');
-}
-/**
- * Post-mutation advisory used by `fireforge reset` / `fireforge import`:
- * warns (never throws, never blocks) when `components.conf` now differs
- * from the last full-build anchor. Silently skipped when no baseline or
- * anchor exists, or when any probe fails.
- */
-export async function warnIfStaticComponentsStale(projectRoot, engineDir) {
-    try {
-        const baseline = await readBuildBaseline(projectRoot);
-        if (baseline === undefined)
-            return;
-        const result = await checkStaticComponentsStale(engineDir, baseline);
-        if (!result.stale)
-            return;
-        warn(formatPostMutationStaticComponentsWarning(result.changedManifests));
-    }
-    catch (error) {
-        verbose(`Static-components post-mutation check skipped: ${toError(error).message}`);
-    }
-}

package/dist/src/core/test-stale-exempt.d.ts

@@ -1,40 +0,0 @@
-/**
- * Edits the stale-build preflight must not count. A test file the build
- * never packages is restaged by `mach test` at dispatch, and a file whose
- * every objdir copy is a symlink back to the edited source is already what
- * the runtime reads. Refusing on either made every iteration on a test (or
- * on symlinked chrome) pay a packaging pass or reach for
- * `--allow-stale-build`, the flag whose refusal text says not to.
- */
-import { type InstallManifestIndex } from './objdir-install-manifests.js';
-/** A changed path the preflight does not count as stale, and why. */
-export interface StaleExemption {
-    path: string;
-    /**
-     * `symlinked`: every objdir copy is a symlink to the edited source.
-     * `test-only`: a test file the build does not package, restaged at dispatch.
-     */
-    why: 'symlinked' | 'test-only';
-}
-/** The single `obj-*` directory under the engine, or undefined when zero or several exist. */
-export declare function findSingleObjDir(engineDir: string): Promise<string | undefined>;
-/**
- * The objdir's install-manifest index, or undefined when there is no single
- * objdir or nothing in it is readable.
- * @param engineDir - Absolute engine directory
- */
-export declare function loadEngineInstallIndex(engineDir: string): Promise<InstallManifestIndex | undefined>;
-/**
- * Splits changed packageable paths into the ones that make the packaged
- * runtime stale and the ones it already serves. Without a readable objdir
- * index every path stays stale, the behaviour before the exemption existed.
- *
- * @param engineDir - Absolute engine directory
- * @param paths - Changed engine-relative paths, already fingerprint-filtered
- */
-export declare function partitionStaleCandidates(engineDir: string, paths: readonly string[]): Promise<{
-    stale: string[];
-    exempt: StaleExemption[];
-}>;
-/** Renders exemptions for a notice or refusal: `a (symlinked), b (test file)`. */
-export declare function formatStaleExemptions(exempt: readonly StaleExemption[], limit?: number): string;

package/dist/src/core/test-stale-exempt.js

@@ -1,70 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Edits the stale-build preflight must not count. A test file the build
- * never packages is restaged by `mach test` at dispatch, and a file whose
- * every objdir copy is a symlink back to the edited source is already what
- * the runtime reads. Refusing on either made every iteration on a test (or
- * on symlinked chrome) pay a packaging pass or reach for
- * `--allow-stale-build`, the flag whose refusal text says not to.
- */
-import { readdir } from 'node:fs/promises';
-import { isTestPath } from './build-audit-resolve.js';
-import { classifyRuntimeDelivery, loadInstallManifestIndex, } from './objdir-install-manifests.js';
-/** The single `obj-*` directory under the engine, or undefined when zero or several exist. */
-export async function findSingleObjDir(engineDir) {
-    try {
-        const entries = await readdir(engineDir, { withFileTypes: true });
-        const objDirs = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith('obj-'));
-        return objDirs.length === 1 ? objDirs[0]?.name : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * The objdir's install-manifest index, or undefined when there is no single
- * objdir or nothing in it is readable.
- * @param engineDir - Absolute engine directory
- */
-export async function loadEngineInstallIndex(engineDir) {
-    const objDir = await findSingleObjDir(engineDir);
-    return objDir === undefined ? undefined : loadInstallManifestIndex(engineDir, objDir);
-}
-/**
- * Splits changed packageable paths into the ones that make the packaged
- * runtime stale and the ones it already serves. Without a readable objdir
- * index every path stays stale, the behaviour before the exemption existed.
- *
- * @param engineDir - Absolute engine directory
- * @param paths - Changed engine-relative paths, already fingerprint-filtered
- */
-export async function partitionStaleCandidates(engineDir, paths) {
-    if (paths.length === 0)
-        return { stale: [], exempt: [] };
-    const index = await loadEngineInstallIndex(engineDir);
-    if (index === undefined)
-        return { stale: [...paths], exempt: [] };
-    const stale = [];
-    const exempt = [];
-    for (const path of paths) {
-        const delivery = await classifyRuntimeDelivery(index, engineDir, path);
-        if (delivery === 'live')
-            exempt.push({ path, why: 'symlinked' });
-        else if (delivery === 'at-dispatch' || (delivery === 'unlisted' && isTestPath(path))) {
-            exempt.push({ path, why: 'test-only' });
-        }
-        else
-            stale.push(path);
-    }
-    return { stale, exempt };
-}
-/** Renders exemptions for a notice or refusal: `a (symlinked), b (test file)`. */
-export function formatStaleExemptions(exempt, limit = 10) {
-    const head = exempt
-        .slice(0, limit)
-        .map(({ path, why }) => why === 'symlinked'
-        ? `${path} (objdir symlink to the source)`
-        : `${path} (test file, restaged at dispatch)`);
-    const extra = exempt.length - head.length;
-    return head.join(', ') + (extra > 0 ? `, … (+${extra} more)` : '');
-}

package/dist/src/core/test-stale-symlink.d.ts

@@ -1,12 +0,0 @@
-/**
- * Safe stale test-harness symlink repair for xpcshell setup failures.
- */
-/**
- * Removes one stale xpcshell `_tests` symlink when mach reports a
- * FileExistsError during test installation.
- *
- * The guard rails are narrow: only quoted FileExistsError
- * destinations inside the active objdir's `_tests` tree are considered, and
- * only when lstat confirms the destination itself is a symlink.
- */
-export declare function tryRepairStaleXpcshellTestSymlink(engineDir: string, objDir: string | undefined, output: string): Promise<boolean>;

package/dist/src/core/test-stale-symlink.js

@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Safe stale test-harness symlink repair for xpcshell setup failures.
- */
-import { isAbsolute, relative, resolve } from 'node:path';
-import { isSymlink, removeFile } from '../utils/fs.js';
-import { warn } from '../utils/logger.js';
-function extractFileExistsDestination(output) {
-    const match = /FileExistsError[^\n]*File exists:\s+(?:(?:'[^']*'|"[^"]*")\s*->\s*)?['"]([^'"]+)['"]/i.exec(output);
-    return match?.[1];
-}
-function isInsideDirectory(parent, candidate) {
-    const rel = relative(parent, candidate);
-    return rel.length === 0 || (!rel.startsWith('..') && !isAbsolute(rel));
-}
-/**
- * Removes one stale xpcshell `_tests` symlink when mach reports a
- * FileExistsError during test installation.
- *
- * The guard rails are narrow: only quoted FileExistsError
- * destinations inside the active objdir's `_tests` tree are considered, and
- * only when lstat confirms the destination itself is a symlink.
- */
-export async function tryRepairStaleXpcshellTestSymlink(engineDir, objDir, output) {
-    if (!objDir || !/FileExistsError/i.test(output))
-        return false;
-    const destination = extractFileExistsDestination(output);
-    if (!destination)
-        return false;
-    const resolvedDestination = resolve(destination);
-    const testsRoot = resolve(engineDir, objDir, '_tests');
-    if (!isInsideDirectory(testsRoot, resolvedDestination))
-        return false;
-    if (!(await isSymlink(resolvedDestination)))
-        return false;
-    await removeFile(resolvedDestination);
-    warn(`Removed stale xpcshell harness symlink under ${objDir}/_tests and retrying mach test once: ${relative(resolve(engineDir), resolvedDestination)}`);
-    return true;
-}

package/dist/src/core/test-stall-triage.d.ts

@@ -1,51 +0,0 @@
-/**
- * Operator-facing triage for the `timed out … with no output` / `Ran 0
- * checks` stall: the shape where the harness dies before any test output.
- *
- * Split out of `test-harness-crash.ts`, which classifies runs. This module
- * only renders advice about one already-classified shape. Keeping the two
- * apart matters because the census below carries claims of unequal
- * evidential strength, and the rules for editing it are not the rules for
- * editing a classifier: a pattern in the classifier is either matched by
- * the output or not, while a cause in the census is an assertion about the
- * world that an operator will act on.
- *
- * Everything here is pure. The platform and the probed display state are
- * injected, so unit tests need no mocking.
- */
-import type { DisplaySleepState } from './display-state.js';
-import type { HarnessCrashSignature } from './test-harness-signature.js';
-/**
- * Optional hint appended to the harness-crash message when a headed run on
- * macOS died at the no-output timeout.
- *
- * When `displayState` names a measured display state, the hint states it as
- * fact rather than as one of three possibilities, which is what probing is
- * for: an operator staring at a bare test failure should not have to
- * rediscover that their machine dimmed. `caffeinate` is described accurately
- * (it prevents sleep, and cannot wake an already-sleeping display), so
- * operators are not sent to a command that could not have helped them.
- *
- * Pure. The platform and the probed state are injected so unit tests need
- * no mocking.
- *
- * @param signature - The recognized crash shape
- * @param context - Run mode, platform, and the probed display state
- * @returns The hint text, or undefined when the shape does not apply
- */
-export declare function headedNoOutputTimeoutHint(signature: HarnessCrashSignature, context: {
-    headless: boolean;
-    platform: string;
-    displayState?: DisplaySleepState;
-}): string | undefined;
-/**
- * Verdict-line note for a headed no-output stall whose display was
- * measured asleep. Returned as the parenthetical the verdict line carries,
- * so the one greppable line an automated consumer reads already names the
- * environmental cause instead of a bare `FAIL reason=crash`.
- */
-export declare function headedDisplayAsleepVerdictNote(signature: HarnessCrashSignature, context: {
-    headless: boolean;
-    platform: string;
-    displayState: DisplaySleepState;
-}): string | undefined;