@hominis/fireforge 0.10.1 → 0.11.0

package/dist/src/commands/furnace/sync.js

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { getProjectPaths, loadConfig } from '../../core/config.js';
+import { applyAllComponents } from '../../core/furnace-apply.js';
+import { logApplyResult } from '../../core/furnace-apply-output.js';
+import { furnaceConfigExists, loadFurnaceConfig } from '../../core/furnace-config.js';
+import { runFurnaceMutation } from '../../core/furnace-operation.js';
+import { findOverrideBaseVersionDrift, formatOverrideBaseVersionDriftWarning, } from '../../core/furnace-version-drift.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { pathExists } from '../../utils/fs.js';
+import { info, intro, outro, spinner, warn } from '../../utils/logger.js';
+import { furnaceRefreshCommand } from './refresh.js';
+/**
+ * Runs the furnace sync command: detects overrides with baseVersion drift,
+ * refreshes them (three-way merge), and re-applies all components.
+ *
+ * This is the recommended single command to run after `fireforge download`
+ * updates the Firefox source.
+ *
+ * @param projectRoot - Root directory of the project
+ * @param options - Sync options
+ */
+export async function furnaceSyncCommand(projectRoot, options = {}) {
+    intro('Furnace Sync');
+    // Pre-flight checks
+    const paths = getProjectPaths(projectRoot);
+    if (!(await pathExists(paths.engine))) {
+        throw new FurnaceError('Engine directory not found. Run "fireforge download" first.');
+    }
+    if (!(await furnaceConfigExists(projectRoot))) {
+        throw new FurnaceError('No furnace.json found. Run "fireforge furnace create" or "fireforge furnace override" to get started.');
+    }
+    const config = await loadFurnaceConfig(projectRoot);
+    const forgeConfig = await loadConfig(projectRoot);
+    const overrideCount = Object.keys(config.overrides).length;
+    const customCount = Object.keys(config.custom).length;
+    if (overrideCount === 0 && customCount === 0) {
+        info('No components to sync.');
+        outro('Done');
+        return;
+    }
+    // Phase 1: Detect and report baseVersion drift
+    const driftEntries = findOverrideBaseVersionDrift(config, forgeConfig.firefox.version);
+    if (driftEntries.length > 0) {
+        info(`Found ${driftEntries.length} override(s) with baseVersion drift:`);
+        for (const entry of driftEntries) {
+            warn(formatOverrideBaseVersionDriftWarning(entry));
+        }
+        // Phase 2: Refresh drifted overrides via three-way merge
+        info('\nRefreshing drifted overrides...');
+        await furnaceRefreshCommand(projectRoot, undefined, {
+            all: true,
+            ...(options.dryRun !== undefined ? { dryRun: options.dryRun } : {}),
+            ...(options.strategy !== undefined ? { strategy: options.strategy } : {}),
+        });
+    }
+    else {
+        info('All overrides are up-to-date with the current Firefox version.');
+    }
+    // Phase 3: Re-apply all components to the engine
+    if (!options.dryRun) {
+        info('\nApplying all components to engine...');
+        const applySpinner = spinner('Applying components...');
+        const result = await runFurnaceMutation(projectRoot, 'apply-rollback', (ctx) => applyAllComponents(projectRoot, false, { operationContext: ctx }), { dryRun: false });
+        applySpinner.stop('Components applied');
+        logApplyResult(result, false);
+        const appliedWithStepErrorsCount = result.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
+        const totalFailures = result.errors.length + appliedWithStepErrorsCount;
+        if (totalFailures > 0) {
+            throw new FurnaceError(`${totalFailures} component${totalFailures === 1 ? '' : 's'} failed to apply cleanly`);
+        }
+        outro(`Sync complete — ${result.applied.length} applied, ${result.skipped.length} skipped`);
+    }
+    else {
+        outro('Dry run complete');
+    }
+}
+//# sourceMappingURL=sync.js.map

package/dist/src/commands/furnace/validate.d.ts

@@ -2,5 +2,8 @@
  * Runs the furnace validate command to perform static analysis on components.
  * @param projectRoot - Root directory of the project
  * @param name - Optional component name to validate (validates all if omitted)
+ * @param options - Optional command options (e.g. --fix)
  */
-export declare function furnaceValidateCommand(projectRoot: string, name?: string): Promise<void>;
+export declare function furnaceValidateCommand(projectRoot: string, name?: string, options?: {
+    fix?: boolean;
+}): Promise<void>;

package/dist/src/commands/furnace/validate.js

@@ -1,17 +1,96 @@
 // SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { getProjectPaths } from '../../core/config.js';
 import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, } from '../../core/furnace-config.js';
+import { addCustomElementRegistration, addJarMnEntries } from '../../core/furnace-registration.js';
 import { validateAllComponents, validateComponent } from '../../core/furnace-validate.js';
 import { FurnaceError } from '../../errors/furnace.js';
 import { pathExists } from '../../utils/fs.js';
-import { info, intro, note, outro, success } from '../../utils/logger.js';
+import { info, intro, note, outro, success, warn } from '../../utils/logger.js';
 import { displayValidationIssues } from './validation-output.js';
+/** Checks that auto-fix can correct. */
+const FIXABLE_CHECKS = new Set([
+    'missing-jar-mn-mjs',
+    'missing-jar-mn-css',
+    'wrong-registration-pattern',
+]);
+/**
+ * Auto-fixes registration issues that have deterministic solutions.
+ * @returns Number of issues fixed
+ */
+async function autoFixIssues(projectRoot, issues) {
+    const { engine: engineDir } = getProjectPaths(projectRoot);
+    const config = await loadFurnaceConfig(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    let fixed = 0;
+    // Group jar.mn fixes per component to batch them
+    const jarMnFixesByComponent = new Map();
+    for (const issue of issues) {
+        if (!FIXABLE_CHECKS.has(issue.check))
+            continue;
+        const customConfig = config.custom[issue.component];
+        if (!customConfig)
+            continue;
+        if (issue.check === 'missing-jar-mn-mjs' || issue.check === 'missing-jar-mn-css') {
+            const ext = issue.check === 'missing-jar-mn-mjs' ? '.mjs' : '.css';
+            const fileName = `${issue.component}${ext}`;
+            const existing = jarMnFixesByComponent.get(issue.component) ?? [];
+            existing.push(fileName);
+            jarMnFixesByComponent.set(issue.component, existing);
+        }
+    }
+    // Fix jar.mn entries
+    for (const [componentName, files] of jarMnFixesByComponent) {
+        try {
+            await addJarMnEntries(engineDir, componentName, files);
+            fixed += files.length;
+            info(`Fixed: added ${files.join(', ')} to jar.mn for ${componentName}`);
+        }
+        catch (err) {
+            warn(`Could not fix jar.mn for ${componentName}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // Fix missing customElements.js registrations
+    for (const issue of issues) {
+        if (issue.check !== 'wrong-registration-pattern')
+            continue;
+        // wrong-registration-pattern means it IS registered, but in the wrong block.
+        // We don't auto-fix this as it requires moving code between blocks, which
+        // is too risky. Only fix truly missing registrations.
+    }
+    // Check for components that are missing from customElements.js entirely
+    // (detected by post-apply consistency, not by validate — but we can check here)
+    for (const [componentName, customConfig] of Object.entries(config.custom)) {
+        if (!customConfig.register)
+            continue;
+        const componentDir = join(furnacePaths.customDir, componentName);
+        if (!(await pathExists(componentDir)))
+            continue;
+        const entries = await readdir(componentDir, { withFileTypes: true });
+        const hasMjs = entries.some((e) => e.isFile() && e.name === `${componentName}.mjs`);
+        if (!hasMjs)
+            continue;
+        const modulePath = `chrome://global/content/elements/${componentName}.mjs`;
+        try {
+            await addCustomElementRegistration(engineDir, componentName, modulePath);
+            // addCustomElementRegistration is idempotent — it returns without error
+            // if already registered. We only count it as fixed if a matching issue
+            // existed in the input.
+        }
+        catch {
+            // Ignore — idempotent call, may already be registered
+        }
+    }
+    return fixed;
+}
 /**
  * Runs the furnace validate command to perform static analysis on components.
  * @param projectRoot - Root directory of the project
  * @param name - Optional component name to validate (validates all if omitted)
+ * @param options - Optional command options (e.g. --fix)
  */
-export async function furnaceValidateCommand(projectRoot, name) {
+export async function furnaceValidateCommand(projectRoot, name, options = {}) {
     intro('Furnace Validate');
     if (!(await furnaceConfigExists(projectRoot))) {
         throw new FurnaceError('No furnace.json found. Run "fireforge furnace create" or "fireforge furnace override" to get started.');
@@ -21,6 +100,7 @@ export async function furnaceValidateCommand(projectRoot, name) {
     let totalErrors = 0;
     let totalWarnings = 0;
     let componentCount;
+    let allIssues = [];
     if (name) {
         // --- Single component validation ---
         let type;
@@ -46,6 +126,7 @@ export async function furnaceValidateCommand(projectRoot, name) {
         }
         const issues = await validateComponent(componentDir, name, type, config, projectRoot);
         componentCount = 1;
+        allIssues = issues;
         if (issues.length === 0) {
             success(`${name} — all checks passed`);
         }
@@ -70,6 +151,7 @@ export async function furnaceValidateCommand(projectRoot, name) {
         const results = await validateAllComponents(projectRoot);
         componentCount = results.size;
         for (const [componentName, issues] of results) {
+            allIssues.push(...issues);
             if (issues.length === 0) {
                 success(`${componentName} — all checks passed`);
             }
@@ -80,10 +162,24 @@ export async function furnaceValidateCommand(projectRoot, name) {
             }
         }
     }
+    // Auto-fix fixable issues when --fix is passed
+    if (options.fix && allIssues.length > 0) {
+        const fixableIssues = allIssues.filter((issue) => FIXABLE_CHECKS.has(issue.check));
+        if (fixableIssues.length > 0) {
+            const fixedCount = await autoFixIssues(projectRoot, fixableIssues);
+            if (fixedCount > 0) {
+                info(`\nAuto-fixed ${fixedCount} issue(s). Re-run validate to confirm.`);
+            }
+        }
+        else {
+            info('\nNo auto-fixable issues found. Remaining issues require manual resolution.');
+        }
+    }
     // Summary
     note(`${totalErrors} error(s), ${totalWarnings} warning(s) across ${componentCount} component(s)`, 'Validation Summary');
     if (totalErrors > 0) {
-        info('Fix the errors above and run "fireforge furnace validate" again.');
+        const fixHint = options.fix ? '' : ' Use --fix to auto-correct registration issues.';
+        info(`Fix the errors above and run "fireforge furnace validate" again.${fixHint}`);
         throw new FurnaceError(`Validation failed with ${totalErrors} error(s).`);
     }
     outro('Validation passed');

package/dist/src/commands/furnace/validation-output.d.ts

@@ -1,7 +1,30 @@
-import type { ValidationIssue } from '../../types/furnace.js';
+import type { getFurnacePaths } from '../../core/furnace-config.js';
+import type { FurnaceConfig, ValidationIssue } from '../../types/furnace.js';
+import { type SpinnerHandle } from '../../utils/logger.js';
 /**
  * Displays validation issues and returns aggregated error and warning counts.
  * @param issues - Validation issues to render
  * @returns Tuple of [errorCount, warningCount]
  */
 export declare function displayValidationIssues(issues: ValidationIssue[]): [number, number];
+export type ValidationResult = {
+    done: true;
+} | {
+    done: false;
+    totalErrors: number;
+    totalWarnings: number;
+    componentCount: number;
+    skippedValidationCount: number;
+};
+/**
+ * Runs the validation phase of a furnace deploy, checking all or a single component.
+ * @param validateSpinner - Active spinner handle for progress display
+ * @param name - Optional component name (validates all if omitted)
+ * @param config - Loaded Furnace configuration
+ * @param furnacePaths - Resolved Furnace workspace paths
+ * @param failedComponents - Names of components whose apply step failed
+ * @param isDryRun - Whether deploy is running in dry-run mode
+ * @param projectRoot - Root directory of the project
+ * @returns Validation counts, or `done: true` if the caller should early-return
+ */
+export declare function runDeployValidation(validateSpinner: SpinnerHandle, name: string | undefined, config: FurnaceConfig, furnacePaths: ReturnType<typeof getFurnacePaths>, failedComponents: Set<string>, isDryRun: boolean, projectRoot: string): Promise<ValidationResult>;

package/dist/src/commands/furnace/validation-output.js

@@ -1,4 +1,9 @@
-import { error, warn } from '../../utils/logger.js';
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { validateAllComponents, validateComponent } from '../../core/furnace-validate.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { pathExists } from '../../utils/fs.js';
+import { error, info, outro, success, warn } from '../../utils/logger.js';
 /**
  * Displays validation issues and returns aggregated error and warning counts.
  * @param issues - Validation issues to render
@@ -19,4 +24,91 @@ export function displayValidationIssues(issues) {
     }
     return [errors, warnings];
 }
+function resolveNamedValidationTarget(name, config, furnacePaths) {
+    if (name in config.overrides) {
+        return {
+            type: 'override',
+            componentDir: join(furnacePaths.overridesDir, name),
+        };
+    }
+    if (name in config.custom) {
+        return {
+            type: 'custom',
+            componentDir: join(furnacePaths.customDir, name),
+        };
+    }
+    if (config.stock.includes(name)) {
+        return 'stock';
+    }
+    throw new FurnaceError(`Component "${name}" not found in furnace.json.`, name);
+}
+/**
+ * Runs the validation phase of a furnace deploy, checking all or a single component.
+ * @param validateSpinner - Active spinner handle for progress display
+ * @param name - Optional component name (validates all if omitted)
+ * @param config - Loaded Furnace configuration
+ * @param furnacePaths - Resolved Furnace workspace paths
+ * @param failedComponents - Names of components whose apply step failed
+ * @param isDryRun - Whether deploy is running in dry-run mode
+ * @param projectRoot - Root directory of the project
+ * @returns Validation counts, or `done: true` if the caller should early-return
+ */
+export async function runDeployValidation(validateSpinner, name, config, furnacePaths, failedComponents, isDryRun, projectRoot) {
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    let componentCount = 0;
+    let skippedValidationCount = 0;
+    if (name && failedComponents.has(name)) {
+        skippedValidationCount = 1;
+        validateSpinner.stop('Validation skipped');
+        warn(`Skipping validation for ${name} because apply failed.`);
+    }
+    else if (name) {
+        const target = resolveNamedValidationTarget(name, config, furnacePaths);
+        if (target === 'stock') {
+            validateSpinner.stop('Validation skipped');
+            info(`"${name}" is a stock component. Stock components are not validated locally.`);
+            outro(isDryRun ? 'Dry run complete' : 'Deploy complete');
+            return { done: true };
+        }
+        if (!(await pathExists(target.componentDir))) {
+            validateSpinner.stop('Validation failed');
+            throw new FurnaceError(`Component directory not found for "${name}".`, name);
+        }
+        const issues = await validateComponent(target.componentDir, name, target.type, config, projectRoot);
+        componentCount = 1;
+        validateSpinner.stop('Validation complete');
+        if (issues.length === 0) {
+            success(`${name} — all checks passed`);
+        }
+        else {
+            const [errors, warnings] = displayValidationIssues(issues);
+            totalErrors += errors;
+            totalWarnings += warnings;
+        }
+    }
+    else {
+        const results = await validateAllComponents(projectRoot);
+        validateSpinner.stop('Validation complete');
+        for (const [componentName, issues] of results) {
+            if (failedComponents.has(componentName)) {
+                skippedValidationCount++;
+                continue;
+            }
+            componentCount++;
+            if (issues.length === 0) {
+                success(`${componentName} — all checks passed`);
+            }
+            else {
+                const [errors, warnings] = displayValidationIssues(issues);
+                totalErrors += errors;
+                totalWarnings += warnings;
+            }
+        }
+        if (skippedValidationCount > 0) {
+            warn(`Skipped validation for ${skippedValidationCount} component(s) because their apply step failed.`);
+        }
+    }
+    return { done: false, totalErrors, totalWarnings, componentCount, skippedValidationCount };
+}
 //# sourceMappingURL=validation-output.js.map

package/dist/src/commands/import.js

@@ -138,7 +138,8 @@ async function checkEngineDrift(engineDir, baseCommit, forceImport) {
  * @param options - Import options
  */
 export async function importCommand(projectRoot, options = {}) {
-    intro('FireForge Import');
+    const isDryRun = options.dryRun === true;
+    intro(isDryRun ? 'FireForge Import (dry run)' : 'FireForge Import');
     const continueOnFailure = options.continue ?? false;
     const forceImport = options.force ?? false;
     const paths = getProjectPaths(projectRoot);
@@ -148,7 +149,7 @@ export async function importCommand(projectRoot, options = {}) {
     }
     // Engine consistency check before applying patches
     const state = await loadState(projectRoot);
-    if (state.baseCommit) {
+    if (state.baseCommit && !isDryRun) {
         const shouldContinue = await checkEngineDrift(paths.engine, state.baseCommit, forceImport);
         if (!shouldContinue)
             return;
@@ -195,10 +196,33 @@ export async function importCommand(projectRoot, options = {}) {
         }
         info('Run "fireforge doctor" for more details.\n');
     }
+    // Dry-run: list patches that would be applied and exit
+    if (isDryRun) {
+        if (manifest) {
+            const patches = options.until
+                ? manifest.patches.filter((p) => {
+                    const untilPatch = manifest.patches.find((u) => u.filename === options.until || u.filename === `${options.until}.patch`);
+                    return untilPatch ? p.order <= untilPatch.order : true;
+                })
+                : manifest.patches;
+            info(`\n[dry-run] Would apply ${patches.length} patch(es) in order:`);
+            for (const patch of patches) {
+                info(`  ${patch.filename} (${patch.filesAffected.length} file${patch.filesAffected.length === 1 ? '' : 's'})`);
+            }
+        }
+        else {
+            info(`\n[dry-run] Would apply ${patchCount} patch(es)`);
+        }
+        outro('Dry run complete — no changes made');
+        return;
+    }
     await checkUncommittedPatchFiles(paths.engine, paths.patches, forceImport);
     const s = spinner('Applying patches...');
     try {
-        const summary = await applyPatchesWithContinue(paths.patches, paths.engine, continueOnFailure);
+        const summary = await applyPatchesWithContinue(paths.patches, paths.engine, {
+            continueOnFailure,
+            untilFilename: options.until,
+        });
         // Handle failures
         if (summary.failed.length > 0) {
             s.error(`${summary.failed.length} patch(es) failed`);
@@ -234,8 +258,17 @@ export function registerImport(program, { getProjectRoot, withErrorHandling }) {
         .description('Apply patches from the patches directory')
         .option('--continue', 'Continue applying patches even if one fails')
         .option('-f, --force', 'Proceed despite engine drift and overwrite unmanaged changes in patch-touched files')
+        .option('--until <patch>', 'Apply patches only up to and including this patch (alias: --stop-at)')
+        .option('--stop-at <patch>', 'Alias for --until')
+        .option('--dry-run', 'Preview which patches would be applied without modifying the engine')
         .action(withErrorHandling(async (options) => {
-        await importCommand(getProjectRoot(), pickDefined(options));
+        // Accept both spellings; --until wins when both are passed.
+        const merged = { ...options };
+        if (merged.until === undefined && merged.stopAt !== undefined) {
+            merged.until = merged.stopAt;
+        }
+        delete merged.stopAt;
+        await importCommand(getProjectRoot(), pickDefined(merged));
     }));
 }
 //# sourceMappingURL=import.js.map

package/dist/src/commands/lint.js

@@ -6,7 +6,7 @@ import { getStatusWithCodes, hasChanges, isGitRepository } from '../core/git.js'
 import { getAllDiff, getDiffForFilesAgainstHead } from '../core/git-diff.js';
 import { getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, } from '../core/git-status.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
-import { lintExportedPatch } from '../core/patch-lint.js';
+import { buildPatchQueueContext, lintExportedPatch, lintPatchQueue } from '../core/patch-lint.js';
 import { GeneralError } from '../errors/base.js';
 import { pathExists } from '../utils/fs.js';
 import { info, intro, outro, success, warn } from '../utils/logger.js';
@@ -85,7 +85,16 @@ export async function lintCommand(projectRoot, files) {
     }
     const config = await loadConfig(projectRoot);
     const filesAffected = extractAffectedFiles(diff);
-    const issues = await lintExportedPatch(paths.engine, filesAffected, diff, config);
+    const issues = [
+        ...(await lintExportedPatch(paths.engine, filesAffected, diff, config)),
+    ];
+    // Cross-patch rules operate over the whole queue, so run them whenever a
+    // patches directory exists — they surface duplicate /dev/null creations
+    // and forward-import chains that the per-patch orchestrator cannot see.
+    if (await pathExists(paths.patches)) {
+        const ctx = await buildPatchQueueContext(paths.patches);
+        issues.push(...lintPatchQueue(ctx));
+    }
     if (issues.length === 0) {
         success('No lint issues found.');
         outro('Lint passed');

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

@@ -0,0 +1,39 @@
+/**
+ * Central manifest of every top-level FireForge command.
+ *
+ * The manifest is iterated from {@link createProgram} in cli.ts so that
+ * adding a new command is a one-line change here instead of a three-line
+ * edit (import + registration call + ordering) spread across cli.ts. It
+ * also gives documentation tooling and tests a single authoritative list
+ * of commands to enumerate.
+ *
+ * The order of entries in {@link COMMAND_MANIFEST} is the order commands
+ * appear in `fireforge --help`; it is intentional, not alphabetical, and
+ * groups related commands together.
+ */
+import type { CommandRegistrar } from '../types/cli.js';
+/**
+ * A single entry in the command manifest.
+ */
+export interface CommandManifestEntry {
+    /**
+     * Human-readable command name, matching the first token of the
+     * command line (e.g. `build`, `furnace`). Informational only — the
+     * authoritative command string lives inside each registrar's
+     * `.command(...)` call — but useful for documentation, manifest
+     * introspection, and test assertions.
+     */
+    name: string;
+    /**
+     * Short one-line group label, used purely for grouping in generated
+     * documentation. Not surfaced in the CLI itself.
+     */
+    group: 'project' | 'workflow' | 'engine' | 'diagnostics' | 'components';
+    /** Registers the command (and any subcommands) on the Commander program. */
+    register: CommandRegistrar;
+}
+/**
+ * Ordered list of every top-level FireForge command. cli.ts iterates this
+ * array to register commands in a single loop.
+ */
+export declare const COMMAND_MANIFEST: readonly CommandManifestEntry[];

package/dist/src/commands/manifest.js

@@ -0,0 +1,59 @@
+import { registerBootstrap } from './bootstrap.js';
+import { registerBuild } from './build.js';
+import { registerConfig } from './config.js';
+import { registerDiscard } from './discard.js';
+import { registerDoctor } from './doctor.js';
+import { registerDownload } from './download.js';
+import { registerExport } from './export.js';
+import { registerExportAll } from './export-all.js';
+import { registerFurnace } from './furnace/index.js';
+import { registerImport } from './import.js';
+import { registerLint } from './lint.js';
+import { registerPackage } from './package.js';
+import { registerPatch } from './patch/index.js';
+import { registerReExport } from './re-export.js';
+import { registerRebase } from './rebase.js';
+import { registerRegister } from './register.js';
+import { registerReset } from './reset.js';
+import { registerResolve } from './resolve.js';
+import { registerRun } from './run.js';
+import { registerSetup } from './setup.js';
+import { registerStatus } from './status.js';
+import { registerTest } from './test.js';
+import { registerToken } from './token.js';
+import { registerVerify } from './verify.js';
+import { registerWatch } from './watch.js';
+import { registerWire } from './wire.js';
+/**
+ * Ordered list of every top-level FireForge command. cli.ts iterates this
+ * array to register commands in a single loop.
+ */
+export const COMMAND_MANIFEST = [
+    { name: 'setup', group: 'project', register: registerSetup },
+    { name: 'download', group: 'engine', register: registerDownload },
+    { name: 'bootstrap', group: 'engine', register: registerBootstrap },
+    { name: 'import', group: 'workflow', register: registerImport },
+    { name: 'resolve', group: 'workflow', register: registerResolve },
+    { name: 'build', group: 'workflow', register: registerBuild },
+    { name: 'run', group: 'workflow', register: registerRun },
+    { name: 'status', group: 'workflow', register: registerStatus },
+    { name: 'reset', group: 'workflow', register: registerReset },
+    { name: 'discard', group: 'workflow', register: registerDiscard },
+    { name: 'export', group: 'workflow', register: registerExport },
+    { name: 'export-all', group: 'workflow', register: registerExportAll },
+    { name: 're-export', group: 'workflow', register: registerReExport },
+    { name: 'patch', group: 'workflow', register: registerPatch },
+    { name: 'rebase', group: 'workflow', register: registerRebase },
+    { name: 'package', group: 'workflow', register: registerPackage },
+    { name: 'watch', group: 'workflow', register: registerWatch },
+    { name: 'test', group: 'workflow', register: registerTest },
+    { name: 'config', group: 'project', register: registerConfig },
+    { name: 'doctor', group: 'diagnostics', register: registerDoctor },
+    { name: 'register', group: 'workflow', register: registerRegister },
+    { name: 'wire', group: 'workflow', register: registerWire },
+    { name: 'token', group: 'components', register: registerToken },
+    { name: 'lint', group: 'diagnostics', register: registerLint },
+    { name: 'verify', group: 'diagnostics', register: registerVerify },
+    { name: 'furnace', group: 'components', register: registerFurnace },
+];
+//# sourceMappingURL=manifest.js.map

package/dist/src/commands/patch/delete.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `fireforge patch delete <name>` — removes a patch from the queue.
+ *
+ * Destructive: refuses when a later patch imports a module owned by the
+ * target (that would leave a dangling forward import), prompts for
+ * confirmation interactively, requires `--yes` for non-TTY, supports
+ * `--dry-run`, and appends to `patches/.fireforge-history.jsonl` on success.
+ */
+import { Command } from 'commander';
+import type { CommandContext } from '../../types/cli.js';
+import type { PatchDeleteOptions } from '../../types/commands/index.js';
+/**
+ * Runs the `patch delete` command: removes a patch file and its manifest
+ * row atomically, refusing when a later patch imports a leaf owned by the
+ * target.
+ *
+ * @param projectRoot - Project root directory
+ * @param identifier - Patch filename or ordinal number to delete
+ * @param options - Command options
+ */
+export declare function patchDeleteCommand(projectRoot: string, identifier: string, options?: PatchDeleteOptions): Promise<void>;
+/**
+ * Registers the `patch delete` subcommand on the `patch` parent.
+ *
+ * @param parent - Parent Commander command
+ * @param context - Shared CLI registration context
+ */
+export declare function registerPatchDelete(parent: Command, context: CommandContext): void;