inkhouse 0.1.0-beta.0

package/scanner/css-patch-regression.ts

@@ -0,0 +1,112 @@
+import assert from 'node:assert/strict';
+
+import { patchCssVariables } from '../src/github';
+
+function mapFromEntries(entries: Array<[string, Array<[string, string]>]>): Map<string, Map<string, string>> {
+  const out = new Map<string, Map<string, string>>();
+  for (const [theme, props] of entries) {
+    out.set(theme, new Map(props));
+  }
+  return out;
+}
+
+function runRegression(): void {
+  const css = [
+    ':root {',
+    '  --primary: oklch(0.5 0.2 120);',
+    '  --background: oklch(1 0 0);',
+    '}',
+    '',
+    ':root[data-theme="secondary"] {',
+    '  --primary: oklch(0.7 0.2 250);',
+    '}',
+    '',
+    '/* keep this comment exactly */',
+    '.button {',
+    '  color: var(--primary);',
+    '}',
+    '',
+  ].join('\n');
+
+  const updates = mapFromEntries([
+    [
+      'primary',
+      [
+        ['--primary', 'oklch(0.62 0.19 250)'],
+        ['--ring', 'oklch(0.72 0.19 250)'],
+      ],
+    ],
+    ['secondary', [['--primary', 'oklch(0.6 0.18 252)']]],
+    ['dark', [['--background', 'oklch(0.15 0.01 285)']]],
+  ]);
+
+  const next = patchCssVariables(css, updates);
+
+  // Existing declarations are updated in-place.
+  assert.match(next, /:root \{\n  --primary: oklch\(0\.62 0\.19 250\);/);
+  assert.match(next, /:root\[data-theme="secondary"\] \{\n  --primary: oklch\(0\.6 0\.18 252\);/);
+
+  // New declarations are appended inside existing block with indentation.
+  assert.match(next, /--background: oklch\(1 0 0\);\n  --ring: oklch\(0\.72 0\.19 250\);/);
+
+  // New theme block is created when missing.
+  assert.match(next, /:root\[data-theme="dark"\] \{\n  --background: oklch\(0\.15 0\.01 285\);\n\}/);
+
+  // Unrelated CSS remains untouched.
+  assert.match(next, /\/\* keep this comment exactly \*\//);
+  assert.match(next, /\.button \{\n  color: var\(--primary\);\n\}/);
+
+  // No accidental duplication for replaced declarations.
+  const primaryDeclCount = (next.match(/--primary:/g) || []).length;
+  assert.equal(primaryDeclCount, 2);
+}
+
+function runThemeRenameRegression(): void {
+  const css = [
+    ':root {',
+    '  --primary: oklch(0.5 0.2 120);',
+    '  --primary-foreground: oklch(0.98 0.01 120);',
+    '}',
+    '',
+    ':root[data-theme="secondary"] {',
+    '  --primary: oklch(0.7 0.2 250);',
+    '  --primary-foreground: oklch(0.98 0.01 250);',
+    '}',
+    '',
+  ].join('\n');
+
+  const updates = mapFromEntries([
+    ['client2', [['--primary', 'oklch(0.65 0.28 330)']]],
+  ]);
+
+  const fullThemeUpdates = mapFromEntries([
+    [
+      'client2',
+      [
+        ['--primary', 'oklch(0.65 0.28 330)'],
+        ['--primary-foreground', 'oklch(0.98 0.01 330)'],
+        ['--background', 'oklch(1 0 0)'],
+      ],
+    ],
+  ]);
+
+  const next = patchCssVariables(
+    css,
+    updates,
+    new Set(['primary', 'client2']),
+    fullThemeUpdates
+  );
+
+  // Stale theme block should be removed.
+  assert.doesNotMatch(next, /:root\[data-theme="secondary"\]/);
+
+  // New theme block should include the full theme payload, not only changed key.
+  assert.match(next, /:root\[data-theme="client2"\] \{/);
+  assert.match(next, /--primary: oklch\(0\.65 0\.28 330\);/);
+  assert.match(next, /--primary-foreground: oklch\(0\.98 0\.01 330\);/);
+  assert.match(next, /--background: oklch\(1 0 0\);/);
+}
+
+runRegression();
+runThemeRenameRegression();
+console.log('css patch regression passed');

package/scanner/css-token-reader-regression.ts

@@ -0,0 +1,92 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { parseCssTokenMap, readTokenSourceMap } from './css-token-reader';
+
+function testRootAndThemeSelectors(): void {
+  const css = `
+    :root {
+      --primary: oklch(62% 0.17 149);
+      --radius: 0.5rem;
+      --font-sans: "Open Sans", sans-serif;
+    }
+    .dark {
+      --primary: oklch(70% 0.14 150);
+    }
+    :root[data-theme="secondary"] {
+      --primary: oklch(62% 0.17 250);
+    }
+  `;
+  const map = parseCssTokenMap(css, 'src/app/globals.css', 'auto');
+  assert.equal(map.mode, 'css');
+  assert.equal(map.colors.primary, 'oklch(62% 0.17 149)');
+  assert.equal(map.radius.base, 8);
+  assert.equal(map.fonts.sans, '"Open Sans", sans-serif');
+  assert.equal(map.themes.dark?.colors.primary, 'oklch(70% 0.14 150)');
+  assert.equal(map.themes.secondary?.colors.primary, 'oklch(62% 0.17 250)');
+}
+
+function testTailwindV4ThemeBlock(): void {
+  const css = `
+    @theme {
+      --color-primary: oklch(0.7 0.2 150);
+      --spacing-md: 1rem;
+      --text-xl: 1.25rem;
+    }
+  `;
+  const map = parseCssTokenMap(css, 'src/app/globals.css', 'auto');
+  assert.equal(map.colors.primary, 'oklch(0.7 0.2 150)');
+  assert.equal(map.spacing.md, 16);
+  assert.equal(map.fontSize.xl, 20);
+}
+
+function testShadowAndColorPrefixes(): void {
+  const css = `
+    :root {
+      --shadow: 0 1px 2px rgba(0,0,0,.1);
+      --shadow-md: 0 8px 16px rgba(0,0,0,.2);
+      --color-background: oklch(1 0 0);
+    }
+  `;
+  const map = parseCssTokenMap(css, 'src/app/tokens.css', 'auto');
+  assert.equal(map.shadows.DEFAULT, '0 1px 2px rgba(0,0,0,.1)');
+  assert.equal(map.shadows.md, '0 8px 16px rgba(0,0,0,.2)');
+  assert.equal(map.colors.background, 'oklch(1 0 0)');
+}
+
+function testImportedCssSourceResolution(): void {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'inkhouse-css-reader-'));
+  try {
+    const appDir = path.join(tmpRoot, 'src', 'app');
+    const themeDir = path.join(tmpRoot, 'src', 'theme');
+    fs.mkdirSync(appDir, { recursive: true });
+    fs.mkdirSync(themeDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(appDir, 'globals.css'),
+      '@import "../theme/brand.css";\nbody { color: var(--foreground); }\n',
+      'utf8'
+    );
+    fs.writeFileSync(
+      path.join(themeDir, 'brand.css'),
+      ':root { --primary: oklch(0.62 0.19 250); --foreground: oklch(0.14 0.01 286); }\n',
+      'utf8'
+    );
+
+    const map = readTokenSourceMap({ projectRoot: tmpRoot, tokenSourceMode: 'auto' });
+    assert.equal(map.mode, 'css');
+    assert.equal(map.source.replace(/\\/g, '/'), 'src/theme/brand.css');
+    assert.equal(map.colors.primary, 'oklch(0.62 0.19 250)');
+    assert.equal(map.colors.foreground, 'oklch(0.14 0.01 286)');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+}
+
+testRootAndThemeSelectors();
+testTailwindV4ThemeBlock();
+testShadowAndColorPrefixes();
+testImportedCssSourceResolution();
+
+console.log('css token reader regression passed');

package/scanner/css-token-reader.ts

@@ -0,0 +1,477 @@
+import fs from 'fs';
+import path from 'path';
+import postcss, { type AtRule, type Declaration, type Rule } from 'postcss';
+import {
+  createEmptyScannedTokenMap,
+  type ScannedThemeTokens,
+  type ScannedTokenMap,
+  type TokenSourceMode,
+} from '../src/token-source';
+
+const CSS_DISCOVERY_PATHS = [
+  'src/app/tokens.css',
+  'src/app/globals.css',
+  'app/globals.css',
+  'styles/globals.css',
+];
+
+const DEFAULT_DTCG_PATH = 'design-tokens/tokens.dtcg.json';
+const REM_TO_PX = 16;
+
+export interface ReadTokenSourceOptions {
+  projectRoot: string;
+  tokenSourceMode?: TokenSourceMode;
+  cssTokenPath?: string;
+  dtcgTokenPath?: string;
+}
+
+type TargetTokenGroup = {
+  colors: Record<string, string>;
+  radius: Record<string, number>;
+  fonts: Record<string, string>;
+  spacing: Record<string, number>;
+  fontSize: Record<string, number>;
+  shadows: Record<string, string>;
+};
+
+function toDisplayPath(projectRoot: string, filePath: string): string {
+  const rel = path.relative(projectRoot, filePath);
+  if (!rel || rel.startsWith('..')) return filePath;
+  return rel.replace(/\\/g, '/');
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function discoverFilePath(projectRoot: string, candidate: string): string | null {
+  if (!candidate) return null;
+  const absolute = path.isAbsolute(candidate) ? candidate : path.resolve(projectRoot, candidate);
+  return fs.existsSync(absolute) ? absolute : null;
+}
+
+function extractImportSpecifier(params: string): string | null {
+  const raw = String(params || '').trim();
+  if (!raw) return null;
+
+  const quoted = raw.match(/^(['"])(.+?)\1(?:\s+.*)?$/);
+  if (quoted) return quoted[2].trim();
+
+  const urlMatch = raw.match(/^url\(\s*(['"]?)([^'")]+)\1\s*\)(?:\s+.*)?$/i);
+  if (urlMatch) return urlMatch[2].trim();
+
+  return null;
+}
+
+function resolveImportedCssPath(baseFilePath: string, params: string): string | null {
+  const specifier = extractImportSpecifier(params);
+  if (!specifier) return null;
+  const lowered = specifier.toLowerCase();
+  if (
+    lowered.startsWith('http://') ||
+    lowered.startsWith('https://') ||
+    lowered.startsWith('//') ||
+    lowered.startsWith('data:')
+  ) {
+    return null;
+  }
+
+  const fromDir = path.dirname(baseFilePath);
+  const direct = path.resolve(fromDir, specifier);
+  if (fs.existsSync(direct)) return direct;
+  if (!path.extname(direct) && fs.existsSync(direct + '.css')) return direct + '.css';
+  return null;
+}
+
+function cssHasTokenDeclarations(cssText: string): boolean {
+  try {
+    const root = postcss.parse(cssText);
+    let found = false;
+    root.walkDecls((decl) => {
+      if (found) return;
+      if (!decl.prop || !decl.prop.startsWith('--')) return;
+      const parent = decl.parent;
+      if (!parent) return;
+      if (parent.type === 'atrule') {
+        const at = parent as AtRule;
+        if ((at.name || '').toLowerCase() === 'theme') found = true;
+        return;
+      }
+      if (parent.type === 'rule') {
+        const selector = (parent as Rule).selector || '';
+        if (parseThemeSelectors(selector).length > 0) found = true;
+      }
+    });
+    return found;
+  } catch {
+    return false;
+  }
+}
+
+function resolveCssTokenPathFromImports(filePath: string, visited: Set<string> = new Set()): string {
+  const absolute = path.resolve(filePath);
+  if (visited.has(absolute)) return absolute;
+  visited.add(absolute);
+
+  let cssText = '';
+  try {
+    cssText = fs.readFileSync(absolute, 'utf-8');
+  } catch {
+    return absolute;
+  }
+
+  if (cssHasTokenDeclarations(cssText)) return absolute;
+
+  let root: postcss.Root;
+  try {
+    root = postcss.parse(cssText, { from: absolute });
+  } catch {
+    return absolute;
+  }
+
+  for (const node of root.nodes || []) {
+    if (node.type !== 'atrule') continue;
+    const at = node as AtRule;
+    if ((at.name || '').toLowerCase() !== 'import') continue;
+    const imported = resolveImportedCssPath(absolute, at.params || '');
+    if (!imported || visited.has(imported)) continue;
+    const resolved = resolveCssTokenPathFromImports(imported, visited);
+    if (resolved && resolved !== absolute) return resolved;
+  }
+
+  return absolute;
+}
+
+function readCssWithImports(filePath: string, visited: Set<string> = new Set()): string {
+  const absolute = path.resolve(filePath);
+  if (visited.has(absolute)) return '';
+  visited.add(absolute);
+
+  let cssText = '';
+  try {
+    cssText = fs.readFileSync(absolute, 'utf-8');
+  } catch {
+    return '';
+  }
+
+  let root: postcss.Root;
+  try {
+    root = postcss.parse(cssText, { from: absolute });
+  } catch {
+    return cssText;
+  }
+
+  const parts: string[] = [];
+  for (const node of root.nodes || []) {
+    if (node.type === 'atrule' && ((node as AtRule).name || '').toLowerCase() === 'import') {
+      const imported = resolveImportedCssPath(absolute, (node as AtRule).params || '');
+      if (imported) {
+        const importedCss = readCssWithImports(imported, visited);
+        if (importedCss.trim()) parts.push(importedCss);
+        continue;
+      }
+    }
+    parts.push(node.toString());
+  }
+
+  return parts.join('\n');
+}
+
+export function discoverCssTokenPath(projectRoot: string, explicitPath?: string): string | null {
+  if (explicitPath && explicitPath.trim()) {
+    const explicit = discoverFilePath(projectRoot, explicitPath.trim());
+    return explicit ? resolveCssTokenPathFromImports(explicit) : null;
+  }
+  for (const rel of CSS_DISCOVERY_PATHS) {
+    const found = discoverFilePath(projectRoot, rel);
+    if (found) return resolveCssTokenPathFromImports(found);
+  }
+  return null;
+}
+
+export function discoverDtcgTokenPath(projectRoot: string, explicitPath?: string): string | null {
+  const candidate = explicitPath && explicitPath.trim() ? explicitPath.trim() : DEFAULT_DTCG_PATH;
+  return discoverFilePath(projectRoot, candidate);
+}
+
+function parseDimensionPx(rawValue: string): number | null {
+  const value = String(rawValue || '').trim().toLowerCase();
+  const pxMatch = value.match(/^(-?\d+(?:\.\d+)?)px$/);
+  if (pxMatch) {
+    const n = parseFloat(pxMatch[1]);
+    return Number.isFinite(n) ? n : null;
+  }
+  const remMatch = value.match(/^(-?\d+(?:\.\d+)?)rem$/);
+  if (remMatch) {
+    const n = parseFloat(remMatch[1]);
+    return Number.isFinite(n) ? n * REM_TO_PX : null;
+  }
+  const emMatch = value.match(/^(-?\d+(?:\.\d+)?)em$/);
+  if (emMatch) {
+    const n = parseFloat(emMatch[1]);
+    return Number.isFinite(n) ? n * REM_TO_PX : null;
+  }
+  const numberMatch = value.match(/^(-?\d+(?:\.\d+)?)$/);
+  if (numberMatch) {
+    const n = parseFloat(numberMatch[1]);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+
+function ensureThemeContainer(map: ScannedTokenMap, themeName: string): ScannedThemeTokens {
+  if (!map.themes[themeName]) {
+    map.themes[themeName] = { colors: {} };
+  }
+  return map.themes[themeName];
+}
+
+function getTargetGroup(map: ScannedTokenMap, themeName: string): TargetTokenGroup {
+  if (themeName === 'primary') {
+    return {
+      colors: map.colors,
+      radius: map.radius,
+      fonts: map.fonts,
+      spacing: map.spacing,
+      fontSize: map.fontSize,
+      shadows: map.shadows,
+    };
+  }
+  const theme = ensureThemeContainer(map, themeName);
+  if (!theme.radius) theme.radius = {};
+  if (!theme.fonts) theme.fonts = {};
+  if (!theme.spacing) theme.spacing = {};
+  if (!theme.fontSize) theme.fontSize = {};
+  if (!theme.shadows) theme.shadows = {};
+  return {
+    colors: theme.colors,
+    radius: theme.radius,
+    fonts: theme.fonts,
+    spacing: theme.spacing,
+    fontSize: theme.fontSize,
+    shadows: theme.shadows,
+  };
+}
+
+function parseThemeSelectors(selector: string): string[] {
+  const themes = new Set<string>();
+  const raw = String(selector || '').trim();
+  if (!raw) return [];
+  const normalized = raw.toLowerCase();
+
+  const dataThemeMatches = normalized.matchAll(/\[data-theme\s*=\s*["']?([^"'\\\]]+)["']?\]/g);
+  for (const match of dataThemeMatches) {
+    const themeName = String(match[1] || '').trim();
+    if (themeName) themes.add(themeName);
+  }
+
+  if (/(\.|:)(dark)\b/.test(normalized)) {
+    themes.add('dark');
+  }
+
+  if (normalized.includes(':root') && themes.size === 0) {
+    themes.add('primary');
+  }
+
+  return Array.from(themes);
+}
+
+type VariableCategory = 'color' | 'radius' | 'font' | 'spacing' | 'fontSize' | 'shadow';
+
+function classifyVariable(rawName: string): { category: VariableCategory; key: string } | null {
+  const name = String(rawName || '').trim().replace(/^--/, '');
+  if (!name) return null;
+
+  if (name === 'radius') return { category: 'radius', key: 'base' };
+  if (name.startsWith('radius-')) return { category: 'radius', key: name.slice('radius-'.length) };
+
+  if (name.startsWith('font-family-')) return { category: 'font', key: name.slice('font-family-'.length) };
+  if (name.startsWith('font-') && !name.startsWith('font-size-')) return { category: 'font', key: name.slice('font-'.length) };
+
+  if (name.startsWith('spacing-')) return { category: 'spacing', key: name.slice('spacing-'.length) };
+  if (name.startsWith('text-')) return { category: 'fontSize', key: name.slice('text-'.length) };
+  if (name.startsWith('font-size-')) return { category: 'fontSize', key: name.slice('font-size-'.length) };
+
+  if (name === 'shadow') return { category: 'shadow', key: 'DEFAULT' };
+  if (name.startsWith('shadow-')) return { category: 'shadow', key: name.slice('shadow-'.length) };
+
+  if (name.startsWith('color-')) return { category: 'color', key: name.slice('color-'.length) };
+  return { category: 'color', key: name };
+}
+
+function applyDeclaration(target: TargetTokenGroup, decl: Declaration): void {
+  if (!decl.prop || !decl.prop.startsWith('--')) return;
+  const classification = classifyVariable(decl.prop);
+  if (!classification || !classification.key) return;
+  const value = String(decl.value || '').trim();
+  if (!value) return;
+
+  if (classification.category === 'color') {
+    target.colors[classification.key] = value;
+    return;
+  }
+  if (classification.category === 'font') {
+    target.fonts[classification.key] = value;
+    return;
+  }
+  if (classification.category === 'shadow') {
+    target.shadows[classification.key] = value;
+    return;
+  }
+  if (classification.category === 'radius') {
+    const px = parseDimensionPx(value);
+    if (px != null) target.radius[classification.key] = px;
+    return;
+  }
+  if (classification.category === 'spacing') {
+    const px = parseDimensionPx(value);
+    if (px != null) target.spacing[classification.key] = px;
+    return;
+  }
+  if (classification.category === 'fontSize') {
+    const px = parseDimensionPx(value);
+    if (px != null) target.fontSize[classification.key] = px;
+  }
+}
+
+function applyRuleTokens(map: ScannedTokenMap, rule: Rule): void {
+  const selectors = Array.isArray(rule.selectors)
+    ? rule.selectors
+    : String(rule.selector || '').split(',');
+  const themes = new Set<string>();
+  for (const selector of selectors) {
+    for (const themeName of parseThemeSelectors(selector)) {
+      themes.add(themeName);
+    }
+  }
+  if (themes.size === 0) return;
+
+  for (const themeName of themes) {
+    const target = getTargetGroup(map, themeName);
+    for (const node of rule.nodes || []) {
+      if (node.type !== 'decl') continue;
+      applyDeclaration(target, node as Declaration);
+    }
+  }
+}
+
+function walkCssNodes(map: ScannedTokenMap, container: postcss.Container): void {
+  for (const node of container.nodes || []) {
+    if (node.type === 'rule') {
+      applyRuleTokens(map, node as Rule);
+      walkCssNodes(map, node as unknown as postcss.Container);
+      continue;
+    }
+    if (node.type === 'atrule') {
+      const at = node as AtRule;
+      if (at.name === 'theme') {
+        const target = getTargetGroup(map, 'primary');
+        for (const child of at.nodes || []) {
+          if (child.type !== 'decl') continue;
+          applyDeclaration(target, child as Declaration);
+        }
+      }
+      walkCssNodes(map, at as unknown as postcss.Container);
+    }
+  }
+}
+
+export function parseCssTokenMap(cssText: string, source: string, requestedMode: TokenSourceMode = 'auto'): ScannedTokenMap {
+  const map = createEmptyScannedTokenMap('css', source, requestedMode);
+  const root = postcss.parse(cssText);
+  walkCssNodes(map, root);
+  return map;
+}
+
+function applyDtcgGroup(
+  source: Record<string, unknown> | undefined,
+  expectedType: string,
+  mapTarget: Record<string, string>,
+): void {
+  if (!source || !isPlainObject(source)) return;
+  for (const [key, entry] of Object.entries(source)) {
+    if (!isPlainObject(entry)) continue;
+    if ((entry.$type as string) !== expectedType) continue;
+    const value = entry.$value;
+    if (typeof value === 'string' && value.trim()) {
+      mapTarget[key] = value.trim();
+    }
+  }
+}
+
+function applyDtcgDimensionGroup(
+  source: Record<string, unknown> | undefined,
+  mapTarget: Record<string, number>,
+): void {
+  if (!source || !isPlainObject(source)) return;
+  for (const [key, entry] of Object.entries(source)) {
+    if (!isPlainObject(entry)) continue;
+    if ((entry.$type as string) !== 'dimension') continue;
+    const value = entry.$value;
+    if (typeof value !== 'string' || !value.trim()) continue;
+    const px = parseDimensionPx(value);
+    if (px != null) mapTarget[key] = px;
+  }
+}
+
+function parseDtcgTokenMap(
+  dtcgJson: unknown,
+  source: string,
+  requestedMode: TokenSourceMode = 'auto'
+): ScannedTokenMap {
+  const map = createEmptyScannedTokenMap('dtcg', source, requestedMode);
+  if (!isPlainObject(dtcgJson)) return map;
+
+  const core = dtcgJson.core;
+  if (isPlainObject(core)) {
+    applyDtcgGroup(core.font as Record<string, unknown> | undefined, 'fontFamily', map.fonts);
+  }
+
+  for (const [themeName, rawTheme] of Object.entries(dtcgJson)) {
+    if (themeName === '$metadata' || themeName === 'core') continue;
+    if (!isPlainObject(rawTheme)) continue;
+
+    const target = getTargetGroup(map, themeName);
+    applyDtcgGroup(rawTheme.color as Record<string, unknown> | undefined, 'color', target.colors);
+    applyDtcgGroup(rawTheme.font as Record<string, unknown> | undefined, 'fontFamily', target.fonts);
+    applyDtcgDimensionGroup(rawTheme.radius as Record<string, unknown> | undefined, target.radius);
+    applyDtcgDimensionGroup(rawTheme.spacing as Record<string, unknown> | undefined, target.spacing);
+    applyDtcgDimensionGroup(rawTheme.fontSize as Record<string, unknown> | undefined, target.fontSize);
+    applyDtcgGroup(rawTheme.shadow as Record<string, unknown> | undefined, 'shadow', target.shadows);
+  }
+
+  return map;
+}
+
+export function readTokenSourceMap(options: ReadTokenSourceOptions): ScannedTokenMap {
+  const projectRoot = path.resolve(options.projectRoot);
+  const requestedMode = options.tokenSourceMode || 'auto';
+  const cssPath = discoverCssTokenPath(projectRoot, options.cssTokenPath);
+  const dtcgPath = discoverDtcgTokenPath(projectRoot, options.dtcgTokenPath);
+
+  if (requestedMode === 'css') {
+    if (!cssPath) return createEmptyScannedTokenMap('embedded', 'embedded:tokens.ts', requestedMode);
+    const cssText = readCssWithImports(cssPath);
+    return parseCssTokenMap(cssText, toDisplayPath(projectRoot, cssPath), requestedMode);
+  }
+
+  if (requestedMode === 'dtcg') {
+    if (!dtcgPath) return createEmptyScannedTokenMap('embedded', 'embedded:tokens.ts', requestedMode);
+    const dtcgText = fs.readFileSync(dtcgPath, 'utf-8');
+    const dtcgJson = JSON.parse(dtcgText);
+    return parseDtcgTokenMap(dtcgJson, toDisplayPath(projectRoot, dtcgPath), requestedMode);
+  }
+
+  // auto mode: CSS always wins when present.
+  if (cssPath) {
+    const cssText = readCssWithImports(cssPath);
+    return parseCssTokenMap(cssText, toDisplayPath(projectRoot, cssPath), requestedMode);
+  }
+  if (dtcgPath) {
+    const dtcgText = fs.readFileSync(dtcgPath, 'utf-8');
+    const dtcgJson = JSON.parse(dtcgText);
+    return parseDtcgTokenMap(dtcgJson, toDisplayPath(projectRoot, dtcgPath), requestedMode);
+  }
+
+  return createEmptyScannedTokenMap('embedded', 'embedded:tokens.ts', requestedMode);
+}