@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/commands/doctor-macos-sdk.js

@@ -1,158 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Doctor check: can the bootstrapped clang link against the macOS SDK the
- * build will use?
- *
- * An Xcode update can ship an SDK whose `.tbd` stubs the pinned toolchain
- * cannot read (Xcode 27.0's `libSystem.tbd` lists `arm64e.x1-macos`
- * targets that clang/lld 21.1.8 rejects as "unknown architecture"). `mach
- * configure` then dies at "checking what kind of list files are supported
- * by the linker" with exit 5, and neither `build` nor `doctor` named the
- * cause: the operator had to read `config.log`. This check links a trivial
- * C program with the bootstrapped clang against the SDK the mozconfig
- * selects, and on failure names the mismatch and lists the SDKs installed.
- *
- * darwin only, and only when a bootstrapped clang exists. A warning, never
- * a failure: the SDK may be one the operator is about to replace. Host SDK
- * and mozconfig paths are built with `posix.join`: they are macOS paths
- * whatever platform the module is loaded on.
- */
-import { existsSync } from 'node:fs';
-import { mkdtemp, readdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, posix } from 'node:path';
-import { mozbuildStateDir } from '../core/toolchain-preflight.js';
-import { toError } from '../utils/errors.js';
-import { exec } from '../utils/process.js';
-import { ok, warning } from './doctor-check-core.js';
-const CHECK_NAME = 'macOS SDK links with the bootstrapped clang';
-/** The bootstrapped clang mach uses on macOS. */
-export function bootstrappedClangPath() {
-    return join(mozbuildStateDir(), 'clang', 'bin', 'clang');
-}
-/**
- * Sources a mozconfig with `ac_add_options` stubbed to print the
- * `--with-macos-sdk=` value, which is how mach reads it. A mozconfig is a
- * shell script: an SDK chosen by shell logic (the first of several
- * candidates that exists) has no literal value to grep.
- */
-const SDK_FROM_MOZCONFIG_SCRIPT = [
-    'ac_add_options() { for a in "$@"; do case "$a" in --with-macos-sdk=*) printf "%s\\n" "${a#--with-macos-sdk=}";; esac; done; }',
-    'mk_add_options() { :; }',
-    '. "$1"',
-].join('\n');
-/**
- * Resolves the SDK the generated mozconfig selects (`--with-macos-sdk`),
- * falling back to `xcrun --show-sdk-path`, which is what configure
- * auto-detects when the mozconfig names none.
- */
-async function resolveSelectedSdk(engineDir) {
-    const mozconfig = posix.join(engineDir, 'mozconfig');
-    if (existsSync(mozconfig)) {
-        const sourced = await exec('/bin/sh', ['-c', SDK_FROM_MOZCONFIG_SCRIPT, 'sh', mozconfig], {
-            cwd: engineDir,
-            env: { topsrcdir: engineDir },
-            timeout: 10_000,
-        });
-        if (sourced.exitCode !== 0) {
-            return {
-                error: `engine/mozconfig failed while selecting the SDK: ${firstLine(sourced.stderr) ?? `exit ${sourced.exitCode}`}`,
-            };
-        }
-        const selected = sourced.stdout
-            .split('\n')
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0)
-            .pop();
-        if (selected !== undefined)
-            return { sdk: selected, source: 'mozconfig' };
-    }
-    const xcrun = await exec('xcrun', ['--show-sdk-path'], { timeout: 10_000 });
-    const path = xcrun.stdout.trim();
-    if (xcrun.exitCode !== 0 || path.length === 0) {
-        return { error: `xcrun --show-sdk-path failed: ${firstLine(xcrun.stderr) ?? 'no output'}` };
-    }
-    return { sdk: path, source: 'xcrun' };
-}
-function firstLine(text) {
-    return text
-        .split('\n')
-        .map((line) => line.trim())
-        .find((line) => line.length > 0);
-}
-/** Every macOS SDK directory on the host FireForge knows where to look for. */
-async function listInstalledSdks() {
-    const roots = [mozbuildStateDir(), '/Library/Developer/CommandLineTools/SDKs'];
-    const developer = await exec('xcode-select', ['-p'], { timeout: 10_000 });
-    if (developer.exitCode === 0 && developer.stdout.trim().length > 0) {
-        roots.push(posix.join(developer.stdout.trim(), 'Platforms/MacOSX.platform/Developer/SDKs'));
-    }
-    const found = [];
-    for (const root of roots) {
-        try {
-            for (const entry of await readdir(root)) {
-                if (/^MacOSX.*\.sdk$/.test(entry))
-                    found.push(posix.join(root, entry));
-            }
-        }
-        catch {
-            // A root that does not exist lists nothing.
-        }
-    }
-    return found;
-}
-/**
- * Links `int main(void){return 0;}` with the bootstrapped clang (through
- * its bundled lld, as the build does) against `sdk`, in a temp directory.
- * @returns undefined on success, else the first error line clang printed
- */
-async function probeSdkLink(clang, sdk) {
-    const dir = await mkdtemp(join(tmpdir(), 'fireforge-sdk-probe-'));
-    try {
-        await writeFile(join(dir, 'probe.c'), 'int main(void) { return 0; }\n');
-        const lld = existsSync(join(clang, '..', 'ld64.lld')) ? ['-fuse-ld=lld'] : [];
-        const linked = await exec(clang, ['-isysroot', sdk, ...lld, '-o', join(dir, 'probe'), join(dir, 'probe.c')], { timeout: 30_000 });
-        if (linked.exitCode === 0)
-            return undefined;
-        const output = `${linked.stderr}\n${linked.stdout}`;
-        return (output
-            .split('\n')
-            .map((line) => line.trim())
-            .find((line) => /error:/.test(line)) ??
-            firstLine(output) ??
-            `exit ${linked.exitCode}`);
-    }
-    finally {
-        await rm(dir, { recursive: true, force: true });
-    }
-}
-/** Runs the check for one engine directory. */
-export async function checkMacosSdkLink(engineDir) {
-    const selected = await resolveSelectedSdk(engineDir);
-    const fix = 'Pin an SDK the bootstrapped toolchain can link in configs/darwin.mozconfig ' +
-        '(ac_add_options --with-macos-sdk=<path>), then run fireforge build.';
-    if ('error' in selected) {
-        return warning(CHECK_NAME, selected.error, fix);
-    }
-    let failure;
-    try {
-        failure = await probeSdkLink(bootstrappedClangPath(), selected.sdk);
-    }
-    catch (error) {
-        failure = toError(error).message;
-    }
-    if (failure === undefined) {
-        return ok(CHECK_NAME, `OK (${selected.sdk}, from ${selected.source})`);
-    }
-    const installed = await listInstalledSdks();
-    return warning(CHECK_NAME, `The bootstrapped clang cannot link against ${selected.sdk} (from ${selected.source}): ${failure}. ` +
-        `mach configure fails at its linker probe the same way. Installed SDKs: ` +
-        (installed.length > 0 ? installed.join(', ') : 'none found') +
-        '.', fix);
-}
-/** Registry entry for the doctor runner. */
-export const MACOS_SDK_LINK_DOCTOR_CHECK = {
-    name: CHECK_NAME,
-    skipIf: (ctx) => process.platform !== 'darwin' || !ctx.engineExists || !existsSync(bootstrappedClangPath()),
-    run: (ctx) => checkMacosSdkLink(ctx.paths.engine),
-};

package/dist/src/commands/doctor-orphaned-harness.d.ts

@@ -1,41 +0,0 @@
-/**
- * Doctor check for pre-existing orphaned test-harness workers.
- *
- * A mach invocation that dies at harness startup can strand a Python
- * `multiprocessing` spawn worker plus its resource tracker. The worker
- * reparents to launchd (PPID 1) and busy-spins at 100% CPU indefinitely.
- * The dispatch-side fix is the process-group reaping in `utils/process.ts`.
- * This check covers orphans that predate it (or leaked from non-FireForge
- * invocations), detecting them by PPID 1 + large accumulated CPU TIME + a
- * `multiprocessing.spawn`/`resource_tracker` command line.
- *
- * Report-only: FireForge never kills pre-existing processes it did not
- * spawn, so the check names each candidate and suggests the kill.
- *
- * Not wired into `test --canary`: a system-wide process scan on the canary
- * hot path buys no coverage the doctor check does not already give.
- */
-import type { DoctorCheckDefinition } from './doctor-check-core.js';
-/** One process matching the orphaned-harness-worker shape. */
-export interface OrphanedHarnessWorker {
-    pid: number;
-    ppid: number;
-    /** Raw TIME column as `ps` printed it. */
-    cpuTime: string;
-    /** Parsed accumulated CPU seconds. */
-    cpuSeconds: number;
-    command: string;
-}
-/**
- * Scans `ps -axo pid=,ppid=,time=,command=` output for orphaned harness
- * workers: PPID 1 (reparented to init/launchd), a multiprocessing
- * worker/tracker command line, and at least `minCpuSeconds` of accumulated
- * CPU time. Pure, so it is fixture-testable without spawning anything.
- */
-export declare function findOrphanedHarnessWorkers(psOutput: string, minCpuSeconds?: number): OrphanedHarnessWorker[];
-/**
- * Doctor check reporting orphaned harness workers. Windows has no `ps`, so
- * the check is skipped there (best-effort platform gap, matching the
- * process-group reaper's POSIX-only sweep).
- */
-export declare const ORPHANED_HARNESS_DOCTOR_CHECK: DoctorCheckDefinition;

package/dist/src/commands/doctor-orphaned-harness.js

@@ -1,98 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Doctor check for pre-existing orphaned test-harness workers.
- *
- * A mach invocation that dies at harness startup can strand a Python
- * `multiprocessing` spawn worker plus its resource tracker. The worker
- * reparents to launchd (PPID 1) and busy-spins at 100% CPU indefinitely.
- * The dispatch-side fix is the process-group reaping in `utils/process.ts`.
- * This check covers orphans that predate it (or leaked from non-FireForge
- * invocations), detecting them by PPID 1 + large accumulated CPU TIME + a
- * `multiprocessing.spawn`/`resource_tracker` command line.
- *
- * Report-only: FireForge never kills pre-existing processes it did not
- * spawn, so the check names each candidate and suggests the kill.
- *
- * Not wired into `test --canary`: a system-wide process scan on the canary
- * hot path buys no coverage the doctor check does not already give.
- */
-import { toError } from '../utils/errors.js';
-import { exec } from '../utils/process.js';
-import { parsePsDuration } from '../utils/ps-duration.js';
-import { ok, warning } from './doctor-check-core.js';
-/**
- * Command-line shapes of Python multiprocessing helper processes: the
- * spawn/forkserver worker bootstrap (`from multiprocessing.spawn import
- * spawn_main; spawn_main(...)`) and the resource tracker.
- */
-const HARNESS_WORKER_COMMAND_PATTERN = /multiprocessing\.(?:spawn|forkserver)\b|multiprocessing\.resource_tracker|from multiprocessing\.\w+ import/;
-/** Minimum accumulated CPU time before a match is reported (10 minutes). */
-const DEFAULT_MIN_CPU_SECONDS = 600;
-/**
- * Scans `ps -axo pid=,ppid=,time=,command=` output for orphaned harness
- * workers: PPID 1 (reparented to init/launchd), a multiprocessing
- * worker/tracker command line, and at least `minCpuSeconds` of accumulated
- * CPU time. Pure, so it is fixture-testable without spawning anything.
- */
-export function findOrphanedHarnessWorkers(psOutput, minCpuSeconds = DEFAULT_MIN_CPU_SECONDS) {
-    const workers = [];
-    for (const line of psOutput.split('\n')) {
-        const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/.exec(line);
-        if (!match)
-            continue;
-        const pid = Number(match[1]);
-        const ppid = Number(match[2]);
-        const cpuTime = match[3] ?? '';
-        const command = (match[4] ?? '').trim();
-        if (ppid !== 1)
-            continue;
-        if (!HARNESS_WORKER_COMMAND_PATTERN.test(command))
-            continue;
-        const cpuSeconds = parsePsDuration(cpuTime);
-        if (Number.isNaN(cpuSeconds) || cpuSeconds < minCpuSeconds)
-            continue;
-        workers.push({ pid, ppid, cpuTime, cpuSeconds, command });
-    }
-    return workers;
-}
-/** Thin exec wrapper for the process listing (tests mock `exec` instead). */
-async function listSystemProcesses() {
-    const result = await exec('ps', ['-axo', 'pid=,ppid=,time=,command='], { timeout: 10000 });
-    if (result.exitCode !== 0) {
-        throw new Error(`ps exited ${result.exitCode}`);
-    }
-    return result.stdout;
-}
-const CHECK_NAME = 'Orphaned harness workers';
-async function runOrphanedHarnessCheck() {
-    let psOutput;
-    try {
-        psOutput = await listSystemProcesses();
-    }
-    catch (error) {
-        return warning(CHECK_NAME, `Could not scan system processes (${toError(error).message}); skipping the orphaned-worker check.`);
-    }
-    const orphans = findOrphanedHarnessWorkers(psOutput);
-    if (orphans.length === 0) {
-        return ok(CHECK_NAME);
-    }
-    const rows = orphans
-        .map((w) => `PID ${w.pid} (CPU time ${w.cpuTime}): ${w.command.slice(0, 160)}`)
-        .join('; ');
-    const pids = orphans.map((w) => String(w.pid)).join(' ');
-    return warning(CHECK_NAME, `Found ${orphans.length} orphaned Python multiprocessing worker(s) — PPID 1 with ` +
-        `high accumulated CPU time, the shape a test harness that died at startup leaves behind ` +
-        `(field incident: one such worker busy-spun for ~26 days). ${rows}`, `These look like workers orphaned by a crashed test harness. Verify each command line, ` +
-        `then terminate with: kill ${pids} (or kill -9 if a process survives). ` +
-        'FireForge never kills pre-existing processes automatically.');
-}
-/**
- * Doctor check reporting orphaned harness workers. Windows has no `ps`, so
- * the check is skipped there (best-effort platform gap, matching the
- * process-group reaper's POSIX-only sweep).
- */
-export const ORPHANED_HARNESS_DOCTOR_CHECK = {
-    name: CHECK_NAME,
-    skipIf: () => process.platform === 'win32',
-    run: runOrphanedHarnessCheck,
-};

package/dist/src/commands/doctor-patch-manifest.d.ts

@@ -1,9 +0,0 @@
-/**
- * The patch-manifest consistency check and its two repair paths, split out of
- * `doctor.ts` for the line budget. Exports a single `DoctorCheckDefinition`
- * consumed by the doctor registry. No registrar is exported and none is
- * wanted.
- */
-import type { DoctorCheckDefinition } from './doctor-check-core.js';
-/** Patch manifest consistency check, with its opt-in repair paths. */
-export declare const PATCH_MANIFEST_CONSISTENCY_CHECK: DoctorCheckDefinition;

package/dist/src/commands/doctor-patch-manifest.js

@@ -1,156 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The patch-manifest consistency check and its two repair paths, split out of
- * `doctor.ts` for the line budget. Exports a single `DoctorCheckDefinition`
- * consumed by the doctor registry. No registrar is exported and none is
- * wanted.
- */
-import { rebuildPatchesManifest, recommendManifestRepair, repairPatchesFilesAffected, validatePatchesManifestConsistency, } from '../core/patch-manifest.js';
-import { FireForgeError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
-import { info, warn } from '../utils/logger.js';
-import { resolveWaitLockSeconds } from '../utils/options.js';
-import { failure, ok, warning } from './doctor-check-core.js';
-const CHECK_NAME = 'Patch manifest consistency';
-/** Runs the narrow `filesAffected` repair over the drifted rows. */
-async function runFilesAffectedRepair(ctx, issues) {
-    const drifted = issues.filter((issue) => issue.code === 'files-affected-mismatch');
-    const otherCodes = [
-        ...new Set(issues.filter((issue) => issue.code !== 'files-affected-mismatch').map((issue) => issue.code)),
-    ].sort((left, right) => left.localeCompare(right));
-    if (drifted.length === 0) {
-        return failure(CHECK_NAME, `--repair-files-affected has nothing to repair: no filesAffected drift, but ${issues.length} ` +
-            `other issue(s) remain (${otherCodes.join(', ')}).`, recommendManifestRepair(issues));
-    }
-    const dryRun = ctx.options.dryRun === true;
-    const result = await repairPatchesFilesAffected(ctx.paths.patches, drifted.map((issue) => issue.filename), {
-        waitLockSeconds: resolveWaitLockSeconds(ctx.options.waitLock),
-        command: 'doctor --repair-files-affected',
-        dryRun,
-    });
-    for (const repair of result.repairs) {
-        info(`  ${describeFilesAffectedRepair(repair, dryRun)}`);
-    }
-    for (const filename of result.skippedFilenames) {
-        warn(`Skipped ${filename}: it has no manifest row, or no patch file on disk. ` +
-            'That is a different consistency issue — re-run doctor without --repair-files-affected ' +
-            'to see it reported.');
-    }
-    if (result.written) {
-        ctx.mutations.push(`patches/patches.json — filesAffected corrected on ${describeCount(result.repairs.length)} (--repair-files-affected)`);
-    }
-    const remaining = otherCodes.length > 0
-        ? ` ${otherCodes.length} other issue type(s) remain: ${otherCodes.join(', ')}.`
-        : '';
-    if (otherCodes.length > 0) {
-        return failure(CHECK_NAME, `${summarizeFilesAffected(result.repairs.length, dryRun)}${remaining}`, recommendManifestRepair(issues.filter((issue) => issue.code !== 'files-affected-mismatch')));
-    }
-    return warning(CHECK_NAME, summarizeFilesAffected(result.repairs.length, dryRun));
-}
-function describeFilesAffectedRepair(repair, dryRun) {
-    const verb = dryRun ? 'would set' : 'set';
-    return `${repair.filename}: ${verb} filesAffected to ${repair.after.length} file(s) (was ${repair.before.length}).`;
-}
-function summarizeFilesAffected(count, dryRun) {
-    if (count === 0)
-        return 'No filesAffected drift to repair.';
-    return dryRun
-        ? `Dry run — would correct filesAffected on ${describeCount(count)}. Nothing was written.`
-        : `Corrected filesAffected on ${describeCount(count)}. No other manifest field was touched.`;
-}
-function describeCount(count) {
-    return `${count} patch${count === 1 ? '' : 'es'}`;
-}
-/** Runs the whole-manifest rebuild. */
-async function runManifestRebuild(ctx) {
-    // Repair stamps sourceEsrVersion into every recovered entry. If the
-    // earlier "fireforge.json is valid" check failed, ctx.config is
-    // undefined and we must refuse rather than fabricate a fallback.
-    // Persisting 'unknown' into manifest metadata is hard to reverse
-    // and would mislead every later command that reads it.
-    if (!ctx.config) {
-        return failure(CHECK_NAME, 'Cannot repair patches.json: fireforge.json could not be loaded, so the Firefox version to stamp into recovered manifest entries is unknown.', 'Fix the fireforge.json errors reported above and re-run "fireforge doctor --repair-patches-manifest". ' +
-            'If the drift is only in filesAffected, "fireforge doctor --repair-files-affected" needs no config.');
-    }
-    const dryRun = ctx.options.dryRun === true;
-    const repaired = await rebuildPatchesManifest(ctx.paths.patches, ctx.config.firefox.version, {
-        waitLockSeconds: resolveWaitLockSeconds(ctx.options.waitLock),
-        command: 'doctor --repair-patches-manifest',
-        dryRun,
-        ...(ctx.options.allowMetadataLoss === true ? { allowMetadataLoss: true } : {}),
-    });
-    // The repair path must not silently overwrite human-written
-    // descriptions on recovered entries, which leaves the queue less
-    // trustworthy as an audit trail. The rebuilder returns the list of
-    // filenames whose metadata was entirely invented, named explicitly
-    // here so the operator knows which patches to review. Entries that
-    // were preserved (only `filesAffected` / ordering drifted) are not
-    // flagged.
-    for (const filename of repaired.recoveredFilenames) {
-        // Telling the operator to hand-edit patches.json contradicts the
-        // README and downstream docs, which treat the manifest as
-        // FireForge-owned. Point at the existing `re-export` / `export`
-        // workflow so the fix stays inside the tool: re-exporting the
-        // same files with an explicit `--description` overwrites the
-        // recovered entry with operator-supplied metadata and supersedes
-        // the mtime-based createdAt stamp.
-        warn(`Recovered manifest entry for ${filename} with generic description and mtime-based createdAt. ` +
-            'Re-export the affected files with `fireforge re-export <filename> --description "<your description>"` ' +
-            '(or `fireforge export <paths...> --name <name> --category <category> --description "<your description>"`) ' +
-            'to overwrite the reconstructed metadata, or accept the generic description if the original text is not recoverable. ' +
-            'Avoid hand-editing patches.json — FireForge owns that file and will regenerate it on the next manifest consistency pass.');
-    }
-    // A row whose patch file is gone is dropped by the rebuild. That is
-    // correct, since the patch file is the source of truth, but a manifest
-    // that quietly loses rows is what makes a repair hard to audit
-    // afterwards, so each one is named.
-    for (const filename of repaired.droppedFilenames) {
-        warn(`Dropped the manifest entry for ${filename}: no such patch file on disk. ` +
-            'Restore the .patch file and re-run the repair if the entry should have survived.');
-    }
-    if (repaired.written) {
-        ctx.mutations.push('patches/patches.json — rebuilt from the on-disk patch files (--repair-patches-manifest)');
-    }
-    const patchCount = repaired.manifest.patches.length;
-    const recovered = repaired.recoveredFilenames.length > 0
-        ? ` (${repaired.recoveredFilenames.length} with reconstructed metadata — see warnings above)`
-        : '';
-    return warning(CHECK_NAME, dryRun
-        ? `Dry run — would rebuild patches.json from ${describeCount(patchCount)}${recovered}. Nothing was written.`
-        : `Rebuilt patches.json from ${describeCount(patchCount)}${recovered}. Review recovered metadata before release.`);
-}
-/** Patch manifest consistency check, with its opt-in repair paths. */
-export const PATCH_MANIFEST_CONSISTENCY_CHECK = {
-    name: CHECK_NAME,
-    dependsOn: ['fireforge.json is valid'],
-    run: async (ctx) => {
-        if (!(await pathExists(ctx.paths.patches))) {
-            return [];
-        }
-        const issues = await validatePatchesManifestConsistency(ctx.paths.patches);
-        if (issues.length === 0) {
-            return ok(CHECK_NAME);
-        }
-        const wantsFilesAffected = ctx.options.repairFilesAffected === true;
-        const wantsRebuild = ctx.options.repairPatchesManifest === true;
-        if (!wantsFilesAffected && !wantsRebuild) {
-            return failure(CHECK_NAME, issues.map((issue) => issue.message).join(' '), recommendManifestRepair(issues));
-        }
-        try {
-            return wantsFilesAffected
-                ? await runFilesAffectedRepair(ctx, issues)
-                : await runManifestRebuild(ctx);
-        }
-        catch (err) {
-            const error = toError(err);
-            // A refusal from the repair itself already carries the remedy that
-            // fits it (which flag, which file to fix). Appending the generic hint
-            // under it buries the specific one and reads as a second, vaguer
-            // instruction. Only an unexpected throw gets the generic hint.
-            return error instanceof FireForgeError
-                ? failure(CHECK_NAME, error.message)
-                : failure(CHECK_NAME, error.message, 'Repair failed. Fix the underlying patch metadata issue and retry the doctor command.');
-        }
-    },
-};

package/dist/src/commands/doctor-post-rebase-audit.d.ts

@@ -1,2 +0,0 @@
-import type { DoctorCheckDefinition } from './doctor-check-core.js';
-export declare const POST_REBASE_AUDIT_CHECK: DoctorCheckDefinition;

package/dist/src/commands/doctor-post-rebase-audit.js

@@ -1,108 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { ok, warning } from './doctor-check-core.js';
-async function readEngineText(engineDir, relativePath) {
-    const fullPath = join(engineDir, relativePath);
-    if (!(await pathExists(fullPath)))
-        return null;
-    return readText(fullPath);
-}
-/**
- * Collects every `browser.toml` under the engine's browser-chrome test tree.
- *
- * Reports unreadable directories separately from "none found": the consumer
- * turns an empty result into the issue "no browser.toml files found", which is
- * the opposite diagnosis from "the tree could not be read". A swallowed
- * mid-walk EACCES also silently shrank the result set, so one unreadable
- * subdirectory produced a false clean for that subtree.
- */
-async function collectBrowserTomlFiles(root) {
-    const testRoot = join(root, 'browser/base/content/test');
-    if (!(await pathExists(testRoot)))
-        return { files: [], unreadable: [] };
-    const result = [];
-    const unreadable = [];
-    async function walk(absDir, relDir) {
-        let entries;
-        try {
-            entries = await readdir(absDir, { withFileTypes: true });
-        }
-        catch (error) {
-            unreadable.push(`${relDir || '.'} (${toError(error).message})`);
-            return;
-        }
-        for (const entry of entries) {
-            const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
-            const absPath = join(absDir, entry.name);
-            if (entry.isDirectory()) {
-                await walk(absPath, relPath);
-            }
-            else if (entry.isFile() && entry.name === 'browser.toml') {
-                result.push(`browser/base/content/test/${relPath}`);
-            }
-        }
-    }
-    await walk(testRoot, '');
-    return { files: result.sort(), unreadable };
-}
-async function runPostRebaseAudit(ctx) {
-    const issues = [];
-    const engineDir = ctx.paths.engine;
-    // The four probes below are upstream-Firefox shape markers: each names a
-    // file and a token that a healthy post-rebase tree must still contain. A
-    // rebase that dropped a fork patch, or an upstream reorganisation, shows up
-    // as one of these going missing. The tokens are coarse on purpose: this
-    // is a smoke check that runs warn-only behind an opt-in flag, not a
-    // structural validator.
-    const mozConfigure = await readEngineText(engineDir, 'browser/moz.configure');
-    if (mozConfigure === null) {
-        issues.push('browser/moz.configure is missing');
-    }
-    else if (!mozConfigure.includes('BROWSER_CHROME_URL')) {
-        issues.push('browser/moz.configure does not mention BROWSER_CHROME_URL');
-    }
-    const browserJar = await readEngineText(engineDir, 'browser/base/jar.mn');
-    if (browserJar === null) {
-        issues.push('browser/base/jar.mn is missing');
-    }
-    else if (!/\.xhtml\b/.test(browserJar)) {
-        issues.push('browser/base/jar.mn has no chrome document .xhtml entries');
-    }
-    const customElements = await readEngineText(engineDir, 'toolkit/content/customElements.js');
-    if (customElements === null) {
-        issues.push('toolkit/content/customElements.js is missing');
-    }
-    else if (!customElements.includes('customElements')) {
-        issues.push('toolkit/content/customElements.js does not contain customElements registrations');
-    }
-    const toolkitJar = await readEngineText(engineDir, 'toolkit/content/jar.mn');
-    if (toolkitJar === null) {
-        issues.push('toolkit/content/jar.mn is missing');
-    }
-    else if (!toolkitJar.includes('content/global/widgets/') &&
-        !toolkitJar.includes('content/global/elements/')) {
-        issues.push('toolkit/content/jar.mn has no widget/element exposure entries');
-    }
-    const browserTomls = await collectBrowserTomlFiles(engineDir);
-    if (browserTomls.unreadable.length > 0) {
-        issues.push(`could not read ${browserTomls.unreadable.length} ` +
-            `${browserTomls.unreadable.length === 1 ? 'directory' : 'directories'} under ` +
-            `browser/base/content/test: ${browserTomls.unreadable.join(', ')}`);
-    }
-    else if (browserTomls.files.length === 0) {
-        issues.push('no browser.toml files found under browser/base/content/test');
-    }
-    if (issues.length === 0) {
-        return ok('Post-rebase registration audit');
-    }
-    return warning('Post-rebase registration audit', `${issues.length} suspicious registration surface${issues.length === 1 ? '' : 's'}: ${issues.join('; ')}.`, 'Inspect the named engine paths, refresh any drifted registration patches, then re-run "fireforge doctor --post-rebase-audit".');
-}
-export const POST_REBASE_AUDIT_CHECK = {
-    name: 'Post-rebase registration audit',
-    skipIf: (ctx) => !ctx.options.postRebaseAudit || !ctx.engineExists,
-    dependsOn: ['fireforge.json is valid'],
-    run: runPostRebaseAudit,
-};

package/dist/src/commands/doctor-source-pin.d.ts

@@ -1,29 +0,0 @@
-/**
- * Doctor check comparing the configured Firefox source pin against what the
- * engine checkout actually is.
- *
- * `fireforge source set` lands `firefox.version` inside `fireforge.json`,
- * beside hand-maintained policy sections. That is convenient and it is also
- * the whole problem: a routine `git checkout -- fireforge.json` (undoing an
- * accidental reformat, say) silently reverts an uncommitted pin along with
- * it, and nothing afterwards reports that the pin and the checkout have
- * diverged. In the field this showed up as a gate flipping green with no
- * change that should have made it green.
- *
- * This is not a lock and not a refusal: a tree may legitimately be
- * mid-migration between two versions. It only makes a mismatched tree
- * visible, which is all that was missing.
- *
- * Scope is limited by what is actually recorded. `firefox.product`,
- * `firefox.sha256` and `firefox.candidate` have no counterpart anywhere on
- * disk (`.fireforge/state.json` records only `downloadedVersion` and
- * `baseCommit`), so there is nothing to compare them against and the check
- * says nothing about them rather than implying it verified them.
- */
-import type { DoctorCheckDefinition } from './doctor-check-core.js';
-/**
- * Pin-vs-checkout reporting. Needs the loaded config, so it declares the
- * dependency on the config check that populates `ctx.config`. It is skipped
- * entirely without an engine, where there is nothing to compare.
- */
-export declare const SOURCE_PIN_DOCTOR_CHECK: DoctorCheckDefinition;