@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,415 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readdir, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-import { confirm } from '@clack/prompts';
-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, 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';
-import { FurnaceError } from '../../errors/furnace.js';
-import { toError } from '../../utils/errors.js';
-import { pathExists, readText, removeDir, writeText } from '../../utils/fs.js';
-import { cancel, info, intro, isCancel, outro, warn } from '../../utils/logger.js';
-import { performCustomRemovalMutations, performOverrideRemovalMutations, } from './remove-mutations.js';
-import { dropChecksumsByPrefix } from './remove-state.js';
-import { browserTestFileName } from './test-file-name.js';
-/**
- * Removes an entire TOML section (header + body lines) for a given test file.
- * Matches from `["filename"]` up to the next section header `[` or end-of-file,
- * consuming the section's metadata keys and surrounding blank lines. This is
- * more robust than a single-line regex that only removes the header.
- */
-function removeTomlSection(toml, testFileName) {
-    const lines = toml.split('\n');
-    const header = `["${testFileName}"]`;
-    const result = [];
-    let i = 0;
-    while (i < lines.length) {
-        if (lines[i]?.trim() === header) {
-            // Skip the header line
-            i++;
-            // Skip all body lines until the next section header or EOF
-            while (i < lines.length && !/^\s*\[/.test(lines[i] ?? '')) {
-                i++;
-            }
-            // Collapse any double blank line left behind
-            while (result.length > 0 && result[result.length - 1]?.trim() === '') {
-                result.pop();
-            }
-            // Re-add a single blank separator if the next line is another section
-            if (i < lines.length && result.length > 0) {
-                result.push('');
-            }
-        }
-        else {
-            result.push(lines[i] ?? '');
-            i++;
-        }
-    }
-    // Trim trailing blank lines and ensure single trailing newline
-    while (result.length > 0 && result[result.length - 1]?.trim() === '') {
-        result.pop();
-    }
-    return result.join('\n') + '\n';
-}
-/**
- * Finds which section a component belongs to in the furnace config.
- * @returns The component type, or undefined if not found
- */
-function findComponentType(config, name) {
-    if (config.stock.includes(name))
-        return 'stock';
-    if (name in config.overrides)
-        return 'override';
-    if (name in config.custom)
-        return 'custom';
-    return undefined;
-}
-/**
- * Removes generated browser mochitest files associated with a custom component.
- * @param name - Custom component tag name
- * @param projectRoot - Root directory of the project
- * @param journal - Rollback journal that snapshots files before deletion
- *
- * The function preserves its original warn-and-continue contract: any failure
- * during cleanup is reported via warn() rather than thrown. Snapshots taken
- * before a failed step are still recorded so a later rollback (triggered by
- * an error elsewhere in the command) can restore whatever was deleted before
- * the failure.
- */
-async function cleanupCustomTestFiles(name, projectRoot, journal) {
-    const partialFailures = [];
-    let forgeConfig;
-    try {
-        forgeConfig = await loadConfig(projectRoot);
-    }
-    catch (error) {
-        const msg = `Could not load config for test cleanup — ${toError(error).message}. Remove test files manually if needed.`;
-        warn(msg);
-        partialFailures.push(msg);
-        return { partialFailures };
-    }
-    const paths = getProjectPaths(projectRoot);
-    const binaryName = forgeConfig.binaryName;
-    const testFileName = browserTestFileName(name, binaryName);
-    const testDir = join(paths.engine, 'browser/base/content/test', binaryName);
-    if (!(await pathExists(testDir)))
-        return { partialFailures };
-    // Step 1: Delete the test file itself
-    try {
-        const testFilePath = join(testDir, testFileName);
-        if (await pathExists(testFilePath)) {
-            await snapshotFile(journal, testFilePath);
-            await unlink(testFilePath);
-            info(`Deleted test file: ${testFileName}`);
-        }
-    }
-    catch (error) {
-        const msg = `Could not delete test file ${testFileName} — ${toError(error).message}. Remove it manually if needed.`;
-        warn(msg);
-        partialFailures.push(msg);
-    }
-    // Step 2: Remove the test entry from browser.toml
-    try {
-        const tomlPath = join(testDir, 'browser.toml');
-        if (await pathExists(tomlPath)) {
-            const toml = await readText(tomlPath);
-            const entryPattern = `["${testFileName}"]`;
-            if (toml.includes(entryPattern)) {
-                await snapshotFile(journal, tomlPath);
-                const updated = removeTomlSection(toml, testFileName);
-                await writeText(tomlPath, updated);
-            }
-        }
-    }
-    catch (error) {
-        const msg = `Could not update browser.toml — ${toError(error).message}. Remove the test entry manually if needed.`;
-        warn(msg);
-        partialFailures.push(msg);
-    }
-    // Step 3: Clean up empty test directory and deregister from moz.build
-    try {
-        const remaining = await readdir(testDir);
-        const hasTests = remaining.some((f) => f.startsWith('browser_') && f.endsWith('.js'));
-        if (!hasTests) {
-            await snapshotDir(journal, testDir);
-            await removeDir(testDir);
-            info(`Deleted empty test directory: browser/base/content/test/${binaryName}/`);
-            const mozBuildPath = join(paths.engine, 'browser/base/moz.build');
-            await snapshotFile(journal, mozBuildPath);
-            if (await deregisterTestManifest(paths.engine, binaryName)) {
-                info('Deregistered test manifest from browser/base/moz.build');
-            }
-        }
-    }
-    catch (error) {
-        const msg = `Could not clean up test directory — ${toError(error).message}. Remove it manually if needed.`;
-        warn(msg);
-        partialFailures.push(msg);
-    }
-    return { partialFailures };
-}
-/**
- * Removes the MochiKit test scaffold a
- * `furnace create --with-tests --test-style mochikit` produced for the
- * component (matches the rename counterpart in `rename.ts`). The test file is
- * `test_<name>.html` under `engine/toolkit/content/tests/widgets/` and the
- * registration is the `["test_<name>.html"]` entry in the same directory's
- * `chrome.toml`.
- *
- * Cleanup that only handles the browser-chrome mochitest layout under
- * `browser/base/content/test/<binary>/` leaves mochikit-style scaffolds and
- * their toml entries orphaned after `furnace remove`. The post-rename name
- * passed in here is the canonical one written to disk by deploy/rename, so
- * the file basenames match without re-deriving from the old name.
- *
- * Best-effort: each step warns on failure rather than throwing so the rest
- * of the remove transaction proceeds. The journal still snapshots touched
- * files so the outer rollback can restore them on a later failure in the
- * same operation.
- */
-async function cleanupCustomMochikitTestFiles(name, projectRoot, journal) {
-    const partialFailures = [];
-    const paths = getProjectPaths(projectRoot);
-    const widgetsTestDir = join(paths.engine, 'toolkit/content/tests/widgets');
-    if (!(await pathExists(widgetsTestDir))) {
-        return { partialFailures };
-    }
-    const testFileName = `test_${name}.html`;
-    const testFilePath = join(widgetsTestDir, testFileName);
-    try {
-        if (await pathExists(testFilePath)) {
-            await snapshotFile(journal, testFilePath);
-            await unlink(testFilePath);
-            info(`Deleted mochikit test file: toolkit/content/tests/widgets/${testFileName}`);
-        }
-    }
-    catch (error) {
-        const msg = `Could not delete mochikit test file ${testFileName} — ${toError(error).message}. Remove it manually if needed.`;
-        warn(msg);
-        partialFailures.push(msg);
-    }
-    const chromeTomlPath = join(widgetsTestDir, 'chrome.toml');
-    try {
-        if (await pathExists(chromeTomlPath)) {
-            const toml = await readText(chromeTomlPath);
-            const headerLine = `["${testFileName}"]`;
-            if (toml.includes(headerLine)) {
-                await snapshotFile(journal, chromeTomlPath);
-                await writeText(chromeTomlPath, removeTomlSection(toml, testFileName));
-            }
-        }
-    }
-    catch (error) {
-        const msg = `Could not update widgets chrome.toml — ${toError(error).message}. Remove the test entry manually if needed.`;
-        warn(msg);
-        partialFailures.push(msg);
-    }
-    return { partialFailures };
-}
-/**
- * Removes generated xpcshell test scaffolds associated with a custom
- * component. Cleanup that handles browser mochitests via
- * `cleanupCustomTestFiles` but never touches the xpcshell scaffold tree
- * leaves an operator who ran `furnace create --with-tests --xpcshell`
- * followed by `furnace remove` with orphan `xpcshell.toml` +
- * `test_<name>_packaged.js` files still referencing the removed component.
- * This pass mirrors the mochitest one: snapshot before removal,
- * warn-and-continue semantics, explicit summary on partial failures.
- */
-async function cleanupCustomXpcshellTestFiles(name, projectRoot, journal) {
-    const partialFailures = [];
-    let forgeConfig;
-    try {
-        forgeConfig = await loadConfig(projectRoot);
-    }
-    catch (error) {
-        const msg = `Could not load config for xpcshell test cleanup — ${toError(error).message}. Remove xpcshell test files manually if needed.`;
-        warn(msg);
-        partialFailures.push(msg);
-        return { partialFailures };
-    }
-    const paths = getProjectPaths(projectRoot);
-    const xpcshellRoot = join(paths.engine, xpcshellTestParentDir(forgeConfig.binaryName));
-    const componentXpcshellDir = join(xpcshellRoot, name);
-    if (!(await pathExists(componentXpcshellDir)))
-        return { partialFailures };
-    try {
-        await snapshotDir(journal, componentXpcshellDir);
-        await removeDir(componentXpcshellDir);
-        info(`Deleted xpcshell test scaffold directory: ${componentXpcshellDir.replace(paths.engine + '/', 'engine/')}`);
-    }
-    catch (error) {
-        const msg = `Could not delete xpcshell test scaffold — ${toError(error).message}. Remove it manually if needed.`;
-        warn(msg);
-        partialFailures.push(msg);
-    }
-    // If the xpcshell parent directory is now empty (no other components
-    // had scaffolds), drop it too so `furnace validate` stays quiet about
-    // the empty per-binary tree. Warn-and-continue on any failure.
-    try {
-        if (await pathExists(xpcshellRoot)) {
-            const remaining = await readdir(xpcshellRoot);
-            if (remaining.length === 0) {
-                await snapshotDir(journal, xpcshellRoot);
-                await removeDir(xpcshellRoot);
-                info(`Deleted empty xpcshell parent directory: ${xpcshellRoot.replace(paths.engine + '/', 'engine/')}`);
-            }
-        }
-    }
-    catch (error) {
-        const msg = `Could not clean up xpcshell parent directory — ${toError(error).message}. Remove it manually if needed.`;
-        warn(msg);
-        partialFailures.push(msg);
-    }
-    return { partialFailures };
-}
-async function loadFreshRemoveTarget(projectRoot, name, engineDir) {
-    const config = await loadFurnaceConfig(projectRoot);
-    const state = await loadFurnaceState(projectRoot);
-    const type = findComponentType(config, name);
-    if (!type) {
-        throw new FurnaceError(`Component "${name}" not found in furnace.json. Run "fireforge furnace list" to see registered components.`, name);
-    }
-    await requireGitEngineForRemove(type, name, engineDir);
-    return { config, ftlDir: resolveFtlDir(config.ftlBasePath), state, type };
-}
-async function cleanupAllCustomTestFiles(name, projectRoot, journal) {
-    const result = await cleanupCustomTestFiles(name, projectRoot, journal);
-    const failures = [...result.partialFailures];
-    failures.push(...(await cleanupCustomXpcshellTestFiles(name, projectRoot, journal)).partialFailures);
-    failures.push(...(await cleanupCustomMochikitTestFiles(name, projectRoot, journal)).partialFailures);
-    return failures;
-}
-/**
- * Confirms the remove operation interactively when TTY is available, or
- * enforces the `--yes` contract in non-interactive mode. Returns `false`
- * when the user cancelled and the caller should exit silently.
- */
-async function confirmFurnaceRemove(name, type, options, isInteractive) {
-    if (!isInteractive && !options.yes) {
-        throw new FurnaceError(`Cannot remove "${name}" in non-interactive mode without --yes flag.`, name);
-    }
-    if (!options.yes && isInteractive) {
-        const confirmed = await confirm({
-            message: `Remove ${type} component "${name}"?`,
-        });
-        if (isCancel(confirmed) || !confirmed) {
-            cancel('Remove cancelled');
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Enforces the engine-as-git precondition for both override and custom
- * removals. Runs before the lock is acquired or a journal is registered so
- * the failure path does not involve any rollback infrastructure.
- */
-async function requireGitEngineForRemove(type, name, engineDir) {
-    if (type !== 'override' && type !== 'custom')
-        return;
-    if (!(await isGitRepository(engineDir))) {
-        throw new FurnaceError(`Cannot remove ${type} component "${name}": engine is not a git repository. Run "fireforge download" to initialise it.`, name);
-    }
-}
-/**
- * Runs the furnace remove command to remove a component from the workspace.
- * @param projectRoot - Root directory of the project
- * @param name - Component tag name to remove
- * @param options - CLI options
- */
-export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
-    const isInteractive = stdioIsInteractive();
-    intro('Furnace Remove');
-    const config = await loadFurnaceConfig(projectRoot);
-    const furnacePaths = getFurnacePaths(projectRoot);
-    // Find which section the component belongs to
-    const type = findComponentType(config, name);
-    if (!type) {
-        throw new FurnaceError(`Component "${name}" not found in furnace.json. Run "fireforge furnace list" to see registered components.`, name);
-    }
-    if (!(await confirmFurnaceRemove(name, type, options, isInteractive))) {
-        return;
-    }
-    // Begin transactional mutation: every file deleted or rewritten is first
-    // snapshotted in a rollback journal so any failure mid-removal restores the
-    // workspace and engine to their pre-command state. The mutation runs under
-    // the furnace-wide lock and is registered with the global SIGINT/SIGTERM
-    // rollback pathway.
-    const paths = getProjectPaths(projectRoot);
-    await requireGitEngineForRemove(type, name, paths.engine);
-    const mutate = async (ctx) => {
-        const journal = createRollbackJournal();
-        ctx.registerJournal(journal);
-        try {
-            const { config: freshConfig, ftlDir, state: freshState, type: freshType, } = await loadFreshRemoveTarget(projectRoot, name, paths.engine);
-            if (freshType === 'override') {
-                await performOverrideRemovalMutations({
-                    name,
-                    paths,
-                    furnacePaths,
-                    freshConfig,
-                    freshState,
-                    ftlDir,
-                    journal,
-                });
-            }
-            else if (freshType === 'custom') {
-                await performCustomRemovalMutations({
-                    projectRoot,
-                    name,
-                    paths,
-                    furnacePaths,
-                    freshConfig,
-                    ftlDir,
-                    journal,
-                });
-            }
-            const testCleanupFailures = freshType === 'custom' ? await cleanupAllCustomTestFiles(name, projectRoot, journal) : [];
-            // Remove entry from furnace.json
-            if (freshType === 'stock') {
-                freshConfig.stock = freshConfig.stock.filter((s) => s !== name);
-            }
-            else if (freshType === 'override') {
-                freshConfig.overrides = Object.fromEntries(Object.entries(freshConfig.overrides).filter(([key]) => key !== name));
-                if (!freshConfig.stock.includes(name)) {
-                    freshConfig.stock.push(name);
-                }
-            }
-            else {
-                freshConfig.custom = Object.fromEntries(Object.entries(freshConfig.custom).filter(([key]) => key !== name));
-            }
-            await snapshotFile(journal, furnacePaths.furnaceConfig);
-            await writeFurnaceConfig(projectRoot, freshConfig);
-            // Drop stale per-file checksums inside the same transactional block.
-            // Snapshotting the state file into the rollback journal means the
-            // entire remove operation is a single atomic unit.
-            await snapshotFile(journal, furnacePaths.furnaceState);
-            await updateFurnaceState(projectRoot, (state) => dropChecksumsByPrefix(state, `${freshType}/${name}/`));
-            // Test-cleanup failures are warn-and-continue by design (test files
-            // are secondary artefacts), but the caller deserves a single summary
-            // line pointing at the residue so they don't have to re-scan earlier
-            // warn output to realise the removal was partial.
-            if (testCleanupFailures.length > 0) {
-                warn(`Component "${name}" removed with ${testCleanupFailures.length} test-cleanup warning(s) above. ` +
-                    `The component is deregistered, but test files may linger in the engine — review and delete manually if needed.`);
-            }
-        }
-        catch (error) {
-            return await completeJournalRollback(ctx, journal, error, {
-                projectRoot: projectRoot,
-                operation: 'remove-rollback',
-                failureMessage: `Failed to remove component "${name}"`,
-                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-browser-test.d.ts

@@ -1,2 +0,0 @@
-/** Rewrites scaffolded browser-chrome test literals after a component rename. */
-export declare function updateBrowserChromeTestContent(content: string, oldName: string, newName: string, binaryName: string): string;

package/dist/src/commands/furnace/rename-browser-test.js

@@ -1,68 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { tagNameToClassName } from '../../core/furnace-constants.js';
-import { escapeRegex } from '../../utils/regex.js';
-import { deriveTestStem } from './test-file-name.js';
-/** Rewrites scaffolded browser-chrome test literals after a component rename. */
-export function updateBrowserChromeTestContent(content, oldName, newName, binaryName) {
-    const oldClassName = tagNameToClassName(oldName);
-    const newClassName = tagNameToClassName(newName);
-    const oldUnderscored = oldName.replace(/-/g, '_');
-    const newUnderscored = newName.replace(/-/g, '_');
-    const oldTestStem = deriveTestStem(oldName, binaryName);
-    const newTestStem = deriveTestStem(newName, binaryName);
-    // One pass over the content, instead of four chained `.replace()` calls.
-    //
-    // Chaining let each rule see the previous rule's output. Renaming
-    // `acme-widget` to `acme-widget-v2` rewrote `test_acme_widget_defined` to
-    // `test_acme_widget_v2_defined` via the underscored form, and then the stem
-    // rule matched the `acme_widget` still inside that result and produced
-    // `test_acme_widget_v2_v2_defined`. A single alternation with a callback
-    // cannot re-enter its own output.
-    //
-    // Ordering is longest-first, because JS alternation takes the first
-    // alternative that matches at a given position.
-    const alternatives = [
-        // The stem is a short bare fragment (`moz-` and binary prefixes stripped,
-        // hyphens underscored), so `panel` for `moz-panel`. Matching it loose, even
-        // with hyphen guards, rewrote unrelated underscore-delimited identifiers
-        // such as `test_panel_group_integration`, because `_` must stay a legal
-        // neighbour for the generated name to match at all. The scaffold emits the
-        // stem in exactly one shape, so anchor to that shape instead of guessing
-        // from boundaries. The anchored shape carries its own guards so it cannot
-        // match inside a longer identifier (`mytest_panel_defined_extra`).
-        {
-            pattern: `(?<![\\w-])test_${escapeRegex(oldTestStem)}_defined(?![\\w-])`,
-            to: `test_${newTestStem}_defined`,
-        },
-        // Word-boundary-aware, matching `furnace/rename.ts` and
-        // `rename-xpcshell.ts`: without the guards a rename of `moz-panel` rewrote
-        // `moz-panel-group`. `_` stays a legal neighbour for the underscored form
-        // because it is embedded in generated identifiers on purpose. `-` is
-        // not.
-        //
-        // Skipped when the underscored form is the tag name (a hyphen-less
-        // component): both rules then match the same text and this one would win
-        // on order, substituting `newUnderscored` where the tag `newName` was
-        // meant. The stem rule still covers the one generated identifier shape.
-        ...(oldUnderscored === oldName
-            ? []
-            : [
-                {
-                    pattern: `(?<![A-Za-z0-9-])${escapeRegex(oldUnderscored)}(?![A-Za-z0-9-])`,
-                    to: newUnderscored,
-                },
-            ]),
-        { pattern: `(?<![\\w-])${escapeRegex(oldName)}(?![\\w-])`, to: newName },
-        { pattern: `\\b${escapeRegex(oldClassName)}\\b`, to: newClassName },
-    ];
-    // Each alternative is its own capture group and the replacement is picked
-    // by the group that matched, rather than by the matched text, which is
-    // ambiguous whenever two rules can produce the same match with different
-    // substitutions.
-    const combined = new RegExp(alternatives.map(({ pattern }) => `(${pattern})`).join('|'), 'g');
-    return content.replace(combined, (matched, ...args) => {
-        const groups = args.slice(0, alternatives.length);
-        const index = groups.findIndex((group) => group !== undefined);
-        return alternatives[index]?.to ?? matched;
-    });
-}

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

@@ -1,29 +0,0 @@
-/**
- * `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

@@ -1,127 +0,0 @@
-// 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

@@ -1,26 +0,0 @@
-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.
- */
-export declare function updateConfigForCustomRename(config: FurnaceConfig, oldName: string, newName: string): void;
-/**
- * Re-keys an override component config entry.
- */
-export declare function updateConfigForOverrideRename(config: FurnaceConfig, oldName: string, newName: string): void;
-/**
- * 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.
- */
-export declare function rekeyStateChecksums(projectRoot: string, componentType: string, oldName: string, newName: string): Promise<void>;