@starklab/stark-mcp 0.1.0

package/src/adopt/rnTailwindResolver.js

@@ -0,0 +1,347 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import fg from 'fast-glob';
+
+import { stkRoot } from '../data.js';
+import { buildModuleGraph } from './moduleGraph.js';
+import {
+  loadRnTokenInventory,
+  isAnalyzableValueNode,
+  buildAliasGraph,
+  classifyTerminalState,
+  classifyNode,
+} from './rnTokenAliasResolver.js';
+import {
+  findExportedConfigObject,
+  getObjectProp,
+  objectKey,
+  stripVariants,
+  matchUtilityBase,
+  collectClassNameUsages,
+} from './tailwindResolver.js';
+
+// "5 is governance, 20 is safety" — see ADOPTION_APP_PLAN.md §4/§5a. Kept as
+// its own local constant per the established per-file duplication convention
+// (tailwindResolver.js and rnTokenAliasResolver.js each keep their own copy
+// rather than importing one another's).
+const WARN_DEPTH = 3;
+
+const DEFAULT_IGNORE = [
+  '**/node_modules/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/.next/**',
+  '**/coverage/**',
+  '**/storybook-static/**',
+  '**/.storybook*/**',
+];
+
+// ---------------------------------------------------------------------------
+// NativeWind detection
+//
+// A bare tailwind.config.js is not itself a NativeWind signal — it could
+// belong to an unrelated web app elsewhere in the same monorepo. Three real
+// signals, checked cheapest-first: the "nativewind" package.json dependency,
+// the "nativewind/babel" Babel preset, or the "withNativeWind" Metro config
+// wrapper. Any one of them is sufficient.
+// ---------------------------------------------------------------------------
+
+function detectNativeWind(root, ignore) {
+  const scanIgnore = [...DEFAULT_IGNORE, ...ignore];
+
+  const pkgFiles = fg.sync(['**/package.json'], { cwd: root, absolute: true, ignore: scanIgnore });
+  for (const file of pkgFiles) {
+    let json;
+    try {
+      json = JSON.parse(readFileSync(file, 'utf-8'));
+    } catch {
+      continue;
+    }
+    const deps = { ...json.dependencies, ...json.devDependencies, ...json.peerDependencies };
+    if (Object.prototype.hasOwnProperty.call(deps, 'nativewind')) {
+      return { found: true, signal: 'package.json', file };
+    }
+  }
+
+  const babelFiles = fg.sync(['**/babel.config.{js,cjs,mjs}'], { cwd: root, absolute: true, ignore: scanIgnore });
+  for (const file of babelFiles) {
+    let src;
+    try {
+      src = readFileSync(file, 'utf-8');
+    } catch {
+      continue;
+    }
+    if (src.includes('nativewind/babel')) {
+      return { found: true, signal: 'babel.config', file };
+    }
+  }
+
+  const metroFiles = fg.sync(['**/metro.config.{js,cjs,mjs}'], { cwd: root, absolute: true, ignore: scanIgnore });
+  for (const file of metroFiles) {
+    let src;
+    try {
+      src = readFileSync(file, 'utf-8');
+    } catch {
+      continue;
+    }
+    if (src.includes('withNativeWind')) {
+      return { found: true, signal: 'metro.config', file };
+    }
+  }
+
+  return { found: false };
+}
+
+// ---------------------------------------------------------------------------
+// Theme extraction — v3 tailwind.config.{js,cjs,mjs,ts} theme.extend.colors
+//
+// RN has no CSS custom properties, so a NativeWind consumer aliasing a Stark
+// token can only do it by importing the RN token constant directly into the
+// config and referencing it as a JS expression (an Identifier or a single-hop
+// member access) — never var(), since there's no DOM/CSS runtime on RN to
+// resolve that against. This is the AST-node-capturing counterpart of
+// tailwindResolver.js's collectV3Colors: it keeps the raw value node instead
+// of a resolved string, because resolution here is classifyNode's JS-import-
+// chain analysis (rnTokenAliasResolver.js), not resolveTerminal's CSS
+// var()-chain analysis.
+//
+// Colors-only, same as the web v3 config parser (its NAMESPACES table
+// implies broader coverage, but spacing/radius/shadow/font are only actually
+// reachable there via v4 CSS @theme — which has no NativeWind analog, since a
+// CSS file can't import a JS token constant). No v4 CSS @theme support here
+// for the same reason.
+//
+// The config file's AST is read straight off the already-built moduleGraph
+// rather than re-parsed — buildModuleGraph globs every .js/.jsx/.ts/.tsx/
+// .mjs/.cjs file under root, tailwind.config.js included, so this reuses that
+// parse and (more importantly) lets classifyNode resolve identifiers through
+// the exact same moduleGraph.imports the rest of the consumer's code is
+// resolved against. A config file that only uses CommonJS require() (no ES
+// import) will have an empty imports map for that file — moduleGraph.js only
+// parses ES import syntax — so a token identifier `require()`'d in rather
+// than `import`'d won't resolve. That's an inherited limitation of
+// moduleGraph.js, not something new being solved here.
+// ---------------------------------------------------------------------------
+
+function collectV3ColorsRn(objExpr, into, file) {
+  if (!objExpr || objExpr.type !== 'ObjectExpression') return;
+  for (const prop of objExpr.properties) {
+    if (prop.type !== 'ObjectProperty') continue;
+    const key = objectKey(prop);
+    if (!key) continue;
+
+    if (isAnalyzableValueNode(prop.value)) {
+      into.set(`--color-${key}`, { node: prop.value, file, line: prop.loc?.start.line ?? null });
+      continue;
+    }
+
+    if (prop.value.type === 'ObjectExpression') {
+      for (const sub of prop.value.properties) {
+        if (sub.type !== 'ObjectProperty') continue;
+        const subKey = objectKey(sub);
+        if (!subKey) continue;
+        if (!isAnalyzableValueNode(sub.value)) continue; // nested-again or dynamic — out of scope
+        const cssKey = subKey === 'DEFAULT' ? key : `${key}-${subKey}`;
+        into.set(`--color-${cssKey}`, { node: sub.value, file, line: sub.loc?.start.line ?? null });
+      }
+    }
+  }
+}
+
+function collectV3ThemeEntriesRn(root, moduleGraph, ignore) {
+  const entries = new Map(); // --color-key -> { node, file, line }
+  const configFiles = fg
+    .sync(['**/tailwind.config.{js,cjs,mjs,ts}'], { cwd: root, absolute: true, ignore: [...DEFAULT_IGNORE, ...ignore] })
+    .sort();
+
+  for (const file of configFiles) {
+    const entry = moduleGraph.graph.get(file);
+    if (!entry?.ast) continue;
+    const configObj = findExportedConfigObject(entry.ast);
+    const themeObj = getObjectProp(configObj, 'theme');
+    // theme.colors (replaces Tailwind's defaults) then theme.extend.colors
+    // (adds to them) — extend wins on a same-name clash, matching Tailwind's
+    // own layering (same order tailwindResolver.js's v3 parser uses).
+    collectV3ColorsRn(getObjectProp(themeObj, 'colors'), entries, file);
+    collectV3ColorsRn(getObjectProp(getObjectProp(themeObj, 'extend'), 'colors'), entries, file);
+  }
+
+  return { found: configFiles.length > 0, entries, configFiles };
+}
+
+// ---------------------------------------------------------------------------
+// Theme-entry classification — reuses rnTokenAliasResolver.js's classifyNode
+// directly on each theme entry's raw value node. This is exactly what
+// classifyAliasGraph does per alias-graph entry there; a NativeWind theme
+// value is just another JS expression subject to the same import/local-const
+// alias-chain analysis, so no separate resolution machinery is needed.
+// ---------------------------------------------------------------------------
+
+function classifyThemeEntriesRn(entries, ctx) {
+  const properties = [];
+  const findings = [];
+  const classified = new Map();
+
+  for (const [name, entry] of entries) {
+    const terminal = classifyNode(entry.file, entry.node, ctx, new Set(), 0);
+    const state = classifyTerminalState(terminal.kind);
+    properties.push({ name, file: entry.file, line: entry.line, state, terminal });
+    classified.set(name, { terminal, file: entry.file, line: entry.line });
+
+    if (terminal.kind === 'stk' && terminal.layer === 'primitive') {
+      findings.push({ rule: 'layer-violation', severity: 'critical', property: name, file: entry.file, line: entry.line, stkToken: terminal.stkToken });
+    }
+    if (terminal.kind === 'stk' && terminal.depth > WARN_DEPTH) {
+      findings.push({ rule: 'deep-alias-chain', severity: 'warning', property: name, file: entry.file, line: entry.line, depth: terminal.depth });
+    }
+    if (state === 'drift') {
+      findings.push({ rule: 'drift-behind-alias', severity: 'critical', property: name, file: entry.file, line: entry.line });
+    }
+    if (state === 'broken') {
+      findings.push({ rule: 'broken-alias', severity: 'critical', property: name, file: entry.file, line: entry.line, reason: terminal.kind });
+    }
+  }
+
+  return { properties, findings, classified };
+}
+
+// ---------------------------------------------------------------------------
+// Pass 2 — JSX className usage scanning
+//
+// Reuses tailwindResolver.js's collectClassNameUsages verbatim (statically-
+// resolvable className/class string values, JSX/TSX-wide). No arbitrary-
+// value bracket handling (`bg-[...]`) — var() has no RN meaning, and matching
+// on a raw hex value would violate "never match by value"; an arbitrary
+// utility simply won't match a theme key below and falls through as out of
+// scope. There is accordingly no "direct" classification path at all on this
+// resolver — "direct" is reserved for that web-only escape hatch.
+// ---------------------------------------------------------------------------
+
+function classifyClassNameUsageRn(cls, classifiedEntries) {
+  const base = stripVariants(cls);
+  const propName = matchUtilityBase(base);
+  if (!propName) return null; // not a utility shape this resolver tracks at all
+  const entry = classifiedEntries.get(propName);
+  if (!entry) return null; // not a consumer theme key — out of scope, not a violation
+  const state = classifyTerminalState(entry.terminal.kind);
+  return { classification: state === 'conformant' ? 'aliased' : state, propName, stkToken: entry.terminal.stkToken };
+}
+
+// Same three-number report as the other three resolvers — local duplicate
+// per the established per-file convention.
+function summarizeReport(usages) {
+  const counts = { direct: 0, aliased: 0, unresolved: 0 };
+  for (const u of usages) {
+    if (u.classification === 'direct') counts.direct++;
+    else if (u.classification === 'aliased') counts.aliased++;
+    else counts.unresolved++;
+  }
+  const total = counts.direct + counts.aliased + counts.unresolved;
+  const pct = (n) => (total === 0 ? 0 : Math.round((n / total) * 1000) / 10);
+  return {
+    total,
+    direct: counts.direct,
+    directPct: pct(counts.direct),
+    aliased: counts.aliased,
+    aliasedPct: pct(counts.aliased),
+    unresolved: counts.unresolved,
+    unresolvedPct: pct(counts.unresolved),
+    conformancePct: pct(counts.direct + counts.aliased),
+  };
+}
+
+/**
+ * Resolves NativeWind's class-name indirection back to Stark RN tokens — the
+ * React Native analog of tailwindResolver.js's web resolver. NativeWind is
+ * the one real Tailwind-syntax library on React Native (a Babel transform
+ * bringing `className` props to RN components, built on Tailwind's own
+ * config/theming), so this is scoped to it specifically rather than any
+ * general "RN Tailwind" abstraction.
+ *
+ * Architecturally this is a JS-import-resolution problem (like
+ * rnTokenAliasResolver.js), not a CSS-var()-chain problem (like
+ * tailwindResolver.js) wearing RN clothes: a NativeWind theme value has no
+ * var() to chase, so a consumer aliasing a Stark token can only do it by
+ * importing the RN token constant into tailwind.config.js and referencing it
+ * as a JS expression. Detection is always cheap, resolution isn't — the same
+ * refusal-to-fabricate-a-score rule as every other resolver in this module.
+ */
+export function resolveRnTailwindTokens(root, { platform = 'native', ignore = [] } = {}) {
+  if (platform !== 'native') {
+    throw new Error(
+      `resolveRnTailwindTokens only supports platform "native" (got "${platform}") — NativeWind is the RN analog of web Tailwind, see tailwindResolver.js for the web resolver.`
+    );
+  }
+
+  const nativewind = detectNativeWind(root, ignore);
+  if (!nativewind.found) {
+    return {
+      platform,
+      root,
+      detected: false,
+      reason: 'No NativeWind signal found ("nativewind" package.json dependency, "nativewind/babel" Babel preset, or "withNativeWind" Metro config wrapper).',
+      report: null,
+    };
+  }
+
+  const moduleGraph = buildModuleGraph(root, { ignore });
+  const { found: v3Found, entries: rawEntries, configFiles } = collectV3ThemeEntriesRn(root, moduleGraph, ignore);
+
+  if (!v3Found) {
+    return {
+      platform,
+      root,
+      detected: true,
+      nativewindSignal: nativewind.signal,
+      reason: 'NativeWind detected but no tailwind.config.{js,cjs,mjs,ts} found.',
+      report: null,
+    };
+  }
+
+  if (rawEntries.size === 0) {
+    return {
+      platform,
+      root,
+      detected: true,
+      nativewindSignal: nativewind.signal,
+      themeParseIncomplete: true,
+      reason: 'NativeWind detected but no statically-resolvable theme.colors entries were found — likely a dynamic/function-based tailwind.config theme, a CommonJS require()-only config, or theme keys outside the color namespace this resolver understands. Not scored.',
+      configFiles: configFiles.map((f) => path.relative(root, f)),
+      report: null,
+    };
+  }
+
+  const stkPkgRoot = stkRoot();
+  const { inventory, layers } = loadRnTokenInventory(stkPkgRoot);
+  const { aliasGraph } = buildAliasGraph(moduleGraph);
+  const ctx = { aliasGraph, moduleGraph, inventory, layers };
+
+  const { properties, findings, classified } = classifyThemeEntriesRn(rawEntries, ctx);
+
+  const rawUsages = collectClassNameUsages(moduleGraph);
+  const usages = [];
+  for (const u of rawUsages) {
+    const result = classifyClassNameUsageRn(u.className, classified);
+    if (!result) continue;
+    usages.push({ file: path.relative(root, u.file), line: u.line, className: u.className, ...result });
+  }
+
+  const report = summarizeReport(usages);
+
+  return {
+    platform,
+    root,
+    detected: true,
+    nativewindSignal: nativewind.signal,
+    source: 'v3',
+    scannedConfigFiles: configFiles.length,
+    scannedJsFiles: moduleGraph.files.length,
+    themeEntryCount: rawEntries.size,
+    tokenInventoryTotal: inventory.size,
+    properties,
+    usages,
+    findings,
+    report,
+  };
+}

package/src/adopt/rnTailwindResolver.test.js

@@ -0,0 +1,263 @@
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { describe, it, expect, afterEach } from 'vitest';
+
+import { resolveRnTailwindTokens } from './rnTailwindResolver.js';
+
+let tmpDirs = [];
+
+afterEach(() => {
+  for (const dir of tmpDirs) rmSync(dir, { recursive: true, force: true });
+  tmpDirs = [];
+});
+
+function fixture(files) {
+  const root = mkdtempSync(path.join(os.tmpdir(), 'stark-adopt-rn-tailwind-'));
+  tmpDirs.push(root);
+  for (const [rel, content] of Object.entries(files)) {
+    const full = path.join(root, rel);
+    mkdirSync(path.dirname(full), { recursive: true });
+    writeFileSync(full, content);
+  }
+  return root;
+}
+
+const NATIVEWIND_PKG = `{ "name": "app", "dependencies": { "nativewind": "^4.0.0" } }`;
+
+function usage(result, className) {
+  return result.usages.find((u) => u.className === className);
+}
+
+describe('resolveRnTailwindTokens — NativeWind detection', () => {
+  it('reports detected:false with no report when there is no NativeWind signal at all', () => {
+    const root = fixture({
+      'package.json': `{ "name": "app", "dependencies": {} }`,
+      'src/App.js': `import { View } from 'react-native'; export const App = () => <View className="flex" />;`,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(result.detected).toBe(false);
+    expect(result.report).toBeNull();
+  });
+
+  it('does not treat a bare tailwind.config.js as a NativeWind signal (could belong to an unrelated web app in the same monorepo)', () => {
+    const root = fixture({
+      'package.json': `{ "name": "app", "dependencies": {} }`,
+      'tailwind.config.js': `
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        module.exports = { theme: { extend: { colors: { primary: stkSurfaceBrand1Strong } } } };
+      `,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(result.detected).toBe(false);
+  });
+
+  it('detects via a "nativewind" package.json dependency', () => {
+    const root = fixture({ 'package.json': NATIVEWIND_PKG });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(result.detected).toBe(true);
+    expect(result.nativewindSignal).toBe('package.json');
+    expect(result.reason).toMatch(/no tailwind\.config/i);
+    expect(result.report).toBeNull();
+  });
+
+  it('detects via a "nativewind/babel" preset in babel.config.js', () => {
+    const root = fixture({
+      'package.json': `{ "name": "app", "dependencies": {} }`,
+      'babel.config.js': `module.exports = { presets: ['babel-preset-expo', 'nativewind/babel'] };`,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(result.detected).toBe(true);
+    expect(result.nativewindSignal).toBe('babel.config');
+  });
+
+  it('detects via a "withNativeWind" wrapper in metro.config.js', () => {
+    const root = fixture({
+      'package.json': `{ "name": "app", "dependencies": {} }`,
+      'metro.config.js': `
+        const { withNativeWind } = require('nativewind/metro');
+        module.exports = withNativeWind(config, { input: './global.css' });
+      `,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(result.detected).toBe(true);
+    expect(result.nativewindSignal).toBe('metro.config');
+  });
+
+  it('reports themeParseIncomplete instead of a zero score for a dynamic/function-based v3 config', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `module.exports = { theme: (helpers) => ({ colors: { primary: helpers.colors.blue } }) };`,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(result.detected).toBe(true);
+    expect(result.themeParseIncomplete).toBe(true);
+    expect(result.report).toBeNull();
+  });
+});
+
+describe('resolveRnTailwindTokens — theme.colors classification', () => {
+  it('classifies a theme entry importing a Stark RN token identifier directly as conformant', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        module.exports = { theme: { extend: { colors: { primary: stkSurfaceBrand1Strong } } } };
+      `,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    const prop = result.properties.find((p) => p.name === '--color-primary');
+    expect(prop.state).toBe('conformant');
+  });
+
+  it('classifies a nested DEFAULT/shade color entry', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        module.exports = { theme: { extend: { colors: { brand: { DEFAULT: stkSurfaceBrand1Strong, 500: '#1956dd' } } } } };
+      `,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(result.properties.find((p) => p.name === '--color-brand').state).toBe('conformant');
+    expect(result.properties.find((p) => p.name === '--color-brand-500').state).toBe('drift');
+  });
+
+  it('classifies a theme entry aliasing a raw literal as drift, not aliased', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `module.exports = { theme: { extend: { colors: { primary: '#1956dd' } } } };`,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    const prop = result.properties.find((p) => p.name === '--color-primary');
+    expect(prop.state).toBe('drift');
+    expect(result.findings.some((f) => f.rule === 'drift-behind-alias' && f.property === '--color-primary')).toBe(true);
+  });
+
+  it('classifies a theme entry aliasing a foreign (non-Stark) import as broken', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `
+        import { someColor } from 'some-other-lib';
+        module.exports = { theme: { extend: { colors: { primary: someColor } } } };
+      `,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    const prop = result.properties.find((p) => p.name === '--color-primary');
+    expect(prop.state).toBe('broken');
+    expect(result.findings.some((f) => f.rule === 'broken-alias' && f.property === '--color-primary')).toBe(true);
+  });
+
+  it('flags a theme entry resolving straight to a primitive RN token as a layer violation', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `
+        import { stkSpacingMd } from '@starklab/stk/rn-spacing';
+        module.exports = { theme: { extend: { colors: { primary: stkSpacingMd } } } };
+      `,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    const prop = result.properties.find((p) => p.name === '--color-primary');
+    expect(prop.state).toBe('conformant');
+    const findings = result.findings.filter((f) => f.rule === 'layer-violation' && f.property === '--color-primary');
+    expect(findings).toHaveLength(1);
+    expect(findings[0].severity).toBe('critical');
+  });
+
+  it('warns past ~3 hops on a multi-hop conformant chain declared in the config file itself', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        const hop4 = stkSurfaceBrand1Strong;
+        const hop3 = hop4;
+        const hop2 = hop3;
+        const hop1 = hop2;
+        module.exports = { theme: { extend: { colors: { primary: hop1 } } } };
+      `,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    const prop = result.properties.find((p) => p.name === '--color-primary');
+    expect(prop.state).toBe('conformant');
+    expect(result.findings.some((f) => f.rule === 'deep-alias-chain' && f.property === '--color-primary')).toBe(true);
+  });
+});
+
+describe('resolveRnTailwindTokens — className usage scanning', () => {
+  it('classifies a className resolving to a conformant theme entry as aliased', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        module.exports = { theme: { extend: { colors: { primary: stkSurfaceBrand1Strong } } } };
+      `,
+      'src/App.js': `import { View } from 'react-native'; export const App = () => <View className="bg-primary" />;`,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(usage(result, 'bg-primary').classification).toBe('aliased');
+    expect(result.report.aliased).toBe(1);
+    expect(result.report.direct).toBe(0);
+  });
+
+  it('classifies a className resolving to a drifted theme entry as drift, not aliased', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `module.exports = { theme: { extend: { colors: { primary: '#1956dd' } } } };`,
+      'src/App.js': `import { View } from 'react-native'; export const App = () => <View className="bg-primary" />;`,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(usage(result, 'bg-primary').classification).toBe('drift');
+  });
+
+  it('strips a variant prefix before matching the base utility', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        module.exports = { theme: { extend: { colors: { primary: stkSurfaceBrand1Strong } } } };
+      `,
+      'src/App.js': `import { View } from 'react-native'; export const App = () => <View className="dark:bg-primary" />;`,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(usage(result, 'dark:bg-primary').classification).toBe('aliased');
+  });
+
+  it('does not count an unrelated utility class or Tailwind default-palette color as a usage', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        module.exports = { theme: { extend: { colors: { primary: stkSurfaceBrand1Strong } } } };
+      `,
+      'src/App.js': `import { View } from 'react-native'; export const App = () => <View className="flex bg-red-500" />;`,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(usage(result, 'flex')).toBeUndefined();
+    expect(usage(result, 'bg-red-500')).toBeUndefined();
+    expect(result.report.total).toBe(0);
+  });
+
+  it('does not count a dynamic className expression (ternary) since it is not statically resolvable', () => {
+    const root = fixture({
+      'package.json': NATIVEWIND_PKG,
+      'tailwind.config.js': `
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        module.exports = { theme: { extend: { colors: { primary: stkSurfaceBrand1Strong } } } };
+      `,
+      'src/App.js': `
+        import { View } from 'react-native';
+        export const App = ({ active }) => <View className={active ? 'bg-primary' : 'bg-primary'} />;
+      `,
+    });
+    const result = resolveRnTailwindTokens(root, { platform: 'native' });
+    expect(result.report.total).toBe(0);
+  });
+});
+
+describe('resolveRnTailwindTokens — platform scope', () => {
+  it('throws for a non-native platform since NativeWind is the RN analog of web Tailwind', () => {
+    const root = fixture({ 'package.json': NATIVEWIND_PKG });
+    expect(() => resolveRnTailwindTokens(root, { platform: 'web' })).toThrow(/native/i);
+  });
+});