@hominis/fireforge 0.54.0 → 0.60.0

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

@@ -1,90 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * AST-based JSDoc validation for top-level declarations in patch-owned
- * chrome subscripts (`browser/base/content/<binaryName>*.js` and similar
- * `.js` files loaded via `Services.scriptloader.loadSubScript`).
- *
- * Why a separate module from {@link ./patch-lint-jsdoc.ts}: chrome
- * subscripts are not ES modules. They are parsed as scripts (no static
- * `export`) and their top-level `class`/`function` declarations are
- * exposed to the loading window as globals rather than declared exports.
- * The export-walker in `patch-lint-jsdoc.ts` would never visit them.
- *
- * The rule shape is identical to the `.sys.mjs` rule once you remove the
- * `export` framing: every top-level class needs a JSDoc, every method
- * needs one when `chromeScriptJsDoc` is at `warning`/`error`, and every
- * top-level function needs a matching @param/@returns block. So the
- * per-declaration validators are reused verbatim from the export module.
- */
-import { parseScript } from './ast-utils.js';
-import { validateClassDecl, validateClassMethods, validateFunctionDecl, } from './patch-lint-jsdoc.js';
-/**
- * Validates JSDoc on top-level declarations in a chrome-subscript `.js`
- * source file. A parse failure returns an empty issue list. Chrome
- * subscripts that use module-only syntax (rare) silently disable the
- * rule rather than emitting confusing parse-error issues.
- *
- * @param source - File content
- * @param options - Optional gates (e.g. class-method JSDoc severity).
- *   `classMethodMode` defaults to `'off'`. The orchestrator passes the
- *   `chromeScriptJsDoc` severity here so a single knob controls both
- *   class-level and method-level enforcement.
- * @returns Array of JSDoc issues found
- */
-export function validateChromeScriptJsDoc(source, options) {
-    const classMethodMode = options?.classMethodMode ?? 'off';
-    const comments = [];
-    let ast;
-    try {
-        ast = parseScript(source, comments);
-    }
-    catch {
-        // Deliberate carve-out, unlike the `.sys.mjs` walker in
-        // `patch-lint-jsdoc.ts` (which reports a parse failure as an issue).
-        // `parseScript` rejects `import`/`export`, so a chrome subscript that was
-        // misclassified as a `.js` file (or that mistakenly uses module syntax)
-        // would emit a pseudo-issue for every rule here. The orchestrator already
-        // runs the export walker on `.sys.mjs` separately, so silently declining
-        // to lint an unparseable script is the correct degradation for this file
-        // and only this file.
-        return [];
-    }
-    const issues = [];
-    const body = ast.body;
-    for (const node of body) {
-        if (node.type === 'FunctionDeclaration') {
-            issues.push(...validateFunctionDecl(node, comments, source));
-        }
-        else if (node.type === 'ClassDeclaration') {
-            issues.push(...validateClassDecl(node, comments, source));
-            if (classMethodMode !== 'off') {
-                issues.push(...validateClassMethods(node, comments, source, classMethodMode));
-            }
-        }
-        // Top-level `var Foo = class {...}` / `let Foo = function() {...}`
-        // patterns are out of scope for V1: chrome subscripts
-        // overwhelmingly use bare `class`/`function` declarations and the
-        // variable-init form would require unwrapping the initializer. Add
-        // it later if a real chrome subscript uses that shape.
-    }
-    return issues;
-}
-/**
- * Per-file dispatch: applies the chrome-subscript JSDoc rule to one file if
- * it qualifies, mapping {@link JsDocIssue} into {@link PatchLintIssue}.
- * Returns an empty array when the file does not qualify (not a chrome
- * subscript, not patch-owned, or the mode is `'off'` / unset). The
- * orchestrator pre-computes `isChromeOwned` (true iff the file is a
- * patch-owned `.js` non-`.sys.mjs`) so the call site fits on a single line.
- */
-export function lintChromeScriptJsDocForFile(file, content, isChromeOwned, mode) {
-    if (!isChromeOwned || !mode || mode === 'off')
-        return [];
-    const jsdocIssues = validateChromeScriptJsDoc(content, { classMethodMode: mode });
-    return jsdocIssues.map((issue) => ({
-        file,
-        check: issue.check,
-        message: issue.message,
-        severity: issue.severity ?? mode,
-    }));
-}

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

@@ -1,59 +0,0 @@
-/**
- * Line counting for the size rules: raw lines, code lines, and the per-line
- * code mask the `addedCode` patch-size metric reads off a file's
- * post-image.
- *
- * "Code" means a line left non-blank once comments are blanked. JS goes
- * through acorn's tokenizer (`stripJsCommentsParsed`), so a regex literal
- * containing `/*`, a string containing `//`, nested template literals,
- * JSDoc and a shebang are all judged correctly, and a blank line inside a
- * template literal counts as blank.
- */
-/**
- * Counts the lines of `content` the way `wc -l` reports them. A naive
- * `split('\n').length` over-counts by one for any content ending in `\n`
- * (the common case), making the size rules fire one line early against
- * the operator's own `wc -l` measurement.
- */
-export declare function countRawLines(content: string): number;
-/** The result of {@link countCodeLines}. */
-export interface CodeLineCount {
-    /**
-     * Lines that carry code: non-blank once comments are blanked. When the
-     * source could not be tokenized this is the raw line count instead, the
-     * upper bound, so an unparsable file never measures smaller than it is.
-     */
-    lines: number;
-    /** False when acorn could tokenize the source neither as a module nor as a script. */
-    parsed: boolean;
-}
-/**
- * Counts the code lines of a JS source: comments are blanked by acorn's
- * tokenizer (module goal first, then script, since chrome subscripts are
- * scripts) and the non-blank lines are counted. When neither goal
- * tokenizes, the raw line count is returned with `parsed: false`. A regex
- * fallback would under-count, which fails open.
- *
- * @param content - JS source text
- */
-export declare function countCodeLines(content: string): CodeLineCount;
-/** The per-line code mask of one post-image. */
-export interface CodeLineMask {
-    /** `code[i]` is true when line `i + 1` carries code. */
-    code: boolean[];
-    /** False for a JS file acorn could not tokenize; every non-blank line then counts. */
-    parsed: boolean;
-}
-/**
- * Classifies every line of a file's post-image as code or not, by file
- * kind: JS through acorn, CSS block comments, `<!-- -->` in markup, and
- * whole-line `#` comments (`;` for `.ini`/`.in`, `!` for `.properties`) in
- * Fluent, manifests, `moz.build` and similar. Any other file counts every
- * non-blank line. In CSS, lines inside a Furnace fragment expansion
- * (`@fireforge-include` … `@fireforge-end-include`) are not code of this
- * file: they are a copy of a shared fragment.
- *
- * @param file - Engine-relative path, used only to pick the file kind
- * @param content - The post-image text
- */
-export declare function codeLineMask(file: string, content: string): CodeLineMask;

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

@@ -1,105 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Line counting for the size rules: raw lines, code lines, and the per-line
- * code mask the `addedCode` patch-size metric reads off a file's
- * post-image.
- *
- * "Code" means a line left non-blank once comments are blanked. JS goes
- * through acorn's tokenizer (`stripJsCommentsParsed`), so a regex literal
- * containing `/*`, a string containing `//`, nested template literals,
- * JSDoc and a shebang are all judged correctly, and a blank line inside a
- * template literal counts as blank.
- */
-import { stripJsCommentsParsed } from '../utils/regex.js';
-import { expandedFragmentLineMask } from './furnace-css-fragments.js';
-import { maskCssComments } from './patch-lint-css.js';
-/**
- * Splits content into lines the way `wc -l` reports them: a trailing
- * newline terminates the last line rather than starting an empty extra one.
- */
-function splitContentLines(content) {
-    const lines = content.split('\n');
-    if (lines[lines.length - 1] === '')
-        lines.pop();
-    return lines;
-}
-/**
- * Counts the lines of `content` the way `wc -l` reports them. A naive
- * `split('\n').length` over-counts by one for any content ending in `\n`
- * (the common case), making the size rules fire one line early against
- * the operator's own `wc -l` measurement.
- */
-export function countRawLines(content) {
-    return splitContentLines(content).length;
-}
-const isBlank = (line) => line.trim() === '';
-/**
- * Counts the code lines of a JS source: comments are blanked by acorn's
- * tokenizer (module goal first, then script, since chrome subscripts are
- * scripts) and the non-blank lines are counted. When neither goal
- * tokenizes, the raw line count is returned with `parsed: false`. A regex
- * fallback would under-count, which fails open.
- *
- * @param content - JS source text
- */
-export function countCodeLines(content) {
-    const stripped = stripJsCommentsParsed(content);
-    if (stripped === null)
-        return { lines: countRawLines(content), parsed: false };
-    return {
-        lines: splitContentLines(stripped).filter((line) => !isBlank(line)).length,
-        parsed: true,
-    };
-}
-const JS_FILE = /\.(?:m?js|jsm|cjs)$/;
-const MARKUP_FILE = /\.(?:x?html|xml|svg|xul|dtd)$/;
-const HASH_COMMENT_FILE = /(?:\.(?:ftl|properties|toml|ini|mn|build|py|conf|configure|sh|ya?ml|in|cfg|mozbuild)|(?:^|\/)(?:Makefile|mozconfig))$/;
-/** Line-comment leaders per hash-comment file kind. */
-function lineCommentPattern(file) {
-    if (/\.(?:ini|in)$/.test(file))
-        return /^\s*[#;]/;
-    if (file.endsWith('.properties'))
-        return /^\s*[#!]/;
-    return /^\s*#/;
-}
-/** Masks `<!-- … -->` comments, keeping newlines. Unclosed comments run to EOF. */
-function maskMarkupComments(source) {
-    return source.replace(/<!--[\s\S]*?(?:-->|$)/g, (m) => m.replace(/[^\n]/g, ' '));
-}
-/**
- * Classifies every line of a file's post-image as code or not, by file
- * kind: JS through acorn, CSS block comments, `<!-- -->` in markup, and
- * whole-line `#` comments (`;` for `.ini`/`.in`, `!` for `.properties`) in
- * Fluent, manifests, `moz.build` and similar. Any other file counts every
- * non-blank line. In CSS, lines inside a Furnace fragment expansion
- * (`@fireforge-include` … `@fireforge-end-include`) are not code of this
- * file: they are a copy of a shared fragment.
- *
- * @param file - Engine-relative path, used only to pick the file kind
- * @param content - The post-image text
- */
-export function codeLineMask(file, content) {
-    if (JS_FILE.test(file)) {
-        const stripped = stripJsCommentsParsed(content);
-        const source = stripped ?? content;
-        return { code: source.split('\n').map((line) => !isBlank(line)), parsed: stripped !== null };
-    }
-    if (file.endsWith('.css')) {
-        const inFragment = expandedFragmentLineMask(content);
-        const code = maskCssComments(content)
-            .split('\n')
-            .map((line, i) => !isBlank(line) && inFragment[i] !== true);
-        return { code, parsed: true };
-    }
-    if (MARKUP_FILE.test(file)) {
-        return {
-            code: maskMarkupComments(content)
-                .split('\n')
-                .map((l) => !isBlank(l)),
-            parsed: true,
-        };
-    }
-    const comment = HASH_COMMENT_FILE.test(file) ? lineCommentPattern(file) : undefined;
-    const code = content.split('\n').map((line) => !isBlank(line) && !comment?.test(line));
-    return { code, parsed: true };
-}

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

@@ -1,26 +0,0 @@
-/**
- * New-file creators map for the patch queue, split out of
- * `patch-lint-cross.ts` to stay under the per-file line budget.
- * Re-exported from there so callers keep importing from `patch-lint.ts`
- * unchanged.
- *
- * Memoised per context object: ownership resolution and cache-key
- * fingerprints call this 2-3× per linted patch, and each call otherwise
- * re-runs `detectNewFilesInDiff` over every queue entry's diff. Keyed weakly
- * so a discarded context frees its map. A caller that mutates a context
- * entry in place must call {@link invalidateNewFileCreatorsCache}.
- */
-import type { PatchQueueBodyEntry, PatchQueueView } from './patch-lint-queue-types.js';
-/** The slice of a queue context the creators map is derived from. */
-type CreatorsContext = PatchQueueView<PatchQueueBodyEntry>;
-/** Drops the memoised creators map after an in-place context entry update. */
-export declare function invalidateNewFileCreatorsCache(ctx: CreatorsContext): void;
-/**
- * Returns the raw `path → patches[]` map of files created in `new file
- * mode` by at least one patch in the queue. Paths created by only one
- * patch are also included so callers can distinguish "no creator" from
- * "exactly one creator" without re-scanning the diffs. The returned map
- * is memoised and shared, so treat it as read-only.
- */
-export declare function collectNewFileCreatorsByPath(ctx: CreatorsContext): Map<string, string[]>;
-export {};

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

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * New-file creators map for the patch queue, split out of
- * `patch-lint-cross.ts` to stay under the per-file line budget.
- * Re-exported from there so callers keep importing from `patch-lint.ts`
- * unchanged.
- *
- * Memoised per context object: ownership resolution and cache-key
- * fingerprints call this 2-3× per linted patch, and each call otherwise
- * re-runs `detectNewFilesInDiff` over every queue entry's diff. Keyed weakly
- * so a discarded context frees its map. A caller that mutates a context
- * entry in place must call {@link invalidateNewFileCreatorsCache}.
- */
-import { detectNewFilesInDiff } from './patch-lint-diff.js';
-const newFileCreatorsMemo = new WeakMap();
-/** Drops the memoised creators map after an in-place context entry update. */
-export function invalidateNewFileCreatorsCache(ctx) {
-    newFileCreatorsMemo.delete(ctx);
-}
-/**
- * Returns the raw `path → patches[]` map of files created in `new file
- * mode` by at least one patch in the queue. Paths created by only one
- * patch are also included so callers can distinguish "no creator" from
- * "exactly one creator" without re-scanning the diffs. The returned map
- * is memoised and shared, so treat it as read-only.
- */
-export function collectNewFileCreatorsByPath(ctx) {
-    const memoised = newFileCreatorsMemo.get(ctx);
-    if (memoised)
-        return memoised;
-    const creators = new Map();
-    for (const entry of ctx.entries) {
-        const newFiles = detectNewFilesInDiff(entry.diff);
-        for (const file of newFiles) {
-            let owners = creators.get(file);
-            if (!owners) {
-                owners = [];
-                creators.set(file, owners);
-            }
-            owners.push(entry.filename);
-        }
-    }
-    newFileCreatorsMemo.set(ctx, creators);
-    return creators;
-}

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

@@ -1,232 +0,0 @@
-/**
- * Cross-patch lint infrastructure: the queue context builder, the
- * duplicate-new-file-creation and forward-import rules, the forward-import
- * ignore-marker, and the per-specifier extractor that powers the
- * forward-import rule.
- *
- * Separated from `patch-lint.ts` so the per-patch and cross-patch rule
- * bodies each stay within the per-file line budget. `patch-lint.ts`
- * re-exports the public surface so callers continue to import from a single
- * module.
- */
-import type { PatchLintIssue, PatchMetadata } from '../types/commands/index.js';
-import type { FireForgeConfig, PatchLintTokenScale, PatchPolicyConfig } from '../types/config.js';
-import type { ForwardRegistrationScope } from './patch-lint-forward-registration-extended.js';
-/**
- * One patch's contribution to {@link PatchQueueContext}.
- *
- * Rules receive a flat view of every patch's metadata, raw diff, and the
- * content of any files the patch newly creates. Reading each patch once up
- * front lets rules operate in O(patches) without re-reading .patch files.
- */
-export interface PatchQueueEntry {
-    /** Filename on disk and in the manifest. */
-    filename: string;
-    /** Order number from the manifest (or filename prefix fallback). */
-    order: number;
-    /** Manifest metadata. Null when the patch file exists but has no entry. */
-    metadata: PatchMetadata | null;
-    /** Raw unified-diff content of the patch body. */
-    diff: string;
-    /**
-     * Map from newly-created file path → the file content the patch would
-     * produce. Populated only for files the patch creates with
-     * `new file mode` + `--- /dev/null`. Modifications to existing files
-     * are not indexed here.
-     */
-    newFiles: Map<string, string>;
-    /**
-     * Every path this patch creates, whatever the body kind: text, a
-     * 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
-     * `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.
-     */
-    createdFiles: Set<string>;
-    /**
-     * Map from existing-file path → concatenated added lines from the patch's
-     * hunks against that file (joined with `\n`). Populated for files the
-     * patch *modifies* (i.e. paths that show up in the diff without a
-     * `new file mode` marker). The forward-import rule and `patch delete`
-     * dependency scan use this to detect imports added into pre-existing
-     * files, a failure mode the newFiles map cannot represent because it
-     * only tracks creations.
-     */
-    modifiedFileAdditions: Map<string, string>;
-}
-/**
- * Queue-wide context passed to cross-patch lint rules.
- *
- * "Projected" means rules receive a potentially hypothetical view of the
- * queue: the caller may have already applied a planned delete, reorder, or
- * re-export to the entries before calling the rule. This lets
- * `patch reorder`, `patch delete`, `export --order`, and `re-export --files`
- * run the same cross-patch checks they would hit on a real run, without
- * mutating disk first.
- */
-export interface PatchQueueContext {
-    /** Entries in application order (lowest `order` first). */
-    entries: PatchQueueEntry[];
-    /**
-     * Optional patchPolicy config. When present, the forward-import rule
-     * validates its "Closest legal ordinal" suggestion against the importing
-     * patch's category range and suppresses it when no legal ordinal exists.
-     * Absent = current behavior (hint always printed).
-     */
-    patchPolicy?: PatchPolicyConfig;
-    /**
-     * Which carriers the forward-registration rule checks, from
-     * `patchLint.forwardRegistration`. Absent = `support-files` only.
-     */
-    forwardRegistration?: ForwardRegistrationScope;
-    /** `patchLint.tokenScales`, for the scales' `minFiles` floors. */
-    tokenScales?: PatchLintTokenScale[];
-}
-/**
- * Builds a {@link PatchQueueContext} by reading every .patch file in the
- * directory and extracting new-file content for each creation.
- *
- * Reads manifest metadata best-effort: if the manifest is missing or a patch
- * file has no metadata entry, the context still populates the entry from the
- * filename prefix so cross-patch rules can operate on a drift state. (A
- * separate consistency check, see `patches verify`, is responsible for
- * reporting the drift as its own error.)
- *
- * @param patchesDir - Path to the patches directory
- */
-export declare function buildPatchQueueContext(patchesDir: string, config?: FireForgeConfig): Promise<PatchQueueContext>;
-export { collectNewFileCreatorsByPath, invalidateNewFileCreatorsCache, } from './patch-lint-creators.js';
-/**
- * Cross-patch lint rule: the same path is newly created (`--- /dev/null →
- * +++ b/path`) by more than one patch. Without it the collision surfaces
- * only when import rolls back mid-apply.
- *
- * Reports one error per conflicting path, naming every patch that creates
- * the path so the operator can pick the correct fix (`patch delete` or
- * `re-export --files`).
- */
-export declare function lintPatchQueueDuplicateCreations(ctx: PatchQueueContext): PatchLintIssue[];
-/**
- * Returns true when a path looks like a JS module/subscript the
- * forward-import rule should scan.
- */
-export declare function isForwardImportableFile(path: string): boolean;
-/**
- * Regex-level extractor for module specifiers in ES module / subscript files.
- *
- * Intentionally conservative. Catches:
- * - `import ... from "specifier"`   (ES module static imports)
- * - `import "specifier"`            (side-effect imports, where the `from`
- *                                   clause is optional in the regex)
- * - `import("specifier")`           (dynamic imports)
- * - ChromeUtils.importESModule("specifier")
- * - ChromeUtils.defineESModuleGetters(obj, { Name: "specifier", ... })
- *
- * Returns the raw specifier strings. Callers should take the leaf basename
- * to match against the newFileIndex, because we do not resolve `resource://`
- * URLs to engine file paths.
- *
- * Also returns the (0-indexed) line number where each specifier was found, so
- * the forward-import rule can correlate specifiers against the ignore-marker
- * line set and skip suppressed matches.
- */
-export interface ExtractedSpecifier {
-    specifier: string;
-    line: number;
-}
-/**
- * Returns import specifiers plus 0-indexed line numbers, preserving the
- * same matching behavior as {@link extractImportSpecifiersWithLines}.
- */
-export declare function extractImportSpecifiersWithLines(source: string): ExtractedSpecifier[];
-/**
- * Marker comment operators can use to suppress the forward-import rule
- * for imports that resolve to a basename false positive (two unrelated
- * files with the same leaf name) or for any other situation where the
- * regex-level resolution lands on the wrong patch.
- *
- * Usage: place the comment on the same line as the import, or on the
- * line immediately above it:
- *
- * ```js
- * // fireforge-ignore: forward-import
- * import { Helper } from "resource:///modules/Helper.sys.mjs";
- *
- * import { Helper } from "resource:///modules/Helper.sys.mjs"; // fireforge-ignore: forward-import
- * ```
- */
-export declare const FORWARD_IMPORT_IGNORE_MARKER = "fireforge-ignore: forward-import";
-/**
- * Returns a Set of 0-indexed line numbers on which the forward-import
- * rule should be suppressed. A marker on line N suppresses matches on
- * line N and N+1 so users can write the marker above the line it
- * describes. Matches on any line past N+1 are not affected.
- */
-export declare function findForwardImportIgnoreLines(source: string): Set<number>;
-/**
- * Cross-patch lint rule: a patch imports a module that a later patch is
- * responsible for creating.
- *
- * Conservative by design: `resource://` URLs are not resolved to engine
- * file paths. Instead a cross-queue index of newly-created files is built,
- * keyed by basename, and imports whose leaf matches an entry owned by a
- * later-ordered patch are flagged. False positives from unrelated basename
- * collisions (two directories both creating `Helper.sys.mjs`) are possible.
- * The README documents the limitation and the inline ignore marker above is
- * the escape hatch.
- *
- * Rules out:
- * - Imports whose leaf matches a newly-created file in the *same* or an
- *   *earlier* patch (legitimate use).
- * - Imports whose leaf is not in the new-file index at all (pre-existing
- *   engine file, not our concern).
- * - Imports on a line suppressed by the ignore marker.
- */
-/** One discovered forward-import edge: a site importing a later-created file. */
-export interface ForwardImportEdge {
-    /** Importing patch filename. */
-    entry: string;
-    /** Importing file path relative to engine/. */
-    sitePath: string;
-    /** Exact import specifier as it appears in source. */
-    specifier: string;
-    /** Specifier with any query/hash stripped (used for fingerprints). */
-    cleaned: string;
-    /** Later-ordered patch creating the imported file. */
-    owner: string;
-    /** Path of the later-created file (relative to engine/). */
-    creates: string;
-}
-/**
- * Returns every forward-import edge in the queue, one per (site, later
- * creator) pair, regardless of any staged-dependency declarations. Used by
- * `patch split` to discover the forward edges it introduces into the new
- * patch so it can auto-declare them (and so its projected lint matches the
- * real per-patch gate).
- */
-export declare function collectForwardImportEdges(ctx: PatchQueueContext): ForwardImportEdge[];
-/**
- * Cross-patch lint rule: flag imports of a module a later-ordered patch is
- * responsible for creating, unless the patch declares an exact staged
- * forward-import for it. Also warns on staged-dependency declarations that
- * never matched (stale). Matching is conservative: by basename, not by
- * resolving `resource://`/`chrome://` URLs, with an inline ignore marker as
- * an escape hatch for unrelated basename collisions.
- */
-export declare function lintPatchQueueForwardImports(ctx: PatchQueueContext): PatchLintIssue[];
-/**
- * Cross-patch lint orchestrator. Runs every cross-patch rule against the
- * provided context and returns combined issues.
- *
- * Separate from `lintExportedPatch` because cross-patch rules operate
- * over the whole queue, not a single patch. Callers integrating both
- * orchestrators (e.g. `fireforge lint`) should concatenate results.
- *
- * @param ctx - Pre-built queue context (use
- *   {@link buildPatchQueueContext} for the default path, or construct
- *   manually for projected/hypothetical states)
- */
-export declare function lintPatchQueue(ctx: PatchQueueContext): PatchLintIssue[];