@hominis/fireforge 0.9.0

package/dist/src/core/mach-build-artifacts.js

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { toError } from '../utils/errors.js';
+import { pathExists, readJson } from '../utils/fs.js';
+import { verbose } from '../utils/logger.js';
+import { isObject, isString } from '../utils/validation.js';
+function validateBuildMozinfo(data) {
+    if (!isObject(data)) {
+        throw new Error('mozinfo metadata must be an object');
+    }
+    const mozinfo = {};
+    if (data['topsrcdir'] !== undefined) {
+        if (!isString(data['topsrcdir'])) {
+            throw new Error('mozinfo.topsrcdir must be a string');
+        }
+        mozinfo.topsrcdir = data['topsrcdir'];
+    }
+    if (data['topobjdir'] !== undefined) {
+        if (!isString(data['topobjdir'])) {
+            throw new Error('mozinfo.topobjdir must be a string');
+        }
+        mozinfo.topobjdir = data['topobjdir'];
+    }
+    if (data['mozconfig'] !== undefined) {
+        if (!isString(data['mozconfig'])) {
+            throw new Error('mozinfo.mozconfig must be a string');
+        }
+        mozinfo.mozconfig = data['mozconfig'];
+    }
+    return mozinfo;
+}
+/**
+ * Checks if build artifacts exist in the engine directory.
+ * Looks for obj-* directories with a dist subdirectory.
+ * @param engineDir - Path to the engine directory
+ * @returns Build artifact check result
+ */
+export async function hasBuildArtifacts(engineDir) {
+    try {
+        const entries = await readdir(engineDir);
+        const objDirs = entries.filter((e) => e.startsWith('obj-')).sort();
+        if (objDirs.length === 0) {
+            return { exists: false };
+        }
+        const validObjDirs = [];
+        for (const objDir of objDirs) {
+            const distPath = join(engineDir, objDir, 'dist');
+            if (await pathExists(distPath)) {
+                validObjDirs.push(objDir);
+            }
+        }
+        if (validObjDirs.length === 0) {
+            const firstObjDir = objDirs[0];
+            return firstObjDir ? { exists: false, objDir: firstObjDir } : { exists: false };
+        }
+        if (validObjDirs.length > 1) {
+            return { exists: true, ambiguous: true, objDirs: validObjDirs };
+        }
+        const selectedObjDir = validObjDirs[0];
+        if (!selectedObjDir) {
+            return { exists: false };
+        }
+        const mozinfoPath = join(engineDir, selectedObjDir, 'mozinfo.json');
+        if (await pathExists(mozinfoPath)) {
+            try {
+                const mozinfo = validateBuildMozinfo(await readJson(mozinfoPath));
+                const expectedSrcDir = resolve(engineDir);
+                const expectedObjDir = resolve(engineDir, selectedObjDir);
+                const actualSrcDir = mozinfo.topsrcdir ? resolve(mozinfo.topsrcdir) : undefined;
+                const actualObjDir = mozinfo.topobjdir ? resolve(mozinfo.topobjdir) : undefined;
+                if ((actualSrcDir !== undefined && actualSrcDir !== expectedSrcDir) ||
+                    (actualObjDir !== undefined && actualObjDir !== expectedObjDir)) {
+                    return {
+                        exists: true,
+                        objDir: selectedObjDir,
+                        metadataMismatch: {
+                            objDir: selectedObjDir,
+                            ...(mozinfo.topsrcdir ? { topsrcdir: mozinfo.topsrcdir } : {}),
+                            ...(mozinfo.topobjdir ? { topobjdir: mozinfo.topobjdir } : {}),
+                            ...(mozinfo.mozconfig ? { mozconfig: mozinfo.mozconfig } : {}),
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                verbose(`Ignoring invalid mozinfo metadata in ${selectedObjDir}: ${toError(error).message}`);
+            }
+        }
+        return { exists: true, objDir: selectedObjDir };
+    }
+    catch (error) {
+        void error;
+        return { exists: false };
+    }
+}
+/** Builds a user-facing explanation when detected build artifacts belong to another workspace. */
+export function buildArtifactMismatchMessage(engineDir, buildCheck, commandName) {
+    if (!buildCheck.metadataMismatch || !buildCheck.objDir) {
+        return undefined;
+    }
+    const expectedObjDir = join(engineDir, buildCheck.objDir);
+    const details = [`Current engine: ${engineDir}`, `Detected objdir: ${expectedObjDir}`];
+    if (buildCheck.metadataMismatch.topsrcdir) {
+        details.push(`mozinfo topsrcdir: ${buildCheck.metadataMismatch.topsrcdir}`);
+    }
+    if (buildCheck.metadataMismatch.topobjdir) {
+        details.push(`mozinfo topobjdir: ${buildCheck.metadataMismatch.topobjdir}`);
+    }
+    if (buildCheck.metadataMismatch.mozconfig) {
+        details.push(`mozinfo mozconfig: ${buildCheck.metadataMismatch.mozconfig}`);
+    }
+    return (`${commandName} cannot use copied or relocated build artifacts whose metadata still points at a different Firefox workspace.\n\n` +
+        `${details.join('\n')}\n\n` +
+        'Delete the stale obj-* directory in this workspace and run "fireforge build" again so mach regenerates build metadata for the current checkout.');
+}
+//# sourceMappingURL=mach-build-artifacts.js.map

package/dist/src/core/mach-mozconfig.d.ts

@@ -0,0 +1,17 @@
+import type { FireForgeConfig } from '../types/config.js';
+/**
+ * Template variables for mozconfig generation.
+ */
+export interface MozconfigVariables {
+    name: string;
+    vendor: string;
+    appId: string;
+    binaryName: string;
+}
+/**
+ * Generates a mozconfig file from templates.
+ * @param configsDir - Path to the configs directory
+ * @param engineDir - Path to the engine directory
+ * @param config - FireForge configuration
+ */
+export declare function generateMozconfig(configsDir: string, engineDir: string, config: FireForgeConfig): Promise<void>;

package/dist/src/core/mach-mozconfig.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { MozconfigError } from '../errors/build.js';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { getPlatform } from '../utils/platform.js';
+/**
+ * Replaces template variables in a string.
+ * @param content - Content with ${variable} placeholders
+ * @param variables - Variables to substitute
+ * @returns Content with variables replaced
+ */
+function replaceVariables(content, variables) {
+    return content
+        .replace(/\$\{name\}/g, variables.name)
+        .replace(/\$\{vendor\}/g, variables.vendor)
+        .replace(/\$\{appId\}/g, variables.appId)
+        .replace(/\$\{binaryName\}/g, variables.binaryName);
+}
+/**
+ * Generates a mozconfig file from templates.
+ * @param configsDir - Path to the configs directory
+ * @param engineDir - Path to the engine directory
+ * @param config - FireForge configuration
+ */
+export async function generateMozconfig(configsDir, engineDir, config) {
+    const platform = getPlatform();
+    const commonPath = join(configsDir, 'common.mozconfig');
+    const platformPath = join(configsDir, `${platform}.mozconfig`);
+    const outputPath = join(engineDir, 'mozconfig');
+    const variables = {
+        name: config.name,
+        vendor: config.vendor,
+        appId: config.appId,
+        binaryName: config.binaryName,
+    };
+    let content = '';
+    // Read common config if it exists
+    if (await pathExists(commonPath)) {
+        const commonContent = await readText(commonPath);
+        content += `# Common configuration\n${replaceVariables(commonContent, variables)}\n\n`;
+    }
+    // Read platform-specific config
+    if (!(await pathExists(platformPath))) {
+        throw new MozconfigError(`Platform mozconfig not found: ${platformPath}`);
+    }
+    const platformContent = await readText(platformPath);
+    content += `# Platform configuration (${platform})\n${replaceVariables(platformContent, variables)}`;
+    await writeText(outputPath, content);
+}
+//# sourceMappingURL=mach-mozconfig.js.map

package/dist/src/core/mach-python.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resets the resolved Python executable. Primarily useful for testing.
+ */
+export declare function resetResolvedPython(): void;
+/**
+ * Dynamically resolves the python executable and ensures it is available.
+ * Checks the Python version range declared by engine/mach when available.
+ * @throws PythonNotFoundError if no suitable python is installed
+ */
+export declare function ensurePython(engineDir?: string): Promise<void>;
+/**
+ * Gets the resolved Python executable name.
+ * @param engineDir - Optional engine directory for engine-specific Python requirements
+ * @returns The resolved Python executable name
+ */
+export declare function getPython(engineDir?: string): Promise<string>;

package/dist/src/core/mach-python.js

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { PythonNotFoundError } from '../errors/build.js';
+import { toError } from '../utils/errors.js';
+import { pathExists, readText } from '../utils/fs.js';
+import { verbose } from '../utils/logger.js';
+import { exec, executableExists } from '../utils/process.js';
+/** Cached Python resolution state */
+const pythonCache = {};
+const DEFAULT_MACH_PYTHON_REQUIREMENTS = {
+    min: { major: 3, minor: 8 },
+    max: { major: 3, minor: 12 },
+};
+function formatPythonMinor(version) {
+    return `${version.major}.${version.minor}`;
+}
+function formatRequirementsKey(requirements) {
+    return `${formatPythonMinor(requirements.min)}-${formatPythonMinor(requirements.max)}`;
+}
+function comparePythonVersions(left, right) {
+    if (left.major !== right.major)
+        return left.major - right.major;
+    if (left.minor !== right.minor)
+        return left.minor - right.minor;
+    return (left.micro ?? 0) - (right.micro ?? 0);
+}
+function isVersionWithinRequirements(version, requirements) {
+    return (comparePythonVersions({ major: version.major, minor: version.minor }, requirements.min) >= 0 &&
+        comparePythonVersions({ major: version.major, minor: version.minor }, requirements.max) <= 0);
+}
+function parsePythonVersion(output) {
+    const match = /(\d+)\.(\d+)\.(\d+)/.exec(output.trim());
+    if (!match)
+        return undefined;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        micro: Number(match[3]),
+    };
+}
+async function readMachPythonRequirements(engineDir) {
+    if (!engineDir) {
+        return DEFAULT_MACH_PYTHON_REQUIREMENTS;
+    }
+    const machPath = join(engineDir, 'mach');
+    if (!(await pathExists(machPath))) {
+        return DEFAULT_MACH_PYTHON_REQUIREMENTS;
+    }
+    try {
+        const machContent = await readText(machPath);
+        const minMatch = /MIN_PYTHON_VERSION\s*=\s*\((\d+),\s*(\d+)\)/.exec(machContent);
+        const maxMatch = /MAX_PYTHON_VERSION_TO_CONSIDER\s*=\s*\((\d+),\s*(\d+)\)/.exec(machContent);
+        if (!minMatch || !maxMatch) {
+            return DEFAULT_MACH_PYTHON_REQUIREMENTS;
+        }
+        return {
+            min: { major: Number(minMatch[1]), minor: Number(minMatch[2]) },
+            max: { major: Number(maxMatch[1]), minor: Number(maxMatch[2]) },
+        };
+    }
+    catch (error) {
+        verbose(`Using default mach python requirements because engine/mach could not be read: ${toError(error).message}`);
+        return DEFAULT_MACH_PYTHON_REQUIREMENTS;
+    }
+}
+function buildPythonCandidates(requirements) {
+    const candidates = [];
+    for (let minor = requirements.max.minor; minor >= requirements.min.minor; minor--) {
+        candidates.push(`python${requirements.min.major}.${minor}`);
+    }
+    candidates.push(`python${requirements.min.major}`, 'python');
+    return [...new Set(candidates)];
+}
+/**
+ * Resets the resolved Python executable. Primarily useful for testing.
+ */
+export function resetResolvedPython() {
+    delete pythonCache.python;
+    delete pythonCache.requirementsKey;
+}
+/**
+ * Dynamically resolves the python executable and ensures it is available.
+ * Checks the Python version range declared by engine/mach when available.
+ * @throws PythonNotFoundError if no suitable python is installed
+ */
+export async function ensurePython(engineDir) {
+    const requirements = await readMachPythonRequirements(engineDir);
+    const requirementsKey = formatRequirementsKey(requirements);
+    if (pythonCache.python && pythonCache.requirementsKey === requirementsKey) {
+        return;
+    }
+    const candidates = buildPythonCandidates(requirements);
+    for (const candidate of candidates) {
+        if (await executableExists(candidate)) {
+            try {
+                const { stdout } = await exec(candidate, [
+                    '-c',
+                    'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}")',
+                ]);
+                const version = parsePythonVersion(stdout);
+                if (version && isVersionWithinRequirements(version, requirements)) {
+                    pythonCache.python = candidate;
+                    pythonCache.requirementsKey = requirementsKey;
+                    return;
+                }
+            }
+            catch (error) {
+                verbose(`Python candidate ${candidate} was not usable: ${toError(error).message}`);
+            }
+        }
+    }
+    throw new PythonNotFoundError(formatPythonMinor(requirements.min), formatPythonMinor(requirements.max));
+}
+/**
+ * Gets the resolved Python executable name.
+ * @param engineDir - Optional engine directory for engine-specific Python requirements
+ * @returns The resolved Python executable name
+ */
+export async function getPython(engineDir) {
+    await ensurePython(engineDir);
+    if (!pythonCache.python) {
+        throw new PythonNotFoundError();
+    }
+    return pythonCache.python;
+}
+//# sourceMappingURL=mach-python.js.map

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

@@ -0,0 +1,106 @@
+export { type BuildArtifactCheck, buildArtifactMismatchMessage, hasBuildArtifacts, } from './mach-build-artifacts.js';
+export { generateMozconfig, type MozconfigVariables } from './mach-mozconfig.js';
+export { ensurePython, resetResolvedPython } from './mach-python.js';
+/**
+ * Ensures mach is available in the engine directory.
+ * @param engineDir - Path to the engine directory
+ * @throws MachNotFoundError if mach is not found
+ */
+export declare function ensureMach(engineDir: string): Promise<void>;
+/**
+ * Options for running mach commands.
+ */
+export interface MachOptions {
+    /** Additional environment variables */
+    env?: Record<string, string>;
+    /** Whether to inherit stdio (show output directly) */
+    inherit?: boolean;
+}
+/**
+ * Result of running a mach command while capturing streamed output.
+ */
+export interface MachCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+/**
+ * Runs a mach command in the engine directory.
+ * @param args - mach command and arguments
+ * @param engineDir - Path to the engine directory
+ * @param options - Command options
+ * @returns Exit code
+ */
+export declare function runMach(args: string[], engineDir: string, options?: MachOptions): Promise<number>;
+/**
+ * Runs a mach command while streaming output to the terminal and capturing it
+ * for post-run diagnostics.
+ */
+export declare function runMachCapture(args: string[], engineDir: string, options?: Omit<MachOptions, 'inherit'>): Promise<MachCommandResult>;
+/**
+ * Runs a mach command while inheriting stdin, streaming output live, and
+ * capturing stdout/stderr for post-run diagnostics.
+ */
+export declare function runMachInheritCapture(args: string[], engineDir: string, options?: Omit<MachOptions, 'inherit'>): Promise<MachCommandResult>;
+/**
+ * Runs mach bootstrap to install build dependencies.
+ * @param engineDir - Path to the engine directory
+ * @returns Exit code
+ */
+export declare function bootstrap(engineDir: string): Promise<number>;
+/**
+ * Runs mach bootstrap while preserving stdin and capturing the emitted output.
+ * @param engineDir - Path to the engine directory
+ * @returns Captured output and exit code
+ */
+export declare function bootstrapWithOutput(engineDir: string): Promise<MachCommandResult>;
+/**
+ * Runs a full mach build.
+ * @param engineDir - Path to the engine directory
+ * @param jobs - Number of parallel jobs (optional)
+ * @returns Exit code
+ */
+export declare function build(engineDir: string, jobs?: number): Promise<number>;
+/**
+ * Runs a fast UI-only build.
+ * @param engineDir - Path to the engine directory
+ * @returns Exit code
+ */
+export declare function buildUI(engineDir: string): Promise<number>;
+/**
+ * Runs the built browser.
+ * @param engineDir - Path to the engine directory
+ * @param args - Additional arguments to pass to the browser
+ * @returns Exit code
+ */
+export declare function run(engineDir: string, args?: string[]): Promise<number>;
+/**
+ * Creates a distribution package.
+ * @param engineDir - Path to the engine directory
+ * @returns Exit code
+ */
+export declare function machPackage(engineDir: string): Promise<number>;
+/**
+ * Runs mach watch for auto-rebuilding.
+ * @param engineDir - Path to the engine directory
+ * @returns Exit code
+ */
+export declare function watch(engineDir: string): Promise<number>;
+/**
+ * Runs mach watch while preserving stdin and capturing emitted output.
+ * @param engineDir - Path to the engine directory
+ * @returns Captured output and exit code
+ */
+export declare function watchWithOutput(engineDir: string): Promise<MachCommandResult>;
+/**
+ * Runs mach test with the given test paths.
+ * @param engineDir - Path to the engine directory
+ * @param testPaths - Test file or directory paths (relative to engine)
+ * @param args - Additional arguments to pass to mach test
+ * @returns Exit code
+ */
+export declare function test(engineDir: string, testPaths?: string[], args?: string[]): Promise<number>;
+/**
+ * Runs mach test while capturing streamed output for better diagnostics.
+ */
+export declare function testWithOutput(engineDir: string, testPaths?: string[], args?: string[]): Promise<MachCommandResult>;

package/dist/src/core/mach.js

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { MachNotFoundError } from '../errors/build.js';
+import { pathExists } from '../utils/fs.js';
+import { exec, execInherit, execInheritCapture, execStream } from '../utils/process.js';
+import { getPython } from './mach-python.js';
+// Re-export sub-modules so existing `from './mach.js'` imports keep working.
+export { buildArtifactMismatchMessage, hasBuildArtifacts, } from './mach-build-artifacts.js';
+export { generateMozconfig } from './mach-mozconfig.js';
+export { ensurePython, resetResolvedPython } from './mach-python.js';
+/**
+ * Ensures mach is available in the engine directory.
+ * @param engineDir - Path to the engine directory
+ * @throws MachNotFoundError if mach is not found
+ */
+export async function ensureMach(engineDir) {
+    const machPath = join(engineDir, 'mach');
+    if (!(await pathExists(machPath))) {
+        throw new MachNotFoundError(engineDir);
+    }
+}
+/**
+ * Runs a mach command in the engine directory.
+ * @param args - mach command and arguments
+ * @param engineDir - Path to the engine directory
+ * @param options - Command options
+ * @returns Exit code
+ */
+export async function runMach(args, engineDir, options = {}) {
+    const python = await getPython(engineDir);
+    await ensureMach(engineDir);
+    const machPath = join(engineDir, 'mach');
+    const execOptions = {
+        cwd: engineDir,
+        ...(options.env ? { env: options.env } : {}),
+    };
+    if (options.inherit) {
+        return execInherit(python, [machPath, ...args], execOptions);
+    }
+    const result = await exec(python, [machPath, ...args], execOptions);
+    return result.exitCode;
+}
+/**
+ * Runs a mach command while streaming output to the terminal and capturing it
+ * for post-run diagnostics.
+ */
+export async function runMachCapture(args, engineDir, options = {}) {
+    const python = await getPython(engineDir);
+    await ensureMach(engineDir);
+    const machPath = join(engineDir, 'mach');
+    let stdout = '';
+    let stderr = '';
+    const exitCode = await execStream(python, [machPath, ...args], {
+        cwd: engineDir,
+        ...(options.env ? { env: options.env } : {}),
+        onStdout: (data) => {
+            stdout += data;
+            process.stdout.write(data);
+        },
+        onStderr: (data) => {
+            stderr += data;
+            process.stderr.write(data);
+        },
+    });
+    return { stdout, stderr, exitCode };
+}
+/**
+ * Runs a mach command while inheriting stdin, streaming output live, and
+ * capturing stdout/stderr for post-run diagnostics.
+ */
+export async function runMachInheritCapture(args, engineDir, options = {}) {
+    const python = await getPython(engineDir);
+    await ensureMach(engineDir);
+    const machPath = join(engineDir, 'mach');
+    return execInheritCapture(python, [machPath, ...args], {
+        cwd: engineDir,
+        ...(options.env ? { env: options.env } : {}),
+    });
+}
+/**
+ * Runs mach bootstrap to install build dependencies.
+ * @param engineDir - Path to the engine directory
+ * @returns Exit code
+ */
+export async function bootstrap(engineDir) {
+    return runMach(['bootstrap', '--application-choice', 'browser'], engineDir, { inherit: true });
+}
+/**
+ * Runs mach bootstrap while preserving stdin and capturing the emitted output.
+ * @param engineDir - Path to the engine directory
+ * @returns Captured output and exit code
+ */
+export async function bootstrapWithOutput(engineDir) {
+    return runMachInheritCapture(['bootstrap', '--application-choice', 'browser'], engineDir);
+}
+/**
+ * Runs a full mach build.
+ * @param engineDir - Path to the engine directory
+ * @param jobs - Number of parallel jobs (optional)
+ * @returns Exit code
+ */
+export async function build(engineDir, jobs) {
+    const args = ['build'];
+    if (jobs !== undefined) {
+        args.push('-j', String(jobs));
+    }
+    return runMach(args, engineDir, { inherit: true });
+}
+/**
+ * Runs a fast UI-only build.
+ * @param engineDir - Path to the engine directory
+ * @returns Exit code
+ */
+export async function buildUI(engineDir) {
+    return runMach(['build', 'faster'], engineDir, { inherit: true });
+}
+/**
+ * Runs the built browser.
+ * @param engineDir - Path to the engine directory
+ * @param args - Additional arguments to pass to the browser
+ * @returns Exit code
+ */
+export async function run(engineDir, args = []) {
+    return runMach(['run', ...args], engineDir, { inherit: true });
+}
+/**
+ * Creates a distribution package.
+ * @param engineDir - Path to the engine directory
+ * @returns Exit code
+ */
+export async function machPackage(engineDir) {
+    return runMach(['package'], engineDir, { inherit: true });
+}
+/**
+ * Runs mach watch for auto-rebuilding.
+ * @param engineDir - Path to the engine directory
+ * @returns Exit code
+ */
+export async function watch(engineDir) {
+    return runMach(['watch'], engineDir, { inherit: true });
+}
+/**
+ * Runs mach watch while preserving stdin and capturing emitted output.
+ * @param engineDir - Path to the engine directory
+ * @returns Captured output and exit code
+ */
+export async function watchWithOutput(engineDir) {
+    return runMachInheritCapture(['watch'], engineDir);
+}
+/**
+ * Runs mach test with the given test paths.
+ * @param engineDir - Path to the engine directory
+ * @param testPaths - Test file or directory paths (relative to engine)
+ * @param args - Additional arguments to pass to mach test
+ * @returns Exit code
+ */
+export async function test(engineDir, testPaths = [], args = []) {
+    return runMach(['test', ...testPaths, ...args], engineDir, { inherit: true });
+}
+/**
+ * Runs mach test while capturing streamed output for better diagnostics.
+ */
+export async function testWithOutput(engineDir, testPaths = [], args = []) {
+    return runMachCapture(['test', ...testPaths, ...args], engineDir);
+}
+//# sourceMappingURL=mach.js.map

package/dist/src/core/manifest-helpers.d.ts

@@ -0,0 +1,25 @@
+import type { JarMnToken, MozBuildToken } from './manifest-tokenizers.js';
+/**
+ * Inserts a line into an array of lines in alphabetical order within a
+ * specified range. The comparison key is extracted from each line.
+ *
+ * @returns Object with insertIndex and previousEntry
+ */
+export declare function findAlphabeticalPosition(lines: string[], startLine: number, endLine: number, newKey: string, extractKey: (line: string) => string | undefined): {
+    insertIndex: number;
+    previousEntry: string | undefined;
+};
+/**
+ * Find alphabetical position within a tokenized jar.mn section.
+ */
+export declare function findAlphabeticalTokenPosition(tokens: JarMnToken[], sectionTargetPattern: RegExp, newKey: string): {
+    insertIndex: number;
+    previousEntry: string | undefined;
+};
+/**
+ * Find alphabetical position within tokenized moz.build list items.
+ */
+export declare function findAlphabeticalMozBuildPosition(tokens: MozBuildToken[], newKey: string): {
+    insertIndex: number;
+    previousEntry: string | undefined;
+};