@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/branding.js

@@ -1,371 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { FireForgeError } from '../errors/base.js';
-import { ExitCode } from '../errors/codes.js';
-import { copyDir, pathExists, readText, writeTextIfChanged } from '../utils/fs.js';
-import { warn } from '../utils/logger.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { DEFAULT_LICENSE, getLicenseHeader } from './license-headers.js';
-/**
- * Error thrown when branding operations fail.
- */
-class BrandingError extends FireForgeError {
-    code = ExitCode.PATCH_ERROR;
-    get userMessage() {
-        return `Branding Error: ${this.message}\n\nBranding is required to set MOZ_APP_VENDOR, MOZ_MACBUNDLE_ID, and other Firefox identity values.`;
-    }
-}
-/**
- * Error thrown when the generated `mozconfig` references a `--with-branding`
- * directory that does not match the branding tree FireForge set up. The
- * mismatch is a silent-corruption hazard: `mach configure` picks the value
- * from mozconfig but the scaffolded branding lives elsewhere, so the build
- * fails deep inside moz.build resolution with a confusing "path does not
- * exist" message. Surface it as an actionable preflight instead.
- *
- * Setup renders templates under `configs/` with `${binaryName}` baked in. A
- * later edit to `fireforge.json`'s `binaryName` (or a re-setup without
- * re-templating) leaves those names stale while `setupBranding` keeps using
- * the current value. Both directions produce the same class of build break.
- */
-export class BrandingMozconfigMismatchError extends FireForgeError {
-    expectedBrandingDir;
-    mozconfigBrandingDir;
-    reason;
-    code = ExitCode.PATCH_ERROR;
-    constructor(expectedBrandingDir, mozconfigBrandingDir, reason) {
-        super(`Generated mozconfig references "${mozconfigBrandingDir}" but the active branding directory is "${expectedBrandingDir}".`);
-        this.expectedBrandingDir = expectedBrandingDir;
-        this.mozconfigBrandingDir = mozconfigBrandingDir;
-        this.reason = reason;
-    }
-    get userMessage() {
-        const diagnosis = this.reason === 'mozconfig-missing-branding'
-            ? `The generated mozconfig does not contain a --with-branding directive (found "${this.mozconfigBrandingDir}"). FireForge expected to write one for binaryName "${this.expectedBrandingDir}".`
-            : this.reason === 'name-mismatch'
-                ? `The generated mozconfig sets --with-branding="${this.mozconfigBrandingDir}" but FireForge set up branding under "${this.expectedBrandingDir}".`
-                : `The generated mozconfig sets --with-branding="${this.mozconfigBrandingDir}" but no moz.build exists under engine/${this.mozconfigBrandingDir}/.`;
-        return (`Branding Error: ${diagnosis}\n\n` +
-            'This usually means the rendered configs/ templates drifted from fireforge.json. Fix one of:\n' +
-            '  1. Edit configs/common.mozconfig so --with-branding uses ${binaryName} (or the current binaryName), then re-run "fireforge build".\n' +
-            '  2. Update fireforge.json so binaryName matches the --with-branding value baked into configs/.\n\n' +
-            'The mismatch is caught before mach builds because resolving the build against the wrong branding tree fails deep in moz.build with a confusing "path does not exist" message.');
-    }
-}
-/**
- * Splits the reverse-domain `appId` for macOS bundle identity. Upstream
- * `toolkit/moz.configure` composes `CFBundleIdentifier` as
- * `<--with-distribution-id>.<MOZ_MACBUNDLE_ID>` (the distribution id
- * defaults to `org.mozilla`), so branding `configure.sh` must carry only the
- * leaf segment while the generated mozconfig carries the remainder as
- * `--with-distribution-id`. Writing the full appId into `MOZ_MACBUNDLE_ID`
- * double-prefixes the shipped bundle id. Config validation guarantees a
- * reverse-domain id, so the split always has both halves.
- */
-export function splitAppId(appId) {
-    const lastDot = appId.lastIndexOf('.');
-    return { distributionId: appId.slice(0, lastDot), leaf: appId.slice(lastDot + 1) };
-}
-const MOZ_APP_VENDOR_IMPLY_REGEX = /imply_option\("MOZ_APP_VENDOR",\s*"[^"]*"\)/;
-const BRANDING_CONFIGURE_MANAGED_KEYS = new Set([
-    'MOZ_APP_DISPLAYNAME',
-    'MOZ_APP_VENDOR',
-    'MOZ_MACBUNDLE_ID',
-]);
-/**
- * Sets up the custom branding directory for the browser.
- *
- * This creates a branding directory based on Firefox's unofficial branding,
- * with customized values for:
- * - configure.sh: MOZ_APP_DISPLAYNAME, MOZ_MACBUNDLE_ID
- * - brand.properties: brandShorterName, brandShortName, brandFullName
- * - brand.ftl: -brand-shorter-name, -brand-short-name, etc.
- *
- * @param engineDir - Path to the engine directory
- * @param config - Branding configuration
- */
-export async function setupBranding(engineDir, config) {
-    const brandingDir = join(engineDir, 'browser', 'branding', config.binaryName);
-    const unofficialDir = join(engineDir, 'browser', 'branding', 'unofficial');
-    // Check if unofficial branding exists as our base
-    if (!(await pathExists(unofficialDir))) {
-        throw new BrandingError(`Unofficial branding directory not found at ${unofficialDir}`);
-    }
-    // Copy unofficial branding as base (if our branding doesn't exist yet)
-    if (!(await pathExists(brandingDir))) {
-        await copyDir(unofficialDir, brandingDir);
-    }
-    const vendorPlacement = await resolveVendorPlacement(engineDir);
-    // Create/update configure.sh with custom values
-    await createConfigureScript(brandingDir, config, vendorPlacement);
-    // Update localization files
-    await updateBrandProperties(brandingDir, config);
-    await updateBrandFtl(brandingDir, config);
-    // Patch moz.configure for MOZ_APP_VENDOR
-    await patchMozConfigure(engineDir, config, vendorPlacement);
-}
-/**
- * Creates the branding configure.sh script.
- */
-async function createConfigureScript(brandingDir, config, vendorPlacement) {
-    const configureShPath = join(brandingDir, 'configure.sh');
-    const existing = (await pathExists(configureShPath))
-        ? await readText(configureShPath)
-        : undefined;
-    await writeTextIfChanged(configureShPath, buildConfigureScriptContent(config, vendorPlacement, existing));
-}
-function buildConfigureScriptContent(config, vendorPlacement, existingContent) {
-    const header = getLicenseHeader(config.license ?? DEFAULT_LICENSE, 'hash');
-    const managedLines = [`MOZ_APP_DISPLAYNAME="${escapeShellValue(config.name)}"`];
-    if (vendorPlacement === 'branding-configure') {
-        managedLines.push(`MOZ_APP_VENDOR="${escapeShellValue(config.vendor)}"`);
-    }
-    managedLines.push(`MOZ_MACBUNDLE_ID="${escapeShellValue(splitAppId(config.appId).leaf)}"`);
-    const preservedLines = existingContent ? extractPreservedConfigureLines(existingContent) : [];
-    const body = [...managedLines, ...preservedLines].join('\n');
-    return `${header}\n\n${body}\n`;
-}
-function extractPreservedConfigureLines(content) {
-    return content.split(/\r?\n/).filter((line) => {
-        const trimmed = line.trim();
-        if (trimmed.length === 0)
-            return false;
-        if (/^#\s*SPDX-License-Identifier:/i.test(trimmed))
-            return false;
-        const keyMatch = /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(trimmed);
-        if (keyMatch && BRANDING_CONFIGURE_MANAGED_KEYS.has(keyMatch[1] ?? ''))
-            return false;
-        return true;
-    });
-}
-function parseConfigureAssignments(content) {
-    const assignments = new Map();
-    for (const line of content.split(/\r?\n/)) {
-        const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line.trim());
-        if (match?.[1] && match[2] !== undefined) {
-            assignments.set(match[1], match[2]);
-        }
-    }
-    return assignments;
-}
-function isConfigureScriptCurrent(content, config, vendorPlacement) {
-    const assignments = parseConfigureAssignments(content);
-    if (assignments.get('MOZ_APP_DISPLAYNAME') !== `"${escapeShellValue(config.name)}"`) {
-        return false;
-    }
-    if (assignments.get('MOZ_MACBUNDLE_ID') !== `"${escapeShellValue(splitAppId(config.appId).leaf)}"`) {
-        return false;
-    }
-    const vendorValue = assignments.get('MOZ_APP_VENDOR');
-    if (vendorPlacement === 'branding-configure') {
-        return vendorValue === `"${escapeShellValue(config.vendor)}"`;
-    }
-    return vendorValue === undefined;
-}
-/**
- * Updates the brand.properties localization file.
- */
-async function updateBrandProperties(brandingDir, config) {
-    const propsPath = join(brandingDir, 'locales', 'en-US', 'brand.properties');
-    if (!(await pathExists(propsPath))) {
-        warn('brand.properties not found in branding directory — browser will use default strings');
-        return;
-    }
-    await writeTextIfChanged(propsPath, buildBrandPropertiesContent(config));
-}
-function buildBrandPropertiesContent(config) {
-    const header = getLicenseHeader(config.license ?? DEFAULT_LICENSE, 'hash');
-    return `${header}
-
-brandShorterName=${escapePropertiesValue(config.name)}
-brandShortName=${escapePropertiesValue(config.name)}
-brandFullName=${escapePropertiesValue(config.name)}
-`;
-}
-/**
- * Updates the brand.ftl localization file.
- */
-async function updateBrandFtl(brandingDir, config) {
-    const ftlPath = join(brandingDir, 'locales', 'en-US', 'brand.ftl');
-    if (!(await pathExists(ftlPath))) {
-        warn('brand.ftl not found in branding directory — browser will use default strings');
-        return;
-    }
-    await writeTextIfChanged(ftlPath, buildBrandFtlContent(config));
-}
-function buildBrandFtlContent(config) {
-    const header = getLicenseHeader(config.license ?? DEFAULT_LICENSE, 'hash');
-    return `${header}
-
-## Brand names
-##
-## These brand names can be used in messages.
-
--brand-shorter-name = ${escapeFtlValue(config.name)}
--brand-short-name = ${escapeFtlValue(config.name)}
--brand-shortcut-name = ${escapeFtlValue(config.name)}
--brand-full-name = ${escapeFtlValue(config.name)}
--brand-product-name = ${escapeFtlValue(config.name)}
--vendor-short-name = ${escapeFtlValue(config.vendor)}
-trademarkInfo = { " " }
-`;
-}
-/**
- * Patches browser/moz.configure to set custom vendor when the upstream
- * configure surface owns MOZ_APP_VENDOR as a project flag. ESR 140 rejects
- * branding configure.sh / confvars origins for that flag, so the value must
- * come from imply_option.
- */
-async function patchMozConfigure(engineDir, config, vendorPlacement) {
-    if (vendorPlacement !== 'moz-configure') {
-        return;
-    }
-    const mozConfigurePath = join(engineDir, 'browser', 'moz.configure');
-    if (!(await pathExists(mozConfigurePath))) {
-        return;
-    }
-    let content = await readText(mozConfigurePath);
-    if (MOZ_APP_VENDOR_IMPLY_REGEX.test(content)) {
-        content = content.replace(MOZ_APP_VENDOR_IMPLY_REGEX, buildMozConfigureVendorLine(config));
-    }
-    else {
-        content = insertMozConfigureVendorLine(content, buildMozConfigureVendorLine(config));
-    }
-    await writeTextIfChanged(mozConfigurePath, content);
-}
-function buildMozConfigureVendorLine(config) {
-    return `imply_option("MOZ_APP_VENDOR", "${escapeString(config.vendor)}")`;
-}
-async function resolveVendorPlacement(engineDir) {
-    const mozConfigurePath = join(engineDir, 'browser', 'moz.configure');
-    const toolkitMozConfigurePath = join(engineDir, 'toolkit', 'moz.configure');
-    const browserMozConfigureExists = await pathExists(mozConfigurePath);
-    const browserMozConfigureContent = browserMozConfigureExists
-        ? await readText(mozConfigurePath)
-        : undefined;
-    if (browserMozConfigureContent !== undefined &&
-        MOZ_APP_VENDOR_IMPLY_REGEX.test(browserMozConfigureContent)) {
-        return 'moz-configure';
-    }
-    if (await toolkitMozConfigureUsesVendorProjectFlag(toolkitMozConfigurePath)) {
-        if (!browserMozConfigureExists) {
-            throw new BrandingError('Firefox toolkit configure declares MOZ_APP_VENDOR as a project_flag, but browser/moz.configure is missing, so FireForge cannot safely set the vendor identity.');
-        }
-        return 'moz-configure';
-    }
-    return 'branding-configure';
-}
-async function toolkitMozConfigureUsesVendorProjectFlag(filePath) {
-    if (!(await pathExists(filePath))) {
-        return false;
-    }
-    const content = await readText(filePath);
-    return /project_flag\(\s*(?:(?!\)\s*\n)[\s\S])*env\s*=\s*"MOZ_APP_VENDOR"/m.test(content);
-}
-function insertMozConfigureVendorLine(content, line) {
-    const includeRegex = /^include\((["'])\.\.\/toolkit\/moz\.configure\1\)\s*$/m;
-    const match = includeRegex.exec(content);
-    if (!match) {
-        return `${content.replace(/\s*$/, '')}\n\n${line}\n`;
-    }
-    const prefix = content.slice(0, match.index).replace(/\s*$/, '');
-    const suffix = content.slice(match.index);
-    return `${prefix}\n\n${line}\n${suffix}`;
-}
-/**
- * Escapes a string for use in Python/configure file.
- */
-function escapeString(value) {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/\t/g, '\\t');
-}
-/**
- * Escapes a string for use inside a shell double-quoted context.
- * Prevents command injection via $, backticks, !, and escape sequences.
- */
-function escapeShellValue(value) {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"')
-        .replace(/\$/g, '\\$')
-        .replace(/`/g, '\\`')
-        .replace(/!/g, '\\!');
-}
-/**
- * Escapes a string for use in .properties file values.
- * Prevents key/value injection via = and : delimiters.
- */
-function escapePropertiesValue(value) {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/\t/g, '\\t');
-}
-/**
- * Escapes a string for use in Fluent (.ftl) file values.
- * Prevents placeables injection via { and }.
- */
-function escapeFtlValue(value) {
-    return value.replace(/\\/g, '\\\\').replace(/\{/g, '\\{').replace(/\}/g, '\\}');
-}
-/**
- * Checks if branding has been set up for the given configuration.
- *
- * @param engineDir - Path to the engine directory
- * @param config - Branding configuration to check for
- * @returns true if branding is already set up
- */
-export async function isBrandingSetup(engineDir, config) {
-    const brandingDir = join(engineDir, 'browser', 'branding', config.binaryName);
-    const configureShPath = join(brandingDir, 'configure.sh');
-    const propsPath = join(brandingDir, 'locales', 'en-US', 'brand.properties');
-    const ftlPath = join(brandingDir, 'locales', 'en-US', 'brand.ftl');
-    if (!(await pathExists(configureShPath))) {
-        return false;
-    }
-    const vendorPlacement = await resolveVendorPlacement(engineDir);
-    const configureContent = await readText(configureShPath);
-    if (!isConfigureScriptCurrent(configureContent, config, vendorPlacement)) {
-        return false;
-    }
-    if (await pathExists(propsPath)) {
-        const propsContent = await readText(propsPath);
-        if (propsContent !== buildBrandPropertiesContent(config)) {
-            return false;
-        }
-    }
-    if (await pathExists(ftlPath)) {
-        const ftlContent = await readText(ftlPath);
-        if (ftlContent !== buildBrandFtlContent(config)) {
-            return false;
-        }
-    }
-    if (vendorPlacement === 'branding-configure') {
-        return configureContent.includes(`MOZ_APP_VENDOR="${escapeShellValue(config.vendor)}"`);
-    }
-    const mozConfigurePath = join(engineDir, 'browser', 'moz.configure');
-    if (!(await pathExists(mozConfigurePath))) {
-        return false;
-    }
-    const mozConfigureContent = await readText(mozConfigurePath);
-    return mozConfigureContent.includes(buildMozConfigureVendorLine(config));
-}
-/**
- * Checks whether a file path belongs to the tool-managed branding directory.
- * @param file - File path (relative to engine root)
- * @param binaryName - The configured binary name (used as branding directory name)
- * @returns true if the path is managed by branding tooling
- */
-export function isBrandingManagedPath(file, binaryName) {
-    const normalized = normalizePathSlashes(file);
-    const brandingRoot = `browser/branding/${binaryName}`;
-    return (normalized === 'browser/moz.configure' ||
-        normalized === brandingRoot ||
-        normalized === `${brandingRoot}/` ||
-        normalized.startsWith(`${brandingRoot}/`));
-}

package/dist/src/core/browser-wire.d.ts

@@ -1,48 +0,0 @@
-import type { RegisterResult } from './moz-manifest-register.js';
-export declare const DEFAULT_BROWSER_SUBSCRIPT_DIR = "browser/base/content";
-/**
- * Result of a wire operation.
- */
-export interface WireResult {
-    /** Whether the subscript was added to browser-main.js */
-    subscriptAdded: boolean;
-    /** Whether the init expression was added to browser-init.js */
-    initAdded: boolean;
-    /** Whether the destroy expression was added to browser-init.js */
-    destroyAdded: boolean;
-    /** Whether the DOM fragment was inserted into browser.xhtml */
-    domInserted: boolean;
-    /** Result of jar.mn registration */
-    jarMnResult: RegisterResult;
-}
-export interface WireOptions {
-    /** Init expression to add to browser-init.js onLoad() */
-    init?: string | undefined;
-    /** Destroy expression to add to browser-init.js onUnload() */
-    destroy?: string | undefined;
-    /** Path to `.inc.xhtml` file relative to engine root */
-    domFilePath?: string | undefined;
-    /**
-     * Top-level chrome document the DOM fragment's `#include` directive is
-     * inserted into, relative to engine/. Defaults to
-     * `browser/base/content/browser.xhtml`. Forks that replace browser.xhtml
-     * with a custom chrome document (e.g. `mybrowser.xhtml`) pass the
-     * replacement path here.
-     */
-    domTargetPath?: string | undefined;
-    /** Dry run: don't write any files */
-    dryRun?: boolean | undefined;
-    /** Insert init block after the block containing this name */
-    after?: string | undefined;
-    /** Subscript directory relative to engine/ (default: "browser/base/content") */
-    subscriptDir?: string | undefined;
-}
-/**
- * Wires a chrome subscript into the browser.
- *
- * @param root - Project root directory
- * @param name - Subscript name (without .js extension)
- * @param options - Wire options
- * @returns Wire result
- */
-export declare function wireSubscript(root: string, name: string, options?: WireOptions): Promise<WireResult>;

package/dist/src/core/browser-wire.js

@@ -1,133 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join, relative } from 'node:path';
-import { GeneralError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { verbose } from '../utils/logger.js';
-import { toRootRelativePath } from '../utils/paths.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { getProjectPaths, loadConfig } from './config.js';
-import { assertSnapshotted, createRollbackJournal, restoreRollbackJournal, snapshotFile, } from './furnace-rollback.js';
-import { registerBrowserContent } from './moz-manifest-register.js';
-import { addDestroyToBrowserInit } from './wire-destroy.js';
-import { addDomFragment, DEFAULT_DOM_TARGET } from './wire-dom-fragment.js';
-import { addInitToBrowserInit } from './wire-init.js';
-import { addSubscriptToBrowserMain } from './wire-subscript.js';
-export const DEFAULT_BROWSER_SUBSCRIPT_DIR = 'browser/base/content';
-const BROWSER_BASE_DIR = 'browser/base';
-/**
- * Wires a chrome subscript into the browser.
- *
- * @param root - Project root directory
- * @param name - Subscript name (without .js extension)
- * @param options - Wire options
- * @returns Wire result
- */
-export async function wireSubscript(root, name, options = {}) {
-    const { engine: engineDir } = getProjectPaths(root);
-    const subscriptDir = toRootRelativePath(engineDir, options.subscriptDir ?? DEFAULT_BROWSER_SUBSCRIPT_DIR);
-    // Compute jar.mn source path relative to browser/base/
-    let jarMnSourcePath;
-    if (subscriptDir !== DEFAULT_BROWSER_SUBSCRIPT_DIR) {
-        const relPath = normalizePathSlashes(relative(join(engineDir, BROWSER_BASE_DIR), join(engineDir, subscriptDir)));
-        jarMnSourcePath = `${relPath}/${name}.js`;
-    }
-    if (options.dryRun) {
-        return {
-            subscriptAdded: true,
-            initAdded: !!options.init,
-            destroyAdded: !!options.destroy,
-            domInserted: !!options.domFilePath,
-            jarMnResult: {
-                manifest: 'browser/base/jar.mn',
-                entry: `[dry-run] Would register content/browser/${name}.js`,
-                skipped: false,
-            },
-        };
-    }
-    // Snapshot every file the five mutation steps might touch so a
-    // mid-sequence failure (most commonly the chrome-document insertion not
-    // finding an anchor) does not leave a half-wired browser behind: new
-    // `loadSubScript` calls in browser-main.js, new init/destroy expressions
-    // in browser-init.js, and a new entry in browser/base/jar.mn, with no way
-    // back but a hand-revert or a re-download. Init/destroy/DOM are
-    // conditional, so those targets are snapshotted only when the
-    // corresponding option would fire a write.
-    const journal = createRollbackJournal();
-    const effectiveDomTargetPath = options.domFilePath
-        ? toRootRelativePath(engineDir, options.domTargetPath ?? DEFAULT_DOM_TARGET)
-        : undefined;
-    await snapshotFile(journal, join(engineDir, 'browser/base/content/browser-main.js'));
-    if (options.init !== undefined || options.destroy !== undefined) {
-        await snapshotFile(journal, join(engineDir, 'browser/base/content/browser-init.js'));
-    }
-    if (effectiveDomTargetPath) {
-        await snapshotFile(journal, join(engineDir, effectiveDomTargetPath));
-    }
-    await snapshotFile(journal, join(engineDir, 'browser/base/jar.mn'));
-    // Compute the project-scoped patch-lint marker (`// <BINARY>:`) so every
-    // wire mutator can stamp it into the emitted comment block. Without it,
-    // `lintModificationComments` trips `missing-modification-comment` on
-    // wire-generated edits the next time the operator exports. A broken config
-    // should not block the wire, so the fallback marker keeps the
-    // lint-friendly default when the config cannot be loaded.
-    let marker = 'FIREFORGE:';
-    try {
-        const config = await loadConfig(root);
-        marker = `${config.binaryName.toUpperCase()}:`;
-    }
-    catch (error) {
-        verbose(`Using default wire marker because fireforge.json could not be loaded: ${toError(error).message}`);
-    }
-    try {
-        // 1. Add subscript to browser-main.js
-        assertSnapshotted(journal, join(engineDir, 'browser/base/content/browser-main.js'), 'browser wire');
-        const subscriptAdded = await addSubscriptToBrowserMain(engineDir, name, marker);
-        // 2. Add init expression to browser-init.js (if provided)
-        let initAdded = false;
-        if (options.init) {
-            // The snapshot above is taken when init or destroy is `!== undefined`
-            // while these writes fire on truthiness. Close, but two separate
-            // conditions over the same file, and that kind of pairing drifts when
-            // a third writer is added later.
-            assertSnapshotted(journal, join(engineDir, 'browser/base/content/browser-init.js'), 'browser wire init');
-            initAdded = await addInitToBrowserInit(engineDir, options.init, options.after, marker);
-        }
-        // 3. Add destroy expression to browser-init.js onUnload() (if provided)
-        let destroyAdded = false;
-        if (options.destroy) {
-            assertSnapshotted(journal, join(engineDir, 'browser/base/content/browser-init.js'), 'browser wire destroy');
-            destroyAdded = await addDestroyToBrowserInit(engineDir, options.destroy, marker);
-        }
-        // 4. Add #include directive to the top-level chrome document (if provided)
-        let domInserted = false;
-        if (options.domFilePath) {
-            domInserted = await addDomFragment(engineDir, toRootRelativePath(engineDir, options.domFilePath), options.domTargetPath);
-        }
-        // 5. Register in jar.mn
-        assertSnapshotted(journal, join(engineDir, 'browser/base/jar.mn'), 'browser wire jar.mn');
-        const jarMnResult = await registerBrowserContent(engineDir, `${name}.js`, undefined, jarMnSourcePath);
-        return {
-            subscriptAdded,
-            initAdded,
-            destroyAdded,
-            domInserted,
-            jarMnResult,
-        };
-    }
-    catch (error) {
-        // Best-effort rollback: if the restore itself fails, surface both the
-        // original wire failure and the rollback failure so the operator knows
-        // the engine may be in a partially-wired state that needs manual
-        // attention. The original error's message is preserved so the user sees
-        // why the wire failed (e.g. "Could not find insertion point in chrome
-        // document") alongside any rollback diagnosis.
-        const originalMessage = toError(error).message;
-        try {
-            await restoreRollbackJournal(journal);
-        }
-        catch (rollbackError) {
-            throw new GeneralError(`Wire failed: ${originalMessage}. Automatic rollback also failed: ${toError(rollbackError).message}. The engine may contain partially-applied wire mutations; review "git status" under engine/ and revert manually.`);
-        }
-        throw error;
-    }
-}

package/dist/src/core/build-audit-platform.d.ts

@@ -1,67 +0,0 @@
-/** Outcome of a moz.build platform-gate lookup for a single source file. */
-export interface PlatformGateResult {
-    /** True when the file is gated off on the current host. */
-    gatedOff: boolean;
-    /**
-     * The gate expression that excluded the file, if any. Surfaced in
-     * verbose output so an operator can confirm the audit's reasoning.
-     */
-    gateExpression?: string;
-}
-/**
- * Scans a moz.build file for a basename match inside a conditional
- * block, returning the gate expression when one encloses the match.
- *
- * The scanner uses indentation to track block scope (Python-style):
- * an `if CONFIG[…]:` line opens a scope at indent N+1, and dedenting
- * back to indent N closes it. A basename match inside that scope
- * inherits the gate expression.
- *
- * @param content moz.build file content
- * @param basename Basename of the source file we are auditing
- * @returns The enclosing gate expression, or undefined if none
- */
-export declare function findEnclosingGate(content: string, basename: string): string | undefined;
-/**
- * Determines whether the given source file is gated off on the current
- * host by an enclosing `if CONFIG[...]:` block in its owning moz.build,
- * or by a path-convention rule for installer-tree subdirectories that
- * are packaged via Makefile.in recipes the audit does not parse.
- * Returns `gatedOff: false` and no expression when no gate is found. The
- * file is not platform-restricted, so the caller should audit it
- * normally.
- *
- * @param engineDir Absolute path to the engine root
- * @param sourcePath Engine-relative POSIX path of the source file
- * @returns Detection result
- */
-export declare function detectPlatformGate(engineDir: string, sourcePath: string): Promise<PlatformGateResult>;
-/**
- * Result of an ancestor `DIRS +=` gate lookup.
- */
-export interface AncestorDirsGateResult {
-    /** True when an ancestor's `DIRS` entry is gated off on this host. */
-    gatedOff: boolean;
-    /** The gate expression that excluded the directory. */
-    gateExpression?: string;
-    /** Engine-relative path of the `moz.build` carrying the gate. */
-    gateFile?: string;
-}
-/**
- * Determines whether the source file's directory is excluded from this
- * build by a gate in an ancestor `moz.build`.
- *
- * `detectPlatformGate` reads only the file's own nearest `moz.build`, which
- * misses the common Firefox shape where the whole subtree is reached
- * through a conditional `DIRS +=` one or more levels up: nothing in
- * `toolkit/mozapps/defaultagent/moz.build` says "Windows only", yet none of
- * it is built on macOS.
- *
- * Errs toward not skipping, like the rest of this module: an unreadable or
- * oversized ancestor, or a directory no `DIRS` entry names, yields
- * `gatedOff: false`.
- *
- * @param engineDir - Absolute path to the engine root
- * @param sourcePath - Engine-relative POSIX path of the source file
- */
-export declare function detectAncestorDirsGate(engineDir: string, sourcePath: string): Promise<AncestorDirsGateResult>;