@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,181 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { Command } from 'commander';
-import { withEngineSessionLock } from '../core/engine-session-lock.js';
-import { GeneralError, LockContentionError } from '../errors/base.js';
-import { addWaitLockOption, commanderArgParser, pickDefined, resolveWaitLockSeconds, stringListOption, } from '../utils/options.js';
-import { parsePositiveIntegerFlag } from '../utils/validation.js';
-import { testCommand } from './test.js';
-import { DEFAULT_HARNESS_RETRIES } from './test-run.js';
-import { emitFailVerdict, resetVerdictEmission, verdictEmitted } from './test-verdict.js';
-const TEST_HELP_TEXT = [
-    '',
-    '[paths...] semantics: a directory argument selects EXACTLY that',
-    'directory. FireForge enumerates the test files of exactly that',
-    'directory and passes the explicit file list to mach, because mach',
-    'resolves test paths by string prefix and a bare directory name',
-    'silently sweeps in sibling directories sharing the prefix (e.g.',
-    'foo also running foo-extras) — an explicit file list cannot',
-    'prefix-match anything. The directory still runs as ONE mach',
-    'invocation (one browser instance), so cross-file state carries',
-    'within it. When prefix-named siblings exist, the excluded',
-    'directories are listed with their test-file counts; pass them as',
-    'separate paths to include them.',
-    '',
-    'Multiple path arguments shard into sequential isolated harness',
-    'runs (one browser instance per argument) by default, which does',
-    'not exercise cross-argument state; --no-shard restores the',
-    'combined single-instance invocation.',
-    '',
-    'Mixed xpcshell and browser/mochitest paths run as two consecutive',
-    'mach invocations (xpcshell first) under one lock hold and one',
-    'verdict; with --build, one pre-test build packages both halves.',
-    '--repeat <n> and --negative-control <diff> run under one lock hold',
-    'too. Each sub-run prints a FIREFORGE-RUN: line (its own verdict',
-    'plus run=<i>/<n>) before the single aggregate verdict.',
-    '',
-    'A dev objdir symlinks chrome JS/CSS and widget files into engine/,',
-    'so the browser reads engine/ sources when it loads them, after the',
-    'build step: an edit made while a suite runs reaches that suite, and',
-    'a hand-made neuter must stay until the verdict line, not until',
-    '"Build complete", since one restored early is gone for later',
-    'shards. --negative-control applies its diff after the build and',
-    'restores it byte-exact only after the run, before the lock is',
-    'released.',
-    '',
-    'Machine-readable verdict: every run (single, sharded, --canary,',
-    '--doctor) ends with exactly one raw stdout line',
-    '  FIREFORGE-VERDICT: PASS|FAIL [reason=crash|server-startup|harness-arguments|',
-    '  test-failures|no-tests|preflight|inconclusive|lock-timeout|killed] [checks=<n>]',
-    '  [unexpected=<n>] [started=<n>/<m> first-unstarted=<path>]',
-    '  [shards=<p>/<t>] [(<note>)] [shuffle=<seed>]',
-    '  [runs=<p>/<n>] [control=caught|missed|inconclusive]',
-    '  [furnace-applied=<names>|furnace-apply=skipped] [log=<path>]',
-    "control= is a negative control's outcome: caught (went red on test",
-    'failures, as a control should; exit 0), missed (stayed green; exit',
-    '5) or inconclusive.',
-    'shuffle=<seed> is the seed a --shuffle run exported to the harness.',
-    "log=<path> names this run's complete output, written to",
-    '.fireforge/logs/ as the run streams, so a piped or truncated run',
-    'still leaves a re-readable artifact.',
-    'The status follows the harness classifier, not the raw exit code:',
-    'a crash-classified run says FAIL reason=crash even at exit 0, and',
-    'a green-summary-override pass says PASS despite a non-zero mach',
-    'exit. An exit-0 run is still FAIL reason=test-failures when its',
-    'summary reports unexpected results, the browser shut down mid-test,',
-    'or a requested file never started; started=/first-unstarted= then',
-    'name how far it got and where a re-run has to pick up.',
-    'reason=preflight covers any failure before the harness ran',
-    '(missing/stale build, invalid paths, port conflicts, config',
-    'errors); reason=inconclusive means engine/ or perf power source',
-    'changed while tests ran, so the result cannot be trusted;',
-    'reason=lock-timeout means the run never started because another',
-    'engine-mutating command held the lock past the wait budget;',
-    'reason=killed means a signal terminated the run before it reached',
-    'any other outcome (written from the signal handler). A sharded',
-    'aggregate reason is the most structural failing shard (crash,',
-    'then no-tests, then test-failures). Count keys are omitted when',
-    'the embedded summary did not print them. A trailing parenthetical',
-    'is an advisory note, never part of the status: "(harness teardown',
-    'noise ignored)" marks a clean suite whose only residue was the',
-    'recognized upstream mozsystemmonitor teardown traceback, and',
-    '"(headed run stalled with the display asleep)" marks a no-output',
-    'stall whose display was measured asleep. Key on this line',
-    'instead of mach internals.',
-    '',
-    'Lock-free checks run before the engine lock is requested: a missing',
-    'launchable binary (with the build that left it missing, when one is',
-    'recorded), the named-file checkJs pass of --build, and the',
-    '--wait-browser/--wait-port budgets. Each is re-checked once under the',
-    'lock; the checks after a pre-test build or an earlier run of the',
-    'sequence wait the budgets out again.',
-].join('\n');
-function registerTestMultiRunOptions(test) {
-    return test
-        .option('--repeat <n>', 'Run the same paths n times under one engine-lock hold (a --build builds once); prints each run and aggregates runs=<passed>/<n> on the verdict', commanderArgParser((raw) => parsePositiveIntegerFlag('--repeat', raw)))
-        .option('--negative-control <diff>', 'Apply this reviewed git diff (engine/ or components/ sources; project-relative path) after the pre-test build and right before dispatch, restore it byte-exact after the run (also on failure, SIGINT and SIGTERM) before the lock is released, and report control=caught|missed|inconclusive on the verdict')
-        .option('--auto-ports', "Let a browser run proceed when the mochitest server or Marionette port is held by something that is not this checkout's own: the engine's harness falls back to a free port itself. Same as test.mochitestPorts: \"auto\". This checkout's own leftovers are still refused.");
-}
-function registerTestSharingOptions(test) {
-    return test
-        .option('--wait-browser [seconds]', 'Wait for this objdir browser before any deployment/build (default 60)', commanderArgParser((raw) => resolveWaitLockSeconds(raw)))
-        .option('--wait-port [seconds]', 'Wait for the mochitest and Marionette ports (default 60)', commanderArgParser((raw) => resolveWaitLockSeconds(raw)))
-        .option('--restart-between-tests', "Forward mochitest's --restart-between-tests: restart the browser between test files to expose undocumented cross-file dependencies (the shape a manifest's standalone key asks for). Mochitest dispatch only.")
-        .option('--keep-log <path>', "Also write this run's log to <path> (a directory receives it under its own name), outside .fireforge/logs/ retention. FIREFORGE_LOG_KEEP sets a session default.")
-        .option('--profile-file <source=destination>', 'Merge a file into the harness profile, e.g. sheet.css=chrome/userChrome.css. Repeatable.', ...stringListOption());
-}
-/** Pre-test build options that shape the coverage claim and the Furnace step. */
-function registerTestBuildOptions(test) {
-    return test
-        .option('--extend-coverage', 'With --build/--build-only and explicit paths, refuse instead of dropping any earlier packaging claim. Scoped builds keep each earlier path by default while its own staging inputs (manifest directory and the fixtures its manifest names) and engine/mozconfig are unchanged; this flag turns a drop into a refusal before the build.')
-        .option('--furnace-apply <mode>', 'With --build/--build-only: all (default; deploy every component with undeployed edits), reached (only components a requested test names; the rest are reported as furnace-skipped=<names>), or none. Same as test.furnaceApply.', commanderArgParser((raw) => {
-        if (raw !== 'all' && raw !== 'reached' && raw !== 'none') {
-            throw new GeneralError(`--furnace-apply must be all, reached or none (got "${raw}")`);
-        }
-        return raw;
-    }))
-        .option('--no-furnace-apply', 'With --build/--build-only, skip the Furnace apply so the build packages engine/ as it stands; names the components whose undeployed components/ edits it leaves out (same as --furnace-apply none)');
-}
-/** Options that run a request on several harness instances, or judge it per file. */
-function registerTestParallelOptions(test) {
-    return test
-        .option('--jobs <n>', 'Run shards on n harness instances at once inside one lock hold, each with its own profile, Marionette port and (via auto ports) server ports. With --no-shard, or one directory argument, the files are split in order into n contiguous chunks. Prints a FIREFORGE-SHARD line per shard and one aggregate verdict. Requires --auto-ports or test.mochitestPorts: "auto".', commanderArgParser((raw) => parsePositiveIntegerFlag('--jobs', raw)))
-        .option('--shard-size <n>', 'Dispatch n files per mach invocation (mochitest restarts the browser between files) and judge each file from the structured log: shards= then counts files and failed-shards= names failed files. Combines with --jobs.', commanderArgParser((raw) => parsePositiveIntegerFlag('--shard-size', raw)))
-        .option('--results <path>', 'Write a JSON record per test file and --repeat run (status, expected, duration, run-log line) from the mozlog structured log, and name it on the verdict as results=<path>')
-        .option('--shared-lock', 'Hold the engine session lock shared when this run is build-less, applies no negative control and uses auto ports, so peers\' build-less runs on this objdir overlap; builds and re-exports still wait. Same as test.lockMode: "shared".');
-}
-/** Registers the test command on the CLI program. */
-export function registerTest(program, { getProjectRoot, withErrorHandling }) {
-    const test = program
-        .command('test [paths...]')
-        .description('Run tests via mach test')
-        .option('--headless', 'Run tests in headless mode')
-        .option('--full-output', "Pass mozbuild's full verbosity through for the TEST phase. mozbuild quiets terminal output to warnings and errors when it detects a coding agent, which removes TEST_START and console INFO — the lines a hang or stall diagnosis needs. This unsets that detection for test dispatches only; the build phase stays quiet.")
-        .option('--build', 'Run incremental UI build before testing')
-        .option('--build-only', 'Run the scoped pre-test build (packaging exactly [paths...], mixed harnesses allowed) and exit without dispatching tests — one build covers both harness halves, then run each half without --build')
-        .option('--refuse-unexported-drift', 'With --build/--build-only, refuse (instead of warning) when the pre-test build would overwrite engine content recorded in neither a patch body nor the pristine baseline — the same belt as "fireforge build --refuse-unexported-drift", armable from the scripted "test --build" shape the hazard actually shows up in')
-        .option('--auto', 'Forward mach test --auto. Valid only when no explicit paths are provided.')
-        .option('--allow-stale-build', 'Allow tests to run even when packageable engine files changed since the last successful FireForge build')
-        .option('--allow-stale-components', 'Run tests despite components.conf changes that only a full "fireforge build" compiles in (the packaged child process will resolve the OLD StaticComponents table)')
-        .option('--kill-stale-marionette', "Terminate a recognized stale browser from this objdir, one holding the Marionette port, or this checkout's own leftover mochitest httpd before running tests. Never touches another checkout's live harness.")
-        .option('--reap-orphans', 'Terminate harness helper processes (httpd, pywebsocket, ssltunnel, moz-http2) from this objdir that survived an earlier run. The census itself runs on every test dispatch and is report-only; this flag (or test.reapOrphans: "reap" in fireforge.json) opts into the kill. Reaps are stamped on the verdict line as orphans-reaped=<n>.')
-        .option('--pgid-file <path>', 'Write the harness process-group id (mach is the group leader) to this file on every spawn, so a supervisor that had to SIGKILL fireforge can still take the whole harness tree with "kill -- -$(cat <path>)". Removed when the run ends normally.')
-        .option('--canary [path]', 'Run one short browser-chrome harness canary. Uses test.canaryPath from fireforge.json when no path is supplied.')
-        .option('--doctor', 'Run a marionette handshake preflight before tests (exit 1 on FAIL). With no paths, runs the preflight only.')
-        .option('--mach-arg <arg>', 'Forward this argument verbatim to `mach test` (repeatable). Escape valve for upstream xpcshell/mochitest flags FireForge does not model.', ...stringListOption())
-        .option('--shuffle [seed]', 'Shuffle isolated mochitest path arguments in a repeatable seeded order (fresh seed when omitted). Native mach --shuffle within each invocation remains unseeded. Export FIREFORGE_SHUFFLE_SEED for custom task code and stamp shuffle=<seed> on the verdict. --no-shard disables the seeded argument permutation. A path-shaped argument right after the flag (browser_x.js, dir/) is a test path, not a seed.', commanderArgParser((raw) => parsePositiveIntegerFlag('--shuffle', raw)))
-        .option('--harness-retries <n>', `Retry budget for recognized harness crashes (resource-monitor tracebacks, pre-test hangs, post-green shutdown re-entry). 0 disables retries. Default: ${DEFAULT_HARNESS_RETRIES}.`, commanderArgParser((raw) => {
-        const n = Number.parseInt(raw, 10);
-        if (!Number.isFinite(n) || n < 0 || n > 10) {
-            throw new GeneralError(`--harness-retries must be an integer in 0..10 (got "${raw}")`);
-        }
-        return n;
-    }))
-        .option('--generic-mach-test', 'Force dispatch through generic `mach test` instead of the suite-specific `mach xpcshell-test` / `mach mochitest` a single-suite run auto-selects (the suite-specific commands skip the mozlog resource monitor that crashes `mach test` on some hosts).')
-        .option('--no-shard', 'Run multiple test paths in one combined mach invocation instead of sequential per-file shards (isolated instances do not exercise cross-file state, so use this to reproduce cross-file pollution bugs)')
-        .option('--perf-samples <path>', 'Publish a perf-sample artifact path to the harness via <BINARYNAME>_PERF_SAMPLE_JSON (resolved against the project root)')
-        .option('--marionette-port <port>', 'Override the Marionette control port (default 2828) for the stale-browser probe, the --doctor preflight, and (unless --mach-arg includes --flavor=xpcshell) auto-forwarded mach args: --setpref=marionette.port=<n> (browser listener) and --marionette=127.0.0.1:<n> (mochitest client). Omits the client flag when --mach-arg already sets --marionette. Use when 2828 is busy or CI assigns another port.', commanderArgParser((raw) => {
-        const n = Number.parseInt(raw, 10);
-        if (!Number.isFinite(n) || n < 1 || n > 65535) {
-            throw new GeneralError(`--marionette-port must be an integer in 1..65535 (got "${raw}")`);
-        }
-        return n;
-    }))
-        .addHelpText('after', TEST_HELP_TEXT);
-    addWaitLockOption(registerTestParallelOptions(registerTestBuildOptions(registerTestMultiRunOptions(registerTestSharingOptions(test))))).action(withErrorHandling(async (paths, options) => {
-        const projectRoot = getProjectRoot();
-        // Fallback for a verdict testCommand did not emit (it takes the lock).
-        resetVerdictEmission();
-        try {
-            await testCommand(projectRoot, paths, pickDefined(options), (body, mode) => withEngineSessionLock(projectRoot, 'test', body, {
-                waitLockSeconds: resolveWaitLockSeconds(options.waitLock),
-                ...(mode === 'shared' ? { mode } : {}),
-            }));
-        }
-        catch (error) {
-            if (!verdictEmitted()) {
-                emitFailVerdict(error instanceof LockContentionError ? 'lock-timeout' : 'preflight');
-            }
-            throw error;
-        }
-    }));
-}

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

@@ -1,71 +0,0 @@
-/**
- * `fireforge test --results <path>`: one record per test file and per
- * `--repeat` run, from the mozlog raw log each dispatch writes.
- *
- * Gates and retry wrappers downstream named a run's failing files by
- * reading `TEST_START`/`TEST_END` lines and the prose of the "sharded test
- * run(s) did not pass" error out of the human log, which nothing promised
- * to keep stable. The results file is the stable form: JSON with a
- * `schemaVersion`, written once the invocation has finished, and named on
- * the verdict line as `results=<path>`.
- */
-import type { RawTestResult } from '../core/test-raw-log.js';
-/** One file's result in one dispatch. */
-export interface TestFileResult extends RawTestResult {
-    /** `--repeat` run (1-based); 1 for a single run. */
-    run: number;
-    /** The shard (path argument or `--shard-size` chunk) the file ran in. */
-    shard: string;
-    /** Line of the run log where this file's dispatch began (1-based). */
-    logLine: number;
-    /**
-     * The shard's dispatched files, on a harness pseudo-record only (see
-     * {@link HARNESS_PSEUDO_TEST}).
-     */
-    shardFiles?: string[];
-    /** The shard's one file, on a harness pseudo-record of a one-file shard. */
-    file?: string;
-}
-/** The document `--results` writes. */
-export interface TestResultsDocument {
-    schemaVersion: 1;
-    /** Files in dispatch-completion order. */
-    files: TestFileResult[];
-    /** Started files that never ended, per dispatch. */
-    unfinished: Array<{
-        test: string;
-        run: number;
-        shard: string;
-    }>;
-}
-/** Clears the collector at the start of an invocation. */
-export declare function resetTestResults(): void;
-/**
- * Adds one dispatch's parsed raw log to the invocation's results.
- *
- * @param results - The dispatch's finished files
- * @param unfinished - Its started-but-unfinished files
- * @param context - Run, shard and run-log line of the dispatch, and the
- *   shard's dispatched files for harness pseudo-records
- */
-export declare function recordTestResults(results: readonly RawTestResult[], unfinished: readonly string[], context: {
-    run: number;
-    shard: string;
-    logLine: number;
-    shardFiles?: readonly string[];
-}): void;
-/** The results collected so far (for tests and the shard summary). */
-export declare function collectedTestResults(): TestResultsDocument;
-/**
- * Writes the collected results.
- *
- * @param path - Destination of `--results`
- */
-export declare function writeTestResults(path: string): Promise<void>;
-/**
- * Creates the scratch directory the dispatches' raw logs go to, runs
- * `body`, and removes it afterwards.
- *
- * @param body - Receives the directory
- */
-export declare function withRawLogDir<T>(body: (dir: string) => Promise<T>): Promise<T>;

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

@@ -1,79 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge test --results <path>`: one record per test file and per
- * `--repeat` run, from the mozlog raw log each dispatch writes.
- *
- * Gates and retry wrappers downstream named a run's failing files by
- * reading `TEST_START`/`TEST_END` lines and the prose of the "sharded test
- * run(s) did not pass" error out of the human log, which nothing promised
- * to keep stable. The results file is the stable form: JSON with a
- * `schemaVersion`, written once the invocation has finished, and named on
- * the verdict line as `results=<path>`.
- */
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { writeJson } from '../utils/fs.js';
-/**
- * The `test` id mozlog gives a result the harness itself reports, such as
- * the no-output TIMEOUT of a hung browser: a record that names no test
- * file. It keeps that id, and gains the shard's files so a consumer can
- * attribute it without matching `shard` labels back to paths.
- */
-const HARNESS_PSEUDO_TEST = 'automation.py';
-let collected = { schemaVersion: 1, files: [], unfinished: [] };
-/** Clears the collector at the start of an invocation. */
-export function resetTestResults() {
-    collected = { schemaVersion: 1, files: [], unfinished: [] };
-}
-/**
- * Adds one dispatch's parsed raw log to the invocation's results.
- *
- * @param results - The dispatch's finished files
- * @param unfinished - Its started-but-unfinished files
- * @param context - Run, shard and run-log line of the dispatch, and the
- *   shard's dispatched files for harness pseudo-records
- */
-export function recordTestResults(results, unfinished, context) {
-    const { shardFiles, ...dispatch } = context;
-    for (const result of results) {
-        collected.files.push({ ...result, ...dispatch, ...harnessRecordFiles(result, shardFiles) });
-    }
-    for (const test of unfinished) {
-        collected.unfinished.push({ test, run: context.run, shard: context.shard });
-    }
-}
-/** The `shardFiles`/`file` keys a harness pseudo-record gains. */
-function harnessRecordFiles(result, shardFiles) {
-    if (result.test !== HARNESS_PSEUDO_TEST || shardFiles === undefined)
-        return {};
-    const only = shardFiles.length === 1 ? shardFiles[0] : undefined;
-    return { shardFiles: [...shardFiles], ...(only === undefined ? {} : { file: only }) };
-}
-/** The results collected so far (for tests and the shard summary). */
-export function collectedTestResults() {
-    return collected;
-}
-/**
- * Writes the collected results.
- *
- * @param path - Destination of `--results`
- */
-export async function writeTestResults(path) {
-    await writeJson(path, collectedTestResults());
-}
-/**
- * Creates the scratch directory the dispatches' raw logs go to, runs
- * `body`, and removes it afterwards.
- *
- * @param body - Receives the directory
- */
-export async function withRawLogDir(body) {
-    const dir = await mkdtemp(join(tmpdir(), 'fireforge-raw-log-'));
-    try {
-        return await body(dir);
-    }
-    finally {
-        await rm(dir, { recursive: true, force: true });
-    }
-}

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

@@ -1,89 +0,0 @@
-/**
- * Run orchestration for `fireforge test`: bounded harness-crash retries and
- * sequential per-file sharding of multi-path invocations.
- *
- * Sharding exists because passing several browser-chrome files to one mach
- * invocation destabilizes later files: cross-file profile/pref bleed in the
- * shared mochitest profile makes the second file time out at window-open
- * while each file passes in isolation. Sequential single-file harness runs
- * cost startup time but make results reproducible. The combined invocation
- * stays available via `--no-shard`.
- */
-import { type DisplaySleepState } from '../core/display-state.js';
-import { type HarnessServerPorts } from '../core/harness-port-reservation.js';
-import { type MachCommandResult } from '../core/mach.js';
-import { type HarnessRunVerdict } from '../core/test-harness-crash.js';
-import { type RawTestResult } from '../core/test-raw-log.js';
-/** Default bounded retry budget for recognized harness crashes. */
-export declare const DEFAULT_HARNESS_RETRIES = 2;
-/**
- * Which mach command a run dispatches to. Single-suite runs use the
- * suite-specific command (`mach xpcshell-test` / `mach mochitest`), which
- * skips the mozlog resource monitor that crashes generic `mach test` on a
- * broken host. `generic` is the plain `mach test` path (mixed/all-tests runs,
- * or the `--generic-mach-test` opt-out).
- */
-export type TestSuite = 'xpcshell' | 'mochitest' | 'generic';
-/** Inputs shared by every harness invocation in one `fireforge test` run. */
-export interface TestRunContext {
-    /** A perf run changed power source; no green result can be trusted. */
-    powerChanged?: boolean;
-    engineDir: string;
-    objDir: string | undefined;
-    classification: {
-        xpcshell: string[];
-        nonXpcshell: string[];
-    };
-    /** Suite-specific dispatch target for this run (E1). */
-    suite: TestSuite;
-    /** Extra mach args before per-shard appdir injection. */
-    baseExtraArgs: readonly string[];
-    /** Bounded harness-crash retry budget (0 disables retries). */
-    harnessRetries: number;
-    /** Whether --headless was requested (crash-hint copy only). */
-    headless: boolean;
-    /** Extra environment variables for the mach process. */
-    env?: Record<string, string>;
-    /**
-     * Pass full mozbuild verbosity through for the TEST phase, by unsetting
-     * the coding-agent markers that quiet it. Off by default.
-     */
-    fullOutput?: boolean;
-    /** `--pgid-file`: where each dispatch publishes its harness process group id. */
-    pgidFile?: string | undefined;
-    /**
-     * Where each dispatch writes its mozlog raw log (`--results`,
-     * `--shard-size`). Unset: no `--log-raw` is added and nothing is parsed.
-     */
-    rawLogDir?: string | undefined;
-    /** `--repeat` run this dispatch belongs to (1-based), for `--results`. */
-    repetition?: number | undefined;
-    /** Prefix for every echoed and logged output line (`--jobs` instances). */
-    outputPrefix?: string | undefined;
-}
-/** Outcome of one (possibly retried) harness invocation. */
-export interface TestRunOutcome {
-    result: MachCommandResult;
-    verdict: HarnessRunVerdict;
-    attempts: number;
-    /** Whether xpcshell appdir injection was attempted for this invocation. */
-    appdirInjectionAttempted: boolean;
-    /**
-     * Display power state measured for a HEADED no-output stall. Undefined
-     * when the shape did not apply and no probe ran.
-     */
-    displayState?: DisplaySleepState | undefined;
-    /** Per-file results from the raw log, when the run wrote one. */
-    fileResults?: RawTestResult[] | undefined;
-    /**
-     * The mochitest server ports the last attempt reported (its "falling
-     * back to port" lines), for the shard line's `ports=` key.
-     */
-    serverPorts?: HarnessServerPorts | undefined;
-}
-/**
- * Runs one mach test invocation for `paths`, retrying recognized harness
- * crashes up to the configured budget. Every attempt goes through the
- * stale-xpcshell-symlink repair path the single-run flow already used.
- */
-export declare function runTestsWithRetries(ctx: TestRunContext, paths: string[], label?: string): Promise<TestRunOutcome>;