@hominis/fireforge 0.35.0 → 0.36.0

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

@@ -4,14 +4,15 @@
  *
  * Orchestrates the full patch-rebase workflow:
  *   1. Reset engine to baseline
- *   2. Apply each patch with escalating fuzz
+ *   2. Apply each patch with escalating context reduction (git apply -C<n>)
  *   3. Pause on failures for manual resolution
  *   4. Re-export successfully applied patches with the new version stamp
  *
  * Supports `--continue` (resume after manual fix) and `--abort` (cancel).
  */
+import { Command } from 'commander';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { getFurnacePaths, updateFurnaceState } from '../../core/furnace-config.js';
+import { clearAppliedFurnaceState } from '../../core/furnace-config.js';
 import { getHead, isGitRepository, isMissingHeadError, resetChanges } from '../../core/git.js';
 import { discoverPatches } from '../../core/patch-files.js';
 import { loadPatchesManifest } from '../../core/patch-manifest.js';
@@ -21,7 +22,8 @@ import { GeneralError } from '../../errors/base.js';
 import { RebaseSessionExistsError } from '../../errors/rebase.js';
 import { pathExists } from '../../utils/fs.js';
 import { info, intro, outro, spinner } from '../../utils/logger.js';
-import { pickDefined } from '../../utils/options.js';
+import { commanderArgParser, pickDefined } from '../../utils/options.js';
+import { parsePositiveIntegerFlag } from '../../utils/validation.js';
 import { handleAbort } from './abort.js';
 import { confirmDirtyEngineReset } from './confirm.js';
 import { handleContinue } from './continue.js';
@@ -78,9 +80,9 @@ async function handleFreshStart(projectRoot, options) {
     }
     info(`Rebasing patches: ${fromVersion} → ${currentVersion}`);
     info(`Found ${manifest.patches.length} patch(es)`);
-    info(`Max fuzz factor: ${maxFuzz}`);
+    info(`Max context-reduction steps (fuzz-like): ${maxFuzz}`);
     if (isDryRun) {
-        info('[dry-run] Would reset engine, apply patches with fuzz, and re-export.');
+        info('[dry-run] Would reset engine, apply patches with context reduction, and re-export.');
         outro('Dry run complete');
         return;
     }
@@ -102,13 +104,7 @@ async function handleFreshStart(projectRoot, options) {
     await resetChanges(paths.engine);
     resetSpinner.stop('Engine reset to baseline');
     // Clear Furnace state — the engine no longer contains deployed components.
-    // Preserve pendingRepair since that tracks authoring-side rollback issues.
-    const furnacePaths = getFurnacePaths(projectRoot);
-    if (await pathExists(furnacePaths.furnaceState)) {
-        await updateFurnaceState(projectRoot, (current) => ({
-            ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
-        }));
-    }
+    await clearAppliedFurnaceState(projectRoot);
     // Create rebase session
     const allPatches = await discoverPatches(paths.patches);
     const session = {
@@ -147,14 +143,13 @@ export async function rebaseCommand(projectRoot, options = {}) {
 export function registerRebase(program, { getProjectRoot, withErrorHandling }) {
     program
         .command('rebase')
-        .description('Semi-automated Firefox source version upgrade — apply patches with fuzz and re-export')
+        .description('Semi-automated Firefox source version upgrade — apply patches with drift tolerance 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')
-        .option('--max-fuzz <n>', 'Maximum fuzz factor for git apply (default: 3)', parseInt)
+        .option('--max-fuzz <n>', 'Maximum context-reduction steps for git apply -C<n> (fuzz-like drift tolerance; default: 3)', commanderArgParser((v) => parsePositiveIntegerFlag('--max-fuzz', v)))
         .option('-y, --yes', 'Skip dirty-tree confirmation prompt')
         .action(withErrorHandling(async (options) => {
         await rebaseCommand(getProjectRoot(), pickDefined(options));
     }));
 }
-//# sourceMappingURL=index.js.map

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

@@ -76,7 +76,7 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
                 success(`  ${entry.filename} — applied cleanly`);
             }
             else {
-                warn(`  ${entry.filename} — applied with fuzz=${result.fuzzFactor}`);
+                warn(`  ${entry.filename} — applied with context reduction (step ${result.fuzzFactor})`);
             }
         }
         else {
@@ -129,7 +129,7 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
     // patch was tested against if we proceeded to stamp. Refuse to claim
     // success and leave the session in place so the user can recover via
     // `fireforge rebase --continue` after fixing the underlying cause.
-    const reExportFailures = await reExportAppliedPatches(session, paths);
+    const { failures: reExportFailures, overlapSkipped } = await reExportAppliedPatches(session, paths);
     if (reExportFailures.length > 0) {
         for (const f of reExportFailures) {
             error(`  ${f.filename}: ${f.error}`);
@@ -138,10 +138,20 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
             `Versions were not stamped and the rebase session has been kept so you can retry. ` +
             `Fix the underlying cause shown above, then re-run "fireforge rebase --continue".`);
     }
-    // Stamp versions
+    if (overlapSkipped.length > 0) {
+        warn(`${overlapSkipped.length} patch(es) share files with other patches and were NOT ` +
+            `re-exported or version-stamped: ${overlapSkipped.join(', ')}. Their .patch files ` +
+            `still describe the pre-rebase source. Re-export them manually (e.g. ` +
+            `"fireforge re-export") and verify the overlapping hunks before the next import.`);
+    }
+    // Stamp versions — only for patches whose .patch file now actually
+    // reflects the new source (overlap-skipped ones keep their old stamp so
+    // the queue does not lie about what each patch was tested against).
+    const overlapSkippedSet = new Set(overlapSkipped);
     const appliedFilenames = session.patches
         .filter((p) => p.status === 'applied-clean' || p.status === 'applied-fuzz' || p.status === 'resolved')
-        .map((p) => p.filename);
+        .map((p) => p.filename)
+        .filter((filename) => !overlapSkippedSet.has(filename));
     if (appliedFilenames.length > 0) {
         await stampPatchVersions(paths.patches, appliedFilenames, session.toVersion, session.toProduct);
     }
@@ -181,9 +191,24 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
 }
 async function reExportAppliedPatches(session, paths) {
     const failures = [];
+    const overlapSkipped = [];
     const manifest = await loadPatchesManifest(paths.patches);
     if (!manifest)
-        return failures;
+        return { failures, overlapSkipped };
+    // Re-export writes `getDiffForFilesAgainstHead(files)` — the CUMULATIVE
+    // diff of those files. For a file claimed by two patches (a supported
+    // `--allow-overlap` queue), that diff contains BOTH patches' hunks, so
+    // rewriting each patch with it would duplicate the shared file's hunks
+    // into every owner: the very next import then fails or silently
+    // double-materialises. Refuse to auto-re-export any patch whose files
+    // overlap another patch; the operator re-exports those manually where
+    // per-patch attribution is possible.
+    const fileOwners = new Map();
+    for (const patch of manifest.patches) {
+        for (const file of patch.filesAffected) {
+            fileOwners.set(file, (fileOwners.get(file) ?? 0) + 1);
+        }
+    }
     const s = spinner('Re-exporting patches...');
     const reExportable = session.patches.filter((entry) => entry.status === 'applied-clean' || entry.status === 'applied-fuzz');
     const startedAt = Date.now();
@@ -191,6 +216,13 @@ async function reExportAppliedPatches(session, paths) {
         const meta = manifest.patches.find((p) => p.filename === entry.filename);
         if (!meta)
             continue;
+        const sharedFiles = meta.filesAffected.filter((f) => (fileOwners.get(f) ?? 0) > 1);
+        if (sharedFiles.length > 0) {
+            overlapSkipped.push(entry.filename);
+            warn(`Skipping re-export of ${entry.filename}: file(s) shared with other patches ` +
+                `(${sharedFiles.join(', ')}). Re-export it manually once the overlap is resolved.`);
+            continue;
+        }
         const existingFiles = [];
         for (const f of meta.filesAffected) {
             if (await pathExists(join(paths.engine, f))) {
@@ -224,6 +256,5 @@ async function reExportAppliedPatches(session, paths) {
     else {
         s.stop('Patches re-exported');
     }
-    return failures;
+    return { failures, overlapSkipped };
 }
-//# sourceMappingURL=patch-loop.js.map

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

@@ -11,7 +11,7 @@ function statusLabel(status, fuzzFactor) {
         case 'applied-clean':
             return 'applied cleanly';
         case 'applied-fuzz':
-            return `applied with fuzz=${fuzzFactor ?? '?'}`;
+            return `applied with context reduction (step ${fuzzFactor ?? '?'})`;
         case 'resolved':
             return 'RESOLVED manually';
         case 'failed':
@@ -43,6 +43,5 @@ export function printSummary(session) {
     const failed = session.patches.filter((p) => p.status === 'failed').length;
     const total = session.patches.length;
     info('');
-    info(`Results: ${total} total: ${clean} clean, ${fuzz} fuzz-applied, ${resolved} manually resolved, ${failed} failed`);
+    info(`Results: ${total} total: ${clean} clean, ${fuzz} context-reduced, ${resolved} manually resolved, ${failed} failed`);
 }
-//# sourceMappingURL=summary.js.map

package/dist/src/commands/rebase.js

@@ -3,4 +3,3 @@
  * `fireforge rebase` — re-exports from `./rebase/` sub-modules.
  */
 export { rebaseCommand, registerRebase } from './rebase/index.js';
-//# sourceMappingURL=rebase.js.map

package/dist/src/commands/register.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
+import { Command } from 'commander';
 import { getProjectPaths } from '../core/config.js';
 import { registerFile } from '../core/manifest-rules.js';
 import { InvalidArgumentError } from '../errors/base.js';
@@ -104,4 +105,3 @@ export function registerRegister(program, { getProjectRoot, withErrorHandling })
         await registerCommand(getProjectRoot(), path, pickDefined(options));
     }));
 }
-//# sourceMappingURL=register.js.map

package/dist/src/commands/reset.js

@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { confirm } from '@clack/prompts';
+import { Command } from 'commander';
 import { getProjectPaths } from '../core/config.js';
-import { getFurnacePaths, updateFurnaceState } from '../core/furnace-config.js';
-import { hasChanges, isGitRepository, resetChanges } from '../core/git.js';
+import { clearAppliedFurnaceState } from '../core/furnace-config.js';
+import { getHead, hasChanges, isGitRepository, isMissingHeadError, resetChanges, } from '../core/git.js';
 import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { pathExists } from '../utils/fs.js';
@@ -24,6 +25,18 @@ export async function resetCommand(projectRoot, options) {
     if (!(await isGitRepository(paths.engine))) {
         throw new GeneralError('Engine directory is not a git repository. Run "fireforge download" to initialize.');
     }
+    // Unborn-HEAD guard (mirrors status): an interrupted download leaves a
+    // repo with no baseline commit, where the entire ~300k-file tree reads
+    // as untracked — a reset against that state is never what the operator
+    // wants, and the guidance names the actual fix.
+    try {
+        await getHead(paths.engine);
+    }
+    catch (headError) {
+        if (!isMissingHeadError(headError))
+            throw headError;
+        throw new GeneralError('Engine repository has no baseline commit yet — a previous "fireforge download" was interrupted before git created the initial Firefox source commit. Re-run "fireforge download --force" to recreate the baseline repository cleanly.');
+    }
     // Check for changes
     const hasUncommittedChanges = await hasChanges(paths.engine);
     if (!hasUncommittedChanges) {
@@ -71,12 +84,7 @@ export async function resetCommand(projectRoot, options) {
         // consistent regardless of the drift oracle.) Preserve pendingRepair:
         // authoring-side rollback markers are about the workspace/component
         // tree, not the engine checkout, so reset must not silently forget them.
-        const furnacePaths = getFurnacePaths(projectRoot);
-        if (await pathExists(furnacePaths.furnaceState)) {
-            await updateFurnaceState(projectRoot, (current) => ({
-                ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
-            }));
-        }
+        await clearAppliedFurnaceState(projectRoot);
         s.stop('Changes reset');
         outro('Working tree restored to clean state');
     }
@@ -96,4 +104,3 @@ export function registerReset(program, { getProjectRoot, withErrorHandling }) {
         await resetCommand(getProjectRoot(), pickDefined(options));
     }));
 }
-//# sourceMappingURL=reset.js.map

package/dist/src/commands/resolve.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
 import { confirm } from '@clack/prompts';
+import { Command } from 'commander';
 import { getProjectPaths, loadConfig, loadState, updateState } from '../core/config.js';
 import { isGitRepository } from '../core/git.js';
 import { getStagedDiffForFiles } from '../core/git-diff.js';
@@ -43,7 +44,7 @@ export async function resolveCommand(projectRoot, options = {}) {
     // pipe / CI shell could otherwise commit whatever the engine
     // currently contains. 2026-04-21 eval (Finding #18): a scripted
     // recovery flow was dead-ended by the unconditional TTY refusal.
-    if (!process.stdin.isTTY && !options.yes) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY) && !options.yes) {
         throw new GeneralError('Cannot run "fireforge resolve" in non-interactive mode. Use a terminal with TTY support, or pass "--yes" to skip the interactive confirmation once the manual merge is complete.');
     }
     if (!options.yes) {
@@ -167,4 +168,3 @@ export function registerResolve(program, { getProjectRoot, withErrorHandling })
         await resolveCommand(getProjectRoot(), options);
     }));
 }
-//# sourceMappingURL=resolve.js.map

package/dist/src/commands/run.js

@@ -2,6 +2,7 @@
 import { createWriteStream } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { Command } from 'commander';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { warnIfFurnaceStale } from '../core/furnace-staleness.js';
 import { buildArtifactMismatchMessage, hasBuildArtifacts, hasRunnableBundle, run, runMachSmoke, } from '../core/mach.js';
@@ -13,7 +14,7 @@ import { SmokeRunError } from '../errors/run.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, removeDir, removeFile } from '../utils/fs.js';
 import { info, intro, verbose, warn } from '../utils/logger.js';
-import { pickDefined } from '../utils/options.js';
+import { commanderArgParser, pickDefined } from '../utils/options.js';
 /**
  * Exit code returned by smoke-run mode when the captured console stream
  * produced one or more error lines that did NOT match the operator's
@@ -330,13 +331,13 @@ export function registerRun(program, { getProjectRoot, withErrorHandling }) {
     program
         .command('run')
         .description('Launch the built browser')
-        .option('--smoke-exit <seconds>', 'Smoke-run mode (POSIX only): launch, capture console, SIGTERM the process group after <seconds>. Exit 0 on a clean window, 12 on unallowed errors, 13 on launch failure.', (value) => {
+        .option('--smoke-exit <seconds>', 'Smoke-run mode (POSIX only): launch, capture console, SIGTERM the process group after <seconds>. Exit 0 on a clean window, 12 on unallowed errors, 13 on launch failure.', commanderArgParser((value) => {
         const parsed = Number.parseInt(value, 10);
         if (!Number.isFinite(parsed) || parsed < 1 || String(parsed) !== value.trim()) {
             throw new Error(`--smoke-exit expects a positive integer number of seconds (got "${value}").`);
         }
         return parsed;
-    })
+    }))
         .option('--console-allow <regex>', 'Allowlist regex (repeatable). Lines that match any entry do not count toward the smoke exit code.', (value, acc) => {
         acc.push(value);
         return acc;
@@ -348,4 +349,3 @@ export function registerRun(program, { getProjectRoot, withErrorHandling }) {
         await runCommand(getProjectRoot(), pickDefined(options));
     }));
 }
-//# sourceMappingURL=run.js.map

package/dist/src/commands/setup-support.js

@@ -388,4 +388,3 @@ export async function writeSetupProjectFiles(projectRoot, config) {
         await writeText(destPath, content);
     }
 }
-//# sourceMappingURL=setup-support.js.map

package/dist/src/commands/setup.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { resolve } from 'node:path';
 import { confirm } from '@clack/prompts';
-import { Option } from 'commander';
+import { Command, Option } from 'commander';
 import { configExists } from '../core/config.js';
 import { ConfigError } from '../errors/config.js';
 import { cancel, intro, isCancel, note, outro, spinner } from '../utils/logger.js';
@@ -93,4 +93,3 @@ export function registerSetup(program, { withErrorHandling }) {
         await setupCommand(resolve(process.cwd()), setupOptions);
     }));
 }
-//# sourceMappingURL=setup.js.map

package/dist/src/commands/source.js

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { Option } from 'commander';
+import { Command, Option } from 'commander';
 import { configExists, loadRawConfigDocument, validateConfig, withConfigFileLock, writeConfigDocument, } from '../core/config.js';
 import { resolveArchive } from '../core/firefox-archive.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
@@ -92,4 +92,3 @@ export function registerSource(program, { getProjectRoot, withErrorHandling }) {
         });
     }));
 }
-//# sourceMappingURL=source.js.map

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

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { isFileRegistered, matchesRegistrablePattern } from '../core/manifest-rules.js';
+import { getPrimaryStatusCode } from '../core/status-classify.js';
 import { GeneralError } from '../errors/base.js';
 import { info, outro, warn } from '../utils/logger.js';
 const STATUS_DESCRIPTIONS = {
@@ -15,17 +16,6 @@ const STATUS_DESCRIPTIONS = {
 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';
@@ -192,4 +182,3 @@ export async function renderDefaultStatus(totalModified, buckets, projectRoot, b
         .map((section) => `${section.files.length} ${section.label}`);
     outro(parts.join(', '));
 }
-//# sourceMappingURL=status-output.js.map