@hominis/fireforge 0.27.1 → 0.27.3

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>;

package/dist/src/commands/status-output.js

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { isFileRegistered, matchesRegistrablePattern } from '../core/manifest-rules.js';
+import { GeneralError } from '../errors/base.js';
+import { info, outro, warn } from '../utils/logger.js';
+const STATUS_DESCRIPTIONS = {
+    M: 'modified',
+    A: 'added',
+    D: 'deleted',
+    R: 'renamed',
+    C: 'copied',
+    U: 'unmerged',
+    '?': 'untracked',
+    '!': 'ignored',
+};
+function getStatusDescription(code) {
+    return STATUS_DESCRIPTIONS[code] ?? 'changed';
+}
+function getPrimaryStatusCode(status) {
+    if (status.includes('?'))
+        return '?';
+    if (status.includes('!'))
+        return '!';
+    for (const code of status) {
+        if (code !== ' ')
+            return code;
+    }
+    return status;
+}
+function isNewFileStatus(status) {
+    const code = getPrimaryStatusCode(status);
+    return code === '?' || code === 'A';
+}
+function groupFilesByStatus(files) {
+    const grouped = new Map();
+    for (const { status, file } of files) {
+        const code = getPrimaryStatusCode(status);
+        const existing = grouped.get(code) ?? [];
+        existing.push(file);
+        grouped.set(code, existing);
+    }
+    return grouped;
+}
+function printStatusGroups(files) {
+    const grouped = groupFilesByStatus(files);
+    for (const [status, fileList] of grouped) {
+        warn(`${getStatusDescription(status)}:`);
+        for (const file of fileList)
+            info(`  ${file}`);
+    }
+}
+async function printUnregisteredWarnings(files, projectRoot, binaryName) {
+    const newFiles = files.filter((f) => isNewFileStatus(f.status));
+    if (newFiles.length === 0)
+        return;
+    const registrableFiles = newFiles.filter((f) => matchesRegistrablePattern(f.file, binaryName));
+    const registrationChecks = await Promise.all(registrableFiles.map(async (f) => {
+        try {
+            return {
+                file: f.file,
+                registered: await isFileRegistered(projectRoot, f.file),
+                manifestMissing: false,
+                manifestMissingMessage: undefined,
+            };
+        }
+        catch (err) {
+            if (err instanceof GeneralError && /^Manifest not found:/i.test(err.message)) {
+                return {
+                    file: f.file,
+                    registered: false,
+                    manifestMissing: true,
+                    manifestMissingMessage: err.message,
+                };
+            }
+            throw err;
+        }
+    }));
+    const unregistered = registrationChecks.filter((f) => !f.registered && !f.manifestMissing);
+    const manifestMissing = registrationChecks.filter((f) => f.manifestMissing);
+    if (unregistered.length > 0) {
+        info('');
+        warn('Potentially unregistered files:');
+        for (const f of unregistered)
+            info(`  ${f.file} — run 'fireforge register ${f.file}'`);
+    }
+    if (manifestMissing.length > 0) {
+        info('');
+        warn('Files whose registration manifest does not exist yet:');
+        for (const f of manifestMissing) {
+            info(`  ${f.file} — ${f.manifestMissingMessage}`);
+            info(`    Create the parent manifest, then run 'fireforge register ${f.file}'.`);
+        }
+    }
+}
+/** Renders the unmanaged-only status view and registration hints. */
+export async function renderUnmanagedOnly(unmanagedFiles, totalModified, projectRoot, binaryName) {
+    info(`${unmanagedFiles.length} unmanaged file${unmanagedFiles.length === 1 ? '' : 's'} (${totalModified} total modified):\n`);
+    if (unmanagedFiles.length > 0) {
+        printStatusGroups(unmanagedFiles);
+        await printUnregisteredWarnings(unmanagedFiles, projectRoot, binaryName);
+    }
+    else {
+        info('No unmanaged changes');
+    }
+    outro(unmanagedFiles.length === 0
+        ? 'No unmanaged changes'
+        : `${unmanagedFiles.length} unmanaged change${unmanagedFiles.length === 1 ? '' : 's'}`);
+}
+/** Renders the default classified status buckets. */
+export async function renderDefaultStatus(totalModified, buckets, projectRoot, binaryName) {
+    const { conflict, unmanaged, patchBacked, patchOwnedDrift, branding, furnace } = buckets;
+    info(`${totalModified} modified file${totalModified === 1 ? '' : 's'}:\n`);
+    if (conflict.length > 0) {
+        warn('Cross-patch ownership conflicts (same file claimed by multiple patches):');
+        printStatusGroups(conflict);
+        for (const entry of conflict) {
+            if (entry.claimedBy && entry.claimedBy.length > 0) {
+                info(`  ${entry.file} — claimed by ${entry.claimedBy.join(', ')}`);
+            }
+        }
+        info('Run "fireforge status --ownership" for the full conflict table, then repartition with "fireforge re-export --files <paths> <patch>".');
+    }
+    if (unmanaged.length > 0) {
+        if (conflict.length > 0)
+            info('');
+        warn('Unmanaged changes:');
+        printStatusGroups(unmanaged);
+        await printUnregisteredWarnings(unmanaged, projectRoot, binaryName);
+    }
+    if (patchBacked.length > 0) {
+        if (conflict.length > 0 || unmanaged.length > 0)
+            info('');
+        warn('Patch-backed materialized changes:');
+        printStatusGroups(patchBacked);
+    }
+    if (patchOwnedDrift.length > 0) {
+        if (conflict.length > 0 || unmanaged.length > 0 || patchBacked.length > 0)
+            info('');
+        warn('Patch-owned drift:');
+        printStatusGroups(patchOwnedDrift);
+        info('These files are claimed by exactly one patch, but engine/ no longer matches that patch output. Re-export the owning patch after reviewing the manual resolution.');
+    }
+    if (branding.length > 0) {
+        if (conflict.length > 0 ||
+            unmanaged.length > 0 ||
+            patchBacked.length > 0 ||
+            patchOwnedDrift.length > 0) {
+            info('');
+        }
+        warn('Tool-managed branding changes:');
+        printStatusGroups(branding);
+    }
+    if (furnace.length > 0) {
+        if (conflict.length > 0 ||
+            unmanaged.length > 0 ||
+            patchBacked.length > 0 ||
+            patchOwnedDrift.length > 0 ||
+            branding.length > 0) {
+            info('');
+        }
+        warn('Furnace-managed component changes:');
+        printStatusGroups(furnace);
+    }
+    if (conflict.length === 0 &&
+        unmanaged.length === 0 &&
+        patchBacked.length === 0 &&
+        patchOwnedDrift.length === 0 &&
+        branding.length === 0 &&
+        furnace.length === 0) {
+        info('No changes');
+    }
+    const parts = [];
+    if (conflict.length > 0)
+        parts.push(`${conflict.length} conflict`);
+    if (unmanaged.length > 0)
+        parts.push(`${unmanaged.length} unmanaged`);
+    if (patchBacked.length > 0)
+        parts.push(`${patchBacked.length} patch-backed`);
+    if (patchOwnedDrift.length > 0)
+        parts.push(`${patchOwnedDrift.length} patch-owned drift`);
+    if (branding.length > 0)
+        parts.push(`${branding.length} branding`);
+    if (furnace.length > 0)
+        parts.push(`${furnace.length} furnace`);
+    outro(parts.join(', '));
+}
+//# sourceMappingURL=status-output.js.map