@hominis/fireforge 0.44.4 → 0.46.0

package/dist/src/core/git.js

@@ -225,15 +225,8 @@ export async function stageAllFiles(dir, options = {}) {
         // monolithic budget forward.
         phase = 'chunked';
         phaseStartedAt = Date.now();
-        try {
-            await stageAllFilesChunked(dir, scan, options);
-            reportProgress?.('Git phase complete: chunked source indexing finished.');
-        }
-        catch (error) {
-            if (error instanceof GitIndexingTimeoutError)
-                throw error;
-            throw error;
-        }
+        await stageAllFilesChunked(dir, scan, options);
+        reportProgress?.('Git phase complete: chunked source indexing finished.');
     }
     finally {
         if (heartbeatTimer)
@@ -285,10 +278,20 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
     reportProgress('Configuring origin remote for build compatibility...');
     await git(['remote', 'add', 'origin', 'https://github.com/mozilla-firefox/firefox'], dir);
     reportProgress('Git phase complete: source git repository metadata initialized.');
+    await stageAndCommitSource(dir, reportProgress, 'Indexing Firefox source with git add -A (this can take several minutes on large trees)...');
+}
+/**
+ * The tail shared by {@link initRepository} and {@link resumeRepository}:
+ * normalizes the Firefox ignore files, stages the whole tree, and creates
+ * the initial source commit. Index-lock failures on either git step are
+ * wrapped into the typed lock error so both entry points report them the
+ * same way.
+ */
+async function stageAndCommitSource(dir, reportProgress, stagingMessage) {
     reportProgress('Normalizing Firefox ignore files for Git-backed mach lint compatibility...');
     await ensureFirefoxIgnorefileCompatibility(dir);
     // Add all files
-    reportProgress('Indexing Firefox source with git add -A (this can take several minutes on large trees)...');
+    reportProgress(stagingMessage);
     await assertNoGitIndexLock(dir);
     try {
         await stageAllFiles(dir, { onProgress: reportProgress });
@@ -310,7 +313,6 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
  * cleans up stale locks, stages all files, and creates the initial commit.
  */
 export async function resumeRepository(dir, options = {}) {
-    await ensureGit();
     const reportProgress = options.onProgress ?? (() => { });
     if (!(await isGitRepository(dir))) {
         throw new GitError('Not a git repository', 'resume');
@@ -324,24 +326,7 @@ export async function resumeRepository(dir, options = {}) {
     await cleanupIndexLock(dir);
     // Ensure origin remote exists (may have been added before the interrupt)
     await ensureOriginRemote(dir);
-    reportProgress('Normalizing Firefox ignore files for Git-backed mach lint compatibility...');
-    await ensureFirefoxIgnorefileCompatibility(dir);
-    // Stage all files
-    reportProgress('Indexing Firefox source (resuming)...');
-    await assertNoGitIndexLock(dir);
-    try {
-        await stageAllFiles(dir, { onProgress: reportProgress });
-    }
-    catch (error) {
-        throw await maybeWrapIndexLockError(dir, error);
-    }
-    // Create initial commit
-    try {
-        await createInitialSourceCommit(dir, reportProgress);
-    }
-    catch (error) {
-        throw await maybeWrapIndexLockError(dir, error);
-    }
+    await stageAndCommitSource(dir, reportProgress, 'Indexing Firefox source (resuming)...');
 }
 async function assertNoGitIndexLock(dir) {
     const lockPath = join(dir, '.git', 'index.lock');
@@ -499,7 +484,6 @@ export async function reversePatch(patchPath, repoDir) {
  * @returns True if there are uncommitted changes
  */
 export async function hasChanges(repoDir) {
-    await ensureGit();
     const entries = await getWorkingTreeStatus(repoDir);
     return entries.length > 0;
 }
@@ -518,7 +502,6 @@ export function isMissingHeadError(error) {
  * @returns Commit hash
  */
 export async function getHead(repoDir) {
-    await ensureGit();
     const output = await git(['rev-parse', 'HEAD'], repoDir);
     return output.trim();
 }
@@ -528,7 +511,6 @@ export async function getHead(repoDir) {
  * @returns Branch name
  */
 export async function getCurrentBranch(repoDir) {
-    await ensureGit();
     const output = await git(['rev-parse', '--abbrev-ref', 'HEAD'], repoDir);
     return output.trim();
 }
@@ -537,7 +519,6 @@ export async function getCurrentBranch(repoDir) {
  * @param repoDir - Repository directory
  */
 export async function resetChanges(repoDir) {
-    await ensureGit();
     try {
         await git(['reset', '--hard', 'HEAD'], repoDir);
     }
@@ -546,16 +527,6 @@ export async function resetChanges(repoDir) {
     }
     await git(['clean', '-fd'], repoDir);
 }
-/**
- * Creates a commit with all current changes.
- * @param repoDir - Repository directory
- * @param message - Commit message
- */
-export async function commit(repoDir, message) {
-    await ensureGit();
-    await stageAllFiles(repoDir);
-    await git(['commit', '-m', message], repoDir);
-}
 /**
  * Gets the status of files with their status codes.
  * @param repoDir - Repository directory

package/dist/src/core/harness-orphans.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Preflight census of ORPHANED test-harness helper processes.
+ *
+ * Stopping a long mochitest run mid-flight does not necessarily take its
+ * helpers with it. A downstream incident left `xpcshell` (the harness
+ * httpd, pegged at 100% CPU), `pywebsocket`, `ssltunnel` and `moz-http2`
+ * alive for an hour. Every subsequent run crawled — a three-second suite
+ * took six minutes of wall clock and audio-start waits timed out — and
+ * nothing in FireForge's output connected the slowness to the survivors.
+ * The hour was spent mis-attributing it to the change under test.
+ *
+ * Visibility alone would have collapsed that hour, which is why the census
+ * runs by default and the kill does not. Two rules keep it honest:
+ *
+ *  - The census runs at PREFLIGHT, before this run spawns anything, so
+ *    every matching process is by construction a survivor of an earlier
+ *    run. No age heuristic is needed, and none is used.
+ *  - A match must be anchored to a Firefox OBJDIR. `xpcshell` and
+ *    `server.js` are far too generic on their own; the same rule
+ *    `mochitest-server-port.ts` applies to the httpd holder applies here,
+ *    for the same reason — FireForge has no business reporting, let alone
+ *    terminating, a process it cannot attribute to the harness.
+ *
+ * `--reap-orphans` opts into termination. Without it the census is
+ * report-only, exactly like the `Orphaned harness workers` doctor check
+ * (which covers a DIFFERENT shape: reparented Python multiprocessing
+ * workers, matched on PPID 1 and accumulated CPU time).
+ */
+/** One surviving harness helper process. */
+export interface OrphanedHarnessProcess {
+    pid: number;
+    ppid: number;
+    /** Raw `ps` ELAPSED column. */
+    elapsed: string;
+    /** Parsed elapsed seconds since the process started. */
+    elapsedSeconds: number;
+    command: string;
+}
+/**
+ * Scans `ps -axo pid=,ppid=,etime=,command=` output for surviving harness
+ * helpers. Pure — fixture-testable without spawning anything.
+ *
+ * @param psOutput - Raw `ps` output
+ * @param objDir - Absolute objdir of this project, when known; widens the
+ *   provenance test beyond the generic `obj-…` path segment
+ * @param selfPid - This process's pid, excluded so FireForge cannot report
+ *   itself
+ */
+export declare function findOrphanedHarnessProcesses(psOutput: string, objDir?: string, selfPid?: number): OrphanedHarnessProcess[];
+/**
+ * Renders the census. Names every process with its elapsed time, because
+ * "a leftover harness process exists" and "a leftover harness process has
+ * been burning a core for 58 minutes" are different findings.
+ */
+export declare function formatOrphanReport(orphans: readonly OrphanedHarnessProcess[]): string;
+/**
+ * Preflight census of surviving harness helpers, run before a test
+ * dispatch.
+ *
+ * Best-effort by construction: a host without a usable `ps` (Windows, a
+ * locked-down container) logs at verbose and runs exactly as before. It
+ * never refuses a run — unlike the server-port preflight, a survivor here
+ * degrades performance rather than making the run dispatch against the
+ * wrong server, so the correct response is to say so loudly, not to stop.
+ *
+ * @param objDir - Absolute objdir of this project, when known
+ * @param options - `reap` terminates each recognized survivor (SIGTERM,
+ *   then SIGKILL for anything that stays)
+ * @returns The census, empty when nothing was found or nothing could be probed
+ */
+export declare function reportOrphanedHarnessProcesses(objDir: string | undefined, options?: {
+    reap?: boolean;
+}): Promise<OrphanedHarnessProcess[]>;

package/dist/src/core/harness-orphans.js

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Preflight census of ORPHANED test-harness helper processes.
+ *
+ * Stopping a long mochitest run mid-flight does not necessarily take its
+ * helpers with it. A downstream incident left `xpcshell` (the harness
+ * httpd, pegged at 100% CPU), `pywebsocket`, `ssltunnel` and `moz-http2`
+ * alive for an hour. Every subsequent run crawled — a three-second suite
+ * took six minutes of wall clock and audio-start waits timed out — and
+ * nothing in FireForge's output connected the slowness to the survivors.
+ * The hour was spent mis-attributing it to the change under test.
+ *
+ * Visibility alone would have collapsed that hour, which is why the census
+ * runs by default and the kill does not. Two rules keep it honest:
+ *
+ *  - The census runs at PREFLIGHT, before this run spawns anything, so
+ *    every matching process is by construction a survivor of an earlier
+ *    run. No age heuristic is needed, and none is used.
+ *  - A match must be anchored to a Firefox OBJDIR. `xpcshell` and
+ *    `server.js` are far too generic on their own; the same rule
+ *    `mochitest-server-port.ts` applies to the httpd holder applies here,
+ *    for the same reason — FireForge has no business reporting, let alone
+ *    terminating, a process it cannot attribute to the harness.
+ *
+ * `--reap-orphans` opts into termination. Without it the census is
+ * report-only, exactly like the `Orphaned harness workers` doctor check
+ * (which covers a DIFFERENT shape: reparented Python multiprocessing
+ * workers, matched on PPID 1 and accumulated CPU time).
+ */
+import { toError } from '../utils/errors.js';
+import { info, verbose, warn } from '../utils/logger.js';
+import { exec } from '../utils/process.js';
+import { parsePsDuration } from '../utils/ps-duration.js';
+import { sleep } from '../utils/sleep.js';
+/**
+ * Harness helper executables/scripts. Every one of these is started by the
+ * mochitest/xpcshell harness and is expected to die with it; none of them
+ * is a thing a developer runs by hand.
+ */
+const HARNESS_HELPER_PATTERN = /\b(?:xpcshell|pywebsocket\w*|websocket_server\.py|ssltunnel|moz-http2|http2_server|httpd\.js|server\.js|runtests\.py|runxpcshelltests\.py)\b/;
+/** Objdir provenance: an explicit objdir path, a `obj-…` path segment, or `_tests/`. */
+function isObjdirAnchored(command, objDir) {
+    if (objDir !== undefined && objDir.length > 0 && command.includes(objDir))
+        return true;
+    if (/[/\\]obj-[^/\\\s]*[/\\]/.test(command))
+        return true;
+    return /[/\\]_tests[/\\]/.test(command);
+}
+/**
+ * Scans `ps -axo pid=,ppid=,etime=,command=` output for surviving harness
+ * helpers. Pure — fixture-testable without spawning anything.
+ *
+ * @param psOutput - Raw `ps` output
+ * @param objDir - Absolute objdir of this project, when known; widens the
+ *   provenance test beyond the generic `obj-…` path segment
+ * @param selfPid - This process's pid, excluded so FireForge cannot report
+ *   itself
+ */
+export function findOrphanedHarnessProcesses(psOutput, objDir, selfPid = process.pid) {
+    const found = [];
+    for (const line of psOutput.split('\n')) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/.exec(line);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const ppid = Number(match[2]);
+        const elapsed = match[3] ?? '';
+        const command = (match[4] ?? '').trim();
+        if (pid === selfPid || ppid === selfPid)
+            continue;
+        if (!HARNESS_HELPER_PATTERN.test(command))
+            continue;
+        if (!isObjdirAnchored(command, objDir))
+            continue;
+        const elapsedSeconds = parsePsDuration(elapsed);
+        found.push({
+            pid,
+            ppid,
+            elapsed,
+            elapsedSeconds: Number.isNaN(elapsedSeconds) ? 0 : elapsedSeconds,
+            command,
+        });
+    }
+    return found;
+}
+/** Grace period between SIGTERM and SIGKILL when reaping. */
+const REAP_GRACE_MS = 500;
+/** Longest command excerpt carried into the report line. */
+const COMMAND_EXCERPT_LIMIT = 160;
+/**
+ * Renders the census. Names every process with its elapsed time, because
+ * "a leftover harness process exists" and "a leftover harness process has
+ * been burning a core for 58 minutes" are different findings.
+ */
+export function formatOrphanReport(orphans) {
+    const rows = orphans
+        .map((p) => `  PID ${p.pid} (up ${p.elapsed}): ${p.command.slice(0, COMMAND_EXCERPT_LIMIT)}`)
+        .join('\n');
+    const pids = orphans.map((p) => String(p.pid)).join(' ');
+    return (`${orphans.length} harness helper process(es) from an EARLIER run are still alive ` +
+        `(this preflight runs before the current run spawns anything, so none of these belong to ` +
+        `it):\n${rows}\n` +
+        `Survivors like these slow every later run without appearing anywhere in its output — a ` +
+        `three-second suite taking minutes of wall clock is the usual symptom. Terminate them with ` +
+        `"kill ${pids}", or re-run with --reap-orphans to have FireForge do it.`);
+}
+/** Thin exec wrapper for the process listing (tests mock `exec` instead). */
+async function listSystemProcesses() {
+    const result = await exec('ps', ['-axo', 'pid=,ppid=,etime=,command='], { timeout: 10000 });
+    if (result.exitCode !== 0) {
+        throw new Error(`ps exited ${result.exitCode}`);
+    }
+    return result.stdout;
+}
+/**
+ * Preflight census of surviving harness helpers, run before a test
+ * dispatch.
+ *
+ * Best-effort by construction: a host without a usable `ps` (Windows, a
+ * locked-down container) logs at verbose and runs exactly as before. It
+ * never refuses a run — unlike the server-port preflight, a survivor here
+ * degrades performance rather than making the run dispatch against the
+ * wrong server, so the correct response is to say so loudly, not to stop.
+ *
+ * @param objDir - Absolute objdir of this project, when known
+ * @param options - `reap` terminates each recognized survivor (SIGTERM,
+ *   then SIGKILL for anything that stays)
+ * @returns The census, empty when nothing was found or nothing could be probed
+ */
+export async function reportOrphanedHarnessProcesses(objDir, options = {}) {
+    if (process.platform === 'win32')
+        return [];
+    let psOutput;
+    try {
+        psOutput = await listSystemProcesses();
+    }
+    catch (error) {
+        verbose(`Orphan preflight: could not scan processes (${toError(error).message}); skipping.`);
+        return [];
+    }
+    const orphans = findOrphanedHarnessProcesses(psOutput, objDir);
+    if (orphans.length === 0) {
+        verbose('Orphan preflight: no surviving harness helper processes.');
+        return [];
+    }
+    warn(formatOrphanReport(orphans));
+    if (options.reap === true) {
+        await reapOrphanedHarnessProcesses(orphans);
+    }
+    return orphans;
+}
+/**
+ * Terminates each census entry: SIGTERM first, then SIGKILL for anything
+ * still alive. Failures are reported, never thrown — a process that exited
+ * between the census and the signal is the common case, not an error.
+ */
+async function reapOrphanedHarnessProcesses(orphans) {
+    for (const orphan of orphans) {
+        try {
+            process.kill(orphan.pid, 'SIGTERM');
+        }
+        catch (error) {
+            verbose(`--reap-orphans: SIGTERM to ${orphan.pid} failed (${toError(error).message}).`);
+            continue;
+        }
+        // Grace period before escalating: the httpd shape in the field
+        // incident ignored SIGTERM while spinning, but an ordinary helper exits
+        // promptly and must not be SIGKILLed for being slow by a millisecond.
+        await sleep(REAP_GRACE_MS);
+        let alive = true;
+        try {
+            process.kill(orphan.pid, 0);
+        }
+        catch {
+            alive = false;
+        }
+        if (alive) {
+            try {
+                process.kill(orphan.pid, 'SIGKILL');
+            }
+            catch (error) {
+                verbose(`--reap-orphans: SIGKILL to ${orphan.pid} failed (${toError(error).message}).`);
+            }
+        }
+        info(`--reap-orphans: terminated PID ${orphan.pid}.`);
+    }
+}

package/dist/src/core/history-log.d.ts

@@ -0,0 +1,19 @@
+import type { HistoryEntry } from './destructive.js';
+/**
+ * Appends a history entry for a mutation that has ALREADY committed, degrading
+ * to a warning when the log cannot be written.
+ *
+ * Eleven call sites across `export-flow` and the `patch` subcommands had each
+ * grown the same `try { await appendHistory(...) } catch { warn(...) }` block.
+ * The swallow is deliberate and load-bearing: the patch files and the manifest
+ * are already on disk by the time this runs, so letting a failed log write
+ * reject would report a completed, irreversible mutation as a failure and send
+ * the operator looking for damage that is not there. Because that reasoning is
+ * easy to lose in a copy, it now lives in one place.
+ * @param patchesDir - The `patches/` directory holding the history log.
+ * @param entry - The entry to append.
+ * @param context - What just committed, rendered into
+ *   `History log append failed after <context>: <reason>` — e.g.
+ *   `patch tier committed (007-foo.patch)`.
+ */
+export declare function appendHistoryBestEffort(patchesDir: string, entry: HistoryEntry, context: string): Promise<void>;

package/dist/src/core/history-log.js

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { toError } from '../utils/errors.js';
+import { warn } from '../utils/logger.js';
+import { appendHistory } from './destructive.js';
+/**
+ * Appends a history entry for a mutation that has ALREADY committed, degrading
+ * to a warning when the log cannot be written.
+ *
+ * Eleven call sites across `export-flow` and the `patch` subcommands had each
+ * grown the same `try { await appendHistory(...) } catch { warn(...) }` block.
+ * The swallow is deliberate and load-bearing: the patch files and the manifest
+ * are already on disk by the time this runs, so letting a failed log write
+ * reject would report a completed, irreversible mutation as a failure and send
+ * the operator looking for damage that is not there. Because that reasoning is
+ * easy to lose in a copy, it now lives in one place.
+ * @param patchesDir - The `patches/` directory holding the history log.
+ * @param entry - The entry to append.
+ * @param context - What just committed, rendered into
+ *   `History log append failed after <context>: <reason>` — e.g.
+ *   `patch tier committed (007-foo.patch)`.
+ */
+export async function appendHistoryBestEffort(patchesDir, entry, context) {
+    try {
+        await appendHistory(patchesDir, entry);
+    }
+    catch (historyError) {
+        warn(`History log append failed after ${context}: ${toError(historyError).message}`);
+    }
+}

package/dist/src/core/mach-error-hints.d.ts

@@ -15,11 +15,6 @@ export interface MachErrorHint {
     /** Actionable, one-line hint to surface alongside the raw mach output. */
     hint: string;
 }
-/**
- * Registered hint patterns. Order-sensitive: the first match wins per
- * pattern, but multiple distinct patterns may fire for the same stderr.
- */
-export declare const MACH_ERROR_HINTS: MachErrorHint[];
 /**
  * Scans captured stderr for known mach errors and returns matching hints.
  * Pure function — safe to call on any string; never throws.

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

@@ -13,7 +13,7 @@
  * Registered hint patterns. Order-sensitive: the first match wins per
  * pattern, but multiple distinct patterns may fire for the same stderr.
  */
-export const MACH_ERROR_HINTS = [
+const MACH_ERROR_HINTS = [
     {
         pattern: /mozbuild\.preprocessor\.Preprocessor\.Error[\s\S]*?no preprocessor directives found/,
         hint: 'A file registered under JS_PREFERENCE_PP_FILES contains no preprocessor directives. ' +

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

@@ -25,12 +25,27 @@
  *     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.
+ *
+ * The COLLAPSE is test-only, deliberately, and not an oversight — the two
+ * reasons are worth stating because from outside it reads like one:
+ *   1. Recognition requires a previously-seen SUITE_END shutdown marker, and
+ *      `mach build` never prints one. Wiring the option into the build
+ *      dispatch would therefore be a silent no-op.
+ *   2. Relaxing that gate for builds would be wrong on its own terms. The
+ *      marker is what separates teardown noise from a traceback raised while
+ *      work was still happening; a build has no equivalent boundary, so
+ *      FireForge cannot tell the known-cosmetic case from a real build-time
+ *      failure and must not withhold the block.
+ * The build path instead RECOGNIZES the signature and says so beside the
+ * verbatim traceback — see {@link KNOWN_TEARDOWN_NOISE_BUILD_NOTE} and
+ * `runProtectedMachBuild`.
  */
 /**
- * True when CAPTURED output carries the documented mozsystemmonitor
- * teardown traceback.
+ * Whole-block recognition — every signal must hold (see module doc). True
+ * when CAPTURED output carries the documented mozsystemmonitor teardown
+ * traceback.
  *
- * The echo filter above only affects what a human sees. The CLASSIFIER
+ * The echo filter below only affects what a human sees. The CLASSIFIER
  * reads the raw capture, and it needs the same recognition to tell "the
  * suite finished clean and then upstream fell over at shutdown" from "the
  * suite did not finish". Deliberately the same two-signal test the echo
@@ -76,6 +91,13 @@ export interface TeardownNoiseContext {
 }
 /** Fresh per-run context — hand the same instance to both stream filters. */
 export declare function createTeardownNoiseContext(): TeardownNoiseContext;
+/**
+ * Build-phase note for the SAME recognized signature. The build path does
+ * not COLLAPSE the traceback (see the module doc's "test-only" note) — it
+ * prints verbatim and this line is added beside it, so one signature reads
+ * the same in both phases without a build losing output it may need.
+ */
+export declare const KNOWN_TEARDOWN_NOISE_BUILD_NOTE: string;
 /** 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. */

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

@@ -26,6 +26,20 @@
  *     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.
+ *
+ * The COLLAPSE is test-only, deliberately, and not an oversight — the two
+ * reasons are worth stating because from outside it reads like one:
+ *   1. Recognition requires a previously-seen SUITE_END shutdown marker, and
+ *      `mach build` never prints one. Wiring the option into the build
+ *      dispatch would therefore be a silent no-op.
+ *   2. Relaxing that gate for builds would be wrong on its own terms. The
+ *      marker is what separates teardown noise from a traceback raised while
+ *      work was still happening; a build has no equivalent boundary, so
+ *      FireForge cannot tell the known-cosmetic case from a real build-time
+ *      failure and must not withhold the block.
+ * The build path instead RECOGNIZES the signature and says so beside the
+ * verbatim traceback — see {@link KNOWN_TEARDOWN_NOISE_BUILD_NOTE} and
+ * `runProtectedMachBuild`.
  */
 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*$/;
@@ -43,15 +57,12 @@ const RESOURCEMONITOR_FRAME_PATTERN = /mozsystemmonitor[/\\]resourcemonitor\.py/
  * 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));
-}
 /**
- * True when CAPTURED output carries the documented mozsystemmonitor
- * teardown traceback.
+ * Whole-block recognition — every signal must hold (see module doc). True
+ * when CAPTURED output carries the documented mozsystemmonitor teardown
+ * traceback.
  *
- * The echo filter above only affects what a human sees. The CLASSIFIER
+ * The echo filter below only affects what a human sees. The CLASSIFIER
  * reads the raw capture, and it needs the same recognition to tell "the
  * suite finished clean and then upstream fell over at shutdown" from "the
  * suite did not finish". Deliberately the same two-signal test the echo
@@ -68,7 +79,8 @@ function isRecognizedTeardownNoise(block) {
  * @returns True when the recognized teardown traceback is present
  */
 export function hasKnownTeardownNoise(output) {
-    return isRecognizedTeardownNoise(output);
+    return (KNOWN_TEARDOWN_ATTRIBUTE_ERROR_PATTERN.test(output) &&
+        RESOURCEMONITOR_FRAME_PATTERN.test(output));
 }
 /**
  * True when a SINGLE line is the documented teardown family's
@@ -93,9 +105,18 @@ export function isKnownTeardownNoiseLine(line) {
 export function createTeardownNoiseContext() {
     return { shutdownSeen: false };
 }
+/**
+ * Build-phase note for the SAME recognized signature. The build path does
+ * not COLLAPSE the traceback (see the module doc's "test-only" note) — it
+ * prints verbatim and this line is added beside it, so one signature reads
+ * the same in both phases without a build losing output it may need.
+ */
+export const KNOWN_TEARDOWN_NOISE_BUILD_NOTE = '[FireForge] The mozsystemmonitor traceback above is the known upstream ' +
+    'SystemResourceMonitor AttributeError — cosmetic, and not a build failure. It is left ' +
+    'verbatim here (unlike a test run, which collapses it); see docs/testing.md.';
 /** 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';
+    'AttributeError at harness shutdown) — not a test failure. See docs/testing.md.\n';
 /** Bounds on the held traceback block before flushing verbatim. */
 const HOLD_LINE_LIMIT = 100;
 const HOLD_BYTE_LIMIT = 16 * 1024;
@@ -136,7 +157,7 @@ export function createKnownTeardownNoiseFilter(context = createTeardownNoiseCont
         const block = resetHold();
         if (block.length === 0)
             return '';
-        return context.shutdownSeen && isRecognizedTeardownNoise(block)
+        return context.shutdownSeen && hasKnownTeardownNoise(block)
             ? KNOWN_TEARDOWN_NOISE_ANNOTATION
             : block;
     };

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

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { MozconfigError } from '../errors/build.js';
 import { pathExists, readText, writeTextIfChanged } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
+import { normalizePathSlashes } from '../utils/paths.js';
 import { getPlatform } from '../utils/platform.js';
 import { BrandingMozconfigMismatchError, splitAppId } from './branding.js';
 /**
@@ -96,7 +97,7 @@ export async function assertBrandingMozconfigAgreement(engineDir, mozconfigPath,
     // Normalise both sides to forward slashes before compare — Windows-edited
     // configs can carry backslash path separators that the build would treat
     // as literal characters in a repo-relative path.
-    const normalizedFound = found.replace(/\\/g, '/');
+    const normalizedFound = normalizePathSlashes(found);
     if (normalizedFound !== expected) {
         throw new BrandingMozconfigMismatchError(expected, found, 'name-mismatch');
     }

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

@@ -1,5 +1,7 @@
 /**
  * Resets the resolved Python executable. Primarily useful for testing.
+ *
+ * @internal Exported only so tests can reach it; not part of the public surface.
  */
 export declare function resetResolvedPython(): void;
 /**

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

@@ -6,7 +6,12 @@ import { pathExists, readText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { exec, executableExists } from '../utils/process.js';
 /** Cached Python resolution state */
-const pythonCache = {};
+/**
+ * The resolved interpreter and the requirement range it was resolved for.
+ * `undefined` means "not resolved yet"; the two always move together, so one
+ * nullable record beats two independently-deletable fields.
+ */
+let pythonCache;
 const DEFAULT_MACH_PYTHON_REQUIREMENTS = {
     min: { major: 3, minor: 8 },
     max: { major: 3, minor: 12 },
@@ -73,10 +78,11 @@ function buildPythonCandidates(requirements) {
 }
 /**
  * Resets the resolved Python executable. Primarily useful for testing.
+ *
+ * @internal Exported only so tests can reach it; not part of the public surface.
  */
 export function resetResolvedPython() {
-    delete pythonCache.python;
-    delete pythonCache.requirementsKey;
+    pythonCache = undefined;
 }
 /**
  * Dynamically resolves the python executable and ensures it is available.
@@ -86,7 +92,7 @@ export function resetResolvedPython() {
 export async function ensurePython(engineDir) {
     const requirements = await readMachPythonRequirements(engineDir);
     const requirementsKey = formatRequirementsKey(requirements);
-    if (pythonCache.python && pythonCache.requirementsKey === requirementsKey) {
+    if (pythonCache?.requirementsKey === requirementsKey) {
         return;
     }
     const candidates = buildPythonCandidates(requirements);
@@ -99,8 +105,7 @@ export async function ensurePython(engineDir) {
                 ]);
                 const version = parsePythonVersion(stdout);
                 if (version && isVersionWithinRequirements(version, requirements)) {
-                    pythonCache.python = candidate;
-                    pythonCache.requirementsKey = requirementsKey;
+                    pythonCache = { python: candidate, requirementsKey };
                     return;
                 }
             }
@@ -118,7 +123,7 @@ export async function ensurePython(engineDir) {
  */
 export async function getPython(engineDir) {
     await ensurePython(engineDir);
-    if (!pythonCache.python) {
+    if (pythonCache === undefined) {
         throw new PythonNotFoundError();
     }
     return pythonCache.python;