@hominis/fireforge 0.35.0 → 0.37.0

package/dist/src/commands/patch/split-plan.js

@@ -7,6 +7,7 @@
  * budget; consumed only by the split command.
  */
 import { join } from 'node:path';
+import {} from '../../core/destructive.js';
 import { getDiffForFilesAgainstHead } from '../../core/git-diff.js';
 import { computeProjectedLintRegressions } from '../../core/lint-projection.js';
 import { extractAffectedFiles } from '../../core/patch-apply.js';
@@ -18,6 +19,7 @@ import { extractNewFileContentFromDiff } from '../../core/patch-transform.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { pathExists } from '../../utils/fs.js';
 import { warn } from '../../utils/logger.js';
+import {} from '../export-flow.js';
 /**
  *
  */
@@ -249,4 +251,3 @@ export function buildSplitSummary(plan) {
     }
     return summary;
 }
-//# sourceMappingURL=split-plan.js.map

package/dist/src/commands/patch/split.js

@@ -18,6 +18,7 @@
  * the worktree.
  */
 import { join } from 'node:path';
+import { Command } from 'commander';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { normalizePatchArtifact } from '../../core/patch-artifact-normalize.js';
@@ -29,7 +30,7 @@ import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
 import { readText, removeFile, writeText } from '../../utils/fs.js';
 import { info, intro, outro, success, warn } from '../../utils/logger.js';
-import { pickDefined } from '../../utils/options.js';
+import { commanderArgParser, pickDefined } from '../../utils/options.js';
 import { placementPlansEqual, resolvePlacementPlan } from '../export-flow.js';
 import { runPatchLint } from '../export-shared.js';
 import { assertSourceOwnsFiles, buildNewPatchMetadata, buildSplitDiff, buildSplitSummary, findOwnerRewriteHolders, mergeStagedForwardImports, projectSplitManifest, rewriteSplitOwners, runProjectedSplitLint, } from './split-plan.js';
@@ -258,13 +259,13 @@ export function registerPatchSplit(parent, context) {
         .requiredOption('--name <name>', 'Name for the new patch')
         .option('--category <category>', "Category for the new patch (default: the source patch's)")
         .option('--description <desc>', 'Description for the new patch')
-        .option('--order <n>', 'Exact sparse order for the new patch', (raw) => {
+        .option('--order <n>', 'Exact sparse order for the new patch', commanderArgParser((raw) => {
         const n = Number.parseInt(raw, 10);
         if (!Number.isInteger(n) || n <= 0) {
             throw new InvalidArgumentError(`--order must be a positive integer, got "${raw}".`, '--order');
         }
         return n;
-    })
+    }))
         .option('--before <patch>', 'Place the new patch before this patch')
         .option('--after <patch>', 'Place the new patch after this patch (default: the source patch)')
         .option('--dry-run', 'Show what would happen without writing')
@@ -289,4 +290,3 @@ export function registerPatchSplit(parent, context) {
         });
     }));
 }
-//# sourceMappingURL=split.js.map

package/dist/src/commands/patch/staged-dependency.d.ts

@@ -10,7 +10,7 @@ import type { PatchStagedDependencyOptions } from '../../types/commands/index.js
  *
  * @param projectRoot - Project root directory
  * @param identifier - Patch filename, ordinal, or manifest name
- * @param options - Mutation mode and forward-import fields
+ * @param options - Mutation mode, entry kind, and declaration fields
  */
 export declare function patchStagedDependencyCommand(projectRoot: string, identifier: string, options?: PatchStagedDependencyOptions): Promise<void>;
 /**

package/dist/src/commands/patch/staged-dependency.js

@@ -3,6 +3,7 @@
  * `fireforge patch staged-dependency <name>` — edits
  * PatchMetadata.stagedDependencies without rewriting the .patch body.
  */
+import { Command } from 'commander';
 import { appendHistory } from '../../core/destructive.js';
 import { mutatePatchMetadata } from '../../core/patch-export.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
@@ -22,6 +23,19 @@ function modeFromOptions(options) {
     }
     return adding ? 'add' : removing ? 'remove' : 'clear';
 }
+function kindFromOptions(options) {
+    const kind = options.kind ?? 'import';
+    if (kind !== 'import' && kind !== 'registration') {
+        throw new InvalidArgumentError(`--kind must be "import" or "registration" (got "${kind}").`, 'patch staged-dependency');
+    }
+    if (kind === 'import' && options.line !== undefined) {
+        throw new InvalidArgumentError('--line only applies to --kind registration; import declarations use --specifier.', 'patch staged-dependency');
+    }
+    if (kind === 'registration' && options.specifier !== undefined) {
+        throw new InvalidArgumentError('--specifier only applies to --kind import; registration declarations use --line.', 'patch staged-dependency');
+    }
+    return kind;
+}
 function requireForwardImportOptions(options, mode) {
     if (!options.file || !options.specifier || !options.creates) {
         throw new InvalidArgumentError(`--${mode} requires --file, --specifier, and --creates.`, 'patch staged-dependency');
@@ -37,102 +51,149 @@ function requireForwardImportOptions(options, mode) {
         dependency.reason = options.reason;
     return dependency;
 }
-function dependencyKey(dependency) {
-    return [dependency.file, dependency.specifier, dependency.creates, dependency.owner ?? ''].join('\0');
+function requireRegistrationOptions(options, mode) {
+    if (!options.file || !options.line || !options.creates) {
+        throw new InvalidArgumentError(`--${mode} --kind registration requires --file, --line, and --creates.`, 'patch staged-dependency');
+    }
+    const dependency = {
+        file: options.file,
+        line: options.line,
+        creates: options.creates,
+    };
+    if (options.owner !== undefined)
+        dependency.owner = options.owner;
+    if (options.reason !== undefined)
+        dependency.reason = options.reason;
+    return dependency;
+}
+function importView(dependency) {
+    return { ...dependency, matcher: dependency.specifier };
 }
-function dependencyLabel(dependency) {
-    const owner = dependency.owner ? ` owner=${dependency.owner}` : '';
-    const reason = dependency.reason ? ` reason="${dependency.reason}"` : '';
-    return `${dependency.file} imports "${dependency.specifier}" from ${dependency.creates}${owner}${reason}`;
+function registrationView(dependency) {
+    return { ...dependency, matcher: dependency.line };
 }
-function removeMatching(existing, target) {
-    return existing.filter((dependency) => dependency.file !== target.file ||
-        dependency.specifier !== target.specifier ||
-        dependency.creates !== target.creates ||
-        (target.owner !== undefined && dependency.owner !== target.owner));
+function dependencyKey(view) {
+    return [view.file, view.matcher, view.creates, view.owner ?? ''].join('\0');
 }
-function applyMode(existing, mode, dependency) {
+function dependencyLabel(kind, view) {
+    const owner = view.owner ? ` owner=${view.owner}` : '';
+    const reason = view.reason ? ` reason="${view.reason}"` : '';
+    if (kind === 'import') {
+        return `${view.file} imports "${view.matcher}" from ${view.creates}${owner}${reason}`;
+    }
+    return `${view.file} registers "${view.matcher}" for ${view.creates}${owner}${reason}`;
+}
+function matchesTarget(view, target) {
+    return (view.file === target.file &&
+        view.matcher === target.matcher &&
+        view.creates === target.creates &&
+        (target.owner === undefined || view.owner === target.owner));
+}
+function applyMode(existing, mode, target, toView, addition) {
     if (mode === 'clear')
         return [];
-    if (!dependency)
+    if (!target)
         return [...existing];
     if (mode === 'remove')
-        return removeMatching(existing, dependency);
-    const seen = new Set(existing.map(dependencyKey));
-    if (seen.has(dependencyKey(dependency)))
+        return existing.filter((entry) => !matchesTarget(toView(entry), target));
+    const seen = new Set(existing.map((entry) => dependencyKey(toView(entry))));
+    if (seen.has(dependencyKey(target)) || addition === undefined)
         return [...existing];
-    return [...existing, dependency];
+    return [...existing, addition];
 }
 /**
  * Renders a one-line summary of a staged-dependency metadata change.
  */
-function describeStagedDependencyChange(before, after, mode, dependency) {
+function describeStagedDependencyChange(beforeCount, afterCount, mode, kind, target) {
+    const noun = kind === 'import' ? 'staged forward-import' : 'staged registration';
     if (mode === 'clear') {
-        return before.length === 0
+        return beforeCount === 0
             ? 'stagedDependencies was already empty — no change'
-            : `cleared ${before.length} staged forward-import declaration(s)`;
+            : `cleared ${beforeCount} staged dependency declaration(s)`;
     }
-    if (!dependency)
+    if (!target)
         return 'stagedDependencies unchanged';
     if (mode === 'add') {
-        return after.length === before.length
-            ? `staged forward-import already present: ${dependencyLabel(dependency)}`
-            : `added staged forward-import: ${dependencyLabel(dependency)}`;
+        return afterCount === beforeCount
+            ? `${noun} already present: ${dependencyLabel(kind, target)}`
+            : `added ${noun}: ${dependencyLabel(kind, target)}`;
     }
-    return after.length === before.length
-        ? `no staged forward-import matched: ${dependencyLabel(dependency)}`
-        : `removed ${before.length - after.length} staged forward-import declaration(s): ${dependencyLabel(dependency)}`;
+    return afterCount === beforeCount
+        ? `no ${noun} matched: ${dependencyLabel(kind, target)}`
+        : `removed ${beforeCount - afterCount} ${noun} declaration(s): ${dependencyLabel(kind, target)}`;
+}
+function countStagedEntries(staged) {
+    return (staged?.forwardImports?.length ?? 0) + (staged?.registrations?.length ?? 0);
 }
 /**
  * Runs the metadata-only staged-dependency mutation command.
  *
  * @param projectRoot - Project root directory
  * @param identifier - Patch filename, ordinal, or manifest name
- * @param options - Mutation mode and forward-import fields
+ * @param options - Mutation mode, entry kind, and declaration fields
  */
 export async function patchStagedDependencyCommand(projectRoot, identifier, options = {}) {
     const isDryRun = options.dryRun === true;
     intro(isDryRun ? 'FireForge patch staged-dependency (dry run)' : 'FireForge patch staged-dependency');
     const mode = modeFromOptions(options);
-    const dependency = mode === 'clear' ? undefined : requireForwardImportOptions(options, mode);
+    const kind = kindFromOptions(options);
+    const importDependency = mode === 'clear' || kind !== 'import' ? undefined : requireForwardImportOptions(options, mode);
+    const registrationDependency = mode === 'clear' || kind !== 'registration'
+        ? undefined
+        : requireRegistrationOptions(options, mode);
+    const target = importDependency !== undefined
+        ? importView(importDependency)
+        : registrationDependency !== undefined
+            ? registrationView(registrationDependency)
+            : undefined;
     const { paths, manifest } = await requirePatchQueue(projectRoot);
-    const target = requirePatchTarget(identifier, manifest.patches);
-    const existing = target.stagedDependencies?.forwardImports ?? [];
-    const projected = applyMode(existing, mode, dependency);
-    const summary = describeStagedDependencyChange(existing, projected, mode, dependency);
+    const targetPatch = requirePatchTarget(identifier, manifest.patches);
+    const applyToStaged = (staged) => {
+        if (mode === 'clear')
+            return {};
+        const forwardImports = applyMode(staged?.forwardImports ?? [], kind === 'import' ? mode : 'add', kind === 'import' ? target : undefined, importView, importDependency);
+        const registrations = applyMode(staged?.registrations ?? [], kind === 'registration' ? mode : 'add', kind === 'registration' ? target : undefined, registrationView, registrationDependency);
+        return {
+            ...(forwardImports.length > 0 ? { forwardImports } : {}),
+            ...(registrations.length > 0 ? { registrations } : {}),
+        };
+    };
+    const existing = targetPatch.stagedDependencies;
+    const projected = applyToStaged(existing);
+    const summary = describeStagedDependencyChange(countStagedEntries(existing), countStagedEntries(projected), mode, kind, target);
     if (isDryRun) {
-        info(`[dry-run] ${target.filename}: ${summary}.`);
+        info(`[dry-run] ${targetPatch.filename}: ${summary}.`);
         outro('Dry run complete — no changes made');
         return;
     }
-    const result = await mutatePatchMetadata(paths.patches, target.filename, (current) => {
-        const before = current.stagedDependencies?.forwardImports ?? [];
-        const after = applyMode(before, mode, dependency);
-        if (after.length === 0)
+    const result = await mutatePatchMetadata(paths.patches, targetPatch.filename, (current) => {
+        const after = applyToStaged(current.stagedDependencies);
+        if (countStagedEntries(after) === 0)
             return { unset: ['stagedDependencies'] };
-        return { set: { stagedDependencies: { forwardImports: after } } };
+        return { set: { stagedDependencies: after } };
     });
     if (!result) {
-        throw new GeneralError(`Patch ${target.filename} disappeared from the manifest during the update. Re-run after investigating.`);
+        throw new GeneralError(`Patch ${targetPatch.filename} disappeared from the manifest during the update. Re-run after investigating.`);
     }
-    const before = result.before.stagedDependencies?.forwardImports ?? [];
-    const after = result.after.stagedDependencies?.forwardImports ?? [];
-    info(`${target.filename}: ${describeStagedDependencyChange(before, after, mode, dependency)}.`);
+    const before = result.before.stagedDependencies;
+    const after = result.after.stagedDependencies;
+    info(`${targetPatch.filename}: ${describeStagedDependencyChange(countStagedEntries(before), countStagedEntries(after), mode, kind, target)}.`);
     try {
         await appendHistory(paths.patches, {
             operation: 'patch-staged-dependency',
             args: {
-                filename: target.filename,
+                filename: targetPatch.filename,
                 mode,
-                before,
-                after,
+                kind,
+                before: before ?? {},
+                after: after ?? {},
             },
             ...(options.yes === true ? { yes: true } : {}),
             result: 'ok',
         });
     }
     catch (historyError) {
-        warn(`History log append failed after patch staged-dependency committed (${target.filename}): ${toError(historyError).message}`);
+        warn(`History log append failed after patch staged-dependency committed (${targetPatch.filename}): ${toError(historyError).message}`);
     }
     outro('Patch staged-dependency complete');
 }
@@ -147,11 +208,13 @@ export function registerPatchStagedDependency(parent, context) {
     parent
         .command('staged-dependency <name>')
         .description('Edit PatchMetadata.stagedDependencies on a single patch (no .patch body rewrite).')
-        .option('--add', 'Add a staged forward-import declaration')
-        .option('--remove', 'Remove matching staged forward-import declaration(s)')
+        .option('--add', 'Add a staged dependency declaration')
+        .option('--remove', 'Remove matching staged dependency declaration(s)')
         .option('--clear', 'Drop the stagedDependencies field entirely')
-        .option('--file <path>', 'Importing file path relative to engine/')
-        .option('--specifier <specifier>', 'Exact import specifier as it appears in source')
+        .option('--kind <kind>', 'Declaration shape: "import" (forward import, the default) or "registration" (jar.mn packaging line, customElements or actor registration)')
+        .option('--file <path>', 'Declaring file path relative to engine/')
+        .option('--specifier <specifier>', 'Exact import specifier as it appears in source (--kind import)')
+        .option('--line <text>', 'Registration/packaging line as the patch adds it, compared whitespace-trimmed (--kind registration)')
         .option('--creates <path>', 'Later-created file path relative to engine/')
         .option('--owner <patch>', 'Exact later patch filename expected to create --creates')
         .option('--reason <text>', 'Human-readable rationale stored with the declaration')
@@ -161,4 +224,3 @@ export function registerPatchStagedDependency(parent, context) {
         await patchStagedDependencyCommand(getProjectRoot(), name, options);
     }));
 }
-//# sourceMappingURL=staged-dependency.js.map

package/dist/src/commands/patch/tier.js

@@ -14,8 +14,8 @@
  * Modes are mutually exclusive: exactly one of `--tier <branding>` or
  * `--clear` must be supplied per invocation.
  */
-import { Option } from 'commander';
-import { appendHistory } from '../../core/destructive.js';
+import { Command, Option } from 'commander';
+import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { updatePatchMetadata } from '../../core/patch-export.js';
 import { InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
@@ -60,11 +60,25 @@ export async function patchTierCommand(projectRoot, identifier, options = {}) {
         : before === undefined
             ? `set tier to "${after}"`
             : `change tier from "${before}" to "${after}"`;
-    if (isDryRun) {
-        info(`[dry-run] ${target.filename}: would ${action}.`);
+    // Destructive-operation contract (docs/lifecycle-invariants.md): manifest
+    // metadata mutations get summary + dry-run + confirmation/--yes + history
+    // uniformly. This command used to accept --yes without ever prompting, so
+    // the flag only appeared in the history record.
+    const decision = await confirmDestructive({
+        operation: 'patch-tier',
+        title: `Patch tier: ${target.filename}`,
+        summary: [`${target.filename}: ${action}`],
+        yes: options.yes === true,
+        dryRun: isDryRun,
+    });
+    if (decision === 'dry-run') {
         outro('Dry run complete — no changes made');
         return;
     }
+    if (decision === 'cancelled') {
+        outro('Cancelled — no changes made');
+        return;
+    }
     // Single write under the patch directory lock (delegated inside
     // updatePatchMetadata). Setting routes through `updates`; clearing
     // routes through `unsetFields` so TypeScript's exact optional types
@@ -116,4 +130,3 @@ export function registerPatchTier(parent, context) {
         });
     }));
 }
-//# sourceMappingURL=tier.js.map

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

@@ -78,4 +78,3 @@ export async function withDryRunReExportLock(fireforgeDir, isDryRun, operation)
         onStaleLockMessage: (ageMs) => `Removing stale FireForge re-export dry-run lock (age: ${Math.round(ageMs / 1000)}s). A previous dry-run process may have crashed.`,
     });
 }
-//# sourceMappingURL=re-export-bulk-scan.js.map

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

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
+import { getProjectPaths } from '../core/config.js';
 import { appendHistory, confirmDestructive } from '../core/destructive.js';
+import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { computeProjectedLintRegressions } from '../core/lint-projection.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
@@ -150,6 +152,9 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
         throw new InvalidArgumentError('reExportFilesInPlace called with no --files.', '--files');
     }
     const requested = [...new Set(filesOption)].sort();
+    // Stale-furnace-source gate (0.37.0 item 4): same refusal as the generic
+    // re-export path — the projected diff would capture stale deployed copies.
+    await enforceFreshFurnaceSources(paths.root, requested, options.allowStaleFurnace === true, 're-export');
     const removed = target.filesAffected.filter((f) => !requested.includes(f));
     const added = requested.filter((f) => !target.filesAffected.includes(f));
     const retained = target.filesAffected.filter((f) => requested.includes(f));
@@ -260,4 +265,3 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     success(`Re-exported ${target.filename}`);
     outro('Re-export complete');
 }
-//# sourceMappingURL=re-export-files.js.map

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

@@ -83,4 +83,3 @@ export function validateReExportOptionCombinations(patches, options) {
         throw new InvalidArgumentError('--tier and --lint-ignore require explicit patch identifiers and cannot be combined with --all (different patches typically need different metadata).', '--all');
     }
 }
-//# sourceMappingURL=re-export-options.js.map

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

@@ -144,4 +144,3 @@ export function assertScanFileAdditionsHaveDiffHunks(args) {
         return;
     throw new InvalidArgumentError(`Refusing to re-export ${patchFilename} with --scan-file because ${noDiffScanFiles.length} explicit added path${noDiffScanFiles.length === 1 ? '' : 's'} produced no diff hunks (${noDiffScanFiles.join(', ')}). Remove unchanged paths or modify them before retrying.`, '--scan-file');
 }
-//# sourceMappingURL=re-export-scan.js.map

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

@@ -1,8 +1,11 @@
 // SPDX-License-Identifier: EUPL-1.2
+/* eslint-disable max-lines -- Re-export is at the guardrail; splitting register plumbing is unrelated to this fix. */
 import { dirname, join } from 'node:path';
 import { multiselect } from '@clack/prompts';
-import { Option } from 'commander';
+import { Command, Option } from 'commander';
 import { getProjectPaths, loadConfig } from '../core/config.js';
+import { withEngineSessionLock } from '../core/engine-session-lock.js';
+import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
 import { isGitRepository } from '../core/git.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { getModifiedFilesInDir, getUntrackedFilesInDir } from '../core/git-status.js';
@@ -127,6 +130,12 @@ async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, co
         for (const f of removed)
             info(`  - ${f}`);
     }
+    // Stale-furnace-source gate (0.37.0 item 4): re-export captures deployed
+    // engine copies, so a component source edited after the last furnace
+    // apply would land in the patch as its OLD deployed content. Refuse (or
+    // warn under --allow-stale-furnace) before diffing. Runs in dry-run too
+    // so the failure surfaces early.
+    await enforceFreshFurnaceSources(paths.root, currentFilesAffected, options.allowStaleFurnace === true, 're-export');
     const missingFiles = await findMissingFiles(paths.engine, currentFilesAffected);
     if (missingFiles.length === currentFilesAffected.length) {
         warn(`Skipped ${patch.filename}: all affected files missing`);
@@ -413,6 +422,7 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
         .filter((v) => v.length > 0))
         .option('--dry-run', 'Show what would change without writing')
         .option('--skip-lint', 'Skip patch lint checks (downgrade errors to warnings)')
+        .option('--allow-stale-furnace', 'Export the deployed engine copy even when the components/ source changed since the last furnace apply')
         .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')
@@ -421,13 +431,13 @@ export function registerReExport(program, { getProjectRoot, withErrorHandling })
         .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) => {
         const { tier, lintIgnore, scanFile, scanFiles, ...rest } = options;
-        await reExportCommand(getProjectRoot(), patches, {
+        const projectRoot = getProjectRoot();
+        await withEngineSessionLock(projectRoot, 're-export', () => reExportCommand(projectRoot, patches, {
             ...pickDefined(rest),
             ...(scanFile !== undefined && scanFile.length > 0 ? { scanFiles: scanFile } : {}),
             ...(scanFiles !== undefined ? { scanFilesManifest: scanFiles } : {}),
             ...(tier !== undefined ? { tier: tier } : {}),
             ...(lintIgnore !== undefined && lintIgnore.length > 0 ? { lintIgnore } : {}),
-        });
+        }));
     }));
 }
-//# sourceMappingURL=re-export.js.map

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

@@ -3,11 +3,10 @@
  * Rebase abort flow.
  */
 import { getProjectPaths, updateState } from '../../core/config.js';
-import { getFurnacePaths, updateFurnaceState } from '../../core/furnace-config.js';
+import { clearAppliedFurnaceState } from '../../core/furnace-config.js';
 import { resetChanges } from '../../core/git.js';
 import { clearRebaseSession, loadRebaseSession } from '../../core/rebase-session.js';
 import { NoRebaseSessionError } from '../../errors/rebase.js';
-import { pathExists } from '../../utils/fs.js';
 import { intro, outro, spinner, success } from '../../utils/logger.js';
 import { confirmDirtyEngineReset } from './confirm.js';
 /**
@@ -47,12 +46,7 @@ export async function handleAbort(projectRoot, yes) {
     // misleading now that reset already succeeded). The rebase session is
     // still kept on disk so the user can retry the abort and let it
     // idempotently re-clear furnace state.
-    const furnacePaths = getFurnacePaths(projectRoot);
-    if (await pathExists(furnacePaths.furnaceState)) {
-        await updateFurnaceState(projectRoot, (current) => ({
-            ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
-        }));
-    }
+    await clearAppliedFurnaceState(projectRoot);
     // Step 3: clear pending resolution transactionally.
     await updateState(projectRoot, (current) => {
         if (!current.pendingResolution)
@@ -67,4 +61,3 @@ export async function handleAbort(projectRoot, yes) {
     success('Rebase aborted and session cleared.');
     outro('Rebase aborted');
 }
-//# sourceMappingURL=abort.js.map

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

@@ -30,4 +30,3 @@ export async function confirmDirtyEngineReset({ engineDir, yes, nonInteractiveCo
     }
     return true;
 }
-//# sourceMappingURL=confirm.js.map

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

@@ -35,4 +35,3 @@ export function buildRebaseConflictSummary(args) {
         ],
     };
 }
-//# sourceMappingURL=conflict-summary.js.map

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

@@ -104,4 +104,3 @@ export async function handleContinue(projectRoot, maxFuzz) {
     // Continue applying remaining patches
     await runPatchLoop(projectRoot, session, paths, maxFuzz);
 }
-//# sourceMappingURL=continue.js.map

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

@@ -3,7 +3,7 @@
  *
  * 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
  *

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