@hominis/fireforge 0.44.3 → 0.45.0

package/dist/src/core/furnace-constants.d.ts

@@ -12,12 +12,33 @@ export declare const JAR_MN = "toolkit/content/jar.mn";
 export declare const WIDGETS_DIR = "toolkit/content/widgets";
 /** Default Fluent localization directory for toolkit global components, relative to engine root */
 export declare const FTL_DIR = "toolkit/locales/en-US/toolkit/global";
+/**
+ * Engine-relative root every browser-chrome / xpcshell test scaffold lives
+ * under, trailing slash included. A `--test-dir` override must stay below
+ * it so the `browser/base/moz.build` manifest registration keeps working.
+ */
+export declare const BROWSER_TEST_SCAFFOLD_ROOT = "browser/base/content/test/";
 /**
  * Returns the engine-relative directory that holds xpcshell scaffolds for
  * a given binary. Matches the form `create-xpcshell.ts` writes and the
  * path `remove.ts` / `rename.ts` / `validate.ts` must clean up.
  */
 export declare function xpcshellTestParentDir(binaryName: string): string;
+/**
+ * Resolves the engine-relative directory a browser-chrome scaffold is
+ * written to: the `--test-dir` override when given, else
+ * `browser/base/content/test/<binaryName>`. The scaffolder AND the
+ * dry-run / success formatters resolve through this one function, so the
+ * printed plan cannot disagree with the files that land on disk.
+ */
+export declare function resolveBrowserChromeTestDir(binaryName: string, override?: string): string;
+/**
+ * Resolves the engine-relative directory an xpcshell scaffold is written
+ * to. A `--test-dir` override names the FINAL directory (no per-component
+ * segment is appended); the default is
+ * `browser/base/content/test/<binaryName>-xpcshell/<componentName>`.
+ */
+export declare function resolveXpcshellTestDir(binaryName: string, componentName: string, override?: string): string;
 /** Returns true when `fileName` has one of the standard component file extensions. */
 export declare function isComponentSourceFile(fileName: string): boolean;
 /**

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

@@ -13,6 +13,12 @@ export const JAR_MN = 'toolkit/content/jar.mn';
 export const WIDGETS_DIR = 'toolkit/content/widgets';
 /** Default Fluent localization directory for toolkit global components, relative to engine root */
 export const FTL_DIR = 'toolkit/locales/en-US/toolkit/global';
+/**
+ * Engine-relative root every browser-chrome / xpcshell test scaffold lives
+ * under, trailing slash included. A `--test-dir` override must stay below
+ * it so the `browser/base/moz.build` manifest registration keeps working.
+ */
+export const BROWSER_TEST_SCAFFOLD_ROOT = 'browser/base/content/test/';
 /**
  * Suffix for the per-binary xpcshell scaffold parent directory. Components
  * created with `furnace create --with-tests --xpcshell` land at
@@ -27,7 +33,26 @@ const XPCSHELL_TEST_DIR_SUFFIX = '-xpcshell';
  * path `remove.ts` / `rename.ts` / `validate.ts` must clean up.
  */
 export function xpcshellTestParentDir(binaryName) {
-    return `browser/base/content/test/${binaryName}${XPCSHELL_TEST_DIR_SUFFIX}`;
+    return `${BROWSER_TEST_SCAFFOLD_ROOT}${binaryName}${XPCSHELL_TEST_DIR_SUFFIX}`;
+}
+/**
+ * Resolves the engine-relative directory a browser-chrome scaffold is
+ * written to: the `--test-dir` override when given, else
+ * `browser/base/content/test/<binaryName>`. The scaffolder AND the
+ * dry-run / success formatters resolve through this one function, so the
+ * printed plan cannot disagree with the files that land on disk.
+ */
+export function resolveBrowserChromeTestDir(binaryName, override) {
+    return override ?? `${BROWSER_TEST_SCAFFOLD_ROOT}${binaryName}`;
+}
+/**
+ * Resolves the engine-relative directory an xpcshell scaffold is written
+ * to. A `--test-dir` override names the FINAL directory (no per-component
+ * segment is appended); the default is
+ * `browser/base/content/test/<binaryName>-xpcshell/<componentName>`.
+ */
+export function resolveXpcshellTestDir(binaryName, componentName, override) {
+    return override ?? `${xpcshellTestParentDir(binaryName)}/${componentName}`;
 }
 /** File extensions that constitute a Furnace component's source files. */
 const COMPONENT_FILE_EXTENSIONS = ['.mjs', '.css', '.ftl'];

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,186 @@
+// 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';
+/**
+ * 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 ${String(p.pid)} (up ${p.elapsed}): ${p.command.slice(0, COMMAND_EXCERPT_LIMIT)}`)
+        .join('\n');
+    const pids = orphans.map((p) => String(p.pid)).join(' ');
+    return (`${String(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 ${String(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 ${String(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 new Promise((resolve) => setTimeout(resolve, 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 ${String(orphan.pid)} failed (${toError(error).message}).`);
+            }
+        }
+        info(`--reap-orphans: terminated PID ${String(orphan.pid)}.`);
+    }
+}

package/dist/src/core/license-headers.d.ts

@@ -69,7 +69,9 @@ export declare function hasUpstreamMplBlockHeader(content: string): boolean;
 export declare function hasAnyLicenseHeaderAnyStyle(content: string): boolean;
 /**
  * Returns true if the first few lines of `content` contain a recognized
- * upstream license identifier string.
+ * upstream license identifier string — Mozilla's MPL boilerplate, an SPDX
+ * tag, the common permissive/copyleft license names, or the CC0
+ * public-domain dedication upstream test files carry.
  *
  * @param content  - File content to check
  * @param maxLines - Number of leading lines to inspect (default 10)
@@ -77,10 +79,12 @@ export declare function hasAnyLicenseHeaderAnyStyle(content: string): boolean;
 export declare function containsUpstreamLicenseText(content: string, maxLines?: number): boolean;
 /**
  * Returns true when the head of `content` carries a recognized THIRD-PARTY
- * permissive license banner (MIT / ISC / BSD-2 / BSD-3 / Apache-2.0), in any
- * comment style. Used by `export` to treat such files as vendored: offering
- * to prepend the project's own license header onto a byte-identity-pinned
- * upstream bundle would mislicense third-party code.
+ * permissive license banner (MIT / ISC / BSD-2 / BSD-3 / Apache-2.0) or the
+ * CC0 public-domain dedication, in any comment style. Used by `export` to
+ * treat such files as vendored: offering to prepend the project's own
+ * license header onto a byte-identity-pinned upstream bundle — or onto a
+ * test file Mozilla dedicated to the public domain — would mislicense code
+ * the project does not own.
  *
  * @param content  - File content to check
  * @param maxLines - Number of leading lines to inspect (default 30 — full

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

@@ -227,9 +227,31 @@ function normalizeLicenseHeadForScan(head) {
     s = s.replace(/\n[ \t]*\*[ \t]*/g, ' ');
     return s.replace(/\s+/g, ' ').trim();
 }
+/**
+ * Recognizes the CC0 public-domain dedication Mozilla puts on most of its
+ * test files, in every spelling the tree carries:
+ *
+ * - the prose (`Any copyright is dedicated to the Public Domain.`), which
+ *   the block, `//` and `#` comment forms all reduce to after
+ *   {@link normalizeLicenseHeadForScan};
+ * - the dedication URL (`creativecommons.org/publicdomain/zero/1.0/`, with
+ *   either scheme);
+ * - the SPDX identifier `CC0-1.0`.
+ *
+ * Deliberately narrow: a bare "public domain" mention, a different Creative
+ * Commons license (`licenses/by/4.0/`, `CC-BY-4.0`) or a made-up
+ * `publicdomain/zero/2.0/` is NOT a CC0 dedication and must not be
+ * accepted as one. `scanText` must already be normalized (and may be
+ * lowercased — the match is case-insensitive).
+ */
+function hasCc0Dedication(scanText) {
+    return /dedicated to the public domain|creativecommons\.org\/publicdomain\/zero\/1\.0|spdx-license-identifier:\s*cc0-1\.0\b/i.test(scanText);
+}
 /**
  * Returns true if the first few lines of `content` contain a recognized
- * upstream license identifier string.
+ * upstream license identifier string — Mozilla's MPL boilerplate, an SPDX
+ * tag, the common permissive/copyleft license names, or the CC0
+ * public-domain dedication upstream test files carry.
  *
  * @param content  - File content to check
  * @param maxLines - Number of leading lines to inspect (default 10)
@@ -244,14 +266,16 @@ export function containsUpstreamLicenseText(content, maxLines = 10) {
         'MIT License',
         'GNU General Public License',
     ];
-    return markers.some((marker) => scanText.includes(marker));
+    return markers.some((marker) => scanText.includes(marker)) || hasCc0Dedication(scanText);
 }
 /**
  * Returns true when the head of `content` carries a recognized THIRD-PARTY
- * permissive license banner (MIT / ISC / BSD-2 / BSD-3 / Apache-2.0), in any
- * comment style. Used by `export` to treat such files as vendored: offering
- * to prepend the project's own license header onto a byte-identity-pinned
- * upstream bundle would mislicense third-party code.
+ * permissive license banner (MIT / ISC / BSD-2 / BSD-3 / Apache-2.0) or the
+ * CC0 public-domain dedication, in any comment style. Used by `export` to
+ * treat such files as vendored: offering to prepend the project's own
+ * license header onto a byte-identity-pinned upstream bundle — or onto a
+ * test file Mozilla dedicated to the public domain — would mislicense code
+ * the project does not own.
  *
  * @param content  - File content to check
  * @param maxLines - Number of leading lines to inspect (default 30 — full
@@ -271,7 +295,9 @@ export function hasThirdPartyPermissiveBanner(content, maxLines = 30) {
     ];
     if (markers.some((marker) => scanText.includes(marker)))
         return true;
-    return /spdx-license-identifier:\s*(mit|isc|bsd-2-clause|bsd-3-clause|apache-2\.0)\b/.test(scanText);
+    if (hasCc0Dedication(scanText))
+        return true;
+    return /spdx-license-identifier:\s*(mit|isc|bsd-2-clause|bsd-3-clause|apache-2\.0|cc0-1\.0)\b/.test(scanText);
 }
 /**
  * Prepends the license header to a file on disk if it is not already present.

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

@@ -25,6 +25,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`.
  */
 /**
  * True when CAPTURED output carries the documented mozsystemmonitor
@@ -76,6 +90,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*$/;
@@ -93,9 +107,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;

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

@@ -23,6 +23,13 @@ export interface MachOptions {
      * stdout/stderr stay raw — the harness classifier depends on the raw
      * traceback. Unrecognized tracebacks always echo verbatim. Opted into by
      * the test dispatchers only.
+     *
+     * Consumed by {@link runMachCapture} ALONE. `runMachInheritCapture` accepts
+     * it in the type and ignores it — the inherit path has no per-chunk hook,
+     * only a mirror stream that feeds the terminal and the run log the same
+     * string, so filtering there would strip the traceback from the raw log
+     * too. The build path uses the recognition NOTE instead; see
+     * `mach-known-noise-filter.ts`.
      */
     annotateKnownTeardownNoise?: boolean;
     /**

package/dist/src/core/mach.js

@@ -2,12 +2,12 @@
 import { basename, join } from 'node:path';
 import { MachNotFoundError } from '../errors/build.js';
 import { pathExists } from '../utils/fs.js';
-import { warn } from '../utils/logger.js';
+import { info, warn } from '../utils/logger.js';
 import { exec, execInherit, execInheritCapture, execSmokeRun, execStream, } from '../utils/process.js';
 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 { createKnownTeardownNoiseFilter, createTeardownNoiseContext, hasKnownTeardownNoise, KNOWN_TEARDOWN_NOISE_BUILD_NOTE, } from './mach-known-noise-filter.js';
 import { getPython } from './mach-python.js';
 import { installMachResourceGuard } from './mach-resource-shim.js';
 import { teeToRunLog, writeToActiveRunLog } from './run-log.js';
@@ -193,6 +193,20 @@ function surfaceMachErrorHints(result) {
  * the same crash family the same number of times.
  */
 const DEFAULT_BUILD_CRASH_RETRIES = 2;
+/**
+ * Names the known mozsystemmonitor teardown traceback when a BUILD carried
+ * it. The test path collapses this signature in the echo; a build cannot
+ * (see `mach-known-noise-filter.ts`), so it reached operators as an
+ * unexplained traceback in a build log — a recognized, documented upstream
+ * defect wearing the appearance of a new one. The output is left verbatim
+ * and this one line is added beside it, so the same signature reads the same
+ * in both phases.
+ */
+function noteKnownTeardownNoiseInBuild(result) {
+    if (!hasKnownTeardownNoise(`${result.stdout}\n${result.stderr}`))
+        return;
+    info(KNOWN_TEARDOWN_NOISE_BUILD_NOTE);
+}
 /**
  * The single protected path every FireForge mach build dispatch routes
  * through — `build`, `build --ui`, and the pre-test `--build` step all use
@@ -222,6 +236,7 @@ export async function runProtectedMachBuild(kind, engineDir, options = {}) {
         const { env } = await installMachResourceGuard(engineDir);
         const result = await runMachInheritCapture(args, engineDir, { env });
         if (result.exitCode === 0) {
+            noteKnownTeardownNoiseInBuild(result);
             return { ...result, attempts: attempt };
         }
         const signature = detectHarnessCrashSignature(`${result.stdout}\n${result.stderr}`);
@@ -233,6 +248,7 @@ export async function runProtectedMachBuild(kind, engineDir, options = {}) {
             continue;
         }
         surfaceMachErrorHints(result);
+        noteKnownTeardownNoiseInBuild(result);
         return { ...result, attempts: attempt, ...(signature ? { crashSignature: signature } : {}) };
     }
 }