@hominis/fireforge 0.34.2 → 0.36.0

package/dist/src/core/furnace-step-errors.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared predicates over {@link StepError} lists.
+ *
+ * Step errors come in two severities: BLOCKING (the default — the apply is
+ * considered failed, triggers rollback and a non-zero exit) and ADVISORY
+ * (`advisory: true` — reported as a warning, never blocks; used by the
+ * `.ftl` helpers whose contract is graceful degradation). Every gate that
+ * decides rollback/failure must count only blocking errors; every reporter
+ * should still surface advisory ones. This module is a leaf (types-only
+ * imports) so both `furnace-apply.ts` and its callers can share the
+ * predicates without import cycles.
+ */
+import type { StepError } from '../types/furnace.js';
+/** Narrow shape shared by applied-component entries carrying step errors. */
+export interface HasStepErrors {
+    stepErrors?: StepError[];
+}
+/** Returns only the blocking (non-advisory) step errors. */
+export declare function blockingStepErrors(stepErrors: StepError[] | undefined): StepError[];
+/** True when the entry carries at least one blocking step error. */
+export declare function hasBlockingStepErrors(entry: HasStepErrors): boolean;
+/** Counts applied entries that carry at least one blocking step error. */
+export declare function countEntriesWithBlockingStepErrors(entries: readonly HasStepErrors[]): number;

package/dist/src/core/furnace-step-errors.js

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Shared predicates over {@link StepError} lists.
+ *
+ * Step errors come in two severities: BLOCKING (the default — the apply is
+ * considered failed, triggers rollback and a non-zero exit) and ADVISORY
+ * (`advisory: true` — reported as a warning, never blocks; used by the
+ * `.ftl` helpers whose contract is graceful degradation). Every gate that
+ * decides rollback/failure must count only blocking errors; every reporter
+ * should still surface advisory ones. This module is a leaf (types-only
+ * imports) so both `furnace-apply.ts` and its callers can share the
+ * predicates without import cycles.
+ */
+/** Returns only the blocking (non-advisory) step errors. */
+export function blockingStepErrors(stepErrors) {
+    return (stepErrors ?? []).filter((e) => e.advisory !== true);
+}
+/** True when the entry carries at least one blocking step error. */
+export function hasBlockingStepErrors(entry) {
+    return blockingStepErrors(entry.stepErrors).length > 0;
+}
+/** Counts applied entries that carry at least one blocking step error. */
+export function countEntriesWithBlockingStepErrors(entries) {
+    return entries.filter((entry) => hasBlockingStepErrors(entry)).length;
+}

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

@@ -184,4 +184,3 @@ export async function cleanStories(engineDir) {
     await removeDir(storiesDir);
     return count;
 }
-//# sourceMappingURL=furnace-stories.js.map

package/dist/src/core/furnace-validate-accessibility.js

@@ -55,4 +55,3 @@ export async function validateAccessibility(componentDir, tagName, customConfig)
     }
     return issues;
 }
-//# sourceMappingURL=furnace-validate-accessibility.js.map

package/dist/src/core/furnace-validate-checks.js

@@ -4,4 +4,3 @@ export { validateAccessibility } from './furnace-validate-accessibility.js';
 export { validateCompatibility } from './furnace-validate-compatibility.js';
 export { checkRegistrationConsistency, validateJarMnEntries, validateRegistrationPatterns, validateTokenLink, } from './furnace-validate-registration.js';
 export { validateStructure } from './furnace-validate-structure.js';
-//# sourceMappingURL=furnace-validate-checks.js.map

package/dist/src/core/furnace-validate-compatibility.js

@@ -149,4 +149,3 @@ export async function validateCompatibility(componentDir, tagName, type, config,
     }
     return issues;
 }
-//# sourceMappingURL=furnace-validate-compatibility.js.map

package/dist/src/core/furnace-validate-helpers.js

@@ -434,4 +434,3 @@ export async function findOrphanedEngineFiles(root, config, tagName, state, ftlD
     }
     return issues;
 }
-//# sourceMappingURL=furnace-validate-helpers.js.map

package/dist/src/core/furnace-validate-registration.js

@@ -5,12 +5,13 @@ import { join } from 'node:path';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
-import { stripJsComments } from '../utils/regex.js';
+import { escapeRegex, stripJsComments } from '../utils/regex.js';
 import { getProjectPaths, loadConfig } from './config.js';
 import { getFurnacePaths } from './furnace-config.js';
 import { CUSTOM_ELEMENTS_JS, FTL_DIR, JAR_MN } from './furnace-constants.js';
 import { expandCssFragments, listFragmentIncludes } from './furnace-css-fragments.js';
 import { findStaleJarMnEntries } from './furnace-registration.js';
+import { isTagAlreadyRegistered } from './furnace-registration-ast.js';
 import { isTagInCorrectCustomElementsPlacement } from './furnace-registration-validate.js';
 import { getTokensCssPath } from './token-manager.js';
 /**
@@ -47,9 +48,6 @@ export async function validateRegistrationPatterns(root, config) {
     }
     return issues;
 }
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 /**
  * Checks registration consistency for a single custom component.
  *
@@ -160,8 +158,11 @@ export async function checkRegistrationConsistency(root, name, config, ftlDir) {
     const cePath = join(engineDir, CUSTOM_ELEMENTS_JS);
     if (await pathExists(cePath)) {
         const ceContent = await readText(cePath);
-        status.customElementsPresent =
-            ceContent.includes(`"${name}"`) || ceContent.includes(`'${name}'`);
+        // Structure-aware check shared with the ADD path — a bare substring
+        // test counted any mention of the tag (a leftover comment, an
+        // unrelated string) as "registered", masking genuinely missing
+        // registrations from both validate and the re-apply drift oracle.
+        status.customElementsPresent = isTagAlreadyRegistered(ceContent, name);
         if (status.customElementsPresent) {
             status.customElementsCorrectBlock = isTagInCorrectCustomElementsPlacement(ceContent, name, true);
         }
@@ -396,4 +397,3 @@ export async function runPostApplyConsistencyChecks(root, config, result, ftlDir
         }
     }
 }
-//# sourceMappingURL=furnace-validate-registration.js.map

package/dist/src/core/furnace-validate-structure.d.ts

@@ -1,4 +1,12 @@
 import type { ComponentType, CustomComponentConfig, ValidationIssue } from '../types/furnace.js';
+/**
+ * Returns true when file content carries unresolved three-way-merge
+ * conflict markers (as left behind by `furnace refresh`). Shared between
+ * the structure validator and `furnace sync`'s pre-apply gate — both must
+ * agree on what "conflicted" means so a file that validate flags can never
+ * slip through sync into the engine.
+ */
+export declare function containsMergeConflictMarkers(content: string): boolean;
 /**
  * Validates the file structure of a component directory.
  * Checks for required files and naming conventions.

package/dist/src/core/furnace-validate-structure.js

@@ -2,6 +2,16 @@
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pathExists, readText } from '../utils/fs.js';
+/**
+ * Returns true when file content carries unresolved three-way-merge
+ * conflict markers (as left behind by `furnace refresh`). Shared between
+ * the structure validator and `furnace sync`'s pre-apply gate — both must
+ * agree on what "conflicted" means so a file that validate flags can never
+ * slip through sync into the engine.
+ */
+export function containsMergeConflictMarkers(content) {
+    return /^<{7}\s/m.test(content) || /^>{7}\s/m.test(content) || /^={7}$/m.test(content);
+}
 /**
  * Validates the file structure of a component directory.
  * Checks for required files and naming conventions.
@@ -65,7 +75,7 @@ export async function validateStructure(componentDir, tagName, type, customConfi
             !entry.name.endsWith('.ftl'))
             continue;
         const content = await readText(join(componentDir, entry.name));
-        if (/^<{7}\s/m.test(content) || /^>{7}\s/m.test(content) || /^={7}$/m.test(content)) {
+        if (containsMergeConflictMarkers(content)) {
             issues.push({
                 component: tagName,
                 severity: 'error',
@@ -109,4 +119,3 @@ export async function validateStructure(componentDir, tagName, type, customConfi
     }
     return issues;
 }
-//# sourceMappingURL=furnace-validate-structure.js.map

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

@@ -298,4 +298,3 @@ async function findOrphanXpcshellScaffolds(root, config) {
     }
     return issues;
 }
-//# sourceMappingURL=furnace-validate.js.map

package/dist/src/core/furnace-version-drift.d.ts

@@ -14,9 +14,12 @@
  * copied from `forgeConfig.firefox.version`. Any string mismatch is worth
  * surfacing — even "140.0" vs "140.9.0esr" is a real drift signal.
  *
- * The result is advisory: apply/deploy emit warnings but do not fail, and
- * status reports drift alongside the component overview. Nothing here
- * should be wired into a blocking code path without an operator prompt.
+ * The result GATES apply/deploy: both warn and then FAIL without --force
+ * (see furnaceApplyCommand / furnaceDeployCommand), and `furnace sync`
+ * re-checks it after refresh before applying. Status reports drift
+ * alongside the component overview. Keep this doc in sync with the gates —
+ * an earlier version claimed the result was advisory, which invited
+ * re-breaking the gate.
  */
 import type { FurnaceConfig } from '../types/furnace.js';
 /** Severity of the version drift between an override's base and the current Firefox version. */

package/dist/src/core/furnace-version-drift.js

@@ -15,9 +15,12 @@
  * copied from `forgeConfig.firefox.version`. Any string mismatch is worth
  * surfacing — even "140.0" vs "140.9.0esr" is a real drift signal.
  *
- * The result is advisory: apply/deploy emit warnings but do not fail, and
- * status reports drift alongside the component overview. Nothing here
- * should be wired into a blocking code path without an operator prompt.
+ * The result GATES apply/deploy: both warn and then FAIL without --force
+ * (see furnaceApplyCommand / furnaceDeployCommand), and `furnace sync`
+ * re-checks it after refresh before applying. Status reports drift
+ * alongside the component overview. Keep this doc in sync with the gates —
+ * an earlier version claimed the result was advisory, which invited
+ * re-breaking the gate.
  */
 /**
  * Parses a version string into its major, minor, and patch numeric
@@ -98,4 +101,3 @@ export function formatOverrideBaseVersionDriftError(entries) {
         'update baseVersion in furnace.json to acknowledge the new baseline, ' +
         'or pass --force to proceed despite the drift.');
 }
-//# sourceMappingURL=furnace-version-drift.js.map

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

@@ -117,4 +117,3 @@ export async function configureGitPerformance(repoDir) {
     await git(['config', 'core.fsmonitor', 'false'], repoDir);
     await git(['config', 'feature.manyFiles', 'true'], repoDir);
 }
-//# sourceMappingURL=git-base.js.map

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

@@ -476,4 +476,3 @@ export async function generateBinaryFilePatch(repoDir, filePath) {
         }
     });
 }
-//# sourceMappingURL=git-diff.js.map

package/dist/src/core/git-file-ops.js

@@ -228,4 +228,3 @@ export async function isBinaryFile(repoDir, filePath) {
         return false;
     }
 }
-//# sourceMappingURL=git-file-ops.js.map

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

@@ -12,9 +12,22 @@ export declare function parsePorcelainStatus(output: string): GitStatusEntry[];
  * @returns Parsed git status entries
  */
 export declare function getWorkingTreeStatus(repoDir: string): Promise<GitStatusEntry[]>;
+/**
+ * Resolves the per-directory expansion cap, honoring the same
+ * FIREFORGE_MAX_UNTRACKED_FILES override the status command documents.
+ */
+export declare function resolveMaxUntrackedFilesPerDir(): number;
 /**
  * Expands collapsed untracked directory entries into individual file entries.
  * Git status may report "?? dir/" instead of listing each file underneath.
+ *
+ * Expansion is capped per directory (FIREFORGE_MAX_UNTRACKED_FILES, default
+ * 5000) with a warning on overflow. The cap used to exist only in the
+ * status command's private expander; this shared one — used by reset,
+ * discard, verify, lint, export-all — was unbounded, so e.g. `reset
+ * --dry-run` after an interrupted download (unborn HEAD, the entire ~300k
+ * file tree untracked) enumerated and printed every file.
+ *
  * @param repoDir - Repository directory
  * @param entries - Parsed status entries
  * @returns Status entries with untracked directories expanded to individual files

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

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

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

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

package/dist/src/core/git.js

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

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

@@ -38,6 +38,22 @@ export declare function getLicenseHeader(license: ProjectLicense, style: Comment
  * @param style   - Comment syntax of the file
  */
 export declare function hasAnyLicenseHeader(content: string, style: CommentStyle): boolean;
+/**
+ * Returns true if `content` starts with the verbatim upstream Mozilla
+ * MPL-2.0 block header (`/* This Source Code Form … *\/`), optionally
+ * preceded by editor-directive comments — the exact shape a JS file
+ * copied from the Firefox source tree carries.
+ *
+ * Deliberately independent of the project license: a new JS file that
+ * legitimately keeps its upstream MPL block header (copied-from-upstream
+ * provenance) is valid in an EUPL/GPL/0BSD project too. Before 0.35.0
+ * this acceptance only existed behind a `license === 'MPL-2.0'` gate in
+ * patch-lint, making it dead code for every other project license and
+ * forcing repo-side audit workarounds.
+ *
+ * @param content - File content to check
+ */
+export declare function hasUpstreamMplBlockHeader(content: string): boolean;
 /**
  * Returns true if `content` starts with any known license header in any
  * comment style (js, css, hash).

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

@@ -119,6 +119,25 @@ export function hasAnyLicenseHeader(content, style) {
     }
     return false;
 }
+/**
+ * Returns true if `content` starts with the verbatim upstream Mozilla
+ * MPL-2.0 block header (`/* This Source Code Form … *\/`), optionally
+ * preceded by editor-directive comments — the exact shape a JS file
+ * copied from the Firefox source tree carries.
+ *
+ * Deliberately independent of the project license: a new JS file that
+ * legitimately keeps its upstream MPL block header (copied-from-upstream
+ * provenance) is valid in an EUPL/GPL/0BSD project too. Before 0.35.0
+ * this acceptance only existed behind a `license === 'MPL-2.0'` gate in
+ * patch-lint, making it dead code for every other project license and
+ * forcing repo-side audit workarounds.
+ *
+ * @param content - File content to check
+ */
+export function hasUpstreamMplBlockHeader(content) {
+    const blockHeader = getLicenseHeader('MPL-2.0', 'css');
+    return (content.startsWith(blockHeader) || stripLeadingEditorDirectives(content).startsWith(blockHeader));
+}
 /**
  * Returns true if `content` starts with any known license header in any
  * comment style (js, css, hash).
@@ -174,4 +193,3 @@ export async function addLicenseHeaderToFile(filePath, license, style) {
     await writeText(filePath, header + '\n' + content);
     return true;
 }
-//# sourceMappingURL=license-headers.js.map

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

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

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

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

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

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

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

@@ -56,6 +56,33 @@ export const MACH_ERROR_HINTS = [
             'remove any `pub type basic_string___self_view = …<_CharT>;` line from ' +
             '`<objdir>/release/build/gecko-profiler-*/out/gecko/bindings.rs`.',
     },
+    {
+        // Firefox declares per-release toolchain minimums in-tree
+        // (`build/moz.configure/bindgen.configure` for cbindgen; mozboot's
+        // MINIMUM_RUST_VERSION for rustc/cargo), and a source hop can move
+        // them. The 152.0b7 → 153.0b8 source-refresh drill hit exactly this:
+        // the first post-hop build died ~8s into `mach configure` with
+        // "ERROR: cbindgen version 0.29.1 is too old. At least version
+        // 0.29.4 is required." — and mach's own remediation text names
+        // "./mach bootstrap", the wrong entry point for a FireForge-managed
+        // repo. Pattern matches configure's cbindgen die() shape.
+        pattern: /\bversion [\d.]+ is too old\.?\s+At least version [\d.]+ is required/i,
+        hint: 'A toolchain component is older than the minimum this Firefox source declares — typical ' +
+            'after "fireforge download --force" moved the engine to a new Firefox major version. ' +
+            'Run "fireforge bootstrap" (not mach\'s suggested "./mach bootstrap") to update the ' +
+            'toolchain, then retry the build.',
+    },
+    {
+        // Same family, rust.configure's die() shapes: "Rust compiler {v} is
+        // too old." / "Cargo package manager {v} is too old." — the minimum
+        // is only named further down that message, so the pattern keys on
+        // the first line.
+        pattern: /\b(?:Rust compiler|Cargo package manager) [\d.]+(?:[\w.-]*)? is too old/i,
+        hint: "The Rust toolchain is older than the minimum this Firefox source declares (mozboot's " +
+            'MINIMUM_RUST_VERSION) — typical after "fireforge download --force" moved the engine to a ' +
+            'new Firefox major version. Run "fireforge bootstrap" to update the toolchain, then retry ' +
+            'the build.',
+    },
     {
         // When `mach build` fails mid-compile, mach's own shutdown pipeline still
         // runs its trailing "Config object not found by mach. / Configure
@@ -93,4 +120,3 @@ export function explainMachError(stderr) {
     }
     return hits;
 }
-//# sourceMappingURL=mach-error-hints.js.map

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

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

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

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

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

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

package/dist/src/core/mach.js

@@ -392,4 +392,3 @@ export async function mochitestWithOutput(engineDir, testPaths = [], args = [],
         env: { ...guard.env, ...env },
     });
 }
-//# sourceMappingURL=mach.js.map

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

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

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

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

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

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

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

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