@hominis/fireforge 0.35.0 → 0.36.0

package/dist/src/core/status-classify.js

@@ -13,7 +13,29 @@ import { verbose } from '../utils/logger.js';
 import { isBrandingManagedPath } from './branding.js';
 import { computePatchedContent } from './patch-apply.js';
 import { loadPatchesManifest } from './patch-manifest.js';
-function getPrimaryStatusCode(status) {
+/**
+ * Builds the file → owning-patch-filenames multimap from manifest rows.
+ * Single source of truth for cross-patch claim detection — status
+ * classification, verify's cross-claim check, and the ownership table all
+ * consume this builder (they used to each rebuild it, one drift away from
+ * disagreeing about what "claimed" means).
+ */
+export function buildPatchClaims(manifestPatches) {
+    const ownersByPath = new Map();
+    for (const patch of manifestPatches) {
+        for (const file of patch.filesAffected) {
+            const existing = ownersByPath.get(file) ?? [];
+            existing.push(patch.filename);
+            ownersByPath.set(file, existing);
+        }
+    }
+    return ownersByPath;
+}
+/**
+ * Reduces a two-character porcelain XY status to its primary code.
+ * Single source of truth — status-output.ts renders from the same logic.
+ */
+export function getPrimaryStatusCode(status) {
     if (status.includes('?'))
         return '?';
     if (status.includes('!'))
@@ -55,20 +77,7 @@ export async function classifyFiles(files, engineDir, patchesDir, binaryName, fu
     // branch where the expected-vs-actual content comparison then routed
     // them into `unmanaged` when the content didn't match either owner's
     // expectation.
-    const patchClaims = new Map();
-    if (manifest) {
-        for (const patch of manifest.patches) {
-            for (const f of patch.filesAffected) {
-                const owners = patchClaims.get(f);
-                if (owners) {
-                    owners.push(patch.filename);
-                }
-                else {
-                    patchClaims.set(f, [patch.filename]);
-                }
-            }
-        }
-    }
+    const patchClaims = manifest ? buildPatchClaims(manifest.patches) : new Map();
     const results = [];
     for (const entry of files) {
         const owners = patchClaims.get(entry.file);
@@ -145,4 +154,3 @@ export async function classifyFiles(files, engineDir, patchesDir, binaryName, fu
     }
     return results;
 }
-//# sourceMappingURL=status-classify.js.map

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

@@ -32,12 +32,34 @@ export interface HarnessCrashSignature {
 export interface HarnessRunVerdict {
     kind: HarnessRunClassification;
     signature?: HarnessCrashSignature;
+    /** First concrete test-failure evidence line, when available. */
+    realFailureLine?: string;
+    /** Harness noise seen in the same output as a real test failure. */
+    secondaryHarnessSignature?: HarnessCrashSignature;
     /**
      * Set when a non-zero mach exit code was overridden because the output
      * embeds a completed green summary — the exit code followed harness
      * noise, not a test result. Callers should surface a note.
      */
     greenSummaryOverride?: boolean;
+    /**
+     * Set when the output embeds a green-LOOKING summary that was REJECTED:
+     * crash or truncation evidence proves the suite never completed, so the
+     * "green" counts only cover the files that ran before the run died
+     * (field report: a SIGSEGV at the second of eight files left a
+     * `Passed: 2 / Failed: 0` summary that 0.35.0 green-washed into a pass).
+     * Callers must fail the run and surface the evidence.
+     */
+    greenSummaryRejected?: GreenSummaryRejection;
+}
+/** Why a green-looking embedded summary was not trusted. */
+export interface GreenSummaryRejection {
+    /** Crash-marker evidence line (mozcrash / signal kill), if any. */
+    crashLine?: string;
+    /** Requested test files with no `TEST_START`/`TEST-START` line at all. */
+    neverStarted: string[];
+    /** Files whose `TEST_START` has no matching end marker. */
+    neverEnded: string[];
 }
 /**
  * Strips non-signal noise from captured output before crash-signature
@@ -47,17 +69,41 @@ export interface HarnessRunVerdict {
  * classification of test results still reads the full output.
  */
 export declare function stripNonSignalNoise(output: string): string;
+/**
+ * Finds the first crash-marker line in the RAW output (see
+ * {@link CRASH_MARKER_PATTERNS}), or undefined when the run shows no
+ * crash evidence. Exported for direct unit testing.
+ */
+export declare function findCrashMarkerLine(output: string): string | undefined;
 /**
  * True when the output embeds a COMPLETED, GREEN suite summary: an
  * execution signal, `Unexpected results: 0` (and no non-zero unexpected
- * count), a `SUITE_END` marker, and no real `TEST-UNEXPECTED-*` lines.
- * Such a run finished its suite; any startup-traceback-shaped noise in the
- * same output is by definition non-fatal, so this vetoes signature-based
- * crash classification (field report: fully green sharded runs reported
- * `CRASH (N attempts)` because degradation warnings matched the psutil
- * signals). Exported for direct unit testing.
+ * count), a `SUITE_END` marker, no real `TEST-UNEXPECTED-*` lines — and
+ * NO crash marker. Such a run finished its suite; any startup-traceback-
+ * shaped noise in the same output is by definition non-fatal, so this
+ * vetoes signature-based crash classification (field report: fully green
+ * sharded runs reported `CRASH (N attempts)` because degradation warnings
+ * matched the psutil signals). A summary printed after a crash marker is
+ * NOT "completed" — it only covers the files that ran before the crash
+ * (0.35.0 green-wash field report). Exported for direct unit testing.
  */
 export declare function hasCompletedGreenSummary(output: string): boolean;
+/**
+ * Cross-checks run completeness against the requested test files: every
+ * requested file must produce a start marker, and every started test must
+ * produce an end marker (the harness emits both even for failing files).
+ *
+ * Ends are paired with starts POSITIONALLY (last open start is closed by
+ * the next end), not by filename — the xpcshell dialect's `TEST_END: Test
+ * PASS` lines do not name the file. Requested paths that are not
+ * test-file-shaped (directories, manifests) are skipped for the
+ * never-started check; the start/end pairing scan covers them regardless.
+ * Exported for direct unit testing.
+ */
+export declare function analyzeTestCompleteness(output: string, requestedPaths: readonly string[]): {
+    neverStarted: string[];
+    neverEnded: string[];
+};
 /**
  * Detects the known harness-crash shapes in captured mach output.
  * Returns undefined for anything that looks like a genuine test result.
@@ -76,9 +122,20 @@ export declare function detectHarnessCrashSignature(output: string): HarnessCras
  *    dispatch prints no `TEST-START`). Bare `Passed:`/`Failed:` summary
  *    lines are still not trusted as evidence of execution.
  * 3. Exit code zero with tests started is a pass; anything else is a
- *    test failure for the regular diagnosis chain.
+ *    test failure for the regular diagnosis chain — except a non-zero
+ *    exit whose embedded summary completed green AND shows no crash
+ *    marker and no truncated/never-started requested file, which is a
+ *    pass with a `greenSummaryOverride` note (harness noise owns the
+ *    exit code). A green-shaped summary WITH such evidence is rejected
+ *    (`greenSummaryRejected`) and fails.
  */
 export declare function classifyHarnessRun(exitCode: number, output: string, requestedPaths: readonly string[]): HarnessRunVerdict;
+/**
+ * Builds the operator-facing failure message for a green-looking summary
+ * that was rejected on crash or truncation evidence (never trusted as a
+ * pass, regardless of how green the embedded counts look).
+ */
+export declare function buildGreenSummaryRejectedMessage(rejection: GreenSummaryRejection, exitCode: number): string;
 /** Builds the operator-facing failure message after retries are exhausted. */
 export declare function buildHarnessCrashMessage(signature: HarnessCrashSignature, attempts: number, commandLabel?: string): string;
 /**

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

@@ -47,10 +47,30 @@ const NONZERO_UNEXPECTED_SUMMARY_PATTERN = /\bUnexpected results:\s*[1-9]/;
  */
 const XPCSHELL_RESULT_SUMMARY_PATTERN = /\bTEST_END\b|\bRan \d+ checks?\b|\bResult summary:/i;
 const UNEXPECTED_LINE_PATTERN = /^.*\bTEST-UNEXPECTED-[A-Z-]+\b.*$/gm;
+const FAIL_LINE_PATTERN = /^.*\bFAIL\b.*$/gm;
+const ASSERTION_LINE_PATTERN = /^.*\b(?:Assertion failure|MOZ_ASSERT|ASSERTION)\b.*$/gim;
 const SHUTDOWN_REENTRY_PATTERN = /Application shut down \(without crashing\) in the middle of a test/i;
 const FOCUS_STALL_PATTERN = /must wait for focus/i;
 const TRACEBACK_PATTERN = /Traceback \(most recent call last\)/;
 const NO_OUTPUT_TIMEOUT_PATTERN = /timed out after \d+ seconds with no output/i;
+/**
+ * Crash-marker lines mozcrash / the mochitest harness print when the
+ * browser process itself died. Matched against the RAW output (never
+ * noise-stripped): any of these proves the run was truncated by a crash,
+ * so an embedded green summary is under-reporting, not a result (field
+ * report: `Main app process: killed by SIGSEGV` at the second of eight
+ * files, summary `Passed: 2 / Failed: 0`, mach exit 1 — 0.35.0 accepted
+ * it as passed and masked a real regression for a whole drill).
+ */
+const CRASH_MARKER_PATTERNS = [
+    /Main app process: killed by SIG\w+/,
+    /\bPROCESS-CRASH\b/,
+    // The minidump-processing header shapes mozcrash emits when it walks a
+    // crash dump after the run.
+    /mozcrash.*minidump/i,
+    /Crash dump filename/i,
+    /Thread \d+ \(crashed\)/,
+];
 /**
  * Startup-traceback fingerprints from the mozlog resource monitor / psutil
  * on macOS. Each is matched per-line so the evidence line in the report is
@@ -165,22 +185,89 @@ function hasExecutionSignal(output) {
         hasXpcshellResultSummary(output));
 }
 /**
- * True when the output embeds a COMPLETED, GREEN suite summary: an
- * execution signal, `Unexpected results: 0` (and no non-zero unexpected
- * count), a `SUITE_END` marker, and no real `TEST-UNEXPECTED-*` lines.
- * Such a run finished its suite; any startup-traceback-shaped noise in the
- * same output is by definition non-fatal, so this vetoes signature-based
- * crash classification (field report: fully green sharded runs reported
- * `CRASH (N attempts)` because degradation warnings matched the psutil
- * signals). Exported for direct unit testing.
+ * Finds the first crash-marker line in the RAW output (see
+ * {@link CRASH_MARKER_PATTERNS}), or undefined when the run shows no
+ * crash evidence. Exported for direct unit testing.
  */
-export function hasCompletedGreenSummary(output) {
+export function findCrashMarkerLine(output) {
+    return findLine(output, CRASH_MARKER_PATTERNS);
+}
+/**
+ * True when the summary lines LOOK green: execution signal, `Unexpected
+ * results: 0` with no non-zero count, `SUITE_END`, no real
+ * `TEST-UNEXPECTED-*` lines. Deliberately blind to crash/truncation
+ * evidence — {@link hasCompletedGreenSummary} layers that on top, and
+ * {@link classifyHarnessRun} needs the distinction to report WHY a
+ * green-shaped summary was rejected.
+ */
+function hasGreenShapedSummary(output) {
     return (hasExecutionSignal(output) &&
         SUITE_END_PATTERN.test(output) &&
         GREEN_UNEXPECTED_SUMMARY_PATTERN.test(output) &&
         !NONZERO_UNEXPECTED_SUMMARY_PATTERN.test(output) &&
         realUnexpectedFailureLines(output).length === 0);
 }
+/**
+ * True when the output embeds a COMPLETED, GREEN suite summary: an
+ * execution signal, `Unexpected results: 0` (and no non-zero unexpected
+ * count), a `SUITE_END` marker, no real `TEST-UNEXPECTED-*` lines — and
+ * NO crash marker. Such a run finished its suite; any startup-traceback-
+ * shaped noise in the same output is by definition non-fatal, so this
+ * vetoes signature-based crash classification (field report: fully green
+ * sharded runs reported `CRASH (N attempts)` because degradation warnings
+ * matched the psutil signals). A summary printed after a crash marker is
+ * NOT "completed" — it only covers the files that ran before the crash
+ * (0.35.0 green-wash field report). Exported for direct unit testing.
+ */
+export function hasCompletedGreenSummary(output) {
+    return hasGreenShapedSummary(output) && findCrashMarkerLine(output) === undefined;
+}
+/** Basename shape of a mozbuild-manifest test implementation file. */
+const TEST_FILE_BASENAME_PATTERN = /^(?:browser|test)_.*\.m?js$/;
+/**
+ * Start/end execution markers, both log dialects: the structured mozlog
+ * `TEST_START`/`TEST_END` pair and the human browser-chrome
+ * `TEST-START`/`TEST-OK` pair. `TEST-UNEXPECTED-*` end shapes are
+ * irrelevant here — any such line already fails the green-summary check
+ * before completeness is consulted.
+ */
+const START_MARKER_PATTERN = /\bTEST[-_]START\b[:| ]*\s*(\S+)?/;
+const END_MARKER_PATTERN = /\bTEST[-_]END\b|\bTEST-OK\b/;
+/**
+ * Cross-checks run completeness against the requested test files: every
+ * requested file must produce a start marker, and every started test must
+ * produce an end marker (the harness emits both even for failing files).
+ *
+ * Ends are paired with starts POSITIONALLY (last open start is closed by
+ * the next end), not by filename — the xpcshell dialect's `TEST_END: Test
+ * PASS` lines do not name the file. Requested paths that are not
+ * test-file-shaped (directories, manifests) are skipped for the
+ * never-started check; the start/end pairing scan covers them regardless.
+ * Exported for direct unit testing.
+ */
+export function analyzeTestCompleteness(output, requestedPaths) {
+    const startedNames = [];
+    const openTests = [];
+    for (const line of output.split(/\r?\n/)) {
+        const startMatch = START_MARKER_PATTERN.exec(line);
+        if (startMatch) {
+            const name = startMatch[1] ?? '(unnamed test)';
+            startedNames.push(name);
+            openTests.push(name);
+            continue;
+        }
+        if (END_MARKER_PATTERN.test(line)) {
+            openTests.pop();
+        }
+    }
+    const neverStarted = requestedPaths.filter((path) => {
+        const base = path.slice(path.lastIndexOf('/') + 1);
+        if (!TEST_FILE_BASENAME_PATTERN.test(base))
+            return false;
+        return !startedNames.some((name) => name.includes(base));
+    });
+    return { neverStarted, neverEnded: openTests };
+}
 /**
  * True when the captured output carries the suite-specific xpcshell
  * result-summary block, which proves tests executed even though the
@@ -193,14 +280,49 @@ function hasXpcshellResultSummary(output) {
 }
 /** Unexpected-failure lines that are NOT the shutdown re-entry artifact. */
 function realUnexpectedFailureLines(output) {
-    const matches = output.match(UNEXPECTED_LINE_PATTERN) ?? [];
-    return matches.filter((line) => !SHUTDOWN_REENTRY_PATTERN.test(line));
+    const matches = [
+        ...(output.match(UNEXPECTED_LINE_PATTERN) ?? []),
+        ...(output.match(FAIL_LINE_PATTERN) ?? []),
+        ...(output.match(ASSERTION_LINE_PATTERN) ?? []),
+    ];
+    if (NONZERO_UNEXPECTED_SUMMARY_PATTERN.test(output)) {
+        const summary = output
+            .split(/\r?\n/)
+            .find((line) => NONZERO_UNEXPECTED_SUMMARY_PATTERN.test(line));
+        if (summary)
+            matches.push(summary);
+    }
+    return [...new Set(matches.map((line) => line.trim()))].filter((line) => !SHUTDOWN_REENTRY_PATTERN.test(line));
+}
+function detectSecondaryHarnessNoise(output) {
+    const evidence = stripNonSignalNoise(output);
+    if (TRACEBACK_PATTERN.test(evidence)) {
+        const signalLine = findLine(evidence, STARTUP_TRACEBACK_SIGNALS);
+        if (signalLine) {
+            return {
+                reason: 'harness traceback also present (resource monitor/psutil)',
+                line: signalLine,
+            };
+        }
+    }
+    const timeoutLine = findLine(evidence, [NO_OUTPUT_TIMEOUT_PATTERN]);
+    if (timeoutLine) {
+        return { reason: 'harness no-output timeout also present', line: timeoutLine };
+    }
+    return undefined;
 }
 /**
  * Detects the known harness-crash shapes in captured mach output.
  * Returns undefined for anything that looks like a genuine test result.
  */
 export function detectHarnessCrashSignature(output) {
+    // Browser/app process crashes are deterministic crash evidence, not
+    // retriable environmental harness noise. Leave them to
+    // `classifyHarnessRun` so it can reject green-looking truncated summaries
+    // with the crash line plus never-started/never-ended file evidence.
+    if (findCrashMarkerLine(output) !== undefined) {
+        return undefined;
+    }
     const hasTestStart = hasExecutionSignal(output);
     const realFailures = realUnexpectedFailureLines(output);
     // A completed green embedded summary vetoes signature-based crash
@@ -265,9 +387,17 @@ export function detectHarnessCrashSignature(output) {
  *    dispatch prints no `TEST-START`). Bare `Passed:`/`Failed:` summary
  *    lines are still not trusted as evidence of execution.
  * 3. Exit code zero with tests started is a pass; anything else is a
- *    test failure for the regular diagnosis chain.
+ *    test failure for the regular diagnosis chain — except a non-zero
+ *    exit whose embedded summary completed green AND shows no crash
+ *    marker and no truncated/never-started requested file, which is a
+ *    pass with a `greenSummaryOverride` note (harness noise owns the
+ *    exit code). A green-shaped summary WITH such evidence is rejected
+ *    (`greenSummaryRejected`) and fails.
  */
 export function classifyHarnessRun(exitCode, output, requestedPaths) {
+    const realFailures = realUnexpectedFailureLines(output);
+    const firstRealFailure = realFailures[0];
+    const secondaryHarnessSignature = firstRealFailure !== undefined ? detectSecondaryHarnessNoise(output) : undefined;
     const signature = detectHarnessCrashSignature(output);
     if (signature) {
         return { kind: 'harness-crash', signature };
@@ -284,10 +414,62 @@ export function classifyHarnessRun(exitCode, output, requestedPaths) {
     // non-zero on harness noise (field report: a fully green --no-shard run
     // exited 1). Real failures always carry a non-zero unexpected count or
     // TEST-UNEXPECTED lines, both of which fail the green-summary check.
-    if (hasCompletedGreenSummary(output)) {
+    //
+    // The override must never win over crash or truncation evidence
+    // (0.35.0 green-wash field report: a SIGSEGV at the second of eight
+    // files produced a "green" `Passed: 2 / Failed: 0` summary and mach
+    // exit 1 — the summary was green only because the crash prevented the
+    // other six files from producing any results). A crash marker or an
+    // unpaired/never-started requested file rejects the override with the
+    // evidence attached, so the caller can say why.
+    if (hasGreenShapedSummary(output)) {
+        const crashLine = findCrashMarkerLine(output);
+        const completeness = analyzeTestCompleteness(output, requestedPaths);
+        if (crashLine !== undefined ||
+            completeness.neverStarted.length > 0 ||
+            completeness.neverEnded.length > 0) {
+            return {
+                kind: 'test-failures',
+                ...(firstRealFailure !== undefined ? { realFailureLine: firstRealFailure } : {}),
+                ...(secondaryHarnessSignature !== undefined ? { secondaryHarnessSignature } : {}),
+                greenSummaryRejected: {
+                    ...(crashLine !== undefined ? { crashLine } : {}),
+                    neverStarted: completeness.neverStarted,
+                    neverEnded: completeness.neverEnded,
+                },
+            };
+        }
         return { kind: 'tests-ran-ok', greenSummaryOverride: true };
     }
-    return { kind: 'test-failures' };
+    return {
+        kind: 'test-failures',
+        ...(firstRealFailure !== undefined ? { realFailureLine: firstRealFailure } : {}),
+        ...(secondaryHarnessSignature !== undefined ? { secondaryHarnessSignature } : {}),
+    };
+}
+/**
+ * Builds the operator-facing failure message for a green-looking summary
+ * that was rejected on crash or truncation evidence (never trusted as a
+ * pass, regardless of how green the embedded counts look).
+ */
+export function buildGreenSummaryRejectedMessage(rejection, exitCode) {
+    const evidence = [];
+    if (rejection.crashLine !== undefined) {
+        evidence.push(`  - crash evidence: ${rejection.crashLine}`);
+    }
+    if (rejection.neverStarted.length > 0) {
+        evidence.push(`  - requested test file(s) that never started: ${rejection.neverStarted.join(', ')}`);
+    }
+    if (rejection.neverEnded.length > 0) {
+        evidence.push(`  - test file(s) that started but never finished: ${rejection.neverEnded.join(', ')}`);
+    }
+    return (`mach exited ${exitCode} and the embedded suite summary looks green, but FireForge did NOT ` +
+        'treat the run as passed:\n\n' +
+        `${evidence.join('\n')}\n\n` +
+        'A crash- or truncation-shortened run under-reports: the "green" counts only cover the ' +
+        'files that ran before the run died, so the summary is not a suite result. Treat this as a ' +
+        'FAILED run — check the crash/truncation point in the output above, then re-run the ' +
+        'remaining files.');
 }
 /** Builds the operator-facing failure message after retries are exhausted. */
 export function buildHarnessCrashMessage(signature, attempts, commandLabel = 'mach test') {
@@ -315,4 +497,3 @@ export function buildNoTestsRanMessage(exitCode, requestedPaths) {
         'Check that the paths are registered in their test manifest (browser.toml / xpcshell.toml) ' +
         'and that the manifest is reachable from moz.build, then retry.');
 }
-//# sourceMappingURL=test-harness-crash.js.map

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

@@ -86,4 +86,3 @@ export function buildHarnessEarlyExitMessage(earlyExit, normalizedPaths) {
         `Requested paths: ${paths}\n\n` +
         'Fix the harness startup/discovery issue above before interpreting this as a test failure.');
 }
-//# sourceMappingURL=test-harness-output.js.map

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

@@ -5,17 +5,21 @@
  * so `fireforge test browser/base/content/test/hominis` silently also
  * ran the sibling directory `browser/base/content/test/hominis-tiles`
  * (152.0b7 → 153.0b8 source-refresh drill: 1224 tests instead of ~200,
- * with no indication the scope widened). A trailing separator makes the
- * prefix match exact — `hominis/` cannot prefix `hominis-tiles/…`.
+ * with no indication the scope widened).
  *
  * FireForge therefore treats a directory argument as meaning EXACTLY
- * that directory: {@link analyzeTestPathScopes} returns a trailing-`/`
- * dispatch form for every existing directory, plus the sibling
- * directories the raw prefix would have swept in so the command layer
- * can tell the operator what was excluded. Note FireForge already
- * rejects non-existent paths up front, so raw prefix-widening was never
- * something an operator could invoke deliberately — it only ever
- * happened by accident.
+ * that directory: {@link analyzeTestPathScopes} enumerates the test
+ * files of exactly that directory and dispatches THAT explicit file
+ * list to mach — a file list cannot prefix-match anything. (0.35.0
+ * instead normalized the directory with a trailing `/`, assuming the
+ * separator makes the prefix match exact; field verification on Firefox
+ * 153 showed mach still swept in the prefix-named sibling, so the
+ * trailing-slash mechanism was cosmetic and its exclusion echo was
+ * wrong.) The prefix-matching sibling directories are still reported so
+ * the command layer can tell the operator what was excluded. Note
+ * FireForge already rejects non-existent paths up front, so raw
+ * prefix-widening was never something an operator could invoke
+ * deliberately — it only ever happened by accident.
  */
 /** A sibling directory the raw mach prefix match would have included. */
 export interface SiblingPrefixMatch {
@@ -29,13 +33,17 @@ export interface TestPathScope {
     /** The path as the operator passed it (engine-relative, normalized). */
     requestedPath: string;
     /**
-     * The form to hand to mach: directories gain a trailing `/` so
-     * mozbuild's prefix match is exact; files pass through unchanged.
+     * 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.
      */
-    dispatchPath: string;
+    dispatchPaths: string[];
     /** True when the path resolved to a directory under engine/. */
     isDirectory: boolean;
-    /** Recursive test-file count inside the requested directory (0 for files). */
+    /** Test files enumerated inside the requested directory (empty for files). */
     testFileCount: number;
     /** Sibling directories a raw prefix match would also have selected. */
     siblingPrefixMatches: SiblingPrefixMatch[];

package/dist/src/core/test-path-scope.js

@@ -6,45 +6,50 @@
  * so `fireforge test browser/base/content/test/hominis` silently also
  * ran the sibling directory `browser/base/content/test/hominis-tiles`
  * (152.0b7 → 153.0b8 source-refresh drill: 1224 tests instead of ~200,
- * with no indication the scope widened). A trailing separator makes the
- * prefix match exact — `hominis/` cannot prefix `hominis-tiles/…`.
+ * with no indication the scope widened).
  *
  * FireForge therefore treats a directory argument as meaning EXACTLY
- * that directory: {@link analyzeTestPathScopes} returns a trailing-`/`
- * dispatch form for every existing directory, plus the sibling
- * directories the raw prefix would have swept in so the command layer
- * can tell the operator what was excluded. Note FireForge already
- * rejects non-existent paths up front, so raw prefix-widening was never
- * something an operator could invoke deliberately — it only ever
- * happened by accident.
+ * that directory: {@link analyzeTestPathScopes} enumerates the test
+ * files of exactly that directory and dispatches THAT explicit file
+ * list to mach — a file list cannot prefix-match anything. (0.35.0
+ * instead normalized the directory with a trailing `/`, assuming the
+ * separator makes the prefix match exact; field verification on Firefox
+ * 153 showed mach still swept in the prefix-named sibling, so the
+ * trailing-slash mechanism was cosmetic and its exclusion echo was
+ * wrong.) The prefix-matching sibling directories are still reported so
+ * the command layer can tell the operator what was excluded. Note
+ * FireForge already rejects non-existent paths up front, so raw
+ * prefix-widening was never something an operator could invoke
+ * deliberately — it only ever happened by accident.
  */
 import { readdir, stat } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 /** Test implementation files as mozbuild manifests name them. */
-const TEST_FILE_PATTERN = /^(?:browser|test)_.*\.m?js$/;
+const TEST_FILE_PATTERN = /^(?:browser|test)_.*\.(?:m?js|x?html)$/;
 /**
- * Recursively counts test-implementation files under a directory.
- * Returns 0 when the directory cannot be read — the count feeds an
- * informational notice, never a decision.
+ * Recursively enumerates test-implementation files under a directory,
+ * returned engine-relative and sorted for deterministic dispatch order.
+ * Returns [] when the directory cannot be read — the caller then falls
+ * back to the directory form and mach owns the failure.
  */
-async function countTestFiles(dir) {
-    let count = 0;
+async function collectTestFiles(dir, relPrefix) {
+    const files = [];
     let entries;
     try {
         entries = await readdir(dir, { withFileTypes: true });
     }
     catch {
-        return 0;
+        return [];
     }
     for (const entry of entries) {
         if (entry.isDirectory()) {
-            count += await countTestFiles(join(dir, entry.name));
+            files.push(...(await collectTestFiles(join(dir, entry.name), `${relPrefix}${entry.name}/`)));
         }
         else if (entry.isFile() && TEST_FILE_PATTERN.test(entry.name)) {
-            count += 1;
+            files.push(`${relPrefix}${entry.name}`);
         }
     }
-    return count;
+    return files.sort();
 }
 /** Probes whether `path` is a directory, without throwing. */
 async function isDirectorySafe(path) {
@@ -65,7 +70,7 @@ async function analyzeTestPathScope(engineDir, requestedPath) {
     if (!(await isDirectorySafe(absolute))) {
         return {
             requestedPath,
-            dispatchPath: requestedPath,
+            dispatchPaths: [requestedPath],
             isDirectory: false,
             testFileCount: 0,
             siblingPrefixMatches: [],
@@ -82,7 +87,7 @@ async function analyzeTestPathScope(engineDir, requestedPath) {
             if (entry.name === base || !entry.name.startsWith(base))
                 continue;
             const siblingRel = parentRel === '.' ? entry.name : `${parentRel}/${entry.name}`;
-            const testFileCount = await countTestFiles(join(dirname(absolute), entry.name));
+            const testFileCount = (await collectTestFiles(join(dirname(absolute), entry.name), `${siblingRel}/`)).length;
             // A prefix-matching sibling with no test files never surfaces in a
             // mach run, so listing it would only add noise.
             if (testFileCount > 0) {
@@ -92,13 +97,16 @@ async function analyzeTestPathScope(engineDir, requestedPath) {
     }
     catch {
         // Unreadable parent: skip the sibling probe; exactness via the
-        // trailing separator is preserved regardless.
+        // explicit file list is preserved regardless.
     }
+    const testFiles = await collectTestFiles(absolute, `${stripped}/`);
     return {
         requestedPath,
-        dispatchPath: `${stripped}/`,
+        // The explicit file list is what makes the selection exact; an empty
+        // enumeration falls back to the directory form.
+        dispatchPaths: testFiles.length > 0 ? testFiles : [`${stripped}/`],
         isDirectory: true,
-        testFileCount: await countTestFiles(absolute),
+        testFileCount: testFiles.length,
         siblingPrefixMatches,
     };
 }
@@ -122,12 +130,19 @@ export async function analyzeTestPathScopes(engineDir, requestedPaths) {
 export function formatScopeNotice(scope) {
     if (!scope.isDirectory || scope.siblingPrefixMatches.length === 0)
         return undefined;
+    const requestedDir = scope.requestedPath.replace(/\/+$/, '');
     const siblings = scope.siblingPrefixMatches
         .map((s) => `${s.path}/ (${s.testFileCount} test file${s.testFileCount === 1 ? '' : 's'})`)
         .join(', ');
-    return (`Selected exactly ${scope.dispatchPath} (${scope.testFileCount} test file${scope.testFileCount === 1 ? '' : 's'}). ` +
-        `Excluded ${scope.siblingPrefixMatches.length} sibling director${scope.siblingPrefixMatches.length === 1 ? 'y' : 'ies'} ` +
-        `that a raw prefix match would also have run: ${siblings}. ` +
+    if (scope.testFileCount === 0) {
+        // Fallback dispatch: with nothing to enumerate, the raw directory
+        // form goes to mach, whose prefix matching CAN sweep the siblings in.
+        // Claiming exclusion here would repeat the 0.35.0 mistake.
+        return (`${requestedDir}/ contains no enumerable test files, so the directory is passed to mach ` +
+            `as-is — mach resolves paths by string prefix, which may also select: ${siblings}.`);
+    }
+    return (`Selected exactly ${requestedDir}/ by passing its ${scope.testFileCount} test file${scope.testFileCount === 1 ? '' : 's'} ` +
+        'explicitly to mach (an explicit file list cannot prefix-match a sibling). ' +
+        `Excluded ${scope.siblingPrefixMatches.length} prefix-named sibling director${scope.siblingPrefixMatches.length === 1 ? 'y' : 'ies'}: ${siblings}. ` +
         'Pass them as separate paths to include them.');
 }
-//# sourceMappingURL=test-path-scope.js.map

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

@@ -112,4 +112,3 @@ export function formatStaleBuildWarning(result) {
         'packaged chrome / jar.mn resources, rerun with "fireforge test --build" (or ' +
         '"fireforge build --ui") first. Passing --build skips this check.');
 }
-//# sourceMappingURL=test-stale-check.js.map

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

@@ -37,4 +37,3 @@ export async function tryRepairStaleXpcshellTestSymlink(engineDir, objDir, outpu
     warn(`Removed stale xpcshell harness symlink under ${objDir}/_tests and retrying mach test once: ${relative(resolve(engineDir), resolvedDestination)}`);
     return true;
 }
-//# sourceMappingURL=test-stale-symlink.js.map

package/dist/src/core/test-xpcshell-retry.js

@@ -20,4 +20,3 @@ export async function retryAfterXpcshellSymlinkRepair(engineDir, objDir, result,
     }
     return result;
 }
-//# sourceMappingURL=test-xpcshell-retry.js.map

package/dist/src/core/token-coverage.js

@@ -95,4 +95,3 @@ export async function measureTokenCoverage(repoDir, cssFiles, projectRoot) {
         files: entries,
     };
 }
-//# sourceMappingURL=token-coverage.js.map