@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,265 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Minimal Markdown pipe-table parser/writer used by token-manager.
- *
- * This is not a general Markdown parser. It understands exactly the
- * slice of GitHub-flavoured Markdown that FireForge emits into token docs:
- *
- *   - Leading `|` per row, trailing `|` optional.
- *   - A separator row of `|---|---|...|` immediately after the header.
- *   - Fenced code blocks (``` / ~~~) are recognised and skipped so that
- *     literal `|` lines inside code samples are never mistaken for rows.
- *   - A table ends on the first non-pipe line (blank line, heading, prose).
- *   - Literal `|` and `\` inside a cell are expressed as `\|` and `\\`
- *     respectively. The parser treats any other backslash as a literal
- *     so prose-style backslashes in cell values (e.g. a Windows path)
- *     still round-trip. Unescaping happens at split time. Serialization
- *     re-applies escapes so round-trips are exact for well-formed input.
- *
- * The parser returns positional metadata (`startLine`, `endLine`) so
- * callers can splice the table back into the surrounding document by
- * range instead of hand-rolled line counters. Mutation operations return
- * a fresh line array rather than mutating in place, matching the rest of
- * the file-patching code in this codebase.
- *
- * Fallback tolerance: rows with more cells than the header get their
- * overflow merged into the last column (using a literal `|` separator
- * between the merged values). This is for the rare case where a FireForge
- * writer emits an unescaped pipe. The parser still produces a consistent
- * cell count rather than desynchronising the table. On re-serialize the
- * merged cell's literal pipes are escaped, so a malformed input becomes
- * a well-formed output after one round trip.
- */
-/**
- * Matches the table separator row: optional leading pipe, one or more
- * dash-only cells (with optional `:` alignment hints) separated by pipes,
- * optional trailing pipe, allowing whitespace around each cell.
- */
-const SEPARATOR_ROW = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?\s*$/;
-/**
- * Returns `true` if the given line looks like a table row (starts with
- * `|`, ignoring leading whitespace). Does not validate cell contents.
- * That is the caller's job.
- */
-function isPipeRow(line) {
-    return /^\s*\|/.test(line);
-}
-/**
- * Splits a pipe-delimited row into trimmed cell strings.
- *
- * Tolerates both `| a | b |` and `| a | b` (no trailing pipe). Leading
- * empty cells (from a leading `|`) are dropped. A trailing empty cell
- * (from a trailing `|`) is also dropped so that rows with and without
- * the trailing pipe produce the same cell count.
- *
- * Escape handling: `\|` is consumed as a literal `|` inside a cell, and
- * `\\` as a literal `\`. Any other backslash stays literal so prose-style
- * uses of `\` survive untouched. Splitting and unescaping happen in the
- * same pass so the returned cells are ready to hand back to callers.
- */
-function splitRow(row) {
-    const trimmed = row.trim();
-    const cells = [];
-    let current = '';
-    for (let i = 0; i < trimmed.length; i++) {
-        const ch = trimmed[i];
-        if (ch === '\\' && i + 1 < trimmed.length) {
-            const next = trimmed[i + 1];
-            if (next === '|' || next === '\\') {
-                current += next;
-                i++;
-                continue;
-            }
-        }
-        if (ch === '|') {
-            cells.push(current);
-            current = '';
-            continue;
-        }
-        current += ch ?? '';
-    }
-    cells.push(current);
-    // Leading `|` gives an empty first segment, so drop it.
-    if (cells.length > 0 && cells[0] === '') {
-        cells.shift();
-    }
-    // Trailing `|` gives an empty last segment, so drop it.
-    if (cells.length > 0 && cells[cells.length - 1] === '') {
-        cells.pop();
-    }
-    return cells.map((cell) => cell.trim());
-}
-/**
- * Escapes a cell value so `serializeRow`'s pipe delimiters can be told
- * apart from literal `|` inside a cell on re-parse. `\` is escaped first
- * (to `\\`) so that the subsequent `|` → `\|` substitution cannot produce
- * an already-escaped sequence by accident. A cell containing
- * literal `\` followed by literal `|` round-trips as `\\\|`, which
- * unescape-on-split reads back as `\` + `|`, not as `\|`.
- */
-function escapeCell(cell) {
-    return cell.replace(/\\/g, '\\\\').replace(/\|/g, '\\|');
-}
-/**
- * Fits a row of cells against a target column count. Extra cells are
- * merged into the last column (so a stray `|` in a cell's value does not
- * desynchronise the table), and missing cells are padded with `''`.
- */
-function fitRowToColumns(cells, columnCount) {
-    if (columnCount <= 0)
-        return [];
-    if (cells.length === columnCount) {
-        return cells;
-    }
-    if (cells.length < columnCount) {
-        return [...cells, ...Array(columnCount - cells.length).fill('')];
-    }
-    // cells.length > columnCount: merge overflow into the last column.
-    const kept = cells.slice(0, columnCount - 1);
-    const tail = cells.slice(columnCount - 1).join(' | ');
-    return [...kept, tail];
-}
-/**
- * Locates the next Markdown table in `lines` starting at or after
- * `fromLine`, skipping fenced code blocks. Returns `null` when no table
- * is found.
- *
- * @param lines - The full document split by newline
- * @param fromLine - Line index to start scanning from (inclusive)
- */
-export function findNextTable(lines, fromLine) {
-    let inFence = false;
-    let fenceMarker = null;
-    for (let i = fromLine; i < lines.length; i++) {
-        const line = lines[i] ?? '';
-        const fenceMatch = /^\s*(```|~~~)/.exec(line);
-        if (fenceMatch) {
-            if (!inFence) {
-                inFence = true;
-                fenceMarker = fenceMatch[1] ?? '```';
-            }
-            else if (fenceMarker && line.trim().startsWith(fenceMarker)) {
-                inFence = false;
-                fenceMarker = null;
-            }
-            continue;
-        }
-        if (inFence)
-            continue;
-        if (!isPipeRow(line))
-            continue;
-        const separatorLine = lines[i + 1];
-        if (separatorLine === undefined || !SEPARATOR_ROW.test(separatorLine))
-            continue;
-        const headers = splitRow(line);
-        if (headers.length === 0)
-            continue;
-        const rows = [];
-        let endLine = i + 2;
-        for (let j = i + 2; j < lines.length; j++) {
-            const rowLine = lines[j] ?? '';
-            if (!isPipeRow(rowLine))
-                break;
-            // Another separator line would signal a malformed table, so bail.
-            if (SEPARATOR_ROW.test(rowLine))
-                break;
-            rows.push(fitRowToColumns(splitRow(rowLine), headers.length));
-            endLine = j + 1;
-        }
-        return { headers, rows, startLine: i, endLine };
-    }
-    return null;
-}
-/**
- * Returns the first table whose header contains all of the provided
- * column names (case-sensitive, order-insensitive). Useful when several
- * pipe tables share a document and you want to select "the one with a
- * Mode column".
- */
-export function findTableByColumns(lines, requiredColumns) {
-    let cursor = 0;
-    for (;;) {
-        const table = findNextTable(lines, cursor);
-        if (!table)
-            return null;
-        const headerSet = new Set(table.headers);
-        const matches = requiredColumns.every((column) => headerSet.has(column));
-        if (matches)
-            return table;
-        cursor = table.endLine;
-    }
-}
-/**
- * Returns the first table that appears after a heading matching the
- * given regex. The heading regex is applied to raw lines (no trimming)
- * so callers that want leading whitespace flexibility should include
- * `^\s*` or `^#+\s*` as appropriate.
- */
-export function findTableAfterHeading(lines, headingPattern) {
-    for (let i = 0; i < lines.length; i++) {
-        if (headingPattern.test(lines[i] ?? '')) {
-            return findNextTable(lines, i + 1);
-        }
-    }
-    return null;
-}
-/**
- * Serialises a single row using the same `| a | b | c |` layout the rest
- * of the token docs use. The leading and trailing pipes are always emitted
- * so that concatenated rows line up consistently. Cell values containing
- * literal `|` or `\` are escaped as `\|` and `\\` respectively so the
- * output survives a round-trip through {@link findNextTable}.
- */
-export function serializeRow(cells) {
-    if (cells.length === 0)
-        return '|';
-    return `| ${cells.map(escapeCell).join(' | ')} |`;
-}
-/**
- * Inserts a new row into `table.rows` at the given zero-based index. A
- * negative index counts from the end. `Infinity` appends. Mutates the
- * table object so callers using {@link rewriteTableRows} see the update.
- */
-export function insertRow(table, cells, index) {
-    const fitted = fitRowToColumns(cells, table.headers.length);
-    const target = Math.max(0, Math.min(index, table.rows.length));
-    table.rows.splice(target, 0, fitted);
-}
-/**
- * Produces a new `lines` array with the given table region replaced by a
- * freshly-serialized version of the table's current headers + rows. The
- * separator row is regenerated from the current header count so edits
- * that change the column count stay consistent.
- */
-export function rewriteTableRows(lines, table) {
-    const headerLine = serializeRow(table.headers);
-    const separatorLine = serializeRow(table.headers.map(() => '---'));
-    const rowLines = table.rows.map((row) => serializeRow(row));
-    return [
-        ...lines.slice(0, table.startLine),
-        headerLine,
-        separatorLine,
-        ...rowLines,
-        ...lines.slice(table.endLine),
-    ];
-}
-/**
- * Updates a specific cell in the first row whose `keyColumn` cell matches
- * `keyValue`. Returns `true` when a row was updated.
- *
- * Used by token-manager to bump the mode-count table without relying on
- * brittle regex patterns that assume specific whitespace.
- */
-export function updateCellByKey(table, keyColumn, keyValue, targetColumn, newValue) {
-    const keyIndex = table.headers.indexOf(keyColumn);
-    const targetIndex = table.headers.indexOf(targetColumn);
-    if (keyIndex === -1 || targetIndex === -1)
-        return false;
-    for (const row of table.rows) {
-        if (row[keyIndex] === keyValue) {
-            row[targetIndex] = newValue;
-            return true;
-        }
-    }
-    return false;
-}

package/dist/src/core/mochitest-server-port.d.ts

@@ -1,81 +0,0 @@
-import { type MarionettePortHolder } from './marionette-port.js';
-/** Default port the mochitest harness binds its httpd to. */
-export declare const DEFAULT_MOCHITEST_SERVER_PORT = 8888;
-/**
- * True when the holder is recognizably the mochitest harness's own
- * `server.js`, launched from an objdir.
- *
- * Both halves are required. `server.js` alone is one of the most common
- * filenames there is, and a developer's unrelated Node service must never
- * be mistaken for harness debris and offered up for termination. So the
- * command line must also show the xpcshell/objdir provenance that only the
- * harness's httpd has.
- */
-export declare function isMochitestServerHolder(holder: MarionettePortHolder): boolean;
-/**
- * How a recognized harness httpd relates to the checkout about to run.
- *
- * `this-checkout` is debris from one of OUR interrupted runs and may be
- * offered for termination. `foreign-checkout` is the same harness serving a
- * LIVE run in a sibling worktree: `server.js` plus objdir provenance is
- * exactly what a peer's in-flight suite looks like, and the only thing
- * separating the two is whose objdir the command line points into.
- * `unrecognized` is not the harness at all.
- */
-export type MochitestServerHolderClass = 'this-checkout' | 'foreign-checkout' | 'unrecognized';
-/**
- * Classifies the holder against this project's engine directory. Every
- * absolute path on the command line is tested with {@link isPathInsideRoot}
- * (a token test, not a substring test, so `/a/hominis/engine` does not claim
- * a holder living under `/a/hominis-2/engine`). On POSIX the command line is
- * the full `ps -o args=` output, so the objdir path is always present for a
- * harness httpd; a holder whose paths all lie elsewhere belongs to another
- * checkout.
- *
- * @param holder - The listener found on the port
- * @param engineDir - Absolute engine directory of THIS project
- */
-export declare function classifyMochitestServerHolder(holder: MarionettePortHolder, engineDir: string): MochitestServerHolderClass;
-/**
- * The objdir a foreign holder is serving from, for the refusal text: the
- * first absolute command-line token with an `obj-…` segment, cut at that
- * segment. Falls back to the first absolute token, then to a placeholder.
- */
-export declare function describeHolderObjdir(commandLine: string): string;
-/**
- * Refuses a mochitest dispatch when the harness's server port is held. It
- * terminates the holder first only for a recognized stale harness httpd,
- * and only when the operator opted in.
- *
- * An unrecognized listener is a refusal too, never a kill. Refusing is the
- * kinder outcome: mochitest cannot bind the port either way, so the choice
- * is between a one-line refusal now and a 370 s stall whose signature says
- * nothing about ports. But FireForge has no business killing a process it
- * cannot attribute to the harness.
- *
- * Best effort: {@link probeMarionettePort} reports an
- * unprobeable port as free, so a host without `lsof` runs exactly as before.
- *
- * A recognized httpd from ANOTHER checkout is a refusal and never a kill
- * either, flag or no flag: it is a peer's live suite, not our debris. The
- * browser-side probe draws the same line for a bare launch it cannot
- * attribute; this one can attribute, because the objdir is on the command
- * line, so it names the other checkout instead of offering `kill -9`.
- *
- * @param port - Port to probe (default {@link DEFAULT_MOCHITEST_SERVER_PORT})
- * @param options - `engineDir` is this project's absolute engine directory,
- *   the ownership boundary; `killStaleServer` opts into terminating a holder
- *   recognized as THIS checkout's debris
- */
-export declare function ensureMochitestServerPortAvailable(port: number | undefined, options: {
-    engineDir: string;
-    killStaleServer?: boolean;
-}): Promise<void>;
-/**
- * Builds the operator-facing refusal. Exported for direct unit testing.
- *
- * @param port - The probed port
- * @param holder - The listener found on it
- * @param holderClass - Whose harness `server.js` it is, if it is one at all
- */
-export declare function describeMochitestServerRefusal(port: number, holder: MarionettePortHolder, holderClass: MochitestServerHolderClass, parentPid?: number): string;

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

@@ -1,175 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Mochitest HTTP server port preflight.
- *
- * The mochitest harness serves its test manifest from an xpcshell-hosted
- * httpd (`server.js`) on `127.0.0.1:8888`. When a previous run is killed
- * between browser launch and teardown, that server can survive (sometimes
- * wedged at 100% CPU and unkillable by the harness's own SIGKILL) and it
- * keeps the port.
- *
- * The next run then does something much worse than failing: its fresh
- * browser connects to the zombie server, which cannot serve the new
- * manifest, so the run stalls between browser startup and `TEST_START` and
- * dies on the 370 s no-output timeout with `Ran 0 checks`. Nothing in that
- * signature names the port, so the failure survives fresh builds and reads
- * as a defect in the change under test. One downstream report spent a
- * multi-hour bisect on it before `lsof -nP -iTCP:8888` gave the answer in
- * one line.
- *
- * `--kill-stale-marionette` never covered this: it clears the browser and
- * the Marionette control port, and the httpd is neither. This preflight is
- * the missing half, and it reuses {@link probeMarionettePort}, which is
- * port-generic, rather than growing a second probe.
- */
-import { PreflightRefusalError } from '../errors/base.js';
-import { isExplicitAbsolutePath, isPathInsideRoot } from '../utils/paths.js';
-import { probeMarionettePort } from './marionette-port.js';
-import { waitForPreflight } from './preflight-wait.js';
-import { isStillOrphanedProcess, readProcessOwner } from './process-owner.js';
-/** Default port the mochitest harness binds its httpd to. */
-export const DEFAULT_MOCHITEST_SERVER_PORT = 8888;
-/**
- * True when the holder is recognizably the mochitest harness's own
- * `server.js`, launched from an objdir.
- *
- * Both halves are required. `server.js` alone is one of the most common
- * filenames there is, and a developer's unrelated Node service must never
- * be mistaken for harness debris and offered up for termination. So the
- * command line must also show the xpcshell/objdir provenance that only the
- * harness's httpd has.
- */
-export function isMochitestServerHolder(holder) {
-    const line = holder.commandLine;
-    if (!/\bserver\.js\b/.test(line))
-        return false;
-    return /\bxpcshell\b/.test(line) || /\/obj-[^/\s]*\//.test(line) || /\b_tests\b/.test(line);
-}
-/**
- * Classifies the holder against this project's engine directory. Every
- * absolute path on the command line is tested with {@link isPathInsideRoot}
- * (a token test, not a substring test, so `/a/hominis/engine` does not claim
- * a holder living under `/a/hominis-2/engine`). On POSIX the command line is
- * the full `ps -o args=` output, so the objdir path is always present for a
- * harness httpd; a holder whose paths all lie elsewhere belongs to another
- * checkout.
- *
- * @param holder - The listener found on the port
- * @param engineDir - Absolute engine directory of THIS project
- */
-export function classifyMochitestServerHolder(holder, engineDir) {
-    if (!isMochitestServerHolder(holder))
-        return 'unrecognized';
-    const absoluteTokens = holder.commandLine.split(/\s+/).filter(isExplicitAbsolutePath);
-    return absoluteTokens.some((token) => isPathInsideRoot(engineDir, token))
-        ? 'this-checkout'
-        : 'foreign-checkout';
-}
-/**
- * The objdir a foreign holder is serving from, for the refusal text: the
- * first absolute command-line token with an `obj-…` segment, cut at that
- * segment. Falls back to the first absolute token, then to a placeholder.
- */
-export function describeHolderObjdir(commandLine) {
-    const tokens = commandLine.split(/\s+/).filter(isExplicitAbsolutePath);
-    for (const token of tokens) {
-        const match = /^(.*?[/\\]obj-[^/\\]*)(?:[/\\]|$)/.exec(token);
-        if (match?.[1])
-            return match[1];
-    }
-    return tokens[0] ?? '(no path visible on the command line)';
-}
-/**
- * Refuses a mochitest dispatch when the harness's server port is held. It
- * terminates the holder first only for a recognized stale harness httpd,
- * and only when the operator opted in.
- *
- * An unrecognized listener is a refusal too, never a kill. Refusing is the
- * kinder outcome: mochitest cannot bind the port either way, so the choice
- * is between a one-line refusal now and a 370 s stall whose signature says
- * nothing about ports. But FireForge has no business killing a process it
- * cannot attribute to the harness.
- *
- * Best effort: {@link probeMarionettePort} reports an
- * unprobeable port as free, so a host without `lsof` runs exactly as before.
- *
- * A recognized httpd from ANOTHER checkout is a refusal and never a kill
- * either, flag or no flag: it is a peer's live suite, not our debris. The
- * browser-side probe draws the same line for a bare launch it cannot
- * attribute; this one can attribute, because the objdir is on the command
- * line, so it names the other checkout instead of offering `kill -9`.
- *
- * @param port - Port to probe (default {@link DEFAULT_MOCHITEST_SERVER_PORT})
- * @param options - `engineDir` is this project's absolute engine directory,
- *   the ownership boundary; `killStaleServer` opts into terminating a holder
- *   recognized as THIS checkout's debris
- */
-export async function ensureMochitestServerPortAvailable(port = DEFAULT_MOCHITEST_SERVER_PORT, options) {
-    const probe = await probeMarionettePort(port);
-    if (!probe.inUse || !probe.holder)
-        return;
-    const holder = probe.holder;
-    const holderClass = classifyMochitestServerHolder(holder, options.engineDir);
-    const owner = await readProcessOwner(holder.pid);
-    if (holderClass === 'this-checkout' &&
-        owner?.parentPid === 1 &&
-        options.killStaleServer === true &&
-        (await isStillOrphanedProcess(holder.pid, holder.commandLine))) {
-        try {
-            process.kill(holder.pid, 'SIGTERM');
-            await waitForPreflight(async () => {
-                if ((await probeMarionettePort(port)).inUse)
-                    throw new PreflightRefusalError(`Mochitest port ${port} remains busy after orphan cleanup; wait for the holder to exit.`, 'mochitest-port-busy');
-            }, 2);
-            return;
-        }
-        catch {
-            // Fall through to the refusal: a wedged httpd is exactly the case
-            // that ignores SIGTERM, and reporting it is more useful than
-            // pretending the port is now free.
-        }
-    }
-    throw new PreflightRefusalError(describeMochitestServerRefusal(port, holder, holderClass, owner?.parentPid) +
-        `\n  Parent: ${owner?.parentPid ?? 'unknown'} (${owner?.owner ?? 'unavailable'}). Use --wait-port [seconds] to queue.`, 'mochitest-port-busy');
-}
-/**
- * Builds the operator-facing refusal. Exported for direct unit testing.
- *
- * @param port - The probed port
- * @param holder - The listener found on it
- * @param holderClass - Whose harness `server.js` it is, if it is one at all
- */
-export function describeMochitestServerRefusal(port, holder, holderClass, parentPid) {
-    const killHint = process.platform === 'win32'
-        ? `Stop-Process -Id ${holder.pid} -Force`
-        : `kill -9 ${holder.pid}`;
-    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 ' +
-        '"Ran 0 checks".\n';
-    if (holderClass === 'this-checkout') {
-        if (parentPid !== 1)
-            return (evidence +
-                '  This checkout has a live or unattributed harness server. Wait for its owner to finish; --wait-port [seconds] queues behind it.');
-        return (evidence +
-            "  This is the mochitest harness's own server.js from THIS checkout's objdir, so it is " +
-            'possibly debris from an interrupted run. For a dead parent, retry with "--kill-stale-marionette" to have FireForge ' +
-            `stop it, or stop it yourself with "${killHint}" (a wedged httpd can ignore SIGTERM).`);
-    }
-    if (holderClass === 'foreign-checkout') {
-        // No kill hint on this branch, on purpose: the PID is a peer's live
-        // suite, and "kill -9 <pid>" is exactly the instruction that would have
-        // destroyed it.
-        return (evidence +
-            `  This is a mochitest httpd from ANOTHER checkout: ${describeHolderObjdir(holder.commandLine)}. ` +
-            'It is serving a live run there, so FireForge will not stop it and "--kill-stale-marionette" ' +
-            'will not either. Wait for that run to finish or free the port yourself, then retry. ' +
-            `Diagnose with "lsof -nP -iTCP:${port}".`);
-    }
-    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:${port}".`);
-}

package/dist/src/core/module-resolution-preflight.d.ts

@@ -1,65 +0,0 @@
-/**
- * Engine-aware resolution preflight for queue-owned system modules.
- *
- * An `.sys.mjs` that a packaged module imports but whose `EXTRA_JS_MODULES`
- * registration never landed kills every xpcshell suite with `xpcshell return
- * code: -11` and no output at all: no import error, no stack, nothing. The
- * queue-level `unregistered-system-module` check catches one shape of this:
- * a module newly created by a patch in the projected queue. The other shape,
- * modules imported from an already-existing module before their moz.build
- * lines land, slips past it entirely.
- *
- * This preflight closes that gap by asking the question against the engine
- * rather than against a projected diff: for every `resource:///modules/…`
- * specifier imported by any queue-owned module, does the module it names
- * exist, and is it registered in a moz.build that covers it?
- *
- * Scope is the queue-owned file set on purpose. A specifier that resolves to
- * no owned file is an upstream Firefox module, which FireForge does not
- * police and cannot cheaply enumerate. Policing only what the fork owns is
- * both the actionable set and the one that produces real incidents.
- *
- * An unscoped `verify` widens that set with the engine worktree: changed
- * files import, and untracked files are targets. A chrome script's lazy
- * getter for a new, not yet exported `.sys.mjs` with no moz.build line
- * SIGSEGVed every start of a shared objdir, and neither file was in the
- * queue yet, so the queue-only scan could not see it.
- */
-/** Why a queue-owned module import does not resolve to a packaged module. */
-export type UnresolvedModuleReason = 'missing-file' | 'unregistered';
-/** One unresolvable or unregistered system-module import. */
-export interface UnresolvedModuleImport {
-    /** Engine-relative path of the module the specifier names. */
-    module: string;
-    /** The `resource://` specifier as written. */
-    specifier: string;
-    /** Engine-relative paths of the files that import it, sorted. */
-    importers: string[];
-    reason: UnresolvedModuleReason;
-}
-/** Engine worktree files the preflight also judges, beside the queue's. */
-export interface WorktreeModuleFiles {
-    /** Changed or untracked files: scanned for imports. */
-    changed: readonly string[];
-    /** Untracked files: new modules the fork has not exported yet. */
-    untracked: readonly string[];
-}
-/** Lists the engine's changed and untracked files for the worktree scan. */
-export declare function collectWorktreeModuleFiles(engineDir: string): Promise<WorktreeModuleFiles>;
-/**
- * Resolves every `resource://` system-module import made by the
- * queue-owned files (and, given `worktree`, by changed engine files) and
- * reports the ones a packaged browser could not load.
- *
- * @param engineDir - Path to the engine checkout
- * @param ownedFiles - Engine-relative paths the patch queue owns
- * @param worktree - Changed and untracked engine files to judge as well
- * @returns Findings sorted by module path. Empty when everything resolves
- */
-export declare function findUnresolvedSystemModuleImports(engineDir: string, ownedFiles: readonly string[], worktree?: WorktreeModuleFiles): Promise<UnresolvedModuleImport[]>;
-/**
- * Renders findings as operator-facing lines, naming the unregistered or
- * unresolvable module, so the failure is a sentence instead of a bare
- * `-11`.
- */
-export declare function formatUnresolvedSystemModuleImports(findings: readonly UnresolvedModuleImport[]): string[];