@hominis/fireforge 0.27.1 → 0.27.2

package/CHANGELOG.md

@@ -3,7 +3,13 @@
 ## 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.

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,9 +63,9 @@ 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 source set --version 145.0.0esr --product firefox-esr --sha256 <archive-sha256>
@@ -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-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/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,46 +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, (message) => {
-                if (phaseState.value === 'extract')
-                    s.message(message);
-            });
-            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
@@ -273,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/re-export.js

@@ -370,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');
     }
@@ -384,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.');
@@ -397,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], [])
@@ -411,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/continue.js

@@ -73,6 +73,8 @@ export async function handleContinue(projectRoot, maxFuzz) {
         // v0.14.0 resolve.ts fix.
         await updatePatchAndMetadata(paths.patches, currentPatch.filename, diffContent, {
             sourceEsrVersion: session.toVersion,
+            sourceVersion: session.toVersion,
+            ...(session.toProduct !== undefined ? { sourceProduct: session.toProduct } : {}),
         });
     }
     finally {

package/dist/src/commands/rebase/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * `fireforge rebase` — semi-automated ESR version upgrade.
+ * `fireforge rebase` — semi-automated Firefox source version upgrade.
  *
  * Orchestrates the full patch-rebase workflow:
  *   1. Reset engine to baseline
@@ -13,7 +13,7 @@ import { Command } from 'commander';
 import type { CommandContext } from '../../types/cli.js';
 import type { RebaseOptions } from '../../types/commands/index.js';
 /**
- * Runs the rebase command to orchestrate an ESR version upgrade.
+ * Runs the rebase command to orchestrate a Firefox source version upgrade.
  * @param projectRoot - Root directory of the project
  * @param options - Rebase options
  */

package/dist/src/commands/rebase/index.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * `fireforge rebase` — semi-automated ESR version upgrade.
+ * `fireforge rebase` — semi-automated Firefox source version upgrade.
  *
  * Orchestrates the full patch-rebase workflow:
  *   1. Reset engine to baseline
@@ -15,6 +15,7 @@ import { getFurnacePaths, updateFurnaceState } from '../../core/furnace-config.j
 import { getHead, isGitRepository, isMissingHeadError, resetChanges } from '../../core/git.js';
 import { discoverPatches } from '../../core/patch-files.js';
 import { loadPatchesManifest } from '../../core/patch-manifest.js';
+import { getPatchSourceProduct, getPatchSourceVersion } from '../../core/patch-source-metadata.js';
 import { hasActiveRebaseSession, saveRebaseSession } from '../../core/rebase-session.js';
 import { GeneralError } from '../../errors/base.js';
 import { RebaseSessionExistsError } from '../../errors/rebase.js';
@@ -65,9 +66,11 @@ async function handleFreshStart(projectRoot, options) {
         throw new GeneralError('No patches found in manifest. Nothing to rebase.');
     }
     // Determine the "from" version from the patches
-    const patchVersions = new Set(manifest.patches.map((p) => p.sourceEsrVersion));
+    const patchVersions = new Set(manifest.patches.map((p) => getPatchSourceVersion(p)));
+    const patchProducts = new Set(manifest.patches.map((p) => getPatchSourceProduct(p)).filter(Boolean));
     const sortedVersions = [...patchVersions].sort();
     const fromVersion = sortedVersions[0] ?? currentVersion;
+    const fromProduct = [...patchProducts].sort()[0] ?? config.firefox.product;
     if (patchVersions.size === 1 && fromVersion === currentVersion) {
         info('All patches already match the current Firefox version. Nothing to rebase.');
         outro('Rebase not needed');
@@ -110,6 +113,8 @@ async function handleFreshStart(projectRoot, options) {
     const allPatches = await discoverPatches(paths.patches);
     const session = {
         startedAt: new Date().toISOString(),
+        fromProduct,
+        toProduct: config.firefox.product,
         fromVersion,
         toVersion: currentVersion,
         preRebaseCommit,
@@ -125,7 +130,7 @@ async function handleFreshStart(projectRoot, options) {
 }
 // ── Public API ──
 /**
- * Runs the rebase command to orchestrate an ESR version upgrade.
+ * Runs the rebase command to orchestrate a Firefox source version upgrade.
  * @param projectRoot - Root directory of the project
  * @param options - Rebase options
  */
@@ -142,7 +147,7 @@ export async function rebaseCommand(projectRoot, options = {}) {
 export function registerRebase(program, { getProjectRoot, withErrorHandling }) {
     program
         .command('rebase')
-        .description('Semi-automated ESR version upgrade — apply patches with fuzz and re-export')
+        .description('Semi-automated Firefox source version upgrade — apply patches with fuzz and re-export')
         .option('--continue', 'Resume after manually resolving a failed patch')
         .option('--abort', 'Cancel the rebase and restore engine to pre-rebase state')
         .option('--dry-run', 'Show what would happen without modifying anything')

package/dist/src/commands/rebase/patch-loop.js

@@ -143,16 +143,16 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
         .filter((p) => p.status === 'applied-clean' || p.status === 'applied-fuzz' || p.status === 'resolved')
         .map((p) => p.filename);
     if (appliedFilenames.length > 0) {
-        await stampPatchVersions(paths.patches, appliedFilenames, session.toVersion);
+        await stampPatchVersions(paths.patches, appliedFilenames, session.toVersion, session.toProduct);
     }
     // Stamp every Furnace override's `baseVersion` to match the rebased
-    // Firefox version. Before this stamp, a successful ESR bump left
+    // Firefox source version. Before this stamp, a successful source bump left
     // overrides in a doctor-failing drift state (each override still
-    // claimed the pre-rebase ESR as its baseline) and every subsequent
+    // claimed the pre-rebase source as its baseline) and every subsequent
     // `fireforge doctor` failed `Furnace component validation`. The
     // stamp is unconditional per the helper's contract: rebase already
     // succeeded on the patch side, so the operator is committing to the
-    // new ESR baseline; per-component health checking stays with
+    // new source baseline; per-component health checking stays with
     // `fireforge furnace validate` / `doctor --repair-furnace`.
     try {
         const overridesStamped = await stampFurnaceOverrideBaseVersions(projectRoot, session.toVersion);
@@ -176,7 +176,7 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
         return next;
     });
     info('');
-    success(`All patches re-exported with sourceEsrVersion=${session.toVersion}`);
+    success(`All patches re-exported with sourceVersion=${session.toVersion}`);
     outro('Rebase complete!');
 }
 async function reExportAppliedPatches(session, paths) {

package/dist/src/commands/rebase/summary.js

@@ -27,7 +27,11 @@ export function statusLabel(status, fuzzFactor) {
  */
 export function printSummary(session) {
     info('');
-    info(`ESR Rebase Summary: ${session.fromVersion} → ${session.toVersion}`);
+    const from = session.fromProduct
+        ? `${session.fromProduct} ${session.fromVersion}`
+        : session.fromVersion;
+    const to = session.toProduct ? `${session.toProduct} ${session.toVersion}` : session.toVersion;
+    info(`Source Rebase Summary: ${from} → ${to}`);
     info('='.repeat(55));
     for (const patch of session.patches) {
         const label = statusLabel(patch.status, patch.fuzzFactor);
@@ -37,7 +41,8 @@ export function printSummary(session) {
     const fuzz = session.patches.filter((p) => p.status === 'applied-fuzz').length;
     const resolved = session.patches.filter((p) => p.status === 'resolved').length;
     const failed = session.patches.filter((p) => p.status === 'failed').length;
+    const total = session.patches.length;
     info('');
-    info(`Results: ${clean} clean, ${fuzz} fuzz-applied, ${resolved} manually resolved, ${failed} failed`);
+    info(`Results: ${total} total: ${clean} clean, ${fuzz} fuzz-applied, ${resolved} manually resolved, ${failed} failed`);
 }
 //# sourceMappingURL=summary.js.map

package/dist/src/commands/resolve.js

@@ -8,6 +8,7 @@ import { stageFiles, unstageFiles } from '../core/git-file-ops.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
 import { updatePatchAndMetadata } from '../core/patch-export.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
+import { buildPatchSourceMetadata } from '../core/patch-source-metadata.js';
 import { GeneralError, ResolutionError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
@@ -132,7 +133,7 @@ export async function resolveCommand(projectRoot, options = {}) {
         const config = await loadConfig(projectRoot);
         await updatePatchAndMetadata(paths.patches, patchFilename, diffContent, {
             filesAffected: diffFilesAffected,
-            sourceEsrVersion: config.firefox.version,
+            ...buildPatchSourceMetadata(config.firefox),
         });
         // Cleanup: Clear pendingResolution from state.json transactionally so
         // we don't clobber concurrent updates to unrelated keys (e.g. another

package/dist/src/commands/status-output.d.ts

@@ -0,0 +1,13 @@
+import type { ClassifiedFile } from '../core/status-classify.js';
+export interface ClassifiedBuckets {
+    conflict: ClassifiedFile[];
+    unmanaged: ClassifiedFile[];
+    patchBacked: ClassifiedFile[];
+    patchOwnedDrift: ClassifiedFile[];
+    branding: ClassifiedFile[];
+    furnace: ClassifiedFile[];
+}
+/** Renders the unmanaged-only status view and registration hints. */
+export declare function renderUnmanagedOnly(unmanagedFiles: ClassifiedFile[], totalModified: number, projectRoot: string, binaryName: string): Promise<void>;
+/** Renders the default classified status buckets. */
+export declare function renderDefaultStatus(totalModified: number, buckets: ClassifiedBuckets, projectRoot: string, binaryName: string): Promise<void>;