rnwind 0.0.4 → 0.0.5

package/src/metro/state.ts

@@ -4,6 +4,7 @@ import { createHash } from 'node:crypto'
 import { UnionBuilder } from '../core/style-builder'
 import { TailwindParser, type SourceEntry } from '../core/parser'
 import { resolveThemeCss } from './css-imports'
+import { buildWrapModules } from './wrap-imports'
 
 /**
  * Default oxide Scanner globs — walk every JS/TS source under the
@@ -49,12 +50,8 @@ const CSS_ENTRY_ENV = 'RNWIND_CSS_ENTRY_FILE'
 const CACHE_DIR_ENV = 'RNWIND_CACHE_DIR'
 /** Env var carrying `watchFolders` from Metro config (NUL-separated). */
 const WATCH_FOLDERS_ENV = 'RNWIND_WATCH_FOLDERS'
-/** Env var carrying extra className prefixes the Metro config supplied. */
-const CLASSNAME_PREFIXES_ENV = 'RNWIND_CLASSNAME_PREFIXES'
-/** Env var carrying extra import sources whose JSX exports get className→style rewrites. Comma-separated. */
-const HOST_SOURCES_ENV = 'RNWIND_HOST_SOURCES'
-/** Env var carrying extra JSX tag names (verbatim, may contain `.`) treated as hosts. Comma-separated. */
-const HOST_COMPONENTS_ENV = 'RNWIND_HOST_COMPONENTS'
+/** Env var carrying extra modules whose component exports get `wrap()`-ed. Comma-separated. */
+const WRAP_MODULES_ENV = 'RNWIND_WRAP_MODULES'
 
 /** Memoised library fingerprint — read once per worker process. */
 let libraryFingerprint: string | undefined
@@ -86,10 +83,10 @@ function readThemeHashFor(cssPath: string): string {
  * dev OR npm install of a new version) the file bytes change, the
  * fingerprint rotates, and Metro's transform cache invalidates.
  *
- * Includes the JSX rewriter (`transform-ast`) alongside the parser /
- * style-builder so a change to the transformer — e.g. renaming the
- * injected context hook — invalidates every stale per-file cache entry
- * on the next dev run. Without this, a user upgrading rnwind in-place
+ * Includes the import-rewriter (`wrap-imports`) and runtime resolver
+ * alongside the parser / style-builder so a change to the transformer —
+ * e.g. renaming the injected wrap helper — invalidates every stale
+ * per-file cache entry on the next dev run. Without this, a user upgrading rnwind in-place
  * would keep loading the old transformed bytes; React-refresh would
  * then preserve fiber state across the version bump and the rendered
  * hook list could shift, surfacing as "change in the order of Hooks"
@@ -105,14 +102,14 @@ function getLibraryFingerprint(): string {
     path.resolve(here, '..', 'core', 'style-builder', 'build-style.cjs'),
     path.resolve(here, '..', 'core', 'parser', 'tw-parser.mjs'),
     path.resolve(here, '..', 'core', 'parser', 'tw-parser.cjs'),
-    path.resolve(here, 'transform-ast.mjs'),
-    path.resolve(here, 'transform-ast.cjs'),
+    path.resolve(here, 'wrap-imports.mjs'),
+    path.resolve(here, 'wrap-imports.cjs'),
     path.resolve(here, 'transformer.mjs'),
     path.resolve(here, 'transformer.cjs'),
     // Source-tree fallback for tests + workspace dev (no built lib yet).
     path.resolve(here, '..', '..', 'src', 'core', 'style-builder', 'build-style.ts'),
     path.resolve(here, '..', '..', 'src', 'core', 'parser', 'tw-parser.ts'),
-    path.resolve(here, '..', '..', 'src', 'metro', 'transform-ast.ts'),
+    path.resolve(here, '..', '..', 'src', 'metro', 'wrap-imports.ts'),
     path.resolve(here, '..', '..', 'src', 'metro', 'transformer.ts'),
   ]
   const hash = createHash('sha256')
@@ -148,18 +145,14 @@ export interface RnwindState {
  * can rebuild the same state without re-reading the Metro config.
  * @param cssEntryFile Absolute path to the user's theme CSS.
  * @param cacheDir Absolute path to the cache dir (`.rnwind`).
- * @param watchFolders
- * @param classNamePrefixes Extra JSX prop-name prefixes to rewrite.
- * @param hostSources
- * @param hostComponents
+ * @param watchFolders Monorepo watch folders to scan for atoms.
+ * @param wrapModules Extra modules whose component exports get `wrap()`-ed.
  */
 export function configureRnwindState(
   cssEntryFile: string,
   cacheDir: string,
   watchFolders: readonly string[] = [],
-  classNamePrefixes?: readonly string[],
-  hostSources?: readonly string[],
-  hostComponents?: readonly string[],
+  wrapModules?: readonly string[],
 ): void {
   process.env[CSS_ENTRY_ENV] = cssEntryFile
   process.env[CACHE_DIR_ENV] = cacheDir
@@ -168,59 +161,23 @@ export function configureRnwindState(
   } else {
     process.env[WATCH_FOLDERS_ENV] = watchFolders.join('\0')
   }
-  if (!classNamePrefixes || classNamePrefixes.length === 0) {
-    delete process.env[CLASSNAME_PREFIXES_ENV]
+  if (!wrapModules || wrapModules.length === 0) {
+    delete process.env[WRAP_MODULES_ENV]
   } else {
-    process.env[CLASSNAME_PREFIXES_ENV] = classNamePrefixes.join(',')
-  }
-  if (!hostSources || hostSources.length === 0) {
-    delete process.env[HOST_SOURCES_ENV]
-  } else {
-    process.env[HOST_SOURCES_ENV] = hostSources.join(',')
-  }
-  if (!hostComponents || hostComponents.length === 0) {
-    delete process.env[HOST_COMPONENTS_ENV]
-  } else {
-    process.env[HOST_COMPONENTS_ENV] = hostComponents.join(',')
+    process.env[WRAP_MODULES_ENV] = wrapModules.join(',')
   }
   cached = null
 }
 
 /**
- * Read the caller-configured extra className prefixes out of the
- * worker environment. Returns an empty array when unset — the
- * transformer applies the built-in `contentContainer` default on top
- * either way.
- * @returns User-supplied extra prefixes.
+ * Effective module → wrap-policy map: the built-in defaults merged with
+ * any extra modules the Metro config supplied.
+ * @returns Module → policy map the import-rewrite consults.
  */
-export function getClassNamePrefixes(): readonly string[] {
-  const raw = process.env[CLASSNAME_PREFIXES_ENV]
-  if (!raw || raw.length === 0) return []
-  return raw.split(',').filter((entry) => entry.length > 0)
-}
-
-/**
- * Read the caller-configured extra host module sources out of the
- * worker environment. Empty array when unset — the transformer applies
- * its built-in default list on top either way.
- * @returns User-supplied extra host sources.
- */
-export function getHostSources(): readonly string[] {
-  const raw = process.env[HOST_SOURCES_ENV]
-  if (!raw || raw.length === 0) return []
-  return raw.split(',').filter((entry) => entry.length > 0)
-}
-
-/**
- * Read the caller-configured extra host JSX tag names out of the worker
- * environment. Verbatim names — may include `.` for member expressions
- * like `'Animated.View'`.
- * @returns User-supplied extra host component names.
- */
-export function getHostComponents(): readonly string[] {
-  const raw = process.env[HOST_COMPONENTS_ENV]
-  if (!raw || raw.length === 0) return []
-  return raw.split(',').filter((entry) => entry.length > 0)
+export function getWrapModules(): ReturnType<typeof buildWrapModules> {
+  const raw = process.env[WRAP_MODULES_ENV]
+  const extra = raw && raw.length > 0 ? raw.split(',').filter((entry) => entry.length > 0) : undefined
+  return buildWrapModules(extra)
 }
 
 /**
@@ -261,14 +218,12 @@ export function getRnwindState(projectRoot: string): RnwindState {
  */
 export function getRnwindCacheKey(): string {
   const cssEntry = process.env[CSS_ENTRY_ENV] ?? ''
-  const prefixes = process.env[CLASSNAME_PREFIXES_ENV] ?? ''
-  // Host source / component config changes which JSX tags get rewritten,
-  // so it MUST flip the cache key — otherwise Metro replays stale
-  // transforms (a newly-opted-in host keeps its raw className, a removed
-  // one keeps the rewrite).
-  const hostSources = process.env[HOST_SOURCES_ENV] ?? ''
-  const hostComponents = process.env[HOST_COMPONENTS_ENV] ?? ''
-  return `rnwind:${cssEntry}:${readThemeHashFor(cssEntry)}|lib:${getLibraryFingerprint()}|pfx:${prefixes}|hs:${hostSources}|hc:${hostComponents}`
+  // Wrap-module config changes which import sites get `wrap()`-ed, so it
+  // MUST flip the cache key — otherwise Metro replays stale transforms
+  // (a newly-opted-in module keeps its raw import, a removed one keeps
+  // the wrap).
+  const wrapModules = process.env[WRAP_MODULES_ENV] ?? ''
+  return `rnwind:${cssEntry}:${readThemeHashFor(cssEntry)}|lib:${getLibraryFingerprint()}|wm:${wrapModules}`
 }
 
 /** Drop the cached state — call after editing the theme CSS. */

package/src/metro/transformer.ts

@@ -4,8 +4,8 @@ import { parse } from '@babel/parser'
 import generate from '@babel/generator'
 import { createHash } from 'node:crypto'
 import { realpathSync } from 'node:fs'
-import { transformAst } from './transform-ast'
-import { getClassNamePrefixes, getHostComponents, getHostSources, getRnwindCacheKey, getRnwindState, onThemeChange } from './state'
+import { getRnwindCacheKey, getRnwindState, getWrapModules, onThemeChange } from './state'
+import { rewriteWrapImports } from './wrap-imports'
 import { STYLE_SPECIFIERS, THEME_SIGNATURE_MODULE } from './resolver'
 import { filterUnknownClassCandidates } from './warn-unknown-classes'
 
@@ -62,15 +62,23 @@ function parseUserSource(source: string): File | null {
  * @param candidates Every candidate oxide surfaced from the source.
  * @param atoms Successfully resolved atoms (keys are class names).
  * @param filename Source path, prefixed onto the warning.
+ * @param features Feature-atom maps (gradient / haptic) — their names are
+ *   known classes even though they carry no RN style, so they're excluded
+ *   from the unknown-class warning.
  */
 function warnUnknownClasses(
   source: string,
   candidates: readonly string[],
   atoms: ReadonlyMap<string, unknown>,
   filename: string,
+  features: ReadonlyArray<ReadonlyMap<string, unknown>> = [],
 ): void {
-  const atomNames = new Set(atoms.keys())
-  const unknown = filterUnknownClassCandidates(source, candidates, atomNames)
+  // Feature atoms (gradient / haptic) resolve to no RN style, so they're
+  // absent from `atoms` — but they're NOT unknown. Fold their names into
+  // the known set so `active:haptic-rigid` etc. don't warn at build time.
+  const known = new Set(atoms.keys())
+  for (const map of features) for (const name of map.keys()) known.add(name)
+  const unknown = filterUnknownClassCandidates(source, candidates, known)
   if (unknown.length === 0) return
   // eslint-disable-next-line no-console
   console.warn(`rnwind: unknown class${unknown.length > 1 ? 'es' : ''} in ${filename}: ${unknown.join(', ')}`)
@@ -114,56 +122,183 @@ function isThemeCssEntry(filename: string): boolean {
 }
 
 /**
- * Parse + run rnwind's JSX rewrite + regenerate source code. When
- * parsing or transformation fails, fall back to the original source —
- * we don't want a transient parse error to crash Metro for a file the
- * upstream might handle fine.
+ * Wrap host imports + compile any className literals, then regenerate
+ * source. Two paths:
+ *  - **className present**: oxide-scan the file, record its atoms into
+ *    the union, and inject the generated-style + theme-signature
+ *    side-effect imports so the runtime registries populate.
+ *  - **import-only** (a `{...rest}` forwarder or a leaf with no literal
+ *    `className=`): just wrap the host imports so a forwarded className
+ *    still resolves at render — no oxide scan, no injected imports.
+ *
+ * On parse failure, fall back to the original source — a transient parse
+ * error shouldn't crash Metro for a file the upstream might handle fine.
  * @param args Metro args; `src` is the original source text.
- * @returns Rewritten source text (with `className=` rewrites applied).
+ * @returns Rewritten source text.
  */
 async function rewriteSource(args: BabelTransformerArgs): Promise<string> {
   const ast = parseUserSource(args.src)
   if (!ast) return args.src
 
+  // Wrap host component imports so `<View className=…>` resolves at render
+  // through the runtime `wrap` (works for literal, spread, and forwarded
+  // classNames alike). No JSX is rewritten here.
+  const wrapped = rewriteWrapImports(ast, getWrapModules())
+
+  if (!/classname=/i.test(args.src)) {
+    // Import-only file: nothing to compile. Drop any stale atom
+    // contribution (className may have just been removed) and emit the
+    // wrapped imports — or the untouched source when nothing wrapped.
+    dropFileSafely(args.filename, projectRootOf(args))
+    return wrapped ? generateModule(ast).code : args.src
+  }
+
   const state = getRnwindState(projectRootOf(args))
   const extension = extensionOf(args.filename)
   const parsed = await state.parser.parseAtoms({ content: args.src, extension })
 
-  warnUnknownClasses(args.src, parsed.candidates, parsed.atoms, args.filename)
+  warnUnknownClasses(args.src, parsed.candidates, parsed.atoms, args.filename, [parsed.gradientAtoms, parsed.hapticAtoms])
 
-  const classNamePrefixes = getClassNamePrefixes()
-  const hostSources = getHostSources()
-  const hostComponents = getHostComponents()
   if (parsed.atoms.size === 0) {
     state.builder.dropFile(args.filename)
     await state.builder.writeSchemes()
-    transformAst(ast, {
-      styleSpecifiers: [],
-      gradientAtoms: parsed.gradientAtoms,
-      hapticAtoms: parsed.hapticAtoms,
-      classNamePrefixes,
-      hostSources,
-      hostComponents,
-    })
     injectThemeSignatureImport(ast)
     return generateModule(ast).code
   }
 
-  const { changed } = await state.builder.recordFile(args.filename, parsed.atoms, parsed.keyframes)
+  const literals = collectClassNameLiterals(ast)
+  const { changed } = await state.builder.recordFile(args.filename, parsed.atoms, parsed.keyframes, literals)
   if (changed) await state.builder.writeSchemes()
 
-  transformAst(ast, {
-    styleSpecifiers: STYLE_SPECIFIERS as unknown as readonly string[],
-    gradientAtoms: parsed.gradientAtoms,
-    hapticAtoms: parsed.hapticAtoms,
-    classNamePrefixes,
-    hostSources,
-    hostComponents,
-  })
+  injectSideEffectImports(ast, STYLE_SPECIFIERS)
   injectThemeSignatureImport(ast)
   return generateModule(ast).code
 }
 
+/**
+ * Drop a file's union contribution, swallowing the "state not configured"
+ * error unit tests hit when they call the transformer without
+ * `configureRnwindState`.
+ * @param filename Absolute source path.
+ * @param projectRoot Project root for state lookup.
+ */
+function dropFileSafely(filename: string, projectRoot: string): void {
+  try {
+    getRnwindState(projectRoot).builder.dropFile(filename)
+  } catch {
+    // State not configured (standalone/unit test). Nothing to drop.
+  }
+}
+
+/**
+ * Whether a JSX attribute names a className-style prop (`className` or
+ * any `<prefix>ClassName`).
+ * @param node JSX attribute node.
+ * @returns True when the attribute is a className prop.
+ */
+function isClassNameAttribute(node: t.JSXAttribute): boolean {
+  if (!t.isJSXIdentifier(node.name)) return false
+  const {name} = node.name
+  return name === 'className' || name.endsWith('ClassName')
+}
+
+/**
+ * Pull static string literals out of a className expression. Handles a
+ * bare string, a no-substitution template, and the branches of a
+ * ternary / `&&` (so `cond ? 'a' : 'b'` and `flag && 'x'` both register
+ * their literals). Dynamic interpolations are skipped — they resolve via
+ * the runtime atom path.
+ * @param expr Expression inside a `className={...}` container.
+ * @param out Accumulator for discovered literals.
+ */
+function collectLiteralsFromExpression(expr: t.Expression | t.JSXEmptyExpression | null | undefined, out: string[]): void {
+  if (!expr) return
+  if (t.isStringLiteral(expr)) {
+    out.push(expr.value)
+    return
+  }
+  if (t.isTemplateLiteral(expr) && expr.expressions.length === 0 && expr.quasis.length === 1) {
+    const cooked = expr.quasis[0]?.value.cooked
+    if (typeof cooked === 'string') out.push(cooked)
+    return
+  }
+  if (t.isConditionalExpression(expr)) {
+    collectLiteralsFromExpression(expr.consequent, out)
+    collectLiteralsFromExpression(expr.alternate, out)
+    return
+  }
+  if (t.isLogicalExpression(expr)) {
+    collectLiteralsFromExpression(expr.right as t.Expression, out)
+  }
+}
+
+/** AST node keys the literal walk skips — position / comment metadata. */
+const SKIP_WALK_KEYS = new Set(['type', 'loc', 'start', 'end', 'range', 'leadingComments', 'trailingComments', 'innerComments'])
+
+/**
+ * Collect the static literals from one className JSX attribute into the
+ * dedup accumulator.
+ * @param attribute The (already className-matched) JSX attribute.
+ * @param seen Dedup set of literals already collected.
+ * @param out Ordered accumulator.
+ */
+function collectAttributeLiterals(attribute: t.JSXAttribute, seen: Set<string>, out: string[]): void {
+  const { value } = attribute
+  const found: string[] = []
+  if (t.isStringLiteral(value)) found.push(value.value)
+  else if (t.isJSXExpressionContainer(value)) collectLiteralsFromExpression(value.expression, found)
+  for (const literal of found) {
+    if (seen.has(literal)) continue
+    seen.add(literal)
+    out.push(literal)
+  }
+}
+
+/**
+ * Walk the AST for every `className=` / `<prefix>ClassName=` literal so
+ * the builder can pre-merge each into a per-scheme molecule. A generic
+ * node walk (no scope build) keeps it cheap; only JSX attribute nodes do
+ * any work.
+ * @param ast Parsed Babel file.
+ * @returns Distinct literal className strings, in first-seen order.
+ */
+function collectClassNameLiterals(ast: File): readonly string[] {
+  const out: string[] = []
+  const seen = new Set<string>()
+  const visit = (node: unknown): void => {
+    if (!node || typeof node !== 'object') return
+    if (Array.isArray(node)) {
+      for (const child of node) visit(child)
+      return
+    }
+    const typed = node as { type?: string; [key: string]: unknown }
+    if (typeof typed.type !== 'string') return
+    if (typed.type === 'JSXAttribute' && isClassNameAttribute(node as t.JSXAttribute)) {
+      collectAttributeLiterals(node as t.JSXAttribute, seen, out)
+    }
+    for (const key in typed) {
+      if (SKIP_WALK_KEYS.has(key)) continue
+      visit(typed[key])
+    }
+  }
+  visit(ast.program)
+  return out
+}
+
+/**
+ * Prepend side-effect imports (`import '<spec>'`) so the generated
+ * per-scheme style + manifest modules load — registering this file's
+ * atoms / molecules / features into the runtime registries the wrapper's
+ * `resolve` reads.
+ * @param ast Babel File AST to mutate in place.
+ * @param specifiers Module specifiers to side-effect-import.
+ */
+function injectSideEffectImports(ast: File, specifiers: readonly string[]): void {
+  for (const specifier of specifiers) {
+    ast.program.body.unshift(t.importDeclaration([], t.stringLiteral(specifier)))
+  }
+}
+
 /**
  * Prepend `import 'rnwind/__generated/theme-signature'` to every
  * rnwind-transformed file. The resolver maps that specifier to the
@@ -252,10 +387,16 @@ function loadUpstream(): UpstreamTransformer | null {
  */
 function isRewriteCandidate(args: BabelTransformerArgs): boolean {
   if (!/\.(?:tsx|ts|jsx|js)$/i.test(args.filename)) return false
-  // Case-insensitive so `<prefix>ClassName=` (e.g. `contentContainerClassName=`)
-  // — which has a capital `C` and so doesn't contain the lowercase
-  // `className=` — still routes the file through the rewrite pass.
-  if (!/classname=/i.test(args.src)) return false
+  // Process the file when it either:
+  //  - carries a `className=` / `<prefix>ClassName=` literal (case-
+  //    insensitive — `contentContainerClassName=` has a capital C), or
+  //  - spreads props (`{...rest}`) onto a host from a wrap-module, where a
+  //    forwarded className must still get its import wrapped (no literal
+  //    appears in this file). A style-less `<View/>` with neither is left
+  //    alone so it never pays for an unused wrapper.
+  const hasClassName = /classname=/i.test(args.src)
+  const isForwarder = /\{\s*\.\.\./.test(args.src) && mentionsWrapModule(args.src)
+  if (!hasClassName && !isForwarder) return false
   if (!args.filename.includes('/node_modules/')) return true
   // node_modules in path → could be a workspace symlink; resolve it.
   try {
@@ -266,6 +407,21 @@ function isRewriteCandidate(args: BabelTransformerArgs): boolean {
   }
 }
 
+/**
+ * Cheap pre-parse check: does the source import from any configured
+ * wrap-module? A quoted specifier match is enough — `rewriteWrapImports`
+ * re-verifies precisely on the AST, so a false positive only costs a
+ * no-op parse.
+ * @param source Source text.
+ * @returns True when a wrap-module specifier appears in the source.
+ */
+function mentionsWrapModule(source: string): boolean {
+  for (const moduleName of getWrapModules().keys()) {
+    if (source.includes(`'${moduleName}'`) || source.includes(`"${moduleName}"`)) return true
+  }
+  return false
+}
+
 /**
  * Fallback parse when no upstream is configured AND Metro didn't hand
  * us an AST. Used by unit tests and standalone setups.

package/src/metro/with-config.ts

@@ -127,35 +127,20 @@ export interface RnwindMetroOptions {
   /** Cache directory. Absolute, or relative to `projectRoot`. Default: `.rnwind` at project root. */
   cacheDir?: string
   /**
-   * Extra JSX prop-name prefixes that rnwind should rewrite. Each
-   * prefix `P` turns `<Tag PClassName="…">` into `<Tag
-   * PStyle={lookupCss(…)}>`. The built-in `'contentContainer'` prefix
-   * is always on (covers ScrollView / FlatList / SectionList); user
-   * entries merge on top.
-   */
-  classNamePrefixes?: readonly string[]
-  /**
-   * Extra module specifiers whose JSX exports rnwind should treat as
-   * "host components" — i.e. tags whose `className="…"` attribute is
-   * rewritten to `style={lookupCss(…)}` at build time (zero runtime
-   * cost). Merged with the built-in defaults: `react-native`,
+   * Extra module specifiers whose component exports rnwind should
+   * auto-wrap at import sites — `import { View } from 'react-native'`
+   * becomes `const View = wrap(_rnw0)` so `<View className="…">` resolves
+   * styles at runtime. Merged with the built-in defaults: `react-native`,
    * `react-native-reanimated`, `react-native-svg`,
-   * `react-native-gesture-handler`, `expo-linear-gradient`, `expo-image`.
+   * `react-native-gesture-handler`, `react-native-safe-area-context`,
+   * `expo-linear-gradient`, `expo-image`, and more.
    *
-   * Anything NOT marked as a host has its `className` left untouched —
-   * the importing component receives the raw string and decides what
-   * to do with it. Use this option to opt your design-system / UI
-   * primitive packages into the zero-runtime path.
-   */
-  hostSources?: readonly string[]
-  /**
-   * Extra JSX tag names (verbatim — may include `.` for member access
-   * like `'Animated.View'`) rnwind should treat as host components,
-   * regardless of where they're imported from. Useful for one-off
-   * escape-hatches: `import { View as MyBox } from 'react-native'`
-   * doesn't change the local name → `'MyBox'` here picks it up.
+   * A module NOT in this list keeps its raw imports — the importing
+   * component receives `className` as a plain prop and can resolve it
+   * via `useCss` / `wrap` itself. Use this to opt your design-system /
+   * UI primitive packages into the auto-wrap path.
    */
-  hostComponents?: readonly string[]
+  wrapModules?: readonly string[]
 }
 
 /** Shape we mutate on Metro's config. Loose so we don't pin Metro's internal types. */
@@ -202,7 +187,7 @@ export function withRnwindConfig<C extends MetroConfigLike>(metroConfig: C, opti
 
   mkdirSync(cacheDir, { recursive: true })
   const watchFolders = (metroConfig.watchFolders ?? []).filter((p) => typeof p === 'string' && p.length > 0)
-  configureRnwindState(cssEntry, cacheDir, watchFolders, options.classNamePrefixes, options.hostSources, options.hostComponents)
+  configureRnwindState(cssEntry, cacheDir, watchFolders, options.wrapModules)
 
   // Warm the state eagerly (in the Metro master process) so oxide's
   // Scanner walks every project source (and every monorepo
@@ -238,7 +223,7 @@ export function withRnwindConfig<C extends MetroConfigLike>(metroConfig: C, opti
   if (options.dtsFile !== false) {
     const dtsPath = options.dtsFile ?? path.resolve(projectRoot, 'rnwind-types.d.ts')
     const schemes = discoverSchemes(cssEntry, projectRoot)
-    writeDtsFile(dtsPath, schemes, options.classNamePrefixes)
+    writeDtsFile(dtsPath, schemes)
   }
 
   // Watch the theme CSS. On edit, we rewrite scheme files AND touch