@hominis/fireforge 0.27.0 → 0.27.2

package/CHANGELOG.md

@@ -2,11 +2,21 @@
 
 ## 0.27.0
 
+- Added first-class `firefox-devedition` source support and atomic `fireforge source set`.
+- Fixed `source set --version` so the subcommand accepts both space and equals forms without colliding with the root CLI version flag.
+- Added `sourceProduct` and `sourceVersion` patch metadata while preserving `sourceEsrVersion` as a deprecated compatibility alias.
+- Renamed source-rebase reporting away from ESR-only wording and clarified summaries with total patch counts.
+- Unified status, ownership, doctor, and verify worktree classification, including an explained patch-owned drift state for manually resolved or re-exported files.
+- Hardened build diagnostics so backend regeneration success/failure and failed make/mach commands include exit codes, tails, log hints, and verbose rerun suggestions.
 - Improved `download --force` git indexing progress with phase, count, and heartbeat output.
+- Added cache metadata progress for archive validation, SHA-256 calculation, and sidecar JSON writes.
+- Added elapsed progress for extraction, initial source commits, and rebase/re-export patch refreshes.
 - Added `re-export --files --allow-shrink` so patch ownership shrinkage is refused unless explicitly acknowledged, with clearer dry-run previews.
 - Surfaced likely new sibling files during plain re-export and aligned verify/status ownership reporting for unowned worktree changes.
 - Preserved patch-owned branding `configure.sh` settings during build preflight.
-- Added custom element registration support for Furnace validate/apply.
+- Added custom element registration support for Furnace validate/apply and Firefox 152-style array-backed ESM registrations.
+- Normalized generated patch artifacts so blank context lines do not trip raw whitespace checks.
+- Improved rebase conflict summaries and added `doctor --post-rebase-audit` for common registration surfaces.
 
 ## 0.26.0
 

package/README.md

@@ -11,12 +11,12 @@ Inspired by [fern.js](https://github.com/ghostery/user-agent-desktop) and [Melon
 ## What It Does
 
 - **Patch based** Edit Firefox inside the `engine/` directory, then export changes into `.patch` files with manifest metadata.
-- **ESR rebasing** Reapply your patches onto a newer Firefox source tree, resolve rejects and re-export the queue against the new baseline, hopefully...
+- **Source rebasing** Reapply your patches onto newer Firefox source trees, including ESR, Beta, and Developer Edition archives, resolve rejects and re-export the queue against the new baseline, hopefully...
 - **Firefox source and build helpers** Download, bootstrap, build, run, test, package, smoke-check, etc.
 - **Wiring and registration** Add chrome scripts, DOM fragments, modules, styles, tests and manifest entries through commands built by learning from existing Firefox conventions.
 - **Furnace components** Create or override `MozLitElement` widgets easily to add new or adapt existing UI components to your needs.
 - **Quality** `lint`, `typecheck`, `verify` and `doctor` catch common issues early.
-- **Tests** Fireforge was build by taking apart and applying patches of all sorts to original Firefox ESR source code across different versions, learning what works vs doesn't and creating some quite extensive tests based on that covering all manner of scenarios. Yes, we mock quite a bit, but when building a tool that modifies a separate code base, I think it's a solid compromise for the time being. Full end-to-end runs are currently run locally on my MacBook, as they require about 30 GB of disk and significant compute for multiple full builds. Full end-to-end via Actions will be added soonishlyTM but might need a different runner...
+- **Tests** Fireforge was build by taking apart and applying patches of all sorts to original Firefox source code across different versions and products, learning what works vs doesn't and creating some quite extensive tests based on that covering all manner of scenarios. Yes, we mock quite a bit, but when building a tool that modifies a separate code base, I think it's a solid compromise for the time being. Full end-to-end runs are currently run locally on my MacBook, as they require about 30 GB of disk and significant compute for multiple full builds. Full end-to-end via Actions will be added soonishlyTM but might need a different runner...
 
 ## Requirements
 
@@ -63,12 +63,12 @@ npx fireforge test browser/base/content/test/browser/
 
 Use `fireforge --help` for the full set of commands.
 
-## Rebasing Firefox
+## Rebasing Firefox Source
 
-When Mozilla publishes a new ESR you need to update the configured Firefox version, download the new source code and reapply the patches:
+When Mozilla publishes a new Firefox source release you need to update the configured version/product, download the new source code and reapply the patches:
 
 ```bash
-npx fireforge config firefox.version 145.0.0esr
+npx fireforge source set --version 145.0.0esr --product firefox-esr --sha256 <archive-sha256>
 npx fireforge download --force
 npx fireforge rebase
 ```
@@ -95,7 +95,7 @@ Use `fireforge furnace --help` for the full set of component commands.
 - **Docker builds** Reproducible builds using Docker containers.
 - **CI mode** Automated setup for continuous integration pipelines.
 - **Update manifests** Generate update server manifests for auto-updates.
-- **Nightly support** Requires implementing `hg clone` support via mozilla-central. Currently fireforge only downloads from the archive.
+- **Nightly source support** Requires implementing `hg clone` support via mozilla-central. ESR, Beta, and Developer Edition source archives are supported through `fireforge source set`.
 - **E2E Github Actions** Requires either a higher tier of Githubs offering, an external VPS or another provider entirely. In any case, full end-to-end testing is currently run solely locally.
 
 ## Licence

package/dist/src/cli.js

@@ -154,6 +154,7 @@ function buildGroupedHelpFormatter(manifest) {
             const desc = helper.optionDescription(opt);
             return formatHelpLine(term, desc, termWidth, helpWidth);
         });
+        optionLines.unshift(formatHelpLine('-V, --version', 'output the version number', termWidth, helpWidth));
         if (optionLines.length > 0) {
             output.push('Options:');
             output.push(...optionLines);
@@ -234,7 +235,6 @@ export function createProgram() {
     program
         .name('fireforge')
         .description('A build tool for customizing Firefox')
-        .version(getPackageVersion())
         .option('-v, --verbose', 'Enable debug output')
         .hook('preAction', (thisCommand) => {
         const opts = thisCommand.opts();
@@ -256,6 +256,10 @@ export function createProgram() {
  * Main CLI entry point.
  */
 export async function main() {
+    if (process.argv.length === 3 && (process.argv[2] === '--version' || process.argv[2] === '-V')) {
+        process.stdout.write(`${getPackageVersion()}\n`);
+        return;
+    }
     const program = createProgram();
     await program.parseAsync(process.argv);
 }

package/dist/src/commands/build.js

@@ -69,6 +69,65 @@ function resolveJobCount(options, configJobs) {
     }
     return jobs;
 }
+function tailLines(text, maxLines) {
+    const lines = text
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length > 0);
+    return lines.slice(-maxLines).join('\n');
+}
+function extractLastMakeError(captured) {
+    const lines = captured.split(/\r?\n/).filter((line) => /\bmake(?:\[\d+\])?: \*\*\*/.test(line));
+    return lines.at(-1)?.trim();
+}
+function extractLikelyFailingCommand(captured) {
+    const lines = captured
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    for (let index = lines.length - 1; index >= 0; index--) {
+        const line = lines[index];
+        if (!line)
+            continue;
+        if (/^make(?:\[\d+\])?:/.test(line))
+            continue;
+        if (/^g?make(?:\[\d+\])?:/.test(line))
+            continue;
+        if (/^Error running mach:/.test(line))
+            continue;
+        if (/^\d+:\d+\.\d+\s+/.test(line))
+            continue;
+        if (/\b(?:cp|clang|clang\+\+|rustc|python|node|make|install_name_tool)\b/.test(line)) {
+            return line;
+        }
+    }
+    return undefined;
+}
+function buildFailureDiagnostics(result, engineDir, objDir, machCommand) {
+    const captured = `${result.stderr}\n${result.stdout}`;
+    const stderrTail = tailLines(result.stderr, 20);
+    const combinedTail = tailLines(captured, 30);
+    const makeError = extractLastMakeError(captured);
+    const failingCommand = extractLikelyFailingCommand(captured);
+    const logHint = objDir
+        ? `engine/${objDir}/ (inspect build logs, warnings, and generated make targets under this objdir)`
+        : 'engine/obj-* (inspect the active objdir for build logs, warnings, and generated make targets)';
+    const verboseRerun = objDir
+        ? `cd ${engineDir} && ./mach build -v; if a make target is named above, retry it with: make -C ${objDir} <target> V=1`
+        : `cd ${engineDir} && ./mach build -v`;
+    return [
+        `Build failed with exit code ${result.exitCode}.`,
+        `Mach phase: ${machCommand}`,
+        makeError ? `Last make error: ${makeError}` : undefined,
+        failingCommand ? `Final failing command/error line: ${failingCommand}` : undefined,
+        stderrTail ? `Captured stderr tail:\n${stderrTail}` : undefined,
+        `Captured output tail:\n${combinedTail}`,
+        `Logs/profile/warnings: ${logHint}`,
+        `Verbose rerun: ${verboseRerun}`,
+    ]
+        .filter((part) => part !== undefined && part.length > 0)
+        .join('\n\n');
+}
 /**
  * Runs the build command.
  * @param projectRoot - Root directory of the project
@@ -172,7 +231,8 @@ export async function buildCommand(projectRoot, options) {
     const timeStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
     if (result.exitCode !== 0) {
         error(`Build failed after ${timeStr}`);
-        throw new BuildError(`Build failed with exit code ${result.exitCode}`, options.ui ? 'mach build faster' : 'mach build');
+        const machCommand = options.ui ? 'mach build faster' : 'mach build';
+        throw new BuildError(buildFailureDiagnostics(result, paths.engine, buildCheck.objDir, machCommand), machCommand);
     }
     // Tool-managed branding edits that land on `browser/moz.configure`
     // before the build cause mach's post-build guard to print one of two

package/dist/src/commands/doctor/post-rebase-audit.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorCheckDefinition } from '../doctor-check-core.js';
+export declare const POST_REBASE_AUDIT_CHECK: DoctorCheckDefinition;

package/dist/src/commands/doctor/post-rebase-audit.js

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathExists, readText } from '../../utils/fs.js';
+import { ok, warning } from '../doctor-check-core.js';
+async function readEngineText(engineDir, relativePath) {
+    const fullPath = join(engineDir, relativePath);
+    if (!(await pathExists(fullPath)))
+        return null;
+    return readText(fullPath);
+}
+async function collectBrowserTomlFiles(root) {
+    const testRoot = join(root, 'browser/base/content/test');
+    if (!(await pathExists(testRoot)))
+        return [];
+    const result = [];
+    async function walk(absDir, relDir) {
+        let entries;
+        try {
+            entries = await readdir(absDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
+            const absPath = join(absDir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(absPath, relPath);
+            }
+            else if (entry.isFile() && entry.name === 'browser.toml') {
+                result.push(`browser/base/content/test/${relPath}`);
+            }
+        }
+    }
+    await walk(testRoot, '');
+    return result.sort();
+}
+async function runPostRebaseAudit(ctx) {
+    const issues = [];
+    const engineDir = ctx.paths.engine;
+    const mozConfigure = await readEngineText(engineDir, 'browser/moz.configure');
+    if (mozConfigure === null) {
+        issues.push('browser/moz.configure is missing');
+    }
+    else if (!mozConfigure.includes('BROWSER_CHROME_URL')) {
+        issues.push('browser/moz.configure does not mention BROWSER_CHROME_URL');
+    }
+    const browserJar = await readEngineText(engineDir, 'browser/base/jar.mn');
+    if (browserJar === null) {
+        issues.push('browser/base/jar.mn is missing');
+    }
+    else if (!/\.xhtml\b/.test(browserJar)) {
+        issues.push('browser/base/jar.mn has no chrome document .xhtml entries');
+    }
+    const customElements = await readEngineText(engineDir, 'toolkit/content/customElements.js');
+    if (customElements === null) {
+        issues.push('toolkit/content/customElements.js is missing');
+    }
+    else if (!customElements.includes('customElements')) {
+        issues.push('toolkit/content/customElements.js does not contain customElements registrations');
+    }
+    const toolkitJar = await readEngineText(engineDir, 'toolkit/content/jar.mn');
+    if (toolkitJar === null) {
+        issues.push('toolkit/content/jar.mn is missing');
+    }
+    else if (!toolkitJar.includes('content/global/widgets/') &&
+        !toolkitJar.includes('content/global/elements/')) {
+        issues.push('toolkit/content/jar.mn has no widget/element exposure entries');
+    }
+    const browserTomls = await collectBrowserTomlFiles(engineDir);
+    if (browserTomls.length === 0) {
+        issues.push('no browser.toml files found under browser/base/content/test');
+    }
+    if (issues.length === 0) {
+        return ok('Post-rebase registration audit');
+    }
+    return warning('Post-rebase registration audit', `${issues.length} suspicious registration surface${issues.length === 1 ? '' : 's'}: ${issues.join('; ')}.`, 'Inspect the named engine paths, refresh any drifted registration patches, then re-run "fireforge doctor --post-rebase-audit".');
+}
+export const POST_REBASE_AUDIT_CHECK = {
+    name: 'Post-rebase registration audit',
+    skipIf: (ctx) => !ctx.options.postRebaseAudit || !ctx.engineExists,
+    dependsOn: ['fireforge.json is valid'],
+    run: runPostRebaseAudit,
+};
+//# sourceMappingURL=post-rebase-audit.js.map

package/dist/src/commands/doctor-working-tree.js

@@ -20,6 +20,7 @@ function summarizeWorkingTreeChangeCount(changeCount) {
 function formatManagedDetail(counts) {
     return [
         counts.patchBacked > 0 ? `${counts.patchBacked} patch-backed` : null,
+        counts.patchOwnedDrift > 0 ? `${counts.patchOwnedDrift} patch-owned drift` : null,
         counts.branding > 0 ? `${counts.branding} branding` : null,
         counts.furnace > 0 ? `${counts.furnace} furnace` : null,
     ]
@@ -57,6 +58,7 @@ export async function inspectEngineWorkingTree(ctx) {
         branding: 0,
         furnace: 0,
         patchBacked: 0,
+        patchOwnedDrift: 0,
         conflict: 0,
         unmanaged: 0,
     };
@@ -67,6 +69,8 @@ export async function inspectEngineWorkingTree(ctx) {
             counts.furnace++;
         else if (entry.classification === 'patch-backed')
             counts.patchBacked++;
+        else if (entry.classification === 'patch-owned-drift')
+            counts.patchOwnedDrift++;
         else if (entry.classification === 'conflict')
             counts.conflict++;
         else
@@ -75,7 +79,7 @@ export async function inspectEngineWorkingTree(ctx) {
     if (counts.conflict > 0) {
         return warning('Engine working tree', `Engine working tree has ${counts.conflict} cross-patch ownership conflict${counts.conflict === 1 ? '' : 's'}. Multiple patches in patches.json claim the same file.`, 'Run "fireforge status --ownership" to see the conflicting patches, then run "fireforge verify" and resolve the overlap.');
     }
-    const managedTotal = counts.branding + counts.furnace + counts.patchBacked;
+    const managedTotal = counts.branding + counts.furnace + counts.patchBacked + counts.patchOwnedDrift;
     if (counts.unmanaged === 0) {
         const managedDetail = formatManagedDetail(counts);
         return {

package/dist/src/commands/doctor.js

@@ -10,6 +10,7 @@ import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { error, info, intro, outro, success, warn } from '../utils/logger.js';
 import { findExecutable } from '../utils/process.js';
+import { POST_REBASE_AUDIT_CHECK } from './doctor/post-rebase-audit.js';
 import { failure, ok, warning } from './doctor-check-core.js';
 import { FURNACE_DOCTOR_CHECKS } from './doctor-furnace.js';
 import { inspectEngineWorkingTree } from './doctor-working-tree.js';
@@ -358,6 +359,7 @@ const DOCTOR_CHECKS = [
         },
         fix: 'Re-export affected files with "fireforge export <paths...>" to create full-file patches',
     },
+    POST_REBASE_AUDIT_CHECK,
     // Furnace checks live in a sibling module so this file stays under the
     // max-lines threshold. Splicing them in as an array preserves the
     // declarative registry contract — each entry remains a single
@@ -466,6 +468,7 @@ export function registerDoctor(program, { getProjectRoot, withErrorHandling }) {
         .option('--repair-patches-manifest', 'Rebuild patches/patches.json from the current patch files before reporting results')
         .option('--repair-furnace', 'Reconcile furnace state: clear stale furnace-state.json entries, re-run furnace apply to fix engine drift, and clear the pending-repair marker set by a failed preview teardown')
         .option('--clear-resolution', 'Clear stale pendingResolution state after the patch queue health check reports no errors')
+        .option('--post-rebase-audit', 'Check common registration surfaces after a Firefox source rebase')
         .action(withErrorHandling(async (options) => {
         const result = await doctorCommand(getProjectRoot(), options);
         if (result.exitCode !== 0) {

package/dist/src/commands/download.js

@@ -111,6 +111,38 @@ function closeRestoreSpinner(restoreSpinner, result) {
     }
     restoreSpinner.stop('Patch-touched files restored');
 }
+async function downloadAndExtractFirefox(args) {
+    const { version, product, engineDir, cacheDir, sha256 } = args;
+    let s = spinner(`Downloading Firefox ${version}...`);
+    let lastPercent = 0;
+    const phaseState = { value: 'download' };
+    try {
+        await downloadFirefoxSource(version, product, engineDir, cacheDir, (downloaded, total) => {
+            if (total <= 0)
+                return;
+            const percent = Math.floor((downloaded / total) * 100);
+            if (percent !== lastPercent && percent % 5 === 0) {
+                s.message(`Downloading Firefox ${version}... ${percent}% (${formatBytes(downloaded)} / ${formatBytes(total)})`);
+                lastPercent = percent;
+            }
+        }, (phase) => {
+            if (phase === 'extract' && phaseState.value === 'download') {
+                s.stop(`Firefox ${version} downloaded`);
+                phaseState.value = 'extract';
+                s = spinner(`Extracting Firefox ${version}... (decompressing ~600 MB of source; typically 30–90s)`);
+            }
+        }, sha256, (message) => {
+            s.message(message);
+        });
+        s.stop(phaseState.value === 'extract'
+            ? `Firefox ${version} extracted`
+            : `Firefox ${version} downloaded`);
+    }
+    catch (error) {
+        s.error(phaseState.value === 'extract' ? 'Extraction failed' : 'Download failed');
+        throw error;
+    }
+}
 /**
  * Runs the download command.
  * @param projectRoot - Root directory of the project
@@ -118,12 +150,9 @@ function closeRestoreSpinner(restoreSpinner, result) {
  */
 export async function downloadCommand(projectRoot, options) {
     intro('FireForge Download');
-    // Load configuration
-    const config = await loadConfig(projectRoot);
+    const config = await loadConfig(projectRoot), version = config.firefox.version;
     const paths = getProjectPaths(projectRoot);
-    const version = config.firefox.version;
     info(`Firefox version: ${version}`);
-    // Disk space pre-flight: Firefox source is ~5 GB
     await checkDiskSpace(projectRoot, 5 * 1024 * 1024 * 1024, warn);
     await withFileLock(join(paths.fireforgeDir, 'download.fireforge.lock'), async () => {
         // Check if engine already exists
@@ -224,43 +253,13 @@ export async function downloadCommand(projectRoot, options) {
         // Ensure cache directory exists
         const cacheDir = join(paths.fireforgeDir, 'cache');
         await ensureDir(cacheDir);
-        // Phase-switched spinners: the download phase runs with the byte-count
-        // progress callbacks below; the extract phase is blocking tar-xz and
-        // has no incremental progress, but it can take 30–90s on a ~600 MB
-        // Firefox tree, so it gets its own spinner message. Before the phase
-        // split, a single "Downloading Firefox … 100%" spinner covered both
-        // — the first-run setup looked hung precisely when the archive had
-        // already reached disk and `tar` was the long pole.
-        let s = spinner(`Downloading Firefox ${version}...`);
-        let lastPercent = 0;
-        const phaseState = { value: 'download' };
-        try {
-            await downloadFirefoxSource(version, config.firefox.product, paths.engine, cacheDir, (downloaded, total) => {
-                if (total <= 0)
-                    return;
-                const percent = Math.floor((downloaded / total) * 100);
-                if (percent !== lastPercent && percent % 5 === 0) {
-                    s.message(`Downloading Firefox ${version}... ${percent}% (${formatBytes(downloaded)} / ${formatBytes(total)})`);
-                    lastPercent = percent;
-                }
-            }, (phase) => {
-                if (phase === 'extract' && phaseState.value === 'download') {
-                    s.stop(`Firefox ${version} downloaded`);
-                    phaseState.value = 'extract';
-                    s = spinner(`Extracting Firefox ${version}... (decompressing ~600 MB of source; typically 30–90s)`);
-                }
-            }, config.firefox.sha256);
-            if (phaseState.value === 'extract') {
-                s.stop(`Firefox ${version} extracted`);
-            }
-            else {
-                s.stop(`Firefox ${version} downloaded`);
-            }
-        }
-        catch (error) {
-            s.error(phaseState.value === 'extract' ? 'Extraction failed' : 'Download failed');
-            throw error;
-        }
+        await downloadAndExtractFirefox({
+            version,
+            product: config.firefox.product,
+            engineDir: paths.engine,
+            cacheDir,
+            ...(config.firefox.sha256 !== undefined ? { sha256: config.firefox.sha256 } : {}),
+        });
         // Finding #17: the git indexing phase of `download` can block for
         // minutes on a ~600 MB Firefox tree — the spinner updates less often
         // than operators expect during the monolithic `git add -A` pass, and
@@ -270,7 +269,7 @@ export async function downloadCommand(projectRoot, options) {
         // still fire as usual; this is an additional up-front signal, not a
         // replacement.
         info('Indexing downloaded source into git (one-time; typically 3–5 minutes on a ~600 MB Firefox tree)...');
-        // Initialize git repository
+        info('Git phase: initializing/resetting source repository metadata.');
         const gitSpinner = spinner('Initializing git repository (this may take a few minutes)...');
         let baseCommit;
         try {

package/dist/src/commands/export-all.js

@@ -8,6 +8,7 @@ import { extractAffectedFiles } from '../core/patch-apply.js';
 import { commitExportedPatch, findAllPatchesForFiles } from '../core/patch-export.js';
 import { buildPatchQueueContext, collectNewFileCreatorsByPath, detectNewFilesInDiff, } from '../core/patch-lint.js';
 import { collectPatchRegistrationReferences } from '../core/patch-registration-refs.js';
+import { buildPatchSourceMetadata } from '../core/patch-source-metadata.js';
 import { GeneralError } from '../errors/base.js';
 import { ensureDir, pathExists } from '../utils/fs.js';
 import { info, intro, outro, spinner } from '../utils/logger.js';
@@ -262,7 +263,7 @@ export async function exportAllCommand(projectRoot, options = {}) {
                 name: patchName,
                 description,
                 filesAffected,
-                sourceEsrVersion: config.firefox.version,
+                ...buildPatchSourceMetadata(config.firefox),
                 explicitSupersede: options.supersede === true,
                 allowOverlap: options.allowOverlap === true,
                 config,
@@ -299,7 +300,7 @@ export async function exportAllCommand(projectRoot, options = {}) {
             description,
             diff,
             filesAffected,
-            sourceEsrVersion: config.firefox.version,
+            ...buildPatchSourceMetadata(config.firefox),
             config,
             policyCommand: 'export-all',
             forceUnsafe: options.forceUnsafe === true,

package/dist/src/commands/export-flow.d.ts

@@ -93,6 +93,8 @@ export interface DryRunPreviewInput {
     description: string;
     filesAffected: string[];
     sourceEsrVersion: string;
+    sourceProduct?: FireForgeConfig['firefox']['product'];
+    sourceVersion?: string;
     explicitSupersede: boolean;
     allowOverlap: boolean;
     /** Optional `PatchMetadata.tier` opt-in carried from the CLI. */

package/dist/src/commands/export-flow.js

@@ -354,6 +354,8 @@ export async function renderDryRunPreview(input) {
         description: input.description,
         filesAffected: input.filesAffected,
         sourceEsrVersion: input.sourceEsrVersion,
+        ...(input.sourceProduct !== undefined ? { sourceProduct: input.sourceProduct } : {}),
+        ...(input.sourceVersion !== undefined ? { sourceVersion: input.sourceVersion } : {}),
         ...(input.tier !== undefined ? { tier: input.tier } : {}),
         ...(input.lintIgnore !== undefined ? { lintIgnore: input.lintIgnore } : {}),
         ...(input.config !== undefined ? { config: input.config } : {}),

package/dist/src/commands/export.js

@@ -13,6 +13,7 @@ import { extractAffectedFiles } from '../core/patch-apply.js';
 import { commitExportedPatch, findAllPatchesForFiles } from '../core/patch-export.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { applyRenameMapToManifest, buildProjectedManifest, enforcePatchPolicy, } from '../core/patch-policy.js';
+import { buildPatchSourceMetadata } from '../core/patch-source-metadata.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { ensureDir, pathExists } from '../utils/fs.js';
@@ -211,7 +212,7 @@ export async function exportCommand(projectRoot, files, options) {
                         name: patchName,
                         description,
                         createdAt: new Date().toISOString(),
-                        sourceEsrVersion: config.firefox.version,
+                        ...buildPatchSourceMetadata(config.firefox),
                         filesAffected,
                         ...(options.tier !== undefined ? { tier: options.tier } : {}),
                         ...(options.lintIgnore !== undefined && options.lintIgnore.length > 0
@@ -263,7 +264,7 @@ export async function exportCommand(projectRoot, files, options) {
                 name: patchName,
                 description,
                 filesAffected,
-                sourceEsrVersion: config.firefox.version,
+                ...buildPatchSourceMetadata(config.firefox),
                 explicitSupersede: options.supersede === true,
                 allowOverlap: options.allowOverlap === true,
                 ...(options.tier !== undefined ? { tier: options.tier } : {}),
@@ -288,7 +289,7 @@ export async function exportCommand(projectRoot, files, options) {
                 name: patchName,
                 description,
                 createdAt: new Date().toISOString(),
-                sourceEsrVersion: config.firefox.version,
+                ...buildPatchSourceMetadata(config.firefox),
                 filesAffected,
                 ...(options.tier !== undefined ? { tier: options.tier } : {}),
                 ...(options.lintIgnore !== undefined && options.lintIgnore.length > 0
@@ -366,7 +367,7 @@ export async function exportCommand(projectRoot, files, options) {
             description,
             diff,
             filesAffected,
-            sourceEsrVersion: config.firefox.version,
+            ...buildPatchSourceMetadata(config.firefox),
             ...(options.tier !== undefined ? { tier: options.tier } : {}),
             ...(options.lintIgnore !== undefined && options.lintIgnore.length > 0
                 ? { lintIgnore: options.lintIgnore }

package/dist/src/commands/import.js

@@ -6,6 +6,7 @@ import { getHead } from '../core/git.js';
 import { getDirtyFiles } from '../core/git-status.js';
 import { applyPatchesWithContinue, computePatchedContent, countPatches, discoverPatches, extractAffectedFiles, PatchError, } from '../core/patch-apply.js';
 import { checkVersionCompatibility, loadPatchesManifest, validatePatchesManifestConsistency, validatePatchIntegrity, } from '../core/patch-manifest.js';
+import { getPatchSourceVersion } from '../core/patch-source-metadata.js';
 import { GeneralError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText } from '../utils/fs.js';
@@ -269,7 +270,7 @@ export async function importCommand(projectRoot, options = {}) {
             // doesn't need to see version warnings for patches outside the range.
             if (options.until !== undefined && !untilFilenameSet.has(patch.filename))
                 continue;
-            const warning = checkVersionCompatibility(patch.sourceEsrVersion, currentVersion);
+            const warning = checkVersionCompatibility(getPatchSourceVersion(patch), currentVersion);
             if (warning) {
                 warn(`${patch.filename}: ${warning}`);
             }

package/dist/src/commands/manifest.js

@@ -18,6 +18,7 @@ import { registerReset } from './reset.js';
 import { registerResolve } from './resolve.js';
 import { registerRun } from './run.js';
 import { registerSetup } from './setup.js';
+import { registerSource } from './source.js';
 import { registerStatus } from './status.js';
 import { registerTest } from './test.js';
 import { registerToken } from './token.js';
@@ -31,6 +32,7 @@ import { registerWire } from './wire.js';
  */
 export const COMMAND_MANIFEST = [
     { name: 'setup', group: 'project', register: registerSetup },
+    { name: 'source', group: 'project', register: registerSource },
     { name: 'download', group: 'engine', register: registerDownload },
     { name: 'bootstrap', group: 'engine', register: registerBootstrap },
     { name: 'import', group: 'workflow', register: registerImport },

package/dist/src/commands/re-export.js

@@ -10,6 +10,7 @@ import { updatePatchAndMetadata } from '../core/patch-export.js';
 import { getClaimedFiles, loadPatchesManifest, resolvePatchIdentifier, stampPatchVersions, } from '../core/patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { elapsedSince } from '../utils/elapsed.js';
 import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { cancel, info, intro, isCancel, outro, spinner, success, warn } from '../utils/logger.js';
@@ -341,8 +342,9 @@ export async function reExportCommand(projectRoot, patches, options) {
     let reExported = 0;
     const reExportedFilenames = [];
     const progress = spinner('Preparing re-export...');
-    for (const patch of selectedPatches) {
-        progress.message(`Re-exporting ${patch.filename}...`);
+    const startedAt = Date.now();
+    for (const [index, patch] of selectedPatches.entries()) {
+        progress.message(`Re-exporting ${index + 1}/${selectedPatches.length}: ${patch.filename} (${patch.filesAffected.length} file(s), ${elapsedSince(startedAt)} elapsed)...`);
         try {
             const exported = await reExportSinglePatch(patch, paths, manifest, options, isDryRun, config);
             if (exported) {
@@ -368,13 +370,13 @@ export async function reExportCommand(projectRoot, patches, options) {
     // which we refuse to version-stamp through.
     const shouldStamp = options.stamp === true && !isDryRun && reExported > 0 && reExported === selectedPatches.length;
     if (shouldStamp) {
-        await stampPatchVersions(paths.patches, reExportedFilenames, config.firefox.version);
+        await stampPatchVersions(paths.patches, reExportedFilenames, config.firefox.version, config.firefox.product);
     }
     if (isDryRun) {
         progress.stop('Dry run complete');
         success(`[dry-run] Would re-export ${reExported} of ${selectedPatches.length} patch(es)`);
         if (options.stamp === true) {
-            info(`[dry-run] Would stamp sourceEsrVersion=${config.firefox.version} on ${reExported} patch(es)`);
+            info(`[dry-run] Would stamp sourceVersion=${config.firefox.version} (${config.firefox.product}) on ${reExported} patch(es)`);
         }
         outro('Dry run complete');
     }
@@ -382,7 +384,7 @@ export async function reExportCommand(projectRoot, patches, options) {
         progress.stop('Re-export complete');
         success(`Re-exported ${reExported} of ${selectedPatches.length} patch(es)`);
         if (shouldStamp) {
-            success(`Stamped sourceEsrVersion=${config.firefox.version} on ${reExportedFilenames.length} patch(es)`);
+            success(`Stamped sourceVersion=${config.firefox.version} (${config.firefox.product}) on ${reExportedFilenames.length} patch(es)`);
         }
         else if (options.stamp === true && reExported !== selectedPatches.length) {
             warn('--stamp was requested but some patches failed or were skipped; refusing to stamp a partial set.');
@@ -395,8 +397,8 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
     program
         .command('re-export [patches...]')
         .description('Refresh existing patch bodies (and filesAffected with --scan) from the current engine ' +
-        'state. Does NOT change sourceEsrVersion by default — use --stamp or run rebase for ' +
-        'version stamping.')
+        'state. Does NOT change sourceVersion/sourceProduct by default — use --stamp or run ' +
+        'rebase for source metadata stamping.')
         .option('-a, --all', 'Re-export all patches')
         .option('-s, --scan', 'Scan directories for new/removed files and update filesAffected')
         .option('--scan-file <path>', 'With --scan, add this explicit engine-relative file to one target patch without collecting adjacent files. Repeatable.', (value, prev) => [...prev, value], [])
@@ -409,7 +411,7 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
         .option('--allow-shrink', 'Allow --files to remove paths currently owned by the patch. Required before --yes can bypass the shrink confirmation.')
         .option('-y, --yes', 'Skip confirmation prompts (required for non-TTY destructive writes)')
         .option('--force-unsafe', 'Bypass cross-patch lint refusal when --files shrinks a patch')
-        .option('--stamp', "After every selected patch refreshes cleanly, stamp each re-exported patch's sourceEsrVersion in patches.json to firefox.version from fireforge.json. No effect on a partial run.")
+        .option('--stamp', "After every selected patch refreshes cleanly, stamp each re-exported patch's sourceVersion/sourceProduct in patches.json to firefox.version/firefox.product from fireforge.json. No effect on a partial run.")
         .addOption(new Option('--tier <tier>', 'Force a tier override on the selected patch (only "branding" recognised). Mutually exclusive with --all.').choices(['branding']))
         .option('--lint-ignore <check-id>', 'Append a lint check ID to the patch\'s PatchMetadata.lintIgnore (union, de-duped, repeatable). Mutually exclusive with --all. Use "fireforge patch lint-ignore" for --remove / --clear.', (value, prev) => [...prev, value], [])
         .action(withErrorHandling(async (patches, options) => {

package/dist/src/commands/rebase/conflict-summary.d.ts

@@ -0,0 +1,12 @@
+export interface RebaseConflictSummary {
+    patchFilename: string;
+    failedFiles: string[];
+    category: string;
+    nextCommands: string[];
+}
+/** Builds a concise operator-facing summary for a failed rebase patch. */
+export declare function buildRebaseConflictSummary(args: {
+    patchFilename: string;
+    error?: string;
+    rejectFiles?: string[];
+}): RebaseConflictSummary;