@hominis/fireforge 0.47.0 → 0.48.0

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,7 @@ 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 { 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';
 // ---------------------------------------------------------------------------
@@ -340,7 +341,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 +462,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 +493,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[];

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

@@ -0,0 +1,240 @@
+// 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 } 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.
+ */
+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;
+}
+function referencesFor(entry, jarTargets) {
+    const refs = [];
+    for (const [rawPath, content] of [...entry.newFiles, ...entry.modifiedFileAdditions]) {
+        const file = normalizePathSlashes(rawPath);
+        const name = basename(file);
+        if (name === 'jar.mn')
+            refs.push(...jarMnReferences(file, content));
+        else if (name === 'moz.build')
+            refs.push(...mozBuildReferences(file, content));
+        else if (TEST_MANIFEST_BASENAMES.has(name))
+            refs.push(...testManifestReferences(file, content));
+        else if (name === 'customElements.js') {
+            refs.push(...customElementsReferences(file, content, jarTargets));
+        }
+    }
+    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}`);
+}
+/**
+ * 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,4 +1,5 @@
 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.
@@ -48,11 +49,23 @@ export declare function extractSupportFileEntries(content: string): SupportFileE
  */
 export declare function buildSupportFileMatcher(manifestPath: string, entry: string): ((candidate: string) => boolean) | undefined;
 /**
- * Flags every `support-files` registration a patch introduces that names a
- * file only a later-ordered patch creates, unless the staged dependency is
- * declared.
+ * 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 - Projected queue in application order
+ * @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>): PatchLintIssue[];
+export declare function lintPatchQueueForwardRegistrations(ctx: PatchQueueView<PatchQueueForwardRegistrationEntry> & {
+    forwardRegistration?: ForwardRegistrationScope;
+}): PatchLintIssue[];