@hominis/fireforge 0.31.0 → 0.32.0

package/dist/src/commands/test-run.js

@@ -11,7 +11,7 @@
  * harness runs cost startup time but make results reproducible; the
  * combined invocation stays available via `--no-shard`.
  */
-import { testWithOutput } from '../core/mach.js';
+import { mochitestWithOutput, testWithOutput, xpcshellTestWithOutput, } from '../core/mach.js';
 import { buildHarnessCrashMessage, classifyHarnessRun, } from '../core/test-harness-crash.js';
 import { retryAfterXpcshellSymlinkRepair } from '../core/test-xpcshell-retry.js';
 import { BuildError } from '../errors/build.js';
@@ -19,6 +19,14 @@ import { info, note, warn } from '../utils/logger.js';
 import { maybeInjectAppdirArg } from './test-appdir.js';
 /** Default bounded retry budget for recognized harness crashes. */
 export const DEFAULT_HARNESS_RETRIES = 2;
+/** Resolves the capturing mach dispatcher for a suite. */
+function dispatchForSuite(suite) {
+    if (suite === 'xpcshell')
+        return xpcshellTestWithOutput;
+    if (suite === 'mochitest')
+        return mochitestWithOutput;
+    return testWithOutput;
+}
 /**
  * Runs one mach test invocation for `paths`, retrying recognized harness
  * crashes up to the configured budget. Every attempt goes through the
@@ -27,6 +35,7 @@ export const DEFAULT_HARNESS_RETRIES = 2;
 export async function runTestsWithRetries(ctx, paths) {
     const extraArgs = [...ctx.baseExtraArgs];
     const appdirInjectionAttempted = await maybeInjectAppdirArg(ctx.engineDir, paths, ctx.objDir, extraArgs);
+    const dispatch = dispatchForSuite(ctx.suite);
     const maxAttempts = Math.max(1, ctx.harnessRetries + 1);
     let attempts = 0;
     let result;
@@ -34,9 +43,9 @@ export async function runTestsWithRetries(ctx, paths) {
     for (;;) {
         attempts += 1;
         result = ctx.env
-            ? await testWithOutput(ctx.engineDir, paths, extraArgs, ctx.env)
-            : await testWithOutput(ctx.engineDir, paths, extraArgs);
-        result = await retryAfterXpcshellSymlinkRepair(ctx.engineDir, ctx.objDir, result, ctx.classification, paths, extraArgs, ctx.env);
+            ? await dispatch(ctx.engineDir, paths, extraArgs, ctx.env)
+            : await dispatch(ctx.engineDir, paths, extraArgs);
+        result = await retryAfterXpcshellSymlinkRepair(ctx.engineDir, ctx.objDir, result, ctx.classification, paths, extraArgs, ctx.env, dispatch);
         const combined = `${result.stdout}\n${result.stderr}`;
         verdict = classifyHarnessRun(result.exitCode, combined, paths);
         if (verdict.kind !== 'harness-crash' || attempts >= maxAttempts)

package/dist/src/commands/test.js

@@ -5,6 +5,7 @@ import { getProjectPaths, loadConfig } from '../core/config.js';
 import { buildArtifactMismatchMessage, buildUI, hasBuildArtifacts, hasRunnableBundle, 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 { buildHarnessCrashMessage, detectHarnessCrashSignature, } from '../core/test-harness-crash.js';
 import { createPostRebuildFailureContext } from '../core/test-harness-output.js';
 import { checkStaleBuildForTest, formatStaleBuildWarning } from '../core/test-stale-check.js';
 import { findNearestXpcshellManifest } from '../core/xpcshell-appdir.js';
@@ -42,6 +43,25 @@ async function classifyTestHarnesses(engineDir, normalizedPaths) {
     }
     return result;
 }
+/**
+ * Picks the mach dispatch target for a (non-mixed) run. A single-suite run
+ * auto-routes to the suite-specific command (`mach xpcshell-test` /
+ * `mach mochitest`), which degrades a broken host resource monitor to a
+ * warning instead of crashing generic `mach test` at startup (E1). Mixed runs
+ * are rejected before this point; a path-less "run all" or an explicit
+ * `--generic-mach-test` opt-out stays on the generic command.
+ */
+function resolveTestSuite(classification, forceGeneric) {
+    if (forceGeneric)
+        return 'generic';
+    if (classification.xpcshell.length > 0 && classification.nonXpcshell.length === 0) {
+        return 'xpcshell';
+    }
+    if (classification.nonXpcshell.length > 0 && classification.xpcshell.length === 0) {
+        return 'mochitest';
+    }
+    return 'generic';
+}
 function buildMixedHarnessMessage(classification) {
     return ('FireForge cannot run xpcshell and browser/mochitest paths in the same mach invocation.\n\n' +
         'Split this into separate `fireforge test` commands so each manifest selects its own harness:\n' +
@@ -80,16 +100,31 @@ async function resolveLaunchablePathForTests(engineDir, binaryName, objDir) {
     }
     return bundleCheck.expectedPath;
 }
-async function runPreTestBuild(projectRoot, paths, projectConfig) {
+async function runPreTestBuild(projectRoot, paths, projectConfig, harnessRetries) {
     await withBuildLock(projectRoot, async () => {
         await prepareBuildEnvironment(projectRoot, paths, projectConfig);
         const s = spinner('Running incremental build...');
-        const buildResult = await buildUI(paths.engine);
-        if (buildResult.exitCode !== 0) {
+        // The pre-test build runs through mach too, so the same resource-monitor
+        // startup crash that aborts `mach test` can abort `mach build faster`.
+        // Run the harness-crash classifier over the build output and retry within
+        // the same `--harness-retries` budget rather than hard-failing with a
+        // bare "Pre-test build failed" (field report E2).
+        const maxAttempts = Math.max(1, harnessRetries + 1);
+        for (let attempt = 1;; attempt += 1) {
+            const buildResult = await buildUI(paths.engine);
+            if (buildResult.exitCode === 0) {
+                s.stop('Build complete');
+                return;
+            }
+            const signature = detectHarnessCrashSignature(`${buildResult.stdout}\n${buildResult.stderr}`);
+            if (signature && attempt < maxAttempts) {
+                s.message(`Pre-test build hit a harness crash (${signature.reason}); ` +
+                    `retrying (attempt ${attempt + 1} of ${maxAttempts})...`);
+                continue;
+            }
             s.error('Pre-test build failed');
-            throw new BuildError('Pre-test build failed', 'mach build faster');
+            throw new BuildError(signature ? buildHarnessCrashMessage(signature, attempt) : 'Pre-test build failed', 'mach build faster');
         }
-        s.stop('Build complete');
     });
 }
 function logTestSelection(normalizedPaths) {
@@ -239,9 +274,10 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     // missing-bundle path instead of a cryptic `Browser process exited
     // during spawn (exit code 1, signal none). stderr tail: (empty)`.
     const launchablePath = await resolveLaunchablePathForTests(paths.engine, projectConfig.binaryName, buildCheck.objDir);
+    const harnessRetries = options.harnessRetries ?? DEFAULT_HARNESS_RETRIES;
     // Run incremental build if requested
     if (options.build) {
-        await runPreTestBuild(projectRoot, paths, projectConfig);
+        await runPreTestBuild(projectRoot, paths, projectConfig, harnessRetries);
         info('');
     }
     else {
@@ -299,6 +335,7 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
     if (classification.xpcshell.length > 0 && classification.nonXpcshell.length > 0) {
         throw new GeneralError(buildMixedHarnessMessage(classification));
     }
+    const suite = resolveTestSuite(classification, options.genericMachTest === true);
     const forwardedMachArgs = options.machArg && options.machArg.length > 0
         ? filterRedundantXpcshellFlavorArgs(options.machArg, classification)
         : [];
@@ -325,8 +362,9 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
         engineDir: paths.engine,
         objDir: buildCheck.objDir,
         classification,
+        suite,
         baseExtraArgs: extraArgs,
-        harnessRetries: options.harnessRetries ?? DEFAULT_HARNESS_RETRIES,
+        harnessRetries,
         ...(perfSampleEnv ? { env: perfSampleEnv } : {}),
     };
     const postRebuildContext = options.build
@@ -381,6 +419,7 @@ export function registerTest(program, { getProjectRoot, withErrorHandling }) {
         }
         return n;
     })
+        .option('--generic-mach-test', 'Force dispatch through generic `mach test` instead of the suite-specific `mach xpcshell-test` / `mach mochitest` a single-suite run auto-selects (the suite-specific commands skip the mozlog resource monitor that crashes `mach test` on some hosts).')
         .option('--no-shard', 'Run multiple test paths in one combined mach invocation instead of sequential per-file shards')
         .option('--perf-samples <path>', 'Publish a perf-sample artifact path to the harness via <BINARYNAME>_PERF_SAMPLE_JSON (resolved against the project root)')
         .option('--marionette-port <port>', 'Override the Marionette control port (default 2828) for the stale-browser probe, the --doctor preflight, and (unless --mach-arg includes --flavor=xpcshell) auto-forwarded mach args: --setpref=marionette.port=<n> (browser listener) and --marionette=127.0.0.1:<n> (mochitest client). Omits the client flag when --mach-arg already sets --marionette. Use when 2828 is busy or CI assigns another port.', (raw) => {

package/dist/src/core/config-validate.js

@@ -243,6 +243,28 @@ const PATCH_LINT_CHECKJS_COMPILER_OPTION_KEYS = [
     'noUnusedLocals',
     'noUnusedParameters',
 ];
+/**
+ * Validates the reviewed `paths` mapping: an object of pattern → string[]
+ * targets, each pattern carrying at most one `*`. Lets patch-owned modules
+ * be typed from their real sources without an ambient stub shim.
+ */
+function parseCheckJsPathsMapping(raw) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new ConfigError('Config field "patchLint.checkJsCompilerOptions.paths" must be a plain object');
+    }
+    const rec = raw;
+    const out = {};
+    for (const [pattern, targets] of Object.entries(rec)) {
+        if ((pattern.match(/\*/g) ?? []).length > 1) {
+            throw new ConfigError(`Config field "patchLint.checkJsCompilerOptions.paths" key "${pattern}" may contain at most one "*"`);
+        }
+        if (!Array.isArray(targets) || targets.some((t) => typeof t !== 'string')) {
+            throw new ConfigError(`Config field "patchLint.checkJsCompilerOptions.paths.${pattern}" must be an array of strings`);
+        }
+        out[pattern] = targets;
+    }
+    return out;
+}
 function parsePatchLintCheckJsCompilerOptions(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
         throw new ConfigError('Config field "patchLint.checkJsCompilerOptions" must be a plain object');
@@ -251,6 +273,10 @@ function parsePatchLintCheckJsCompilerOptions(raw) {
     const allowed = new Set(PATCH_LINT_CHECKJS_COMPILER_OPTION_KEYS);
     const out = {};
     for (const key of Object.keys(rec)) {
+        if (key === 'paths') {
+            out.paths = parseCheckJsPathsMapping(rec[key]);
+            continue;
+        }
         if (!allowed.has(key)) {
             throw new ConfigError(`Config field "patchLint.checkJsCompilerOptions" has unknown key "${key}"`);
         }

package/dist/src/core/furnace-jsconfig.js

@@ -51,12 +51,28 @@ async function computeDesiredChromePathEntries(config, customDir, jsconfigAbsPat
         for (const file of files.sort()) {
             if (!file.endsWith('.mjs'))
                 continue;
-            const sourcePath = normalizePathSlashes(relative(jsconfigDir, join(componentDir, file)));
+            // Emit a `./`-prefixed relative value. TypeScript treats a bare
+            // `paths` value (`moz-widget/moz-widget.mjs`) as non-relative and
+            // rejects it without `baseUrl` (TS5090); a `./`-prefixed value
+            // resolves against the jsconfig directory with no `baseUrl` (which
+            // TS6 deprecates, TS5101). `../`-prefixed paths are already relative
+            // and left untouched.
+            const rel = normalizePathSlashes(relative(jsconfigDir, join(componentDir, file)));
+            const sourcePath = rel.startsWith('.') ? rel : `./${rel}`;
             entries[`${CHROME_ELEMENTS_URL_PREFIX}${file}`] = [sourcePath];
         }
     }
     return entries;
 }
+/**
+ * Compares two `paths` values treating a leading `./` as insignificant, so
+ * the reconciler does not churn between `./x` and bare `x` forms (either
+ * direction). Used to decide whether a managed entry is stale.
+ */
+function samePathValue(a, b) {
+    const strip = (p) => (p.startsWith('./') ? p.slice(2) : p);
+    return strip(a) === strip(b);
+}
 /** True when `key`/`value` is a Furnace-managed chrome-elements mapping. */
 function isManagedEntry(key, value, jsconfigDir, customDir) {
     if (!key.startsWith(CHROME_ELEMENTS_URL_PREFIX))
@@ -119,7 +135,11 @@ export async function syncFurnaceJsconfigPaths(root, config, options) {
             result.pruned.push(key);
             continue;
         }
-        if (value[0] !== want[0]) {
+        // Treat `./x` and bare `x` as equal so a previously-synced bare value (or
+        // a hand-written `./` prefix) is not rewritten as "stale" on every run.
+        // The existing value is kept verbatim when equivalent — no churn either
+        // way; only a genuinely different target updates (to the `./` form).
+        if (!samePathValue(value[0] ?? '', want[0] ?? '')) {
             result.updated.push(key);
             nextPaths[key] = want;
         }

package/dist/src/core/git-base.d.ts

@@ -63,6 +63,21 @@ export declare function git(args: string[], cwd: string, options?: {
     timeout?: number;
     env?: Record<string, string>;
 }): Promise<string>;
+/**
+ * Splits a pathspec list into chunks whose joined byte length stays well under
+ * the OS `ARG_MAX` limit, so a single batched `git` invocation over hundreds of
+ * Mozilla-length paths cannot fail with `E2BIG`. The 96 KB budget is
+ * deliberately conservative — even the smallest historical `ARG_MAX` (256 KB)
+ * leaves room for the fixed git arguments plus the inherited environment.
+ *
+ * Chunk boundaries are output-neutral for every batched caller here: each
+ * caller merges the per-chunk results into a single Set/Map keyed by path, so
+ * how the paths are grouped across invocations never affects the result.
+ * @param paths - Pathspecs to chunk
+ * @param budgetBytes - Maximum joined byte length per chunk
+ * @returns Path chunks, each safe to pass as a single argv tail
+ */
+export declare function chunkPathspecs(paths: string[], budgetBytes?: number): string[][];
 /**
  * Configures git performance settings for large trees.
  * Enables index preloading, untracked cache, and the manyFiles feature

package/dist/src/core/git-base.js

@@ -72,6 +72,38 @@ export async function git(args, cwd, options) {
     }
     return result.stdout;
 }
+/**
+ * Splits a pathspec list into chunks whose joined byte length stays well under
+ * the OS `ARG_MAX` limit, so a single batched `git` invocation over hundreds of
+ * Mozilla-length paths cannot fail with `E2BIG`. The 96 KB budget is
+ * deliberately conservative — even the smallest historical `ARG_MAX` (256 KB)
+ * leaves room for the fixed git arguments plus the inherited environment.
+ *
+ * Chunk boundaries are output-neutral for every batched caller here: each
+ * caller merges the per-chunk results into a single Set/Map keyed by path, so
+ * how the paths are grouped across invocations never affects the result.
+ * @param paths - Pathspecs to chunk
+ * @param budgetBytes - Maximum joined byte length per chunk
+ * @returns Path chunks, each safe to pass as a single argv tail
+ */
+export function chunkPathspecs(paths, budgetBytes = 96_000) {
+    const chunks = [];
+    let current = [];
+    let used = 0;
+    for (const path of paths) {
+        const cost = Buffer.byteLength(path) + 1;
+        if (current.length > 0 && used + cost > budgetBytes) {
+            chunks.push(current);
+            current = [];
+            used = 0;
+        }
+        current.push(path);
+        used += cost;
+    }
+    if (current.length > 0)
+        chunks.push(current);
+    return chunks;
+}
 /**
  * Configures git performance settings for large trees.
  * Enables index preloading, untracked cache, and the manyFiles feature

package/dist/src/core/git-diff.d.ts

@@ -40,6 +40,14 @@ export declare function getAllDiff(repoDir: string): Promise<string>;
  * Builds a combined diff against HEAD for the provided files without touching
  * the real git index. Tracked files use `git diff HEAD`; untracked files use
  * synthesized new-file diffs.
+ *
+ * Performance: the work is batched into a handful of `git` invocations
+ * (one `ls-tree` to classify, one `diff` over all tracked files, one
+ * `hash-object` over all new text files) rather than the ~2 spawns per file the
+ * previous per-file loop issued — that fan-out dominated the cold-run cost on a
+ * Firefox-sized checkout (~700 serial spawns, ~99s). Binary, directory, and
+ * recursion paths stay per-file because they are rare and (for binary) mutate
+ * the index.
  * @param repoDir - Repository directory
  * @param files - File paths to diff (relative to repo root)
  * @returns Combined diff content