@ksmv/ui-checks 0.1.0

package/dist/color.js

@@ -0,0 +1,192 @@
+import { converter, parse } from "culori";
+import valueParser from "postcss-value-parser";
+const toRgb = converter("rgb");
+const unsupportedFunctions = new Set(["color-mix", "light-dark"]);
+const literalColorFunctions = new Set([
+    "color",
+    "hsl",
+    "hsla",
+    "hwb",
+    "lab",
+    "lch",
+    "oklab",
+    "oklch",
+    "rgb",
+    "rgba",
+]);
+export function isColorBearingProperty(property) {
+    const cssProperty = property
+        .replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)
+        .toLowerCase();
+    return (cssProperty.startsWith("--") ||
+        cssProperty === "color" ||
+        cssProperty.endsWith("-color") ||
+        cssProperty === "background" ||
+        cssProperty === "background-image" ||
+        cssProperty === "border" ||
+        /^(?:border-(?:top|right|bottom|left|block|inline)(?:-(?:start|end))?)$/.test(cssProperty) ||
+        cssProperty === "border-image" ||
+        cssProperty === "border-image-source" ||
+        cssProperty === "outline" ||
+        cssProperty === "box-shadow" ||
+        cssProperty === "text-shadow" ||
+        cssProperty === "fill" ||
+        cssProperty === "stroke" ||
+        cssProperty === "filter" ||
+        cssProperty === "text-decoration" ||
+        cssProperty === "text-emphasis" ||
+        cssProperty === "column-rule");
+}
+function parsedColor(value) {
+    const parsed = parse(value);
+    const color = parsed ? toRgb(parsed) : undefined;
+    if (!color ||
+        !Number.isFinite(color.r) ||
+        !Number.isFinite(color.g) ||
+        !Number.isFinite(color.b) ||
+        (color.alpha !== undefined && !Number.isFinite(color.alpha))) {
+        return undefined;
+    }
+    return {
+        ...color,
+        alpha: color.alpha === undefined
+            ? undefined
+            : Math.min(1, Math.max(0, color.alpha)),
+        b: Math.min(1, Math.max(0, color.b)),
+        g: Math.min(1, Math.max(0, color.g)),
+        r: Math.min(1, Math.max(0, color.r)),
+    };
+}
+function stringifyNodes(nodes) {
+    return valueParser.stringify(nodes).trim();
+}
+function splitVarArguments(nodes) {
+    const comma = nodes.findIndex((node) => node.type === "div" && node.value === ",");
+    return {
+        fallback: comma < 0 ? undefined : stringifyNodes(nodes.slice(comma + 1)),
+        name: stringifyNodes(comma < 0 ? nodes : nodes.slice(0, comma)),
+    };
+}
+export function containsUnsupportedColorFunction(value) {
+    let unsupported = false;
+    valueParser(value).walk((node) => {
+        if (node.type === "function" &&
+            unsupportedFunctions.has(node.value.toLowerCase())) {
+            unsupported = true;
+            return false;
+        }
+        return undefined;
+    });
+    return unsupported;
+}
+export function containsLiteralColor(value) {
+    let literal = false;
+    valueParser(value).walk((node) => {
+        if (node.type === "function" && node.value.toLowerCase() !== "var") {
+            if (literalColorFunctions.has(node.value.toLowerCase()) ||
+                parsedColor(valueParser.stringify(node))) {
+                literal = true;
+                return false;
+            }
+        }
+        if (node.type === "word" &&
+            node.value.toLowerCase() !== "currentcolor" &&
+            node.value.toLowerCase() !== "transparent" &&
+            parsedColor(node.value)) {
+            literal = true;
+            return false;
+        }
+        return undefined;
+    });
+    return literal;
+}
+export function referencedTokens(value) {
+    const references = new Set();
+    valueParser(value).walk((node) => {
+        if (node.type === "function" && node.value === "var") {
+            const { name } = splitVarArguments(node.nodes);
+            if (name.startsWith("--")) {
+                references.add(name);
+            }
+        }
+        return undefined;
+    });
+    return [...references];
+}
+export function unresolvedTokenReferences(value, tokens, stack = new Set()) {
+    const unresolved = new Set();
+    valueParser(value).walk((node) => {
+        if (node.type !== "function" || node.value !== "var") {
+            return undefined;
+        }
+        const { fallback, name } = splitVarArguments(node.nodes);
+        if (!name.startsWith("--")) {
+            return false;
+        }
+        if (stack.has(name)) {
+            unresolved.add(name);
+            return false;
+        }
+        const declared = tokens.get(name);
+        if (declared !== undefined) {
+            for (const reference of unresolvedTokenReferences(declared, tokens, new Set([...stack, name]))) {
+                unresolved.add(reference);
+            }
+        }
+        else if (fallback !== undefined) {
+            for (const reference of unresolvedTokenReferences(fallback, tokens, new Set([...stack, name]))) {
+                unresolved.add(reference);
+            }
+        }
+        else {
+            unresolved.add(name);
+        }
+        return false;
+    });
+    return [...unresolved];
+}
+export function resolveColor(value, tokens, stack = new Set()) {
+    if (!value || containsUnsupportedColorFunction(value)) {
+        return { status: "uncovered" };
+    }
+    const parsedValue = valueParser(value.trim());
+    const meaningful = parsedValue.nodes.filter((node) => node.type !== "space" && node.type !== "comment");
+    if (meaningful.length === 1 &&
+        meaningful[0].type === "function" &&
+        meaningful[0].value === "var") {
+        const { fallback, name } = splitVarArguments(meaningful[0].nodes);
+        if (stack.has(name)) {
+            return { status: "uncovered" };
+        }
+        const next = tokens.get(name) ?? fallback;
+        return resolveColor(next, tokens, new Set([...stack, name]));
+    }
+    const color = parsedColor(value.trim());
+    return color ? { color, status: "resolved" } : { status: "uncovered" };
+}
+function composite(foreground, background) {
+    const alpha = foreground.alpha ?? 1;
+    return {
+        b: foreground.b * alpha + background.b * (1 - alpha),
+        g: foreground.g * alpha + background.g * (1 - alpha),
+        mode: "rgb",
+        r: foreground.r * alpha + background.r * (1 - alpha),
+    };
+}
+function luminance(color) {
+    const channel = (value) => value <= 0.04045
+        ? value / 12.92
+        : ((value + 0.055) / 1.055) ** 2.4;
+    return (0.2126 * channel(color.r) +
+        0.7152 * channel(color.g) +
+        0.0722 * channel(color.b));
+}
+export function contrastRatio(foreground, background) {
+    if ((background.alpha ?? 1) < 1) {
+        return undefined;
+    }
+    const composed = composite(foreground, background);
+    const [lighter, darker] = [luminance(composed), luminance(background)].sort((left, right) => right - left);
+    const ratio = (lighter + 0.05) / (darker + 0.05);
+    return Number.isFinite(ratio) ? ratio : undefined;
+}

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+import type { ContractSource } from "./contracts.js";
+import type { Suppression } from "./result.js";
+export interface ComputedEvidenceRef {
+    file: string;
+    theme: string;
+}
+export interface ThemeConfig {
+    computedEvidence?: ComputedEvidenceRef;
+    files: string[];
+    name: string;
+    selector: string;
+}
+export interface ChecksConfig {
+    baseline?: string;
+    contractSource?: ContractSource;
+    exclude?: string[];
+    failOnUncovered?: boolean;
+    include: string[];
+    root?: string;
+    suppressions?: Suppression[];
+    themes?: ThemeConfig[];
+}
+export declare function defineConfig<const Config extends ChecksConfig>(config: Config): Config;

package/dist/config.js

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+    return config;
+}

package/dist/contracts.d.ts

@@ -0,0 +1,40 @@
+export declare const tokenNamePattern: RegExp;
+export type ContractSource = "bundled" | "@ksmv/ui-react";
+export interface ThemeContract {
+    brandComposition: string[];
+    contractVersion: string;
+    derived: Record<string, string>;
+    prefix: "--ui-";
+    required: string[];
+    schemaVersion: 1;
+}
+export interface ContrastPair {
+    background: string;
+    context: string;
+    foreground: string;
+    minimum: number;
+}
+export interface ContrastManifest {
+    contractVersion: string;
+    pairs: ContrastPair[];
+    schemaVersion: 1;
+}
+export interface ContractIdentity {
+    contractVersion: string;
+    sha256: string;
+}
+export interface ContractSet {
+    contrast: ContrastManifest;
+    identities: {
+        contrast: ContractIdentity;
+        theme: ContractIdentity;
+    };
+    source: ContractSource;
+    theme: ThemeContract;
+}
+export declare function parseThemeContract(content: string): ThemeContract;
+export declare function parseContrastManifest(content: string): ContrastManifest;
+export declare function resolveContractSet({ root, source, }: {
+    root: string;
+    source: ContractSource;
+}): Promise<ContractSet>;

package/dist/contracts.js

@@ -0,0 +1,138 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+export const tokenNamePattern = /^--ui-[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const semverPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function exactKeys(value, keys) {
+    return Object.keys(value).sort().join(",") === [...keys].sort().join(",");
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isTokenList(value) {
+    return Array.isArray(value) && value.every((token) => typeof token === "string" && tokenNamePattern.test(token));
+}
+export function parseThemeContract(content) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch {
+        throw new Error("Unsupported theme contract.");
+    }
+    if (!isRecord(value) ||
+        !exactKeys(value, [
+            "brandComposition",
+            "contractVersion",
+            "derived",
+            "prefix",
+            "required",
+            "schemaVersion",
+        ]) ||
+        value.schemaVersion !== 1 ||
+        value.prefix !== "--ui-" ||
+        typeof value.contractVersion !== "string" ||
+        !semverPattern.test(value.contractVersion) ||
+        !isTokenList(value.required) ||
+        new Set(value.required).size !== value.required.length ||
+        !isTokenList(value.brandComposition) ||
+        new Set(value.brandComposition).size !== value.brandComposition.length ||
+        !isRecord(value.derived) ||
+        Object.entries(value.derived).some(([token, fallback]) => !tokenNamePattern.test(token) ||
+            typeof fallback !== "string" ||
+            !tokenNamePattern.test(fallback))) {
+        throw new Error("Unsupported theme contract.");
+    }
+    return value;
+}
+export function parseContrastManifest(content) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch {
+        throw new Error("Unsupported contrast manifest.");
+    }
+    if (!isRecord(value) ||
+        !exactKeys(value, ["contractVersion", "pairs", "schemaVersion"]) ||
+        value.schemaVersion !== 1 ||
+        typeof value.contractVersion !== "string" ||
+        !semverPattern.test(value.contractVersion) ||
+        !Array.isArray(value.pairs)) {
+        throw new Error("Unsupported contrast manifest.");
+    }
+    const identities = [];
+    for (const pair of value.pairs) {
+        if (!isRecord(pair) ||
+            !exactKeys(pair, ["background", "context", "foreground", "minimum"]) ||
+            typeof pair.background !== "string" ||
+            !tokenNamePattern.test(pair.background) ||
+            typeof pair.foreground !== "string" ||
+            !tokenNamePattern.test(pair.foreground) ||
+            typeof pair.context !== "string" ||
+            pair.context.length === 0 ||
+            typeof pair.minimum !== "number" ||
+            !Number.isFinite(pair.minimum) ||
+            pair.minimum <= 0) {
+            throw new Error("Unsupported contrast manifest.");
+        }
+        identities.push(`${pair.context}\u0000${pair.foreground}\u0000${pair.background}`);
+    }
+    if (new Set(identities).size !== identities.length) {
+        throw new Error("Unsupported contrast manifest.");
+    }
+    return value;
+}
+function identity(content, contractVersion) {
+    return {
+        contractVersion,
+        sha256: `sha256:${createHash("sha256").update(content).digest("hex")}`,
+    };
+}
+async function reactContractPaths(root) {
+    const requireFromRoot = createRequire(resolve(root, "package.json"));
+    try {
+        return {
+            contrast: requireFromRoot.resolve("@ksmv/ui-react/contrast-contract.json"),
+            theme: requireFromRoot.resolve("@ksmv/ui-react/theme-contract.json"),
+        };
+    }
+    catch {
+        throw new Error("Unable to resolve the configured contract source.");
+    }
+}
+export async function resolveContractSet({ root, source, }) {
+    try {
+        const paths = source === "bundled"
+            ? {
+                contrast: new URL("./contrast-contract.json", import.meta.url),
+                theme: new URL("./theme-contract.json", import.meta.url),
+            }
+            : await reactContractPaths(root);
+        const [contrastContent, themeContent] = await Promise.all([
+            readFile(paths.contrast, "utf8"),
+            readFile(paths.theme, "utf8"),
+        ]);
+        const contrast = parseContrastManifest(contrastContent);
+        const theme = parseThemeContract(themeContent);
+        return {
+            contrast,
+            identities: {
+                contrast: identity(contrastContent, contrast.contractVersion),
+                theme: identity(themeContent, theme.contractVersion),
+            },
+            source,
+            theme,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            (error.message === "Unsupported theme contract." ||
+                error.message === "Unsupported contrast manifest." ||
+                error.message === "Unable to resolve the configured contract source.")) {
+            throw error;
+        }
+        throw new Error("Unable to resolve the configured contract source.");
+    }
+}

package/dist/contrast-contract.json

@@ -0,0 +1,38 @@
+{
+  "contractVersion": "1.0.0",
+  "schemaVersion": 1,
+  "pairs": [
+    { "foreground": "--ui-action-primary-text", "background": "--ui-action-primary-bg", "minimum": 4.5, "context": "normal-text" },
+    { "foreground": "--ui-action-primary-text", "background": "--ui-action-primary-bg-hover", "minimum": 4.5, "context": "normal-text-hover" },
+    { "foreground": "--ui-action-primary-text", "background": "--ui-action-primary-bg-active", "minimum": 4.5, "context": "normal-text-active" },
+    { "foreground": "--ui-action-secondary-text", "background": "--ui-action-secondary-bg", "minimum": 4.5, "context": "normal-text" },
+    { "foreground": "--ui-action-secondary-text", "background": "--ui-action-secondary-bg-hover", "minimum": 4.5, "context": "normal-text-hover" },
+    { "foreground": "--ui-action-secondary-text", "background": "--ui-action-secondary-bg-active", "minimum": 4.5, "context": "normal-text-active" },
+    { "foreground": "--ui-action-danger-text", "background": "--ui-action-danger-bg", "minimum": 4.5, "context": "normal-text" },
+    { "foreground": "--ui-action-danger-text", "background": "--ui-action-danger-bg-hover", "minimum": 4.5, "context": "normal-text-hover" },
+    { "foreground": "--ui-action-danger-text", "background": "--ui-action-danger-bg-active", "minimum": 4.5, "context": "normal-text-active" },
+    { "foreground": "--ui-action-ghost-text", "background": "--ui-surface", "minimum": 4.5, "context": "normal-text" },
+    { "foreground": "--ui-action-ghost-text", "background": "--ui-action-ghost-bg-hover", "minimum": 4.5, "context": "normal-text-hover" },
+    { "foreground": "--ui-action-ghost-text", "background": "--ui-action-ghost-bg-active", "minimum": 4.5, "context": "normal-text-active" },
+    { "foreground": "--ui-status-success-text", "background": "--ui-status-success-bg", "minimum": 4.5, "context": "status-text" },
+    { "foreground": "--ui-status-success", "background": "--ui-status-success-bg", "minimum": 3, "context": "status-indicator" },
+    { "foreground": "--ui-status-warning-text", "background": "--ui-status-warning-bg", "minimum": 4.5, "context": "status-text" },
+    { "foreground": "--ui-status-warning", "background": "--ui-status-warning-bg", "minimum": 3, "context": "status-indicator" },
+    { "foreground": "--ui-status-danger-text", "background": "--ui-status-danger-bg", "minimum": 4.5, "context": "status-text" },
+    { "foreground": "--ui-status-danger", "background": "--ui-status-danger-bg", "minimum": 3, "context": "status-indicator" },
+    { "foreground": "--ui-status-info-text", "background": "--ui-status-info-bg", "minimum": 4.5, "context": "status-text" },
+    { "foreground": "--ui-status-info", "background": "--ui-status-info-bg", "minimum": 3, "context": "status-indicator" },
+    { "foreground": "--ui-status-success", "background": "--ui-surface", "minimum": 3, "context": "status-indicator-on-surface" },
+    { "foreground": "--ui-status-warning", "background": "--ui-surface", "minimum": 3, "context": "status-indicator-on-surface" },
+    { "foreground": "--ui-status-danger", "background": "--ui-surface", "minimum": 3, "context": "status-indicator-on-surface" },
+    { "foreground": "--ui-status-info", "background": "--ui-surface", "minimum": 3, "context": "status-indicator-on-surface" },
+    { "foreground": "--ui-status-info", "background": "--ui-border", "minimum": 3, "context": "loading-indicator" },
+    { "foreground": "--ui-status-danger-text", "background": "--ui-surface", "minimum": 4.5, "context": "field-error-text" },
+    { "foreground": "--ui-status-danger", "background": "--ui-surface", "minimum": 3, "context": "invalid-control-boundary" },
+    { "foreground": "--ui-status-info", "background": "--ui-surface-subtle", "minimum": 3, "context": "progress-indicator" },
+    { "foreground": "--ui-text-inverse", "background": "--ui-surface-inverse", "minimum": 4.5, "context": "inverse-text" },
+    { "foreground": "--ui-border-control", "background": "--ui-surface", "minimum": 3, "context": "control-boundary" },
+    { "foreground": "--ui-focus-ring", "background": "--ui-surface", "minimum": 3, "context": "focus-indicator" },
+    { "foreground": "--ui-focus-ring", "background": "--ui-focus-ring-offset", "minimum": 3, "context": "focus-indicator" }
+  ]
+}

package/dist/evidence.d.ts

@@ -0,0 +1,24 @@
+import type { ThemeConfig } from "./config.js";
+import { type ContractIdentity, type ContractSet } from "./contracts.js";
+export interface ThemeEvidence {
+    capturedAt: string;
+    contracts: {
+        contrast: ContractIdentity;
+        theme: ContractIdentity;
+    };
+    schemaVersion: 1;
+    selectors: string[];
+    sourceHash: string;
+    themes: Record<string, {
+        selector: string;
+        tokens: Record<string, string>;
+    }>;
+}
+export declare function computeThemeSourceHash(root: string, files: string[]): Promise<string>;
+export declare function loadComputedEvidence({ contracts, evidenceByPath, now, root, themes, }: {
+    contracts: ContractSet;
+    evidenceByPath?: Map<string, ThemeEvidence>;
+    now?: Date;
+    root: string;
+    themes: ThemeConfig[];
+}): Promise<Record<string, Record<string, string>>>;

package/dist/evidence.js

@@ -0,0 +1,132 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import { tokenNamePattern, } from "./contracts.js";
+function normalizedFiles(root, files) {
+    return [...new Set(files.map((file) => file.replaceAll("\\", "/")))]
+        .sort()
+        .map((file) => {
+        const absolute = resolve(root, file);
+        const fromRoot = relative(root, absolute).replaceAll("\\", "/");
+        if (isAbsolute(file) ||
+            fromRoot === ".." ||
+            fromRoot.startsWith("../")) {
+            throw new Error("Invalid computed theme evidence.");
+        }
+        return { absolute, path: fromRoot };
+    });
+}
+export async function computeThemeSourceHash(root, files) {
+    const hash = createHash("sha256");
+    for (const file of normalizedFiles(root, files)) {
+        hash.update(file.path);
+        hash.update("\0");
+        hash.update(await readFile(file.absolute));
+        hash.update("\0");
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+function exactKeys(value, keys) {
+    return Object.keys(value).sort().join(",") === [...keys].sort().join(",");
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function sameIdentity(actual, expected) {
+    return isRecord(actual) &&
+        exactKeys(actual, ["contractVersion", "sha256"]) &&
+        actual.contractVersion === expected.contractVersion &&
+        actual.sha256 === expected.sha256;
+}
+function requiredEvidenceTokens(contracts) {
+    return new Set([
+        ...contracts.theme.required,
+        ...Object.keys(contracts.theme.derived),
+        ...Object.values(contracts.theme.derived),
+        ...contracts.contrast.pairs.flatMap(({ background, foreground }) => [
+            background,
+            foreground,
+        ]),
+    ]);
+}
+function validateEvidenceShape(value, contracts) {
+    if (!isRecord(value) ||
+        !exactKeys(value, [
+            "capturedAt",
+            "contracts",
+            "schemaVersion",
+            "selectors",
+            "sourceHash",
+            "themes",
+        ]) ||
+        value.schemaVersion !== 1 ||
+        typeof value.capturedAt !== "string" ||
+        !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value.capturedAt) ||
+        typeof value.sourceHash !== "string" ||
+        !/^sha256:[a-f0-9]{64}$/.test(value.sourceHash) ||
+        !Array.isArray(value.selectors) ||
+        value.selectors.some((selector) => typeof selector !== "string") ||
+        !isRecord(value.contracts) ||
+        !exactKeys(value.contracts, ["contrast", "theme"]) ||
+        !sameIdentity(value.contracts.contrast, contracts.identities.contrast) ||
+        !sameIdentity(value.contracts.theme, contracts.identities.theme) ||
+        !isRecord(value.themes)) {
+        return false;
+    }
+    return Object.values(value.themes).every((theme) => isRecord(theme) &&
+        exactKeys(theme, ["selector", "tokens"]) &&
+        typeof theme.selector === "string" &&
+        isRecord(theme.tokens) &&
+        Object.entries(theme.tokens).every(([token, tokenValue]) => tokenNamePattern.test(token) &&
+            typeof tokenValue === "string" &&
+            tokenValue.trim().length > 0 &&
+            !/var\s*\(/i.test(tokenValue)));
+}
+export async function loadComputedEvidence({ contracts, evidenceByPath, now = new Date(), root, themes, }) {
+    try {
+        const configured = themes.filter((theme) => theme.computedEvidence);
+        const grouped = new Map();
+        for (const theme of configured) {
+            const path = theme.computedEvidence.file.replaceAll("\\", "/");
+            grouped.set(path, [...(grouped.get(path) ?? []), theme]);
+        }
+        const result = {};
+        const requiredTokens = requiredEvidenceTokens(contracts);
+        for (const [path, group] of grouped) {
+            const injected = evidenceByPath?.get(path);
+            const evidence = injected ?? JSON.parse(await readFile(resolve(root, path), "utf8"));
+            if (!validateEvidenceShape(evidence, contracts)) {
+                throw new Error("shape");
+            }
+            const capturedAt = new Date(evidence.capturedAt);
+            if (!Number.isFinite(capturedAt.valueOf()) || capturedAt > now) {
+                throw new Error("time");
+            }
+            const selectors = [...new Set(group.map(({ selector }) => selector))].sort();
+            if ([...new Set(evidence.selectors)].sort().join("\0") !== selectors.join("\0")) {
+                throw new Error("selectors");
+            }
+            const files = [...new Set(group.flatMap(({ files }) => files))];
+            if (evidence.sourceHash !== await computeThemeSourceHash(root, files)) {
+                throw new Error("source");
+            }
+            for (const theme of group) {
+                const name = theme.computedEvidence.theme;
+                const computedTheme = evidence.themes[name];
+                if (!computedTheme || computedTheme.selector !== theme.selector) {
+                    throw new Error("theme");
+                }
+                for (const token of requiredTokens) {
+                    if (computedTheme.tokens[token] === undefined) {
+                        throw new Error("tokens");
+                    }
+                }
+                result[theme.name] = { ...computedTheme.tokens };
+            }
+        }
+        return result;
+    }
+    catch {
+        throw new Error("Invalid computed theme evidence.");
+    }
+}

package/dist/governance.d.ts

@@ -0,0 +1,9 @@
+import type { ChecksConfig } from "./config.js";
+import type { CheckReport, Violation } from "./result.js";
+export declare function resolveReportExitCode(report: CheckReport, failOnUncovered: boolean): 0 | 1 | 2;
+export declare function applyConfiguredSuppressions(report: CheckReport, config: ChecksConfig): {
+    issues: Violation[];
+    valid: boolean;
+};
+export declare function applyConfiguredBaseline(report: CheckReport, config: ChecksConfig, issues: Violation[]): Promise<void>;
+export declare function applyDebtControls(report: CheckReport, config: ChecksConfig): Promise<void>;