@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/lint/rules/registration.js

@@ -0,0 +1,264 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Build-manifest and reference rules. Over the final state: moz.build lists
+ * mozbuild keeps sorted, created modules a resource URL imports but no
+ * moz.build installs, and manifest entries the owned changes add that name a
+ * file nothing provides. Over the order of sequential groups (a patch
+ * queue): an import or manifest entry that names a file only a later group
+ * creates, unless the group declares that staged dependency.
+ *
+ * A staged dependency is declared in the group's meta as
+ * `stagedDependencies: [{ file, creates }]`: `file` (in this group) may
+ * reference `creates` (created by a later group).
+ */
+import { isRecord } from '../../kernel/json.js';
+import { manifestKind, manifestReferences, mozBuildSortViolations } from '../../mozbuild/index.js';
+import { textContent } from '../../project/index.js';
+import { importSpecifiers } from '../../syntax/index.js';
+import { basename, isJsFile } from '../rule.js';
+const sortedLists = {
+    id: 'mozbuild-unsorted-list',
+    severity: 'error',
+    description: 'Strict-ordered moz.build lists in owned files are sorted, as configure requires',
+    check(context) {
+        return context.owned.all().flatMap((file) => manifestKind(file.path) !== 'moz-build' ||
+            file.text === undefined ||
+            !context.selected(file.path)
+            ? []
+            : mozBuildSortViolations(file.text).map((violation) => ({
+                path: file.path,
+                line: violation.line + 1,
+                group: file.group,
+                message: `moz.build list ${violation.variable} is not sorted: expected "${violation.expected}" ` +
+                    `but found "${violation.got}" (configure fails with UnsortedError).`,
+            })));
+    },
+};
+/** The `/modules/…` install path a `resource:///modules/` or `resource://gre/modules/` URL names. */
+function installedModulePath(specifier) {
+    const cleaned = specifier.split(/[?#]/)[0] ?? specifier;
+    const match = /^resource:\/\/(?:\/|gre\/)modules\/(.+\.sys\.mjs)$/.exec(cleaned);
+    return match?.[1] === undefined ? undefined : `/modules/${match[1]}`;
+}
+/** The text a change introduces: a created file whole, a modified file's added lines. */
+async function introducedText(context, change) {
+    if (change.kind === 'delete' || change.binary)
+        return undefined;
+    if (change.kind === 'create')
+        return textContent(await change.after());
+    const added = await context.owned.added(change);
+    return added.map((entry) => entry.text).join('\n');
+}
+const unregisteredModule = {
+    id: 'unregistered-system-module',
+    severity: 'error',
+    description: 'A created module that owned code imports by resource URL is installed by a moz.build list',
+    async check(context) {
+        const imported = new Set();
+        for (const file of context.owned.all()) {
+            if (!isJsFile(file.path))
+                continue;
+            const text = await introducedText(context, file.change);
+            for (const { specifier } of importSpecifiers(text ?? '')) {
+                const installed = installedModulePath(specifier);
+                if (installed !== undefined)
+                    imported.add(installed);
+            }
+        }
+        const listed = context.owned
+            .all()
+            .filter((file) => manifestKind(file.path) === 'moz-build')
+            .flatMap((file) => manifestReferences(file.path, file.text ?? ''));
+        return context.owned.all().flatMap((file) => {
+            if (!file.created || !file.path.endsWith('.sys.mjs') || !context.selected(file.path))
+                return [];
+            if (![...imported].some((suffix) => file.path.endsWith(suffix)))
+                return [];
+            if (listed.some((reference) => reference.matcher.matches(file.path)))
+                return [];
+            const leaf = basename(file.path);
+            return [
+                {
+                    path: file.path,
+                    group: file.group,
+                    message: `The module is imported by resource URL, but no owned moz.build lists ${leaf}. Add it ` +
+                        'to EXTRA_JS_MODULES (or its namespaced list): source checks resolve the file, the ' +
+                        'packaged browser does not.',
+                },
+            ];
+        });
+    },
+};
+/** Reference kinds that name one file; support-files may name directories. */
+const FILE_REFERENCES = new Set(['jar-source', 'test', 'head', 'tail']);
+const danglingRegistration = {
+    id: 'dangling-registration',
+    severity: 'error',
+    description: 'Manifest entries the owned changes add name files that exist',
+    async check(context) {
+        const drafts = [];
+        for (const file of context.owned.all()) {
+            if (manifestKind(file.path) === undefined || !context.selected(file.path))
+                continue;
+            const added = file.created
+                ? undefined
+                : new Set((await context.owned.added(file.change)).map((entry) => entry.line));
+            for (const reference of manifestReferences(file.path, file.text ?? '')) {
+                const target = reference.matcher.exact;
+                if (target === undefined || !FILE_REFERENCES.has(reference.kind))
+                    continue;
+                if (added !== undefined && !added.has(reference.line + 1))
+                    continue;
+                if (context.owned.get(target) !== undefined)
+                    continue;
+                if (!context.owned.deletes(target) && (await context.engine.read(target)) !== undefined)
+                    continue;
+                drafts.push({
+                    path: file.path,
+                    line: reference.line + 1,
+                    group: file.group,
+                    message: `"${reference.token}" names ${target}, which neither the owned changes nor the engine provide.`,
+                });
+            }
+        }
+        return drafts;
+    },
+};
+function stagedDependencies(group) {
+    const declared = group.meta['stagedDependencies'];
+    if (!Array.isArray(declared))
+        return [];
+    return declared.flatMap((entry) => isRecord(entry) && typeof entry['file'] === 'string' && typeof entry['creates'] === 'string'
+        ? [{ file: entry['file'], creates: entry['creates'] }]
+        : []);
+}
+const IMPORTABLE = /\.(?:m?js|jsm)$/;
+/** Every forward edge of a sequential change set, in group order. */
+function forwardEdges(context) {
+    let edges = edgesByRun.get(context);
+    if (edges === undefined) {
+        edges = collectForwardEdges(context);
+        edgesByRun.set(context, edges);
+    }
+    return edges;
+}
+/** The forward edges of each run, shared by the three rules that read them. */
+const edgesByRun = new WeakMap();
+async function collectForwardEdges(context) {
+    const order = new Map(context.changes.groups.map((group, index) => [group.id, index]));
+    const creations = context.changes.changes
+        .filter((change) => change.kind === 'create' && change.group !== undefined)
+        .map((change) => ({
+        path: change.path,
+        group: change.group ?? '',
+        index: order.get(change.group ?? '') ?? 0,
+    }));
+    const edges = [];
+    for (const [index, group] of context.changes.groups.entries()) {
+        const later = creations.filter((creation) => creation.index > index);
+        if (later.length === 0)
+            continue;
+        for (const step of context.changes.inGroup(group.id)) {
+            const text = await introducedText(context, step);
+            if (text === undefined)
+                continue;
+            const lineOf = step.kind === 'create' ? (line) => line : await addedLineMap(context, step);
+            if (IMPORTABLE.test(step.path)) {
+                for (const { specifier, line } of importSpecifiers(text)) {
+                    const leaf = basename(specifier.split(/[?#]/)[0] ?? specifier);
+                    if (!IMPORTABLE.test(leaf))
+                        continue;
+                    for (const creation of later.filter((candidate) => basename(candidate.path) === leaf)) {
+                        edges.push({
+                            kind: 'import',
+                            group: group.id,
+                            site: step.path,
+                            line: lineOf(line),
+                            token: specifier,
+                            creates: creation.path,
+                            creator: creation.group,
+                        });
+                    }
+                }
+            }
+            if (manifestKind(step.path) !== undefined) {
+                for (const reference of manifestReferences(step.path, text)) {
+                    for (const creation of later.filter((candidate) => reference.matcher.matches(candidate.path))) {
+                        edges.push({
+                            kind: 'registration',
+                            group: group.id,
+                            site: step.path,
+                            line: lineOf(reference.line + 1),
+                            token: reference.token,
+                            creates: creation.path,
+                            creator: creation.group,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return edges;
+}
+/** Maps a line of the joined added lines to its line in the step's result. */
+async function addedLineMap(context, step) {
+    const added = await context.owned.added(step);
+    return (line) => added[line - 1]?.line ?? line;
+}
+function isDeclared(context, edge) {
+    const group = context.changes.group(edge.group);
+    return (group !== undefined &&
+        stagedDependencies(group).some((d) => d.file === edge.site && d.creates === edge.creates));
+}
+function forwardRule(id, kind) {
+    return {
+        id,
+        severity: 'error',
+        description: kind === 'import'
+            ? 'In sequential groups, no import names a module only a later group creates'
+            : 'In sequential groups, no manifest entry names a file only a later group creates',
+        async check(context) {
+            if (!context.sequential)
+                return [];
+            return (await forwardEdges(context))
+                .filter((edge) => edge.kind === kind && !isDeclared(context, edge))
+                .map((edge) => ({
+                path: edge.site,
+                line: edge.line,
+                group: edge.group,
+                message: `"${edge.token}" names ${edge.creates}, which the later group ${edge.creator} creates, ` +
+                    'so the groups before it do not build alone. Reorder the groups, move the reference ' +
+                    `into ${edge.creator}, or declare the staged dependency { file: "${edge.site}", ` +
+                    `creates: "${edge.creates}" } on ${edge.group}.`,
+            }));
+        },
+    };
+}
+const unusedStaged = {
+    id: 'staged-dependency-unused',
+    severity: 'warning',
+    description: 'Every declared staged dependency matches a forward reference',
+    async check(context) {
+        if (!context.sequential)
+            return [];
+        const edges = await forwardEdges(context);
+        return context.changes.groups.flatMap((group) => stagedDependencies(group)
+            .filter((declared) => !edges.some((edge) => edge.group === group.id &&
+            edge.site === declared.file &&
+            edge.creates === declared.creates))
+            .map((declared) => ({
+            path: declared.file,
+            group: group.id,
+            message: `The staged dependency on ${declared.creates} matches no reference from ${declared.file} to a file a later group creates. Remove it.`,
+        })));
+    },
+};
+/** The build-manifest and reference rules. */
+export const registrationRules = [
+    sortedLists,
+    unregisteredModule,
+    danglingRegistration,
+    forwardRule('forward-import', 'import'),
+    forwardRule('forward-registration', 'registration'),
+    unusedStaged,
+];

package/dist/src/lint/rules/size.js

@@ -0,0 +1,299 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Size rules. `file-too-large` holds every created JavaScript file to the
+ * bands of its class; `large-patch-lines` and `large-patch-files` hold every
+ * group's own steps to the bands of its tier. Lines are counted the way
+ * `wc -l` counts them, or as code lines (non-blank once comments are
+ * blanked) under the `code` / `addedCode` metrics.
+ */
+import { fileSizeBands, patchSizeBands, } from '../../config/index.js';
+import { matchesGlob } from '../../kernel/glob.js';
+import { textContent } from '../../project/index.js';
+import { blankCssComments, blankJsCommentsParsed, fragmentExpansions } from '../../syntax/index.js';
+import { isJsFile, isTestFile } from '../rule.js';
+function bandOf(count, bands) {
+    if (bands.error !== null && count > bands.error)
+        return 'error';
+    if (count > bands.warning)
+        return 'warning';
+    if (count > bands.notice)
+        return 'notice';
+    return undefined;
+}
+function lines(text) {
+    const split = text.split('\n');
+    if (split.at(-1) === '')
+        split.pop();
+    return split;
+}
+const blank = (line) => line.trim() === '';
+const MARKUP = /\.(?:x?html|xml|svg|xul|dtd)$/;
+const HASH_COMMENTS = /(?:\.(?:ftl|properties|toml|ini|mn|build|py|conf|configure|sh|ya?ml|in|cfg|mozbuild)|(?:^|\/)(?:Makefile|mozconfig))$/;
+/** Lines inside an expanded component fragment: a copy of shared CSS, not this file's code. */
+function fragmentLines(css) {
+    const mask = css.map(() => false);
+    for (const [start, end] of fragmentExpansions(css))
+        mask.fill(true, start, end + 1);
+    return mask;
+}
+/**
+ * Which lines of a file carry code, by file kind: JavaScript through acorn,
+ * CSS block comments (and fragment expansions), `<!-- -->` in markup, and
+ * whole-line `#` comments (`;` in `.ini`/`.in`, `!` in `.properties`) in
+ * Fluent, manifests and build files. Any other file counts every non-blank
+ * line. JavaScript acorn cannot tokenize counts every non-blank line and is
+ * reported as not parsed.
+ *
+ * @param path - Engine-relative path, which picks the kind
+ * @param text - The content
+ */
+export function codeLines(path, text) {
+    if (/\.(?:m?js|jsm|cjs)$/.test(path)) {
+        const blanked = blankJsCommentsParsed(text);
+        return {
+            code: (blanked ?? text).split('\n').map((line) => !blank(line)),
+            parsed: blanked !== undefined,
+        };
+    }
+    if (path.endsWith('.css')) {
+        const fragments = fragmentLines(text.split('\n'));
+        const code = blankCssComments(text)
+            .split('\n')
+            .map((line, i) => !blank(line) && fragments[i] !== true);
+        return { code, parsed: true };
+    }
+    if (MARKUP.test(path)) {
+        const blanked = text.replace(/<!--[\s\S]*?(?:-->|$)/g, (m) => m.replace(/[^\n]/g, ' '));
+        return { code: blanked.split('\n').map((line) => !blank(line)), parsed: true };
+    }
+    const comment = HASH_COMMENTS.test(path)
+        ? /\.(?:ini|in)$/.test(path)
+            ? /^\s*[#;]/
+            : path.endsWith('.properties')
+                ? /^\s*[#!]/
+                : /^\s*#/
+        : undefined;
+    return {
+        code: text.split('\n').map((line) => !blank(line) && comment?.test(line) !== true),
+        parsed: true,
+    };
+}
+const fileTooLarge = {
+    id: 'file-too-large',
+    severity: 'warning',
+    description: 'Created JavaScript files stay under the size bands of their class',
+    check(context) {
+        const thresholds = context.config.patchLint.fileSizeThresholds;
+        const byCode = context.config.patchLint.fileSizeMetric === 'code';
+        const drafts = [];
+        for (const file of context.owned.all()) {
+            if (!file.created || !isJsFile(file.path) || file.text === undefined)
+                continue;
+            if (!context.selected(file.path))
+                continue;
+            let count = lines(file.text).length;
+            let unit = 'lines';
+            if (byCode) {
+                const counted = codeLines(file.path, file.text);
+                if (counted.parsed) {
+                    count = lines(file.text).filter((_, i) => counted.code[i] === true).length;
+                    unit = 'code lines';
+                }
+                else {
+                    drafts.push({
+                        path: file.path,
+                        group: file.group,
+                        severity: 'notice',
+                        message: `The file did not tokenize, so its ${count} raw lines were counted instead of code lines.`,
+                    });
+                }
+            }
+            const test = isTestFile(file.path);
+            const bands = fileSizeBands(test ? 'test' : 'general', thresholds?.[test ? 'test' : 'general']);
+            const band = bandOf(count, bands);
+            if (band === undefined)
+                continue;
+            drafts.push({
+                path: file.path,
+                group: file.group,
+                severity: band,
+                measurement: count,
+                message: sizeMessage(`${test ? 'Test file' : 'File'} has ${count} ${unit}`, band, bands, {
+                    key: 'patchLint.fileSizeThresholds',
+                    advice: test ? 'Consider splitting it by subject.' : 'Consider decomposing it.',
+                }),
+            });
+        }
+        return drafts;
+    },
+};
+/**
+ * A size finding's message: what each band means for a gate. A notice is
+ * over the design target and advisory; a warning fails a zero-warning gate,
+ * so it names the threshold key; an error asks for the split.
+ */
+function sizeMessage(subject, band, bands, how) {
+    const limits = `warning threshold ${bands.warning}${bands.error === null ? '' : `, error threshold ${bands.error}`}`;
+    if (band === 'error')
+        return `${subject} (error threshold ${bands.error ?? ''}). ${how.advice}`;
+    if (band === 'notice') {
+        return `${subject}, over the design target of ${bands.notice} (${limits}). Advisory; does not fail --max-warnings 0.`;
+    }
+    return (`${subject} (${limits}). A warning fails a gate run with --max-warnings 0; tune "${how.key}" ` +
+        `if these limits are wrong for this project. ${how.advice}`);
+}
+/** Paths a branding group may touch besides `browser/branding/` to register the flavour. */
+const BRANDING_SIBLINGS = new Set([
+    'browser/moz.configure',
+    'browser/confvars.sh',
+]);
+/**
+ * The tier a group is held to: `test` when every file is a test (which wins
+ * over branding), `branding` when the group declares it or every file sits
+ * under `browser/branding/` or is a registration sibling, else `general`.
+ *
+ * @param paths - The group's files
+ * @param declared - The group's declared tier
+ */
+export function groupTier(paths, declared) {
+    if (paths.length > 0 && paths.every(isTestFile))
+        return 'test';
+    if (declared === 'branding')
+        return 'branding';
+    const branding = paths.some((path) => path.startsWith('browser/branding/')) &&
+        paths.every((path) => path.startsWith('browser/branding/') || BRANDING_SIBLINGS.has(path));
+    return branding ? 'branding' : 'general';
+}
+function diffLineCount(diff) {
+    if (diff === undefined)
+        return 0;
+    if (diff.binary !== undefined)
+        return diff.header.length;
+    return diff.hunks.reduce((sum, hunk) => sum + 1 + hunk.lines.length + hunk.trailing.length, diff.header.length);
+}
+async function addedCodeLines(context, step) {
+    if (step.kind === 'delete' || step.binary)
+        return 0;
+    const text = textContent(await step.after());
+    const mask = text === undefined ? undefined : codeLines(step.path, text).code;
+    const added = await context.owned.added(step);
+    return added.filter((entry) => (mask ? mask[entry.line - 1] === true : !blank(entry.text)))
+        .length;
+}
+/**
+ * Measures one group's own steps: under `diff`, the lines of its unified
+ * diff (a binary section counts its header); under `addedCode`, the added
+ * lines that carry code in each step's result. Files matching
+ * `patchSizeRegistrationFiles` count toward neither number.
+ *
+ * @param context - The rule context
+ * @param groupId - The group
+ */
+async function measureGroup(context, groupId) {
+    const globs = context.config.patchLint.patchSizeRegistrationFiles ?? [];
+    const steps = context.changes.inGroup(groupId);
+    const registration = (path) => globs.some((glob) => matchesGlob(path, glob, { basename: true }));
+    const counted = steps.filter((step) => !registration(step.path));
+    const addedCode = context.config.patchLint.patchSizeMetric === 'addedCode';
+    let lineCount = 0;
+    let testLines = 0;
+    for (const step of counted) {
+        const stepLines = addedCode
+            ? await addedCodeLines(context, step)
+            : diffLineCount(await context.owned.diff(step));
+        lineCount += stepLines;
+        if (addedCode && isTestFile(step.path))
+            testLines += stepLines;
+    }
+    return {
+        tier: groupTier(steps.map((step) => step.path), context.changes.group(groupId)?.tier),
+        addedCode,
+        lines: lineCount,
+        testLines,
+        files: counted.length,
+        registrationFiles: steps.length - counted.length,
+    };
+}
+const SPLIT_ADVICE = 'Consider splitting it into smaller, focused groups.';
+function lineChecks(size, thresholds, testBands) {
+    if (!size.addedCode)
+        return [{ count: size.lines, bands: thresholds.lines, subject: `is ${size.lines} diff lines` }];
+    if (size.tier !== 'general') {
+        return [
+            { count: size.lines, bands: thresholds.lines, subject: `adds ${size.lines} code lines` },
+        ];
+    }
+    const product = size.lines - size.testLines;
+    const checks = [
+        {
+            count: product,
+            bands: thresholds.lines,
+            subject: `adds ${product} code lines${size.testLines > 0 ? ' in non-test files' : ''}`,
+            share: 'product',
+        },
+    ];
+    if (size.testLines > 0) {
+        checks.push({
+            count: size.testLines,
+            bands: testBands,
+            subject: `adds ${size.testLines} code lines in test files (test tier)`,
+            share: 'test',
+        });
+    }
+    return checks;
+}
+function patchSizeRule(id) {
+    return {
+        id,
+        severity: 'warning',
+        description: id === 'large-patch-lines'
+            ? "A group's own lines stay under the size bands of its tier"
+            : "A group's file count stays under the bands of its tier",
+        async check(context) {
+            const overrides = context.config.patchLint.patchSizeThresholds;
+            const drafts = [];
+            for (const group of context.changes.groups) {
+                if (group.sized === false)
+                    continue;
+                const size = await measureGroup(context, group.id);
+                const thresholds = patchSizeBands(size.tier, overrides?.[size.tier]);
+                const key = { key: 'patchLint.patchSizeThresholds', advice: SPLIT_ADVICE };
+                if (id === 'large-patch-files') {
+                    const band = bandOf(size.files, thresholds.files);
+                    if (band === undefined)
+                        continue;
+                    const excluded = size.registrationFiles > 0
+                        ? ` (not counting ${size.registrationFiles} registration file(s))`
+                        : '';
+                    drafts.push({
+                        group: group.id,
+                        severity: band,
+                        measurement: size.files,
+                        message: sizeMessage(`Group touches ${size.files} files${excluded}`, band, thresholds.files, key),
+                    });
+                    continue;
+                }
+                const testBands = patchSizeBands('test', overrides?.test).lines;
+                for (const check of lineChecks(size, thresholds, testBands)) {
+                    const band = bandOf(check.count, check.bands);
+                    if (band === undefined)
+                        continue;
+                    drafts.push({
+                        group: group.id,
+                        severity: band,
+                        measurement: check.count,
+                        ...(check.share === undefined ? {} : { share: check.share }),
+                        message: sizeMessage(`Group ${check.subject}`, band, check.bands, key),
+                    });
+                }
+            }
+            return drafts;
+        },
+    };
+}
+/** The size rules. */
+export const sizeRules = [
+    fileTooLarge,
+    patchSizeRule('large-patch-lines'),
+    patchSizeRule('large-patch-files'),
+];

package/dist/src/lint/run.js

@@ -0,0 +1,126 @@
+import { checkOwnedJs, explainOwnedJs } from './checkjs.js';
+import { loadOwnedFiles } from './input.js';
+import { runRule, } from './rule.js';
+import { cssRules } from './rules/css.js';
+import { javascriptRules } from './rules/javascript.js';
+import { licenseRules } from './rules/license.js';
+import { policyRules } from './rules/policy.js';
+import { registrationRules } from './rules/registration.js';
+import { sizeRules } from './rules/size.js';
+import { applyWaivers } from './waivers.js';
+function checkJsInput(context) {
+    return {
+        owned: context.owned,
+        engine: context.engine,
+        lint: context.config.patchLint,
+        projectRoot: context.projectRoot,
+        cacheDir: context.cacheDir,
+        complete: context.complete,
+        selected: context.selected,
+    };
+}
+const checkJs = {
+    id: 'checkjs-type-error',
+    severity: 'error',
+    description: 'Created modules (and with checkJsTestFiles, test scripts) type-check',
+    check(context) {
+        return context.config.patchLint.checkJs ? checkOwnedJs(checkJsInput(context)) : [];
+    },
+};
+/** Every rule, in report order within a path. */
+export const RULES = [
+    ...licenseRules,
+    ...javascriptRules,
+    ...cssRules,
+    ...sizeRules,
+    ...registrationRules,
+    checkJs,
+    ...policyRules,
+];
+/** Whether a path is one of `paths` or lies under one. */
+function under(paths) {
+    const prefixes = paths.map((path) => path.replace(/\/+$/, ''));
+    return (path) => prefixes.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
+}
+async function contextFor(changes, engine, config, options) {
+    return {
+        changes,
+        owned: await loadOwnedFiles(changes),
+        engine,
+        config,
+        projectRoot: options.projectRoot,
+        sequential: options.sequential ?? false,
+        tokens: options.tokens,
+        cacheDir: options.cacheDir,
+        selected: options.paths === undefined || options.paths.length === 0 ? () => true : under(options.paths),
+        complete: options.paths === undefined || options.paths.length === 0,
+        component: under(options.components ?? []),
+    };
+}
+function compare(a, b) {
+    const key = (finding) => [
+        finding.group ?? '',
+        finding.path ?? '',
+        String(finding.line ?? 0).padStart(8, '0'),
+        finding.rule,
+    ].join('\0');
+    return key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0;
+}
+/** Applies `patchLint.rules` to the waiver notices, which no rule's run produced. */
+function configured(config, finding) {
+    const severity = config.patchLint.rules?.['lint-ignore-removable'];
+    if (finding.rule !== 'lint-ignore-removable' || severity === undefined)
+        return [finding];
+    return severity === 'off' ? [] : [{ ...finding, severity }];
+}
+/**
+ * Runs every rule over the owned changes and applies the groups' waivers.
+ *
+ * @param changes - The owned changes, from either mode
+ * @param engine - Reads engine files around them
+ * @param config - The project configuration
+ * @param options - See {@link LintOptions}
+ * @throws FireForgeError when checkJs is on and TypeScript or a configured shim is missing
+ */
+export async function runLint(changes, engine, config, options) {
+    const context = await contextFor(changes, engine, config, options);
+    const findings = [];
+    for (const rule of RULES)
+        findings.push(...(await runRule(rule, context)));
+    const outcome = applyWaivers(changes, findings);
+    return {
+        findings: outcome.kept.flatMap((finding) => configured(config, finding)).sort(compare),
+        suppressed: outcome.suppressed.sort(compare),
+        waivers: outcome.waivers,
+    };
+}
+/**
+ * The strict typing pass alone (`checkjs-type-error`), with the severity
+ * and waivers `lint` applies to it. Nothing when `patchLint.checkJs` is off.
+ *
+ * @param changes - The owned changes
+ * @param engine - Reads the targets of a reviewed `paths` mapping
+ * @param config - The project configuration
+ * @param options - The project root and cache directory
+ * @throws FireForgeError when TypeScript or a configured shim is missing
+ */
+export async function checkOwnedTypes(changes, engine, config, options) {
+    const context = await contextFor(changes, engine, config, options);
+    const findings = await runRule(checkJs, context);
+    return applyWaivers(changes, findings)
+        .kept.filter((finding) => finding.rule === checkJs.id)
+        .sort(compare);
+}
+/**
+ * How the strict typing pass sees one file, without checking anything.
+ *
+ * @param changes - The owned changes
+ * @param engine - Reads the targets of a reviewed `paths` mapping
+ * @param config - The project configuration
+ * @param options - The project root
+ * @param path - Engine-relative path of the file
+ */
+export async function explainOwnedTypes(changes, engine, config, options, path) {
+    const context = await contextFor(changes, engine, config, options);
+    return explainOwnedJs(checkJsInput(context), path);
+}