@hominis/fireforge 0.26.0 → 0.27.1

package/dist/src/commands/verify.js

@@ -16,6 +16,8 @@
  */
 import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../core/config.js';
+import { isGitRepository } from '../core/git.js';
+import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
 import { buildPatchQueueContext, lintPatchQueue } from '../core/patch-lint.js';
 import { loadPatchesManifest, validatePatchesManifestConsistency } from '../core/patch-manifest.js';
 import { evaluatePatchPolicy } from '../core/patch-policy.js';
@@ -100,6 +102,15 @@ function detectCrossPatchFileClaims(manifestPatches) {
     }
     return results;
 }
+async function detectUnownedWorktreeChanges(engineDir, claimedFiles) {
+    if (!(await pathExists(engineDir)) || !(await isGitRepository(engineDir))) {
+        return [];
+    }
+    const entries = await expandUntrackedDirectoryEntries(engineDir, await getWorkingTreeStatus(engineDir));
+    return [
+        ...new Set(entries.map((entry) => entry.file).filter((file) => !claimedFiles.has(file))),
+    ].sort();
+}
 /**
  * Collects the same queue-health findings reported by `fireforge verify`
  * without printing. Used by doctor recovery paths that need a read-only
@@ -177,6 +188,22 @@ export async function collectPatchQueueHealth(projectRoot) {
         warningCount += lintWarnings;
     }
     if (manifest) {
+        const claimedFiles = new Set();
+        for (const patch of manifest.patches) {
+            for (const file of patch.filesAffected) {
+                claimedFiles.add(file);
+            }
+        }
+        const unownedWorktreeChanges = await detectUnownedWorktreeChanges(paths.engine, claimedFiles);
+        if (unownedWorktreeChanges.length > 0) {
+            groups.push({
+                title: `Unowned worktree changes (${unownedWorktreeChanges.length})`,
+                issues: unownedWorktreeChanges.map((file) => `${file} is changed in engine/ but is not listed in any patch filesAffected entry`),
+                errorCount: 0,
+                warningCount: unownedWorktreeChanges.length,
+            });
+            warningCount += unownedWorktreeChanges.length;
+        }
         const registrationIssues = await detectDanglingRegistrations(paths.patches, paths.engine, manifest.patches);
         if (registrationIssues.length > 0) {
             groups.push({

package/dist/src/core/branding.js

@@ -54,6 +54,11 @@ export class BrandingMozconfigMismatchError extends FireForgeError {
     }
 }
 const MOZ_APP_VENDOR_IMPLY_REGEX = /imply_option\("MOZ_APP_VENDOR",\s*"[^"]*"\)/;
+const BRANDING_CONFIGURE_MANAGED_KEYS = new Set([
+    'MOZ_APP_DISPLAYNAME',
+    'MOZ_APP_VENDOR',
+    'MOZ_MACBUNDLE_ID',
+]);
 /**
  * Sets up the custom branding directory for the browser.
  *
@@ -91,16 +96,58 @@ export async function setupBranding(engineDir, config) {
  */
 async function createConfigureScript(brandingDir, config, vendorPlacement) {
     const configureShPath = join(brandingDir, 'configure.sh');
-    await writeTextIfChanged(configureShPath, buildConfigureScriptContent(config, vendorPlacement));
+    const existing = (await pathExists(configureShPath))
+        ? await readText(configureShPath)
+        : undefined;
+    await writeTextIfChanged(configureShPath, buildConfigureScriptContent(config, vendorPlacement, existing));
 }
-function buildConfigureScriptContent(config, vendorPlacement) {
+function buildConfigureScriptContent(config, vendorPlacement, existingContent) {
     const header = getLicenseHeader(config.license ?? DEFAULT_LICENSE, 'hash');
-    const lines = [`MOZ_APP_DISPLAYNAME="${escapeShellValue(config.name)}"`];
+    const managedLines = [`MOZ_APP_DISPLAYNAME="${escapeShellValue(config.name)}"`];
+    if (vendorPlacement === 'branding-configure') {
+        managedLines.push(`MOZ_APP_VENDOR="${escapeShellValue(config.vendor)}"`);
+    }
+    managedLines.push(`MOZ_MACBUNDLE_ID="${escapeShellValue(config.appId)}"`);
+    const preservedLines = existingContent ? extractPreservedConfigureLines(existingContent) : [];
+    const body = [...managedLines, ...preservedLines].join('\n');
+    return `${header}\n\n${body}\n`;
+}
+function extractPreservedConfigureLines(content) {
+    return content.split(/\r?\n/).filter((line) => {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            return false;
+        if (/^#\s*SPDX-License-Identifier:/i.test(trimmed))
+            return false;
+        const keyMatch = /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(trimmed);
+        if (keyMatch && BRANDING_CONFIGURE_MANAGED_KEYS.has(keyMatch[1] ?? ''))
+            return false;
+        return true;
+    });
+}
+function parseConfigureAssignments(content) {
+    const assignments = new Map();
+    for (const line of content.split(/\r?\n/)) {
+        const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line.trim());
+        if (match?.[1] && match[2] !== undefined) {
+            assignments.set(match[1], match[2]);
+        }
+    }
+    return assignments;
+}
+function isConfigureScriptCurrent(content, config, vendorPlacement) {
+    const assignments = parseConfigureAssignments(content);
+    if (assignments.get('MOZ_APP_DISPLAYNAME') !== `"${escapeShellValue(config.name)}"`) {
+        return false;
+    }
+    if (assignments.get('MOZ_MACBUNDLE_ID') !== `"${escapeShellValue(config.appId)}"`) {
+        return false;
+    }
+    const vendorValue = assignments.get('MOZ_APP_VENDOR');
     if (vendorPlacement === 'branding-configure') {
-        lines.push(`MOZ_APP_VENDOR="${escapeShellValue(config.vendor)}"`);
+        return vendorValue === `"${escapeShellValue(config.vendor)}"`;
     }
-    lines.push(`MOZ_MACBUNDLE_ID="${escapeShellValue(config.appId)}"`);
-    return `${header}\n\n${lines.join('\n')}\n`;
+    return vendorValue === undefined;
 }
 /**
  * Updates the brand.properties localization file.
@@ -270,7 +317,7 @@ export async function isBrandingSetup(engineDir, config) {
     }
     const vendorPlacement = await resolveVendorPlacement(engineDir);
     const configureContent = await readText(configureShPath);
-    if (configureContent !== buildConfigureScriptContent(config, vendorPlacement)) {
+    if (!isConfigureScriptCurrent(configureContent, config, vendorPlacement)) {
         return false;
     }
     if (await pathExists(propsPath)) {

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

@@ -67,7 +67,7 @@ export function validateConfig(data) {
         throw new ConfigError('Config field "firefox.version" must be a valid Firefox version (e.g., "145.0")');
     }
     const firefoxProduct = requireConfigString(firefoxRec, 'product', 'firefox.product');
-    const validProducts = ['firefox', 'firefox-esr', 'firefox-beta'];
+    const validProducts = ['firefox', 'firefox-esr', 'firefox-beta', 'firefox-devedition'];
     if (!validProducts.includes(firefoxProduct)) {
         throw new ConfigError(`Config field "firefox.product" must be one of: ${validProducts.join(', ')}`);
     }

package/dist/src/core/firefox-extract.d.ts

@@ -6,7 +6,7 @@
  * @param archivePath - Path to the archive
  * @param destDir - Destination directory
  */
-export declare function extractTarXz(archivePath: string, destDir: string): Promise<void>;
+export declare function extractTarXz(archivePath: string, destDir: string, onProgress?: (message: string) => void): Promise<void>;
 /**
  * Gets the Firefox version from an existing source directory.
  * @param engineDir - Path to the engine directory

package/dist/src/core/firefox-extract.js

@@ -4,6 +4,7 @@
  */
 import { join } from 'node:path';
 import { ExtractionError } from '../errors/download.js';
+import { elapsedSince } from '../utils/elapsed.js';
 import { ensureDir, pathExists } from '../utils/fs.js';
 import { exec, executableExists } from '../utils/process.js';
 /**
@@ -11,15 +12,26 @@ import { exec, executableExists } from '../utils/process.js';
  * @param archivePath - Path to the archive
  * @param destDir - Destination directory
  */
-export async function extractTarXz(archivePath, destDir) {
+export async function extractTarXz(archivePath, destDir, onProgress) {
     if (!(await executableExists('tar'))) {
         throw new ExtractionError(archivePath, new Error('The "tar" command was not found. Please install tar (or ensure it is on your PATH) and try again.'));
     }
     await ensureDir(destDir);
+    const startedAt = Date.now();
+    onProgress?.(`Extracting source archive (${elapsedSince(startedAt)} elapsed)...`);
+    const heartbeat = onProgress
+        ? setInterval(() => {
+            onProgress(`Extracting source archive (${elapsedSince(startedAt)} elapsed)...`);
+        }, 15_000)
+        : null;
+    heartbeat?.unref();
     const result = await exec('tar', ['-xf', archivePath, '-C', destDir]);
+    if (heartbeat)
+        clearInterval(heartbeat);
     if (result.exitCode !== 0) {
         throw new ExtractionError(archivePath, new Error(`tar exited with code ${result.exitCode}:\n${result.stderr}`));
     }
+    onProgress?.(`Source archive extracted (${elapsedSince(startedAt)} elapsed)`);
 }
 /**
  * Gets the Firefox version from an existing source directory.

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

@@ -34,6 +34,7 @@ export declare function getTarballFilename(version: string, product?: FirefoxPro
 export type FirefoxSourcePhase = 'download' | 'extract';
 /** Callback fired at phase transitions during {@link downloadFirefoxSource}. */
 export type FirefoxSourcePhaseCallback = (phase: FirefoxSourcePhase) => void;
+export type FirefoxSourceProgressCallback = (message: string) => void;
 /**
  * Downloads and extracts Firefox source.
  * @param version - Firefox version to download
@@ -45,4 +46,4 @@ export type FirefoxSourcePhaseCallback = (phase: FirefoxSourcePhase) => void;
  *   between phases (`'download'` → `'extract'`). Fires exactly once per
  *   phase even if the cached archive path skips the wire entirely.
  */
-export declare function downloadFirefoxSource(version: string, product: FirefoxProduct, destDir: string, cacheDir: string, onProgress?: ProgressCallback, onPhase?: FirefoxSourcePhaseCallback, expectedSha256?: string): Promise<void>;
+export declare function downloadFirefoxSource(version: string, product: FirefoxProduct, destDir: string, cacheDir: string, onProgress?: ProgressCallback, onPhase?: FirefoxSourcePhaseCallback, expectedSha256?: string, onPhaseProgress?: FirefoxSourceProgressCallback): Promise<void>;

package/dist/src/core/firefox.js

@@ -44,7 +44,7 @@ export function getTarballFilename(version, product = 'firefox') {
  *   between phases (`'download'` → `'extract'`). Fires exactly once per
  *   phase even if the cached archive path skips the wire entirely.
  */
-export async function downloadFirefoxSource(version, product, destDir, cacheDir, onProgress, onPhase, expectedSha256) {
+export async function downloadFirefoxSource(version, product, destDir, cacheDir, onProgress, onPhase, expectedSha256, onPhaseProgress) {
     const archive = resolveArchive(version, product);
     const tarballPath = join(cacheDir, archive.filename);
     // Ensure cache directory exists
@@ -56,7 +56,7 @@ export async function downloadFirefoxSource(version, product, destDir, cacheDir,
     onPhase?.('extract');
     const tempDir = `${destDir}.tmp-${randomUUID()}`;
     try {
-        await extractTarXz(tarballPath, tempDir);
+        await extractTarXz(tarballPath, tempDir, onPhaseProgress);
     }
     catch (error) {
         await removeDir(tempDir);

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

@@ -81,6 +81,30 @@ function isInsideDOMContentLoaded(ancestors, content) {
     }
     return false;
 }
+function collectArrayDeclarations(ast) {
+    const arrays = new Map();
+    walkAST(ast, {
+        enter(node) {
+            if (node.type !== 'VariableDeclarator')
+                return;
+            const declarator = node;
+            if (declarator.id.type !== 'Identifier' || declarator.init?.type !== 'ArrayExpression') {
+                return;
+            }
+            arrays.set(declarator.id.name, declarator.init);
+        },
+    });
+    return arrays;
+}
+function resolveForOfArray(right, declaredArrays) {
+    if (right.type === 'ArrayExpression') {
+        return right;
+    }
+    if (right.type === 'Identifier') {
+        return declaredArrays.get(right.name);
+    }
+    return undefined;
+}
 function selectRegistrationTarget(targets, isESModule, tagName) {
     const target = isESModule
         ? targets.find((candidate) => candidate.insideDCL)
@@ -116,6 +140,7 @@ function buildRegistrationEntry(referenceEntry, tagName, modulePath, markerComme
 function addRegistrationAST(content, tagName, modulePath, isESModule, markerComment) {
     validateTagName(tagName);
     const ast = parseScript(content);
+    const declaredArrays = collectArrayDeclarations(ast);
     const ancestors = [];
     // Collect all ForOfStatement nodes with ArrayExpression rights
     const forOfs = [];
@@ -124,8 +149,8 @@ function addRegistrationAST(content, tagName, modulePath, isESModule, markerComm
             ancestors.push(node);
             if (node.type === 'ForOfStatement') {
                 const forOf = node;
-                if (forOf.right.type === 'ArrayExpression') {
-                    const array = forOf.right;
+                const array = resolveForOfArray(forOf.right, declaredArrays);
+                if (array) {
                     forOfs.push({
                         array,
                         insideDCL: isInsideDOMContentLoaded(ancestors, content),
@@ -262,6 +287,9 @@ function addRegistrationRegexFallback(content, tagName, modulePath, isESModule,
     const insertPos = firstMatch.index;
     return content.slice(0, insertPos) + newEntry + '\n' + content.slice(insertPos);
 }
+function hasRecognizableRegistrationLoop(content) {
+    return /for\s*\(\s*(?:let|const|var)\s*\[[^)]*\]\s+of\s+(?:\[|[A-Za-z_$][\w$]*)/.test(content);
+}
 /**
  * Adds a custom element registration entry to customElements.js.
  *
@@ -303,7 +331,7 @@ export async function addCustomElementRegistration(engineDir, tagName, modulePat
     // assumption is violated the AST path errors with a confusing
     // "Could not find DOMContentLoaded block" message — fail fast here with
     // actionable guidance instead.
-    if (!/for\s*\(\s*(?:let|const|var)\s*\[/.test(content)) {
+    if (!hasRecognizableRegistrationLoop(content)) {
         throw new FurnaceError(`${CUSTOM_ELEMENTS_JS} does not contain a recognizable registration loop; refusing to mutate. ` +
             'Run "fireforge reset --force" to restore the engine, or inspect the file manually.', tagName);
     }
@@ -359,7 +387,7 @@ export async function validateCustomElementRegistration(engineDir, tagName, modu
         return;
     }
     const isESModule = modulePath.endsWith('.mjs');
-    if (!/for\s*\(\s*(?:let|const|var)\s*\[/.test(content)) {
+    if (!hasRecognizableRegistrationLoop(content)) {
         throw new FurnaceError(`${CUSTOM_ELEMENTS_JS} does not contain a recognizable registration loop; refusing to mutate. ` +
             'Run "fireforge reset --force" to restore the engine, or inspect the file manually.', tagName);
     }

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

@@ -30,3 +30,10 @@ export declare function validateTagName(tagName: string): void;
  * @param isESModule - Whether the module uses ESM (Pattern B) or not (Pattern A)
  */
 export declare function validateRegistrationPlacement(result: string, tagName: string, isESModule: boolean): void;
+/**
+ * Returns whether a tag appears in the correct customElements.js placement.
+ * ESM entries may either appear textually inside/after DOMContentLoaded or
+ * inside an array declared before DOMContentLoaded and consumed by a for-of
+ * loop inside the listener, as Firefox 152 Beta does for acornElements.
+ */
+export declare function isTagInCorrectCustomElementsPlacement(content: string, tagName: string, isESModule: boolean): boolean;

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

@@ -4,6 +4,7 @@
  * Used after both AST and legacy code paths to avoid duplicating logic.
  */
 import { FurnaceError } from '../errors/furnace.js';
+import { stripJsComments } from '../utils/regex.js';
 /**
  * Regex for valid custom element tag names. A valid name is lowercase, starts
  * with a letter, and contains one or more hyphen-separated groups where each
@@ -36,17 +37,58 @@ export function validateTagName(tagName) {
  * @param isESModule - Whether the module uses ESM (Pattern B) or not (Pattern A)
  */
 export function validateRegistrationPlacement(result, tagName, isESModule) {
-    const dclPattern = /document\.addEventListener\(\s*["']DOMContentLoaded["']/;
     const insertedPos = result.lastIndexOf(`"${tagName}"`);
     if (insertedPos === -1)
         return;
-    const contentBeforeTag = result.slice(0, insertedPos);
-    const hasDCLBefore = dclPattern.test(contentBeforeTag);
-    if (isESModule && !hasDCLBefore) {
+    if (!isTagInCorrectCustomElementsPlacement(result, tagName, isESModule)) {
+        if (!isESModule) {
+            throw new FurnaceError(`${tagName} was registered in the DOMContentLoaded/importESModule block (Pattern B) instead of the loadSubScript block (Pattern A). This will cause the component to fail at runtime. The customElements.js file structure may have changed upstream — manual intervention required.`, tagName);
+        }
         throw new FurnaceError(`${tagName} was registered in the loadSubScript block (Pattern A) instead of the DOMContentLoaded/importESModule block (Pattern B). This will cause the component to fail at runtime. The customElements.js file structure may have changed upstream — manual intervention required.`, tagName);
     }
-    if (!isESModule && hasDCLBefore) {
-        throw new FurnaceError(`${tagName} was registered in the DOMContentLoaded/importESModule block (Pattern B) instead of the loadSubScript block (Pattern A). This will cause the component to fail at runtime. The customElements.js file structure may have changed upstream — manual intervention required.`, tagName);
+}
+/**
+ * Returns whether a tag appears in the correct customElements.js placement.
+ * ESM entries may either appear textually inside/after DOMContentLoaded or
+ * inside an array declared before DOMContentLoaded and consumed by a for-of
+ * loop inside the listener, as Firefox 152 Beta does for acornElements.
+ */
+export function isTagInCorrectCustomElementsPlacement(content, tagName, isESModule) {
+    const stripped = stripJsComments(content);
+    const tagPattern = new RegExp(`["']${escapeRegex(tagName)}["']`);
+    const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(stripped);
+    if (!dclMatch) {
+        return !isESModule && tagPattern.test(stripped);
+    }
+    const beforeDcl = stripped.slice(0, dclMatch.index);
+    const afterDcl = stripped.slice(dclMatch.index);
+    const tagBeforeDcl = tagPattern.test(beforeDcl);
+    const tagAfterDcl = tagPattern.test(afterDcl);
+    if (!isESModule) {
+        return tagBeforeDcl && !tagAfterDcl;
     }
+    return (tagAfterDcl || isTagInArrayConsumedInsideDOMContentLoaded(stripped, dclMatch.index, tagName));
+}
+function isTagInArrayConsumedInsideDOMContentLoaded(content, domContentLoadedIdx, tagName) {
+    const beforeDcl = content.slice(0, domContentLoadedIdx);
+    const afterDcl = content.slice(domContentLoadedIdx);
+    const consumedArrays = new Set();
+    const forOfPattern = /for\s*\(\s*(?:let|const|var)\s*\[[^)]*\]\s+of\s+([A-Za-z_$][\w$]*)\s*\)/g;
+    let match;
+    while ((match = forOfPattern.exec(afterDcl)) !== null) {
+        if (match[1])
+            consumedArrays.add(match[1]);
+    }
+    for (const arrayName of consumedArrays) {
+        const declarationPattern = new RegExp(`(?:const|let|var)\\s+${escapeRegex(arrayName)}\\s*=\\s*\\[([\\s\\S]*?)\\];`);
+        const declaration = declarationPattern.exec(beforeDcl);
+        if (declaration?.[1] && new RegExp(`["']${escapeRegex(tagName)}["']`).test(declaration[1])) {
+            return true;
+        }
+    }
+    return false;
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 //# sourceMappingURL=furnace-registration-validate.js.map

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

@@ -9,6 +9,7 @@ import { 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 { isTagInCorrectCustomElementsPlacement } from './furnace-registration-validate.js';
 import { getTokensCssPath } from './token-manager.js';
 /**
  * Validates that all Furnace-managed .mjs components are registered in the
@@ -27,20 +28,13 @@ export async function validateRegistrationPatterns(root, config) {
         return issues;
     }
     const content = await readText(filePath);
-    // Find the DOMContentLoaded block boundary (handles multi-line addEventListener)
-    const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(content);
-    if (!dclMatch) {
-        return issues;
-    }
-    const domContentLoadedIdx = dclMatch.index;
     // Get all custom component tag names that use .mjs (all custom components do)
     for (const [name, customConfig] of Object.entries(config.custom)) {
         if (!customConfig.register)
             continue;
-        // Check if this tag is referenced before the DOMContentLoaded block
-        const contentBeforeDCL = stripJsComments(content.slice(0, domContentLoadedIdx));
-        const tagPattern = new RegExp(`"${name}"`);
-        if (tagPattern.test(contentBeforeDCL)) {
+        const stripped = stripJsComments(content);
+        const tagPattern = new RegExp(`["']${escapeRegex(name)}["']`);
+        if (tagPattern.test(stripped) && !isTagInCorrectCustomElementsPlacement(content, name, true)) {
             issues.push({
                 component: name,
                 severity: 'error',
@@ -51,6 +45,9 @@ export async function validateRegistrationPatterns(root, config) {
     }
     return issues;
 }
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 /**
  * Checks registration consistency for a single custom component.
  *
@@ -150,13 +147,7 @@ export async function checkRegistrationConsistency(root, name, config, ftlDir) {
         status.customElementsPresent =
             ceContent.includes(`"${name}"`) || ceContent.includes(`'${name}'`);
         if (status.customElementsPresent) {
-            // Check it's in the correct block (after DOMContentLoaded)
-            const dclMatch = /document\.addEventListener\(\s*["']DOMContentLoaded["']/.exec(ceContent);
-            if (dclMatch) {
-                const afterDcl = ceContent.slice(dclMatch.index);
-                status.customElementsCorrectBlock =
-                    afterDcl.includes(`"${name}"`) || afterDcl.includes(`'${name}'`);
-            }
+            status.customElementsCorrectBlock = isTagInCorrectCustomElementsPlacement(ceContent, name, true);
         }
     }
     return status;

package/dist/src/core/git.js

@@ -2,6 +2,7 @@
 import { readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 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 { verbose } from '../utils/logger.js';
@@ -105,12 +106,8 @@ async function isPathIgnored(dir, relativePath) {
  * saw. The typed error carries the environment-variable override so the
  * operator can extend the budget and re-run.
  */
-async function stageAllFilesChunked(dir, options = {}) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    const directories = entries
-        .filter((e) => e.isDirectory() && e.name !== '.git')
-        .map((e) => e.name)
-        .sort();
+async function stageAllFilesChunked(dir, scan, options = {}) {
+    const { directories, topLevelFiles: topLevelCandidates } = scan;
     async function runChunk(args, label) {
         try {
             await git(args, dir, {
@@ -126,29 +123,30 @@ async function stageAllFilesChunked(dir, options = {}) {
             throw error;
         }
     }
+    let stagedDirectories = 0;
     for (const dirName of directories) {
+        stagedDirectories++;
         if (await isPathIgnored(dir, dirName)) {
-            options.onProgress?.(`Skipping gitignored: ${dirName}/`);
+            options.onProgress?.(`Skipping gitignored directory ${stagedDirectories}/${directories.length}: ${dirName}/`);
             continue;
         }
-        options.onProgress?.(`Staging directory: ${dirName}/...`);
+        options.onProgress?.(`Staging directory ${stagedDirectories}/${directories.length}: ${dirName}/...`);
         await runChunk(['add', '--', dirName], dirName);
     }
     // Stage any top-level files (excluding gitignored ones — `git add`
     // on an explicit ignored path errors out, which would otherwise
     // abort the chunked fallback after the monolithic path has already
     // timed out).
-    const topLevelCandidates = entries.filter((e) => e.isFile()).map((e) => e.name);
     const topLevelFiles = [];
     for (const name of topLevelCandidates) {
         if (await isPathIgnored(dir, name)) {
-            options.onProgress?.(`Skipping gitignored: ${name}`);
+            options.onProgress?.(`Skipping gitignored top-level file: ${name}`);
             continue;
         }
         topLevelFiles.push(name);
     }
     if (topLevelFiles.length > 0) {
-        options.onProgress?.('Staging top-level files...');
+        options.onProgress?.(`Staging ${topLevelFiles.length} top-level file(s)...`);
         await runChunk(['add', '--', ...topLevelFiles], 'top-level files');
     }
 }
@@ -161,6 +159,20 @@ async function stageAllFilesChunked(dir, options = {}) {
  * SIGINT'd mid-way assuming the process had stalled.
  */
 const GIT_ADD_HEARTBEAT_MS = 15_000;
+const GIT_COMMIT_HEARTBEAT_MS = 15_000;
+async function scanTopLevelSource(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return {
+        directories: entries
+            .filter((entry) => entry.isDirectory() && entry.name !== '.git')
+            .map((entry) => entry.name)
+            .sort(),
+        topLevelFiles: entries
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name)
+            .sort(),
+    };
+}
 /**
  * Stages all files in the repository.
  * Tries a monolithic `git add -A` first; if that times out, falls back to
@@ -169,6 +181,9 @@ const GIT_ADD_HEARTBEAT_MS = 15_000;
 export async function stageAllFiles(dir, options = {}) {
     const timeout = options.timeout ?? GIT_ADD_TIMEOUT_MS;
     const reportProgress = options.onProgress;
+    reportProgress?.('Scanning Firefox source tree before indexing...');
+    const scan = await scanTopLevelSource(dir);
+    reportProgress?.(`Source scan complete: ${scan.directories.length} top-level director${scan.directories.length === 1 ? 'y' : 'ies'}, ${scan.topLevelFiles.length} top-level file${scan.topLevelFiles.length === 1 ? '' : 's'}`);
     // 2026-04-26 eval Finding 5: the pre-fix heartbeat used a single
     // `heartbeatStartedAt` set at function entry and reported cumulative
     // elapsed for the whole `stageAllFiles` invocation. After a
@@ -191,7 +206,9 @@ export async function stageAllFiles(dir, options = {}) {
     heartbeatTimer?.unref();
     try {
         try {
+            reportProgress?.(`Starting monolithic git add -A for ${scan.directories.length} director${scan.directories.length === 1 ? 'y' : 'ies'} and ${scan.topLevelFiles.length} top-level file${scan.topLevelFiles.length === 1 ? '' : 's'}...`);
             await git(['add', '-A'], dir, { timeout, env: GIT_ADD_ENV });
+            reportProgress?.('Monolithic git add -A completed.');
             return;
         }
         catch (error) {
@@ -215,7 +232,7 @@ export async function stageAllFiles(dir, options = {}) {
         phase = 'chunked';
         phaseStartedAt = Date.now();
         try {
-            await stageAllFilesChunked(dir, options);
+            await stageAllFilesChunked(dir, scan, options);
         }
         catch (error) {
             if (error instanceof GitIndexingTimeoutError)
@@ -228,6 +245,21 @@ export async function stageAllFiles(dir, options = {}) {
             clearInterval(heartbeatTimer);
     }
 }
+async function createInitialSourceCommit(dir, reportProgress) {
+    const startedAt = Date.now();
+    reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
+    const heartbeat = setInterval(() => {
+        reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
+    }, GIT_COMMIT_HEARTBEAT_MS);
+    heartbeat.unref();
+    try {
+        await git(['commit', '-m', 'Initial Firefox source'], dir);
+    }
+    finally {
+        clearInterval(heartbeat);
+    }
+    reportProgress(`Initial Firefox source commit created (${elapsedSince(startedAt)} elapsed).`);
+}
 /**
  * Initializes a new git repository with an orphan branch.
  * @param dir - Directory to initialize
@@ -264,9 +296,8 @@ export async function initRepository(dir, branchName = 'main', options = {}) {
         throw await maybeWrapIndexLockError(dir, error);
     }
     // Create initial commit
-    reportProgress('Creating initial Firefox source commit...');
     try {
-        await git(['commit', '-m', 'Initial Firefox source'], dir);
+        await createInitialSourceCommit(dir, reportProgress);
     }
     catch (error) {
         throw await maybeWrapIndexLockError(dir, error);
@@ -301,9 +332,8 @@ export async function resumeRepository(dir, options = {}) {
         throw await maybeWrapIndexLockError(dir, error);
     }
     // Create initial commit
-    reportProgress('Creating initial Firefox source commit...');
     try {
-        await git(['commit', '-m', 'Initial Firefox source'], dir);
+        await createInitialSourceCommit(dir, reportProgress);
     }
     catch (error) {
         throw await maybeWrapIndexLockError(dir, error);

package/dist/src/core/patch-artifact-normalize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Normalizes generated patch files for repository whitespace checks.
+ *
+ * Unified diffs conventionally encode a blank context line as a physical line
+ * containing one space. `git apply` also accepts the same hunk as an empty
+ * physical line, while repository-level `git diff --check` flags the
+ * single-space artifact as trailing whitespace in `patches/*.patch`.
+ */
+export declare function normalizePatchArtifact(content: string): string;

package/dist/src/core/patch-artifact-normalize.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Normalizes generated patch files for repository whitespace checks.
+ *
+ * Unified diffs conventionally encode a blank context line as a physical line
+ * containing one space. `git apply` also accepts the same hunk as an empty
+ * physical line, while repository-level `git diff --check` flags the
+ * single-space artifact as trailing whitespace in `patches/*.patch`.
+ */
+export function normalizePatchArtifact(content) {
+    return content.replace(/^ $/gm, '');
+}
+//# sourceMappingURL=patch-artifact-normalize.js.map

package/dist/src/core/patch-export-update.js

@@ -4,6 +4,7 @@ import { toError } from '../utils/errors.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
 import { withPatchDirectoryLock } from './patch-apply.js';
+import { normalizePatchArtifact } from './patch-artifact-normalize.js';
 import { loadPatchesManifest, savePatchesManifest } from './patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
 /**
@@ -38,7 +39,7 @@ export async function updatePatchAndMetadata(patchesDir, filename, newContent, u
         }
         let patchWritten = false;
         try {
-            await writeText(patchPath, newContent);
+            await writeText(patchPath, normalizePatchArtifact(newContent));
             patchWritten = true;
             await savePatchesManifest(patchesDir, manifest);
         }