@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/license-headers.js

@@ -1,318 +0,0 @@
-import { readText, writeText } from '../utils/fs.js';
-/** Default license when fireforge.json omits the license field. */
-export const DEFAULT_LICENSE = 'MPL-2.0';
-/**
- * Raw (unwrapped) header lines per license.
- *
- * Each entry uses the community-recommended file notice for the license.
- */
-const HEADER_LINES = {
-    'MPL-2.0': [
-        'This Source Code Form is subject to the terms of the Mozilla Public',
-        'License, v. 2.0. If a copy of the MPL was not distributed with this',
-        'file, You can obtain one at http://mozilla.org/MPL/2.0/.',
-    ],
-    'EUPL-1.2': ['SPDX-License-Identifier: EUPL-1.2'],
-    'GPL-2.0-or-later': [
-        'SPDX-License-Identifier: GPL-2.0-or-later',
-        'This file is free software; you can redistribute it and/or modify it',
-        'under the terms of the GNU General Public License as published by the',
-        'Free Software Foundation; either version 2 of the License, or (at your',
-        'option) any later version.',
-    ],
-    '0BSD': ['SPDX-License-Identifier: 0BSD'],
-};
-/**
- * Returns a formatted license header comment for the given license and
- * comment style.
- *
- * @param license - SPDX identifier of the project license
- * @param style   - Comment syntax to wrap the header in
- * @returns Multi-line string ready to be placed at the top of a source file
- */
-export function getLicenseHeader(license, style) {
-    const lines = HEADER_LINES[license];
-    switch (style) {
-        case 'js':
-            if (lines.length === 1) {
-                return `/* ${lines[0]} */`;
-            }
-            return lines.map((l) => `// ${l}`).join('\n');
-        case 'css':
-            if (lines.length === 1) {
-                return `/* ${lines[0]} */`;
-            }
-            return (`/* ${lines[0]}\n` +
-                lines
-                    .slice(1, -1)
-                    .map((l) => ` * ${l}`)
-                    .join('\n') +
-                (lines.length > 2 ? '\n' : '') +
-                ` * ${lines[lines.length - 1]} */`);
-        case 'hash':
-            return lines.map((l) => `# ${l}`).join('\n');
-    }
-}
-/**
- * Single-line `/* ... *\/` block comments containing either an Emacs
- * file-mode marker (`-*-`) or a vim modeline (`vim:`). These are Mozilla's
- * canonical first-line editor directives that legitimately precede the
- * license header in many Firefox source files.
- *
- * Restricted to single-line blocks so a multi-line license header never
- * gets accidentally consumed.
- */
-const EDITOR_DIRECTIVE_BLOCK_COMMENT = /^[ \t]*\/\*[^\r\n]*?(?:-\*-|\bvim:)[^\r\n]*?\*\/[ \t]*\r?\n?/;
-/**
- * Strips any leading run of editor-directive block comments and blank
- * lines, returning the remaining content.
- *
- * Mozilla's coding convention places editor directives like
- * `/* -*- Mode: javascript; ... -*- *\/` and `/* vim: set ... *\/` on
- * lines 1 and 2, with the canonical license header following on lines 3+.
- * The raw `content.startsWith(...)` check used by {@link hasAnyLicenseHeader}
- * never matches in that shape. This helper lets the caller test the
- * post-directive prefix as a fallback.
- *
- * @param content - File content to strip
- */
-function stripLeadingEditorDirectives(content) {
-    let result = content;
-    let prev;
-    do {
-        prev = result;
-        result = result.replace(/^[ \t]*\r?\n/, '');
-        result = result.replace(EDITOR_DIRECTIVE_BLOCK_COMMENT, '');
-    } while (result !== prev);
-    return result;
-}
-/**
- * Collapses all whitespace runs to single spaces and trims, so header
- * comparisons ignore the exact line-break/wrap positions.
- */
-function normalizeText(text) {
-    return text.replace(/\s+/g, ' ').trim();
-}
-/**
- * The canonical upstream MPL-2.0 notice as a single normalized sentence
- * (including the `http://mozilla.org/MPL/2.0/.` URL). Wrap-agnostic
- * header checks match against this instead of an exact rendering.
- */
-const MPL_HEADER_NORMALIZED = normalizeText(HEADER_LINES['MPL-2.0'].join(' '));
-/**
- * Extracts only the leading comment span of `content` for the given
- * comment style and returns it whitespace-normalized:
- *
- * - `js`:   a leading run of `//` lines (markers stripped), or (when the
- *           file opens with a block comment instead) the first
- *           `/* … *\/` block.
- * - `css`:  the first `/* … *\/` block, with the ` * ` continuation-line
- *           prefixes stripped (same collapsing
- *           {@link normalizeLicenseHeadForScan} does).
- * - `hash`: a leading run of `#` lines (markers stripped).
- *
- * A non-comment first line yields `''`. This lets callers accept a known
- * header text regardless of where upstream wrapped its lines (e.g. the
- * older Mozilla wrap that breaks after "file,"), without ever matching
- * text beyond the leading comment.
- */
-function normalizeCommentHead(content, style) {
-    const src = content.replace(/\r\n?/g, '\n');
-    const collectLineRun = (marker) => {
-        const parts = [];
-        for (const line of src.split('\n')) {
-            const m = marker.exec(line);
-            if (!m)
-                break;
-            parts.push(m[1] ?? '');
-        }
-        return normalizeText(parts.join(' '));
-    };
-    if (style === 'hash') {
-        return collectLineRun(/^[ \t]*#[ \t]?(.*)$/);
-    }
-    if (style === 'js' && /^[ \t]*\/\//.test(src)) {
-        return collectLineRun(/^[ \t]*\/\/[ \t]?(.*)$/);
-    }
-    const block = /^[ \t]*\/\*([\s\S]*?)\*\//.exec(src);
-    if (!block)
-        return '';
-    return normalizeText((block[1] ?? '').replace(/\n[ \t]*\*[ \t]*/g, ' '));
-}
-/**
- * Returns true if `content` starts with any known license header for the
- * given comment style.
- *
- * For `js` files, MPL-2.0 is also accepted in the upstream Mozilla block-
- * comment form (`/* ... *\/`) used by the Firefox source tree, not just the
- * `// ` line-comment form `getLicenseHeader` emits. Otherwise a new JS file
- * copied from upstream Firefox hits `missing-license-header` even with a
- * verbatim standard MPL header.
- *
- * Editor-directive block comments (`/* -*- ... -*- *\/`, `/* vim: ... *\/`)
- * leading the file are tolerated: Mozilla's canonical layout puts those on
- * lines 1 and 2 with the MPL header on lines 3+, which a raw `startsWith` check
- * would miss.
- *
- * The MPL-2.0 header is additionally matched on normalized whitespace (see
- * {@link normalizeCommentHead}) so upstream files using the older Mozilla
- * wrap (breaking after "file," instead of "with this") are accepted too.
- * Only the wrap position differs, never the wording.
- *
- * @param content - File content to check
- * @param style   - Comment syntax of the file
- */
-export function hasAnyLicenseHeader(content, style) {
-    const candidates = [content, stripLeadingEditorDirectives(content)];
-    const licenses = Object.keys(HEADER_LINES);
-    for (const candidate of candidates) {
-        if (licenses.some((license) => candidate.startsWith(getLicenseHeader(license, style)))) {
-            return true;
-        }
-        if (style === 'js' && candidate.startsWith(getLicenseHeader('MPL-2.0', 'css'))) {
-            return true;
-        }
-        if (normalizeCommentHead(candidate, style).startsWith(MPL_HEADER_NORMALIZED)) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Returns true if `content` starts with the verbatim upstream Mozilla
- * MPL-2.0 block header (`/* This Source Code Form … *\/`), optionally
- * preceded by editor-directive comments, the exact shape a JS file copied
- * from the Firefox source tree carries.
- *
- * Independent of the project license: a new JS file that
- * legitimately keeps its upstream MPL block header is valid in an
- * EUPL/GPL/0BSD project too.
- *
- * Matching is wrap-agnostic: after the exact `startsWith` fast path, the
- * leading block comment is compared on normalized whitespace (see
- * {@link normalizeCommentHead}) so the older upstream wrap (breaking after
- * "file," instead of "with this", as `ext-browser.js` ships) passes too.
- * Only the line-break position may differ. Altered wording still rejects.
- *
- * @param content - File content to check
- */
-export function hasUpstreamMplBlockHeader(content) {
-    const blockHeader = getLicenseHeader('MPL-2.0', 'css');
-    const candidates = [content, stripLeadingEditorDirectives(content)];
-    for (const candidate of candidates) {
-        if (candidate.startsWith(blockHeader))
-            return true;
-        if (normalizeCommentHead(candidate, 'css').startsWith(MPL_HEADER_NORMALIZED))
-            return true;
-    }
-    return false;
-}
-/**
- * Returns true if `content` starts with any known license header in any
- * comment style (js, css, hash).
- *
- * @param content - File content to check
- */
-export function hasAnyLicenseHeaderAnyStyle(content) {
-    const styles = ['js', 'css', 'hash'];
-    return styles.some((style) => hasAnyLicenseHeader(content, style));
-}
-/**
- * Collapses block-comment continuation lines (`\n` + ` * ` prefixes) so
- * substring markers like `Mozilla Public License` match Mozilla's wrapped
- * MPL boilerplate.
- */
-function normalizeLicenseHeadForScan(head) {
-    let s = head.replace(/\r\n?/g, '\n');
-    s = s.replace(/\n[ \t]*\*[ \t]*/g, ' ');
-    return s.replace(/\s+/g, ' ').trim();
-}
-/**
- * Recognizes the CC0 public-domain dedication Mozilla puts on most of its
- * test files, in every spelling the tree carries:
- *
- * - the prose (`Any copyright is dedicated to the Public Domain.`), which
- *   the block, `//` and `#` comment forms all reduce to after
- *   {@link normalizeLicenseHeadForScan}.
- * - the dedication URL (`creativecommons.org/publicdomain/zero/1.0/`, with
- *   either scheme).
- * - the SPDX identifier `CC0-1.0`.
- *
- * Narrow on purpose: a bare "public domain" mention, a different Creative
- * Commons license (`licenses/by/4.0/`, `CC-BY-4.0`) or a made-up
- * `publicdomain/zero/2.0/` is not a CC0 dedication and must not be
- * accepted as one. `scanText` must already be normalized (and may be
- * lowercased, since the match is case-insensitive).
- */
-function hasCc0Dedication(scanText) {
-    return /dedicated to the public domain|creativecommons\.org\/publicdomain\/zero\/1\.0|spdx-license-identifier:\s*cc0-1\.0\b/i.test(scanText);
-}
-/**
- * Returns true if the first few lines of `content` contain a recognized
- * upstream license identifier string: Mozilla's MPL boilerplate, an SPDX
- * tag, the common permissive/copyleft license names, or the CC0
- * public-domain dedication upstream test files carry.
- *
- * @param content  - File content to check
- * @param maxLines - Number of leading lines to inspect (default 10)
- */
-export function containsUpstreamLicenseText(content, maxLines = 10) {
-    const head = content.split('\n').slice(0, maxLines).join('\n');
-    const scanText = normalizeLicenseHeadForScan(head);
-    const markers = [
-        'Mozilla Public License',
-        'SPDX-License-Identifier',
-        'Apache License',
-        'MIT License',
-        'GNU General Public License',
-    ];
-    return markers.some((marker) => scanText.includes(marker)) || hasCc0Dedication(scanText);
-}
-/**
- * Returns true when the head of `content` carries a recognized third-party
- * permissive license banner (MIT / ISC / BSD-2 / BSD-3 / Apache-2.0) or the
- * CC0 public-domain dedication, in any comment style. Used by `export` to
- * treat such files as vendored: offering to prepend the project's own
- * license header onto a byte-identity-pinned upstream bundle, or onto a
- * test file Mozilla dedicated to the public domain, would mislicense code
- * the project does not own.
- *
- * @param content  - File content to check
- * @param maxLines - Number of leading lines to inspect (default 30, because
- *   full MIT/BSD license texts run longer than the 10-line project-header
- *   scan)
- */
-export function hasThirdPartyPermissiveBanner(content, maxLines = 30) {
-    const head = content.split('\n').slice(0, maxLines).join('\n');
-    const scanText = normalizeLicenseHeadForScan(head).toLowerCase();
-    const markers = [
-        'mit license',
-        'permission is hereby granted, free of charge',
-        'isc license',
-        'permission to use, copy, modify',
-        'redistribution and use in source and binary forms',
-        'apache license',
-        'licensed under the apache license',
-    ];
-    if (markers.some((marker) => scanText.includes(marker)))
-        return true;
-    if (hasCc0Dedication(scanText))
-        return true;
-    return /spdx-license-identifier:\s*(mit|isc|bsd-2-clause|bsd-3-clause|apache-2\.0|cc0-1\.0)\b/.test(scanText);
-}
-/**
- * Prepends the license header to a file on disk if it is not already present.
- *
- * @param filePath - Absolute path to the file
- * @param license  - SPDX identifier of the license to add
- * @param style    - Comment syntax matching the file type
- * @returns true if the header was added, false if already present
- */
-export async function addLicenseHeaderToFile(filePath, license, style) {
-    const content = await readText(filePath);
-    const header = getLicenseHeader(license, style);
-    if (content.startsWith(header))
-        return false;
-    await writeText(filePath, header + '\n' + content);
-    return true;
-}

package/dist/src/core/line-prefixer.d.ts

@@ -1,18 +0,0 @@
-/**
- * Prefixes every line of a chunked stream, for output from several
- * concurrent harness instances (`fireforge test --jobs`) that share one
- * terminal and one run log. Without a prefix, interleaved lines from two
- * browsers cannot be attributed after the fact.
- */
-/** A stateful line prefixer for one stream. */
-export interface LinePrefixer {
-    /** Returns `chunk` with the prefix inserted at the start of each line. */
-    transform(chunk: string): string;
-}
-/**
- * Creates a prefixer. Line state carries across chunks, so a line split
- * between two chunks gets the prefix exactly once.
- *
- * @param prefix - Text to insert, e.g. `[job 2] `
- */
-export declare function createLinePrefixer(prefix: string): LinePrefixer;

package/dist/src/core/line-prefixer.js

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Prefixes every line of a chunked stream, for output from several
- * concurrent harness instances (`fireforge test --jobs`) that share one
- * terminal and one run log. Without a prefix, interleaved lines from two
- * browsers cannot be attributed after the fact.
- */
-/**
- * Creates a prefixer. Line state carries across chunks, so a line split
- * between two chunks gets the prefix exactly once.
- *
- * @param prefix - Text to insert, e.g. `[job 2] `
- */
-export function createLinePrefixer(prefix) {
-    let atLineStart = true;
-    return {
-        transform(chunk) {
-            if (chunk.length === 0)
-                return chunk;
-            let out = '';
-            let start = 0;
-            for (let index = chunk.indexOf('\n'); index !== -1; index = chunk.indexOf('\n', start)) {
-                out += `${atLineStart ? prefix : ''}${chunk.slice(start, index + 1)}`;
-                atLineStart = true;
-                start = index + 1;
-            }
-            if (start < chunk.length) {
-                out += `${atLineStart ? prefix : ''}${chunk.slice(start)}`;
-                atLineStart = false;
-            }
-            return out;
-        },
-    };
-}

package/dist/src/core/lit-template-regions.d.ts

@@ -1,4 +0,0 @@
-/** Collects Lit html quasis, masking expressions while preserving nested templates. */
-export declare function collectLitTemplateRegions(content: string): string[];
-/** Reads actual attribute names and values, skipping quoted values as indivisible tokens. */
-export declare function parseTemplateAttributes(source: string): Map<string, string | undefined>;

package/dist/src/core/lit-template-regions.js

@@ -1,50 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { tokenizer } from 'acorn';
-/** Collects Lit html quasis, masking expressions while preserving nested templates. */
-export function collectLitTemplateRegions(content) {
-    const regions = [];
-    const stack = [];
-    let previous = '';
-    let previousValue;
-    try {
-        for (const token of tokenizer(content, { ecmaVersion: 'latest', sourceType: 'module' })) {
-            const label = token.type.label;
-            if (label === '`') {
-                if (previous === 'template' || previous === 'invalidTemplate') {
-                    const closed = stack.pop();
-                    if (closed?.html)
-                        regions.push(closed.text);
-                }
-                else {
-                    stack.push({ html: previous === 'name' && previousValue === 'html', text: '' });
-                }
-            }
-            else if (label === 'template') {
-                const current = stack.at(-1);
-                if (current)
-                    current.text += content.slice(token.start, token.end);
-            }
-            else if (label === '${') {
-                const current = stack.at(-1);
-                if (current)
-                    current.text += '${expression}';
-            }
-            previous = label;
-            previousValue = content.slice(token.start, token.end);
-        }
-    }
-    catch {
-        // Keep completed regions from a file being edited; never re-pair backticks.
-    }
-    return regions;
-}
-/** Reads actual attribute names and values, skipping quoted values as indivisible tokens. */
-export function parseTemplateAttributes(source) {
-    const attributes = new Map();
-    const pattern = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
-    for (const match of source.matchAll(pattern)) {
-        if (match[1])
-            attributes.set(match[1].toLowerCase(), match[2] ?? match[3] ?? match[4]);
-    }
-    return attributes;
-}

package/dist/src/core/mach-build-artifacts.d.ts

@@ -1,176 +0,0 @@
-/**
- * Result of checking for build artifacts.
- */
-export interface BuildArtifactCheck {
-    /** Whether build artifacts exist */
-    exists: boolean;
-    /** Name of the obj-* directory if found */
-    objDir?: string;
-    /** Whether multiple valid obj-* directories were found */
-    ambiguous?: boolean;
-    /** All candidate obj-* directories with build artifacts */
-    objDirs?: string[];
-    /**
-     * Objdir name the active mozconfig declares via `MOZ_OBJDIR`, when the
-     * candidates were ambiguous and the declaration did not resolve to exactly
-     * one of them. Carried so the refusal can say the declaration was seen and
-     * did not help. That is itself the diagnosis.
-     */
-    declaredObjDir?: string;
-    /** Build metadata points at a different source or objdir */
-    metadataMismatch?: {
-        objDir: string;
-        topsrcdir?: string;
-        topobjdir?: string;
-        mozconfig?: string;
-    };
-}
-/**
- * Checks if build artifacts exist in the engine directory.
- * Looks for obj-* directories with a dist subdirectory. Detection is
- * symlink-agnostic on purpose: building/running against a symlinked
- * objdir in place is the user's own arrangement. The clone path, where a
- * symlink would route writes into the original build, refuses separately
- * (`assertCloneSafeObjdir` in tree-store.ts).
- * @param engineDir - Path to the engine directory
- * @returns Build artifact check result
- */
-export declare function hasBuildArtifacts(engineDir: string): Promise<BuildArtifactCheck>;
-/**
- * Outcome of the `hasRunnableBundle` probe. Distinguishes "no objdir at
- * all" from "objdir exists but the launchable binary is not yet written"
- * so callers (notably `fireforge run`) can give the operator a specific
- * message instead of the generic build-artifacts-missing line.
- */
-export interface RunnableBundleCheck {
-    /** True when an objdir is present and the expected binary was found under it. */
-    runnable: boolean;
-    /** Repo-relative (engine-rooted) path we probed. Populated even on failure for error copy. */
-    expectedPath?: string;
-}
-/**
- * Checks whether the built browser's launchable binary exists under
- * `<engineDir>/<objDir>/dist/...`. `hasBuildArtifacts` only confirms that
- * an obj tree with a `dist/` subdir exists. A partial or in-progress build
- * can satisfy that check without ever writing the executable, which is the
- * failure mode that makes `fireforge run` throw `mach run` after having
- * reported the build as usable. Separating the probes lets `run` fail fast
- * with a precise message and `watch` stay permissive (it exists to drive
- * rebuilds of incomplete trees) while still reporting the bundle state in
- * its startup banner.
- *
- * Platform layout:
- * - macOS: `<objDir>/dist/*.app/Contents/MacOS/<binaryName>` (the `.app`
- *   display casing can differ from `binaryName`, e.g. `MyBrowser.app` for
- *   binary `mybrowser`, so we enumerate the `*.app` bundles rather than
- *   compute the name.
- * - Linux: `<objDir>/dist/bin/<binaryName>`.
- * - Windows: `<objDir>/dist/bin/<binaryName>.exe`.
- *
- * Returns `runnable: false` with no `expectedPath` when the `objDir`
- * itself cannot be scanned. Same degraded contract as `hasBuildArtifacts`.
- *
- * @param engineDir Path to the engine directory
- * @param binaryName Lowercase binary name from `fireforge.json`
- * @param objDir The single matching `obj-*` directory name (caller
- *   resolves it, typically from `hasBuildArtifacts().objDir`)
- * @returns Structured check result
- */
-export declare function hasRunnableBundle(engineDir: string, binaryName: string, objDir: string): Promise<RunnableBundleCheck>;
-/** Builds a user-facing explanation when detected build artifacts belong to another workspace. */
-export declare function buildArtifactMismatchMessage(engineDir: string, buildCheck: BuildArtifactCheck, commandName: string): string | undefined;
-/**
- * Outcome of an in-place mozinfo.json rewrite attempt. A successful rewrite
- * returns the paths written. A refused rewrite returns a human-readable
- * reason so the build flow can surface it alongside the original mismatch
- * message before falling back to the clean-rebuild instruction.
- */
-export interface MozinfoRewriteResult {
-    /** Whether mozinfo.json was patched in place. */
-    rewritten: boolean;
-    /** Reason the rewrite was refused (populated when `rewritten === false`). */
-    reason?: string;
-    /** New `topsrcdir` value written to disk (populated on success). */
-    newTopsrcdir?: string;
-    /** Original source prefix checked after configure. */
-    oldTopsrcdir?: string;
-    /** New `topobjdir` value written to disk (populated on success). */
-    newTopobjdir?: string;
-    /** New `mozconfig` value written to disk (populated on success when it lived inside topsrcdir). */
-    newMozconfig?: string;
-}
-/**
- * Safe-relocation rewriter for mozinfo.json under the active obj-* tree.
- *
- * Copied objdirs retain source symlinks, dependency metadata and tracking
- * inventories as well as mozinfo.json. Repair them before configure so
- * config.track cannot write nulls into the primary checkout. Configure then
- * regenerates the root config files; callers verify old-source links too.
- *
- * Safety rules. The rewrite is refused when any of them are violated:
- *   - `topsrcdir` and `topobjdir` must both be present and non-empty.
- *   - `topobjdir` must resolve to `<topsrcdir>/<objDir>`. A non-in-tree
- *     objdir means the previous workspace was configured differently,
- *     so a blind prefix-rewrite could point mach at the wrong tree.
- *   - The computed new `topobjdir` must be `<engineDir>/<objDir>`. If it
- *     is not, the objDir name itself changed and we cannot prove safety.
- *
- * When any rule trips, the caller should fall back to the clean-rebuild
- * instruction, which is always a correct (if expensive) recovery path.
- *
- * @param engineDir Absolute path to the current engine checkout.
- * @param objDir Name of the obj-* directory to rewrite against.
- * @returns Result object. Callers inspect `rewritten` and surface `reason`.
- */
-export declare function attemptMozinfoRewrite(engineDir: string, objDir: string): Promise<MozinfoRewriteResult>;
-/** Per-command wording for {@link assertBuildArtifacts}. */
-export interface BuildArtifactPreflightOptions {
-    /** Label passed to {@link buildArtifactMismatchMessage} (e.g. `'Tests'`). */
-    label: string;
-    /** Sentence naming what needs a build, e.g. `'Tests require a completed build.'` */
-    requirement: string;
-    /** Follow-up telling the operator what to run, shown after `requirement`. */
-    remediation: string;
-    /**
-     * Whether a missing/incomplete build is fatal. `fireforge build` runs
-     * legitimately with no artifacts and only enforces this under `--ui`, so it
-     * opts in rather than out.
-     */
-    requireExisting?: boolean;
-}
-/**
- * Shared build-artifact preflight: rejects ambiguous multi-objdir checkouts,
- * artifacts whose metadata points at another tree, and (when
- * `requireExisting`) missing or incomplete builds, each with the actionable
- * message for that case.
- *
- * Takes an already-probed {@link BuildArtifactCheck} rather than probing
- * itself, so it stays a pure validator: callers keep their own
- * `hasBuildArtifacts` call (which their suites already stub) and this
- * function needs no test double of its own.
- */
-export declare function assertBuildArtifacts(engineDir: string, buildCheck: BuildArtifactCheck, options: BuildArtifactPreflightOptions): void;
-/**
- * Post-`mach configure` relocation check for a cloned objdir: confirms
- * configure actually regenerated `<engineDir>/<objDir>` and that none of
- * the four configure-generated root files (`config.status`, `backend.mk`,
- * `Makefile`, `config/autoconf.mk`) still names `forbiddenDir` (the
- * primary engine a relocated clone must never consult). Exit code 0 alone
- * proves neither: a stray MOZCONFIG/MOZ_OBJDIR can steer configure at a
- * different objdir entirely. Nested Makefiles are products of the verified
- * `config.status` and are not scanned. `.deps` files are build products a
- * configure cannot regenerate and are explicitly out of scope, and any
- * primary-path strings they retain are read-only staleness corrected by
- * the first in-tree rebuild. Pure checker: returns a human-readable
- * violation, or `undefined` when clean. Callers own the error type and
- * remediation copy. Unreadable metadata is itself a violation (fail
- * closed).
- */
-export declare function findObjdirRelocationViolation(args: {
-    /** The relocated (tree) engine directory configure ran in. */
-    engineDir: string;
-    /** The obj-* directory name configure was expected to target. */
-    objDir: string;
-    /** The primary engine dir whose absolute path must not appear. */
-    forbiddenDir: string;
-}): Promise<string | undefined>;