@crossworks/share-ui 0.230.43

package/src/lib/ink-audit.test.ts

@@ -0,0 +1,314 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { COLOR_THEMES } from './themes';
+import { parseThemeBlocks } from './theme-css-blocks';
+
+/**
+ * INK AUDIT — discovers what is used as text, instead of being told.
+ *
+ * `themes.test.ts` asserts a hand-written list of pairs. That is exactly why
+ * three separate instances of the same bug survived a session spent on
+ * contrast: a contract only covers the tokens it enumerates. The accent pair
+ * was listed, so it was caught. `chart-3` was not, so `hljs-title` rendered
+ * function names at 1.02:1 — the same colour as the code background — on the
+ * `claude` theme, and a user found it.
+ *
+ * So this test does not enumerate. It SCANS every `color:` declaration in the
+ * shipped CSS, resolves which token each one paints with, and measures that
+ * token against the surfaces it can land on, in every theme and both modes.
+ * A new `color: var(--whatever)` is audited the moment it is written, by
+ * nobody's decision.
+ *
+ * The rule it enforces: a token used as text must be either
+ *   (a) INK-SAFE — it clears AA on every neutral surface in every theme, or
+ *   (b) SCOPED — declared below as only ever landing on specific surfaces,
+ *       and it clears AA on those.
+ * Anything else fails, and the fix is a `-ink` token (see `--primary-ink`).
+ */
+
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const REPO = join(HERE, '..', '..', '..', '..');
+const THEME_CSS = readFileSync(join(HERE, '..', '..', 'styles', 'themes.css'), 'utf8');
+
+/** Every stylesheet that ships to a browser. Discovered, not listed, so a new
+ *  globals.css cannot quietly opt out of the audit. */
+function shippedStylesheets(): string[] {
+  const out: string[] = [];
+  const walk = (dir: string, depth = 0) => {
+    if (depth > 4) return;
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e === 'node_modules' || e === '.next' || e === 'dist' || e.startsWith('.')) continue;
+      const p = join(dir, e);
+      if (statSync(p).isDirectory()) walk(p, depth + 1);
+      else if (e.endsWith('.css') && e !== 'themes.css') out.push(p);
+    }
+  };
+  // Post-split roots: the shared stylesheets (app.css + friends) live in
+  // share-ui and the server app; jackdaw's own globals.css is audited by its
+  // repo (it imports these same files from the published package).
+  for (const root of ['server/web/app', 'packages/share-ui/styles']) {
+    walk(join(REPO, root));
+  }
+  return out;
+}
+
+// ── colour maths (shared shape with themes.test.ts) ──────────────────────────
+const clamp = (x: number) => Math.min(1, Math.max(0, x));
+const toLin = (c: number) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+
+function linear(value: string): [number, number, number] {
+  const v = value.trim();
+  if (v.startsWith('#')) {
+    let h = v.slice(1);
+    if (h.length === 3)
+      h = h
+        .split('')
+        .map((c) => c + c)
+        .join('');
+    if (h.length === 8) h = h.slice(0, 6);
+    return [0, 2, 4].map((i) => toLin(parseInt(h.slice(i, i + 2), 16) / 255)) as [
+      number,
+      number,
+      number,
+    ];
+  }
+  const args = v
+    .slice(v.indexOf('(') + 1, v.lastIndexOf(')'))
+    .split('/')[0]!
+    .trim()
+    .split(/[\s,]+/);
+  if (v.startsWith('oklch')) {
+    const L = args[0]!.endsWith('%') ? parseFloat(args[0]!) / 100 : parseFloat(args[0]!);
+    const C = args[1]!.endsWith('%') ? (parseFloat(args[1]!) / 100) * 0.4 : parseFloat(args[1]!);
+    const H = ((parseFloat(args[2] ?? '0') || 0) * Math.PI) / 180;
+    const [a, b] = [C * Math.cos(H), C * Math.sin(H)];
+    const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+    const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+    const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+    return [
+      clamp(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+      clamp(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+      clamp(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s),
+    ];
+  }
+  if (v.startsWith('hsl')) {
+    const [h, sPct, lPct] = args.map((x) => parseFloat(x));
+    const [S, L] = [sPct! / 100, lPct! / 100];
+    const k = (n: number) => (n + h! / 30) % 12;
+    const a = S * Math.min(L, 1 - L);
+    const f = (n: number) => L - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+    return [f(0), f(8), f(4)].map(toLin) as [number, number, number];
+  }
+  throw new Error(`unsupported colour notation: ${value}`);
+}
+
+const lum = ([r, g, b]: [number, number, number]) => 0.2126 * r + 0.7152 * g + 0.0722 * b;
+const contrast = (a: string, b: string) => {
+  const [x, y] = [lum(linear(a)), lum(linear(b))];
+  return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
+};
+
+const BLOCKS = parseThemeBlocks(THEME_CSS);
+
+function tokensOf(selector: string): Record<string, string> {
+  const block = BLOCKS.get(selector);
+  if (!block) throw new Error(`no block for ${selector}`);
+  return block;
+}
+const resolved = (sel: string) => ({ ...tokensOf(':root'), ...tokensOf(sel) });
+
+/** Surfaces a token can land on when nothing narrows it. */
+const NEUTRAL_SURFACES = ['background', 'card', 'muted', 'popover', 'sidebar'] as const;
+
+/**
+ * Tokens that are legitimately scoped: they only ever paint text on the
+ * surface(s) named here, so they are measured against those and not the rest.
+ * Each entry is a CLAIM about where the token is used — narrower than the
+ * conservative default, and therefore reviewable. Adding one is a decision,
+ * not a workaround.
+ */
+const SCOPED: Record<string, readonly string[]> = {
+  'card-foreground': ['card'],
+  'popover-foreground': ['popover'],
+  'sidebar-foreground': ['sidebar'],
+  'accent-foreground': ['accent'],
+  'sidebar-accent-foreground': ['sidebar-accent'],
+  'primary-foreground': ['primary'],
+  'secondary-foreground': ['secondary'],
+  'destructive-foreground': ['destructive'],
+  'success-foreground': ['success'],
+  'warning-foreground': ['warning'],
+  'info-foreground': ['info'],
+  // (muted-foreground needs no entry: the app's standard secondary ink lands
+  // anywhere, so the conservative default — every neutral surface — IS its
+  // contract, and the generator solves it against exactly that set.)
+};
+
+/**
+ * KNOWN-UNSAFE BASELINE — debt that existed when this audit was written, with
+ * the reason and where it is tracked. The list may only ever SHRINK.
+ *
+ * Two rules keep it honest, and the second is the one that matters:
+ *   1. A token NOT listed here must be clean → a newly-introduced bad ink fails
+ *      immediately, which is the entire point of the audit.
+ *   2. A token listed here must STILL be failing → the moment it is fixed, the
+ *      test fails telling you to delete the entry. A baseline that can hold
+ *      stale exemptions is just a mute button.
+ *
+ * EMPTY since the theme generator landed: every text token is now solved
+ * against its surfaces at build time, the chart-as-text consumers moved to the
+ * derived code + success/warning/info roles (task 002794f9), and the two
+ * self-contradicting palettes were dropped. The mechanism stays: the next bad
+ * ink fails CI, and parking it here is a visible, tracked decision.
+ */
+const KNOWN_UNSAFE: Record<string, string> = {};
+
+/** Non-colour `color:` values that carry no token to audit. */
+const IGNORED_VALUES = /^(inherit|currentcolor|transparent|unset|initial|revert)$/i;
+
+/**
+ * COMPUTED-VALUE ALLOWLIST. The audit can only measure a bare `var(--token)`;
+ * a `color-mix()`, a relative `oklch(from …)` or a literal hex is opaque to
+ * it. Those used to be SKIPPED SILENTLY — which is exactly how
+ * `.prose-accent h3`'s color-mix() shipped below AA on 52 of 164 surfaces and
+ * survived a session spent on contrast. Now an unresolvable ink FAILS unless
+ * its selector is listed here with a reason, and a listed selector that stops
+ * existing fails too (an allowlist that can hold stale entries is a mute
+ * button, same rule as KNOWN_UNSAFE).
+ */
+const COMPUTED_ALLOWED: Record<string, string> = {
+  '.ProseMirror .diff-removed-body':
+    'struck ghost text of a REMOVED diff block — 65% foreground is deliberate de-emphasis, ' +
+    'the content is decoration around its Restore pill, not information',
+};
+
+type Use = { file: string; selector: string; token: string };
+type Opaque = { file: string; selector: string; value: string };
+
+/** Every `color:` declaration painting with a theme token, plus every one the
+ *  audit CANNOT resolve (computed/literal values — see COMPUTED_ALLOWED).
+ *  Deliberately not `background-color` / `border-color` — those are surfaces,
+ *  not ink. */
+function inkUses(): { uses: Use[]; opaque: Opaque[] } {
+  const uses: Use[] = [];
+  const opaque: Opaque[] = [];
+  for (const path of shippedStylesheets()) {
+    const css = readFileSync(path, 'utf8');
+    for (const rule of css.matchAll(/([^{}]+)\{([^{}]*)\}/g)) {
+      const selector = rule[1]!.trim().split('\n').pop()!.trim();
+      for (const d of rule[2]!.matchAll(/(?:^|[;{]|\s)color:\s*([^;]+)/g)) {
+        const value = d[1]!.trim();
+        if (IGNORED_VALUES.test(value)) continue;
+        const varMatch = /^var\(--([a-z0-9-]+)\)$/.exec(value);
+        const file = path.replace(REPO + '/', '');
+        if (varMatch) uses.push({ file, selector, token: varMatch[1]! });
+        else opaque.push({ file, selector, value });
+      }
+    }
+  }
+  return { uses, opaque };
+}
+
+describe('ink audit — every token used as text', () => {
+  const { uses, opaque } = inkUses();
+
+  it('finds the `color:` declarations at all (guards against a dead scan)', () => {
+    // A scanner that silently matches nothing passes forever. This is the
+    // canary: the app demonstrably paints text with theme tokens.
+    expect(
+      uses.length,
+      'no `color: var(--token)` declarations found — the scan is broken',
+    ).toBeGreaterThan(10);
+  });
+
+  it('every computed/literal ink is explicitly allowlisted', () => {
+    const unlisted = opaque.filter((o) => !(o.selector in COMPUTED_ALLOWED));
+    expect(
+      unlisted.map((o) => `${o.file} → ${o.selector}: color: ${o.value}`),
+      `these \`color:\` declarations use values the audit cannot measure. Either paint with a ` +
+        `bare var(--token) (deriving a new token in themes/ if needed), or add the selector to ` +
+        `COMPUTED_ALLOWED with a reason — silence is how .prose-accent h3 shipped below AA.`,
+    ).toEqual([]);
+  });
+
+  it('the computed allowlist names only selectors that still exist', () => {
+    const live = new Set(opaque.map((o) => o.selector));
+    const stale = Object.keys(COMPUTED_ALLOWED).filter((sel) => !live.has(sel));
+    expect(
+      stale,
+      `COMPUTED_ALLOWED lists ${stale.join(', ')}, which no stylesheet declares any more — ` +
+        `delete the entr${stale.length === 1 ? 'y' : 'ies'}.`,
+    ).toEqual([]);
+  });
+
+  const byToken = [...new Set(uses.map((u) => u.token))].sort();
+
+  it.each(byToken)('--%s is legible everywhere it can land', (token) => {
+    const surfaces = SCOPED[token] ?? NEUTRAL_SURFACES;
+    const where = uses
+      .filter((u) => u.token === token)
+      .map((u) => `${u.file} → ${u.selector}`)
+      .slice(0, 3);
+
+    const failures: string[] = [];
+    for (const theme of COLOR_THEMES) {
+      for (const [mode, selector] of [
+        ['light', theme.id === 'clean-slate' ? ':root' : `[data-color-theme="${theme.id}"]`],
+        ['dark', theme.id === 'clean-slate' ? '.dark' : `.dark[data-color-theme="${theme.id}"]`],
+      ] as const) {
+        const t = resolved(selector);
+        if (!t[token]) continue;
+        for (const surface of surfaces) {
+          if (!t[surface]) continue;
+          const ratio = contrast(t[token]!, t[surface]!);
+          if (ratio < 4.5) {
+            failures.push(`${theme.id} ${mode}: on ${surface} = ${ratio.toFixed(2)}:1`);
+          }
+        }
+      }
+    }
+
+    if (token in KNOWN_UNSAFE) {
+      // Rule 2: the baseline may only shrink. If this token now passes, the
+      // entry is stale and must go, or the list slowly becomes a mute button.
+      expect(
+        failures.length,
+        `--${token} is in KNOWN_UNSAFE but now passes everywhere. Delete its entry from ` +
+          `KNOWN_UNSAFE — the baseline is shrink-only.`,
+      ).toBeGreaterThan(0);
+      return;
+    }
+
+    expect(
+      failures,
+      `--${token} is used as TEXT here:\n    ${where.join('\n    ')}\n` +
+        `  …but it is illegible in ${failures.length} theme/surface combinations, worst first:\n    ` +
+        failures
+          .sort((a, b) => parseFloat(a.split('= ')[1]!) - parseFloat(b.split('= ')[1]!))
+          .slice(0, 5)
+          .join('\n    ') +
+        `\n  Either give it a contrast-corrected \`-ink\` token (see --primary-ink), or if it ` +
+        `truly only ever lands on specific surfaces, declare that in SCOPED with a reason.`,
+    ).toEqual([]);
+  });
+
+  it('the known-unsafe baseline names only tokens that are actually used', () => {
+    // A baseline entry for a token nobody paints with any more is dead weight
+    // that makes the debt look bigger than it is.
+    const used = new Set(uses.map((u) => u.token));
+    const orphaned = Object.keys(KNOWN_UNSAFE).filter((t) => !used.has(t));
+    expect(
+      orphaned,
+      `KNOWN_UNSAFE lists ${orphaned.join(', ')}, which no \`color:\` declaration uses any more — ` +
+        `delete the entr${orphaned.length === 1 ? 'y' : 'ies'}.`,
+    ).toEqual([]);
+  });
+});

package/src/lib/theme-css-blocks.ts

@@ -0,0 +1,26 @@
+/**
+ * Parse a generated theme stylesheet into token blocks, indexed by EACH
+ * selector in a block's selector list — the shared lookup behind the theme
+ * audits (themes.test.ts, ink-audit.test.ts).
+ *
+ * Exact-selector indexing matters more than it looks: the audits used to find
+ * blocks by `indexOf('<selector> {')`, and once the light blocks grew the
+ * `.light` island (`:root, .light { … }`, see themes/generate.mjs) that
+ * substring stopped matching the light block — and for the per-theme form,
+ * `[data-color-theme="x"] {` matched INSIDE `.dark[data-color-theme="x"] {`,
+ * silently auditing dark values as light. Indexing every selector of every
+ * block makes the lookup exact and both failure modes structural.
+ */
+export function parseThemeBlocks(css: string): Map<string, Record<string, string>> {
+  const map = new Map<string, Record<string, string>>();
+  // Comments out first, or the file's header comment glues itself onto the
+  // first block's selector list and `:root` never gets keyed.
+  const src = css.replace(/\/\*[\s\S]*?\*\//g, '');
+  for (const m of src.matchAll(/(^|\n)([^{}\n][^{}]*)\{([^}]*)\}/g)) {
+    const tokens: Record<string, string> = {};
+    for (const t of m[3]!.matchAll(/--([\w-]+):\s*([^;]+);/g)) tokens[t[1]!] = t[2]!.trim();
+    if (Object.keys(tokens).length === 0) continue;
+    for (const sel of m[2]!.split(',')) map.set(sel.trim(), tokens);
+  }
+  return map;
+}

package/src/lib/theme-generator.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, it } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+// The generator is plain .mjs (it runs under `node` at build time with no
+// transpile step); vitest resolves it fine. Importing it is side-effect free —
+// the CLI is guarded to direct execution.
+import { generateCss, generateMode, generateRegistry, ROLE_HUES } from '../../themes/generate.mjs';
+import { contrast, cssToHex, deltaE, solvePair, solveText } from '../../themes/model.mjs';
+import { THEME_SEEDS } from '../../themes/seeds.mjs';
+
+/**
+ * The generator's own guarantees. `themes.test.ts` re-measures the WCAG
+ * numbers on the shipped CSS with independent maths; this suite covers what
+ * that one can't:
+ *
+ *   - DRIFT: the checked-in artifacts are exactly what the seeds generate.
+ *     Editing themes.css by hand, or seeds without `pnpm themes:build`, fails
+ *     here — the generated file cannot rot out from under its source.
+ *   - the anchored-solver's behavioural contract (a passing value is emitted
+ *     byte-for-byte; a failing one moves minimally; the ROUNDED hex is what
+ *     gets validated — floats that clear 4.5 land at 4.48 as 8-bit hex, which
+ *     cost nine test failures the first time),
+ *   - distinguishability: the semantic roles stay tellable-apart from
+ *     destructive and each other, and generated chart ramps never collapse
+ *     two steps onto one colour (the achromatic dark ramps did exactly that
+ *     before the ladder was made sequential).
+ */
+
+const read = (rel: string) => readFileSync(fileURLToPath(new URL(rel, import.meta.url)), 'utf8');
+
+describe('drift', () => {
+  // Full regeneration solves every token of every theme — seconds, not ms.
+  it('styles/themes.css is exactly what the seeds generate', { timeout: 30_000 }, () => {
+    expect(
+      read('../../styles/themes.css') === generateCss(),
+      'themes.css does not match themes/seeds.mjs — run `pnpm themes:build` (and never edit the generated file by hand)',
+    ).toBe(true);
+  });
+
+  it('the picker registry is exactly what the seeds generate', { timeout: 30_000 }, () => {
+    expect(
+      read('./theme-registry.gen.ts') === generateRegistry(),
+      'theme-registry.gen.ts does not match themes/seeds.mjs — run `pnpm themes:build`',
+    ).toBe(true);
+  });
+});
+
+describe('anchored solver', () => {
+  it('emits a passing anchor byte-for-byte unchanged', () => {
+    expect(solveText('#1e293b', ['#ffffff', '#f8fafc']).hex).toBe('#1e293b');
+  });
+
+  it('moves a failing anchor the minimum, keeping hue and chroma', () => {
+    const r = solveText('#999999', ['#ffffff']);
+    expect(contrast(r.hex, '#ffffff')).toBeGreaterThanOrEqual(4.5);
+    // an achromatic anchor stays achromatic (hue/chroma untouched) …
+    const [rr, gg, bb] = [r.hex.slice(1, 3), r.hex.slice(3, 5), r.hex.slice(5, 7)];
+    expect(rr).toBe(gg);
+    expect(gg).toBe(bb);
+    // … and lands just past the threshold, not at some distant safe colour.
+    expect(contrast(r.hex, '#ffffff')).toBeLessThan(5.2);
+  });
+
+  it('validates the rounded hex it emits, not the float candidate', () => {
+    // Property: for a spread of anchors and surfaces, the EMITTED hex —
+    // re-parsed as 8-bit — must clear the ratio. A solver that measures floats
+    // fails this on boundary values.
+    const surfaces = ['#ffffff', '#f3f4f6', '#1b1b19', '#262626'];
+    for (const anchor of ['#6366f1', '#ef4444', '#0c9746', '#ae6f00', '#c96442', '#72e3ad']) {
+      for (const surface of surfaces) {
+        const r = solveText(anchor, [surface]);
+        expect(r.feasible).toBe(true);
+        expect(contrast(r.hex, surface), `${anchor} solved on ${surface}`).toBeGreaterThanOrEqual(
+          4.5,
+        );
+      }
+    }
+  });
+
+  it('pair solve keeps a consistent authored pair verbatim', () => {
+    const pair = solvePair('#457928', '#ffffff'); // pinnacle primary: passes as authored
+    expect(pair.fill).toBe(cssToHex('#457928'));
+    expect(pair.fg).toBe('#ffffff');
+  });
+
+  it('pair solve deepens a broken fill rather than flipping its text dark', () => {
+    // White on #e6067a is 3.9:1 — the classic authored defect. The one-sided
+    // fix is near-black text (an identity flip); the pair solve must instead
+    // deepen the fill and KEEP the light foreground.
+    const pair = solvePair('#e6067a', '#ffffff');
+    expect(contrast(pair.fg, pair.fill)).toBeGreaterThanOrEqual(4.5);
+    expect(deltaE(pair.fg, '#ffffff'), 'foreground flipped instead of fill deepening').toBeLessThan(
+      0.1,
+    );
+    expect(deltaE(pair.fill, '#e6067a')).toBeLessThan(0.2);
+  });
+});
+
+describe('generated palette distinguishability', () => {
+  const ROLES = Object.keys(ROLE_HUES);
+  for (const seed of THEME_SEEDS) {
+    for (const mode of ['light', 'dark'] as const) {
+      it(`${seed.id} ${mode}: roles and charts stay tellable-apart`, () => {
+        const t = generateMode(seed[mode], { mode }) as Record<string, string>;
+        // each semantic role vs destructive and vs its siblings
+        const fills = ['destructive', ...ROLES];
+        for (let i = 0; i < fills.length; i++) {
+          for (let j = i + 1; j < fills.length; j++) {
+            const d = deltaE(t[fills[i]!]!, t[fills[j]!]!);
+            expect(
+              d,
+              `${seed.id}/${mode}: ${fills[i]} and ${fills[j]} are ΔE ${d.toFixed(3)} apart — ` +
+                `a status colour that can be mistaken for another is worse than none`,
+            ).toBeGreaterThanOrEqual(0.06);
+          }
+        }
+        // charts: a categorical ramp with two equal steps mislabels data
+        if (!seed[mode].charts) {
+          for (let i = 1; i <= 5; i++) {
+            for (let j = i + 1; j <= 5; j++) {
+              const d = deltaE(t[`chart-${i}`]!, t[`chart-${j}`]!);
+              expect(
+                d,
+                `${seed.id}/${mode}: chart-${i} vs chart-${j} ΔE ${d.toFixed(3)}`,
+              ).toBeGreaterThanOrEqual(0.05);
+            }
+          }
+        }
+      });
+    }
+  }
+});
+
+describe('infeasible seeds fail loudly', () => {
+  it('a mid-luminance surface pair aborts generation instead of emitting a failing ink', () => {
+    // One surface needs light text, the other dark — no single ink clears
+    // 4.5:1 on both. The generator must throw a seed-naming error, not emit a
+    // value for CI to trip over three artifacts downstream.
+    const seed = {
+      background: '#8a8a8a', // mid-luminance: kills dark inks
+      card: '#3a5a6a', //      dark-mid: kills light inks
+      foreground: '#1e293b',
+      primary: '#6366f1',
+      'primary-foreground': '#ffffff',
+      secondary: '#e5e7eb',
+      muted: '#8a8a8a',
+      'muted-foreground': '#3d4451',
+      accent: '#e0e7ff',
+      destructive: '#df3236',
+      'destructive-foreground': '#ffffff',
+      border: '#d1d5db',
+    };
+    expect(() => generateMode(seed, { mode: 'light' })).toThrow(/no feasible ink/);
+  });
+});
+
+describe('seeds hygiene', () => {
+  it('ids are unique and clean-slate is the baseline', () => {
+    const ids = THEME_SEEDS.map((t) => t.id);
+    expect(new Set(ids).size).toBe(ids.length);
+    expect(ids[0]).toBe('clean-slate');
+  });
+
+  it('every seeded colour is normalised 6-digit hex', () => {
+    // The extractor normalised all notations; keeping seeds in one notation is
+    // what makes "passing anchors ship byte-for-byte" reviewable in a diff.
+    for (const t of THEME_SEEDS) {
+      for (const mode of ['light', 'dark'] as const) {
+        for (const [k, v] of Object.entries(t[mode])) {
+          if (k === 'extras') continue;
+          const values = k === 'charts' ? (v as string[]) : [v as string];
+          for (const value of values) {
+            expect(value, `${t.id}.${mode}.${k}`).toMatch(/^#[0-9a-f]{6}$/);
+          }
+        }
+      }
+    }
+  });
+});