@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/build-baseline.js

@@ -1,261 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Persists a marker describing the state of the engine tree at the time of
- * the last successful `fireforge build`. Two downstream consumers share this
- * marker:
- *
- *   - `build-audit`: after a build succeeds, compare engine files touched
- *     since the baseline against the dist bundle to flag silent
- *     packaging drops (e.g. a pref file never registered in moz.build).
- *   - `build-prepare`: before a build starts, detect whether any
- *     `moz.build` / `moz.configure` / `Makefile.in` changed since the
- *     baseline and run `mach configure` before the build step so the
- *     recursive-make backend isn't stale.
- *
- * The marker lives under `.fireforge/last-build.json`. It is written only
- * on successful build completion. A failed build does not update it, so a
- * subsequent run still audits against the last known-good tree.
- */
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { PreflightRefusalError } from '../errors/base.js';
-import { mapWithConcurrency } from '../utils/concurrency.js';
-import { getNodeErrorCode, toError } from '../utils/errors.js';
-import { readJson, writeJson } from '../utils/fs.js';
-import { sha256Hex } from '../utils/hash.js';
-import { verbose } from '../utils/logger.js';
-import { isBuildInputPath, isJarManifestPath, isPackageablePath, isXpcomManifestPath, } from './build-audit.js';
-import { DELETED_FILE_FINGERPRINT, } from './build-baseline-types.js';
-import { describeBuildBaselineProblem, findBuildBaselineProblem, isCoverageProblem, } from './build-baseline-validate.js';
-import { FIREFORGE_DIR } from './config-paths.js';
-import { hashEngineFile } from './coverage-extend.js';
-import { getHead, hasChanges, isMissingHeadError } from './git.js';
-import { git } from './git-base.js';
-import { historyRecordIdentity } from './history-log-file.js';
-/*
- * Keep the IO fan-out bounded: a patched Firefox checkout can carry hundreds
- * of dirty packageable paths and serial reads add directly to every build.
- */
-const FINGERPRINT_IO_CONCURRENCY = 16;
-/** Name of the last-build marker file under `.fireforge/`. */
-const BUILD_BASELINE_FILENAME = 'last-build.json';
-/**
- * Resolves the on-disk path of the build baseline marker.
- * @param projectRoot - Root directory of the project
- * @returns Absolute path of the marker file
- */
-export function getBuildBaselinePath(projectRoot) {
-    return join(projectRoot, FIREFORGE_DIR, BUILD_BASELINE_FILENAME);
-}
-/**
- * Reads the last-build baseline if present. Returns undefined when no
- * previous successful build has been recorded. Builds can replace invalid
- * markers; dispatch preflights pass `refuse` so invalid coverage never
- * becomes the implicit full claim of a baseline without coverage.
- * @param projectRoot - Root directory of the project
- */
-export async function readBuildBaseline(projectRoot, invalid = 'ignore') {
-    const path = getBuildBaselinePath(projectRoot);
-    let problem;
-    try {
-        const value = await readJson(path);
-        problem = findBuildBaselineProblem(value);
-        if (problem !== undefined) {
-            throw new Error(`invalid baseline field ${describeBuildBaselineProblem(problem)}`);
-        }
-        return value;
-    }
-    catch (error) {
-        if (getNodeErrorCode(error) === 'ENOENT')
-            return undefined;
-        if (invalid === 'refuse') {
-            // A coverage field is what a scoped `test --build` writes, so a fresh
-            // scoped build over the requested paths replaces it as well as a full
-            // one does.
-            const remedy = problem !== undefined && isCoverageProblem(problem)
-                ? 'The field is part of the packaging-coverage claim a scoped "fireforge test --build" records. Rerun this test with --build to record a fresh claim for its paths, or run "fireforge build" to record a full baseline.'
-                : 'Run "fireforge build" to record a fresh baseline before dispatching tests.';
-            throw new PreflightRefusalError(`Build baseline ${path} is invalid: ${toError(error).message}. ${remedy}`, 'invalid-build-baseline');
-        }
-        verbose(`Ignoring invalid build baseline ${path}: ${toError(error).message}`);
-        return undefined;
-    }
-}
-/** This process's {@link BuildBaseline.recorder} stamp. */
-function baselineRecorder() {
-    const { pid, invocationId, sessionId } = historyRecordIdentity();
-    return { pid, invocationId, ...(sessionId !== undefined ? { sessionId } : {}) };
-}
-/**
- * Records a successful build by writing a fresh baseline marker. Captures
- * engine HEAD SHA (or an empty string when the engine has no HEAD yet) and
- * the current binaryName. Caller is responsible for only invoking this
- * after the build exit code was zero.
- *
- * @param options - See {@link WriteBuildBaselineOptions}
- */
-export async function writeBuildBaseline(options) {
-    const { projectRoot, engineDir, binaryName, testPackagingCoverage, testCoverageRecords, fullCoverageAnchor, previousBaseline, recordedBy, staticComponentsHandling = 'auto', buildKind = 'full', controlBuild, } = options;
-    let engineHeadSha = '';
-    try {
-        engineHeadSha = await getHead(engineDir);
-    }
-    catch (error) {
-        // Engine may be an unborn branch (freshly cloned + reset, or
-        // mid-import). Record an empty SHA and let downstream fall back to "no
-        // prior state" behavior. Any other git failure is bubbled up, because
-        // we don't want to silently write a garbage marker.
-        if (!isMissingHeadError(error)) {
-            throw error;
-        }
-    }
-    const packageableFingerprints = await collectPackageableFingerprints(engineDir);
-    const testInputFingerprints = await collectDirtyFingerprints(engineDir, () => true, 'test staging fingerprint');
-    const buildInputFingerprints = await collectBuildInputFingerprints(engineDir, previousBaseline, buildKind);
-    // A full-coverage write (and a no-claim `fireforge build` record)
-    // just recompiled the StaticComponents table, so it anchors the table to
-    // the current engine state. A scoped write did not, so carry the previous
-    // anchor forward verbatim.
-    const staticComponentsBaseline = staticComponentsHandling === 'refresh' ||
-        (staticComponentsHandling === 'auto' &&
-            (testPackagingCoverage === undefined || testPackagingCoverage === 'full'))
-        ? await collectStaticComponentsBaseline(engineDir, engineHeadSha)
-        : previousBaseline?.staticComponentsBaseline;
-    const mozconfigHash = await hashEngineFile(engineDir, 'mozconfig');
-    const baseline = {
-        engineHeadSha,
-        builtAt: new Date().toISOString(),
-        binaryName,
-        ...(packageableFingerprints !== undefined ? { packageableFingerprints } : {}),
-        ...(testInputFingerprints !== undefined ? { testInputFingerprints } : {}),
-        ...(buildInputFingerprints !== undefined ? { buildInputFingerprints } : {}),
-        ...(testPackagingCoverage !== undefined ? { testPackagingCoverage } : {}),
-        ...(testCoverageRecords !== undefined ? { testCoverageRecords } : {}),
-        ...(fullCoverageAnchor !== undefined ? { fullCoverageAnchor } : {}),
-        ...(mozconfigHash !== undefined ? { mozconfigHash } : {}),
-        ...(staticComponentsBaseline !== undefined ? { staticComponentsBaseline } : {}),
-        ...(recordedBy !== undefined ? { recordedBy } : {}),
-        recorder: baselineRecorder(),
-        ...(controlBuild !== undefined ? { controlBuild } : {}),
-    };
-    await writeJson(getBuildBaselinePath(projectRoot), baseline);
-}
-/**
- * Reads the current engine workdir and computes a SHA-256 fingerprint for
- * every packageable path that is either modified against HEAD or untracked.
- * The stale-build preflight (`checkStaleBuildForTest`) compares the live
- * fingerprint for each packageable-dirty file to the baseline's entry: a
- * matching hash means the build already saw this exact content, a differing
- * or new one means the file is genuinely stale.
- *
- * Returns `undefined` on any git failure so a broken probe never corrupts
- * the on-disk baseline with `{}`. The stale-check then falls back to a
- * path-only comparison.
- */
-async function collectPackageableFingerprints(engineDir) {
-    return collectDirtyFingerprints(engineDir, isPackageablePath, 'packageable fingerprint');
-}
-/**
- * Content fingerprints of the dirty build-input manifests
- * ({@link isBuildInputPath}) this build consumed. Backend inputs
- * (`moz.build` & co) are always taken from the live tree: the
- * auto-configure preflight reconfigured against them before this build
- * ran. `jar.mn` entries are taken from the live tree only after a full
- * build. A `faster` write carries the previous record's `jar.mn` entries
- * forward verbatim, because `mach build faster` is the build the
- * `jar.mn` escalation exists to bypass, and recording a `jar.mn` it did
- * not install would silence the next escalation. Returns `undefined` on
- * probe failure so the field is omitted rather than written as `{}`.
- */
-async function collectBuildInputFingerprints(engineDir, previousBaseline, buildKind) {
-    const live = await collectDirtyFingerprints(engineDir, isBuildInputPath, 'build-input fingerprint');
-    if (live === undefined || buildKind === 'full') {
-        return live;
-    }
-    const fingerprints = {};
-    for (const [path, hash] of Object.entries(live)) {
-        if (!isJarManifestPath(path))
-            fingerprints[path] = hash;
-    }
-    for (const [path, hash] of Object.entries(previousBaseline?.buildInputFingerprints ?? {})) {
-        if (isJarManifestPath(path))
-            fingerprints[path] = hash;
-    }
-    return fingerprints;
-}
-/**
- * Anchor for the compiled StaticComponents table: the engine HEAD SHA of
- * this (full) build plus content fingerprints of the `components.conf`
- * manifests dirty right now, using the same dirty-path probe family as
- * {@link collectPackageableFingerprints}, filtered to XPCOM manifests.
- * Returns `undefined` on probe failure so a broken probe omits the field
- * (the static-components stale check then degrades to "fresh") rather than
- * anchoring to a garbage record.
- */
-async function collectStaticComponentsBaseline(engineDir, engineHeadSha) {
-    const fingerprints = await collectDirtyFingerprints(engineDir, isXpcomManifestPath, 'static-components fingerprint');
-    if (fingerprints === undefined) {
-        return undefined;
-    }
-    return { engineHeadSha, fingerprints };
-}
-/**
- * Shared dirty-path fingerprint probe backing
- * {@link collectPackageableFingerprints} and
- * {@link collectStaticComponentsBaseline}: enumerates engine workdir
- * modifications (tracked and untracked), keeps the paths `includePath`
- * accepts, and hashes each. Returns `undefined` on any git failure so a
- * broken probe never corrupts the on-disk baseline with `{}`.
- */
-async function collectDirtyFingerprints(engineDir, includePath, contextLabel) {
-    try {
-        const dirtyPaths = new Set();
-        if (await hasChanges(engineDir)) {
-            // NUL-separated and unquoted: git's default output backslash-quotes a
-            // non-ASCII path (`"a/\303\251.js"`), which is neither the file on
-            // disk nor a key the baseline validator accepts.
-            const worktreeDiff = await git(['-c', 'core.quotePath=false', 'diff', '--name-only', '-z', 'HEAD'], engineDir);
-            const untracked = await git(['-c', 'core.quotePath=false', 'ls-files', '--others', '--exclude-standard', '-z'], engineDir);
-            for (const path of `${worktreeDiff}\0${untracked}`.split('\0')) {
-                if (path.length > 0)
-                    dirtyPaths.add(path);
-            }
-        }
-        const included = [...dirtyPaths].filter(includePath);
-        if (included.length === 0) {
-            return {};
-        }
-        const entries = await mapWithConcurrency(included, FINGERPRINT_IO_CONCURRENCY, async (relPath) => {
-            try {
-                const buffer = await readFile(join(engineDir, relPath));
-                return [relPath, sha256Hex(buffer)];
-            }
-            catch (fileError) {
-                if (getNodeErrorCode(fileError) === 'ENOENT') {
-                    // A path reported by git but absent on disk is normally a tracked
-                    // deletion, not a failed fingerprint. Recording the tombstone lets
-                    // the next stale check prove that deletion was already built.
-                    return [relPath, DELETED_FILE_FINGERPRINT];
-                }
-                // A file that disappeared between status probe and hash is
-                // expected in concurrent scenarios. Non-ENOENT failures remain
-                // untrusted and are skipped without failing the whole baseline write.
-                verbose(`Build baseline: skipping ${contextLabel} for ${relPath} — ${toError(fileError).message}`);
-                return undefined;
-            }
-        });
-        const fingerprints = {};
-        // Incomplete maps cannot prove retained test inputs unchanged.
-        if (entries.some((entry) => entry === undefined))
-            return undefined;
-        for (const entry of entries) {
-            if (entry !== undefined)
-                fingerprints[entry[0]] = entry[1];
-        }
-        return fingerprints;
-    }
-    catch (error) {
-        verbose(`Build baseline: ${contextLabel} probe failed — ${toError(error).message}`);
-        return undefined;
-    }
-}

package/dist/src/core/build-jar-escalation.d.ts

@@ -1,61 +0,0 @@
-/**
- * Decides whether a changed `jar.mn` really forces the pre-test build to
- * escalate from `mach build faster` to a full `mach build`.
- *
- * Escalating on every changed jar.mn (`any changed jar.mn ⇒ full build`)
- * costs ~10 minutes against ~20 s for a chrome-only slice and is paid twice
- * per green/no-change pair on a Furnace-touching slice. A downstream
- * experiment (two clean runs, 2026-08-29) showed that rule is over-broad
- * for the common case: a jar-only registration of a new content file added
- * to an existing `dist/bin` manifest was installed by a plain
- * `fireforge build --ui` both times: `faster/install_dist_bin_browser` named
- * the destination, the file landed in `dist/bin/…/content/browser/` and in
- * the `.app` bundle, and a plain `fireforge test` fetched it over
- * `chrome://` at runtime. Neither run escalated, and neither needed to.
- *
- * What the experiment did not exercise, and what therefore still escalates:
- *
- *  - a new `jar.mn` file. The install manifest for a manifest the backend
- *    has never seen does not exist yet, and `mach build faster` consumes
- *    install manifests rather than regenerating the backend that writes
- *    them.
- *  - a manifest whose jar declaration carries a bracketed base-directory
- *    prefix (`[some/dir] name.jar:`), which redirects the install
- *    destination away from the default chrome root. That redirect is the
- *    "non-dist/bin target" half nobody has run.
- *
- * Everything else about the rule is unchanged, and every failure to read or
- * parse a manifest escalates: this narrows a conservative rule, so its
- * error direction stays the slow-but-correct one.
- */
-/** Why one changed `jar.mn` still forces a full build. */
-export interface JarEscalationCause {
-    /** Engine-relative manifest path. */
-    path: string;
-    /** Operator-facing reason, printed with the escalation notice. */
-    reason: string;
-}
-/** Outcome of {@link evaluateJarManifestEscalation}. */
-export interface JarEscalationDecision {
-    /** True when at least one changed manifest still needs a full build. */
-    escalate: boolean;
-    /** One entry per manifest that forces the escalation. */
-    causes: JarEscalationCause[];
-    /** Manifests the narrowing cleared. Kept for the verbose explanation. */
-    cleared: string[];
-}
-/**
- * Evaluates every changed `jar.mn` against the narrowed rule.
- *
- * @param engineDir - Absolute engine directory
- * @param changedPaths - Engine-relative paths changed since the last
- *   successful build (non-`jar.mn` entries are ignored)
- * @returns The escalation decision with per-manifest causes
- */
-export declare function evaluateJarManifestEscalation(engineDir: string, changedPaths: readonly string[]): Promise<JarEscalationDecision>;
-/**
- * Renders the operator-facing escalation notice. Names the manifest and the
- * reason: "a jar.mn changed" is the sentence that made the previous rule
- * impossible to argue with from outside.
- */
-export declare function formatJarEscalationNotice(decision: JarEscalationDecision): string;

package/dist/src/core/build-jar-escalation.js

@@ -1,125 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Decides whether a changed `jar.mn` really forces the pre-test build to
- * escalate from `mach build faster` to a full `mach build`.
- *
- * Escalating on every changed jar.mn (`any changed jar.mn ⇒ full build`)
- * costs ~10 minutes against ~20 s for a chrome-only slice and is paid twice
- * per green/no-change pair on a Furnace-touching slice. A downstream
- * experiment (two clean runs, 2026-08-29) showed that rule is over-broad
- * for the common case: a jar-only registration of a new content file added
- * to an existing `dist/bin` manifest was installed by a plain
- * `fireforge build --ui` both times: `faster/install_dist_bin_browser` named
- * the destination, the file landed in `dist/bin/…/content/browser/` and in
- * the `.app` bundle, and a plain `fireforge test` fetched it over
- * `chrome://` at runtime. Neither run escalated, and neither needed to.
- *
- * What the experiment did not exercise, and what therefore still escalates:
- *
- *  - a new `jar.mn` file. The install manifest for a manifest the backend
- *    has never seen does not exist yet, and `mach build faster` consumes
- *    install manifests rather than regenerating the backend that writes
- *    them.
- *  - a manifest whose jar declaration carries a bracketed base-directory
- *    prefix (`[some/dir] name.jar:`), which redirects the install
- *    destination away from the default chrome root. That redirect is the
- *    "non-dist/bin target" half nobody has run.
- *
- * Everything else about the rule is unchanged, and every failure to read or
- * parse a manifest escalates: this narrows a conservative rule, so its
- * error direction stays the slow-but-correct one.
- */
-import { join } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { readText } from '../utils/fs.js';
-import { verbose } from '../utils/logger.js';
-import { isJarManifestPath } from './build-audit.js';
-import { getUntrackedFilesInDir } from './git-status.js';
-/**
- * A jar declaration line: an optional bracketed base-directory prefix, then
- * the jar name. Matched at column zero because entry lines inside a section
- * are indented. An indented `foo.jar:` is content, not a declaration.
- */
-const JAR_DECLARATION_PATTERN = /^(\[[^\]]*\]\s*)?[^\s[\]]+\.jar:\s*$/;
-/** True when the jar declaration redirects the install base directory. */
-function declaresNonDefaultBase(line) {
-    const match = JAR_DECLARATION_PATTERN.exec(line);
-    if (!match)
-        return false;
-    return match[1] !== undefined;
-}
-/**
- * True when a changed `jar.mn` is new to the last successful build.
- *
- * Untracked in the engine repo is the reliable signal: a fork's engine tree
- * is a checkout of upstream with patches applied to the worktree, so a
- * manifest a patch created is untracked and one that shipped upstream is
- * tracked. The baseline's fingerprints cannot answer this on their own: they
- * record only the paths that were dirty at the last build, so a clean
- * pre-existing manifest has no entry either.
- */
-async function isNewJarManifest(engineDir, path) {
-    const untracked = await getUntrackedFilesInDir(engineDir, path);
-    return untracked.includes(path);
-}
-/**
- * Evaluates every changed `jar.mn` against the narrowed rule.
- *
- * @param engineDir - Absolute engine directory
- * @param changedPaths - Engine-relative paths changed since the last
- *   successful build (non-`jar.mn` entries are ignored)
- * @returns The escalation decision with per-manifest causes
- */
-export async function evaluateJarManifestEscalation(engineDir, changedPaths) {
-    const causes = [];
-    const cleared = [];
-    for (const path of changedPaths.filter(isJarManifestPath)) {
-        let isNew;
-        try {
-            isNew = await isNewJarManifest(engineDir, path);
-        }
-        catch (error) {
-            // Fail closed: an unanswerable "is this new?" keeps the old rule.
-            verbose(`jar escalation: could not classify engine/${path} (${toError(error).message}); escalating.`);
-            causes.push({ path, reason: 'could not determine whether the manifest is new' });
-            continue;
-        }
-        if (isNew) {
-            causes.push({ path, reason: 'new jar.mn (no install manifest exists for it yet)' });
-            continue;
-        }
-        let body;
-        try {
-            body = await readText(join(engineDir, path));
-        }
-        catch (error) {
-            verbose(`jar escalation: could not read engine/${path} (${toError(error).message}); escalating.`);
-            causes.push({ path, reason: 'manifest could not be read' });
-            continue;
-        }
-        const redirected = body
-            .split(/\r?\n/)
-            .filter((line) => declaresNonDefaultBase(line))
-            .map((line) => line.trim());
-        if (redirected.length > 0) {
-            causes.push({
-                path,
-                reason: `jar declaration redirects the install base directory (${redirected[0] ?? ''})`,
-            });
-            continue;
-        }
-        cleared.push(path);
-    }
-    return { escalate: causes.length > 0, causes, cleared };
-}
-/**
- * Renders the operator-facing escalation notice. Names the manifest and the
- * reason: "a jar.mn changed" is the sentence that made the previous rule
- * impossible to argue with from outside.
- */
-export function formatJarEscalationNotice(decision) {
-    const detail = decision.causes.map((c) => `engine/${c.path} (${c.reason})`).join('; ');
-    return (`Escalating this pre-test build to a full mach build so new install-manifest destinations ` +
-        `are created: ${detail}. A changed jar.mn that merely adds entries to an existing ` +
-        `dist/bin manifest no longer escalates.`);
-}

package/dist/src/core/build-overwrite-guard.d.ts

@@ -1,92 +0,0 @@
-/**
- * Loud guard against silently reverting unexported engine drift.
- *
- * `build-prepare` rewrites engine files from FireForge-owned sources before
- * every build: the branding tree, every Furnace-managed component, and
- * `mozconfig`. On a multi-session checkout that is a silent destructive
- * write: one session edits a file in `engine/` while another holds the
- * engine lock, the lock-holder's build rewrites it back to its patch
- * baseline, and the editing session's later `re-export --wait-lock`
- * captures a hybrid file that every gate then passes.
- *
- * This guard runs before the writes, classifies the engine's dirty files
- * with the same classifier `fireforge status` uses, and reports the ones
- * whose content is explained by neither a patch body nor the pristine
- * baseline. Advisory by default (a warning naming every file), refusing
- * under an explicit flag.
- *
- * A deployed Furnace file is checked against its component source as well
- * (`deployed-unexported`): when the engine copy equals the Furnace-composed
- * current source, differs from it only inside generated fragment
- * expansions, or is exactly Furnace's last recorded deployment, the
- * overwrite destroys nothing that is not a component source, so it is safe
- * even though no patch records it yet. Without this, peers' deployed but
- * unexported widgets refused every belted build on a shared checkout.
- */
-import type { FireForgeConfig } from '../types/config.js';
-import { type DeployedSourceMatch } from './furnace-composed-source.js';
-import { type ClassifiedFile } from './status-classify.js';
-/** One file whose unexported content a build-prepare overwrite would destroy. */
-export interface UnexportedDriftAtRisk {
-    file: string;
-    classification: ClassifiedFile['classification'];
-    owner?: string | undefined;
-}
-/**
- * A deployed Furnace file no patch records yet whose content is its
- * component source's (see {@link DeployedSourceMatch}), so the overwrite is
- * safe. Its patch still owes a re-export.
- */
-export interface DeployedUnexportedFile {
-    file: string;
-    classification: 'deployed-unexported';
-    match: DeployedSourceMatch;
-    owner?: string | undefined;
-}
-/** Outcome of {@link assessUnexportedDrift}. */
-export interface UnexportedDriftAssessment {
-    /** Files whose content the overwrite would destroy unrecorded. */
-    atRisk: UnexportedDriftAtRisk[];
-    /** Files the overwrite rewrites from their own component source. */
-    deployedUnexported: DeployedUnexportedFile[];
-}
-/**
- * Finds engine files that build-prepare is about to overwrite and whose
- * current content is recorded nowhere.
- *
- * Fail-open: any probe failure is reported verbosely and yields an empty
- * list. A build must not fail because an advisory guard could not run.
- *
- * @internal The at-risk half of {@link assessUnexportedDrift}, kept for the
- * guard's tests; build-prepare consumes the full assessment.
- *
- * @param projectRoot - Project root
- * @param config - Loaded FireForge config (reads `binaryName`)
- * @returns At-risk files, sorted by path
- */
-export declare function findUnexportedDriftAtRisk(projectRoot: string, config: FireForgeConfig): Promise<UnexportedDriftAtRisk[]>;
-/**
- * Classifies the engine files build-prepare is about to overwrite into the
- * ones whose content is recorded nowhere (`atRisk`) and the deployed
- * Furnace files no patch records yet whose content is their component
- * source's (`deployedUnexported`, safe to overwrite).
- *
- * Fail-open like {@link findUnexportedDriftAtRisk}: a probe failure yields
- * an empty assessment.
- *
- * @param projectRoot - Project root
- * @param config - Loaded FireForge config (reads `binaryName`)
- * @returns Both lists, sorted by path
- */
-export declare function assessUnexportedDrift(projectRoot: string, config: FireForgeConfig): Promise<UnexportedDriftAssessment>;
-/**
- * Renders the informational note for deployed Furnace files the overwrite
- * rewrites from their own component source: safe for this build, but their
- * patches still owe a re-export.
- */
-export declare function formatDeployedUnexportedNote(files: readonly DeployedUnexportedFile[]): string;
-/**
- * Renders the operator-facing warning (or refusal body) naming every file
- * whose unexported content the build is about to overwrite.
- */
-export declare function formatUnexportedDriftWarning(files: readonly UnexportedDriftAtRisk[]): string;