@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/git.js

@@ -1,540 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readdir, stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { ExecTimeoutError } from '../errors/base.js';
-import { GitError, GitIndexingTimeoutError, GitIndexLockError, PatchApplyError, } from '../errors/git.js';
-import { elapsedSince } from '../utils/elapsed.js';
-import { toError } from '../utils/errors.js';
-import { pathExists, pathExistsStrict, removeFile } from '../utils/fs.js';
-import { verbose } from '../utils/logger.js';
-import { exec } from '../utils/process.js';
-import { ensureFirefoxIgnorefileCompatibility } from './firefox-ignorefile.js';
-import { chunkPathspecs, configureGitLineEndings, configureGitPerformance, ensureGit, git, GIT_ADD_CHUNK_TIMEOUT_ENV_VAR, GIT_ADD_CHUNK_TIMEOUT_MS, GIT_ADD_TIMEOUT_MS, } from './git-base.js';
-import { getWorkingTreeStatus } from './git-status.js';
-// ── Functions that remain in this file ──
-/**
- * Checks if a directory is a git repository.
- * @param dir - Directory to check
- * @returns True if the directory is a git repository
- */
-export async function isGitRepository(dir) {
-    const gitDir = join(dir, '.git');
-    return pathExistsStrict(gitDir);
-}
-/**
- * Ensures the repository has an "origin" remote.
- *
- * Firefox's mach bootstrap and build scripts shell out to
- * `git remote get-url origin` and emit noisy errors when the remote is
- * absent.  This adds a local-only dummy remote so those scripts stay quiet.
- * Nothing is ever fetched from or pushed to this remote.
- *
- * @param dir - Git working directory
- */
-export async function ensureOriginRemote(dir) {
-    const result = await exec('git', ['remote', 'get-url', 'origin'], { cwd: dir });
-    if (result.exitCode !== 0) {
-        await git(['remote', 'add', 'origin', 'https://github.com/mozilla-firefox/firefox'], dir);
-    }
-}
-// ── Large-tree staging helpers ──
-const GIT_ADD_ENV = { GIT_INDEX_THREADS: '0' };
-/**
- * Returns true when the error looks like a process killed by the spawn
- * timeout (SIGTERM → exit code 143) or an AbortError raised by
- * `AbortSignal.timeout`. Node's `child_process` layer rejects with an
- * AbortError when the signal fires, so both shapes have to be recognised.
- */
-function isTimeoutError(error) {
-    // `exec` rejects with a typed ExecTimeoutError when its `timeout`
-    // option fires (the raw AbortError check below is kept for defence in
-    // depth against other abort paths).
-    if (error instanceof ExecTimeoutError)
-        return true;
-    if (error instanceof Error && error.name === 'AbortError')
-        return true;
-    if (!(error instanceof GitError))
-        return false;
-    if (/SIGTERM|timed out|exit code 143/i.test(error.message))
-        return true;
-    if (error.cause instanceof Error && error.cause.name === 'AbortError')
-        return true;
-    return false;
-}
-/**
- * Removes `.git/index.lock` left behind by a killed git process.
- */
-async function cleanupIndexLock(dir) {
-    const lockPath = join(dir, '.git', 'index.lock');
-    if (await pathExists(lockPath)) {
-        await removeFile(lockPath);
-        verbose('Cleaned up stale .git/index.lock after timeout');
-    }
-}
-/**
- * Returns true when {@link relativePath} is ignored by `.gitignore` (or any
- * other exclusion mechanism git considers, e.g. `.git/info/exclude`,
- * core.excludesFile). Used by the chunked staging fallback to skip entries
- * that would otherwise fail `git add -- <path>` with the fatal "The
- * following paths are ignored by one of your .gitignore files" error, a
- * state the monolithic `git add -A` path silently handles. A Firefox
- * checkout's top-level `.vscode/` is the common case: without this, the
- * chunked invocation aborts the whole fallback and turns a recoverable
- * monolithic timeout into a hard setup failure.
- *
- * `git check-ignore -q -- <path>` exits 0 when the path is ignored, 1 when
- * it is not, and >=128 on real failures. Anything other than 0/1 is treated
- * as "unknown" and conservatively returns false, so the chunk runs and any
- * real underlying failure surfaces normally.
- */
-async function isPathIgnored(dir, relativePath) {
-    const result = await exec('git', ['check-ignore', '-q', '--', relativePath], { cwd: dir });
-    if (result.exitCode === 0)
-        return true;
-    if (result.exitCode === 1)
-        return false;
-    // Any other shape is "we don't know", so let the caller proceed and
-    // surface the real error if `git add` rejects the path.
-    return false;
-}
-/**
- * Stages every file by walking top-level directories one at a time. This
- * avoids a single monolithic `git add -A` that may time out on very large
- * (~300 K file) trees like Firefox.
- *
- * A chunked pass that hits its own timeout raises a typed
- * {@link GitIndexingTimeoutError} rather than an opaque `AbortError: The
- * operation was aborted`. The typed error carries the environment-variable
- * override so the operator can extend the budget and re-run.
- */
-async function stageAllFilesChunked(dir, scan, options = {}) {
-    const { directories, topLevelFiles: topLevelCandidates } = scan;
-    async function runChunk(args, label) {
-        try {
-            await git(args, dir, {
-                timeout: GIT_ADD_CHUNK_TIMEOUT_MS,
-                env: GIT_ADD_ENV,
-            });
-        }
-        catch (error) {
-            if (isTimeoutError(error)) {
-                throw new GitIndexingTimeoutError('chunked', GIT_ADD_CHUNK_TIMEOUT_MS, GIT_ADD_CHUNK_TIMEOUT_ENV_VAR, error instanceof Error ? error : undefined);
-            }
-            verbose(`Chunked staging failed on ${label}: ${toError(error).message}`);
-            throw error;
-        }
-    }
-    let stagedDirectories = 0;
-    for (const dirName of directories) {
-        stagedDirectories++;
-        if (await isPathIgnored(dir, dirName)) {
-            options.onProgress?.(`Skipping gitignored directory ${stagedDirectories}/${directories.length}: ${dirName}/`);
-            continue;
-        }
-        options.onProgress?.(`Staging directory ${stagedDirectories}/${directories.length}: ${dirName}/...`);
-        await runChunk(['add', '--', dirName], dirName);
-    }
-    // Stage any top-level files (excluding gitignored ones, because `git add`
-    // on an explicit ignored path errors out, which would otherwise
-    // abort the chunked fallback after the monolithic path has already
-    // timed out).
-    const topLevelFiles = [];
-    for (const name of topLevelCandidates) {
-        if (await isPathIgnored(dir, name)) {
-            options.onProgress?.(`Skipping gitignored top-level file: ${name}`);
-            continue;
-        }
-        topLevelFiles.push(name);
-    }
-    if (topLevelFiles.length > 0) {
-        options.onProgress?.(`Staging ${topLevelFiles.length} top-level file(s)...`);
-        await runChunk(['add', '--', ...topLevelFiles], 'top-level files');
-    }
-}
-/**
- * Interval between heartbeat progress messages during the monolithic
- * `git add -A`. On a fresh ~600 MB Firefox tree the monolithic add runs
- * 60 to 120 seconds, during which git emits nothing to stdout/stderr. Without a
- * heartbeat the CLI spinner stays pinned on "Indexing Firefox source …" for
- * the full window and looks hung, which invites a SIGINT mid-way.
- */
-const GIT_ADD_HEARTBEAT_MS = 15_000;
-const GIT_COMMIT_HEARTBEAT_MS = 15_000;
-async function scanTopLevelSource(dir) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    return {
-        directories: entries
-            .filter((entry) => entry.isDirectory() && entry.name !== '.git')
-            .map((entry) => entry.name)
-            .sort(),
-        topLevelFiles: entries
-            .filter((entry) => entry.isFile())
-            .map((entry) => entry.name)
-            .sort(),
-    };
-}
-/**
- * Stages all files in the repository.
- * Tries a monolithic `git add -A` first. If that times out, falls back to
- * directory-by-directory staged adds.
- */
-export async function stageAllFiles(dir, options = {}) {
-    const timeout = options.timeout ?? GIT_ADD_TIMEOUT_MS;
-    const reportProgress = options.onProgress;
-    reportProgress?.('Scanning Firefox source tree before indexing...');
-    const scan = await scanTopLevelSource(dir);
-    reportProgress?.(`Source scan complete: ${scan.directories.length} top-level director${scan.directories.length === 1 ? 'y' : 'ies'}, ${scan.topLevelFiles.length} top-level file${scan.topLevelFiles.length === 1 ? '' : 's'}`);
-    // The heartbeat tracks a per-phase start timestamp and labels each tick
-    // with the phase. A single start time set at function entry reports
-    // cumulative elapsed for the whole `stageAllFiles` invocation, so after a
-    // monolithic timeout the chunked-phase ticks name numbers that already
-    // include the entire monolithic budget, with no way to tell from the log
-    // where one attempt ended and the next began.
-    let phase = 'monolithic';
-    let phaseStartedAt = Date.now();
-    const heartbeatTimer = reportProgress
-        ? setInterval(() => {
-            const elapsedS = Math.round((Date.now() - phaseStartedAt) / 1000);
-            const label = phase === 'monolithic' ? 'monolithic' : 'chunked staging';
-            reportProgress(`Indexing Firefox source (${label}, ${elapsedS}s elapsed)`);
-        }, GIT_ADD_HEARTBEAT_MS)
-        : null;
-    heartbeatTimer?.unref();
-    try {
-        try {
-            reportProgress?.('Git phase: starting git add -A source indexing.');
-            reportProgress?.(`Starting monolithic git add -A for ${scan.directories.length} director${scan.directories.length === 1 ? 'y' : 'ies'} and ${scan.topLevelFiles.length} top-level file${scan.topLevelFiles.length === 1 ? '' : 's'}...`);
-            await git(['add', '-A'], dir, { timeout, env: GIT_ADD_ENV });
-            reportProgress?.('Git phase complete: git add -A source indexing finished.');
-            return;
-        }
-        catch (error) {
-            if (!isTimeoutError(error)) {
-                throw await maybeWrapIndexLockError(dir, error);
-            }
-            // Emit a loud, one-line banner so non-TTY log scrapers and TTY
-            // operators both see that the monolithic attempt lost and the chunked
-            // pass is starting. Without it the fallback transition is invisible
-            // and the heartbeat simply goes quiet for minutes.
-            options.onProgress?.(`Monolithic git add reached the ${Math.round(timeout / 1000)}s timeout; falling back to chunked staging. This pass may take several more minutes on a large tree.`);
-        }
-        // The killed process may have left an index lock
-        await cleanupIndexLock(dir);
-        // Reset elapsed accounting for the chunked phase so its heartbeat
-        // names a believable per-phase number rather than rolling the
-        // monolithic budget forward.
-        phase = 'chunked';
-        phaseStartedAt = Date.now();
-        await stageAllFilesChunked(dir, scan, options);
-        reportProgress?.('Git phase complete: chunked source indexing finished.');
-    }
-    finally {
-        if (heartbeatTimer)
-            clearInterval(heartbeatTimer);
-    }
-}
-async function createInitialSourceCommit(dir, reportProgress) {
-    const startedAt = Date.now();
-    reportProgress('Git phase: creating initial source commit.');
-    reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
-    const heartbeat = setInterval(() => {
-        reportProgress(`Creating initial Firefox source commit (${elapsedSince(startedAt)} elapsed)...`);
-    }, GIT_COMMIT_HEARTBEAT_MS);
-    heartbeat.unref();
-    try {
-        await git(['commit', '-m', 'Initial Firefox source'], dir);
-    }
-    finally {
-        clearInterval(heartbeat);
-    }
-    reportProgress(`Git phase complete: initial source commit created (${elapsedSince(startedAt)} elapsed).`);
-}
-/**
- * Initializes a new git repository with an orphan branch.
- * @param dir - Directory to initialize
- * @param branchName - Name for the initial branch
- */
-export async function initRepository(dir, branchName = 'main', options = {}) {
-    await ensureGit();
-    const reportProgress = options.onProgress ?? (() => { });
-    // Initialize repository
-    reportProgress('Git phase: initializing source git repository.');
-    reportProgress('Creating git repository...');
-    await git(['init'], dir);
-    // Create orphan branch
-    reportProgress(`Creating ${branchName} baseline branch...`);
-    await git(['checkout', '--orphan', branchName], dir);
-    // Configure git for the repository
-    reportProgress('Configuring git identity...');
-    await git(['config', 'user.email', 'fireforge@localhost'], dir);
-    await git(['config', 'user.name', 'FireForge'], dir);
-    // Enable performance settings for large trees
-    reportProgress('Configuring git performance settings...');
-    await configureGitPerformance(dir);
-    await configureGitLineEndings(dir);
-    // Add a local-only origin remote so that Firefox's mach bootstrap and
-    // build scripts (which shell out to `git remote get-url origin`) don't
-    // fail.  Nothing is ever fetched from or pushed to this remote.
-    reportProgress('Configuring origin remote for build compatibility...');
-    await git(['remote', 'add', 'origin', 'https://github.com/mozilla-firefox/firefox'], dir);
-    reportProgress('Git phase complete: source git repository metadata initialized.');
-    await stageAndCommitSource(dir, reportProgress, 'Indexing Firefox source with git add -A (this can take several minutes on large trees)...');
-}
-/**
- * The tail shared by {@link initRepository} and {@link resumeRepository}:
- * normalizes the Firefox ignore files, stages the whole tree, and creates
- * the initial source commit. Index-lock failures on either git step are
- * wrapped into the typed lock error so both entry points report them the
- * same way.
- */
-async function stageAndCommitSource(dir, reportProgress, stagingMessage) {
-    reportProgress('Normalizing Firefox ignore files for Git-backed mach lint compatibility...');
-    await ensureFirefoxIgnorefileCompatibility(dir);
-    // Add all files
-    reportProgress(stagingMessage);
-    await assertNoGitIndexLock(dir);
-    try {
-        await stageAllFiles(dir, { onProgress: reportProgress });
-    }
-    catch (error) {
-        throw await maybeWrapIndexLockError(dir, error);
-    }
-    // Create initial commit
-    try {
-        await createInitialSourceCommit(dir, reportProgress);
-    }
-    catch (error) {
-        throw await maybeWrapIndexLockError(dir, error);
-    }
-}
-/**
- * Resumes a partially initialized git repository (e.g. after a killed
- * `git add -A` left an unborn HEAD).  Re-applies performance settings,
- * cleans up stale locks, stages all files, and creates the initial commit.
- */
-export async function resumeRepository(dir, options = {}) {
-    const reportProgress = options.onProgress ?? (() => { });
-    if (!(await isGitRepository(dir))) {
-        throw new GitError('Not a git repository', 'resume');
-    }
-    reportProgress('Resuming interrupted repository initialization...');
-    // Ensure performance settings are in place (may not have been set)
-    reportProgress('Configuring git performance settings...');
-    await configureGitPerformance(dir);
-    await configureGitLineEndings(dir);
-    // Clean up any stale index lock left by the killed process
-    await cleanupIndexLock(dir);
-    // Ensure origin remote exists (may have been added before the interrupt)
-    await ensureOriginRemote(dir);
-    await stageAndCommitSource(dir, reportProgress, 'Indexing Firefox source (resuming)...');
-}
-async function assertNoGitIndexLock(dir) {
-    const lockPath = join(dir, '.git', 'index.lock');
-    if (!(await pathExists(lockPath))) {
-        return;
-    }
-    throw new GitIndexLockError(lockPath, await getLockAgeMs(lockPath));
-}
-async function getLockAgeMs(lockPath) {
-    try {
-        const stats = await stat(lockPath);
-        return Math.max(0, Date.now() - stats.mtimeMs);
-    }
-    catch {
-        return undefined;
-    }
-}
-async function maybeWrapIndexLockError(dir, error) {
-    const lockPath = join(dir, '.git', 'index.lock');
-    if (error instanceof GitError &&
-        /index\.lock/i.test(error.message) &&
-        /(unable to create|another git process seems to be running|file exists)/i.test(error.message)) {
-        return new GitIndexLockError(lockPath);
-    }
-    if (error instanceof GitError &&
-        /(unable to create|locked|lock file)/i.test(error.message) &&
-        (await pathExists(lockPath))) {
-        return new GitIndexLockError(lockPath, await getLockAgeMs(lockPath));
-    }
-    return toError(error);
-}
-/**
- * Applies a patch file using git apply.
- * @param patchPath - Path to the patch file
- * @param repoDir - Repository directory
- * @param options - Application options
- */
-export async function applyPatch(patchPath, repoDir, options = {}) {
-    await ensureGit();
-    if (!options.reject) {
-        const checkArgs = ['apply', '--check', '--', patchPath];
-        const result = await exec('git', checkArgs, { cwd: repoDir });
-        if (result.exitCode !== 0) {
-            throw new PatchApplyError(patchPath, new Error(result.stderr));
-        }
-    }
-    // Actually apply the patch
-    const applyArgs = ['apply'];
-    if (options.reject) {
-        applyArgs.push('--reject');
-    }
-    applyArgs.push('--', patchPath);
-    const applyResult = await exec('git', applyArgs, { cwd: repoDir });
-    if (applyResult.exitCode !== 0) {
-        throw new PatchApplyError(patchPath, new Error(applyResult.stderr));
-    }
-}
-/**
- * Applies a patch idempotently using reverse-forward pattern. First tries to
- * reverse the patch (in case it is already applied), then applies it forward.
- *
- * @param patchPath - Path to the patch file
- * @param repoDir - Repository directory
- * @param options.reject - Fall back to `git apply --reject`
- * @param options.protectedFiles - Files that must not be reset to HEAD by the
- *   recovery step. Callers applying a patch queue pass the files already
- *   touched by previously applied patches in the same run: two overlapping
- *   patches (an `--allow-overlap` queue) share files, and a blanket
- *   `checkout HEAD` would wipe the earlier patch's changes from the shared
- *   file before applying the later one, leaving the engine in a hybrid state
- *   the summary never describes.
- */
-export async function applyPatchIdempotent(patchPath, repoDir, options = {}) {
-    await ensureGit();
-    // Try to reverse the patch (ignore errors if not applied)
-    const reverseResult = await exec('git', ['apply', '--reverse', '--', patchPath], {
-        cwd: repoDir,
-    });
-    // If reverse failed (patch wasn't applied), restore only the files the
-    // patch would have touched so that unrelated local edits are preserved.
-    if (reverseResult.exitCode !== 0) {
-        // Extract the set of files referenced in the patch
-        const listResult = await exec('git', ['apply', '--numstat', '--', patchPath], { cwd: repoDir });
-        const touchedFiles = listResult.stdout
-            .split('\n')
-            .map((line) => line.split('\t')[2])
-            .filter((f) => !!f)
-            .filter((f) => !(options.protectedFiles?.has(f) ?? false));
-        if (touchedFiles.length > 0) {
-            await restoreFilesToHead(repoDir, patchPath, touchedFiles);
-        }
-    }
-    // Apply forward
-    await applyPatch(patchPath, repoDir, options);
-}
-/**
- * Restores `files` to their HEAD state, deleting files the patch would create
- * (present on disk from a partial apply but absent in HEAD, where
- * `git checkout HEAD --` fails, and ignoring that failure leaves stray files
- * that make the subsequent forward apply die with "already exists" and no
- * hint why).
- *
- * Every git invocation is chunked via {@link chunkPathspecs} so a very large
- * patch cannot hit `E2BIG`, and every exit code is checked. A silent failed
- * restore is the confusing state this recovery step exists to prevent.
- */
-async function restoreFilesToHead(repoDir, patchPath, files) {
-    // Partition into tracked-in-HEAD (restore via checkout) and absent-in-HEAD
-    // (patch-created leftovers: delete from the worktree).
-    const trackedInHead = new Set();
-    for (const chunk of chunkPathspecs(files)) {
-        const lsTree = await exec('git', ['ls-tree', '-r', '--name-only', 'HEAD', '--', ...chunk], {
-            cwd: repoDir,
-        });
-        if (lsTree.exitCode !== 0) {
-            throw new PatchApplyError(patchPath, new Error(`git ls-tree failed while preparing recovery: ${lsTree.stderr.trim()}`));
-        }
-        for (const line of lsTree.stdout.split('\n')) {
-            if (line.length > 0)
-                trackedInHead.add(line);
-        }
-    }
-    const toCheckout = files.filter((f) => trackedInHead.has(f));
-    const toDelete = files.filter((f) => !trackedInHead.has(f));
-    for (const chunk of chunkPathspecs(toCheckout)) {
-        const checkout = await exec('git', ['checkout', 'HEAD', '--', ...chunk], { cwd: repoDir });
-        if (checkout.exitCode !== 0) {
-            throw new PatchApplyError(patchPath, new Error(`Could not restore patch-touched files to HEAD before applying: ${checkout.stderr.trim()}`));
-        }
-    }
-    for (const file of toDelete) {
-        const target = join(repoDir, file);
-        if (await pathExists(target)) {
-            await removeFile(target);
-            verbose(`Removed stray patch-created file before apply: ${file}`);
-        }
-    }
-}
-/**
- * Reverses a previously applied patch.
- * @param patchPath - Path to the patch file
- * @param repoDir - Repository directory
- */
-export async function reversePatch(patchPath, repoDir) {
-    await ensureGit();
-    const result = await exec('git', ['apply', '--reverse', '--', patchPath], { cwd: repoDir });
-    if (result.exitCode !== 0) {
-        throw new PatchApplyError(patchPath, new Error(result.stderr));
-    }
-}
-/**
- * Checks if the repository has uncommitted changes.
- * @param repoDir - Repository directory
- * @returns True if there are uncommitted changes
- */
-export async function hasChanges(repoDir) {
-    const entries = await getWorkingTreeStatus(repoDir);
-    return entries.length > 0;
-}
-/**
- * Checks whether an error indicates the repository has no HEAD (e.g. unborn branch).
- * @param error - The error to check
- * @returns True if the error is a missing-HEAD error
- */
-export function isMissingHeadError(error) {
-    return (error instanceof Error &&
-        /(ambiguous argument 'HEAD'|unknown revision or path not in the working tree)/i.test(error.message));
-}
-/**
- * Gets the current HEAD commit hash.
- * @param repoDir - Repository directory
- * @returns Commit hash
- */
-export async function getHead(repoDir) {
-    const output = await git(['rev-parse', 'HEAD'], repoDir);
-    return output.trim();
-}
-/**
- * Gets the current branch name.
- * @param repoDir - Repository directory
- * @returns Branch name
- */
-export async function getCurrentBranch(repoDir) {
-    const output = await git(['rev-parse', '--abbrev-ref', 'HEAD'], repoDir);
-    return output.trim();
-}
-/**
- * Resets all changes in the repository.
- * @param repoDir - Repository directory
- */
-export async function resetChanges(repoDir) {
-    try {
-        await git(['reset', '--hard', 'HEAD'], repoDir);
-    }
-    catch (error) {
-        throw await maybeWrapIndexLockError(repoDir, error);
-    }
-    await git(['clean', '-fd'], repoDir);
-}
-/**
- * Gets the status of files with their status codes.
- * @param repoDir - Repository directory
- * @returns Array of [status, filepath] tuples
- */
-export async function getStatusWithCodes(repoDir) {
-    const entries = await getWorkingTreeStatus(repoDir);
-    return entries.map((entry) => ({
-        status: entry.status.trim(),
-        file: entry.file,
-    }));
-}

package/dist/src/core/harness-helper-pids.d.ts

@@ -1,98 +0,0 @@
-/**
- * Teardown reaper for the helper processes one mach test dispatch launched.
- *
- * The mochitest harness starts its httpd (`xpcshell … server.js`), the
- * websocket server, ssltunnel and the websocket/process bridge as plain
- * children, and the browser through mozprocess, which puts it in a process
- * group of its own. It logs each launch as `runtests.py | <what> pid: <n>`.
- * When mach dies before its own cleanup runs (a forwarded SIGTERM, a
- * no-output timeout, a harness crash, a supervisor kill), the helpers do not
- * necessarily die with it: the 2026-09-13 incident left the httpd reparented
- * to launchd at 100% CPU for hours after a gate killed the run at its bound.
- *
- * The exec layer already sweeps the dispatch's process group after close.
- * That reaches every helper that stayed in the group, and nothing else: the
- * browser is in its own group, and a helper that re-grouped itself is not.
- * This module closes that gap in two passes:
- *
- *  - {@link createHelperPidTracker} collects the announced pids from the
- *    streamed output. {@link reapTrackedHarnessPids} runs after mach has
- *    exited; a tracked pid still alive at that point is by definition a
- *    survivor (its parent is gone), so no age heuristic is needed. Before
- *    signalling, each pid is re-read from `ps` and must still be anchored to
- *    the objdir and still look like the thing the harness launched: a pid
- *    recycled onto an unrelated process between the launch line and
- *    teardown is skipped.
- *  - Not every helper is announced. mozserve starts `moz-http2` with
- *    `start_new_session=True` and logs no pid, so it is in neither the
- *    group nor the tracker, and it was the other survivor of the incident.
- *    {@link snapshotObjdirHelpers} records which same-objdir helpers existed
- *    before the dispatch spawned; after mach exits, a helper-shaped process
- *    under THIS checkout's absolute objdir that is not in that baseline and
- *    is reparented (its parent, the harness, is gone) is one this dispatch
- *    launched, and is reaped too. The absolute-path anchor keeps a sibling
- *    checkout's live harness out of it; the baseline keeps a survivor of an
- *    earlier run out of it, so the preflight census's report-only posture
- *    still decides that one's fate.
- */
-/**
- * What the harness said it launched, as it names it in the log line, or
- * `unannounced` for a survivor found by the post-close objdir scan.
- */
-export type TrackedHarnessKind = 'Server' | 'Websocket server' | 'SSL tunnel' | 'websocket/process bridge' | 'Application' | 'unannounced';
-/** One helper the harness launched. */
-export interface TrackedHarnessPid {
-    pid: number;
-    kind: TrackedHarnessKind;
-    /** Command line, when the entry came from `ps` rather than a log line. */
-    command?: string;
-}
-/** Which child stream a chunk came from. */
-export type OutputStreamName = 'stdout' | 'stderr';
-/** Collects harness launch announcements from streamed output chunks. */
-export interface HelperPidTracker {
-    /** Feed one chunk. Chunk boundaries need not align with lines. */
-    feed(stream: OutputStreamName, chunk: string): void;
-    /** Every pid announced so far, in announcement order, without duplicates. */
-    tracked(): TrackedHarnessPid[];
-}
-/**
- * Creates a tracker for one dispatch. The two streams are buffered apart so
- * a half-line on one cannot be glued to a half-line on the other.
- */
-export declare function createHelperPidTracker(): HelperPidTracker;
-/**
- * Decides whether a `ps` row still describes the process the harness
- * announced. Exported for fixture tests.
- *
- * The helpers must match the census's helper pattern and the objdir anchor.
- * The browser has no helper-shaped name, so the anchor alone attributes it:
- * its binary lives under the objdir (`<objdir>/dist/<App>.app/…`).
- */
-export declare function isStillTrackedProcess(tracked: TrackedHarnessPid, command: string, objDir: string | undefined): boolean;
-/**
- * Records the same-objdir helpers alive before a dispatch spawns anything,
- * so the post-close pass can tell this dispatch's unannounced helpers from
- * an earlier run's survivors. Undefined when `ps` is unusable or no objdir
- * is known; the post-close pass then reaps no unannounced process at all.
- *
- * @param objDir - This project's absolute objdir
- * @returns The pids to leave alone at teardown, or undefined for "no baseline"
- */
-export declare function snapshotObjdirHelpers(objDir: string | undefined): Promise<Set<number> | undefined>;
-/**
- * Terminates every process this dispatch launched that is still alive after
- * mach exited: the announced pids still attributable to the dispatch, and
- * the unannounced same-objdir survivors that appeared since the baseline.
- *
- * Best-effort like the census: a host without `ps` logs at verbose and
- * reaps nothing rather than signalling on the strength of a pid alone.
- *
- * @param tracked - The pids the harness announced during the dispatch
- * @param objDir - This project's absolute objdir, for the anchor rule
- * @param baseline - Same-objdir helpers alive before the dispatch spawned
- *   ({@link snapshotObjdirHelpers}); never touched here. Undefined disables
- *   the unannounced pass entirely
- * @returns How many survivors are confirmed gone afterwards
- */
-export declare function reapTrackedHarnessPids(tracked: readonly TrackedHarnessPid[], objDir: string | undefined, baseline?: ReadonlySet<number>): Promise<number>;