@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/patch-lint-forward-registration-extended.d.ts

@@ -1,61 +0,0 @@
-import type { PatchQueueForwardRegistrationEntry, PatchQueueView } from './patch-lint-queue-types.js';
-/** Which carriers `forward-registration` checks. */
-export type ForwardRegistrationScope = 'support-files' | 'extended';
-/** The carrier kind a forward registration was found in. */
-export type ForwardRegistrationKind = 'support-files' | 'jar-mn' | 'moz-build' | 'test-manifest' | 'custom-elements';
-/** One undeclared forward registration: a line naming a file a later patch creates. */
-export interface ForwardRegistration {
-    /** The patch that adds the registration line. */
-    patch: string;
-    /** Carrier kind. */
-    kind: ForwardRegistrationKind;
-    /** Engine-relative path of the carrier file (the manifest, jar.mn, …). */
-    file: string;
-    /** The added line, whitespace-trimmed, that names the target. */
-    line: string;
-    /** The token on that line that names the target, as written. */
-    token: string;
-    /** Engine-relative path of the file the later patch creates. */
-    creates: string;
-    /** The later patch that creates it. */
-    owner: string;
-    /** How many distinct added lines in the carrier name the same target. */
-    occurrences: number;
-    /** Paste-and-run declaration that records the stage as intentional. */
-    command: string;
-}
-/**
- * jar target → packaged source, over every jar.mn line the queue adds. Only
- * exact (wildcard-free) sources can back a chrome URL lookup.
- */
-export declare function buildJarTargetIndex(entries: readonly PatchQueueForwardRegistrationEntry[]): Map<string, string>;
-/** True for a jar.mn, moz.build or test manifest, the carriers {@link resolveCarrierReferences} reads. */
-export declare function isRegistrationCarrier(file: string): boolean;
-/**
- * The engine paths named by the lines of one jar.mn, moz.build or test
- * manifest, resolved the way this rule resolves them. Exported for a caller
- * outside the queue lint (re-export's adjacency belt asks which files a
- * patch's added registration lines name). A `customElements.js` chrome URL
- * resolves only through the queue's jar.mn index, so it is not covered.
- *
- * @param rawPath - Engine-relative path of the carrier
- * @param content - The carrier lines to read (typically the added ones)
- * @returns One entry per resolvable token. `exact` is set when it has no wildcard.
- */
-export declare function resolveCarrierReferences(rawPath: string, content: string): {
-    line: string;
-    exact?: string;
-    matches: (candidate: string) => boolean;
-}[];
-/** The discharge command, in the exact shape the support-files arm prints. */
-export declare function formatRegistrationDeclaration(patch: string, file: string, line: string, creates: string, owner: string): string;
-/**
- * Finds every undeclared forward registration in the extended carriers:
- * a registration line a patch adds that names a file only a later-ordered
- * patch creates. Creators come from `createdFiles` (the `new file mode`
- * sections), never `filesAffected`.
- *
- * @param ctx - Queue in application order
- * @returns One record per (patch, carrier, created file), first line quoted
- */
-export declare function findExtendedForwardRegistrations(ctx: PatchQueueView<PatchQueueForwardRegistrationEntry>): ForwardRegistration[];

package/dist/src/core/patch-lint-forward-registration-extended.js

@@ -1,265 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The opt-in arms of the `forward-registration` rule
- * (`patchLint.forwardRegistration: "extended"`).
- *
- * The default rule covers test-manifest `support-files` only. These arms
- * cover the carriers whose target resolves WITHOUT the build system:
- *
- * - a jar.mn pair line: the packaged source is on the line, in parentheses,
- *   relative to the jar.mn directory (or `/`-rooted at the source root);
- * - a moz.build path token (a quoted string with a `.` or `/`), relative to
- *   the moz.build directory (or `/`-rooted);
- * - a test manifest's section header (`["browser_foo.js"]`) and `head`,
- *   relative to the manifest directory;
- * - a `customElements.js` `chrome://<pkg>/content/<path>` URL, resolved
- *   through the jar.mn lines the same queue adds (`content/<pkg>/<path>`
- *   is the jar target that URL serves).
- *
- * Anything else stays silent: a preprocessor or locale substitution, a
- * `**` or `!` pattern, a path that climbs out of the tree, a chrome URL no
- * queue jar.mn line packages. A rule that guessed there would refuse
- * correct queues on a Firefox-sized tree.
- *
- * Opt-in because a queue that predates it can carry many such edges on a
- * ratchet, and a new error on install would red a `--max-warnings 0` gate.
- */
-import { basename, dirname, posix } from 'node:path';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { escapeRegex } from '../utils/regex.js';
-import { parseJarMnEntry } from './build-audit-registration.js';
-import { isLaterOwner, quoteRegistrationLine, STAGED_DEPENDENCY_REASON_PLACEHOLDER, } from './patch-lint-staged-registration.js';
-const TEST_MANIFEST_BASENAMES = new Set([
-    'xpcshell.toml',
-    'xpcshell.ini',
-    'mochitest.toml',
-    'mochitest.ini',
-    'browser.toml',
-    'browser.ini',
-    'chrome.toml',
-    'chrome.ini',
-    'a11y.toml',
-    'a11y.ini',
-]);
-/**
- * Resolves a path token against a base directory into a matcher. A leading
- * `/` is rooted at the source tree. Only a `*` inside one segment is
- * expanded. Substitutions (`%`, `@`), `**`, `!` and paths that climb out of
- * the tree resolve to nothing.
- */
-function resolvePathToken(baseDir, token) {
-    if (/[%@!\s]/.test(token) || token.includes('**'))
-        return undefined;
-    const joined = token.startsWith('/')
-        ? posix.normalize(token.slice(1))
-        : posix.normalize(posix.join(baseDir, normalizePathSlashes(token)));
-    if (joined.startsWith('..') || joined === '.' || joined.length === 0)
-        return undefined;
-    if (!joined.includes('*')) {
-        return { exact: joined, matches: (candidate) => candidate === joined };
-    }
-    const pattern = new RegExp(`^${joined
-        .split('*')
-        .map((part) => escapeRegex(part))
-        .join('[^/]*')}$`);
-    return { matches: (candidate) => pattern.test(candidate) };
-}
-function carrierDir(file) {
-    const dir = normalizePathSlashes(dirname(file));
-    return dir === '.' ? '' : dir;
-}
-function jarMnReferences(file, content) {
-    const refs = [];
-    for (const raw of content.split('\n')) {
-        const parsed = parseJarMnEntry(raw);
-        if (!parsed)
-            continue;
-        const resolved = resolvePathToken(carrierDir(file), parsed.source);
-        if (resolved)
-            refs.push({ kind: 'jar-mn', file, line: raw.trim(), token: parsed.source, ...resolved });
-    }
-    return refs;
-}
-function mozBuildReferences(file, content) {
-    const refs = [];
-    for (const raw of content.split('\n')) {
-        if (raw.trimStart().startsWith('#'))
-            continue;
-        for (const quoted of raw.matchAll(/["']([^"']+)["']/g)) {
-            const token = quoted[1] ?? '';
-            // A path names a file: it has an extension or a directory. Bare words
-            // ("Firefox", a define's value) are not paths.
-            if (!token.includes('.') && !token.includes('/'))
-                continue;
-            const resolved = resolvePathToken(carrierDir(file), token);
-            if (resolved)
-                refs.push({ kind: 'moz-build', file, line: raw.trim(), token, ...resolved });
-        }
-    }
-    return refs;
-}
-function testManifestReferences(file, content) {
-    const refs = [];
-    for (const raw of content.split('\n')) {
-        const section = /^\s*\[\s*["']?([^"'\]]+?)["']?\s*\]\s*$/.exec(raw);
-        const head = /^\s*head\s*=\s*["']?([^"'\s]+)["']?\s*$/.exec(raw);
-        const token = section?.[1] ?? head?.[1];
-        if (token === undefined || token === 'DEFAULT')
-            continue;
-        const resolved = resolvePathToken(carrierDir(file), token);
-        if (resolved)
-            refs.push({ kind: 'test-manifest', file, line: raw.trim(), token, ...resolved });
-    }
-    return refs;
-}
-/**
- * jar target → packaged source, over every jar.mn line the queue adds. Only
- * exact (wildcard-free) sources can back a chrome URL lookup.
- */
-export function buildJarTargetIndex(entries) {
-    const index = new Map();
-    for (const entry of entries) {
-        for (const [file, content] of [...entry.newFiles, ...entry.modifiedFileAdditions]) {
-            if (basename(normalizePathSlashes(file)) !== 'jar.mn')
-                continue;
-            for (const raw of content.split('\n')) {
-                const parsed = parseJarMnEntry(raw);
-                if (!parsed)
-                    continue;
-                const resolved = resolvePathToken(carrierDir(file), parsed.source);
-                if (resolved?.exact !== undefined)
-                    index.set(parsed.target, resolved.exact);
-            }
-        }
-    }
-    return index;
-}
-function customElementsReferences(file, content, jarTargets) {
-    const refs = [];
-    for (const raw of content.split('\n')) {
-        for (const url of raw.matchAll(/chrome:\/\/([\w.-]+)\/content\/([^"'\s)]+)/g)) {
-            const source = jarTargets.get(`content/${url[1] ?? ''}/${url[2] ?? ''}`);
-            if (source === undefined)
-                continue;
-            refs.push({
-                kind: 'custom-elements',
-                file,
-                line: raw.trim(),
-                token: url[0],
-                exact: source,
-                matches: (candidate) => candidate === source,
-            });
-        }
-    }
-    return refs;
-}
-/** True for a jar.mn, moz.build or test manifest, the carriers {@link resolveCarrierReferences} reads. */
-export function isRegistrationCarrier(file) {
-    const name = basename(normalizePathSlashes(file));
-    return name === 'jar.mn' || name === 'moz.build' || TEST_MANIFEST_BASENAMES.has(name);
-}
-function carrierReferences(file, content) {
-    const name = basename(file);
-    if (name === 'jar.mn')
-        return jarMnReferences(file, content);
-    if (name === 'moz.build')
-        return mozBuildReferences(file, content);
-    if (TEST_MANIFEST_BASENAMES.has(name))
-        return testManifestReferences(file, content);
-    return [];
-}
-/**
- * The engine paths named by the lines of one jar.mn, moz.build or test
- * manifest, resolved the way this rule resolves them. Exported for a caller
- * outside the queue lint (re-export's adjacency belt asks which files a
- * patch's added registration lines name). A `customElements.js` chrome URL
- * resolves only through the queue's jar.mn index, so it is not covered.
- *
- * @param rawPath - Engine-relative path of the carrier
- * @param content - The carrier lines to read (typically the added ones)
- * @returns One entry per resolvable token. `exact` is set when it has no wildcard.
- */
-export function resolveCarrierReferences(rawPath, content) {
-    return carrierReferences(normalizePathSlashes(rawPath), content);
-}
-function referencesFor(entry, jarTargets) {
-    const refs = [];
-    for (const [rawPath, content] of [...entry.newFiles, ...entry.modifiedFileAdditions]) {
-        const file = normalizePathSlashes(rawPath);
-        if (basename(file) === 'customElements.js') {
-            refs.push(...customElementsReferences(file, content, jarTargets));
-        }
-        else {
-            refs.push(...carrierReferences(file, content));
-        }
-    }
-    return refs;
-}
-function isDeclared(entry, file, created) {
-    return (entry.metadata?.stagedDependencies?.registrations ?? []).some((registration) => normalizePathSlashes(registration.file) === file &&
-        normalizePathSlashes(registration.creates) === created);
-}
-/** The discharge command, in the exact shape the support-files arm prints. */
-export function formatRegistrationDeclaration(patch, file, line, creates, owner) {
-    return (`fireforge patch staged-dependency ${patch} --add --kind registration ` +
-        `--file ${file} --line "${quoteRegistrationLine(line)}" ` +
-        `--creates ${creates} --owner ${owner} ${STAGED_DEPENDENCY_REASON_PLACEHOLDER}`);
-}
-/**
- * Finds every undeclared forward registration in the extended carriers:
- * a registration line a patch adds that names a file only a later-ordered
- * patch creates. Creators come from `createdFiles` (the `new file mode`
- * sections), never `filesAffected`.
- *
- * @param ctx - Queue in application order
- * @returns One record per (patch, carrier, created file), first line quoted
- */
-export function findExtendedForwardRegistrations(ctx) {
-    const jarTargets = buildJarTargetIndex(ctx.entries);
-    const creatorsByPath = new Map();
-    for (const entry of ctx.entries) {
-        for (const created of entry.createdFiles) {
-            const path = normalizePathSlashes(created);
-            const list = creatorsByPath.get(path) ?? [];
-            list.push(entry);
-            creatorsByPath.set(path, list);
-        }
-    }
-    const found = new Map();
-    const linesByKey = new Map();
-    for (const entry of ctx.entries) {
-        for (const ref of referencesFor(entry, jarTargets)) {
-            const candidates = ref.exact !== undefined
-                ? (creatorsByPath.get(ref.exact) ?? []).map((owner) => [ref.exact ?? '', owner])
-                : [...creatorsByPath].flatMap(([path, owners]) => ref.matches(path) ? owners.map((owner) => [path, owner]) : []);
-            for (const [created, later] of candidates) {
-                if (!isLaterOwner(later, entry))
-                    continue;
-                if (isDeclared(entry, ref.file, created))
-                    continue;
-                const key = `${entry.filename}|${ref.file}|${created}|${later.filename}`;
-                const existing = found.get(key);
-                if (existing !== undefined) {
-                    const lines = linesByKey.get(key) ?? new Set();
-                    lines.add(ref.line);
-                    linesByKey.set(key, lines);
-                    existing.occurrences = lines.size;
-                    continue;
-                }
-                linesByKey.set(key, new Set([ref.line]));
-                found.set(key, {
-                    patch: entry.filename,
-                    kind: ref.kind,
-                    file: ref.file,
-                    line: ref.line,
-                    token: ref.token,
-                    creates: created,
-                    owner: later.filename,
-                    occurrences: 1,
-                    command: formatRegistrationDeclaration(entry.filename, ref.file, ref.line, created, later.filename),
-                });
-            }
-        }
-    }
-    return [...found.values()];
-}

package/dist/src/core/patch-lint-forward-registration.d.ts

@@ -1,71 +0,0 @@
-import type { PatchLintIssue } from '../types/commands/index.js';
-import { type ForwardRegistration, type ForwardRegistrationScope } from './patch-lint-forward-registration-extended.js';
-import type { PatchQueueForwardRegistrationEntry, PatchQueueView } from './patch-lint-queue-types.js';
-/**
- * One `support-files` entry, with the line the patch actually adds it on.
- *
- * The entry alone is not enough for the discharge command the rule prints:
- * `--line` is compared, whitespace-trimmed, against the lines the patch
- * adds, and a synthesised `support-files = ["<entry>"]` only ever matches a
- * manifest whose array is single-line and single-entry. Carrying the source
- * line keeps the remedy and the validation talking about the same text.
- */
-export interface SupportFileEntry {
-    /** The entry as written inside the manifest (e.g. `fixtures/*.sqlite`). */
-    entry: string;
-    /** The first added line, whitespace-trimmed, that spells the entry out. */
-    line: string;
-    /**
-     * How many distinct added lines spell it out. Above one, the printed
-     * command quotes the first and says so: one declaration covers the file
-     * either way, because the declared check keys on file + creates.
-     */
-    occurrences: number;
-}
-/**
- * Extracts the `support-files` entries declared in `content`, each paired
- * with the manifest line it is written on.
- *
- * Handles the TOML array on one line and spread over several, and the
- * whitespace-separated `.ini` spelling. Anything else (a computed value, a
- * shape this does not recognise) yields nothing, because a rule that
- * guesses at a manifest it cannot parse refuses correct queues.
- *
- * Quoted tokens are matched per physical line rather than over the whole
- * accumulated array body, so a multi-line array attributes each element to
- * its own line. Entries are deduplicated: a manifest that lists the same
- * file under two per-test sections needs one declaration, not two.
- */
-export declare function extractSupportFileEntries(content: string): SupportFileEntry[];
-/**
- * Resolves one `support-files` entry, relative to its manifest's directory,
- * into a matcher over engine-relative paths.
- *
- * Only a `*` inside a single path segment is expanded, the shape the
- * downstream report uses (`fixtures/*.sqlite`). `**`, `!` exclusions and
- * absolute `/`-rooted entries return undefined: they either cross directory
- * boundaries or subtract, and a matcher that guessed at them would attribute
- * a creation to the wrong manifest.
- */
-export declare function buildSupportFileMatcher(manifestPath: string, entry: string): ((candidate: string) => boolean) | undefined;
-/**
- * Every undeclared forward registration in the queue, over the carriers
- * `scope` selects: `support-files` (the default) or `extended` (adds
- * jar.mn, moz.build, test-manifest sections and customElements.js; see
- * `patch-lint-forward-registration-extended.ts`).
- *
- * @param ctx - Queue in application order
- * @param scope - Which carriers to check
- */
-export declare function collectForwardRegistrations(ctx: PatchQueueView<PatchQueueForwardRegistrationEntry>, scope?: ForwardRegistrationScope): ForwardRegistration[];
-/**
- * Flags every forward registration the queue's scope selects, unless the
- * staged dependency is declared.
- *
- * @param ctx - Projected queue in application order, with its
- *   `forwardRegistration` scope (default `support-files`)
- * @returns One issue per undeclared forward registration
- */
-export declare function lintPatchQueueForwardRegistrations(ctx: PatchQueueView<PatchQueueForwardRegistrationEntry> & {
-    forwardRegistration?: ForwardRegistrationScope;
-}): PatchLintIssue[];

package/dist/src/core/patch-lint-forward-registration.js

@@ -1,266 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Cross-patch lint rule: a test manifest that registers a file a
- * later-ordered patch creates, without declaring the staged dependency.
- *
- * The import kind has had this arm since forward-import shipped. The
- * registration kind never did. `--kind registration` metadata was only ever
- * checked for staleness once declared, so a patch whose `xpcshell.toml`
- * carried `support-files = ["fixtures/*.sqlite"]` for a fixture the next
- * patch creates passed lint in both arms. Declaring the dependency and
- * removing the declaration produced identical silence, so the gap was
- * invisible rather than merely absent.
- *
- * Scope is narrow by default: test-manifest `support-files` only. The
- * carriers whose target resolves without the build system (jar.mn pair
- * lines, moz.build path tokens, test-manifest sections, customElements.js
- * chrome URLs) are opt-in through `patchLint.forwardRegistration:
- * "extended"` (see `patch-lint-forward-registration-extended.ts`), since a
- * queue that predates them can carry such edges on a ratchet and a new
- * error on install would red its gate. The staged-registration declaration
- * remains the documented escape hatch for a deliberate stage.
- */
-import { basename, dirname, posix } from 'node:path';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { escapeRegex } from '../utils/regex.js';
-import { findExtendedForwardRegistrations, formatRegistrationDeclaration, } from './patch-lint-forward-registration-extended.js';
-import { isLaterOwner } from './patch-lint-staged-registration.js';
-/**
- * Manifest basenames whose `support-files` key registers auxiliary files
- * for a test suite. Closed and documented on purpose: a pattern like
- * "anything .toml" would sweep in Cargo and taskcluster manifests, whose
- * `support-files`-shaped keys mean something else entirely.
- */
-const TEST_MANIFEST_BASENAMES = new Set([
-    'xpcshell.toml',
-    'xpcshell.ini',
-    'mochitest.toml',
-    'mochitest.ini',
-    'browser.toml',
-    'browser.ini',
-    'chrome.toml',
-    'chrome.ini',
-    'a11y.toml',
-    'a11y.ini',
-]);
-/** True for a path whose basename is a recognised test manifest. */
-function isTestManifestPath(path) {
-    return TEST_MANIFEST_BASENAMES.has(basename(normalizePathSlashes(path)));
-}
-/** Matches the start of a `support-files` assignment. */
-const SUPPORT_FILES_PATTERN = /^\s*support-files\s*=\s*(.*)$/;
-/**
- * Extracts the `support-files` entries declared in `content`, each paired
- * with the manifest line it is written on.
- *
- * Handles the TOML array on one line and spread over several, and the
- * whitespace-separated `.ini` spelling. Anything else (a computed value, a
- * shape this does not recognise) yields nothing, because a rule that
- * guesses at a manifest it cannot parse refuses correct queues.
- *
- * Quoted tokens are matched per physical line rather than over the whole
- * accumulated array body, so a multi-line array attributes each element to
- * its own line. Entries are deduplicated: a manifest that lists the same
- * file under two per-test sections needs one declaration, not two.
- */
-export function extractSupportFileEntries(content) {
-    const lines = content.split('\n');
-    const order = [];
-    const sourceLines = new Map();
-    const record = (entry, source) => {
-        let seen = sourceLines.get(entry);
-        if (seen === undefined) {
-            seen = [];
-            sourceLines.set(entry, seen);
-            order.push(entry);
-        }
-        const trimmed = source.trim();
-        if (!seen.includes(trimmed))
-            seen.push(trimmed);
-    };
-    for (let i = 0; i < lines.length; i++) {
-        const raw = lines[i] ?? '';
-        const match = SUPPORT_FILES_PATTERN.exec(raw);
-        if (!match)
-            continue;
-        const head = match[1] ?? '';
-        if (!head.trimStart().startsWith('[')) {
-            // `.ini` spelling: whitespace-separated bare paths on one line.
-            for (const token of head.split(/\s+/).filter((t) => t.length > 0))
-                record(token, raw);
-            continue;
-        }
-        // TOML array: walk the physical lines until the closing bracket,
-        // bounded so an unterminated array in a malformed manifest cannot walk
-        // the file.
-        let body = head;
-        let scanned = 0;
-        let current = raw;
-        for (;;) {
-            for (const quoted of current.matchAll(/["']([^"']+)["']/g)) {
-                if (quoted[1] !== undefined)
-                    record(quoted[1], current);
-            }
-            if (body.includes(']') || i + 1 >= lines.length || scanned >= 200)
-                break;
-            i += 1;
-            scanned += 1;
-            current = lines[i] ?? '';
-            body += `\n${current}`;
-        }
-    }
-    return order.map((entry) => {
-        const seen = sourceLines.get(entry) ?? [];
-        return { entry, line: seen[0] ?? '', occurrences: seen.length };
-    });
-}
-/**
- * Resolves one `support-files` entry, relative to its manifest's directory,
- * into a matcher over engine-relative paths.
- *
- * Only a `*` inside a single path segment is expanded, the shape the
- * downstream report uses (`fixtures/*.sqlite`). `**`, `!` exclusions and
- * absolute `/`-rooted entries return undefined: they either cross directory
- * boundaries or subtract, and a matcher that guessed at them would attribute
- * a creation to the wrong manifest.
- */
-export function buildSupportFileMatcher(manifestPath, entry) {
-    if (entry.startsWith('!') || entry.includes('**') || entry.startsWith('/'))
-        return undefined;
-    const resolved = posix.normalize(posix.join(normalizePathSlashes(dirname(manifestPath)), normalizePathSlashes(entry)));
-    if (resolved.startsWith('..'))
-        return undefined;
-    if (!resolved.includes('*')) {
-        return (candidate) => normalizePathSlashes(candidate) === resolved;
-    }
-    const pattern = new RegExp(`^${resolved
-        .split('*')
-        .map((part) => escapeRegex(part))
-        .join('[^/]*')}$`);
-    return (candidate) => pattern.test(normalizePathSlashes(candidate));
-}
-/** True when this patch already declares the staged registration. */
-function isDeclared(entry, manifestPath, createdPath) {
-    return (entry.metadata?.stagedDependencies?.registrations ?? []).some((registration) => normalizePathSlashes(registration.file) === normalizePathSlashes(manifestPath) &&
-        normalizePathSlashes(registration.creates) === normalizePathSlashes(createdPath));
-}
-/**
- * Finds every `support-files` registration a patch introduces that names a
- * file only a later-ordered patch creates, unless the staged dependency is
- * declared.
- *
- * @param ctx - Projected queue in application order
- * @returns One record per (patch, manifest, entry, created file)
- */
-function findSupportFileForwardRegistrations(ctx) {
-    const found = [];
-    for (const entry of ctx.entries) {
-        // Both arms: a manifest this patch creates and one it modifies can each
-        // introduce a registration line.
-        const manifests = [
-            ...entry.newFiles,
-            ...entry.modifiedFileAdditions,
-        ].filter(([path]) => isTestManifestPath(path));
-        for (const [manifestPath, content] of manifests) {
-            for (const { entry: raw, line: addedLine, occurrences } of extractSupportFileEntries(content)) {
-                const matches = buildSupportFileMatcher(manifestPath, raw);
-                if (matches === undefined)
-                    continue;
-                for (const later of ctx.entries) {
-                    // Same predicate the declared-registration arm validates against,
-                    // tiebreak included: two spellings of "later" would let one rule
-                    // flag a pair the other considers already satisfied.
-                    if (!isLaterOwner(later, entry))
-                        continue;
-                    for (const created of later.createdFiles) {
-                        if (!matches(created))
-                            continue;
-                        if (isDeclared(entry, manifestPath, created))
-                            continue;
-                        found.push({
-                            patch: entry.filename,
-                            kind: 'support-files',
-                            file: manifestPath,
-                            // `--line` is the line as the patch adds it, which is what the
-                            // declared arm compares and what `--remove` matches on.
-                            // Synthesising `support-files = ["<entry>"]` instead only ever
-                            // matched a single-line single-entry array, so the pasted
-                            // command left the declaring patch red with
-                            // staged-dependency-unused.
-                            line: addedLine,
-                            token: raw,
-                            creates: created,
-                            owner: later.filename,
-                            occurrences,
-                            command: formatRegistrationDeclaration(entry.filename, manifestPath, addedLine, created, later.filename),
-                        });
-                    }
-                }
-            }
-        }
-    }
-    return found;
-}
-/**
- * Every undeclared forward registration in the queue, over the carriers
- * `scope` selects: `support-files` (the default) or `extended` (adds
- * jar.mn, moz.build, test-manifest sections and customElements.js; see
- * `patch-lint-forward-registration-extended.ts`).
- *
- * @param ctx - Queue in application order
- * @param scope - Which carriers to check
- */
-export function collectForwardRegistrations(ctx, scope = 'support-files') {
-    const found = findSupportFileForwardRegistrations(ctx);
-    if (scope === 'extended')
-        found.push(...findExtendedForwardRegistrations(ctx));
-    return found;
-}
-const KIND_PHRASES = {
-    'support-files': 'as a support file',
-    'jar-mn': 'for packaging',
-    'moz-build': 'in the build',
-    'test-manifest': 'as a test',
-    'custom-elements': 'as a custom element',
-};
-/**
- * Flags every forward registration the queue's scope selects, unless the
- * staged dependency is declared.
- *
- * @param ctx - Projected queue in application order, with its
- *   `forwardRegistration` scope (default `support-files`)
- * @returns One issue per undeclared forward registration
- */
-export function lintPatchQueueForwardRegistrations(ctx) {
-    return collectForwardRegistrations(ctx, ctx.forwardRegistration).map((found) => {
-        const ambiguity = found.occurrences > 1
-            ? ` (the entry is spelled out on ${found.occurrences} added lines here; ` +
-                'the first is quoted, and one declaration covers the file either way ' +
-                'because the declared check keys on --file and --creates.)'
-            : '';
-        return {
-            file: found.file,
-            check: 'forward-registration',
-            patches: [found.patch],
-            fingerprint: `forward-registration|${found.patch}|${found.file}|${found.token}|${found.creates}|${found.owner}`,
-            stagedDeclarations: [
-                {
-                    patch: found.patch,
-                    kind: 'registration',
-                    file: found.file,
-                    line: found.line,
-                    creates: found.creates,
-                    owner: found.owner,
-                },
-            ],
-            message: `${found.file} in ${found.patch} registers "${found.token}" ${KIND_PHRASES[found.kind]}, ` +
-                `but ${found.creates} is created by the later patch ${found.owner}. ` +
-                'Applying the queue up to this patch leaves the registration dangling. ' +
-                'Reorder the patches so the file is created first, move the registration into ' +
-                'the later patch, or declare the intentional staged dependency with: ' +
-                found.command +
-                ambiguity,
-            severity: 'error',
-        };
-    });
-}