@hominis/fireforge 0.10.1 → 0.11.0

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

@@ -0,0 +1,308 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getProjectPaths, loadConfig } from '../../core/config.js';
+import { getFurnacePaths, loadFurnaceConfig, updateFurnaceState, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { isComponentSourceFile, resolveFtlDir, tagNameToClassName, } from '../../core/furnace-constants.js';
+import { recordFurnaceRollbackFailure, runFurnaceMutation } from '../../core/furnace-operation.js';
+import { addCustomElementRegistration, addJarMnEntries, removeCustomElementRegistration, removeJarMnEntries, } from '../../core/furnace-registration.js';
+import { CUSTOM_ELEMENT_TAG_PATTERN, CUSTOM_ELEMENT_TAG_RULES, } from '../../core/furnace-registration-validate.js';
+import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
+import { getStoriesDir } from '../../core/furnace-stories.js';
+import { InvalidArgumentError } from '../../errors/base.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { toError } from '../../utils/errors.js';
+import { copyFile, ensureDir, pathExists, readText, removeDir, removeFile, writeText, } from '../../utils/fs.js';
+import { info, intro, note, outro, warn } from '../../utils/logger.js';
+function updateConfigForCustomRename(config, oldName, newName) {
+    const oldConfig = config.custom[oldName];
+    if (!oldConfig)
+        return;
+    config.custom[newName] = {
+        ...oldConfig,
+        targetPath: oldConfig.targetPath.replace(new RegExp(`(^|/)${oldName}$`), `$1${newName}`),
+    };
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- idiomatic key removal from config record
+    delete config.custom[oldName];
+    // Update composes references in other components
+    for (const customConfig of Object.values(config.custom)) {
+        if (customConfig.composes) {
+            customConfig.composes = customConfig.composes.map((ref) => (ref === oldName ? newName : ref));
+        }
+    }
+}
+function updateConfigForOverrideRename(config, oldName, newName) {
+    const oldConfig = config.overrides[oldName];
+    if (!oldConfig)
+        return;
+    config.overrides[newName] = { ...oldConfig };
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- idiomatic key removal from config record
+    delete config.overrides[oldName];
+}
+/**
+ * Derives the test file name for a component, matching the convention used by
+ * `furnace create --with-tests`.
+ */
+function deriveTestFileName(componentName, binaryName) {
+    const strippedName = componentName.startsWith('moz-') ? componentName.slice(4) : componentName;
+    const withoutBinaryPrefix = strippedName.startsWith(binaryName + '-')
+        ? strippedName.slice(binaryName.length + 1)
+        : strippedName;
+    const underscored = withoutBinaryPrefix.replace(/-/g, '_');
+    return `browser_${binaryName}_${underscored}.js`;
+}
+/**
+ * Renames test files created by `furnace create --with-tests` in the engine
+ * test directory. Best-effort: failures are logged as warnings but do not
+ * block the rename.
+ */
+async function renameTestFiles(engineDir, projectRoot, oldName, newName, journal) {
+    let forgeConfig;
+    try {
+        forgeConfig = await loadConfig(projectRoot);
+    }
+    catch {
+        return; // Cannot determine test paths without config.
+    }
+    const binaryName = forgeConfig.binaryName;
+    const oldTestFileName = deriveTestFileName(oldName, binaryName);
+    const newTestFileName = deriveTestFileName(newName, binaryName);
+    const testDir = join(engineDir, 'browser/base/content/test', binaryName);
+    if (!(await pathExists(testDir)))
+        return;
+    // Rename the test JS file
+    const oldTestPath = join(testDir, oldTestFileName);
+    const newTestPath = join(testDir, newTestFileName);
+    if (await pathExists(oldTestPath)) {
+        try {
+            await snapshotFile(journal, oldTestPath);
+            const content = await readText(oldTestPath);
+            await writeText(newTestPath, content);
+            await removeFile(oldTestPath);
+            info(`Renamed test file: ${oldTestFileName} → ${newTestFileName}`);
+        }
+        catch (error) {
+            warn(`Could not rename test file — ${toError(error).message}. Rename it manually if needed.`);
+        }
+    }
+    // Update browser.toml entry
+    const tomlPath = join(testDir, 'browser.toml');
+    if (await pathExists(tomlPath)) {
+        try {
+            const toml = await readText(tomlPath);
+            if (toml.includes(`["${oldTestFileName}"]`)) {
+                await snapshotFile(journal, tomlPath);
+                const updated = toml.replace(`["${oldTestFileName}"]`, `["${newTestFileName}"]`);
+                await writeText(tomlPath, updated);
+                info(`Updated browser.toml: ${oldTestFileName} → ${newTestFileName}`);
+            }
+        }
+        catch (error) {
+            warn(`Could not update browser.toml — ${toError(error).message}. Update it manually if needed.`);
+        }
+    }
+}
+/**
+ * Performs the transactional rename mutation inside a furnace lock.
+ */
+async function performRenameMutations(args) {
+    const { projectRoot, oldName, newName, oldDir, newDir, isCustom, componentType, config } = args;
+    const oldClassName = tagNameToClassName(oldName);
+    const newClassName = tagNameToClassName(newName);
+    await runFurnaceMutation(projectRoot, 'rename-rollback', async (ctx) => {
+        const journal = createRollbackJournal();
+        ctx.registerJournal(journal);
+        try {
+            await snapshotDir(journal, oldDir);
+            await snapshotFile(journal, args.furnaceConfigPath);
+            // 1. Create new directory with renamed files and updated content
+            await ensureDir(newDir);
+            const entries = await readdir(oldDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isFile())
+                    continue;
+                const oldFileName = entry.name;
+                const newFileName = oldFileName.replace(oldName, newName);
+                const oldPath = join(oldDir, oldFileName);
+                const newPath = join(newDir, newFileName);
+                if (isComponentSourceFile(oldFileName)) {
+                    let content = await readText(oldPath);
+                    // Use word-boundary-aware patterns so substrings in other
+                    // identifiers (e.g. "moz-panel" inside "moz-panel-group") are
+                    // not replaced.
+                    const tagPattern = new RegExp(`(?<![\\w-])${oldName.replace(/-/g, '\\-')}(?![\\w-])`, 'g');
+                    const classPattern = new RegExp(`\\b${oldClassName}\\b`, 'g');
+                    content = content.replace(tagPattern, newName);
+                    content = content.replace(classPattern, newClassName);
+                    await writeText(newPath, content);
+                }
+                else {
+                    await copyFile(oldPath, newPath);
+                }
+            }
+            // 2. Update furnace.json
+            if (isCustom) {
+                updateConfigForCustomRename(config, oldName, newName);
+            }
+            else {
+                updateConfigForOverrideRename(config, oldName, newName);
+            }
+            await writeFurnaceConfig(projectRoot, config);
+            // 3. Update engine registrations (custom components only)
+            if (isCustom && config.custom[newName]?.register && (await pathExists(args.engineDir))) {
+                const ftlDir = resolveFtlDir(config.ftlBasePath);
+                await updateEngineRegistrations(args.engineDir, oldName, newName, newDir, ftlDir, journal);
+            }
+            // 4. Re-key furnace-state.json checksums from old name to new name
+            await rekeyStateChecksums(args.projectRoot, componentType, oldName, newName);
+            // 5. Remove old directory
+            await removeDir(oldDir);
+            // 6. Clean up stale Storybook story file for the old name (if it exists
+            // from a previous `furnace preview` session). The next preview will
+            // regenerate the story under the new name via `syncStories`.
+            const oldStoryPath = join(getStoriesDir(args.engineDir), 'furnace', `${oldName}.stories.mjs`);
+            if (await pathExists(oldStoryPath)) {
+                await snapshotFile(journal, oldStoryPath);
+                await removeFile(oldStoryPath);
+                info(`Deleted stale story file: ${oldName}.stories.mjs`);
+            }
+            // 7. Rename test files created by `furnace create --with-tests` (custom only).
+            if (isCustom && (await pathExists(args.engineDir))) {
+                await renameTestFiles(args.engineDir, projectRoot, oldName, newName, journal);
+            }
+            info(`Renamed ${componentType} component: ${oldName} → ${newName}`);
+        }
+        catch (error) {
+            try {
+                if (await pathExists(newDir)) {
+                    await removeDir(newDir);
+                }
+            }
+            catch {
+                // Best effort cleanup
+            }
+            try {
+                await restoreRollbackJournalOrThrow(journal, `Failed to rename component "${oldName}" to "${newName}"`);
+            }
+            catch (rollbackError) {
+                await recordFurnaceRollbackFailure(projectRoot, 'rename-rollback', toError(rollbackError).message);
+                throw rollbackError;
+            }
+            throw error;
+        }
+    });
+}
+/**
+ * Re-keys checksum entries in furnace-state.json from the old component name
+ * to the new name so that `doctor` doesn't flag stale entries and the next
+ * `apply` can correctly detect whether the renamed component has changed.
+ */
+async function rekeyStateChecksums(projectRoot, componentType, oldName, newName) {
+    const oldPrefix = `${componentType}/${oldName}/`;
+    const newPrefix = `${componentType}/${newName}/`;
+    await updateFurnaceState(projectRoot, (state) => {
+        const result = { ...state };
+        for (const field of ['appliedChecksums', 'engineChecksums']) {
+            const checksums = state[field];
+            if (!checksums)
+                continue;
+            const updated = {};
+            for (const [key, value] of Object.entries(checksums)) {
+                if (key.startsWith(oldPrefix)) {
+                    updated[newPrefix + key.slice(oldPrefix.length)] = value;
+                }
+                else {
+                    updated[key] = value;
+                }
+            }
+            result[field] = updated;
+        }
+        return result;
+    });
+}
+async function updateEngineRegistrations(engineDir, oldName, newName, newDir, ftlDir, journal) {
+    const customElementsPath = join(engineDir, 'toolkit/content/customElements.js');
+    const jarMnPath = join(engineDir, 'toolkit/content/jar.mn');
+    if (await pathExists(customElementsPath)) {
+        await snapshotFile(journal, customElementsPath);
+        await removeCustomElementRegistration(engineDir, oldName);
+        await addCustomElementRegistration(engineDir, newName, `chrome://global/content/elements/${newName}.mjs`);
+    }
+    if (await pathExists(jarMnPath)) {
+        await snapshotFile(journal, jarMnPath);
+        await removeJarMnEntries(engineDir, oldName);
+        const files = (await readdir(newDir, { withFileTypes: true }))
+            .filter((e) => e.isFile() && (e.name.endsWith('.mjs') || e.name.endsWith('.css')))
+            .map((e) => e.name);
+        if (files.length > 0) {
+            await addJarMnEntries(engineDir, newName, files);
+        }
+    }
+    // Rename FTL localization files in the engine locale directory
+    const ftlDirPath = join(engineDir, ftlDir);
+    const oldFtlPath = join(ftlDirPath, `${oldName}.ftl`);
+    const newFtlPath = join(ftlDirPath, `${newName}.ftl`);
+    if (await pathExists(oldFtlPath)) {
+        await snapshotFile(journal, oldFtlPath);
+        const ftlContent = await readText(oldFtlPath);
+        await writeText(newFtlPath, ftlContent);
+        await removeFile(oldFtlPath);
+    }
+}
+/**
+ * Renames a custom or override component atomically: updates directory name,
+ * file names, file contents, furnace.json, and engine registrations.
+ */
+export async function furnaceRenameCommand(projectRoot, oldName, newName) {
+    intro('Furnace Rename');
+    if (!CUSTOM_ELEMENT_TAG_PATTERN.test(oldName)) {
+        throw new InvalidArgumentError(`Invalid source name "${oldName}": ${CUSTOM_ELEMENT_TAG_RULES}`, 'old-name');
+    }
+    if (!CUSTOM_ELEMENT_TAG_PATTERN.test(newName)) {
+        throw new InvalidArgumentError(`Invalid target name "${newName}": ${CUSTOM_ELEMENT_TAG_RULES}`, 'new-name');
+    }
+    if (oldName === newName) {
+        throw new InvalidArgumentError('Source and target names are identical.', 'new-name');
+    }
+    const config = await loadFurnaceConfig(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    const paths = getProjectPaths(projectRoot);
+    const isCustom = oldName in config.custom;
+    const isOverride = oldName in config.overrides;
+    if (!isCustom && !isOverride) {
+        throw new FurnaceError(`Component "${oldName}" not found in furnace.json. Only custom and override components can be renamed.`, oldName);
+    }
+    if (newName in config.custom || newName in config.overrides || config.stock.includes(newName)) {
+        throw new FurnaceError(`A component named "${newName}" already exists in furnace.json.`, newName);
+    }
+    const componentType = isCustom ? 'custom' : 'override';
+    const baseDir = isCustom ? furnacePaths.customDir : furnacePaths.overridesDir;
+    const oldDir = join(baseDir, oldName);
+    const newDir = join(baseDir, newName);
+    if (!(await pathExists(oldDir))) {
+        throw new FurnaceError(`Component directory not found: components/${componentType}s/${oldName}`, oldName);
+    }
+    if (await pathExists(newDir)) {
+        throw new FurnaceError(`Target directory already exists: components/${componentType}s/${newName}`, newName);
+    }
+    await performRenameMutations({
+        projectRoot,
+        oldName,
+        newName,
+        oldDir,
+        newDir,
+        isCustom,
+        componentType,
+        config,
+        furnaceConfigPath: furnacePaths.furnaceConfig,
+        engineDir: paths.engine,
+    });
+    note(`Component renamed: ${oldName} → ${newName}\n\n` +
+        `Directory: components/${componentType}s/${newName}/\n\n` +
+        'Next steps:\n' +
+        '  1. Review the renamed files for any remaining references\n' +
+        '  2. Run "fireforge furnace validate" to verify\n' +
+        '  3. Run "fireforge furnace apply" to update the engine', newName);
+    outro('Rename complete');
+}
+//# sourceMappingURL=rename.js.map

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

@@ -1,5 +1,8 @@
 /**
  * Runs the furnace scan command to discover MozLitElement components.
  * @param projectRoot - Root directory of the project
+ * @param options - Scan options
  */
-export declare function furnaceScanCommand(projectRoot: string): Promise<void>;
+export declare function furnaceScanCommand(projectRoot: string, options?: {
+    deep?: boolean;
+}): Promise<void>;

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

@@ -1,11 +1,15 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { confirm, multiselect } from '@clack/prompts';
+import { confirm, multiselect, select } from '@clack/prompts';
 import { getProjectPaths } from '../../core/config.js';
-import { ensureFurnaceConfig, furnaceConfigExists, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
-import { scanWidgetsDirectory } from '../../core/furnace-scanner.js';
+import { ensureFurnaceConfig, furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { recordFurnaceRollbackFailure, runFurnaceMutation } from '../../core/furnace-operation.js';
+import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotFile, } from '../../core/furnace-rollback.js';
+import { DEEP_SCAN_PATHS, scanWidgetsDirectory } from '../../core/furnace-scanner.js';
 import { FurnaceError } from '../../errors/furnace.js';
+import { toError } from '../../utils/errors.js';
 import { pathExists } from '../../utils/fs.js';
 import { cancel, info, intro, isCancel, note, outro, spinner, success, } from '../../utils/logger.js';
+import { furnaceOverrideCommand } from './override.js';
 /**
  * Prompts the user to add newly discovered stock components to furnace.json.
  * @param components - Components discovered in the engine scan
@@ -41,24 +45,81 @@ async function promptAddComponents(components, tracked, projectRoot) {
         outro('Scan complete');
         return;
     }
-    const config = await ensureFurnaceConfig(projectRoot);
-    const toAdd = selected.filter((s) => !config.stock.includes(s));
-    config.stock.push(...toAdd);
-    await writeFurnaceConfig(projectRoot, config);
-    success(`Added ${selected.length} component${selected.length === 1 ? '' : 's'} to furnace.json`);
+    // Wrap the furnace.json mutation in the standard furnace lifecycle so the
+    // write goes through the furnace-wide lock and is visible to the global
+    // SIGINT/SIGTERM rollback pathway. The journal snapshots furnace.json
+    // *before* `ensureFurnaceConfig` runs, so a failed run after the file is
+    // auto-created cleans up after itself instead of leaving an unwanted
+    // default config behind.
+    await runFurnaceMutation(projectRoot, 'scan-rollback', async (ctx) => {
+        const journal = createRollbackJournal();
+        ctx.registerJournal(journal);
+        const furnacePaths = getFurnacePaths(projectRoot);
+        await snapshotFile(journal, furnacePaths.furnaceConfig);
+        try {
+            const config = await ensureFurnaceConfig(projectRoot);
+            const toAdd = selected.filter((s) => !config.stock.includes(s));
+            config.stock.push(...toAdd);
+            await writeFurnaceConfig(projectRoot, config);
+        }
+        catch (error) {
+            try {
+                await restoreRollbackJournalOrThrow(journal, 'Failed to update furnace.json during scan');
+            }
+            catch (rollbackError) {
+                await recordFurnaceRollbackFailure(projectRoot, 'scan-rollback', toError(rollbackError).message);
+                throw rollbackError;
+            }
+            throw error;
+        }
+    });
+    const addedNames = selected;
+    success(`Added ${addedNames.length} component${addedNames.length === 1 ? '' : 's'} to furnace.json`);
+    // Offer to immediately override one of the just-added stock components.
+    const shouldOverride = await confirm({
+        message: 'Override any of the newly added components?',
+    });
+    if (isCancel(shouldOverride) || !shouldOverride) {
+        return;
+    }
+    const overrideTarget = await select({
+        message: 'Select a component to override',
+        options: addedNames.map((name) => ({ value: name, label: name })),
+    });
+    if (isCancel(overrideTarget)) {
+        cancel('Cancelled');
+        return;
+    }
+    await furnaceOverrideCommand(projectRoot, overrideTarget);
 }
 /**
  * Runs the furnace scan command to discover MozLitElement components.
  * @param projectRoot - Root directory of the project
+ * @param options - Scan options
  */
-export async function furnaceScanCommand(projectRoot) {
-    intro('Furnace Scan');
+export async function furnaceScanCommand(projectRoot, options = {}) {
+    intro(options.deep ? 'Furnace Scan (deep)' : 'Furnace Scan');
     const paths = getProjectPaths(projectRoot);
     if (!(await pathExists(paths.engine))) {
         throw new FurnaceError('Engine directory not found. Run "fireforge download" first.');
     }
+    // Load scan paths from config if available, merge with deep paths if requested
+    const extraScanPaths = [];
+    if (await furnaceConfigExists(projectRoot)) {
+        const preConfig = await loadFurnaceConfig(projectRoot);
+        if (preConfig.scanPaths) {
+            extraScanPaths.push(...preConfig.scanPaths);
+        }
+    }
+    if (options.deep) {
+        for (const deepPath of DEEP_SCAN_PATHS) {
+            if (!extraScanPaths.includes(deepPath)) {
+                extraScanPaths.push(deepPath);
+            }
+        }
+    }
     const s = spinner('Scanning engine for components...');
-    const components = await scanWidgetsDirectory(paths.engine);
+    const components = await scanWidgetsDirectory(paths.engine, undefined, extraScanPaths.length > 0 ? extraScanPaths : undefined);
     s.stop(`Found ${components.length} component${components.length === 1 ? '' : 's'}`);
     // Build tracking info from furnace.json if it exists
     const tracked = new Map();

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

@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
-import { getProjectPaths } from '../../core/config.js';
-import { extractComponentChecksums, hasComponentChanged } from '../../core/furnace-apply.js';
+import { getProjectPaths, loadConfig } from '../../core/config.js';
+import { extractComponentChecksums, hasComponentChanged, hasCustomEngineDrift, hasOverrideEngineDrift, } from '../../core/furnace-apply.js';
 import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, loadFurnaceState, } from '../../core/furnace-config.js';
+import { resolveFtlDir } from '../../core/furnace-constants.js';
 import { checkRegistrationConsistency } from '../../core/furnace-validate-checks.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, note, outro, warn } from '../../utils/logger.js';
@@ -13,7 +15,7 @@ import { info, intro, note, outro, warn } from '../../utils/logger.js';
  * @param config - Loaded Furnace configuration
  * @param projectRoot - Root directory of the project
  */
-async function showDetailedComponentStatus(name, config, projectRoot) {
+async function showDetailedComponentStatus(name, config, state, projectRoot, paths, furnacePaths, ftlDir) {
     const customConfig = config.custom[name];
     const overrideConfig = config.overrides[name];
     if (!customConfig && !overrideConfig && !config.stock.includes(name)) {
@@ -23,20 +25,51 @@ async function showDetailedComponentStatus(name, config, projectRoot) {
         info(`"${name}" is an override component (${overrideConfig.type}).`);
         info(`Base path: ${overrideConfig.basePath}`);
         info(`Base version: ${overrideConfig.baseVersion}`);
-        outro('');
+        // baseVersion drift is advisory but reported here alongside the other
+        // override metadata so the operator sees the warning before drilling
+        // into registration drift or file diff.
+        const forgeConfig = await loadConfig(projectRoot);
+        const scopedDrift = findOverrideBaseVersionDrift(config, forgeConfig.firefox.version).filter((entry) => entry.name === name);
+        for (const entry of scopedDrift) {
+            warn(formatOverrideBaseVersionDriftWarning(entry));
+        }
+        const overrideDir = join(furnacePaths.overridesDir, name);
+        const sourceExists = await pathExists(overrideDir);
+        const lines = [`${sourceExists ? '\u2713' : '\u2717'} Override directory exists`];
+        if (!sourceExists) {
+            lines.push('\u2717 Workspace status unavailable (override directory missing)');
+            lines.push('\u2717 Engine comparison unavailable (override directory missing)');
+            note(lines.join('\n'), `${name} Override Status`);
+            outro('Status complete');
+            return;
+        }
+        const previous = extractComponentChecksums(state.appliedChecksums, 'override', name);
+        const workspaceChanged = await hasComponentChanged(overrideDir, previous);
+        lines.push(`${workspaceChanged ? '\u2717' : '\u2713'} Workspace unchanged since last apply`);
+        const engineExists = await pathExists(paths.engine);
+        if (!engineExists) {
+            lines.push('\u2717 Engine comparison unavailable (engine directory missing)');
+            note(lines.join('\n'), `${name} Override Status`);
+            outro('Status complete');
+            return;
+        }
+        const engineDrifted = await hasOverrideEngineDrift(paths.engine, overrideDir, overrideConfig, ftlDir);
+        lines.push(`${engineDrifted ? '\u2717' : '\u2713'} Engine matches override workspace`);
+        note(lines.join('\n'), `${name} Override Status`);
+        outro('Status complete');
         return;
     }
     if (config.stock.includes(name)) {
         info(`"${name}" is a stock component. No local registration to check.`);
-        outro('');
+        outro('Status complete');
         return;
     }
     if (!customConfig) {
-        outro('');
+        outro('Status complete');
         return;
     }
     // Custom component — run registration consistency check
-    const status = await checkRegistrationConsistency(projectRoot, name, customConfig);
+    const status = await checkRegistrationConsistency(projectRoot, name, customConfig, ftlDir);
     const lines = [];
     const check = (ok, label) => {
         lines.push(`${ok ? '\u2713' : '\u2717'} ${label}`);
@@ -55,7 +88,7 @@ async function showDetailedComponentStatus(name, config, projectRoot) {
         lines.push(`Missing in engine: ${status.missingTargetFiles.join(', ')}`);
     }
     note(lines.join('\n'), `${name} Registration Status`);
-    outro('');
+    outro('Status complete');
 }
 /**
  * Runs the furnace status command to show an overview of Furnace state.
@@ -74,10 +107,18 @@ export async function furnaceStatusCommand(projectRoot, name) {
     const state = await loadFurnaceState(projectRoot);
     const paths = getProjectPaths(projectRoot);
     const furnacePaths = getFurnacePaths(projectRoot);
+    const ftlDir = resolveFtlDir(config.ftlBasePath);
     if (name) {
-        await showDetailedComponentStatus(name, config, projectRoot);
+        await showDetailedComponentStatus(name, config, state, projectRoot, paths, furnacePaths, ftlDir);
         return;
     }
+    // Surface a pendingRepair marker before the normal summary so it cannot
+    // be missed. The marker means the last mutation could not roll back
+    // cleanly, so the engine and workspace may have drifted in ways apply
+    // cannot detect from checksums alone — doctor is the right next step.
+    if (state.pendingRepair) {
+        warn(`Furnace is in pending-repair state from ${state.pendingRepair.operation} (${state.pendingRepair.timestamp}): ${state.pendingRepair.reason}. Run \`fireforge doctor --repair-furnace\` to reconcile.`);
+    }
     // --- Overview mode ---
     const overrideCount = Object.keys(config.overrides).length;
     const customCount = Object.keys(config.custom).length;
@@ -103,35 +144,59 @@ export async function furnaceStatusCommand(projectRoot, name) {
     // Last apply
     lines.push(`Last apply: ${state.lastApply ?? 'never'}`);
     note(lines.join('\n'), 'Furnace Status');
-    // Check for changes since last apply
+    // Surface override baseVersion drift from the project config. This check
+    // is cheap (no I/O besides the already-loaded fireforge.json) and catches
+    // the single most common silent-drift case: Firefox bumped, overrides
+    // still point at the old version. Advisory only — status never fails.
+    const forgeConfig = await loadConfig(projectRoot);
+    for (const entry of findOverrideBaseVersionDrift(config, forgeConfig.firefox.version)) {
+        warn(formatOverrideBaseVersionDriftWarning(entry));
+    }
+    // Check for both workspace changes (developer edits) and engine drift
+    // (reset/download/manual edits). The two have different remediation
+    // hints, so report them separately rather than collapsing into a single
+    // "something is off" message.
     if (await pathExists(paths.engine)) {
-        let changesDetected = false;
-        for (const oName of Object.keys(config.overrides)) {
+        let workspaceChanged = false;
+        let engineDrifted = false;
+        for (const [oName, overrideConfig] of Object.entries(config.overrides)) {
             const componentDir = join(furnacePaths.overridesDir, oName);
             if (!(await pathExists(componentDir)))
                 continue;
             const previous = extractComponentChecksums(state.appliedChecksums, 'override', oName);
             if (await hasComponentChanged(componentDir, previous)) {
-                changesDetected = true;
-                break;
+                workspaceChanged = true;
+            }
+            else if (await hasOverrideEngineDrift(paths.engine, componentDir, overrideConfig, ftlDir)) {
+                engineDrifted = true;
             }
+            if (workspaceChanged && engineDrifted)
+                break;
         }
-        if (!changesDetected) {
-            for (const cName of Object.keys(config.custom)) {
+        if (!(workspaceChanged && engineDrifted)) {
+            for (const [cName, customConfig] of Object.entries(config.custom)) {
                 const componentDir = join(furnacePaths.customDir, cName);
                 if (!(await pathExists(componentDir)))
                     continue;
                 const previous = extractComponentChecksums(state.appliedChecksums, 'custom', cName);
                 if (await hasComponentChanged(componentDir, previous)) {
-                    changesDetected = true;
-                    break;
+                    workspaceChanged = true;
                 }
+                else if (await hasCustomEngineDrift(projectRoot, cName, componentDir, customConfig, ftlDir)) {
+                    engineDrifted = true;
+                }
+                if (workspaceChanged && engineDrifted)
+                    break;
             }
         }
-        if (changesDetected) {
+        if (workspaceChanged) {
             warn('Components have been modified since last apply. Run `fireforge build` or `fireforge furnace apply`.');
         }
+        if (engineDrifted) {
+            warn('Engine drift detected since last apply (reset/download/manual edit). Run `fireforge furnace apply` to re-deploy.');
+        }
     }
-    outro('');
+    info('Tip: run `furnace status <name>` for detailed component info, or `furnace --help` for all subcommands.');
+    outro('Status complete');
 }
 //# sourceMappingURL=status.js.map

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

@@ -0,0 +1,12 @@
+import type { FurnaceSyncOptions } from '../../types/commands/index.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 declare function furnaceSyncCommand(projectRoot: string, options?: FurnaceSyncOptions): Promise<void>;