@hominis/fireforge 0.35.0 → 0.37.0

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