@hominis/fireforge 0.49.2 → 0.50.0

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

@@ -6,7 +6,7 @@ import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { stdioIsInteractive } from '../../core/destructive.js';
 import { getFurnacePaths, loadFurnaceConfig, loadFurnaceState, updateFurnaceState, writeFurnaceConfig, } from '../../core/furnace-config.js';
 import { resolveFtlDir, xpcshellTestParentDir } from '../../core/furnace-constants.js';
-import { completeJournalRollback, runFurnaceMutation } from '../../core/furnace-operation.js';
+import { completeJournalRollback, runFurnaceMutation, waitLockMutationOptions, } from '../../core/furnace-operation.js';
 import { createRollbackJournal, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
 import { isGitRepository } from '../../core/git.js';
 import { deregisterTestManifest } from '../../core/moz-manifest-register.js';
@@ -343,7 +343,7 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
     // rollback pathway.
     const paths = getProjectPaths(projectRoot);
     await requireGitEngineForRemove(type, name, paths.engine);
-    await runFurnaceMutation(projectRoot, 'remove-rollback', async (ctx) => {
+    const mutate = async (ctx) => {
         const journal = createRollbackJournal();
         ctx.registerJournal(journal);
         try {
@@ -408,7 +408,8 @@ export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
                 subject: `component "${name}"`,
             });
         }
-    });
+    };
+    await runFurnaceMutation(projectRoot, 'remove-rollback', mutate, waitLockMutationOptions(options.waitLockSeconds));
     info(`Removed "${name}" from furnace.json`);
     outro('Component removed');
 }

package/dist/src/commands/furnace/rename-dry-run.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `furnace rename --dry-run`: the plan a rename would carry out, rendered
+ * from reads only. A rename edits three engine registration files besides
+ * moving the component, and before this none of those edits was visible
+ * until it had run.
+ */
+import type { FurnaceConfig } from '../../types/furnace.js';
+/** Inputs for {@link renderRenamePlan}. */
+export interface RenamePlanInput {
+    config: FurnaceConfig;
+    oldName: string;
+    newName: string;
+    /** Workspace directory of the component being renamed. */
+    oldDir: string;
+    /** On-disk directory label: `custom` or `overrides`. */
+    componentDirLabel: 'custom' | 'overrides';
+    engineDir: string;
+    /** Project marker a freshly added registration line would carry. */
+    markerComment: string | undefined;
+}
+/**
+ * Renders the rename plan: workspace file moves, the furnace.json re-key,
+ * and, for a custom component, every engine edit the real run would make
+ * (registrations only when the component is registered).
+ *
+ * @param input - See {@link RenamePlanInput}
+ * @returns The plan as display lines joined by newlines
+ */
+export declare function renderRenamePlan(input: RenamePlanInput): Promise<string>;

package/dist/src/commands/furnace/rename-dry-run.js

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `furnace rename --dry-run`: the plan a rename would carry out, rendered
+ * from reads only. A rename edits three engine registration files besides
+ * moving the component, and before this none of those edits was visible
+ * until it had run.
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isComponentSourceFile, JAR_MN, resolveFtlChromeSubPath, resolveFtlDir, resolveFtlLocaleJarMnPath, } from '../../core/furnace-constants.js';
+import { hasLocaleFtlJarMnEntry } from '../../core/furnace-registration.js';
+import { isTagAlreadyRegistered } from '../../core/furnace-registration-ast.js';
+import { pathExists, readText } from '../../utils/fs.js';
+import { renameComponentFileName, renameTagInDescription } from './rename-helpers.js';
+/** Plan lines for the workspace move and the furnace.json re-key. */
+async function workspaceLines(input) {
+    const { config, oldName, newName, oldDir, componentDirLabel } = input;
+    const lines = [
+        `Workspace: components/${componentDirLabel}/${oldName}/ → components/${componentDirLabel}/${newName}/`,
+    ];
+    const entries = (await readdir(oldDir, { withFileTypes: true }))
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .sort();
+    for (const fileName of entries) {
+        const renamed = renameComponentFileName(fileName, oldName, newName);
+        const rewrite = isComponentSourceFile(fileName) ? ' (tag and class references rewritten)' : '';
+        lines.push(`  ${fileName}${renamed === fileName ? '' : ` → ${renamed}`}${rewrite}`);
+    }
+    const entry = config.custom[oldName] ?? config.overrides[oldName];
+    lines.push(`furnace.json: "${oldName}" → "${newName}"`);
+    if (entry) {
+        const description = renameTagInDescription(entry.description, oldName, newName);
+        if (description !== entry.description) {
+            lines.push(`  description: "${entry.description}" → "${description}"`);
+        }
+    }
+    return lines;
+}
+/** Plan line for the customElements.js registration. */
+async function customElementsLine(input) {
+    const { engineDir, oldName, newName, markerComment } = input;
+    const path = join(engineDir, 'toolkit/content/customElements.js');
+    if (!(await pathExists(path)))
+        return undefined;
+    const content = await readText(path);
+    const oldRegistered = isTagAlreadyRegistered(content, oldName);
+    if (isTagAlreadyRegistered(content, newName)) {
+        return `customElements.js: "${newName}" is already registered${oldRegistered ? `; remove the "${oldName}" entry` : ''}`;
+    }
+    if (oldRegistered) {
+        return `customElements.js: rewrite the "${oldName}" entry in place as "${newName}" (position and marker comments kept)`;
+    }
+    const marker = markerComment !== undefined ? ` marked // ${markerComment}:` : '';
+    return `customElements.js: add a "${newName}" entry${marker}`;
+}
+/** Plan line for the toolkit/content/jar.mn widget lines. */
+async function jarLine(input) {
+    const { engineDir, oldName, newName, oldDir } = input;
+    const path = join(engineDir, JAR_MN);
+    if (!(await pathExists(path)))
+        return undefined;
+    const oldLines = (await readText(path))
+        .split('\n')
+        .filter((line) => line.includes(`(widgets/${oldName}/`)).length;
+    const newFiles = (await readdir(oldDir, { withFileTypes: true }))
+        .filter((entry) => entry.isFile() && /\.(?:mjs|css)$/.test(entry.name))
+        .map((entry) => renameComponentFileName(entry.name, oldName, newName))
+        .sort();
+    return (`${JAR_MN}: replace ${oldLines} "${oldName}" line(s) with ` +
+        (newFiles.length > 0 ? newFiles.join(', ') : 'none (no .mjs/.css files)'));
+}
+/** Plan lines for the deployed .ftl and its locale jar.mn line. */
+async function localeLines(input, componentConfig) {
+    const { config, engineDir, oldName, newName } = input;
+    if (!componentConfig.localized)
+        return [];
+    const ftlDir = resolveFtlDir(config.ftlBasePath);
+    const lines = [];
+    if (await pathExists(join(engineDir, ftlDir, `${oldName}.ftl`))) {
+        lines.push(`${ftlDir}/${oldName}.ftl → ${newName}.ftl`);
+    }
+    const chromeSubPath = resolveFtlChromeSubPath(ftlDir);
+    const localeJarRel = resolveFtlLocaleJarMnPath(ftlDir);
+    if (chromeSubPath === undefined || localeJarRel === undefined)
+        return lines;
+    const present = await hasLocaleFtlJarMnEntry(engineDir, localeJarRel, oldName, chromeSubPath);
+    if (componentConfig.sharedFtl !== undefined) {
+        lines.push(`${localeJarRel}: no per-component line (sharedFtl: ${componentConfig.sharedFtl})` +
+            (present ? `; remove the stale "${oldName}.ftl" line` : ''));
+    }
+    else {
+        lines.push(present
+            ? `${localeJarRel}: re-point the "${oldName}.ftl" line to "${newName}.ftl"`
+            : `${localeJarRel}: no "${oldName}.ftl" line to re-point (left unchanged)`);
+    }
+    return lines;
+}
+/**
+ * Renders the rename plan: workspace file moves, the furnace.json re-key,
+ * and, for a custom component, every engine edit the real run would make
+ * (registrations only when the component is registered).
+ *
+ * @param input - See {@link RenamePlanInput}
+ * @returns The plan as display lines joined by newlines
+ */
+export async function renderRenamePlan(input) {
+    const lines = await workspaceLines(input);
+    const componentConfig = input.config.custom[input.oldName];
+    if (!componentConfig || !(await pathExists(input.engineDir))) {
+        return lines.join('\n');
+    }
+    lines.push('Engine:');
+    const engineLines = componentConfig.register
+        ? [
+            await customElementsLine(input),
+            await jarLine(input),
+            ...(await localeLines(input, componentConfig)),
+        ].filter((line) => line !== undefined)
+        : ['registrations untouched (register: false)'];
+    if (await pathExists(join(input.engineDir, componentConfig.targetPath))) {
+        engineLines.push(`remove the stale deployed directory ${componentConfig.targetPath}/`);
+    }
+    lines.push(...engineLines.map((line) => `  ${line}`));
+    lines.push('Test scaffolds named after the old tag are renamed when present.');
+    return lines.join('\n');
+}

package/dist/src/commands/furnace/rename-helpers.d.ts

@@ -3,6 +3,13 @@ import type { FurnaceConfig } from '../../types/furnace.js';
  * Applies a component rename to scaffold-owned filenames only.
  */
 export declare function renameComponentFileName(fileName: string, oldName: string, newName: string): string;
+/**
+ * Rewrites whole-tag mentions of the old name in a component description,
+ * so a rename does not carry a description that still names the old tag.
+ * Boundary-aware like the source rewrite: `moz-panel` inside
+ * `moz-panel-group` is left alone.
+ */
+export declare function renameTagInDescription(description: string, oldName: string, newName: string): string;
 /**
  * Re-keys a custom component config entry and same-config compose references.
  */

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

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { updateFurnaceState } from '../../core/furnace-config.js';
+import { escapeRegex } from '../../utils/regex.js';
 /**
  * Applies a component rename to scaffold-owned filenames only.
  */
@@ -11,6 +12,15 @@ export function renameComponentFileName(fileName, oldName, newName) {
     }
     return fileName;
 }
+/**
+ * Rewrites whole-tag mentions of the old name in a component description,
+ * so a rename does not carry a description that still names the old tag.
+ * Boundary-aware like the source rewrite: `moz-panel` inside
+ * `moz-panel-group` is left alone.
+ */
+export function renameTagInDescription(description, oldName, newName) {
+    return description.replace(new RegExp(`(?<![\\w-])${escapeRegex(oldName)}(?![\\w-])`, 'g'), newName);
+}
 /**
  * Re-keys a custom component config entry and same-config compose references.
  */
@@ -20,6 +30,7 @@ export function updateConfigForCustomRename(config, oldName, newName) {
         return;
     config.custom[newName] = {
         ...oldConfig,
+        description: renameTagInDescription(oldConfig.description, oldName, newName),
         targetPath: oldConfig.targetPath.replace(new RegExp(`(^|/)${oldName}$`), `$1${newName}`),
     };
     // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- idiomatic key removal from config record
@@ -37,7 +48,10 @@ export function updateConfigForOverrideRename(config, oldName, newName) {
     const oldConfig = config.overrides[oldName];
     if (!oldConfig)
         return;
-    config.overrides[newName] = { ...oldConfig };
+    config.overrides[newName] = {
+        ...oldConfig,
+        description: renameTagInDescription(oldConfig.description, oldName, newName),
+    };
     // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- idiomatic key removal from config record
     delete config.overrides[oldName];
 }

package/dist/src/commands/furnace/rename-registrations.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Engine registration edits for `furnace rename`: the customElements.js
+ * entry (rewritten in place, keeping its marker comments), the
+ * toolkit/content/jar.mn widget lines, the deployed `.ftl`, and the locale
+ * jar.mn line (re-pointed only when one existed, never for `sharedFtl`).
+ */
+import { type RollbackJournal } from '../../core/furnace-rollback.js';
+import type { CustomComponentConfig } from '../../types/furnace.js';
+/**
+ * The project marker (`// <MARKER>:`) a registration line written by the
+ * rename carries, resolved exactly as `furnace apply` resolves it. An
+ * unreadable fireforge.json degrades to no marker rather than failing the
+ * rename.
+ */
+export declare function loadMarkerComment(projectRoot: string): Promise<string | undefined>;
+/** Inputs for {@link updateEngineRegistrations}. */
+export interface UpdateEngineRegistrationsOptions {
+    /** Absolute path to the engine checkout. */
+    engineDir: string;
+    /** Tag name being renamed away from. */
+    oldName: string;
+    /** Tag name being renamed to. */
+    newName: string;
+    /** Workspace directory holding the renamed component's files. */
+    newDir: string;
+    /** Engine-relative directory localized components deploy their `.ftl` into. */
+    ftlDir: string;
+    /** The renamed component's furnace.json entry (`localized`, `sharedFtl`). */
+    componentConfig: CustomComponentConfig;
+    /** Project marker for a registration line the rename has to add fresh. */
+    markerComment: string | undefined;
+    /** Rollback journal every write is recorded in. */
+    journal: RollbackJournal;
+}
+/**
+ * Re-points the engine-side registrations (customElements.js, jar.mn, and
+ * the localized `.ftl` entries) from the old tag name to the new one.
+ *
+ * @param options - See {@link UpdateEngineRegistrationsOptions}
+ */
+export declare function updateEngineRegistrations(options: UpdateEngineRegistrationsOptions): Promise<void>;

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

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Engine registration edits for `furnace rename`: the customElements.js
+ * entry (rewritten in place, keeping its marker comments), the
+ * toolkit/content/jar.mn widget lines, the deployed `.ftl`, and the locale
+ * jar.mn line (re-pointed only when one existed, never for `sharedFtl`).
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { loadConfig } from '../../core/config.js';
+import { resolveFtlChromeSubPath, resolveFtlLocaleJarMnPath, } from '../../core/furnace-constants.js';
+import { resolveFurnaceMarkerComment } from '../../core/furnace-marker.js';
+import { addCustomElementRegistration, addJarMnEntries, addLocaleFtlJarMnEntry, removeCustomElementRegistration, removeJarMnEntries, removeLocaleFtlJarMnEntry, renameCustomElementRegistration, } from '../../core/furnace-registration.js';
+import { snapshotFile } from '../../core/furnace-rollback.js';
+import { pathExists, readText, removeFile, writeText } from '../../utils/fs.js';
+/**
+ * The project marker (`// <MARKER>:`) a registration line written by the
+ * rename carries, resolved exactly as `furnace apply` resolves it. An
+ * unreadable fireforge.json degrades to no marker rather than failing the
+ * rename.
+ */
+export async function loadMarkerComment(projectRoot) {
+    try {
+        return resolveFurnaceMarkerComment(await loadConfig(projectRoot));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Re-points the engine-side registrations (customElements.js, jar.mn, and
+ * the localized `.ftl` entries) from the old tag name to the new one.
+ *
+ * @param options - See {@link UpdateEngineRegistrationsOptions}
+ */
+export async function updateEngineRegistrations(options) {
+    const { engineDir, oldName, newName, newDir, ftlDir, componentConfig, markerComment, journal } = options;
+    const customElementsPath = join(engineDir, 'toolkit/content/customElements.js');
+    const jarMnPath = join(engineDir, 'toolkit/content/jar.mn');
+    if (await pathExists(customElementsPath)) {
+        await snapshotFile(journal, customElementsPath);
+        // Rewrite the existing entry in place: it keeps its position, layout and
+        // trailing `// <MARKER>:` comments. Only when there is no entry to
+        // rewrite is a fresh one added, carrying the project marker like every
+        // line `furnace apply` writes.
+        if (!(await renameCustomElementRegistration(engineDir, oldName, newName))) {
+            await removeCustomElementRegistration(engineDir, oldName);
+            await addCustomElementRegistration(engineDir, newName, `chrome://global/content/elements/${newName}.mjs`, markerComment !== undefined ? { markerComment } : {});
+        }
+    }
+    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);
+        await snapshotFile(journal, newFtlPath);
+        const ftlContent = await readText(oldFtlPath);
+        await writeText(newFtlPath, ftlContent);
+        await removeFile(oldFtlPath);
+    }
+    // Re-point the locale jar.mn chrome registration when the component is
+    // localized. Renaming the .ftl file on disk alone leaves the locale
+    // jar.mn pointing at `locale/.../${oldName}.ftl`, so `furnace validate`
+    // passes while the engine still carries a stale registration for the
+    // now-missing file. Only an existing line is re-pointed: a `sharedFtl`
+    // component has no per-component .ftl, and adding a line for one names a
+    // file that does not exist (an unmanaged edit `mach build` trips over).
+    if (componentConfig.localized) {
+        const chromeSubPath = resolveFtlChromeSubPath(ftlDir);
+        const localeJarRel = resolveFtlLocaleJarMnPath(ftlDir);
+        if (chromeSubPath !== undefined && localeJarRel !== undefined) {
+            const localeJarAbs = join(engineDir, localeJarRel);
+            if (await pathExists(localeJarAbs)) {
+                await snapshotFile(journal, localeJarAbs);
+                const removed = await removeLocaleFtlJarMnEntry(engineDir, localeJarRel, oldName, chromeSubPath);
+                if (removed && componentConfig.sharedFtl === undefined) {
+                    await addLocaleFtlJarMnEntry(engineDir, localeJarRel, newName, chromeSubPath);
+                }
+            }
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
+import type { FurnaceRenameOptions } from '../../types/commands/index.js';
 /**
  * Renames a custom or override component atomically: updates directory name,
  * file names, file contents, furnace.json, and engine registrations.
  */
-export declare function furnaceRenameCommand(projectRoot: string, oldName: string, newName: string): Promise<void>;
+export declare function furnaceRenameCommand(projectRoot: string, oldName: string, newName: string, options?: FurnaceRenameOptions): Promise<void>;

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

@@ -3,9 +3,8 @@ import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { getProjectPaths, loadConfig } from '../../core/config.js';
 import { getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
-import { isComponentSourceFile, resolveFtlChromeSubPath, resolveFtlDir, resolveFtlLocaleJarMnPath, tagNameToClassName, } from '../../core/furnace-constants.js';
-import { completeJournalRollback, runFurnaceMutation } from '../../core/furnace-operation.js';
-import { addCustomElementRegistration, addJarMnEntries, addLocaleFtlJarMnEntry, removeCustomElementRegistration, removeJarMnEntries, removeLocaleFtlJarMnEntry, } from '../../core/furnace-registration.js';
+import { isComponentSourceFile, resolveFtlDir, tagNameToClassName, } from '../../core/furnace-constants.js';
+import { completeJournalRollback, runFurnaceMutation, waitLockMutationOptions, } from '../../core/furnace-operation.js';
 import { CUSTOM_ELEMENT_TAG_PATTERN, CUSTOM_ELEMENT_TAG_RULES, } from '../../core/furnace-registration-validate.js';
 import { createRollbackJournal, recordCreatedDir, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
 import { getStoriesDir } from '../../core/furnace-stories.js';
@@ -16,7 +15,9 @@ import { copyFile, ensureDir, pathExists, readText, removeDir, removeFile, write
 import { info, intro, note, outro, warn } from '../../utils/logger.js';
 import { escapeRegex } from '../../utils/regex.js';
 import { updateBrowserChromeTestContent } from './rename-browser-test.js';
+import { renderRenamePlan } from './rename-dry-run.js';
 import { rekeyStateChecksums, renameComponentFileName, updateConfigForCustomRename, updateConfigForOverrideRename, } from './rename-helpers.js';
+import { loadMarkerComment, updateEngineRegistrations } from './rename-registrations.js';
 import { renameXpcshellTestFiles } from './rename-xpcshell.js';
 import { browserTestFileName } from './test-file-name.js';
 /**
@@ -165,7 +166,7 @@ async function performRenameMutations(args) {
     const { projectRoot, oldName, newName } = args;
     const oldClassName = tagNameToClassName(oldName);
     const newClassName = tagNameToClassName(newName);
-    await runFurnaceMutation(projectRoot, 'rename-rollback', async (ctx) => {
+    const mutate = async (ctx) => {
         const journal = createRollbackJournal();
         ctx.registerJournal(journal);
         let newDir = args.newDir;
@@ -245,16 +246,16 @@ async function performRenameMutations(args) {
             }
             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);
-                const isLocalized = config.custom[newName].localized;
+            const newConfig = config.custom[newName];
+            if (isCustom && newConfig?.register && (await pathExists(args.engineDir))) {
                 await updateEngineRegistrations({
                     engineDir: args.engineDir,
                     oldName,
                     newName,
                     newDir,
-                    ftlDir,
-                    isLocalized,
+                    ftlDir: resolveFtlDir(config.ftlBasePath),
+                    componentConfig: newConfig,
+                    markerComment: await loadMarkerComment(projectRoot),
                     journal,
                 });
             }
@@ -318,68 +319,15 @@ async function performRenameMutations(args) {
                 subject: `rename "${oldName}" → "${newName}"`,
             });
         }
-    });
-}
-/**
- * Re-points the engine-side registrations (customElements.js, jar.mn, and
- * the localized `.ftl` entries) from the old tag name to the new one.
- *
- * @param options - See {@link UpdateEngineRegistrationsOptions}
- */
-async function updateEngineRegistrations(options) {
-    const { engineDir, oldName, newName, newDir, ftlDir, isLocalized, journal } = options;
-    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);
-        await snapshotFile(journal, newFtlPath);
-        const ftlContent = await readText(oldFtlPath);
-        await writeText(newFtlPath, ftlContent);
-        await removeFile(oldFtlPath);
-    }
-    // Re-wire the locale jar.mn chrome registration when the component is
-    // localized. `updateEngineRegistrations` renames the .ftl file on disk but
-    // leaves the locale jar.mn pointing at `locale/.../${oldName}.ftl`, so
-    // `furnace validate` passes while the engine still carries a stale
-    // registration for the now-missing file.
-    if (isLocalized) {
-        const chromeSubPath = resolveFtlChromeSubPath(ftlDir);
-        const localeJarRel = resolveFtlLocaleJarMnPath(ftlDir);
-        if (chromeSubPath !== undefined && localeJarRel !== undefined) {
-            const localeJarAbs = join(engineDir, localeJarRel);
-            if (await pathExists(localeJarAbs)) {
-                await snapshotFile(journal, localeJarAbs);
-                await removeLocaleFtlJarMnEntry(engineDir, localeJarRel, oldName, chromeSubPath);
-                await addLocaleFtlJarMnEntry(engineDir, localeJarRel, newName, chromeSubPath);
-            }
-        }
-    }
+    };
+    await runFurnaceMutation(projectRoot, 'rename-rollback', mutate, waitLockMutationOptions(args.waitLockSeconds));
 }
 /**
  * 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');
+export async function furnaceRenameCommand(projectRoot, oldName, newName, options = {}) {
+    intro(options.dryRun ? 'Furnace Rename (dry run)' : 'Furnace Rename');
     if (!CUSTOM_ELEMENT_TAG_PATTERN.test(oldName)) {
         throw new InvalidArgumentError(`Invalid source name "${oldName}": ${CUSTOM_ELEMENT_TAG_RULES}`, 'old-name');
     }
@@ -419,6 +367,19 @@ export async function furnaceRenameCommand(projectRoot, oldName, newName) {
     if (await pathExists(newDir)) {
         throw new FurnaceError(`Target directory already exists: components/${componentDirLabel}/${newName}`, newName);
     }
+    if (options.dryRun) {
+        note(await renderRenamePlan({
+            config,
+            oldName,
+            newName,
+            oldDir,
+            componentDirLabel,
+            engineDir: paths.engine,
+            markerComment: await loadMarkerComment(projectRoot),
+        }), `${oldName} → ${newName}`);
+        outro('Dry run complete (no files modified)');
+        return;
+    }
     await performRenameMutations({
         projectRoot,
         oldName,
@@ -427,6 +388,7 @@ export async function furnaceRenameCommand(projectRoot, oldName, newName) {
         furnaceConfigPath: furnacePaths.furnaceConfig,
         furnacePaths,
         engineDir: paths.engine,
+        waitLockSeconds: options.waitLockSeconds,
     });
     note(`Component renamed: ${oldName} → ${newName}\n\n` +
         `Directory: components/${componentDirLabel}/${newName}/\n\n` +

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

@@ -1,9 +1,14 @@
+import type { FurnaceLockWaitable } from '../../types/commands/index.js';
+/** Options for `furnace scan`. */
+export interface FurnaceScanOptions extends FurnaceLockWaitable {
+    /** Search additional Firefox directories beyond the default widgets path. */
+    deep?: boolean;
+    /** Persist every untracked component into furnace.json's stock section. */
+    track?: boolean;
+}
 /**
  * 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, options?: {
-    deep?: boolean;
-    track?: boolean;
-}): Promise<void>;
+export declare function furnaceScanCommand(projectRoot: string, options?: FurnaceScanOptions): Promise<void>;

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

@@ -2,7 +2,7 @@
 import { confirm, multiselect, select } from '@clack/prompts';
 import { stdioIsInteractive } from '../../core/destructive.js';
 import { ensureFurnaceConfig, furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
-import { completeJournalRollback, runFurnaceMutation } from '../../core/furnace-operation.js';
+import { completeJournalRollback, runFurnaceMutation, waitLockMutationOptions, } from '../../core/furnace-operation.js';
 import { assertFurnaceEngineReady } from '../../core/furnace-precondition.js';
 import { createRollbackJournal, snapshotFile } from '../../core/furnace-rollback.js';
 import { DEEP_SCAN_PATHS, scanWidgetsDirectory } from '../../core/furnace-scanner.js';
@@ -13,8 +13,9 @@ import { furnaceOverrideCommand } from './override.js';
  * @param components - Components discovered in the engine scan
  * @param tracked - Existing Furnace tracking map keyed by tag name
  * @param projectRoot - Root directory of the project
+ * @param waitLockSeconds - Resolved `--wait-lock` budget for the furnace lock
  */
-async function promptAddComponents(components, tracked, projectRoot) {
+async function promptAddComponents(components, tracked, projectRoot, waitLockSeconds) {
     const untrackedComponents = components.filter((c) => !tracked.has(c.tagName));
     const shouldAdd = await confirm({ message: 'Add components to furnace.json?' });
     if (isCancel(shouldAdd) || !shouldAdd) {
@@ -36,7 +37,7 @@ async function promptAddComponents(components, tracked, projectRoot) {
         outro('Scan complete');
         return;
     }
-    await persistStockComponents(projectRoot, selected);
+    await persistStockComponents(projectRoot, selected, waitLockSeconds);
     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.
@@ -54,7 +55,7 @@ async function promptAddComponents(components, tracked, projectRoot) {
         cancel('Cancelled');
         return;
     }
-    await furnaceOverrideCommand(projectRoot, overrideTarget);
+    await furnaceOverrideCommand(projectRoot, overrideTarget, waitLockSeconds !== undefined ? { waitLockSeconds } : {});
 }
 /**
  * Persists discovered component tag names into the `stock` section of
@@ -69,8 +70,8 @@ async function promptAddComponents(components, tracked, projectRoot) {
  * auto-created cleans up after itself instead of leaving an unwanted default
  * config behind.
  */
-async function persistStockComponents(projectRoot, names) {
-    await runFurnaceMutation(projectRoot, 'scan-rollback', async (ctx) => {
+async function persistStockComponents(projectRoot, names, waitLockSeconds) {
+    const mutate = async (ctx) => {
         const journal = createRollbackJournal();
         ctx.registerJournal(journal);
         const furnacePaths = getFurnacePaths(projectRoot);
@@ -96,7 +97,8 @@ async function persistStockComponents(projectRoot, names) {
                 subject: `furnace.json update during scan`,
             });
         }
-    });
+    };
+    await runFurnaceMutation(projectRoot, 'scan-rollback', mutate, waitLockMutationOptions(waitLockSeconds));
 }
 /**
  * Renders a component's discovered capabilities as a display suffix. Shared
@@ -172,14 +174,14 @@ export async function furnaceScanCommand(projectRoot, options = {}) {
             return;
         }
         const untrackedNames = untrackedComponentList.map((c) => c.tagName);
-        await persistStockComponents(projectRoot, untrackedNames);
+        await persistStockComponents(projectRoot, untrackedNames, options.waitLockSeconds);
         success(`Tracked ${untrackedNames.length} component${untrackedNames.length === 1 ? '' : 's'} in the stock section of furnace.json`);
         outro('Scan complete');
         return;
     }
     const isInteractive = stdioIsInteractive();
     if (isInteractive && untrackedCount > 0) {
-        await promptAddComponents(components, tracked, projectRoot);
+        await promptAddComponents(components, tracked, projectRoot, options.waitLockSeconds);
         return;
     }
     if (untrackedCount > 0) {

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

@@ -3,7 +3,7 @@ import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { loadConfig } from '../../core/config.js';
 import { applyAllComponents } from '../../core/furnace-apply.js';
-import { logApplyResult } from '../../core/furnace-apply-output.js';
+import { formatSkipBreakdown, logApplyResult } from '../../core/furnace-apply-output.js';
 import { getFurnacePaths, loadFurnaceConfig } from '../../core/furnace-config.js';
 import { reportJsconfigPathsSync } from '../../core/furnace-jsconfig.js';
 import { runFurnaceMutation, waitLockMutationOptions } from '../../core/furnace-operation.js';
@@ -136,7 +136,8 @@ export async function furnaceSyncCommand(projectRoot, options = {}) {
             throw new FurnaceError(`${totalFailures} component${totalFailures === 1 ? '' : 's'} failed to apply cleanly`);
         }
         await reportJsconfigPathsSync(projectRoot, config, false);
-        outro(`Sync complete — ${result.applied.length} applied, ${result.skipped.length} skipped`);
+        outro(`Sync complete — ${result.applied.length} applied, ${result.skipped.length} skipped` +
+            formatSkipBreakdown(result.skipped));
     }
     else {
         outro('Dry run complete');