@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/objdir-install-manifests.js

@@ -1,226 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Reads the objdir's mozpack install manifests to tell how an engine source
- * reaches the runtime a test runs against.
- *
- * mozbuild installs packaged files from manifests under
- * `obj-*\/_build_manifests/install/` and `obj-*\/faster/install_*`. Each
- * line after the version is a `\x1f`-separated entry: type 1 installs a
- * symlink to an absolute source, 2 copies it, 7 preprocesses it, and 5/6
- * are the pattern forms of 1/2 (`base`, `pattern`, `dest dir`). In a
- * non-Windows dev build most chrome and test files are type-1 symlinks back
- * into `engine/`, so an edit to such a file is already what the runtime
- * reads. `_test_files` is rewritten and installed by `mach test` itself on
- * every dispatch, so test files are restaged when a run starts.
- *
- * Every classification is conservative: an entry whose install base is
- * unknown, a symlink that does not resolve to the edited source, or an
- * unreadable manifest leaves the path classified as packaged.
- */
-import { lstat, readdir, readFile, realpath } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { verbose } from '../utils/logger.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { escapeRegex } from '../utils/regex.js';
-/** Install-manifest field separator. */
-const FIELD_SEPARATOR = '\x1f';
-/** mozpack entry types that install a symlink. */
-const SYMLINK_TYPE = '1';
-const PATTERN_SYMLINK_TYPE = '5';
-const PATTERN_COPY_TYPE = '6';
-/** Entry types with no source file (existence markers, inline content). */
-const SOURCELESS_TYPES = new Set(['3', '4', '8']);
-/** The manifest `mach test` writes and installs at every dispatch. */
-const DISPATCH_MANIFEST = '_test_files';
-/** Converts a mozpack pattern (`*`, `**`, `?`) to an anchored RegExp. */
-function patternToRegExp(pattern) {
-    if (pattern.split('/').includes('..'))
-        return undefined;
-    let source = '';
-    for (let i = 0; i < pattern.length; i += 1) {
-        const char = pattern[i] ?? '';
-        if (pattern.startsWith('**/', i)) {
-            source += '(?:.*/)?';
-            i += 2;
-        }
-        else if (pattern.startsWith('**', i)) {
-            source += '.*';
-            i += 1;
-        }
-        else if (char === '*')
-            source += '[^/]*';
-        else if (char === '?')
-            source += '[^/]';
-        else
-            source += escapeRegex(char);
-    }
-    return new RegExp(`^${source}$`);
-}
-function engineRelative(roots, absolute) {
-    const normalized = normalizePathSlashes(absolute);
-    for (const root of roots) {
-        if (normalized.startsWith(`${root}/`))
-            return normalized.slice(root.length + 1);
-    }
-    return undefined;
-}
-/** Install base (objdir-relative) of a `_build_manifests/install/<name>` manifest. */
-function buildManifestBase(name) {
-    if (name === DISPATCH_MANIFEST || name === '_tests')
-        return '_tests';
-    const dist = /^dist_(.+)$/.exec(name);
-    return dist ? `dist/${dist[1] ?? ''}` : undefined;
-}
-/** `faster/install_*` manifest name → install base, from `faster/Makefile`. */
-async function fasterManifestBases(objDirPath) {
-    const bases = new Map();
-    const makefile = await readFile(join(objDirPath, 'faster', 'Makefile'), 'utf8').catch(() => '');
-    const line = /^INSTALL_MANIFESTS\s*=(.*)$/m.exec(makefile)?.[1] ?? '';
-    for (const base of line.trim().split(/\s+/).filter(Boolean)) {
-        bases.set(`install_${base.replaceAll('/', '_')}`, base);
-    }
-    // `mach build faster` installs a merged copy of the per-directory
-    // manifests, rooted at dist/bin.
-    bases.set('unified_install_dist_bin', 'dist/bin');
-    return bases;
-}
-function parseManifest(index, content, installRoot, atDispatch) {
-    for (const line of content.split('\n').slice(1)) {
-        const fields = line.split(FIELD_SEPARATOR);
-        const [type = '', dest = '', source = ''] = fields;
-        if (SOURCELESS_TYPES.has(type) || source === '')
-            continue;
-        const base = engineRelative(index.engineRoots, source);
-        if (base === undefined)
-            continue;
-        if (type === PATTERN_SYMLINK_TYPE || type === PATTERN_COPY_TYPE) {
-            const pattern = patternToRegExp(fields[3] ?? '');
-            const destDir = fields[4];
-            if (pattern === undefined)
-                continue;
-            index.patterns.push({
-                symlink: type === PATTERN_SYMLINK_TYPE,
-                base,
-                pattern,
-                destDir: installRoot === undefined || destDir === undefined
-                    ? undefined
-                    : join(installRoot, destDir),
-                atDispatch,
-            });
-            continue;
-        }
-        const entries = index.explicit.get(base) ?? [];
-        entries.push({
-            symlink: type === SYMLINK_TYPE,
-            dest: installRoot === undefined ? undefined : join(installRoot, dest),
-            atDispatch,
-        });
-        index.explicit.set(base, entries);
-    }
-}
-async function readManifests(dir, baseFor, index, objDirPath) {
-    let names;
-    try {
-        names = await readdir(dir);
-    }
-    catch {
-        return false;
-    }
-    for (const name of names) {
-        if (name.startsWith('.') || name.endsWith('.track') || name === 'Makefile')
-            continue;
-        const content = await readFile(join(dir, name), 'utf8').catch(() => undefined);
-        if (content === undefined)
-            continue;
-        const base = baseFor(name);
-        parseManifest(index, content, base === undefined ? undefined : join(objDirPath, base), name === DISPATCH_MANIFEST);
-    }
-    return true;
-}
-/**
- * Loads every install manifest of `objDir`. Undefined when neither manifest
- * directory is readable, i.e. nothing can be classified.
- *
- * @param engineDir - Absolute engine directory
- * @param objDir - Objdir name under the engine directory
- */
-export async function loadInstallManifestIndex(engineDir, objDir) {
-    const objDirPath = join(engineDir, objDir);
-    const roots = [normalizePathSlashes(resolve(engineDir))];
-    const real = await realpath(engineDir).catch(() => undefined);
-    if (real !== undefined && !roots.includes(normalizePathSlashes(real))) {
-        roots.push(normalizePathSlashes(real));
-    }
-    const index = { explicit: new Map(), patterns: [], engineRoots: roots };
-    try {
-        const fasterBases = await fasterManifestBases(objDirPath);
-        const readBuild = await readManifests(join(objDirPath, '_build_manifests', 'install'), buildManifestBase, index, objDirPath);
-        const readFaster = await readManifests(join(objDirPath, 'faster'), (name) => fasterBases.get(name), index, objDirPath);
-        return readBuild || readFaster ? index : undefined;
-    }
-    catch (error) {
-        verbose(`Install manifests unreadable under ${objDir}: ${toError(error).message}`);
-        return undefined;
-    }
-}
-/** True when `dest` is a symlink resolving to the same file as `source`. */
-async function isSymlinkTo(dest, source) {
-    if (dest === undefined)
-        return false;
-    try {
-        if (!(await lstat(dest)).isSymbolicLink())
-            return false;
-        return (await realpath(dest)) === (await realpath(source));
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Classifies how `relPath` reaches the runtime. See {@link RuntimeDelivery}.
- *
- * @param index - Index from {@link loadInstallManifestIndex}
- * @param engineDir - Absolute engine directory
- * @param relPath - Engine-relative POSIX path
- */
-export async function classifyRuntimeDelivery(index, engineDir, relPath) {
-    const entries = [...(index.explicit.get(relPath) ?? [])];
-    for (const pattern of index.patterns) {
-        if (!relPath.startsWith(`${pattern.base}/`))
-            continue;
-        const rest = relPath.slice(pattern.base.length + 1);
-        if (!pattern.pattern.test(rest))
-            continue;
-        entries.push({
-            symlink: pattern.symlink,
-            dest: pattern.destDir === undefined ? undefined : join(pattern.destDir, rest),
-            atDispatch: pattern.atDispatch,
-        });
-    }
-    if (entries.length === 0)
-        return 'unlisted';
-    if (entries.every((entry) => entry.atDispatch))
-        return 'at-dispatch';
-    const source = join(engineDir, relPath);
-    for (const entry of entries) {
-        if (entry.atDispatch)
-            continue;
-        if (!entry.symlink || !(await isSymlinkTo(entry.dest, source)))
-            return 'packaged';
-    }
-    return 'live';
-}
-/**
- * True when any install-manifest entry installs something from at or
- * beneath the engine-relative directory `dir`, or a pattern entry's base
- * contains it.
- */
-export function installsFromDirectory(index, dir) {
-    const prefix = dir.replace(/\/+$/, '');
-    const under = (path) => path === prefix || path.startsWith(`${prefix}/`);
-    for (const source of index.explicit.keys())
-        if (under(source))
-            return true;
-    return index.patterns.some((pattern) => under(pattern.base) || prefix.startsWith(`${pattern.base}/`));
-}

package/dist/src/core/objdir-maintenance.d.ts

@@ -1,10 +0,0 @@
-/** Refuses an objdir that writes through a directory alias into a different checkout. */
-export declare function assertLocalObjdir(engineDir: string, objDir: string): Promise<void>;
-/** Repairs copied links and dependency metadata BEFORE configure can consume config.track. */
-export declare function relocateObjdirProducts(engineDir: string, objDir: string, oldRoot: string): Promise<void>;
-/** Finds a link still consulting the previous source tree after relocation/configure. */
-export declare function findStaleObjdirLink(engineDir: string, objDir: string, oldRoot: string): Promise<string | undefined>;
-/** Prunes only dangling _tests symlinks; never descends through a symlink. */
-export declare function pruneDanglingTestLinks(engineDir: string, objDir: string): Promise<number>;
-/** Names a partial-config group whose entire persisted value set was nulled. */
-export declare function assertHealthyPartialConfig(engineDir: string, objDir: string): Promise<void>;

package/dist/src/core/objdir-maintenance.js

@@ -1,167 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { lstat, readdir, readFile, readlink, realpath, rename, rm, symlink, } from 'node:fs/promises';
-import { dirname, join, resolve, sep } from 'node:path';
-import { GeneralError } from '../errors/base.js';
-import { getNodeErrorCode } from '../utils/errors.js';
-import { writeText } from '../utils/fs.js';
-/** Visits objdir entries without following directory symlinks into another tree. */
-async function walk(dir, visit) {
-    for (const entry of await readdir(dir, { withFileTypes: true })) {
-        const path = join(dir, entry.name);
-        if (entry.isDirectory())
-            await walk(path, visit);
-        else
-            await visit(path, entry.isSymbolicLink());
-    }
-}
-/** Refuses an objdir that writes through a directory alias into a different checkout. */
-export async function assertLocalObjdir(engineDir, objDir) {
-    if (!/^[^/\\:]+$/.test(objDir) || objDir === '.' || objDir === '..') {
-        throw new GeneralError(`Objdir ${objDir} must be a local directory name.`);
-    }
-    const expected = resolve(engineDir, objDir);
-    if ((await realpath(expected)) !== resolve(await realpath(engineDir), objDir) ||
-        !(await lstat(expected)).isDirectory()) {
-        throw new GeneralError(`Objdir ${expected} resolves outside its local directory. Refusing to configure or rewrite it.`);
-    }
-}
-function replacePrefix(value, oldRoot, newRoot) {
-    return value === oldRoot || value.startsWith(oldRoot + sep)
-        ? newRoot + value.slice(oldRoot.length)
-        : value;
-}
-/** Rewrites references under oldRoot, including the forward-slash spelling mozbuild writes on Windows. */
-function rewriteRootReferences(content, oldRoot, newRoot) {
-    const rewritten = content.replaceAll(oldRoot + sep, newRoot + sep);
-    if (sep !== '\\')
-        return rewritten;
-    return rewritten
-        .replaceAll(oldRoot + '/', newRoot + '/')
-        .replaceAll(oldRoot.replaceAll('\\', '/') + '/', newRoot.replaceAll('\\', '/') + '/');
-}
-function isDependencyMetadata(path) {
-    return (/\.(?:pp|d)$/.test(path) ||
-        /[/\\]faster[/\\]/.test(path) ||
-        /[/\\]config\.statusd[/\\].*[/\\]config\.track$/.test(path) ||
-        /[/\\]\.fingerprint[/\\].*\.json$/.test(path));
-}
-/** Repairs copied links and dependency metadata BEFORE configure can consume config.track. */
-export async function relocateObjdirProducts(engineDir, objDir, oldRoot) {
-    await assertLocalObjdir(engineDir, objDir);
-    const root = resolve(engineDir, objDir);
-    const newRoot = resolve(engineDir);
-    const canonicalRoot = await realpath(root);
-    // Configure writes these groups. Even a local objdir can contain a copied
-    // directory alias into a peer, so validate each parent before touching it.
-    for (const directory of ['config.statusd', 'config.statusd/substs', 'config.statusd/defines']) {
-        const path = join(root, directory);
-        try {
-            if (!(await lstat(path)).isDirectory() ||
-                (await realpath(path)) !== join(canonicalRoot, directory))
-                throw new GeneralError(`Partial-config directory ${path} is aliased. Refusing relocation before configure.`);
-        }
-        catch (error) {
-            if (getNodeErrorCode(error) !== 'ENOENT')
-                throw error;
-        }
-    }
-    await walk(root, async (path, link) => {
-        // Remove tracking symlinks too, without following their write targets.
-        if (/[/\\]config\.statusd[/\\].*[/\\]config\.track$/.test(path)) {
-            await rm(path);
-            return;
-        }
-        if (link) {
-            const target = await readlink(path);
-            const absolute = resolve(dirname(path), target);
-            const relocated = replacePrefix(absolute, oldRoot, newRoot);
-            if (relocated !== absolute) {
-                const temp = `${path}.relocate-${process.pid}`;
-                await symlink(relocated, temp);
-                try {
-                    await rename(temp, path);
-                }
-                catch (error) {
-                    // Windows refuses to rename over a directory link; replace it in two steps.
-                    if (process.platform !== 'win32' || getNodeErrorCode(error) !== 'EPERM')
-                        throw error;
-                    await rm(path);
-                    await rename(temp, path);
-                }
-                finally {
-                    await rm(temp, { force: true });
-                }
-            }
-        }
-        else if (isDependencyMetadata(path)) {
-            const content = await readFile(path, 'utf8');
-            const rewritten = rewriteRootReferences(content, oldRoot, newRoot);
-            if (content !== rewritten)
-                await writeText(path, rewritten);
-        }
-    });
-}
-/** Finds a link still consulting the previous source tree after relocation/configure. */
-export async function findStaleObjdirLink(engineDir, objDir, oldRoot) {
-    let violation;
-    await walk(resolve(engineDir, objDir), async (path, link) => {
-        if (!link || violation)
-            return;
-        const target = resolve(dirname(path), await readlink(path));
-        const canonical = await realpath(path).catch(() => target);
-        if ([target, canonical].some((value) => value === oldRoot || value.startsWith(oldRoot + sep))) {
-            violation = `${path} still links to the previous engine ${oldRoot}`;
-        }
-    });
-    return violation;
-}
-/** Prunes only dangling _tests symlinks; never descends through a symlink. */
-export async function pruneDanglingTestLinks(engineDir, objDir) {
-    let removed = 0;
-    const root = join(engineDir, objDir, '_tests');
-    try {
-        if (!(await lstat(root)).isDirectory())
-            return 0;
-        await assertLocalObjdir(engineDir, objDir);
-        await walk(root, async (path, link) => {
-            if (!link)
-                return;
-            try {
-                await realpath(path);
-            }
-            catch (error) {
-                if (getNodeErrorCode(error) !== 'ENOENT')
-                    throw error;
-                await rm(path);
-                removed++;
-            }
-        });
-    }
-    catch (error) {
-        if (getNodeErrorCode(error) !== 'ENOENT')
-            throw error;
-    }
-    return removed;
-}
-/** Names a partial-config group whose entire persisted value set was nulled. */
-export async function assertHealthyPartialConfig(engineDir, objDir) {
-    for (const group of ['substs', 'defines']) {
-        const dir = join(engineDir, objDir, 'config.statusd', group);
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-        }
-        catch (error) {
-            if (getNodeErrorCode(error) === 'ENOENT')
-                continue;
-            throw error;
-        }
-        const files = entries.filter((entry) => entry.isFile() && entry.name !== 'config.track');
-        if (files.length === 0)
-            continue;
-        const values = await Promise.all(files.map((entry) => readFile(join(dir, entry.name), 'utf8')));
-        if (values.every((value) => value.trim() === 'null')) {
-            throw new GeneralError(`All ${files.length} partial-config ${group} values in ${dir} are null. Repair with "cd engine && python3 ./mach configure", then retry the full build.`);
-        }
-    }
-}

package/dist/src/core/ownership-table.d.ts

@@ -1,53 +0,0 @@
-import type { PatchMetadata } from '../types/commands/index.js';
-import type { FileClassification } from './status-classify.js';
-/**
- * A row in the flat path → owning-patch ownership table.
- */
-export interface OwnershipRow {
-    path: string;
-    owners: string[];
-    conflict: boolean;
-    conflictReason: 'files-affected' | 'duplicate-create' | null;
-    unmanaged: boolean;
-    state: 'owned' | 'patch-backed' | 'patch-owned-drift' | 'unmanaged' | 'conflict';
-}
-interface StatusFile {
-    status: string;
-    file: string;
-}
-/**
- * Builds the flat ownership table from the manifest, worktree status, and the
- * duplicate-new-file-creation map produced by cross-patch lint.
- *
- * Populated from three sources:
- *
- *   1. Every path in every patch's `filesAffected`, so managed paths show up
- *      even when they are not currently modified on disk.
- *   2. Any worktree status entries not claimed by any patch (flagged as
- *      `unmanaged`).
- *   3. Paths created by more than one patch in `new file mode`, surfaced as
- *      ownership conflicts with `conflictReason = 'duplicate-create'`. This
- *      is what keeps `status --ownership` aligned with `fireforge verify`:
- *      walking only `filesAffected` reports a queue clean that `verify`
- *      rejects for duplicate `/dev/null → b/foo.js` creations.
- *
- * A path claimed by more than one patch (either via `filesAffected` or as a
- * duplicate creation) is flagged as `conflict` with the origin recorded in
- * `conflictReason` so the output can disambiguate.
- *
- * @param manifestPatches - Manifest rows, each with its `filesAffected`
- * @param worktreeFiles - Raw worktree status entries. Untracked and modified
- *   both acceptable
- * @param newFileCreatorsByPath - Map produced by
- *   {@link import('../core/patch-lint.js').collectNewFileCreatorsByPath}.
- *   Paths with a `.length > 1` owner list become duplicate-create conflicts
- */
-export declare function buildOwnershipTable(manifestPatches: PatchMetadata[], worktreeFiles: StatusFile[], newFileCreatorsByPath: Map<string, string[]>, classifications?: Map<string, FileClassification>): OwnershipRow[];
-/**
- * Renders the ownership table as a GitHub-flavored Markdown pipe table.
- * Using markdown-table's own serializer would require a seed document to
- * graft onto, which is overkill for ad-hoc status output. The rendering
- * here is trivial enough to inline.
- */
-export declare function renderOwnershipTable(rows: OwnershipRow[]): void;
-export {};

package/dist/src/core/ownership-table.js

@@ -1,159 +0,0 @@
-import { info } from '../utils/logger.js';
-import { buildPatchClaims } from './status-classify.js';
-/**
- * Builds the flat ownership table from the manifest, worktree status, and the
- * duplicate-new-file-creation map produced by cross-patch lint.
- *
- * Populated from three sources:
- *
- *   1. Every path in every patch's `filesAffected`, so managed paths show up
- *      even when they are not currently modified on disk.
- *   2. Any worktree status entries not claimed by any patch (flagged as
- *      `unmanaged`).
- *   3. Paths created by more than one patch in `new file mode`, surfaced as
- *      ownership conflicts with `conflictReason = 'duplicate-create'`. This
- *      is what keeps `status --ownership` aligned with `fireforge verify`:
- *      walking only `filesAffected` reports a queue clean that `verify`
- *      rejects for duplicate `/dev/null → b/foo.js` creations.
- *
- * A path claimed by more than one patch (either via `filesAffected` or as a
- * duplicate creation) is flagged as `conflict` with the origin recorded in
- * `conflictReason` so the output can disambiguate.
- *
- * @param manifestPatches - Manifest rows, each with its `filesAffected`
- * @param worktreeFiles - Raw worktree status entries. Untracked and modified
- *   both acceptable
- * @param newFileCreatorsByPath - Map produced by
- *   {@link import('../core/patch-lint.js').collectNewFileCreatorsByPath}.
- *   Paths with a `.length > 1` owner list become duplicate-create conflicts
- */
-export function buildOwnershipTable(manifestPatches, worktreeFiles, newFileCreatorsByPath, classifications = new Map()) {
-    const ownersByPath = buildPatchClaims(manifestPatches);
-    // Merge duplicate-new-file-creation findings. The structured helper
-    // returns all new-file paths, so we filter to the ones with more
-    // than one creator. Paths are added to the table even when no patch
-    // listed them in `filesAffected`, because the two-patch duplicate
-    // creation is exactly the shape that manifests as an ownership
-    // conflict without showing up in filesAffected (e.g. drift caused
-    // by manual patches.json editing).
-    const duplicateCreateByPath = new Map();
-    for (const [path, creators] of newFileCreatorsByPath) {
-        if (creators.length <= 1)
-            continue;
-        duplicateCreateByPath.set(path, creators);
-        if (!ownersByPath.has(path)) {
-            ownersByPath.set(path, [...creators]);
-        }
-    }
-    const worktreeSet = new Set(worktreeFiles.map((f) => f.file));
-    const unmanagedOnly = [];
-    for (const path of worktreeSet) {
-        if (!ownersByPath.has(path)) {
-            unmanagedOnly.push(path);
-        }
-    }
-    const rows = [];
-    for (const [path, owners] of ownersByPath) {
-        const duplicateOwners = duplicateCreateByPath.get(path);
-        const isFilesAffectedConflict = owners.length > 1;
-        const isDuplicateCreateConflict = duplicateOwners !== undefined;
-        // Prefer the filesAffected reason when both apply: it's the older
-        // source of drift and the operator will usually want to fix the
-        // manifest rows even when the bodies also duplicate-create.
-        const conflictReason = isFilesAffectedConflict
-            ? 'files-affected'
-            : isDuplicateCreateConflict
-                ? 'duplicate-create'
-                : null;
-        // If the duplicate-create finding introduced new patches not in
-        // filesAffected, merge them into owners so the rendered cell lists
-        // everyone responsible for the conflict, matching what `verify`
-        // prints.
-        const mergedOwners = duplicateOwners
-            ? Array.from(new Set([...owners, ...duplicateOwners])).sort((a, b) => a.localeCompare(b))
-            : owners;
-        rows.push({
-            path,
-            owners: mergedOwners,
-            conflict: isFilesAffectedConflict || isDuplicateCreateConflict,
-            conflictReason,
-            unmanaged: false,
-            state: isFilesAffectedConflict || isDuplicateCreateConflict
-                ? 'conflict'
-                : classifications.get(path) === 'patch-backed'
-                    ? 'patch-backed'
-                    : classifications.get(path) === 'patch-owned-drift'
-                        ? 'patch-owned-drift'
-                        : 'owned',
-        });
-    }
-    for (const path of unmanagedOnly) {
-        rows.push({
-            path,
-            owners: [],
-            conflict: false,
-            conflictReason: null,
-            unmanaged: true,
-            state: 'unmanaged',
-        });
-    }
-    rows.sort((a, b) => a.path.localeCompare(b.path));
-    return rows;
-}
-/**
- * Human-readable label for the conflict column. Distinguishes
- * `files-affected` drift (two manifest rows claiming the same path) from
- * `duplicate-create` drift (two patches both hitting `/dev/null → b/path`
- * in their bodies) so the operator can tell at a glance which fix
- * applies. The former wants `re-export --files`, the latter wants
- * `patch delete`.
- */
-function renderConflictCell(row) {
-    if (!row.conflict)
-        return row.unmanaged ? 'unmanaged' : '';
-    if (row.conflictReason === 'duplicate-create')
-        return 'CONFLICT (dup-create)';
-    return 'CONFLICT';
-}
-function renderStateCell(row) {
-    if (row.conflict)
-        return renderConflictCell(row);
-    switch (row.state) {
-        case 'owned':
-            return 'owned';
-        case 'patch-backed':
-            return 'patch-backed';
-        case 'patch-owned-drift':
-            return 'patch-owned drift';
-        case 'unmanaged':
-            return 'unmanaged';
-        case 'conflict':
-            return renderConflictCell(row);
-    }
-}
-/**
- * Renders the ownership table as a GitHub-flavored Markdown pipe table.
- * Using markdown-table's own serializer would require a seed document to
- * graft onto, which is overkill for ad-hoc status output. The rendering
- * here is trivial enough to inline.
- */
-export function renderOwnershipTable(rows) {
-    if (rows.length === 0) {
-        info('No tracked or modified files.');
-        return;
-    }
-    const pathHeader = 'path';
-    const ownerHeader = 'owning patch';
-    const stateHeader = 'state';
-    const pathWidth = Math.max(pathHeader.length, ...rows.map((r) => r.path.length));
-    const ownerWidth = Math.max(ownerHeader.length, ...rows.map((r) => (r.unmanaged ? 1 : r.owners.join(', ').length)));
-    const stateWidth = Math.max(stateHeader.length, ...rows.map((r) => renderStateCell(r).length), 8);
-    const pad = (text, width) => text + ' '.repeat(width - text.length);
-    info(`| ${pad(pathHeader, pathWidth)} | ${pad(ownerHeader, ownerWidth)} | ${pad(stateHeader, stateWidth)} |`);
-    info(`| ${'-'.repeat(pathWidth)} | ${'-'.repeat(ownerWidth)} | ${'-'.repeat(stateWidth)} |`);
-    for (const row of rows) {
-        const ownerCell = row.unmanaged ? '-' : row.owners.join(', ');
-        const stateCell = renderStateCell(row);
-        info(`| ${pad(row.path, pathWidth)} | ${pad(ownerCell, ownerWidth)} | ${pad(stateCell, stateWidth)} |`);
-    }
-}

package/dist/src/core/parent-exit-watchdog.d.ts

@@ -1,62 +0,0 @@
-/**
- * Detects the death of FireForge's own parent while a harness runs.
- *
- * A supervisor that SIGKILLs the process above `fireforge test` (the
- * 2026-09-13 incident: a gate killed its `npm` step at the 15-minute bound)
- * signals nothing below it. FireForge is not told; its stdout pipe merely
- * breaks, and the broken-pipe handler swallows EPIPE on purpose so `| head`
- * works. The mach tree it spawned as a separate process group keeps running
- * under nobody's supervision, and the httpd in that tree spun at 100% CPU
- * for hours.
- *
- * SIGKILL cannot be caught, but reparenting can be observed: once the parent
- * is gone, `process.ppid` changes (to launchd/init, or to a subreaper). This
- * watchdog polls for that while a dispatch is in flight and fires once. It
- * does not decide what to do about it; the test command tears down the
- * harness tree and ends the run.
- *
- * Off on Windows: `process.ppid` is not refreshed there after the parent
- * exits, and there is no process group to signal in response anyway.
- */
-/** Options for {@link startParentExitWatchdog}. */
-export interface ParentExitWatchdogOptions {
-    /** Probe interval, default {@link DEFAULT_INTERVAL_MS}. */
-    intervalMs?: number;
-    /** Called exactly once, the first time the parent is seen to be gone. */
-    onParentExit: (info: {
-        originalPpid: number;
-        currentPpid: number;
-    }) => void;
-    /**
-     * Reads the current parent pid; default `process.ppid`. Injectable because
-     * `process.ppid` cannot be stubbed on every Node line: redefining the
-     * property is honoured on Node 26 and silently ignored on Node 22, so a
-     * test that stubs it passes on one and never observes a reparent on the
-     * other.
-     */
-    readPpid?: () => number;
-}
-/** Handle for a running watchdog. */
-export interface ParentExitWatchdog {
-    /** Stops probing. Idempotent. A stopped watchdog never fires. */
-    stop(): void;
-}
-/**
- * True once any watchdog in this process has seen the parent die. The
- * dispatch loop reads it to end the run instead of classifying the killed
- * harness as a crash and retrying it under a parent that no longer exists.
- */
-export declare function parentExited(): boolean;
-/**
- * Forgets an observed parent exit.
- *
- * @internal Exported only so tests can reach it. It is not part of the
- * public surface.
- */
-export declare function resetParentExitForTests(): void;
-/**
- * Starts probing `process.ppid`. The timer is unref'd so the watchdog can
- * never be the thing keeping FireForge alive; while a child runs, the child
- * does that.
- */
-export declare function startParentExitWatchdog(options: ParentExitWatchdogOptions): ParentExitWatchdog;