@hominis/fireforge 0.45.0 → 0.46.0

package/dist/src/core/mach.d.ts

@@ -2,7 +2,7 @@ import { type SmokeLineCallback, type SmokeRunResult } from '../utils/process.js
 import { type HarnessCrashSignature } from './test-harness-crash.js';
 export { attemptMozinfoRewrite, buildArtifactMismatchMessage, hasBuildArtifacts, hasRunnableBundle, } from './mach-build-artifacts.js';
 export { generateMozconfig } from './mach-mozconfig.js';
-export { ensurePython, resetResolvedPython } from './mach-python.js';
+export { ensurePython } from './mach-python.js';
 /**
  * Ensures mach is available in the engine directory.
  * @param engineDir - Path to the engine directory
@@ -66,12 +66,6 @@ export declare function runMachCapture(args: string[], engineDir: string, option
  * capturing stdout/stderr for post-run diagnostics.
  */
 export declare function runMachInheritCapture(args: string[], engineDir: string, options?: Omit<MachOptions, 'inherit'>): Promise<MachCommandResult>;
-/**
- * Runs mach bootstrap to install build dependencies.
- * @param engineDir - Path to the engine directory
- * @returns Exit code
- */
-export declare function bootstrap(engineDir: string): Promise<number>;
 /**
  * Runs mach bootstrap while preserving stdin and capturing the emitted output.
  * @param engineDir - Path to the engine directory
@@ -197,29 +191,15 @@ export interface RunMachSmokeOptions {
  * the runner to chrome-specific pattern logic.
  */
 export declare function runMachSmoke(args: string[], engineDir: string, options: RunMachSmokeOptions): Promise<SmokeRunResult>;
-/**
- * Creates a distribution package.
- * @param engineDir - Path to the engine directory
- * @returns Exit code
- */
-export declare function machPackage(engineDir: string): Promise<number>;
 /**
  * Creates a distribution package while streaming output to the terminal
- * and capturing the stderr tail for post-run diagnostics. Callers that
- * want to consult {@link explainMachError} on failure should use this
- * variant; the inherit-only `machPackage` above remains for callers that
- * just need an exit code.
+ * and capturing the stderr tail for post-run diagnostics, so callers can
+ * consult {@link explainMachError} on failure.
  *
  * @param engineDir - Path to the engine directory
  * @returns Captured mach result (stdout tail, stderr tail, exit code)
  */
 export declare function machPackageCapture(engineDir: string): Promise<MachCommandResult>;
-/**
- * Runs mach watch for auto-rebuilding.
- * @param engineDir - Path to the engine directory
- * @returns Exit code
- */
-export declare function watch(engineDir: string): Promise<number>;
 /**
  * Runs mach watch while preserving stdin and capturing emitted output.
  *
@@ -238,38 +218,44 @@ export declare function watchWithOutput(engineDir: string, options?: {
     env?: Record<string, string>;
 }): Promise<MachCommandResult>;
 /**
- * Runs mach test with the given test paths.
- * @param engineDir - Path to the engine directory
- * @param testPaths - Test file or directory paths (relative to engine)
- * @param args - Additional arguments to pass to mach test
- * @returns Exit code
- */
-export declare function test(engineDir: string, testPaths?: string[], args?: string[]): Promise<number>;
-/**
- * Runs mach test while capturing streamed output for better diagnostics.
+ * Which mach test command a capturing test dispatch runs.
  *
- * @param engineDir - Absolute path to the engine checkout
- * @param testPaths - Test paths to pass to `mach test`; empty runs the default set
- * @param args - Extra `mach test` arguments appended after the paths
- * @param env - Optional extra environment variables for the mach process
- *   (merged over `process.env` by the exec layer). Used by
- *   `fireforge test --perf-samples` to publish the artifact-path contract.
+ * - `test`: the generic `mach test` (mixed/all-tests runs, or the
+ *   `--generic-mach-test` opt-out).
+ * - `xpcshell-test` / `mochitest`: the suite-specific commands. Unlike the
+ *   generic `mach test`, these degrade a broken mozlog resource monitor to a
+ *   warning instead of crashing at startup, so `fireforge test` dispatches
+ *   single-suite runs to them to stay resilient to the host psutil failure.
  */
-export declare function testWithOutput(engineDir: string, testPaths?: string[], args?: string[], env?: Record<string, string>, fullOutput?: boolean): Promise<MachCommandResult>;
+export type MachTestSuiteKind = 'test' | 'xpcshell-test' | 'mochitest';
+/** Options for {@link runMachTestSuite}. */
+export interface MachTestSuiteOptions {
+    /** Absolute path to the engine checkout. */
+    engineDir: string;
+    /** Test paths to pass to the mach command; empty runs the default set. */
+    testPaths?: string[];
+    /** Extra mach arguments appended after the paths. */
+    args?: string[];
+    /**
+     * Extra environment variables for the mach process (merged over
+     * `process.env` by the exec layer). Used by `fireforge test
+     * --perf-samples` to publish the artifact-path contract.
+     */
+    env?: Record<string, string> | undefined;
+    /**
+     * Pass full mozbuild verbosity through by unsetting the coding-agent
+     * markers that quiet it. See {@link CODING_AGENT_ENV_MARKERS}.
+     */
+    fullOutput?: boolean | undefined;
+}
 /**
- * Runs `mach xpcshell-test` (the suite-specific xpcshell command) while
- * capturing output. Unlike the generic `mach test`, the suite-specific
- * commands degrade a broken mozlog resource monitor to a warning instead of
- * crashing at startup, so `fireforge test` dispatches single-suite runs here
- * to stay resilient to the host psutil failure.
+ * Runs one mach test command (`mach test` / `mach xpcshell-test` / `mach
+ * mochitest`) while capturing streamed output for better diagnostics. The
+ * three commands share every other detail of the dispatch — resource guard,
+ * verbosity env, teardown-noise annotation — so they share one entry point
+ * keyed by `kind` rather than three copies that drift.
  *
- * Signature mirrors {@link testWithOutput} so the two are interchangeable in
- * the dispatch path.
- */
-export declare function xpcshellTestWithOutput(engineDir: string, testPaths?: string[], args?: string[], env?: Record<string, string>, fullOutput?: boolean): Promise<MachCommandResult>;
-/**
- * Runs `mach mochitest` (covers browser-chrome / mochitest flavors) while
- * capturing output. The suite-specific counterpart to {@link testWithOutput}
- * for non-xpcshell single-suite runs — see {@link xpcshellTestWithOutput}.
+ * @param kind - Which mach command to run
+ * @param options - Engine checkout, test paths, extra args, env, verbosity
  */
-export declare function mochitestWithOutput(engineDir: string, testPaths?: string[], args?: string[], env?: Record<string, string>, fullOutput?: boolean): Promise<MachCommandResult>;
+export declare function runMachTestSuite(kind: MachTestSuiteKind, options: MachTestSuiteOptions): Promise<MachCommandResult>;

package/dist/src/core/mach.js

@@ -20,7 +20,7 @@ import { detectHarnessCrashSignature } from './test-harness-crash.js';
 // that mocks `mach.js`.
 export { attemptMozinfoRewrite, buildArtifactMismatchMessage, hasBuildArtifacts, hasRunnableBundle, } from './mach-build-artifacts.js';
 export { generateMozconfig } from './mach-mozconfig.js';
-export { ensurePython, resetResolvedPython } from './mach-python.js';
+export { ensurePython } from './mach-python.js';
 /**
  * Ensures mach is available in the engine directory.
  * @param engineDir - Path to the engine directory
@@ -149,14 +149,6 @@ export async function runMachInheritCapture(args, engineDir, options = {}) {
         processGroup: true,
     });
 }
-/**
- * Runs mach bootstrap to install build dependencies.
- * @param engineDir - Path to the engine directory
- * @returns Exit code
- */
-export async function bootstrap(engineDir) {
-    return runMach(['bootstrap', '--application-choice', 'browser'], engineDir, { inherit: true });
-}
 /**
  * Runs mach bootstrap while preserving stdin and capturing the emitted output.
  * @param engineDir - Path to the engine directory
@@ -351,20 +343,10 @@ export async function runMachSmoke(args, engineDir, options) {
         ...(options.mirror ? { mirror: options.mirror } : {}),
     });
 }
-/**
- * Creates a distribution package.
- * @param engineDir - Path to the engine directory
- * @returns Exit code
- */
-export async function machPackage(engineDir) {
-    return runMach(['package'], engineDir, { inherit: true });
-}
 /**
  * Creates a distribution package while streaming output to the terminal
- * and capturing the stderr tail for post-run diagnostics. Callers that
- * want to consult {@link explainMachError} on failure should use this
- * variant; the inherit-only `machPackage` above remains for callers that
- * just need an exit code.
+ * and capturing the stderr tail for post-run diagnostics, so callers can
+ * consult {@link explainMachError} on failure.
  *
  * @param engineDir - Path to the engine directory
  * @returns Captured mach result (stdout tail, stderr tail, exit code)
@@ -372,14 +354,6 @@ export async function machPackage(engineDir) {
 export async function machPackageCapture(engineDir) {
     return runMachCapture(['package'], engineDir);
 }
-/**
- * Runs mach watch for auto-rebuilding.
- * @param engineDir - Path to the engine directory
- * @returns Exit code
- */
-export async function watch(engineDir) {
-    return runMach(['watch'], engineDir, { inherit: true });
-}
 /**
  * Runs mach watch while preserving stdin and capturing emitted output.
  *
@@ -397,16 +371,6 @@ export async function watch(engineDir) {
 export async function watchWithOutput(engineDir, options = {}) {
     return runMachInheritCapture(['watch'], engineDir, options.env ? { env: options.env } : {});
 }
-/**
- * Runs mach test with the given test paths.
- * @param engineDir - Path to the engine directory
- * @param testPaths - Test file or directory paths (relative to engine)
- * @param args - Additional arguments to pass to mach test
- * @returns Exit code
- */
-export async function test(engineDir, testPaths = [], args = []) {
-    return runMach(['test', ...testPaths, ...args], engineDir, { inherit: true });
-}
 /**
  * Environment markers mozbuild reads to decide it is running under a coding
  * agent (`mozbuild.util.is_running_under_coding_agent`), which quiets
@@ -433,52 +397,20 @@ function testVerbosityEnvUnset(fullOutput) {
     return fullOutput === true ? CODING_AGENT_ENV_MARKERS : undefined;
 }
 /**
- * Runs mach test while capturing streamed output for better diagnostics.
+ * Runs one mach test command (`mach test` / `mach xpcshell-test` / `mach
+ * mochitest`) while capturing streamed output for better diagnostics. The
+ * three commands share every other detail of the dispatch — resource guard,
+ * verbosity env, teardown-noise annotation — so they share one entry point
+ * keyed by `kind` rather than three copies that drift.
  *
- * @param engineDir - Absolute path to the engine checkout
- * @param testPaths - Test paths to pass to `mach test`; empty runs the default set
- * @param args - Extra `mach test` arguments appended after the paths
- * @param env - Optional extra environment variables for the mach process
- *   (merged over `process.env` by the exec layer). Used by
- *   `fireforge test --perf-samples` to publish the artifact-path contract.
- */
-export async function testWithOutput(engineDir, testPaths = [], args = [], env, fullOutput) {
-    const guard = await installMachResourceGuard(engineDir);
-    const envUnset = testVerbosityEnvUnset(fullOutput);
-    return runMachCapture(['test', ...testPaths, ...args], engineDir, {
-        env: { ...guard.env, ...env },
-        ...(envUnset ? { envUnset } : {}),
-        annotateKnownTeardownNoise: true,
-    });
-}
-/**
- * Runs `mach xpcshell-test` (the suite-specific xpcshell command) while
- * capturing output. Unlike the generic `mach test`, the suite-specific
- * commands degrade a broken mozlog resource monitor to a warning instead of
- * crashing at startup, so `fireforge test` dispatches single-suite runs here
- * to stay resilient to the host psutil failure.
- *
- * Signature mirrors {@link testWithOutput} so the two are interchangeable in
- * the dispatch path.
- */
-export async function xpcshellTestWithOutput(engineDir, testPaths = [], args = [], env, fullOutput) {
-    const guard = await installMachResourceGuard(engineDir);
-    const envUnset = testVerbosityEnvUnset(fullOutput);
-    return runMachCapture(['xpcshell-test', ...testPaths, ...args], engineDir, {
-        env: { ...guard.env, ...env },
-        ...(envUnset ? { envUnset } : {}),
-        annotateKnownTeardownNoise: true,
-    });
-}
-/**
- * Runs `mach mochitest` (covers browser-chrome / mochitest flavors) while
- * capturing output. The suite-specific counterpart to {@link testWithOutput}
- * for non-xpcshell single-suite runs — see {@link xpcshellTestWithOutput}.
+ * @param kind - Which mach command to run
+ * @param options - Engine checkout, test paths, extra args, env, verbosity
  */
-export async function mochitestWithOutput(engineDir, testPaths = [], args = [], env, fullOutput) {
+export async function runMachTestSuite(kind, options) {
+    const { engineDir, testPaths = [], args = [], env, fullOutput } = options;
     const guard = await installMachResourceGuard(engineDir);
     const envUnset = testVerbosityEnvUnset(fullOutput);
-    return runMachCapture(['mochitest', ...testPaths, ...args], engineDir, {
+    return runMachCapture([kind, ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
         ...(envUnset ? { envUnset } : {}),
         annotateKnownTeardownNoise: true,

package/dist/src/core/marionette-port.d.ts

@@ -147,20 +147,3 @@ export declare function hasExplicitXpcshellFlavor(machArgs: string[]): boolean;
  * Marionette-driven browser).
  */
 export declare function shouldAutoForwardMarionettePortToMach(machArgs: string[]): boolean;
-/**
- * Heuristic: do the test paths or forwarded mach args indicate a flavour
- * that actually launches a Marionette-driven browser? Browser-chrome and
- * mochitest do; xpcshell does not. A no-paths invocation (the default "run
- * all tests" shape) is treated as marionette-relevant since it includes
- * browser-chrome.
- *
- * Note: `fireforge test` auto-forward of `--marionette-port` to mach uses
- * {@link shouldAutoForwardMarionettePortToMach} (mach-arg flavor gate) rather
- * than this function alone, so toolkit paths without `/mochitest/` still get
- * the listener pref and harness `--marionette=127.0.0.1:<n>` when appropriate.
- *
- * @param testPaths - Engine-relative paths after `stripEnginePrefix`.
- * @param machArgs - Forwarded mach args (post-`--mach-arg`).
- * @returns `true` when the run is likely to bind a Marionette listener.
- */
-export declare function isMarionetteFlavor(testPaths: string[], machArgs: string[]): boolean;

package/dist/src/core/marionette-port.js

@@ -24,7 +24,7 @@
  * installed the probe returns `{ inUse: false }` rather than failing the
  * test run — it is a best-effort friendliness check, not a prerequisite.
  */
-import { GeneralError } from '../errors/base.js';
+import { PreflightRefusalError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { getPlatform } from '../utils/platform.js';
 import { exec } from '../utils/process.js';
@@ -133,10 +133,10 @@ export async function ensureLaunchableBrowserNotRunning(launchableBinary, option
             return;
         }
         catch (error) {
-            throw new GeneralError(`A browser from this objdir is still running (PID ${holder.pid}), but FireForge could not terminate it: ${toError(error).message}`);
+            throw new PreflightRefusalError(`A browser from this objdir is still running (PID ${holder.pid}), but FireForge could not terminate it: ${toError(error).message}`, 'stale-browser-kill-failed');
         }
     }
-    throw new GeneralError(describeRunningBundleRefusal(holder));
+    throw new PreflightRefusalError(describeRunningBundleRefusal(holder), 'stale-browser');
 }
 /**
  * True when the process was launched BY a test harness — its command line
@@ -349,18 +349,18 @@ export async function assertMarionettePortAvailable(port = DEFAULT_MARIONETTE_PO
         const killHint = process.platform === 'win32'
             ? `Stop-Process -Id ${holder.pid} -Force`
             : `kill ${holder.pid}  # or "kill -9 ${holder.pid}" if it doesn't exit`;
-        throw new GeneralError(`Marionette port ${port} is already in use by ${holder.command} (PID ${holder.pid}). ` +
+        throw new PreflightRefusalError(`Marionette port ${port} is already in use by ${holder.command} (PID ${holder.pid}). ` +
             `This is usually a browser left running by a previously interrupted "fireforge test" run. ` +
             `Kill it with "${killHint}", then retry. ` +
             `(If you expected ${holder.command} to be running on ${port}, stop it manually or pass ` +
-            `"--marionette-port <port>" to launch mach test on a different port.)`);
+            `"--marionette-port <port>" to launch mach test on a different port.)`, 'marionette-port-busy');
     }
     // Non-browser holder: mach test will still fail to bind, but the
     // cause is not a stale FireForge-launched browser. Flag it
     // explicitly so the operator can decide what to do instead of
     // getting mach's bind error with no FireForge context.
-    throw new GeneralError(`Marionette port ${port} is already in use by ${holder.command} (PID ${holder.pid}). ` +
-        `This is not a FireForge-launched browser; stop the holder process or free the port before rerunning.`);
+    throw new PreflightRefusalError(`Marionette port ${port} is already in use by ${holder.command} (PID ${holder.pid}). ` +
+        `This is not a FireForge-launched browser; stop the holder process or free the port before rerunning.`, 'marionette-port-busy');
 }
 /**
  * Ensures the Marionette port is usable, optionally terminating a stale
@@ -390,8 +390,8 @@ export async function ensureMarionettePortAvailable(port = DEFAULT_MARIONETTE_PO
         }
     }
     catch (error) {
-        throw new GeneralError(`Marionette port ${port} is held by stale browser ${holder.command} (PID ${holder.pid}), ` +
-            `but FireForge could not terminate it: ${toError(error).message}`);
+        throw new PreflightRefusalError(`Marionette port ${port} is held by stale browser ${holder.command} (PID ${holder.pid}), ` +
+            `but FireForge could not terminate it: ${toError(error).message}`, 'stale-browser-kill-failed');
     }
 }
 /**
@@ -410,10 +410,7 @@ export async function ensureMarionettePortAvailable(port = DEFAULT_MARIONETTE_PO
  *   `undefined`.
  */
 export function extractForwardedMarionettePort(machArgs) {
-    for (let i = 0; i < machArgs.length; i++) {
-        const arg = machArgs[i];
-        if (arg === undefined)
-            continue;
+    for (const [i, arg] of machArgs.entries()) {
         // `--marionette-port=NNNN`
         let match = /^--marionette-port=(\d+)$/.exec(arg);
         if (match?.[1]) {
@@ -452,10 +449,7 @@ export function extractForwardedMarionettePort(machArgs) {
  */
 export function forwardedMachArgsIncludeMarionetteClient(machArgs) {
     const valueLooksLikeHostPort = (token) => /:[0-9]+$/.test(token) || /^\[[^]]+\]:[0-9]+$/.test(token);
-    for (let i = 0; i < machArgs.length; i++) {
-        const arg = machArgs[i];
-        if (arg === undefined)
-            continue;
+    for (const [i, arg] of machArgs.entries()) {
         if (arg.startsWith('--marionette=') && !arg.startsWith('--marionette-port=')) {
             return true;
         }
@@ -473,8 +467,7 @@ export function forwardedMachArgsIncludeMarionetteClient(machArgs) {
  * for runs where the pref is ignored anyway.
  */
 export function hasExplicitXpcshellFlavor(machArgs) {
-    for (let i = 0; i < machArgs.length; i += 1) {
-        const arg = machArgs[i] ?? '';
+    for (const [i, arg] of machArgs.entries()) {
         if (/^--flavor=xpcshell\b/.test(arg) || arg === '--flavor=xpcshell-tests')
             return true;
         if (arg === '--flavor' && /^xpcshell(?:-tests)?$/.test(machArgs[i + 1] ?? ''))
@@ -493,42 +486,3 @@ export function hasExplicitXpcshellFlavor(machArgs) {
 export function shouldAutoForwardMarionettePortToMach(machArgs) {
     return !hasExplicitXpcshellFlavor(machArgs);
 }
-/**
- * Heuristic: do the test paths or forwarded mach args indicate a flavour
- * that actually launches a Marionette-driven browser? Browser-chrome and
- * mochitest do; xpcshell does not. A no-paths invocation (the default "run
- * all tests" shape) is treated as marionette-relevant since it includes
- * browser-chrome.
- *
- * Note: `fireforge test` auto-forward of `--marionette-port` to mach uses
- * {@link shouldAutoForwardMarionettePortToMach} (mach-arg flavor gate) rather
- * than this function alone, so toolkit paths without `/mochitest/` still get
- * the listener pref and harness `--marionette=127.0.0.1:<n>` when appropriate.
- *
- * @param testPaths - Engine-relative paths after `stripEnginePrefix`.
- * @param machArgs - Forwarded mach args (post-`--mach-arg`).
- * @returns `true` when the run is likely to bind a Marionette listener.
- */
-export function isMarionetteFlavor(testPaths, machArgs) {
-    if (hasExplicitXpcshellFlavor(machArgs))
-        return false;
-    for (const arg of machArgs) {
-        if (/^--flavor=(browser-chrome|mochitest|chrome|a11y)\b/.test(arg))
-            return true;
-    }
-    if (testPaths.length === 0)
-        return true;
-    for (const path of testPaths) {
-        const base = path.split('/').pop() ?? path;
-        if (/^browser_.+\.(js|ini|toml)$/.test(base))
-            return true;
-        if (path.includes('/mochitest/') || path.startsWith('mochitest/'))
-            return true;
-        if (path.includes('/browser-chrome/') || path.startsWith('browser-chrome/'))
-            return true;
-        if (path.includes('toolkit/content/tests/') && !path.includes('/tests/xpcshell/')) {
-            return true;
-        }
-    }
-    return false;
-}

package/dist/src/core/marionette-preflight.js

@@ -22,6 +22,7 @@ import { pathExists } from '../utils/fs.js';
 import { info, verbose, warn } from '../utils/logger.js';
 import { installGracefulShutdownForwarder, trackChildClosure } from '../utils/process.js';
 import { killProcessTree, sweepProcessGroup } from '../utils/process-group.js';
+import { sleep } from '../utils/sleep.js';
 import { ensureMach } from './mach.js';
 import { getPython } from './mach-python.js';
 /** Marionette's default TCP port when the browser is launched with `--marionette`. */
@@ -143,7 +144,7 @@ export async function runMarionettePreflight(engineDir, options = {}) {
         const spawnedChild = child;
         closure = trackChildClosure();
         forwarder = installGracefulShutdownForwarder(spawnedChild, 500, (signal) => {
-            killProcessGroup(spawnedChild, signal);
+            killProcessTree(spawnedChild, signal, process.platform !== 'win32');
         });
         child.stderr?.on('data', (data) => {
             const chunk = data.toString();
@@ -155,10 +156,10 @@ export async function runMarionettePreflight(engineDir, options = {}) {
         // never come.
         const settleDeadline = Math.min(spawnSettleMs, Math.max(0, timeoutMs - elapsed()));
         if (settleDeadline > 0) {
-            await delay(settleDeadline);
+            await sleep(settleDeadline, { unref: true });
         }
         if (hasChildExited(spawnedChild)) {
-            return fail('browser-spawns', `Browser process exited during spawn (exit code ${String(spawnedChild.exitCode)}, signal ${spawnedChild.signalCode ?? 'none'}). ` +
+            return fail('browser-spawns', `Browser process exited during spawn (exit code ${spawnedChild.exitCode}, signal ${spawnedChild.signalCode ?? 'none'}). ` +
                 `stderr tail: ${stderrTail.trim().slice(-2_000) || '(empty)'}`, elapsed());
         }
         // Layer 6: marionette handshake within the remaining budget.
@@ -175,7 +176,7 @@ export async function runMarionettePreflight(engineDir, options = {}) {
         // Child may have exited before the socket was ever ready — surface that
         // distinctly from "socket never answered" so the operator has a lead.
         if (hasChildExited(spawnedChild)) {
-            return fail('marionette-handshake', `Browser process exited before marionette handshake (exit code ${String(spawnedChild.exitCode)}, signal ${spawnedChild.signalCode ?? 'none'}). ` +
+            return fail('marionette-handshake', `Browser process exited before marionette handshake (exit code ${spawnedChild.exitCode}, signal ${spawnedChild.signalCode ?? 'none'}). ` +
                 `stderr tail: ${stderrTail.trim().slice(-2_000) || '(empty)'}`, elapsed());
         }
         return fail('marionette-handshake', `Marionette socket on 127.0.0.1:${port} did not respond within ${timeoutMs}ms. ` +
@@ -203,12 +204,12 @@ async function teardownPreflightChild(child, forwarder, closure, profileDir) {
     forwarder?.dispose();
     const groupPid = child?.pid;
     if (child && !hasChildExited(child)) {
-        killProcessGroup(child, 'SIGTERM');
+        killProcessTree(child, 'SIGTERM', process.platform !== 'win32');
         // Small escalation: if the child doesn't honour SIGTERM quickly, SIGKILL
         // so we don't leave a ghost mach process around after a failed probe.
-        await delay(500);
+        await sleep(500, { unref: true });
         if (!hasChildExited(child)) {
-            killProcessGroup(child, 'SIGKILL');
+            killProcessTree(child, 'SIGKILL', process.platform !== 'win32');
         }
     }
     // Reap anything that outlived the group signal. The file's own comments
@@ -237,19 +238,6 @@ async function teardownPreflightChild(child, forwarder, closure, profileDir) {
         warn(`Could not clean up marionette preflight profile: ${toError(error).message}`);
     }
 }
-/**
- * Sends `signal` to the child's whole process group when possible, falling
- * back to a direct `child.kill` for environments that don't support
- * `detached: true` (Windows in particular: Node still returns a pid, but
- * `kill(-pid, …)` is not a supported kernel primitive).
- */
-function killProcessGroup(child, signal) {
-    // Delegates to the shared implementation, which is a strict superset of
-    // the hand-rolled one this replaced: same POSIX `kill(-pid)` with the same
-    // fall-through to a direct `child.kill`, plus a Windows `taskkill /T /F`
-    // branch and an already-exited early return.
-    killProcessTree(child, signal, process.platform !== 'win32');
-}
 function fail(layer, message, durationMs) {
     return {
         ok: false,
@@ -267,7 +255,7 @@ async function waitForMarionetteSocket(port, connectFn, keepTrying) {
         if (result.ok) {
             return { ok: true };
         }
-        await delay(400);
+        await sleep(400, { unref: true });
     }
     return { ok: false };
 }
@@ -312,12 +300,6 @@ function attemptMarionetteConnect(port, connectFn) {
         });
     });
 }
-function delay(ms) {
-    return new Promise((resolve) => {
-        const timer = setTimeout(resolve, ms);
-        timer.unref();
-    });
-}
 /** Renders a PASS/FAIL banner to the CLI using the shared logger helpers. */
 export function reportMarionettePreflight(result) {
     if (result.ok) {

package/dist/src/core/mochitest-server-port.js

@@ -100,8 +100,8 @@ export function describeMochitestServerRefusal(port, holder, recognized) {
     const killHint = process.platform === 'win32'
         ? `Stop-Process -Id ${holder.pid} -Force`
         : `kill -9 ${holder.pid}`;
-    const evidence = `The mochitest server port ${String(port)} is already held by ${holder.command} ` +
-        `(PID ${String(holder.pid)}).\n` +
+    const evidence = `The mochitest server port ${port} is already held by ${holder.command} ` +
+        `(PID ${holder.pid}).\n` +
         `  command: ${holder.commandLine}\n` +
         "  A browser launched now would connect to THAT server, which cannot serve this run's " +
         'manifest — the run would stall before TEST_START and die on the no-output timeout with ' +
@@ -115,5 +115,5 @@ export function describeMochitestServerRefusal(port, holder, recognized) {
     return (evidence +
         "  This is NOT the mochitest harness's server.js, so FireForge will not offer to kill it. " +
         `Stop the holder yourself with "${killHint}" if it is yours, or free the port, then retry. ` +
-        `Diagnose with "lsof -nP -iTCP:${String(port)}".`);
+        `Diagnose with "lsof -nP -iTCP:${port}".`);
 }