@hominis/fireforge 0.44.3 → 0.45.0

package/dist/src/core/build-baseline-types.d.ts

@@ -35,6 +35,34 @@ export interface BuildBaseline {
      * a tracked deletion.
      */
     packageableFingerprints?: Record<string, string>;
+    /**
+     * Content hash per build-input manifest (`jar.mn`, `moz.build`,
+     * `moz.configure`, `Makefile.in`, `mozbuild.in`) that was dirty
+     * (modified-against-HEAD or untracked) when the recorded build succeeded.
+     * Same key/value shape as {@link BuildBaseline.packageableFingerprints}.
+     *
+     * Consumed by `build-prepare`: a dirty build input whose live hash still
+     * matches its entry was already consumed by the recorded build, so it
+     * neither re-runs `mach configure` nor escalates a pre-test build to a
+     * full `mach build`. Without this the persistent worktree diff every
+     * fork carries (imported patches + Furnace-applied components) made a
+     * patch-touched `jar.mn` "changed" on EVERY run, and each `test --build`
+     * after a full build paid the full build again.
+     *
+     * Refresh rules, per entry kind:
+     * - backend inputs (`moz.build` & co) are refreshed on every successful
+     *   write — every baseline-writing path ran the auto-configure preflight
+     *   against the previous baseline, so a changed one was reconfigured;
+     * - `jar.mn` entries are refreshed only by a FULL build and carried
+     *   forward verbatim from the previous record on a `faster` write, since
+     *   `fireforge build --ui` never escalates and recording a `jar.mn` no
+     *   full build has installed would hide the next escalation.
+     *
+     * Absent on baselines written before the field existed; `build-prepare`
+     * then falls back to the path-only comparison (every dirty build input
+     * counts as changed).
+     */
+    buildInputFingerprints?: Record<string, string>;
     /**
      * What the packaged test runtime produced by the recorded build covers.
      *

package/dist/src/core/build-baseline.d.ts

@@ -16,6 +16,15 @@
  * subsequent run still audits against the last known-good tree.
  */
 import { type BuildBaseline, type TestPackagingCoverage } from './build-baseline-types.js';
+/**
+ * Which mach build produced the baseline being written. Decides whether
+ * the `jar.mn` half of {@link BuildBaseline.buildInputFingerprints} is
+ * refreshed (`'full'`) or carried forward from the previous record
+ * (`'faster'`). `fireforge build --ui` and a non-escalated `test --build`
+ * are `'faster'`; `fireforge build` and an escalated `test --build` are
+ * `'full'`.
+ */
+export type BaselineBuildKind = 'full' | 'faster';
 /** Name of the last-build marker file under `.fireforge/`. */
 export declare const BUILD_BASELINE_FILENAME = "last-build.json";
 /**
@@ -56,5 +65,11 @@ export declare function readBuildBaseline(projectRoot: string): Promise<BuildBas
  *   keeps the previous anchor: needed by `--extend-coverage`, whose union
  *   can EVALUATE to `'full'` while the build that produced it was still a
  *   scoped `mach build faster` that did not rebake the compiled table.
+ * @param buildKind - Which mach build produced this baseline (default
+ *   `'full'`). A `'faster'` write carries the previous record's `jar.mn`
+ *   fingerprints forward instead of refreshing them — see
+ *   {@link BuildBaseline.buildInputFingerprints}. Every caller that ran
+ *   `mach build faster` MUST say so, or the next pre-test build skips an
+ *   escalation no full build has honoured.
  */
-export declare function writeBuildBaseline(projectRoot: string, engineDir: string, binaryName: string, testPackagingCoverage?: TestPackagingCoverage, previousBaseline?: BuildBaseline, recordedBy?: string, staticComponentsHandling?: 'auto' | 'refresh' | 'carry-forward'): Promise<void>;
+export declare function writeBuildBaseline(projectRoot: string, engineDir: string, binaryName: string, testPackagingCoverage?: TestPackagingCoverage, previousBaseline?: BuildBaseline, recordedBy?: string, staticComponentsHandling?: 'auto' | 'refresh' | 'carry-forward', buildKind?: BaselineBuildKind): Promise<void>;

package/dist/src/core/build-baseline.js

@@ -23,7 +23,7 @@ import { mapWithConcurrency } from '../utils/concurrency.js';
 import { getNodeErrorCode, toError } from '../utils/errors.js';
 import { pathExists, readJson, writeJson } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
-import { isPackageablePath, isXpcomManifestPath } from './build-audit.js';
+import { isBuildInputPath, isJarManifestPath, isPackageablePath, isXpcomManifestPath, } from './build-audit.js';
 import { DELETED_FILE_FINGERPRINT, } from './build-baseline-types.js';
 import { FIREFORGE_DIR } from './config-paths.js';
 import { hashEngineFile } from './coverage-extend.js';
@@ -90,8 +90,14 @@ export async function readBuildBaseline(projectRoot) {
  *   keeps the previous anchor: needed by `--extend-coverage`, whose union
  *   can EVALUATE to `'full'` while the build that produced it was still a
  *   scoped `mach build faster` that did not rebake the compiled table.
+ * @param buildKind - Which mach build produced this baseline (default
+ *   `'full'`). A `'faster'` write carries the previous record's `jar.mn`
+ *   fingerprints forward instead of refreshing them — see
+ *   {@link BuildBaseline.buildInputFingerprints}. Every caller that ran
+ *   `mach build faster` MUST say so, or the next pre-test build skips an
+ *   escalation no full build has honoured.
  */
-export async function writeBuildBaseline(projectRoot, engineDir, binaryName, testPackagingCoverage, previousBaseline, recordedBy, staticComponentsHandling = 'auto') {
+export async function writeBuildBaseline(projectRoot, engineDir, binaryName, testPackagingCoverage, previousBaseline, recordedBy, staticComponentsHandling = 'auto', buildKind = 'full') {
     let engineHeadSha = '';
     try {
         engineHeadSha = await getHead(engineDir);
@@ -106,6 +112,7 @@ export async function writeBuildBaseline(projectRoot, engineDir, binaryName, tes
         }
     }
     const packageableFingerprints = await collectPackageableFingerprints(engineDir);
+    const buildInputFingerprints = await collectBuildInputFingerprints(engineDir, previousBaseline, buildKind);
     // A full-coverage write (and the legacy no-claim `fireforge build` shape)
     // just recompiled the StaticComponents table, so it anchors the table to
     // the current engine state. A scoped write did not — carry the previous
@@ -121,6 +128,7 @@ export async function writeBuildBaseline(projectRoot, engineDir, binaryName, tes
         builtAt: new Date().toISOString(),
         binaryName,
         ...(packageableFingerprints !== undefined ? { packageableFingerprints } : {}),
+        ...(buildInputFingerprints !== undefined ? { buildInputFingerprints } : {}),
         ...(testPackagingCoverage !== undefined ? { testPackagingCoverage } : {}),
         ...(mozconfigHash !== undefined ? { mozconfigHash } : {}),
         ...(staticComponentsBaseline !== undefined ? { staticComponentsBaseline } : {}),
@@ -143,6 +151,34 @@ export async function writeBuildBaseline(projectRoot, engineDir, binaryName, tes
 async function collectPackageableFingerprints(engineDir) {
     return collectDirtyFingerprints(engineDir, isPackageablePath, 'packageable fingerprint');
 }
+/**
+ * Content fingerprints of the dirty build-input manifests
+ * ({@link isBuildInputPath}) this build consumed. Backend inputs
+ * (`moz.build` & co) are always taken from the live tree: the
+ * auto-configure preflight reconfigured against them before this build
+ * ran. `jar.mn` entries are taken from the live tree only after a FULL
+ * build; a `faster` write carries the previous record's `jar.mn` entries
+ * forward verbatim, because `mach build faster` is exactly the build the
+ * `jar.mn` escalation exists to bypass, and recording a `jar.mn` it did
+ * not install would silence the next escalation. Returns `undefined` on
+ * probe failure so the field is omitted rather than written as `{}`.
+ */
+async function collectBuildInputFingerprints(engineDir, previousBaseline, buildKind) {
+    const live = await collectDirtyFingerprints(engineDir, isBuildInputPath, 'build-input fingerprint');
+    if (live === undefined || buildKind === 'full') {
+        return live;
+    }
+    const fingerprints = {};
+    for (const [path, hash] of Object.entries(live)) {
+        if (!isJarManifestPath(path))
+            fingerprints[path] = hash;
+    }
+    for (const [path, hash] of Object.entries(previousBaseline?.buildInputFingerprints ?? {})) {
+        if (isJarManifestPath(path))
+            fingerprints[path] = hash;
+    }
+    return fingerprints;
+}
 /**
  * Anchor for the compiled StaticComponents table: the engine HEAD SHA of
  * this (full) build plus content fingerprints of the `components.conf`

package/dist/src/core/build-jar-escalation.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Decides whether a changed `jar.mn` really forces the pre-test build to
+ * escalate from `mach build faster` to a full `mach build`.
+ *
+ * The 0.41.0 rule was `any changed jar.mn ⇒ full build`, which costs ~10
+ * minutes against ~20 s for a chrome-only slice and is paid TWICE per
+ * green/no-change pair on a Furnace-touching slice. A downstream experiment
+ * (two clean runs, 2026-08-29, against 0.44.4) showed the rule is over-broad
+ * for the common case: a jar-only registration of a NEW content file added
+ * to an EXISTING `dist/bin` manifest was installed by a plain
+ * `fireforge build --ui` both times — `faster/install_dist_bin_browser` named
+ * the destination, the file landed in `dist/bin/…/content/browser/` and in
+ * the `.app` bundle, and a plain `fireforge test` fetched it over
+ * `chrome://` at runtime. Neither run escalated, and neither needed to.
+ *
+ * What the experiment did NOT exercise, and what therefore still escalates:
+ *
+ *  - a NEW `jar.mn` file. The install manifest for a manifest the backend
+ *    has never seen does not exist yet, and `mach build faster` consumes
+ *    install manifests rather than regenerating the backend that writes
+ *    them.
+ *  - a manifest whose jar declaration carries a bracketed base-directory
+ *    prefix (`[some/dir] name.jar:`), which redirects the install
+ *    destination away from the default chrome root. That redirect is the
+ *    "non-dist/bin target" half nobody has run.
+ *
+ * Everything else about the rule is unchanged, and every failure to read or
+ * parse a manifest escalates: this narrows a conservative rule, so its
+ * error direction stays the slow-but-correct one.
+ */
+import type { BuildBaseline } from './build-baseline-types.js';
+/** Why one changed `jar.mn` still forces a full build. */
+export interface JarEscalationCause {
+    /** Engine-relative manifest path. */
+    path: string;
+    /** Operator-facing reason, printed with the escalation notice. */
+    reason: string;
+}
+/** Outcome of {@link evaluateJarManifestEscalation}. */
+export interface JarEscalationDecision {
+    /** True when at least one changed manifest still needs a full build. */
+    escalate: boolean;
+    /** One entry per manifest that forces the escalation. */
+    causes: JarEscalationCause[];
+    /** Manifests the narrowing cleared; kept for the verbose explanation. */
+    cleared: string[];
+}
+/**
+ * Evaluates every changed `jar.mn` against the narrowed rule.
+ *
+ * @param engineDir - Absolute engine directory
+ * @param changedPaths - Engine-relative paths changed since the last
+ *   successful build (non-`jar.mn` entries are ignored)
+ * @param baseline - Last successful build's baseline (reserved: the
+ *   fingerprint map already gated which paths reach here)
+ * @returns The escalation decision with per-manifest causes
+ */
+export declare function evaluateJarManifestEscalation(engineDir: string, changedPaths: readonly string[], baseline: BuildBaseline | undefined): Promise<JarEscalationDecision>;
+/**
+ * Renders the operator-facing escalation notice. Names the manifest AND the
+ * reason: "a jar.mn changed" is the sentence that made the previous rule
+ * impossible to argue with from outside.
+ */
+export declare function formatJarEscalationNotice(decision: JarEscalationDecision): string;

package/dist/src/core/build-jar-escalation.js

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Decides whether a changed `jar.mn` really forces the pre-test build to
+ * escalate from `mach build faster` to a full `mach build`.
+ *
+ * The 0.41.0 rule was `any changed jar.mn ⇒ full build`, which costs ~10
+ * minutes against ~20 s for a chrome-only slice and is paid TWICE per
+ * green/no-change pair on a Furnace-touching slice. A downstream experiment
+ * (two clean runs, 2026-08-29, against 0.44.4) showed the rule is over-broad
+ * for the common case: a jar-only registration of a NEW content file added
+ * to an EXISTING `dist/bin` manifest was installed by a plain
+ * `fireforge build --ui` both times — `faster/install_dist_bin_browser` named
+ * the destination, the file landed in `dist/bin/…/content/browser/` and in
+ * the `.app` bundle, and a plain `fireforge test` fetched it over
+ * `chrome://` at runtime. Neither run escalated, and neither needed to.
+ *
+ * What the experiment did NOT exercise, and what therefore still escalates:
+ *
+ *  - a NEW `jar.mn` file. The install manifest for a manifest the backend
+ *    has never seen does not exist yet, and `mach build faster` consumes
+ *    install manifests rather than regenerating the backend that writes
+ *    them.
+ *  - a manifest whose jar declaration carries a bracketed base-directory
+ *    prefix (`[some/dir] name.jar:`), which redirects the install
+ *    destination away from the default chrome root. That redirect is the
+ *    "non-dist/bin target" half nobody has run.
+ *
+ * Everything else about the rule is unchanged, and every failure to read or
+ * parse a manifest escalates: this narrows a conservative rule, so its
+ * error direction stays the slow-but-correct one.
+ */
+import { join } from 'node:path';
+import { readText } from '../utils/fs.js';
+import { verbose } from '../utils/logger.js';
+import { isJarManifestPath } from './build-audit.js';
+import { getUntrackedFilesInDir } from './git-status.js';
+/**
+ * A jar declaration line: an optional bracketed base-directory prefix, then
+ * the jar name. Matched at column zero because entry lines inside a section
+ * are indented — an indented `foo.jar:` is content, not a declaration.
+ */
+const JAR_DECLARATION_PATTERN = /^(\[[^\]]*\]\s*)?[^\s[\]]+\.jar:\s*$/;
+/** True when the jar declaration redirects the install base directory. */
+function declaresNonDefaultBase(line) {
+    const match = JAR_DECLARATION_PATTERN.exec(line);
+    if (!match)
+        return false;
+    return match[1] !== undefined;
+}
+/**
+ * True when a changed `jar.mn` is NEW to the last successful build.
+ *
+ * Untracked in the engine repo is the reliable tell: a fork's engine tree is
+ * a checkout of upstream with patches applied to the WORKTREE, so a manifest
+ * a patch created is untracked and one that shipped upstream is tracked. The
+ * baseline's fingerprints cannot answer this on their own — they record only
+ * the paths that were DIRTY at the last build, so a clean pre-existing
+ * manifest has no entry either.
+ */
+async function isNewJarManifest(engineDir, path) {
+    const untracked = await getUntrackedFilesInDir(engineDir, path);
+    return untracked.includes(path);
+}
+/**
+ * Evaluates every changed `jar.mn` against the narrowed rule.
+ *
+ * @param engineDir - Absolute engine directory
+ * @param changedPaths - Engine-relative paths changed since the last
+ *   successful build (non-`jar.mn` entries are ignored)
+ * @param baseline - Last successful build's baseline (reserved: the
+ *   fingerprint map already gated which paths reach here)
+ * @returns The escalation decision with per-manifest causes
+ */
+export async function evaluateJarManifestEscalation(engineDir, changedPaths, baseline) {
+    void baseline;
+    const causes = [];
+    const cleared = [];
+    for (const path of changedPaths.filter(isJarManifestPath)) {
+        let isNew;
+        try {
+            isNew = await isNewJarManifest(engineDir, path);
+        }
+        catch (error) {
+            // Fail closed: an unanswerable "is this new?" keeps the old rule.
+            verbose(`jar escalation: could not classify engine/${path} (${String(error)}); escalating.`);
+            causes.push({ path, reason: 'could not determine whether the manifest is new' });
+            continue;
+        }
+        if (isNew) {
+            causes.push({ path, reason: 'new jar.mn (no install manifest exists for it yet)' });
+            continue;
+        }
+        let body;
+        try {
+            body = await readText(join(engineDir, path));
+        }
+        catch (error) {
+            verbose(`jar escalation: could not read engine/${path} (${String(error)}); escalating.`);
+            causes.push({ path, reason: 'manifest could not be read' });
+            continue;
+        }
+        const redirected = body
+            .split(/\r?\n/)
+            .filter((line) => declaresNonDefaultBase(line))
+            .map((line) => line.trim());
+        if (redirected.length > 0) {
+            causes.push({
+                path,
+                reason: `jar declaration redirects the install base directory (${redirected[0] ?? ''})`,
+            });
+            continue;
+        }
+        cleared.push(path);
+    }
+    return { escalate: causes.length > 0, causes, cleared };
+}
+/**
+ * Renders the operator-facing escalation notice. Names the manifest AND the
+ * reason: "a jar.mn changed" is the sentence that made the previous rule
+ * impossible to argue with from outside.
+ */
+export function formatJarEscalationNotice(decision) {
+    const detail = decision.causes.map((c) => `engine/${c.path} (${c.reason})`).join('; ');
+    return (`Escalating this pre-test build to a full mach build so new install-manifest destinations ` +
+        `are created: ${detail}. A changed jar.mn that merely adds entries to an existing ` +
+        `dist/bin manifest no longer escalates.`);
+}

package/dist/src/core/build-prepare.d.ts

@@ -14,6 +14,11 @@ export interface BuildPreparation {
     reconfigured: boolean;
     /** A changed packaging manifest cannot be safely handled by `mach build faster`. */
     fullBuildRequired?: boolean;
+    /**
+     * Operator-facing explanation for {@link fullBuildRequired}, naming the
+     * manifest and why it still escalates. Absent when no escalation applies.
+     */
+    fullBuildReason?: string;
 }
 /** Options for {@link prepareBuildEnvironment}. */
 export interface PrepareBuildOptions {
@@ -31,7 +36,13 @@ export interface PrepareBuildOptions {
      */
     refuseUnexportedDrift?: boolean | undefined;
 }
-/** Packaging manifests whose graph/destination directories need a full build. */
+/**
+ * Packaging manifests whose graph/destination directories MAY need a full
+ * build. Path-shape only: {@link evaluateJarManifestEscalation} decides
+ * whether a given changed manifest actually forces one (a new manifest, or
+ * one that redirects its install base directory), so an entry added to an
+ * existing `dist/bin` manifest no longer costs a ~10-minute build.
+ */
 export declare function requiresFullBuildForIncrementalTest(path: string): boolean;
 /**
  * Describes an exit code in the shell's 128+N signal convention. Truncated

package/dist/src/core/build-prepare.js

@@ -11,8 +11,10 @@ import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { info, notice, spinner, verbose, warn } from '../utils/logger.js';
 import { isBrandingSetup, setupBranding } from './branding.js';
+import { isBuildInputPath, isJarManifestPath } from './build-audit.js';
+import { evaluateJarManifestEscalation, formatJarEscalationNotice, } from './build-jar-escalation.js';
 import { findUnexportedDriftAtRisk, formatUnexportedDriftWarning, } from './build-overwrite-guard.js';
-import { collectChangedEnginePaths } from './engine-changes.js';
+import { collectChangedEnginePaths, dropPathsMatchingFingerprints } from './engine-changes.js';
 import { applyAllComponents } from './furnace-apply.js';
 import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, loadFurnaceState, } from './furnace-config.js';
 import { runFurnaceMutation } from './furnace-operation.js';
@@ -22,9 +24,43 @@ import { generateMozconfig, runMachCapture } from './mach.js';
 import { explainMachError } from './mach-error-hints.js';
 /** Path fragments of files whose edits invalidate the recursive-make backend. */
 const BACKEND_INVALIDATING_SUFFIXES = ['moz.build', 'moz.configure', 'Makefile.in'];
-/** Packaging manifests whose graph/destination directories need a full build. */
+/**
+ * Packaging manifests whose graph/destination directories MAY need a full
+ * build. Path-shape only: {@link evaluateJarManifestEscalation} decides
+ * whether a given changed manifest actually forces one (a new manifest, or
+ * one that redirects its install base directory), so an entry added to an
+ * existing `dist/bin` manifest no longer costs a ~10-minute build.
+ */
 export function requiresFullBuildForIncrementalTest(path) {
-    return path === 'jar.mn' || path.endsWith('/jar.mn');
+    return isJarManifestPath(path);
+}
+/**
+ * Build-input manifests changed since the last SUCCESSFUL build — not
+ * merely dirty against HEAD. `collectChangedEnginePaths` unions the
+ * baseline-to-HEAD diff with every worktree modification, and a fork's
+ * worktree is permanently dirty (imported patches, Furnace-applied
+ * components), so on its own it reports a patch-touched `jar.mn` or
+ * `moz.build` as changed on every run: `mach configure` re-ran and the
+ * pre-test build escalated to a full `mach build` after each full build
+ * that had already consumed exactly this content. The baseline's
+ * `buildInputFingerprints` say what the last successful build saw;
+ * anything byte-identical to that is dropped here. A baseline without the
+ * field (written before it existed) keeps every dirty input, which is the
+ * old behaviour.
+ *
+ * @param engineDir - Path to the engine directory
+ * @param baseline - Last successful build's baseline
+ * @returns Engine-relative build-input paths that still need acting on
+ */
+async function collectChangedBuildInputs(engineDir, baseline) {
+    const changed = await collectChangedEnginePaths(engineDir, baseline, 'Auto-configure');
+    const dirtyInputs = changed.filter(isBuildInputPath);
+    const stillChanged = await dropPathsMatchingFingerprints(engineDir, dirtyInputs, baseline.buildInputFingerprints);
+    const unchangedSinceBuild = dirtyInputs.filter((path) => !stillChanged.includes(path));
+    if (unchangedSinceBuild.length > 0) {
+        verbose(`Auto-configure: ${unchangedSinceBuild.length} dirty build input(s) byte-identical to the last successful build, not treated as changed: ${unchangedSinceBuild.join(', ')}`);
+    }
+    return stillChanged;
 }
 /**
  * Extracts the tail of captured `mach configure` output so the underlying
@@ -78,6 +114,24 @@ function buildConfigureFailureError(captured) {
         (hints.length > 0 ? `\n\n${hints.map((hint) => `Hint: ${hint}`).join('\n')}` : '') +
         '\n\nBuild stopped because continuing would hide the real configure failure.', 'mach configure');
 }
+/**
+ * Runs the narrowed `jar.mn` escalation rule over this run's changed build
+ * inputs and returns the operator-facing reason when a full build is still
+ * required, or undefined when the narrowing cleared every changed manifest.
+ *
+ * Extracted so `prepareBuildEnvironment` stays under the complexity budget.
+ *
+ * @param engineDir - Absolute engine directory
+ * @param changed - Build inputs changed since the last successful build
+ * @param baseline - Last successful build's baseline
+ */
+async function decideJarEscalation(engineDir, changed, baseline) {
+    const decision = await evaluateJarManifestEscalation(engineDir, changed.filter(requiresFullBuildForIncrementalTest), baseline);
+    if (decision.cleared.length > 0) {
+        verbose(`jar escalation: ${String(decision.cleared.length)} changed jar.mn add entries to an existing dist/bin manifest; not escalating for ${decision.cleared.join(', ')}.`);
+    }
+    return decision.escalate ? formatJarEscalationNotice(decision) : undefined;
+}
 /**
  * Returns true when the file path matches a pattern that forces
  * `mach configure` to regenerate the backend. Exported for testing.
@@ -148,10 +202,13 @@ export async function prepareBuildEnvironment(projectRoot, paths, config, option
     // work against a stale recursive-make backend.
     let reconfigured = false;
     let fullBuildRequired = false;
+    let fullBuildReason;
     if (options.previousBaseline) {
-        const changed = await collectChangedEnginePaths(paths.engine, options.previousBaseline, 'Auto-configure');
+        const changed = await collectChangedBuildInputs(paths.engine, options.previousBaseline);
         const invalidating = changed.filter(isBackendInvalidatingFile);
-        fullBuildRequired = changed.some(requiresFullBuildForIncrementalTest);
+        const jarEscalation = await decideJarEscalation(paths.engine, changed, options.previousBaseline);
+        fullBuildRequired = jarEscalation !== undefined;
+        fullBuildReason = jarEscalation;
         if (invalidating.length > 0) {
             // Warning severity: this is the "why is this run slow" explanation,
             // and an info-level line does not survive an agent output filter that
@@ -271,5 +328,10 @@ export async function prepareBuildEnvironment(projectRoot, paths, config, option
         mozconfigSpinner.error('Failed to generate mozconfig');
         throw error;
     }
-    return { furnaceApplied, reconfigured, fullBuildRequired };
+    return {
+        furnaceApplied,
+        reconfigured,
+        fullBuildRequired,
+        ...(fullBuildReason !== undefined ? { fullBuildReason } : {}),
+    };
 }

package/dist/src/core/config-validate-file-size.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Validation for `patchLint.fileSizeThresholds`.
+ *
+ * Split out of `config-validate.ts`, which is at its per-file line budget.
+ */
+import type { PatchLintFileSizeThresholds } from '../types/config.js';
+/**
+ * Parses the `patchLint.fileSizeThresholds` block. Ordering is validated
+ * against the MERGED triple (overrides on top of the defaults), so setting
+ * only `warning` cannot land below the default `notice`.
+ */
+export declare function parsePatchLintFileSizeThresholds(raw: unknown): PatchLintFileSizeThresholds;

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

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Validation for `patchLint.fileSizeThresholds`.
+ *
+ * Split out of `config-validate.ts`, which is at its per-file line budget.
+ */
+import { ConfigError } from '../errors/config.js';
+import { isObject } from '../utils/validation.js';
+import { DEFAULT_FILE_SIZE_THRESHOLDS } from './patch-lint-file-size.js';
+/**
+ * Parses one `patchLint.fileSizeThresholds.<tier>` triple. Every field is
+ * optional and merges over the built-in default; values must be positive
+ * integers and stay ordered `notice <= warning <= error`, because an
+ * out-of-order triple would silently disable a band instead of failing.
+ */
+function parseFileSizeTier(raw, field) {
+    if (!isObject(raw)) {
+        throw new ConfigError(`Config field "${field}" must be a plain object`);
+    }
+    const out = {};
+    for (const key of ['notice', 'warning', 'error']) {
+        const value = raw[key];
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0) {
+            throw new ConfigError(`Config field "${field}.${key}" must be a positive integer`);
+        }
+        out[key] = value;
+    }
+    for (const key of Object.keys(raw)) {
+        if (!['notice', 'warning', 'error'].includes(key)) {
+            throw new ConfigError(`Config field "${field}" has unknown key "${key}"`);
+        }
+    }
+    return out;
+}
+/**
+ * Parses the `patchLint.fileSizeThresholds` block. Ordering is validated
+ * against the MERGED triple (overrides on top of the defaults), so setting
+ * only `warning` cannot land below the default `notice`.
+ */
+export function parsePatchLintFileSizeThresholds(raw) {
+    if (!isObject(raw)) {
+        throw new ConfigError('Config field "patchLint.fileSizeThresholds" must be a plain object');
+    }
+    const out = {};
+    for (const tier of ['general', 'test']) {
+        const value = raw[tier];
+        if (value === undefined)
+            continue;
+        const parsed = parseFileSizeTier(value, `patchLint.fileSizeThresholds.${tier}`);
+        const merged = { ...DEFAULT_FILE_SIZE_THRESHOLDS[tier], ...parsed };
+        if (merged.notice > merged.warning || merged.warning > merged.error) {
+            throw new ConfigError(`Config field "patchLint.fileSizeThresholds.${tier}" must satisfy notice <= warning <= error ` +
+                `(resolved: ${String(merged.notice)}/${String(merged.warning)}/${String(merged.error)})`);
+        }
+        out[tier] = parsed;
+    }
+    for (const key of Object.keys(raw)) {
+        if (key !== 'general' && key !== 'test') {
+            throw new ConfigError(`Config field "patchLint.fileSizeThresholds" has unknown key "${key}"`);
+        }
+    }
+    return out;
+}

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

@@ -8,6 +8,7 @@ import { parseObject } from '../utils/parse.js';
 import { isContainedRelativePath, isExplicitAbsolutePath } from '../utils/paths.js';
 import { describeProductVersionIncompatibility, FIREFOX_PRODUCTS, isObject, isValidAppId, isValidFirefoxCandidate, isValidFirefoxProduct, isValidFirefoxVersion, isValidProjectLicense, PROJECT_LICENSES, } from '../utils/validation.js';
 import { SUPPORTED_CONFIG_ROOT_KEYS } from './config-paths.js';
+import { parsePatchLintFileSizeThresholds } from './config-validate-file-size.js';
 import { parsePatchPolicyBlock } from './config-validate-patch-policy.js';
 import { parseExternalToolchainsBlock, parseTestBlock } from './config-validate-test-toolchains.js';
 /**
@@ -323,6 +324,7 @@ function optionalPatchLintBoolean(rec, key) {
 }
 /** Severity-gate fields, each parsed and assigned identically. */
 const PATCH_LINT_SEVERITY_GATE_KEYS = [
+    'prettier',
     'jsdocClassMethods',
     'testAssertionFloor',
     'chromeScriptJsDoc',
@@ -359,6 +361,10 @@ function parsePatchLintBlock(rec) {
         }
         out.rawColorAllowlist = rawColorAllowlist;
     }
+    const fileSizeThresholds = rec.raw('fileSizeThresholds');
+    if (fileSizeThresholds !== undefined) {
+        out.fileSizeThresholds = parsePatchLintFileSizeThresholds(fileSizeThresholds);
+    }
     for (const key of PATCH_LINT_SEVERITY_GATE_KEYS) {
         const gate = parseSeverityGate(rec.raw(key), `patchLint.${key}`);
         if (gate !== undefined)

package/dist/src/core/engine-changes.d.ts

@@ -20,3 +20,21 @@ import type { BuildBaseline } from './build-baseline-types.js';
  * @returns Sorted engine-relative POSIX paths
  */
 export declare function collectChangedEnginePaths(engineDir: string, baseline: BuildBaseline | undefined, contextLabel: string): Promise<string[]>;
+/**
+ * Drops every path whose live content still matches the fingerprint the
+ * last successful build recorded for it, keeping the rest. Shared by the
+ * stale-build preflight (`packageableFingerprints`) and the auto-configure /
+ * full-build escalation in `build-prepare` (`buildInputFingerprints`).
+ *
+ * A path with no recorded entry, an unreadable file, or a differing hash
+ * is kept — "cannot prove unchanged" must never turn into "unchanged".
+ * With no fingerprint set at all (a baseline written before the field
+ * existed) every path is kept, which is the path-only comparison the
+ * fingerprints refine.
+ *
+ * @param engineDir - Path to the engine directory
+ * @param paths - Candidate engine-relative POSIX paths
+ * @param fingerprints - Recorded hashes keyed by engine-relative path
+ * @returns The subset of `paths` that cannot be proven unchanged
+ */
+export declare function dropPathsMatchingFingerprints(engineDir: string, paths: readonly string[], fingerprints: Record<string, string> | undefined): Promise<string[]>;

package/dist/src/core/engine-changes.js

@@ -6,6 +6,7 @@
  */
 import { toError } from '../utils/errors.js';
 import { verbose } from '../utils/logger.js';
+import { hashEngineFile } from './coverage-extend.js';
 import { hasChanges, isMissingHeadError } from './git.js';
 import { git } from './git-base.js';
 import { getUntrackedFiles } from './git-status.js';
@@ -59,3 +60,36 @@ export async function collectChangedEnginePaths(engineDir, baseline, contextLabe
     }
     return [...collected].sort();
 }
+/**
+ * Drops every path whose live content still matches the fingerprint the
+ * last successful build recorded for it, keeping the rest. Shared by the
+ * stale-build preflight (`packageableFingerprints`) and the auto-configure /
+ * full-build escalation in `build-prepare` (`buildInputFingerprints`).
+ *
+ * A path with no recorded entry, an unreadable file, or a differing hash
+ * is kept — "cannot prove unchanged" must never turn into "unchanged".
+ * With no fingerprint set at all (a baseline written before the field
+ * existed) every path is kept, which is the path-only comparison the
+ * fingerprints refine.
+ *
+ * @param engineDir - Path to the engine directory
+ * @param paths - Candidate engine-relative POSIX paths
+ * @param fingerprints - Recorded hashes keyed by engine-relative path
+ * @returns The subset of `paths` that cannot be proven unchanged
+ */
+export async function dropPathsMatchingFingerprints(engineDir, paths, fingerprints) {
+    if (!fingerprints)
+        return [...paths];
+    const kept = [];
+    for (const path of paths) {
+        const recorded = fingerprints[path];
+        if (recorded === undefined) {
+            kept.push(path);
+            continue;
+        }
+        const live = await hashEngineFile(engineDir, path);
+        if (live === undefined || live !== recorded)
+            kept.push(path);
+    }
+    return kept;
+}