@hominis/fireforge 0.45.0 → 0.46.0

package/dist/src/commands/doctor-post-rebase-audit.js

@@ -88,7 +88,7 @@ async function runPostRebaseAudit(ctx) {
     }
     const browserTomls = await collectBrowserTomlFiles(engineDir);
     if (browserTomls.unreadable.length > 0) {
-        issues.push(`could not read ${String(browserTomls.unreadable.length)} ` +
+        issues.push(`could not read ${browserTomls.unreadable.length} ` +
             `${browserTomls.unreadable.length === 1 ? 'directory' : 'directories'} under ` +
             `browser/base/content/test: ${browserTomls.unreadable.join(', ')}`);
     }

package/dist/src/commands/doctor.d.ts

@@ -21,6 +21,8 @@ export declare function validateCheckDependencies(checks: readonly DoctorCheckDe
  * context-population dependency chain (see {@link DOCTOR_CHECKS}) must
  * also update this list, which gives us a single place to notice and
  * think through the consequences.
+ *
+ * @internal Exported only so tests can reach it; not part of the public surface.
  */
 export declare const DOCTOR_CHECK_ORDER: readonly string[];
 /**

package/dist/src/commands/doctor.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { Command } from 'commander';
-import { configExists, getProjectPaths, loadConfig, loadState, updateState, } from '../core/config.js';
+import { configExists, getProjectPaths, loadConfig, loadState } from '../core/config.js';
 import { furnaceConfigExists as checkFurnaceConfigExists } from '../core/furnace-config.js';
 import { getCurrentBranch, getHead, isGitRepository, isMissingHeadError } from '../core/git.js';
 import { ensureGit } from '../core/git-base.js';
@@ -14,7 +14,7 @@ import { pathExists } from '../utils/fs.js';
 import { error, info, intro, outro, success, warn } from '../utils/logger.js';
 import { addWaitLockOption } from '../utils/options.js';
 import { findExecutable } from '../utils/process.js';
-import { failure, ok, resolveDoctorSeverity, warning } from './doctor-check-core.js';
+import { failure, ok, warning } from './doctor-check-core.js';
 import { EXTERNAL_TOOLCHAIN_DOCTOR_CHECK } from './doctor-external-toolchains.js';
 import { FURNACE_DOCTOR_CHECKS } from './doctor-furnace.js';
 import { ORPHANED_HARNESS_DOCTOR_CHECK } from './doctor-orphaned-harness.js';
@@ -22,6 +22,7 @@ import { PATCH_MANIFEST_CONSISTENCY_CHECK } from './doctor-patch-manifest.js';
 import { POST_REBASE_AUDIT_CHECK } from './doctor-post-rebase-audit.js';
 import { SOURCE_PIN_DOCTOR_CHECK } from './doctor-source-pin.js';
 import { inspectEngineWorkingTree } from './doctor-working-tree.js';
+import { clearPendingResolution } from './pending-resolution.js';
 import { collectPatchQueueHealth } from './verify.js';
 /**
  * Runs a single check definition, converting thrown errors into
@@ -202,11 +203,7 @@ const DOCTOR_CHECKS = [
                 if (health.errorCount > 0) {
                     return failure('Pending Resolution', `Refusing to clear pending resolution for ${patchFilename}: patch queue health check found ${health.errorCount} error(s).`, 'Run "fireforge verify" for details, fix the queue, then retry "fireforge doctor --clear-resolution".');
                 }
-                await updateState(ctx.projectRoot, (current) => {
-                    const next = { ...current };
-                    delete next.pendingResolution;
-                    return next;
-                });
+                await clearPendingResolution(ctx.projectRoot);
                 return ok('Pending Resolution');
             }
             return failure('Pending Resolution', `You are currently resolving a conflict for patch ${patchFilename}.`, 'Build and Export commands may behave unexpectedly until "fireforge resolve" is completed. If the queue now verifies cleanly, run "fireforge doctor --clear-resolution" to discard the stale marker.');
@@ -322,6 +319,8 @@ validateCheckDependencies(DOCTOR_CHECKS);
  * context-population dependency chain (see {@link DOCTOR_CHECKS}) must
  * also update this list, which gives us a single place to notice and
  * think through the consequences.
+ *
+ * @internal Exported only so tests can reach it; not part of the public surface.
  */
 export const DOCTOR_CHECK_ORDER = DOCTOR_CHECKS.map((check) => check.name);
 /**
@@ -336,7 +335,7 @@ export function reportDoctorResults(checks, mutations = []) {
     let warningCount = 0;
     let failedCount = 0;
     for (const check of checks) {
-        const severity = resolveDoctorSeverity(check);
+        const severity = check.severity;
         if (severity === 'warning') {
             warn(`! ${check.name}: ${check.message}`);
             if (check.fix) {

package/dist/src/commands/download.js

@@ -110,11 +110,6 @@ function closeRestoreSpinner(restoreSpinner, result) {
     }
     restoreSpinner.stop('Patch-touched files restored');
 }
-async function clearStaleFurnaceApplyState(projectRoot) {
-    // --force installs a new baseCommit, which invalidates every applied
-    // checksum in furnace-state.json.
-    await clearAppliedFurnaceState(projectRoot);
-}
 async function activateReplacementEngine(args) {
     const { engineDir, replacementDir, backupDir } = args;
     await rename(engineDir, backupDir);
@@ -155,28 +150,39 @@ async function restorePreviousEngine(args) {
     }
 }
 async function downloadAndExtractFirefox(args) {
-    const { version, product, engineDir, cacheDir, sha256, candidate } = args;
+    const { version, product, engineDir, cacheDir, sha256, candidate, allowUnverifiedDownload } = 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);
-        }, candidate);
+        await downloadFirefoxSource({
+            version: version,
+            product: product,
+            destDir: engineDir,
+            cacheDir: cacheDir,
+            onProgress: (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;
+                }
+            },
+            onPhase: (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)`);
+                }
+            },
+            expectedSha256: sha256,
+            onPhaseProgress: (message) => {
+                s.message(message);
+            },
+            candidate: candidate,
+            integrity: allowUnverifiedDownload === undefined ? undefined : { allowUnverifiedDownload },
+        });
         s.stop(phaseState.value === 'extract'
             ? `Firefox ${version} extracted`
             : `Firefox ${version} downloaded`);
@@ -235,7 +241,9 @@ async function initializeDownloadedEngine(args) {
             throw error;
         }
         if (replacementActivated) {
-            await clearStaleFurnaceApplyState(projectRoot);
+            // --force installs a new baseCommit, which invalidates every applied
+            // checksum in furnace-state.json.
+            await clearAppliedFurnaceState(projectRoot);
         }
         await updateState(projectRoot, {
             downloadedVersion: version,
@@ -389,6 +397,9 @@ export async function downloadCommand(projectRoot, options) {
                 ...(config.firefox.candidate !== undefined
                     ? { candidate: config.firefox.candidate }
                     : {}),
+                ...(config.firefox.allowUnverifiedDownload !== undefined
+                    ? { allowUnverifiedDownload: config.firefox.allowUnverifiedDownload }
+                    : {}),
             });
             if (replacementEngineDir && backupEngineDir) {
                 warn('Activating replacement engine directory...');

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

@@ -19,10 +19,20 @@ import { info, intro, outro, spinner } from '../utils/logger.js';
 import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../utils/options.js';
 import { renderDryRunPreview } from './export-flow.js';
 import { autoFixLicenseHeaders, promptExportPatchMetadata, runPatchLint, runSupersedeAndOverlapGates, } from './export-shared.js';
+/**
+ * The engine paths an export-all entry owns: its current file plus, for a
+ * rename, the path it came from. Spelled once because three call sites had
+ * copied the same `filter((value): value is string => !!value)` narrowing.
+ * @param entry - Export entry carrying `file` and an optional `originalPath`.
+ * @returns Both paths when the entry was renamed, otherwise just `file`.
+ */
+function ownedPaths(entry) {
+    return [entry.file, entry.originalPath].filter((value) => !!value);
+}
 async function checkBrandingManagedFiles(paths, config) {
     const changedFiles = await getWorkingTreeStatus(paths.engine);
     const brandingManagedFiles = changedFiles
-        .flatMap((entry) => [entry.file, entry.originalPath].filter((value) => !!value))
+        .flatMap((entry) => ownedPaths(entry))
         .filter((file) => isBrandingManagedPath(file, config.binaryName));
     if (brandingManagedFiles.length > 0) {
         throw new GeneralError('Export-all refuses to capture tool-managed branding changes by default.\n\n' +
@@ -52,7 +62,7 @@ async function resolveFurnaceExclusionPolicy(paths, projectRoot, excludeFurnace)
     const rawStatus = await getWorkingTreeStatus(paths.engine);
     const changedFiles = await expandUntrackedDirectoryEntries(paths.engine, rawStatus);
     const furnaceManagedFiles = changedFiles
-        .flatMap((entry) => [entry.file, entry.originalPath].filter((value) => !!value))
+        .flatMap((entry) => ownedPaths(entry))
         .filter((file) => [...prefixes].some((prefix) => file.startsWith(prefix)));
     if (furnaceManagedFiles.length === 0)
         return new Set();
@@ -196,7 +206,7 @@ export async function exportAllCommand(projectRoot, options = {}) {
         const allChanged = await expandUntrackedDirectoryEntries(paths.engine, rawChanged);
         const nonFurnacePaths = [
             ...new Set(allChanged
-                .flatMap((entry) => [entry.file, entry.originalPath].filter((value) => !!value))
+                .flatMap((entry) => ownedPaths(entry))
                 .filter((file) => !furnaceExcluded.has(file))),
         ].sort();
         scopedExportPaths = nonFurnacePaths;
@@ -254,7 +264,14 @@ export async function exportAllCommand(projectRoot, options = {}) {
         const patchQueueCtx = (await pathExists(paths.patches))
             ? await buildPatchQueueContext(paths.patches)
             : undefined;
-        await runPatchLint(paths.engine, filesAffected, diff, config, options.skipLint, patchQueueCtx);
+        await runPatchLint({
+            engineDir: paths.engine,
+            filesAffected,
+            diffContent: diff,
+            config,
+            skipLint: options.skipLint,
+            patchQueueCtx,
+        });
         // Dry-run: enumerate filename, metadata, and supersede coverage without
         // writing. Mirrors `fireforge export --dry-run` so the same preview
         // surface is available for both targeted and aggregate exports. Runs

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

@@ -10,14 +10,12 @@
 import { join } from 'node:path';
 import {} from '../core/destructive.js';
 import { detectMovedCodeOverlaps, formatAdoptThenSplitRemedy, } from '../core/export-moved-code-shape.js';
-import { normalizePatchArtifact } from '../core/patch-artifact-normalize.js';
-import { findAllPatchesForFilesWithDetails, patchNameSlug, planExport, } from '../core/patch-export.js';
-import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, lintPatchQueue, } from '../core/patch-lint.js';
+import { buildPlanExportInput, findAllPatchesForFilesWithDetails, patchNameSlug, planExport, } from '../core/patch-export.js';
+import { buildPatchQueueContext, lintPatchQueue } from '../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../core/patch-lock.js';
 import { addPatchToManifest, loadPatchesManifest, loadPatchesManifestForWrite, renumberPatchesInManifest, resolvePatchIdentifier, savePatchesManifest, } from '../core/patch-manifest.js';
-import { requirePatchOrder } from '../core/patch-parse.js';
+import { formatPatchOrder, requirePatchOrder } from '../core/patch-parse.js';
 import { applyRenameMapToManifest, buildProjectedManifest, enforcePatchPolicy, } from '../core/patch-policy.js';
-import { buildNewFileTextProjection } from '../core/patch-transform.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
@@ -25,6 +23,8 @@ import { info, warn } from '../utils/logger.js';
 import { groupProjectedPlacementErrors } from './export-placement-conflicts.js';
 import { assertPlacementAvoidsReservedRanges } from './export-placement-policy.js';
 import { findPartialOwnershipOverlap } from './export-shared.js';
+import { projectEntryBody } from './patch/entry-projection.js';
+import { getSortedRenameEntries, renameMapsEqual } from './patch-rename-map.js';
 function buildFilenameForPlacement(category, name, order, width) {
     const padded = String(order).padStart(Math.max(3, width), '0');
     return `${padded}-${category}-${patchNameSlug(name, category)}.patch`;
@@ -35,9 +35,6 @@ function prefixWidthForPatches(manifestPatches, requestedOrder) {
         return Math.max(width, match?.[1]?.length ?? 3, String(requestedOrder).length);
     }, 3);
 }
-function getSortedRenameEntries(renameMap) {
-    return Array.from(renameMap.entries()).sort((a, b) => a[1].newOrder - b[1].newOrder);
-}
 /**
  * Structural equality for placement plans — used by placement-mode export
  * and `patch split` to verify the queue did not change between the
@@ -47,20 +44,7 @@ export function placementPlansEqual(left, right) {
     if (left.insertionOrder !== right.insertionOrder || left.newFilename !== right.newFilename) {
         return false;
     }
-    const leftEntries = getSortedRenameEntries(left.renameMap);
-    const rightEntries = getSortedRenameEntries(right.renameMap);
-    if (leftEntries.length !== rightEntries.length) {
-        return false;
-    }
-    return leftEntries.every(([leftFilename, leftEntry], index) => {
-        const rightTuple = rightEntries[index];
-        if (!rightTuple)
-            return false;
-        const [rightFilename, rightEntry] = rightTuple;
-        return (leftFilename === rightFilename &&
-            leftEntry.newFilename === rightEntry.newFilename &&
-            leftEntry.newOrder === rightEntry.newOrder);
-    });
+    return renameMapsEqual(left.renameMap, right.renameMap);
 }
 /**
  * Computes the shift map that moves existing patches out of the requested
@@ -72,7 +56,7 @@ export function computePlacementPlan(manifestPatches, newPatchCategory, newPatch
     // Failing fast here prevents a NaN requestedOrder from producing a
     // filename like "NaN-ui-foo.patch".
     if (!Number.isInteger(requestedOrder) || requestedOrder <= 0) {
-        throw new InvalidArgumentError(`computePlacementPlan requires a positive integer order, got ${String(requestedOrder)}.`, 'requestedOrder');
+        throw new InvalidArgumentError(`computePlacementPlan requires a positive integer order, got ${requestedOrder}.`, 'requestedOrder');
     }
     const sorted = [...manifestPatches].sort((a, b) => a.order - b.order);
     const renameMap = new Map();
@@ -90,7 +74,7 @@ export function computePlacementPlan(manifestPatches, newPatchCategory, newPatch
         }
         const newOrder = cursor + 1;
         const currentRest = patch.filename.replace(/^\d+-/, '');
-        const newFilename = `${String(newOrder).padStart(prefixWidth, '0')}-${currentRest}`;
+        const newFilename = `${formatPatchOrder(newOrder, prefixWidth)}-${currentRest}`;
         renameMap.set(patch.filename, { newOrder, newFilename });
         cursor = newOrder;
     }
@@ -109,11 +93,11 @@ export function computePlacementPlan(manifestPatches, newPatchCategory, newPatch
  */
 export function computeExactPlacementPlan(manifestPatches, newPatchCategory, newPatchName, requestedOrder) {
     if (!Number.isInteger(requestedOrder) || requestedOrder <= 0) {
-        throw new InvalidArgumentError(`--order must be a positive integer, got ${String(requestedOrder)}.`, '--order');
+        throw new InvalidArgumentError(`--order must be a positive integer, got ${requestedOrder}.`, '--order');
     }
     const occupied = manifestPatches.find((patch) => patch.order === requestedOrder);
     if (occupied) {
-        throw new InvalidArgumentError(`--order ${String(requestedOrder)} is already occupied by ${occupied.filename}. ` +
+        throw new InvalidArgumentError(`--order ${requestedOrder} is already occupied by ${occupied.filename}. ` +
             'Choose an unused order or use --before/--after for positional insertion.', '--order');
     }
     return {
@@ -140,7 +124,7 @@ export async function resolvePlacementPlan(patchesDir, options, category, name,
         // function is called directly from the command body which could
         // reach here with a NaN/0/negative value passed in via test harness.
         if (!Number.isInteger(options.order) || options.order <= 0) {
-            throw new InvalidArgumentError(`--order must be a positive integer, got ${String(options.order)}.`, '--order');
+            throw new InvalidArgumentError(`--order must be a positive integer, got ${options.order}.`, '--order');
         }
         return computeExactPlacementPlan(existingPatches, category, name, options.order);
     }
@@ -190,9 +174,7 @@ export async function projectPlacementForLint(patchesDir, plan, diff, config) {
         filename: plan.newFilename,
         order: plan.insertionOrder,
         metadata: null,
-        diff,
-        newFiles: buildNewFileTextProjection(diff),
-        modifiedFileAdditions: buildModifiedFileAdditionsFromDiff(diff),
+        ...projectEntryBody(diff),
     });
     projectedEntries.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
     const policyRest = baseCtx.patchPolicy ? { patchPolicy: baseCtx.patchPolicy } : {};
@@ -294,7 +276,7 @@ export async function commitPlacementExport(input) {
             }
             // Normalize identically to commitExportedPatch — the two export
             // paths must produce one artifact contract for the same diff.
-            await writeText(patchPath, normalizePatchArtifact(input.diff));
+            await writeText(patchPath, input.diff);
             await addPatchToManifest(input.patchesDir, {
                 ...input.metadata,
                 filename: currentPlan.newFilename,
@@ -380,19 +362,7 @@ export async function renderDryRunPreview(input) {
     const overlap = manifest !== null
         ? findPartialOwnershipOverlap(manifest, input.filesAffected, supersedingFilenames)
         : new Map();
-    const plan = await planExport({
-        patchesDir: input.patchesDir,
-        category: input.category,
-        name: input.name,
-        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 } : {}),
-    });
+    const plan = await planExport(buildPlanExportInput(input));
     if (input.config !== undefined) {
         enforcePatchPolicy({
             config: input.config,
@@ -426,7 +396,7 @@ export async function renderDryRunPreview(input) {
     }
     if (overlap.size > 0) {
         const entries = [...overlap.entries()].sort(([a], [b]) => a.localeCompare(b));
-        warn(`\n[dry-run] Would create cross-patch ownership overlap on ${String(entries.length)} file${entries.length === 1 ? '' : 's'}:`);
+        warn(`\n[dry-run] Would create cross-patch ownership overlap on ${entries.length} file${entries.length === 1 ? '' : 's'}:`);
         for (const [file, owners] of entries) {
             warn(`  - ${file} already claimed by: ${owners.join(', ')}`);
         }

package/dist/src/commands/export-placement-conflicts.js

@@ -66,10 +66,10 @@ export function groupProjectedPlacementErrors(projectedErrors, baselineErrors, p
             details.push(`  ${formatPatchLintIssue(issue)}`);
         }
     };
-    pushGroup(`errors in the exported patch content (${String(exported.length)}):`, exported);
+    pushGroup(`errors in the exported patch content (${exported.length}):`, exported);
     pushGroup(`consequences of renumbering existing patches to make room at ordinal ` +
-        `${String(plan.insertionOrder)} (${String(renumbering.length)}) — these come from ` +
+        `${plan.insertionOrder} (${renumbering.length}) — these come from ` +
         'renumbering, NOT from the exported content:', renumbering);
-    pushGroup(`errors already present in the queue before this export (${String(preExisting.length)}):`, preExisting);
+    pushGroup(`errors already present in the queue before this export (${preExisting.length}):`, preExisting);
     return details;
 }

package/dist/src/commands/export-placement-gate.js

@@ -10,7 +10,7 @@ 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 { InvalidArgumentError } from '../errors/base.js';
-import { outro } from '../utils/logger.js';
+import { proceedAfterDecision } from './destructive-decision.js';
 import { placementSummary, projectPlacementForLint, resolvePlacementPlan, } from './export-flow.js';
 /**
  * Spreadable optional metadata (`tier`, `lintIgnore`) derived from the
@@ -85,14 +85,8 @@ export async function gatePlacementPlan(args) {
             unsafeOverride: options.forceUnsafe === true,
             conflicts,
         });
-        if (decision === 'dry-run') {
-            outro('Dry run complete — no changes made');
+        if (!proceedAfterDecision(decision, 'Export cancelled'))
             return 'stop';
-        }
-        if (decision === 'declined') {
-            outro('Export cancelled');
-            return 'stop';
-        }
     }
     else if (conflicts && options.forceUnsafe !== true) {
         s.stop();

package/dist/src/commands/export-placement-policy.js

@@ -2,10 +2,8 @@
 /**
  * Policy-aware checks for export placement plans.
  */
+import { formatOrderRange, formatPatchOrder } from '../core/patch-parse.js';
 import { InvalidArgumentError } from '../errors/base.js';
-function reservedRangeLabel(range) {
-    return `${String(range.from).padStart(3, '0')}-${String(range.to).padStart(3, '0')}`;
-}
 function findReservedRange(config, order) {
     return (config.patchPolicy?.reservedRanges?.find((range) => order >= range.from && order <= range.to) ??
         null);
@@ -42,11 +40,11 @@ export function assertPlacementAvoidsReservedRanges(plan, manifestPatches, confi
             (oldOrder !== undefined ? findReservedRange(config, oldOrder) : null);
         if (reserved === null)
             continue;
-        const label = reservedRangeLabel(reserved);
+        const label = formatOrderRange(reserved);
         const freeOrder = firstFreeOrderBelowReservedRange(manifestPatches, reserved);
         if (freeOrder !== null) {
             throw new InvalidArgumentError(`Positional insert would renumber the reserved range ${label}; ` +
-                `pass --order ${String(freeOrder).padStart(3, '0')} (first free order below the ` +
+                `pass --order ${formatPatchOrder(freeOrder)} (first free order below the ` +
                 'reserved block) to place the new patch without renumbering reserved patches.', 'export placement');
         }
         throw new InvalidArgumentError(`Positional insert would renumber the reserved range ${label}; ` +

package/dist/src/commands/export-shared.d.ts

@@ -2,29 +2,43 @@ import type { PatchesManifest, PatchLintIssue } from '../types/commands/index.js
 import type { ExportOptions, PatchCategory } from '../types/commands/index.js';
 import type { FireForgeConfig } from '../types/config.js';
 import type { SpinnerHandle } from '../utils/logger.js';
+export interface RunPatchLintOptions {
+    /** Engine root directory. */
+    engineDir: string;
+    /** Files touched by the patch. */
+    filesAffected: string[];
+    /** Raw unified diff string. */
+    diffContent: string;
+    /** Project configuration. */
+    config: FireForgeConfig;
+    /** If true, downgrade errors to warnings. */
+    skipLint?: boolean | undefined;
+    /** Optional cross-patch context for ownership resolution. */
+    patchQueueCtx?: import('../core/patch-lint-cross.js').PatchQueueContext | undefined;
+    /**
+     * Optional per-patch set of `check` IDs to suppress (threaded from
+     * `PatchMetadata.lintIgnore`). Surgical alternative to `--skip-lint` when
+     * exactly one advisory rule does not apply to a specific patch — e.g.
+     * `large-patch-lines` on a cohesive branding bundle that genuinely cannot
+     * be split.
+     */
+    ignoreChecks?: ReadonlySet<string> | undefined;
+    /**
+     * Optional explicit tier override (threaded from `PatchMetadata.tier`).
+     * Forces the branding-tier thresholds when set, independent of the
+     * auto-detect allowlist. When the branding tier is applied, a single
+     * `info()` line surfaces the choice so the tier decision is visible rather
+     * than silent.
+     */
+    patchTier?: 'branding' | undefined;
+}
 /**
  * Runs the full patch lint pipeline and reports results. Warnings are always
  * displayed. Errors block the export unless skipLint is true.
  *
- * @param engineDir - Engine root directory
- * @param filesAffected - Files touched by the patch
- * @param diffContent - Raw unified diff string
- * @param config - Project configuration
- * @param skipLint - If true, downgrade errors to warnings
- * @param patchQueueCtx - Optional cross-patch context for ownership
- *   resolution
- * @param ignoreChecks - Optional per-patch set of `check` IDs to suppress
- *   (threaded from `PatchMetadata.lintIgnore`). Surgical alternative to
- *   `--skip-lint` when exactly one advisory rule does not apply to a
- *   specific patch — e.g. `large-patch-lines` on a cohesive branding bundle
- *   that genuinely cannot be split.
- * @param patchTier - Optional explicit tier override (threaded from
- *   `PatchMetadata.tier`). Forces the branding-tier thresholds when set,
- *   independent of the auto-detect allowlist. When the branding tier is
- *   applied, a single `info()` line surfaces the choice so the tier decision
- *   is visible rather than silent.
+ * @param options - See {@link RunPatchLintOptions}
  */
-export declare function runPatchLint(engineDir: string, filesAffected: string[], diffContent: string, config: FireForgeConfig, skipLint?: boolean, patchQueueCtx?: import('../core/patch-lint-cross.js').PatchQueueContext, ignoreChecks?: ReadonlySet<string>, patchTier?: 'branding'): Promise<void>;
+export declare function runPatchLint(options: RunPatchLintOptions): Promise<void>;
 /**
  * Prints a patch-lint issue list with `runPatchLint`'s exact severity
  * buckets and skip-lint semantics, throwing on errors unless `skipLint`.
@@ -32,17 +46,22 @@ export declare function runPatchLint(engineDir: string, filesAffected: string[],
  * stored issues through the identical reporter without re-linting.
  */
 export declare function reportPatchLintOutcome(issues: PatchLintIssue[], skipLint?: boolean): void;
+/** Patch identity resolved for an export, from flags or interactive prompts. */
+export interface ExportPatchMetadata {
+    /** Normalized patch name (without order prefix or extension). */
+    patchName: string;
+    /** Category the patch is filed under. */
+    selectedCategory: PatchCategory;
+    /** Human-readable patch description. */
+    description: string;
+}
 /**
  * Resolves patch metadata interactively or from flags, with shared validation.
  * @param options - Export command options
  * @param isInteractive - Whether interactive prompts are allowed
  * @param commandName - Command name for error/help text
  */
-export declare function promptExportPatchMetadata(options: ExportOptions, isInteractive: boolean, commandName: 'export' | 'export-all', config?: FireForgeConfig): Promise<{
-    patchName: string;
-    selectedCategory: PatchCategory;
-    description: string;
-} | null>;
+export declare function promptExportPatchMetadata(options: ExportOptions, isInteractive: boolean, commandName: 'export' | 'export-all', config?: FireForgeConfig): Promise<ExportPatchMetadata | null>;
 /**
  * Confirms whether an export may supersede existing patches.
  * @param patchesDir - Patches directory

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

@@ -15,25 +15,10 @@ import { describePatchNameProblem, normalizePatchDisplayName, PATCH_CATEGORIES,
  * Runs the full patch lint pipeline and reports results. Warnings are always
  * displayed. Errors block the export unless skipLint is true.
  *
- * @param engineDir - Engine root directory
- * @param filesAffected - Files touched by the patch
- * @param diffContent - Raw unified diff string
- * @param config - Project configuration
- * @param skipLint - If true, downgrade errors to warnings
- * @param patchQueueCtx - Optional cross-patch context for ownership
- *   resolution
- * @param ignoreChecks - Optional per-patch set of `check` IDs to suppress
- *   (threaded from `PatchMetadata.lintIgnore`). Surgical alternative to
- *   `--skip-lint` when exactly one advisory rule does not apply to a
- *   specific patch — e.g. `large-patch-lines` on a cohesive branding bundle
- *   that genuinely cannot be split.
- * @param patchTier - Optional explicit tier override (threaded from
- *   `PatchMetadata.tier`). Forces the branding-tier thresholds when set,
- *   independent of the auto-detect allowlist. When the branding tier is
- *   applied, a single `info()` line surfaces the choice so the tier decision
- *   is visible rather than silent.
+ * @param options - See {@link RunPatchLintOptions}
  */
-export async function runPatchLint(engineDir, filesAffected, diffContent, config, skipLint, patchQueueCtx, ignoreChecks, patchTier) {
+export async function runPatchLint(options) {
+    const { engineDir, filesAffected, diffContent, config, skipLint, patchQueueCtx, ignoreChecks, patchTier, } = options;
     // Compute the tier decision independently of the lint pipeline so it can
     // be surfaced even when the rule body emitted no issues — a branding patch
     // under the soft threshold still benefits from operators knowing which
@@ -353,7 +338,7 @@ export async function guardOwnershipOverlap(args) {
         return true;
     s.stop();
     const entries = [...overlap.entries()].sort(([a], [b]) => a.localeCompare(b));
-    warn(`This export would create cross-patch ownership overlap on ${String(entries.length)} file${entries.length === 1 ? '' : 's'}:`);
+    warn(`This export would create cross-patch ownership overlap on ${entries.length} file${entries.length === 1 ? '' : 's'}:`);
     for (const [file, owners] of entries) {
         warn(`  - ${file} already claimed by: ${owners.join(', ')}`);
     }

package/dist/src/commands/export.js

@@ -258,7 +258,16 @@ export async function exportCommand(projectRoot, files, options) {
         const patchQueueCtx = (await pathExists(paths.patches))
             ? await buildPatchQueueContext(paths.patches)
             : undefined;
-        await runPatchLint(paths.engine, filesAffected, diff, config, options.skipLint, patchQueueCtx, exportIgnoreChecks, options.tier);
+        await runPatchLint({
+            engineDir: paths.engine,
+            filesAffected,
+            diffContent: diff,
+            config,
+            skipLint: options.skipLint,
+            patchQueueCtx,
+            ignoreChecks: exportIgnoreChecks,
+            patchTier: options.tier,
+        });
         // Resolve placement (if any flag was given). Placement is mutually
         // exclusive with supersede — the semantics overlap confusingly.
         let placementPlan = null;

package/dist/src/commands/furnace/authoring-config.d.ts

@@ -0,0 +1,13 @@
+import type { FurnaceConfig } from '../../types/index.js';
+/**
+ * Loads `furnace.json` for an authoring command, defaulting to an empty
+ * configuration when the project has none yet.
+ *
+ * `furnace create` and `furnace override` both need this: they are the two
+ * commands that may run before any furnace configuration exists, and both must
+ * treat "no file" as "nothing registered yet" rather than an error. They had a
+ * byte-identical private copy each.
+ * @param projectRoot - Project root to load from.
+ * @returns The parsed configuration, or a fresh default.
+ */
+export declare function loadAuthoringFurnaceConfig(projectRoot: string): Promise<FurnaceConfig>;

package/dist/src/commands/furnace/authoring-config.js

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { createDefaultFurnaceConfig, furnaceConfigExists, loadFurnaceConfig, } from '../../core/furnace-config.js';
+/**
+ * Loads `furnace.json` for an authoring command, defaulting to an empty
+ * configuration when the project has none yet.
+ *
+ * `furnace create` and `furnace override` both need this: they are the two
+ * commands that may run before any furnace configuration exists, and both must
+ * treat "no file" as "nothing registered yet" rather than an error. They had a
+ * byte-identical private copy each.
+ * @param projectRoot - Project root to load from.
+ * @returns The parsed configuration, or a fresh default.
+ */
+export async function loadAuthoringFurnaceConfig(projectRoot) {
+    if (await furnaceConfigExists(projectRoot)) {
+        return loadFurnaceConfig(projectRoot);
+    }
+    return createDefaultFurnaceConfig();
+}

package/dist/src/commands/furnace/chrome-doc-remove.js

@@ -10,7 +10,7 @@ import { loadConfig } from '../../core/config.js';
 import { stdioIsInteractive } from '../../core/destructive.js';
 import { completeJournalRollback, runFurnaceMutation, } from '../../core/furnace-operation.js';
 import { assertFurnaceEngineReady } from '../../core/furnace-precondition.js';
-import { createRollbackJournal, snapshotDir, snapshotFile } from '../../core/furnace-rollback.js';
+import { createRollbackJournal, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { pathExists, readText, removeDir, removeFile, writeText } from '../../utils/fs.js';
 import { cancel, info, intro, isCancel, note, outro } from '../../utils/logger.js';