@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/test-perf-scope.d.ts

@@ -1,50 +0,0 @@
-/**
- * Scope of the evidence a `--perf-samples` run reports and invalidates on.
- *
- * - A stale-build refusal on a perf run says which stale packaged files are
- *   staging inputs of the sampled test and which lie elsewhere, so a sample
- *   whose fixture is unaffected can proceed knowingly under
- *   `--allow-stale-build`.
- * - An engine edit that lands while a sample runs makes the verdict
- *   `inconclusive` only when the edited path is something the running build
- *   packages (an install-manifest source, or a test file). An edit to a
- *   compiled source, a build file or anything else no manifest installs
- *   cannot reach the running binary, so the sample stands with a warning.
- */
-/**
- * The perf-impact line of a stale-build refusal.
- *
- * @param engineDir - Absolute engine directory
- * @param stalePaths - Stale packaged paths the refusal names
- * @param requested - Normalized request paths of the run
- */
-export declare function describePerfStaleImpact(engineDir: string, stalePaths: readonly string[], requested: readonly string[]): Promise<string>;
-/**
- * Tolerance for `assertEngineGenerationUnchanged` on a `--perf-samples` run:
- * true (with a warning naming the edits) when HEAD did not move and no
- * changed path is packaged by the running build.
- *
- * @param engineDir - Absolute engine directory
- */
-export declare function perfGenerationTolerance(engineDir: string): (before: string, after: string) => Promise<boolean>;
-/**
- * Tolerance for `assertEngineGenerationUnchanged` on an ordinary run: true
- * (with a warning, and `drift-tolerated=<n>` on the verdict) when HEAD did
- * not move and every changed path is one the running browser cannot see.
- *
- * A peer deleting an unrelated chrome script must not make a whole run
- * inconclusive. What a running browser can see mid-run is narrower than
- * "anything under engine/": a file the objdir links to its source (`live`),
- * one the harness stages at dispatch (`at-dispatch`), and the run's own
- * test files and the staging inputs their manifests name. A compiled
- * source, or a file the build copied into the package, is already fixed in
- * the running binary or package; the next run's stale-build gate judges it.
- *
- * Perf runs keep {@link perfGenerationTolerance}: a sample is also void
- * when a packaged path changes.
- *
- * @param engineDir - Absolute engine directory
- * @param requested - Normalized request paths of the run
- * @param onTolerated - Receives the tolerated path count
- */
-export declare function runGenerationTolerance(engineDir: string, requested: readonly string[], onTolerated: (count: number) => void): (before: string, after: string) => Promise<boolean>;

package/dist/src/commands/test-perf-scope.js

@@ -1,138 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Scope of the evidence a `--perf-samples` run reports and invalidates on.
- *
- * - A stale-build refusal on a perf run says which stale packaged files are
- *   staging inputs of the sampled test and which lie elsewhere, so a sample
- *   whose fixture is unaffected can proceed knowingly under
- *   `--allow-stale-build`.
- * - An engine edit that lands while a sample runs makes the verdict
- *   `inconclusive` only when the edited path is something the running build
- *   packages (an install-manifest source, or a test file). An edit to a
- *   compiled source, a build file or anything else no manifest installs
- *   cannot reach the running binary, so the sample stands with a warning.
- */
-import { isTestPath } from '../core/build-audit-resolve.js';
-import { collectStagingInputs, isUnderPath } from '../core/coverage-records.js';
-import { generationDeltaPaths } from '../core/engine-session-lock.js';
-import { classifyRuntimeDelivery, installsFromDirectory, } from '../core/objdir-install-manifests.js';
-import { loadEngineInstallIndex } from '../core/test-stale-exempt.js';
-import { warn } from '../utils/logger.js';
-/** How many paths an impact line names per group. */
-const IMPACT_LIST_LIMIT = 5;
-function capList(paths) {
-    const head = paths.slice(0, IMPACT_LIST_LIMIT).join(', ');
-    const extra = paths.length - Math.min(paths.length, IMPACT_LIST_LIMIT);
-    return extra > 0 ? `${head}, … (+${extra} more)` : head;
-}
-/**
- * The perf-impact line of a stale-build refusal.
- *
- * @param engineDir - Absolute engine directory
- * @param stalePaths - Stale packaged paths the refusal names
- * @param requested - Normalized request paths of the run
- */
-export async function describePerfStaleImpact(engineDir, stalePaths, requested) {
-    const inputs = [];
-    for (const path of requested)
-        inputs.push(...(await collectStagingInputs(engineDir, path)));
-    const fixture = stalePaths.filter((path) => inputs.some((input) => isUnderPath(path, input)));
-    const elsewhere = stalePaths.filter((path) => !fixture.includes(path));
-    const fixturePart = fixture.length > 0
-        ? `${fixture.length} stale file(s) are staging inputs of the sampled test (${capList(fixture)}), so the sample would measure the old content`
-        : requested.length > 0
-            ? "the sampled test's own staging inputs are unaffected"
-            : 'no test paths were named, so every stale file may be measured';
-    const elsewherePart = elsewhere.length > 0 && requested.length > 0
-        ? `; ${elsewhere.length} stale packaged file(s) lie outside them (${capList(elsewhere)}) and affect the sample only if the measured path loads them`
-        : '';
-    return (`Perf sample impact: ${fixturePart}${elsewherePart}. Repackage first, or pass ` +
-        '--allow-stale-build to take the sample knowingly.');
-}
-/**
- * Tolerance for `assertEngineGenerationUnchanged` on a `--perf-samples` run:
- * true (with a warning naming the edits) when HEAD did not move and no
- * changed path is packaged by the running build.
- *
- * @param engineDir - Absolute engine directory
- */
-export function perfGenerationTolerance(engineDir) {
-    return async (before, after) => {
-        const delta = generationDeltaPaths(before, after);
-        if (delta.headMoved || delta.paths.length === 0)
-            return false;
-        const index = await loadEngineInstallIndex(engineDir);
-        if (index === undefined)
-            return false;
-        for (const path of delta.paths) {
-            if (isTestPath(path))
-                return false;
-            if (path.endsWith('/')) {
-                if (installsFromDirectory(index, path))
-                    return false;
-            }
-            else if ((await classifyRuntimeDelivery(index, engineDir, path)) !== 'unlisted') {
-                return false;
-            }
-        }
-        warn(`engine/ changed while this perf sample ran, but only in files the running build does not ` +
-            `package (${capList(delta.paths)}); the sample stands. Rebuild before the next sample if ` +
-            'they belong in it.');
-        return true;
-    };
-}
-/**
- * Tolerance for `assertEngineGenerationUnchanged` on an ordinary run: true
- * (with a warning, and `drift-tolerated=<n>` on the verdict) when HEAD did
- * not move and every changed path is one the running browser cannot see.
- *
- * A peer deleting an unrelated chrome script must not make a whole run
- * inconclusive. What a running browser can see mid-run is narrower than
- * "anything under engine/": a file the objdir links to its source (`live`),
- * one the harness stages at dispatch (`at-dispatch`), and the run's own
- * test files and the staging inputs their manifests name. A compiled
- * source, or a file the build copied into the package, is already fixed in
- * the running binary or package; the next run's stale-build gate judges it.
- *
- * Perf runs keep {@link perfGenerationTolerance}: a sample is also void
- * when a packaged path changes.
- *
- * @param engineDir - Absolute engine directory
- * @param requested - Normalized request paths of the run
- * @param onTolerated - Receives the tolerated path count
- */
-export function runGenerationTolerance(engineDir, requested, onTolerated) {
-    return async (before, after) => {
-        const delta = generationDeltaPaths(before, after);
-        if (delta.headMoved || delta.paths.length === 0)
-            return false;
-        const index = await loadEngineInstallIndex(engineDir);
-        if (index === undefined)
-            return false;
-        const inputs = [...requested];
-        for (const path of requested)
-            inputs.push(...(await collectStagingInputs(engineDir, path)));
-        for (const path of delta.paths) {
-            const bare = path.endsWith('/') ? path.slice(0, -1) : path;
-            if (inputs.some((input) => isUnderPath(bare, input) || isUnderPath(input, bare))) {
-                return false;
-            }
-            // A path-less run requests every test, so any test file is its own.
-            if (requested.length === 0 && isTestPath(path))
-                return false;
-            if (path.endsWith('/')) {
-                if (installsFromDirectory(index, path))
-                    return false;
-                continue;
-            }
-            const delivery = await classifyRuntimeDelivery(index, engineDir, path);
-            if (delivery === 'live' || delivery === 'at-dispatch')
-                return false;
-        }
-        warn(`engine/ changed while this run was in flight, but only in files the running browser ` +
-            `cannot see (${capList(delta.paths)}); the verdict stands. The next run's stale-build ` +
-            'gate judges whether they need a rebuild.');
-        onTolerated(delta.paths.length);
-        return true;
-    };
-}

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

@@ -1,61 +0,0 @@
-/**
- * The `fireforge test` checks that run BEFORE the engine session lock.
- *
- * Everything here reads, never writes, so none of it needs the lock, and
- * running it first keeps each check from costing a full place in the lock
- * queue before it can refuse:
- *
- *  - a missing launchable binary (a peer's interrupted build) refuses
- *    before the wait, naming the cause;
- *  - the named-file checkJs pass refuses a type error without a queue;
- *  - `--wait-browser` and `--wait-port` spend their budget without holding
- *    the lock, so no peer queues behind a run that is doing nothing.
- *
- * The in-lock ladder in `test.ts` still runs in full afterwards. That is
- * the "re-check once under the lock": the waits this pass spent are
- * stripped from the options it returns, so the in-lock browser and port
- * checks probe once instead of waiting again.
- */
-import type { TestOptions } from '../types/commands/index.js';
-/**
- * Resolves the launchable binary a test run needs, or refuses naming why
- * it is missing. The cause comes from the build run record, which any
- * session's build writes, so a session that never ran the build can still
- * say "a peer's build was interrupted" rather than only "the binary is
- * missing".
- *
- * @param projectRoot - Project root
- * @param engineDir - Absolute engine directory
- * @param binaryName - Configured binary name
- * @param objDir - Active objdir, when one exists
- * @returns The engine-relative launchable path, or undefined without an objdir
- */
-export declare function resolveLaunchablePathForTests(projectRoot: string, engineDir: string, binaryName: string, objDir: string | undefined): Promise<string | undefined>;
-/** Build-artifact preflight wording for `fireforge test`. */
-export declare const TEST_BUILD_PREFLIGHT: {
-    readonly label: "Tests";
-    readonly requirement: "Tests require a completed build.";
-    readonly remediation: "Run 'fireforge build' first, then run 'fireforge test'.";
-    readonly requireExisting: true;
-};
-/**
- * Runs the lock-free checks and waits, and returns the options the in-lock
- * run should use: with `waitBrowser`/`waitPort` removed when their budget
- * was already spent here.
- *
- * @param projectRoot - Project root
- * @param testPaths - Requested test paths
- * @param options - Parsed test options
- */
-export declare function runTestPreLockPreflight(projectRoot: string, testPaths: string[], options: TestOptions): Promise<TestOptions>;
-/**
- * `options` with the wait budgets the pre-lock pass spent put back, for a
- * browser or port check that follows work this invocation already did
- * under the lock: its pre-test build, or an earlier run of a sequence. A
- * busy browser there is a peer that started after the lock was taken, and
- * refusing would throw the build away, so it is waited out like the first
- * check's.
- *
- * @param options - In-lock run options
- */
-export declare function rearmSpentWaits(options: TestOptions): TestOptions;

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

@@ -1,301 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The `fireforge test` checks that run BEFORE the engine session lock.
- *
- * Everything here reads, never writes, so none of it needs the lock, and
- * running it first keeps each check from costing a full place in the lock
- * queue before it can refuse:
- *
- *  - a missing launchable binary (a peer's interrupted build) refuses
- *    before the wait, naming the cause;
- *  - the named-file checkJs pass refuses a type error without a queue;
- *  - `--wait-browser` and `--wait-port` spend their budget without holding
- *    the lock, so no peer queues behind a run that is doing nothing.
- *
- * The in-lock ladder in `test.ts` still runs in full afterwards. That is
- * the "re-check once under the lock": the waits this pass spent are
- * stripped from the options it returns, so the in-lock browser and port
- * checks probe once instead of waiting again.
- */
-import { join } from 'node:path';
-import { describeBuildRunState, readBuildRunState } from '../core/build-run-record.js';
-import { getProjectPaths, loadConfig } from '../core/config.js';
-import { assertEngineExists } from '../core/engine-precondition.js';
-import { autoPortsRequested } from '../core/harness-port-fallback.js';
-import { hasBuildArtifacts, hasRunnableBundle } from '../core/mach.js';
-import { assertBuildArtifacts } from '../core/mach-build-artifacts.js';
-import { assertMarionettePortAvailable, ensureLaunchableBrowserNotRunning, extractForwardedMarionettePort, } from '../core/marionette-port.js';
-import { ensureMochitestServerPortAvailable } from '../core/mochitest-server-port.js';
-import { planNegativeControl } from '../core/negative-control.js';
-import { formatCompiledControlRefusal } from '../core/negative-control-compiled.js';
-import { waitBeforeLock } from '../core/preflight-wait.js';
-import { PreflightRefusalError } from '../errors/base.js';
-import { info } from '../utils/logger.js';
-import { resolveWaitLockSeconds } from '../utils/options.js';
-import { stripEnginePrefix } from '../utils/paths.js';
-import { checkRequestedTestTypes } from './test-checkjs.js';
-import { assertPathlessTestMode, classifyBeforeDispatch, resolveCanaryPath } from './test-modes.js';
-import { enforceStaleBuildGate } from './test-stale-gate.js';
-/**
- * Resolves the launchable binary a test run needs, or refuses naming why
- * it is missing. The cause comes from the build run record, which any
- * session's build writes, so a session that never ran the build can still
- * say "a peer's build was interrupted" rather than only "the binary is
- * missing".
- *
- * @param projectRoot - Project root
- * @param engineDir - Absolute engine directory
- * @param binaryName - Configured binary name
- * @param objDir - Active objdir, when one exists
- * @returns The engine-relative launchable path, or undefined without an objdir
- */
-export async function resolveLaunchablePathForTests(projectRoot, engineDir, binaryName, objDir) {
-    if (!objDir)
-        return undefined;
-    const bundleCheck = await hasRunnableBundle(engineDir, binaryName, objDir);
-    if (bundleCheck.runnable)
-        return bundleCheck.expectedPath;
-    const expectedSuffix = bundleCheck.expectedPath
-        ? ` (expected at engine/${bundleCheck.expectedPath})`
-        : '';
-    const cause = describeBuildRunState(await readBuildRunState(projectRoot));
-    throw new PreflightRefusalError(`Tests require a complete launchable build${expectedSuffix}. ` +
-        'The obj-*/dist/ tree exists but the launchable binary is missing' +
-        (cause !== undefined
-            ? `.\n\n${cause}\n\n`
-            : ' — typically the result of an interrupted or partially failed `fireforge build`.\n\n') +
-        'Run "fireforge build" again and let it finish before retrying "fireforge test".', 'no-launchable-binary');
-}
-/** Build-artifact preflight wording for `fireforge test`. */
-export const TEST_BUILD_PREFLIGHT = {
-    label: 'Tests',
-    requirement: 'Tests require a completed build.',
-    remediation: "Run 'fireforge build' first, then run 'fireforge test'.",
-    requireExisting: true,
-};
-/**
- * The head of the in-lock ladder, run early: argument shape, engine, build
- * artifacts and config. Each refuses with exactly the message it gives
- * under the lock. Returns undefined when there is no objdir to check
- * further.
- */
-async function loadPreLockContext(projectRoot, testPaths, options) {
-    assertPathlessTestMode(testPaths, options);
-    const paths = getProjectPaths(projectRoot);
-    await assertEngineExists(paths.engine);
-    const buildCheck = await hasBuildArtifacts(paths.engine);
-    assertBuildArtifacts(paths.engine, buildCheck, TEST_BUILD_PREFLIGHT);
-    const config = await loadConfig(projectRoot);
-    return buildCheck.objDir === undefined ? undefined : { paths, config, objDir: buildCheck.objDir };
-}
-/**
- * Runs the lock-free checks and waits, and returns the options the in-lock
- * run should use: with `waitBrowser`/`waitPort` removed when their budget
- * was already spent here.
- *
- * @param projectRoot - Project root
- * @param testPaths - Requested test paths
- * @param options - Parsed test options
- */
-export async function runTestPreLockPreflight(projectRoot, testPaths, options) {
-    const loaded = await loadPreLockContext(projectRoot, testPaths, options);
-    if (loaded === undefined)
-        return withLockMode(options, 'exclusive');
-    const { paths, config, objDir } = loaded;
-    options = withLockMode(options, resolveTestLockMode(options, config));
-    let launchablePath;
-    try {
-        launchablePath = await resolveLaunchablePathForTests(projectRoot, paths.engine, config.binaryName, objDir);
-    }
-    catch (error) {
-        // A build in progress holds the engine lock and relinks the bundle
-        // before it lets go, so this run queues behind it rather than refusing.
-        if ((await readBuildRunState(projectRoot)).kind !== 'running')
-            throw error;
-        info('The launchable binary is missing while a build runs; queueing behind it.');
-    }
-    const canaryPath = resolveCanaryPath(options, config);
-    const normalizedPaths = (canaryPath !== undefined ? [canaryPath] : testPaths).map((path) => stripEnginePrefix(path).trim());
-    if (options.build === true || options.buildOnly === true) {
-        await checkRequestedTestTypes(paths, config, normalizedPaths);
-    }
-    else {
-        await refuseCompiledControlBeforeLock(projectRoot, paths.engine, options);
-        await refuseStalePackagingBeforeLock(projectRoot, paths.engine, options, {
-            normalizedPaths,
-            launchablePath,
-        });
-    }
-    return waitForResourcesBeforeLock(paths.engine, config, options, {
-        launchablePath,
-        normalizedPaths,
-    });
-}
-/** `options` with `sharedLock` set to the resolved decision. */
-function withLockMode(options, mode) {
-    if (mode === 'exclusive' && options.sharedLock === undefined)
-        return options;
-    const rest = { ...options };
-    delete rest.sharedLock;
-    return mode === 'shared' ? { ...rest, sharedLock: true } : rest;
-}
-/**
- * How this run holds the engine session lock. Shared only on request
- * (`--shared-lock` or `test.lockMode: "shared"`), and only for a run that
- * writes nothing into engine/ or the objdir and can move its ports: no
- * build, no negative control, auto ports. Every other run stays exclusive,
- * so a shared holder can never overlap a build or a re-export.
- */
-function resolveTestLockMode(options, config) {
-    const requested = options.sharedLock === true || config.test?.lockMode === 'shared';
-    if (!requested)
-        return 'exclusive';
-    const writes = options.build === true ||
-        options.buildOnly === true ||
-        options.negativeControl !== undefined ||
-        options.canary !== undefined ||
-        options.doctor === true;
-    if (writes || !autoPortsRequested(options, config)) {
-        info('Shared test lock requested, but this run ' +
-            (writes
-                ? 'builds, applies a negative control, or runs a canary/doctor preflight'
-                : 'does not use auto ports (--auto-ports or test.mochitestPorts: "auto")') +
-            ', so it holds the engine lock exclusively.');
-        return 'exclusive';
-    }
-    return 'shared';
-}
-/**
- * Refuses a build-less `--negative-control` on compiled source before the
- * lock: applied after the build it is never compiled, so the run could only
- * report `control=missed` against the unmutated binary.
- */
-async function refuseCompiledControlBeforeLock(projectRoot, engineDir, options) {
-    if (options.negativeControl === undefined)
-        return;
-    let plan;
-    try {
-        plan = await planNegativeControl(projectRoot, engineDir, options.negativeControl);
-    }
-    catch {
-        // Any other refusal (including a control a killed run left applied,
-        // which only the in-lock recovery may undo) is the in-lock pass's.
-        return;
-    }
-    if (plan.compiled === undefined)
-        return;
-    throw new PreflightRefusalError(formatCompiledControlRefusal(plan.compiled), 'negative-control');
-}
-/**
- * Runs the build-less run's packaging gates (coverage, stale content,
- * StaticComponents) before the lock, so a refusal surfaces before the run
- * queues instead of after it reached the head of the queue. The same gate
- * runs again under the lock, where a peer's build may since have changed
- * the answer; this pass only refuses early what would refuse anyway.
- *
- * Skipped while a build runs (it will rewrite the record this reads) and
- * under `--allow-stale-build`/`--allow-stale-components`, whose warnings
- * belong to the in-lock pass alone. A `--negative-control` refusal says to
- * add `--build`: without it the control has nothing current to run on, and
- * the invocation would end `control=inconclusive` after a full queue.
- */
-async function refuseStalePackagingBeforeLock(projectRoot, engineDir, options, request) {
-    if (options.allowStaleBuild === true || options.allowStaleComponents === true)
-        return;
-    if ((await readBuildRunState(projectRoot)).kind === 'running')
-        return;
-    try {
-        await enforceStaleBuildGate(projectRoot, engineDir, options, request.normalizedPaths, {
-            quiet: true,
-            launchablePath: request.launchablePath,
-        });
-    }
-    catch (error) {
-        if (options.negativeControl === undefined || !(error instanceof PreflightRefusalError)) {
-            throw error;
-        }
-        throw new PreflightRefusalError(`${error.message}\n\nThis --negative-control run has no --build, so its control would ` +
-            'run on this packaging and end inconclusive. Add --build: the control is then planned ' +
-            'against a fresh build of the requested paths.', error.note);
-    }
-}
-/**
- * `options` without one wait budget, which this pass already spent. The
- * budget moves to `spentWaits`, for {@link rearmSpentWaits}.
- */
-function withoutOption(options, key) {
-    const rest = { ...options, spentWaits: { ...options.spentWaits, [key]: options[key] } };
-    if (key === 'waitBrowser')
-        delete rest.waitBrowser;
-    else
-        delete rest.waitPort;
-    return rest;
-}
-/**
- * `options` with the wait budgets the pre-lock pass spent put back, for a
- * browser or port check that follows work this invocation already did
- * under the lock: its pre-test build, or an earlier run of a sequence. A
- * busy browser there is a peer that started after the lock was taken, and
- * refusing would throw the build away, so it is waited out like the first
- * check's.
- *
- * @param options - In-lock run options
- */
-export function rearmSpentWaits(options) {
-    const spent = options.spentWaits;
-    if (spent === undefined)
-        return options;
-    const rearmed = { ...options };
-    if (spent.waitBrowser !== undefined)
-        rearmed.waitBrowser = spent.waitBrowser;
-    if (spent.waitPort !== undefined)
-        rearmed.waitPort = spent.waitPort;
-    delete rearmed.spentWaits;
-    return rearmed;
-}
-/**
- * Spends `--wait-browser` and `--wait-port` before the lock, mirroring
- * which in-lock checks would apply to this run, and strips each budget it
- * spent from the returned options.
- */
-async function waitForResourcesBeforeLock(engineDir, config, options, request) {
-    if (options.waitBrowser === undefined && options.waitPort === undefined)
-        return options;
-    let xpcshellOnly;
-    try {
-        ({ xpcshellOnly } = await classifyBeforeDispatch(engineDir, request.normalizedPaths, {
-            allowMixed: true,
-        }));
-    }
-    catch {
-        return options;
-    }
-    const kill = options.killStaleMarionette === true;
-    let result = options;
-    const building = options.build === true || options.buildOnly === true;
-    if (options.waitBrowser !== undefined &&
-        request.launchablePath !== undefined &&
-        (building || !xpcshellOnly)) {
-        const binary = join(engineDir, request.launchablePath);
-        await waitBeforeLock(() => ensureLaunchableBrowserNotRunning(binary), resolveWaitLockSeconds(options.waitBrowser), 
-        // A stale browser the run may reap is not worth waiting out; the
-        // in-lock check terminates it.
-        kill ? ['stale-browser'] : []);
-        result = withoutOption(result, 'waitBrowser');
-    }
-    // Port waits stay under the lock with --kill-stale-marionette: a stale
-    // listener reads as busy until the in-lock pass reaps it, so waiting it
-    // out here would only burn the budget.
-    if (options.waitPort !== undefined && options.buildOnly !== true && !kill) {
-        const seconds = resolveWaitLockSeconds(options.waitPort);
-        if (!xpcshellOnly) {
-            await waitBeforeLock(() => ensureMochitestServerPortAvailable(undefined, { engineDir }), seconds);
-        }
-        if (!xpcshellOnly || options.doctor === true) {
-            const port = options.marionettePort ?? extractForwardedMarionettePort(options.machArg ?? []);
-            await waitBeforeLock(() => assertMarionettePortAvailable(port, { binaryName: config.binaryName }), seconds);
-        }
-        result = withoutOption(result, 'waitPort');
-    }
-    return result;
-}

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-/** Registers the test command on the CLI program. */
-export declare function registerTest(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;