rainbowindex 0.1.4 → 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,1258 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_EXCLUDES,
+  DEFAULT_PATTERNS,
+  MAX_DIRECTIVE_INPUT_SIZE,
+  analyzeProjectCSS,
+  collectProjectClasses,
+  extractDirectives,
+  finalizeProjectCompilation,
+  getFontPreloadLinks,
+  hasApplyLikeDirective,
+  hasRIActivation,
+  resolveDirectives,
+  resolveGoogleFonts,
+  validateGlobPattern
+} from "./chunk-RPXZ3O6R.mjs";
+import {
+  devWarn
+} from "./chunk-5N4GPK26.mjs";
+
+// src/entries/cli.ts
+import { realpathSync } from "fs";
+import { resolve as resolve6 } from "path";
+import { pathToFileURL } from "url";
+
+// src/cli/args.ts
+import { relative, resolve } from "path";
+function parseArgs(argv, callbacks) {
+  if (argv[0] === "framework") {
+    throw new Error(
+      `Framework runners were removed. Use your project's Vite scripts directly, such as "pnpm dev" or "pnpm build".`
+    );
+  }
+  const opts = {
+    command: "build",
+    globs: [],
+    watch: false,
+    minify: false,
+    strict: false,
+    subcommandExplicit: false,
+    earlyExit: false
+  };
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "build" && !opts.subcommandExplicit && opts.globs.length === 0) {
+      opts.command = "build";
+      opts.subcommandExplicit = true;
+      i++;
+      continue;
+    }
+    if (arg === "generate-types") {
+      opts.command = "generate-types";
+      opts.subcommandExplicit = true;
+      i++;
+      continue;
+    }
+    if (arg === "init" || arg === "--init") {
+      opts.command = "init";
+      opts.subcommandExplicit = true;
+      i++;
+      continue;
+    }
+    if (arg === "create" || arg === "--create") {
+      opts.command = "create";
+      opts.subcommandExplicit = true;
+      i++;
+      continue;
+    }
+    if (arg === "preload-fonts") {
+      opts.command = "preload-fonts";
+      opts.subcommandExplicit = true;
+      i++;
+      continue;
+    }
+    if (arg === "-o" || arg === "--output") {
+      if (i + 1 >= argv.length) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      opts.output = argv[++i];
+      i++;
+      continue;
+    }
+    if (arg === "--css") {
+      if (i + 1 >= argv.length) {
+        throw new Error("Missing value for --css");
+      }
+      opts.cssFile = argv[++i];
+      i++;
+      continue;
+    }
+    if (arg === "--template") {
+      if (i + 1 >= argv.length) {
+        throw new Error("Missing value for --template");
+      }
+      opts.template = argv[++i];
+      i++;
+      continue;
+    }
+    if (arg === "--watch") {
+      opts.watch = true;
+      i++;
+      continue;
+    }
+    if (arg === "--minify") {
+      opts.minify = true;
+      i++;
+      continue;
+    }
+    if (arg === "--strict") {
+      opts.strict = true;
+      i++;
+      continue;
+    }
+    if (arg === "--version" || arg === "-v") {
+      console.log(callbacks.getVersion());
+      opts.earlyExit = true;
+      return opts;
+    }
+    if (arg === "--help" || arg === "-h") {
+      callbacks.printHelp(opts.subcommandExplicit ? opts.command : void 0);
+      opts.earlyExit = true;
+      return opts;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option "${arg}". Run rainbowindex --help for usage.`);
+    }
+    if (opts.command === "create") {
+      if (opts.targetDir) {
+        throw new Error(`Unexpected extra argument "${arg}" for create.`);
+      }
+      opts.targetDir = arg;
+      i++;
+      continue;
+    }
+    if (opts.command === "init") {
+      throw new Error(`Unexpected extra argument "${arg}" for init.`);
+    }
+    opts.globs.push(arg);
+    i++;
+  }
+  if (opts.command === "create" && !opts.targetDir) {
+    throw new Error("create requires a project directory. Example: rainbowindex create my-app");
+  }
+  if (opts.watch && !opts.output) {
+    throw new Error(
+      '--output is required with --watch. Example: rainbowindex "src/**/*.tsx" --watch -o dist/styles.css'
+    );
+  }
+  if (opts.output) {
+    const resolved = resolve(process.cwd(), opts.output);
+    const rel = relative(process.cwd(), resolved);
+    if (rel.startsWith("..") || resolve(rel) === rel) {
+      throw new Error(
+        `Output path "${opts.output}" resolves outside the project root. Use a relative path within the project directory.`
+      );
+    }
+  }
+  return opts;
+}
+var SUBCOMMAND_HELP = {
+  build: `
+\u{1F308} rainbowindex build \u2014 Generate CSS from source files
+
+Usage:
+  rainbowindex <glob...> [options]
+  rainbowindex --css <file> [options]
+
+Options:
+  -o, --output <file>    Output CSS file path (omit to write to stdout)
+  --watch                Re-run on source-file changes (requires --output)
+  --minify               Minify output via LightningCSS
+  --css <file>           CSS input with directives (auto-detected if omitted)
+  -h, --help             Show this help
+
+Inputs:
+  Pass one or more globs to scan for class names. If no globs are passed and
+  a CSS file with @source directives is found, those are used instead.
+
+Examples:
+  rainbowindex "src/**/*.tsx" -o dist/styles.css
+  rainbowindex "src/**/*.tsx" --watch -o dist/styles.css
+  rainbowindex --css src/styles.css -o dist/styles.css --minify
+`,
+  init: `
+\u{1F308} rainbowindex init \u2014 Wire Rainbow Index into the current Vite app
+
+Usage:
+  rainbowindex init [options]
+
+What this does:
+  1. Installs rainbowindex as a dev dependency (if not already installed).
+  2. Creates or patches vite.config.* to register the Vite plugin.
+  3. Creates or updates a CSS entry file with @import "rainbowindex".
+  4. Adds the CSS import to your entry file (src/main.tsx, src/main.ts, \u2026).
+
+Options:
+  --css <file>           Stylesheet path to create/patch (default: src/index.css)
+  -h, --help             Show this help
+
+Notes:
+  Detects pnpm / yarn / bun / npm from lockfiles, package.json#packageManager,
+  and npm_config_user_agent. Requires an existing Vite project \u2014 if you do not
+  have one yet, use \`rainbowindex create <dir>\`.
+
+Examples:
+  rainbowindex init
+  rainbowindex init --css src/styles.css
+`,
+  create: `
+\u{1F308} rainbowindex create \u2014 Scaffold a Vite app with Rainbow Index ready
+
+Usage:
+  rainbowindex create <dir> [options]
+
+Options:
+  --template <name>      Vite template (default: react-ts)
+                         Examples: vanilla, vanilla-ts, react, react-ts, vue, vue-ts, svelte, svelte-ts
+  --css <file>           Stylesheet path inside the new app (default: src/index.css)
+  -h, --help             Show this help
+
+What this does:
+  1. Runs \`create vite\` for the given template.
+  2. Runs \`rainbowindex init\` inside the new directory.
+
+Examples:
+  rainbowindex create my-app
+  rainbowindex create my-app --template vue-ts
+`,
+  "generate-types": `
+\u{1F308} rainbowindex generate-types \u2014 Generate TypeScript types for ri() autocomplete
+
+Usage:
+  rainbowindex generate-types [options]
+
+Options:
+  --css <file>           CSS input with @color/@text/@utility/etc directives
+  --strict               Drop the \`string & {}\` escape hatch from the union
+  -h, --help             Show this help
+
+Output:
+  Writes \`rainbowindex-env.d.ts\` to the current working directory. Include it
+  in tsconfig.json#include (or the equivalent) so the editor picks it up.
+
+Examples:
+  rainbowindex generate-types
+  rainbowindex generate-types --strict --css src/styles.css
+`,
+  "preload-fonts": `
+\u{1F308} rainbowindex preload-fonts \u2014 Generate <link rel="preload"> tags
+
+Usage:
+  rainbowindex preload-fonts [options]
+
+Options:
+  --css <file>           CSS input with @font directives
+  -h, --help             Show this help
+
+Output:
+  Prints <link rel="preload"> tags to stdout for fonts declared in the @font
+  block (faces marked preload), or via @font-face.
+
+Examples:
+  rainbowindex preload-fonts --css src/styles.css > preload.html
+`
+};
+function printHelp(subcommand) {
+  if (subcommand) {
+    console.log(SUBCOMMAND_HELP[subcommand]);
+    return;
+  }
+  console.log(`
+\u{1F308} Rainbow Index CLI
+
+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 generate-types          Generate TypeScript types for ri()
+  rainbowindex preload-fonts           Generate font preload link tags
+
+Run \`rainbowindex <subcommand> --help\` for subcommand-specific options.
+
+Options:
+  -o, --output <file>    Output CSS file path
+  --watch                Watch for changes
+  --minify               Minify output via LightningCSS
+  --css <file>           CSS file with directives (default: auto-detect)
+  --template <name>      Vite template for create (default: react-ts)
+  --strict               No string escape hatch in generated types
+  -v, --version          Show version
+  -h, --help             Show this help
+
+Environment Variables:
+  RI_CACHE_DIR           Override font metadata cache directory (default: node_modules/.cache/rainbowindex)
+  RI_FONT_CACHE_TTL      Font cache max age in seconds (default: 604800 = 7 days)
+  RI_FETCH_FONTS=0       Disable network requests for Google Fonts metadata (default: enabled)
+  RI_OFFLINE=1           Skip network requests, use cached font data only
+  RI_DEBUG=1             Enable debug logging
+
+Diagnostics:
+  Warnings carry [RI-NNNN] codes. Full table: https://rainbowindex.dev/docs/diagnostics
+
+Examples:
+  rainbowindex init
+  rainbowindex create my-app --template react-ts
+  rainbowindex "src/**/*.tsx" -o dist/styles.css
+  rainbowindex "src/**/*.tsx" --watch -o dist/styles.css
+  rainbowindex generate-types --strict
+`);
+}
+
+// src/cli/css-file.ts
+import { existsSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import { resolve as resolve2 } from "path";
+var CSS_CANDIDATES = Object.freeze([
+  "src/index.css",
+  "src/style.css",
+  "src/styles.css",
+  "src/app.css",
+  "src/global.css",
+  "index.css",
+  "style.css",
+  "styles.css",
+  "app.css",
+  "global.css"
+]);
+var MAX_CSS_FILE_SIZE = MAX_DIRECTIVE_INPUT_SIZE;
+async function findCSSFileAsync(cwd) {
+  const candidates = CSS_CANDIDATES;
+  const results = await Promise.all(
+    candidates.map(async (candidate) => {
+      const full = resolve2(cwd, candidate);
+      try {
+        const fileSize = (await stat(full)).size;
+        if (fileSize > MAX_CSS_FILE_SIZE) return null;
+        const content = await readFile(full, "utf-8");
+        return hasRIActivation(content) ? full : null;
+      } catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+          return null;
+        }
+        console.warn(
+          `[RI-1404] Could not read candidate CSS file "${full}" \u2014 ${err instanceof Error ? err.message : String(err)}`
+        );
+        return null;
+      }
+    })
+  );
+  return results.find((r) => r !== null) ?? null;
+}
+async function readCSSFileAsync(cssFile) {
+  const fileSize = (await stat(cssFile)).size;
+  if (fileSize > MAX_CSS_FILE_SIZE) {
+    throw new Error(`CSS file "${cssFile}" exceeds ${MAX_CSS_FILE_SIZE / 1048576} MB limit.`);
+  }
+  const content = await readFile(cssFile, "utf-8");
+  return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+}
+async function loadProjectCSS(opts, cwd) {
+  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 };
+  }
+  const cssFile = await findCSSFileAsync(cwd);
+  if (!cssFile) return { css: "", cssFile: null };
+  return { css: await readCSSFileAsync(cssFile), cssFile };
+}
+async function loadProjectTheme(opts, cwd) {
+  const { css } = await loadProjectCSS(opts, cwd);
+  const parseWarnings = [];
+  const directives = extractDirectives(css, parseWarnings);
+  const theme = resolveDirectives(directives);
+  for (const w of parseWarnings) console.error(w);
+  return theme;
+}
+
+// src/cli/build.ts
+async function buildCSS(opts, cwd) {
+  const { css: cssSource, cssFile } = await loadProjectCSS(opts, cwd);
+  const analysis = analyzeProjectCSS(cssSource);
+  const { theme, warnings, warningSeen } = analysis;
+  const validGlobs = [];
+  for (const g of opts.globs) {
+    const err = validateGlobPattern(g);
+    if (err) {
+      console.error(`[RI-1404] CLI glob pattern rejected: ${err}`);
+    } else {
+      validGlobs.push(g);
+    }
+  }
+  const cliSources = validGlobs.map((g) => ({ pattern: g, negated: false, inline: false }));
+  const scannedClasses = await collectProjectClasses(
+    theme.sources,
+    cliSources,
+    cwd,
+    warnings,
+    warningSeen
+  );
+  const buildWarnings = [];
+  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.'
+    );
+  }
+  const compiled = await finalizeProjectCompilation({
+    css: cssSource,
+    classNames: scannedClasses,
+    analysis,
+    resolveFonts: resolveGoogleFonts
+  });
+  if (compiled.classNames.length === 0) {
+    const hadAnyGlob = opts.globs.length > 0;
+    const hadAnySource = theme.sources.length > 0;
+    if (!hadAnyGlob && !hadAnySource) {
+      buildWarnings.push(
+        '[RI-1603] No source files were scanned and no utility classes were compiled. Either pass a glob (`rainbowindex "src/**/*.{ts,tsx}" -o out.css`) or add `@source "src/**/*.{ts,tsx}";` to your CSS input.'
+      );
+    } else {
+      buildWarnings.push(
+        `[RI-1603] No utility classes were found in the scanned sources. Verify your glob/@source patterns match files that contain class names${cssFile ? ` (CSS input: ${cssFile})` : ""}.`
+      );
+    }
+  }
+  const emitted = /* @__PURE__ */ new Set();
+  for (const warning of [...compiled.warnings, ...buildWarnings]) {
+    if (!emitted.has(warning)) {
+      console.error(warning);
+      emitted.add(warning);
+    }
+  }
+  return { css: compiled.css, theme: compiled.theme, cssFile };
+}
+
+// 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";
+async function generateTypes(opts, cwd) {
+  const theme = await loadProjectTheme(opts, cwd);
+  const SAFE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+  const validateNames = (names, context) => {
+    return names.filter((n) => {
+      if (SAFE_NAME_RE.test(n)) return true;
+      console.error(
+        `[RI-1014] Skipping ${context} name "${n}" \u2014 contains characters unsafe for TypeScript type generation.`
+      );
+      return false;
+    });
+  };
+  const colorNames = validateNames(Object.keys(theme.colors), "color");
+  const textSizes = validateNames(Object.keys(theme.text), "text");
+  const breakpoints = validateNames(Object.keys(theme.breakpoints), "breakpoint");
+  const weightNames = validateNames(Object.keys(theme.weights), "weight");
+  const staticCustomUtilities = validateNames(
+    theme.customUtilities.filter((u) => !u.functional).map((u) => u.name),
+    "utility"
+  );
+  const functionalCustomUtilities = validateNames(
+    theme.customUtilities.filter((u) => u.functional).map((u) => u.name),
+    "utility"
+  );
+  const union = (names) => names.length > 0 ? names.map((n) => `"${n}"`).join(" | ") : "never";
+  const lines = [
+    "// rainbowindex-env.d.ts (auto-generated \u2014 do not edit)",
+    "",
+    `type ColorName = ${union(colorNames)};`,
+    `type ColorStop = "50" | "100" | "150" | "200" | "250" | "300" | "350" | "400" | "450" | "500" | "550" | "600" | "650" | "700" | "750" | "800" | "850" | "900" | "950";`,
+    "type SpacingToken = `${number}` | `${number}_${number}`;",
+    `type TextSize = ${union(textSizes)};`,
+    `type Variant = ${union(breakpoints)} | "hover" | "focus" | "focus-visible" | "active" | "disabled" | "dark" | "first" | "last" | "odd" | "even";`,
+    `type WeightName = ${union(weightNames)};`,
+    "",
+    "type RainbowClass =",
+    '  | `${"bg" | "text" | "border" | "outline" | "accent" | "caret" | "fill" | "stroke"}-${ColorName}-${ColorStop}`',
+    '  | `${"p" | "px" | "py" | "pt" | "pb" | "pl" | "pr" | "ps" | "pe" | "pbs" | "pbe" | "m" | "mx" | "my" | "mt" | "mb" | "ml" | "mr" | "ms" | "me" | "mbs" | "mbe" | "gap" | "gap-x" | "gap-y"}-${SpacingToken}`',
+    "  | `text-${TextSize}`",
+    "  | `text-fluid-${TextSize}`",
+    '  | `font-${"sans" | "serif" | "mono"}`',
+    "  | `font-${WeightName}`",
+    "  | `w-${SpacingToken}` | `h-${SpacingToken}` | `size-${SpacingToken}`"
+  ];
+  if (staticCustomUtilities.length > 0) {
+    lines.push(`  | ${staticCustomUtilities.map((n) => `"${n}"`).join(" | ")}`);
+  }
+  if (functionalCustomUtilities.length > 0) {
+    lines.push(`  | ${functionalCustomUtilities.map((n) => `\`${n}-\${string}\``).join(" | ")}`);
+  }
+  lines.push("  | `${Variant}:${Exclude<RainbowClass, `${string}:${string}`>}`");
+  if (!opts.strict) {
+    lines.push("  | (string & {});");
+  } else {
+    lines.push("  ;");
+  }
+  lines.push(
+    "",
+    'declare module "rainbowindex" {',
+    "  type ClassInput = RainbowClass | false | null | undefined | ClassInput[];",
+    "  export function ri(...classes: ClassInput[]): string;",
+    "  export function createRi(snapshot: unknown): (...classes: ClassInput[]) => string;",
+    "}",
+    ""
+  );
+  const outputPath = resolve3(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);
+        console.warn(
+          `[RI-1604] "${outputPath}" exists and does not appear to be auto-generated. Original saved to "${backupPath}" before overwrite.`
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(
+          `[RI-1604] "${outputPath}" exists with hand edits and the backup write to "${backupPath}" failed: ${msg}. Aborting to avoid data loss \u2014 move the file aside and re-run.`
+        );
+        process.exitCode = 1;
+        return;
+      }
+    }
+  }
+  try {
+    await writeFile(outputPath, newContent);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[rainbowindex] Failed to write types file "${outputPath}": ${msg}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`[rainbowindex] Generated types: ${outputPath}`);
+  console.log(
+    '[rainbowindex] Add it to tsconfig.json#include (e.g. "include": ["src", "rainbowindex-env.d.ts"]) so the editor picks up RainbowClass autocomplete.'
+  );
+}
+
+// src/cli/preload-fonts.ts
+async function preloadFonts(opts, cwd) {
+  const theme = await loadProjectTheme(opts, cwd);
+  const links = getFontPreloadLinks(theme.fonts);
+  if (links.length === 0) {
+    console.log("[rainbowindex] No font preload links to generate.");
+    return;
+  }
+  for (const link of links) {
+    const safeHref = link.href.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&#39;");
+    console.log(
+      `<link rel="preload" href="${safeHref}" as="${link.as}" type="${link.type}" crossorigin>`
+    );
+  }
+}
+
+// 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
+async function minifyIfRequested(css, opts) {
+  if (!opts.minify) return css;
+  const { optimizeCSS } = await import("./optimize-6NWJVT6W.mjs");
+  return optimizeCSS(css);
+}
+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 });
+  await writeFileAtomic(outputPath, css);
+  return result;
+}
+async function watchMode(opts, cwd) {
+  if (!opts.output) {
+    throw new Error("--output is required with --watch");
+  }
+  const outputFile = opts.output;
+  const initialBuild = await buildAndWrite(opts, cwd, outputFile);
+  console.log(`[rainbowindex] Built: ${opts.output}`);
+  let chokidar;
+  try {
+    chokidar = await import("chokidar");
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`Watch mode could not load "chokidar" (a bundled dependency): ${detail}`);
+  }
+  const watchPaths = opts.globs.length > 0 ? [...opts.globs] : [...DEFAULT_PATTERNS];
+  if (initialBuild.cssFile) watchPaths.push(initialBuild.cssFile);
+  const watcher = chokidar.watch(watchPaths, {
+    cwd,
+    ignored: [...DEFAULT_EXCLUDES],
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 50 }
+  });
+  let debounceTimer = null;
+  let building = false;
+  let pendingRebuild = false;
+  let buildDoneResolve = null;
+  let buildDonePromise = null;
+  let consecutiveErrors = 0;
+  let errorsPaused = false;
+  const MAX_CONSECUTIVE_ERRORS = 5;
+  const MIN_REBUILD_INTERVAL_MS = 500;
+  let lastBuildStart = 0;
+  const currentWatchedPaths = new Set(watchPaths);
+  const MAX_WATCHED_PATHS = 1e4;
+  const syncSourceWatchPaths = (theme) => {
+    const newPaths = theme.sources.filter((s) => !s.negated && !s.inline).map((s) => s.pattern);
+    const newPathSet = new Set(newPaths);
+    for (const p of currentWatchedPaths) {
+      if (!newPathSet.has(p) && !watchPaths.includes(p)) {
+        watcher.unwatch(p);
+        currentWatchedPaths.delete(p);
+      }
+    }
+    for (const p of newPaths) {
+      if (!currentWatchedPaths.has(p)) {
+        if (currentWatchedPaths.size >= MAX_WATCHED_PATHS) {
+          console.warn(
+            `[rainbowindex] Watched path count (${currentWatchedPaths.size}) exceeds ${MAX_WATCHED_PATHS} limit. This may cause EMFILE errors. Narrow your @source patterns or increase the OS file descriptor limit (ulimit -n).`
+          );
+          break;
+        }
+        watcher.add(p);
+        currentWatchedPaths.add(p);
+      }
+    }
+  };
+  syncSourceWatchPaths(initialBuild.theme);
+  const rebuild = () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      if (building) {
+        pendingRebuild = true;
+        return;
+      }
+      if (errorsPaused) {
+        errorsPaused = false;
+        consecutiveErrors = 0;
+      } else if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+        console.error(
+          `[rainbowindex] Paused rebuilds after ${MAX_CONSECUTIVE_ERRORS} consecutive errors. Fix the issue and save a file to resume.`
+        );
+        errorsPaused = true;
+        return;
+      }
+      const now = Date.now();
+      const elapsed = now - lastBuildStart;
+      if (lastBuildStart > 0 && elapsed < MIN_REBUILD_INTERVAL_MS) {
+        pendingRebuild = true;
+        setTimeout(rebuild, MIN_REBUILD_INTERVAL_MS - elapsed);
+        return;
+      }
+      lastBuildStart = now;
+      building = true;
+      buildDonePromise = new Promise((resolveBuild) => {
+        buildDoneResolve = resolveBuild;
+      });
+      try {
+        const result = await buildAndWrite(opts, cwd, outputFile);
+        console.log(`[rainbowindex] Rebuilt: ${outputFile}`);
+        consecutiveErrors = 0;
+        errorsPaused = false;
+        syncSourceWatchPaths(result.theme);
+      } catch (err) {
+        consecutiveErrors++;
+        console.error("[rainbowindex] Build error:", err);
+      } finally {
+        building = false;
+        buildDoneResolve?.();
+        buildDoneResolve = null;
+        buildDonePromise = null;
+        if (pendingRebuild) {
+          pendingRebuild = false;
+          rebuild();
+        }
+      }
+    }, 100);
+  };
+  watcher.on("change", rebuild);
+  watcher.on("add", rebuild);
+  watcher.on("unlink", rebuild);
+  watcher.on("error", (err) => {
+    console.error("[rainbowindex] Watcher error:", err);
+  });
+  let cleanupCalled = false;
+  const cleanup = () => {
+    if (cleanupCalled) return;
+    cleanupCalled = true;
+    if (debounceTimer) clearTimeout(debounceTimer);
+    pendingRebuild = false;
+    const doExit = () => {
+      watcher.close().then(() => {
+        console.log("\n[rainbowindex] Watcher stopped.");
+        process.exit(0);
+      }).catch(() => {
+        process.exit(1);
+      });
+    };
+    if (building && buildDonePromise) {
+      const timeout = new Promise((r) => setTimeout(r, 5e3));
+      Promise.race([buildDonePromise, timeout]).then(doExit);
+    } else {
+      doExit();
+    }
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+
+// src/cli/vite-setup.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { mkdir as mkdir2, readFile as readFile3, readdir, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, relative as relative2, resolve as resolve5 } from "path";
+var VITE_CONFIG_FILES = [
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs",
+  "vite.config.cts",
+  "vite.config.cjs"
+];
+var ENTRY_FILES = [
+  "src/main.tsx",
+  "src/main.ts",
+  "src/main.jsx",
+  "src/main.js",
+  "main.tsx",
+  "main.ts",
+  "main.jsx",
+  "main.js"
+];
+var DEFAULT_CREATE_TEMPLATE = "react-ts";
+var DEFAULT_RUNNER = {
+  run(command, args, cwd) {
+    return new Promise((resolveRun, rejectRun) => {
+      const child = spawn(command, args, {
+        cwd,
+        stdio: "inherit"
+      });
+      child.on("error", rejectRun);
+      child.on("exit", (code, signal) => {
+        if (code === 0) {
+          resolveRun();
+          return;
+        }
+        rejectRun(
+          new Error(
+            signal ? `Command "${command}" terminated by signal ${signal}.` : `Command "${command} ${args.join(" ")}" failed with exit code ${code ?? 1}.`
+          )
+        );
+      });
+    });
+  }
+};
+async function initViteProject(opts, cwd, deps = {}) {
+  const project = loadViteProject(cwd);
+  const packageManager = deps.packageManager ?? detectPackageManager(cwd, deps.env);
+  const runner = deps.runner ?? DEFAULT_RUNNER;
+  const [cssPath, entryFile] = await Promise.all([
+    resolveStylesheetPath(cwd, opts.cssFile),
+    findEntryFile(cwd)
+  ]);
+  let dependencyInstalled = false;
+  if (!hasRainbowIndexDependency(project.packageJSON)) {
+    await installRainbowIndex(cwd, packageManager, runner);
+    dependencyInstalled = true;
+  }
+  const [
+    { path: configPath, changed: configChanged, created: configCreated },
+    { changed: cssChanged, created: cssCreated }
+  ] = await Promise.all([
+    ensureViteConfig(cwd, project.packageJSON, project.viteConfigPath),
+    ensureStylesheet(cssPath)
+  ]);
+  const entryChanged = cssCreated ? await ensureStylesheetImport(entryFile, cssPath) : false;
+  const rootLabel = relative2(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: ${relative2(cwd, configPath).replaceAll("\\", "/")}`
+    );
+  } else if (configChanged) {
+    console.log(
+      `[rainbowindex] Updated Vite config: ${relative2(cwd, configPath).replaceAll("\\", "/")}`
+    );
+  }
+  if (cssCreated) {
+    console.log(
+      `[rainbowindex] Created stylesheet: ${relative2(cwd, cssPath).replaceAll("\\", "/")}`
+    );
+  } else if (cssChanged) {
+    console.log(
+      `[rainbowindex] Updated stylesheet: ${relative2(cwd, cssPath).replaceAll("\\", "/")}`
+    );
+  }
+  if (entryChanged && entryFile) {
+    console.log(
+      `[rainbowindex] Added stylesheet import: ${relative2(cwd, entryFile).replaceAll("\\", "/")}`
+    );
+  }
+  if (!dependencyInstalled && !configChanged && !configCreated && !cssChanged && !cssCreated) {
+    console.log("[rainbowindex] Rainbow Index was already wired for Vite.");
+    return;
+  }
+  console.log("");
+  console.log("[rainbowindex] Next steps:");
+  console.log("  1. Restart your dev server (Vite must reload vite.config to pick up the plugin).");
+  console.log(
+    "  2. Add utility classes to your components \u2014 autocomplete works after `rainbowindex generate-types`."
+  );
+  console.log(
+    "  3. Customize via CSS directives (@color, @text, @spacing). See https://github.com/rainbowindex/rainbowindex#theming"
+  );
+}
+async function createViteProject(opts, cwd, deps = {}) {
+  if (!opts.targetDir) {
+    throw new Error("create requires a project directory. Example: rainbowindex create my-app");
+  }
+  const packageManager = deps.packageManager ?? detectPackageManager(cwd, deps.env);
+  const runner = deps.runner ?? DEFAULT_RUNNER;
+  const targetDir = opts.targetDir;
+  const targetRoot = resolve5(cwd, targetDir);
+  await ensureScaffoldTargetIsUsable(targetRoot);
+  const template = opts.template || DEFAULT_CREATE_TEMPLATE;
+  const scaffold = getCreateCommand(packageManager, targetDir, template);
+  console.log(`[rainbowindex] Creating Vite app with template "${template}"...`);
+  await runner.run(scaffold.command, scaffold.args, cwd);
+  await initViteProject({ cssFile: opts.cssFile }, targetRoot, {
+    ...deps,
+    packageManager,
+    runner
+  });
+  const displayTarget = relative2(cwd, targetRoot) || ".";
+  console.log(`[rainbowindex] Ready: ${displayTarget}`);
+  console.log(`[rainbowindex] Next: cd ${displayTarget} && ${packageManager} run dev`);
+}
+function detectPackageManager(cwd, env = process.env) {
+  if (existsSync3(resolve5(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(resolve5(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync3(resolve5(cwd, "bun.lock")) || existsSync3(resolve5(cwd, "bun.lockb"))) return "bun";
+  if (existsSync3(resolve5(cwd, "package-lock.json")) || existsSync3(resolve5(cwd, "npm-shrinkwrap.json"))) {
+    return "npm";
+  }
+  const packageJSON = readPackageJSONSync(cwd);
+  const packageManagerField = packageJSON?.packageManager ?? "";
+  if (packageManagerField.startsWith("pnpm@")) return "pnpm";
+  if (packageManagerField.startsWith("yarn@")) return "yarn";
+  if (packageManagerField.startsWith("bun@")) return "bun";
+  if (packageManagerField.startsWith("npm@")) return "npm";
+  const userAgent = env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("pnpm/")) return "pnpm";
+  if (userAgent.startsWith("yarn/")) return "yarn";
+  if (userAgent.startsWith("bun/")) return "bun";
+  return "npm";
+}
+function loadViteProject(cwd) {
+  const packageJSON = readPackageJSONSync(cwd);
+  const hasViteDependency = packageJSON?.dependencies?.vite || packageJSON?.devDependencies?.vite || packageJSON?.optionalDependencies?.vite;
+  const hasViteScript = Object.values(packageJSON?.scripts ?? {}).some(
+    (script) => /\bvite\b/.test(script)
+  );
+  const viteConfigPath = findExistingViteConfig(cwd);
+  if (!hasViteDependency && !hasViteScript && !viteConfigPath) {
+    throw new Error(
+      `"${cwd}" does not look like a Vite project. Add Vite first or run rainbowindex create <app-name>.`
+    );
+  }
+  return { packageJSON, viteConfigPath };
+}
+async function ensureScaffoldTargetIsUsable(targetRoot) {
+  if (!existsSync3(targetRoot)) return;
+  const entries = await readdir(targetRoot);
+  if (entries.length > 0) {
+    throw new Error(
+      `Target directory "${targetRoot}" already exists and is not empty. Choose a new directory.`
+    );
+  }
+}
+async function installRainbowIndex(cwd, packageManager, runner) {
+  const install = getInstallCommand(packageManager);
+  await runner.run(install.command, install.args, cwd);
+}
+async function ensureViteConfig(cwd, packageJSON, existingPath) {
+  if (!existingPath) {
+    const fileName = chooseViteConfigName(cwd, packageJSON);
+    const configPath = resolve5(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 readFile3(existingPath, "utf-8");
+  const updated = patchViteConfig(original, existingPath);
+  if (updated === original) {
+    return { path: existingPath, changed: false, created: false };
+  }
+  await writeFile3(existingPath, updated, "utf-8");
+  return { path: existingPath, changed: true, created: false };
+}
+var VITE_CONFIG_MANUAL_SNIPPET = `
+  import { defineConfig } from "vite";
+  import rainbowindex from "rainbowindex/vite";
+
+  export default defineConfig({
+    plugins: [rainbowindex()],
+  });
+`;
+function configPatchError(configPath, reason) {
+  return new Error(
+    `Could not update "${configPath}" automatically (${reason}).
+
+Add the following to your Vite config manually:
+${VITE_CONFIG_MANUAL_SNIPPET}`
+  );
+}
+function patchViteConfig(source, configPath) {
+  let next = source;
+  if (!/["']rainbowindex\/vite["']/.test(next)) {
+    next = insertImportStatement(next, 'import rainbowindex from "rainbowindex/vite";');
+  }
+  if (/\brainbowindex\s*\(/.test(next)) {
+    return next;
+  }
+  const pluginsMatch = /\bplugins\s*:\s*\[/.exec(next);
+  if (pluginsMatch) {
+    const arrayStart = next.indexOf("[", pluginsMatch.index);
+    const arrayEnd = findMatchingDelimiter(next, arrayStart, "[", "]");
+    if (arrayEnd === -1) {
+      throw configPatchError(configPath, "could not find the end of the plugins array");
+    }
+    const inner = next.slice(arrayStart + 1, arrayEnd).trim();
+    const injection = inner.length === 0 ? "rainbowindex()" : "rainbowindex(), ";
+    return `${next.slice(0, arrayStart + 1)}${injection}${next.slice(arrayStart + 1)}`;
+  }
+  const objectStart = findConfigObjectStart(next);
+  if (objectStart === -1) {
+    throw configPatchError(configPath, "no `defineConfig({...})` or `export default {...}` found");
+  }
+  return `${next.slice(0, objectStart + 1)}
+	plugins: [rainbowindex()],${next.slice(objectStart + 1)}`;
+}
+function insertImportStatement(source, statement) {
+  let insertAt = 0;
+  const importRe = /^\s*import .*$/gm;
+  for (const match of source.matchAll(importRe)) {
+    insertAt = match.index + match[0].length;
+    if (source[insertAt] === "\n") insertAt++;
+  }
+  if (insertAt === 0) {
+    return `${statement}
+
+${source}`;
+  }
+  return `${source.slice(0, insertAt)}${statement}
+${source.slice(insertAt)}`;
+}
+function findConfigObjectStart(source) {
+  const defineConfigMatch = /defineConfig\s*\(\s*\{/.exec(source);
+  if (defineConfigMatch) {
+    return source.indexOf("{", defineConfigMatch.index);
+  }
+  const exportDefaultMatch = /export\s+default\s+\{/.exec(source);
+  if (exportDefaultMatch) {
+    return source.indexOf("{", exportDefaultMatch.index);
+  }
+  return -1;
+}
+function findMatchingDelimiter(input, start, open, close) {
+  let depth = 0;
+  let quote = null;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = start; i < input.length; i++) {
+    const ch = input[i];
+    const next = input[i + 1];
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (quote) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch;
+      continue;
+    }
+    if (ch === open) {
+      depth++;
+      continue;
+    }
+    if (ch === close) {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+async function resolveStylesheetPath(cwd, cssFile) {
+  if (cssFile) return resolve5(cwd, cssFile);
+  const importedCSS = await findImportedStylesheet(cwd);
+  if (importedCSS) return importedCSS;
+  for (const candidate of CSS_CANDIDATES) {
+    const fullPath = resolve5(cwd, candidate);
+    if (existsSync3(fullPath)) return fullPath;
+  }
+  return existsSync3(resolve5(cwd, "src")) ? resolve5(cwd, "src/index.css") : resolve5(cwd, "index.css");
+}
+async function ensureStylesheet(cssPath) {
+  if (!existsSync3(cssPath)) {
+    await mkdir2(dirname3(cssPath), { recursive: true });
+    await writeFile3(cssPath, '@import "rainbowindex";\n', "utf-8");
+    return { changed: true, created: true };
+  }
+  const original = await readFile3(cssPath, "utf-8");
+  if (/@import\s+["']rainbowindex["']/.test(original)) {
+    return { changed: false, created: false };
+  }
+  const updated = insertRainbowImport(original);
+  await writeFile3(cssPath, updated, "utf-8");
+  return { changed: true, created: false };
+}
+function insertRainbowImport(source) {
+  const bom = source.charCodeAt(0) === 65279 ? "\uFEFF" : "";
+  const content = bom ? source.slice(1) : source;
+  const charsetMatch = /^\s*@charset\s+[^;]+;\s*/i.exec(content);
+  if (charsetMatch) {
+    return `${bom}${charsetMatch[0]}@import "rainbowindex";
+
+${content.slice(charsetMatch[0].length)}`;
+  }
+  if (content.trim().length === 0) {
+    return `${bom}@import "rainbowindex";
+`;
+  }
+  return `${bom}@import "rainbowindex";
+
+${content}`;
+}
+async function ensureStylesheetImport(entryFile, cssPath) {
+  if (!entryFile || !existsSync3(entryFile)) return false;
+  const original = await readFile3(entryFile, "utf-8");
+  const relativePath = toImportPath(dirname3(entryFile), cssPath);
+  if (hasStylesheetImport(original, relativePath)) {
+    return false;
+  }
+  const updated = insertImportStatement(original, `import "${relativePath}";`);
+  await writeFile3(entryFile, updated, "utf-8");
+  return true;
+}
+async function findImportedStylesheet(cwd) {
+  for (const entryFile of ENTRY_FILES) {
+    const fullPath = resolve5(cwd, entryFile);
+    if (!existsSync3(fullPath)) continue;
+    const content = await readFile3(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 = resolve5(dirname3(fullPath), importPath);
+      if (existsSync3(stylesheet)) return stylesheet;
+    }
+  }
+  return null;
+}
+async function findEntryFile(cwd) {
+  for (const entryFile of ENTRY_FILES) {
+    const fullPath = resolve5(cwd, entryFile);
+    if (existsSync3(fullPath)) return fullPath;
+  }
+  return null;
+}
+function hasStylesheetImport(source, importPath) {
+  const escapedPath = importPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`import\\s+(?:.+?\\s+from\\s+)?["']${escapedPath}["']`).test(source);
+}
+function toImportPath(fromDir, targetFile) {
+  const rel = relative2(fromDir, targetFile).replaceAll("\\", "/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function findExistingViteConfig(cwd) {
+  for (const name of VITE_CONFIG_FILES) {
+    const fullPath = resolve5(cwd, name);
+    if (existsSync3(fullPath)) return fullPath;
+  }
+  return null;
+}
+function chooseViteConfigName(cwd, packageJSON) {
+  if (existsSync3(resolve5(cwd, "tsconfig.json")) || existsSync3(resolve5(cwd, "tsconfig.app.json")) || existsSync3(resolve5(cwd, "src/main.ts")) || existsSync3(resolve5(cwd, "src/main.tsx")) || packageJSON?.dependencies?.typescript || packageJSON?.devDependencies?.typescript) {
+    return "vite.config.ts";
+  }
+  return packageJSON?.type === "module" ? "vite.config.js" : "vite.config.mjs";
+}
+function hasRainbowIndexDependency(packageJSON) {
+  if (!packageJSON) return false;
+  return Boolean(
+    packageJSON.dependencies?.rainbowindex || packageJSON.devDependencies?.rainbowindex || packageJSON.optionalDependencies?.rainbowindex
+  );
+}
+function getCreateCommand(packageManager, targetDir, template) {
+  switch (packageManager) {
+    case "pnpm":
+      return {
+        command: "pnpm",
+        args: ["create", "vite", targetDir, "--template", template]
+      };
+    case "yarn":
+      return {
+        command: "yarn",
+        args: ["create", "vite", targetDir, "--template", template]
+      };
+    case "bun":
+      return {
+        command: "bun",
+        args: ["create", "vite", targetDir, "--template", template]
+      };
+    default:
+      return {
+        command: "npm",
+        args: ["create", "vite@latest", targetDir, "--", "--template", template]
+      };
+  }
+}
+function getInstallCommand(packageManager) {
+  switch (packageManager) {
+    case "pnpm":
+      return { command: "pnpm", args: ["add", "-D", "rainbowindex"] };
+    case "yarn":
+      return { command: "yarn", args: ["add", "-D", "rainbowindex"] };
+    case "bun":
+      return { command: "bun", args: ["add", "-d", "rainbowindex"] };
+    default:
+      return { command: "npm", args: ["install", "-D", "rainbowindex"] };
+  }
+}
+function readPackageJSONSync(cwd) {
+  const packagePath = resolve5(cwd, "package.json");
+  if (!existsSync3(packagePath)) return null;
+  try {
+    return JSON.parse(readFileSync(packagePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/entries/cli.ts
+function getVersion() {
+  return true ? "0.2.0" : "unknown";
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    printHelp();
+    return;
+  }
+  const opts = parseArgs(args, { getVersion, printHelp });
+  if (opts.earlyExit) return;
+  const cwd = process.cwd();
+  switch (opts.command) {
+    case "init":
+      await initViteProject(opts, cwd);
+      break;
+    case "create":
+      await createViteProject(opts, cwd);
+      break;
+    case "generate-types":
+      await generateTypes(opts, cwd);
+      break;
+    case "preload-fonts":
+      await preloadFonts(opts, cwd);
+      break;
+    case "build": {
+      if (opts.watch) {
+        await watchMode(opts, cwd);
+        return;
+      }
+      if (opts.output) {
+        await buildAndWrite(opts, cwd, opts.output);
+        console.log(`[rainbowindex] Built: ${opts.output}`);
+      } else {
+        const { css } = await buildCSS(opts, cwd);
+        process.stdout.write(await minifyIfRequested(css, opts));
+      }
+      break;
+    }
+  }
+}
+var isDirectExecution = (() => {
+  const entry = process.argv[1];
+  if (entry === void 0) return false;
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(resolve6(entry))).href;
+  } catch {
+    return false;
+  }
+})();
+if (isDirectExecution) {
+  void main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  });
+}