@hominis/fireforge 0.9.0

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

@@ -0,0 +1,372 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { FurnaceError } from '../errors/furnace.js';
+import { toError } from '../utils/errors.js';
+import { pathExists, readJson, writeJson } from '../utils/fs.js';
+import { warn } from '../utils/logger.js';
+import { isArray, isBoolean, isObject, isString } from '../utils/validation.js';
+import { FIREFORGE_DIR } from './config.js';
+import { quarantineStateFile, withStateFileLock } from './state-file.js';
+/** Name of the furnace configuration file */
+export const FURNACE_CONFIG_FILENAME = 'furnace.json';
+/** Name of the furnace state file */
+export const FURNACE_STATE_FILENAME = 'furnace-state.json';
+/** Name of the components directory */
+export const COMPONENTS_DIR = 'components';
+/** Name of the overrides subdirectory */
+export const OVERRIDES_DIR = 'overrides';
+/** Name of the custom subdirectory */
+export const CUSTOM_DIR = 'custom';
+/**
+ * Gets all furnace-related paths based on a root directory.
+ * @param root - Root directory of the project
+ * @returns All furnace paths
+ */
+export function getFurnacePaths(root) {
+    const componentsDir = join(root, COMPONENTS_DIR);
+    return {
+        furnaceConfig: join(root, FURNACE_CONFIG_FILENAME),
+        componentsDir,
+        overridesDir: join(componentsDir, OVERRIDES_DIR),
+        customDir: join(componentsDir, CUSTOM_DIR),
+        furnaceState: join(root, FIREFORGE_DIR, FURNACE_STATE_FILENAME),
+    };
+}
+/**
+ * Checks if a furnace.json exists in the given directory.
+ * @param root - Root directory to check
+ * @returns True if furnace.json exists
+ */
+export async function furnaceConfigExists(root) {
+    const paths = getFurnacePaths(root);
+    return pathExists(paths.furnaceConfig);
+}
+/**
+ * Validates an override component config object.
+ * @param data - Raw data to validate
+ * @param name - Component name for error messages
+ */
+function parseStringArray(value, fieldName) {
+    if (!isArray(value)) {
+        throw new FurnaceError(`Furnace config: "${fieldName}" must be an array`);
+    }
+    const items = [];
+    for (const item of value) {
+        if (!isString(item)) {
+            throw new FurnaceError(`Furnace config: "${fieldName}" array must contain only strings`);
+        }
+        items.push(item);
+    }
+    return items;
+}
+function parseOverrideConfig(data, name) {
+    const validTypes = ['css-only', 'full'];
+    if (!isString(data['type']) || !validTypes.includes(data['type'])) {
+        throw new FurnaceError(`Furnace config: override "${name}.type" must be one of: ${validTypes.join(', ')}`);
+    }
+    if (!isString(data['description'])) {
+        throw new FurnaceError(`Furnace config: override "${name}.description" must be a string`);
+    }
+    if (!isString(data['basePath'])) {
+        throw new FurnaceError(`Furnace config: override "${name}.basePath" must be a string`);
+    }
+    if (data['basePath'].includes('..')) {
+        throw new FurnaceError(`Furnace config: override "${name}.basePath" must not contain ".." (path traversal)`);
+    }
+    if (!isString(data['baseVersion'])) {
+        throw new FurnaceError(`Furnace config: override "${name}.baseVersion" must be a string`);
+    }
+    return {
+        type: data['type'] === 'css-only' ? 'css-only' : 'full',
+        description: data['description'],
+        basePath: data['basePath'],
+        baseVersion: data['baseVersion'],
+    };
+}
+/**
+ * Validates a custom component config object.
+ * @param data - Raw data to validate
+ * @param name - Component name for error messages
+ */
+function parseCustomConfig(data, name) {
+    if (!isString(data['description'])) {
+        throw new FurnaceError(`Furnace config: custom "${name}.description" must be a string`);
+    }
+    if (!isString(data['targetPath'])) {
+        throw new FurnaceError(`Furnace config: custom "${name}.targetPath" must be a string`);
+    }
+    if (data['targetPath'].includes('..')) {
+        throw new FurnaceError(`Furnace config: custom "${name}.targetPath" must not contain ".." (path traversal)`);
+    }
+    if (!isBoolean(data['register'])) {
+        throw new FurnaceError(`Furnace config: custom "${name}.register" must be a boolean`);
+    }
+    if (!isBoolean(data['localized'])) {
+        throw new FurnaceError(`Furnace config: custom "${name}.localized" must be a boolean`);
+    }
+    if (data['composes'] !== undefined) {
+        parseStringArray(data['composes'], `${name}.composes`);
+    }
+    return {
+        description: data['description'],
+        targetPath: data['targetPath'],
+        register: data['register'],
+        localized: data['localized'],
+        ...(data['composes'] !== undefined
+            ? { composes: parseStringArray(data['composes'], `${name}.composes`) }
+            : {}),
+    };
+}
+/**
+ * Validates a raw config object and returns a typed FurnaceConfig.
+ * @param data - Raw data to validate
+ * @returns Validated FurnaceConfig
+ * @throws Error if validation fails
+ */
+export function validateFurnaceConfig(data) {
+    if (!isObject(data)) {
+        throw new FurnaceError('Furnace config must be an object');
+    }
+    if (data['version'] !== 1) {
+        throw new FurnaceError('Furnace config: "version" must be 1');
+    }
+    if (!isString(data['componentPrefix'])) {
+        throw new FurnaceError('Furnace config: "componentPrefix" must be a string');
+    }
+    // Validate optional tokenPrefix
+    if (data['tokenPrefix'] !== undefined && !isString(data['tokenPrefix'])) {
+        throw new FurnaceError('Furnace config: "tokenPrefix" must be a string if provided');
+    }
+    // Validate optional tokenAllowlist
+    if (data['tokenAllowlist'] !== undefined) {
+        parseStringArray(data['tokenAllowlist'], 'tokenAllowlist');
+    }
+    const stock = parseStringArray(data['stock'], 'stock');
+    // Validate overrides
+    if (!isObject(data['overrides'])) {
+        throw new FurnaceError('Furnace config: "overrides" must be an object');
+    }
+    const overrides = {};
+    for (const [name, value] of Object.entries(data['overrides'])) {
+        if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+            throw new FurnaceError(`Furnace config: override name "${name}" must match /^[a-z][a-z0-9-]*$/ (lowercase, no path separators)`);
+        }
+        if (!isObject(value)) {
+            throw new FurnaceError(`Furnace config: override "${name}" must be an object`);
+        }
+        overrides[name] = parseOverrideConfig(value, name);
+    }
+    // Validate custom
+    if (!isObject(data['custom'])) {
+        throw new FurnaceError('Furnace config: "custom" must be an object');
+    }
+    const custom = {};
+    for (const [name, value] of Object.entries(data['custom'])) {
+        if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+            throw new FurnaceError(`Furnace config: custom name "${name}" must match /^[a-z][a-z0-9-]*$/ (lowercase, no path separators)`);
+        }
+        if (!isObject(value)) {
+            throw new FurnaceError(`Furnace config: custom "${name}" must be an object`);
+        }
+        custom[name] = parseCustomConfig(value, name);
+    }
+    const config = {
+        version: 1,
+        componentPrefix: data['componentPrefix'],
+        stock,
+        overrides,
+        custom,
+    };
+    if (data['tokenPrefix'] !== undefined) {
+        config.tokenPrefix = data['tokenPrefix'];
+    }
+    if (data['tokenAllowlist'] !== undefined) {
+        config.tokenAllowlist = parseStringArray(data['tokenAllowlist'], 'tokenAllowlist');
+    }
+    return config;
+}
+/**
+ * Validates a parsed furnace state object and returns a typed FurnaceState.
+ * @param data - Parsed JSON state data
+ * @returns Validated FurnaceState
+ */
+export function validateFurnaceState(data) {
+    const result = sanitizeFurnaceState(data);
+    if (result.issues.length > 0) {
+        throw new FurnaceError(`Invalid furnace state: ${result.issues.join('; ')}`);
+    }
+    return result.state;
+}
+function sanitizeFurnaceState(data) {
+    if (!isObject(data)) {
+        return {
+            state: {},
+            issues: ['the root value must be a JSON object'],
+            recoveredFields: [],
+        };
+    }
+    const state = {};
+    const issues = [];
+    const recoveredFields = [];
+    if (data['lastApply'] !== undefined) {
+        if (!isString(data['lastApply'])) {
+            issues.push('field "lastApply" must be a string');
+        }
+        else {
+            state.lastApply = data['lastApply'];
+            recoveredFields.push('lastApply');
+        }
+    }
+    if (data['appliedChecksums'] !== undefined) {
+        if (!isObject(data['appliedChecksums'])) {
+            issues.push('field "appliedChecksums" must be an object of string checksum values');
+        }
+        else {
+            const appliedChecksums = {};
+            let hasInvalidChecksum = false;
+            for (const [filePath, checksum] of Object.entries(data['appliedChecksums'])) {
+                if (!isString(checksum)) {
+                    hasInvalidChecksum = true;
+                    issues.push(`appliedChecksums["${filePath}"] must be a string`);
+                    continue;
+                }
+                appliedChecksums[filePath] = checksum;
+            }
+            if (Object.keys(appliedChecksums).length > 0 || !hasInvalidChecksum) {
+                state.appliedChecksums = appliedChecksums;
+                recoveredFields.push('appliedChecksums');
+            }
+        }
+    }
+    return { state, issues, recoveredFields };
+}
+async function recoverInvalidFurnaceState(statePath, result, alreadyLocked = false) {
+    const recover = async () => {
+        const quarantinedFile = await quarantineStateFile(statePath, 'invalid');
+        if (result.recoveredFields.length > 0) {
+            await writeJson(statePath, result.state);
+        }
+        const recoveryMessage = result.recoveredFields.length > 0
+            ? ` Recovered valid field${result.recoveredFields.length === 1 ? '' : 's'}: ${result.recoveredFields.join(', ')}.`
+            : ' No valid furnace state fields could be recovered; using defaults.';
+        const quarantineMessage = quarantinedFile
+            ? ` Quarantined the original file as ${quarantinedFile}.`
+            : '';
+        warn(`Furnace state file (.fireforge/furnace-state.json) was invalid: ${result.issues.join('; ')}.${recoveryMessage}${quarantineMessage}`);
+        return result.state;
+    };
+    return alreadyLocked ? recover() : withStateFileLock(statePath, recover);
+}
+async function loadFurnaceStateFromPath(statePath, alreadyLocked = false) {
+    if (!(await pathExists(statePath))) {
+        return {};
+    }
+    try {
+        const data = await readJson(statePath);
+        const result = sanitizeFurnaceState(data);
+        if (result.issues.length === 0) {
+            return result.state;
+        }
+        return await recoverInvalidFurnaceState(statePath, result, alreadyLocked);
+    }
+    catch (error) {
+        return await recoverInvalidFurnaceState(statePath, {
+            state: {},
+            issues: [`the file could not be parsed: ${toError(error).message}`],
+            recoveredFields: [],
+        }, alreadyLocked);
+    }
+}
+/**
+ * Loads and validates the furnace.json configuration.
+ * @param root - Root directory of the project
+ * @returns Validated FurnaceConfig
+ * @throws Error if config doesn't exist or is invalid
+ */
+export async function loadFurnaceConfig(root) {
+    const paths = getFurnacePaths(root);
+    if (!(await pathExists(paths.furnaceConfig))) {
+        throw new FurnaceError(`Furnace configuration file not found: ${paths.furnaceConfig}\n\n` +
+            'Run "fireforge furnace create" or "fireforge furnace override" to get started.');
+    }
+    try {
+        const data = await readJson(paths.furnaceConfig);
+        return validateFurnaceConfig(data);
+    }
+    catch (error) {
+        if (error instanceof FurnaceError) {
+            throw error;
+        }
+        throw new FurnaceError(`Invalid furnace.json at ${paths.furnaceConfig}: ${toError(error).message}`);
+    }
+}
+/**
+ * Writes a furnace configuration to furnace.json.
+ * @param root - Root directory of the project
+ * @param config - Configuration to write
+ */
+export async function writeFurnaceConfig(root, config) {
+    const paths = getFurnacePaths(root);
+    await writeJson(paths.furnaceConfig, config);
+}
+/**
+ * Creates a default furnace configuration.
+ * @returns A valid empty FurnaceConfig
+ */
+export function createDefaultFurnaceConfig() {
+    return {
+        version: 1,
+        componentPrefix: 'moz-',
+        stock: [],
+        overrides: {},
+        custom: {},
+    };
+}
+/**
+ * Loads furnace config if it exists, or creates and writes a default config.
+ * @param root - Root directory of the project
+ * @returns FurnaceConfig (existing or newly created)
+ */
+export async function ensureFurnaceConfig(root) {
+    if (await furnaceConfigExists(root)) {
+        return loadFurnaceConfig(root);
+    }
+    const config = createDefaultFurnaceConfig();
+    await writeFurnaceConfig(root, config);
+    return config;
+}
+/**
+ * Loads the furnace state, or returns defaults if it doesn't exist.
+ * @param root - Root directory of the project
+ * @returns Furnace state
+ */
+export async function loadFurnaceState(root) {
+    const paths = getFurnacePaths(root);
+    return loadFurnaceStateFromPath(paths.furnaceState);
+}
+/**
+ * Saves the furnace state.
+ * @param root - Root directory of the project
+ * @param state - State to save
+ */
+export async function saveFurnaceState(root, state) {
+    const paths = getFurnacePaths(root);
+    const validatedState = validateFurnaceState(state);
+    await withStateFileLock(paths.furnaceState, async () => {
+        await writeJson(paths.furnaceState, validatedState);
+    });
+}
+/**
+ * Updates furnace state fields transactionally under the state file lock.
+ * @param root - Root directory of the project
+ * @param updates - Fields to update, or a transactional updater function
+ */
+export async function updateFurnaceState(root, updates) {
+    const paths = getFurnacePaths(root);
+    await withStateFileLock(paths.furnaceState, async () => {
+        const current = await loadFurnaceStateFromPath(paths.furnaceState, true);
+        const nextState = typeof updates === 'function' ? updates(current) : { ...current, ...updates };
+        await writeJson(paths.furnaceState, validateFurnaceState(nextState));
+    });
+}
+//# sourceMappingURL=furnace-config.js.map

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

@@ -0,0 +1,4 @@
+/** Path to customElements.js within the engine source tree */
+export declare const CUSTOM_ELEMENTS_JS = "toolkit/content/customElements.js";
+/** Path to jar.mn within the engine source tree (toolkit global) */
+export declare const JAR_MN = "toolkit/content/jar.mn";

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

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: EUPL-1.2
+/** Path to customElements.js within the engine source tree */
+export const CUSTOM_ELEMENTS_JS = 'toolkit/content/customElements.js';
+/** Path to jar.mn within the engine source tree (toolkit global) */
+export const JAR_MN = 'toolkit/content/jar.mn';
+//# sourceMappingURL=furnace-constants.js.map

package/dist/src/core/furnace-registration-ast.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AST-based custom element registration updates for customElements.js.
+ * Removal logic is in furnace-registration-remove.ts.
+ */
+export { removeCustomElementRegistration } from './furnace-registration-remove.js';
+export { CUSTOM_ELEMENTS_JS, JAR_MN } from './furnace-constants.js';
+/**
+ * Adds a custom element registration entry to customElements.js.
+ *
+ * The entry is inserted into the array literal inside the `for...of` loop
+ * that registers all custom elements:
+ * ```js
+ *   ["tag", "chrome://global/content/elements/tag.mjs"],
+ * ```
+ *
+ * New entries are inserted in alphabetical order relative to existing entries.
+ * This operation is idempotent — if the tag is already registered the file is
+ * left unchanged.
+ *
+ * @param engineDir - Path to the Firefox engine source root
+ * @param tagName - Custom element tag name
+ * @param modulePath - chrome:// URI for the module
+ */
+export declare function addCustomElementRegistration(engineDir: string, tagName: string, modulePath: string): Promise<void>;

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

@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * AST-based custom element registration updates for customElements.js.
+ * Removal logic is in furnace-registration-remove.ts.
+ */
+import { join } from 'node:path';
+import MagicString from 'magic-string';
+import { FurnaceError } from '../errors/furnace.js';
+import { toError } from '../utils/errors.js';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { detectIndent, getNodeSource, parseScript, walkAST, } from './ast-utils.js';
+import { CUSTOM_ELEMENTS_JS } from './furnace-constants.js';
+import { validateRegistrationPlacement, validateTagName } from './furnace-registration-validate.js';
+// Re-export from split modules so existing import sites continue working
+export { removeCustomElementRegistration } from './furnace-registration-remove.js';
+// Re-export constants so existing import sites continue working
+export { CUSTOM_ELEMENTS_JS, JAR_MN } from './furnace-constants.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Checks whether a `ForOfStatement` is nested inside a
+ * `document.addEventListener("DOMContentLoaded", ...)` call by
+ * inspecting the ancestor stack.
+ */
+function isInsideDOMContentLoaded(ancestors, content) {
+    for (let i = ancestors.length - 1; i >= 0; i--) {
+        const ancestor = ancestors[i];
+        if (!ancestor || ancestor.type !== 'CallExpression')
+            continue;
+        const call = ancestor;
+        if (call.callee.type === 'MemberExpression' &&
+            call.callee.object.type === 'Identifier' &&
+            call.callee.object.name === 'document' &&
+            call.callee.property.type === 'Identifier' &&
+            call.callee.property.name === 'addEventListener') {
+            const firstArg = call.arguments[0];
+            if (firstArg &&
+                firstArg.type === 'Literal' &&
+                firstArg.value === 'DOMContentLoaded') {
+                return true;
+            }
+            // Check if "DOMContentLoaded" appears in the call's source (handles edge cases)
+            const src = getNodeSource(content, call);
+            if (/["']DOMContentLoaded["']/.test(src)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function selectRegistrationTarget(targets, isESModule, tagName) {
+    const target = isESModule
+        ? targets.find((candidate) => candidate.insideDCL)
+        : targets.find((candidate) => !candidate.insideDCL);
+    if (target) {
+        return target;
+    }
+    if (isESModule) {
+        throw new FurnaceError('Could not find DOMContentLoaded block in customElements.js', tagName);
+    }
+    throw new FurnaceError(`${tagName} would land in the DOMContentLoaded/importESModule block (Pattern B) instead of the loadSubScript block (Pattern A) — no non-DOMContentLoaded registration array found in customElements.js. The file structure may have changed upstream — manual intervention required.`, tagName);
+}
+function buildRegistrationEntry(referenceEntry, tagName, modulePath) {
+    if (!referenceEntry) {
+        return `    ["${tagName}", "${modulePath}"],`;
+    }
+    if (referenceEntry.isMultiLine) {
+        const indent = referenceEntry.indent;
+        const inner = referenceEntry.innerIndent ?? indent + '  ';
+        return `${indent}[\n${inner}"${tagName}",\n${inner}"${modulePath}",\n${indent}],`;
+    }
+    return `${referenceEntry.indent}["${tagName}", "${modulePath}"],`;
+}
+/**
+ * AST-based implementation: parses customElements.js, walks to find the
+ * target ForOfStatement array, and inserts the new entry at the correct
+ * alphabetical position using magic-string.
+ */
+function addRegistrationAST(content, tagName, modulePath, isESModule) {
+    validateTagName(tagName);
+    const ast = parseScript(content);
+    const ancestors = [];
+    // Collect all ForOfStatement nodes with ArrayExpression rights
+    const forOfs = [];
+    walkAST(ast, {
+        enter(node) {
+            ancestors.push(node);
+            if (node.type === 'ForOfStatement') {
+                const forOf = node;
+                if (forOf.right.type === 'ArrayExpression') {
+                    const array = forOf.right;
+                    forOfs.push({
+                        array,
+                        insideDCL: isInsideDOMContentLoaded(ancestors, content),
+                    });
+                }
+            }
+        },
+        leave() {
+            ancestors.pop();
+        },
+    });
+    // Select the target array
+    const target = selectRegistrationTarget(forOfs, isESModule, tagName);
+    const array = target.array;
+    // Parse existing entries from the ArrayExpression elements
+    const entries = [];
+    for (const el of array.elements) {
+        if (!el || el.type !== 'ArrayExpression')
+            continue;
+        const entryArr = el;
+        const firstEl = entryArr.elements[0];
+        if (!firstEl || firstEl.type !== 'Literal')
+            continue;
+        const tag = String(firstEl.value);
+        // Detect if this entry is multi-line
+        const entrySrc = getNodeSource(content, entryArr);
+        const isMultiLine = entrySrc.includes('\n');
+        const indent = detectIndent(content, entryArr.start);
+        let innerIndent;
+        if (isMultiLine) {
+            const firstElNode = firstEl;
+            innerIndent = detectIndent(content, firstElNode.start);
+        }
+        entries.push({ tag, node: entryArr, isMultiLine, indent, innerIndent });
+    }
+    // Find alphabetical insertion position
+    let insertAfterNode = null;
+    let insertBeforeNode = null;
+    let referenceEntry;
+    for (const entry of entries) {
+        if (entry.tag > tagName) {
+            insertBeforeNode = entry.node;
+            if (!referenceEntry)
+                referenceEntry = entry;
+            break;
+        }
+        insertAfterNode = entry.node;
+        referenceEntry = entry;
+    }
+    // Build new entry string matching detected format
+    const newEntry = buildRegistrationEntry(referenceEntry, tagName, modulePath);
+    const ms = new MagicString(content);
+    // Helper: find the start-of-line position for a given offset
+    function lineStart(pos) {
+        let i = pos - 1;
+        while (i >= 0 && content[i] !== '\n')
+            i--;
+        return i + 1;
+    }
+    // Helper: find the end-of-line position (the \n itself) for a given offset
+    function lineEnd(pos) {
+        let i = pos;
+        while (i < content.length && content[i] !== '\n')
+            i++;
+        return i;
+    }
+    // Find the insertion position (character offset)
+    if (insertBeforeNode) {
+        const sol = lineStart(insertBeforeNode.start);
+        ms.appendLeft(sol, newEntry + '\n');
+    }
+    else if (insertAfterNode) {
+        const eol = lineEnd(insertAfterNode.end);
+        ms.appendRight(eol, '\n' + newEntry);
+    }
+    else {
+        const eol = lineEnd(array.start);
+        ms.appendRight(eol, '\n' + newEntry);
+    }
+    return ms.toString();
+}
+/**
+ * Adds a custom element registration entry to customElements.js.
+ *
+ * The entry is inserted into the array literal inside the `for...of` loop
+ * that registers all custom elements:
+ * ```js
+ *   ["tag", "chrome://global/content/elements/tag.mjs"],
+ * ```
+ *
+ * New entries are inserted in alphabetical order relative to existing entries.
+ * This operation is idempotent — if the tag is already registered the file is
+ * left unchanged.
+ *
+ * @param engineDir - Path to the Firefox engine source root
+ * @param tagName - Custom element tag name
+ * @param modulePath - chrome:// URI for the module
+ */
+export async function addCustomElementRegistration(engineDir, tagName, modulePath) {
+    const filePath = join(engineDir, CUSTOM_ELEMENTS_JS);
+    if (!(await pathExists(filePath))) {
+        throw new FurnaceError('customElements.js not found in engine', tagName);
+    }
+    const content = await readText(filePath);
+    // Idempotency: already registered (standalone block or array entry).
+    if (content.includes(`setElementCreationCallback("${tagName}"`) ||
+        content.includes(`["${tagName}",`) ||
+        new RegExp(`^\\s*"${tagName}",\\s*$`, 'm').test(content)) {
+        return;
+    }
+    const isESModule = modulePath.endsWith('.mjs');
+    let nextContent;
+    try {
+        nextContent = addRegistrationAST(content, tagName, modulePath, isESModule);
+    }
+    catch (error) {
+        if (error instanceof FurnaceError) {
+            throw error;
+        }
+        const parserError = toError(error);
+        throw new FurnaceError(`Failed to update ${CUSTOM_ELEMENTS_JS} using AST registration parsing: ${parserError.message}`, tagName, parserError);
+    }
+    validateRegistrationPlacement(nextContent, tagName, isESModule);
+    await writeText(filePath, nextContent);
+}
+//# sourceMappingURL=furnace-registration-ast.js.map

package/dist/src/core/furnace-registration-remove.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Removal of custom element registrations from customElements.js.
+ * Supports three removal strategies: standalone callback, single-line array, multi-line array.
+ */
+/**
+ * Removes a custom element registration from customElements.js.
+ *
+ * This operation is idempotent — if the tag is not registered or the file does
+ * not exist, nothing happens.
+ *
+ * @param engineDir - Path to the Firefox engine source root
+ * @param tagName - Custom element tag name to remove
+ */
+export declare function removeCustomElementRegistration(engineDir: string, tagName: string): Promise<void>;