@hominis/fireforge 0.47.1 → 0.49.0

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

@@ -0,0 +1,151 @@
+// 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;
+}
+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);
+                }
+                finally {
+                    await rm(temp, { force: true });
+                }
+            }
+        }
+        else if (isDependencyMetadata(path)) {
+            const content = await readFile(path, 'utf8');
+            const rewritten = content.replaceAll(oldRoot + sep, newRoot + sep);
+            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/patch-apply-fuzz.d.ts

@@ -26,6 +26,18 @@ export interface FuzzyApplyResult {
     /** List of `.rej` files created (when falling through to --reject). */
     rejectFiles?: string[];
 }
+/**
+ * The context-reduction ladder shared by the real apply and the dry-run
+ * replay: step 0 is an exact apply, step k passes `-C(3-k)`.
+ * @param maxFuzz - Maximum context-reduction steps (validated by callers)
+ * @returns One `git apply` argument list per step, in order
+ */
+export declare function contextReductionSteps(maxFuzz: number): string[][];
+/**
+ * Validates a `maxFuzz` value.
+ * @throws InvalidArgumentError when `maxFuzz` is not a non-negative integer
+ */
+export declare function assertValidMaxFuzz(maxFuzz: number): void;
 /**
  * Attempts to apply a patch with escalating context reduction.
  *

package/dist/src/core/patch-apply-fuzz.js

@@ -23,6 +23,29 @@ import { exec } from '../utils/process.js';
 import { ensureGit } from './git-base.js';
 /** Git's default diff context width, the ceiling for reduction steps. */
 const GIT_DEFAULT_CONTEXT = 3;
+/**
+ * The context-reduction ladder shared by the real apply and the dry-run
+ * replay: step 0 is an exact apply, step k passes `-C(3-k)`.
+ * @param maxFuzz - Maximum context-reduction steps (validated by callers)
+ * @returns One `git apply` argument list per step, in order
+ */
+export function contextReductionSteps(maxFuzz) {
+    const maxSteps = Math.min(maxFuzz, GIT_DEFAULT_CONTEXT);
+    const steps = [];
+    for (let step = 0; step <= maxSteps; step++) {
+        steps.push(step > 0 ? [`-C${GIT_DEFAULT_CONTEXT - step}`] : []);
+    }
+    return steps;
+}
+/**
+ * Validates a `maxFuzz` value.
+ * @throws InvalidArgumentError when `maxFuzz` is not a non-negative integer
+ */
+export function assertValidMaxFuzz(maxFuzz) {
+    if (!Number.isInteger(maxFuzz) || maxFuzz < 0) {
+        throw new InvalidArgumentError(`maxFuzz must be a non-negative integer, got ${maxFuzz}.`, 'maxFuzz');
+    }
+}
 // ── Implementation ──
 /**
  * Attempts to apply a patch with escalating context reduction.
@@ -41,14 +64,12 @@ const GIT_DEFAULT_CONTEXT = 3;
  *   (including the exact-match one) and fall straight through to `--reject`
  */
 export async function applyPatchWithFuzz(patchPath, engineDir, maxFuzz = 3) {
-    if (!Number.isInteger(maxFuzz) || maxFuzz < 0) {
-        throw new InvalidArgumentError(`maxFuzz must be a non-negative integer, got ${maxFuzz}.`, 'maxFuzz');
-    }
+    assertValidMaxFuzz(maxFuzz);
     await ensureGit();
     // Try exact match first, then escalate context reduction.
-    const maxSteps = Math.min(maxFuzz, GIT_DEFAULT_CONTEXT);
-    for (let step = 0; step <= maxSteps; step++) {
-        const contextArgs = step > 0 ? [`-C${GIT_DEFAULT_CONTEXT - step}`] : [];
+    const ladder = contextReductionSteps(maxFuzz);
+    const maxSteps = ladder.length - 1;
+    for (const [step, contextArgs] of ladder.entries()) {
         const check = await exec('git', ['apply', '--check', ...contextArgs, '--', patchPath], {
             cwd: engineDir,
         });

package/dist/src/core/patch-apply.d.ts

@@ -63,6 +63,19 @@ export interface PatchedContentContext {
     getAffectingPatches: (filePath: string) => readonly PatchInfo[];
     /** Patch body text, memoized per patch path across the whole batch. */
     readPatchBody: (patch: PatchInfo) => Promise<string>;
+    /**
+     * Reads the HEAD content of every path in one `git cat-file --batch`
+     * and holds it for the next {@link computePatched} of each path, which
+     * otherwise spawns one `git show` per file. Call it before a loop.
+     */
+    prefetchBase: (filePaths: readonly string[]) => Promise<void>;
+    /**
+     * Hashes every live file in one `git hash-object` per ARG_MAX chunk and
+     * holds the hashes for {@link liveBlobHash}.
+     */
+    prefetchLiveBlobHashes: (fullPaths: readonly string[]) => Promise<void>;
+    /** The live blob hash of a file, from the prefetch or a single hash-object. */
+    liveBlobHash: (fullPath: string) => Promise<string | undefined>;
 }
 /**
  * Builds a batched patched-content context that loads the manifest and

package/dist/src/core/patch-apply.js

@@ -11,7 +11,7 @@ import { pathExists, readText, writeFileAtomic, writeText } from '../utils/fs.js
 import { verbose } from '../utils/logger.js';
 import { isContainedRelativePath } from '../utils/paths.js';
 import { applyPatchIdempotent, reversePatch } from './git.js';
-import { getFileContentAtRef } from './git-file-ops.js';
+import { getFileContentAtRef, getFilesContentAtRef, hashObjectBatch } from './git-file-ops.js';
 import { discoverPatches } from './patch-files.js';
 import { loadPatchesManifest } from './patch-manifest.js';
 import { extractAffectedFiles, extractConflictingFiles, isNewFileInPatch, parseDiffSections, } from './patch-parse.js';
@@ -395,12 +395,37 @@ export async function createPatchedContentContext(patchesDir, engineDir) {
         return body;
     };
     const getAffectingPatches = (filePath) => affectingByFile.get(filePath) ?? [];
+    // Prefetched HEAD content, consumed on first use so a large scan does not
+    // hold every base file for the life of the context.
+    const baseContent = new Map();
+    const takeBase = async (filePath) => {
+        if (baseContent.has(filePath)) {
+            const content = baseContent.get(filePath) ?? null;
+            baseContent.delete(filePath);
+            return content;
+        }
+        return getFileContentAtRef(engineDir, filePath);
+    };
+    const liveHashes = new Map();
     return {
         manifestPatches: manifest?.patches ?? [],
         getAffectingPatches,
         readPatchBody,
+        prefetchBase: async (filePaths) => {
+            const wanted = filePaths.filter((file) => !baseContent.has(file));
+            for (const [file, content] of await getFilesContentAtRef(engineDir, wanted)) {
+                baseContent.set(file, content);
+            }
+        },
+        prefetchLiveBlobHashes: async (fullPaths) => {
+            const wanted = fullPaths.filter((path) => !liveHashes.has(path));
+            for (const [path, hash] of await hashObjectBatch(engineDir, wanted)) {
+                liveHashes.set(path, hash);
+            }
+        },
+        liveBlobHash: async (fullPath) => liveHashes.get(fullPath) ?? (await hashObjectBatch(engineDir, [fullPath])).get(fullPath),
         computePatched: async (filePath) => {
-            let content = await getFileContentAtRef(engineDir, filePath);
+            let content = await takeBase(filePath);
             for (const patch of getAffectingPatches(filePath)) {
                 content = applyPatchTextToContent(content, await readPatchBody(patch), filePath);
             }

package/dist/src/core/patch-lint-checkjs-cache.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Parsed `SourceFile`s reused across programs, keyed by file name and the
+ * parse options TypeScript asked for. The language service shares files
+ * across programs the same way (its document registry): a `SourceFile` is
+ * parsed and bound once, and every program that includes it reuses both.
+ * Only valid while the files cannot change and every program uses the same
+ * compiler options, which holds within one lint run.
+ */
+export type CheckJsSourceFileCache = Map<string, import('typescript').SourceFile>;
+/**
+ * Returns `host` with a shared-parse `getSourceFile` when a cache is given,
+ * or `host` itself when not.
+ * @param host - The program's compiler host
+ * @param cache - Shared parse cache, or undefined for an unshared program
+ * @param shimPath - Path the host serves the composed shim at
+ * @param shimSource - The composed shim text
+ */
+export declare function withSharedSourceFiles(host: import('typescript').CompilerHost, cache: CheckJsSourceFileCache | undefined, shimPath: string, shimSource: string): import('typescript').CompilerHost;

package/dist/src/core/patch-lint-checkjs-cache.js

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Parsed-source sharing across checkJs programs.
+ *
+ * Its own module rather than part of `patch-lint-checkjs.ts` only because
+ * that file sits on a 500-line budget.
+ */
+import { sha256Hex } from '../utils/hash.js';
+/**
+ * Wraps a host's `getSourceFile` so each file is parsed at most once per
+ * cache. The shim is keyed by its content as well, since the shim text is
+ * composed per call rather than read from disk.
+ */
+function cachingGetSourceFile(cache, shimPath, shimSource, getSourceFile) {
+    const shimDigest = sha256Hex(shimSource);
+    return (fileName, languageVersionOrOptions, onError, shouldCreate) => {
+        const parse = typeof languageVersionOrOptions === 'object'
+            ? `${languageVersionOrOptions.languageVersion}|${String(languageVersionOrOptions.impliedNodeFormat)}`
+            : String(languageVersionOrOptions);
+        const key = fileName === shimPath ? `${fileName}\0${parse}\0${shimDigest}` : `${fileName}\0${parse}`;
+        const cached = cache.get(key);
+        if (cached !== undefined)
+            return cached;
+        const created = getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreate);
+        if (created !== undefined)
+            cache.set(key, created);
+        return created;
+    };
+}
+/**
+ * Returns `host` with a shared-parse `getSourceFile` when a cache is given,
+ * or `host` itself when not.
+ * @param host - The program's compiler host
+ * @param cache - Shared parse cache, or undefined for an unshared program
+ * @param shimPath - Path the host serves the composed shim at
+ * @param shimSource - The composed shim text
+ */
+export function withSharedSourceFiles(host, cache, shimPath, shimSource) {
+    if (cache === undefined)
+        return host;
+    return {
+        ...host,
+        getSourceFile: cachingGetSourceFile(cache, shimPath, shimSource, host.getSourceFile.bind(host)),
+    };
+}

package/dist/src/core/patch-lint-checkjs.d.ts

@@ -26,6 +26,7 @@
  */
 import type { PatchLintIssue } from '../types/commands/index.js';
 import type { PatchLintCheckJsCompilerOptions, PatchLintConfig, PatchLintSeverityGate } from '../types/config.js';
+import { type CheckJsSourceFileCache } from './patch-lint-checkjs-cache.js';
 /** How a checkJs run controls reporting and resolution. See module docs. */
 export interface CheckJsMode {
     strict: boolean;
@@ -76,6 +77,11 @@ export interface RunCheckJsGroupedInput {
      * targets.
      */
     rootScope?: ReadonlySet<string>;
+    /**
+     * Parsed source files shared across several programs built with the same
+     * compiler options and shim in one run. See {@link runCheckJsTestFilesGrouped}.
+     */
+    sourceFileCache?: CheckJsSourceFileCache;
 }
 /**
  * Builds the checkJs program once over `resolutionOwned` and returns its

package/dist/src/core/patch-lint-checkjs.js

@@ -30,6 +30,8 @@ import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { normalizePathSlashes } from '../utils/paths.js';
+import { withGeckoDomTypes } from './gecko-dom-types.js';
+import { withSharedSourceFiles } from './patch-lint-checkjs-cache.js';
 import { collectUnmanagedCompanions, retargetUnmanagedCompanionHints, } from './patch-lint-unmanaged-companion.js';
 import { composeShimSource, SHIM_FILENAME, SUPPRESSED_DIAGNOSTIC_CODES, TEST_HARNESS_SHIM, UNDEFINED_IDENTIFIER_CODES, UNDEFINED_IDENTIFIER_HINT, } from './typecheck-shim.js';
 // ---------------------------------------------------------------------------
@@ -294,7 +296,7 @@ export async function runCheckJsGrouped(input) {
     // Custom compiler host: reads patch-owned files from disk, returns
     // the shim for the shim path, and returns empty content for
     // anything else to avoid reading the full Firefox tree.
-    const defaultHost = ts.createCompilerHost(options);
+    const defaultHost = withGeckoDomTypes(ts, ts.createCompilerHost(options));
     // Files pulled in via a reviewed `paths` mapping: outside the owned set
     // but read from disk so the resolver's targets actually type-check.
     const pathsResolved = new Set();
@@ -340,7 +342,7 @@ export async function runCheckJsGrouped(input) {
             });
         },
     };
-    const program = ts.createProgram(rootFiles, options, host);
+    const program = ts.createProgram(rootFiles, options, withSharedSourceFiles(host, input.sourceFileCache, shimPath, shimSource));
     const byFile = groupOwnedDiagnostics(ts, [...program.getSemanticDiagnostics(), ...program.getSyntacticDiagnostics()], relByAbsolute, input.mode?.undefinedIdentifiers ?? 'warning');
     verbose(`checkJs: analyzed ${rootFiles.length - 1} file(s) across ${byFile.size} owning file(s)`);
     return { byFile, global: [] };
@@ -461,6 +463,11 @@ export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint,
     const mode = modeFromPatchLintConfig(patchLint);
     const seenGlobal = new Set();
     const files = [...testFiles].sort((a, b) => a.localeCompare(b));
+    // Every test program below shares options and shim, and mostly the same
+    // files: TypeScript's lib declarations, the shim, and the directory's
+    // head.js helpers. Parsing them once instead of once per test file took
+    // a 467-test queue's pass from 66 s to a fraction of that.
+    const sourceFileCache = new Map();
     const companions = await collectUnmanagedCompanions(repoDir, files, testFiles);
     for (const file of files) {
         // Under a rootScope only the scoped files get their own program, but
@@ -487,6 +494,7 @@ export async function runCheckJsTestFilesGrouped(repoDir, testFiles, patchLint,
             projectRoot,
             mode,
             builtinShimSuffix: TEST_HARNESS_SHIM,
+            sourceFileCache,
         });
         const own = result.byFile.get(file);
         if (own && own.length > 0) {

package/dist/src/core/patch-lint-cross.d.ts

@@ -11,6 +11,7 @@
  */
 import type { PatchLintIssue, PatchMetadata } from '../types/commands/index.js';
 import type { FireForgeConfig, PatchPolicyConfig } from '../types/config.js';
+import type { ForwardRegistrationScope } from './patch-lint-forward-registration-extended.js';
 /**
  * One patch's contribution to {@link PatchQueueContext}.
  *
@@ -39,7 +40,7 @@ export interface PatchQueueEntry {
      * reconstructable `GIT binary patch`, or a payload-less
      * `Binary files … differ` stub. `newFiles` is text-only by design (a
      * binary authors no imports, so the import rules gain nothing from it and
-     * `extractNewFileContent` correctly refuses to decode one), but "does a
+     * `extractNewFileContentFromDiff` correctly refuses to decode one), but "does a
      * later patch create this path" is a question about existence after apply,
      * not about content, and answering it from `newFiles` made every binary
      * creation invisible to the staged-registration rules.
@@ -76,6 +77,11 @@ export interface PatchQueueContext {
      * Absent = current behavior (hint always printed).
      */
     patchPolicy?: PatchPolicyConfig;
+    /**
+     * Which carriers the forward-registration rule checks, from
+     * `patchLint.forwardRegistration`. Absent = `support-files` only.
+     */
+    forwardRegistration?: ForwardRegistrationScope;
 }
 /**
  * Builds a {@link PatchQueueContext} by reading every .patch file in the

package/dist/src/core/patch-lint-cross.js

@@ -11,7 +11,6 @@
  * module.
  */
 import { basename } from 'node:path';
-import { toError } from '../utils/errors.js';
 import { readText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { stripJsComments } from '../utils/regex.js';
@@ -24,7 +23,7 @@ import { lintPatchQueueModuleRegistrations } from './patch-lint-module-registrat
 import { describeRegistrationFailure, findStagedRegistrationFailure, isLaterOwner, quoteRegistrationLine, } from './patch-lint-staged-registration.js';
 import { loadPatchesManifest } from './patch-manifest-io.js';
 import { categoryRangeForOrder, categoryRangeLabel } from './patch-policy.js';
-import { extractNewFileContent } from './patch-transform.js';
+import { extractNewFileContentsFromDiff } from './patch-transform.js';
 /**
  * Builds a {@link PatchQueueContext} by reading every .patch file in the
  * directory and extracting new-file content for each creation.
@@ -50,15 +49,11 @@ export async function buildPatchQueueContext(patchesDir, config) {
     for (const patch of patches) {
         const diff = await readText(patch.path);
         const newFilePaths = detectNewFilesInDiff(diff);
-        const newFiles = new Map();
-        for (const newFile of newFilePaths) {
-            try {
-                const content = await extractNewFileContent(patch.path, newFile);
-                newFiles.set(newFile, content);
-            }
-            catch (error) {
-                verbose(`Skipping forward-import scan for ${newFile} in ${patch.filename}: ${toError(error).message}`);
-            }
+        // One parse of the body already in hand. Extracting per file re-read
+        // the whole patch from disk for every file it creates.
+        const { contents: newFiles, refused } = extractNewFileContentsFromDiff(diff, newFilePaths);
+        for (const newFile of refused) {
+            verbose(`Skipping forward-import scan for ${newFile} in ${patch.filename}: binary section cannot be extracted as text`);
         }
         // Added-line content for every file the patch modifies but does not
         // create. Fed to the forward-import rule so imports introduced into
@@ -87,7 +82,13 @@ export async function buildPatchQueueContext(patchesDir, config) {
     }
     // Sort by order so rules can rely on entries being in apply order.
     entries.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-    return { entries, ...(config?.patchPolicy ? { patchPolicy: config.patchPolicy } : {}) };
+    return {
+        entries,
+        ...(config?.patchPolicy ? { patchPolicy: config.patchPolicy } : {}),
+        ...(config?.patchLint?.forwardRegistration !== undefined
+            ? { forwardRegistration: config.patchLint.forwardRegistration }
+            : {}),
+    };
 }
 // The creators map (split out of `lintPatchQueueDuplicateCreations` so
 // `status --ownership` can consume the structured data) lives in

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

@@ -0,0 +1,38 @@
+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;
+}
+/** 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[];