rainbowindex 0.6.0 → 0.7.0

package/dist/cli.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 import {
-  CSS_ENTRY_CANDIDATES,
-  enumerateClassNames
-} from "./chunk-ZR7XJMUN.mjs";
+  snapshotFromCSS
+} from "./chunk-6OORICWF.mjs";
 import {
   DEFAULT_EXCLUDES,
   DEFAULT_PATTERNS,
@@ -10,39 +9,74 @@ import {
   disableScanChangeTracking,
   enableScanChangeTracking,
   enableSourceFileListCache,
-  getFontPreloadLinks,
   invalidateSourceFileListCache,
-  markSourceFileChanged
-} from "./chunk-WK6S4HTC.mjs";
+  markSourceFileChanged,
+  resolveSourceFilesAsync
+} from "./chunk-2T7V5XLK.mjs";
+import {
+  CANONICAL_COLOR_STOPS,
+  CSS_ENTRY_CANDIDATES,
+  createClassInspector,
+  enumerateClassNames,
+  listThemeTokens,
+  outermostCandidates,
+  resolveColorSwatch
+} from "./chunk-WBESS2ZD.mjs";
+import {
+  createNodeImportResolver
+} from "./chunk-W756NVYI.mjs";
 import {
   MAX_DIRECTIVE_INPUT_SIZE,
+  analyzeProjectCSS,
   codepointCompare,
+  extractClassCandidates,
   extractClassesFromSource,
   extractDirectives,
+  findClosingBrace,
+  getFontPreloadLinks,
   hasApplyLikeDirective,
   hasRIActivation,
+  inlineDirectiveImports,
   listVariants,
-  resolveDirectives
-} from "./chunk-KSNYSR3C.mjs";
+  resolveDirectives,
+  stripCSSComments
+} from "./chunk-FJOZJIKB.mjs";
+import "./chunk-L56IRO7A.mjs";
 import {
   devWarn
-} from "./chunk-6U4IOFOS.mjs";
+} from "./chunk-XQGSG2HK.mjs";
 
 // src/entries/cli.ts
 import { realpathSync } from "fs";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve10 } from "path";
 import { pathToFileURL } from "url";
 
 // src/cli/args.ts
 import { relative, resolve } from "path";
-var OUTPUT = {
+var WRITE = {
+  names: ["--write"],
+  describe: "Apply the migration in place (default: write a preview beside it)",
+  apply(opts) {
+    opts.write = true;
+  }
+};
+var cssInput = (describe) => ({
+  names: ["--css"],
+  valueName: "<file>",
+  describe,
+  apply(opts, value) {
+    opts.cssFile = value;
+  }
+});
+var output = (describe) => ({
   names: ["-o", "--output"],
   valueName: "<file>",
-  describe: "Output CSS file path (omit to write to stdout)",
+  describe,
   apply(opts, value) {
     opts.output = value;
   }
-};
+});
+var OUTPUT = output("Output CSS file path (omit to write to stdout)");
 var WATCH = {
   names: ["--watch"],
   describe: "Re-run on source-file changes (requires --output)",
@@ -73,33 +107,14 @@ var TEMPLATE = {
     opts.template = value;
   }
 };
-var applyCSSFile = (opts, value) => {
-  opts.cssFile = value;
-};
-var CSS_INPUT = {
-  names: ["--css"],
-  valueName: "<file>",
-  describe: "CSS input with directives (auto-detected if omitted)",
-  apply: applyCSSFile
-};
-var CSS_INPUT_TYPES = {
-  names: ["--css"],
-  valueName: "<file>",
-  describe: "CSS input with @color/@text/@utility/etc directives",
-  apply: applyCSSFile
-};
-var CSS_INPUT_FONTS = {
-  names: ["--css"],
-  valueName: "<file>",
-  describe: "CSS input with @font directives",
-  apply: applyCSSFile
-};
-var CSS_TARGET = {
-  names: ["--css"],
-  valueName: "<file>",
-  describe: "Stylesheet path to create/patch (default: src/index.css)",
-  apply: applyCSSFile
-};
+var CSS_INPUT = cssInput("CSS input with directives (auto-detected if omitted)");
+var CSS_INPUT_TYPES = cssInput("CSS input with @color/@text/@utility/etc directives");
+var CSS_INPUT_FONTS = cssInput("CSS input with @font directives");
+var TOKENS_OUTPUT = output(
+  "Token module path (default: rainbowindex-tokens.ts); tokens.json lands beside it"
+);
+var SNAPSHOT_OUTPUT = output("Snapshot module path (default: rainbowindex-snapshot.ts)");
+var CSS_TARGET = cssInput("Stylesheet path to create/patch (default: src/index.css)");
 var COMMANDS = {
   build: {
     summary: "Generate CSS from source files",
@@ -147,6 +162,27 @@ Examples:
   rainbowindex create my-app
   rainbowindex create my-app --template vue-ts`
   },
+  migrate: {
+    summary: "Translate a Tailwind v4 project into Rainbow Index directives",
+    usage: "  rainbowindex migrate tailwind [glob...] [options]",
+    intro: `What this does:
+  1. Finds the Tailwind CSS entry and translates its @theme into directives.
+  2. Adds @import "rainbowindex/tailwind.css" so the familiar class names
+     keep resolving, and keeps your dark-mode strategy.
+  3. Scans the globs you pass and reports every class the new theme rejects.
+  4. Writes migration-report.md with what still needs a person.`,
+    flags: [CSS_INPUT, WRITE],
+    positionals: "migrate",
+    body: `Safety:
+  Nothing is overwritten without --write. By default the translated entry is
+  written beside the original as <name>.rainbowindex.css so you can read it
+  first. With --write, the original is kept as <name>.css.tailwind.bak.
+
+Examples:
+  rainbowindex migrate tailwind
+  rainbowindex migrate tailwind "src/**/*.{ts,tsx}"
+  rainbowindex migrate tailwind --css app/globals.css --write`
+  },
   "generate-types": {
     summary: "Generate TypeScript types for ri() autocomplete",
     usage: "  rainbowindex generate-types [options]",
@@ -160,6 +196,57 @@ Examples:
   rainbowindex generate-types
   rainbowindex generate-types --strict --css src/styles.css`
   },
+  "generate-snapshot": {
+    summary: "Generate a theme snapshot module so client ri() is theme-aware",
+    usage: "  rainbowindex generate-snapshot [options]",
+    flags: [CSS_INPUT_TYPES, SNAPSHOT_OUTPUT],
+    positionals: "none",
+    body: `Why:
+  \`ri()\` asks the published theme whether \`text-lg\` is a size or a color. A
+  browser bundle runs no compile, so without a published theme it guesses, and
+  a size can be read as a color and dropped. The Vite plugin handles this on
+  its own \u2014 this command is for every other bundler.
+
+Output:
+  Writes \`rainbowindex-snapshot.ts\` to the current working directory. Import
+  it once, as early as possible in your entry point:
+
+    import "./rainbowindex-snapshot";
+
+  It also exports \`ri\` bound to that snapshot, for multi-tenant rendering.
+  Re-run it when the theme changes; unchanged input rewrites nothing.
+
+Examples:
+  rainbowindex generate-snapshot
+  rainbowindex generate-snapshot --css src/styles.css -o src/theme.ts`
+  },
+  "generate-tokens": {
+    summary: "Generate typed token exports and a W3C Design Tokens file",
+    usage: "  rainbowindex generate-tokens [options]",
+    flags: [CSS_INPUT_TYPES, TOKENS_OUTPUT],
+    positionals: "none",
+    body: `Why:
+  A class is the right way to style an element and the wrong way to hand a
+  chart library a series color or a canvas a fill. Those need the token's
+  value. This writes the theme as data, so that code can read it without
+  re-declaring the palette in JavaScript.
+
+Output:
+  \`rainbowindex-tokens.ts\` \u2014 \`tokens.color.brand[500]\`, typed \`as const\`, so a
+  typo is a compile error and the editor completes the names. The values are
+  \`var()\` references rather than literals, so they still follow the cascade.
+
+  \`tokens.json\` beside it \u2014 the same theme in the W3C Design Tokens format,
+  with values resolved to hex, which is what Style Dictionary and Figma
+  importers read. A design tool has no cascade to resolve a \`var()\` against.
+
+  Both are sorted and derived from the CSS entry alone, so re-running on an
+  unchanged theme rewrites nothing.
+
+Examples:
+  rainbowindex generate-tokens
+  rainbowindex generate-tokens --css src/styles.css -o src/tokens.ts`
+  },
   scan: {
     summary: "Show what the class scanner extracts (debugging)",
     usage: "  rainbowindex scan <file|glob...>",
@@ -211,6 +298,7 @@ function parseArgs(argv, callbacks) {
     watch: false,
     minify: false,
     strict: false,
+    write: false,
     subcommandExplicit: false,
     earlyExit: false
   };
@@ -280,8 +368,18 @@ function parseArgs(argv, callbacks) {
       opts.targetDir = arg;
       continue;
     }
+    if (spec.positionals === "migrate") {
+      if (opts.migrateSource === void 0) opts.migrateSource = arg;
+      else opts.globs.push(arg);
+      continue;
+    }
     throw new Error(`Unexpected extra argument "${arg}" for ${opts.command}.`);
   }
+  if (opts.command === "migrate" && opts.migrateSource === void 0) {
+    throw new Error(
+      "migrate requires a source. The only one is `tailwind`: rainbowindex migrate tailwind"
+    );
+  }
   if (opts.command === "create" && !opts.targetDir) {
     throw new Error("create requires a project directory. Example: rainbowindex create my-app");
   }
@@ -347,7 +445,10 @@ Usage:
   rainbowindex <glob> [options]        Generate CSS from source files
   rainbowindex init                    Wire Rainbow Index into the current Vite app
   rainbowindex create <dir>            Scaffold a Vite app with Rainbow Index ready
+  rainbowindex migrate tailwind        Translate a Tailwind v4 project into directives
   rainbowindex generate-types          Generate TypeScript types for ri()
+  rainbowindex generate-snapshot       Generate the theme snapshot for client ri()
+  rainbowindex generate-tokens         Generate typed token exports + tokens.json
   rainbowindex preload-fonts           Generate font preload link tags
   rainbowindex scan <file...>          Show what the class scanner extracts
 
@@ -414,20 +515,32 @@ async function readCSSFileAsync(cssFile) {
   return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
 }
 async function loadProjectCSS(opts, cwd) {
+  const load = async (cssFile2) => {
+    const inlined = inlineDirectiveImports(await readCSSFileAsync(cssFile2), {
+      resolve: createNodeImportResolver({ cwd }),
+      from: cssFile2
+    });
+    return {
+      css: inlined.css,
+      cssFile: cssFile2,
+      imports: inlined.files,
+      warnings: inlined.warnings
+    };
+  };
   if (opts.cssFile) {
     const cssFile2 = resolve2(cwd, opts.cssFile);
     if (!existsSync(cssFile2)) {
       throw new Error(`[RI-1605] CSS input file not found: ${cssFile2}`);
     }
-    return { css: await readCSSFileAsync(cssFile2), cssFile: cssFile2 };
+    return load(cssFile2);
   }
   const cssFile = await findCSSFileAsync(cwd);
-  if (!cssFile) return { css: "", cssFile: null };
-  return { css: await readCSSFileAsync(cssFile), cssFile };
+  if (!cssFile) return { css: "", cssFile: null, imports: [], warnings: [] };
+  return load(cssFile);
 }
 async function loadProjectTheme(opts, cwd) {
-  const { css } = await loadProjectCSS(opts, cwd);
-  const parseWarnings = [];
+  const { css, warnings } = await loadProjectCSS(opts, cwd);
+  const parseWarnings = [...warnings];
   const directives = extractDirectives(css, parseWarnings);
   const theme = resolveDirectives(directives);
   for (const w of parseWarnings) console.error(w);
@@ -436,7 +549,7 @@ async function loadProjectTheme(opts, cwd) {
 
 // src/cli/build.ts
 async function buildCSS(opts, cwd) {
-  const { css: cssSource, cssFile } = await loadProjectCSS(opts, cwd);
+  const { css: cssSource, cssFile, warnings: importWarnings } = await loadProjectCSS(opts, cwd);
   const { compiled } = await compileScannedProject({
     css: cssSource,
     cssPath: cssFile ?? void 0,
@@ -445,9 +558,12 @@ async function buildCSS(opts, cwd) {
     onInvalidPattern: (err) => {
       console.error(`[RI-1404] CLI glob pattern rejected: ${err}`);
       return void 0;
-    }
+    },
+    // loadProjectCSS already inlined them; a second pass would find nothing
+    // and would re-emit the same unresolved-import warnings.
+    resolveImport: null
   });
-  const buildWarnings = [];
+  const buildWarnings = [...importWarnings];
   if (hasApplyLikeDirective(cssSource)) {
     buildWarnings.push(
       '[RI-1009] @apply is only supported via the PostCSS plugin. To expand @apply: (1) add `postcss.config.js` with `import rainbowindex from "rainbowindex"; export default { plugins: [rainbowindex()] };`, or (2) use the Vite plugin (`import rainbowindex from "rainbowindex/vite"`), which wires PostCSS automatically. The CLI does not run PostCSS so it cannot expand @apply.'
@@ -476,10 +592,227 @@ async function buildCSS(opts, cwd) {
   return { css: compiled.css, theme: compiled.theme, cssFile };
 }
 
+// src/cli/generate-snapshot.ts
+import { relative as relative2, resolve as resolve3 } from "path";
+
+// src/cli/atomic-write.ts
+import { writeFile, rename, unlink } from "fs/promises";
+import { dirname, join } from "path";
+function isIgnorableCleanupError(err) {
+  return !!err && typeof err === "object" && "code" in err && (err.code === "ENOENT" || err.code === "EPERM");
+}
+async function writeFileAtomic(filePath, content) {
+  const dir = dirname(filePath);
+  const tmp = join(dir, `.ri-tmp-${process.pid}-${Date.now()}`);
+  try {
+    await writeFile(tmp, content);
+    await rename(tmp, filePath);
+  } catch (err) {
+    try {
+      await unlink(tmp);
+    } catch (cleanupErr) {
+      if (!isIgnorableCleanupError(cleanupErr)) {
+        const msg = cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr);
+        devWarn(`[RI-DEV] Failed to remove temp file "${tmp}": ${msg}`);
+      }
+    }
+    throw err;
+  }
+}
+
+// src/cli/generate-snapshot.ts
+var SNAPSHOT_FILE = "rainbowindex-snapshot.ts";
+async function generateSnapshot(opts, cwd) {
+  const { css, cssFile, warnings } = await loadProjectCSS(opts, cwd);
+  for (const warning of warnings) console.error(warning);
+  const analysis = analyzeProjectCSS(css);
+  for (const warning of analysis.warnings) console.error(warning);
+  const snapshot = snapshotFromCSS(css);
+  const source = cssFile === null ? "no CSS entry found" : relative2(cwd, cssFile);
+  const outPath = resolve3(cwd, opts.output ?? SNAPSHOT_FILE);
+  const body = `/**
+ * Generated by \`rainbowindex generate-snapshot\` from ${source}.
+ * Do not edit. Re-run the command when the theme changes.
+ *
+ * Import this once, as early as possible in your entry point:
+ *
+ *   import "./${relative2(cwd, outPath).split("\\\\").join("/")}";
+ *
+ * That publishes the theme, so the default \`ri()\` resolves your project's
+ * text sizes, weights, font slots, and color names. Without it \`ri()\` has no
+ * theme and can read a size as a color and drop it.
+ *
+ * For multi-tenant rendering \u2014 more than one theme in one process \u2014 import
+ * \`ri\` from here instead of from "rainbowindex": it is bound to this snapshot
+ * and shares no module state.
+ */
+import { createRi, hydrateSnapshot, publishSnapshot } from "rainbowindex";
+
+export const snapshot = hydrateSnapshot(${JSON.stringify(snapshot, null, "	")});
+
+publishSnapshot(snapshot);
+
+export const ri = createRi(snapshot);
+`;
+  await writeFileAtomic(outPath, body);
+  console.log(`[rainbowindex] Wrote: ${relative2(cwd, outPath)}`);
+}
+
+// src/cli/generate-tokens.ts
+import { relative as relative3, resolve as resolve4 } from "path";
+var TOKENS_FILE = "rainbowindex-tokens.ts";
+var TOKENS_JSON_FILE = "tokens.json";
+function byKey([a], [b]) {
+  const na = /^\d+$/.test(a);
+  const nb = /^\d+$/.test(b);
+  if (na && nb) return Number(a) - Number(b);
+  if (na !== nb) return na ? -1 : 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function key(name) {
+  return IDENT_RE.test(name) ? name : JSON.stringify(name);
+}
+function renderObject(value, indent) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number") return String(value);
+  const entries = Object.entries(value).sort(byKey);
+  if (entries.length === 0) return "{}";
+  const inner = entries.map(([k, v]) => `${indent}	${key(k)}: ${renderObject(v, `${indent}	`)},`).join("\n");
+  return `{
+${inner}
+${indent}}`;
+}
+function buildVarTokens(theme) {
+  const tokens = listThemeTokens(theme);
+  const out = {};
+  const color = {};
+  for (const { name, kind } of tokens.colors) {
+    if (kind === "generative") {
+      const stops = {};
+      for (const stop of CANONICAL_COLOR_STOPS) {
+        stops[String(stop)] = `var(--color-${name}-${stop})`;
+      }
+      color[name] = stops;
+    } else {
+      color[name] = `var(--color-${name})`;
+    }
+  }
+  if (Object.keys(color).length > 0) out.color = color;
+  const simple = [
+    ["text", "text", Object.fromEntries(tokens.textSizes.map((t) => [t.name, t.fontSize]))],
+    ["breakpoint", "breakpoint", tokens.breakpoints],
+    ["shadow", "shadow", tokens.shadows],
+    ["weight", "weight", tokens.weights],
+    ["ease", "ease", tokens.easing],
+    ["blur", "blur", tokens.blur],
+    ["z", "z", tokens.z],
+    ["leading", "leading", tokens.leading],
+    ["tracking", "tracking", tokens.tracking],
+    ["opacity", "opacity", tokens.opacity],
+    ["duration", "duration", tokens.duration],
+    ["rounded", "rounded", tokens.radii],
+    ["animate", "animate", Object.fromEntries(tokens.animations.map((n) => [n, n]))]
+  ];
+  for (const [group, prefix, values] of simple) {
+    const names = Object.keys(values);
+    if (names.length === 0) continue;
+    out[group] = Object.fromEntries(names.map((n) => [n, `var(--${prefix}-${n})`]));
+  }
+  if (tokens.fonts.length > 0) {
+    out.font = Object.fromEntries(tokens.fonts.map((f) => [f.slot, `var(--font-${f.slot})`]));
+  }
+  return out;
+}
+function buildDesignTokens(theme) {
+  const tokens = listThemeTokens(theme);
+  const out = {};
+  const color = {};
+  for (const { name, kind } of tokens.colors) {
+    if (kind === "generative") {
+      const stops = {};
+      for (const stop of CANONICAL_COLOR_STOPS) {
+        const swatch2 = resolveColorSwatch(theme, name, stop);
+        if (swatch2 === null) continue;
+        stops[String(stop)] = { $type: "color", $value: swatch2.light.hex };
+      }
+      if (Object.keys(stops).length > 0) color[name] = stops;
+      continue;
+    }
+    const swatch = resolveColorSwatch(theme, name);
+    if (swatch !== null) color[name] = { $type: "color", $value: swatch.light.hex };
+  }
+  if (Object.keys(color).length > 0) out.color = color;
+  const typed = [
+    ["text", "dimension", Object.fromEntries(tokens.textSizes.map((t) => [t.name, t.fontSize]))],
+    ["breakpoint", "dimension", tokens.breakpoints],
+    ["tracking", "dimension", tokens.tracking],
+    ["blur", "dimension", tokens.blur],
+    ["rounded", "dimension", tokens.radii],
+    ["weight", "fontWeight", tokens.weights],
+    ["duration", "duration", tokens.duration],
+    ["ease", "cubicBezier", tokens.easing],
+    ["shadow", "shadow", tokens.shadows],
+    ["leading", "number", tokens.leading],
+    ["opacity", "number", tokens.opacity],
+    ["z", "number", tokens.z]
+  ];
+  for (const [group, type, values] of typed) {
+    const names = Object.keys(values);
+    if (names.length === 0) continue;
+    out[group] = Object.fromEntries(
+      names.map((n) => [n, { $type: type, $value: String(values[n]) }])
+    );
+  }
+  if (tokens.fonts.length > 0) {
+    out.font = Object.fromEntries(
+      tokens.fonts.map((f) => [f.slot, { $type: "fontFamily", $value: f.family }])
+    );
+  }
+  return out;
+}
+function sortDeep(value) {
+  if (Array.isArray(value)) return value.map(sortDeep);
+  if (value === null || typeof value !== "object") return value;
+  const entries = Object.entries(value).sort(byKey);
+  return Object.fromEntries(entries.map(([k, v]) => [k, sortDeep(v)]));
+}
+async function generateTokens(opts, cwd) {
+  const { css, cssFile, warnings } = await loadProjectCSS(opts, cwd);
+  for (const warning of warnings) console.error(warning);
+  const analysis = analyzeProjectCSS(css);
+  for (const warning of analysis.warnings) console.error(warning);
+  const source = cssFile === null ? "no CSS entry found" : relative3(cwd, cssFile);
+  const outPath = resolve4(cwd, opts.output ?? TOKENS_FILE);
+  const jsonPath = resolve4(outPath, "..", TOKENS_JSON_FILE);
+  const body = `/**
+ * Generated by \`rainbowindex generate-tokens\` from ${source}.
+ * Do not edit. Re-run the command when the theme changes.
+ *
+ * Every value is a \`var()\` reference, not a literal, so it still follows the
+ * cascade \u2014 a \`[data-theme]\` override or a dark-mode flip changes what it
+ * resolves to. Use these where a class cannot go: a chart's series colors, a
+ * canvas fill, an inline style computed at runtime.
+ *
+ *   import { tokens } from "./${relative3(cwd, outPath).split("\\\\").join("/").replace(/\.tsx?$/, "")}";
+ *   <Chart color={tokens.color.brand[500]} />
+ */
+export const tokens = ${renderObject(buildVarTokens(analysis.theme), "")} as const;
+
+export type Tokens = typeof tokens;
+`;
+  await writeFileAtomic(outPath, body);
+  console.log(`[rainbowindex] Wrote: ${relative3(cwd, outPath)}`);
+  const designTokens = sortDeep(buildDesignTokens(analysis.theme));
+  await writeFileAtomic(jsonPath, `${JSON.stringify(designTokens, null, "	")}
+`);
+  console.log(`[rainbowindex] Wrote: ${relative3(cwd, jsonPath)}`);
+}
+
 // src/cli/generate-types.ts
 import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile2, writeFile } from "fs/promises";
-import { resolve as resolve3 } from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve5 } from "path";
 async function generateTypes(opts, cwd) {
   const theme = await loadProjectTheme(opts, cwd);
   const SAFE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
@@ -582,14 +915,14 @@ async function generateTypes(opts, cwd) {
     "}",
     ""
   );
-  const outputPath = resolve3(cwd, "rainbowindex-env.d.ts");
+  const outputPath = resolve5(cwd, "rainbowindex-env.d.ts");
   const newContent = lines.join("\n");
   if (existsSync2(outputPath)) {
     const existing = await readFile2(outputPath, "utf-8");
     if (!existing.startsWith("// rainbowindex-env.d.ts (auto-generated")) {
       const backupPath = `${outputPath}.bak`;
       try {
-        await writeFile(backupPath, existing);
+        await writeFile2(backupPath, existing);
         console.warn(
           `[RI-1604] "${outputPath}" exists and does not appear to be auto-generated. Original saved to "${backupPath}" before overwrite.`
         );
@@ -604,7 +937,7 @@ async function generateTypes(opts, cwd) {
     }
   }
   try {
-    await writeFile(outputPath, newContent);
+    await writeFile2(outputPath, newContent);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`[rainbowindex] Failed to write types file "${outputPath}": ${msg}`);
@@ -617,6 +950,642 @@ async function generateTypes(opts, cwd) {
   );
 }
 
+// src/cli/migrate.ts
+import { readFile as readFile3 } from "fs/promises";
+import { readdirSync, readFileSync } from "fs";
+import { basename, dirname as dirname2, join as join2, relative as relative4, resolve as resolve6 } from "path";
+
+// src/migrate/tailwind.ts
+var TAILWIND_IMPORT_RE = /@import\s+["']tailwindcss(?:\/[\w-]+)?["']/;
+var RI_IMPORT_RE = /@import\s+["']rainbowindex(?:\/[\w.-]+)?["']/;
+var TAILWIND_PACKAGES = [
+  "tailwindcss",
+  "@tailwindcss/vite",
+  "@tailwindcss/postcss",
+  "@tailwindcss/cli"
+];
+var LEGACY_CONFIG_FILES = [
+  "tailwind.config.js",
+  "tailwind.config.mjs",
+  "tailwind.config.cjs",
+  "tailwind.config.ts"
+];
+function detectTailwind(options) {
+  const signals = [];
+  const css = stripCSSComments(options.css);
+  if (TAILWIND_IMPORT_RE.test(css)) signals.push('@import "tailwindcss"');
+  if (/@theme\b/.test(css)) signals.push("@theme");
+  if (/@custom-variant\b/.test(css)) signals.push("@custom-variant");
+  const deps = {
+    ...options.packageJson?.dependencies ?? {},
+    ...options.packageJson?.devDependencies ?? {}
+  };
+  for (const name of TAILWIND_PACKAGES) {
+    if (Object.hasOwn(deps, name)) signals.push(`${name} in package.json`);
+  }
+  const legacyConfig = (options.files ?? []).find((f) => LEGACY_CONFIG_FILES.includes(f)) ?? null;
+  return { isTailwind: signals.length > 0, signals, legacyConfig };
+}
+function scanAtRules(css) {
+  const out = [];
+  for (let i = 0; i < css.length; i++) {
+    if (css[i] !== "@") continue;
+    let nameEnd = i + 1;
+    while (nameEnd < css.length && /[\w-]/.test(css[nameEnd])) nameEnd++;
+    const name = css.slice(i + 1, nameEnd);
+    if (!name) continue;
+    let j = nameEnd;
+    while (j < css.length && css[j] !== "{" && css[j] !== ";") j++;
+    if (j >= css.length) break;
+    const prelude = css.slice(nameEnd, j).trim();
+    if (css[j] === ";") {
+      out.push({ name, prelude, body: null, start: i, end: j + 1 });
+      i = j;
+      continue;
+    }
+    const close = findClosingBrace(css, j);
+    if (close === -1) break;
+    out.push({ name, prelude, body: css.slice(j + 1, close), start: i, end: close + 1 });
+    i = close;
+  }
+  return out;
+}
+var NAMESPACES = [
+  { prefix: "--font-weight-", directive: "weight" },
+  { prefix: "--color-", directive: "color" },
+  { prefix: "--font-", directive: "font" },
+  { prefix: "--text-", directive: "text" },
+  { prefix: "--tracking-", directive: "tracking" },
+  { prefix: "--leading-", directive: "leading" },
+  { prefix: "--breakpoint-", directive: "breakpoint" },
+  { prefix: "--radius-", directive: "rounded" },
+  { prefix: "--shadow-", directive: "shadow" },
+  { prefix: "--blur-", directive: "blur" },
+  { prefix: "--ease-", directive: "ease" },
+  { prefix: "--animate-", directive: "animate" }
+];
+var UNSUPPORTED_NAMESPACES = [
+  { prefix: "--container-", action: "Rainbow Index's container ladder is built in; drop these." },
+  {
+    prefix: "--default-",
+    action: "A Tailwind internal, and its `--theme()` value is Tailwind's own function. Drop it."
+  },
+  { prefix: "--max-width-", action: "Use an arbitrary value: `max-w-[65ch]`." },
+  {
+    prefix: "--inset-shadow-",
+    action: "There is no theme namespace for inset shadows \u2014 define an `@utility` per name."
+  },
+  {
+    prefix: "--drop-shadow-",
+    action: "There is no theme namespace for drop shadows \u2014 define an `@utility` per name."
+  },
+  {
+    prefix: "--text-shadow-",
+    action: "There is no theme namespace for text shadows \u2014 define an `@utility` per name."
+  },
+  { prefix: "--perspective-", action: "Use an arbitrary value: `perspective-[800px]`." },
+  { prefix: "--aspect-", action: "Use an arbitrary value: `aspect-[16/10]`." }
+];
+function tokenName(key2, prefix) {
+  return key2.slice(prefix.length);
+}
+function emitBlock(directive, bucket) {
+  const lines = [...bucket].map(
+    ([key2, value]) => value.startsWith("{") ? `	${key2} ${value}` : `	${key2}: ${value};`
+  );
+  return `@${directive} {
+${lines.join("\n")}
+}
+`;
+}
+function reindent(body, depth) {
+  const pad = "	".repeat(depth);
+  const lines = body.trim().split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  return lines.map((line) => pad + line).join("\n");
+}
+function migrateTailwindCSS(input) {
+  const css = stripCSSComments(input);
+  const atRules = scanAtRules(css);
+  const buckets = /* @__PURE__ */ new Map();
+  const bucket = (directive) => {
+    let existing = buckets.get(directive);
+    if (existing === void 0) {
+      existing = /* @__PURE__ */ new Map();
+      buckets.set(directive, existing);
+    }
+    return existing;
+  };
+  const manual = [];
+  const keyframes = /* @__PURE__ */ new Map();
+  const consumed = [];
+  let darkVariant = null;
+  const lineHeights = /* @__PURE__ */ new Map();
+  for (const rule of atRules) {
+    switch (rule.name) {
+      case "import": {
+        const target = `@import ${rule.prelude}`;
+        if (TAILWIND_IMPORT_RE.test(target) || RI_IMPORT_RE.test(target)) {
+          consumed.push([rule.start, rule.end]);
+        }
+        break;
+      }
+      case "color": {
+        if (rule.prelude.trim() !== "dark" || rule.body === null) break;
+        const variant = /variant\s*:\s*([^;}]+)/.exec(rule.body)?.[1]?.trim();
+        if (variant === void 0) break;
+        consumed.push([rule.start, rule.end]);
+        darkVariant = variant.startsWith("selector") ? "selector" : "media";
+        break;
+      }
+      case "theme": {
+        consumed.push([rule.start, rule.end]);
+        if (rule.body === null) break;
+        if (/\binline\b/.test(rule.prelude)) {
+          manual.push({
+            found: `@theme ${rule.prelude}`,
+            reason: "`@theme inline` emits resolved values rather than variable references.",
+            action: "Rainbow Index emits `var()` references so a token follows the cascade. Check any place you relied on the inlined value."
+          });
+        }
+        translateThemeBody(rule.body, bucket, lineHeights, manual, keyframes);
+        break;
+      }
+      case "keyframes": {
+        const name = rule.prelude.trim();
+        if (name && rule.body !== null) {
+          keyframes.set(name, rule.body.trim());
+          consumed.push([rule.start, rule.end]);
+        }
+        break;
+      }
+      case "custom-variant": {
+        consumed.push([rule.start, rule.end]);
+        const name = rule.prelude.split(/[\s(]/)[0]?.trim() ?? "";
+        const rest = rule.prelude.slice(name.length).trim();
+        if (name === "dark") {
+          darkVariant = /prefers-color-scheme/.test(rest) ? "media" : "selector";
+          break;
+        }
+        const body = rule.body === null ? rest : `{
+${rule.body.trim()}
+}`;
+        bucketCustom(buckets, `@custom ${name} ${body}${rule.body === null ? ";" : ""}`);
+        break;
+      }
+      case "plugin":
+      case "config":
+      case "reference": {
+        consumed.push([rule.start, rule.end]);
+        manual.push({
+          found: `@${rule.name} ${rule.prelude}`.trim(),
+          reason: `\`@${rule.name}\` has no Rainbow Index equivalent.`,
+          action: rule.name === "plugin" ? "Reimplement what the plugin added with `@utility` and `@custom`." : rule.name === "config" ? "A v3 JavaScript config is not read. Move the values into directives." : "Remove it; Rainbow Index resolves the theme from the entry itself."
+        });
+        break;
+      }
+      case "variant": {
+        manual.push({
+          found: `@variant ${rule.prelude}`,
+          reason: "`@variant` applies a variant to a rule body; there is no equivalent.",
+          action: "Write the variant on the class, or express it as a nested selector."
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const textBucket = buckets.get("text");
+  if (textBucket) {
+    for (const [name, leading] of lineHeights) {
+      const size = textBucket.get(name);
+      if (size !== void 0) textBucket.set(name, `${size}, ${leading}`);
+    }
+  }
+  const animateBucket = buckets.get("animate");
+  if (animateBucket) {
+    for (const [name, shorthand] of [...animateBucket]) {
+      const frames = keyframes.get(firstWord(shorthand)) ?? keyframes.get(name);
+      if (frames === void 0) {
+        animateBucket.delete(name);
+        manual.push({
+          found: `--animate-${name}: ${shorthand}`,
+          reason: "No matching `@keyframes` was found in this file.",
+          action: "Add the keyframes to an `@animate` entry, or drop the token."
+        });
+        continue;
+      }
+      animateBucket.set(
+        name,
+        `{
+		animation: ${shorthand};
+		@keyframes ${name} {
+${reindent(frames, 3)}
+		}
+	}`
+      );
+    }
+    if (animateBucket.size === 0) buckets.delete("animate");
+  }
+  return {
+    css: assemble(css, consumed, buckets, darkVariant),
+    translated: [...buckets].map(([directive, entries]) => ({
+      directive: `@${directive}`,
+      entries: entries.size
+    })),
+    manual,
+    darkVariant
+  };
+}
+function bucketCustom(buckets, statement) {
+  let existing = buckets.get("__custom");
+  if (existing === void 0) {
+    existing = /* @__PURE__ */ new Map();
+    buckets.set("__custom", existing);
+  }
+  existing.set(statement, "");
+}
+function firstWord(value) {
+  return value.trim().split(/\s+/)[0] ?? "";
+}
+function readThemeBody(body) {
+  const keyframes = /* @__PURE__ */ new Map();
+  let rest = "";
+  let at = 0;
+  for (const rule of scanAtRules(body)) {
+    rest += body.slice(at, rule.start);
+    at = rule.end;
+    if (rule.name === "keyframes" && rule.body !== null) {
+      keyframes.set(rule.prelude.trim(), rule.body.trim());
+    }
+  }
+  rest += body.slice(at);
+  const entries = [];
+  for (const statement of splitTopLevel(rest, ";")) {
+    const text = statement.trim();
+    if (!text) continue;
+    const colon = text.indexOf(":");
+    if (colon === -1) continue;
+    const key2 = text.slice(0, colon).trim();
+    const value = text.slice(colon + 1).trim().replace(/\s+/g, " ");
+    if (key2 && value) entries.push([key2, value]);
+  }
+  return { entries, keyframes };
+}
+function splitTopLevel(input, char) {
+  const out = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      i++;
+      while (i < input.length && input[i] !== quote) {
+        if (input[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth = Math.max(0, depth - 1);
+    else if (ch === char && depth === 0) {
+      out.push(input.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(input.slice(start));
+  return out;
+}
+function translateThemeBody(body, bucket, lineHeights, manual, keyframes) {
+  const parsed = readThemeBody(body);
+  for (const [name, frames] of parsed.keyframes) keyframes.set(name, frames);
+  for (const [key2, value] of parsed.entries) {
+    if (key2 === "--spacing") {
+      bucket("spacing").set("base", value);
+      continue;
+    }
+    if (key2.endsWith("-*") || value === "initial") continue;
+    if (key2.endsWith("--line-height")) {
+      const size = key2.slice("--text-".length, -"--line-height".length);
+      if (key2.startsWith("--text-")) lineHeights.set(size, value);
+      continue;
+    }
+    const modifier = /--(?:font-weight|letter-spacing|tracking)$/.exec(key2);
+    if (modifier) {
+      manual.push({
+        found: `${key2}: ${value}`,
+        reason: "A per-size weight or tracking modifier has no `@text` equivalent.",
+        action: "Set it on the element, or define an `@utility`."
+      });
+      continue;
+    }
+    const unsupported = UNSUPPORTED_NAMESPACES.find(
+      (n) => key2.startsWith(n.prefix) || key2 === n.prefix.slice(0, -1)
+    );
+    if (unsupported) {
+      manual.push({
+        found: `${key2}: ${value}`,
+        reason: `The \`${unsupported.prefix}*\` namespace has no counterpart.`,
+        action: unsupported.action
+      });
+      continue;
+    }
+    const bare = NAMESPACES.find((n) => key2 === n.prefix.slice(0, -1));
+    if (bare) {
+      bucket(bare.directive).set("DEFAULT", value);
+      continue;
+    }
+    const namespace = NAMESPACES.find((n) => key2.startsWith(n.prefix));
+    if (!namespace) {
+      bucket("__root").set(key2, value);
+      continue;
+    }
+    bucket(namespace.directive).set(tokenName(key2, namespace.prefix), value);
+  }
+}
+function assemble(css, consumed, buckets, darkVariant) {
+  const parts = [
+    '@import "rainbowindex";',
+    "/* Tailwind's default scales, so the familiar class names keep resolving.",
+    "   Drop this line and only what you declare below exists. */",
+    '@import "rainbowindex/tailwind.css";',
+    ""
+  ];
+  if (darkVariant === "selector") {
+    parts.push("/* `dark:` follows the .dark class, as it did under Tailwind. */");
+    parts.push("@color dark {\n	variant: selector(.dark);\n}");
+    parts.push("");
+  }
+  const root = buckets.get("__root");
+  const customs = buckets.get("__custom");
+  for (const [directive, entries] of buckets) {
+    if (directive === "__root" || directive === "__custom") continue;
+    if (entries.size === 0) continue;
+    parts.push(emitBlock(directive, entries));
+  }
+  if (customs) {
+    for (const statement of customs.keys()) parts.push(statement);
+    parts.push("");
+  }
+  if (root && root.size > 0) {
+    parts.push(`:root {
+${[...root].map(([k, v]) => `	${k}: ${v};`).join("\n")}
+}
+`);
+  }
+  consumed.sort((a, b) => a[0] - b[0]);
+  let rest = "";
+  let at = 0;
+  for (const [start, end] of consumed) {
+    if (start < at) continue;
+    rest += css.slice(at, start);
+    at = end;
+  }
+  rest += css.slice(at);
+  const tail = rest.trim();
+  if (tail) parts.push(tail, "");
+  return `${parts.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}
+`;
+}
+
+// src/cli/migrate.ts
+var ENTRY_CANDIDATES = [
+  "src/index.css",
+  "src/style.css",
+  "src/styles.css",
+  "src/app.css",
+  "src/global.css",
+  "src/globals.css",
+  "app/globals.css",
+  "styles/globals.css",
+  "index.css",
+  "style.css",
+  "styles.css",
+  "app.css",
+  "global.css"
+];
+function readJSON(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function findEntry(cwd, explicit) {
+  if (explicit) {
+    const path = resolve6(cwd, explicit);
+    return readFileSync(path, "utf8") ? path : null;
+  }
+  for (const candidate of ENTRY_CANDIDATES) {
+    const path = resolve6(cwd, candidate);
+    let css;
+    try {
+      css = readFileSync(path, "utf8");
+    } catch {
+      continue;
+    }
+    if (detectTailwind({ css }).isTailwind) return path;
+  }
+  return null;
+}
+async function scanAuthoredClasses(globs, cwd) {
+  if (globs.length === 0) return { classes: /* @__PURE__ */ new Set(), files: [] };
+  const { files } = await resolveSourceFilesAsync(
+    globs.map((pattern) => ({ pattern, negated: false, inline: false, absolute: false })),
+    cwd
+  );
+  const classes = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    let content;
+    try {
+      content = await readFile3(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const candidate of outermostCandidates(extractClassCandidates({ content, path: file }))) {
+      if (AUTHORED_ORIGINS.has(candidate.origin)) classes.add(candidate.value);
+    }
+  }
+  return { classes, files };
+}
+var AUTHORED_ORIGINS = /* @__PURE__ */ new Set(["attribute", "helper", "safelist"]);
+function bullet(step) {
+  return `- \`${step.found}\`
+  - ${step.reason}${step.action ? `
+  - ${step.action}` : ""}`;
+}
+async function migrateProject(opts, cwd) {
+  const source = opts.migrateSource ?? "tailwind";
+  if (source !== "tailwind") {
+    return {
+      code: 1,
+      summary: `Unknown migration source "${source}". The only one is \`tailwind\`.`,
+      written: []
+    };
+  }
+  const entry = findEntry(cwd, opts.cssFile);
+  if (entry === null) {
+    return {
+      code: 1,
+      summary: `No Tailwind CSS entry found. Looked for a stylesheet with \`@import "tailwindcss"\` or \`@theme\` at: ${ENTRY_CANDIDATES.join(", ")}.
+Point at it with --css <file>.`,
+      written: []
+    };
+  }
+  const original = readFileSync(entry, "utf8");
+  const detection = detectTailwind({
+    css: original,
+    packageJson: readJSON(join2(cwd, "package.json")),
+    files: readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name)
+  });
+  if (!detection.isTailwind) {
+    return {
+      code: 1,
+      summary: `${relative4(cwd, entry)} does not look like a Tailwind v4 entry \u2014 no \`@import "tailwindcss"\`, no \`@theme\`, and no Tailwind package.`,
+      written: []
+    };
+  }
+  const result = migrateTailwindCSS(original);
+  const inlined = inlineDirectiveImports(result.css, {
+    resolve: createNodeImportResolver({ cwd }),
+    from: entry
+  });
+  const presetResolved = inlined.css !== result.css;
+  const analysis = analyzeProjectCSS(inlined.css);
+  const inspector = createClassInspector(analysis.theme);
+  const { classes: authored, files } = await scanAuthoredClasses(opts.globs, cwd);
+  const rejected = /* @__PURE__ */ new Map();
+  if (presetResolved) {
+    for (const className of authored) {
+      const validation = inspector.validate(className);
+      if (validation.ok) continue;
+      const bucket = rejected.get(validation.reason) ?? [];
+      bucket.push(className);
+      rejected.set(validation.reason, bucket);
+    }
+  }
+  const outPath = join2(dirname2(entry), `${basename(entry, ".css")}.rainbowindex.css`);
+  const reportPath = join2(cwd, "migration-report.md");
+  const report = buildReport({
+    entry: relative4(cwd, entry),
+    detection,
+    result,
+    rejected,
+    scanned: authored.size,
+    files: files.length,
+    presetResolved
+  });
+  const written = [];
+  if (opts.write) {
+    await writeFileAtomic(`${entry}.tailwind.bak`, original);
+    await writeFileAtomic(entry, result.css);
+    written.push(relative4(cwd, `${entry}.tailwind.bak`), relative4(cwd, entry));
+  } else {
+    await writeFileAtomic(outPath, result.css);
+    written.push(relative4(cwd, outPath));
+  }
+  await writeFileAtomic(reportPath, report);
+  written.push(relative4(cwd, reportPath));
+  const tokens = result.translated.reduce((n, t) => n + t.entries, 0);
+  const summary = [
+    `Migrated ${relative4(cwd, entry)} \u2014 ${tokens} tokens across ${result.translated.length} directives.`,
+    result.darkVariant === "selector" ? "  dark: kept on the .dark class." : null,
+    result.manual.length === 1 ? "  1 thing needs a person." : `  ${result.manual.length} things need a person.`,
+    !presetResolved ? "  Could not resolve rainbowindex/tailwind.css \u2014 install the package to have\n  your classes checked against the migrated theme." : rejected.size > 0 ? `  ${[...rejected.values()].flat().length} of ${authored.size} classes in your source do not resolve.` : authored.size > 0 ? `  All ${authored.size} classes in your source resolve.` : null,
+    "",
+    ...written.map((file) => `  wrote ${file}`),
+    "",
+    opts.write ? "Applied. The original is beside it as *.css.tailwind.bak." : "Nothing was overwritten. Re-run with --write to apply."
+  ].filter((line) => line !== null).join("\n");
+  return { code: 0, summary, written };
+}
+function buildReport(input) {
+  const { entry, detection, result, rejected, scanned } = input;
+  const lines = [
+    "# Tailwind \u2192 Rainbow Index",
+    "",
+    `Entry: \`${entry}\``,
+    `Detected by: ${detection.signals.map((s) => `\`${s}\``).join(", ")}`,
+    ""
+  ];
+  if (detection.legacyConfig) {
+    lines.push(
+      "> [!WARNING]",
+      `> \`${detection.legacyConfig}\` is a Tailwind v3 JavaScript config. It was **not** read.`,
+      "> Anything defined only there has to be moved into the CSS entry by hand.",
+      ""
+    );
+  }
+  lines.push("## Translated", "", "| Directive | Tokens |", "| --- | --- |");
+  for (const { directive, entries } of result.translated) {
+    lines.push(`| \`${directive}\` | ${entries} |`);
+  }
+  lines.push("");
+  if (result.darkVariant !== null) {
+    lines.push(
+      "## Dark mode",
+      "",
+      result.darkVariant === "selector" ? "Your `dark` custom variant used a class, so the theme now says\n`@color dark { variant: selector(.dark); }` \u2014 `dark:` and the colour tokens\nboth follow `.dark`, as they did." : "Your `dark` custom variant used `prefers-color-scheme`, which is already the\ndefault here. Nothing was added.",
+      ""
+    );
+  }
+  lines.push("## Needs a person", "");
+  if (result.manual.length === 0) {
+    lines.push("Nothing. Every construct in the entry had a counterpart.", "");
+  } else {
+    lines.push(...result.manual.map(bullet), "");
+  }
+  lines.push("## Classes in your source", "");
+  if (!input.presetResolved) {
+    lines.push(
+      "> [!NOTE]",
+      "> `rainbowindex/tailwind.css` could not be resolved, so this check was",
+      "> skipped. Install the package (`pnpm add -D rainbowindex`) and re-run \u2014",
+      "> without the preset every class from Tailwind's own scales would read as",
+      "> unresolved, which would be alarming and wrong.",
+      ""
+    );
+  } else if (scanned === 0) {
+    lines.push(
+      'No source files were scanned. Pass globs \u2014 `rainbowindex migrate tailwind "src/**/*.tsx"`',
+      "\u2014 to have every class checked against the migrated theme.",
+      ""
+    );
+  } else if (rejected.size === 0) {
+    lines.push(`All ${scanned} classes found in your source resolve against the new theme.`, "");
+  } else {
+    const total = [...rejected.values()].flat().length;
+    lines.push(
+      `${total} of ${scanned} classes across ${input.files} file${input.files === 1 ? "" : "s"} do not resolve. Grouped by why:`,
+      "",
+      ...[...rejected].map(
+        ([reason, classes]) => `### ${reason} (${classes.length})
+
+${classes.slice(0, 40).map((c) => `- \`${c}\``).join("\n")}${classes.length > 40 ? `
+- \u2026and ${classes.length - 40} more` : ""}`
+      ),
+      ""
+    );
+  }
+  lines.push(
+    "## Differences to expect",
+    "",
+    "These are by design, not migration defects:",
+    "",
+    "- **Directional utilities emit logical properties.** `pl-4` is",
+    "  `padding-inline-start`, not `padding-left`. Identical in LTR; mirrored in RTL.",
+    "- **`opacity-50` emits `50%`**, where Tailwind emits `0.5`. Same rendering.",
+    "- **Colour tokens are one `light-dark()` declaration**, not a `:root` block plus",
+    "  a `.dark` block. See [theming.md](https://rainbowindex.dev/theming).",
+    "- **Only what you name exists.** The preset import restores Tailwind's scales;",
+    "  drop it and the theme is exactly your own directives.",
+    ""
+  );
+  return `${lines.join("\n")}
+`;
+}
+
 // src/cli/preload-fonts.ts
 async function preloadFonts(opts, cwd) {
   const theme = await loadProjectTheme(opts, cwd);
@@ -635,34 +1604,7 @@ async function preloadFonts(opts, cwd) {
 
 // src/cli/watch.ts
 import { mkdir } from "fs/promises";
-import { resolve as resolve4, dirname as dirname2 } from "path";
-
-// src/cli/atomic-write.ts
-import { writeFile as writeFile2, rename, unlink } from "fs/promises";
-import { dirname, join } from "path";
-function isIgnorableCleanupError(err) {
-  return !!err && typeof err === "object" && "code" in err && (err.code === "ENOENT" || err.code === "EPERM");
-}
-async function writeFileAtomic(filePath, content) {
-  const dir = dirname(filePath);
-  const tmp = join(dir, `.ri-tmp-${process.pid}-${Date.now()}`);
-  try {
-    await writeFile2(tmp, content);
-    await rename(tmp, filePath);
-  } catch (err) {
-    try {
-      await unlink(tmp);
-    } catch (cleanupErr) {
-      if (!isIgnorableCleanupError(cleanupErr)) {
-        const msg = cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr);
-        devWarn(`[RI-DEV] Failed to remove temp file "${tmp}": ${msg}`);
-      }
-    }
-    throw err;
-  }
-}
-
-// src/cli/watch.ts
+import { resolve as resolve7, dirname as dirname3 } from "path";
 async function minifyIfRequested(css, opts) {
   if (!opts.minify) return css;
   const { optimizeCSS } = await import("./optimize-6NWJVT6W.mjs");
@@ -671,8 +1613,8 @@ async function minifyIfRequested(css, opts) {
 async function buildAndWrite(opts, cwd, outputFile) {
   const result = await buildCSS(opts, cwd);
   const css = await minifyIfRequested(result.css, opts);
-  const outputPath = resolve4(cwd, outputFile);
-  await mkdir(dirname2(outputPath), { recursive: true });
+  const outputPath = resolve7(cwd, outputFile);
+  await mkdir(dirname3(outputPath), { recursive: true });
   await writeFileAtomic(outputPath, css);
   return result;
 }
@@ -819,8 +1761,8 @@ async function watchMode(opts, cwd) {
 }
 
 // src/cli/scan.ts
-import { readFile as readFile3 } from "fs/promises";
-import { relative as relative2, resolve as resolve5 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { relative as relative5, resolve as resolve8 } from "path";
 import { glob } from "tinyglobby";
 async function scanFiles(opts, cwd) {
   const files = [...new Set(await glob(opts.globs, { cwd }))].sort(codepointCompare);
@@ -828,15 +1770,15 @@ async function scanFiles(opts, cwd) {
     throw new Error(`No files matched ${opts.globs.map((g) => `"${g}"`).join(", ")}.`);
   }
   for (const file of files) {
-    const path = resolve5(cwd, file);
+    const path = resolve8(cwd, file);
     const warnings = [];
     const classes = extractClassesFromSource(
-      { path, content: await readFile3(path, "utf-8") },
+      { path, content: await readFile4(path, "utf-8") },
       warnings
     );
     const sorted = [...classes].sort(codepointCompare);
     console.log(
-      `${relative2(cwd, path)} (${sorted.length} class${sorted.length === 1 ? "" : "es"})`
+      `${relative5(cwd, path)} (${sorted.length} class${sorted.length === 1 ? "" : "es"})`
     );
     for (const cls of sorted) {
       console.log(`  ${cls}`);
@@ -849,9 +1791,9 @@ async function scanFiles(opts, cwd) {
 
 // src/cli/vite-setup.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { mkdir as mkdir2, readFile as readFile4, readdir, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3, relative as relative3, resolve as resolve6 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { mkdir as mkdir2, readFile as readFile5, readdir, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname4, relative as relative6, resolve as resolve9 } from "path";
 var VITE_CONFIG_FILES = [
   "vite.config.ts",
   "vite.config.mts",
@@ -914,32 +1856,32 @@ async function initViteProject(opts, cwd, deps = {}) {
     ensureStylesheet(cssPath)
   ]);
   const entryChanged = cssCreated ? await ensureStylesheetImport(entryFile, cssPath) : false;
-  const rootLabel = relative3(process.cwd(), cwd) || ".";
+  const rootLabel = relative6(process.cwd(), cwd) || ".";
   console.log(`[rainbowindex] Initialized Vite project: ${rootLabel}`);
   if (dependencyInstalled) {
     console.log("[rainbowindex] Added dev dependency: rainbowindex");
   }
   if (configCreated) {
     console.log(
-      `[rainbowindex] Created Vite config: ${relative3(cwd, configPath).replaceAll("\\", "/")}`
+      `[rainbowindex] Created Vite config: ${relative6(cwd, configPath).replaceAll("\\", "/")}`
     );
   } else if (configChanged) {
     console.log(
-      `[rainbowindex] Updated Vite config: ${relative3(cwd, configPath).replaceAll("\\", "/")}`
+      `[rainbowindex] Updated Vite config: ${relative6(cwd, configPath).replaceAll("\\", "/")}`
     );
   }
   if (cssCreated) {
     console.log(
-      `[rainbowindex] Created stylesheet: ${relative3(cwd, cssPath).replaceAll("\\", "/")}`
+      `[rainbowindex] Created stylesheet: ${relative6(cwd, cssPath).replaceAll("\\", "/")}`
     );
   } else if (cssChanged) {
     console.log(
-      `[rainbowindex] Updated stylesheet: ${relative3(cwd, cssPath).replaceAll("\\", "/")}`
+      `[rainbowindex] Updated stylesheet: ${relative6(cwd, cssPath).replaceAll("\\", "/")}`
     );
   }
   if (entryChanged && entryFile) {
     console.log(
-      `[rainbowindex] Added stylesheet import: ${relative3(cwd, entryFile).replaceAll("\\", "/")}`
+      `[rainbowindex] Added stylesheet import: ${relative6(cwd, entryFile).replaceAll("\\", "/")}`
     );
   }
   if (!dependencyInstalled && !configChanged && !configCreated && !cssChanged && !cssCreated) {
@@ -963,7 +1905,7 @@ async function createViteProject(opts, cwd, deps = {}) {
   const packageManager = deps.packageManager ?? detectPackageManager(cwd, deps.env);
   const runner = deps.runner ?? DEFAULT_RUNNER;
   const targetDir = opts.targetDir;
-  const targetRoot = resolve6(cwd, targetDir);
+  const targetRoot = resolve9(cwd, targetDir);
   await ensureScaffoldTargetIsUsable(targetRoot);
   const template = opts.template || DEFAULT_CREATE_TEMPLATE;
   const scaffold = getCreateCommand(packageManager, targetDir, template);
@@ -974,15 +1916,15 @@ async function createViteProject(opts, cwd, deps = {}) {
     packageManager,
     runner
   });
-  const displayTarget = relative3(cwd, targetRoot) || ".";
+  const displayTarget = relative6(cwd, targetRoot) || ".";
   console.log(`[rainbowindex] Ready: ${displayTarget}`);
   console.log(`[rainbowindex] Next: cd ${displayTarget} && ${packageManager} run dev`);
 }
 function detectPackageManager(cwd, env = process.env) {
-  if (existsSync3(resolve6(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync3(resolve6(cwd, "yarn.lock"))) return "yarn";
-  if (existsSync3(resolve6(cwd, "bun.lock")) || existsSync3(resolve6(cwd, "bun.lockb"))) return "bun";
-  if (existsSync3(resolve6(cwd, "package-lock.json")) || existsSync3(resolve6(cwd, "npm-shrinkwrap.json"))) {
+  if (existsSync3(resolve9(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(resolve9(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync3(resolve9(cwd, "bun.lock")) || existsSync3(resolve9(cwd, "bun.lockb"))) return "bun";
+  if (existsSync3(resolve9(cwd, "package-lock.json")) || existsSync3(resolve9(cwd, "npm-shrinkwrap.json"))) {
     return "npm";
   }
   const packageJSON = readPackageJSONSync(cwd);
@@ -1027,12 +1969,12 @@ async function installRainbowIndex(cwd, packageManager, runner) {
 async function ensureViteConfig(cwd, packageJSON, existingPath) {
   if (!existingPath) {
     const fileName = chooseViteConfigName(cwd, packageJSON);
-    const configPath = resolve6(cwd, fileName);
+    const configPath = resolve9(cwd, fileName);
     const content = 'import { defineConfig } from "vite";\nimport rainbowindex from "rainbowindex/vite";\n\nexport default defineConfig({\n	plugins: [rainbowindex()],\n});\n';
     await writeFile3(configPath, content, "utf-8");
     return { path: configPath, changed: true, created: true };
   }
-  const original = await readFile4(existingPath, "utf-8");
+  const original = await readFile5(existingPath, "utf-8");
   const updated = patchViteConfig(original, existingPath);
   if (updated === original) {
     return { path: existingPath, changed: false, created: false };
@@ -1161,22 +2103,22 @@ function findMatchingDelimiter(input, start, open, close) {
   return -1;
 }
 async function resolveStylesheetPath(cwd, cssFile) {
-  if (cssFile) return resolve6(cwd, cssFile);
+  if (cssFile) return resolve9(cwd, cssFile);
   const importedCSS = await findImportedStylesheet(cwd);
   if (importedCSS) return importedCSS;
   for (const candidate of CSS_ENTRY_CANDIDATES) {
-    const fullPath = resolve6(cwd, candidate);
+    const fullPath = resolve9(cwd, candidate);
     if (existsSync3(fullPath)) return fullPath;
   }
-  return existsSync3(resolve6(cwd, "src")) ? resolve6(cwd, "src/index.css") : resolve6(cwd, "index.css");
+  return existsSync3(resolve9(cwd, "src")) ? resolve9(cwd, "src/index.css") : resolve9(cwd, "index.css");
 }
 async function ensureStylesheet(cssPath) {
   if (!existsSync3(cssPath)) {
-    await mkdir2(dirname3(cssPath), { recursive: true });
+    await mkdir2(dirname4(cssPath), { recursive: true });
     await writeFile3(cssPath, '@import "rainbowindex";\n', "utf-8");
     return { changed: true, created: true };
   }
-  const original = await readFile4(cssPath, "utf-8");
+  const original = await readFile5(cssPath, "utf-8");
   if (/@import\s+["']rainbowindex["']/.test(original)) {
     return { changed: false, created: false };
   }
@@ -1203,8 +2145,8 @@ ${content}`;
 }
 async function ensureStylesheetImport(entryFile, cssPath) {
   if (!entryFile || !existsSync3(entryFile)) return false;
-  const original = await readFile4(entryFile, "utf-8");
-  const relativePath = toImportPath(dirname3(entryFile), cssPath);
+  const original = await readFile5(entryFile, "utf-8");
+  const relativePath = toImportPath(dirname4(entryFile), cssPath);
   if (hasStylesheetImport(original, relativePath)) {
     return false;
   }
@@ -1214,16 +2156,16 @@ async function ensureStylesheetImport(entryFile, cssPath) {
 }
 async function findImportedStylesheet(cwd) {
   for (const entryFile of ENTRY_FILES) {
-    const fullPath = resolve6(cwd, entryFile);
+    const fullPath = resolve9(cwd, entryFile);
     if (!existsSync3(fullPath)) continue;
-    const content = await readFile4(fullPath, "utf-8");
+    const content = await readFile5(fullPath, "utf-8");
     const matches = content.matchAll(
       /import\s+(?:.+?\s+from\s+)?["']([^"']+\.css(?:\?[^"']*)?)["']/g
     );
     for (const match of matches) {
       const importPath = match[1].split("?")[0];
       if (!importPath.startsWith(".")) continue;
-      const stylesheet = resolve6(dirname3(fullPath), importPath);
+      const stylesheet = resolve9(dirname4(fullPath), importPath);
       if (existsSync3(stylesheet)) return stylesheet;
     }
   }
@@ -1231,7 +2173,7 @@ async function findImportedStylesheet(cwd) {
 }
 async function findEntryFile(cwd) {
   for (const entryFile of ENTRY_FILES) {
-    const fullPath = resolve6(cwd, entryFile);
+    const fullPath = resolve9(cwd, entryFile);
     if (existsSync3(fullPath)) return fullPath;
   }
   return null;
@@ -1241,18 +2183,18 @@ function hasStylesheetImport(source, importPath) {
   return new RegExp(`import\\s+(?:.+?\\s+from\\s+)?["']${escapedPath}["']`).test(source);
 }
 function toImportPath(fromDir, targetFile) {
-  const rel = relative3(fromDir, targetFile).replaceAll("\\", "/");
+  const rel = relative6(fromDir, targetFile).replaceAll("\\", "/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
 function findExistingViteConfig(cwd) {
   for (const name of VITE_CONFIG_FILES) {
-    const fullPath = resolve6(cwd, name);
+    const fullPath = resolve9(cwd, name);
     if (existsSync3(fullPath)) return fullPath;
   }
   return null;
 }
 function chooseViteConfigName(cwd, packageJSON) {
-  if (existsSync3(resolve6(cwd, "tsconfig.json")) || existsSync3(resolve6(cwd, "tsconfig.app.json")) || existsSync3(resolve6(cwd, "src/main.ts")) || existsSync3(resolve6(cwd, "src/main.tsx")) || packageJSON?.dependencies?.typescript || packageJSON?.devDependencies?.typescript) {
+  if (existsSync3(resolve9(cwd, "tsconfig.json")) || existsSync3(resolve9(cwd, "tsconfig.app.json")) || existsSync3(resolve9(cwd, "src/main.ts")) || existsSync3(resolve9(cwd, "src/main.tsx")) || packageJSON?.dependencies?.typescript || packageJSON?.devDependencies?.typescript) {
     return "vite.config.ts";
   }
   return packageJSON?.type === "module" ? "vite.config.js" : "vite.config.mjs";
@@ -1300,10 +2242,10 @@ function getInstallCommand(packageManager) {
   }
 }
 function readPackageJSONSync(cwd) {
-  const packagePath = resolve6(cwd, "package.json");
+  const packagePath = resolve9(cwd, "package.json");
   if (!existsSync3(packagePath)) return null;
   try {
-    return JSON.parse(readFileSync(packagePath, "utf-8"));
+    return JSON.parse(readFileSync2(packagePath, "utf-8"));
   } catch {
     return null;
   }
@@ -1311,7 +2253,7 @@ function readPackageJSONSync(cwd) {
 
 // src/entries/cli.ts
 function getVersion() {
-  return true ? "0.6.0" : "unknown";
+  return true ? "0.7.0" : "unknown";
 }
 async function main() {
   const args = process.argv.slice(2);
@@ -1332,12 +2274,24 @@ async function main() {
     case "generate-types":
       await generateTypes(opts, cwd);
       break;
+    case "generate-snapshot":
+      await generateSnapshot(opts, cwd);
+      break;
+    case "generate-tokens":
+      await generateTokens(opts, cwd);
+      break;
     case "preload-fonts":
       await preloadFonts(opts, cwd);
       break;
     case "scan":
       await scanFiles(opts, cwd);
       break;
+    case "migrate": {
+      const result = await migrateProject(opts, cwd);
+      (result.code === 0 ? console.log : console.error)(result.summary);
+      if (result.code !== 0) process.exitCode = result.code;
+      break;
+    }
     case "build": {
       if (opts.watch) {
         await watchMode(opts, cwd);
@@ -1358,7 +2312,7 @@ var isDirectExecution = (() => {
   const entry = process.argv[1];
   if (entry === void 0) return false;
   try {
-    return import.meta.url === pathToFileURL(realpathSync(resolve7(entry))).href;
+    return import.meta.url === pathToFileURL(realpathSync(resolve10(entry))).href;
   } catch {
     return false;
   }