@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,590 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * 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 { basename } from 'node:path';
-import { readText } from '../utils/fs.js';
-import { verbose } from '../utils/logger.js';
-import { stripJsComments } from '../utils/regex.js';
-import { discoverPatches } from './patch-files.js';
-import { lintPatchQueueBinaryBodies } from './patch-lint-binary.js';
-import { collectNewFileCreatorsByPath } from './patch-lint-creators.js';
-import { detectNewFilesInDiff, extractAddedLinesPerFile } from './patch-lint-diff.js';
-import { lintPatchQueueForwardRegistrations } from './patch-lint-forward-registration.js';
-import { lintPatchQueueModuleRegistrations } from './patch-lint-module-registration.js';
-import { describeRegistrationFailure, findStagedRegistrationFailure, isLaterOwner, quoteRegistrationLine, STAGED_DEPENDENCY_REASON_PLACEHOLDER, stagedDependencyUnusedFingerprint, } from './patch-lint-staged-registration.js';
-import { lintTokenScaleFloors } from './patch-lint-token-scale.js';
-import { loadPatchesManifest } from './patch-manifest-io.js';
-import { categoryRangeForOrder, categoryRangeLabel } from './patch-policy.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.
- *
- * 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 async function buildPatchQueueContext(patchesDir, config) {
-    const patches = await discoverPatches(patchesDir);
-    const manifest = await loadPatchesManifest(patchesDir);
-    const metadataByFilename = new Map();
-    if (manifest) {
-        for (const entry of manifest.patches) {
-            metadataByFilename.set(entry.filename, entry);
-        }
-    }
-    const entries = [];
-    for (const patch of patches) {
-        const diff = await readText(patch.path);
-        const newFilePaths = detectNewFilesInDiff(diff);
-        // 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
-        // pre-existing files are checked too, not only imports in brand-new
-        // files. Paths in newFilePaths are skipped on purpose: they are
-        // already covered by the newFiles map, which carries full content
-        // rather than only the added lines.
-        const addedLinesByFile = extractAddedLinesPerFile(diff);
-        const modifiedFileAdditions = new Map();
-        for (const [file, lines] of addedLinesByFile) {
-            if (newFilePaths.has(file))
-                continue;
-            modifiedFileAdditions.set(file, lines.join('\n'));
-        }
-        entries.push({
-            filename: patch.filename,
-            order: Number.isFinite(patch.order) ? patch.order : entries.length + 1,
-            metadata: metadataByFilename.get(patch.filename) ?? null,
-            diff,
-            newFiles,
-            // Straight from the detector, before the text-extraction filter above
-            // drops the bodies it cannot decode.
-            createdFiles: newFilePaths,
-            modifiedFileAdditions,
-        });
-    }
-    // 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 } : {}),
-        ...(config?.patchLint?.forwardRegistration !== undefined
-            ? { forwardRegistration: config.patchLint.forwardRegistration }
-            : {}),
-        ...(config?.patchLint?.tokenScales !== undefined
-            ? { tokenScales: config.patchLint.tokenScales }
-            : {}),
-    };
-}
-// The creators map (split out of `lintPatchQueueDuplicateCreations` so
-// `status --ownership` can consume the structured data) lives in
-// `patch-lint-creators.ts` with its per-context memoisation. It is
-// re-exported here so callers keep importing from `patch-lint.ts`.
-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 function lintPatchQueueDuplicateCreations(ctx) {
-    const creators = collectNewFileCreatorsByPath(ctx);
-    const issues = [];
-    for (const [file, owners] of creators) {
-        if (owners.length > 1) {
-            issues.push({
-                file,
-                check: 'duplicate-new-file-creation',
-                patches: [...owners].sort((a, b) => a.localeCompare(b)),
-                fingerprint: `duplicate-new-file-creation|${file}|${[...owners].sort((a, b) => a.localeCompare(b)).join(',')}`,
-                message: `File "${file}" is created (new file mode) by multiple patches: ${owners.join(', ')}. ` +
-                    'Only one patch may create a given path. Use "patch delete" or ' +
-                    '"re-export --files" to remove the duplicate.',
-                severity: 'error',
-            });
-        }
-    }
-    return issues;
-}
-const FORWARD_IMPORTABLE_EXTENSIONS = ['.mjs', '.sys.mjs', '.js', '.jsm'];
-/**
- * Returns true when a path looks like a JS module/subscript the
- * forward-import rule should scan.
- */
-export function isForwardImportableFile(path) {
-    return FORWARD_IMPORTABLE_EXTENSIONS.some((ext) => path.endsWith(ext));
-}
-function buildLineOffsets(source) {
-    const offsets = [0];
-    for (let i = 0; i < source.length; i++) {
-        if (source[i] === '\n')
-            offsets.push(i + 1);
-    }
-    return offsets;
-}
-function makeOffsetToLine(lineOffsets) {
-    return (offset) => {
-        let lo = 0;
-        let hi = lineOffsets.length - 1;
-        while (lo < hi) {
-            const mid = (lo + hi + 1) >>> 1;
-            const candidate = lineOffsets[mid];
-            if (candidate === undefined || candidate > offset) {
-                hi = mid - 1;
-            }
-            else {
-                lo = mid;
-            }
-        }
-        return lo;
-    };
-}
-/**
- * Walks `defineESModuleGetters(obj, { ... })` calls using a balanced
- * brace walker so nested object literals and multi-line shapes do not
- * terminate the parse early. Appends the string literals found inside
- * the getter map to `results`.
- */
-function collectGetterSpecifiers(stripped, results, offsetToLine) {
-    const gettersOpenPattern = /defineESModuleGetters\s*\(/g;
-    let match;
-    while ((match = gettersOpenPattern.exec(stripped)) !== null) {
-        const openParen = stripped.indexOf('(', match.index);
-        if (openParen === -1)
-            continue;
-        // Walk to the first top-level `{` inside the call, the start of
-        // the getter-map object literal. Bail if we reach the closing `)`
-        // first (no object literal argument given).
-        let depthParen = 1;
-        let openBrace = -1;
-        for (let i = openParen + 1; i < stripped.length; i++) {
-            const char = stripped[i];
-            if (char === '(')
-                depthParen += 1;
-            else if (char === ')') {
-                depthParen -= 1;
-                if (depthParen === 0)
-                    break;
-            }
-            else if (char === '{' && depthParen === 1) {
-                openBrace = i;
-                break;
-            }
-        }
-        if (openBrace === -1)
-            continue;
-        // Walk the object-literal body with balanced braces so nested
-        // `{ ... }` inside a value does not terminate the walk early.
-        let depthBrace = 1;
-        let closeBrace = -1;
-        for (let i = openBrace + 1; i < stripped.length; i++) {
-            const char = stripped[i];
-            if (char === '{')
-                depthBrace += 1;
-            else if (char === '}') {
-                depthBrace -= 1;
-                if (depthBrace === 0) {
-                    closeBrace = i;
-                    break;
-                }
-            }
-        }
-        if (closeBrace === -1)
-            continue;
-        const body = stripped.slice(openBrace + 1, closeBrace);
-        const bodyStart = openBrace + 1;
-        const stringLiteralPattern = /["']([^"']+)["']/g;
-        let strMatch;
-        while ((strMatch = stringLiteralPattern.exec(body)) !== null) {
-            if (strMatch[1]) {
-                results.push({
-                    specifier: strMatch[1],
-                    line: offsetToLine(bodyStart + strMatch.index),
-                });
-            }
-        }
-    }
-}
-/**
- * Returns import specifiers plus 0-indexed line numbers, preserving the
- * same matching behavior as {@link extractImportSpecifiersWithLines}.
- */
-export function extractImportSpecifiersWithLines(source) {
-    // stripJsComments replaces comment bodies with space runs of equal
-    // length, preserving character offsets. That lets us match against
-    // the stripped source (so we do not match `import` tokens inside
-    // block comments or string literals) while still reporting line
-    // numbers based on the original source, which is what the
-    // ignore-marker scan walks.
-    const stripped = stripJsComments(source);
-    const results = [];
-    const lineOffsets = buildLineOffsets(source);
-    const offsetToLine = makeOffsetToLine(lineOffsets);
-    const importFromPattern = /\bimport\s+(?:[^'"]*?\s+from\s+)?["']([^"']+)["']/g;
-    let match;
-    while ((match = importFromPattern.exec(stripped)) !== null) {
-        if (match[1])
-            results.push({ specifier: match[1], line: offsetToLine(match.index) });
-    }
-    const dynamicImportPattern = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
-    while ((match = dynamicImportPattern.exec(stripped)) !== null) {
-        if (match[1])
-            results.push({ specifier: match[1], line: offsetToLine(match.index) });
-    }
-    // ChromeUtils.importESModule("resource://...") is a Firefox single-module import
-    const chromeUtilsPattern = /ChromeUtils\.importESModule\s*\(\s*["']([^"']+)["']/g;
-    while ((match = chromeUtilsPattern.exec(stripped)) !== null) {
-        if (match[1])
-            results.push({ specifier: match[1], line: offsetToLine(match.index) });
-    }
-    collectGetterSpecifiers(stripped, results, offsetToLine);
-    return results;
-}
-/**
- * Bare `Name: "url"` property lines added inside a pre-existing
- * `defineESModuleGetters` (or `XPCOMUtils` lazy-getter) map. Applied only to
- * `modifiedFileAdditions`: a patch that inserts one property into an
- * existing getter object never carries the `defineESModuleGetters(` opener
- * in its added lines, so the balanced-brace walk in
- * {@link extractImportSpecifiersWithLines} cannot see it. The
- * URL-scheme restriction keeps ordinary object literals
- * (`label: "Foo.sys.mjs"`) out. The leaf-extension filter downstream does
- * the rest.
- */
-const BARE_GETTER_PROPERTY_LINE = /^\s*(?:["'])?[A-Za-z_$][\w$]*(?:["'])?\s*:\s*["']((?:resource|chrome|moz-src):\/\/[^"']+)["']\s*,?\s*$/;
-/**
- * Extracts specifiers from bare getter-property lines in added-lines-only
- * content. Comment stripping preserves line alignment, so the reported line
- * numbers match what {@link findForwardImportIgnoreLines} walks.
- */
-function extractBareGetterSpecifiers(source) {
-    const stripped = stripJsComments(source);
-    const results = [];
-    const lines = stripped.split('\n');
-    for (const [i, line] of lines.entries()) {
-        const match = BARE_GETTER_PROPERTY_LINE.exec(line);
-        if (match?.[1])
-            results.push({ specifier: match[1], line: i });
-    }
-    return results;
-}
-/**
- * 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 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 function findForwardImportIgnoreLines(source) {
-    const lines = source.split('\n');
-    const ignored = new Set();
-    for (const [i, line] of lines.entries()) {
-        if (line.includes(FORWARD_IMPORT_IGNORE_MARKER)) {
-            ignored.add(i);
-            ignored.add(i + 1);
-        }
-    }
-    return ignored;
-}
-function stagedDependencyKey(entry, dependency) {
-    return [
-        entry.filename,
-        dependency.file,
-        dependency.specifier,
-        dependency.creates,
-        dependency.owner ?? '',
-    ].join('\0');
-}
-function findMatchingStagedDependency(entry, sitePath, specifier, laterOwners) {
-    const declarations = entry.metadata?.stagedDependencies?.forwardImports ?? [];
-    return declarations.find((dependency) => dependency.file === sitePath &&
-        dependency.specifier === specifier &&
-        laterOwners.some((owner) => owner.fullPath === dependency.creates &&
-            (dependency.owner === undefined || dependency.owner === owner.filename)));
-}
-/** Builds a basename → creators index from one path set per entry. */
-function buildCreatorIndex(ctx, pathsOf) {
-    const index = new Map();
-    for (const entry of ctx.entries) {
-        for (const fullPath of pathsOf(entry)) {
-            const leaf = basename(fullPath);
-            let owners = index.get(leaf);
-            if (!owners) {
-                owners = [];
-                index.set(leaf, owners);
-            }
-            owners.push({ filename: entry.filename, order: entry.order, fullPath });
-        }
-    }
-    return index;
-}
-/**
- * Basename → later-creators index for the forward-IMPORT scan.
- *
- * Keyed on `newFiles`: this index answers "which patch creates
- * the module this specifier resolves to", and a binary is not a module.
- */
-function buildNewFileIndex(ctx) {
-    return buildCreatorIndex(ctx, (entry) => entry.newFiles.keys());
-}
-/**
- * Basename → creators index for the staged-REGISTRATION rules.
- *
- * Keyed on `createdFiles`, which includes binary creations. A registration
- * (`support-files`, a jar.mn line, an actor entry) points at a file that
- * must exist after apply. Whether its body was text or a `GIT binary patch`
- * has nothing to do with it. Resolving this from `newFiles` made a declared
- * dependency on a binary fixture report `creates-unresolved`, so the
- * declaration read as stale on every lint run and removing it changed
- * nothing either. The failure was symmetric and therefore invisible.
- */
-function buildCreatedFileIndex(ctx) {
-    return buildCreatorIndex(ctx, (entry) => entry.createdFiles);
-}
-/**
- * Visits every forward-import site (an import whose leaf is created by a
- * later-ordered patch). Shared by {@link lintPatchQueueForwardImports} (which
- * resolves/reports each) and {@link collectForwardImportEdges} (which returns
- * them structurally). We scan a created file's full body and a modified
- * file's added lines only, so it flags imports *this patch introduces*, not
- * pre-existing HEAD imports that happen to collide with a later-created file.
- */
-function eachForwardImportSite(ctx, newFileIndex, visit) {
-    const checkSite = (entry, sitePath, content, includeBareGetterLines = false) => {
-        if (!isForwardImportableFile(sitePath))
-            return;
-        const sites = extractImportSpecifiersWithLines(content);
-        if (includeBareGetterLines) {
-            // Dedupe by (specifier, line): a patch that adds the whole getter
-            // call carries both the opener (found by the balanced walk) and the
-            // property line (found here), so report each site once.
-            const seen = new Set(sites.map((site) => `${site.specifier}|${site.line}`));
-            for (const extra of extractBareGetterSpecifiers(content)) {
-                if (!seen.has(`${extra.specifier}|${extra.line}`))
-                    sites.push(extra);
-            }
-        }
-        const ignoreLines = findForwardImportIgnoreLines(content);
-        for (const { specifier, line } of sites) {
-            if (ignoreLines.has(line))
-                continue;
-            const cleaned = specifier.split(/[?#]/)[0] ?? specifier;
-            const leaf = basename(cleaned);
-            if (!leaf || !isForwardImportableFile(leaf))
-                continue;
-            const owners = newFileIndex.get(leaf);
-            if (!owners)
-                continue;
-            const laterOwners = owners.filter((owner) => isLaterOwner(owner, entry));
-            if (laterOwners.length === 0)
-                continue;
-            visit(entry, sitePath, specifier, cleaned, laterOwners);
-        }
-    };
-    for (const entry of ctx.entries) {
-        for (const [path, content] of entry.newFiles)
-            checkSite(entry, path, content);
-        for (const [path, added] of entry.modifiedFileAdditions)
-            checkSite(entry, path, added, true);
-    }
-}
-/**
- * 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 function collectForwardImportEdges(ctx) {
-    const newFileIndex = buildNewFileIndex(ctx);
-    const edges = [];
-    eachForwardImportSite(ctx, newFileIndex, (entry, sitePath, specifier, cleaned, laterOwners) => {
-        for (const owner of laterOwners) {
-            edges.push({
-                entry: entry.filename,
-                sitePath,
-                specifier,
-                cleaned,
-                owner: owner.filename,
-                creates: owner.fullPath,
-            });
-        }
-    });
-    return edges;
-}
-/**
- * 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 function lintPatchQueueForwardImports(ctx) {
-    const newFileIndex = buildNewFileIndex(ctx);
-    const createdFileIndex = buildCreatedFileIndex(ctx);
-    const issues = [];
-    const usedStagedDeclarations = new Set();
-    eachForwardImportSite(ctx, newFileIndex, (entry, sitePath, specifier, cleaned, laterOwners) => {
-        const stagedDependency = findMatchingStagedDependency(entry, sitePath, specifier, laterOwners);
-        if (stagedDependency) {
-            usedStagedDeclarations.add(stagedDependencyKey(entry, stagedDependency));
-            return;
-        }
-        const ownersSummary = laterOwners
-            .map((o) => `${o.filename} (creates ${o.fullPath})`)
-            .join(', ');
-        const fingerprintOwners = [...laterOwners]
-            .map((o) => `${o.filename}:${o.fullPath}`)
-            .sort((a, b) => a.localeCompare(b))
-            .join(',');
-        // Lowest ordinal that lands after every later-ordered creator. It
-        // turns the operator's "guess and re-run" loop into a single shot
-        // when the only fix is reordering. When patchPolicy is available and
-        // that ordinal falls outside the importing patch's category range,
-        // `patch reorder` would refuse it, so suppress the hint and point at
-        // the staged-dependency remedy instead.
-        const suggestedOrder = Math.max(...laterOwners.map((o) => o.order)) + 1;
-        const category = entry.metadata?.category ?? /^\d+-([a-z]+)-/.exec(entry.filename)?.[1];
-        let ordinalHint = `Closest legal ordinal that satisfies this dependency: ${suggestedOrder}.`;
-        if (ctx.patchPolicy &&
-            category !== undefined &&
-            categoryRangeForOrder(ctx.patchPolicy, category, suggestedOrder) === null) {
-            const label = categoryRangeLabel(ctx.patchPolicy.ranges, category);
-            ordinalHint =
-                `No legal ordinal in the ${category} category range (${label}) lands after the ` +
-                    'creating patch(es); declaring the staged dependency is the recommended remedy.';
-        }
-        // The exact per-owner invocation turns the refusal into a paste-and-run
-        // remedy instead of a flag-discovery exercise.
-        const stagedCommands = laterOwners
-            .map((o) => `fireforge patch staged-dependency ${entry.filename} --add ` +
-            `--file ${sitePath} --specifier "${specifier}" ` +
-            `--creates ${o.fullPath} --owner ${o.filename} ${STAGED_DEPENDENCY_REASON_PLACEHOLDER}`)
-            .join('; ');
-        issues.push({
-            file: sitePath,
-            check: 'forward-import',
-            patches: [entry.filename],
-            fingerprint: `forward-import|${sitePath}|${cleaned}|${fingerprintOwners}`,
-            stagedDeclarations: laterOwners.map((o) => ({
-                patch: entry.filename,
-                kind: 'import',
-                file: sitePath,
-                specifier,
-                creates: o.fullPath,
-                owner: o.filename,
-            })),
-            message: `${sitePath} in ${entry.filename} imports "${specifier}", ` +
-                `but the matching new file is created by a later patch: ${ownersSummary}. ` +
-                'Reorder the patches so the dependency is created first, move the import ' +
-                'into the later patch, declare the intentional staged dependency with: ' +
-                `${stagedCommands}; or mark the import with ` +
-                `"// ${FORWARD_IMPORT_IGNORE_MARKER}" if the basename collision is a false positive. ` +
-                ordinalHint,
-            severity: 'error',
-        });
-    });
-    for (const entry of ctx.entries) {
-        for (const dependency of entry.metadata?.stagedDependencies?.forwardImports ?? []) {
-            if (usedStagedDeclarations.has(stagedDependencyKey(entry, dependency)))
-                continue;
-            issues.push({
-                file: dependency.file,
-                check: 'staged-dependency-unused',
-                patches: [entry.filename],
-                fingerprint: stagedDependencyUnusedFingerprint(entry.filename, dependency),
-                message: `${entry.filename} declares a staged forward import from ${dependency.file} ` +
-                    `to "${dependency.specifier}" / ${dependency.creates}, but that exact forward dependency was not found. ` +
-                    'Remove the stale declaration with "fireforge patch staged-dependency --remove" or update it to match the current queue.',
-                severity: 'warning',
-            });
-        }
-        // Registration-kind declarations: a jar.mn packaging line,
-        // customElements registration, or actor registration referencing a
-        // later-created file. There is no import specifier to match. The
-        // declaration is "used" when the declared line (whitespace-trimmed)
-        // appears among the lines this patch adds to the declaring file and its
-        // `creates` resolves to a file a later-ordered patch actually creates
-        // (with `owner`, when set, naming that patch), mirroring
-        // findMatchingStagedDependency for the import kind.
-        for (const registration of entry.metadata?.stagedDependencies?.registrations ?? []) {
-            const failure = findStagedRegistrationFailure(entry, registration, createdFileIndex);
-            if (failure === undefined)
-                continue;
-            issues.push({
-                file: registration.file,
-                check: 'staged-dependency-unused',
-                patches: [entry.filename],
-                fingerprint: stagedDependencyUnusedFingerprint(entry.filename, registration),
-                message: `${entry.filename} declares a staged registration in ${registration.file} ` +
-                    `("${registration.line}") for ${registration.creates}, but ${describeRegistrationFailure(failure)} ` +
-                    'Remove the stale declaration with: ' +
-                    `fireforge patch staged-dependency ${entry.filename} --remove --kind registration ` +
-                    `--file ${registration.file} --line "${quoteRegistrationLine(registration.line)}" ` +
-                    `--creates ${registration.creates}; or update it to match the patch and queue.`,
-                severity: 'warning',
-            });
-        }
-    }
-    return issues;
-}
-/**
- * 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 function lintPatchQueue(ctx) {
-    return [
-        ...lintPatchQueueDuplicateCreations(ctx),
-        ...lintPatchQueueForwardImports(ctx),
-        ...lintPatchQueueModuleRegistrations(ctx),
-        ...lintPatchQueueForwardRegistrations(ctx),
-        ...lintPatchQueueBinaryBodies(ctx),
-        ...lintTokenScaleFloors(ctx.entries.flatMap((entry) => [...entry.newFiles]), ctx.tokenScales ?? []),
-    ];
-}

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

@@ -1,27 +0,0 @@
-/**
- * CSS patch-lint rules: introduced raw color values, non-tokenized
- * custom-property references, and (opt-in) token scales over created CSS.
- *
- * Split out of `patch-lint.ts` so each rule family stays within the
- * per-file line budget. `patch-lint.ts` re-exports `lintPatchedCss` so
- * existing callers keep importing from the single module.
- */
-import type { PatchLintIssue } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-/**
- * Masks CSS block comments with spaces, preserving newlines so line
- * numbers stay stable. An unclosed trailing `/*` is masked to EOF,
- * matching how a CSS parser treats it.
- */
-export declare function maskCssComments(source: string): string;
-/**
- * Lints patched CSS files for introduced raw color values and non-tokenized
- * custom properties.
- *
- * @param repoDir - Absolute path to the engine (repository) directory
- * @param affectedFiles - File paths (relative to repoDir) affected by the patch
- * @param diffContent - Optional unified diff used to scope raw color checks to introduced lines
- * @param config - Project configuration
- * @returns Array of lint issues found
- */
-export declare function lintPatchedCss(repoDir: string, affectedFiles: string[], diffContent?: string, config?: FireForgeConfig): Promise<PatchLintIssue[]>;