@hominis/fireforge 0.45.0 → 0.46.0

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

@@ -0,0 +1,210 @@
+// 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, which is what made
+ * the gap invisible rather than merely absent.
+ *
+ * Scope is deliberately narrow: test-manifest `support-files` only. A
+ * jar.mn packaging line or an actor/customElements registration names its
+ * target through indirection the linter cannot resolve without the build
+ * system, and a rule that guesses there would refuse correct queues on a
+ * Firefox-sized tree. 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 { isLaterOwner, quoteRegistrationLine } 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));
+}
+/**
+ * Flags 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 issue per undeclared forward registration
+ */
+export function lintPatchQueueForwardRegistrations(ctx) {
+    const issues = [];
+    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;
+                // `--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.
+                const declaredLine = quoteRegistrationLine(addedLine);
+                const ambiguity = occurrences > 1
+                    ? ` (the entry is spelled out on ${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.)'
+                    : '';
+                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;
+                        issues.push({
+                            file: manifestPath,
+                            check: 'forward-registration',
+                            patches: [entry.filename],
+                            fingerprint: `forward-registration|${entry.filename}|${manifestPath}|${raw}|${created}|${later.filename}`,
+                            message: `${manifestPath} in ${entry.filename} registers "${raw}" as a support file, ` +
+                                `but ${created} is created by the later patch ${later.filename}. ` +
+                                '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: ' +
+                                `fireforge patch staged-dependency ${entry.filename} --add --kind registration ` +
+                                `--file ${manifestPath} --line "${declaredLine}" ` +
+                                `--creates ${created} --owner ${later.filename}` +
+                                ambiguity,
+                            severity: 'error',
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return issues;
+}

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

@@ -46,8 +46,8 @@ function findAttachedJsDoc(comments, declStart, source) {
  * loses the param name. String literal types may contain braces too, so
  * quoted runs are skipped verbatim.
  *
- * @returns Index just past the matching close brace, or -1 when the type
- *   expression never closes (malformed doc — caller skips the tag).
+ * @returns Index just past the matching close brace, or undefined when the
+ *   type expression never closes (malformed doc — caller skips the tag).
  */
 function skipBalancedTypeBraces(jsDoc, start) {
     let depth = 0;
@@ -73,7 +73,7 @@ function skipBalancedTypeBraces(jsDoc, start) {
                 return i + 1;
         }
     }
-    return -1;
+    return undefined;
 }
 function extractParamNames(jsDoc) {
     const names = [];
@@ -87,7 +87,7 @@ function extractParamNames(jsDoc) {
         // inline object types or Record<…> generics don't truncate the scan.
         if (jsDoc[i] === '{') {
             const afterType = skipBalancedTypeBraces(jsDoc, i);
-            if (afterType === -1)
+            if (afterType === undefined)
                 continue;
             i = afterType;
             while (i < jsDoc.length && /\s/.test(jsDoc[i] ?? ''))
@@ -124,6 +124,17 @@ function hasPrivateOrInternalTag(jsDoc) {
 function functionReturnsValue(node) {
     return walkForReturn(node.body);
 }
+/**
+ * Narrows an arbitrary child value reached by walking a node's own
+ * properties to an ESTree node. Acorn's AST holds nodes, arrays of nodes,
+ * and plain scalars in the same property positions, so the discriminating
+ * `type` string is the only structural signal available.
+ */
+function isEstreeNode(value) {
+    if (typeof value !== 'object' || value === null || !('type' in value))
+        return false;
+    return typeof value.type === 'string';
+}
 function walkForReturn(node) {
     if (node.type === 'ReturnStatement') {
         return node.argument != null;
@@ -139,20 +150,16 @@ function walkForReturn(node) {
     for (const [key, val] of entries) {
         if (key === 'type')
             continue;
-        if (val && typeof val === 'object') {
-            if (Array.isArray(val)) {
-                for (const child of val) {
-                    if (child && typeof child === 'object' && 'type' in child) {
-                        if (walkForReturn(child))
-                            return true;
-                    }
-                }
-            }
-            else if ('type' in val) {
-                if (walkForReturn(val))
+        if (Array.isArray(val)) {
+            const children = val;
+            for (const child of children) {
+                if (isEstreeNode(child) && walkForReturn(child))
                     return true;
             }
         }
+        else if (isEstreeNode(val) && walkForReturn(val)) {
+            return true;
+        }
     }
     return false;
 }
@@ -183,12 +190,7 @@ function findLocalDeclaration(body, name) {
 // Line number helpers
 // ---------------------------------------------------------------------------
 function lineAt(source, offset) {
-    let line = 1;
-    for (let i = 0; i < offset && i < source.length; i++) {
-        if (source[i] === '\n')
-            line++;
-    }
-    return line;
+    return source.slice(0, offset).split('\n').length;
 }
 /**
  * Validates @param name matching and @returns presence on a function-like
@@ -198,21 +200,19 @@ function lineAt(source, offset) {
  */
 function validateParamsAndReturns(fnNode, jsDoc, issues, ctx) {
     const docText = jsDoc.value;
-    if (!ctx.skipParams) {
-        const actualParams = fnNode.params
-            .map((p) => (p.type === 'Identifier' ? p.name : null))
-            .filter((n) => n !== null);
-        if (actualParams.length > 0) {
-            const docParams = extractParamNames(docText);
-            for (const param of actualParams) {
-                if (!docParams.includes(param)) {
-                    issues.push({
-                        line: ctx.line,
-                        check: ctx.paramCheck,
-                        message: `Exported ${ctx.label} at line ${ctx.line}: @param "${param}" is missing or misnamed in JSDoc.`,
-                        ...(ctx.severity ? { severity: ctx.severity } : {}),
-                    });
-                }
+    const actualParams = fnNode.params
+        .map((p) => (p.type === 'Identifier' ? p.name : null))
+        .filter((n) => n !== null);
+    if (actualParams.length > 0) {
+        const docParams = extractParamNames(docText);
+        for (const param of actualParams) {
+            if (!docParams.includes(param)) {
+                issues.push({
+                    line: ctx.line,
+                    check: ctx.paramCheck,
+                    message: `Exported ${ctx.label} at line ${ctx.line}: @param "${param}" is missing or misnamed in JSDoc.`,
+                    ...(ctx.severity ? { severity: ctx.severity } : {}),
+                });
             }
         }
     }

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

@@ -1,12 +1,6 @@
 import type { PatchLintIssue } from '../types/commands/index.js';
-interface ModuleRegistrationQueueEntry {
-    filename: string;
-    newFiles: ReadonlyMap<string, string>;
-    modifiedFileAdditions: ReadonlyMap<string, string>;
-}
-interface ModuleRegistrationQueueContext {
-    entries: readonly ModuleRegistrationQueueEntry[];
-}
+import type { PatchQueueRegistrationEntry, PatchQueueView } from './patch-lint-queue-types.js';
+type ModuleRegistrationQueueContext = PatchQueueView<PatchQueueRegistrationEntry>;
 /**
  * Maps Firefox's common system-module resource URLs to their source
  * suffix. Exported alongside {@link extractResourceModuleSpecifiers} so

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

@@ -94,7 +94,7 @@ export async function invokePatchLintPrettier(engineDir, projectRoot, files, gat
             {
                 file: '(prettier)',
                 check: 'prettier-format',
-                message: `prettier exited ${String(result.exitCode)} without completing the check: ` +
+                message: `prettier exited ${result.exitCode} without completing the check: ` +
                     output.trim().split('\n').slice(-5).join(' ').slice(0, 400),
                 severity,
             },

package/dist/src/core/patch-lint-queue-types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Structural views of the cross-patch lint queue context.
+ *
+ * A leaf module by design: it imports nothing, so the individual rule
+ * modules can describe the slice of `PatchQueueContext` they read without
+ * importing `patch-lint-cross.ts` (which imports them back). Previously each
+ * rule re-declared its own private `{ entries }` interface; sharing them here
+ * keeps the dependency edge one-way and `dpdm` clean while stating the shape
+ * once.
+ */
+/**
+ * The slice of a queue entry consumed by rules that read raw patch bodies
+ * (the new-file creators map, the binary-body check).
+ */
+export interface PatchQueueBodyEntry {
+    /** Filename on disk and in the manifest. */
+    filename: string;
+    /** Raw unified-diff content of the patch body. */
+    diff: string;
+}
+/**
+ * The slice of a queue entry consumed by the module-registration rule: the
+ * per-path content maps rather than the raw diff.
+ */
+export interface PatchQueueRegistrationEntry {
+    /** Filename on disk and in the manifest. */
+    filename: string;
+    /** Newly-created file path → the content the patch would produce. */
+    newFiles: ReadonlyMap<string, string>;
+    /** Existing file path → the lines the patch adds to it. */
+    modifiedFileAdditions: ReadonlyMap<string, string>;
+}
+/**
+ * Structural queue view: the `entries` field of a `PatchQueueContext`,
+ * narrowed to whichever entry slice a rule needs.
+ */
+export interface PatchQueueView<TEntry> {
+    /** Entries in application order (lowest `order` first). */
+    entries: readonly TEntry[];
+}
+/**
+ * The slice consumed by the forward-registration rule: the same content maps
+ * the module-registration rule reads, plus the body-kind-agnostic creation
+ * set and the ordering/metadata needed to decide "later" and "declared".
+ */
+export interface PatchQueueForwardRegistrationEntry extends PatchQueueRegistrationEntry {
+    /** Order number from the manifest (or filename prefix fallback). */
+    order: number;
+    /** Every path this patch creates, whatever the body kind. */
+    createdFiles: ReadonlySet<string>;
+    /** Manifest metadata. Null when the patch file exists but has no entry. */
+    metadata: {
+        stagedDependencies?: {
+            registrations?: readonly {
+                file: string;
+                creates: string;
+            }[];
+        };
+    } | null;
+}

package/dist/src/core/patch-lint-queue-types.js

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Structural views of the cross-patch lint queue context.
+ *
+ * A leaf module by design: it imports nothing, so the individual rule
+ * modules can describe the slice of `PatchQueueContext` they read without
+ * importing `patch-lint-cross.ts` (which imports them back). Previously each
+ * rule re-declared its own private `{ entries }` interface; sharing them here
+ * keeps the dependency edge one-way and `dpdm` clean while stating the shape
+ * once.
+ */
+export {};

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

@@ -0,0 +1,61 @@
+import type { PatchStagedRegistration } from '../types/commands/index.js';
+/** A patch that creates a given path, with its position in the queue. */
+export interface NewFileOwner {
+    filename: string;
+    order: number;
+    fullPath: string;
+}
+/** The ordering fields `isLaterOwner` compares an owner against. */
+export interface QueuePosition {
+    filename: string;
+    order: number;
+}
+/**
+ * Later-in-apply-order predicate shared by the forward-import scan, the
+ * forward-registration rule and the registration validation: strictly
+ * higher ordinal, or same ordinal with a lexicographically later filename
+ * (the apply loop's tiebreak).
+ *
+ * @param owner - The creating patch
+ * @param entry - The referencing patch
+ * @returns True when `owner` applies after `entry`
+ */
+export declare function isLaterOwner(owner: QueuePosition, entry: QueuePosition): boolean;
+/** The slice of a queue entry the registration validation reads. */
+export interface StagedRegistrationEntry extends QueuePosition {
+    newFiles: ReadonlyMap<string, string>;
+    modifiedFileAdditions: ReadonlyMap<string, string>;
+}
+/** Why a staged registration declaration failed validation. */
+export type StagedRegistrationFailure = {
+    kind: 'line-absent';
+} | {
+    kind: 'creates-unresolved';
+} | {
+    kind: 'owner-mismatch';
+    creators: readonly NewFileOwner[];
+};
+/**
+ * Validates one registration-kind declaration against the patch content
+ * and the queue, mirroring {@link findMatchingStagedDependency}: the
+ * declared line must be added by this patch, `creates` must exactly match
+ * a file a LATER-ordered patch creates (an earlier-only creator means the
+ * dependency is already satisfied and the declaration is stale), and
+ * `owner`, when set, must name one of those creating patches. Returns
+ * undefined when valid.
+ */
+export declare function findStagedRegistrationFailure(entry: StagedRegistrationEntry, registration: PatchStagedRegistration, createdFileIndex: Map<string, NewFileOwner[]>): StagedRegistrationFailure | undefined;
+/** Message tail for each {@link StagedRegistrationFailure} shape. */
+export declare function describeRegistrationFailure(failure: StagedRegistrationFailure): string;
+/**
+ * Renders `line` for the `--line "…"` argument of a paste-and-run
+ * `patch staged-dependency` command.
+ *
+ * A registration line is quoted for the shell in the messages that print
+ * the command, and a `support-files` element carries its own quotes
+ * (`"file_tiles_find.html",` is what a multi-line TOML array adds). Without
+ * escaping, the shell would eat them and the declaration would be written
+ * with a line the patch never adds — the exact mismatch that made the
+ * forward-registration remedy leave the declaring patch red.
+ */
+export declare function quoteRegistrationLine(line: string): string;

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

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Validation of `--kind registration` staged-dependency declarations.
+ *
+ * Split out of `patch-lint-cross.ts` to keep that file inside the per-file
+ * line budget, and because the forward-registration rule needs the same
+ * apply-order predicate: two spellings of "later in the queue" would let the
+ * rule that FLAGS an undeclared registration and the rule that validates a
+ * DECLARED one disagree about the very same pair of patches.
+ *
+ * Exports helpers consumed by `patch-lint-cross.ts` and
+ * `patch-lint-forward-registration.ts`; no registrar, no rule of its own.
+ */
+import { basename } from 'node:path';
+/**
+ * Later-in-apply-order predicate shared by the forward-import scan, the
+ * forward-registration rule and the registration validation: strictly
+ * higher ordinal, or same ordinal with a lexicographically later filename
+ * (the apply loop's tiebreak).
+ *
+ * @param owner - The creating patch
+ * @param entry - The referencing patch
+ * @returns True when `owner` applies after `entry`
+ */
+export function isLaterOwner(owner, entry) {
+    return (owner.order > entry.order || (owner.order === entry.order && owner.filename > entry.filename));
+}
+/**
+ * Validates one registration-kind declaration against the patch content
+ * and the queue, mirroring {@link findMatchingStagedDependency}: the
+ * declared line must be added by this patch, `creates` must exactly match
+ * a file a LATER-ordered patch creates (an earlier-only creator means the
+ * dependency is already satisfied and the declaration is stale), and
+ * `owner`, when set, must name one of those creating patches. Returns
+ * undefined when valid.
+ */
+export function findStagedRegistrationFailure(entry, registration, createdFileIndex) {
+    if (!isRegistrationLinePresent(entry, registration))
+        return { kind: 'line-absent' };
+    const creators = (createdFileIndex.get(basename(registration.creates)) ?? []).filter((owner) => owner.fullPath === registration.creates && isLaterOwner(owner, entry));
+    if (creators.length === 0)
+        return { kind: 'creates-unresolved' };
+    if (registration.owner !== undefined &&
+        !creators.some((owner) => owner.filename === registration.owner)) {
+        return { kind: 'owner-mismatch', creators };
+    }
+    return undefined;
+}
+/** Message tail for each {@link StagedRegistrationFailure} shape. */
+export function describeRegistrationFailure(failure) {
+    switch (failure.kind) {
+        case 'line-absent':
+            return 'the patch does not add that line.';
+        case 'creates-unresolved':
+            return ('no later-ordered patch creates that file — the declaration is stale, ' +
+                'or the queue order no longer stages it.');
+        case 'owner-mismatch':
+            return `that file is created by ${failure.creators.map((o) => o.filename).join(', ')}, not the declared owner.`;
+    }
+}
+/**
+ * True when the declared registration/packaging line appears (trimmed)
+ * among the lines the patch introduces in the declaring file — either as a
+ * newly-created file's content or as added lines to an existing file
+ * (where jar.mn / customElements.js / actor-registration edits land).
+ */
+function isRegistrationLinePresent(entry, registration) {
+    const declared = registration.line.trim();
+    if (declared.length === 0)
+        return false;
+    const introduced = [
+        entry.newFiles.get(registration.file),
+        entry.modifiedFileAdditions.get(registration.file),
+    ];
+    return introduced.some((content) => content !== undefined && content.split('\n').some((line) => line.trim() === declared));
+}
+/**
+ * Renders `line` for the `--line "…"` argument of a paste-and-run
+ * `patch staged-dependency` command.
+ *
+ * A registration line is quoted for the shell in the messages that print
+ * the command, and a `support-files` element carries its own quotes
+ * (`"file_tiles_find.html",` is what a multi-line TOML array adds). Without
+ * escaping, the shell would eat them and the declaration would be written
+ * with a line the patch never adds — the exact mismatch that made the
+ * forward-registration remedy leave the declaring patch red.
+ */
+export function quoteRegistrationLine(line) {
+    return line.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}

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

@@ -2,7 +2,8 @@ import type { PatchLintIssue } from '../types/commands/index.js';
 import type { FireForgeConfig, ProjectLicense } from '../types/config.js';
 import { type CommentStyle } from './license-headers.js';
 import { lintPatchedCss } from './patch-lint-css.js';
-export * from './patch-lint-reexports.js';
+export * from './patch-lint-cross.js';
+export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
 export { lintPatchedCss };
 /**
  * Canonical `[check] file: message` rendering of a patch-lint issue — the
@@ -132,6 +133,17 @@ export type PatchSizeTierDecision = {
  * defensive-for-tests choice.
  */
 export declare function resolvePatchSizeTier(filesAffected: ReadonlyArray<string>, patchTier?: 'branding'): PatchSizeTierDecision;
+/** Line and file-count thresholds governing one patch-size tier. */
+export interface PatchSizeThresholds {
+    /** Added-line counts at which notice/warning/error issues fire. */
+    lines: {
+        notice: number;
+        warning: number;
+        error: number;
+    };
+    /** Maximum number of files a patch may touch before an issue fires. */
+    maxFiles: number;
+}
 /**
  * Read-only view of the size thresholds a tier enforces.
  * Public-API companion to {@link resolvePatchSizeTier} /
@@ -139,14 +151,7 @@ export declare function resolvePatchSizeTier(filesAffected: ReadonlyArray<string
  * checks against the SAME numbers `large-patch-lines` /
  * `large-patch-files` fire on instead of mirroring them.
  */
-export declare function getPatchSizeThresholds(tier: 'general' | 'test' | 'branding'): {
-    lines: {
-        notice: number;
-        warning: number;
-        error: number;
-    };
-    maxFiles: number;
-};
+export declare function getPatchSizeThresholds(tier: 'general' | 'test' | 'branding'): PatchSizeThresholds;
 /**
  * Checks patch size and emits advisory warnings.
  *

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

@@ -22,9 +22,10 @@ import { invokePatchLintPrettier } from './patch-lint-prettier.js';
 // The cross-patch lint infrastructure (queue context builder,
 // duplicate-creation and forward-import rules, ignore marker) lives in
 // `patch-lint-cross.ts` so the per-patch and cross-patch rule bodies each
-// stay within the per-file line budget. The public surface is re-exported
-// from `patch-lint-reexports.ts` so callers keep importing from one module.
-export * from './patch-lint-reexports.js';
+// stay within the per-file line budget. Its surface is re-exported here so
+// callers keep importing from one module.
+export * from './patch-lint-cross.js';
+export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
 // The CSS rule bodies live in `patch-lint-css.ts` (same per-file-budget
 // split as the other rule families); re-export the imported binding so
 // callers and tests keep importing `lintPatchedCss` from this module.