@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/test-harness-infra.d.ts

@@ -1,32 +0,0 @@
-/**
- * Harness failures that are the environment's, not the tests': the
- * operator message for a recognized harness crash after its retries ran
- * out, and the mochitest server that never came up.
- *
- * A server never comes up when the harness's httpd cannot bind its port,
- * typically because a parallel `--jobs` instance, a sibling checkout or a
- * leftover httpd held it (see `harness-port-reservation.ts`). Without this
- * shape the run read as `no-tests`, a finding about the
- * request, and was not retried. It is an infrastructure failure instead:
- * `classifyHarnessRun` reports it as a `harness-crash` carrying
- * `verdictReason: 'server-startup'`, so the harness-crash retry loop
- * (`--harness-retries`) reruns the shard, and a run that exhausts the
- * budget says `reason=server-startup` on its verdict line.
- */
-import type { HarnessCrashSignature } from './test-harness-signature.js';
-/**
- * Detects a mochitest server that failed to start. The caller checks that
- * no test ran first: both lines precede any test.
- *
- * @param output - Captured mach stdout and stderr
- * @returns The infrastructure signature, or undefined
- */
-export declare function detectServerStartupFailure(output: string): HarnessCrashSignature | undefined;
-/**
- * Builds the operator-facing failure message after retries are exhausted.
- *
- * @param signature - The recognized shape
- * @param attempts - Attempts made
- * @param commandLabel - The mach command, for the message
- */
-export declare function buildHarnessCrashMessage(signature: HarnessCrashSignature, attempts: number, commandLabel?: string): string;

package/dist/src/core/test-harness-infra.js

@@ -1,69 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Harness failures that are the environment's, not the tests': the
- * operator message for a recognized harness crash after its retries ran
- * out, and the mochitest server that never came up.
- *
- * A server never comes up when the harness's httpd cannot bind its port,
- * typically because a parallel `--jobs` instance, a sibling checkout or a
- * leftover httpd held it (see `harness-port-reservation.ts`). Without this
- * shape the run read as `no-tests`, a finding about the
- * request, and was not retried. It is an infrastructure failure instead:
- * `classifyHarnessRun` reports it as a `harness-crash` carrying
- * `verdictReason: 'server-startup'`, so the harness-crash retry loop
- * (`--harness-retries`) reruns the shard, and a run that exhausts the
- * budget says `reason=server-startup` on its verdict line.
- */
-/**
- * The harness's own lines for the shape: the httpd's bind failure
- * (`!!! could not start server on port 8888`) and `runtests.py`'s wait for
- * it (`Timed out while waiting for server startup`).
- */
-const SERVER_STARTUP_FAILURE_PATTERNS = [
-    /could not start server on port \d+/,
-    /Timed out while waiting for server startup/,
-];
-/**
- * Detects a mochitest server that failed to start. The caller checks that
- * no test ran first: both lines precede any test.
- *
- * @param output - Captured mach stdout and stderr
- * @returns The infrastructure signature, or undefined
- */
-export function detectServerStartupFailure(output) {
-    for (const line of output.split(/\r?\n/)) {
-        if (SERVER_STARTUP_FAILURE_PATTERNS.some((pattern) => pattern.test(line))) {
-            return {
-                reason: 'mochitest server failed to start (server-startup)',
-                line: line.trim(),
-                verdictReason: 'server-startup',
-            };
-        }
-    }
-    return undefined;
-}
-/**
- * Builds the operator-facing failure message after retries are exhausted.
- *
- * @param signature - The recognized shape
- * @param attempts - Attempts made
- * @param commandLabel - The mach command, for the message
- */
-export function buildHarnessCrashMessage(signature, attempts, commandLabel = 'mach test') {
-    if (signature.verdictReason !== 'server-startup') {
-        return (`${commandLabel} crashed in the harness itself (not in your tests) on all ${attempts} attempt(s).\n\n` +
-            `Detected shape: ${signature.reason}\n` +
-            `Evidence line: ${signature.line}\n\n` +
-            'This failure mode is environmental (mozlog resource monitor / psutil on macOS, focus-stall ' +
-            'shutdown re-entry, or a pre-test hang) rather than a test regression. Re-run the command, ' +
-            'raise the retry budget with --harness-retries <n>, or run the file in isolation. ' +
-            'If it persists across many runs, inspect the mach virtualenv (mach resyncs psutil on its own; ' +
-            'patching it manually does not stick).');
-    }
-    return (`${commandLabel} could not start a mochitest server on all ${attempts} attempt(s), so no ` +
-        'test ran (an infrastructure failure, not a test result).\n\n' +
-        `Evidence line: ${signature.line}\n\n` +
-        'Another harness (a parallel --jobs instance, a sibling checkout, or a leftover httpd) ' +
-        'most likely held the server port when this one started. Re-run the shard, raise the ' +
-        'retry budget with --harness-retries <n>, or check "lsof -nP -iTCP:8888".');
-}

package/dist/src/core/test-harness-output.d.ts

@@ -1,45 +0,0 @@
-export type HarnessEarlyExitKind = 'startup' | 'zero-tests';
-export interface HarnessEarlyExit {
-    kind: HarnessEarlyExitKind;
-    line: string;
-}
-export interface PostRebuildFailureContext {
-    rebuildCommand: string;
-    requestedPaths: readonly string[];
-    firstFailureLine?: string;
-}
-/**
- * Finds the first high-signal failure line from captured mach test output.
- *
- * Selection is by first matching line, not by first matching pattern, so the
- * bare `AttributeError:` arm above has exactly the same standing as
- * `TEST-UNEXPECTED-FAIL`: whichever appears earlier in the text wins. That
- * is how a run whose real defect was an export shard's file-count assertion
- * got diagnosed as the recognized mozsystemmonitor teardown crash. The
- * information was present and the selection was wrong, which is the
- * expensive kind of wrong, because the named cause is a real, documented,
- * unrelated upstream defect and therefore reads as an answer.
- *
- * So a capture carrying the recognized teardown incident gets two passes:
- * candidates excluding its `AttributeError` header first, and only if that
- * finds nothing does the full set apply. The narrowness the rest of the
- * codebase maintains is preserved exactly: the exclusion is gated on
- * `hasKnownTeardownNoise` for the whole capture, so it requires both the
- * closed attribute allowlist and a `resourcemonitor.py` frame. A novel
- * attribute, or a traceback from anywhere else, stays a real failure and is
- * still eligible to be reported.
- *
- * @param output - Raw captured stdout/stderr from the run
- * @returns The chosen failure line, or the first non-empty line
- */
-export declare function findFirstUsefulFailureLine(output: string): string | undefined;
-/** Starts a post-rebuild context block for a focused test failure. */
-export declare function createPostRebuildFailureContext(rebuildCommand: string, requestedPaths: readonly string[]): PostRebuildFailureContext;
-/** Adds the first useful failure line from captured output to an existing context block. */
-export declare function completePostRebuildFailureContext(context: PostRebuildFailureContext, output: string): PostRebuildFailureContext;
-/** Prepends post-rebuild context when the test failure happened after a successful rebuild. */
-export declare function prependPostRebuildFailureContext(message: string, context: PostRebuildFailureContext | undefined): string;
-/** Classifies mach output where no requested test actually began running. */
-export declare function classifyHarnessEarlyExit(output: string, normalizedPaths: readonly string[]): HarnessEarlyExit | undefined;
-/** Builds the user-facing message for a harness startup or zero-run failure. */
-export declare function buildHarnessEarlyExitMessage(earlyExit: HarnessEarlyExit, normalizedPaths: readonly string[]): string;

package/dist/src/core/test-harness-output.js

@@ -1,119 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { hasKnownTeardownNoise, isKnownTeardownNoiseLine } from './mach-known-noise-filter.js';
-function getNonEmptyOutputLines(output) {
-    return output
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-}
-function findFirstMatchingLine(lines, patterns) {
-    return lines.find((line) => patterns.some((pattern) => pattern.test(line)));
-}
-const FAILURE_LINE_PATTERNS = [
-    /\bTEST-UNEXPECTED-[A-Z-]+\b/,
-    /\bPROCESS-CRASH\b/i,
-    /\bTIMEOUT\b/i,
-    /timed out/i,
-    /HominisBrowserUnavailableError/i,
-    /Marionette.*(?:session|startup|start).*fail/i,
-    /(?:failed|unable) to (?:start|create|open).*Marionette/i,
-    /SessionNotCreatedException/i,
-    /Browser process exited during spawn/i,
-    /Failed to load (?:resource|chrome):\/\//i,
-    /\b(?:Error|Exception|TypeError|ReferenceError|SyntaxError):\s+/,
-    /AttributeError:\s+/,
-];
-/**
- * Finds the first high-signal failure line from captured mach test output.
- *
- * Selection is by first matching line, not by first matching pattern, so the
- * bare `AttributeError:` arm above has exactly the same standing as
- * `TEST-UNEXPECTED-FAIL`: whichever appears earlier in the text wins. That
- * is how a run whose real defect was an export shard's file-count assertion
- * got diagnosed as the recognized mozsystemmonitor teardown crash. The
- * information was present and the selection was wrong, which is the
- * expensive kind of wrong, because the named cause is a real, documented,
- * unrelated upstream defect and therefore reads as an answer.
- *
- * So a capture carrying the recognized teardown incident gets two passes:
- * candidates excluding its `AttributeError` header first, and only if that
- * finds nothing does the full set apply. The narrowness the rest of the
- * codebase maintains is preserved exactly: the exclusion is gated on
- * `hasKnownTeardownNoise` for the whole capture, so it requires both the
- * closed attribute allowlist and a `resourcemonitor.py` frame. A novel
- * attribute, or a traceback from anywhere else, stays a real failure and is
- * still eligible to be reported.
- *
- * @param output - Raw captured stdout/stderr from the run
- * @returns The chosen failure line, or the first non-empty line
- */
-export function findFirstUsefulFailureLine(output) {
-    const lines = getNonEmptyOutputLines(output);
-    if (hasKnownTeardownNoise(output)) {
-        const withoutNoise = lines.filter((line) => !isKnownTeardownNoiseLine(line));
-        const preferred = findFirstMatchingLine(withoutNoise, FAILURE_LINE_PATTERNS);
-        if (preferred !== undefined)
-            return preferred;
-    }
-    const matched = findFirstMatchingLine(lines, FAILURE_LINE_PATTERNS);
-    return matched ?? lines[0];
-}
-/** Starts a post-rebuild context block for a focused test failure. */
-export function createPostRebuildFailureContext(rebuildCommand, requestedPaths) {
-    return { rebuildCommand, requestedPaths };
-}
-/** Adds the first useful failure line from captured output to an existing context block. */
-export function completePostRebuildFailureContext(context, output) {
-    const firstFailureLine = findFirstUsefulFailureLine(output);
-    return firstFailureLine ? { ...context, firstFailureLine } : context;
-}
-/** Prepends post-rebuild context when the test failure happened after a successful rebuild. */
-export function prependPostRebuildFailureContext(message, context) {
-    if (!context)
-        return message;
-    const requestedPaths = context.requestedPaths.length > 0 ? context.requestedPaths.join(', ') : '(all tests)';
-    return ('Post-rebuild test failure:\n\n' +
-        `Rebuild command: ${context.rebuildCommand}\n` +
-        `Requested paths: ${requestedPaths}\n` +
-        `First post-rebuild failure: ${context.firstFailureLine ?? '(no captured output)'}\n\n` +
-        message);
-}
-/** Classifies mach output where no requested test actually began running. */
-export function classifyHarnessEarlyExit(output, normalizedPaths) {
-    const lines = getNonEmptyOutputLines(output);
-    const startupLine = findFirstMatchingLine(lines, [
-        /HominisBrowserUnavailableError/i,
-        /Marionette.*(?:session|startup|start).*fail/i,
-        /(?:failed|unable) to (?:start|create|open).*Marionette/i,
-        /SessionNotCreatedException/i,
-        /Browser process exited during spawn/i,
-    ]);
-    if (startupLine) {
-        return { kind: 'startup', line: startupLine };
-    }
-    if (normalizedPaths.length === 0)
-        return undefined;
-    const zeroTestsLine = findFirstMatchingLine(lines, [
-        /\bRan 0 tests?\b/i,
-        /\b0 tests? ran\b/i,
-        /\b0 tests? selected\b/i,
-        /\b0 subtests\b/i,
-        /\bno tests (?:were )?(?:run|ran|selected|collected|found)\b/i,
-    ]);
-    if (zeroTestsLine) {
-        return { kind: 'zero-tests', line: zeroTestsLine };
-    }
-    return undefined;
-}
-/** Builds the user-facing message for a harness startup or zero-run failure. */
-export function buildHarnessEarlyExitMessage(earlyExit, normalizedPaths) {
-    const reason = earlyExit.kind === 'startup'
-        ? 'The test harness failed during browser/session startup before the selected tests began.'
-        : 'The test harness exited after reporting that zero selected tests ran.';
-    const paths = normalizedPaths.length > 0 ? normalizedPaths.join(', ') : '(all tests)';
-    return (`mach test did not run the selected tests.\n\n` +
-        `${reason}\n\n` +
-        `Actionable harness line: ${earlyExit.line}\n\n` +
-        `Requested paths: ${paths}\n\n` +
-        'Fix the harness startup/discovery issue above before interpreting this as a test failure.');
-}

package/dist/src/core/test-harness-signature.d.ts

@@ -1,57 +0,0 @@
-/**
- * The recognized-harness-crash shape, in a module of its own.
- *
- * It lives apart from both of its users to break an import cycle:
- * `test-harness-crash.ts` re-exports the operator advice in
- * `test-stall-triage.ts`, and the triage text is keyed on this signature. A
- * type-only edge is erased at runtime, but the cycle gate reads the import
- * graph rather than the emitted code, and a shared leaf is a truer
- * description of the relationship than either direction of the cycle was:
- * neither module owns this type more than the other.
- *
- * {@link IncompleteRunEvidence} lives here for the same reason:
- * `test-run-completeness.ts` produces it from helpers in
- * `test-harness-crash.ts`, whose verdict type carries it.
- */
-/** A recognized harness-crash shape with its evidence line. */
-export interface HarnessCrashSignature {
-    /** Stable reason id for the recognized shape. */
-    reason: string;
-    /** The concrete output line the recognition was based on. */
-    line: string;
-    /**
-     * The verdict line's `reason=` for an infrastructure shape that is not a
-     * crash of the harness: `server-startup` when a mochitest server never
-     * came up. Unset: `reason=crash`.
-     */
-    verdictReason?: 'server-startup';
-}
-/**
- * The verdict line's `started=<n>/<m> first-unstarted=<path>
- * [started-source=<src>]` keys, or nothing when every file started.
- */
-export declare function formatIncompleteSuffix(evidence: IncompleteRunEvidence | undefined): string;
-/** The verdict line's `shards=<p>/<t> [failed-shards=<labels>]` keys of a sharded run. */
-export declare function formatShardsSuffix(shards: {
-    passed: number;
-    total: number;
-    failed?: readonly string[];
-} | undefined): string;
-/** Why an exit-0 run that would have read as a pass was failed instead. */
-export interface IncompleteRunEvidence {
-    /** Requested test files that produced a start (or skip) marker. */
-    started: number;
-    /** Requested test files the run could account for (test-file-shaped paths). */
-    requested: number;
-    /** First requested file, in dispatch order, that never started. */
-    firstUnstarted?: string;
-    /**
-     * Which evidence the start count came from, stamped with a short count:
-     * the structured raw log, the streamed output, or the capped capture.
-     */
-    startedSource?: 'raw' | 'stream' | 'capture';
-    /** The harness's "shut down in the middle of a test" line, when present. */
-    shutdownLine?: string;
-    /** The summary's non-zero `Unexpected results:` count, when it printed one. */
-    unexpected?: number;
-}

package/dist/src/core/test-harness-signature.js

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The recognized-harness-crash shape, in a module of its own.
- *
- * It lives apart from both of its users to break an import cycle:
- * `test-harness-crash.ts` re-exports the operator advice in
- * `test-stall-triage.ts`, and the triage text is keyed on this signature. A
- * type-only edge is erased at runtime, but the cycle gate reads the import
- * graph rather than the emitted code, and a shared leaf is a truer
- * description of the relationship than either direction of the cycle was:
- * neither module owns this type more than the other.
- *
- * {@link IncompleteRunEvidence} lives here for the same reason:
- * `test-run-completeness.ts` produces it from helpers in
- * `test-harness-crash.ts`, whose verdict type carries it.
- */
-/**
- * The verdict line's `started=<n>/<m> first-unstarted=<path>
- * [started-source=<src>]` keys, or nothing when every file started.
- */
-export function formatIncompleteSuffix(evidence) {
-    if (evidence?.firstUnstarted === undefined)
-        return '';
-    const source = evidence.startedSource === undefined ? '' : ` started-source=${evidence.startedSource}`;
-    return ` started=${evidence.started}/${evidence.requested} first-unstarted=${evidence.firstUnstarted}${source}`;
-}
-/** The verdict line's `shards=<p>/<t> [failed-shards=<labels>]` keys of a sharded run. */
-export function formatShardsSuffix(shards) {
-    if (shards === undefined)
-        return '';
-    const failed = shards.failed !== undefined && shards.failed.length > 0
-        ? ` failed-shards=${shards.failed.join(',')}`
-        : '';
-    return ` shards=${shards.passed}/${shards.total}${failed}`;
-}

package/dist/src/core/test-harness-verdict-notes.d.ts

@@ -1,54 +0,0 @@
-/**
- * Verdict-note helpers for the harness classifier.
- *
- * Split out of `test-harness-crash.ts` (at its per-file line budget). These
- * decide the advisory parenthetical on the `FIREFORGE-VERDICT:` line. None
- * of them changes a status or a reason key, which the verdict contract's
- * consumers parse.
- */
-/**
- * The only part of the classifier's summary counts these notes read.
- * Structural rather than an import of `HarnessSummaryCounts`: a type edge
- * back into `test-harness-crash.ts` is still an edge, and the cycle gate
- * rejects it.
- */
-interface SummaryCountsView {
-    unexpected?: number;
-}
-/**
- * Belt for the residual case the tightened {@link FAIL_LINE_PATTERN} /
- * {@link ASSERTION_LINE_PATTERN} cannot reach: the summary reported
- * `Unexpected results: 0`, yet the run is still classified `test-failures`
- * on evidence lines that carry NO `TEST-UNEXPECTED-*` marker.
- *
- * `unexpected=0` printed beside `reason=test-failures` means the verdict
- * rests on pattern matching rather than on a harness result, and a
- * reader who cannot see that spends hours attributing a red run to the
- * change under test. The note says so on the verdict line itself.
- *
- * This is a note and not a reclassification: a non-zero exit with no
- * green-shaped summary is still a failing run, and inventing a new `reason`
- * would break the `FIREFORGE-VERDICT:` contract its consumers parse.
- */
-export declare function unmarkedFailureEvidenceNote(counts: SummaryCountsView, realFailures: readonly string[]): string | undefined;
-/** Caps an evidence line so the one-line verdict note stays one line. */
-export declare function truncateEvidence(line: string): string;
-/**
- * Outcome of the green-teardown belt.
- *
- * `accepted` is the pass. A rejection carries `rejectedBy` only when the
- * recognized teardown noise was present, i.e. when the belt was the thing
- * that could have applied and did not. That is what the field is for: a run
- * with no teardown traceback was never a candidate and naming a "rejecting
- * condition" for it would be noise, whereas a run that does carry the
- * traceback and still fails is the shape an operator otherwise cannot
- * diagnose from outside. Every condition is all-or-nothing, so the failing
- * verdict looks identical whichever one rejected it, and a downstream report
- * spent a re-run and a filed-bug's worth of effort guessing between them.
- */
-export interface GreenTeardownOverride {
-    accepted: boolean;
-    /** Which single condition rejected, when the teardown noise was present. */
-    rejectedBy?: string;
-}
-export {};

package/dist/src/core/test-harness-verdict-notes.js

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Verdict-note helpers for the harness classifier.
- *
- * Split out of `test-harness-crash.ts` (at its per-file line budget). These
- * decide the advisory parenthetical on the `FIREFORGE-VERDICT:` line. None
- * of them changes a status or a reason key, which the verdict contract's
- * consumers parse.
- */
-/**
- * A single `TEST-UNEXPECTED-*` marker. Local copy of the classifier's line
- * pattern: importing the value would draw a runtime edge back into
- * `test-harness-crash.ts` and make the split circular.
- */
-const UNEXPECTED_MARKER = /TEST-UNEXPECTED-\w+/;
-/**
- * Belt for the residual case the tightened {@link FAIL_LINE_PATTERN} /
- * {@link ASSERTION_LINE_PATTERN} cannot reach: the summary reported
- * `Unexpected results: 0`, yet the run is still classified `test-failures`
- * on evidence lines that carry NO `TEST-UNEXPECTED-*` marker.
- *
- * `unexpected=0` printed beside `reason=test-failures` means the verdict
- * rests on pattern matching rather than on a harness result, and a
- * reader who cannot see that spends hours attributing a red run to the
- * change under test. The note says so on the verdict line itself.
- *
- * This is a note and not a reclassification: a non-zero exit with no
- * green-shaped summary is still a failing run, and inventing a new `reason`
- * would break the `FIREFORGE-VERDICT:` contract its consumers parse.
- */
-export function unmarkedFailureEvidenceNote(counts, realFailures) {
-    if (counts.unexpected !== 0)
-        return undefined;
-    if (realFailures.length === 0)
-        return undefined;
-    if (realFailures.some((line) => UNEXPECTED_MARKER.test(line)))
-        return undefined;
-    return 'summary reported 0 unexpected; no TEST-UNEXPECTED marker in the matched evidence';
-}
-/** Caps an evidence line so the one-line verdict note stays one line. */
-export function truncateEvidence(line) {
-    const flat = line.trim().replace(/\s+/g, ' ');
-    return flat.length <= GREEN_TEARDOWN_EVIDENCE_LIMIT
-        ? flat
-        : `${flat.slice(0, GREEN_TEARDOWN_EVIDENCE_LIMIT)}…`;
-}
-/** Character budget for an evidence excerpt inside the verdict note. */
-const GREEN_TEARDOWN_EVIDENCE_LIMIT = 80;

package/dist/src/core/test-host-state.d.ts

@@ -1,14 +0,0 @@
-export interface TestHostState {
-    load: number;
-    topProcess?: {
-        cpu: number;
-        command: string;
-    };
-    power: 'ac' | 'battery' | 'unknown';
-}
-/** Samples load/top process and the macOS power SOURCE (including charging on AC). */
-export declare function sampleTestHost(): Promise<TestHostState>;
-/** Reports host contention alongside a suite's result, without inventing a test failure. */
-export declare function reportTestHost(state: TestHostState, phase: string): boolean;
-/** Stamps each perf artifact before the verdict, preserving the producer's schema and data. */
-export declare function stampPerfHost(env: Record<string, string> | undefined, start: TestHostState, end: TestHostState): Promise<boolean>;

package/dist/src/core/test-host-state.js

@@ -1,80 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { loadavg } from 'node:os';
-import { toError } from '../utils/errors.js';
-import { pathExists, readJson, writeJson } from '../utils/fs.js';
-import { notice } from '../utils/logger.js';
-import { exec } from '../utils/process.js';
-import { isObject } from '../utils/validation.js';
-/** Samples load/top process and the macOS power SOURCE (including charging on AC). */
-export async function sampleTestHost() {
-    const state = { load: loadavg()[0] ?? 0, power: 'unknown' };
-    try {
-        const result = await exec('ps', ['-axo', 'pcpu=,comm='], { timeout: 5000 });
-        const processes = result.stdout
-            .split('\n')
-            .flatMap((line) => {
-            const match = /^\s*([\d.]+)\s+(.+)$/.exec(line);
-            return match ? [{ cpu: Number(match[1]), command: match[2] ?? '' }] : [];
-        })
-            .sort((a, b) => b.cpu - a.cpu);
-        if (processes[0])
-            state.topProcess = processes[0];
-    }
-    catch {
-        /* Host diagnostics remain best effort. */
-    }
-    if (process.platform === 'darwin') {
-        try {
-            const result = await exec('pmset', ['-g', 'ps'], { timeout: 5000 });
-            state.power = /'AC Power'/.test(result.stdout)
-                ? 'ac'
-                : /'Battery Power'/.test(result.stdout)
-                    ? 'battery'
-                    : 'unknown';
-        }
-        catch {
-            /* Keep unknown when power tooling is unavailable. */
-        }
-    }
-    return state;
-}
-/** Reports host contention alongside a suite's result, without inventing a test failure. */
-export function reportTestHost(state, phase) {
-    const pegged = (state.topProcess?.cpu ?? 0) >= 90;
-    if (state.load < 4 && !pegged)
-        return false;
-    notice(`Host load at ${phase}: ${state.load.toFixed(2)}; top process ${state.topProcess?.command ?? '(unknown)'} ${state.topProcess?.cpu ?? 0}% CPU. Timing failures may reflect host contention.`);
-    return true;
-}
-/** Stamps each perf artifact before the verdict, preserving the producer's schema and data. */
-export async function stampPerfHost(env, start, end) {
-    if (!env)
-        return false;
-    const artifacts = [
-        ...new Set(Object.entries(env)
-            .filter(([key]) => key.endsWith('_PERF_SAMPLE_JSON'))
-            .map(([, path]) => path)),
-    ];
-    if (artifacts.length === 0)
-        return false;
-    const changed = start.power !== 'unknown' && end.power !== 'unknown' && start.power !== end.power;
-    if (changed)
-        notice(`Perf power source changed during the run (${start.power} → ${end.power}); this sample is inconclusive.`);
-    for (const artifact of artifacts) {
-        try {
-            if (!(await pathExists(artifact)))
-                continue;
-            const sample = await readJson(artifact);
-            if (!isObject(sample))
-                throw new Error('sample JSON is not an object');
-            await writeJson(artifact, {
-                ...sample,
-                fireforgeHost: { start, end, powerSourceChanged: changed },
-            });
-        }
-        catch (error) {
-            notice(`Could not annotate perf artifact ${artifact}: ${toError(error).message}. The harness outcome is preserved; inspect or regenerate this artifact before using it as perf evidence.`);
-        }
-    }
-    return changed;
-}

package/dist/src/core/test-path-scope.d.ts

@@ -1,59 +0,0 @@
-/**
- * Directory-argument scope analysis for `fireforge test`.
- *
- * mozbuild's test resolver matches command-line paths by string prefix, so
- * `fireforge test browser/base/content/test/hominis` also runs the sibling
- * directory `browser/base/content/test/hominis-tiles`, silently, and with
- * no indication the scope widened.
- *
- * FireForge therefore treats a directory argument as meaning exactly that
- * directory: {@link analyzeTestPathScopes} enumerates the test files of
- * exactly that directory and dispatches that explicit file list to mach,
- * because a file list cannot prefix-match anything. Normalizing the
- * directory with a trailing `/` does not work. Mach still sweeps in the
- * prefix-named sibling. The prefix-matching sibling directories are still
- * reported so the command layer can tell the operator what was excluded.
- *
- * FireForge already rejects non-existent paths up front, so raw
- * prefix-widening was never something an operator could invoke on purpose.
- * It only ever happened by accident.
- */
-/** A sibling directory the raw mach prefix match would have included. */
-export interface SiblingPrefixMatch {
-    /** Engine-relative path of the sibling directory. */
-    path: string;
-    /** Recursive count of `browser_*` / `test_*` JS files under it. */
-    testFileCount: number;
-}
-/** Scope analysis for one `fireforge test` path argument. */
-export interface TestPathScope {
-    /** The path as the operator passed it (engine-relative, normalized). */
-    requestedPath: string;
-    /**
-     * The paths to hand to mach for this argument: the explicit test-file
-     * list for a directory (mach cannot prefix-widen an explicit file
-     * list), or the argument unchanged for files. A directory containing
-     * no enumerable test files falls back to the trailing-`/` directory
-     * form: there is nothing to list, and mach owns the "no tests found"
-     * failure.
-     */
-    dispatchPaths: string[];
-    /** True when the path resolved to a directory under engine/. */
-    isDirectory: boolean;
-    /** Test files enumerated inside the requested directory (empty for files). */
-    testFileCount: number;
-    /** Sibling directories a raw prefix match would also have selected. */
-    siblingPrefixMatches: SiblingPrefixMatch[];
-}
-/**
- * Analyzes every test path argument of a run.
- *
- * @param engineDir - Path to the engine directory
- * @param requestedPaths - Engine-relative test path arguments
- */
-export declare function analyzeTestPathScopes(engineDir: string, requestedPaths: readonly string[]): Promise<TestPathScope[]>;
-/**
- * Formats the sibling-exclusion notice for one scope, or undefined when
- * nothing needs saying (file arg, or no prefix-matching siblings).
- */
-export declare function formatScopeNotice(scope: TestPathScope): string | undefined;