@hominis/fireforge 0.35.0 → 0.37.0

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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { warn } from '../utils/logger.js';
 import { ensureGit, git } from './git-base.js';
 /**
  * Parses NUL-delimited porcelain status output.
@@ -43,22 +45,51 @@ export async function getWorkingTreeStatus(repoDir) {
     await ensureGit();
     return parsePorcelainStatus(await git(['status', '--porcelain=v1', '-z'], repoDir));
 }
+/** Default per-directory cap for untracked-directory expansion. */
+const DEFAULT_MAX_UNTRACKED_FILES_PER_DIR = 5000;
+/**
+ * Resolves the per-directory expansion cap, honoring the same
+ * FIREFORGE_MAX_UNTRACKED_FILES override the status command documents.
+ */
+export function resolveMaxUntrackedFilesPerDir() {
+    const raw = process.env['FIREFORGE_MAX_UNTRACKED_FILES'];
+    if (raw === undefined || raw.length === 0)
+        return DEFAULT_MAX_UNTRACKED_FILES_PER_DIR;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        warn(`Ignoring FIREFORGE_MAX_UNTRACKED_FILES="${raw}" — expected a positive integer. Falling back to ${String(DEFAULT_MAX_UNTRACKED_FILES_PER_DIR)}.`);
+        return DEFAULT_MAX_UNTRACKED_FILES_PER_DIR;
+    }
+    return parsed;
+}
 /**
  * Expands collapsed untracked directory entries into individual file entries.
  * Git status may report "?? dir/" instead of listing each file underneath.
+ *
+ * Expansion is capped per directory (FIREFORGE_MAX_UNTRACKED_FILES, default
+ * 5000) with a warning on overflow. The cap used to exist only in the
+ * status command's private expander; this shared one — used by reset,
+ * discard, verify, lint, export-all — was unbounded, so e.g. `reset
+ * --dry-run` after an interrupted download (unborn HEAD, the entire ~300k
+ * file tree untracked) enumerated and printed every file.
+ *
  * @param repoDir - Repository directory
  * @param entries - Parsed status entries
  * @returns Status entries with untracked directories expanded to individual files
  */
 export async function expandUntrackedDirectoryEntries(repoDir, entries) {
     const expanded = [];
+    const maxPerDir = resolveMaxUntrackedFilesPerDir();
     for (const entry of entries) {
         if (!entry.isUntracked || !entry.file.endsWith('/')) {
             expanded.push(entry);
             continue;
         }
         const individualFiles = await getUntrackedFilesInDir(repoDir, entry.file);
-        for (const file of individualFiles) {
+        if (individualFiles.length > maxPerDir) {
+            warn(`Untracked directory ${entry.file} contains ${String(individualFiles.length)} files — only the first ${String(maxPerDir)} are listed. Add a .gitignore entry or clean the directory.`);
+        }
+        for (const file of individualFiles.slice(0, maxPerDir)) {
             expanded.push({
                 status: '??',
                 indexStatus: '?',
@@ -125,4 +156,3 @@ export async function getDirtyFiles(repoDir, files) {
     const untracked = untrackedOutput.split('\n').filter((line) => line.trim().length > 0);
     return [...new Set([...tracked, ...untracked])].sort();
 }
-//# sourceMappingURL=git-status.js.map

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

@@ -53,12 +53,21 @@ export declare function applyPatch(patchPath: string, repoDir: string, options?:
  * Applies a patch idempotently using reverse-forward pattern.
  * First tries to reverse the patch (in case it's already applied),
  * then applies it forward.
+ *
  * @param patchPath - Path to the patch file
  * @param repoDir - Repository directory
- * @param options - Application options
+ * @param options.reject - Fall back to `git apply --reject`
+ * @param options.protectedFiles - Files that must NOT be reset to HEAD by
+ *   the recovery step. Callers applying a patch QUEUE pass the files
+ *   already touched by previously applied patches in the same run: two
+ *   overlapping patches (an `--allow-overlap` queue) share files, and the
+ *   blanket `checkout HEAD` used to wipe the earlier patch's changes from
+ *   the shared file before applying the later one — leaving the engine in
+ *   a hybrid state the summary never described.
  */
 export declare function applyPatchIdempotent(patchPath: string, repoDir: string, options?: {
     reject?: boolean;
+    protectedFiles?: ReadonlySet<string>;
 }): Promise<void>;
 /**
  * Reverses a previously applied patch.

package/dist/src/core/git.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
+import { ExecTimeoutError } from '../errors/base.js';
 import { GitError, GitIndexingTimeoutError, GitIndexLockError, PatchApplyError, } from '../errors/git.js';
 import { elapsedSince } from '../utils/elapsed.js';
 import { toError } from '../utils/errors.js';
@@ -8,7 +9,7 @@ import { pathExists, pathExistsStrict, removeFile } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { exec } from '../utils/process.js';
 import { ensureFirefoxIgnorefileCompatibility } from './firefox-ignorefile.js';
-import { configureGitPerformance, ensureGit, git, GIT_ADD_CHUNK_TIMEOUT_ENV_VAR, GIT_ADD_CHUNK_TIMEOUT_MS, GIT_ADD_TIMEOUT_MS, } from './git-base.js';
+import { chunkPathspecs, configureGitPerformance, ensureGit, git, GIT_ADD_CHUNK_TIMEOUT_ENV_VAR, GIT_ADD_CHUNK_TIMEOUT_MS, GIT_ADD_TIMEOUT_MS, } from './git-base.js';
 import { getWorkingTreeStatus } from './git-status.js';
 // ── Functions that remain in this file ──
 /**
@@ -47,6 +48,11 @@ const GIT_ADD_ENV = { GIT_INDEX_THREADS: '0' };
  * detection here needs to recognise that shape too.
  */
 function isTimeoutError(error) {
+    // `exec` now rejects with a typed ExecTimeoutError when its `timeout`
+    // option fires (the raw AbortError check below is kept for defence in
+    // depth against other abort paths).
+    if (error instanceof ExecTimeoutError)
+        return true;
     if (error instanceof Error && error.name === 'AbortError')
         return true;
     if (!(error instanceof GitError))
@@ -410,9 +416,17 @@ export async function applyPatch(patchPath, repoDir, options = {}) {
  * Applies a patch idempotently using reverse-forward pattern.
  * First tries to reverse the patch (in case it's already applied),
  * then applies it forward.
+ *
  * @param patchPath - Path to the patch file
  * @param repoDir - Repository directory
- * @param options - Application options
+ * @param options.reject - Fall back to `git apply --reject`
+ * @param options.protectedFiles - Files that must NOT be reset to HEAD by
+ *   the recovery step. Callers applying a patch QUEUE pass the files
+ *   already touched by previously applied patches in the same run: two
+ *   overlapping patches (an `--allow-overlap` queue) share files, and the
+ *   blanket `checkout HEAD` used to wipe the earlier patch's changes from
+ *   the shared file before applying the later one — leaving the engine in
+ *   a hybrid state the summary never described.
  */
 export async function applyPatchIdempotent(patchPath, repoDir, options = {}) {
     await ensureGit();
@@ -428,15 +442,59 @@ export async function applyPatchIdempotent(patchPath, repoDir, options = {}) {
         const touchedFiles = listResult.stdout
             .split('\n')
             .map((line) => line.split('\t')[2])
-            .filter((f) => !!f);
+            .filter((f) => !!f)
+            .filter((f) => !(options.protectedFiles?.has(f) ?? false));
         if (touchedFiles.length > 0) {
-            // Restore only the files the patch touches
-            await exec('git', ['checkout', 'HEAD', '--', ...touchedFiles], { cwd: repoDir });
+            await restoreFilesToHead(repoDir, patchPath, touchedFiles);
         }
     }
     // Apply forward
     await applyPatch(patchPath, repoDir, options);
 }
+/**
+ * Restores `files` to their HEAD state, deleting files the patch would
+ * CREATE (present on disk from a partial apply but absent in HEAD — for
+ * those, `git checkout HEAD --` fails, and the historical code ignored
+ * that failure entirely, leaving stray files that made the subsequent
+ * forward apply die with "already exists" and no hint why).
+ *
+ * Every git invocation is chunked via {@link chunkPathspecs} so a very
+ * large patch cannot hit `E2BIG`, and every exit code is checked — a
+ * silent failed restore is precisely the confusing state this recovery
+ * step exists to prevent.
+ */
+async function restoreFilesToHead(repoDir, patchPath, files) {
+    // Partition into tracked-in-HEAD (restore via checkout) and absent-in-HEAD
+    // (patch-created leftovers: delete from the worktree).
+    const trackedInHead = new Set();
+    for (const chunk of chunkPathspecs(files)) {
+        const lsTree = await exec('git', ['ls-tree', '-r', '--name-only', 'HEAD', '--', ...chunk], {
+            cwd: repoDir,
+        });
+        if (lsTree.exitCode !== 0) {
+            throw new PatchApplyError(patchPath, new Error(`git ls-tree failed while preparing recovery: ${lsTree.stderr.trim()}`));
+        }
+        for (const line of lsTree.stdout.split('\n')) {
+            if (line.length > 0)
+                trackedInHead.add(line);
+        }
+    }
+    const toCheckout = files.filter((f) => trackedInHead.has(f));
+    const toDelete = files.filter((f) => !trackedInHead.has(f));
+    for (const chunk of chunkPathspecs(toCheckout)) {
+        const checkout = await exec('git', ['checkout', 'HEAD', '--', ...chunk], { cwd: repoDir });
+        if (checkout.exitCode !== 0) {
+            throw new PatchApplyError(patchPath, new Error(`Could not restore patch-touched files to HEAD before applying: ${checkout.stderr.trim()}`));
+        }
+    }
+    for (const file of toDelete) {
+        const target = join(repoDir, file);
+        if (await pathExists(target)) {
+            await removeFile(target);
+            verbose(`Removed stray patch-created file before apply: ${file}`);
+        }
+    }
+}
 /**
  * Reverses a previously applied patch.
  * @param patchPath - Path to the patch file
@@ -524,4 +582,3 @@ export async function getStatusWithCodes(repoDir) {
         file: entry.file,
     }));
 }
-//# sourceMappingURL=git.js.map

package/dist/src/core/license-headers.js

@@ -193,4 +193,3 @@ export async function addLicenseHeaderToFile(filePath, license, style) {
     await writeText(filePath, header + '\n' + content);
     return true;
 }
-//# sourceMappingURL=license-headers.js.map

package/dist/src/core/lint-cache.js

@@ -174,4 +174,3 @@ export function setCachedPerPatchLintIssues(cache, patchFilename, key, issues) {
         updatedAt: new Date().toISOString(),
     };
 }
-//# sourceMappingURL=lint-cache.js.map

package/dist/src/core/lint-projection.js

@@ -41,4 +41,3 @@ export function computeProjectedLintRegressions(baseline, projected) {
     }
     return regressions;
 }
-//# sourceMappingURL=lint-projection.js.map

package/dist/src/core/mach-build-artifacts.js

@@ -285,4 +285,3 @@ export async function attemptMozinfoRewrite(engineDir, objDir) {
         ...(newMozconfig ? { newMozconfig } : {}),
     };
 }
-//# sourceMappingURL=mach-build-artifacts.js.map

package/dist/src/core/mach-error-hints.js

@@ -120,4 +120,3 @@ export function explainMachError(stderr) {
     }
     return hits;
 }
-//# sourceMappingURL=mach-error-hints.js.map

package/dist/src/core/mach-known-noise-filter.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Terminal-echo filter for the KNOWN upstream mozsystemmonitor teardown
+ * traceback (0.37.0 item 8).
+ *
+ * Every headless test run against the 153-beta engine ends with an
+ * `AttributeError: 'SystemResourceMonitor' object has no attribute
+ * 'stop_time'` traceback at harness teardown — upstream noise that sits
+ * exactly where a reader looks for the failure summary. 0.36.0 already made
+ * real failure lines beat this traceback in CLASSIFICATION; this filter
+ * closes the PRESENTATION gap by collapsing the echoed traceback to one
+ * labeled line.
+ *
+ * Scope is deliberately narrow:
+ *   - Only the terminal ECHO is filtered. The captured stdout/stderr strings
+ *     stay raw — the classifier (`test-harness-crash.ts`) depends on the
+ *     raw traceback for its green-summary override and secondary-noise
+ *     detection.
+ *   - Only the exact documented incident is collapsed, and every condition
+ *     must hold: an `AttributeError` on `SystemResourceMonitor` naming one
+ *     of the two known attributes (`stop_time`, `poll_interval` — the
+ *     0.34.0 guard family), AND a `mozsystemmonitor/resourcemonitor.py`
+ *     stack frame, AND a previously-seen SUITE_END shutdown marker (shared
+ *     across the run's stdout/stderr filter instances — the marker usually
+ *     lands on stdout while the traceback lands on stderr). A novel
+ *     attribute, a novel exception type in resourcemonitor.py, or a
+ *     pre-shutdown occurrence is echoed verbatim, always.
+ *   - The hold buffer is bounded; on overflow the block is flushed verbatim
+ *     and the filter returns to pass-through, so output is never lost.
+ */
+/**
+ * Shared across the stdout and stderr filter instances of ONE mach run:
+ * SUITE_END typically arrives on stdout while the teardown traceback lands
+ * on stderr, so the shutdown-seen flag must be visible to both. The two
+ * pipes are independent, so a traceback can theoretically beat the marker
+ * through — the block then prints verbatim, the correct failure direction.
+ */
+export interface TeardownNoiseContext {
+    shutdownSeen: boolean;
+}
+/** Fresh per-run context — hand the same instance to both stream filters. */
+export declare function createTeardownNoiseContext(): TeardownNoiseContext;
+/** One line replaces the whole recognized traceback block in the echo. */
+export declare const KNOWN_TEARDOWN_NOISE_ANNOTATION: string;
+/** Chunk-safe, line-buffered echo filter. See module doc. */
+export interface KnownTeardownNoiseFilter {
+    /** Feed a raw chunk; returns the text to echo now (possibly empty). */
+    transform(chunk: string): string;
+    /** Flush any buffered residue verbatim (call after the stream closes). */
+    flush(): string;
+}
+/**
+ * Creates a stateful filter for one output stream. Complete lines outside a
+ * traceback pass straight through (only the trailing partial line is held
+ * back); a `Traceback (most recent call last)` header switches to hold mode
+ * until the block ends, then either the one-line annotation (recognized
+ * signature after a seen shutdown marker) or the verbatim block (anything
+ * else) is emitted. Pass the run's shared {@link TeardownNoiseContext} so
+ * both stream filters see the same shutdown flag.
+ */
+export declare function createKnownTeardownNoiseFilter(context?: TeardownNoiseContext): KnownTeardownNoiseFilter;

package/dist/src/core/mach-known-noise-filter.js

@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Terminal-echo filter for the KNOWN upstream mozsystemmonitor teardown
+ * traceback (0.37.0 item 8).
+ *
+ * Every headless test run against the 153-beta engine ends with an
+ * `AttributeError: 'SystemResourceMonitor' object has no attribute
+ * 'stop_time'` traceback at harness teardown — upstream noise that sits
+ * exactly where a reader looks for the failure summary. 0.36.0 already made
+ * real failure lines beat this traceback in CLASSIFICATION; this filter
+ * closes the PRESENTATION gap by collapsing the echoed traceback to one
+ * labeled line.
+ *
+ * Scope is deliberately narrow:
+ *   - Only the terminal ECHO is filtered. The captured stdout/stderr strings
+ *     stay raw — the classifier (`test-harness-crash.ts`) depends on the
+ *     raw traceback for its green-summary override and secondary-noise
+ *     detection.
+ *   - Only the exact documented incident is collapsed, and every condition
+ *     must hold: an `AttributeError` on `SystemResourceMonitor` naming one
+ *     of the two known attributes (`stop_time`, `poll_interval` — the
+ *     0.34.0 guard family), AND a `mozsystemmonitor/resourcemonitor.py`
+ *     stack frame, AND a previously-seen SUITE_END shutdown marker (shared
+ *     across the run's stdout/stderr filter instances — the marker usually
+ *     lands on stdout while the traceback lands on stderr). A novel
+ *     attribute, a novel exception type in resourcemonitor.py, or a
+ *     pre-shutdown occurrence is echoed verbatim, always.
+ *   - The hold buffer is bounded; on overflow the block is flushed verbatim
+ *     and the filter returns to pass-through, so output is never lost.
+ */
+const TRACEBACK_HEADER_PATTERN = /^Traceback \(most recent call last\)/;
+const CHAINED_EXCEPTION_CONNECTOR_PATTERN = /^(?:During handling of the above exception, another exception occurred:|The above exception was the direct cause of the following exception:)\s*$/;
+/**
+ * Closed allowlist of the documented teardown family's attributes:
+ * `stop_time` (the 0.37.0 item-8 incident) and `poll_interval` (the same
+ * mozsystemmonitor init failure the 0.34.0 resource-guard family covers —
+ * `test-harness-crash.ts` already classifies it as recognized noise). Any
+ * other missing attribute is a NEW upstream defect and must print verbatim.
+ */
+const KNOWN_TEARDOWN_ATTRIBUTE_ERROR_PATTERN = /AttributeError: 'SystemResourceMonitor' object has no attribute '(?:stop_time|poll_interval)'/;
+const RESOURCEMONITOR_FRAME_PATTERN = /mozsystemmonitor[/\\]resourcemonitor\.py/;
+/**
+ * Shutdown marker: the harness's SUITE_END line. Matches the shape
+ * `test-harness-crash.ts` keys its summary parsing on (module-private
+ * there; duplicated here with this cross-reference rather than exported).
+ */
+const SHUTDOWN_MARKER_PATTERN = /\bSUITE_END\b/;
+/** Whole-block recognition — every signal must hold (see module doc). */
+function isRecognizedTeardownNoise(block) {
+    return (KNOWN_TEARDOWN_ATTRIBUTE_ERROR_PATTERN.test(block) && RESOURCEMONITOR_FRAME_PATTERN.test(block));
+}
+/** Fresh per-run context — hand the same instance to both stream filters. */
+export function createTeardownNoiseContext() {
+    return { shutdownSeen: false };
+}
+/** One line replaces the whole recognized traceback block in the echo. */
+export const KNOWN_TEARDOWN_NOISE_ANNOTATION = '[FireForge] Known upstream mozsystemmonitor teardown noise (SystemResourceMonitor ' +
+    'AttributeError at harness shutdown) — not a test failure. See FireForge docs.\n';
+/** Bounds on the held traceback block before flushing verbatim. */
+const HOLD_LINE_LIMIT = 100;
+const HOLD_BYTE_LIMIT = 16 * 1024;
+/**
+ * Creates a stateful filter for one output stream. Complete lines outside a
+ * traceback pass straight through (only the trailing partial line is held
+ * back); a `Traceback (most recent call last)` header switches to hold mode
+ * until the block ends, then either the one-line annotation (recognized
+ * signature after a seen shutdown marker) or the verbatim block (anything
+ * else) is emitted. Pass the run's shared {@link TeardownNoiseContext} so
+ * both stream filters see the same shutdown flag.
+ */
+export function createKnownTeardownNoiseFilter(context = createTeardownNoiseContext()) {
+    /** Partial (no trailing newline yet) input line. */
+    let partial = '';
+    /** Held traceback lines (each WITH its newline) while in hold mode. */
+    let held = [];
+    let heldBytes = 0;
+    /**
+     * State machine:
+     *   'pass'    — outside any traceback; lines echo through.
+     *   'inside'  — between a Traceback header and its closing exception line.
+     *   'closed'  — saw the closing `SomeError: …` line; still holding in
+     *               case a chained-exception connector continues the block
+     *               (the real fixture chains two tracebacks — the whole
+     *               chain must be evaluated as ONE block or the second half
+     *               would print raw after the annotation).
+     */
+    let state = 'pass';
+    const resetHold = () => {
+        const block = held.join('');
+        held = [];
+        heldBytes = 0;
+        state = 'pass';
+        return block;
+    };
+    const releaseHeld = () => {
+        const block = resetHold();
+        if (block.length === 0)
+            return '';
+        return context.shutdownSeen && isRecognizedTeardownNoise(block)
+            ? KNOWN_TEARDOWN_NOISE_ANNOTATION
+            : block;
+    };
+    const hold = (line) => {
+        held.push(line);
+        heldBytes += line.length;
+        if (held.length > HOLD_LINE_LIMIT || heldBytes > HOLD_BYTE_LIMIT) {
+            // Pathological block: flush verbatim rather than risk withholding
+            // output; do not attempt recognition on oversized blocks.
+            return { out: resetHold(), overflowed: true };
+        }
+        return { out: '', overflowed: false };
+    };
+    const processLine = (line) => {
+        const content = line.replace(/\r?\n$/, '');
+        if (state === 'pass') {
+            if (TRACEBACK_HEADER_PATTERN.test(content)) {
+                state = 'inside';
+                return hold(line).out;
+            }
+            if (SHUTDOWN_MARKER_PATTERN.test(content))
+                context.shutdownSeen = true;
+            return line;
+        }
+        if (state === 'inside') {
+            const isContinuation = content.trim().length === 0 ||
+                /^[ \t]/.test(content) ||
+                TRACEBACK_HEADER_PATTERN.test(content);
+            const { out, overflowed } = hold(line);
+            // The first unindented line is the closing `SomeError: …` line; keep
+            // holding in case a chained connector extends the block.
+            if (!overflowed && !isContinuation) {
+                state = 'closed';
+            }
+            return out;
+        }
+        // state === 'closed': only a blank line, a chained-exception connector,
+        // or another Traceback header continues the block.
+        if (content.trim().length === 0 || CHAINED_EXCEPTION_CONNECTOR_PATTERN.test(content)) {
+            return hold(line).out;
+        }
+        if (TRACEBACK_HEADER_PATTERN.test(content)) {
+            const { out, overflowed } = hold(line);
+            if (!overflowed)
+                state = 'inside';
+            return out;
+        }
+        return releaseHeld() + processLineInPass(line);
+    };
+    // Re-dispatch a line through pass-mode handling after a block release —
+    // the line that ended the block may itself start a new traceback.
+    const processLineInPass = (line) => {
+        const content = line.replace(/\r?\n$/, '');
+        if (TRACEBACK_HEADER_PATTERN.test(content)) {
+            state = 'inside';
+            return hold(line).out;
+        }
+        if (SHUTDOWN_MARKER_PATTERN.test(content))
+            context.shutdownSeen = true;
+        return line;
+    };
+    return {
+        transform(chunk) {
+            let out = '';
+            let buffer = partial + chunk;
+            partial = '';
+            let newlineIndex = buffer.indexOf('\n');
+            while (newlineIndex !== -1) {
+                const line = buffer.slice(0, newlineIndex + 1);
+                buffer = buffer.slice(newlineIndex + 1);
+                out += processLine(line);
+                newlineIndex = buffer.indexOf('\n');
+            }
+            partial = buffer;
+            return out;
+        },
+        flush() {
+            let out = '';
+            if (state !== 'pass') {
+                // A stream that closes mid-block: fold the trailing partial line in
+                // and evaluate — the final exception line is often the last thing
+                // printed, without a trailing newline.
+                if (partial.length > 0) {
+                    held.push(partial);
+                    partial = '';
+                }
+                out += releaseHeld();
+            }
+            out += partial;
+            partial = '';
+            return out;
+        },
+    };
+}

package/dist/src/core/mach-mozconfig.js

@@ -113,4 +113,3 @@ export async function generateMozconfig(configsDir, engineDir, config) {
     // the single source of truth for both the render and the sanity-check.
     await assertBrandingMozconfigAgreement(engineDir, outputPath, config);
 }
-//# sourceMappingURL=mach-mozconfig.js.map

package/dist/src/core/mach-python.js

@@ -123,4 +123,3 @@ export async function getPython(engineDir) {
     }
     return pythonCache.python;
 }
-//# sourceMappingURL=mach-python.js.map

package/dist/src/core/mach-resource-shim.js

@@ -549,4 +549,3 @@ export async function installMachResourceGuard(engineDir) {
     const env = machResourceShimEnv(await ensureSitecustomizeFallback());
     return { env, sitePackagesDirs };
 }
-//# sourceMappingURL=mach-resource-shim.js.map

package/dist/src/core/mach.d.ts

@@ -17,6 +17,14 @@ export interface MachOptions {
     env?: Record<string, string>;
     /** Whether to inherit stdio (show output directly) */
     inherit?: boolean;
+    /**
+     * Collapse the KNOWN mozsystemmonitor teardown traceback to one labeled
+     * line in the terminal ECHO (capture-only option). The captured
+     * stdout/stderr stay raw — the harness classifier depends on the raw
+     * traceback. Unrecognized tracebacks always echo verbatim. Opted into by
+     * the test dispatchers only.
+     */
+    annotateKnownTeardownNoise?: boolean;
 }
 /**
  * Result of running a mach command while capturing streamed output.

package/dist/src/core/mach.js

@@ -7,6 +7,7 @@ import { exec, execInherit, execInheritCapture, execSmokeRun, execStream, } from
 import { createSiblingLockPath, withFileLock } from './file-lock.js';
 import { ensureFirefoxIgnorefileCompatibility } from './firefox-ignorefile.js';
 import { explainMachError } from './mach-error-hints.js';
+import { createKnownTeardownNoiseFilter, createTeardownNoiseContext, } from './mach-known-noise-filter.js';
 import { getPython } from './mach-python.js';
 import { installMachResourceGuard } from './mach-resource-shim.js';
 import { detectHarnessCrashSignature } from './test-harness-crash.js';
@@ -42,7 +43,12 @@ export async function runMach(args, engineDir, options = {}) {
         ...(options.env ? { env: options.env } : {}),
     };
     if (options.inherit) {
-        return execInherit(python, [machPath, ...args], execOptions);
+        // Group-reap every long-lived inherited mach dispatch (bootstrap, run,
+        // watch): a mach dying at startup must not strand multiprocessing
+        // workers. Short-lived metadata queries below stay on plain exec() —
+        // adding groups there would touch every non-mach exec consumer's path
+        // for no reaping benefit.
+        return execInherit(python, [machPath, ...args], { ...execOptions, processGroup: true });
     }
     const result = await exec(python, [machPath, ...args], execOptions);
     return result.exitCode;
@@ -67,24 +73,47 @@ export async function runMachCapture(args, engineDir, options = {}) {
     const machPath = join(engineDir, 'mach');
     let stdout = '';
     let stderr = '';
+    // Echo-path filters only: the captured strings above accumulate RAW so the
+    // classifier still sees the full teardown traceback. When the option is
+    // off, the filters are absent and echo is a straight write (unchanged).
+    // One shutdown context per run, shared by both stream filters: the
+    // SUITE_END marker usually arrives on stdout while the teardown traceback
+    // lands on stderr, so the shutdown-seen flag must span the pair.
+    const noiseContext = options.annotateKnownTeardownNoise === true ? createTeardownNoiseContext() : undefined;
+    const stdoutFilter = noiseContext && createKnownTeardownNoiseFilter(noiseContext);
+    const stderrFilter = noiseContext && createKnownTeardownNoiseFilter(noiseContext);
     const exitCode = await execStream(python, [machPath, ...args], {
         cwd: engineDir,
         ...(options.env ? { env: options.env } : {}),
+        // Every capture dispatch (test suites, protected builds, package,
+        // storybook) runs as a process-group leader and is group-reaped on
+        // exit/abort — see ExecOptions.processGroup (0.37.0 item 9a).
+        processGroup: true,
         onStdout: (data) => {
             stdout += data;
             if (stdout.length > CAPTURE_TAIL_LIMIT) {
                 stdout = stdout.slice(-CAPTURE_TAIL_LIMIT);
             }
-            process.stdout.write(data);
+            process.stdout.write(stdoutFilter ? stdoutFilter.transform(data) : data);
         },
         onStderr: (data) => {
             stderr += data;
             if (stderr.length > CAPTURE_TAIL_LIMIT) {
                 stderr = stderr.slice(-CAPTURE_TAIL_LIMIT);
             }
-            process.stderr.write(data);
+            process.stderr.write(stderrFilter ? stderrFilter.transform(data) : data);
         },
     });
+    if (stdoutFilter) {
+        const residue = stdoutFilter.flush();
+        if (residue.length > 0)
+            process.stdout.write(residue);
+    }
+    if (stderrFilter) {
+        const residue = stderrFilter.flush();
+        if (residue.length > 0)
+            process.stderr.write(residue);
+    }
     return { stdout, stderr, exitCode };
 }
 /**
@@ -99,6 +128,7 @@ export async function runMachInheritCapture(args, engineDir, options = {}) {
     return execInheritCapture(python, [machPath, ...args], {
         cwd: engineDir,
         ...(options.env ? { env: options.env } : {}),
+        processGroup: true,
     });
 }
 /**
@@ -363,6 +393,7 @@ export async function testWithOutput(engineDir, testPaths = [], args = [], env)
     const guard = await installMachResourceGuard(engineDir);
     return runMachCapture(['test', ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
+        annotateKnownTeardownNoise: true,
     });
 }
 /**
@@ -379,6 +410,7 @@ export async function xpcshellTestWithOutput(engineDir, testPaths = [], args = [
     const guard = await installMachResourceGuard(engineDir);
     return runMachCapture(['xpcshell-test', ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
+        annotateKnownTeardownNoise: true,
     });
 }
 /**
@@ -390,6 +422,6 @@ export async function mochitestWithOutput(engineDir, testPaths = [], args = [],
     const guard = await installMachResourceGuard(engineDir);
     return runMachCapture(['mochitest', ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
+        annotateKnownTeardownNoise: true,
     });
 }
-//# sourceMappingURL=mach.js.map

package/dist/src/core/manifest-helpers.js

@@ -118,4 +118,3 @@ export function findAlphabeticalMozBuildPosition(tokens, newKey) {
     }
     return { insertIndex: insertLineIndex, previousEntry };
 }
-//# sourceMappingURL=manifest-helpers.js.map

package/dist/src/core/manifest-register.js

@@ -64,4 +64,3 @@ export async function registerToolkitWidget(engineDir, tagName, fileName, dryRun
     }
     return { manifest, entry, previousEntry, skipped: false };
 }
-//# sourceMappingURL=manifest-register.js.map

package/dist/src/core/manifest-rules.js

@@ -250,4 +250,3 @@ export async function registerFile(root, filePath, dryRun = false, after, option
     }
     throw new InvalidArgumentError(buildUnknownPatternMessage(normalizedPath, config.binaryName), 'path');
 }
-//# sourceMappingURL=manifest-rules.js.map

package/dist/src/core/manifest-tokenizers.js

@@ -109,4 +109,3 @@ export function tokenizeMozBuildList(lines, listPattern) {
         return null;
     return { tokens, startLine, endLine };
 }
-//# sourceMappingURL=manifest-tokenizers.js.map