@hominis/fireforge 0.28.5 → 0.29.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.29.0
+
+- Improved `fireforge test --build` failure reporting so post-rebuild focused test failures name the rebuild command, requested paths, and first failure line separately from stale-artifact rebuild advice.
+
 ## 0.28.0
 
 - Restored mach lint compatibility for FireForge-managed Git-backed Firefox checkouts by materializing a `.hgignore` copy of `.gitignore` when Firefox's ignorefile linter config is present.

package/dist/src/commands/test.js

@@ -5,9 +5,9 @@ import { getProjectPaths, loadConfig } from '../core/config.js';
 import { buildArtifactMismatchMessage, buildUI, hasBuildArtifacts, hasRunnableBundle, testWithOutput, withBuildLock, } from '../core/mach.js';
 import { assertMarionettePortAvailable, extractForwardedMarionettePort, forwardedMachArgsIncludeMarionetteClient, shouldAutoForwardMarionettePortToMach, } from '../core/marionette-port.js';
 import { formatMarionettePreflightLine, reportMarionettePreflight, runMarionettePreflight, } from '../core/marionette-preflight.js';
-import { buildHarnessEarlyExitMessage, classifyHarnessEarlyExit, } from '../core/test-harness-output.js';
+import { buildHarnessEarlyExitMessage, classifyHarnessEarlyExit, completePostRebuildFailureContext, createPostRebuildFailureContext, prependPostRebuildFailureContext, } from '../core/test-harness-output.js';
 import { checkStaleBuildForTest, formatStaleBuildWarning } from '../core/test-stale-check.js';
-import { tryRepairStaleXpcshellTestSymlink } from '../core/test-stale-symlink.js';
+import { retryAfterXpcshellSymlinkRepair } from '../core/test-xpcshell-retry.js';
 import { findNearestXpcshellManifest } from '../core/xpcshell-appdir.js';
 import { GeneralError } from '../errors/base.js';
 import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
@@ -34,7 +34,12 @@ function buildUnknownTestMessage(testPaths) {
         'The file may exist, but Firefox does not currently resolve it as a runnable test.\n\n' +
         'Check the nearest test manifest (for example browser.toml or xpcshell.toml), confirm the file is listed under the correct test type, and make sure each parent moz.build registers that manifest before retrying.');
 }
-function buildStaleBuildMessage() {
+function buildStaleBuildMessage(postRebuild) {
+    if (postRebuild) {
+        return ('Firefox test runtime still reported stale-artifact-shaped resource failures after the rebuild completed.\n\n' +
+            'FireForge already ran the requested rebuild before this focused test, so treat the remaining failure as a real runtime, registration, routing, or test-contract regression rather than another stale deployed-artifact-only blocker.\n\n' +
+            'Check the first post-rebuild failure above and the raw mach output for the concrete path or module that still fails.');
+    }
     return ('Firefox test runtime appears to be using stale build artifacts.\n\n' +
         'The failing output referenced missing branding or distribution resources, which usually means the current obj-* build does not match recent engine or branding changes.\n\n' +
         'Re-run "fireforge build --ui" or "fireforge test --build" and then retry.');
@@ -171,6 +176,15 @@ async function runPreTestBuild(projectRoot, paths, projectConfig) {
         s.stop('Build complete');
     });
 }
+function logTestSelection(normalizedPaths) {
+    if (normalizedPaths.length > 0) {
+        info(`Running tests: ${normalizedPaths.join(', ')}`);
+    }
+    else {
+        info('Running all tests...');
+    }
+    info('');
+}
 // Detects the `AttributeError: 'MochitestDesktop' object has no attribute
 // 'http3Server'` teardown crash. The attribute is lazy-initialized inside
 // harness code paths that presume chrome://branding resolves correctly; a
@@ -188,16 +202,23 @@ function buildMochitestHttp3ServerMessage() {
         "  - The `BROWSER_CHROME_MANIFESTS` entry for your fork's chrome.manifest is registered.\n\n" +
         'This is an upstream Firefox harness interaction; FireForge can only diagnose it.');
 }
-function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted, binaryName) {
+function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted, binaryName, postRebuildContext) {
     if (result.exitCode === 0 || result.exitCode === 130)
         return;
     const combinedOutput = `${result.stdout}\n${result.stderr}`;
+    const failureContext = postRebuildContext
+        ? completePostRebuildFailureContext(postRebuildContext, combinedOutput)
+        : undefined;
+    const withContext = (message) => prependPostRebuildFailureContext(message, failureContext);
+    const throwGeneral = (message) => {
+        throw new GeneralError(withContext(message));
+    };
     if (/UNKNOWN TEST\b/i.test(combinedOutput)) {
-        throw new GeneralError(buildUnknownTestMessage(normalizedPaths));
+        throwGeneral(buildUnknownTestMessage(normalizedPaths));
     }
     const earlyExit = classifyHarnessEarlyExit(combinedOutput, normalizedPaths);
     if (earlyExit) {
-        throw new GeneralError(buildHarnessEarlyExitMessage(earlyExit, normalizedPaths));
+        throwGeneral(buildHarnessEarlyExitMessage(earlyExit, normalizedPaths));
     }
     // Fork-owned module load failures must beat the branding stale-build
     // branch: 2026-04-21 eval (Finding #14) saw a fork's test fail with
@@ -206,7 +227,7 @@ function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted
     // stale-build pattern matched, so the operator was told to rebuild
     // when the real fix is to register the missing module.
     if (hasForkModuleSignal(combinedOutput, binaryName)) {
-        throw new GeneralError(buildForkModuleMessage(binaryName));
+        throwGeneral(buildForkModuleMessage(binaryName));
     }
     // Branding-specific stale-build signals keep priority over the broader
     // xpcshell-appdir hint: when `chrome://branding/locale/brand.properties`
@@ -219,24 +240,24 @@ function handleNonZeroTestExit(result, normalizedPaths, appdirInjectionAttempted
     // which is the more useful diagnosis in practice for `Failed to load
     // resource:///modules/…`.
     if (hasStaleBuildArtifactsSignal(combinedOutput)) {
-        throw new GeneralError(buildStaleBuildMessage());
+        throwGeneral(buildStaleBuildMessage(Boolean(failureContext)));
     }
     if (hasXpcshellAppdirSignal(combinedOutput)) {
-        throw new GeneralError(buildXpcshellAppdirMessage(appdirInjectionAttempted));
+        throwGeneral(buildXpcshellAppdirMessage(appdirInjectionAttempted));
     }
     if (hasMochitestHttp3ServerSignal(combinedOutput)) {
-        throw new GeneralError(buildMochitestHttp3ServerMessage());
+        throwGeneral(buildMochitestHttp3ServerMessage());
     }
     if (/FileExistsError/i.test(combinedOutput) &&
         /(mochitest|xpcshell|_tests)/i.test(combinedOutput)) {
-        throw new GeneralError(buildHarnessSymlinkMessage());
+        throwGeneral(buildHarnessSymlinkMessage());
     }
     if (/invalid filename/i.test(combinedOutput) ||
         /chrome:\/\/mochitests.*not found/i.test(combinedOutput)) {
         info('Hint: The test file may not be registered in browser.toml or jar.mn.');
         info('Run "fireforge register <test-path>" to register it.');
     }
-    throw new BuildError(`Tests failed with exit code ${result.exitCode}. Check the output above for details.`, 'mach test');
+    throw new BuildError(withContext(`Tests failed with exit code ${result.exitCode}. Check the output above for details.`), 'mach test');
 }
 /**
  * Runs the test command to execute mach tests.
@@ -362,10 +383,6 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
             throw new GeneralError('Marionette preflight reported FAIL — see output above. Aborting before mach test runs.');
         }
     }
-    // Normalize test paths (strip engine/ prefix if present). Uses the
-    // shared `stripEnginePrefix` helper so `test`, `register`, `lint`, and
-    // `export` all accept the same prefix forms. Also trim to match the
-    // previous case-insensitive + leading-whitespace-tolerant contract.
     const normalizedPaths = testPaths.map((p) => stripEnginePrefix(p).trim());
     await assertTestPathsExist(paths.engine, normalizedPaths);
     const classification = await classifyTestHarnesses(paths.engine, normalizedPaths);
@@ -375,7 +392,6 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     const forwardedMachArgs = options.machArg && options.machArg.length > 0
         ? filterRedundantXpcshellFlavorArgs(options.machArg, classification)
         : [];
-    // Build extra args
     const extraArgs = [];
     if (options.headless) {
         extraArgs.push('--headless');
@@ -430,14 +446,7 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     // overrides via `--mach-arg=--app-path=…` always win — we skip injection
     // when the operator already passed one.
     const appdirInjection = await maybeInjectAppdirArg(paths.engine, normalizedPaths, buildCheck.objDir, extraArgs);
-    // Log what we're doing
-    if (normalizedPaths.length > 0) {
-        info(`Running tests: ${normalizedPaths.join(', ')}`);
-    }
-    else {
-        info('Running all tests...');
-    }
-    info('');
+    logTestSelection(normalizedPaths);
     let result;
     try {
         result = await testWithOutput(paths.engine, normalizedPaths, extraArgs);
@@ -445,15 +454,10 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     catch (error) {
         throw new BuildError('Test process failed to start', 'mach test', error instanceof Error ? error : undefined);
     }
-    if (result.exitCode !== 0 &&
-        classification.xpcshell.length > 0 &&
-        classification.nonXpcshell.length === 0) {
-        const repaired = await tryRepairStaleXpcshellTestSymlink(paths.engine, buildCheck.objDir, `${result.stdout}\n${result.stderr}`);
-        if (repaired) {
-            result = await testWithOutput(paths.engine, normalizedPaths, extraArgs);
-        }
-    }
-    handleNonZeroTestExit(result, normalizedPaths, appdirInjection, projectConfig.binaryName);
+    result = await retryAfterXpcshellSymlinkRepair(paths.engine, buildCheck.objDir, result, classification, normalizedPaths, extraArgs);
+    handleNonZeroTestExit(result, normalizedPaths, appdirInjection, projectConfig.binaryName, options.build
+        ? createPostRebuildFailureContext('fireforge test --build', normalizedPaths)
+        : undefined);
 }
 /** Registers the test command on the CLI program. */
 export function registerTest(program, { getProjectRoot, withErrorHandling }) {

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

@@ -3,6 +3,19 @@ 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. */
+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. */

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

@@ -8,6 +8,45 @@ function getNonEmptyOutputLines(output) {
 function findFirstMatchingLine(lines, patterns) {
     return lines.find((line) => patterns.some((pattern) => pattern.test(line)));
 }
+/** Finds the first high-signal failure line from captured mach test output. */
+export function findFirstUsefulFailureLine(output) {
+    const lines = getNonEmptyOutputLines(output);
+    const matched = findFirstMatchingLine(lines, [
+        /\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+/,
+    ]);
+    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);

package/dist/src/core/test-xpcshell-retry.d.ts

@@ -0,0 +1,7 @@
+import { type MachCommandResult } from './mach.js';
+export interface XpcshellRetryClassification {
+    xpcshell: readonly string[];
+    nonXpcshell: readonly string[];
+}
+/** Removes a stale xpcshell install symlink and retries the focused mach test once. */
+export declare function retryAfterXpcshellSymlinkRepair(engineDir: string, objDir: string | undefined, result: MachCommandResult, classification: XpcshellRetryClassification, normalizedPaths: string[], extraArgs: string[]): Promise<MachCommandResult>;

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

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { testWithOutput } from './mach.js';
+import { tryRepairStaleXpcshellTestSymlink } from './test-stale-symlink.js';
+/** Removes a stale xpcshell install symlink and retries the focused mach test once. */
+export async function retryAfterXpcshellSymlinkRepair(engineDir, objDir, result, classification, normalizedPaths, extraArgs) {
+    if (result.exitCode !== 0 &&
+        classification.xpcshell.length > 0 &&
+        classification.nonXpcshell.length === 0) {
+        const repaired = await tryRepairStaleXpcshellTestSymlink(engineDir, objDir, `${result.stdout}\n${result.stderr}`);
+        if (repaired) {
+            return testWithOutput(engineDir, normalizedPaths, extraArgs);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=test-xpcshell-retry.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.28.5",
+  "version": "0.29.0",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",