@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/ast-utils.js

@@ -1,105 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import * as acorn from 'acorn';
-import { walk } from 'estree-walker';
-/**
- * Bridges acorn's return type to the positioned ESTree program type.
- * `acorn.parse` produces nodes that carry both the ESTree shape and
- * `start`/`end` offsets at runtime, but its static `acorn.Program` type is
- * nominally distinct from `estree.Program`, so the compiler cannot verify
- * the conversion structurally, hence the double assertion. This helper is the
- * only sanctioned crossing point between the two types.
- */
-function toPositionedProgram(program) {
-    // eslint-disable-next-line no-restricted-syntax -- the sanctioned acorn→estree bridge this rule's message points at
-    return program;
-}
-/**
- * Parse JavaScript source as a script, not an ES module.
- * All Mozilla chrome JS files (`browser-main.js`, `browser-init.js`,
- * `customElements.js`, etc.) are scripts that run in a privileged scope.
- *
- * @param content - Source text to parse
- * @param onComment - Optional array that acorn fills with comment nodes
- * @returns Parsed program AST with character-offset positions
- */
-export function parseScript(content, onComment) {
-    const opts = {
-        sourceType: 'script',
-        ecmaVersion: 'latest',
-    };
-    if (onComment)
-        opts.onComment = onComment;
-    return toPositionedProgram(acorn.parse(content, opts));
-}
-/**
- * Parse JavaScript source as an ES module.
- * Used for `.sys.mjs` files which use static import/export syntax.
- *
- * @param content - Source text to parse
- * @param onComment - Optional array that acorn fills with comment nodes
- * @returns Parsed program AST with character-offset positions
- */
-export function parseModule(content, onComment) {
-    const opts = {
-        sourceType: 'module',
-        ecmaVersion: 'latest',
-        locations: true,
-    };
-    if (onComment)
-        opts.onComment = onComment;
-    return toPositionedProgram(acorn.parse(content, opts));
-}
-/**
- * Convenience cast from `acorn.Node` (or the generic ESTree union returned
- * by estree-walker callbacks) to a positioned, narrowly-typed node.
- *
- * Caller obligation: you must already have discriminated on `node.type`.
- * This performs no runtime check. It exists to attach acorn's `start`/`end`
- * offsets to a node the caller has already narrowed, typically inside an
- * `if (node.type === 'CallExpression')` branch or an equivalent walker
- * guard. Calling it on an undiscriminated node produces a value whose type
- * is wrong.
- *
- * No runtime `type` assertion: every call site sits in the hot loop of a lint
- * or registration walker and is already post-narrowing, so the check would
- * cost traversal time on every node to re-prove what the enclosing branch
- * established.
- */
-export function asEstree(node) {
-    return node;
-}
-/**
- * Type-safe wrapper around estree-walker's `walk()` that bridges the
- * acorn→estree type gap. Centralises the single `as unknown as` cast so
- * callers don't need it.
- */
-export function walkAST(ast, visitors) {
-    return walk(ast, visitors);
-}
-/**
- * Read backward from `position` to the preceding newline (or start of
- * string) and return the leading whitespace.  This is the "visual indent"
- * of whatever token begins at `position`.
- *
- * ```
- * "  try {\n    foo();\n  }"
- *                          ^  detectIndent(…, 26) → "  "
- * ```
- */
-export function detectIndent(content, position) {
-    let i = position - 1;
-    while (i >= 0 && content[i] !== '\n') {
-        i--;
-    }
-    // i is now at the newline (or -1 for start-of-string)
-    const lineStart = i + 1;
-    const slice = content.slice(lineStart, position);
-    const match = /^(\s*)/.exec(slice);
-    return match?.[1] ?? '';
-}
-/**
- * Extract the raw source text for a node's range.
- */
-export function getNodeSource(content, node) {
-    return content.slice(node.start, node.end);
-}

package/dist/src/core/brand-validation.d.ts

@@ -1,7 +0,0 @@
-/**
- * Validates that a brand override matches the configured brand.
- * @param configuredBrand - The brand configured in fireforge.json
- * @param requestedBrand - The brand requested via CLI flag
- * @throws InvalidArgumentError if the brands don't match
- */
-export declare function validateBrandOverride(configuredBrand: string, requestedBrand?: string): void;

package/dist/src/core/brand-validation.js

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { InvalidArgumentError } from '../errors/base.js';
-/**
- * Validates that a brand override matches the configured brand.
- * @param configuredBrand - The brand configured in fireforge.json
- * @param requestedBrand - The brand requested via CLI flag
- * @throws InvalidArgumentError if the brands don't match
- */
-export function validateBrandOverride(configuredBrand, requestedBrand) {
-    if (!requestedBrand || requestedBrand === configuredBrand) {
-        return;
-    }
-    throw new InvalidArgumentError(`Brand override "${requestedBrand}" is not supported yet. FireForge currently operates only on the configured brand "${configuredBrand}".`, 'brand');
-}

package/dist/src/core/branding.d.ts

@@ -1,86 +0,0 @@
-import { FireForgeError } from '../errors/base.js';
-import type { ProjectLicense } from '../types/config.js';
-/**
- * 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 declare class BrandingMozconfigMismatchError extends FireForgeError {
-    readonly expectedBrandingDir: string;
-    readonly mozconfigBrandingDir: string;
-    readonly reason: 'mozconfig-missing-branding' | 'name-mismatch' | 'branding-dir-missing';
-    readonly code: 6;
-    constructor(expectedBrandingDir: string, mozconfigBrandingDir: string, reason: 'mozconfig-missing-branding' | 'name-mismatch' | 'branding-dir-missing');
-    get userMessage(): string;
-}
-/**
- * Full branding configuration.
- */
-export interface BrandingConfig {
-    /** Display name (e.g., "MyBrowser") */
-    name: string;
-    /** Vendor name (e.g., "My Company") */
-    vendor: string;
-    /** Application ID in reverse-domain format (e.g., "org.mybrowser.browser") */
-    appId: string;
-    /** Binary/branding directory name (e.g., "mybrowser") */
-    binaryName: string;
-    /**
-     * Project license (from fireforge.json). Used to stamp the generated
-     * `configure.sh`, `brand.properties`, and `brand.ftl` files with the
-     * matching header so `patch-lint` does not flag them for
-     * `missing-license-header` when the project is not MPL-2.0. Optional.
-     * Falls back to {@link DEFAULT_LICENSE}.
-     */
-    license?: ProjectLicense;
-}
-/**
- * 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 declare function splitAppId(appId: string): {
-    distributionId: string;
-    leaf: string;
-};
-/**
- * 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 declare function setupBranding(engineDir: string, config: BrandingConfig): Promise<void>;
-/**
- * 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 declare function isBrandingSetup(engineDir: string, config: BrandingConfig): Promise<boolean>;
-/**
- * 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 declare function isBrandingManagedPath(file: string, binaryName: string): boolean;

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>;