design-constraint-validator 1.0.0

package/cli/commands/validate.d.ts

@@ -0,0 +1,3 @@
+import type { ValidateOptions } from '../types.js';
+export declare function validateCommand(_options: ValidateOptions): Promise<void>;
+//# sourceMappingURL=validate.d.ts.map

package/cli/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["validate.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,wBAAsB,eAAe,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA0G9E"}

package/cli/commands/validate.js

@@ -0,0 +1,131 @@
+import { flattenTokens } from '../../core/flatten.js';
+import { createValidationEngine } from '../engine-helpers.js';
+import { loadConfig } from '../config.js';
+import { parseBreakpoints, loadTokensWithBreakpoint } from '../../core/breakpoints.js';
+import { loadCrossAxisPlugin } from '../../core/cross-axis-config.js';
+export async function validateCommand(_options) {
+    try {
+        const bps = parseBreakpoints(process.argv);
+        const crossAxisDebug = process.argv.includes('--cross-axis-debug');
+        const plan = bps.length ? bps : [undefined];
+        let anyErrors = false;
+        let totalErrors = 0;
+        let totalWarnings = 0;
+        const argv = process.argv.slice(2);
+        const failOnIdx = argv.indexOf('--fail-on');
+        const failOn = failOnIdx >= 0 ? argv[failOnIdx + 1] : 'error';
+        const sumIdx = argv.indexOf('--summary');
+        const summaryFmt = sumIdx >= 0 ? argv[sumIdx + 1] : 'none';
+        const rows = [];
+        function pushRow(bpLabel, stats) { rows.push({ bp: bpLabel, ...stats }); }
+        function printSummaryTable(rs) {
+            if (!rs.length)
+                return;
+            const showTotalLine = !rs.some(r => r.bp === 'TOTAL');
+            const cols = ['scope', 'rules', 'warnings', 'errors'];
+            const data = rs.map(r => ({ scope: r.bp, rules: String(r.rules), warnings: String(r.warnings), errors: String(r.errors) }));
+            const widths = cols.map(c => Math.max(c.length, ...data.map(d => d[c].length)));
+            const line = (vals) => vals.map((v, i) => v.padEnd(widths[i])).join('  ');
+            console.log(line(cols));
+            console.log(line(widths.map(w => '-'.repeat(w))));
+            for (const d of data)
+                console.log(line(cols.map(c => d[c])));
+            if (showTotalLine && rs.length > 1) {
+                const tot = rs.reduce((a, b) => ({ rules: a.rules + b.rules, warnings: a.warnings + b.warnings, errors: a.errors + b.errors }), { rules: 0, warnings: 0, errors: 0 });
+                console.log(line(['TOTAL', String(tot.rules), String(tot.warnings), String(tot.errors)]));
+            }
+        }
+        const cfgRes = loadConfig(_options.config);
+        if (!cfgRes.ok) {
+            console.error(cfgRes.error);
+            process.exit(2);
+        }
+        const config = cfgRes.value;
+        const perBpTimings = [];
+        const tStartTotal = globalThis.performance.now();
+        for (const bp of plan) {
+            const tStart = globalThis.performance.now();
+            const tokens = loadTokensWithBreakpoint(bp);
+            const engine = createValidationEngine(tokens, bp, config);
+            const initIds = Object.keys(flattenTokens(tokens).flat).reduce((a, k) => { a[k] = true; return a; }, {});
+            const knownIds = new Set(Object.keys(initIds));
+            // Load global + bp-specific cross-axis rules (bp file optional)
+            engine.use(loadCrossAxisPlugin('themes/cross-axis.rules.json', bp, { debug: crossAxisDebug, knownIds }));
+            if (bp) {
+                const bpRulesPath = `themes/cross-axis.${bp}.rules.json`;
+                engine.use(loadCrossAxisPlugin(bpRulesPath, bp, { debug: crossAxisDebug, knownIds }));
+            }
+            const { ThresholdPlugin } = await import('../../core/constraints/threshold.js');
+            engine.use(ThresholdPlugin([{ id: 'control.size.min', op: '>=', valuePx: 44, where: 'Touch target (WCAG / Apple HIG)' }]));
+            const allIds = new Set(Object.keys(initIds));
+            const issues = engine.evaluate(allIds);
+            const errs = issues.filter((i) => i.level === 'error');
+            const warns = issues.filter((i) => i.level !== 'error');
+            if (errs.length)
+                anyErrors = true;
+            totalErrors += errs.length;
+            totalWarnings += warns.length;
+            const rulesEvaluated = errs.length + warns.length;
+            pushRow(bp ?? 'global', { rules: rulesEvaluated, warnings: warns.length, errors: errs.length });
+            const dur = globalThis.performance.now() - tStart;
+            perBpTimings.push({ bp: bp ?? 'global', ms: dur });
+            console.log(`validate${bp ? ` [bp=${bp}]` : ''}: ${errs.length} error(s), ${warns.length} warning(s)${_options.perf ? ` (${dur.toFixed(2)}ms)` : ''}`);
+            for (const it of issues) {
+                const tag = it.level === 'error' ? 'ERROR' : 'WARN ';
+                console.log(`${tag} ${it.rule}  ${it.id}${it.where ? ' @ ' + it.where : ''}${bp ? ` [${bp}]` : ''} — ${it.message}`);
+            }
+        }
+        const totalMs = globalThis.performance.now() - tStartTotal;
+        // Append aggregate total row if multiple scopes and not already added
+        if (rows.length > 1) {
+            const agg = rows.reduce((a, b) => ({ rules: a.rules + b.rules, warnings: a.warnings + b.warnings, errors: a.errors + b.errors }), { rules: 0, warnings: 0, errors: 0 });
+            rows.push({ bp: 'TOTAL', ...agg });
+        }
+        if (_options.perf) {
+            console.log('[perf] per-breakpoint timings:');
+            for (const t of perBpTimings)
+                console.log(`  ${t.bp}: ${t.ms.toFixed(2)}ms`);
+            console.log(`[perf] total: ${totalMs.toFixed(2)}ms`);
+        }
+        if (summaryFmt === 'json') {
+            // Provide machine-readable aggregate separate from rows if TOTAL present
+            const totalRow = rows.find(r => r.bp === 'TOTAL');
+            const json = totalRow ? { rows, total: { rules: totalRow.rules, warnings: totalRow.warnings, errors: totalRow.errors } } : { rows };
+            console.log(JSON.stringify(json, null, 2));
+        }
+        else if (summaryFmt === 'table') {
+            printSummaryTable(rows);
+        }
+        let code = anyErrors ? 1 : 0;
+        // Budget checks (do not override fail-on semantics unless budgets add failures)
+        const budgetTotal = _options['budget-total-ms'] ?? _options.budgetTotalMs;
+        const budgetPerBp = _options['budget-per-bp-ms'] ?? _options.budgetPerBpMs;
+        let budgetFailed = false;
+        if (budgetTotal != null && totalMs > budgetTotal) {
+            console.error(`[perf] total time ${totalMs.toFixed(2)}ms exceeded budget ${budgetTotal}ms`);
+            budgetFailed = true;
+        }
+        if (budgetPerBp != null) {
+            for (const t of perBpTimings) {
+                if (t.ms > budgetPerBp) {
+                    console.error(`[perf] ${t.bp} time ${t.ms.toFixed(2)}ms exceeded per-breakpoint budget ${budgetPerBp}ms`);
+                    budgetFailed = true;
+                }
+            }
+        }
+        if (failOn === 'off')
+            code = 0;
+        else if (failOn === 'warn')
+            code = (totalErrors + totalWarnings) > 0 ? 1 : 0;
+        else
+            code = totalErrors > 0 ? 1 : 0;
+        if (budgetFailed)
+            code = Math.max(code, 1);
+        process.exit(code);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error('validate: failed:', msg);
+        process.exit(2);
+    }
+}

package/cli/commands/validate.ts

@@ -0,0 +1,115 @@
+import { flattenTokens } from '../../core/flatten.js';
+import { createValidationEngine } from '../engine-helpers.js';
+import { loadConfig } from '../config.js';
+import { parseBreakpoints, loadTokensWithBreakpoint, type Breakpoint } from '../../core/breakpoints.js';
+import { loadCrossAxisPlugin } from '../../core/cross-axis-config.js';
+import type { ConstraintIssue } from '../../core/engine.js';
+import type { ValidateOptions } from '../types.js';
+
+export async function validateCommand(_options: ValidateOptions): Promise<void> {
+  try {
+    const bps = parseBreakpoints(process.argv);
+    const crossAxisDebug = process.argv.includes('--cross-axis-debug');
+    const plan: (Breakpoint | undefined)[] = bps.length ? bps : [undefined];
+    let anyErrors = false; let totalErrors = 0; let totalWarnings = 0;
+    const argv = process.argv.slice(2);
+    const failOnIdx = argv.indexOf('--fail-on');
+    type FailOn = 'off' | 'warn' | 'error';
+    const failOn: FailOn = failOnIdx >= 0 ? (argv[failOnIdx + 1] as FailOn) : 'error';
+    const sumIdx = argv.indexOf('--summary');
+    type SummaryFmt = 'table' | 'json' | 'none';
+    const summaryFmt: SummaryFmt = sumIdx >= 0 ? (argv[sumIdx + 1] as SummaryFmt) : 'none';
+    type VRow = { bp: string; rules: number; warnings: number; errors: number };
+    const rows: VRow[] = [];
+    function pushRow(bpLabel: string, stats: { rules: number; warnings: number; errors: number }) { rows.push({ bp: bpLabel, ...stats }); }
+    function printSummaryTable(rs: VRow[]) {
+      if (!rs.length) return;
+      const showTotalLine = !rs.some(r => r.bp === 'TOTAL');
+      const cols = ['scope','rules','warnings','errors'] as const;
+      const data = rs.map(r => ({ scope: r.bp, rules: String(r.rules), warnings: String(r.warnings), errors: String(r.errors) }));
+      const widths = cols.map(c => Math.max(c.length, ...data.map(d => d[c].length)));
+      const line = (vals: string[]) => vals.map((v,i)=>v.padEnd(widths[i])).join('  ');
+      console.log(line(cols as unknown as string[]));
+      console.log(line(widths.map(w => '-'.repeat(w))));
+      for (const d of data) console.log(line(cols.map(c => d[c])));
+      if (showTotalLine && rs.length > 1) {
+        const tot = rs.reduce((a,b)=>({ rules:a.rules+b.rules, warnings:a.warnings+b.warnings, errors:a.errors+b.errors }), { rules:0,warnings:0,errors:0 });
+        console.log(line(['TOTAL', String(tot.rules), String(tot.warnings), String(tot.errors)]));
+      }
+    }
+    const cfgRes = loadConfig(_options.config);
+    if (!cfgRes.ok) { console.error(cfgRes.error); process.exit(2); }
+    const config = cfgRes.value;
+    const perBpTimings: Array<{ bp: string; ms: number }> = [];
+    const tStartTotal = globalThis.performance.now();
+    for (const bp of plan) {
+      const tStart = globalThis.performance.now();
+      const tokens = loadTokensWithBreakpoint(bp);
+      const engine = createValidationEngine(tokens, bp, config);
+      const initIds = Object.keys(flattenTokens(tokens).flat).reduce<Record<string, true>>((a,k)=>{a[k]=true;return a;},{});
+      const knownIds = new Set(Object.keys(initIds));
+      // Load global + bp-specific cross-axis rules (bp file optional)
+      engine.use(loadCrossAxisPlugin('themes/cross-axis.rules.json', bp, { debug: crossAxisDebug, knownIds }));
+      if (bp) {
+        const bpRulesPath = `themes/cross-axis.${bp}.rules.json`;
+        engine.use(loadCrossAxisPlugin(bpRulesPath, bp, { debug: crossAxisDebug, knownIds }));
+      }
+      const { ThresholdPlugin } = await import('../../core/constraints/threshold.js');
+      engine.use(ThresholdPlugin([{ id: 'control.size.min', op: '>=', valuePx: 44, where: 'Touch target (WCAG / Apple HIG)' }]));
+      const allIds = new Set(Object.keys(initIds));
+      const issues = engine.evaluate(allIds);
+      const errs = issues.filter((i: ConstraintIssue) => i.level === 'error');
+      const warns = issues.filter((i: ConstraintIssue) => i.level !== 'error');
+      if (errs.length) anyErrors = true;
+      totalErrors += errs.length; totalWarnings += warns.length;
+      const rulesEvaluated = errs.length + warns.length; pushRow(bp ?? 'global', { rules: rulesEvaluated, warnings: warns.length, errors: errs.length });
+      const dur = globalThis.performance.now() - tStart;
+      perBpTimings.push({ bp: bp ?? 'global', ms: dur });
+      console.log(`validate${bp ? ` [bp=${bp}]` : ''}: ${errs.length} error(s), ${warns.length} warning(s)${_options.perf ? ` (${dur.toFixed(2)}ms)` : ''}`);
+      for (const it of issues) { const tag = it.level === 'error' ? 'ERROR' : 'WARN '; console.log(`${tag} ${it.rule}  ${it.id}${it.where ? ' @ ' + it.where : ''}${bp ? ` [${bp}]` : ''} — ${it.message}`); }
+    }
+    const totalMs = globalThis.performance.now() - tStartTotal;
+    // Append aggregate total row if multiple scopes and not already added
+    if (rows.length > 1) {
+      const agg = rows.reduce((a,b)=>({ rules:a.rules+b.rules, warnings:a.warnings+b.warnings, errors:a.errors+b.errors }), { rules:0,warnings:0,errors:0 });
+      rows.push({ bp: 'TOTAL', ...agg });
+    }
+    if (_options.perf) {
+      console.log('[perf] per-breakpoint timings:');
+      for (const t of perBpTimings) console.log(`  ${t.bp}: ${t.ms.toFixed(2)}ms`);
+      console.log(`[perf] total: ${totalMs.toFixed(2)}ms`);
+    }
+    if (summaryFmt === 'json') {
+      // Provide machine-readable aggregate separate from rows if TOTAL present
+      const totalRow = rows.find(r => r.bp === 'TOTAL');
+      const json = totalRow ? { rows, total: { rules: totalRow.rules, warnings: totalRow.warnings, errors: totalRow.errors } } : { rows };
+      console.log(JSON.stringify(json, null, 2));
+    } else if (summaryFmt === 'table') {
+      printSummaryTable(rows);
+    }
+    let code = anyErrors ? 1 : 0;
+    // Budget checks (do not override fail-on semantics unless budgets add failures)
+    const budgetTotal = (_options as any)['budget-total-ms'] ?? _options.budgetTotalMs;
+    const budgetPerBp = (_options as any)['budget-per-bp-ms'] ?? _options.budgetPerBpMs;
+    let budgetFailed = false;
+    if (budgetTotal != null && totalMs > budgetTotal) {
+      console.error(`[perf] total time ${totalMs.toFixed(2)}ms exceeded budget ${budgetTotal}ms`);
+      budgetFailed = true;
+    }
+    if (budgetPerBp != null) {
+      for (const t of perBpTimings) {
+        if (t.ms > budgetPerBp) {
+          console.error(`[perf] ${t.bp} time ${t.ms.toFixed(2)}ms exceeded per-breakpoint budget ${budgetPerBp}ms`);
+          budgetFailed = true;
+        }
+      }
+    }
+    if (failOn === 'off') code = 0; else if (failOn === 'warn') code = (totalErrors + totalWarnings) > 0 ? 1 : 0; else code = totalErrors > 0 ? 1 : 0;
+    if (budgetFailed) code = Math.max(code, 1);
+    process.exit(code);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error('validate: failed:', msg);
+    process.exit(2);
+  }
+}

package/cli/commands/why.d.ts

@@ -0,0 +1,3 @@
+import type { WhyOptions } from '../types.js';
+export declare function whyCommand(options: WhyOptions): Promise<void>;
+//# sourceMappingURL=why.d.ts.map

package/cli/commands/why.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"why.d.ts","sourceRoot":"","sources":["why.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,wBAAsB,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAuCnE"}

package/cli/commands/why.js

@@ -0,0 +1,64 @@
+import { readFileSync } from 'node:fs';
+import { flattenTokens } from '../../core/flatten.js';
+import { explain } from '../../core/why.js';
+import { loadTokens } from './utils.js';
+export async function whyCommand(options) {
+    const tokensPath = options.tokens || 'tokens/tokens.json';
+    const tokens = loadTokens(tokensPath);
+    const { flat, edges } = flattenTokens(tokens);
+    const target = options.tokenId;
+    if (!flat[target]) {
+        console.error(`❌ Token not found: ${target}`);
+        const { suggestIds } = await import('../../core/cli-format.js');
+        const suggestions = suggestIds(target, Object.keys(flat));
+        if (suggestions.length > 0) {
+            console.log(`\nDid you mean:`);
+            suggestions.slice(0, 5).forEach(s => console.log(`  ${s.id}`));
+        }
+        else {
+            console.log(`\nAvailable tokens:`);
+            Object.keys(flat).sort().slice(0, 10).forEach(id => console.log(`  ${id}`));
+            if (Object.keys(flat).length > 10)
+                console.log(`  ... and ${Object.keys(flat).length - 10} more`);
+        }
+        process.exit(1);
+    }
+    function safeLoad(p) { try {
+        return JSON.parse(readFileSync(p, 'utf8'));
+    }
+    catch {
+        return {};
+    } }
+    const overrides = safeLoad('tokens/overrides/local.json');
+    const theme = safeLoad('themes/theme.json');
+    const report = explain(target, flat, edges, { overrides: overrides?.overrides ?? overrides, theme });
+    const format = options.format || 'json';
+    if (format === 'table') {
+        const { pad, trunc } = await import('../../core/cli-format.js');
+        console.log(`\n=== Token Analysis: ${target} ===`);
+        console.log(`Value: ${report.value}`);
+        console.log(`Raw: ${report.raw || 'N/A'}`);
+        console.log(`Provenance: ${report.provenance}`);
+        if (report.dependsOn && report.dependsOn.length > 0) {
+            console.log(`\nDependencies (${report.dependsOn.length}):`);
+            console.log(pad('TOKEN', 30) + pad('VALUE', 20) + 'TYPE');
+            console.log('-'.repeat(70));
+            report.dependsOn.forEach((depId) => { const dep = flat[depId]; if (dep)
+                console.log(pad(trunc(depId, 28), 30) + pad(trunc(String(dep.value), 18), 20) + (dep.type || 'unknown')); });
+        }
+        if (report.dependents && report.dependents.length > 0) {
+            console.log(`\nDependents (${report.dependents.length}):`);
+            console.log(pad('TOKEN', 30) + pad('VALUE', 20) + 'TYPE');
+            console.log('-'.repeat(70));
+            report.dependents.forEach((depId) => { const dep = flat[depId]; if (dep)
+                console.log(pad(trunc(depId, 28), 30) + pad(trunc(String(dep.value), 18), 20) + (dep.type || 'unknown')); });
+        }
+        if (report.refs && report.refs.length > 0)
+            console.log(`\nReferences: ${report.refs.join(', ')}`);
+        if (report.chain && report.chain.length > 0)
+            console.log(`\nReference Chain: ${report.chain.join(' → ')}`);
+    }
+    else {
+        console.log(JSON.stringify(report, null, 2));
+    }
+}

package/cli/commands/why.ts

@@ -0,0 +1,46 @@
+import { readFileSync } from 'node:fs';
+import { flattenTokens } from '../../core/flatten.js';
+import { explain } from '../../core/why.js';
+import type { WhyOptions } from '../types.js';
+import { loadTokens } from './utils.js';
+
+export async function whyCommand(options: WhyOptions): Promise<void> {
+  const tokensPath = options.tokens || 'tokens/tokens.json';
+  const tokens = loadTokens(tokensPath);
+  const { flat, edges } = flattenTokens(tokens);
+  const target = options.tokenId;
+  if (!flat[target]) {
+    console.error(`❌ Token not found: ${target}`);
+    const { suggestIds } = await import('../../core/cli-format.js');
+    const suggestions = suggestIds(target, Object.keys(flat));
+    if (suggestions.length > 0) {
+      console.log(`\nDid you mean:`); suggestions.slice(0, 5).forEach(s => console.log(`  ${s.id}`));
+    } else {
+      console.log(`\nAvailable tokens:`); Object.keys(flat).sort().slice(0, 10).forEach(id => console.log(`  ${id}`));
+      if (Object.keys(flat).length > 10) console.log(`  ... and ${Object.keys(flat).length - 10} more`);
+    }
+    process.exit(1);
+  }
+  function safeLoad(p: string) { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return {}; } }
+  const overrides = safeLoad('tokens/overrides/local.json');
+  const theme = safeLoad('themes/theme.json');
+  const report = explain(target, flat, edges, { overrides: overrides?.overrides ?? overrides, theme });
+  const format = options.format || 'json';
+  if (format === 'table') {
+    const { pad, trunc } = await import('../../core/cli-format.js');
+    console.log(`\n=== Token Analysis: ${target} ===`);
+    console.log(`Value: ${report.value}`); console.log(`Raw: ${report.raw || 'N/A'}`); console.log(`Provenance: ${report.provenance}`);
+    if (report.dependsOn && report.dependsOn.length > 0) {
+      console.log(`\nDependencies (${report.dependsOn.length}):`); console.log(pad('TOKEN', 30) + pad('VALUE', 20) + 'TYPE'); console.log('-'.repeat(70));
+      report.dependsOn.forEach((depId: string) => { const dep = flat[depId]; if (dep) console.log(pad(trunc(depId, 28), 30) + pad(trunc(String(dep.value), 18), 20) + (dep.type || 'unknown')); });
+    }
+    if (report.dependents && report.dependents.length > 0) {
+      console.log(`\nDependents (${report.dependents.length}):`); console.log(pad('TOKEN', 30) + pad('VALUE', 20) + 'TYPE'); console.log('-'.repeat(70));
+      report.dependents.forEach((depId: string) => { const dep = flat[depId]; if (dep) console.log(pad(trunc(depId, 28), 30) + pad(trunc(String(dep.value), 18), 20) + (dep.type || 'unknown')); });
+    }
+    if (report.refs && report.refs.length > 0) console.log(`\nReferences: ${report.refs.join(', ')}`);
+    if (report.chain && report.chain.length > 0) console.log(`\nReference Chain: ${report.chain.join(' → ')}`);
+  } else {
+    console.log(JSON.stringify(report, null, 2));
+  }
+}

package/cli/config-schema.d.ts

@@ -0,0 +1,238 @@
+import { z } from 'zod';
+export declare const WcagRuleSchema: z.ZodObject<{
+    foreground: z.ZodString;
+    background: z.ZodString;
+    ratio: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    foreground: string;
+    background: string;
+    description?: string | undefined;
+    ratio?: number | undefined;
+}, {
+    foreground: string;
+    background: string;
+    description?: string | undefined;
+    ratio?: number | undefined;
+}>;
+export declare const ConstraintsSchema: z.ZodObject<{
+    wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        foreground: z.ZodString;
+        background: z.ZodString;
+        ratio: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        foreground: string;
+        background: string;
+        description?: string | undefined;
+        ratio?: number | undefined;
+    }, {
+        foreground: string;
+        background: string;
+        description?: string | undefined;
+        ratio?: number | undefined;
+    }>, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        foreground: z.ZodString;
+        background: z.ZodString;
+        ratio: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        foreground: string;
+        background: string;
+        description?: string | undefined;
+        ratio?: number | undefined;
+    }, {
+        foreground: string;
+        background: string;
+        description?: string | undefined;
+        ratio?: number | undefined;
+    }>, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        foreground: z.ZodString;
+        background: z.ZodString;
+        ratio: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        foreground: string;
+        background: string;
+        description?: string | undefined;
+        ratio?: number | undefined;
+    }, {
+        foreground: string;
+        background: string;
+        description?: string | undefined;
+        ratio?: number | undefined;
+    }>, "many">>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const DcvConfigSchema: z.ZodObject<{
+    version: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            foreground: z.ZodString;
+            background: z.ZodString;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            foreground: z.ZodString;
+            background: z.ZodString;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            foreground: z.ZodString;
+            background: z.ZodString;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    version: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            foreground: z.ZodString;
+            background: z.ZodString;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            foreground: z.ZodString;
+            background: z.ZodString;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            foreground: z.ZodString;
+            background: z.ZodString;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    version: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            foreground: z.ZodString;
+            background: z.ZodString;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            foreground: z.ZodString;
+            background: z.ZodString;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        wcag: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            foreground: z.ZodString;
+            background: z.ZodString;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }, {
+            foreground: string;
+            background: string;
+            description?: string | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type DcvConfigParsed = z.infer<typeof DcvConfigSchema>;
+export declare function validateConfig(raw: unknown): {
+    value?: DcvConfigParsed;
+    errors?: string[];
+};
+//# sourceMappingURL=config-schema.d.ts.map

package/cli/config-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["config-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAKzB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAEd,CAAC;AAEjB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGZ,CAAC;AAEjB,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,KAAK,CAAC,EAAE,eAAe,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAM3F"}

package/cli/config-schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export const WcagRuleSchema = z.object({
+    foreground: z.string(),
+    background: z.string(),
+    ratio: z.number().positive().optional(),
+    description: z.string().optional()
+});
+export const ConstraintsSchema = z.object({
+    wcag: z.array(WcagRuleSchema).optional()
+}).passthrough();
+export const DcvConfigSchema = z.object({
+    version: z.string().optional(),
+    constraints: ConstraintsSchema.optional()
+}).passthrough();
+export function validateConfig(raw) {
+    const res = DcvConfigSchema.safeParse(raw);
+    if (!res.success) {
+        return { errors: res.error.errors.map(e => `${e.path.join('.') || '<root>'}: ${e.message}`) };
+    }
+    return { value: res.data };
+}

package/cli/config-schema.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+
+export const WcagRuleSchema = z.object({
+  foreground: z.string(),
+  background: z.string(),
+  ratio: z.number().positive().optional(),
+  description: z.string().optional()
+});
+
+export const ConstraintsSchema = z.object({
+  wcag: z.array(WcagRuleSchema).optional()
+}).passthrough();
+
+export const DcvConfigSchema = z.object({
+  version: z.string().optional(),
+  constraints: ConstraintsSchema.optional()
+}).passthrough();
+
+export type DcvConfigParsed = z.infer<typeof DcvConfigSchema>;
+
+export function validateConfig(raw: unknown): { value?: DcvConfigParsed; errors?: string[] } {
+  const res = DcvConfigSchema.safeParse(raw);
+  if (!res.success) {
+    return { errors: res.error.errors.map(e => `${e.path.join('.')||'<root>'}: ${e.message}`) };
+  }
+  return { value: res.data };
+}