@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/furnace-registration.js

@@ -1,348 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { FurnaceError } from '../errors/furnace.js';
-import { pathExists, readText, writeText } from '../utils/fs.js';
-/**
- * Returns the leading whitespace of the first line matching `pattern`, whose
- * first capture group must be that indentation. `undefined` when no line
- * matches, so callers can chain progressively looser patterns before falling
- * back to a convention default.
- */
-function detectIndent(lines, pattern) {
-    for (const line of lines) {
-        const match = pattern.exec(line);
-        if (match?.[1])
-            return match[1];
-    }
-    return undefined;
-}
-/**
- * Detects the indentation used by existing `content/global/elements/` lines
- * in jar.mn. Falls back to 3 spaces (the historical Firefox convention) when
- * no reference line is found.
- */
-function detectJarMnIndent(lines) {
-    return detectIndent(lines, /^(\s+)content\/global\/elements\//) ?? '   ';
-}
-// Re-export everything from the AST module so existing imports keep working
-export { addCustomElementRegistration, validateCustomElementRegistration, } from './furnace-registration-ast.js';
-export { removeCustomElementRegistration } from './furnace-registration-remove.js';
-export { renameCustomElementRegistration } from './furnace-registration-rename.js';
-import { escapeRegex } from '../utils/regex.js';
-import { JAR_MN } from './furnace-constants.js';
-/**
- * True when jar.mn already registers `file` of component `tagName` anywhere
- * in the file: either a line targeting `content/global/elements/<file>` or a
- * line sourcing `(widgets/<tagName>/<file>)`. The position of the existing
- * line is irrelevant. A hand-written line below an unrelated entry counts
- * exactly like one Furnace wrote itself, so apply never adds a second line
- * and mach never fails with "Item already in manifest". Boundary-aware so
- * `moz-card.css` does not match `moz-card-group.css`.
- */
-function isJarMnFileRegistered(content, tagName, file) {
-    const escapedFile = escapeRegex(file);
-    const target = new RegExp(`content/global/elements/${escapedFile}(?:\\s|$)`, 'm');
-    const source = new RegExp(`\\(widgets/${escapeRegex(tagName)}/${escapedFile}\\)`);
-    return target.test(content) || source.test(content);
-}
-/**
- * Adds jar.mn entries that map chrome:// URIs to on-disk paths for a
- * component's files.
- *
- * ## Assumed jar.mn format
- *
- * Firefox's `toolkit/content/jar.mn` uses a stable format that has not
- * changed in the custom-element era (Firefox 90+). The entry format is:
- *
- * ```
- *    content/global/elements/{file}  (widgets/{tagName}/{file})
- * ```
- *
- * - **Indent**: detected dynamically from the nearest existing
- *   `content/global/elements/` line. Falls back to 3 spaces when no
- *   reference line exists.
- * - **Insertion point**: identified by existing lines matching the regex
- *   `^\s+content\/global\/elements\/([^.]+)\.`. New entries are inserted
- *   in alphabetical order relative to these.
- * - **Fallback**: if no `content/global/elements/` line exists (empty
- *   project), looks for any `content/global/` line and inserts after it.
- * - **Idempotency**: entries already present anywhere in the file (an exact
- *   target match on `content/global/elements/{file}`, or a source match on
- *   `(widgets/{tagName}/{file})`) are skipped, including hand-written ones.
- *
- * If Firefox upstream changes the jar.mn section ordering or switches to a
- * different resource registration mechanism, the preflight validation in
- * `validateJarMnInsertionForFiles` will catch the format mismatch before any writes
- * occur.
- *
- * @param engineDir - Path to the Firefox engine source root
- * @param tagName - Custom element tag name
- * @param files - Filenames to register (e.g. ["moz-widget.mjs", "moz-widget.css"])
- */
-export async function addJarMnEntries(engineDir, tagName, files) {
-    const filePath = join(engineDir, JAR_MN);
-    if (!(await pathExists(filePath))) {
-        throw new FurnaceError('jar.mn not found in engine', tagName);
-    }
-    let content = await readText(filePath);
-    const lines = content.split('\n');
-    // Filter to files not already registered anywhere in the jar.
-    const newFiles = [...new Set(files)].filter((f) => !isJarMnFileRegistered(content, tagName, f));
-    if (newFiles.length === 0)
-        return 0;
-    // Build new entry lines using the indent detected from existing entries.
-    const indent = detectJarMnIndent(lines);
-    const newEntries = newFiles.map((f) => `${indent}content/global/elements/${f}  (widgets/${tagName}/${f})`);
-    // Find insertion point among existing content/global/elements/ lines
-    const elementLinePattern = /^\s+content\/global\/elements\/([^.]+)\./;
-    let insertIndex = -1;
-    for (const [i, line] of lines.entries()) {
-        const match = elementLinePattern.exec(line);
-        if (match) {
-            const existingTag = match[1] ?? '';
-            if (existingTag > tagName) {
-                insertIndex = i;
-                break;
-            }
-            // Track last element entry line as fallback (insert after it)
-            insertIndex = i + 1;
-        }
-    }
-    if (insertIndex === -1) {
-        // Fallback: find last content/global/ line
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const line = lines[i];
-            if (line !== undefined && /^\s+content\/global\//.test(line)) {
-                insertIndex = i + 1;
-                break;
-            }
-        }
-    }
-    if (insertIndex === -1) {
-        const nonEmpty = lines.some((line) => line.trim().length > 0);
-        if (!nonEmpty) {
-            throw new FurnaceError('jar.mn is empty or contains only whitespace. It may be malformed — verify the engine was downloaded correctly.', tagName);
-        }
-        throw new FurnaceError('Could not find a content/global/ section in jar.mn for element entries. The file may be malformed.', tagName);
-    }
-    lines.splice(insertIndex, 0, ...newEntries);
-    content = lines.join('\n');
-    await writeText(filePath, content);
-    return newFiles.length;
-}
-/**
- * Adds a locale jar.mn entry mapping `<chromeSubPath>/<tagName>.ftl` to the
- * on-disk `.ftl` that `furnace apply` just copied under the FTL tree. Without
- * this entry the chrome URI passed to `window.MozXULElement.insertFTLIfNeeded`
- * does not resolve at runtime, so the generated `--localized` component
- * silently ships broken l10n.
- *
- * Degrades gracefully: if the locale jar.mn (e.g. `toolkit/locales/jar.mn`)
- * does not exist, returns 0 rather than throwing, so a custom fork without a
- * standard locales package can still apply a localized component.
- *
- * The written entry mirrors the Mozilla convention for toolkit widgets:
- *
- *   locale/@AB_CD@/<chromeSubPath>/<tagName>.ftl (%<chromeSubPath>/<tagName>.ftl)
- *
- * @param engineDir - Path to the Firefox engine source root
- * @param jarMnRelPath - Engine-relative path to the locale jar.mn
- * @param tagName - Custom element tag name (base of the `.ftl` file)
- * @param chromeSubPath - Chrome sub-path (e.g. `toolkit/global`)
- * @returns Number of entries inserted (0 when already present, or jar.mn missing)
- */
-export async function addLocaleFtlJarMnEntry(engineDir, jarMnRelPath, tagName, chromeSubPath) {
-    const filePath = join(engineDir, jarMnRelPath);
-    if (!(await pathExists(filePath))) {
-        return 0;
-    }
-    const content = await readText(filePath);
-    const lines = content.split('\n');
-    const ftlFile = `${tagName}.ftl`;
-    const escapedTag = escapeRegex(tagName);
-    const escapedChrome = escapeRegex(chromeSubPath);
-    const presencePattern = new RegExp(`locale\\/(?:@AB_CD@|[a-zA-Z-]+)\\/${escapedChrome}\\/${escapedTag}\\.ftl`, 'm');
-    if (presencePattern.test(content)) {
-        return 0;
-    }
-    const indent = detectLocaleJarMnIndent(lines, chromeSubPath);
-    const newEntry = `${indent}locale/@AB_CD@/${chromeSubPath}/${ftlFile} (%${chromeSubPath}/${ftlFile})`;
-    const sectionPattern = new RegExp(`^(\\s+)locale\\/(?:@AB_CD@|[a-zA-Z-]+)\\/${escapedChrome}\\/([^.\\s]+)\\.ftl`);
-    let insertIndex = -1;
-    for (const [i, line] of lines.entries()) {
-        const match = sectionPattern.exec(line);
-        if (match) {
-            const existingTag = match[2] ?? '';
-            if (existingTag > tagName) {
-                insertIndex = i;
-                break;
-            }
-            insertIndex = i + 1;
-        }
-    }
-    if (insertIndex === -1) {
-        // No existing entries under this chrome sub-path. Fall back to end-of-file
-        // placement so the operator can reorder manually if desired.
-        insertIndex = lines.length;
-    }
-    lines.splice(insertIndex, 0, newEntry);
-    await writeText(filePath, lines.join('\n'));
-    return 1;
-}
-/** Detects locale jar.mn indentation by sampling an existing matching entry. */
-function detectLocaleJarMnIndent(lines, chromeSubPath) {
-    const escapedChrome = escapeRegex(chromeSubPath);
-    const exact = new RegExp(`^(\\s+)locale\\/(?:@AB_CD@|[a-zA-Z-]+)\\/${escapedChrome}\\/`);
-    // Fall back to any existing `locale/...` indent before giving up.
-    return detectIndent(lines, exact) ?? detectIndent(lines, /^(\s+)locale\//) ?? '  ';
-}
-/** Matches a per-widget locale jar.mn line for `<chromeSubPath>/<tagName>.ftl`. */
-function localeFtlJarMnPattern(tagName, chromeSubPath) {
-    return new RegExp(`locale\\/(?:@AB_CD@|[a-zA-Z-]+)\\/${escapeRegex(chromeSubPath)}\\/${escapeRegex(tagName)}\\.ftl`);
-}
-/**
- * True when the locale jar.mn carries a per-widget line for `tagName`.
- * False when the jar.mn is missing. Used by `furnace rename --dry-run` to
- * say whether a rename would re-point a line or leave the jar alone.
- */
-export async function hasLocaleFtlJarMnEntry(engineDir, jarMnRelPath, tagName, chromeSubPath) {
-    const filePath = join(engineDir, jarMnRelPath);
-    if (!(await pathExists(filePath)))
-        return false;
-    return localeFtlJarMnPattern(tagName, chromeSubPath).test(await readText(filePath));
-}
-/**
- * Removes a locale jar.mn entry previously written by `addLocaleFtlJarMnEntry`.
- * Idempotent: if the entry is absent or the file is missing, nothing happens.
- *
- * @returns True when a line was removed, so a rename re-points only an
- *   entry that existed instead of inventing one
- */
-export async function removeLocaleFtlJarMnEntry(engineDir, jarMnRelPath, tagName, chromeSubPath) {
-    const filePath = join(engineDir, jarMnRelPath);
-    if (!(await pathExists(filePath))) {
-        return false;
-    }
-    const content = await readText(filePath);
-    const lines = content.split('\n');
-    const pattern = localeFtlJarMnPattern(tagName, chromeSubPath);
-    const filtered = lines.filter((line) => !pattern.test(line));
-    if (filtered.length === lines.length)
-        return false;
-    await writeText(filePath, filtered.join('\n'));
-    return true;
-}
-/**
- * Removes all jar.mn entries for a given tag name.
- *
- * This operation is idempotent: if no entries exist or the file is missing,
- * nothing happens.
- *
- * @param engineDir - Path to the Firefox engine source root
- * @param tagName - Custom element tag name whose entries should be removed
- */
-export async function removeJarMnEntries(engineDir, tagName) {
-    const filePath = join(engineDir, JAR_MN);
-    if (!(await pathExists(filePath))) {
-        return;
-    }
-    let content = await readText(filePath);
-    const lines = content.split('\n');
-    // Match by the source mapping segment `(widgets/<tagName>/...)` so every
-    // line the component registered is removed regardless of the target
-    // basename. A helper `.mjs` whose name does not start with the tag (e.g.
-    // a renamed `foo-utils.mjs`) otherwise survives the remove pass and leaves
-    // a stale registration that breaks packaging. The target-path match is
-    // kept as an OR for lines that carry no source mapping.
-    // Word boundaries keep "moz-card" from matching "moz-card-group".
-    const sourcePattern = new RegExp(`\\(widgets/${escapeRegex(tagName)}/`);
-    const legacyTargetPattern = new RegExp(`content/global/elements/${escapeRegex(tagName)}\\.`);
-    const filtered = lines.filter((line) => !sourcePattern.test(line) && !legacyTargetPattern.test(line));
-    if (filtered.length === lines.length)
-        return;
-    content = filtered.join('\n');
-    await writeText(filePath, content);
-}
-const WIDGET_SOURCE_MAPPING_PATTERN = /\(widgets\/([^/)]+)\/([^)]+)\)/;
-/**
- * Scans jar.mn for widget registration lines `(widgets/<tag>/<file>)` whose
- * workspace source file no longer exists. A renamed component helper
- * otherwise leaves the old line pointing at a deleted file and every build
- * fails at packaging. Only tags in `managedTags` (furnace-managed custom
- * components) are inspected, so upstream lines are never touched.
- */
-export async function findStaleJarMnEntries(engineDir, customDir, managedTags) {
-    const filePath = join(engineDir, JAR_MN);
-    if (!(await pathExists(filePath)))
-        return [];
-    const managed = new Set(managedTags);
-    const stale = [];
-    for (const line of (await readText(filePath)).split('\n')) {
-        const match = WIDGET_SOURCE_MAPPING_PATTERN.exec(line);
-        if (!match)
-            continue;
-        const tagName = match[1] ?? '';
-        const fileName = match[2] ?? '';
-        if (!managed.has(tagName))
-            continue;
-        if (!(await pathExists(join(customDir, tagName, fileName)))) {
-            stale.push({ tagName, fileName, line: line.trim() });
-        }
-    }
-    return stale;
-}
-/**
- * Removes every stale widget registration line found by
- * {@link findStaleJarMnEntries}. Returns the removed entries. Used by
- * `furnace validate --fix` and `doctor --repair-furnace`.
- */
-export async function pruneStaleJarMnEntries(engineDir, customDir, managedTags) {
-    const stale = await findStaleJarMnEntries(engineDir, customDir, managedTags);
-    if (stale.length === 0)
-        return [];
-    const filePath = join(engineDir, JAR_MN);
-    const staleLines = new Set(stale.map((entry) => entry.line));
-    const lines = (await readText(filePath)).split('\n');
-    const filtered = lines.filter((line) => !staleLines.has(line.trim()));
-    await writeText(filePath, filtered.join('\n'));
-    return stale;
-}
-/**
- * Validates that jar.mn entries *could* be added without writing anything.
- * Used by dry-run to surface structural problems early.
- */
-export async function validateJarMnInsertionForFiles(engineDir, tagName, files) {
-    const filePath = join(engineDir, JAR_MN);
-    if (!(await pathExists(filePath))) {
-        throw new FurnaceError('jar.mn not found in engine', tagName);
-    }
-    const content = await readText(filePath);
-    const lines = content.split('\n');
-    const newFiles = files.filter((f) => !isJarMnFileRegistered(content, tagName, f));
-    if (newFiles.length === 0)
-        return;
-    const elementLinePattern = /^\s+content\/global\/elements\/([^.]+)\./;
-    let hasInsertionPoint = false;
-    for (const line of lines) {
-        if (elementLinePattern.test(line)) {
-            hasInsertionPoint = true;
-            break;
-        }
-    }
-    if (!hasInsertionPoint) {
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const line = lines[i];
-            if (line !== undefined && /^\s+content\/global\//.test(line)) {
-                hasInsertionPoint = true;
-                break;
-            }
-        }
-    }
-    if (!hasInsertionPoint) {
-        const nonEmpty = lines.some((line) => line.trim().length > 0);
-        if (!nonEmpty) {
-            throw new FurnaceError('jar.mn is empty or contains only whitespace. It may be malformed — verify the engine was downloaded correctly.', tagName);
-        }
-        throw new FurnaceError('Could not find a content/global/ section in jar.mn for element entries. The file may be malformed.', tagName);
-    }
-}

package/dist/src/core/furnace-rollback.d.ts

@@ -1,48 +0,0 @@
-interface FileSnapshot {
-    existed: boolean;
-    content?: Uint8Array;
-    mode?: number;
-}
-export interface RollbackJournal {
-    files: Map<string, FileSnapshot>;
-    createdDirs: Set<string>;
-    /** Paths that were skipped during snapshotDir because they are symlinks. */
-    skippedSymlinks: Set<string>;
-}
-/** Creates an empty rollback journal for tracking touched files and created directories. */
-export declare function createRollbackJournal(): RollbackJournal;
-/** Records a directory that should be removed if the operation later rolls back. */
-export declare function recordCreatedDir(journal: RollbackJournal, dirPath: string): void;
-/**
- * Recursively snapshots every file under a directory tree so a later rollback
- * can restore deleted files. Skips symlinks to avoid following them out of the
- * tree. The directory itself is not recorded as "created", so callers that
- * intend to delete and restore the directory should record it explicitly.
- *
- * Safe to call on a missing path: it returns without recording anything.
- */
-export declare function snapshotDir(journal: RollbackJournal, dirPath: string): Promise<void>;
-/** Snapshots a file once so rollback can restore its previous contents or absence. */
-export declare function snapshotFile(journal: RollbackJournal, filePath: string): Promise<void>;
-/**
- * Asserts that a file about to be mutated was already snapshotted into the
- * journal that will undo the mutation.
- *
- * The snapshot list and the mutation list are separately maintained in every
- * caller that writes conditionally, and they drift: a new conditional write
- * whose matching snapshot condition was not updated produces a file the
- * rollback cannot restore, and nothing notices until a real failure. This
- * checks the pairing at the point of the write, where the two lists are
- * supposed to agree.
- *
- * @param journal - The journal that will restore this file
- * @param filePath - Absolute path about to be written
- * @param context - What is about to write it, for the failure message
- * @throws {@link InternalInvariantError} when the file was never snapshotted.
- */
-export declare function assertSnapshotted(journal: RollbackJournal, filePath: string, context: string): void;
-/** Restores all snapshotted files and removes directories created during the operation. */
-export declare function restoreRollbackJournal(journal: RollbackJournal): Promise<void>;
-/** Restores a rollback journal and wraps rollback failures in a FurnaceError. */
-export declare function restoreRollbackJournalOrThrow(journal: RollbackJournal, context: string): Promise<void>;
-export {};

package/dist/src/core/furnace-rollback.js

@@ -1,170 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { chmod, mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { dirname, isAbsolute, join } from 'node:path';
-import { FurnaceError } from '../errors/furnace.js';
-import { assert } from '../utils/assert.js';
-import { toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
-/** Creates an empty rollback journal for tracking touched files and created directories. */
-export function createRollbackJournal() {
-    return {
-        files: new Map(),
-        createdDirs: new Set(),
-        skippedSymlinks: new Set(),
-    };
-}
-/** Records a directory that should be removed if the operation later rolls back. */
-export function recordCreatedDir(journal, dirPath) {
-    journal.createdDirs.add(dirPath);
-}
-/**
- * Recursively snapshots every file under a directory tree so a later rollback
- * can restore deleted files. Skips symlinks to avoid following them out of the
- * tree. The directory itself is not recorded as "created", so callers that
- * intend to delete and restore the directory should record it explicitly.
- *
- * Safe to call on a missing path: it returns without recording anything.
- */
-export async function snapshotDir(journal, dirPath) {
-    if (!(await pathExists(dirPath))) {
-        return;
-    }
-    const entries = await readdir(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.isSymbolicLink()) {
-            journal.skippedSymlinks.add(join(dirPath, entry.name));
-            continue;
-        }
-        const childPath = join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-            await snapshotDir(journal, childPath);
-        }
-        else if (entry.isFile()) {
-            await snapshotFile(journal, childPath);
-        }
-    }
-}
-/** Snapshots a file once so rollback can restore its previous contents or absence. */
-export async function snapshotFile(journal, filePath) {
-    // Journal keys are the paths rollback will later write back to, and the
-    // restore runs from whatever cwd the process happens to be in by then. A
-    // relative key would therefore restore somewhere other than where the
-    // snapshot was taken, silently, and only on the failure path where nobody
-    // is watching. Every caller composes an absolute path already, and this
-    // keeps it that way.
-    assert(isAbsolute(filePath), () => `snapshot path is absolute (got "${filePath}")`);
-    if (journal.files.has(filePath)) {
-        return;
-    }
-    if (!(await pathExists(filePath))) {
-        journal.files.set(filePath, { existed: false });
-        return;
-    }
-    const [content, fileStat] = await Promise.all([readFile(filePath), stat(filePath)]);
-    journal.files.set(filePath, {
-        existed: true,
-        content,
-        mode: fileStat.mode,
-    });
-}
-/**
- * Asserts that a file about to be mutated was already snapshotted into the
- * journal that will undo the mutation.
- *
- * The snapshot list and the mutation list are separately maintained in every
- * caller that writes conditionally, and they drift: a new conditional write
- * whose matching snapshot condition was not updated produces a file the
- * rollback cannot restore, and nothing notices until a real failure. This
- * checks the pairing at the point of the write, where the two lists are
- * supposed to agree.
- *
- * @param journal - The journal that will restore this file
- * @param filePath - Absolute path about to be written
- * @param context - What is about to write it, for the failure message
- * @throws {@link InternalInvariantError} when the file was never snapshotted.
- */
-export function assertSnapshotted(journal, filePath, context) {
-    assert(journal.files.has(filePath), () => `${context} snapshotted "${filePath}" before mutating it`);
-}
-async function restoreFile(filePath, snapshot) {
-    if (!snapshot.existed) {
-        await rm(filePath, { force: true });
-        return;
-    }
-    await mkdir(dirname(filePath), { recursive: true });
-    // Write to a sibling temp file and atomically rename it over the target. A
-    // direct writeFile would race with any in-flight write by the body (e.g. a
-    // signal-handler-driven rollback landing on top of a still-running
-    // `writeFile('corrupted')`), producing interleaved byte sequences like
-    // `"pristined"` where the first 8 bytes come from the rollback write and
-    // the trailing byte from the body write. rename(2) is atomic within a
-    // filesystem, so either write wins outright and the target is never left
-    // in a hybrid state.
-    const tempPath = `${filePath}.rollback-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    try {
-        await writeFile(tempPath, snapshot.content ?? new Uint8Array());
-        if (snapshot.mode !== undefined) {
-            await chmod(tempPath, snapshot.mode);
-        }
-        await rename(tempPath, filePath);
-    }
-    catch (error) {
-        await rm(tempPath, { force: true }).catch(() => undefined);
-        throw error;
-    }
-}
-/** Maximum number of concurrent file restorations during rollback. */
-const RESTORE_CONCURRENCY = 8;
-/** Restores all snapshotted files and removes directories created during the operation. */
-export async function restoreRollbackJournal(journal) {
-    const fileEntries = [...journal.files.entries()].sort(([left], [right]) => right.length - left.length);
-    // Restore files in parallel with bounded concurrency. Each restoreFile uses
-    // atomic rename, so concurrent restorations to different paths are safe.
-    const errors = [];
-    let index = 0;
-    async function worker() {
-        while (index < fileEntries.length) {
-            const current = index++;
-            const entry = fileEntries[current];
-            if (!entry)
-                break;
-            const [filePath, snapshot] = entry;
-            try {
-                await restoreFile(filePath, snapshot);
-            }
-            catch (error) {
-                errors.push({
-                    path: filePath,
-                    error: toError(error).message,
-                });
-            }
-        }
-    }
-    const workers = Array.from({ length: Math.min(RESTORE_CONCURRENCY, fileEntries.length) }, () => worker());
-    await Promise.all(workers);
-    if (errors.length > 0) {
-        const summary = errors.map((e) => `${e.path}: ${e.error}`).join('; ');
-        throw new FurnaceError(`Rollback failed to restore ${errors.length} file(s): ${summary}`);
-    }
-    // Directory removal is only safe once every file is back where it belongs:
-    // a created directory may hold a restored file, and removing it recursively
-    // would undo the restore we just performed. The throw above is what
-    // normally enforces this. The assertion names it so a future early-return
-    // or error-swallowing edit cannot quietly reach the rm loop with failures
-    // outstanding.
-    assert(errors.length === 0, 'all journal files restored before created directories are removed');
-    const createdDirs = [...journal.createdDirs].sort((left, right) => right.length - left.length);
-    for (const dirPath of createdDirs) {
-        await rm(dirPath, { recursive: true, force: true });
-    }
-}
-/** Restores a rollback journal and wraps rollback failures in a FurnaceError. */
-export async function restoreRollbackJournalOrThrow(journal, context) {
-    try {
-        await restoreRollbackJournal(journal);
-    }
-    catch (error) {
-        const message = toError(error).message;
-        throw new FurnaceError(`${context}; automatic rollback failed: ${message}`);
-    }
-}

package/dist/src/core/furnace-scanner.d.ts

@@ -1,47 +0,0 @@
-import type { ScannedComponent } from '../types/furnace.js';
-/** Path to the widgets directory within the engine source tree */
-/**
- * Additional Firefox source directories known to contain MozLitElement
- * components. Used by `--deep` scan mode to discover components beyond
- * the primary widgets directory.
- */
-export declare const DEEP_SCAN_PATHS: readonly string[];
-/**
- * Parses customElements.js to extract tag-to-module mappings.
- *
- * Looks for registration patterns like:
- * ```
- * lazy.customElements.setElementCreationCallback("moz-button", () => {
- *   import("chrome://global/content/elements/moz-button.mjs");
- * });
- * ```
- *
- * @param engineDir - Path to the Firefox engine source root
- * @returns Map of tagName to module path
- */
-export declare function scanCustomElementsRegistrations(engineDir: string): Promise<Map<string, string>>;
-/**
- * Scans the widgets directory to discover all MozLitElement custom elements.
- *
- * Each subdirectory starting with `moz-` that contains a `.mjs` file is
- * considered a component. For each component, checks whether it has associated
- * CSS, Fluent localization, and customElements.js registration.
- *
- * @param engineDir - Path to the Firefox engine source root
- * @returns Array of discovered components
- */
-export declare function scanWidgetsDirectory(engineDir: string, ftlDir?: string, extraPaths?: string[], componentPrefix?: string): Promise<ScannedComponent[]>;
-/**
- * Gets detailed information about a single component by tag name.
- * @param engineDir - Path to the Firefox engine source root
- * @param tagName - Component tag name (e.g., "moz-button")
- * @returns Component details, or null if not found in the source tree
- */
-export declare function getComponentDetails(engineDir: string, tagName: string, ftlDir?: string): Promise<ScannedComponent | null>;
-/**
- * Checks whether a component directory exists in the engine source tree.
- * @param engineDir - Path to the Firefox engine source root
- * @param tagName - Component tag name (e.g., "moz-button")
- * @returns True if the component directory exists
- */
-export declare function isComponentInEngine(engineDir: string, tagName: string): Promise<boolean>;