@ksmv/ui-checks 0.1.0

package/dist/rules/tokenContrast.d.ts

@@ -0,0 +1,11 @@
+import type { ThemeConfig } from "../config.js";
+import { type ContrastManifest } from "../contracts.js";
+import type { CheckRule } from "../scan.js";
+export type { ContrastManifest, ContrastPair } from "../contracts.js";
+export interface TokenContrastOptions {
+    computed?: Record<string, Record<string, string>>;
+    manifest: ContrastManifest;
+    themes: ThemeConfig[];
+}
+export declare function loadContrastManifest(url?: URL): Promise<ContrastManifest>;
+export declare function createTokenContrastRule({ computed, manifest, themes, }: TokenContrastOptions): CheckRule;

package/dist/rules/tokenContrast.js

@@ -0,0 +1,170 @@
+import { isComputedPropertyName, isIdentifier, isJsxAttribute, isJsxExpression, isObjectLiteralExpression, isPropertyAssignment, isJsxSpreadAttribute, isStringLiteralLikeNode, } from "typescript/unstable/ast";
+import { contrastRatio, isColorBearingProperty, resolveColor, } from "../color.js";
+import { parseContrastManifest, } from "../contracts.js";
+import { createThemeCollector } from "./theme.js";
+export async function loadContrastManifest(url) {
+    const { readFile } = await import("node:fs/promises");
+    const packaged = url ?? new URL("../contrast-contract.json", import.meta.url);
+    return parseContrastManifest(await readFile(packaged, "utf8"));
+}
+function findingLocation(theme) {
+    const first = theme.declarations.values().next().value;
+    return {
+        column: first?.column ?? 1,
+        line: first?.line ?? 1,
+        path: first?.path ?? [...theme.files].sort()[0] ?? "theme.css",
+    };
+}
+function propertyName(node) {
+    if (isIdentifier(node) || isStringLiteralLikeNode(node)) {
+        return node.text;
+    }
+    return isComputedPropertyName(node) && isStringLiteralLikeNode(node.expression)
+        ? node.expression.text
+        : undefined;
+}
+function dynamicStyleResult(file) {
+    const result = { uncovered: [], violations: [] };
+    if (!file.sourceFile) {
+        return result;
+    }
+    const sourceFile = file.sourceFile;
+    const visit = (node) => {
+        if (isJsxSpreadAttribute(node)) {
+            const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+            result.uncovered.push({
+                column: position.character + 1,
+                line: position.line + 1,
+                message: "JSX prop spreads require computed coverage.",
+                nodeKind: "tsx-props-spread",
+                path: file.path,
+                rule: "tokens/contrast",
+            });
+        }
+        if (isJsxAttribute(node) &&
+            isIdentifier(node.name) &&
+            (node.name.text === "className" ||
+                node.name.text === "style" ||
+                isColorBearingProperty(node.name.text)) &&
+            node.initializer &&
+            isJsxExpression(node.initializer) &&
+            node.initializer.expression) {
+            let isDynamic = !isStringLiteralLikeNode(node.initializer.expression);
+            if (node.name.text === "style" &&
+                isObjectLiteralExpression(node.initializer.expression)) {
+                isDynamic = node.initializer.expression.properties.some((property) => {
+                    if (!("name" in property)) {
+                        return true;
+                    }
+                    const name = propertyName(property.name);
+                    if (name === undefined) {
+                        return true;
+                    }
+                    if (!isColorBearingProperty(name)) {
+                        return false;
+                    }
+                    return (!isPropertyAssignment(property) ||
+                        !isStringLiteralLikeNode(property.initializer));
+                });
+            }
+            if (isDynamic) {
+                const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+                result.uncovered.push({
+                    column: position.character + 1,
+                    line: position.line + 1,
+                    message: "Dynamic class or color expressions require computed coverage.",
+                    nodeKind: "tsx-attribute",
+                    path: file.path,
+                    rule: "tokens/contrast",
+                });
+            }
+        }
+        node.forEachChild(visit);
+    };
+    sourceFile.forEachChild(visit);
+    return result;
+}
+export function createTokenContrastRule({ computed = {}, manifest, themes, }) {
+    const collector = createThemeCollector(themes);
+    return {
+        name: "tokens/contrast",
+        begin: collector.begin,
+        check(file) {
+            collector.collect(file);
+            return dynamicStyleResult(file);
+        },
+        complete() {
+            const result = { uncovered: [], violations: [] };
+            for (const theme of collector.themes) {
+                const location = findingLocation(theme);
+                const computedTheme = computed[theme.name] ?? {};
+                const hasCompleteComputedEvidence = manifest.pairs.every(({ background, foreground }) => computedTheme[background] !== undefined &&
+                    computedTheme[foreground] !== undefined);
+                if (theme.overlapping && !hasCompleteComputedEvidence) {
+                    result.uncovered.push({
+                        ...location,
+                        message: `Theme ${theme.name} uses overlapping selectors.`,
+                        nodeKind: "theme-selector",
+                        rule: "tokens/contrast",
+                        required: true,
+                    });
+                    continue;
+                }
+                const missingComputedEndpoints = theme.unresolved
+                    ? manifest.pairs.flatMap(({ background, foreground }) => [background, foreground].filter((token) => computedTheme[token] === undefined))
+                    : [];
+                if (missingComputedEndpoints.length > 0) {
+                    result.uncovered.push({
+                        ...location,
+                        message: `Theme ${theme.name} has unresolved cascade conditions.`,
+                        nodeKind: "theme-cascade",
+                        rule: "tokens/contrast",
+                        required: true,
+                    });
+                    continue;
+                }
+                const tokens = new Map([...theme.declarations].map(([name, declaration]) => [
+                    name,
+                    declaration.value,
+                ]));
+                for (const [name, value] of Object.entries(computedTheme)) {
+                    tokens.set(name, value);
+                }
+                for (const pair of manifest.pairs) {
+                    const background = resolveColor(tokens.get(pair.background), tokens);
+                    const foreground = resolveColor(tokens.get(pair.foreground), tokens);
+                    if (background.status === "uncovered" ||
+                        foreground.status === "uncovered") {
+                        result.uncovered.push({
+                            ...location,
+                            message: `Contrast pair ${pair.context} could not be resolved.`,
+                            nodeKind: `contrast-pair:${pair.context}:${pair.foreground}:${pair.background}`,
+                            rule: "tokens/contrast",
+                            required: true,
+                        });
+                        continue;
+                    }
+                    const ratio = contrastRatio(foreground.color, background.color);
+                    if (ratio === undefined) {
+                        result.uncovered.push({
+                            ...location,
+                            message: `Contrast pair ${pair.context} requires a known opaque background.`,
+                            nodeKind: `contrast-pair:${pair.context}:${pair.foreground}:${pair.background}`,
+                            rule: "tokens/contrast",
+                            required: true,
+                        });
+                    }
+                    else if (ratio < pair.minimum) {
+                        result.violations.push({
+                            ...location,
+                            message: `Contrast pair ${pair.context} is below ${pair.minimum}:1.`,
+                            nodeKind: `contrast-pair:${pair.context}:${pair.foreground}:${pair.background}`,
+                            rule: "tokens/contrast",
+                        });
+                    }
+                }
+            }
+            return result;
+        },
+    };
+}

package/dist/rules/tokenPrefix.d.ts

@@ -0,0 +1,2 @@
+import type { CheckRule } from "../scan.js";
+export declare function createTokenPrefixRule(): CheckRule;

package/dist/rules/tokenPrefix.js

@@ -0,0 +1,62 @@
+import { isComputedPropertyName, isIdentifier, isJsxAttribute, isJsxExpression, isObjectLiteralExpression, isPropertyAssignment, isStringLiteralLikeNode, } from "typescript/unstable/ast";
+export function createTokenPrefixRule() {
+    return {
+        name: "tokens/prefix",
+        check(file) {
+            const violations = [];
+            file.cssRoot?.walkDecls((declaration) => {
+                if (declaration.prop.startsWith("--") &&
+                    !declaration.prop.startsWith("--ui-")) {
+                    violations.push({
+                        column: declaration.source?.start?.column ?? 1,
+                        line: declaration.source?.start?.line ?? 1,
+                        message: "Public custom properties must use the --ui- prefix.",
+                        nodeKind: "css-custom-property",
+                        path: file.path,
+                        rule: "tokens/prefix",
+                    });
+                }
+            });
+            if (file.sourceFile) {
+                const sourceFile = file.sourceFile;
+                const visit = (node) => {
+                    if (isJsxAttribute(node) &&
+                        isIdentifier(node.name) &&
+                        node.name.text === "style" &&
+                        node.initializer &&
+                        isJsxExpression(node.initializer) &&
+                        node.initializer.expression &&
+                        isObjectLiteralExpression(node.initializer.expression)) {
+                        for (const property of node.initializer.expression.properties) {
+                            if (!isPropertyAssignment(property)) {
+                                continue;
+                            }
+                            const propertyNode = property.name;
+                            const name = isIdentifier(propertyNode) ||
+                                isStringLiteralLikeNode(propertyNode)
+                                ? propertyNode.text
+                                : isComputedPropertyName(propertyNode) &&
+                                    isStringLiteralLikeNode(propertyNode.expression)
+                                    ? propertyNode.expression.text
+                                    : undefined;
+                            if (name?.startsWith("--") && !name.startsWith("--ui-")) {
+                                const position = sourceFile.getLineAndCharacterOfPosition(propertyNode.getStart(sourceFile));
+                                violations.push({
+                                    column: position.character + 1,
+                                    line: position.line + 1,
+                                    message: "Public custom properties must use the --ui- prefix.",
+                                    nodeKind: "tsx-custom-property",
+                                    path: file.path,
+                                    rule: "tokens/prefix",
+                                });
+                            }
+                        }
+                    }
+                    node.forEachChild(visit);
+                };
+                sourceFile.forEachChild(visit);
+            }
+            return { uncovered: [], violations };
+        },
+    };
+}

package/dist/scan.d.ts

@@ -0,0 +1,40 @@
+import { type Root } from "postcss";
+import { SyntaxKind, type SourceFile } from "typescript/unstable/ast";
+import type { ChecksConfig } from "./config.js";
+import type { CheckReport, Uncovered, Violation } from "./result.js";
+export interface ScannedFile {
+    content: string;
+    cssRoot?: Root;
+    path: string;
+    sourceFile?: SourceFile;
+    typescriptTokens?: TypeScriptToken[];
+}
+export interface TypeScriptToken {
+    end: number;
+    kind: SyntaxKind;
+    start: number;
+    text: string;
+}
+export interface RuleResult {
+    uncovered: Uncovered[];
+    violations: Violation[];
+}
+export interface CheckRule {
+    begin?(): Promise<void> | void;
+    check(file: ScannedFile): Promise<RuleResult> | RuleResult;
+    complete?(): Promise<RuleResult> | RuleResult;
+    name: string;
+}
+export interface RunChecksOptions {
+    applyGovernance?: boolean;
+    /**
+     * Replaces disk reads for rule input. The TypeScript API cannot be handed an
+     * in-memory source, so supplying this disables type analysis and records an
+     * operational error: a run must never mix rule findings from one version of a
+     * file with type findings from another. Intended for tests that need to
+     * simulate an I/O failure.
+     */
+    readFile?: (absolutePath: string) => Promise<string>;
+    rules?: CheckRule[];
+}
+export declare function runChecks(config: ChecksConfig, options?: RunChecksOptions): Promise<CheckReport>;

package/dist/scan.js

@@ -0,0 +1,398 @@
+import { glob, readFile as readFileFromDisk } from "node:fs/promises";
+import { extname, relative, resolve } from "node:path";
+import postcss from "postcss";
+import { computeLineStarts, createScanner, LanguageVariant, SyntaxKind, } from "typescript/unstable/ast";
+import { API } from "typescript/unstable/sync";
+import { resolveContractSet } from "./contracts.js";
+import { loadComputedEvidence } from "./evidence.js";
+import { applyDebtControls } from "./governance.js";
+const supportedExtensions = [".css", ".js", ".jsx", ".ts", ".tsx"];
+function toPosixPath(path) {
+    return path.replaceAll("\\", "/");
+}
+function compareFindings(left, right) {
+    return (left.path.localeCompare(right.path) ||
+        left.line - right.line ||
+        left.column - right.column ||
+        left.rule.localeCompare(right.rule) ||
+        left.message.localeCompare(right.message));
+}
+function scanTypeScript(content, path) {
+    const scanner = createScanner(true, LanguageVariant.JSX, content);
+    const tokens = [];
+    const uncovered = [];
+    let kind = scanner.scan();
+    while (kind !== SyntaxKind.EndOfFile) {
+        tokens.push({
+            end: scanner.getTokenEnd(),
+            kind,
+            start: scanner.getTokenStart(),
+            text: scanner.getTokenText(),
+        });
+        kind = scanner.scan();
+    }
+    const lineStarts = computeLineStarts(content);
+    for (let index = 0; index < tokens.length; index += 1) {
+        const attribute = tokens[index];
+        if (attribute.kind !== SyntaxKind.Identifier ||
+            (attribute.text !== "className" && attribute.text !== "style") ||
+            tokens[index + 1]?.kind !== SyntaxKind.EqualsToken ||
+            tokens[index + 2]?.kind !== SyntaxKind.OpenBraceToken) {
+            continue;
+        }
+        const expression = tokens[index + 3];
+        const isStatic = expression?.kind === SyntaxKind.StringLiteral ||
+            expression?.kind === SyntaxKind.NoSubstitutionTemplateLiteral ||
+            expression?.kind === SyntaxKind.NumericLiteral ||
+            (attribute.text === "style" &&
+                expression?.kind === SyntaxKind.OpenBraceToken);
+        if (isStatic) {
+            continue;
+        }
+        let lineIndex = 0;
+        while (lineIndex + 1 < lineStarts.length &&
+            lineStarts[lineIndex + 1] <= attribute.start) {
+            lineIndex += 1;
+        }
+        uncovered.push({
+            column: attribute.start - lineStarts[lineIndex] + 1,
+            line: lineIndex + 1,
+            message: "Dynamic class or style expression requires computed coverage.",
+            nodeKind: "tsx-attribute",
+            path,
+            rule: "coverage/dynamic-expression",
+        });
+    }
+    const nodesChecked = content.match(/<[A-Za-z][\w.-]*/g)?.length ?? 0;
+    return { nodesChecked, tokens, uncovered };
+}
+async function discoverFiles(root, include, exclude = []) {
+    const paths = new Set();
+    for await (const path of glob(include, { cwd: root, exclude })) {
+        if (supportedExtensions.includes(extname(path).toLowerCase())) {
+            paths.add(resolve(root, path));
+        }
+    }
+    return [...paths].sort((left, right) => left.localeCompare(right));
+}
+function emptyReport(rulesExecuted) {
+    return {
+        baselineDebt: [],
+        baselineMatches: [],
+        declarationsChecked: 0,
+        durationMs: 0,
+        exitCode: 0,
+        filesDiscovered: 0,
+        filesIgnored: [],
+        filesRead: 0,
+        nodesChecked: 0,
+        operationalErrors: [],
+        rulesExecuted,
+        schemaVersion: 1,
+        suppressions: [],
+        uncovered: [],
+        violations: [],
+    };
+}
+function resolveExitCode(report, failOnUncovered) {
+    if (report.operationalErrors.length > 0 ||
+        report.uncovered.some(({ required }) => required === true) ||
+        (failOnUncovered && report.uncovered.length > 0)) {
+        return 2;
+    }
+    return report.violations.length > 0 ? 1 : 0;
+}
+function validateRuntimeConfig(value) {
+    if (!value || typeof value !== "object") {
+        return "Configuration must be an object.";
+    }
+    const candidate = value;
+    if (!Array.isArray(candidate.include) ||
+        candidate.include.length === 0 ||
+        candidate.include.some((pattern) => typeof pattern !== "string" || pattern.length === 0)) {
+        return "At least one include pattern is required.";
+    }
+    if (candidate.exclude !== undefined &&
+        (!Array.isArray(candidate.exclude) ||
+            candidate.exclude.some((pattern) => typeof pattern !== "string"))) {
+        return "Exclude patterns must be an array of strings.";
+    }
+    if (candidate.failOnUncovered !== undefined &&
+        typeof candidate.failOnUncovered !== "boolean") {
+        return "failOnUncovered must be a boolean.";
+    }
+    if (candidate.root !== undefined && typeof candidate.root !== "string") {
+        return "Root must be a string.";
+    }
+    if (candidate.contractSource !== undefined &&
+        candidate.contractSource !== "bundled" &&
+        candidate.contractSource !== "@ksmv/ui-react") {
+        return "contractSource must be bundled or @ksmv/ui-react.";
+    }
+    if (candidate.themes !== undefined &&
+        (!Array.isArray(candidate.themes) ||
+            candidate.themes.some((theme) => !theme ||
+                typeof theme !== "object" ||
+                typeof theme.name !== "string" ||
+                theme.name.trim().length === 0 ||
+                typeof theme.selector !== "string" ||
+                theme.selector.trim().length === 0 ||
+                !Array.isArray(theme.files) ||
+                theme.files.length === 0 ||
+                theme.files.some((path) => typeof path !== "string" || path.length === 0) ||
+                (theme.computedEvidence !== undefined &&
+                    (!theme.computedEvidence ||
+                        typeof theme.computedEvidence !== "object" ||
+                        typeof theme.computedEvidence.file !== "string" ||
+                        theme.computedEvidence.file.length === 0 ||
+                        typeof theme.computedEvidence.theme !== "string" ||
+                        theme.computedEvidence.theme.length === 0))))) {
+        return "Themes must be an array of named selectors with files.";
+    }
+    return undefined;
+}
+export async function runChecks(config, options = {}) {
+    const startedAt = performance.now();
+    const configurationError = validateRuntimeConfig(config);
+    if (configurationError) {
+        const report = emptyReport(["coverage/dynamic-expression"]);
+        report.operationalErrors.push({
+            code: "config",
+            message: configurationError,
+        });
+        report.exitCode = 2;
+        report.durationMs = Math.round((performance.now() - startedAt) * 100) / 100;
+        return report;
+    }
+    const usesDefaultRules = options.rules === undefined;
+    const root = resolve(config.root ?? process.cwd());
+    if (usesDefaultRules && config.contractSource === undefined) {
+        const report = emptyReport(["coverage/dynamic-expression"]);
+        report.operationalErrors.push({
+            code: "config",
+            message: "contractSource is required when using the default rules.",
+        });
+        report.exitCode = 2;
+        report.durationMs = Math.round((performance.now() - startedAt) * 100) / 100;
+        return report;
+    }
+    let rules;
+    let contracts;
+    try {
+        let configuredRules = options.rules;
+        if (configuredRules === undefined) {
+            contracts = await resolveContractSet({
+                root,
+                source: config.contractSource,
+            });
+            const computed = await loadComputedEvidence({
+                contracts,
+                root,
+                themes: config.themes ?? [],
+            });
+            configuredRules = await (await import("./rules/default.js")).createDefaultRules({
+                computed,
+                contract: contracts.theme,
+                manifest: contracts.contrast,
+                themes: config.themes ?? [],
+            });
+        }
+        rules = [...(await configuredRules)].sort((left, right) => left.name.localeCompare(right.name));
+    }
+    catch {
+        const report = emptyReport(["coverage/dynamic-expression"]);
+        if (contracts) {
+            report.contracts = {
+                contrast: contracts.identities.contrast,
+                source: contracts.source,
+                theme: contracts.identities.theme,
+            };
+        }
+        report.operationalErrors.push({
+            code: usesDefaultRules ? "config" : "internal",
+            message: "Unable to initialize configured rules.",
+        });
+        report.exitCode = 2;
+        report.durationMs = Math.round((performance.now() - startedAt) * 100) / 100;
+        return report;
+    }
+    const report = emptyReport([
+        "coverage/dynamic-expression",
+        ...rules.map(({ name }) => name),
+    ]);
+    if (contracts) {
+        report.contracts = {
+            contrast: contracts.identities.contrast,
+            source: contracts.source,
+            theme: contracts.identities.theme,
+        };
+    }
+    for (const rule of rules) {
+        await rule.begin?.();
+    }
+    if (!Array.isArray(config.include) || config.include.length === 0) {
+        report.operationalErrors.push({
+            code: "config",
+            message: "At least one include pattern is required.",
+        });
+        report.exitCode = 2;
+        report.durationMs = Math.round((performance.now() - startedAt) * 100) / 100;
+        return report;
+    }
+    const includedBeforeExcludes = await discoverFiles(root, config.include);
+    const absolutePaths = await discoverFiles(root, config.include, config.exclude);
+    const selected = new Set(absolutePaths);
+    report.filesIgnored = includedBeforeExcludes
+        .filter((path) => !selected.has(path))
+        .map((path) => ({
+        path: toPosixPath(relative(root, path)),
+        reason: "excluded-by-configuration",
+    }))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    report.filesDiscovered = includedBeforeExcludes.length;
+    if (absolutePaths.length === 0) {
+        report.operationalErrors.push({
+            code: "no-files",
+            message: "No files matched the configured include patterns.",
+        });
+        report.exitCode = 2;
+        report.durationMs = Math.round((performance.now() - startedAt) * 100) / 100;
+        return report;
+    }
+    const readSource = options.readFile ??
+        ((absolutePath) => readFileFromDisk(absolutePath, "utf8"));
+    // The TypeScript API always reads from disk. If rule input comes from
+    // somewhere else, the two would describe different versions of the same file
+    // in one report, so type analysis is refused rather than silently mixed.
+    const typeScriptPaths = options.readFile
+        ? []
+        : absolutePaths.filter((path) => extname(path).toLowerCase() !== ".css");
+    if (options.readFile) {
+        report.operationalErrors.push({
+            code: "internal",
+            message: "Type analysis is unavailable when file reading is overridden.",
+        });
+    }
+    let typeScriptApi;
+    let typeScriptSnapshot;
+    if (typeScriptPaths.length > 0) {
+        try {
+            typeScriptApi = new API({ cwd: root });
+            typeScriptSnapshot = typeScriptApi.updateSnapshot({
+                openFiles: typeScriptPaths,
+            });
+        }
+        catch {
+            typeScriptApi?.close();
+            typeScriptApi = undefined;
+            report.operationalErrors.push({
+                code: "internal",
+                message: "Unable to initialize TypeScript analysis.",
+            });
+        }
+    }
+    for (const absolutePath of absolutePaths) {
+        const path = toPosixPath(relative(root, absolutePath));
+        let content;
+        try {
+            content = await readSource(absolutePath);
+            report.filesRead += 1;
+        }
+        catch {
+            report.operationalErrors.push({
+                code: "read",
+                message: "Unable to read file.",
+                path,
+            });
+            continue;
+        }
+        if (usesDefaultRules &&
+            config.contractSource === "bundled" &&
+            /(?:from\s*|import\s*(?:\(\s*)?)["']@ksmv\/ui-react(?:\/[^"']*)?["']/.test(content) &&
+            !report.operationalErrors.some(({ code, message }) => code === "config" &&
+                message === "React source requires React package contracts.")) {
+            report.operationalErrors.push({
+                code: "config",
+                message: "React source requires React package contracts.",
+                path,
+            });
+        }
+        const file = { content, path };
+        const extension = extname(absolutePath).toLowerCase();
+        try {
+            if (extension === ".css") {
+                file.cssRoot = postcss.parse(content, { from: absolutePath });
+                file.cssRoot.walkDecls(() => {
+                    report.declarationsChecked += 1;
+                });
+            }
+            else {
+                const coverage = scanTypeScript(content, path);
+                file.typescriptTokens = coverage.tokens;
+                const project = typeScriptSnapshot?.getDefaultProjectForFile(absolutePath);
+                if (typeScriptSnapshot && !project) {
+                    throw new Error("parse");
+                }
+                if (project) {
+                    if (project.program.getSyntacticDiagnostics(absolutePath).length > 0) {
+                        throw new Error("parse");
+                    }
+                    file.sourceFile = project.program.getSourceFile(absolutePath);
+                }
+                report.nodesChecked += coverage.nodesChecked;
+                report.uncovered.push(...coverage.uncovered);
+            }
+        }
+        catch {
+            report.operationalErrors.push({
+                code: "parse",
+                message: "Unable to parse file.",
+                path,
+            });
+            continue;
+        }
+        for (const rule of rules) {
+            try {
+                const result = await rule.check(file);
+                report.violations.push(...result.violations);
+                report.uncovered.push(...result.uncovered);
+            }
+            catch {
+                report.operationalErrors.push({
+                    code: "internal",
+                    message: `Rule ${rule.name} could not complete.`,
+                    path,
+                });
+            }
+        }
+    }
+    for (const rule of rules) {
+        if (!rule.complete) {
+            continue;
+        }
+        try {
+            const result = await rule.complete();
+            report.violations.push(...result.violations);
+            report.uncovered.push(...result.uncovered);
+        }
+        catch {
+            report.operationalErrors.push({
+                code: "internal",
+                message: `Rule ${rule.name} could not complete.`,
+            });
+        }
+    }
+    typeScriptSnapshot?.dispose();
+    typeScriptApi?.close();
+    if (options.applyGovernance ?? usesDefaultRules) {
+        await applyDebtControls(report, config);
+    }
+    report.violations.sort(compareFindings);
+    report.baselineMatches.sort(compareFindings);
+    report.uncovered.sort(compareFindings);
+    report.operationalErrors.sort((left, right) => (left.path ?? "").localeCompare(right.path ?? "") ||
+        left.code.localeCompare(right.code));
+    report.exitCode = resolveExitCode(report, config.failOnUncovered ?? true);
+    report.durationMs = Math.round((performance.now() - startedAt) * 100) / 100;
+    return report;
+}