@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/status-scope.d.ts

@@ -1,37 +0,0 @@
-/**
- * `status --patches <list>`: judges only the named patches' files. Split
- * out of status.ts, which sits at the max-lines budget.
- *
- * On a shared engine a peer's unexported work keeps a tree-wide gate red
- * for everyone. The scope keeps a file when the patch that owns it (or,
- * for a conflict, any patch that claims it) is named, and an ownership
- * row when any of its owners is named. An unmanaged file has no owning
- * patch, so no scope covers it: scoped runs never judge unexported files.
- * That is the point of the scope, and also its limit, which the docs say.
- */
-import type { OwnershipRow } from '../core/ownership-table.js';
-import type { ClassifiedFile, StatusFile } from '../core/status-classify.js';
-/** The resolved `--patches` scope: manifest filenames, in request order. */
-export interface StatusScope {
-    patches: string[];
-}
-/**
- * Resolves raw `--patches` values against the manifest. Returns undefined
- * when the flag was not given, and refuses a name that matches no patch
- * (so a typo fails loud instead of judging nothing).
- *
- * @param patchesDir - Absolute path to the patches directory
- * @param requested - Raw `--patches` values (each may be a comma list)
- */
-export declare function resolveStatusScope(patchesDir: string, requested: readonly string[] | undefined): Promise<StatusScope | undefined>;
-/** Keeps only the classified entries the scope covers. No scope keeps all. */
-export declare function scopeClassified(classified: ClassifiedFile[], scope: StatusScope | undefined): ClassifiedFile[];
-/** Keeps only the ownership rows with an owner in scope. No scope keeps all. */
-export declare function scopeOwnershipRows(rows: OwnershipRow[], scope: StatusScope | undefined): OwnershipRow[];
-/**
- * Builds the ownership rows from the full scan (classification needs every
- * file to find claims), then narrows them to the scope.
- */
-export declare function collectScopedOwnershipRows(patchesDir: string, files: StatusFile[], classified: readonly ClassifiedFile[], scope: StatusScope | undefined): Promise<OwnershipRow[]>;
-/** The paths the `ownership-conflict` check class judges. */
-export declare function ownershipConflictPaths(rows: readonly OwnershipRow[]): string[];

package/dist/src/commands/status-scope.js

@@ -1,54 +0,0 @@
-import { loadPatchesManifest } from '../core/patch-manifest.js';
-import { selectPatchSubset } from '../core/patch-subset.js';
-import { GeneralError } from '../errors/base.js';
-import { collectOwnershipRows } from './status-ownership.js';
-/**
- * Resolves raw `--patches` values against the manifest. Returns undefined
- * when the flag was not given, and refuses a name that matches no patch
- * (so a typo fails loud instead of judging nothing).
- *
- * @param patchesDir - Absolute path to the patches directory
- * @param requested - Raw `--patches` values (each may be a comma list)
- */
-export async function resolveStatusScope(patchesDir, requested) {
-    if (requested === undefined || requested.length === 0)
-        return undefined;
-    const manifest = await loadPatchesManifest(patchesDir);
-    if (!manifest || manifest.patches.length === 0) {
-        throw new GeneralError('--patches needs a patch queue, but patches.json lists no patches.');
-    }
-    const subset = selectPatchSubset(manifest, requested, '--patches selects patches (filename, stem, order number, manifest name, or slug), not engine files.');
-    return { patches: subset.map((patch) => patch.filename) };
-}
-/** True when the entry's owner, or any patch claiming it, is in scope. */
-function isInScope(entry, names) {
-    if (entry.owner !== undefined && names.has(entry.owner))
-        return true;
-    return entry.claimedBy?.some((patch) => names.has(patch)) === true;
-}
-/** Keeps only the classified entries the scope covers. No scope keeps all. */
-export function scopeClassified(classified, scope) {
-    if (scope === undefined)
-        return classified;
-    const names = new Set(scope.patches);
-    return classified.filter((entry) => isInScope(entry, names));
-}
-/** Keeps only the ownership rows with an owner in scope. No scope keeps all. */
-export function scopeOwnershipRows(rows, scope) {
-    if (scope === undefined)
-        return rows;
-    const names = new Set(scope.patches);
-    return rows.filter((row) => row.owners.some((owner) => names.has(owner)));
-}
-/**
- * Builds the ownership rows from the full scan (classification needs every
- * file to find claims), then narrows them to the scope.
- */
-export async function collectScopedOwnershipRows(patchesDir, files, classified, scope) {
-    const rows = await collectOwnershipRows(patchesDir, (await loadPatchesManifest(patchesDir))?.patches ?? [], files, classified);
-    return scopeOwnershipRows(rows, scope);
-}
-/** The paths the `ownership-conflict` check class judges. */
-export function ownershipConflictPaths(rows) {
-    return rows.filter((row) => row.conflict).map((row) => row.path);
-}

package/dist/src/commands/status.d.ts

@@ -1,11 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-import type { StatusOptions } from '../types/commands/index.js';
-/**
- * Runs the status command to show modified files.
- * @param projectRoot - Root directory of the project
- * @param options - Status display options
- */
-export declare function statusCommand(projectRoot: string, options?: StatusOptions): Promise<void>;
-/** Registers the status command on the CLI program. */
-export declare function registerStatus(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/test-appdir.d.ts

@@ -1,6 +0,0 @@
-/**
- * Resolves and appends an xpcshell `--app-path=<abs>` argument when the
- * selected manifest requests a browser appdir that rebranded forks otherwise
- * fail to discover.
- */
-export declare function maybeInjectAppdirArg(engineDir: string, normalizedPaths: readonly string[], objDir: string | undefined, extraArgs: string[]): Promise<boolean>;

package/dist/src/commands/test-appdir.js

@@ -1,29 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { operatorAlreadySetAppPath, resolveXpcshellAppdirArg, } from '../core/xpcshell-appdir.js';
-import { info, warn } from '../utils/logger.js';
-/**
- * Resolves and appends an xpcshell `--app-path=<abs>` argument when the
- * selected manifest requests a browser appdir that rebranded forks otherwise
- * fail to discover.
- */
-export async function maybeInjectAppdirArg(engineDir, normalizedPaths, objDir, extraArgs) {
-    if (!objDir)
-        return false;
-    if (operatorAlreadySetAppPath(extraArgs))
-        return false;
-    const outcome = await resolveXpcshellAppdirArg(engineDir, normalizedPaths, objDir);
-    switch (outcome.kind) {
-        case 'none':
-            return false;
-        case 'mismatch':
-            warn(`xpcshell appdir auto-injection skipped — multiple test paths resolved to different app dirs (${outcome.values.join(', ')}). Pass --mach-arg=--app-path=<abs> to disambiguate.`);
-            return false;
-        case 'unresolved':
-            warn(`xpcshell appdir auto-injection skipped — manifest at ${outcome.manifestPath} requests appdir "${outcome.relativeAppdir}" but no matching directory exists under ${objDir}/dist/. Build artifacts may be stale.`);
-            return false;
-        case 'injected':
-            extraArgs.push(`--app-path=${outcome.result.appPath}`);
-            info(`xpcshell appdir auto-injected: --app-path=${outcome.result.appPath} (from ${outcome.result.manifestPath} firefox-appdir=${outcome.result.relativeAppdir}).`);
-            return true;
-    }
-}

package/dist/src/commands/test-browser-preflight.d.ts

@@ -1,28 +0,0 @@
-import type { TestOptions } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-/**
- * Runs the `--doctor` marionette handshake probe. With no test paths the
- * probe is the entire command (returns `'stop'` after reporting). With
- * paths it gates the mach invocation, where a FAIL throws before mach runs.
- */
-export declare function runDoctorPreflight(args: {
-    engineDir: string;
-    effectivePort: number | undefined;
-    hasTestPaths: boolean;
-    objDir: string | undefined;
-    binaryName: string;
-    launchablePath: string | undefined;
-}): Promise<'stop' | 'continue'>;
-/**
- * Auto-forwards `--marionette-port` to mach (`--setpref=marionette.port`
- * for the listener, `--marionette=127.0.0.1:<n>` for the mochitest
- * client), skipping each piece the operator already forwarded via
- * `--mach-arg` and the xpcshell flavor that ignores the pref entirely.
- * Mutates `extraArgs` in place.
- */
-export declare function appendMarionetteForwardingArgs(extraArgs: string[], options: TestOptions, forwardedPort: number | undefined, xpcshellOnly?: boolean): void;
-/** Prepares profile overlays and browser/port ownership preconditions. */
-export declare function ensureTestBrowserEnvironment(engineDir: string, launchablePath: string | undefined, xpcshellOnly: boolean, projectConfig: FireForgeConfig, options: TestOptions, objDir: string | undefined): Promise<{
-    forwardedPort: number | undefined;
-    effectivePort: number | undefined;
-}>;

package/dist/src/commands/test-browser-preflight.js

@@ -1,197 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { reportOrphanedHarnessProcesses } from '../core/harness-orphans.js';
-import { deferBusyPortToHarness, resolveAutoPorts } from '../core/harness-port-fallback.js';
-import { assertMarionettePortAvailable, DEFAULT_MARIONETTE_PORT, ensureLaunchableBrowserNotRunning, ensureMarionettePortAvailable, extractForwardedMarionettePort, forwardedMachArgsIncludeMarionetteClient, shouldAutoForwardMarionettePortToMach, } from '../core/marionette-port.js';
-import { formatMarionettePreflightLine, reportMarionettePreflight, runMarionettePreflight, } from '../core/marionette-preflight.js';
-import { DEFAULT_MOCHITEST_SERVER_PORT, ensureMochitestServerPortAvailable, } from '../core/mochitest-server-port.js';
-import { waitForPreflight } from '../core/preflight-wait.js';
-import { GeneralError } from '../errors/base.js';
-import { info, outro, verbose } from '../utils/logger.js';
-import { resolveWaitLockSeconds } from '../utils/options.js';
-import { addVerdictRunCount, emitFailVerdict, emitPassVerdict } from './test-verdict.js';
-/**
- * Runs the `--doctor` marionette handshake probe. With no test paths the
- * probe is the entire command (returns `'stop'` after reporting). With
- * paths it gates the mach invocation, where a FAIL throws before mach runs.
- */
-export async function runDoctorPreflight(args) {
-    const { engineDir, effectivePort, hasTestPaths, objDir, binaryName, launchablePath } = args;
-    // Non-TTY captures need the banner even if clack's renderer defers output
-    // in pipe mode. TTY users need the clack framing. Gated rather than
-    // written twice: the unconditional pair printed the same line twice on a
-    // terminal.
-    if (process.stdout.isTTY) {
-        info('Running marionette preflight...');
-    }
-    else {
-        process.stdout.write('Running marionette preflight...\n');
-    }
-    const preflight = effectivePort !== undefined
-        ? await runMarionettePreflight(engineDir, { port: effectivePort })
-        : await runMarionettePreflight(engineDir);
-    // The authoritative PASS/FAIL line is written with `process.stdout.write`
-    // as the first output after the probe returns, because clack's renderer
-    // can drop the summary under non-TTY capture.
-    //
-    // Gated on non-TTY: unconditional, it stacks with the two clack renderings
-    // below and the same line appears three times on a terminal. Captured
-    // streams are exactly where this branch still fires.
-    const directLine = formatMarionettePreflightLine(preflight);
-    if (!process.stdout.isTTY) {
-        process.stdout.write(`${directLine}\n`);
-    }
-    process.stdout.write(`Marionette preflight environment: objdir=${objDir ?? '(none)'}; binary=${binaryName}; app=${launchablePath ? `engine/${launchablePath}` : '(unknown)'}; port=${effectivePort ?? 2828}; elapsed=${preflight.durationMs}ms\n`);
-    reportMarionettePreflight(preflight);
-    if (!hasTestPaths) {
-        if (!preflight.ok) {
-            emitFailVerdict('preflight');
-            throw new GeneralError('Marionette preflight reported FAIL — see output above.');
-        }
-        // Doctor-only runs end here, so they carry their own verdict line
-        // (reason=preflight on failure). With test paths the verdict comes
-        // from the actual harness run downstream.
-        emitPassVerdict();
-        outro('Test completed');
-        return 'stop';
-    }
-    if (!preflight.ok) {
-        emitFailVerdict('preflight');
-        throw new GeneralError('Marionette preflight reported FAIL — see output above. Aborting before mach test runs.');
-    }
-    return 'continue';
-}
-/**
- * Auto-forwards `--marionette-port` to mach (`--setpref=marionette.port`
- * for the listener, `--marionette=127.0.0.1:<n>` for the mochitest
- * client), skipping each piece the operator already forwarded via
- * `--mach-arg` and the xpcshell flavor that ignores the pref entirely.
- * Mutates `extraArgs` in place.
- */
-export function appendMarionetteForwardingArgs(extraArgs, options, forwardedPort, xpcshellOnly = false) {
-    // Auto-forward the Marionette port to mach when `--marionette-port` is set.
-    // `--setpref=marionette.port=<n>` configures where the browser listener
-    // binds. `--marionette=127.0.0.1:<n>` tells the mochitest harness client to
-    // connect there (default client is 127.0.0.1:2828). xpcshell ignores both
-    // for browser Marionette.
-    //
-    // Skip setpref forwarding when the operator already supplied an equivalent
-    // arg via `--mach-arg`: duplicates would confuse without changing
-    // semantics. Skip when mach args explicitly request `--flavor=xpcshell` (or
-    // `xpcshell-tests`): the preflight still honours `--marionette-port`, but
-    // mach does not use the marionette.port pref on that harness. Any other arg
-    // shape still forwards so toolkit widget paths and mixed suites stay
-    // aligned with the probe without duplicate `--mach-arg` flags.
-    //
-    // Skip auto `--marionette=...` when `--mach-arg` already includes a client
-    // `--marionette=...` (or two-token `--marionette host:port`).
-    if (options.marionettePort === undefined)
-        return;
-    if (xpcshellOnly) {
-        // Manifest classification says every requested path is xpcshell.
-        // xpcshell ignores the browser Marionette path entirely, and forwarding
-        // the mochitest client flags here makes mach reject the dispatch.
-        info(`--marionette-port=${options.marionettePort} applied to the preflight probe only: the requested paths are xpcshell-only, and xpcshell ignores the browser Marionette port. Not forwarding --setpref=marionette.port or --marionette to mach.`);
-        return;
-    }
-    {
-        const operatorAlreadyForwarded = forwardedPort !== undefined;
-        const machArgs = options.machArg ?? [];
-        if (operatorAlreadyForwarded) {
-            info(`--marionette-port=${options.marionettePort} set, but the same port is already forwarded via --mach-arg; skipping auto-forward.`);
-        }
-        else if (shouldAutoForwardMarionettePortToMach(machArgs)) {
-            extraArgs.push(`--setpref=marionette.port=${options.marionettePort}`);
-        }
-        else {
-            info(`--marionette-port=${options.marionettePort} applied to the preflight probe, but --flavor=xpcshell is set — mach is not auto-configured with --setpref=marionette.port or --marionette (xpcshell ignores the browser Marionette path). Pass --mach-arg --setpref=marionette.port=${options.marionettePort} explicitly if you still need mach to see the port.`);
-        }
-        if (shouldAutoForwardMarionettePortToMach(machArgs) &&
-            !forwardedMachArgsIncludeMarionetteClient(machArgs)) {
-            extraArgs.push(`--marionette=127.0.0.1:${options.marionettePort}`);
-        }
-    }
-}
-async function ensureTestMarionettePortAvailable(port, binaryName, options, skip) {
-    // Refuse a stale listener before mach surfaces a generic bind failure.
-    // This also recognizes a fork-branded browser via binaryName.
-    if (skip.xpcshellOnly && !skip.doctor) {
-        // xpcshell does not bind the browser Marionette port, so a developer's
-        // interactive browser holding 2828 must not kill an xpcshell run.
-        // --doctor keeps the preflight: its probe launches a
-        // Marionette browser regardless of the requested harness.
-        const message = 'Skipping the Marionette stale-port preflight: all requested paths are xpcshell ' +
-            '(xpcshell does not bind the browser Marionette port).';
-        if (options.marionettePort !== undefined || options.killStaleMarionette === true) {
-            info(message);
-        }
-        else {
-            verbose(message);
-        }
-        return;
-    }
-    if (options.killStaleMarionette === true) {
-        await ensureMarionettePortAvailable(port, { binaryName, killStaleBrowser: true });
-        return;
-    }
-    await assertMarionettePortAvailable(port, { binaryName });
-}
-/** Prepares profile overlays and browser/port ownership preconditions. */
-export async function ensureTestBrowserEnvironment(engineDir, launchablePath, xpcshellOnly, projectConfig, options, objDir) {
-    // A timed-out mochitest can leave the built app alive after its Marionette
-    // listener has disappeared. The port probe cannot see that case, but the
-    // survivor can still steal focus and wedge every later headed run.
-    if (!xpcshellOnly && launchablePath) {
-        await waitForPreflight(() => ensureLaunchableBrowserNotRunning(join(engineDir, launchablePath), {
-            killStaleBrowser: options.killStaleMarionette === true,
-        }), options.waitBrowser === undefined ? undefined : resolveWaitLockSeconds(options.waitBrowser));
-    }
-    // Packaging-only runs must protect a running objdir, but do not bind any
-    // harness ports or launch tests, so peer listeners cannot block packaging.
-    if (options.buildOnly)
-        return { forwardedPort: undefined, effectivePort: undefined };
-    // A zombie mochitest httpd squatting the server port makes a fresh
-    // browser connect to a server that cannot serve this run's manifest,
-    // which surfaces as a 370s "Ran 0 checks" stall naming nothing. xpcshell
-    // does not use the httpd, so an xpcshell-only run is never blocked by it.
-    // Auto ports (opt-in) step aside for a peer's listener and let the
-    // harness's own busy-port fallback move this run; see
-    // src/core/harness-port-fallback.ts.
-    const autoPorts = xpcshellOnly
-        ? undefined
-        : await resolveAutoPorts(engineDir, options, projectConfig);
-    if (!xpcshellOnly &&
-        !(autoPorts?.serverPorts === true &&
-            (await deferBusyPortToHarness(DEFAULT_MOCHITEST_SERVER_PORT, 'Mochitest server', engineDir)))) {
-        await waitForPreflight(() => ensureMochitestServerPortAvailable(undefined, {
-            engineDir,
-            killStaleServer: options.killStaleMarionette === true,
-        }), options.waitPort === undefined ? undefined : resolveWaitLockSeconds(options.waitPort));
-    }
-    // Helpers that outlived an earlier run (httpd, pywebsocket, ssltunnel,
-    // moz-http2) slow every later run without appearing in its output. Both
-    // harnesses are affected, so this census is not gated on xpcshellOnly.
-    // Reaping is opt-in per invocation (--reap-orphans) or per repo
-    // (test.reapOrphans: "reap"); a reap is stamped on the verdict line so a
-    // green after one is not mistaken for a green on a quiet machine.
-    const census = await reportOrphanedHarnessProcesses(objDir, {
-        reap: options.reapOrphans === true || projectConfig.test?.reapOrphans === 'reap',
-    });
-    addVerdictRunCount('orphans-reaped', census.reaped);
-    const forwardedPort = options.machArg
-        ? extractForwardedMarionettePort(options.machArg)
-        : undefined;
-    const effectivePort = options.marionettePort ?? forwardedPort;
-    // Never under --doctor: its handshake launches a browser on this port
-    // itself and would talk to the peer's browser instead.
-    if (autoPorts?.marionettePort === true &&
-        options.doctor !== true &&
-        (await deferBusyPortToHarness(effectivePort ?? DEFAULT_MARIONETTE_PORT, 'Marionette', engineDir))) {
-        return { forwardedPort, effectivePort };
-    }
-    await waitForPreflight(() => ensureTestMarionettePortAvailable(effectivePort, projectConfig.binaryName, options, {
-        xpcshellOnly,
-        doctor: options.doctor === true,
-    }), options.waitPort === undefined ? undefined : resolveWaitLockSeconds(options.waitPort));
-    return { forwardedPort, effectivePort };
-}

package/dist/src/commands/test-build-furnace.d.ts

@@ -1,21 +0,0 @@
-/**
- * What a pre-test build did with Furnace components. `prepareBuildEnvironment`
- * runs `furnace apply` over the whole `components/` tree, so a
- * `fireforge test --build` meant to capture the committed behaviour could
- * silently ship component edits nobody had deployed yet (another session's
- * included). The applied names therefore ride the verdict line, and `--no-furnace-apply` packages `engine/` as it
- * stands, naming the undeployed edits it left out.
- */
-import type { BuildPreparation } from '../core/build-prepare.js';
-/**
- * Reports the pre-test build's Furnace step: the components it deployed
- * (notice plus `furnace-applied=<names>` on the verdict line), or, when the
- * apply was skipped, the components whose undeployed edits this build
- * leaves out (`furnace-apply=skipped`).
- *
- * @param projectRoot - Root directory of the project
- * @param preparation - Result of `prepareBuildEnvironment`
- * @param skipped - True under `--no-furnace-apply` / `--furnace-apply none`
- * @param unreached - Components `--furnace-apply reached` left out
- */
-export declare function reportPreTestFurnace(projectRoot: string, preparation: BuildPreparation, skipped: boolean, unreached?: readonly string[]): Promise<void>;

package/dist/src/commands/test-build-furnace.js

@@ -1,53 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * What a pre-test build did with Furnace components. `prepareBuildEnvironment`
- * runs `furnace apply` over the whole `components/` tree, so a
- * `fireforge test --build` meant to capture the committed behaviour could
- * silently ship component edits nobody had deployed yet (another session's
- * included). The applied names therefore ride the verdict line, and `--no-furnace-apply` packages `engine/` as it
- * stands, naming the undeployed edits it left out.
- */
-import { listStaleFurnaceComponents } from '../core/furnace-staleness.js';
-import { toError } from '../utils/errors.js';
-import { notice, verbose } from '../utils/logger.js';
-import { setVerdictRunAttribute } from './test-verdict.js';
-/**
- * Reports the pre-test build's Furnace step: the components it deployed
- * (notice plus `furnace-applied=<names>` on the verdict line), or, when the
- * apply was skipped, the components whose undeployed edits this build
- * leaves out (`furnace-apply=skipped`).
- *
- * @param projectRoot - Root directory of the project
- * @param preparation - Result of `prepareBuildEnvironment`
- * @param skipped - True under `--no-furnace-apply` / `--furnace-apply none`
- * @param unreached - Components `--furnace-apply reached` left out
- */
-export async function reportPreTestFurnace(projectRoot, preparation, skipped, unreached) {
-    if (skipped) {
-        setVerdictRunAttribute('furnace-apply', 'skipped');
-        let pending = [];
-        try {
-            pending = await listStaleFurnaceComponents(projectRoot);
-        }
-        catch (error) {
-            verbose(`Furnace pending-edit probe failed: ${toError(error).message}`);
-        }
-        notice(pending.length > 0
-            ? `Furnace apply skipped (--no-furnace-apply): engine/ is packaged as it stands. ${pending.length} component(s) with undeployed components/ edits are NOT in this build: ${pending.join(', ')}.`
-            : 'Furnace apply skipped (--no-furnace-apply): engine/ is packaged as it stands.');
-        return;
-    }
-    if (unreached !== undefined && unreached.length > 0) {
-        setVerdictRunAttribute('furnace-skipped', unreached.join(','));
-        notice(`--furnace-apply reached: ${unreached.length} component(s) with undeployed components/ ` +
-            `edits that no requested test reaches are NOT in this build: ${unreached.join(', ')}.`);
-    }
-    const applied = preparation.furnaceAppliedNames ?? [];
-    if (applied.length === 0)
-        return;
-    setVerdictRunAttribute('furnace-applied', applied.join(','));
-    notice(`This pre-test build deployed ${applied.length} Furnace component(s) whose components/ source ` +
-        `changed since their last deploy: ${applied.join(', ')}. Those edits (another session's ` +
-        'undeployed edits included) are in the runtime under test. Pass --no-furnace-apply to ' +
-        'package engine/ as it stands, for example for a before-capture.');
-}

package/dist/src/commands/test-build-phase.d.ts

@@ -1,34 +0,0 @@
-/**
- * Pre-test build phase for `fireforge test`, split out of `test.ts` (at
- * the per-file line budget): the incremental protected mach build with
- * its baseline write, and the `--build-only` union-build shape.
- */
-import type { ControlBuildStamp } from '../core/build-baseline-types.js';
-import type { TestOptions } from '../types/commands/index.js';
-import type { FireForgeConfig, ProjectPaths } from '../types/config.js';
-import type { HarnessClassification } from './test-modes.js';
-/**
- * Runs the pre-test build (or the stale-build gate when no build was
- * requested). Returns `true` when the run is complete: the `--build-only`
- * union-build shape, which packages every requested path
- * (mixed harnesses legal, nothing dispatches), prints the per-harness
- * next steps, and emits the run's single `PASS` verdict.
- */
-export declare function runTestBuildPhase(projectRoot: string, paths: ProjectPaths, projectConfig: FireForgeConfig, harnessRetries: number, options: TestOptions, request: {
-    classification: HarnessClassification;
-    normalizedPaths: string[];
-    /** Forces a full pre-test build (a compiled negative control). */
-    fullBuildReason?: string;
-    /** Recorded on the pre-test build's baseline (a compiled negative control). */
-    controlBuild?: ControlBuildStamp;
-    /**
-     * The stamp this invocation's own control build recorded, which a
-     * build-less run after it accepts (see `TestRunHooks.ownControlBuild`).
-     */
-    ownControlBuild?: ControlBuildStamp;
-    /**
-     * Engine-relative launchable binary: anchors the stale-compiled check,
-     * which refuses a build-less run and escalates a `--build` one.
-     */
-    launchablePath?: string | undefined;
-}): Promise<boolean>;