@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/lint/checkjs.js

@@ -0,0 +1,400 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Strict typing of owned JavaScript (`patchLint.checkJs`).
+ *
+ * Programs are built in memory over the owned files' final content; the
+ * engine is never read except for the targets of a reviewed `paths`
+ * mapping. One program checks every created module (`.sys.mjs`); with
+ * `checkJsTestFiles` each created test script is its own program with its
+ * directory's created `head*.js` helpers, since mochitest scripts share
+ * top-level scope only with those. Every program resolves `resource:` and
+ * `chrome:` imports to the created module whose basename the specifier ends
+ * with (`.mjs` also finding `.sys.mjs`), when exactly one matches; any other
+ * URL import falls to the shim's wildcard modules and types as `any`.
+ *
+ * Each program's result is cached by the digests of everything it read
+ * (see `cache.ts`), so an unchanged program is not rebuilt.
+ */
+import { posix } from 'node:path';
+import { hash } from '../kernel/hash.js';
+import { textContent } from '../project/index.js';
+import { importSpecifiers } from '../syntax/index.js';
+import { pruneCache, readCached, writeCached } from './cache.js';
+import { basename, directoryOf, isTestFile } from './rule.js';
+import { composeShim, judgeDiagnostic, loadTypeScript, withGeckoDomTypes, } from './typescript.js';
+/** Where owned files live inside a program: a root no real file can sit under. */
+const ROOT = '/fireforge-engine/';
+/** Whether a path is a test script the test pass checks. */
+function isTestScript(path) {
+    return path.endsWith('.js') && !path.endsWith('.sys.mjs') && isTestFile(path);
+}
+/** Whether a path is a test directory's `head.js` / `head_*.js` helper. */
+function isHeadScript(path) {
+    return /^head(?:_.*)?\.js$/.test(basename(path));
+}
+/**
+ * The created module a URL specifier resolves to: the one whose basename is
+ * the specifier's last segment (`.mjs` also matching `.sys.mjs`). Relative,
+ * ambiguous and unknown specifiers resolve to nothing.
+ *
+ * @param modules - The resolvable modules
+ */
+export function moduleMatcher(modules) {
+    const byName = new Map();
+    for (const path of modules)
+        byName.set(basename(path), [...(byName.get(basename(path)) ?? []), path]);
+    return (specifier) => {
+        if (specifier.startsWith('.'))
+            return undefined;
+        const name = basename(specifier.split(/[?#]/)[0] ?? specifier);
+        if (name === '')
+            return undefined;
+        const candidates = [...(byName.get(name) ?? [])];
+        if (name.endsWith('.mjs') && !name.endsWith('.sys.mjs')) {
+            candidates.push(...(byName.get(name.replace(/\.mjs$/, '.sys.mjs')) ?? []));
+        }
+        return candidates.length === 1 ? candidates[0] : undefined;
+    };
+}
+/**
+ * The engine paths a reviewed `paths` mapping offers for a specifier, in
+ * the order tried: patterns as declared, each pattern's targets in order. A
+ * pattern's one `*` captures text that replaces the target's one `*`.
+ *
+ * @param paths - `checkJsCompilerOptions.paths`
+ * @param specifier - The import specifier
+ */
+export function pathsCandidates(paths, specifier) {
+    const candidates = [];
+    for (const [pattern, targets] of Object.entries(paths)) {
+        const star = pattern.indexOf('*');
+        let captured = '';
+        if (star === -1) {
+            if (specifier !== pattern)
+                continue;
+        }
+        else {
+            const [prefix, suffix] = [pattern.slice(0, star), pattern.slice(star + 1)];
+            if (specifier.length < prefix.length + suffix.length)
+                continue;
+            if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix))
+                continue;
+            captured = specifier.slice(prefix.length, specifier.length - suffix.length);
+        }
+        for (const target of targets) {
+            const at = target.indexOf('*');
+            const path = at === -1 ? target : target.slice(0, at) + captured + target.slice(at + 1);
+            candidates.push(posix.normalize(path).replace(/^\.\//, ''));
+        }
+    }
+    return candidates;
+}
+const TYPE_IMPORT = /\bimport\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g;
+function specifiersOf(source) {
+    return [
+        ...importSpecifiers(source).map((entry) => entry.specifier),
+        ...[...source.matchAll(TYPE_IMPORT)].map((match) => match[1] ?? ''),
+    ];
+}
+/** The program's in-memory files: owned content plus the `paths` targets it can reach. */
+async function programFiles(input, sources, paths) {
+    const files = new Map(sources);
+    const mapped = new Map();
+    if (paths === undefined)
+        return { files, mapped };
+    const queue = [...files.values()];
+    for (let source = queue.pop(); source !== undefined; source = queue.pop()) {
+        for (const specifier of specifiersOf(source)) {
+            if (mapped.has(specifier))
+                continue;
+            for (const candidate of pathsCandidates(paths, specifier)) {
+                let text = files.get(candidate) ?? input.owned.get(candidate)?.text;
+                if (text === undefined && !input.owned.deletes(candidate)) {
+                    const bytes = await input.engine.read(candidate);
+                    text = bytes === undefined ? undefined : textContent(bytes);
+                }
+                if (text === undefined)
+                    continue;
+                mapped.set(specifier, candidate);
+                if (!files.has(candidate)) {
+                    files.set(candidate, text);
+                    queue.push(text);
+                }
+                break;
+            }
+        }
+    }
+    return { files, mapped };
+}
+function compilerOptions(ts, lint) {
+    const strict = lint.checkJsStrict;
+    const { paths, ...flags } = lint.checkJsCompilerOptions ?? {};
+    return {
+        allowJs: true,
+        checkJs: true,
+        noEmit: true,
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        skipLibCheck: true,
+        types: [],
+        strict,
+        noImplicitAny: strict,
+        ...(strict ? flags : {}),
+        ...(strict && paths !== undefined ? { paths } : {}),
+    };
+}
+/** Implicit-`any` codes, which an unresolved URL import explains. */
+const IMPLICIT_ANY = new Set([7005, 7006, 7008, 7010, 7011, 7019, 7031, 7034]);
+const WILDCARD_MEMBER = /^Namespace '"([^"]*)"' has no exported member /;
+/** The extension TypeScript is told a resolved file has. */
+function extensionOf(ts, path) {
+    if (path.endsWith('.d.ts'))
+        return ts.Extension.Dts;
+    if (path.endsWith('.ts'))
+        return ts.Extension.Ts;
+    if (path.endsWith('.js'))
+        return ts.Extension.Js;
+    return ts.Extension.Mjs;
+}
+/** Builds one program and returns its findings on the unit's report files. */
+function runUnit(shared, unit) {
+    const { ts, options, files } = shared;
+    const shimPath = ROOT + unit.shim.fileName;
+    const unresolved = new Map();
+    const resolved = new Map();
+    const note = (into, file, specifier) => {
+        into.set(file, new Set([...(into.get(file) ?? []), specifier]));
+    };
+    const base = withGeckoDomTypes(ts, ts.createCompilerHost(options));
+    const memoryText = (fileName) => fileName === shimPath
+        ? unit.shim.source
+        : fileName.startsWith(ROOT)
+            ? files.get(fileName.slice(ROOT.length))
+            : undefined;
+    const host = {
+        ...base,
+        getCurrentDirectory: () => ROOT,
+        getSourceFile(fileName, languageVersion, onError) {
+            const key = `${fileName}\0${typeof languageVersion === 'object' ? languageVersion.languageVersion : languageVersion}`;
+            const cached = shared.parsed.get(key);
+            if (cached !== undefined)
+                return cached;
+            const text = memoryText(fileName);
+            const file = text !== undefined
+                ? ts.createSourceFile(fileName, text, languageVersion, true)
+                : fileName.startsWith(ROOT)
+                    ? ts.createSourceFile(fileName, '', languageVersion, true)
+                    : base.getSourceFile(fileName, languageVersion, onError);
+            if (file !== undefined)
+                shared.parsed.set(key, file);
+            return file;
+        },
+        fileExists: (fileName) => memoryText(fileName) !== undefined ||
+            (!fileName.startsWith(ROOT) && base.fileExists(fileName)),
+        readFile: (fileName) => memoryText(fileName) ?? (fileName.startsWith(ROOT) ? undefined : base.readFile(fileName)),
+        resolveModuleNameLiterals: (literals, containingFile) => literals.map((literal) => {
+            const target = shared.resolveModule(literal.text);
+            if (target === undefined) {
+                if (/^(?:resource|chrome):/.test(literal.text))
+                    note(unresolved, containingFile, literal.text);
+                return { resolvedModule: undefined };
+            }
+            note(resolved, containingFile, literal.text);
+            return {
+                resolvedModule: {
+                    resolvedFileName: ROOT + target,
+                    extension: extensionOf(ts, target),
+                    isExternalLibraryImport: false,
+                },
+            };
+        }),
+    };
+    const program = ts.createProgram([...unit.roots.map((root) => ROOT + root), shimPath], options, host);
+    const findings = [];
+    for (const file of program.getSourceFiles()) {
+        const path = file.fileName.startsWith(ROOT) ? file.fileName.slice(ROOT.length) : undefined;
+        if (path === undefined || !unit.report.has(path))
+            continue;
+        const anyTyped = unresolved.get(file.fileName);
+        for (const diagnostic of [
+            ...program.getSyntacticDiagnostics(file),
+            ...program.getSemanticDiagnostics(file),
+        ]) {
+            const judged = judgeDiagnostic(ts, diagnostic, {
+                undefinedIdentifiers: shared.undefinedIdentifiers,
+                isResolved: (containing, specifier) => resolved.get(containing)?.has(specifier) === true,
+            });
+            if (judged === undefined)
+                continue;
+            const member = judged.code === 2694 ? WILDCARD_MEMBER.exec(judged.message)?.[1] : undefined;
+            if (member !== undefined &&
+                (member === 'resource:*' || member === 'chrome:*' || anyTyped?.has(member) === true)) {
+                continue;
+            }
+            const hint = IMPLICIT_ANY.has(judged.code) && anyTyped !== undefined
+                ? ` (${[...anyTyped].sort().join(', ')} resolves to no owned module here, so it types as any; annotate explicitly.)`
+                : '';
+            findings.push({
+                path,
+                line: file.getLineAndCharacterOfPosition(diagnostic.start ?? 0).line + 1,
+                severity: judged.severity,
+                message: `TS${judged.code}: ${judged.message}${hint}`,
+            });
+        }
+    }
+    const read = program
+        .getSourceFiles()
+        .flatMap((file) => file.fileName.startsWith(ROOT) && files.has(file.fileName.slice(ROOT.length))
+        ? [file.fileName.slice(ROOT.length)]
+        : []);
+    return { findings, read };
+}
+/** The programs to run: the module program, then one per test script. */
+async function plan(input) {
+    const created = input.owned.all().filter((file) => file.created && file.text !== undefined);
+    const sources = new Map(created.map((file) => [file.path, file.text ?? '']));
+    const modules = created
+        .map((file) => file.path)
+        .filter((path) => path.endsWith('.mjs') && !isTestScript(path));
+    const roots = modules.filter((path) => path.endsWith('.sys.mjs') && input.selected(path));
+    const units = [];
+    const litTypes = input.lint.litTypes;
+    if (roots.length > 0) {
+        const shim = await composeShim(input.projectRoot, input.lint.checkJsExtraShim, { litTypes });
+        units.push({ roots, report: new Set(roots), shim });
+    }
+    if (input.lint.checkJsTestFiles) {
+        const paths = created.map((file) => file.path);
+        const heads = paths.filter(isHeadScript);
+        const selected = paths.filter((path) => isTestScript(path) && !isHeadScript(path) && input.selected(path));
+        if (selected.length > 0) {
+            const shim = await composeShim(input.projectRoot, input.lint.checkJsTestShim, {
+                litTypes,
+                testHarness: true,
+            });
+            for (const test of selected.sort()) {
+                const own = heads.filter((head) => directoryOf(head) === directoryOf(test));
+                units.push({ roots: [test, ...own], report: new Set([test]), shim });
+            }
+        }
+    }
+    return { units, modules, sources };
+}
+/**
+ * Type-checks the created modules and, with `checkJsTestFiles`, the created
+ * test scripts. Findings carry the path and line they are on.
+ *
+ * @param input - See {@link CheckJsInput}
+ * @throws FireForgeError when TypeScript is not installed or a configured shim is missing
+ */
+export async function checkOwnedJs(input) {
+    const { units, modules, sources } = await plan(input);
+    if (units.length === 0)
+        return [];
+    const ts = await loadTypeScript();
+    const options = compilerOptions(ts, input.lint);
+    const { files, mapped } = await programFiles(input, sources, options.paths);
+    const matchModule = moduleMatcher(modules);
+    const shared = {
+        ts,
+        options,
+        files,
+        resolveModule: (specifier) => matchModule(specifier) ?? mapped.get(specifier),
+        parsed: new Map(),
+        undefinedIdentifiers: input.lint.undefinedIdentifiers,
+    };
+    const digests = new Map([...files].map(([path, text]) => [path, hash(text)]));
+    const drafts = [];
+    const used = new Set();
+    for (const unit of units) {
+        const key = hash(JSON.stringify([
+            ts.version,
+            unit.roots,
+            [...unit.report],
+            unit.shim.fileName,
+            options,
+            modules,
+            [...mapped],
+            input.lint.undefinedIdentifiers,
+        ]));
+        used.add(key);
+        let findings = await readCached(input.cacheDir, key, digests);
+        if (findings === undefined) {
+            const result = runUnit(shared, unit);
+            findings = result.findings;
+            await writeCached(input.cacheDir, key, result.read, digests, findings);
+        }
+        drafts.push(...findings.map((finding) => ({
+            path: finding.path,
+            line: finding.line,
+            severity: finding.severity,
+            message: finding.message,
+            group: input.owned.get(finding.path)?.group,
+        })));
+    }
+    if (input.complete && input.cacheDir !== undefined)
+        await pruneCache(input.cacheDir, used);
+    return drafts;
+}
+function noneReason(input, path) {
+    const file = input.owned.get(path);
+    if (!input.lint.checkJs)
+        return 'patchLint.checkJs is off';
+    if (file === undefined)
+        return 'the project does not own this file';
+    if (!file.created)
+        return 'the project modifies this upstream file; only files it creates are checked';
+    if (isHeadScript(path)) {
+        return 'it is a head helper, checked inside each test program of its directory';
+    }
+    if (isTestScript(path)) {
+        return input.lint.checkJsTestFiles
+            ? undefined
+            : 'it is a test script and patchLint.checkJsTestFiles is off';
+    }
+    return path.endsWith('.sys.mjs')
+        ? undefined
+        : 'only created .sys.mjs modules and test scripts are checked';
+}
+/**
+ * How the strict owned pass sees one file, without checking anything.
+ *
+ * @param input - See {@link CheckJsInput}
+ * @param path - Engine-relative path
+ */
+export async function explainOwnedJs(input, path) {
+    const text = input.owned.get(path)?.text ?? '';
+    const { modules, sources } = await plan({ ...input, selected: () => false });
+    const paths = input.lint.checkJsStrict ? input.lint.checkJsCompilerOptions?.paths : undefined;
+    const { mapped } = await programFiles(input, new Map([...sources, [path, text]]), paths);
+    const match = moduleMatcher(modules);
+    const imports = [...new Set(specifiersOf(text).filter((s) => /^(?:resource|chrome):/.test(s)))]
+        .sort()
+        .map((specifier) => {
+        const owned = match(specifier);
+        if (owned !== undefined)
+            return { specifier, resolution: 'owned', target: owned };
+        const target = mapped.get(specifier);
+        return target === undefined
+            ? { specifier, resolution: 'any' }
+            : { specifier, resolution: 'paths', target };
+    });
+    const reason = noneReason(input, path);
+    if (reason !== undefined)
+        return { program: 'none', reason, heads: [], imports };
+    const test = isTestScript(path);
+    const heads = test
+        ? input.owned
+            .all()
+            .map((file) => file.path)
+            .filter((other) => other !== path && isHeadScript(other) && directoryOf(other) === directoryOf(path))
+        : [];
+    const shim = test ? input.lint.checkJsTestShim : input.lint.checkJsExtraShim;
+    return {
+        program: test ? 'test' : 'module',
+        heads,
+        imports,
+        ...(shim === undefined ? {} : { shim }),
+    };
+}

package/dist/src/lint/index.js

@@ -0,0 +1,3 @@
+export { lintReportJson, lintVerdict, renderLintReport } from './report.js';
+export { checkOwnedTypes, explainOwnedTypes, RULES, runLint } from './run.js';
+export { composeShim, judgeDiagnostic, loadTypeScript, withGeckoDomTypes, } from './typescript.js';

package/dist/src/lint/input.js

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * The owned changes as rules read them: each live path's final text,
+ * decoded once, and each change's added and removed lines, read from the
+ * provider's unified diff.
+ */
+import { addedLines, parsePatch } from '../diff/index.js';
+import { textContent } from '../project/index.js';
+/**
+ * A unified diff replacing every line, for a provider without a diff
+ * function: correct, if larger than the real diff.
+ */
+function wholeFileDiff(change, before, after) {
+    const lines = (text) => text === '' ? [] : text.replace(/\n$/, '').split('\n');
+    const old = lines(before);
+    const next = lines(after);
+    const path = change.path;
+    return [
+        `diff --git a/${path} b/${path}`,
+        change.kind === 'create' ? '--- /dev/null' : `--- a/${path}`,
+        change.kind === 'delete' ? '+++ /dev/null' : `+++ b/${path}`,
+        `@@ -${old.length === 0 ? 0 : 1},${old.length} +${next.length === 0 ? 0 : 1},${next.length} @@`,
+        ...old.map((line) => `-${line}`),
+        ...next.map((line) => `+${line}`),
+        '',
+    ].join('\n');
+}
+async function readText(reader) {
+    return textContent(await reader()) ?? '';
+}
+/** The owned changes, indexed for rules. Build one per run with {@link loadOwnedFiles}. */
+export class OwnedFiles {
+    changes;
+    byPath;
+    diffs = new Map();
+    constructor(changes, files) {
+        this.changes = changes;
+        this.byPath = new Map(files.map((file) => [file.path, file]));
+    }
+    /** Every live owned path, by path. */
+    all() {
+        return [...this.byPath.values()];
+    }
+    /** The live owned path, or undefined when the project does not own it or deletes it. */
+    get(path) {
+        return this.byPath.get(path);
+    }
+    /** Whether the project deletes this upstream path. */
+    deletes(path) {
+        return this.changes.final(path)?.kind === 'delete';
+    }
+    /** The text section of a change's diff, or undefined for a binary change. */
+    diff(change) {
+        let pending = this.diffs.get(change);
+        if (pending === undefined) {
+            pending = this.readDiff(change);
+            this.diffs.set(change, pending);
+        }
+        return pending;
+    }
+    /** The lines a change adds, numbered in its after content. */
+    async added(change) {
+        const diff = await this.diff(change);
+        return diff === undefined ? [] : addedLines(diff);
+    }
+    /** The lines a change removes, without their markers. */
+    async removed(change) {
+        const diff = await this.diff(change);
+        return (diff?.hunks ?? []).flatMap((hunk) => hunk.lines.filter((line) => line.startsWith('-')).map((line) => line.slice(1)));
+    }
+    async readDiff(change) {
+        if (change.binary)
+            return undefined;
+        const text = this.changes.diff === undefined
+            ? wholeFileDiff(change, change.kind === 'create' ? '' : await readText(change.before), change.kind === 'delete' ? '' : await readText(change.after))
+            : await this.changes.diff(change);
+        return parsePatch(text).files.find((file) => file.path === change.path);
+    }
+}
+/**
+ * Reads the final text of every live owned path.
+ *
+ * @param changes - The owned changes
+ */
+export async function loadOwnedFiles(changes) {
+    const live = changes
+        .net()
+        .filter((change) => change.kind !== 'delete');
+    const files = await Promise.all(live.map(async (change) => {
+        const bytes = await change.after();
+        return {
+            path: change.path,
+            change,
+            created: change.kind === 'create',
+            text: change.binary || change.mode === '120000' ? undefined : textContent(bytes),
+            group: change.group,
+        };
+    }));
+    return new OwnedFiles(changes, files);
+}

package/dist/src/lint/report.js

@@ -0,0 +1,107 @@
+function count(report, severity) {
+    return report.findings.filter((finding) => finding.severity === severity).length;
+}
+/**
+ * Judges a report: any error fails, and so do more warnings than
+ * `maxWarnings` when it is given. Notices never fail.
+ *
+ * @param report - The report
+ * @param maxWarnings - The most warnings a passing run may have
+ */
+export function lintVerdict(report, maxWarnings) {
+    const errors = count(report, 'error');
+    const warnings = count(report, 'warning');
+    const notices = count(report, 'notice');
+    const reason = errors > 0
+        ? `${errors} error(s)`
+        : maxWarnings !== undefined && warnings > maxWarnings
+            ? `${warnings} warning(s), more than --max-warnings ${maxWarnings}`
+            : undefined;
+    return {
+        pass: reason === undefined,
+        errors,
+        warnings,
+        notices,
+        ...(reason === undefined ? {} : { reason }),
+    };
+}
+function findingJson(finding) {
+    return {
+        rule: finding.rule,
+        severity: finding.severity,
+        message: finding.message,
+        path: finding.path ?? null,
+        line: finding.line ?? null,
+        group: finding.group ?? null,
+        ...(finding.measurement === undefined ? {} : { measurement: finding.measurement }),
+        ...(finding.share === undefined ? {} : { share: finding.share }),
+    };
+}
+/**
+ * The `--json` document of a run.
+ *
+ * @param report - The report
+ * @param verdict - Its judgement
+ */
+export function lintReportJson(report, verdict) {
+    return {
+        pass: verdict.pass,
+        errors: verdict.errors,
+        warnings: verdict.warnings,
+        notices: verdict.notices,
+        findings: report.findings.map(findingJson),
+        suppressed: report.suppressed.map(findingJson),
+        waivers: report.waivers.map((waiver) => ({
+            group: waiver.group,
+            rule: waiver.rule,
+            max: waiver.max,
+            reason: waiver.reason,
+            share: waiver.share ?? null,
+            measurement: waiver.measurement,
+            state: waiver.state,
+        })),
+    };
+}
+/**
+ * Human lines for a report: findings under a heading per group (project-
+ * level findings first), each `severity path:line [rule] message`. Notices
+ * are summarised in one line per rule unless `verbose`.
+ *
+ * @param report - The report
+ * @param verdict - Its judgement
+ * @param verbose - Print every notice
+ */
+export function renderLintReport(report, verdict, verbose) {
+    const shown = report.findings.filter((finding) => verbose || finding.severity !== 'notice');
+    const lines = [];
+    let heading;
+    for (const finding of shown) {
+        const group = finding.group ?? '(project)';
+        if (group !== heading) {
+            if (heading !== undefined)
+                lines.push('');
+            lines.push(group);
+            heading = group;
+        }
+        const where = finding.path === undefined
+            ? ''
+            : `${finding.path}${finding.line === undefined ? '' : `:${finding.line}`} `;
+        lines.push(`  ${finding.severity.padEnd(7)} ${where}[${finding.rule}] ${finding.message}`);
+    }
+    if (!verbose && verdict.notices > 0) {
+        const byRule = new Map();
+        for (const finding of report.findings) {
+            if (finding.severity === 'notice')
+                byRule.set(finding.rule, (byRule.get(finding.rule) ?? 0) + 1);
+        }
+        if (lines.length > 0)
+            lines.push('');
+        lines.push(`Notices (advisory; --verbose lists them): ${[...byRule].map(([rule, n]) => `${rule} ${n}`).join(', ')}`);
+    }
+    if (lines.length > 0)
+        lines.push('');
+    const suppressed = report.suppressed.length > 0 ? `, ${report.suppressed.length} waived` : '';
+    lines.push(`Lint: ${verdict.errors} error(s), ${verdict.warnings} warning(s), ${verdict.notices} notice(s)${suppressed}` +
+        (verdict.pass ? '' : ` — failed: ${verdict.reason ?? ''}`));
+    return lines;
+}

package/dist/src/lint/rule.js

@@ -0,0 +1,41 @@
+/**
+ * Runs one rule under the configured severity: `patchLint.rules[id]` turns it
+ * off or replaces the severity of every finding; otherwise a finding keeps
+ * its own severity (a size band) or takes the rule's default.
+ *
+ * @param rule - The rule
+ * @param context - What it reads
+ */
+export async function runRule(rule, context) {
+    const configured = context.config.patchLint.rules?.[rule.id];
+    const effective = configured ?? rule.severity;
+    if (effective === 'off')
+        return [];
+    const drafts = await rule.check(context);
+    return drafts.map((draft) => ({
+        ...draft,
+        rule: rule.id,
+        severity: configured !== undefined && configured !== 'off' ? configured : (draft.severity ?? effective),
+    }));
+}
+/** True for `.js`, `.mjs`, `.jsm` and `.sys.mjs` files. */
+export function isJsFile(path) {
+    return /\.(?:m?js|jsm)$/.test(path);
+}
+/**
+ * The test class of the size rules and the strict typing of test scripts: a
+ * path under `/test/`, or a `browser_`, `test_` or `xpcshell_` `.js` file.
+ */
+export function isTestFile(path) {
+    if (path.includes('/test/'))
+        return true;
+    return /^(?:browser_|test_|xpcshell_).*\.js$/.test(basename(path));
+}
+/** The last segment of a forward-slash path. */
+export function basename(path) {
+    return path.slice(path.lastIndexOf('/') + 1);
+}
+/** The directory part of a forward-slash path, with a trailing slash, or `''` at the top. */
+export function directoryOf(path) {
+    return path.slice(0, path.lastIndexOf('/') + 1);
+}