@hominis/fireforge 0.19.6 → 0.21.0

package/dist/src/commands/download.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
 import { getProjectPaths, loadConfig, updateState } from '../core/config.js';
+import { withFileLock } from '../core/file-lock.js';
 import { downloadFirefoxSource, formatBytes } from '../core/firefox.js';
 import { getFurnacePaths, updateFurnaceState } from '../core/furnace-config.js';
 import { getHead, initRepository, isGitRepository, isMissingHeadError, resumeRepository, } from '../core/git.js';
@@ -9,7 +10,7 @@ import { getDirtyFiles } from '../core/git-status.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { EngineExistsError, PartialEngineExistsError } from '../errors/download.js';
 import { toError } from '../utils/errors.js';
-import { checkDiskSpace, ensureDir, pathExists, removeDir } from '../utils/fs.js';
+import { checkDiskSpace, ensureDir, pathExists, pathExistsStrict, removeDir } from '../utils/fs.js';
 import { info, intro, outro, spinner, verbose, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
 /**
@@ -124,203 +125,205 @@ export async function downloadCommand(projectRoot, options) {
     info(`Firefox version: ${version}`);
     // Disk space pre-flight: Firefox source is ~5 GB
     await checkDiskSpace(projectRoot, 5 * 1024 * 1024 * 1024, warn);
-    // Check if engine already exists
-    if (await pathExists(paths.engine)) {
-        if (!options.force) {
-            if (await isGitRepository(paths.engine)) {
-                try {
-                    await getHead(paths.engine);
-                }
-                catch (error) {
-                    if (isMissingHeadError(error)) {
-                        // Partial init detected — attempt to resume instead of requiring --force
-                        info('Detected partially initialized engine. Attempting to resume...');
-                        // Snapshot patch-touched files that are already dirty so we
-                        // can preserve them after the resume commit.
-                        const patchFiles = await getPatchTouchedFiles(paths.patches);
-                        const preExistingDirty = patchFiles.size > 0
-                            ? new Set(await getDirtyFiles(paths.engine, [...patchFiles]))
-                            : new Set();
-                        const resumeSpinner = spinner('Resuming git repository initialization...');
-                        try {
-                            await resumeRepository(paths.engine, {
-                                // The non-TTY spinner fallback in `src/utils/logger.ts`
-                                // already calls `p.log.step(msg)` from `message()`, so
-                                // forwarding the progress message is the single authority
-                                // in both TTY and non-TTY modes. Before 0.16.0 this
-                                // callback also invoked `step(message)` explicitly when
-                                // stdio was not a TTY, which printed the same step line
-                                // twice in CI logs (once from the fallback, once from
-                                // the explicit call).
-                                onProgress: (message) => {
-                                    resumeSpinner.message(message);
-                                },
-                            });
-                            const baseCommit = await getHead(paths.engine);
-                            resumeSpinner.stop('Git repository resumed successfully');
-                            // Restore patch-touched files BEFORE stamping state. If this
-                            // step fails (disk full, permission denied, git object issue),
-                            // state.json keeps the previous downloadedVersion so the
-                            // invariant "state.downloadedVersion matches a clean engine"
-                            // holds. A retry of `fireforge download` then re-enters the
-                            // resume path instead of declaring success against a dirty
-                            // engine.
-                            await cleanPatchTouchedFiles(paths.engine, paths.patches, preExistingDirty);
-                            await updateState(projectRoot, {
-                                downloadedVersion: version,
-                                baseCommit,
-                            });
-                            await noteUnappliedPatches(paths.patches);
-                            outro(`Firefox ${version} is ready! (resumed from partial init)`);
-                            return;
-                        }
-                        catch (error) {
-                            resumeSpinner.error('Resume failed');
-                            // Preserve the underlying cause so the user sees *why* the
-                            // resume failed (timeout, permission denied, corrupted object,
-                            // disk full, …) instead of only the generic "partial engine
-                            // exists" story. Verbose mode prints the stack for deeper
-                            // triage.
-                            const cause = toError(error);
-                            verbose(`Resume failure detail: ${cause.message}`);
-                            if (cause.stack) {
-                                verbose(cause.stack);
+    await withFileLock(join(paths.fireforgeDir, 'download.fireforge.lock'), async () => {
+        // Check if engine already exists
+        if (await pathExistsStrict(paths.engine)) {
+            if (!options.force) {
+                if (await isGitRepository(paths.engine)) {
+                    try {
+                        await getHead(paths.engine);
+                    }
+                    catch (error) {
+                        if (isMissingHeadError(error)) {
+                            // Partial init detected — attempt to resume instead of requiring --force
+                            info('Detected partially initialized engine. Attempting to resume...');
+                            // Snapshot patch-touched files that are already dirty so we
+                            // can preserve them after the resume commit.
+                            const patchFiles = await getPatchTouchedFiles(paths.patches);
+                            const preExistingDirty = patchFiles.size > 0
+                                ? new Set(await getDirtyFiles(paths.engine, [...patchFiles]))
+                                : new Set();
+                            const resumeSpinner = spinner('Resuming git repository initialization...');
+                            try {
+                                await resumeRepository(paths.engine, {
+                                    // The non-TTY spinner fallback in `src/utils/logger.ts`
+                                    // already calls `p.log.step(msg)` from `message()`, so
+                                    // forwarding the progress message is the single authority
+                                    // in both TTY and non-TTY modes. Before 0.16.0 this
+                                    // callback also invoked `step(message)` explicitly when
+                                    // stdio was not a TTY, which printed the same step line
+                                    // twice in CI logs (once from the fallback, once from
+                                    // the explicit call).
+                                    onProgress: (message) => {
+                                        resumeSpinner.message(message);
+                                    },
+                                });
+                                const baseCommit = await getHead(paths.engine);
+                                resumeSpinner.stop('Git repository resumed successfully');
+                                // Restore patch-touched files BEFORE stamping state. If this
+                                // step fails (disk full, permission denied, git object issue),
+                                // state.json keeps the previous downloadedVersion so the
+                                // invariant "state.downloadedVersion matches a clean engine"
+                                // holds. A retry of `fireforge download` then re-enters the
+                                // resume path instead of declaring success against a dirty
+                                // engine.
+                                await cleanPatchTouchedFiles(paths.engine, paths.patches, preExistingDirty);
+                                await updateState(projectRoot, {
+                                    downloadedVersion: version,
+                                    baseCommit,
+                                });
+                                await noteUnappliedPatches(paths.patches);
+                                outro(`Firefox ${version} is ready! (resumed from partial init)`);
+                                return;
+                            }
+                            catch (error) {
+                                resumeSpinner.error('Resume failed');
+                                // Preserve the underlying cause so the user sees *why* the
+                                // resume failed (timeout, permission denied, corrupted object,
+                                // disk full, …) instead of only the generic "partial engine
+                                // exists" story. Verbose mode prints the stack for deeper
+                                // triage.
+                                const cause = toError(error);
+                                verbose(`Resume failure detail: ${cause.message}`);
+                                if (cause.stack) {
+                                    verbose(cause.stack);
+                                }
+                                throw new PartialEngineExistsError(paths.engine, cause);
                             }
-                            throw new PartialEngineExistsError(paths.engine, cause);
                         }
+                        // Re-throw unexpected git errors (corrupted objects, permission
+                        // denied, …) wrapped in PartialEngineExistsError so the user sees
+                        // both narratives: "we detected a partial engine and attempted
+                        // resume" AND the underlying git failure. Without the wrap the
+                        // raw git error loses the context that resume was in flight.
+                        const cause = toError(error);
+                        verbose(`Partial-engine probe failed with unexpected error: ${cause.message}`);
+                        if (cause.stack) {
+                            verbose(cause.stack);
+                        }
+                        throw new PartialEngineExistsError(paths.engine, cause);
                     }
-                    // Re-throw unexpected git errors (corrupted objects, permission
-                    // denied, …) wrapped in PartialEngineExistsError so the user sees
-                    // both narratives: "we detected a partial engine and attempted
-                    // resume" AND the underlying git failure. Without the wrap the
-                    // raw git error loses the context that resume was in flight.
-                    const cause = toError(error);
-                    verbose(`Partial-engine probe failed with unexpected error: ${cause.message}`);
-                    if (cause.stack) {
-                        verbose(cause.stack);
-                    }
-                    throw new PartialEngineExistsError(paths.engine, cause);
                 }
+                throw new EngineExistsError(paths.engine);
+            }
+            warn('Removing existing engine directory...');
+            await removeDir(paths.engine);
+            // --force installs a new baseCommit, which invalidates every applied
+            // checksum in furnace-state.json. Clearing the state now prevents a
+            // subsequent `furnace apply` from reporting "up to date" against an
+            // engine that no longer contains any of the deployed files. Preserve
+            // pendingRepair: authoring-side rollback markers describe unresolved
+            // component workspace state and should survive an engine refresh.
+            const furnacePaths = getFurnacePaths(projectRoot);
+            if (await pathExists(furnacePaths.furnaceState)) {
+                await updateFurnaceState(projectRoot, (current) => ({
+                    ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
+                }));
             }
-            throw new EngineExistsError(paths.engine);
-        }
-        warn('Removing existing engine directory...');
-        await removeDir(paths.engine);
-        // --force installs a new baseCommit, which invalidates every applied
-        // checksum in furnace-state.json. Clearing the state now prevents a
-        // subsequent `furnace apply` from reporting "up to date" against an
-        // engine that no longer contains any of the deployed files. Preserve
-        // pendingRepair: authoring-side rollback markers describe unresolved
-        // component workspace state and should survive an engine refresh.
-        const furnacePaths = getFurnacePaths(projectRoot);
-        if (await pathExists(furnacePaths.furnaceState)) {
-            await updateFurnaceState(projectRoot, (current) => ({
-                ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
-            }));
         }
-    }
-    // Ensure cache directory exists
-    const cacheDir = join(paths.fireforgeDir, 'cache');
-    await ensureDir(cacheDir);
-    // Phase-switched spinners: the download phase runs with the byte-count
-    // progress callbacks below; the extract phase is blocking tar-xz and
-    // has no incremental progress, but it can take 30–90s on a ~600 MB
-    // Firefox tree, so it gets its own spinner message. Before the phase
-    // split, a single "Downloading Firefox … 100%" spinner covered both
-    // — the first-run setup looked hung precisely when the archive had
-    // already reached disk and `tar` was the long pole.
-    let s = spinner(`Downloading Firefox ${version}...`);
-    let lastPercent = 0;
-    const phaseState = { value: 'download' };
-    try {
-        await downloadFirefoxSource(version, config.firefox.product, paths.engine, cacheDir, (downloaded, total) => {
-            if (total <= 0)
-                return;
-            const percent = Math.floor((downloaded / total) * 100);
-            if (percent !== lastPercent && percent % 5 === 0) {
-                s.message(`Downloading Firefox ${version}... ${percent}% (${formatBytes(downloaded)} / ${formatBytes(total)})`);
-                lastPercent = percent;
+        // Ensure cache directory exists
+        const cacheDir = join(paths.fireforgeDir, 'cache');
+        await ensureDir(cacheDir);
+        // Phase-switched spinners: the download phase runs with the byte-count
+        // progress callbacks below; the extract phase is blocking tar-xz and
+        // has no incremental progress, but it can take 30–90s on a ~600 MB
+        // Firefox tree, so it gets its own spinner message. Before the phase
+        // split, a single "Downloading Firefox … 100%" spinner covered both
+        // — the first-run setup looked hung precisely when the archive had
+        // already reached disk and `tar` was the long pole.
+        let s = spinner(`Downloading Firefox ${version}...`);
+        let lastPercent = 0;
+        const phaseState = { value: 'download' };
+        try {
+            await downloadFirefoxSource(version, config.firefox.product, paths.engine, cacheDir, (downloaded, total) => {
+                if (total <= 0)
+                    return;
+                const percent = Math.floor((downloaded / total) * 100);
+                if (percent !== lastPercent && percent % 5 === 0) {
+                    s.message(`Downloading Firefox ${version}... ${percent}% (${formatBytes(downloaded)} / ${formatBytes(total)})`);
+                    lastPercent = percent;
+                }
+            }, (phase) => {
+                if (phase === 'extract' && phaseState.value === 'download') {
+                    s.stop(`Firefox ${version} downloaded`);
+                    phaseState.value = 'extract';
+                    s = spinner(`Extracting Firefox ${version}... (decompressing ~600 MB of source; typically 30–90s)`);
+                }
+            }, config.firefox.sha256);
+            if (phaseState.value === 'extract') {
+                s.stop(`Firefox ${version} extracted`);
             }
-        }, (phase) => {
-            if (phase === 'extract' && phaseState.value === 'download') {
+            else {
                 s.stop(`Firefox ${version} downloaded`);
-                phaseState.value = 'extract';
-                s = spinner(`Extracting Firefox ${version}... (decompressing ~600 MB of source; typically 30–90s)`);
             }
-        });
-        if (phaseState.value === 'extract') {
-            s.stop(`Firefox ${version} extracted`);
         }
-        else {
-            s.stop(`Firefox ${version} downloaded`);
+        catch (error) {
+            s.error(phaseState.value === 'extract' ? 'Extraction failed' : 'Download failed');
+            throw error;
         }
-    }
-    catch (error) {
-        s.error(phaseState.value === 'extract' ? 'Extraction failed' : 'Download failed');
-        throw error;
-    }
-    // Finding #17: the git indexing phase of `download` can block for
-    // minutes on a ~600 MB Firefox tree — the spinner updates less often
-    // than operators expect during the monolithic `git add -A` pass, and
-    // non-TTY shells see long stretches of silence. Emit a one-line
-    // heads-up banner BEFORE the spinner starts so even a log-scraping
-    // CI job notes the expected duration. The progress callbacks below
-    // still fire as usual; this is an additional up-front signal, not a
-    // replacement.
-    info('Indexing downloaded source into git (one-time; typically 1–3 minutes on a ~600 MB Firefox tree)...');
-    // Initialize git repository
-    const gitSpinner = spinner('Initializing git repository (this may take a few minutes)...');
-    let baseCommit;
-    try {
-        await initRepository(paths.engine, 'firefox', {
-            // Same one-authority rule as the resume path above: the non-TTY
-            // spinner fallback already emits `step(msg)` internally, so
-            // calling `step()` in addition to `.message()` duplicated every
-            // git-init progress line in CI logs.
-            onProgress: (message) => {
-                gitSpinner.message(message);
-            },
+        // Finding #17: the git indexing phase of `download` can block for
+        // minutes on a ~600 MB Firefox tree — the spinner updates less often
+        // than operators expect during the monolithic `git add -A` pass, and
+        // non-TTY shells see long stretches of silence. Emit a one-line
+        // heads-up banner BEFORE the spinner starts so even a log-scraping
+        // CI job notes the expected duration. The progress callbacks below
+        // still fire as usual; this is an additional up-front signal, not a
+        // replacement.
+        info('Indexing downloaded source into git (one-time; typically 1–3 minutes on a ~600 MB Firefox tree)...');
+        // Initialize git repository
+        const gitSpinner = spinner('Initializing git repository (this may take a few minutes)...');
+        let baseCommit;
+        try {
+            await initRepository(paths.engine, 'firefox', {
+                // Same one-authority rule as the resume path above: the non-TTY
+                // spinner fallback already emits `step(msg)` internally, so
+                // calling `step()` in addition to `.message()` duplicated every
+                // git-init progress line in CI logs.
+                onProgress: (message) => {
+                    gitSpinner.message(message);
+                },
+            });
+            baseCommit = await getHead(paths.engine);
+            gitSpinner.stop('Git repository initialized');
+        }
+        catch (error) {
+            gitSpinner.error('Failed to initialize git repository');
+            warn('engine/ may now contain a partially initialized git repository. Re-run "fireforge download --force" to recreate the baseline cleanly.');
+            throw error;
+        }
+        // Restore any patch-touched files that ended up dirty after the initial
+        // commit (e.g. line-ending normalisation or extraction artefacts) so that
+        // a subsequent `fireforge import` works without --force.
+        //
+        // Wrapped in a dedicated spinner because the restore can itself take
+        // tens of seconds on a ~600 MB Firefox tree: it walks every file in the
+        // patch manifest, calls `git status` / `git checkout` for each, and the
+        // eval's "download looks hung" report landed at least partly on this
+        // post-commit window. An operator watching the CLI needs to see that
+        // this phase is distinct from the preceding git-add work.
+        //
+        // This runs BEFORE updateState so a restore failure keeps the previous
+        // downloadedVersion in state.json. The invariant we preserve is
+        // "state.downloadedVersion matches a clean engine": stamping the new
+        // version only after the restore succeeds means a failed clean-up will
+        // re-enter the resume path on the next `fireforge download` rather than
+        // reporting success against a dirty engine.
+        const restoreSpinner = spinner('Restoring patch-touched files to baseline...');
+        try {
+            const restoreResult = await cleanPatchTouchedFiles(paths.engine, paths.patches);
+            closeRestoreSpinner(restoreSpinner, restoreResult);
+        }
+        catch (error) {
+            restoreSpinner.error('Failed to restore patch-touched files');
+            throw error;
+        }
+        await updateState(projectRoot, {
+            downloadedVersion: version,
+            baseCommit,
         });
-        baseCommit = await getHead(paths.engine);
-        gitSpinner.stop('Git repository initialized');
-    }
-    catch (error) {
-        gitSpinner.error('Failed to initialize git repository');
-        warn('engine/ may now contain a partially initialized git repository. Re-run "fireforge download --force" to recreate the baseline cleanly.');
-        throw error;
-    }
-    // Restore any patch-touched files that ended up dirty after the initial
-    // commit (e.g. line-ending normalisation or extraction artefacts) so that
-    // a subsequent `fireforge import` works without --force.
-    //
-    // Wrapped in a dedicated spinner because the restore can itself take
-    // tens of seconds on a ~600 MB Firefox tree: it walks every file in the
-    // patch manifest, calls `git status` / `git checkout` for each, and the
-    // eval's "download looks hung" report landed at least partly on this
-    // post-commit window. An operator watching the CLI needs to see that
-    // this phase is distinct from the preceding git-add work.
-    //
-    // This runs BEFORE updateState so a restore failure keeps the previous
-    // downloadedVersion in state.json. The invariant we preserve is
-    // "state.downloadedVersion matches a clean engine": stamping the new
-    // version only after the restore succeeds means a failed clean-up will
-    // re-enter the resume path on the next `fireforge download` rather than
-    // reporting success against a dirty engine.
-    const restoreSpinner = spinner('Restoring patch-touched files to baseline...');
-    try {
-        const restoreResult = await cleanPatchTouchedFiles(paths.engine, paths.patches);
-        closeRestoreSpinner(restoreSpinner, restoreResult);
-    }
-    catch (error) {
-        restoreSpinner.error('Failed to restore patch-touched files');
-        throw error;
-    }
-    await updateState(projectRoot, {
-        downloadedVersion: version,
-        baseCommit,
+        await noteUnappliedPatches(paths.patches);
+        outro(`Firefox ${version} is ready!`);
     });
-    await noteUnappliedPatches(paths.patches);
-    outro(`Firefox ${version} is ready!`);
 }
 /** Registers the download command on the CLI program. */
 export function registerDownload(program, { getProjectRoot, withErrorHandling }) {

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

@@ -8,7 +8,7 @@
  * testable without dragging the whole command harness along for the ride.
  */
 import { join } from 'node:path';
-import { findAllPatchesForFilesWithDetails, planExport } from '../core/patch-export.js';
+import { findAllPatchesForFilesWithDetails, planExport, sanitizeName, } from '../core/patch-export.js';
 import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFilesInDiff, lintPatchQueue, } from '../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../core/patch-lock.js';
 import { addPatchToManifest, loadPatchesManifest, renumberPatchesInManifest, resolvePatchIdentifier, savePatchesManifest, } from '../core/patch-manifest.js';
@@ -17,20 +17,9 @@ import { InvalidArgumentError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readText, removeFile, writeText } from '../utils/fs.js';
 import { info, warn } from '../utils/logger.js';
-/**
- * Sanitizes a patch name for use in a filename. Mirrors the private helper
- * in patch-export.ts.
- */
-function sanitizeExportName(name) {
-    return name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 50);
-}
 function buildFilenameForPlacement(category, name, order, width) {
     const padded = String(order).padStart(Math.max(3, width), '0');
-    return `${padded}-${category}-${sanitizeExportName(name)}.patch`;
+    return `${padded}-${category}-${sanitizeName(name)}.patch`;
 }
 function getSortedRenameEntries(renameMap) {
     return Array.from(renameMap.entries()).sort((a, b) => a[1].newOrder - b[1].newOrder);

package/dist/src/commands/furnace/chrome-doc-remove.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `fireforge furnace chrome-doc remove <name>` — removes the files and
+ * registrations created by `furnace chrome-doc create`.
+ */
+/** Options for `furnace chrome-doc remove`. */
+export interface FurnaceChromeDocRemoveOptions {
+    /** Skip confirmation. Required for real non-interactive removal. */
+    yes?: boolean;
+    /** Print the removal plan without writing files. */
+    dryRun?: boolean;
+}
+/** Runs `furnace chrome-doc remove <name>`. */
+export declare function furnaceChromeDocRemoveCommand(projectRoot: string, name: string, options?: FurnaceChromeDocRemoveOptions): Promise<void>;

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

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `fireforge furnace chrome-doc remove <name>` — removes the files and
+ * registrations created by `furnace chrome-doc create`.
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { confirm } from '@clack/prompts';
+import { loadConfig } from '../../core/config.js';
+import { runFurnaceMutation } from '../../core/furnace-operation.js';
+import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotDir, snapshotFile, } from '../../core/furnace-rollback.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { pathExists, readText, removeDir, removeFile, writeText } from '../../utils/fs.js';
+import { cancel, info, intro, isCancel, note, outro } from '../../utils/logger.js';
+import { buildChromeDocPlan, validateChromeDocName } from './chrome-doc.js';
+function removeExactLine(content, line) {
+    const lines = content.split('\n');
+    const filtered = lines.filter((candidate) => candidate !== line);
+    return filtered.join('\n').replace(/\n*$/, '\n');
+}
+async function removeChromeDocJarEntryIfPresent(engineDir, file, entry, journal) {
+    const jarPath = join(engineDir, file);
+    if (!(await pathExists(jarPath))) {
+        throw new FurnaceError(`Required jar file ${jarPath} does not exist; cannot remove chrome-doc entry. Check that the fork's engine layout matches the expected browser/ and locales/ tree.`);
+    }
+    const existing = await readText(jarPath);
+    if (!existing.includes(entry)) {
+        return false;
+    }
+    await snapshotFile(journal, jarPath);
+    await writeText(jarPath, removeExactLine(existing, entry));
+    return true;
+}
+async function removeEmptyDirIfPresent(dirPath, journal) {
+    if (!(await pathExists(dirPath)))
+        return false;
+    const entries = await readdir(dirPath);
+    if (entries.length > 0)
+        return false;
+    await snapshotDir(journal, dirPath);
+    await removeDir(dirPath);
+    return true;
+}
+function renderChromeDocRemoveDryRun(name, plan) {
+    const jarLines = plan.jarEntries.map(({ file, entry, present }) => `  engine/${file}: ${present ? 'would remove' : 'not present'} ${entry.trim()}`);
+    const testLines = plan.testDir !== undefined
+        ? ['', 'Would remove test directory if present:', `  engine/${plan.testDir}/`]
+        : [];
+    return [
+        `[dry-run] Chrome document "${name}" removal plan`,
+        '',
+        'Would remove source files if present:',
+        ...plan.files.map((f) => `  engine/${f}`),
+        ...testLines,
+        '',
+        'Jar registrations:',
+        ...jarLines,
+    ].join('\n');
+}
+async function performChromeDocRemoveMutations(args) {
+    const journal = createRollbackJournal();
+    args.operationContext.registerJournal(journal);
+    let removedFiles = 0;
+    let removedJarEntries = 0;
+    let removedTestDir = false;
+    try {
+        for (const file of args.plan.files) {
+            const filePath = join(args.engineDir, file);
+            if (await pathExists(filePath)) {
+                await snapshotFile(journal, filePath);
+                await removeFile(filePath);
+                removedFiles++;
+            }
+        }
+        for (const { file, entry } of args.plan.jarEntries) {
+            if (await removeChromeDocJarEntryIfPresent(args.engineDir, file, entry, journal)) {
+                removedJarEntries++;
+            }
+        }
+        const testDir = join(args.engineDir, 'browser/base/content/test', `${args.binaryName}-xpcshell`, args.name);
+        if (await pathExists(testDir)) {
+            await snapshotDir(journal, testDir);
+            await removeDir(testDir);
+            removedTestDir = true;
+        }
+        await removeEmptyDirIfPresent(join(args.engineDir, 'browser/base/content/test', `${args.binaryName}-xpcshell`), journal);
+    }
+    catch (error) {
+        await restoreRollbackJournalOrThrow(journal, `Failed to remove chrome-doc "${args.name}"`);
+        throw error;
+    }
+    return { removedFiles, removedJarEntries, removedTestDir };
+}
+/** Runs `furnace chrome-doc remove <name>`. */
+export async function furnaceChromeDocRemoveCommand(projectRoot, name, options = {}) {
+    intro('Furnace chrome-doc remove');
+    validateChromeDocName(name);
+    const forgeConfig = await loadConfig(projectRoot);
+    const engineDir = join(projectRoot, 'engine');
+    if (!(await pathExists(engineDir))) {
+        throw new FurnaceError('Engine directory not found. Run "fireforge download" first before removing a chrome-doc.');
+    }
+    const plan = await buildChromeDocPlan({
+        engineDir,
+        name,
+        withTests: true,
+        binaryName: forgeConfig.binaryName,
+        includeLocaleEntryWhenWildcard: true,
+    });
+    if (options.dryRun) {
+        note(renderChromeDocRemoveDryRun(name, plan), name);
+        outro('Dry run complete');
+        return;
+    }
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    if (!options.yes && !isInteractive) {
+        throw new FurnaceError(`Cannot remove chrome-doc "${name}" in non-interactive mode without --yes flag.`, name);
+    }
+    if (!options.yes && isInteractive) {
+        const confirmed = await confirm({
+            message: `Remove chrome document "${name}" and its scaffolded registrations?`,
+        });
+        if (isCancel(confirmed) || !confirmed) {
+            cancel('Remove cancelled');
+            return;
+        }
+    }
+    const result = await runFurnaceMutation(projectRoot, 'chrome-doc-rollback', (ctx) => performChromeDocRemoveMutations({
+        name,
+        engineDir,
+        plan,
+        binaryName: forgeConfig.binaryName,
+        operationContext: ctx,
+    }));
+    info(`Removed ${result.removedFiles} source file${result.removedFiles === 1 ? '' : 's'} and ` +
+        `${result.removedJarEntries} jar registration${result.removedJarEntries === 1 ? '' : 's'} for "${name}".`);
+    if (result.removedTestDir) {
+        info('Removed xpcshell packaging test directory.');
+    }
+    outro('Chrome document removed');
+}
+//# sourceMappingURL=chrome-doc-remove.js.map